Merge branch 'master-l1calo-phase1-derivation-tools' into 'master'

L1Calo Phase1 eFEX TOB decorator and config update (ATLASRECTS-7473)

See merge request atlas/athena!60631

Trigger/TrigT1/L1CaloFEX/L1CaloFEXAlgos/python/jFexEmulatedTowersConfig.py → Trigger/TrigT1/L1CaloFEX/L1CaloFEXAlgos/python/FexEmulatedTowersConfig.py

@@ -18,6 +18,18 @@ def jFexEmulatedTowersCfg(  flags, name, writeKey="L1_jFexEmulatedTowers"):
 
     return acc
 
+def eFexEmulatedTowersCfg(flags, name, writeKey = "L1_eFexEmulatedTowers", verificationMode = False):
+    """
+    Config for emulating eFex input data from LATOME readout
+    """    
+    acc=ComponentAccumulator()
+    
+    emulator = CompFactory.LVL1.eFexTowerBuilder(name)
+    emulator.eFexContainerWriteKey   = writeKey
+    emulator.MappingVerificationMode = verificationMode
+    acc.addEventAlgo(emulator)
+
+    return acc
 
 
 if __name__ == '__main__':
@@ -27,16 +39,17 @@ if __name__ == '__main__':
     import sys
 
     import argparse
-    parser = argparse.ArgumentParser(prog='python -m L1CaloFEXTools.L1CaloFEXToolsConfig',
-                                   description="""Decorator tool for FEX towers athena script.\n\n
-                                   Example: python -m L1CaloFEXTools.L1CaloFEXToolsConfig --filesInput "data22*" --evtMax 10 --outputs eTOBs """)
+    parser = argparse.ArgumentParser(prog='python -m L1CaloFEXAlgos.FexEmulatedTowersConfig',
+                                   description="""Emulator tools for FEX towers athena script.\n\n
+                                   Example: python -m L1CaloFEXAlgos.FexEmulatedTowersConfig --filesInput "data22*" --evtMax 10 --outputs jTowers """)
     parser.add_argument('--evtMax',type=int,default=-1,help="number of events")
     parser.add_argument('--filesInput',nargs='+',help="input files",required=True)
+    parser.add_argument('--outputs',nargs='+',choices={"jTowers","eTowers"},required=True, help="What data to decode and emulate")
     parser.add_argument('--outputLevel',default="WARNING",choices={ 'INFO','WARNING','DEBUG','VERBOSE'})
     args = parser.parse_args()
 
 
-    log = logging.getLogger('L1CaloFEXToolsConfig')
+    log = logging.getLogger('FexEmulatedTowersConfig')
     log.setLevel(logging.DEBUG)
 
     from AthenaCommon import Constants
@@ -65,7 +78,7 @@ if __name__ == '__main__':
         flags.IOVDb.GlobalTag = flags.Trigger.OnlineCondTag
 
     if not flags.Input.isMC and flags.Input.RunNumber[0] > 400000:
-        flags.GeoModel.AtlasVersion = 'ATLAS-R3S-2021-03-01-00'
+        flags.GeoModel.AtlasVersion = 'ATLAS-R3S-2021-02-00-00'
 
     # Enable only calo for this test
     from AthenaConfiguration.DetectorConfigFlags import setupDetectorsFromList
@@ -112,25 +125,43 @@ if __name__ == '__main__':
     ########################################
     # Emulated jFex Towers
     ########################################
-    
-    jFexEmulatedTool = jFexEmulatedTowersCfg(flags,'jFexEmulatedTowers')
-    acc.merge(jFexEmulatedTool)
-    outputEDM += addEDM('xAOD::jFexTowerContainer', 'L1_jFexEmulatedTowers')
-    
+    if 'jTowers' in args.outputs:
+        jFexEmulatedTool = jFexEmulatedTowersCfg(flags,'jFexEmulatedTowers')
+        acc.merge(jFexEmulatedTool)
+        outputEDM += addEDM('xAOD::jFexTowerContainer', 'L1_jFexEmulatedTowers')
+        
+        # decode any data towers for comparison with emulated
+        from L1CaloFEXByteStream.L1CaloFEXByteStreamConfig import jFexInputByteStreamToolCfg
+        inputjFexTool = jFexInputByteStreamToolCfg('jFexInputBSDecoder', flags)
+        for module_id in inputjFexTool.ROBIDs:
+            maybeMissingRobs.append(module_id)
+
+        decoderTools += [inputjFexTool]
+        # saving/adding the jTower xAOD container
+        outputEDM += addEDM('xAOD::jFexTowerContainer', inputjFexTool.jTowersWriteKey.Path)
+
     ########################################
-    # jFex Data Towers
+    # Emulated eFex     
     ########################################
-    from L1CaloFEXByteStream.L1CaloFEXByteStreamConfig import jFexInputByteStreamToolCfg
-    inputjFexTool = jFexInputByteStreamToolCfg('jFexInputBSDecoder', flags)
-    for module_id in inputjFexTool.ROBIDs:
-        maybeMissingRobs.append(module_id)
-
-    decoderTools += [inputjFexTool]
-    # saving/adding the jTower xAOD container
-    outputEDM += addEDM('xAOD::jFexTowerContainer', inputjFexTool.jTowersWriteKey.Path)
-    
+    if 'eTowers' in args.outputs:
+        eFexEmulatedTool = eFexEmulatedTowersCfg(flags,'L1_eFexEmulatedTowers')
+        acc.merge(eFexEmulatedTool)
+        outputEDM += addEDM('xAOD::eFexTowerContainer', 'L1_eFexEmulatedTowers')
+
+        # decode any data towers for comparison with emulated
+        from L1CaloFEXByteStream.L1CaloFEXByteStreamConfig import eFexByteStreamToolCfg
+        inputeFexTool = eFexByteStreamToolCfg('eFexBSDecoder', flags,TOBs=False,xTOBs=False,decodeInputs=True)
+        for module_id in inputeFexTool.ROBIDs:
+            maybeMissingRobs.append(module_id)    
+
+        decoderTools += [inputeFexTool]
+        # saving/adding the eTower xAOD container
+        outputEDM += addEDM('xAOD::eFexTowerContainer', 'L1_eFexDataTowers')
+
+    #
     decoderAlg = CompFactory.L1TriggerByteStreamDecoderAlg(name="L1TriggerByteStreamDecoder",
-                                                         DecoderTools=decoderTools, OutputLevel=algLogLevel, MaybeMissingROBs=maybeMissingRobs)
+                                                           DecoderTools=decoderTools, OutputLevel=algLogLevel, 
+                                                           MaybeMissingROBs=maybeMissingRobs)
 
     acc.addEventAlgo(decoderAlg, sequenceName='AthAlgSeq')
     

Trigger/TrigT1/L1CaloFEX/L1CaloFEXAlgos/python/L1CaloFEXAlgosConfig.py

@@ -7,57 +7,71 @@ from AthenaConfiguration.ComponentFactory import CompFactory
 from L1CaloFEXByteStream.L1CaloFEXByteStreamConfig import jFexInputByteStreamToolCfg
 from AthenaConfiguration.Enums import Format
 
-def L1CaloFEXDecoratorCfg(flags, name):
-    
+def L1CaloFEXDecoratorCfg(flags, name, jTowersReadKey = 'L1_jFexDataTowers', ExtraInfo = False):
+
     acc=ComponentAccumulator()
     
     decorator = CompFactory.LVL1.jFexTower2SCellDecorator(name)
+    decorator.jTowersReadKey = jTowersReadKey 
+    decorator.ExtraInfo = ExtraInfo
     acc.addEventAlgo(decorator)
 
     return acc
 
-
-def jFexEmulatedTowersDerivationCfg(flags, name):
+def eFexTOBDecoratorCfg(flags, name, eFexEMRoIContainer = "L1_eEMRoI", eFexTauRoIContainer = "L1_eTauRoI"):
     """
-    Create emulated towers for derivation jobs running on RAWD
-    Requires to decode the SCells (the legacy TriggerTowers are already available)
+    Configure the eFEX TOB decorator algorithm
+    Requires the eFEXTOBEtTool
     """
-    acc=ComponentAccumulator()
+    acc = ComponentAccumulator()
 
-    from L1CaloFEXSim.L1CaloFEXSimCfg import ReadSCellFromByteStreamCfg
-    acc.merge(ReadSCellFromByteStreamCfg(flags,keyIn="SC_ET_ID"))
+    from L1CaloFEXSim.L1CaloFEXSimCfg import eFEXTOBEtToolCfg
+    acc.popToolsAndMerge(eFEXTOBEtToolCfg(flags))
 
-    emulator = CompFactory.LVL1.jFexEmulatedTowers(name)
-    emulator.jTowersWriteKey   = "L1_jFexEmulatedTowers"
-    acc.addEventAlgo(emulator)
+    decorator = CompFactory.LVL1.eFexTOBDecorator(name, eFexEMRoIContainer = eFexEMRoIContainer, eFexTauRoIContainer = eFexTauRoIContainer)
 
-    return acc
+    # in case the TOB containers are different from default we also have to change the write handles
+    if eFexEMRoIContainer != "L1_eEMRoI":
+        decorator.RetaCoreDecDecorKey = eFexEMRoIContainer+".RetaCoreDec"
+        decorator.RetaEnvDecDecorKey = eFexEMRoIContainer+".RetaEnvDec"
+        decorator.RetaEMDecDecorKey = eFexEMRoIContainer+".RhadEMDec"
+        decorator.RhadHadDecDecorKey = eFexEMRoIContainer+".RhadHadDec"
+        decorator.WstotDenDecDecorKey = eFexEMRoIContainer+".WstotDenDec"
+        decorator.WstotNumDecDecorKey = eFexEMRoIContainer+".WstotNumDec"
 
+    if eFexEMRoIContainer != "L1_eTauRoI":
+        decorator.RCoreDecorKey = eFexTauRoIContainer+".RCoreDec"
+        decorator.REnvDecorKey = eFexTauRoIContainer+".REnvDec"
+        decorator.REMCoreDecorKey = eFexTauRoIContainer+".REMCoreDec"
+        decorator.REMHadDecorKey = eFexTauRoIContainer+".REMHadDec"
+
+    acc.addEventAlgo(decorator)
+
+    return acc
 
 if __name__ == '__main__':
-    from AthenaConfiguration.AllConfigFlags import initConfigFlags
+    from AthenaConfiguration.AllConfigFlags import ConfigFlags as flags
     from AthenaCommon.Logging import logging
     import glob
     import sys
 
     import argparse
-    parser = argparse.ArgumentParser(prog='python -m L1CaloFEXTools.L1CaloFEXToolsConfig',
+    parser = argparse.ArgumentParser(prog='python -m L1CaloFEXAlgos.L1CaloFEXAlgosConfig',
                                    description="""Decorator tool for FEX towers athena script.\n\n
-                                   Example: python -m L1CaloFEXTools.L1CaloFEXToolsConfig --filesInput "data22*" --evtMax 10 --outputs eTOBs """)
+                                   Example: python -m L1CaloFEXAlgos.L1CaloFEXAlgosConfig --filesInput "data22*" --evtMax 10 --outputs eTOBs """)
     parser.add_argument('--evtMax',type=int,default=-1,help="number of events")
     parser.add_argument('--filesInput',nargs='+',help="input files",required=True)
     parser.add_argument('--outputLevel',default="WARNING",choices={ 'INFO','WARNING','DEBUG','VERBOSE'})
-    parser.add_argument('--outputs',nargs='+',choices={"jTowers","jTOBs"},required=True, help="What data to decode and output.")
+    parser.add_argument('--outputs',nargs='+',choices={"jTowers","jTOBs","eTOBs"},required=True, help="What data to decode and output.")
     args = parser.parse_args()
 
 
-    log = logging.getLogger('L1CaloFEXToolsConfig')
+    log = logging.getLogger('L1CaloFEXAlgosConfig')
     log.setLevel(logging.DEBUG)
 
     from AthenaCommon import Constants
     algLogLevel = getattr(Constants,args.outputLevel)
 
-    flags = initConfigFlags()
     if any(["data" in f for f in args.filesInput]):
         flags.Trigger.triggerConfig='DB'
 
@@ -96,8 +110,7 @@ if __name__ == '__main__':
     # The decoderAlg needs to load ByteStreamMetadata for the detector mask
     from TriggerJobOpts.TriggerByteStreamConfig import ByteStreamReadCfg
     acc.merge(ByteStreamReadCfg(flags))
-    
-    
+        
     # Generate run3 L1 menu
     from TrigConfigSvc.TrigConfigSvcCfg import L1ConfigSvcCfg
     acc.merge(L1ConfigSvcCfg(flags))
@@ -135,9 +148,25 @@ if __name__ == '__main__':
         # saving/adding the jTower xAOD container
         outputEDM += addEDM('xAOD::jFexTowerContainer', inputjFexTool.jTowersWriteKey.Path)
 
-    decoderAlg = CompFactory.L1TriggerByteStreamDecoderAlg(name="L1TriggerByteStreamDecoder",
-                                                         DecoderTools=decoderTools, OutputLevel=algLogLevel, MaybeMissingROBs=maybeMissingRobs)
 
+    ########################################
+    # eFEX ROIs
+    ########################################
+    if 'eTOBs' in args.outputs:
+        from L1CaloFEXByteStream.L1CaloFEXByteStreamConfig import eFexByteStreamToolCfg
+        eFexTool = eFexByteStreamToolCfg('eFexBSDecoder', flags, TOBs=True, xTOBs=False, decodeInputs=False)
+        for module_id in eFexTool.ROBIDs:
+            maybeMissingRobs.append(module_id)
+
+        decoderTools += [eFexTool]
+        # saving/adding EDM
+        outputEDM += addEDM('xAOD::eFexEMRoIContainer', eFexTool.eEMContainerWriteKey.Path)
+        outputEDM += addEDM('xAOD::eFexTauRoIContainer', eFexTool.eTAUContainerWriteKey.Path)
+
+
+    # Add the decoder tools
+    decoderAlg = CompFactory.L1TriggerByteStreamDecoderAlg(name="L1TriggerByteStreamDecoder",
+                                                           DecoderTools=decoderTools, OutputLevel=algLogLevel, MaybeMissingROBs=maybeMissingRobs)
     acc.addEventAlgo(decoderAlg, sequenceName='AthAlgSeq')
 
     ########################################
@@ -151,10 +180,15 @@ if __name__ == '__main__':
     # Creates the TriggerTower container
     acc.merge(TriggerTowersInputCfg(flags))
     
-    # Uses SCell to decorate the jTowers
-    DecoratorAlgo = L1CaloFEXDecoratorCfg(flags, 'jFexTower2SCellDecorator')   
-    acc.merge(DecoratorAlgo)
+    # Uses SCell to decorate the jTowers (with extra info)
+    if 'jTowers' in args.outputs:
+        DecoratorAlgo = L1CaloFEXDecoratorCfg(flags,'jFexTower2SCellDecorator', ExtraInfo = True)   
+        acc.merge(DecoratorAlgo)
 
+    # Decorate eFEX RoIs
+    if 'eTOBs' in args.outputs:
+        DecoratorAlgo = eFexTOBDecoratorCfg(flags,'eFexTOBDecorator')
+        acc.merge(DecoratorAlgo)
 
 
     # Saving containers

Trigger/TrigT1/L1CaloFEX/L1CaloFEXAlgos/src/components/L1CaloFEXAlgos_entries.cxx

@@ -5,9 +5,11 @@
 #include "../jFexTower2SCellDecorator.h"
 #include "../eFexTowerBuilder.h"
 #include "../jFexEmulatedTowers.h"
+#include "../eFexTOBDecorator.h"
 
 using namespace LVL1;
 
 DECLARE_COMPONENT( jFexTower2SCellDecorator )
 DECLARE_COMPONENT( eFexTowerBuilder )
 DECLARE_COMPONENT( jFexEmulatedTowers )
+DECLARE_COMPONENT( eFexTOBDecorator )

Trigger/TrigT1/L1CaloFEX/L1CaloFEXAlgos/src/eFexTOBDecorator.cxx

+/*
+  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+
+//***************************************************************************
+//                           eFexTOBDecorator  -  description
+//                              -------------------
+//      This algorithm decorates the eFEX TOBs with jet descriminant variables  
+//      recalculated from input data using the eFEXTOBEtTool
+//      
+//     begin                : 03 02 2022
+//     email                : paul.daniel.thompson@cern.ch
+//***************************************************************************/
+#include "eFexTOBDecorator.h"
+#include "L1CaloFEXSim/eFEXegTOB.h"
+#include "L1CaloFEXSim/eFEXtauAlgo.h"
+
+namespace LVL1 {
+
+  eFexTOBDecorator::eFexTOBDecorator(const std::string& name, ISvcLocator* svc) : AthAlgorithm(name, svc){}
+
+  StatusCode eFexTOBDecorator::initialize() {
+    ATH_MSG_INFO( "L1CaloFEXTools/eFexTOBDecorator::initialize()");
+
+    // initialise read and decorator write handles
+    ATH_CHECK( m_eFEXegEDMContainerKey.initialize() );
+    ATH_CHECK( m_eFEXtauEDMContainerKey.initialize() );
+
+    ATH_CHECK( m_RetaCoreDec.initialize() );
+    ATH_CHECK( m_RetaEnvDec.initialize() );
+    ATH_CHECK( m_RhadEMDec.initialize() );
+    ATH_CHECK( m_RhadHadDec.initialize() );
+    ATH_CHECK( m_WstotDenDec.initialize() );    
+    ATH_CHECK( m_WstotNumDec.initialize() );    
+
+    ATH_CHECK( m_RCoreDec.initialize() );      
+    ATH_CHECK( m_REnvDec.initialize() );       
+    ATH_CHECK( m_REMCoreDec.initialize() );    
+    ATH_CHECK( m_REMHadDec.initialize() );     
+
+    // Retrieve the TOB ET sum tool
+    ATH_CHECK( m_eFEXTOBEtTool.retrieve() );
+
+    return StatusCode::SUCCESS;
+  }
+
+  StatusCode eFexTOBDecorator::execute() {
+    
+    // read the TOB containers
+    SG::ReadHandle<xAOD::eFexEMRoIContainer> eFEXegEDMContainerObj{m_eFEXegEDMContainerKey};
+    if (!eFEXegEDMContainerObj.isValid()) {
+      ATH_MSG_ERROR("Failed to retrieve EDM collection");
+      return StatusCode::SUCCESS; 
+    }
+    const xAOD::eFexEMRoIContainer* emEDMConstPtr = eFEXegEDMContainerObj.cptr();
+
+    SG::ReadHandle<xAOD::eFexTauRoIContainer> eFEXtauEDMContainerObj{m_eFEXtauEDMContainerKey};
+    if (!eFEXtauEDMContainerObj.isValid()) {
+      ATH_MSG_ERROR("Failed to retrieve tau EDM collection");
+      return StatusCode::SUCCESS; 
+    }
+    const xAOD::eFexTauRoIContainer* tauEDMConstPtr = eFEXtauEDMContainerObj.cptr();
+    
+    //Setup EM Decorator Handlers
+    SG::WriteDecorHandle<xAOD::eFexEMRoIContainer, unsigned int >   RetaCoreDec  (m_RetaCoreDec );
+    SG::WriteDecorHandle<xAOD::eFexEMRoIContainer, unsigned int >   RetaEnvDec   (m_RetaEnvDec  );
+    SG::WriteDecorHandle<xAOD::eFexEMRoIContainer, unsigned int >   RhadEMDec    (m_RhadEMDec   );
+    SG::WriteDecorHandle<xAOD::eFexEMRoIContainer, unsigned int >   RhadHadDec   (m_RhadHadDec  );
+    SG::WriteDecorHandle<xAOD::eFexEMRoIContainer, unsigned int >   WstotDenDec  (m_WstotDenDec );
+    SG::WriteDecorHandle<xAOD::eFexEMRoIContainer, unsigned int >   WstotNumDec  (m_WstotNumDec );
+
+    //looping over EM TOB to decorate them
+    for ( const xAOD::eFexEMRoI* emRoI : *emEDMConstPtr ){
+              
+      float eta = emRoI->eta();
+      float phi = emRoI->phi();
+      int seed = emRoI->seed();
+      int UnD = emRoI->UpNotDown();
+      std::vector<unsigned int> RetaSums;
+      std::vector<unsigned int> RhadSums;
+      std::vector<unsigned int> WstotSums;
+
+      ATH_CHECK( m_eFEXTOBEtTool->getegSums(eta, phi, seed, UnD, RetaSums, RhadSums, WstotSums) );
+
+      RetaCoreDec (*emRoI) = RetaSums[0];
+      RetaEnvDec  (*emRoI) = RetaSums[1];
+      RhadEMDec   (*emRoI) = RhadSums[0];
+      RhadHadDec  (*emRoI) = RhadSums[1];
+      WstotDenDec (*emRoI) = WstotSums[0];
+      WstotNumDec (*emRoI) = WstotSums[1];
+    }
+
+    //Setup Tau Decorator Handlers
+    SG::WriteDecorHandle<xAOD::eFexTauRoIContainer, unsigned int >   RCoreDec   (m_RCoreDec   );
+    SG::WriteDecorHandle<xAOD::eFexTauRoIContainer, unsigned int >   REnvDec    (m_REnvDec    );
+    SG::WriteDecorHandle<xAOD::eFexTauRoIContainer, unsigned int >   REMCoreDec (m_REMCoreDec );
+    SG::WriteDecorHandle<xAOD::eFexTauRoIContainer, unsigned int >   REMHadDec  (m_REMHadDec  );
+
+    //looping over Tau TOB to decorate them
+    for ( const xAOD::eFexTauRoI* tauRoI : *tauEDMConstPtr ){
+              
+      float eta = tauRoI->eta();
+      float phi = tauRoI->phi();
+      int seed = tauRoI->seed();
+      int UnD = tauRoI->upNotDown();
+      std::vector<unsigned int> RcoreSums;
+      std::vector<unsigned int> RemSums;
+
+      ATH_CHECK( m_eFEXTOBEtTool->gettauSums(eta, phi, seed, UnD, RcoreSums, RemSums) );
+
+      RCoreDec   (*tauRoI) = RcoreSums[0];
+      REnvDec    (*tauRoI) = RcoreSums[1];
+      REMCoreDec (*tauRoI) = RemSums[0];
+      REMHadDec  (*tauRoI) = RemSums[1];
+    }
+    
+    // Return gracefully
+    return StatusCode::SUCCESS;
+  }
+
+}

Trigger/TrigT1/L1CaloFEX/L1CaloFEXAlgos/src/eFexTOBDecorator.h

+/*
+  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+
+//***************************************************************************
+//                           eFexTOBDecorator  -  description:
+//       This algorithm decorates the eFEX TOBs with the recalculated isolation variables
+//                              -------------------
+//     begin                : 13 02 2023
+//     email                : paul.daniel.thompson@cern.ch
+//***************************************************************************/
+
+#ifndef EFEXTOBDECORATORTOOL_H
+#define EFEXTOBDECORATORTOOL_H
+
+#include "AthenaBaseComps/AthAlgorithm.h"
+#include "AsgTools/ToolHandle.h"
+#include "StoreGate/ReadHandleKey.h"
+#include "StoreGate/WriteDecorHandle.h"
+
+
+#include "L1CaloFEXToolInterfaces/IeFEXTOBEtTool.h"
+#include "xAODTrigger/eFexEMRoIContainer.h"
+#include "xAODTrigger/eFexTauRoIContainer.h"
+
+namespace LVL1 {
+    
+  class eFexTOBDecorator : public AthAlgorithm{
+  public:
+    eFexTOBDecorator(const std::string& name, ISvcLocator* svc);
+
+    // Function initialising the algorithm
+    virtual StatusCode initialize();
+    // Function executing the algorithm
+    virtual StatusCode execute();
+    	
+  private:
+    const std::string m_ReadKeyEM_name = "L1_eEMRoI";
+    const std::string m_ReadKeyTau_name = "L1_eTauRoI";
+
+    // Readhandles for eFEX TOBs
+    SG::ReadHandleKey<xAOD::eFexEMRoIContainer> m_eFEXegEDMContainerKey{this,"eFexEMRoIContainer",m_ReadKeyEM_name,"SG key of the input eFex RoI container"};
+    SG::ReadHandleKey<xAOD::eFexTauRoIContainer> m_eFEXtauEDMContainerKey{this,"eFexTauRoIContainer",m_ReadKeyTau_name,"SG key of the input eFex Tau RoI container"};
+    
+    // WriteDecor handles for the EM RoI decorations
+    SG::WriteDecorHandleKey<xAOD::eFexEMRoIContainer> m_RetaCoreDec { this, "RetaCoreDecDecorKey"  , m_ReadKeyEM_name+".RetaCoreDec"  , "Recalculated EM RetaCore" };
+    SG::WriteDecorHandleKey<xAOD::eFexEMRoIContainer> m_RetaEnvDec  { this, "RetaEnvDecDecorKey"   , m_ReadKeyEM_name+".RetaEnvDec"   , "Recalculated EM RetaEnv"  };
+    SG::WriteDecorHandleKey<xAOD::eFexEMRoIContainer> m_RhadEMDec   { this, "RetaEMDecDecorKey"    , m_ReadKeyEM_name+".RhadEMDec"    , "Recalculated EM RetaEM"   };
+    SG::WriteDecorHandleKey<xAOD::eFexEMRoIContainer> m_RhadHadDec  { this, "RhadHadDecDecorKey"   , m_ReadKeyEM_name+".RhadHadDec"   , "Recalculated EM RhadHad"  };
+    SG::WriteDecorHandleKey<xAOD::eFexEMRoIContainer> m_WstotDenDec { this, "WstotDenDecDecorKey"  , m_ReadKeyEM_name+".WstotDenDec"  , "Recalculated EM WstotDen" };
+    SG::WriteDecorHandleKey<xAOD::eFexEMRoIContainer> m_WstotNumDec { this, "WstotNumDecDecorKey"  , m_ReadKeyEM_name+".WstotNumDec"  , "Recalculated EM WstotNum" };
+
+    // WriteDecor handles for the Tau RoI decorations
+    SG::WriteDecorHandleKey<xAOD::eFexTauRoIContainer> m_RCoreDec   { this, "RCoreDecorKey"   , m_ReadKeyTau_name+".RCoreDec"   , "Recalculated Tau RCore" };
+    SG::WriteDecorHandleKey<xAOD::eFexTauRoIContainer> m_REnvDec    { this, "REnvDecorKey"    , m_ReadKeyTau_name+".REnvDec"    , "Recalculated Tau REnv" };
+    SG::WriteDecorHandleKey<xAOD::eFexTauRoIContainer> m_REMCoreDec { this, "REMCoreDecorKey" , m_ReadKeyTau_name+".REMCoreDec" , "Recalculated Tau REMCore" };
+    SG::WriteDecorHandleKey<xAOD::eFexTauRoIContainer> m_REMHadDec  { this, "REMHadDecorKey"  , m_ReadKeyTau_name+".REMHadDec"  , "Recalculated Tau REMHad" };
+
+    ToolHandle<IeFEXTOBEtTool> m_eFEXTOBEtTool {this, "eFEXTOBEtTool", "LVL1::eFEXTOBEtTool", "Tool for reconstructing TOB ET sums"};
+  };
+}
+#endif

Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/python/L1CaloFEXSimCfg.py

@@ -41,6 +41,20 @@ def ReadSCellFromByteStreamCfg(flags, key='SCell', keyIn='SC_ET_ID',SCmask=True)
 
     return acc
 
+def eFEXTOBEtToolCfg(flags):
+    """
+    Configure the eFEX TOB Et Tool which recalculates isolation variables
+    The tool requires eTowers as inputs (add eTowerMaker algorithm)
+    """
+    acc = ComponentAccumulator()
+
+    eTowerMakerAlg = CompFactory.LVL1.eTowerMakerFromSuperCells('eTowerMakerFromSuperCells')
+    acc.addEventAlgo(eTowerMakerAlg)
+
+    eFEXTOBEtTool = CompFactory.LVL1.eFEXTOBEtTool
+    acc.setPrivateTools(eFEXTOBEtTool())
+
+    return acc
 
 def TriggerTowersInputCfg(flags):
     '''Configuration to provide TriggerTowers as input to the Fex simulation'''