LVL1CTP::CTPSimulation Class Reference

#include <CTPSimulation.h>

Inheritance diagram for LVL1CTP::CTPSimulation:

Public Member Functions
	CTPSimulation (const std::string &name, ISvcLocator *pSvcLocator)
	~CTPSimulation ()
virtual StatusCode	initialize () override
virtual StatusCode	start () override
virtual StatusCode	execute (const EventContext &context) const override
virtual StatusCode	stop () override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	bookHists ()
StatusCode	setHistLabels (const TrigConf::L1Menu &l1menu)
StatusCode	createMultiplicityHist (const std::string &type, unsigned int maxMult=10)
StatusCode	setMultiplicityHistLabels (const TrigConf::L1Menu &l1menu, const std::string &type)
StatusCode	hbook (const std::string &path, std::unique_ptr< TH1 > hist)
StatusCode	hbook (const std::string &path, std::unique_ptr< TH2 > hist)
StatusCode	storeMetadata ()
LockedHandle< TH1 > &	get1DHist (const std::string &histName) const
LockedHandle< TH2 > &	get2DHist (const std::string &histName) const
std::string	getBaseHistPath () const
StatusCode	fillInputHistograms (const EventContext &context) const
StatusCode	extractMultiplicities (std::map< std::string, unsigned int > &thrMultiMap, const EventContext &context) const
StatusCode	simulateItems (const std::map< std::string, unsigned int > &thrMultiMap, const EventContext &context) const
unsigned int	calculateMultiplicity (const TrigConf::L1Threshold &confThr, const TrigConf::L1Menu *l1menu, const EventContext &context) const
unsigned int	calculateJetMultiplicity (const TrigConf::L1Threshold &confThr, const TrigConf::L1Menu *l1menu, const EventContext &context) const
unsigned int	calculateEMMultiplicity (const TrigConf::L1Threshold &confThr, const TrigConf::L1Menu *l1menu, const EventContext &context) const
unsigned int	calculateTauMultiplicity (const TrigConf::L1Threshold &confThr, const TrigConf::L1Menu *l1menu, const EventContext &context) const
unsigned int	calculateMETMultiplicity (const TrigConf::L1Threshold &confThr, const TrigConf::L1Menu *l1menu, const EventContext &context) const
unsigned int	calculateMuonMultiplicity (const TrigConf::L1Threshold &confThr, const TrigConf::L1Menu *l1menu, const EventContext &context) const
unsigned int	calculateTopoMultiplicity (const TrigConf::L1Threshold &confThr, const TrigConf::L1Menu *l1menu, const EventContext &context, bool UseLegacy) const
unsigned int	calculateTopoOptMultiplicity (const TrigConf::L1Threshold &confThr, const TrigConf::L1Menu *l1menu, const EventContext &context) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< ITHistSvc >	m_histSvc { this, "THistSvc", "THistSvc/THistSvc", "Histogramming svc" }
ToolHandle< LVL1CTP::ResultBuilder >	m_resultBuilder { this, "ResultBuilder", "LVL1CTP::ResultBuilder/ResultBuilder", "Builds the CTP result" }
ATHRNG::RNGWrapper	m_RNGEngines
std::map< std::string, LockedHandle< TH1 > >	m_hist1D
std::map< std::string, LockedHandle< TH2 > >	m_hist2D
SG::ReadHandleKey< LVL1::FrontPanelCTP >	m_iKeyTopo { this, "TopoInput", LVL1::DEFAULT_L1TopoCTPLocation, "Input from topo" }
SG::ReadHandleKey< LVL1::FrontPanelCTP >	m_iKeyLegacyTopo { this, "LegacyTopoInput", LVL1::DEFAULT_L1TopoLegacyCTPLocation, "Input from legacy topo" }
SG::ReadHandleKey< LVL1::MuCTPICTP >	m_iKeyMuctpi { this, "MuctpiInput", LVL1MUCTPI::DEFAULT_MuonCTPLocation, "Input from Muctpi" }
SG::ReadHandleKey< LVL1::EmTauCTP >	m_iKeyCtpinEM { this, "CtpinEMInput", LVL1::TrigT1CaloDefs::EmTauCTPLocation, "Input from CTPIN em and tau (legacy)" }
SG::ReadHandleKey< LVL1::JetCTP >	m_iKeyCtpinJet { this, "CtpinJetInput", LVL1::TrigT1CaloDefs::JetCTPLocation, "Input from CTPIN jet (legacy)" }
SG::ReadHandleKey< LVL1::EnergyCTP >	m_iKeyCtpinXE { this, "CtpinXEInput", LVL1::TrigT1CaloDefs::EnergyCTPLocation, "Input from CTPIN energy (te,xe,xs - legacy)" }
SG::ReadHandleKey< xAOD::JetRoIContainer >	m_iKeyJFexJets { this, "jFexJetInput", "jRoundJets", "Input list of jFEX jets" }
SG::ReadHandleKey< xAOD::JetRoIContainer >	m_iKeyJFexLJets { this, "jFexLJetInput", "jRoundLargeRJets", "Input list of jFEX large-R jets" }
SG::ReadHandleKey< xAOD::JetRoIContainer >	m_iKeyGFexJets { this, "gFexJetInput", "gL1Jets", "Input list of gFEX jets" }
SG::ReadHandleKey< xAOD::EnergySumRoI >	m_iKeyGFexMETNC { this, "gFexMETNCInput", "gXENOISECUTPerf", "Input list of gFEX MET NC" }
SG::ReadHandleKey< xAOD::EnergySumRoI >	m_iKeyGFexMETRho { this, "gFexMETRhoInput", "gXERHOPerf", "Input list of gFEX MET Rho" }
SG::ReadHandleKey< xAOD::EnergySumRoI >	m_iKeyGFexMETJwoJ { this, "gFexMETJwoJInput", "gXEJWOJPerf", "Input list of gFEX MET JwoJ" }
SG::ReadHandleKey< xAOD::TrigEMClusterContainer >	m_iKeyEFexCluster { this, "eFexClusterInput", "SClusterCl", "Input list of eFEX cluster" }
SG::ReadHandleKey< xAOD::EmTauRoIContainer >	m_iKeyEFexTau { this, "eFexTauInput", "SClusterTau", "Input list of eFEX tau" }
SG::ReadHandleKey< LVL1::ZdcCTP >	m_iKeyZDC {this, "ZdcInput", LVL1::TrigT1CaloDefs::ZdcCTPLocation, "Input from Zdc"}
SG::ReadHandleKey< LVL1::TrtCTP >	m_iKeyTRT {this, "TrtInput", LVL1::DEFAULT_TrtCTPLocation, "Input from Trt"}
SG::WriteHandleKey< CTP_RDO >	m_oKeyRDO {this, "RDOOutput", LVL1CTP::DEFAULT_RDOOutputLocation, "Output of CTP RDO object (sim)"}
SG::WriteHandleKey< xAOD::CTPResult >	m_oKeyCTPResult {this, "CTPResultOutput", LVL1CTP::DEFAULT_CTPResultOutputLocation, "Output of CTPResult (sim)"}
SG::WriteHandleKey< CTPSLink >	m_oKeySLink {this, "ROIOutput", LVL1CTP::DEFAULT_CTPSLinkLocation, "Output of CTP SLink object (sim)"}
Gaudi::Property< bool >	m_isData { this, "IsData", false, "emulate CTP as part of MC or rerun on data" }
Gaudi::Property< std::string >	m_histPath { this, "HistPath", "/EXPERT/L1", "Booking path for the histogram" }
Gaudi::Property< bool >	m_doZDC {this, "DoZDC", false, "emulate CTP with ZDC included"}
Gaudi::Property< bool >	m_doTRT {this, "DoTRT", false, "emulate CTP with TRT included"}
Gaudi::Property< bool >	m_forceBunchGroupPattern { this, "ForceBunchGroupPattern", true, "When true, ignore the bunchgroups and use the provided BunchGroupPattern" }
Gaudi::Property< unsigned int >	m_bunchGroupPattern { this, "BunchGroupPattern", 0x0003, "Bunchgroup pattern applied at every event, useful for simulation. Bit x corresponds to bunchgroup x" }
Gaudi::Property< bool >	m_doL1CaloLegacy { this, "DoL1CaloLegacy", false, "Use L1Calo legacy" }
Gaudi::Property< bool >	m_doL1Topo { this, "DoL1Topo", false, "Use L1Topo" }
Gaudi::Property< bool >	m_doL1TopoLegacy { this, "DoL1TopoLegacy", false, "Use L1Topo Legacy" }
Gaudi::Property< bool >	m_muonRun2Format { this, "MuonMultiplicityRun2Format", false, "Interpret muon multiplicity in Run 2 format (bit 0 unused)" }
Gaudi::Property< bool >	m_useEDMxAOD { this, "UseEDMxAOD", false, "Use EDM based on xAOD class" }
SG::ReadCondHandleKey< TrigConf::L1BunchGroupSet >	m_bgKey {this, "L1BunchGroup", "L1BunchGroup", "L1BunchGroupSet key name"}
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 65 of file CTPSimulation.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

CTPSimulation()

LVL1CTP::CTPSimulation::CTPSimulation	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 42 of file CTPSimulation.cxx.

                                                                                     :
   AthReentrantAlgorithm ( name, pSvcLocator ),
   m_RNGEngines( CTPSimRanluxFactory, SG::getNSlots() )
{}

~CTPSimulation()

LVL1CTP::CTPSimulation::~CTPSimulation

(

)

Definition at line 47 of file CTPSimulation.cxx.

{}

Member Function Documentation

bookHists()

StatusCode LVL1CTP::CTPSimulation::bookHists ( )

private

Definition at line 337 of file CTPSimulation.cxx.

                                {
 
   // jets
   ATH_CHECK ( hbook( "/input/jets/", std::make_unique<TH1I>("jJetPt","Jet p_{T} - jJ", 40, 0, 80) ));
   ATH_CHECK ( hbook( "/input/jets/", std::make_unique<TH1I>("jJetEta","Jet #eta - jJ", 64, -3.2, 3.2) ));
   ATH_CHECK ( hbook( "/input/jets/", std::make_unique<TH1I>("jJetPhi","Jet #phi - jJ", 64, -3.2, 3.2) ));
   ATH_CHECK ( hbook( "/input/jets/", std::make_unique<TH1I>("jLJetPt","Jet p_{T} - jLJ", 40, 0, 80) ));
   ATH_CHECK ( hbook( "/input/jets/", std::make_unique<TH1I>("jLJetEta","Jet #eta - jLJ", 64, -3.2, 3.2) ));
   ATH_CHECK ( hbook( "/input/jets/", std::make_unique<TH1I>("jLJetPhi","Jet #phi - jLJ", 64, -3.2, 3.2) ));
   ATH_CHECK ( hbook( "/input/jets/", std::make_unique<TH1I>("gJetPt","Jet p_{T} - gJ", 40, 0, 80) ));
   ATH_CHECK ( hbook( "/input/jets/", std::make_unique<TH1I>("gJetEta","Jet #eta - gJ", 64, -3.2, 3.2) ));
   ATH_CHECK ( hbook( "/input/jets/", std::make_unique<TH1I>("gJetPhi","Jet #phi - gJ", 64, -3.2, 3.2) ));
   ATH_CHECK ( hbook( "/input/jets/", std::make_unique<TH1I>("gLJetPt","Jet p_{T} - gLJ", 40, 0, 80) ));
   ATH_CHECK ( hbook( "/input/jets/", std::make_unique<TH1I>("gLJetEta","Jet #eta - gLJ", 64, -3.2, 3.2) ));
   ATH_CHECK ( hbook( "/input/jets/", std::make_unique<TH1I>("gLJetPhi","Jet #phi - gLJ", 64, -3.2, 3.2) ));
 
   // MET
   ATH_CHECK ( hbook( "/input/met/", std::make_unique<TH1I>("Pufit","Missing ET from algorithm pufit", 40, 0, 80) ));
   ATH_CHECK ( hbook( "/input/met/", std::make_unique<TH1I>("PufitPhi","Missing ET PUfit phi", 64, -3.2, 3.2) ));
   ATH_CHECK ( hbook( "/input/met/", std::make_unique<TH1I>("Rho","Missing ET from algorithm rhosub", 40, 0, 80) ));
   ATH_CHECK ( hbook( "/input/met/", std::make_unique<TH1I>("RhoPhi","Missing ET rhosub phi", 64, -3.2, 3.2) ));
   ATH_CHECK ( hbook( "/input/met/", std::make_unique<TH1I>("JwoJ","Missing ET from algorithm jet without jets", 40, 0, 80) ));
   ATH_CHECK ( hbook( "/input/met/", std::make_unique<TH1I>("JwoJPhi","Missing ET jet without jet phi", 64, -3.2, 3.2) ));
 
   // cluster
   ATH_CHECK ( hbook( "/input/em/", std::make_unique<TH1I>("et","Cluster et", 40, 0, 40) ));
   ATH_CHECK ( hbook( "/input/em/", std::make_unique<TH1I>("eta","Cluster eta ", 64, -3.2, 3.2) ));
   ATH_CHECK ( hbook( "/input/em/", std::make_unique<TH1I>("phi","Cluster phi", 64, -3.2, 3.2) ));
 
   // tau
   ATH_CHECK ( hbook( "/input/tau/", std::make_unique<TH1I>("et","Tau et", 40, 0, 40) ));
   ATH_CHECK ( hbook( "/input/tau/", std::make_unique<TH1I>("eta","Tau eta ", 64, -3.2, 3.2) ));
   ATH_CHECK ( hbook( "/input/tau/", std::make_unique<TH1I>("phi","Tau phi", 64, -3.2, 3.2) ));
   ATH_CHECK ( hbook( "/input/tau/", std::make_unique<TH1I>("emIso","Tau em isolation", 40, 0, 1) ));
   ATH_CHECK ( hbook( "/input/tau/", std::make_unique<TH1I>("hadIso","Tau hadronic isolation", 40, 0, 1) ));
   ATH_CHECK ( hbook( "/input/tau/", std::make_unique<TH1I>("R3ET","Tau eT", 40, 0, 40) ));
   ATH_CHECK ( hbook( "/input/tau/", std::make_unique<TH1I>("R3Iso","Tau isolation", 40, 0, 1) ));
 
   // input counts
   ATH_CHECK ( hbook( "/input/counts/", std::make_unique<TH1I>("jJets","Number of jets (jJ)", 40, 0, 40) ));
   ATH_CHECK ( hbook( "/input/counts/", std::make_unique<TH1I>("jLJets","Number of jets (jLJ)", 40, 0, 40) ));
   ATH_CHECK ( hbook( "/input/counts/", std::make_unique<TH1I>("gJets","Number of jets (gJ)", 40, 0, 40) ));
   ATH_CHECK ( hbook( "/input/counts/", std::make_unique<TH1I>("gLJets","Number of jets (gLJ)", 40, 0, 40) ));
   ATH_CHECK ( hbook( "/input/counts/", std::make_unique<TH1I>("muons","Number of muons", 10, 0, 10) ));
   ATH_CHECK ( hbook( "/input/counts/", std::make_unique<TH1I>("emcluster","Number of EM clusters", 20, 0, 20) ));
   ATH_CHECK ( hbook( "/input/counts/", std::make_unique<TH1I>("taus","Number of TAU candidates", 20, 0, 20) ));
 
   // threshold multiplicities
   ATH_CHECK ( createMultiplicityHist( "muon" ) );
   ATH_CHECK ( createMultiplicityHist( "jet" ) );
   ATH_CHECK ( createMultiplicityHist( "xe", 2) );
   ATH_CHECK ( createMultiplicityHist( "te", 2) );
   ATH_CHECK ( createMultiplicityHist( "xs", 2) );
   ATH_CHECK ( createMultiplicityHist( "em" ) );
   ATH_CHECK ( createMultiplicityHist( "tau" ) );
 
   ATH_CHECK ( hbook( "/multi/all", (std::unique_ptr<TH2>)std::make_unique<TH2I>("LegacyMult", "Legacy thresholds multiplicity", 1, 0, 1, 10, 0, 10) ));
   ATH_CHECK ( hbook( "/multi/all", (std::unique_ptr<TH2>)std::make_unique<TH2I>("R3Mult", "New thresholds multiplicity", 1, 0, 1, 10, 0, 10) ));
 
   // Topo
   ATH_CHECK( hbook( "/input/topo/", std::make_unique<TH1I>("LegacyTopo0","L1Topo Decision (Legacy 0)", 64, 0, 64) ));
   ATH_CHECK( hbook( "/input/topo/", std::make_unique<TH1I>("LegacyTopo1","L1Topo Decision (Legacy 1)", 64, 0, 64) ));
   ATH_CHECK( hbook( "/input/topo/", std::make_unique<TH1I>("Topo1El","L1Topo Decision (Topo 1 electrical)", 64, 0, 64) ));
   ATH_CHECK( hbook( "/input/topo/", std::make_unique<TH1I>("Topo2El","L1Topo Decision (Topo 2 electrical)", 64, 0, 64) ));
   ATH_CHECK( hbook( "/input/topo/", std::make_unique<TH1I>("Topo3El","L1Topo Decision (Topo 3 electrical)", 64, 0, 64) ));
   ATH_CHECK( hbook( "/input/topo/", std::make_unique<TH1I>("Topo1Opt0","L1Topo Decision (Topo 1 optical 0)", 128, 0, 128) ));
   ATH_CHECK( hbook( "/input/topo/", std::make_unique<TH1I>("Topo1Opt1","L1Topo Decision (Topo 1 optical 1)", 128, 0, 128) ));
   ATH_CHECK( hbook( "/input/topo/", std::make_unique<TH1I>("Topo1Opt2","L1Topo Decision (Topo 1 optical 2)", 128, 0, 128) ));
   ATH_CHECK( hbook( "/input/topo/", std::make_unique<TH1I>("Topo1Opt3","L1Topo Decision (Topo 1 optical 3)", 128, 0, 128) ));
 
   // item decision
   ATH_CHECK ( hbook( "/output/", std::make_unique<TH1I>("tbpById", "Items decision (tbp)", 512, 0, 512) ));
   ATH_CHECK ( hbook( "/output/", std::make_unique<TH1I>("tapById", "Items decision (tap)", 512, 0, 512) ));
   ATH_CHECK ( hbook( "/output/", std::make_unique<TH1I>("tavById", "Items decision (tav)", 512, 0, 512) ));
   ATH_CHECK ( hbook( "/output/", std::make_unique<TH1I>("tbpByName", "Items decision (tbp)", 512, 0, 512) ));
   ATH_CHECK ( hbook( "/output/", std::make_unique<TH1I>("tapByName", "Items decision (tap)", 512, 0, 512) ));
   ATH_CHECK ( hbook( "/output/", std::make_unique<TH1I>("tavByName", "Items decision (tav)", 512, 0, 512) ));
 
   ATH_CHECK ( hbook( "/", std::make_unique<TH1I>("bcid", "Bunch crossing ID", 3564, 0, 3564)) );
 
   ATH_CHECK(storeMetadata());
 
   return StatusCode::SUCCESS;
}

calculateEMMultiplicity()

unsigned int LVL1CTP::CTPSimulation::calculateEMMultiplicity ( const TrigConf::L1Threshold & confThr, const TrigConf::L1Menu * l1menu, const EventContext & context ) const

private

Definition at line 859 of file CTPSimulation.cxx.

                                                                                                                                                     {
   unsigned int multiplicity (0);
   if ( confThr.name()[0]=='e' ) {
      // new EM threshold from eFEX
      if(!m_iKeyEFexCluster.empty()) {
         float scale = l1menu->getObject("thresholds.legacyCalo.EM.emscale").getValue<float>();
         auto eFexCluster = SG::makeHandle( m_iKeyEFexCluster, context );
         for ( const auto cl : *eFexCluster ) {
            float eta = cl->eta();
            int ieta = int((eta + (eta>0 ? 0.005 : -0.005))/0.1);
            unsigned int thrV = confThr.thrValue( ieta );
            bool clusterPasses = ( ((unsigned int) cl->et()) > (thrV * scale) ); // need to add cut on isolation and other variables, once available
            multiplicity +=  clusterPasses ? 1 : 0;
         }
      }
   } else {
      // old EM threshold from data
      if(m_doL1CaloLegacy) {
         auto ctpinEM  = SG::makeHandle( m_iKeyCtpinEM, context );
         if ( ctpinEM.isValid() ) {
            if( l1menu->connector("EM1").hasLine(confThr.name()) ) {
               auto & triggerline = l1menu->connector("EM1").triggerLine(confThr.name());
               multiplicity = CTPUtil::getMult( ctpinEM->cableWord0(), triggerline.startbit(), triggerline.endbit() );
            } else if( l1menu->connector("EM2").hasLine(confThr.name()) ) {
               auto & triggerline = l1menu->connector("EM2").triggerLine(confThr.name());
               multiplicity = CTPUtil::getMult( ctpinEM->cableWord1(), triggerline.startbit(), triggerline.endbit() );
            }
         }
      }
   }
   get2DHist( "/multi/em/" + confThr.type() + "Mult" )->Fill(confThr.mapping(), multiplicity);
   ATH_MSG_DEBUG("EM MULT calculated mult for threshold " << confThr.name() << " : " << multiplicity);
   return multiplicity;
}

calculateJetMultiplicity()

unsigned int LVL1CTP::CTPSimulation::calculateJetMultiplicity ( const TrigConf::L1Threshold & confThr, const TrigConf::L1Menu * l1menu, const EventContext & context ) const

private

Definition at line 836 of file CTPSimulation.cxx.

                                                                                                                                                      {
   unsigned int multiplicity = 0;
   if( confThr.type() == "JET" ) {
      if(m_doL1CaloLegacy) {
         auto ctpinJet  = SG::makeHandle( m_iKeyCtpinJet, context );
         if ( ctpinJet.isValid() ) {
            if( l1menu->connector("JET1").hasLine(confThr.name()) ) {
               auto & triggerline = l1menu->connector("JET1").triggerLine(confThr.name());
               multiplicity = CTPUtil::getMult( ctpinJet->cableWord0(), triggerline.startbit(), triggerline.endbit() );
            } else if( l1menu->connector("JET2").hasLine(confThr.name()) ) {
               auto & triggerline = l1menu->connector("JET2").triggerLine(confThr.name());
               multiplicity = CTPUtil::getMult( ctpinJet->cableWord1(), triggerline.startbit(), triggerline.endbit() );
            }
         }
      }
   }
   get2DHist( "/multi/jet/" + confThr.type() + "Mult" )->Fill(confThr.mapping(), multiplicity);
   ATH_MSG_DEBUG("JET MULT calculated mult for threshold " << confThr.name() << " : " << multiplicity);
   return multiplicity;
}

calculateMETMultiplicity()

unsigned int LVL1CTP::CTPSimulation::calculateMETMultiplicity ( const TrigConf::L1Threshold & confThr, const TrigConf::L1Menu * l1menu, const EventContext & context ) const

private

Definition at line 934 of file CTPSimulation.cxx.

                                                                                                                                                      {
   unsigned int multiplicity = 0;
   if ( confThr.type() == "XE" or confThr.type() == "TE" or confThr.type() == "XS" ) {
      // old XE, TE, XS
      if(m_doL1CaloLegacy) {
         auto ctpinEnergy = SG::makeHandle( m_iKeyCtpinXE, context );
         if ( ctpinEnergy.isValid() ) {
            if( l1menu->connector("EN1").hasLine(confThr.name()) ) {
               auto & triggerline = l1menu->connector("EN1").triggerLine(confThr.name());
               multiplicity = CTPUtil::getMult( ctpinEnergy->cableWord0(), triggerline.startbit(), triggerline.endbit() );
            } else if( l1menu->connector("EN2").hasLine(confThr.name()) ) {
               auto & triggerline = l1menu->connector("EN2").triggerLine(confThr.name());
               multiplicity = CTPUtil::getMult( ctpinEnergy->cableWord1(), triggerline.startbit(), triggerline.endbit() );
            }
         }
      }
   } else {
      // new XE
      const SG::ReadHandleKey< xAOD::EnergySumRoI > * rhk { nullptr };
      if ( confThr.name().find("gXENC")==0 ) {
         rhk = & m_iKeyGFexMETNC;
         ATH_MSG_DEBUG("Using Pufit input for threshold " << confThr.name() );
      } else if ( confThr.name().find("gXERHO")==0 ) {
         rhk = & m_iKeyGFexMETRho;
         ATH_MSG_DEBUG("Using Rho input for threshold " << confThr.name() );
      } else if ( confThr.name().find("gXEJWOJ")==0 ) {
         rhk = & m_iKeyGFexMETJwoJ;
         ATH_MSG_DEBUG("Using JwoJ input for threshold " << confThr.name() );
      } else {
         rhk = & m_iKeyGFexMETJwoJ;
         ATH_MSG_DEBUG("Using default input JwoJ for threshold " << confThr.name() );
      }
      if(!rhk->empty()) {
         auto met = SG::makeHandle( *rhk, context );
         multiplicity = ( met->energyT()/1000. < confThr.getAttribute<unsigned int>("xe") ) ? 0 : 1; // energyT value is in MeV, cut in GeV
      }
   }
   if(confThr.type() == "TE") {
      get2DHist( "/multi/te/" + confThr.type() + "Mult" )->Fill(confThr.mapping(), multiplicity);
      ATH_MSG_DEBUG("TE MULT calculated mult for threshold " << confThr.name() << " : " << multiplicity);
   } else  if(confThr.type() == "XS") {
      get2DHist( "/multi/xs/" + confThr.type() + "Mult" )->Fill(confThr.mapping(), multiplicity);
      ATH_MSG_DEBUG("XS MULT calculated mult for threshold " << confThr.name() << " : " << multiplicity);
   } else {
      get2DHist( "/multi/xe/" + confThr.type() + "Mult" )->Fill(confThr.mapping(), multiplicity);
      ATH_MSG_DEBUG("XE MULT calculated mult for threshold " << confThr.name() << " : " << multiplicity);
   }
   return multiplicity;
}

calculateMultiplicity()

unsigned int LVL1CTP::CTPSimulation::calculateMultiplicity ( const TrigConf::L1Threshold & confThr, const TrigConf::L1Menu * l1menu, const EventContext & context ) const

private

Definition at line 1101 of file CTPSimulation.cxx.

                                                                                                                                                   {
   unsigned int multiplicity = 0;
   try {
      if ( confThr.type() == "EM" ) {
         multiplicity = calculateEMMultiplicity( confThr, l1menu, context );
      } else if ( confThr.type() == "TAU" ) {
         multiplicity = calculateTauMultiplicity( confThr, l1menu, context );
      } else if ( confThr.type() == "XE" || confThr.type() == "TE" || confThr.type() == "XS" ) {
         multiplicity = calculateMETMultiplicity( confThr, l1menu, context );
      } else if ( confThr.type() == "JET" ) {
         multiplicity = calculateJetMultiplicity( confThr, l1menu, context );
      } else if ( confThr.type() == "MU" ) {
         multiplicity = calculateMuonMultiplicity( confThr, l1menu, context );
      } else if ( confThr.type() == "R2TOPO") {
     multiplicity = calculateTopoMultiplicity( confThr, l1menu, context, true );
      } else if ( confThr.type() == "TOPO" ) {
     multiplicity = calculateTopoMultiplicity( confThr, l1menu, context, m_doL1TopoLegacy);
      } else if ( confThr.type()[0] == 'e' || confThr.type()[0] == 'c' || confThr.type()[0] == 'j' || confThr.type()[0] == 'g' ){
         multiplicity = calculateTopoOptMultiplicity( confThr, l1menu, context );
      }
   }
   catch(std::exception & ex) {
      ATH_MSG_FATAL("Caught exception when calculating multiplicity for threshold " << confThr.name() << ": " << ex.what());
      throw;
   }
   // all other thresholds are not simulated
   return multiplicity;
}

calculateMuonMultiplicity()

unsigned int LVL1CTP::CTPSimulation::calculateMuonMultiplicity ( const TrigConf::L1Threshold & confThr, const TrigConf::L1Menu * l1menu, const EventContext & context ) const

private

Definition at line 986 of file CTPSimulation.cxx.

                                                                                                                                                       {
   if(m_iKeyMuctpi.empty()) {
      return 0;
   }
   unsigned int multiplicity = 0;
   auto ctpinMuon  = SG::makeHandle( m_iKeyMuctpi, context );
   if ( ctpinMuon.isValid() ) {
      auto & triggerline = l1menu->connector("MuCTPiOpt0").triggerLine(confThr.name());
      multiplicity = CTPUtil::getMuonMult( ctpinMuon->muCTPIWord(), triggerline.startbit() + (m_muonRun2Format ? 1 : 0), triggerline.endbit()+ (m_muonRun2Format ? 1 : 0) );
   }
   get2DHist( "/multi/muon/" + confThr.type() + "Mult" )->Fill(confThr.mapping(), multiplicity);
   ATH_MSG_DEBUG("MU MULT calculated mult for threshold " << confThr.name() << " : " << multiplicity);
   return multiplicity;
}

calculateTauMultiplicity()

unsigned int LVL1CTP::CTPSimulation::calculateTauMultiplicity ( const TrigConf::L1Threshold & confThr, const TrigConf::L1Menu * l1menu, const EventContext & context ) const

private

Definition at line 896 of file CTPSimulation.cxx.

                                                                                                                                                      {
   unsigned int multiplicity = 0;
   if ( confThr.name()[0]=='e' ) {
      // new TAU threshold from eFEX
      auto eFexTaus  = SG::makeHandle( m_iKeyEFexTau, context );
      const static SG::AuxElement::ConstAccessor<float> accR3ClET ("R3ClusterET");
      const static SG::AuxElement::ConstAccessor<float> accR3ClIso ("R3ClusterIso");
      if( eFexTaus.isValid() ) {
         for ( const auto tau : *eFexTaus ) {
            unsigned int eT = (unsigned int) (accR3ClET(*tau)/1000.); // tau eT is in MeV while the cut is in GeV - this is only temporary and needs to be made consistent for all L1Calo
            //float iso = accR3ClIso(*tau);
            unsigned int etCut = confThr.data().get_child("et").get_value<unsigned int>();
            bool tauPasses = ( eT >= etCut ); // need to add cut on isolation and other variables, once available
            multiplicity +=  tauPasses ? 1 : 0;
         }
      }
   } else {
      // old TAU threshold
      if(m_doL1CaloLegacy) {
         auto ctpinEM  = SG::makeHandle( m_iKeyCtpinEM, context );
         if ( ctpinEM.isValid() ) {
            if( l1menu->connector("TAU1").hasLine(confThr.name()) ) {
               auto & triggerline = l1menu->connector("TAU1").triggerLine(confThr.name());
               multiplicity = CTPUtil::getMult( ctpinEM->cableWord2(), triggerline.startbit(), triggerline.endbit() );
            } else if( l1menu->connector("TAU2").hasLine(confThr.name()) ) {
               auto & triggerline = l1menu->connector("TAU2").triggerLine(confThr.name());
               multiplicity = CTPUtil::getMult( ctpinEM->cableWord3(), triggerline.startbit(), triggerline.endbit() );
            }
         }
      }
   }
   get2DHist( "/multi/tau/" + confThr.type() + "Mult" )->Fill(confThr.mapping(), multiplicity);
   ATH_MSG_DEBUG("TAU MULT calculated mult for threshold " << confThr.name() << " : " << multiplicity);
   return multiplicity;
}

calculateTopoMultiplicity()

unsigned int LVL1CTP::CTPSimulation::calculateTopoMultiplicity ( const TrigConf::L1Threshold & confThr, const TrigConf::L1Menu * l1menu, const EventContext & context, bool UseLegacy = false ) const

private

Definition at line 1042 of file CTPSimulation.cxx.

                                                                                                                                                                             {
   unsigned int multiplicity = 0;
   if(UseLegacy){
     if (m_iKeyLegacyTopo.empty() || !m_doL1TopoLegacy )
       {
     return 0;
       }
     multiplicity = 0;
     auto topoInput = SG::makeHandle( m_iKeyTopo, context );
     if(topoInput.isValid()) {
       uint64_t cable = 0;
       std::string conn("");
       if( l1menu->connector("LegacyTopo0").hasLine(confThr.name()) ) {
     conn = "LegacyTopo0";
     cable = ( (uint64_t)topoInput->cableWord1( 1 ) << 32) + topoInput->cableWord1( 0 );
       } else if( l1menu->connector("LegacyTopo1").hasLine(confThr.name()) ) {
     conn = "LegacyTopo1";
     cable = ( (uint64_t)topoInput->cableWord2( 1 ) << 32) + topoInput->cableWord2( 0 );
       }
       if(conn != "") {
     auto & triggerline = l1menu->connector(conn).triggerLine(confThr.name());
     ATH_MSG_DEBUG( " ---> Topo input " << confThr.name() << " on module " << conn
            << ", cable start " << triggerline.startbit() << " and end " << triggerline.endbit()
            << " double word 0x" << std::setw(16) << std::setfill('0') << std::hex << cable << std::dec << std::setfill(' ') );
     multiplicity = CTPUtil::getMultTopo( cable, triggerline.startbit(), triggerline.endbit(), triggerline.clock() );
       }
     }
   }
   else{
     if (m_iKeyTopo.empty() || !m_doL1Topo )
       {
     return 0;
       }
     multiplicity = 0;
     auto topoInput = SG::makeHandle( m_iKeyTopo, context );
     if(topoInput.isValid()) {
       uint64_t cable = 0;
       std::string conn("");
       if( l1menu->connector("Topo2El").hasLine(confThr.name()) ) {
         conn = "Topo2El";
         cable = ( (uint64_t)topoInput->cableWord1( 1 ) << 32) + topoInput->cableWord1( 0 );
       } else if( l1menu->connector("Topo3El").hasLine(confThr.name()) ) {
         conn = "Topo3El";
         cable = ( (uint64_t)topoInput->cableWord2( 1 ) << 32) + topoInput->cableWord2( 0 );
       }
       if(conn != "") {
         auto & triggerline = l1menu->connector(conn).triggerLine(confThr.name());
         ATH_MSG_DEBUG( " ---> Topo input " << confThr.name() << " on module " << conn
                        << ", cable start " << triggerline.startbit() << " and end " << triggerline.endbit()
                        << " double word 0x" << std::setw(16) << std::setfill('0') << std::hex << cable << std::dec << std::setfill(' ') );
         multiplicity = CTPUtil::getMultTopo( cable, triggerline.startbit(), triggerline.endbit(), triggerline.clock() );
       }
     }
   }
   return multiplicity;
}

calculateTopoOptMultiplicity()

unsigned int LVL1CTP::CTPSimulation::calculateTopoOptMultiplicity ( const TrigConf::L1Threshold & confThr, const TrigConf::L1Menu * l1menu, const EventContext & context ) const

private

Definition at line 1003 of file CTPSimulation.cxx.

                                                                                                                                                          {
  if(m_iKeyTopo.empty() || !m_doL1Topo ) {
    return 0;
  }
  unsigned int multiplicity = 0;
  auto topoInput = SG::makeHandle( m_iKeyTopo, context );
  std::string connector = "";
  if (topoInput.isValid()) {
    connector = l1menu->connectorNameFromThreshold(confThr.name());
    auto & triggerline = l1menu->connector(connector).triggerLine(confThr.name());
    std::bitset<128> bits = topoInput->optcableWord(connector);
    multiplicity = CTPUtil::getOptMult( bits, triggerline.startbit(), triggerline.endbit() );
  }
  std::string subfolder = "";
  if (confThr.type().find("XE") != std::string::npos) {
    subfolder = "xe";
  } else if (confThr.type().find("TE") != std::string::npos) {
    subfolder = "te";
  } else if (confThr.type().find("TAU") != std::string::npos) {
    subfolder = "tau";
  } else if (confThr.type().find("EM") != std::string::npos) {
    subfolder = "em";
  } else if (confThr.type().find("jJ") != std::string::npos) {
    subfolder = "jet";
  } else if (confThr.type().find("jLJ") != std::string::npos) {
    subfolder = "jet";
  } else if (confThr.type().find("gJ") != std::string::npos) {
    subfolder = "jet";
  } else if (confThr.type().find("gLJ") != std::string::npos) {
    subfolder = "jet";
  }
  get2DHist( "/multi/" + subfolder + "/" + confThr.type() + "Mult" )->Fill(confThr.mapping(), multiplicity);
  ATH_MSG_DEBUG("TOPO OPT input MULT calculated mult for threshold " << confThr.name() << " : " << multiplicity << " received via connector: " << connector);
  //ATH_MSG_INFO("TOPO OPT input MULT calculated mult for threshold " << confThr.name() << " : " << multiplicity << " received via connector: " << connector);
  return multiplicity;
}

createMultiplicityHist()

StatusCode LVL1CTP::CTPSimulation::createMultiplicityHist ( const std::string & type, unsigned int maxMult = 10 )

private

Definition at line 143 of file CTPSimulation.cxx.

                                                                                          {
 
   StatusCode sc;
   std::map<std::string,std::vector<std::string>> typeMapping = {
      { "muon", {"MU"} },
      { "jet", {"JET", "jJ", "jLJ", "gJ", "gLJ"} },
      { "xe", {"XE", "gXE", "jXE"} },
      { "te", {"TE", "jTE", "gTE"} },
      { "xs", {"XS"} },
      { "em", {"EM", "eEM", "jEM"} },
      { "tau", {"TAU", "eTAU", "jTAU", "cTAU"} }
   };
   std::vector<TrigConf::L1Threshold> thrV;
   for( const std::string & t : typeMapping[type] ) {
      size_t xsize = 1;
      TH2* hist = new TH2I( Form("%sMult", t.c_str()),
                            Form("%s threshold multiplicity", t.c_str()), xsize, 0, xsize, maxMult, 0, maxMult);
      sc = hbook( "/multi/" + type, std::unique_ptr<TH2>(hist));
   }
 
   return sc;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode LVL1CTP::CTPSimulation::execute ( const EventContext & context ) const

overridevirtual

Definition at line 127 of file CTPSimulation.cxx.

                                                                 {
 
   ATH_MSG_DEBUG("execute");
 
   fillInputHistograms(context).ignore();
 
   std::map<std::string, unsigned int> thrMultiMap;
 
   extractMultiplicities(thrMultiMap, context).ignore();
 
   simulateItems(thrMultiMap, context).ignore();
 
   return StatusCode::SUCCESS;
}

extractMultiplicities()

StatusCode LVL1CTP::CTPSimulation::extractMultiplicities ( std::map< std::string, unsigned int > & thrMultiMap, const EventContext & context ) const

private

Definition at line 622 of file CTPSimulation.cxx.

                                                                                                                            {
 
   const TrigConf::L1Menu * l1menu = nullptr;
   ATH_CHECK( detStore()->retrieve(l1menu) );
 
   thrMultiMap.clear();
 
   std::vector<std::string> connNames = l1menu->connectorNames();
   for (const std::string connName : {"LegacyTopo0", "LegacyTopo1", "Topo1El", "Topo2El", "Topo3El", "Topo1Opt0", "Topo1Opt1", "Topo1Opt2", "Topo1Opt3", "CTPCAL", "NIM2"})
   {
      if( find(connNames.begin(), connNames.end(), connName) == connNames.end() ) {
         continue;
      }
      bool opt_cable = false;
      std::bitset<128> cable128 {0};
      uint64_t cable {0};
      if (connName.starts_with( "Legacy")) { // legacy topo
         if (m_iKeyLegacyTopo.empty() || !m_doL1CaloLegacy || !m_doL1TopoLegacy )
         {
            continue;
         }
         auto topoInput = SG::makeHandle( m_iKeyLegacyTopo, context );
         if (not topoInput.isValid()) {
            continue;
         }
         if(connName == "LegacyTopo0") {
            cable = ( (uint64_t)topoInput->cableWord1( 1 ) << 32) + topoInput->cableWord1( 0 );
         } else if (connName == "LegacyTopo1") {
            cable = ( (uint64_t)topoInput->cableWord2( 1 ) << 32) + topoInput->cableWord2( 0 );
         }
      }
      else if (connName.starts_with( "CTPCAL") && m_doZDC) // ZDC simulation
      {
         auto zdcInput = SG::makeHandle(m_iKeyZDC, context);
         if (not zdcInput.isValid())
         {
            continue;
         }
         cable = static_cast<uint64_t>(zdcInput->cableWord0());
         auto &conn = l1menu->connector(connName);
         for (auto &tl : conn.triggerLines()){
            if (tl.name().find("ZDC") == std::string::npos)
            {
               continue;
            }
         uint flatIndex = tl.flatindex();
         uint pass = (cable & (uint64_t(0x1) << flatIndex)) == 0 ? 0 : 1;
         thrMultiMap[tl.name()] = pass;
         ATH_MSG_DEBUG(tl.name() << " MULT calculated mult for topo " << pass);
 
         }
         continue;
      }
      else if (connName.starts_with( "NIM2"))
      {
     if (m_doTRT) // TRT simulation
     {
             auto trtInput = SG::makeHandle(m_iKeyTRT, context);
             if (not trtInput.isValid())
             {
                continue;
             }
             cable = static_cast<uint64_t>(trtInput->cableWord0());
             auto &conn = l1menu->connector(connName);
             for (auto &tl : conn.triggerLines()){
                if (tl.name().find("TRT") == std::string::npos)
                {
                   continue;
                }
                uint flatIndex = tl.flatindex();
                uint pass = (cable & (uint64_t(0x1) << flatIndex)) == 0 ? 0 : 1;
                thrMultiMap[tl.name()] = pass;
                ATH_MSG_DEBUG(tl.name() << " MULT calculated mult for topo " << pass);
             }
         }
     if (m_doZDC) // ZDC ALT simulation
     {
             auto zdcInput = SG::makeHandle(m_iKeyZDC, context);
             if (not zdcInput.isValid())
             {
                continue;
             }
             cable = static_cast<uint64_t>(zdcInput->cableWord1());
             auto &conn = l1menu->connector(connName);
             for (const auto &tl : conn.triggerLines()){
                if (tl.name().find("ZDC") == std::string::npos)
                {
                   continue;
                }
                uint flatIndex = tl.flatindex();
                uint pass = (cable & (uint64_t(0x1) << flatIndex)) == 0 ? 0 : 1;
                thrMultiMap[tl.name()] = pass;
                ATH_MSG_DEBUG(tl.name() << " MULT calculated mult for topo " << pass);
             }
     } 
         continue;
      }
 
       else { // new topo
         if (m_iKeyTopo.empty() || !m_doL1Topo )
         {
            continue;
         }
         auto topoInput = SG::makeHandle( m_iKeyTopo, context );
         if (not topoInput.isValid()) {
            continue;
         }
         if(connName == "Topo1El") {
            cable = ( (uint64_t)topoInput->cableWord0( 1 ) << 32) + topoInput->cableWord0( 0 );
         } else if(connName == "Topo2El") {
            cable = ( (uint64_t)topoInput->cableWord1( 1 ) << 32) + topoInput->cableWord1( 0 );
         } else if (connName == "Topo3El") {
            cable = ( (uint64_t)topoInput->cableWord2( 1 ) << 32) + topoInput->cableWord2( 0 );
         } else if(connName == "Topo1Opt0") {
            ATH_MSG_DEBUG("BIT word Topo1Opt0: " << topoInput->optcableWord( connName ));
            opt_cable = true;
            cable128 = topoInput->optcableWord( connName );
         } else if(connName == "Topo1Opt1") {
            ATH_MSG_DEBUG("BIT word Topo1Opt1: " << topoInput->optcableWord( connName ));
            opt_cable = true;
            cable128 = topoInput->optcableWord( connName );
         } else if(connName == "Topo1Opt2") {
            ATH_MSG_DEBUG("BIT word Topo1Opt2: " << topoInput->optcableWord( connName ));
            opt_cable = true;
            cable128 = topoInput->optcableWord( connName );
         } else if(connName == "Topo1Opt3") {
            ATH_MSG_DEBUG("BIT word Topo1Opt3: " << topoInput->optcableWord( connName ));
            opt_cable = true;
            cable128 = topoInput->optcableWord( connName );
         }
      }
      auto & conn = l1menu->connector(connName);
      for(uint fpga : {0,1}) {
         for(uint clock : {0,1}) {
            for(auto & tl : conn.triggerLines(fpga,clock)) {
               uint flatIndex = tl.flatindex();
               uint pass = 0;
               if (opt_cable) {
                   pass = ((cable128 >> flatIndex).test(0)) == 0 ? 0 : 1;
               }
               else {
                   pass = (cable & (static_cast<uint64_t>(0x1) << flatIndex)) == 0 ? 0 : 1;
               }
               if(size_t pos = tl.name().find('['); pos == std::string::npos) {
                  thrMultiMap[tl.name()] = pass;
                  ATH_MSG_DEBUG(tl.name() << " MULT calculated mult for topo " << pass);
               } else {
                  auto thrName = tl.name().substr(0,pos);
                  int bit = std::stoi(tl.name().substr(pos+1));
                  thrMultiMap.try_emplace(thrName, 0);
                  thrMultiMap[thrName] += (pass << bit);
                  ATH_MSG_DEBUG(thrName << " MULT updated mult for topo " << pass);
               }
            }
         }
      }
   }
   for ( auto & thr : l1menu->thresholds() ) {
      if (thr->type() == "TOPO" or thr->type() == "MULTTOPO" or thr->type() == "MUTOPO")
      {
         continue;
      }
      if( thr->type() == "ZDC" && m_doZDC ){
         continue;
      }
      if( thr->name() == "NIMTRT" && m_doTRT ){
         continue;
      }
      // get the multiplicity for each threshold
      unsigned int multiplicity = calculateMultiplicity(*thr, l1menu, context);
      // and record in threshold--> multiplicity map (to be used for item decision)
      thrMultiMap[thr->name()] = multiplicity;
      ATH_MSG_DEBUG( thr->name()  << " MULT calculated mult for topo " << multiplicity);
   }
 
   // internal triggers
   auto bcid = context.eventID().bunch_crossing_id();
   if( m_forceBunchGroupPattern ) {
      // force bunch group pattern from job options
      for ( size_t bg = 0; bg < 16; ++bg ) {
         std::string bgName("BGRP");
         bgName += std::to_string(bg);
         thrMultiMap[bgName] = ( m_bunchGroupPattern & (0x1<<bg) ) ? 1 : 0;
      }
   } else {
      // use bunchgroup definition from configuration and pick according to the BCID
      SG::ReadCondHandle<TrigConf::L1BunchGroupSet> bgkey(m_bgKey, context);
      ATH_CHECK(bgkey.isValid());
      const TrigConf::L1BunchGroupSet *l1bgs = *bgkey;
      if (l1bgs)
      {
         for (size_t i = 0; i < l1bgs->maxNBunchGroups(); ++i)
         {
            std::shared_ptr<TrigConf::L1BunchGroup> bg = l1bgs->getBunchGroup(i);
            thrMultiMap[std::string("BGRP") + std::to_string(i)] = bg->contains(bcid) ? 1 : 0;
         }
      }
      else
      {
         ATH_MSG_ERROR("Did not find L1BunchGroupSet in DetectorStore");
      }
   }
   
   // all RNDM triggers run with 40MHz, so they are always in
   thrMultiMap["RNDM0"] = 1;
   thrMultiMap["RNDM1"] = 1;
   thrMultiMap["RNDM2"] = 1;
   thrMultiMap["RNDM3"] = 1;
 
   return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 89 of file AthCommonAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

fillInputHistograms()

StatusCode LVL1CTP::CTPSimulation::fillInputHistograms ( const EventContext & context ) const

private

Definition at line 423 of file CTPSimulation.cxx.

                                                                           {
 
   ATH_MSG_DEBUG( "fillInputHistograms" );
 
   // jFEX jets
   if( not m_iKeyJFexJets.empty() ) {
      auto jFexJets  = SG::makeHandle( m_iKeyJFexJets, context );
      if(jFexJets.isValid()) {
         get1DHist("/input/counts/jJets")->Fill(jFexJets->size());
         auto h0 = *get1DHist("/input/jets/jJetPt"); // calling operator* to get the Guard outside the filling loop
         auto h1 = *get1DHist("/input/jets/jJetEta");
         auto h2 = *get1DHist("/input/jets/jJetPhi");
         for( const auto jet : *jFexJets ) {
            h0->Fill(fabs(jet->et8x8()/1000.));
            h1->Fill(jet->eta());
            h2->Fill(jet->phi());
         }
      } else {
         ATH_MSG_DEBUG("No collection " << m_iKeyJFexJets);
      }
   }
 
   // jFEX large-R jets
   if( not m_iKeyJFexLJets.empty() ) {
      auto jFexLJets = SG::makeHandle( m_iKeyJFexLJets, context );
      if(jFexLJets.isValid()) {
         get1DHist("/input/counts/jLets")->Fill(jFexLJets->size());
         auto h0 = *get1DHist("/input/jets/jLJetPt");
         auto h1 = *get1DHist("/input/jets/jLJetEta");
         auto h2 = *get1DHist("/input/jets/jLJetPhi");
         for( const auto jet : *jFexLJets ) {
            h0->Fill(fabs(jet->et8x8()/1000.));
            h1->Fill(jet->eta());
            h2->Fill(jet->phi());
         }
      } else {
         ATH_MSG_DEBUG("No collection " << m_iKeyJFexLJets);
      }
   } else {
      ATH_MSG_DEBUG("No collection " << m_iKeyJFexLJets);
   }
 
   // gFEX jets
   if( not m_iKeyGFexJets.empty() ) {
      auto gFexJets  = SG::makeHandle( m_iKeyGFexJets, context );
      if(gFexJets.isValid()) {
         get1DHist("/input/counts/gJets")->Fill(gFexJets->size());
         auto h0 = *get1DHist("/input/jets/gJetPt");
         auto h1 = *get1DHist("/input/jets/gJetEta");
         auto h2 = *get1DHist("/input/jets/gJetPhi");
         for( const auto jet : *gFexJets ) {
            h0->Fill(fabs(jet->et8x8()/1000.));
            h1->Fill(jet->eta());
            h2->Fill(jet->phi());
         }
      } else {
         ATH_MSG_DEBUG("No collection " << m_iKeyGFexJets);
      }
   }
 
   // MET
   if( not m_iKeyGFexMETNC.empty() ) {
      auto gFexMETPufit  = SG::makeHandle( m_iKeyGFexMETNC, context );
      if( gFexMETPufit.isValid() ) {
         get1DHist("/input/met/Pufit")->Fill(gFexMETPufit->energyT()/1000.);
         get1DHist("/input/met/PufitPhi")->Fill(atan2(gFexMETPufit->energyX(), gFexMETPufit->energyY()));
      } else {
         ATH_MSG_DEBUG("No collection " << m_iKeyGFexMETNC);
      }
   }
 
   if( not m_iKeyGFexMETRho.empty() ) {
      auto gFexMETRho  = SG::makeHandle( m_iKeyGFexMETRho, context );
      if( gFexMETRho.isValid() ) {
         get1DHist("/input/met/Rho")->Fill(gFexMETRho->energyT()/1000.);
         get1DHist("/input/met/RhoPhi")->Fill(atan2(gFexMETRho->energyX(), gFexMETRho->energyY()));
      } else {
         ATH_MSG_DEBUG("No collection " << m_iKeyGFexMETRho);
      }
   }
 
   if( not m_iKeyGFexMETJwoJ.empty() ) {
      auto gFexMETJwoJ  = SG::makeHandle( m_iKeyGFexMETJwoJ, context );
      if( gFexMETJwoJ.isValid() ) {
         get1DHist("/input/met/JwoJ")->Fill(gFexMETJwoJ->energyT()/1000.);
         get1DHist("/input/met/JwoJPhi")->Fill(atan2(gFexMETJwoJ->energyX(), gFexMETJwoJ->energyY()));
      } else {
         ATH_MSG_DEBUG("No collection " << m_iKeyGFexMETJwoJ);
      }
   }
 
   // EM cluster
   if( not m_iKeyEFexCluster.empty() ) {
      auto eFexCluster  = SG::makeHandle( m_iKeyEFexCluster, context );
      if( eFexCluster.isValid() ) {
         get1DHist( "/input/counts/emcluster")->Fill(eFexCluster->size());
         auto h0 = *get1DHist("/input/em/et");
         auto h1 = *get1DHist("/input/em/eta");
         auto h2 = *get1DHist("/input/em/phi");
         for( const auto cl : *eFexCluster ) {
            h0->Fill(cl->et());
            h1->Fill(cl->eta());
            h2->Fill(cl->phi());
         }
      } else {
         ATH_MSG_DEBUG("No collection " << m_iKeyEFexCluster);
      }
   }
 
   // eFEX Tau
   if( not m_iKeyEFexTau.empty() ) {
      auto eFexTau  = SG::makeHandle( m_iKeyEFexTau, context );
      if( eFexTau.isValid() ) {
         get1DHist( "/input/counts/taus")->Fill(eFexTau->size());
         auto h0 = *get1DHist("/input/tau/et");
         auto h1 = *get1DHist("/input/tau/eta");
         auto h2 = *get1DHist("/input/tau/phi");
         auto h3 = *get1DHist("/input/tau/emIso");
         auto h4 = *get1DHist("/input/tau/hadIso");
         auto h5 = *get1DHist("/input/tau/R3ClusterET");
         auto h6 = *get1DHist("/input/tau/R3ClusterIso");
         const static SG::AuxElement::ConstAccessor<float> accR3ClET ("R3ClusterET");
         const static SG::AuxElement::ConstAccessor<float> accR3ClIso ("R3ClusterIso");
         for( const auto tau : *eFexTau ) {
            h0->Fill(tau->eT());
            h1->Fill(tau->eta());
            h2->Fill(tau->phi());
            h3->Fill(tau->emIsol());
            h4->Fill(tau->hadIsol());
            h5->Fill(accR3ClET(*tau)/1000.);
            h6->Fill(accR3ClIso(*tau));
         }
      } else {
         ATH_MSG_DEBUG("No collection " << m_iKeyEFexTau);
      }
   }
 
   // topo
   if( not m_iKeyLegacyTopo.empty() && m_doL1CaloLegacy && m_doL1TopoLegacy ) {
      auto legacyTopoInput = SG::makeHandle( m_iKeyLegacyTopo, context );
      if(legacyTopoInput.isValid()) {
         ATH_MSG_DEBUG("Retrieved input from L1Topo from StoreGate with key " << m_iKeyTopo);
         ATH_MSG_DEBUG("L1TopoLegacy0 word 0 is: 0x" << std::hex << std::setw( 8 ) << std::setfill( '0' ) << legacyTopoInput->cableWord1(0));
         ATH_MSG_DEBUG("L1TopoLegacy0 word 1 is: 0x" << std::hex << std::setw( 8 ) << std::setfill( '0' ) << legacyTopoInput->cableWord1(1));
         ATH_MSG_DEBUG("L1TopoLegacy1 word 0 is: 0x" << std::hex << std::setw( 8 ) << std::setfill( '0' ) << legacyTopoInput->cableWord2(0));
         ATH_MSG_DEBUG("L1TopoLegacy1 word 1 is: 0x" << std::hex << std::setw( 8 ) << std::setfill( '0' ) << legacyTopoInput->cableWord2(1));
         auto h0 = *get1DHist("/input/topo/LegacyTopo0");
         auto h1 = *get1DHist("/input/topo/LegacyTopo1");
         for(unsigned int i=0; i<32; ++i) {
            uint32_t mask = 0x1; mask <<= i;
            if( (legacyTopoInput->cableWord1(0) & mask) != 0 ) h0->Fill(i); // cable 0, clock 0
            if( (legacyTopoInput->cableWord1(1) & mask) != 0 ) h0->Fill(32 + i); // cable 0, clock 1
            if( (legacyTopoInput->cableWord2(0) & mask) != 0 ) h1->Fill(i); // cable 1, clock 0
            if( (legacyTopoInput->cableWord2(1) & mask) != 0 ) h1->Fill(32 + i); // cable 1, clock 1
         }
      }
   }
 
   if( not m_iKeyTopo.empty() && m_doL1Topo ) {
      auto topoInput = SG::makeHandle( m_iKeyTopo, context );
      if(topoInput.isValid()) {
         ATH_MSG_DEBUG("Retrieved input from L1Topo from StoreGate with key " << m_iKeyTopo);
         ATH_MSG_DEBUG("L1Topo0 word 0 is: 0x" << std::hex << std::setw( 8 ) << std::setfill( '0' ) << topoInput->cableWord1(0));
         ATH_MSG_DEBUG("L1Topo0 word 1 is: 0x" << std::hex << std::setw( 8 ) << std::setfill( '0' ) << topoInput->cableWord1(1));
         ATH_MSG_DEBUG("L1Topo1 word 0 is: 0x" << std::hex << std::setw( 8 ) << std::setfill( '0' ) << topoInput->cableWord2(0));
         ATH_MSG_DEBUG("L1Topo1 word 1 is: 0x" << std::hex << std::setw( 8 ) << std::setfill( '0' ) << topoInput->cableWord2(1));
         auto h0 = *get1DHist("/input/topo/Topo2El");
         auto h1 = *get1DHist("/input/topo/Topo3El");
         for(unsigned int i=0; i<32; ++i) {
            uint32_t mask = 0x1; mask <<= i;
            if( (topoInput->cableWord1(0) & mask) != 0 ) h0->Fill(i); // cable 0, clock 0
            if( (topoInput->cableWord1(1) & mask) != 0 ) h0->Fill(32 + i); // cable 0, clock 1
            if( (topoInput->cableWord2(0) & mask) != 0 ) h1->Fill(i); // cable 1, clock 0
            if( (topoInput->cableWord2(1) & mask) != 0 ) h1->Fill(32 + i); // cable 1, clock 1
         }
         auto h2 = *get1DHist("/input/topo/Topo1Opt0");
         auto h3 = *get1DHist("/input/topo/Topo1Opt1");
         auto h4 = *get1DHist("/input/topo/Topo1Opt2");
         auto h5 = *get1DHist("/input/topo/Topo1Opt3");
         for(unsigned int i=0; i<128; i += 3) {
           std::bitset<128> mask = 0x11; mask <<= i;
           if( (topoInput->optcableWord("Topo1Opt0") & mask) != 0 ) h2->Fill(i); //
           if( (topoInput->optcableWord("Topo1Opt1") & mask) != 0 ) h3->Fill(i); //
           if( (topoInput->optcableWord("Topo1Opt2") & mask) != 0 ) h4->Fill(i); //
           if( (topoInput->optcableWord("Topo1Opt3") & mask) != 0 ) h5->Fill(i); //
         }
      } else {
         ATH_MSG_DEBUG("No collection " << m_iKeyTopo);
      }
   }
 
   // bcid
   auto bcid = context.eventID().bunch_crossing_id();
   get1DHist( "/bcid")->Fill(bcid);
 
   return StatusCode::SUCCESS;
}

filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

get1DHist()

LockedHandle< TH1 > & LVL1CTP::CTPSimulation::get1DHist ( const std::string & histName ) const

private

Definition at line 255 of file CTPSimulation.cxx.

                                                                {
   auto itr = m_hist1D.find(histName);
   if (itr == m_hist1D.end()) {
      throw GaudiException("1D-hist "+histName +" does not exist", name(), StatusCode::FAILURE);
   }
   // returning non-const LockHandle from const function is OK:
   LockedHandle<TH1>& h ATLAS_THREAD_SAFE = const_cast<LockedHandle<TH1>&>(itr->second);
   return h;
}

get2DHist()

LockedHandle< TH2 > & LVL1CTP::CTPSimulation::get2DHist ( const std::string & histName ) const

private

Definition at line 266 of file CTPSimulation.cxx.

                                                                {
   auto itr = m_hist2D.find(histName);
   if (itr == m_hist2D.end()) {
      throw GaudiException("2D-hist "+histName +" does not exist", name(), StatusCode::FAILURE);
   }
   // returning non-const LockHandle from const function is OK:
   LockedHandle<TH2>& h ATLAS_THREAD_SAFE = const_cast<LockedHandle<TH2>&>(itr->second);
   return h;
}

getBaseHistPath()

std::string LVL1CTP::CTPSimulation::getBaseHistPath ( ) const

private

Definition at line 199 of file CTPSimulation.cxx.

                                            {
   std::string baseHistPath( m_histPath );
   if(baseHistPath.back()!='/') baseHistPath += "/";
   baseHistPath += name();
   return baseHistPath;
}

hbook() [1/2]

StatusCode LVL1CTP::CTPSimulation::hbook ( const std::string & path, std::unique_ptr< TH1 > hist )

private

Definition at line 207 of file CTPSimulation.cxx.

                                                                           {
   const std::string & hname(hist->GetName());
 
   std::string key(path);
   if(key.back()!='/') key += "/";
   key+=hname;
 
   if(m_hist1D.find(key)!=m_hist1D.end()) {
      ATH_MSG_WARNING("1D-hist " << key << " already exists, won't register it");
      return StatusCode::RECOVERABLE;
   }
 
   LockedHandle<TH1> lh;
   StatusCode sc = m_histSvc->regShared( getBaseHistPath() + key, std::move(hist), lh );
   if( sc.isSuccess() ) {
      ATH_MSG_DEBUG("1D-hist " << hname << " registered with key - " << key);
      m_hist1D[key] = lh;
   } else {
      ATH_MSG_WARNING("Could not register histogram " << hname);
   }
   return sc;
}

hbook() [2/2]

StatusCode LVL1CTP::CTPSimulation::hbook ( const std::string & path, std::unique_ptr< TH2 > hist )

private

Definition at line 231 of file CTPSimulation.cxx.

                                                                           {
   const std::string & hname(hist->GetName());
 
   std::string key(path);
   if(key.back()!='/') key += "/";
   key+=hname;
 
   if(m_hist2D.find(key)!=m_hist2D.end()) {
      ATH_MSG_WARNING("2D-hist " << key << " already exists, won't register it");
      return StatusCode::RECOVERABLE;
   }
 
   LockedHandle<TH2> lh;
   StatusCode sc = m_histSvc->regShared( getBaseHistPath() + key, std::move(hist), lh );
   if( sc.isSuccess() ) {
      ATH_MSG_DEBUG("2D-hist " << hname << " registered with key - " << key);
      m_hist2D[key] = lh;
   } else {
      ATH_MSG_WARNING("Could not register histogram " << hname);
   }
   return sc;
}

initialize()

StatusCode LVL1CTP::CTPSimulation::initialize ( )

overridevirtual

Definition at line 51 of file CTPSimulation.cxx.

                                 {
 
   ATH_MSG_DEBUG("initialize");
   if(m_forceBunchGroupPattern) {
      ATH_MSG_INFO("Will use bunchgroup pattern 0x" << std::hex << m_bunchGroupPattern);
   } else {
      ATH_MSG_INFO("Will use bunchgroup definition from bunchgroup set");
   }
 
   if( m_isData ) {
      if(m_useEDMxAOD){
    CHECK( m_oKeyCTPResult.assign(LVL1CTP::DEFAULT_CTPResultOutputLocation_Rerun) );
      } else {
    CHECK( m_oKeyRDO.assign(LVL1CTP::DEFAULT_RDOOutputLocation_Rerun) );
      }
      CHECK( m_oKeySLink.assign(LVL1CTP::DEFAULT_CTPSLinkLocation_Rerun) );
   }
   ATH_CHECK( m_bgKey.initialize( !m_forceBunchGroupPattern ) );
 
   
   // data links
   ATH_CHECK( m_iKeyTopo.initialize( !m_iKeyTopo.empty() && m_doL1Topo ) );
   ATH_CHECK( m_iKeyMuctpi.initialize( ! m_iKeyMuctpi.empty() ) );
 
   // Legacy L1Calo
   ATH_CHECK( m_iKeyLegacyTopo.initialize( !m_iKeyLegacyTopo.empty() &&  m_doL1CaloLegacy && m_doL1TopoLegacy ) );
   ATH_CHECK( m_iKeyCtpinEM.initialize( m_doL1CaloLegacy ) );
   ATH_CHECK( m_iKeyCtpinJet.initialize( m_doL1CaloLegacy ) );
   ATH_CHECK( m_iKeyCtpinXE.initialize( m_doL1CaloLegacy ) );
 
   // new L1Calo
   ATH_CHECK( m_iKeyJFexJets.initialize( ! m_iKeyJFexJets.empty() ) );
   ATH_CHECK( m_iKeyJFexLJets.initialize( ! m_iKeyJFexLJets.empty() ) );
   ATH_CHECK( m_iKeyGFexJets.initialize( ! m_iKeyGFexJets.empty() ) );
   ATH_CHECK( m_iKeyGFexMETNC.initialize( ! m_iKeyGFexMETNC.empty() ) );
   ATH_CHECK( m_iKeyGFexMETRho.initialize( ! m_iKeyGFexMETRho.empty() ) );
   ATH_CHECK( m_iKeyGFexMETJwoJ.initialize( ! m_iKeyGFexMETJwoJ.empty() ) );
   ATH_CHECK( m_iKeyEFexCluster.initialize( ! m_iKeyEFexCluster.empty() ) );
   ATH_CHECK( m_iKeyEFexTau.initialize( ! m_iKeyEFexTau.empty() ) );
   ATH_CHECK( m_oKeyCTPResult.initialize( m_useEDMxAOD && !m_oKeyCTPResult.empty() ) );
   ATH_CHECK( m_oKeyRDO.initialize( !m_useEDMxAOD && !m_oKeyRDO.empty() ) );
   ATH_CHECK( m_oKeySLink.initialize( ! m_oKeySLink.empty() ) );
 
   // L1ZDC
   ATH_CHECK(  m_iKeyZDC.initialize( ! m_iKeyZDC.empty() && m_doZDC ) );
 
   // L1TRT
   ATH_CHECK(  m_iKeyTRT.initialize( ! m_iKeyTRT.empty() && m_doTRT ) );
 
   // services
   ATH_CHECK( m_histSvc.retrieve() );
 
   // tools
   ATH_CHECK( m_resultBuilder.retrieve() );
 
   ATH_MSG_DEBUG("Registering histograms under " << getBaseHistPath() << " in " << m_histSvc);
 
   return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

setHistLabels()

StatusCode LVL1CTP::CTPSimulation::setHistLabels ( const TrigConf::L1Menu & l1menu )

private

Definition at line 277 of file CTPSimulation.cxx.

                                                                {
 
   ATH_MSG_DEBUG("setHistLabels(). L1 menu " << l1menu.size() << " items" );
   // threshold multiplicities
   ATH_CHECK ( setMultiplicityHistLabels( l1menu, "muon" ) );
   ATH_CHECK ( setMultiplicityHistLabels( l1menu, "jet" ) );
   ATH_CHECK ( setMultiplicityHistLabels( l1menu, "xe" ) );
   ATH_CHECK ( setMultiplicityHistLabels( l1menu, "te" ) );
   ATH_CHECK ( setMultiplicityHistLabels( l1menu, "xs" ) );
   ATH_CHECK ( setMultiplicityHistLabels( l1menu, "em" ) );
   ATH_CHECK ( setMultiplicityHistLabels( l1menu, "tau" ) );
 
   // Topo
   std::vector<std::string> connNames = l1menu.connectorNames();
   for( const std::string connName : {"LegacyTopo0", "LegacyTopo1", "Topo1El", "Topo2El", "Topo3El", "Topo1Opt0", "Topo1Opt1", "Topo1Opt2", "Topo1Opt3"}) {
      if( find(connNames.begin(), connNames.end(), connName) == connNames.end() ) {
         continue;
      }
      auto hTopo = *get1DHist("/input/topo/" + connName);
      for(uint fpga : {0,1}) {
         for(uint clock : {0,1}) {
            for(auto & tl : l1menu.connector(connName).triggerLines(fpga,clock)) {
               uint flatIndex = tl.flatindex();
               hTopo->GetXaxis()->SetBinLabel(flatIndex+1,tl.name().c_str());
            }
         }
      }
   }
 
   std::vector<std::string> orderedItemnames;
   orderedItemnames.reserve( l1menu.size() );
   for( const auto & item : l1menu ) {
      orderedItemnames.emplace_back(item.name());
   }
   std::sort(orderedItemnames.begin(), orderedItemnames.end());
 
   // item decision
   auto tbpById = *get1DHist( "/output/tbpById" );
   auto tapById = *get1DHist( "/output/tapById" );
   auto tavById = *get1DHist( "/output/tavById" );
   auto tbpByName = *get1DHist( "/output/tbpByName" );
   auto tapByName = *get1DHist( "/output/tapByName" );
   auto tavByName = *get1DHist( "/output/tavByName" );
   unsigned int bin = 1;
   for ( const std::string & itemname : orderedItemnames ) {
      unsigned int ctpId(0);
      TrigConf::L1Item item = l1menu.item( itemname );
      ctpId = item.ctpId();
      tbpById->GetXaxis()->SetBinLabel( ctpId+1, itemname.c_str() );
      tapById->GetXaxis()->SetBinLabel( ctpId+1, itemname.c_str() );
      tavById->GetXaxis()->SetBinLabel( ctpId+1, itemname.c_str() );
      tbpByName->GetXaxis()->SetBinLabel( bin, itemname.c_str() );
      tapByName->GetXaxis()->SetBinLabel( bin, itemname.c_str() );
      tavByName->GetXaxis()->SetBinLabel( bin++, itemname.c_str() );
   }
 
   return StatusCode::SUCCESS;
}

setMultiplicityHistLabels()

StatusCode LVL1CTP::CTPSimulation::setMultiplicityHistLabels ( const TrigConf::L1Menu & l1menu, const std::string & type )

private

Definition at line 167 of file CTPSimulation.cxx.

                                                                                                    {
   StatusCode sc;
   std::map<std::string,std::vector<std::string>> typeMapping = {
      { "muon", {"MU"} },
      { "jet", {"JET", "jJ", "jLJ", "gJ", "gLJ"} },
      { "xe", {"XE", "gXE", "jXE"} },
      { "te", {"TE", "jTE", "gTE"} },
      { "xs", {"XS"} },
      { "em", {"EM", "eEM", "jEM"} },
      { "tau", {"TAU", "eTAU", "jTAU", "cTAU"} }
   };
 
 
   std::vector<TrigConf::L1Threshold> thrV;
   for( const std::string & t : typeMapping[type] ) {
     try {
       auto hist = get2DHist( "/multi/" + type + "/" + t + "Mult" );
       auto & thrV = l1menu.thresholds(t);
       while( hist->GetNbinsX() < (int)thrV.size() ) {
     hist->LabelsInflate("xaxis");
       }
       for(auto thr : thrV) {
     hist->GetXaxis()->SetBinLabel(thr->mapping()+1, thr->name().c_str() );
       }
     } catch (std::exception & ex) {
       ATH_MSG_DEBUG("Caught exception when setting new JSON MultiplicityHistLabel " << t << " : " << ex.what());
     }
   }
   return sc;
}

simulateItems()

StatusCode LVL1CTP::CTPSimulation::simulateItems ( const std::map< std::string, unsigned int > & thrMultiMap, const EventContext & context ) const

private

Definition at line 1131 of file CTPSimulation.cxx.

{
 
   std::vector<uint32_t> tip;
   CHECK( m_resultBuilder->constructTIPVector( thrMultiMap, tip ) );
 
   std::map<std::string, unsigned int> itemDecisionMap;
   CLHEP::HepRandomEngine* rndmEngine = m_RNGEngines.getEngine( context );
   CHECK( m_resultBuilder->buildItemDecision(thrMultiMap, itemDecisionMap, rndmEngine) );
 
   std::vector<uint32_t> tbp;
   std::vector<uint32_t> tap;
   std::vector<uint32_t> tav;
   unsigned char triggerType(0);
   CHECK( m_resultBuilder->constructResultVectors( itemDecisionMap, tbp, tap, tav, triggerType ) );
 
   // Create a fixed vector of 6 extra words to allow for inserting prescale change information
   // when running a partition with preloaded data, see ATR-24654
   const std::vector<uint32_t> extra(size_t{6}, uint32_t{0});
 
   auto eventID = context.eventID();
 
   // create CTP output format and store in the event
   if (m_useEDMxAOD) {
     std::pair< std::unique_ptr<xAOD::CTPResult>, std::unique_ptr<xAOD::CTPResultAuxInfo> > ctpResultAuxPair = m_resultBuilder->constructCTPResult( eventID, tbp, tap, tav, tip, extra, triggerType);
     std::unique_ptr<xAOD::CTPResult> ctpResult = std::move(ctpResultAuxPair.first);
     std::unique_ptr<xAOD::CTPResultAuxInfo> ctpResultAux = std::move(ctpResultAuxPair.second);
     auto ctpResultWriteHandle = SG::makeHandle( m_oKeyCTPResult, context );
     ATH_CHECK( ctpResultWriteHandle.record( std::move(ctpResult), std::move(ctpResultAux) ));
   }
   else   {
     std::unique_ptr<CTP_RDO> rdo = m_resultBuilder->constructRDOResult( eventID, tbp, tap, tav, tip, extra );
     auto rdoWriteHandle = SG::makeHandle( m_oKeyRDO, context );
     ATH_CHECK( rdoWriteHandle.record( std::move(rdo) ));
   }
   std::unique_ptr<CTPSLink> roi = m_resultBuilder->constructRoIResult( eventID, tbp, tap, tav, tip, extra, triggerType );
   auto sLinkWriteHandle = SG::makeHandle( m_oKeySLink, context );
   ATH_CHECK( sLinkWriteHandle.record( std::move(roi)  ));
 
   // fill histograms with item simulation results
   {
      auto tbpById = *get1DHist( "/output/tbpById" );
      auto tapById = *get1DHist( "/output/tapById" );
      auto tavById = *get1DHist( "/output/tavById" );
      for( unsigned int ctpId= 0; ctpId < 512; ++ctpId ) {
         unsigned int wordNr = ctpId / 32;
         unsigned int posWithinWord = ctpId % 32;
         auto mask = 1L << posWithinWord;
         if( 0 != (tbp[wordNr] & mask) ) {
            tbpById->Fill( ctpId );
         }
         if( 0 != (tap[wordNr] & mask) ) {
            tapById->Fill( ctpId );
         }
         if( 0 != (tav[wordNr] & mask) ) {
            tavById->Fill( ctpId );
         }
      }
   }
   return StatusCode::SUCCESS;
}

start()

StatusCode LVL1CTP::CTPSimulation::start ( )

overridevirtual

Definition at line 112 of file CTPSimulation.cxx.

                            {
 
   const TrigConf::L1Menu * l1menu = nullptr;
   ATH_CHECK( detStore()->retrieve(l1menu) );
 
   bookHists().ignore();
 
   // configure the CTP ResultBuilder
   ATH_CHECK( m_resultBuilder->setConfiguration( *l1menu ) );
   setHistLabels(*l1menu).ignore();
 
   return StatusCode::SUCCESS;
}

stop()

StatusCode LVL1CTP::CTPSimulation::stop ( )

overridevirtual

Definition at line 1196 of file CTPSimulation.cxx.

                           {
 
   const TrigConf::L1Menu * l1menu = nullptr;
   ATH_CHECK( detStore()->retrieve(l1menu) );
 
   constexpr unsigned int sizeOfCTPOutput = 512;
 
   unsigned int tbp[sizeOfCTPOutput];
   unsigned int tap[sizeOfCTPOutput];
   unsigned int tav[sizeOfCTPOutput];
   {
      auto h = *get1DHist( "/output/tbpById" );
      for( unsigned int id = 0; id < sizeOfCTPOutput; ++id ) tbp[id] = h->GetBinContent(id+1);
   }
   {
      auto h = *get1DHist( "/output/tapById" );
      for( unsigned int id = 0; id < sizeOfCTPOutput; ++id ) tap[id] = h->GetBinContent(id+1);
   }
   {
      auto h = *get1DHist( "/output/tavById" );
      for( unsigned int id = 0; id < sizeOfCTPOutput; ++id ) tav[id] = h->GetBinContent(id+1);
   }
 
   // fill the byName TAV histograms from the byID ones
   {
      auto htbp = *get1DHist( "/output/tbpByName" );
      auto htap = *get1DHist( "/output/tapByName" );
      auto htav = *get1DHist( "/output/tavByName" );
      for( auto & item : *l1menu ) {
         unsigned int ctpId = item.ctpId();
         htbp->Fill( item.name().c_str(), tbp[ctpId]);
         htap->Fill( item.name().c_str(), tap[ctpId]);
         htav->Fill( item.name().c_str(), tav[ctpId]);
      }
      htbp->Sumw2(0);
      htap->Sumw2(0);
      htav->Sumw2(0);
      htbp->LabelsDeflate();
      htap->LabelsDeflate();
      htav->LabelsDeflate();
 
   }
 
   // fill the threshold summary hists
   {
      // run 2 thresholds (legacy + muon)
      std::vector<std::string> thrHists{ "em/EM", "muon/MU", "tau/TAU", "jet/JET", "xe/XE", "te/TE", "xs/XS" };
      auto hist = * get2DHist( "/multi/all/LegacyMult" );
      for(const std::string & histpath : thrHists) {
         auto h = * get2DHist( "/multi/" + histpath + "Mult" );
         auto xaxis = h->GetXaxis();
         size_t xsize = xaxis->GetNbins();
         size_t ysize = h->GetNbinsY();
         for(size_t x = 1; x<xsize; x++) {
            std::string s("");
            for(size_t y = 1; y<=ysize; y++) {
               size_t binContent = h->GetBinContent(x,y);
               hist->Fill(xaxis->GetBinLabel(x),y-1,binContent);
               s += std::to_string(binContent) + " ";
            }
            ATH_MSG_DEBUG( "REGTEST CTPSim " << xaxis->GetBinLabel(x) << " MULT " << s);
         }
      }
      hist->Sumw2(0);
      hist->LabelsDeflate();
   }
   {
      // run 3 thresholds
      auto hist = * get2DHist( "/multi/all/R3Mult" );
      std::vector<std::string> thrHists = { "em/eEM", "em/jEM", "muon/MU", "tau/eTAU", "tau/jTAU", "tau/cTAU", "jet/jJ", "jet/jLJ", "jet/gJ", "jet/gLJ", "xe/gXE", "xe/jXE", "te/jTE", "te/gTE" };
      for(const std::string & histpath : thrHists) {
         auto h = * get2DHist( "/multi/" + histpath + "Mult" );
         auto xaxis = h->GetXaxis();
         size_t xsize = xaxis->GetNbins();
         size_t ysize = h->GetNbinsY();
         for(size_t x = 1; x<=xsize; x++) {
            std::string s("");
            for(size_t y = 1; y<=ysize; y++) {
               size_t binContent = h->GetBinContent(x,y);
               hist->Fill(xaxis->GetBinLabel(x) ,y-1, binContent);
               s += std::to_string(binContent) + " ";
            }
            ATH_MSG_DEBUG( "REGTEST CTPSim " << xaxis->GetBinLabel(x) << " MULT " << s);
         }
      }
      hist->Sumw2(0);
      hist->LabelsDeflate();
   }
 
   if ( msgLvl(MSG::DEBUG) ) {
      for( auto & item : *l1menu ) {
         ATH_MSG_DEBUG( "REGTEST CTPSim " << item.name() << " " << item.ctpId() <<
                        " TBP " << tbp[item.ctpId()] <<
                        " TAP " << tap[item.ctpId()] <<
                        " TAV " << tav[item.ctpId()]);
      }
   }
   return StatusCode::SUCCESS;
}

storeMetadata()

StatusCode LVL1CTP::CTPSimulation::storeMetadata ( )

private

Definition at line 1301 of file CTPSimulation.cxx.

                                    {
   std::vector<std::string> storedPaths;
   for( auto & entry : m_hist1D ) {
      storedPaths.push_back( getBaseHistPath() + entry.first);
   }
   for( auto & entry : m_hist2D ) {
      storedPaths.push_back( getBaseHistPath() + entry.first);
   }
   std::scoped_lock<std::mutex> metadataLock(s_metadataMutex);
   for (const auto & path : storedPaths) {
      auto pos = path.find_last_of('/');
      std::string histName = path.substr(pos+1);
      const std::string treePath = path.substr(0, pos) + "/metadata";
      //must be non-const so root can use the string buffer    
      std::string interval{"run"};
      std::string triggerData{"<none>"};
      //coverity[UNNECESSARY_STRING_COPY]
      std::string mergeData{"<default>"};
      if (!m_histSvc->existsTree(treePath)) {
         auto tree = std::make_unique<TTree>("metadata", "Monitoring Metadata");
         tree->SetDirectory(nullptr);
         tree->Branch("Name", histName.data(), "Name/C");
         tree->Branch("Interval", interval.data(), "Interval/C");
         tree->Branch("TriggerChain", triggerData.data(), "TriggerChain/C");
         tree->Branch("MergeMethod", mergeData.data(), "MergeMethod/C");
         tree->Fill();
         if (!m_histSvc->regTree(treePath, std::move(tree))) {
            MsgStream log(Athena::getMessageSvc(), "OfflineHistogramProvider");
            log << MSG::ERROR
                << "Failed to register DQ metadata TTree " << treePath << endmsg;
         }
      } else {
         TTree *tree{nullptr};
         if (m_histSvc->getTree(treePath, tree).isSuccess()) {
            tree->SetBranchAddress("Name", histName.data());
            tree->SetBranchAddress("Interval", interval.data());
            tree->SetBranchAddress("TriggerChain", triggerData.data());
            tree->SetBranchAddress("MergeMethod", mergeData.data());
            tree->Fill();
         } else {
            MsgStream log(Athena::getMessageSvc(), "OfflineHistogramProvider");
            log << MSG::ERROR
                << "Failed to retrieve DQ metadata TTree " << treePath << " which is reported to exist" << endmsg;
         }
      }
   }
   return StatusCode::SUCCESS;
}

sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

                                                      {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_bgKey

SG::ReadCondHandleKey<TrigConf::L1BunchGroupSet> LVL1CTP::CTPSimulation::m_bgKey {this, "L1BunchGroup", "L1BunchGroup", "L1BunchGroupSet key name"}

private

Definition at line 171 of file CTPSimulation.h.

{this, "L1BunchGroup", "L1BunchGroup", "L1BunchGroupSet key name"};

m_bunchGroupPattern

Gaudi::Property<unsigned int> LVL1CTP::CTPSimulation::m_bunchGroupPattern { this, "BunchGroupPattern", 0x0003, "Bunchgroup pattern applied at every event, useful for simulation. Bit x corresponds to bunchgroup x" }

private

Definition at line 162 of file CTPSimulation.h.

{ this, "BunchGroupPattern", 0x0003, "Bunchgroup pattern applied at every event, useful for simulation. Bit x corresponds to bunchgroup x" };

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_doL1CaloLegacy

Gaudi::Property<bool> LVL1CTP::CTPSimulation::m_doL1CaloLegacy { this, "DoL1CaloLegacy", false, "Use L1Calo legacy" }

private

Definition at line 164 of file CTPSimulation.h.

{ this, "DoL1CaloLegacy", false, "Use L1Calo legacy" };

m_doL1Topo

Gaudi::Property<bool> LVL1CTP::CTPSimulation::m_doL1Topo { this, "DoL1Topo", false, "Use L1Topo" }

private

Definition at line 165 of file CTPSimulation.h.

{ this, "DoL1Topo",       false, "Use L1Topo" };

m_doL1TopoLegacy

Gaudi::Property<bool> LVL1CTP::CTPSimulation::m_doL1TopoLegacy { this, "DoL1TopoLegacy", false, "Use L1Topo Legacy" }

private

Definition at line 166 of file CTPSimulation.h.

{ this, "DoL1TopoLegacy", false, "Use L1Topo Legacy" };

m_doTRT

Gaudi::Property<bool> LVL1CTP::CTPSimulation::m_doTRT {this, "DoTRT", false, "emulate CTP with TRT included"}

private

Definition at line 160 of file CTPSimulation.h.

{this, "DoTRT", false, "emulate CTP with TRT included"};

m_doZDC

Gaudi::Property<bool> LVL1CTP::CTPSimulation::m_doZDC {this, "DoZDC", false, "emulate CTP with ZDC included"}

private

Definition at line 159 of file CTPSimulation.h.

{this, "DoZDC", false, "emulate CTP with ZDC included"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_forceBunchGroupPattern

Gaudi::Property<bool> LVL1CTP::CTPSimulation::m_forceBunchGroupPattern { this, "ForceBunchGroupPattern", true, "When true, ignore the bunchgroups and use the provided BunchGroupPattern" }

private

Definition at line 161 of file CTPSimulation.h.

{ this, "ForceBunchGroupPattern", true, "When true, ignore the bunchgroups and use the provided BunchGroupPattern" };

m_hist1D

std::map<std::string, LockedHandle<TH1> > LVL1CTP::CTPSimulation::m_hist1D

private

Definition at line 119 of file CTPSimulation.h.

m_hist2D

std::map<std::string, LockedHandle<TH2> > LVL1CTP::CTPSimulation::m_hist2D

private

Definition at line 120 of file CTPSimulation.h.

m_histPath

Gaudi::Property<std::string> LVL1CTP::CTPSimulation::m_histPath { this, "HistPath", "/EXPERT/L1", "Booking path for the histogram" }

private

Definition at line 158 of file CTPSimulation.h.

{ this, "HistPath",  "/EXPERT/L1", "Booking path for the histogram" };

m_histSvc

ServiceHandle<ITHistSvc> LVL1CTP::CTPSimulation::m_histSvc { this, "THistSvc", "THistSvc/THistSvc", "Histogramming svc" }

private

Definition at line 111 of file CTPSimulation.h.

{ this, "THistSvc", "THistSvc/THistSvc", "Histogramming svc" };

m_iKeyCtpinEM

SG::ReadHandleKey<LVL1::EmTauCTP> LVL1CTP::CTPSimulation::m_iKeyCtpinEM { this, "CtpinEMInput", LVL1::TrigT1CaloDefs::EmTauCTPLocation, "Input from CTPIN em and tau (legacy)" }

private

Definition at line 130 of file CTPSimulation.h.

{  this, "CtpinEMInput",  LVL1::TrigT1CaloDefs::EmTauCTPLocation, "Input from CTPIN em and tau (legacy)" };

m_iKeyCtpinJet

SG::ReadHandleKey<LVL1::JetCTP> LVL1CTP::CTPSimulation::m_iKeyCtpinJet { this, "CtpinJetInput", LVL1::TrigT1CaloDefs::JetCTPLocation, "Input from CTPIN jet (legacy)" }

private

Definition at line 131 of file CTPSimulation.h.

{ this, "CtpinJetInput", LVL1::TrigT1CaloDefs::JetCTPLocation, "Input from CTPIN jet (legacy)" };

m_iKeyCtpinXE

SG::ReadHandleKey<LVL1::EnergyCTP> LVL1CTP::CTPSimulation::m_iKeyCtpinXE { this, "CtpinXEInput", LVL1::TrigT1CaloDefs::EnergyCTPLocation, "Input from CTPIN energy (te,xe,xs - legacy)" }

private

Definition at line 132 of file CTPSimulation.h.

{  this, "CtpinXEInput",  LVL1::TrigT1CaloDefs::EnergyCTPLocation, "Input from CTPIN energy (te,xe,xs - legacy)" };

m_iKeyEFexCluster

SG::ReadHandleKey< xAOD::TrigEMClusterContainer > LVL1CTP::CTPSimulation::m_iKeyEFexCluster { this, "eFexClusterInput", "SClusterCl", "Input list of eFEX cluster" }

private

Definition at line 143 of file CTPSimulation.h.

{  this, "eFexClusterInput", "SClusterCl", "Input list of eFEX cluster" };

m_iKeyEFexTau

SG::ReadHandleKey< xAOD::EmTauRoIContainer > LVL1CTP::CTPSimulation::m_iKeyEFexTau { this, "eFexTauInput", "SClusterTau", "Input list of eFEX tau" }

private

Definition at line 144 of file CTPSimulation.h.

{  this, "eFexTauInput", "SClusterTau", "Input list of eFEX tau" };

m_iKeyGFexJets

SG::ReadHandleKey< xAOD::JetRoIContainer > LVL1CTP::CTPSimulation::m_iKeyGFexJets { this, "gFexJetInput", "gL1Jets", "Input list of gFEX jets" }

private

Definition at line 138 of file CTPSimulation.h.

{  this, "gFexJetInput", "gL1Jets", "Input list of gFEX jets" };

m_iKeyGFexMETJwoJ

SG::ReadHandleKey< xAOD::EnergySumRoI > LVL1CTP::CTPSimulation::m_iKeyGFexMETJwoJ { this, "gFexMETJwoJInput", "gXEJWOJPerf", "Input list of gFEX MET JwoJ" }

private

Definition at line 141 of file CTPSimulation.h.

{  this, "gFexMETJwoJInput", "gXEJWOJPerf", "Input list of gFEX MET JwoJ" };

m_iKeyGFexMETNC

SG::ReadHandleKey< xAOD::EnergySumRoI > LVL1CTP::CTPSimulation::m_iKeyGFexMETNC { this, "gFexMETNCInput", "gXENOISECUTPerf", "Input list of gFEX MET NC" }

private

Definition at line 139 of file CTPSimulation.h.

{  this, "gFexMETNCInput", "gXENOISECUTPerf", "Input list of gFEX MET NC" };

m_iKeyGFexMETRho

SG::ReadHandleKey< xAOD::EnergySumRoI > LVL1CTP::CTPSimulation::m_iKeyGFexMETRho { this, "gFexMETRhoInput", "gXERHOPerf", "Input list of gFEX MET Rho" }

private

Definition at line 140 of file CTPSimulation.h.

{  this, "gFexMETRhoInput", "gXERHOPerf", "Input list of gFEX MET Rho" };

m_iKeyJFexJets

SG::ReadHandleKey< xAOD::JetRoIContainer > LVL1CTP::CTPSimulation::m_iKeyJFexJets { this, "jFexJetInput", "jRoundJets", "Input list of jFEX jets" }

private

Definition at line 135 of file CTPSimulation.h.

{  this, "jFexJetInput",  "jRoundJets", "Input list of jFEX jets" };

m_iKeyJFexLJets

SG::ReadHandleKey< xAOD::JetRoIContainer > LVL1CTP::CTPSimulation::m_iKeyJFexLJets { this, "jFexLJetInput", "jRoundLargeRJets", "Input list of jFEX large-R jets" }

private

Definition at line 136 of file CTPSimulation.h.

{  this, "jFexLJetInput",  "jRoundLargeRJets", "Input list of jFEX large-R jets" };

m_iKeyLegacyTopo

SG::ReadHandleKey<LVL1::FrontPanelCTP> LVL1CTP::CTPSimulation::m_iKeyLegacyTopo { this, "LegacyTopoInput", LVL1::DEFAULT_L1TopoLegacyCTPLocation, "Input from legacy topo" }

private

Definition at line 126 of file CTPSimulation.h.

{ this, "LegacyTopoInput", LVL1::DEFAULT_L1TopoLegacyCTPLocation, "Input from legacy topo" };

m_iKeyMuctpi

SG::ReadHandleKey<LVL1::MuCTPICTP> LVL1CTP::CTPSimulation::m_iKeyMuctpi { this, "MuctpiInput", LVL1MUCTPI::DEFAULT_MuonCTPLocation, "Input from Muctpi" }

private

Definition at line 128 of file CTPSimulation.h.

{ this, "MuctpiInput", LVL1MUCTPI::DEFAULT_MuonCTPLocation, "Input from Muctpi" };

m_iKeyTopo

SG::ReadHandleKey<LVL1::FrontPanelCTP> LVL1CTP::CTPSimulation::m_iKeyTopo { this, "TopoInput", LVL1::DEFAULT_L1TopoCTPLocation, "Input from topo" }

private

Definition at line 124 of file CTPSimulation.h.

{ this, "TopoInput", LVL1::DEFAULT_L1TopoCTPLocation, "Input from topo" };

m_iKeyTRT

SG::ReadHandleKey<LVL1::TrtCTP> LVL1CTP::CTPSimulation::m_iKeyTRT {this, "TrtInput", LVL1::DEFAULT_TrtCTPLocation, "Input from Trt"}

private

Definition at line 148 of file CTPSimulation.h.

{this, "TrtInput", LVL1::DEFAULT_TrtCTPLocation, "Input from Trt"};

m_iKeyZDC

SG::ReadHandleKey<LVL1::ZdcCTP> LVL1CTP::CTPSimulation::m_iKeyZDC {this, "ZdcInput", LVL1::TrigT1CaloDefs::ZdcCTPLocation, "Input from Zdc"}

private

Definition at line 146 of file CTPSimulation.h.

{this, "ZdcInput", LVL1::TrigT1CaloDefs::ZdcCTPLocation, "Input from Zdc"};

m_isData

Gaudi::Property<bool> LVL1CTP::CTPSimulation::m_isData { this, "IsData", false, "emulate CTP as part of MC or rerun on data" }

private

Definition at line 157 of file CTPSimulation.h.

{ this, "IsData", false, "emulate CTP as part of MC or rerun on data" };

m_muonRun2Format

Gaudi::Property<bool> LVL1CTP::CTPSimulation::m_muonRun2Format { this, "MuonMultiplicityRun2Format", false, "Interpret muon multiplicity in Run 2 format (bit 0 unused)" }

private

Definition at line 167 of file CTPSimulation.h.

{ this, "MuonMultiplicityRun2Format", false, "Interpret muon multiplicity in Run 2 format (bit 0 unused)" };

m_oKeyCTPResult

SG::WriteHandleKey<xAOD::CTPResult> LVL1CTP::CTPSimulation::m_oKeyCTPResult {this, "CTPResultOutput", LVL1CTP::DEFAULT_CTPResultOutputLocation, "Output of CTPResult (sim)"}

private

Definition at line 152 of file CTPSimulation.h.

{this, "CTPResultOutput", LVL1CTP::DEFAULT_CTPResultOutputLocation, "Output of CTPResult (sim)"};

m_oKeyRDO

SG::WriteHandleKey<CTP_RDO> LVL1CTP::CTPSimulation::m_oKeyRDO {this, "RDOOutput", LVL1CTP::DEFAULT_RDOOutputLocation, "Output of CTP RDO object (sim)"}

private

Definition at line 151 of file CTPSimulation.h.

{this, "RDOOutput", LVL1CTP::DEFAULT_RDOOutputLocation, "Output of CTP RDO object (sim)"};

m_oKeySLink

SG::WriteHandleKey<CTPSLink> LVL1CTP::CTPSimulation::m_oKeySLink {this, "ROIOutput", LVL1CTP::DEFAULT_CTPSLinkLocation, "Output of CTP SLink object (sim)"}

private

Definition at line 153 of file CTPSimulation.h.

{this, "ROIOutput", LVL1CTP::DEFAULT_CTPSLinkLocation, "Output of CTP SLink object (sim)"};

m_resultBuilder

ToolHandle<LVL1CTP::ResultBuilder> LVL1CTP::CTPSimulation::m_resultBuilder { this, "ResultBuilder", "LVL1CTP::ResultBuilder/ResultBuilder", "Builds the CTP result" }

private

Definition at line 113 of file CTPSimulation.h.

{ this, "ResultBuilder", "LVL1CTP::ResultBuilder/ResultBuilder", "Builds the CTP result" };

m_RNGEngines

ATHRNG::RNGWrapper LVL1CTP::CTPSimulation::m_RNGEngines

private

Definition at line 116 of file CTPSimulation.h.

m_useEDMxAOD

Gaudi::Property<bool> LVL1CTP::CTPSimulation::m_useEDMxAOD { this, "UseEDMxAOD", false, "Use EDM based on xAOD class" }

private

Definition at line 169 of file CTPSimulation.h.

{ this, "UseEDMxAOD", false, "Use EDM based on xAOD class" };

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

The documentation for this class was generated from the following files:

• CTPSimulation.h
• CTPSimulation.cxx