TrigDecisionChecker Class Reference

bSimple TopAlg to read & check TrigDecision data More...

#include <TrigDecisionChecker.h>

Inheritance diagram for TrigDecisionChecker:

Collaboration diagram for TrigDecisionChecker:

Public Member Functions
	TrigDecisionChecker (const std::string &name, ISvcLocator *pSvcLocator)
	std Gaudi Algorithm constructor
	~TrigDecisionChecker ()
	std deconstructor
StatusCode	initialize ()
	std Gaudi initialize method
StatusCode	execute (const EventContext &ctx)
	std Gaudi execute method -> use TrigDecisionTool to 'look' at the trigger data
StatusCode	finalize ()
	std Gaudi finalize method
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
virtual bool	isReEntrant () const override final
	Legacy algorithms are not thread-safe.
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
template<class T>
StatusCode	checkEDM (const std::string &trigItem)
StatusCode	checkTauEDM (const std::string &trigItem)
StatusCode	checkMuonEDM (const std::string &trigItem)
StatusCode	checkBphysEDM (const std::string &trigItem)
	Bphysics EDM checker.
StatusCode	checkBjetEDM (const std::string &trigItem)
StatusCode	checkElectronEDM (const std::string &trigItem)
StatusCode	checkPhotonEDM (const std::string &trigItem)
StatusCode	checkMinBiasEDM (const std::string &trigItem)
void	checkTrigSpacePointCounts (const Trig::FeatureContainer &fc)
void	checkTrigT2MBTSBits (const Trig::FeatureContainer &fc)
void	checkTrigVertexCounts (const Trig::FeatureContainer &fc)
void	checkTrigTrackCounts (const Trig::FeatureContainer &fc)
StatusCode	checkJetEDM (const std::string &trigItem)
StatusCode	checkMetEDM (const std::string &trigItem)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
Gaudi::Property< bool >	m_eventDecisionPrintout {this, "WriteEventDecision", true}
Gaudi::Property< std::string >	m_printoutFileName { this, "WriteOutFilename", "", "when set the stat is saved in this file"}
std::map< std::string, int >	m_L1Summary
std::vector< std::string >	m_summary
std::vector< int >	m_summaryPass
std::vector< int >	m_summaryPassRaw
std::vector< int >	m_summaryPassPhys
std::vector< int >	m_summaryChainPass
std::vector< int >	m_summaryChainPassRaw
std::vector< int >	m_summaryChainPassPhys
std::vector< int >	m_summaryChainPT
std::vector< int >	m_summaryChainPS
bool	m_first_event
Gaudi::Property< int >	m_monitoringBlockSize { this, "MonitoringBlock", 100}
std::vector< int >	m_countEvent
std::vector< int >	m_runCountSigs
std::vector< std::vector< int > * >	m_countSigs
Gaudi::Property< std::vector< std::string > >	m_countSigNames { this, "MonitoredChains", {} }
int	m_eventNumber = 0
float	m_muSum = 0
ToolHandle< Trig::TrigDecisionTool >	m_trigDec {this, "TrigDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool"}
	interface to use the trigger data: TriggerTool
Gaudi::Property< std::vector< std::string > >	m_muonItems { this, "MuonItems", {} }
	Muon triggers to test output for.
Gaudi::Property< std::vector< std::string > >	m_bjetItems { this, "BjetItems", {} }
Gaudi::Property< std::vector< std::string > >	m_bphysItems { this, "BphysicsItems", {} }
Gaudi::Property< std::vector< std::string > >	m_electronItems { this, "ElectronItems", {} }
	Bphysics chains to test.
Gaudi::Property< std::vector< std::string > >	m_photonItems { this, "PhotonItems", {} }
Gaudi::Property< std::vector< std::string > >	m_TauItems { this, "TauItems", {} }
Gaudi::Property< std::vector< std::string > >	m_minBiasItems { this, "MinBiasItems", {} }
Gaudi::Property< std::vector< std::string > >	m_jetItems { this, "JetItems", {} }
Gaudi::Property< std::vector< std::string > >	m_metItems { this, "MetItems", {} }
std::vector< float >	m_chainPrescales
std::vector< float >	m_chainPrescalesCalculated
std::vector< float >	m_chain_passthrough
std::vector< float >	m_chain_passthrough_calculated
std::vector< int >	m_lower_chain_accept
std::map< std::string, std::string >	m_lowerChainMap
std::string	m_eventInfoName
Gaudi::Property< bool >	m_checkBits { this, "CheckTrigPassBits", false, "TrigPassBits retrieval from TDT"}
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

bSimple TopAlg to read & check TrigDecision data

Author

Nicolas Berger Nicol.nosp@m.as.B.nosp@m.erger.nosp@m.@cer.nosp@m.n.ch - CERN

Till Eifert Till..nosp@m.Eife.nosp@m.rt@ce.nosp@m.rn.c.nosp@m.h - U. of Geneva, Switzerland

Ricardo Goncalo Jose..nosp@m.Gonc.nosp@m.alo@c.nosp@m.ern..nosp@m.ch - Royal Holloway, U. of London

Roger Moore rwmoo.nosp@m.re@u.nosp@m.alber.nosp@m.ta.c.nosp@m.a - University of Alberta, Canada

Mark Owen marko.nosp@m.wen@.nosp@m.cern..nosp@m.ch

Definition at line 43 of file TrigDecisionChecker.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

TrigDecisionChecker()

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

std Gaudi Algorithm constructor

R.Goncalo - 21/10/2007 - add tests for TrigDecisionTool: TrigDecisionChecker based on TrigDecisionMaker/TrigDecisionTest.

Definition at line 42 of file TrigDecisionChecker.cxx.

: AthAlgorithm(name, pSvcLocator),
  m_first_event(true)
{
}

~TrigDecisionChecker()

TrigDecisionChecker::~TrigDecisionChecker

(

)

std deconstructor

Definition at line 49 of file TrigDecisionChecker.cxx.

{}

Member Function Documentation

checkBjetEDM()

StatusCode TrigDecisionChecker::checkBjetEDM ( const std::string & trigItem )

private

Definition at line 611 of file TrigDecisionChecker.cxx.

                                                                     {
    
    ATH_MSG_INFO("REGTEST ==========START of bjet EDM/Navigation check for chain " << trigItem << " ===========");
    
    ATH_MSG_INFO("Chain passed = " << m_trigDec->isPassed(trigItem));
    
    // Get feature container
    Trig::FeatureContainer fc = m_trigDec->features(trigItem);
    
    // Get online combinations
    const std::vector< Trig::Combination >& bjetCombs = fc.getCombinations();
    ATH_MSG_INFO("REGTEST - RETRIEVED " << bjetCombs.size() << " COMBINATIONS FOR "  << trigItem);
    
    // Loop on combinations
    std::vector< Trig::Combination >::const_iterator bjetComb;
    for( bjetComb = bjetCombs.begin(); bjetComb != bjetCombs.end(); ++bjetComb ) {
        
        const Trig::Combination& comb = *bjetComb;
        ATH_MSG_INFO("REGTEST - ------------ NEW COMBINATION ------------");
        
        // Get online pv - histo
        const std::vector< Trig::Feature<xAOD::VertexContainer> > onlinepvs_histo = comb.get<xAOD::VertexContainer>("EFHistoPrmVtx");
        ATH_MSG_INFO("REGTEST - RETRIEVED PV (HISTO) -   size: " << onlinepvs_histo.size());
        if(onlinepvs_histo.size()) {
            const xAOD::VertexContainer* onlinepv_histo = onlinepvs_histo[0].cptr();
            ATH_MSG_INFO("REGTEST -                  -   nVert: " << onlinepv_histo->size());
            if(onlinepv_histo->size()) {
                ATH_MSG_INFO("REGTEST -                  -   z[0]: " << (*(onlinepv_histo))[0]->z());
            }
        }
        
        // Get online pv - id tracking
        const std::vector< Trig::Feature<xAOD::VertexContainer> > onlinepvs_id = comb.get<xAOD::VertexContainer>("xPrimVx");
        ATH_MSG_INFO("REGTEST - RETRIEVED PV (IDTRK) -   size: " << onlinepvs_id.size());
        if(onlinepvs_id.size()) {
            const xAOD::VertexContainer* onlinepv_id = onlinepvs_id[0].cptr();
            ATH_MSG_INFO("REGTEST -                  -   nVert: " << onlinepv_id->size());
            if(onlinepv_id->size()) {
                ATH_MSG_INFO("REGTEST -                  -   z[0]: " << (*(onlinepv_id))[0]->z());
            }
        }
        
        // Get online jet - from EFBjetSequenceAllTE
        const std::vector< Trig::Feature<xAOD::JetContainer> > onlinejets_efbjet = comb.get<xAOD::JetContainer>("TrigJetRec");
        ATH_MSG_INFO("REGTEST - RETRIEVED JETS (EFBJET)  -   size: " << onlinejets_efbjet.size());
        if(onlinejets_efbjet.size()) {
            const xAOD::JetContainer* onlinejet_efbjet = onlinejets_efbjet[0].cptr();
            ATH_MSG_INFO("REGTEST -                  -   nJet: " << onlinejet_efbjet->size());
            for(const auto* jet_efbjet : *onlinejet_efbjet) {
                // Dump
                ATH_MSG_INFO("REGTEST -                  -   eta/phi: " << jet_efbjet->eta() << " / " << jet_efbjet->phi());
            }
        }
        
        // Get online jet - from JetSplitter
        const std::vector< Trig::Feature<xAOD::JetContainer> > onlinejets_split = comb.get<xAOD::JetContainer>("SplitJet");
        ATH_MSG_INFO("REGTEST - RETRIEVED JETS (SPLIT)  -   size: " << onlinejets_split.size());
        if(onlinejets_split.size()) {
            const xAOD::JetContainer* onlinejet_split = onlinejets_split[0].cptr();
            ATH_MSG_INFO("REGTEST -                  -   nJet: " << onlinejet_split->size());
            for(const auto* jet_split : *onlinejet_split) {
                // Dump
                ATH_MSG_INFO("REGTEST -                  -   eta/phi: " << jet_split->eta() << " / " << jet_split->phi());
            }
        }
        
        // Get online jet - from SuperRoiBuilder (will this work for superROI ??)
        const std::vector< Trig::Feature<xAOD::JetContainer> > onlinejets_super = comb.get<xAOD::JetContainer>("SuperRoi");
        ATH_MSG_INFO("REGTEST - RETRIEVED JETS (SUPER)  -   size: " << onlinejets_super.size());
        if(onlinejets_super.size()) {
            const xAOD::JetContainer* onlinejet_super = onlinejets_super[0].cptr();
            ATH_MSG_INFO("REGTEST -                  -   nJet: " << onlinejet_super->size());
            for(const auto* jet_super : *onlinejet_super) {
                // Dump
                ATH_MSG_INFO("REGTEST -                  -   eta/phi: " << jet_super->eta() << " / " << jet_super->phi());
            }
        }
        
        // Get online track particles (InDetTrigTrackingxAODCnv_BjetPrmVtx_FTF)
        const std::vector< Trig::Feature<xAOD::TrackParticleContainer> > onlinetracks_prmvtx = comb.get<xAOD::TrackParticleContainer>("InDetTrigTrackingxAODCnv_BjetPrmVtx_FTF");
        ATH_MSG_INFO("REGTEST - RETRIEVED TRACKS (BJETPRMVTX_FTF) -   size: " << onlinetracks_prmvtx.size());
        if(onlinetracks_prmvtx.size()) {
            const xAOD::TrackParticleContainer* onlinetrack_prmvtx = onlinetracks_prmvtx[0].cptr();
            ATH_MSG_INFO("REGTEST -                  -   nTrack: " << onlinetrack_prmvtx->size());
            for(const auto* trk : *onlinetrack_prmvtx) {
                // Dump
                uint8_t nInn=0, nNext=0, nPix=0, nSCT=0;
                trk->summaryValue(nInn,  xAOD::numberOfInnermostPixelLayerHits);
                trk->summaryValue(nNext, xAOD::numberOfNextToInnermostPixelLayerHits);
                trk->summaryValue(nPix,  xAOD::numberOfPixelHits);
                trk->summaryValue(nSCT,  xAOD::numberOfSCTHits);
                ATH_MSG_INFO("REGTEST -                  -   inn/next/pix/sct: " << (int)nInn << " / " << (int)nNext << " / " << (int)nPix << " / " << (int)nSCT);
            }
        }
        
        // Get online track particles (InDetTrigTrackingxAODCnv_Bjet_FTF)
        const std::vector< Trig::Feature<xAOD::TrackParticleContainer> > onlinetracks_bjetftf = comb.get<xAOD::TrackParticleContainer>("InDetTrigTrackingxAODCnv_Bjet_FTF");
        ATH_MSG_INFO("REGTEST - RETRIEVED TRACKS (BJET_FTF) -   size: " << onlinetracks_bjetftf.size());
        if(onlinetracks_bjetftf.size()) {
            const xAOD::TrackParticleContainer* onlinetrack_bjetftf = onlinetracks_bjetftf[0].cptr();
            ATH_MSG_INFO("REGTEST -                  -   nTrack: " << onlinetrack_bjetftf->size());
            for(const auto* trk : *onlinetrack_bjetftf) {
                // Dump
                uint8_t nInn=0, nNext=0, nPix=0, nSCT=0;
                trk->summaryValue(nInn,  xAOD::numberOfInnermostPixelLayerHits);
                trk->summaryValue(nNext, xAOD::numberOfNextToInnermostPixelLayerHits);
                trk->summaryValue(nPix,  xAOD::numberOfPixelHits);
                trk->summaryValue(nSCT,  xAOD::numberOfSCTHits);
                ATH_MSG_INFO("REGTEST -                  -   inn/next/pix/sct: " << (int)nInn << " / " << (int)nNext << " / " << (int)nPix << " / " << (int)nSCT);
            }
        }
        
        // Get online track particles (InDetTrigTrackingxAODCnv_Bjet_IDTrig)
        const std::vector< Trig::Feature<xAOD::TrackParticleContainer> > onlinetracks_bjetprec = comb.get<xAOD::TrackParticleContainer>("InDetTrigTrackingxAODCnv_Bjet_IDTrig");
        ATH_MSG_INFO("REGTEST - RETRIEVED TRACKS (BJET_IDTRIG) -   size: " << onlinetracks_bjetprec.size());
        if(onlinetracks_bjetprec.size()) {
            const xAOD::TrackParticleContainer* onlinetrack_bjetprec = onlinetracks_bjetprec[0].cptr();
            ATH_MSG_INFO("REGTEST -                  -   nTrack: " << onlinetrack_bjetprec->size());
            for(const auto* trk : *onlinetrack_bjetprec) {
                // Dump
                uint8_t nInn=0, nNext=0, nPix=0, nSCT=0;
                trk->summaryValue(nInn,  xAOD::numberOfInnermostPixelLayerHits);
                trk->summaryValue(nNext, xAOD::numberOfNextToInnermostPixelLayerHits);
                trk->summaryValue(nPix,  xAOD::numberOfPixelHits);
                trk->summaryValue(nSCT,  xAOD::numberOfSCTHits);
                ATH_MSG_INFO("REGTEST -                  -   inn/next/pix/sct: " << (int)nInn << " / " << (int)nNext << " / " << (int)nPix << " / " << (int)nSCT);
            }
        }
        
        // Get online bjet
        const std::vector< Trig::Feature<xAOD::BTaggingContainer> > onlinebjets = comb.get<xAOD::BTaggingContainer>();
        ATH_MSG_INFO("REGTEST - RETRIEVED BJETS  -   size: " << onlinebjets.size());
        if(onlinebjets.size()) {
            const xAOD::BTaggingContainer* onlinebjet = onlinebjets[0].cptr();
            ATH_MSG_INFO("REGTEST -                  -   nBjet: " << onlinebjet->size());
            for(const auto* bjet : *onlinebjet) {
                // Dump
                double wIP2D, wIP3D, wSV1, wCOMB, wMV1;
                bjet->loglikelihoodratio("IP2D", wIP2D);
                bjet->loglikelihoodratio("IP3D", wIP3D);
                bjet->loglikelihoodratio("SV1", wSV1);
                wCOMB = wIP3D+wSV1;
                wMV1 = bjet->MV1_discriminant();
                ATH_MSG_INFO("REGTEST -                  -   IP2D/IP3D/SV1/IP3D+SV1/MV1: " << wIP2D << " / " << wIP3D << " / " << wSV1 << " / " << wCOMB << " / " << wMV1);
            }
        }
        
    }
    
    msg(MSG::INFO) << "REGTEST ==========END of bjet EDM/Navigation check for chain " << trigItem << " ===========" << endmsg;
    
    return StatusCode::SUCCESS;
}//checkBjetEDM

checkBphysEDM()

StatusCode TrigDecisionChecker::checkBphysEDM ( const std::string & trigItem )

private

Bphysics EDM checker.

Definition at line 854 of file TrigDecisionChecker.cxx.

                                                                      {
    
    msg(MSG::INFO) << "REGTEST ==========START of Bphysics EDM/Navigation check for chain " << trigItem << " ===========" << endmsg;
    
    ATH_MSG_INFO("Chain passed = " << m_trigDec->isPassed(trigItem));
    
    Trig::FeatureContainer fc = m_trigDec->features(trigItem);
    
    const std::vector< Trig::Feature<xAOD::TrigBphysContainer> > fc_bphys = fc.get<xAOD::TrigBphysContainer>();
    ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::TrigBphysContainer> > = " << fc_bphys.size());
    
    for( const auto& cont_bphys : fc_bphys ) {
        ATH_MSG_INFO("REGTEST Got Bphysics container, size = " << cont_bphys.cptr()->size());
        for ( auto bphys:  *(cont_bphys.cptr()) )  {
            ATH_MSG_INFO("REGTEST  Bphysics Item mass, fitmass, secVx, nTP: "
                         << bphys->mass()*0.001 << " , " << bphys->fitmass() * 0.001 << " , "
                         << bphys->secondaryDecay() << " , " << bphys->nTrackParticles()
                         );
        } // for
        
    }// loop over bphys features
    
    //    const std::vector< Trig::Feature<CombinedMuonFeature> > vec_cbmufeats = fc.get<CombinedMuonFeature>();
    //    ATH_MSG_INFO("Size of vector< Trig::Feature<CombinedMuonFeature> > = " << vec_cbmufeats.size());
    //
    //    for( auto cbmufeat : vec_cbmufeats) {
    //        ATH_MSG_INFO("REGTEST CombinedMuonFeature with pt, eta, phi = " << cbmufeat.cptr()->pt() << ", " << cbmufeat.cptr()->eta() << ", " << cbmufeat.cptr()->phi());
    //    }
    //    
    ATH_MSG_INFO("REGTEST ==========END of Bphysics EDM/Navigation check for chain " << trigItem << " ===========");
    
    return StatusCode::SUCCESS;
}//checkBphysEDM

checkEDM()

template<class T>

StatusCode TrigDecisionChecker::checkEDM ( const std::string & trigItem )

private

Definition at line 545 of file TrigDecisionChecker.cxx.

                                                                 {
    ATH_MSG_INFO("REGTEST Check TrigPassBits for " << trigItem << " and type " << ClassID_traits< T >::typeName() );
    m_trigDec->isPassed(trigItem) ? ATH_MSG_INFO("REGTEST " << trigItem << " Passes ") : ATH_MSG_INFO("REGTEST " << trigItem << " Fails");
    const auto fc = m_trigDec->features(trigItem,TrigDefs::alsoDeactivateTEs);
    const auto vec = fc.get<T>();
    const auto vecbits = fc.get<xAOD::TrigPassBits>();
    std::string label="";
    for(const auto& feat:vecbits){
        const auto *xbits=feat.cptr();
        TrigConf::HLTTriggerElement::getLabel(feat.te()->getId(), label );
        const auto *cont=(m_trigDec->ancestor<T>(feat.te())).cptr();
        if(cont){
            ATH_MSG_INFO("REGTEST TrigPassBits for TE " << label  
                    <<  " size " << cont->size());
 
            if(cont->size()!=xbits->size()) {
                ATH_MSG_WARNING("REGTEST Container and bit size not equal, continue");
                continue;
            }
            int npassed=0;
            for(const auto &ptr:*cont){
                if(xbits->isPassing(ptr,cont))
                    npassed++;
            }
            ATH_MSG_INFO("REGTEST TrigPassBits for container type " << ClassID_traits< T >::typeName() 
                         <<  " size " << cont->size() << " xbits " << xbits->size() << " selected " << npassed);
        }
    }
 
 
 
    for(const auto& feat:vec){
        const auto *cont=feat.cptr();
        const TrigPassBits *bits=(m_trigDec->ancestor<TrigPassBits>(feat.te())).cptr();
        const xAOD::TrigPassBits *xbits=(m_trigDec->ancestor<xAOD::TrigPassBits>(feat.te())).cptr();
        TrigConf::HLTTriggerElement::getLabel(feat.te()->getId(), label );
        if(!cont){
            ATH_MSG_WARNING(label << "  " << ClassID_traits< T >::typeName() << "REGTEST: TrigPassBits container is null ");
            continue;
        }
        if(!bits){
            ATH_MSG_WARNING(label << " " << ClassID_traits< T >::typeName() << " REGTEST: TrigPassBits old bits null ");
        }
        if(!xbits){
            ATH_MSG_WARNING(label << " " << ClassID_traits< T >::typeName() << " REGTEST: TrigPassBits xbits null ");
            continue;
        }
        //
        const size_t bitlen = ( (cont->size() - 1)/32 ) + 1;
        if(bits) 
            ATH_MSG_INFO("REGTEST Retrieved container type " << ClassID_traits< T >::typeName() <<  " size " << cont->size() 
                    << " bits " << bits->size() << " Expect vector of bits " << bitlen);
        int npassed=0;
        if(xbits){
            for(const auto &ptr:*cont){
                if(xbits->isPassing(ptr,cont))
                    npassed++;
            }
            ATH_MSG_INFO("REGTEST TrigPassBits for container type " << ClassID_traits< T >::typeName() 
                    <<  " size " << cont->size() << " xbits " << xbits->size() << " selected " << npassed);
        }
    }
    
    return StatusCode::SUCCESS;
}

checkElectronEDM()

StatusCode TrigDecisionChecker::checkElectronEDM ( const std::string & trigItem )

private

Definition at line 893 of file TrigDecisionChecker.cxx.

                                                                         {
    msg(MSG::INFO) << "REGTEST ==========START of Electron EDM/Navigation check for chain " << trigItem << " ===========" << endmsg;
    
    ATH_MSG_INFO("Chain passed = " << m_trigDec->isPassed(trigItem));
    
    Trig::FeatureContainer fc = m_trigDec->features(trigItem);
    const std::vector< Trig::Feature<xAOD::ElectronContainer> > vec_el = fc.get<xAOD::ElectronContainer>();
    ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::ElectronContainer> > = " << vec_el.size());
    float val_float=-99.;
    for(const auto& elfeat : vec_el){
        ATH_MSG_INFO("REGTEST: Got electron container, size = " << elfeat.cptr()->size());
        const xAOD::ElectronContainer *elCont = elfeat.cptr();
        
        for(const auto eg : *elCont){
            if (eg) {
                ATH_MSG_INFO(" REGTEST: egamma energy: " << eg->e() );
                ATH_MSG_INFO(" REGTEST: egamma eta: " << eg->eta() );
                ATH_MSG_INFO(" REGTEST: egamma phi: " << eg->phi() );
            } else{
                ATH_MSG_INFO(" REGTEST: problems with egamma pointer" );
                return StatusCode::SUCCESS;
            }
            ATH_MSG_INFO(" REGTEST: caloCluster variables ");
            if (eg->caloCluster()) {
                ATH_MSG_INFO(" REGTEST: egamma cluster transverse energy: " << eg->caloCluster()->et() );
                ATH_MSG_INFO(" REGTEST: egamma cluster eta: " << eg->caloCluster()->eta() );
                ATH_MSG_INFO(" REGTEST: egamma cluster phi: " << eg->caloCluster()->phi() );
                double tmpeta = -999.;
                double tmpphi = -999.;
                eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::ETACALOFRAME,tmpeta);
                eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::PHICALOFRAME,tmpphi); 
                ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. etaCalo = " << tmpeta); 
                ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. phiCalo = " << tmpphi);
            } else{
                ATH_MSG_INFO(" REGTEST: problems with egamma cluster pointer" );
            }
            ATH_MSG_INFO(" REGTEST: trackmatch variables ");
            if(eg->trackParticle()){
                ATH_MSG_INFO(" REGTEST: pt=  " << eg->trackParticle()->pt());
                ATH_MSG_INFO(" REGTEST: charge=  " << eg->trackParticle()->charge());
                ATH_MSG_INFO(" REGTEST: E/p=  " << eg->caloCluster()->et() / eg->trackParticle()->pt() );
                eg->trackCaloMatchValue(val_float,xAOD::EgammaParameters::deltaEta1);
                ATH_MSG_INFO(" REGTEST: Delta eta 1st sampling=  " << val_float);
                eg->trackCaloMatchValue(val_float,xAOD::EgammaParameters::deltaPhi2);
                ATH_MSG_INFO(" REGTEST: Delta phi 2nd sampling=  " << val_float);
            } else{
                ATH_MSG_INFO(" REGTEST: no electron eg->trackParticle() pointer");
            }
        }
    }
    
    msg(MSG::INFO) << "REGTEST ==========END of Electron EDM/Navigation check ===========" << endmsg;
    return StatusCode::SUCCESS;
}

checkJetEDM()

StatusCode TrigDecisionChecker::checkJetEDM ( const std::string & trigItem )

private

Definition at line 1108 of file TrigDecisionChecker.cxx.

                                                                    {
    ATH_MSG_DEBUG("in checkJetEDM()");
    
    ATH_MSG_INFO("REGTEST =====For chain " << trigItem << "=====");
    
    ATH_MSG_INFO("Chain passed = " << m_trigDec->isPassed(trigItem));
    
    Trig::FeatureContainer fc = m_trigDec->features(trigItem);
    const std::vector< Trig::Feature<xAOD::JetContainer> > vec_jet = fc.get<xAOD::JetContainer>();
    ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::JetContainer> > = " << vec_jet.size());
    for(const auto& jetfeat : vec_jet){
        const xAOD::JetContainer * jetCont = jetfeat.cptr();
        
        int jetContsize = jetCont->size();
        ATH_MSG_INFO("REGTEST Got jet container, size: " << jetContsize);
        
        int i = 0;
        for(const auto thisjet : *jetCont){
            ++i;
            ATH_MSG_INFO("REGTEST Looking at jet " << i);
            if (thisjet) {
                //checks jet variables
                ATH_MSG_DEBUG("REGTEST    Checking jet variables");
                ATH_MSG_INFO("REGTEST    pt: " << thisjet->pt() );
                ATH_MSG_INFO("REGTEST    eta: " << thisjet->eta() );
                ATH_MSG_INFO("REGTEST    phi: " << thisjet->phi() );
                ATH_MSG_INFO("REGTEST    m: " << thisjet->m() );
                ATH_MSG_INFO("REGTEST    e: " << thisjet->e() );
                ATH_MSG_INFO("REGTEST    px: " << thisjet->px() );
                ATH_MSG_INFO("REGTEST    py: " << thisjet->py() );
                ATH_MSG_INFO("REGTEST    pz: " << thisjet->pz() );
                ATH_MSG_INFO("REGTEST    type: " << thisjet->type() );
                ATH_MSG_INFO("REGTEST    algorithm (kt: 0, cam: 1, antikt: 2, ...): " << thisjet->getAlgorithmType() );
                ATH_MSG_INFO("REGTEST    size parameter: " << thisjet->getSizeParameter() );
                ATH_MSG_INFO("REGTEST    input (LCTopo: 0, EMTopo: 1, ...): " << thisjet->getInputType() );
                ATH_MSG_INFO("REGTEST    constituents signal state (uncalibrated: 0, calibrated: 1): " << thisjet->getConstituentsSignalState() );
                ATH_MSG_INFO("REGTEST    number of constituents: " << thisjet->numConstituents() );
            }
            else{
                ATH_MSG_ERROR("REGTEST Problem with jet pointer" );
                return StatusCode::FAILURE;
            }
        }
        if (jetContsize == i) ATH_MSG_INFO("REGTEST size of jet container == number of displayed jets: " << (jetContsize == i) );
        else ATH_MSG_WARNING("REGTEST Problem with displaying jets");
    }
    
    ATH_MSG_DEBUG("leaving checkJetEDM()");
    
    return StatusCode::SUCCESS;
}

checkMetEDM()

StatusCode TrigDecisionChecker::checkMetEDM ( const std::string & trigItem )

private

Definition at line 1160 of file TrigDecisionChecker.cxx.

                                                                    {
    ATH_MSG_DEBUG("in checkMetEDM()");
 
    ATH_MSG_INFO("REGTEST =====For chain " << trigItem << "=====");
 
    ATH_MSG_INFO("Chain passed = " << m_trigDec->isPassed(trigItem));
 
    Trig::FeatureContainer fc = m_trigDec->features(trigItem);
    const std::vector< Trig::Feature<xAOD::TrigMissingETContainer> > vec_met = fc.get<xAOD::TrigMissingETContainer>();
    ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::TrigMissingETContainer> > = " << vec_met.size());
    for(const auto& metfeat : vec_met){
        const xAOD::TrigMissingETContainer * metCont = metfeat.cptr();
 
        ATH_MSG_INFO("REGTEST Fot trigMet container, size: " << metCont->size());
 
        const xAOD::TrigMissingET * metObj = metCont->front(); // the first object in the container typically holds the total MET, other objects hold components
 
        if (metObj){
            ATH_MSG_DEBUG("REGTEST    Checking met variables");
            ATH_MSG_INFO("REGTEST    ex: " << metObj->ex() );
            ATH_MSG_INFO("REGTEST    ey: " << metObj->ey() );
            ATH_MSG_INFO("REGTEST    sumEt: " << metObj->sumEt() );
            ATH_MSG_INFO("REGTEST    ez: " << metObj->ez() );
            ATH_MSG_INFO("REGTEST    sumE: " << metObj->sumE() );
            ATH_MSG_INFO("REGTEST    number of components: " << metObj->getNumberOfComponents() );
        }
        else{
            ATH_MSG_ERROR("REGTEST Problem with met pointer" );
            return StatusCode::FAILURE;
        }
    }
    
    ATH_MSG_DEBUG("leaving checkMetEDM()");
 
    return StatusCode::SUCCESS;
}

checkMinBiasEDM()

StatusCode TrigDecisionChecker::checkMinBiasEDM ( const std::string & trigItem )

private

Definition at line 991 of file TrigDecisionChecker.cxx.

                                                                        {
    msg(MSG::INFO) << "REGTEST ==========START of MinBias EDM/Navigation check for chain " << trigItem << " ===========" << endmsg;
    
    ATH_MSG_INFO("Chain passed = " << m_trigDec->isPassed(trigItem));
    
    Trig::FeatureContainer fc = m_trigDec->features(trigItem);
    
    checkTrigSpacePointCounts(fc);
    checkTrigT2MBTSBits(fc);
    checkTrigVertexCounts(fc);  
    checkTrigTrackCounts(fc);
    
    msg(MSG::INFO) << "REGTEST ==========END of MinBias EDM/Navigation check ===========" << endmsg;
    return StatusCode::SUCCESS;
}

checkMuonEDM()

StatusCode TrigDecisionChecker::checkMuonEDM ( const std::string & trigItem )

private

Definition at line 765 of file TrigDecisionChecker.cxx.

                                                                     {
    
    msg(MSG::INFO) << "REGTEST ==========START of muon EDM/Navigation check for chain " << trigItem << " ===========" << endmsg;
    
    ATH_MSG_INFO("Chain passed = " << m_trigDec->isPassed(trigItem));
    
    Trig::FeatureContainer fc = m_trigDec->features(trigItem);
    
    const std::vector< Trig::Feature<xAOD::MuonContainer> > vec_muons = fc.get<xAOD::MuonContainer>();
    ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::MuonContainer> > = " << vec_muons.size());
    
    for( const auto& mufeat : vec_muons ) {
        ATH_MSG_INFO("REGTEST Got muon container, size = " << mufeat.cptr()->size());
        for(auto muItr : *(mufeat.cptr())) {      
            ATH_MSG_INFO("REGTEST MuonFeature with pt, eta, phi = " << muItr->pt() << ", " << muItr->eta() << ", " << muItr->phi());
        }
    }// loop over muon features
    
    const std::vector< Trig::Feature<xAOD::L2CombinedMuonContainer> > vec_L2CBmuons = fc.get<xAOD::L2CombinedMuonContainer>();
    ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::L2CombinedMuonContainer> > = " << vec_L2CBmuons.size());
    
    for( const auto& l2cbmufeat : vec_L2CBmuons) {
        ATH_MSG_INFO("REGTEST Got muon container, size = " << l2cbmufeat.cptr()->size());
        for(auto l2cbmuItr : *(l2cbmufeat.cptr())) {      
            ATH_MSG_INFO("REGTEST MuonFeature with pt, eta, phi = " << l2cbmuItr->pt() << ", " << l2cbmuItr->eta() << ", " << l2cbmuItr->phi());
        }
    }// loop over muon L2 CB features
    
    const std::vector< Trig::Feature<xAOD::L2StandAloneMuonContainer> > vec_L2SAmuons = fc.get<xAOD::L2StandAloneMuonContainer>();
    ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::L2StandAloneMuonContainer> > = " << vec_L2SAmuons.size());
    
    for( const auto& l2samufeat : vec_L2SAmuons) {
        ATH_MSG_INFO("REGTEST Got muon container, size = " << l2samufeat.cptr()->size());
        for(auto l2samuItr : *(l2samufeat.cptr())) {      
            ATH_MSG_INFO("REGTEST MuonFeature with pt, eta, phi = " << l2samuItr->pt() << ", " << l2samuItr->eta() << ", " << l2samuItr->phi());
        }
    }// loop over muon L2 SA features
    
    msg(MSG::INFO) << "REGTEST ==========END of muon EDM/Navigation check for chain " << trigItem << " ===========" << endmsg;
    
    return StatusCode::SUCCESS;
}//checkMuonEDM

checkPhotonEDM()

StatusCode TrigDecisionChecker::checkPhotonEDM ( const std::string & trigItem )

private

Definition at line 948 of file TrigDecisionChecker.cxx.

                                                                       {
    msg(MSG::INFO) << "REGTEST ==========START of Photon EDM/Navigation check for chain " << trigItem << " ===========" << endmsg;
    
    ATH_MSG_INFO("Chain passed = " << m_trigDec->isPassed(trigItem));
    
    Trig::FeatureContainer fc = m_trigDec->features(trigItem);
    const std::vector< Trig::Feature<xAOD::PhotonContainer> > vec_ph = fc.get<xAOD::PhotonContainer>();
    ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::PhotonContainer> > = " << vec_ph.size());
    //float val_float=-99.;
    for(const auto& phfeat : vec_ph){
        ATH_MSG_INFO("REGTEST: Got photon container, size = " << phfeat.cptr()->size());
        const xAOD::PhotonContainer *phCont = phfeat.cptr();
        
        for(const auto eg : *phCont){
            if (eg) {
                ATH_MSG_INFO(" REGTEST: egamma energy: " << eg->e() );
                ATH_MSG_INFO(" REGTEST: egamma eta: " << eg->eta() );
                ATH_MSG_INFO(" REGTEST: egamma phi: " << eg->phi() );
            } else{
                ATH_MSG_INFO(" REGTEST: problems with egamma pointer" );
                return StatusCode::SUCCESS;
            }
            ATH_MSG_INFO(" REGTEST: caloCluster variables ");
            if (eg->caloCluster()) {
                ATH_MSG_INFO(" REGTEST: egamma cluster transverse energy: " << eg->caloCluster()->et() );
                ATH_MSG_INFO(" REGTEST: egamma cluster eta: " << eg->caloCluster()->eta() );
                ATH_MSG_INFO(" REGTEST: egamma cluster phi: " << eg->caloCluster()->phi() );
                double tmpeta = -999.;
                double tmpphi = -999.;
                eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::ETACALOFRAME,tmpeta);
                eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::PHICALOFRAME,tmpphi); 
                ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. etaCalo = " << tmpeta); 
                ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. phiCalo = " << tmpphi);
            } else{
                ATH_MSG_INFO(" REGTEST: problems with egamma cluster pointer" );
            }
        }
    }
    
    msg(MSG::INFO) << "REGTEST ==========END of Photon EDM/Navigation check ===========" << endmsg;
    return StatusCode::SUCCESS;
}

checkTauEDM()

StatusCode TrigDecisionChecker::checkTauEDM ( const std::string & trigItem )

private

Definition at line 808 of file TrigDecisionChecker.cxx.

                                                                    {
    msg(MSG::INFO)<< "REGTEST ==========START of tau EDM/Navigation check for chain " << trigItem<< "===========" << endmsg;
    Trig::FeatureContainer fc = m_trigDec->features(trigItem);
    const std::vector< Trig::Feature<xAOD::TauJetContainer> > vec_tauHLTClust = fc.get<xAOD::TauJetContainer>();
    ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::TauJetContainer> > = " << vec_tauHLTClust.size());
    for(const auto& cont_tau : vec_tauHLTClust) {
        ATH_MSG_INFO("REGTEST Got Tau container, size = " << cont_tau.cptr()->size());
        
        for(auto tauItr : *(cont_tau.cptr())) {
            
            msg(MSG::INFO) << "REGTEST "<<" HLT tau number of tracks: "<<tauItr->nTracks()<<endmsg;
            msg(MSG::INFO)  << "REGTEST "<<" HLT tau pt : "<<tauItr->pt()<<endmsg;
            msg(MSG::INFO)  << "REGTEST "<<" HLT tau phi : "<<tauItr->phi()<<endmsg;
            msg(MSG::INFO)  << "REGTEST "<<" HLT tau eta : "<<tauItr->eta()<<endmsg;
            if( !tauItr->jetLink().isValid() ) {
                ATH_MSG_WARNING("tau does not have jet seed");
                return StatusCode::SUCCESS;
            }
            
            const xAOD::Jet* pJetSeed = *(tauItr->jetLink());   
            xAOD::JetConstituentVector::const_iterator clusItr  = pJetSeed->getConstituents().begin();
            xAOD::JetConstituentVector::const_iterator clusItrE = pJetSeed->getConstituents().end();   
            for (int clusCount = 0; clusItr != clusItrE; ++clusItr, ++clusCount) {     
                ATH_MSG_INFO( "REGTEST Tau Cluster " << clusCount << " pt = " << (*clusItr)->pt()<< " eta = " << (*clusItr)->eta()<< " phi = " << (*clusItr)->phi() );     
            }  
            for (unsigned int trackNum = 0;  trackNum < tauItr->nTracks(); ++trackNum) {
                
            const xAOD::TrackParticle *linkTrack = tauItr->track(trackNum)->track();
                if (!linkTrack) {
                    ATH_MSG_WARNING("can't get tau linked track");
                    return StatusCode::SUCCESS;
                } else {
                    ATH_MSG_DEBUG("Got the tau linked track");
                }     
                ATH_MSG_INFO( "REGTEST Tau linked track " << trackNum << " pt = " << linkTrack->pt()<< " eta = " << linkTrack->eta() << " phi = " << linkTrack->phi() );
            }
            
        }
    }
    
    msg(MSG::INFO) << "REGTEST ==========END of Tau EDM/Navigation check ===========" << endmsg;
    return StatusCode::SUCCESS;        
}

checkTrigSpacePointCounts()

void TrigDecisionChecker::checkTrigSpacePointCounts ( const Trig::FeatureContainer & fc )

private

Definition at line 1007 of file TrigDecisionChecker.cxx.

                                                                                 {
    
    const std::vector< Trig::Feature<xAOD::TrigSpacePointCounts> > vec_sp = fc.get<xAOD::TrigSpacePointCounts>();
    ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::TrigSpacePointCounts> > = " << vec_sp.size());
    
    float sum;
    auto fun = [&sum](const std::vector<float>& vec){sum = 0.; for (const auto &i: vec) sum += i; return sum;};
    
    for(const auto& spfeat : vec_sp){
        const xAOD::TrigSpacePointCounts *spCounts = spfeat.cptr();
        if (spCounts){
            ATH_MSG_INFO(" REGTEST: SUM of contentsPixelClusEndcapC: " << fun(spCounts->contentsPixelClusEndcapC()) );
            ATH_MSG_INFO(" REGTEST: SUM of contentsPixelClusBarrel: " << fun(spCounts->contentsPixelClusBarrel()) );
            ATH_MSG_INFO(" REGTEST: SUM of contentsPixelClusEndcapA: " << fun(spCounts->contentsPixelClusEndcapA()) );
            
            ATH_MSG_INFO(" REGTEST: pixelClusTotBins: " << spCounts->pixelClusTotBins() );
            ATH_MSG_INFO(" REGTEST: pixelClusTotMin: " << spCounts->pixelClusTotMin() );
            ATH_MSG_INFO(" REGTEST: pixelClusTotMax: " << spCounts->pixelClusTotMax() );
            ATH_MSG_INFO(" REGTEST: pixelClusSizeBins: " << spCounts->pixelClusSizeBins() );
            ATH_MSG_INFO(" REGTEST: pixelClusSizeMin: " << spCounts->pixelClusSizeMin() );
            ATH_MSG_INFO(" REGTEST: pixelClusSizeMax: " << spCounts->pixelClusSizeMax() );
            ATH_MSG_INFO(" REGTEST: sctSpEndcapC: " << spCounts->sctSpEndcapC() );
            ATH_MSG_INFO(" REGTEST: sctSpBarrel: " << spCounts->sctSpBarrel() );      
            ATH_MSG_INFO(" REGTEST: sctSpEndcapA: " << spCounts->sctSpEndcapA() );
        } else{
            ATH_MSG_INFO(" REGTEST: problems with TrigSpacePointCounts pointer" );
            return;
        }
    }
}

checkTrigT2MBTSBits()

void TrigDecisionChecker::checkTrigT2MBTSBits ( const Trig::FeatureContainer & fc )

private

Definition at line 1038 of file TrigDecisionChecker.cxx.

                                                                           {
    
    const std::vector< Trig::Feature<xAOD::TrigT2MbtsBits> > vec_mbts = fc.get<xAOD::TrigT2MbtsBits>();
    ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::TrigT2MbtsBits> > = " << vec_mbts.size());
    
    float sum;
    auto fun = [&sum](const std::vector<float>& vec){sum = 0.; for (const auto &i: vec) sum += i; return sum;};
    
    for(const auto& mbtsfeat : vec_mbts){
        const xAOD::TrigT2MbtsBits *mbtsBits = mbtsfeat.cptr();
        if (mbtsBits){
            ATH_MSG_INFO(" REGTEST: SUM of triggerEnergies: " << fun(mbtsBits->triggerEnergies()) );
            ATH_MSG_INFO(" REGTEST: SUM of triggerTimes: " << fun(mbtsBits->triggerTimes()) );
        } else{
            ATH_MSG_INFO(" REGTEST: problems with TrigT2MBTSBits pointer" );
            return;
        }
    }
}

checkTrigTrackCounts()

void TrigDecisionChecker::checkTrigTrackCounts ( const Trig::FeatureContainer & fc )

private

Definition at line 1078 of file TrigDecisionChecker.cxx.

                                                                            {
    
    const std::vector< Trig::Feature<xAOD::TrigTrackCounts> > vec_t = fc.get<xAOD::TrigTrackCounts>();
    ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::TrigTrackCounts> > = " << vec_t.size());
    
    float sum;
    auto fun = [&sum](const std::vector<float>& vec){sum = 0.; for (const auto &i: vec) sum += i; return sum;};
    
    for(const auto& tfeat : vec_t){
        const xAOD::TrigTrackCounts *tCounts = tfeat.cptr();
        if (tCounts){
            ATH_MSG_INFO(" REGTEST: SUM of z0_pt: " << fun(tCounts->z0_pt()) );
            ATH_MSG_INFO(" REGTEST: SUM of eta_phi: " << fun(tCounts->eta_phi()) );
            
            ATH_MSG_INFO(" REGTEST: z0Bins: " << tCounts->z0Bins() );
            ATH_MSG_INFO(" REGTEST: z0Min: " << tCounts->z0Min() );
            ATH_MSG_INFO(" REGTEST: z0Max: " << tCounts->z0Max() );
            ATH_MSG_INFO(" REGTEST: ptBins: " << tCounts->ptBins() );
            ATH_MSG_INFO(" REGTEST: ptMin: " << tCounts->ptMin() );
            ATH_MSG_INFO(" REGTEST: ptMax: " << tCounts->ptMax() );
            ATH_MSG_INFO(" REGTEST: etaBins: " << tCounts->etaBins() );
            ATH_MSG_INFO(" REGTEST: etaMin: " << tCounts->etaMin() );
            ATH_MSG_INFO(" REGTEST: etaMax: " << tCounts->etaMax() );
        } else{
            ATH_MSG_INFO(" REGTEST: problems with TrigTrackCounts pointer" );
            return;
        }
    }
}

checkTrigVertexCounts()

void TrigDecisionChecker::checkTrigVertexCounts ( const Trig::FeatureContainer & fc )

private

Definition at line 1058 of file TrigDecisionChecker.cxx.

                                                                             {
    
    const std::vector< Trig::Feature<xAOD::TrigVertexCounts> > vec_v = fc.get<xAOD::TrigVertexCounts>();
    ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::TrigVertexCounts> > = " << vec_v.size());
    
    auto funu = [](const std::vector<uint>& vec){uint sum = 0; for (const auto &i: vec) sum += i; return sum;};
    auto funf = [](const std::vector<float>& vec){float sum = 0.; for (const auto &i: vec) sum += i; return sum;};
    
    for(const auto& vfeat : vec_v){
        const xAOD::TrigVertexCounts *vCounts = vfeat.cptr();
        if (vCounts){
            ATH_MSG_INFO(" REGTEST: SUM of vtxNtrks: " << funu(vCounts->vtxNtrks()) );
            ATH_MSG_INFO(" REGTEST: SUM of vtxTrkPtSqSum: " << funf(vCounts->vtxTrkPtSqSum()) );
        } else{
            ATH_MSG_INFO(" REGTEST: problems with TrigVertexCounts pointer" );
            return;
        }
    }
}

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 TrigDecisionChecker::execute ( const EventContext & ctx )

virtual

std Gaudi execute method -> use TrigDecisionTool to 'look' at the trigger data

Implements AthAlgorithm.

Definition at line 215 of file TrigDecisionChecker.cxx.

{
    m_eventNumber++;
    
    // check mu value
    const xAOD::EventInfo* eventInfo = nullptr;
    //#sc = evtStore()->retrieve(eventInfo, m_eventInfoName);
    StatusCode sc;
    if (m_eventInfoName == "") {
        sc=evtStore()->retrieve(eventInfo);
    } else {
        sc=evtStore()->retrieve(eventInfo, m_eventInfoName);
    }
    if ( sc.isFailure() || !eventInfo )
    {
      ATH_MSG_INFO("Container '" << m_eventInfoName << "' could not be retrieved from StoreGate !");
      sc = StatusCode::SUCCESS;
      return sc;
    } else {
      ATH_MSG_DEBUG("Container '" << m_eventInfoName << "' retrieved from StoreGate");
    }
    
    if ( eventInfo ) {
        float mu = eventInfo->actualInteractionsPerCrossing();
        float muave =  eventInfo->averageInteractionsPerCrossing(); 
        msg(MSG::INFO) << "run number  " << eventInfo->runNumber() << " event number " << eventInfo->eventNumber() << 
        " lumi block " << eventInfo->lumiBlock() << endmsg;
        msg(MSG::INFO) << "mu value " << mu << " average mu value " << muave <<  " event number " << m_eventNumber <<  endmsg;
        m_muSum = m_muSum + eventInfo->actualInteractionsPerCrossing();
    }
    
    
    for(const auto& tauItem : m_TauItems) {
        ATH_MSG_INFO("Check tau items " << tauItem);
        sc = checkTauEDM(tauItem);
        if ( sc.isFailure() ) {
            msg(MSG::ERROR) << "Could not finish checkTauEDM test for chain " <<tauItem << endmsg;
            return sc;
        }
        if(m_checkBits) {
            if(checkEDM<xAOD::TauJetContainer>(tauItem).isFailure()) 
                ATH_MSG_ERROR("Could not finish checkTauJetEDM test for chain " << tauItem);
        }
    }
    
    for(const auto& muonItem : m_muonItems) {
        sc = checkMuonEDM(muonItem);
        if ( sc.isFailure() ) {
            msg(MSG::ERROR) << "Could not finish checkMuonEDM test for chain " << muonItem << endmsg;
            return sc;
        }
        if(m_checkBits) {
            if(checkEDM<xAOD::MuonContainer>(muonItem).isFailure()) 
                ATH_MSG_ERROR("Could not finish checkMuonEDM test for chain " << muonItem);
            if(checkEDM<xAOD::L2CombinedMuonContainer>(muonItem).isFailure())
                ATH_MSG_ERROR("Could not finish checkMuonEDM test for chain " << muonItem);
            if(checkEDM<xAOD::L2StandAloneMuonContainer>(muonItem).isFailure())
                ATH_MSG_ERROR("Could not finish checkMuonEDM test for chain " << muonItem);
        }
    }
    
    for(const auto& bjetItem : m_bjetItems) {
        sc = checkBjetEDM(bjetItem);
        if ( sc.isFailure() ) {
            msg(MSG::ERROR) << "Could not finish checkBjetEDM test for chain " << bjetItem << endmsg;
            return sc;
        }
        if(m_checkBits) {
            if(checkEDM<xAOD::BTaggingContainer>(bjetItem).isFailure()) 
                ATH_MSG_ERROR("Could not finish checkBjetEDM test for chain " << bjetItem);
        }
    }
    
    for(const auto& bphysItem : m_bphysItems) {
        sc = checkBphysEDM(bphysItem);
        if ( sc.isFailure() ) {
            msg(MSG::ERROR) << "Could not finish checkBphysEDM test for chain " << bphysItem << endmsg;
            // return sc; try not to return for other tests to run
        }
        if(m_checkBits) {
            if(checkEDM<xAOD::TrigBphysContainer>(bphysItem).isFailure()) 
                ATH_MSG_ERROR("Could not finish checkJetEDM test for chain " << bphysItem);
        }
    }
    
    for(const auto& electronItem : m_electronItems) {
        ATH_MSG_INFO("Check Electron items " << electronItem);
        sc = checkElectronEDM(electronItem);
        if ( sc.isFailure() ) {
            msg(MSG::ERROR) << "Could not finish checkElectronEDM test for chain " << electronItem << endmsg;
        }
        if(m_checkBits) {
            if(checkEDM<xAOD::ElectronContainer>(electronItem).isFailure()) 
                ATH_MSG_ERROR("Could not finish checkElectronEDM test for chain " << electronItem);
            if(checkEDM<xAOD::CaloClusterContainer>(electronItem).isFailure()) 
                ATH_MSG_ERROR("Could not finish checkElectronEDM test for chain " << electronItem);
            if(checkEDM<xAOD::TrigElectronContainer>(electronItem).isFailure()) 
                ATH_MSG_ERROR("Could not finish checkElectronEDM test for chain " << electronItem);
        }
    }
    
    for(const auto& photonItem : m_photonItems) {
        sc = checkPhotonEDM(photonItem);
        if ( sc.isFailure() ) {
          ATH_MSG_ERROR("Could not finish checkPhotonEDM test for chain " << photonItem);
        }
        if(m_checkBits) {
            if(checkEDM<xAOD::PhotonContainer>(photonItem).isFailure()) 
              ATH_MSG_ERROR("Could not finish checkPhotonEDM test for chain " << photonItem);
            if(checkEDM<xAOD::CaloClusterContainer>(photonItem).isFailure()) 
              ATH_MSG_ERROR("Could not finish checkPhotonEDM test for chain " << photonItem);
        }
    }
    
    for(const auto& minBiasItem : m_minBiasItems) {
        sc = checkMinBiasEDM(minBiasItem);
        if ( sc.isFailure() ) {
            msg(MSG::ERROR) << "Could not finish checkMinBiasEDM test for chain " << minBiasItem << endmsg;
            return sc;
        }
    }
    
    ATH_MSG_INFO("REGTEST ==========START of Jet EDM/Navigation check===========");
    for(const auto& jetItem : m_jetItems) {
        sc = checkJetEDM(jetItem);
        if ( sc.isFailure() ) {
            ATH_MSG_INFO("REGTEST Could not finish checkJetEDM test for chain " << jetItem);
            return sc;
        }
        if(m_checkBits) {
            if(checkEDM<xAOD::JetContainer>(jetItem).isFailure()) 
                ATH_MSG_ERROR("Could not finish checkJetEDM test for chain " << jetItem);
        }
    }
    ATH_MSG_INFO("REGTEST ==========END of Jet EDM/Navigation check===========");
    
    ATH_MSG_INFO("REGTEST ==========START of Met EDM/Navigation check===========");
    for(const auto& metItem : m_metItems) {
        sc = checkMetEDM(metItem);
        if ( sc.isFailure() ) {
            ATH_MSG_INFO("REGTEST Could not finish checkMetEDM test for chain " << metItem);
            return sc;
        }
    }
    ATH_MSG_INFO("REGTEST =========END of Met EDM/Navigation check============");
    
    if (m_eventDecisionPrintout) {
        msg(MSG::INFO) << "TrigDecisionChecker::execute" << endmsg;
        
        msg(MSG::INFO) << "Pass state     = " << m_trigDec->isPassed("EF_.*") << endmsg;
        msg(MSG::INFO) << "Pass state L1  = " << m_trigDec->isPassed("L1_.*") << endmsg;
        msg(MSG::INFO) << "Pass state L2  = " << m_trigDec->isPassed("L2_.*") << endmsg;
        msg(MSG::INFO) << "Pass state EF  = " << m_trigDec->isPassed("EF_.*") << endmsg;
        msg(MSG::INFO) << "Pass state HLT = " << m_trigDec->isPassed("HLT_.*") << endmsg;
    }
 
    // L1
    std::vector<std::string> allItems = m_trigDec->getListOfTriggers("L1_.*");
    if (!allItems.empty()) {
        if (m_eventDecisionPrintout) msg(MSG::INFO) << "Items : " << allItems.size() << endmsg;
        
        for (std::vector<std::string>::const_iterator itemIt = allItems.begin();
             itemIt != allItems.end(); ++itemIt) {
            
            const LVL1CTP::Lvl1Item* aItem = m_trigDec->ExperimentalAndExpertMethods().getItemDetails(*itemIt);
            
            if (!aItem) continue;
            if (aItem->name()=="") continue;
            
            if (m_eventDecisionPrintout) msg(MSG::INFO) << "Item " << aItem->name() << " : Item ID " << aItem->hashId() << " : " << aItem->isPassed() << endmsg;
            
            // fill bookkeeping map with zeros if first event
            std::string item_name = aItem->name();
            if (m_first_event) m_L1Summary[item_name] = 0;
            
            // increment counter for L1 summary
            if (aItem->isPassed()) m_L1Summary[item_name] = (m_L1Summary[item_name]+1);
            int count = (m_L1Summary.find(item_name))->second;
            if (m_eventDecisionPrintout) msg(MSG::INFO) << "L1_map[" << item_name << "] = " << count << endmsg;
            
            
        }
    } else {
      ATH_MSG_WARNING("Could not retrieve L1 Items !!");
    }
    
    
    // HLT Chains
    
    // Get all configured chain names from config
    std::vector<std::string> confChains = m_trigDec->getListOfTriggers("L2_.*, EF_.*, HLT_.*");
    msg(MSG::INFO) << "Configuring for " << confChains.size() << " HLT chain counters" << endmsg;
    
    // resize & initialise counters in first event
    if (m_first_event) {
        m_summary.resize(0); // vector for chain names
        m_summaryPassRaw.resize(confChains.size(),0);
        m_summaryPass.resize(confChains.size(),0);
        m_summaryPassPhys.resize(confChains.size(),0);
        m_summaryChainPassRaw.resize(confChains.size(),0);
        m_summaryChainPass.resize(confChains.size(),0);
        m_summaryChainPassPhys.resize(confChains.size(),0);
        m_summaryChainPT.resize(confChains.size(),0);
        m_summaryChainPS.resize(confChains.size(),0);
        m_chainPrescales.resize(confChains.size(),0);
        m_chainPrescalesCalculated.resize(confChains.size(),0);
        m_chain_passthrough.resize(confChains.size(),0);
        m_chain_passthrough_calculated.resize(confChains.size(),0);
        m_lower_chain_accept.resize(confChains.size(),0);
        
        // make vector of names and sort alphabetically
        std::map<std::string,float> t_pt_map;
        std::map<std::string,float> t_ps_map;
        
        for(std::vector<std::string>::iterator chIter = confChains.begin(); chIter != confChains.end(); ++chIter) {
            const TrigConf::HLTChain * ch = m_trigDec->ExperimentalAndExpertMethods().getChainConfigurationDetails(*chIter);
            std::string name = *chIter;
            m_summary.push_back(name);
            t_pt_map[name] = ch->pass_through();
            t_ps_map[name] = ch->prescale();
            m_lowerChainMap[name] = ch->lower_chain_name();
            ATH_MSG_DEBUG("Configured chain: " << name
                          << "; prescale=" << ch->prescale()
                          << "; passthrough=" << ch->pass_through()
                          << "; lower chain=" << ch->lower_chain_name());
        }
        // sort by chain names to group together L2 and EF chains: do this for
        // first event only and use ordering in m_summary for later processing
        std::sort(m_summary.begin(),m_summary.end());
        
        // store prescaled factor from *configuration* chain
        for (unsigned int k=0; k<m_summary.size(); ++k) {
            // prescales
            std::map<std::string,float>::iterator psIt=t_ps_map.find(m_summary[k]);
            float ps = -1;
            if (psIt!=t_ps_map.end()) ps = (*psIt).second;
            m_chainPrescales[k]=ps;
            // passthrough
            std::map<std::string,float>::iterator ptIt=t_pt_map.find(m_summary[k]);
            float pt = -1;
            if (ptIt!=t_pt_map.end()) pt = (*ptIt).second;
            m_chain_passthrough[k]=pt;
        }
    }
    
    // all events: loop over names of configured chains, find their status,
    //   increment counters
    for (unsigned int i=0; i<m_summary.size(); ++i){
        std::string name = m_summary[i];
        ATH_MSG_VERBOSE("Testing chain: " << name);
        
        const HLT::Chain* aChain = m_trigDec->ExperimentalAndExpertMethods().getChainDetails(name);
        if (! aChain) { // inactive chain
            continue;
        }
        
        // use TrigDecisionTool methods directly
        if ( m_trigDec->isPassed(name, TrigDefs::allowResurrectedDecision | TrigDefs::requireDecision) ) {
            ATH_MSG_VERBOSE("chain: " << name << " Passed RAW");
            ++m_summaryPassRaw[i];
        }
        if ( m_trigDec->isPassed(name) ) {
            ATH_MSG_VERBOSE("chain: " << name << " Passed");
            ++m_summaryPass[i];
        }
        if ( m_trigDec->isPassed(name) ) {
            ATH_MSG_VERBOSE("chain: " << name << " Passed PHYSICS");
            ++m_summaryPassPhys[i];
        }
        
        
        // Reproduce the definitions of raw, with PS, with PT, as used in monitoring:
        // http://alxr.usatlas.bnl.gov/lxr/source/atlas/Trigger/TrigMonitoring/TrigSteerMonitor/src/TrigChainMoni.cxx#380
        // chainPassed == (chainPassedRaw() && !aChain->isPrescaled()) || isPassedThrough
        if (aChain->chainPassedRaw()){
            ++m_summaryChainPassRaw[i];
        }
        if (aChain->chainPassedRaw() && !aChain->isPrescaled()){
            ++m_summaryChainPS[i];
        }
        if (aChain->chainPassed()){
            ++m_summaryChainPT[i];
        }
        if (!(aChain->isPrescaled())){ // get prescale fraction by counting events
            ++m_chainPrescalesCalculated[i];
        }
        if (aChain->isPassedThrough()){ // get passthrough fraction by counting events
            ++m_chain_passthrough_calculated[i];
        }
        // events accepted by the lower chain
        std::map<std::string,std::string>::iterator lcIt=m_lowerChainMap.find(m_summary[i]);
        if (lcIt!=m_lowerChainMap.end()) {
            if ( !m_trigDec->getListOfTriggers((*lcIt).second).empty() &&m_trigDec->isPassed((*lcIt).second) ) {
                ++m_lower_chain_accept[i];
            }
        }
        // print info for each event
        if (m_eventDecisionPrintout){
            msg(MSG::INFO) << "chain " << name << " = "
            << m_summaryChainPassRaw[i] << endmsg;
        }
    }
    
    // TrigDecisionTool tests on a few specific sigs:
    for (unsigned int i=0; i < m_countSigNames.size(); ++i) {
        ATH_MSG_DEBUG("Monitoring " << m_countSigNames[i]);
        if ( !m_trigDec->getListOfTriggers(m_countSigNames[i]).empty() ) {
            if ( m_trigDec->isPassed(m_countSigNames[i]) )
                m_runCountSigs[i] = m_runCountSigs[i]+1;
        } else {
            msg(MSG::WARNING) << m_countSigNames[i] << " not configured!" << endmsg;
        }
    }
    
    if (m_eventNumber%m_monitoringBlockSize == 0) {
        m_countEvent.push_back(m_eventNumber);
        
        for (unsigned int i=0; i < m_countSigNames.size(); ++i) {
            (m_countSigs[i])->push_back(m_runCountSigs[i]);
            m_runCountSigs[i]=0;
        }
    }
    
    // reset first event flag
    if (m_first_event) m_first_event = false;
    
    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();
}

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();
  }

finalize()

StatusCode TrigDecisionChecker::finalize

(

)

std Gaudi finalize method

m_lower_chain_accept[i]

m_lower_chain_accept[i]

Definition at line 104 of file TrigDecisionChecker.cxx.

{
    
    // print summary of trigger decisions for each level
    msg(MSG::INFO) << "==========================================================" << endmsg;
    msg(MSG::INFO) << "TrigDecisionTool summary:" << endmsg;
    msg(MSG::INFO) << "==========================================================" << endmsg;
    
    // LVL1
    std::map<std::string,int>::iterator itL1,itL1End=m_L1Summary.end();
    for ( itL1=m_L1Summary.begin(); itL1!=itL1End; ++itL1 ) {
        msg(MSG::INFO) << "REGTEST item " << (*itL1).first << " accepted events=" << (*itL1).second << endmsg;
    }
    
    // HLT
    for ( unsigned int i=0; i<m_summary.size(); ++i) {
        msg(MSG::INFO) << "REGTEST chain " << m_summary[i] << " accepted events= " << m_summaryPassPhys[i]
        <<" ( PS: " << m_summaryChainPS[i] << " , PT: " << m_summaryChainPT[i] << ")" << endmsg;
    }
    
    // print out nr. of events passed in blocks of N events for specific chains (configurable)
    ATH_MSG_INFO(" ");
    ATH_MSG_INFO("TrigDecisionTool tests: monitored chain efficiency");
    ATH_MSG_INFO("==================================================");
    msg(MSG::INFO) << "REGTEST  Nr.events: ";
    for (unsigned int k=0; k<m_countEvent.size();++k) {
        msg() << m_countEvent[k] << " ";
    }
    msg() << endmsg;
    for (unsigned int i=0; i<m_countSigNames.size();++i) {
        msg(MSG::INFO) << "REGTEST " << m_countSigNames[i] << " : ";
        for (unsigned int j=0; j<(m_countSigs[i])->size();++j) {
            msg() << (*m_countSigs[i])[j] << " ";
        }
        msg() << endmsg;
    }
    
    // compare prescale and passthrough fractions from configuration and by counting events
    ATH_MSG_INFO(" ");
    ATH_MSG_INFO("TrigDecisionTool tests: chain prescale/passthrough ");
    ATH_MSG_INFO("==================================================");
    // HLT
    msg(MSG::INFO) << "REGTEST Chain (passed raw) PS(conf) PS(counts) PT(conf) PT(counts) (Lower chain)";
    for ( unsigned int i=0; i<m_summary.size(); ++i) {
        if (m_lower_chain_accept[i]!=0) {
            msg(MSG::INFO) << "REGTEST " << m_summary[i] << " (" << m_summaryChainPT[i] << ") \t"
            << " \t" << m_chainPrescales[i] << " \t" << m_chainPrescalesCalculated[i] 
            << " \t" << m_chain_passthrough[i] << " \t" << m_chain_passthrough_calculated[i] 
            << " (" << m_lower_chain_accept[i] << ")" << endmsg;
        } else {
            msg(MSG::INFO) << "REGTEST " << m_summary[i] << " (" << m_summaryChainPT[i] << ") \t"
            << " \t" << m_chainPrescales[i] << "   ---   "
            << " \t" << m_chain_passthrough[i] << "   ---   "
            << " (lower chain passed no events)" << endmsg;
        }
    }
    ATH_MSG_INFO("REGTEST ran on " << m_eventNumber << " events");
    ATH_MSG_INFO("Average mu value " << m_muSum/float(m_eventNumber));
    
    // open output file and write out counts
    if (not m_printoutFileName.empty()) {
        ATH_MSG_INFO("==================================================");
        ATH_MSG_INFO("Opening " << m_printoutFileName << " for writing trigger counts");
        std::ofstream printoutFile(m_printoutFileName);
        
        /*
         m_L1Summary - isPassed for L[1
         m_summaryChainPassRaw  - chainPassedRaw for HLT     
         m_summaryPass     - chain Passed for HLT     
         m_summaryPassPhys - chain Physics Passed for HLT     
         m_summaryChainPS - chainPassedRaw && !isPrescaled for HLT     
         m_summaryChainPT - (chainPassedRaw && !isPrescaled) || isPassedThrough for HLT     
         */
        
        printoutFile  << std::setiosflags(std::ios::left) << std::setw(25) << "* L1 item"
        << std::setw(15) << " #Passed " << std::endl;
        std::map<std::string,int>::iterator l1,l1End=m_L1Summary.end();
        for ( l1=m_L1Summary.begin(); l1!=l1End; ++l1 ) {
            printoutFile << std::setiosflags(std::ios::left) << (*l1).first 
            << std::setw(10) << (*l1).second << std::endl;
        }
        
        printoutFile  << std::setiosflags(std::ios::left) << std::setw(25) << "* Chain name"
        << std::setw(15) << " #Passed Raw "
        << std::setw(15) << " #passed  "
        << std::setw(15) << " #Physics Passed "<< std::endl;
        for ( unsigned int i=0; i<m_summary.size(); ++i) {
            printoutFile << std::setiosflags(std::ios::left) << std::setw(25) << m_summary[i] 
            << std::setw(15) << m_summaryPassRaw[i] 
            << std::setw(15) << m_summaryPass[i] 
            << std::setw(15) << m_summaryPassPhys[i] << std::endl;
            
            //    std::cout << std::setiosflags(std::ios::dec) << std::setw(6) << i << "|"
            //        << std::setiosflags(std::ios::dec) << std::setw(4) << (*(m_elink_vec[i]))->algorithmId() << "|"
            //        << std::setw(11) << *(m_elink_vec[i]) << "|";
        }
        ATH_MSG_INFO("Closing output file " << m_printoutFileName);
        printoutFile.close();
    }
    
    // cleanup newed vectors
    ATH_MSG_INFO("==================================================");
    ATH_MSG_INFO("Cleaning up counters...");
    for (unsigned int i=0; i<m_countSigs.size(); ++i) {
        delete m_countSigs[i];
    }
    ATH_MSG_INFO("Finalised successfully");
    
    return StatusCode::SUCCESS;
}

initialize()

StatusCode TrigDecisionChecker::initialize

(

)

std Gaudi initialize method

Definition at line 52 of file TrigDecisionChecker.cxx.

{
    // reset event counters
    m_first_event=true;
    m_eventNumber=0;
    m_muSum=0.0;
    
    // Reset keys
    
    // print out properties
    ATH_MSG_INFO("Initializing...");
    ATH_MSG_INFO("MonitoredChains:    " << m_countSigNames);
    //ATH_MSG_INFO("MonitoredTauItem:   " << m_tauItem);
    ATH_MSG_INFO("MonitoringBlock:    " << m_monitoringBlockSize);
    if (not m_printoutFileName.empty()) {
      ATH_MSG_INFO("PrintOutFilename:   " << m_printoutFileName);
    }
 
    // get handle to TrigDecisionTool
    ATH_CHECK(m_trigDec.retrieve());
 
    // reserve space for vectors
    m_summary.reserve(700);
    m_summaryChainPassRaw.reserve(700);
    m_summaryChainPassRaw.reserve(700);
    m_summaryChainPT.reserve(700);
    m_summaryChainPS.reserve(700);
    m_summaryPassRaw.reserve(700);
    m_summaryPass.reserve(700);
    m_summaryPassPhys.reserve(700);
    m_chainPrescales.reserve(700);
    m_chainPrescalesCalculated.reserve(700);
    m_chain_passthrough.reserve(700);
    m_chain_passthrough_calculated.reserve(700);
    m_lower_chain_accept.reserve(700);
    
    // initialize vectors for chains to monitor
    ATH_MSG_INFO("Monitoring number of events passing these chains (blocks of "
                 << m_monitoringBlockSize << " events):");
    for (unsigned int i=0; i < m_countSigNames.size(); ++i) {
        ATH_MSG_INFO("Initializing monitoring counters for " << m_countSigNames[i]);
        m_countSigs.push_back(new std::vector<int>());
        m_runCountSigs.push_back(0);
    }
    
    
    ATH_MSG_INFO("Initialization successful");    
    
    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;
  }

isReEntrant()

virtual bool AthAlgorithm::isReEntrant ( ) const

inlinefinaloverrideprotectedvirtualinherited

Legacy algorithms are not thread-safe.

Definition at line 47 of file AthAlgorithm.h.

{ return false; }

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 );
  }

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_bjetItems

Gaudi::Property<std::vector<std::string> > TrigDecisionChecker::m_bjetItems { this, "BjetItems", {} }

private

Definition at line 114 of file TrigDecisionChecker.h.

{ this, "BjetItems", {} };

m_bphysItems

Gaudi::Property<std::vector<std::string> > TrigDecisionChecker::m_bphysItems { this, "BphysicsItems", {} }

private

Definition at line 116 of file TrigDecisionChecker.h.

{ this, "BphysicsItems", {} }; 

m_chain_passthrough

std::vector<float> TrigDecisionChecker::m_chain_passthrough

private

Definition at line 139 of file TrigDecisionChecker.h.

m_chain_passthrough_calculated

std::vector<float> TrigDecisionChecker::m_chain_passthrough_calculated

private

Definition at line 140 of file TrigDecisionChecker.h.

m_chainPrescales

std::vector<float> TrigDecisionChecker::m_chainPrescales

private

Definition at line 137 of file TrigDecisionChecker.h.

m_chainPrescalesCalculated

std::vector<float> TrigDecisionChecker::m_chainPrescalesCalculated

private

Definition at line 138 of file TrigDecisionChecker.h.

m_checkBits

Gaudi::Property<bool> TrigDecisionChecker::m_checkBits { this, "CheckTrigPassBits", false, "TrigPassBits retrieval from TDT"}

private

Definition at line 148 of file TrigDecisionChecker.h.

{ this, "CheckTrigPassBits", false, "TrigPassBits retrieval from TDT"};

m_countEvent

std::vector<int> TrigDecisionChecker::m_countEvent

private

Definition at line 101 of file TrigDecisionChecker.h.

m_countSigNames

Gaudi::Property<std::vector<std::string> > TrigDecisionChecker::m_countSigNames { this, "MonitoredChains", {} }

private

Definition at line 104 of file TrigDecisionChecker.h.

{ this, "MonitoredChains", {} };

m_countSigs

std::vector<std::vector<int>* > TrigDecisionChecker::m_countSigs

private

Definition at line 103 of file TrigDecisionChecker.h.

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_electronItems

Gaudi::Property<std::vector<std::string> > TrigDecisionChecker::m_electronItems { this, "ElectronItems", {} }

private

Bphysics chains to test.

Definition at line 119 of file TrigDecisionChecker.h.

{ this, "ElectronItems", {} };

m_eventDecisionPrintout

Gaudi::Property<bool> TrigDecisionChecker::m_eventDecisionPrintout {this, "WriteEventDecision", true}

private

Definition at line 80 of file TrigDecisionChecker.h.

{this, "WriteEventDecision", true};

m_eventInfoName

std::string TrigDecisionChecker::m_eventInfoName

private

Definition at line 145 of file TrigDecisionChecker.h.

m_eventNumber

int TrigDecisionChecker::m_eventNumber = 0

private

Definition at line 105 of file TrigDecisionChecker.h.

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_first_event

bool TrigDecisionChecker::m_first_event

private

Definition at line 96 of file TrigDecisionChecker.h.

m_jetItems

Gaudi::Property<std::vector<std::string> > TrigDecisionChecker::m_jetItems { this, "JetItems", {} }

private

Definition at line 131 of file TrigDecisionChecker.h.

{ this, "JetItems", {} };

m_L1Summary

std::map<std::string,int> TrigDecisionChecker::m_L1Summary

private

Definition at line 86 of file TrigDecisionChecker.h.

m_lower_chain_accept

std::vector<int> TrigDecisionChecker::m_lower_chain_accept

private

Definition at line 141 of file TrigDecisionChecker.h.

m_lowerChainMap

std::map<std::string,std::string> TrigDecisionChecker::m_lowerChainMap

private

Definition at line 142 of file TrigDecisionChecker.h.

m_metItems

Gaudi::Property<std::vector<std::string> > TrigDecisionChecker::m_metItems { this, "MetItems", {} }

private

Definition at line 134 of file TrigDecisionChecker.h.

{ this, "MetItems", {} };

m_minBiasItems

Gaudi::Property<std::vector<std::string> > TrigDecisionChecker::m_minBiasItems { this, "MinBiasItems", {} }

private

Definition at line 128 of file TrigDecisionChecker.h.

{ this, "MinBiasItems", {} };

m_monitoringBlockSize

Gaudi::Property<int> TrigDecisionChecker::m_monitoringBlockSize { this, "MonitoringBlock", 100}

private

Definition at line 99 of file TrigDecisionChecker.h.

{ this, "MonitoringBlock",  100};

m_muonItems

Gaudi::Property<std::vector<std::string> > TrigDecisionChecker::m_muonItems { this, "MuonItems", {} }

private

Muon triggers to test output for.

Definition at line 111 of file TrigDecisionChecker.h.

{ this, "MuonItems", {} };

m_muSum

float TrigDecisionChecker::m_muSum = 0

private

Definition at line 106 of file TrigDecisionChecker.h.

m_photonItems

Gaudi::Property<std::vector<std::string> > TrigDecisionChecker::m_photonItems { this, "PhotonItems", {} }

private

Definition at line 122 of file TrigDecisionChecker.h.

{ this, "PhotonItems", {} };

m_printoutFileName

Gaudi::Property<std::string> TrigDecisionChecker::m_printoutFileName { this, "WriteOutFilename", "", "when set the stat is saved in this file"}

private

Definition at line 83 of file TrigDecisionChecker.h.

{ this, "WriteOutFilename", "", "when set the stat is saved in this file"};

m_runCountSigs

std::vector<int> TrigDecisionChecker::m_runCountSigs

private

Definition at line 102 of file TrigDecisionChecker.h.

m_summary

std::vector<std::string> TrigDecisionChecker::m_summary

private

Definition at line 87 of file TrigDecisionChecker.h.

m_summaryChainPass

std::vector<int> TrigDecisionChecker::m_summaryChainPass

private

Definition at line 91 of file TrigDecisionChecker.h.

m_summaryChainPassPhys

std::vector<int> TrigDecisionChecker::m_summaryChainPassPhys

private

Definition at line 93 of file TrigDecisionChecker.h.

m_summaryChainPassRaw

std::vector<int> TrigDecisionChecker::m_summaryChainPassRaw

private

Definition at line 92 of file TrigDecisionChecker.h.

m_summaryChainPS

std::vector<int> TrigDecisionChecker::m_summaryChainPS

private

Definition at line 95 of file TrigDecisionChecker.h.

m_summaryChainPT

std::vector<int> TrigDecisionChecker::m_summaryChainPT

private

Definition at line 94 of file TrigDecisionChecker.h.

m_summaryPass

std::vector<int> TrigDecisionChecker::m_summaryPass

private

Definition at line 88 of file TrigDecisionChecker.h.

m_summaryPassPhys

std::vector<int> TrigDecisionChecker::m_summaryPassPhys

private

Definition at line 90 of file TrigDecisionChecker.h.

m_summaryPassRaw

std::vector<int> TrigDecisionChecker::m_summaryPassRaw

private

Definition at line 89 of file TrigDecisionChecker.h.

m_TauItems

Gaudi::Property<std::vector<std::string> > TrigDecisionChecker::m_TauItems { this, "TauItems", {} }

private

Definition at line 125 of file TrigDecisionChecker.h.

{ this, "TauItems", {} };

m_trigDec

ToolHandle<Trig::TrigDecisionTool> TrigDecisionChecker::m_trigDec {this, "TrigDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool"}

private

interface to use the trigger data: TriggerTool

Definition at line 108 of file TrigDecisionChecker.h.

{this, "TrigDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool"}; 

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:

• TrigDecisionChecker.h
• TrigDecisionChecker.cxx