ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
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 ()
 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 const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
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

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
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< 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 73 of file TrigDecisionChecker.cxx.

74: AthAlgorithm(name, pSvcLocator),
75 m_first_event(true)
76{
77
78
79}
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:

◆ ~TrigDecisionChecker()

TrigDecisionChecker::~TrigDecisionChecker ( )

std deconstructor

Definition at line 82 of file TrigDecisionChecker.cxx.

82{}

Member Function Documentation

◆ checkBjetEDM()

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

Definition at line 644 of file TrigDecisionChecker.cxx.

644 {
645
646 ATH_MSG_INFO("REGTEST ==========START of bjet EDM/Navigation check for chain " << trigItem << " ===========");
647
648 ATH_MSG_INFO("Chain passed = " << m_trigDec->isPassed(trigItem));
649
650 // Get feature container
651 Trig::FeatureContainer fc = m_trigDec->features(trigItem);
652
653 // Get online combinations
654 const std::vector< Trig::Combination >& bjetCombs = fc.getCombinations();
655 ATH_MSG_INFO("REGTEST - RETRIEVED " << bjetCombs.size() << " COMBINATIONS FOR " << trigItem);
656
657 // Loop on combinations
658 std::vector< Trig::Combination >::const_iterator bjetComb;
659 for( bjetComb = bjetCombs.begin(); bjetComb != bjetCombs.end(); ++bjetComb ) {
660
661 const Trig::Combination& comb = *bjetComb;
662 ATH_MSG_INFO("REGTEST - ------------ NEW COMBINATION ------------");
663
664 // Get online pv - histo
665 const std::vector< Trig::Feature<xAOD::VertexContainer> > onlinepvs_histo = comb.get<xAOD::VertexContainer>("EFHistoPrmVtx");
666 ATH_MSG_INFO("REGTEST - RETRIEVED PV (HISTO) - size: " << onlinepvs_histo.size());
667 if(onlinepvs_histo.size()) {
668 const xAOD::VertexContainer* onlinepv_histo = onlinepvs_histo[0].cptr();
669 ATH_MSG_INFO("REGTEST - - nVert: " << onlinepv_histo->size());
670 if(onlinepv_histo->size()) {
671 ATH_MSG_INFO("REGTEST - - z[0]: " << (*(onlinepv_histo))[0]->z());
672 }
673 }
674
675 // Get online pv - id tracking
676 const std::vector< Trig::Feature<xAOD::VertexContainer> > onlinepvs_id = comb.get<xAOD::VertexContainer>("xPrimVx");
677 ATH_MSG_INFO("REGTEST - RETRIEVED PV (IDTRK) - size: " << onlinepvs_id.size());
678 if(onlinepvs_id.size()) {
679 const xAOD::VertexContainer* onlinepv_id = onlinepvs_id[0].cptr();
680 ATH_MSG_INFO("REGTEST - - nVert: " << onlinepv_id->size());
681 if(onlinepv_id->size()) {
682 ATH_MSG_INFO("REGTEST - - z[0]: " << (*(onlinepv_id))[0]->z());
683 }
684 }
685
686 // Get online jet - from EFBjetSequenceAllTE
687 const std::vector< Trig::Feature<xAOD::JetContainer> > onlinejets_efbjet = comb.get<xAOD::JetContainer>("TrigJetRec");
688 ATH_MSG_INFO("REGTEST - RETRIEVED JETS (EFBJET) - size: " << onlinejets_efbjet.size());
689 if(onlinejets_efbjet.size()) {
690 const xAOD::JetContainer* onlinejet_efbjet = onlinejets_efbjet[0].cptr();
691 ATH_MSG_INFO("REGTEST - - nJet: " << onlinejet_efbjet->size());
692 for(const auto* jet_efbjet : *onlinejet_efbjet) {
693 // Dump
694 ATH_MSG_INFO("REGTEST - - eta/phi: " << jet_efbjet->eta() << " / " << jet_efbjet->phi());
695 }
696 }
697
698 // Get online jet - from JetSplitter
699 const std::vector< Trig::Feature<xAOD::JetContainer> > onlinejets_split = comb.get<xAOD::JetContainer>("SplitJet");
700 ATH_MSG_INFO("REGTEST - RETRIEVED JETS (SPLIT) - size: " << onlinejets_split.size());
701 if(onlinejets_split.size()) {
702 const xAOD::JetContainer* onlinejet_split = onlinejets_split[0].cptr();
703 ATH_MSG_INFO("REGTEST - - nJet: " << onlinejet_split->size());
704 for(const auto* jet_split : *onlinejet_split) {
705 // Dump
706 ATH_MSG_INFO("REGTEST - - eta/phi: " << jet_split->eta() << " / " << jet_split->phi());
707 }
708 }
709
710 // Get online jet - from SuperRoiBuilder (will this work for superROI ??)
711 const std::vector< Trig::Feature<xAOD::JetContainer> > onlinejets_super = comb.get<xAOD::JetContainer>("SuperRoi");
712 ATH_MSG_INFO("REGTEST - RETRIEVED JETS (SUPER) - size: " << onlinejets_super.size());
713 if(onlinejets_super.size()) {
714 const xAOD::JetContainer* onlinejet_super = onlinejets_super[0].cptr();
715 ATH_MSG_INFO("REGTEST - - nJet: " << onlinejet_super->size());
716 for(const auto* jet_super : *onlinejet_super) {
717 // Dump
718 ATH_MSG_INFO("REGTEST - - eta/phi: " << jet_super->eta() << " / " << jet_super->phi());
719 }
720 }
721
722 // Get online track particles (InDetTrigTrackingxAODCnv_BjetPrmVtx_FTF)
723 const std::vector< Trig::Feature<xAOD::TrackParticleContainer> > onlinetracks_prmvtx = comb.get<xAOD::TrackParticleContainer>("InDetTrigTrackingxAODCnv_BjetPrmVtx_FTF");
724 ATH_MSG_INFO("REGTEST - RETRIEVED TRACKS (BJETPRMVTX_FTF) - size: " << onlinetracks_prmvtx.size());
725 if(onlinetracks_prmvtx.size()) {
726 const xAOD::TrackParticleContainer* onlinetrack_prmvtx = onlinetracks_prmvtx[0].cptr();
727 ATH_MSG_INFO("REGTEST - - nTrack: " << onlinetrack_prmvtx->size());
728 for(const auto* trk : *onlinetrack_prmvtx) {
729 // Dump
730 uint8_t nInn=0, nNext=0, nPix=0, nSCT=0;
731 trk->summaryValue(nInn, xAOD::numberOfInnermostPixelLayerHits);
732 trk->summaryValue(nNext, xAOD::numberOfNextToInnermostPixelLayerHits);
733 trk->summaryValue(nPix, xAOD::numberOfPixelHits);
734 trk->summaryValue(nSCT, xAOD::numberOfSCTHits);
735 ATH_MSG_INFO("REGTEST - - inn/next/pix/sct: " << (int)nInn << " / " << (int)nNext << " / " << (int)nPix << " / " << (int)nSCT);
736 }
737 }
738
739 // Get online track particles (InDetTrigTrackingxAODCnv_Bjet_FTF)
740 const std::vector< Trig::Feature<xAOD::TrackParticleContainer> > onlinetracks_bjetftf = comb.get<xAOD::TrackParticleContainer>("InDetTrigTrackingxAODCnv_Bjet_FTF");
741 ATH_MSG_INFO("REGTEST - RETRIEVED TRACKS (BJET_FTF) - size: " << onlinetracks_bjetftf.size());
742 if(onlinetracks_bjetftf.size()) {
743 const xAOD::TrackParticleContainer* onlinetrack_bjetftf = onlinetracks_bjetftf[0].cptr();
744 ATH_MSG_INFO("REGTEST - - nTrack: " << onlinetrack_bjetftf->size());
745 for(const auto* trk : *onlinetrack_bjetftf) {
746 // Dump
747 uint8_t nInn=0, nNext=0, nPix=0, nSCT=0;
748 trk->summaryValue(nInn, xAOD::numberOfInnermostPixelLayerHits);
749 trk->summaryValue(nNext, xAOD::numberOfNextToInnermostPixelLayerHits);
750 trk->summaryValue(nPix, xAOD::numberOfPixelHits);
751 trk->summaryValue(nSCT, xAOD::numberOfSCTHits);
752 ATH_MSG_INFO("REGTEST - - inn/next/pix/sct: " << (int)nInn << " / " << (int)nNext << " / " << (int)nPix << " / " << (int)nSCT);
753 }
754 }
755
756 // Get online track particles (InDetTrigTrackingxAODCnv_Bjet_IDTrig)
757 const std::vector< Trig::Feature<xAOD::TrackParticleContainer> > onlinetracks_bjetprec = comb.get<xAOD::TrackParticleContainer>("InDetTrigTrackingxAODCnv_Bjet_IDTrig");
758 ATH_MSG_INFO("REGTEST - RETRIEVED TRACKS (BJET_IDTRIG) - size: " << onlinetracks_bjetprec.size());
759 if(onlinetracks_bjetprec.size()) {
760 const xAOD::TrackParticleContainer* onlinetrack_bjetprec = onlinetracks_bjetprec[0].cptr();
761 ATH_MSG_INFO("REGTEST - - nTrack: " << onlinetrack_bjetprec->size());
762 for(const auto* trk : *onlinetrack_bjetprec) {
763 // Dump
764 uint8_t nInn=0, nNext=0, nPix=0, nSCT=0;
765 trk->summaryValue(nInn, xAOD::numberOfInnermostPixelLayerHits);
766 trk->summaryValue(nNext, xAOD::numberOfNextToInnermostPixelLayerHits);
767 trk->summaryValue(nPix, xAOD::numberOfPixelHits);
768 trk->summaryValue(nSCT, xAOD::numberOfSCTHits);
769 ATH_MSG_INFO("REGTEST - - inn/next/pix/sct: " << (int)nInn << " / " << (int)nNext << " / " << (int)nPix << " / " << (int)nSCT);
770 }
771 }
772
773 // Get online bjet
774 const std::vector< Trig::Feature<xAOD::BTaggingContainer> > onlinebjets = comb.get<xAOD::BTaggingContainer>();
775 ATH_MSG_INFO("REGTEST - RETRIEVED BJETS - size: " << onlinebjets.size());
776 if(onlinebjets.size()) {
777 const xAOD::BTaggingContainer* onlinebjet = onlinebjets[0].cptr();
778 ATH_MSG_INFO("REGTEST - - nBjet: " << onlinebjet->size());
779 for(const auto* bjet : *onlinebjet) {
780 // Dump
781 double wIP2D, wIP3D, wSV1, wCOMB, wMV1;
782 bjet->loglikelihoodratio("IP2D", wIP2D);
783 bjet->loglikelihoodratio("IP3D", wIP3D);
784 bjet->loglikelihoodratio("SV1", wSV1);
785 wCOMB = wIP3D+wSV1;
786 wMV1 = bjet->MV1_discriminant();
787 ATH_MSG_INFO("REGTEST - - IP2D/IP3D/SV1/IP3D+SV1/MV1: " << wIP2D << " / " << wIP3D << " / " << wSV1 << " / " << wCOMB << " / " << wMV1);
788 }
789 }
790
791 }
792
793 msg(MSG::INFO) << "REGTEST ==========END of bjet EDM/Navigation check for chain " << trigItem << " ===========" << endmsg;
794
795 return StatusCode::SUCCESS;
796}//checkBjetEDM
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
z
#define z
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition AthCommonMsg.h:24
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
TrigDecisionChecker::m_trigDec
ToolHandle< Trig::TrigDecisionTool > m_trigDec
interface to use the trigger data: TriggerTool
Definition TrigDecisionChecker.h:113
Trig::Combination::get
std::vector< Trig::Feature< T > > get(const std::string &label="", unsigned int condition=TrigDefs::Physics, const std::string &teName="") const
Method used to get objects.
Definition Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/Combination.h:170
Trig::FeatureContainer::getCombinations
const std::vector< Trig::Combination > & getCombinations() const
gives back reference to combinations collected through append
Definition FeatureContainer.h:111
python.BuildSignatureFlags.bjet
AthConfigFlags bjet(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:375
xAOD::BTaggingContainer
BTaggingContainer_v1 BTaggingContainer
Definition of the current "BTagging container version".
Definition BTaggingContainer.h:17
xAOD::VertexContainer
VertexContainer_v1 VertexContainer
Definition of the current "Vertex container version".
Definition VertexContainer.h:14
xAOD::TrackParticleContainer
TrackParticleContainer_v1 TrackParticleContainer
Definition of the current "TrackParticle container version".
Definition Event/xAOD/xAODTracking/xAODTracking/TrackParticleContainer.h:14
xAOD::JetContainer
JetContainer_v1 JetContainer
Definition of the current "jet container version".
Definition JetContainer.h:17
xAOD::numberOfNextToInnermostPixelLayerHits
@ numberOfNextToInnermostPixelLayerHits
these are the hits in the 1st pixel barrel layer
Definition TrackingPrimitives.h:249
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition TrackingPrimitives.h:269
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition TrackingPrimitives.h:238
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition TrackingPrimitives.h:260

◆ checkBphysEDM()

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

Bphysics EDM checker.

Definition at line 887 of file TrigDecisionChecker.cxx.

887 {
888
889 msg(MSG::INFO) << "REGTEST ==========START of Bphysics EDM/Navigation check for chain " << trigItem << " ===========" << endmsg;
890
891 ATH_MSG_INFO("Chain passed = " << m_trigDec->isPassed(trigItem));
892
893 Trig::FeatureContainer fc = m_trigDec->features(trigItem);
894
895 const std::vector< Trig::Feature<xAOD::TrigBphysContainer> > fc_bphys = fc.get<xAOD::TrigBphysContainer>();
896 ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::TrigBphysContainer> > = " << fc_bphys.size());
897
898 for( const auto& cont_bphys : fc_bphys ) {
899 ATH_MSG_INFO("REGTEST Got Bphysics container, size = " << cont_bphys.cptr()->size());
900 for ( auto bphys: *(cont_bphys.cptr()) ) {
901 ATH_MSG_INFO("REGTEST Bphysics Item mass, fitmass, secVx, nTP: "
902 << bphys->mass()*0.001 << " , " << bphys->fitmass() * 0.001 << " , "
903 << bphys->secondaryDecay() << " , " << bphys->nTrackParticles()
904 );
905 } // for
906
907 }// loop over bphys features
908
909 // const std::vector< Trig::Feature<CombinedMuonFeature> > vec_cbmufeats = fc.get<CombinedMuonFeature>();
910 // ATH_MSG_INFO("Size of vector< Trig::Feature<CombinedMuonFeature> > = " << vec_cbmufeats.size());
911 //
912 // for( auto cbmufeat : vec_cbmufeats) {
913 // ATH_MSG_INFO("REGTEST CombinedMuonFeature with pt, eta, phi = " << cbmufeat.cptr()->pt() << ", " << cbmufeat.cptr()->eta() << ", " << cbmufeat.cptr()->phi());
914 // }
915 //
916 ATH_MSG_INFO("REGTEST ==========END of Bphysics EDM/Navigation check for chain " << trigItem << " ===========");
917
918 return StatusCode::SUCCESS;
919}//checkBphysEDM
Trig::FeatureContainer::get
const std::vector< Trig::Feature< T > > get(const std::string &label="", unsigned int condition=TrigDefs::Physics, const std::string &teName="") const
returns flattened vector of Features of given type This method is in fact sullied by 3 arguments.
Definition FeatureContainer.h:151
xAOD::TrigBphysContainer
TrigBphysContainer_v1 TrigBphysContainer
Definition TrigBphysContainer.h:12

◆ checkEDM()

template<class T>
StatusCode TrigDecisionChecker::checkEDM ( const std::string & trigItem)
private

Definition at line 578 of file TrigDecisionChecker.cxx.

578 {
579 ATH_MSG_INFO("REGTEST Check TrigPassBits for " << trigItem << " and type " << ClassID_traits< T >::typeName() );
580 m_trigDec->isPassed(trigItem) ? ATH_MSG_INFO("REGTEST " << trigItem << " Passes ") : ATH_MSG_INFO("REGTEST " << trigItem << " Fails");
581 const auto fc = m_trigDec->features(trigItem,TrigDefs::alsoDeactivateTEs);
582 const auto vec = fc.get<T>();
583 const auto vecbits = fc.get<xAOD::TrigPassBits>();
584 std::string label="";
585 for(const auto& feat:vecbits){
586 const auto *xbits=feat.cptr();
587 TrigConf::HLTTriggerElement::getLabel(feat.te()->getId(), label );
588 const auto *cont=(m_trigDec->ancestor<T>(feat.te())).cptr();
589 if(cont){
590 ATH_MSG_INFO("REGTEST TrigPassBits for TE " << label
591 << " size " << cont->size());
592
593 if(cont->size()!=xbits->size()) {
594 ATH_MSG_WARNING("REGTEST Container and bit size not equal, continue");
595 continue;
596 }
597 int npassed=0;
598 for(const auto &ptr:*cont){
599 if(xbits->isPassing(ptr,cont))
600 npassed++;
601 }
602 ATH_MSG_INFO("REGTEST TrigPassBits for container type " << ClassID_traits< T >::typeName()
603 << " size " << cont->size() << " xbits " << xbits->size() << " selected " << npassed);
604 }
605 }
606
607
608
609 for(const auto& feat:vec){
610 const auto *cont=feat.cptr();
611 const TrigPassBits *bits=(m_trigDec->ancestor<TrigPassBits>(feat.te())).cptr();
612 const xAOD::TrigPassBits *xbits=(m_trigDec->ancestor<xAOD::TrigPassBits>(feat.te())).cptr();
613 TrigConf::HLTTriggerElement::getLabel(feat.te()->getId(), label );
614 if(!cont){
615 ATH_MSG_WARNING(label << " " << ClassID_traits< T >::typeName() << "REGTEST: TrigPassBits container is null ");
616 continue;
617 }
618 if(!bits){
619 ATH_MSG_WARNING(label << " " << ClassID_traits< T >::typeName() << " REGTEST: TrigPassBits old bits null ");
620 }
621 if(!xbits){
622 ATH_MSG_WARNING(label << " " << ClassID_traits< T >::typeName() << " REGTEST: TrigPassBits xbits null ");
623 continue;
624 }
625 //
626 const size_t bitlen = ( (cont->size() - 1)/32 ) + 1;
627 if(bits)
628 ATH_MSG_INFO("REGTEST Retrieved container type " << ClassID_traits< T >::typeName() << " size " << cont->size()
629 << " bits " << bits->size() << " Expect vector of bits " << bitlen);
630 int npassed=0;
631 if(xbits){
632 for(const auto &ptr:*cont){
633 if(xbits->isPassing(ptr,cont))
634 npassed++;
635 }
636 ATH_MSG_INFO("REGTEST TrigPassBits for container type " << ClassID_traits< T >::typeName()
637 << " size " << cont->size() << " xbits " << xbits->size() << " selected " << npassed);
638 }
639 }
640
641 return StatusCode::SUCCESS;
642}
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
vec
std::vector< size_t > vec
Definition CombinationsGeneratorTest.cxx:9
TrigConf::HLTTriggerElement::getLabel
static bool getLabel(unsigned int id, std::string &label)
find name from ID in the map m_IdToLabel
Definition HLTTriggerElement.cxx:63
TrigPassBits::size
unsigned int size() const
gets size of the bits array
Definition Trigger/TrigEvent/TrigSteeringEvent/TrigSteeringEvent/TrigPassBits.h:44
xAOD::TrigPassBits_v1::size
uint32_t size() const
The size of the target container.
xAOD::TrigPassBits_v1::isPassing
bool isPassing(const OBJ *obj, const CONT *container) const
Check if an element of a container is passing/failing.
label
std::string label(const std::string &format, int i)
Definition label.h:19
TSU::T
unsigned long long T
Definition L1TopoDataTypes.h:35
xAOD::TrigPassBits
TrigPassBits_v1 TrigPassBits
Define the latest version of the trigger pass bits class.
Definition Event/xAOD/xAODTrigger/xAODTrigger/TrigPassBits.h:16
ClassID_traits::typeName
static const std::string & typeName()
Definition Control/AthenaKernel/AthenaKernel/ClassID_traits.h:49

◆ checkElectronEDM()

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

Definition at line 926 of file TrigDecisionChecker.cxx.

926 {
927 msg(MSG::INFO) << "REGTEST ==========START of Electron EDM/Navigation check for chain " << trigItem << " ===========" << endmsg;
928
929 ATH_MSG_INFO("Chain passed = " << m_trigDec->isPassed(trigItem));
930
931 Trig::FeatureContainer fc = m_trigDec->features(trigItem);
932 const std::vector< Trig::Feature<xAOD::ElectronContainer> > vec_el = fc.get<xAOD::ElectronContainer>();
933 ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::ElectronContainer> > = " << vec_el.size());
934 float val_float=-99.;
935 for(const auto& elfeat : vec_el){
936 ATH_MSG_INFO("REGTEST: Got electron container, size = " << elfeat.cptr()->size());
937 const xAOD::ElectronContainer *elCont = elfeat.cptr();
938
939 for(const auto eg : *elCont){
940 if (eg) {
941 ATH_MSG_INFO(" REGTEST: egamma energy: " << eg->e() );
942 ATH_MSG_INFO(" REGTEST: egamma eta: " << eg->eta() );
943 ATH_MSG_INFO(" REGTEST: egamma phi: " << eg->phi() );
944 } else{
945 ATH_MSG_INFO(" REGTEST: problems with egamma pointer" );
946 return StatusCode::SUCCESS;
947 }
948 ATH_MSG_INFO(" REGTEST: caloCluster variables ");
949 if (eg->caloCluster()) {
950 ATH_MSG_INFO(" REGTEST: egamma cluster transverse energy: " << eg->caloCluster()->et() );
951 ATH_MSG_INFO(" REGTEST: egamma cluster eta: " << eg->caloCluster()->eta() );
952 ATH_MSG_INFO(" REGTEST: egamma cluster phi: " << eg->caloCluster()->phi() );
953 double tmpeta = -999.;
954 double tmpphi = -999.;
955 eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::ETACALOFRAME,tmpeta);
956 eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::PHICALOFRAME,tmpphi);
957 ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. etaCalo = " << tmpeta);
958 ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. phiCalo = " << tmpphi);
959 } else{
960 ATH_MSG_INFO(" REGTEST: problems with egamma cluster pointer" );
961 }
962 ATH_MSG_INFO(" REGTEST: trackmatch variables ");
963 if(eg->trackParticle()){
964 ATH_MSG_INFO(" REGTEST: pt= " << eg->trackParticle()->pt());
965 ATH_MSG_INFO(" REGTEST: charge= " << eg->trackParticle()->charge());
966 ATH_MSG_INFO(" REGTEST: E/p= " << eg->caloCluster()->et() / eg->trackParticle()->pt() );
967 eg->trackCaloMatchValue(val_float,xAOD::EgammaParameters::deltaEta1);
968 ATH_MSG_INFO(" REGTEST: Delta eta 1st sampling= " << val_float);
969 eg->trackCaloMatchValue(val_float,xAOD::EgammaParameters::deltaPhi2);
970 ATH_MSG_INFO(" REGTEST: Delta phi 2nd sampling= " << val_float);
971 } else{
972 ATH_MSG_INFO(" REGTEST: no electron eg->trackParticle() pointer");
973 }
974 }
975 }
976
977 msg(MSG::INFO) << "REGTEST ==========END of Electron EDM/Navigation check ===========" << endmsg;
978 return StatusCode::SUCCESS;
979}
xAOD::CaloCluster_v1::ETACALOFRAME
@ ETACALOFRAME
Eta in the calo frame (for egamma)
Definition CaloCluster_v1.h:190
xAOD::CaloCluster_v1::PHICALOFRAME
@ PHICALOFRAME
Phi in the calo frame (for egamma)
Definition CaloCluster_v1.h:191
xAOD::EgammaParameters::deltaPhi2
@ deltaPhi2
difference between the cluster phi (second sampling) and the phi of the track extrapolated to the sec...
Definition EgammaEnums.h:205
xAOD::EgammaParameters::deltaEta1
@ deltaEta1
difference between the cluster eta (first sampling) and the eta of the track extrapolated to the firs...
Definition EgammaEnums.h:185
xAOD::ElectronContainer
ElectronContainer_v1 ElectronContainer
Definition of the current "electron container version".
Definition Event/xAOD/xAODEgamma/xAODEgamma/ElectronContainer.h:17

◆ checkJetEDM()

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

Definition at line 1141 of file TrigDecisionChecker.cxx.

1141 {
1142 ATH_MSG_DEBUG("in checkJetEDM()");
1143
1144 ATH_MSG_INFO("REGTEST =====For chain " << trigItem << "=====");
1145
1146 ATH_MSG_INFO("Chain passed = " << m_trigDec->isPassed(trigItem));
1147
1148 Trig::FeatureContainer fc = m_trigDec->features(trigItem);
1149 const std::vector< Trig::Feature<xAOD::JetContainer> > vec_jet = fc.get<xAOD::JetContainer>();
1150 ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::JetContainer> > = " << vec_jet.size());
1151 for(const auto& jetfeat : vec_jet){
1152 const xAOD::JetContainer * jetCont = jetfeat.cptr();
1153
1154 int jetContsize = jetCont->size();
1155 ATH_MSG_INFO("REGTEST Got jet container, size: " << jetContsize);
1156
1157 int i = 0;
1158 for(const auto thisjet : *jetCont){
1159 ++i;
1160 ATH_MSG_INFO("REGTEST Looking at jet " << i);
1161 if (thisjet) {
1162 //checks jet variables
1163 ATH_MSG_DEBUG("REGTEST Checking jet variables");
1164 ATH_MSG_INFO("REGTEST pt: " << thisjet->pt() );
1165 ATH_MSG_INFO("REGTEST eta: " << thisjet->eta() );
1166 ATH_MSG_INFO("REGTEST phi: " << thisjet->phi() );
1167 ATH_MSG_INFO("REGTEST m: " << thisjet->m() );
1168 ATH_MSG_INFO("REGTEST e: " << thisjet->e() );
1169 ATH_MSG_INFO("REGTEST px: " << thisjet->px() );
1170 ATH_MSG_INFO("REGTEST py: " << thisjet->py() );
1171 ATH_MSG_INFO("REGTEST pz: " << thisjet->pz() );
1172 ATH_MSG_INFO("REGTEST type: " << thisjet->type() );
1173 ATH_MSG_INFO("REGTEST algorithm (kt: 0, cam: 1, antikt: 2, ...): " << thisjet->getAlgorithmType() );
1174 ATH_MSG_INFO("REGTEST size parameter: " << thisjet->getSizeParameter() );
1175 ATH_MSG_INFO("REGTEST input (LCTopo: 0, EMTopo: 1, ...): " << thisjet->getInputType() );
1176 ATH_MSG_INFO("REGTEST constituents signal state (uncalibrated: 0, calibrated: 1): " << thisjet->getConstituentsSignalState() );
1177 ATH_MSG_INFO("REGTEST number of constituents: " << thisjet->numConstituents() );
1178 }
1179 else{
1180 ATH_MSG_ERROR("REGTEST Problem with jet pointer" );
1181 return StatusCode::FAILURE;
1182 }
1183 }
1184 if (jetContsize == i) ATH_MSG_INFO("REGTEST size of jet container == number of displayed jets: " << (jetContsize == i) );
1185 else ATH_MSG_WARNING("REGTEST Problem with displaying jets");
1186 }
1187
1188 ATH_MSG_DEBUG("leaving checkJetEDM()");
1189
1190 return StatusCode::SUCCESS;
1191}
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29

◆ checkMetEDM()

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

Definition at line 1193 of file TrigDecisionChecker.cxx.

1193 {
1194 ATH_MSG_DEBUG("in checkMetEDM()");
1195
1196 ATH_MSG_INFO("REGTEST =====For chain " << trigItem << "=====");
1197
1198 ATH_MSG_INFO("Chain passed = " << m_trigDec->isPassed(trigItem));
1199
1200 Trig::FeatureContainer fc = m_trigDec->features(trigItem);
1201 const std::vector< Trig::Feature<xAOD::TrigMissingETContainer> > vec_met = fc.get<xAOD::TrigMissingETContainer>();
1202 ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::TrigMissingETContainer> > = " << vec_met.size());
1203 for(const auto& metfeat : vec_met){
1204 const xAOD::TrigMissingETContainer * metCont = metfeat.cptr();
1205
1206 ATH_MSG_INFO("REGTEST Fot trigMet container, size: " << metCont->size());
1207
1208 const xAOD::TrigMissingET * metObj = metCont->front(); // the first object in the container typically holds the total MET, other objects hold components
1209
1210 if (metObj){
1211 ATH_MSG_DEBUG("REGTEST Checking met variables");
1212 ATH_MSG_INFO("REGTEST ex: " << metObj->ex() );
1213 ATH_MSG_INFO("REGTEST ey: " << metObj->ey() );
1214 ATH_MSG_INFO("REGTEST sumEt: " << metObj->sumEt() );
1215 ATH_MSG_INFO("REGTEST ez: " << metObj->ez() );
1216 ATH_MSG_INFO("REGTEST sumE: " << metObj->sumE() );
1217 ATH_MSG_INFO("REGTEST number of components: " << metObj->getNumberOfComponents() );
1218 }
1219 else{
1220 ATH_MSG_ERROR("REGTEST Problem with met pointer" );
1221 return StatusCode::FAILURE;
1222 }
1223 }
1224
1225 ATH_MSG_DEBUG("leaving checkMetEDM()");
1226
1227 return StatusCode::SUCCESS;
1228}
DataVector::front
const T * front() const
Access the first element in the collection as an rvalue.
xAOD::TrigMissingET_v1::ex
float ex() const
Get the x component of the missing energy.
xAOD::TrigMissingET_v1::sumE
float sumE() const
Get the sum of the E of the missing energy.
xAOD::TrigMissingET_v1::getNumberOfComponents
unsigned int getNumberOfComponents() const
Get the number of components.
Definition TrigMissingET_v1.cxx:103
xAOD::TrigMissingET_v1::sumEt
float sumEt() const
Get the sum of the ET of the missing energy.
xAOD::TrigMissingET_v1::ez
float ez() const
Get the z component of the missing energy.
xAOD::TrigMissingET_v1::ey
float ey() const
Get the y component of the missing energy.
xAOD::TrigMissingETContainer
TrigMissingETContainer_v1 TrigMissingETContainer
DataVector of TrigMissingET - the current version.
Definition Event/xAOD/xAODTrigMissingET/xAODTrigMissingET/TrigMissingETContainer.h:13
xAOD::TrigMissingET
TrigMissingET_v1 TrigMissingET
Define the most recent version of the TrigMissingET class.
Definition Event/xAOD/xAODTrigMissingET/xAODTrigMissingET/TrigMissingET.h:12

◆ checkMinBiasEDM()

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

Definition at line 1024 of file TrigDecisionChecker.cxx.

1024 {
1025 msg(MSG::INFO) << "REGTEST ==========START of MinBias EDM/Navigation check for chain " << trigItem << " ===========" << endmsg;
1026
1027 ATH_MSG_INFO("Chain passed = " << m_trigDec->isPassed(trigItem));
1028
1029 Trig::FeatureContainer fc = m_trigDec->features(trigItem);
1030
1031 checkTrigSpacePointCounts(fc);
1032 checkTrigT2MBTSBits(fc);
1033 checkTrigVertexCounts(fc);
1034 checkTrigTrackCounts(fc);
1035
1036 msg(MSG::INFO) << "REGTEST ==========END of MinBias EDM/Navigation check ===========" << endmsg;
1037 return StatusCode::SUCCESS;
1038}
TrigDecisionChecker::checkTrigSpacePointCounts
void checkTrigSpacePointCounts(const Trig::FeatureContainer &fc)
Definition TrigDecisionChecker.cxx:1040
TrigDecisionChecker::checkTrigTrackCounts
void checkTrigTrackCounts(const Trig::FeatureContainer &fc)
Definition TrigDecisionChecker.cxx:1111
TrigDecisionChecker::checkTrigVertexCounts
void checkTrigVertexCounts(const Trig::FeatureContainer &fc)
Definition TrigDecisionChecker.cxx:1091
TrigDecisionChecker::checkTrigT2MBTSBits
void checkTrigT2MBTSBits(const Trig::FeatureContainer &fc)
Definition TrigDecisionChecker.cxx:1071

◆ checkMuonEDM()

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

Definition at line 798 of file TrigDecisionChecker.cxx.

798 {
799
800 msg(MSG::INFO) << "REGTEST ==========START of muon EDM/Navigation check for chain " << trigItem << " ===========" << endmsg;
801
802 ATH_MSG_INFO("Chain passed = " << m_trigDec->isPassed(trigItem));
803
804 Trig::FeatureContainer fc = m_trigDec->features(trigItem);
805
806 const std::vector< Trig::Feature<xAOD::MuonContainer> > vec_muons = fc.get<xAOD::MuonContainer>();
807 ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::MuonContainer> > = " << vec_muons.size());
808
809 for( const auto& mufeat : vec_muons ) {
810 ATH_MSG_INFO("REGTEST Got muon container, size = " << mufeat.cptr()->size());
811 for(auto muItr : *(mufeat.cptr())) {
812 ATH_MSG_INFO("REGTEST MuonFeature with pt, eta, phi = " << muItr->pt() << ", " << muItr->eta() << ", " << muItr->phi());
813 }
814 }// loop over muon features
815
816 const std::vector< Trig::Feature<xAOD::L2CombinedMuonContainer> > vec_L2CBmuons = fc.get<xAOD::L2CombinedMuonContainer>();
817 ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::L2CombinedMuonContainer> > = " << vec_L2CBmuons.size());
818
819 for( const auto& l2cbmufeat : vec_L2CBmuons) {
820 ATH_MSG_INFO("REGTEST Got muon container, size = " << l2cbmufeat.cptr()->size());
821 for(auto l2cbmuItr : *(l2cbmufeat.cptr())) {
822 ATH_MSG_INFO("REGTEST MuonFeature with pt, eta, phi = " << l2cbmuItr->pt() << ", " << l2cbmuItr->eta() << ", " << l2cbmuItr->phi());
823 }
824 }// loop over muon L2 CB features
825
826 const std::vector< Trig::Feature<xAOD::L2StandAloneMuonContainer> > vec_L2SAmuons = fc.get<xAOD::L2StandAloneMuonContainer>();
827 ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::L2StandAloneMuonContainer> > = " << vec_L2SAmuons.size());
828
829 for( const auto& l2samufeat : vec_L2SAmuons) {
830 ATH_MSG_INFO("REGTEST Got muon container, size = " << l2samufeat.cptr()->size());
831 for(auto l2samuItr : *(l2samufeat.cptr())) {
832 ATH_MSG_INFO("REGTEST MuonFeature with pt, eta, phi = " << l2samuItr->pt() << ", " << l2samuItr->eta() << ", " << l2samuItr->phi());
833 }
834 }// loop over muon L2 SA features
835
836 msg(MSG::INFO) << "REGTEST ==========END of muon EDM/Navigation check for chain " << trigItem << " ===========" << endmsg;
837
838 return StatusCode::SUCCESS;
839}//checkMuonEDM
xAOD::L2CombinedMuonContainer
L2CombinedMuonContainer_v1 L2CombinedMuonContainer
Define the latest version of the muon CB container.
Definition L2CombinedMuonContainer.h:15
xAOD::L2StandAloneMuonContainer
L2StandAloneMuonContainer_v2 L2StandAloneMuonContainer
Define the latest version of the muon SA container.
Definition L2StandAloneMuonContainer.h:17
xAOD::MuonContainer
MuonContainer_v1 MuonContainer
Definition of the current "Muon container version".
Definition Event/xAOD/xAODMuon/xAODMuon/MuonContainer.h:14

◆ checkPhotonEDM()

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

Definition at line 981 of file TrigDecisionChecker.cxx.

981 {
982 msg(MSG::INFO) << "REGTEST ==========START of Photon EDM/Navigation check for chain " << trigItem << " ===========" << endmsg;
983
984 ATH_MSG_INFO("Chain passed = " << m_trigDec->isPassed(trigItem));
985
986 Trig::FeatureContainer fc = m_trigDec->features(trigItem);
987 const std::vector< Trig::Feature<xAOD::PhotonContainer> > vec_ph = fc.get<xAOD::PhotonContainer>();
988 ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::PhotonContainer> > = " << vec_ph.size());
989 //float val_float=-99.;
990 for(const auto& phfeat : vec_ph){
991 ATH_MSG_INFO("REGTEST: Got photon container, size = " << phfeat.cptr()->size());
992 const xAOD::PhotonContainer *phCont = phfeat.cptr();
993
994 for(const auto eg : *phCont){
995 if (eg) {
996 ATH_MSG_INFO(" REGTEST: egamma energy: " << eg->e() );
997 ATH_MSG_INFO(" REGTEST: egamma eta: " << eg->eta() );
998 ATH_MSG_INFO(" REGTEST: egamma phi: " << eg->phi() );
999 } else{
1000 ATH_MSG_INFO(" REGTEST: problems with egamma pointer" );
1001 return StatusCode::SUCCESS;
1002 }
1003 ATH_MSG_INFO(" REGTEST: caloCluster variables ");
1004 if (eg->caloCluster()) {
1005 ATH_MSG_INFO(" REGTEST: egamma cluster transverse energy: " << eg->caloCluster()->et() );
1006 ATH_MSG_INFO(" REGTEST: egamma cluster eta: " << eg->caloCluster()->eta() );
1007 ATH_MSG_INFO(" REGTEST: egamma cluster phi: " << eg->caloCluster()->phi() );
1008 double tmpeta = -999.;
1009 double tmpphi = -999.;
1010 eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::ETACALOFRAME,tmpeta);
1011 eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::PHICALOFRAME,tmpphi);
1012 ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. etaCalo = " << tmpeta);
1013 ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. phiCalo = " << tmpphi);
1014 } else{
1015 ATH_MSG_INFO(" REGTEST: problems with egamma cluster pointer" );
1016 }
1017 }
1018 }
1019
1020 msg(MSG::INFO) << "REGTEST ==========END of Photon EDM/Navigation check ===========" << endmsg;
1021 return StatusCode::SUCCESS;
1022}
xAOD::PhotonContainer
PhotonContainer_v1 PhotonContainer
Definition of the current "photon container version".
Definition Event/xAOD/xAODEgamma/xAODEgamma/PhotonContainer.h:17

◆ checkTauEDM()

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

Definition at line 841 of file TrigDecisionChecker.cxx.

841 {
842 msg(MSG::INFO)<< "REGTEST ==========START of tau EDM/Navigation check for chain " << trigItem<< "===========" << endmsg;
843 Trig::FeatureContainer fc = m_trigDec->features(trigItem);
844 const std::vector< Trig::Feature<xAOD::TauJetContainer> > vec_tauHLTClust = fc.get<xAOD::TauJetContainer>();
845 ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::TauJetContainer> > = " << vec_tauHLTClust.size());
846 for(const auto& cont_tau : vec_tauHLTClust) {
847 ATH_MSG_INFO("REGTEST Got Tau container, size = " << cont_tau.cptr()->size());
848
849 for(auto tauItr : *(cont_tau.cptr())) {
850
851 msg(MSG::INFO) << "REGTEST "<<" HLT tau number of tracks: "<<tauItr->nTracks()<<endmsg;
852 msg(MSG::INFO) << "REGTEST "<<" HLT tau pt : "<<tauItr->pt()<<endmsg;
853 msg(MSG::INFO) << "REGTEST "<<" HLT tau phi : "<<tauItr->phi()<<endmsg;
854 msg(MSG::INFO) << "REGTEST "<<" HLT tau eta : "<<tauItr->eta()<<endmsg;
855 if( !tauItr->jetLink().isValid() ) {
856 ATH_MSG_WARNING("tau does not have jet seed");
857 return StatusCode::SUCCESS;
858 }
859
860 const xAOD::Jet* pJetSeed = *(tauItr->jetLink());
861 xAOD::JetConstituentVector::const_iterator clusItr = pJetSeed->getConstituents().begin();
862 xAOD::JetConstituentVector::const_iterator clusItrE = pJetSeed->getConstituents().end();
863 for (int clusCount = 0; clusItr != clusItrE; ++clusItr, ++clusCount) {
864 ATH_MSG_INFO( "REGTEST Tau Cluster " << clusCount << " pt = " << (*clusItr)->pt()<< " eta = " << (*clusItr)->eta()<< " phi = " << (*clusItr)->phi() );
865 }
866 for (unsigned int trackNum = 0; trackNum < tauItr->nTracks(); ++trackNum) {
867
868 const xAOD::TrackParticle *linkTrack = tauItr->track(trackNum)->track();
869 if (!linkTrack) {
870 ATH_MSG_WARNING("can't get tau linked track");
871 return StatusCode::SUCCESS;
872 } else {
873 ATH_MSG_DEBUG("Got the tau linked track");
874 }
875 ATH_MSG_INFO( "REGTEST Tau linked track " << trackNum << " pt = " << linkTrack->pt()<< " eta = " << linkTrack->eta() << " phi = " << linkTrack->phi() );
876 }
877
878 }
879 }
880
881 msg(MSG::INFO) << "REGTEST ==========END of Tau EDM/Navigation check ===========" << endmsg;
882 return StatusCode::SUCCESS;
883}
xAOD::JetConstituentVector::begin
iterator begin() const
iterator on the first constituent
Definition JetConstituentVector.cxx:103
xAOD::JetConstituentVector::end
iterator end() const
iterator after the last constituent
Definition JetConstituentVector.cxx:104
xAOD::Jet_v1::getConstituents
JetConstituentVector getConstituents() const
Return a vector of consituents. The object behaves like vector<const IParticle*>. See JetConstituentV...
Definition Jet_v1.cxx:147
xAOD::TrackParticle_v1::track
const Trk::Track * track() const
Returns a pointer (which can be NULL) to the Trk::Track which was used to make this TrackParticle.
Definition TrackParticle_v1.cxx:734
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition TrackParticle_v1.cxx:75
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition TrackParticle_v1.cxx:79
xAOD::Jet
Jet_v1 Jet
Definition of the current "jet version".
Definition Event/xAOD/xAODJet/xAODJet/Jet.h:17
xAOD::TrackParticle
TrackParticle_v1 TrackParticle
Reference the current persistent version:
Definition Event/xAOD/xAODTracking/xAODTracking/TrackParticle.h:13
xAOD::TauJetContainer
TauJetContainer_v3 TauJetContainer
Definition of the current "taujet container version".
Definition Event/xAOD/xAODTau/xAODTau/TauJetContainer.h:17

◆ checkTrigSpacePointCounts()

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

Definition at line 1040 of file TrigDecisionChecker.cxx.

1040 {
1041
1042 const std::vector< Trig::Feature<xAOD::TrigSpacePointCounts> > vec_sp = fc.get<xAOD::TrigSpacePointCounts>();
1043 ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::TrigSpacePointCounts> > = " << vec_sp.size());
1044
1045 float sum;
1046 auto fun = [&sum](const std::vector<float>& vec){sum = 0.; for (const auto &i: vec) sum += i; return sum;};
1047
1048 for(const auto& spfeat : vec_sp){
1049 const xAOD::TrigSpacePointCounts *spCounts = spfeat.cptr();
1050 if (spCounts){
1051 ATH_MSG_INFO(" REGTEST: SUM of contentsPixelClusEndcapC: " << fun(spCounts->contentsPixelClusEndcapC()) );
1052 ATH_MSG_INFO(" REGTEST: SUM of contentsPixelClusBarrel: " << fun(spCounts->contentsPixelClusBarrel()) );
1053 ATH_MSG_INFO(" REGTEST: SUM of contentsPixelClusEndcapA: " << fun(spCounts->contentsPixelClusEndcapA()) );
1054
1055 ATH_MSG_INFO(" REGTEST: pixelClusTotBins: " << spCounts->pixelClusTotBins() );
1056 ATH_MSG_INFO(" REGTEST: pixelClusTotMin: " << spCounts->pixelClusTotMin() );
1057 ATH_MSG_INFO(" REGTEST: pixelClusTotMax: " << spCounts->pixelClusTotMax() );
1058 ATH_MSG_INFO(" REGTEST: pixelClusSizeBins: " << spCounts->pixelClusSizeBins() );
1059 ATH_MSG_INFO(" REGTEST: pixelClusSizeMin: " << spCounts->pixelClusSizeMin() );
1060 ATH_MSG_INFO(" REGTEST: pixelClusSizeMax: " << spCounts->pixelClusSizeMax() );
1061 ATH_MSG_INFO(" REGTEST: sctSpEndcapC: " << spCounts->sctSpEndcapC() );
1062 ATH_MSG_INFO(" REGTEST: sctSpBarrel: " << spCounts->sctSpBarrel() );
1063 ATH_MSG_INFO(" REGTEST: sctSpEndcapA: " << spCounts->sctSpEndcapA() );
1064 } else{
1065 ATH_MSG_INFO(" REGTEST: problems with TrigSpacePointCounts pointer" );
1066 return;
1067 }
1068 }
1069}
xAOD::TrigSpacePointCounts_v1::sctSpEndcapA
unsigned int sctSpEndcapA() const
xAOD::TrigSpacePointCounts_v1::pixelClusSizeMin
float pixelClusSizeMin() const
xAOD::TrigSpacePointCounts_v1::pixelClusTotBins
unsigned int pixelClusTotBins() const
xAOD::TrigSpacePointCounts_v1::sctSpBarrel
unsigned int sctSpBarrel() const
xAOD::TrigSpacePointCounts_v1::pixelClusSizeBins
unsigned int pixelClusSizeBins() const
xAOD::TrigSpacePointCounts_v1::contentsPixelClusEndcapC
const std::vector< float > & contentsPixelClusEndcapC() const
getters
xAOD::TrigSpacePointCounts_v1::contentsPixelClusEndcapA
const std::vector< float > & contentsPixelClusEndcapA() const
xAOD::TrigSpacePointCounts_v1::sctSpEndcapC
unsigned int sctSpEndcapC() const
xAOD::TrigSpacePointCounts_v1::pixelClusSizeMax
float pixelClusSizeMax() const
xAOD::TrigSpacePointCounts_v1::pixelClusTotMax
float pixelClusTotMax() const
xAOD::TrigSpacePointCounts_v1::pixelClusTotMin
float pixelClusTotMin() const
xAOD::TrigSpacePointCounts_v1::contentsPixelClusBarrel
const std::vector< float > & contentsPixelClusBarrel() const

◆ checkTrigT2MBTSBits()

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

Definition at line 1071 of file TrigDecisionChecker.cxx.

1071 {
1072
1073 const std::vector< Trig::Feature<xAOD::TrigT2MbtsBits> > vec_mbts = fc.get<xAOD::TrigT2MbtsBits>();
1074 ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::TrigT2MbtsBits> > = " << vec_mbts.size());
1075
1076 float sum;
1077 auto fun = [&sum](const std::vector<float>& vec){sum = 0.; for (const auto &i: vec) sum += i; return sum;};
1078
1079 for(const auto& mbtsfeat : vec_mbts){
1080 const xAOD::TrigT2MbtsBits *mbtsBits = mbtsfeat.cptr();
1081 if (mbtsBits){
1082 ATH_MSG_INFO(" REGTEST: SUM of triggerEnergies: " << fun(mbtsBits->triggerEnergies()) );
1083 ATH_MSG_INFO(" REGTEST: SUM of triggerTimes: " << fun(mbtsBits->triggerTimes()) );
1084 } else{
1085 ATH_MSG_INFO(" REGTEST: problems with TrigT2MBTSBits pointer" );
1086 return;
1087 }
1088 }
1089}
xAOD::TrigT2MbtsBits_v1::triggerEnergies
const std::vector< float > & triggerEnergies() const
Return the trigger energies of each counter.
xAOD::TrigT2MbtsBits_v1::triggerTimes
const std::vector< float > & triggerTimes() const
Return the relative times of the triggers.

◆ checkTrigTrackCounts()

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

Definition at line 1111 of file TrigDecisionChecker.cxx.

1111 {
1112
1113 const std::vector< Trig::Feature<xAOD::TrigTrackCounts> > vec_t = fc.get<xAOD::TrigTrackCounts>();
1114 ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::TrigTrackCounts> > = " << vec_t.size());
1115
1116 float sum;
1117 auto fun = [&sum](const std::vector<float>& vec){sum = 0.; for (const auto &i: vec) sum += i; return sum;};
1118
1119 for(const auto& tfeat : vec_t){
1120 const xAOD::TrigTrackCounts *tCounts = tfeat.cptr();
1121 if (tCounts){
1122 ATH_MSG_INFO(" REGTEST: SUM of z0_pt: " << fun(tCounts->z0_pt()) );
1123 ATH_MSG_INFO(" REGTEST: SUM of eta_phi: " << fun(tCounts->eta_phi()) );
1124
1125 ATH_MSG_INFO(" REGTEST: z0Bins: " << tCounts->z0Bins() );
1126 ATH_MSG_INFO(" REGTEST: z0Min: " << tCounts->z0Min() );
1127 ATH_MSG_INFO(" REGTEST: z0Max: " << tCounts->z0Max() );
1128 ATH_MSG_INFO(" REGTEST: ptBins: " << tCounts->ptBins() );
1129 ATH_MSG_INFO(" REGTEST: ptMin: " << tCounts->ptMin() );
1130 ATH_MSG_INFO(" REGTEST: ptMax: " << tCounts->ptMax() );
1131 ATH_MSG_INFO(" REGTEST: etaBins: " << tCounts->etaBins() );
1132 ATH_MSG_INFO(" REGTEST: etaMin: " << tCounts->etaMin() );
1133 ATH_MSG_INFO(" REGTEST: etaMax: " << tCounts->etaMax() );
1134 } else{
1135 ATH_MSG_INFO(" REGTEST: problems with TrigTrackCounts pointer" );
1136 return;
1137 }
1138 }
1139}
xAOD::TrigTrackCounts_v1::eta_phi
const std::vector< float > & eta_phi() const
xAOD::TrigTrackCounts_v1::etaMin
float etaMin() const
xAOD::TrigTrackCounts_v1::etaBins
unsigned int etaBins() const
xAOD::TrigTrackCounts_v1::z0_pt
const std::vector< float > & z0_pt() const
getters
xAOD::TrigTrackCounts_v1::ptMin
float ptMin() const
xAOD::TrigTrackCounts_v1::etaMax
float etaMax() const
xAOD::TrigTrackCounts_v1::z0Max
float z0Max() const
xAOD::TrigTrackCounts_v1::z0Min
float z0Min() const
xAOD::TrigTrackCounts_v1::ptMax
float ptMax() const
xAOD::TrigTrackCounts_v1::z0Bins
unsigned int z0Bins() const
xAOD::TrigTrackCounts_v1::ptBins
unsigned int ptBins() const

◆ checkTrigVertexCounts()

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

Definition at line 1091 of file TrigDecisionChecker.cxx.

1091 {
1092
1093 const std::vector< Trig::Feature<xAOD::TrigVertexCounts> > vec_v = fc.get<xAOD::TrigVertexCounts>();
1094 ATH_MSG_INFO("Size of vector< Trig::Feature<xAOD::TrigVertexCounts> > = " << vec_v.size());
1095
1096 auto funu = [](const std::vector<uint>& vec){uint sum = 0; for (const auto &i: vec) sum += i; return sum;};
1097 auto funf = [](const std::vector<float>& vec){float sum = 0.; for (const auto &i: vec) sum += i; return sum;};
1098
1099 for(const auto& vfeat : vec_v){
1100 const xAOD::TrigVertexCounts *vCounts = vfeat.cptr();
1101 if (vCounts){
1102 ATH_MSG_INFO(" REGTEST: SUM of vtxNtrks: " << funu(vCounts->vtxNtrks()) );
1103 ATH_MSG_INFO(" REGTEST: SUM of vtxTrkPtSqSum: " << funf(vCounts->vtxTrkPtSqSum()) );
1104 } else{
1105 ATH_MSG_INFO(" REGTEST: problems with TrigVertexCounts pointer" );
1106 return;
1107 }
1108 }
1109}
uint
unsigned int uint
Definition LArOFPhaseFill.cxx:20
xAOD::TrigVertexCounts_v1::vtxTrkPtSqSum
const std::vector< float > & vtxTrkPtSqSum() const
xAOD::TrigVertexCounts_v1::vtxNtrks
const std::vector< unsigned int > & vtxNtrks() const
getters

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< 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.

158 {
159 return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160 hndl.value(),
161 hndl.documentation());
162
163 }
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145

◆ declareProperty()

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

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
147 return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

◆ evtStore()

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

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

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

◆ execute()

StatusCode TrigDecisionChecker::execute ( )

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

Definition at line 248 of file TrigDecisionChecker.cxx.

249{
250 m_eventNumber++;
251
252 // check mu value
253 const xAOD::EventInfo* eventInfo = nullptr;
254 //#sc = evtStore()->retrieve(eventInfo, m_eventInfoName);
255 StatusCode sc;
256 if (m_eventInfoName == "") {
257 sc=evtStore()->retrieve(eventInfo);
258 } else {
259 sc=evtStore()->retrieve(eventInfo, m_eventInfoName);
260 }
261 if ( sc.isFailure() || !eventInfo )
262 {
263 ATH_MSG_INFO("Container '" << m_eventInfoName << "' could not be retrieved from StoreGate !");
264 sc = StatusCode::SUCCESS;
265 return sc;
266 } else {
267 ATH_MSG_DEBUG("Container '" << m_eventInfoName << "' retrieved from StoreGate");
268 }
269
270 if ( eventInfo ) {
271 float mu = eventInfo->actualInteractionsPerCrossing();
272 float muave = eventInfo->averageInteractionsPerCrossing();
273 msg(MSG::INFO) << "run number " << eventInfo->runNumber() << " event number " << eventInfo->eventNumber() <<
274 " lumi block " << eventInfo->lumiBlock() << endmsg;
275 msg(MSG::INFO) << "mu value " << mu << " average mu value " << muave << " event number " << m_eventNumber << endmsg;
276 m_muSum = m_muSum + eventInfo->actualInteractionsPerCrossing();
277 }
278
279
280 for(const auto& tauItem : m_TauItems) {
281 ATH_MSG_INFO("Check tau items " << tauItem);
282 sc = checkTauEDM(tauItem);
283 if ( sc.isFailure() ) {
284 msg(MSG::ERROR) << "Could not finish checkTauEDM test for chain " <<tauItem << endmsg;
285 return sc;
286 }
287 if(m_checkBits) {
288 if(checkEDM<xAOD::TauJetContainer>(tauItem).isFailure())
289 ATH_MSG_ERROR("Could not finish checkTauJetEDM test for chain " << tauItem);
290 }
291 }
292
293 for(const auto& muonItem : m_muonItems) {
294 sc = checkMuonEDM(muonItem);
295 if ( sc.isFailure() ) {
296 msg(MSG::ERROR) << "Could not finish checkMuonEDM test for chain " << muonItem << endmsg;
297 return sc;
298 }
299 if(m_checkBits) {
300 if(checkEDM<xAOD::MuonContainer>(muonItem).isFailure())
301 ATH_MSG_ERROR("Could not finish checkMuonEDM test for chain " << muonItem);
302 if(checkEDM<xAOD::L2CombinedMuonContainer>(muonItem).isFailure())
303 ATH_MSG_ERROR("Could not finish checkMuonEDM test for chain " << muonItem);
304 if(checkEDM<xAOD::L2StandAloneMuonContainer>(muonItem).isFailure())
305 ATH_MSG_ERROR("Could not finish checkMuonEDM test for chain " << muonItem);
306 }
307 }
308
309 for(const auto& bjetItem : m_bjetItems) {
310 sc = checkBjetEDM(bjetItem);
311 if ( sc.isFailure() ) {
312 msg(MSG::ERROR) << "Could not finish checkBjetEDM test for chain " << bjetItem << endmsg;
313 return sc;
314 }
315 if(m_checkBits) {
316 if(checkEDM<xAOD::BTaggingContainer>(bjetItem).isFailure())
317 ATH_MSG_ERROR("Could not finish checkBjetEDM test for chain " << bjetItem);
318 }
319 }
320
321 for(const auto& bphysItem : m_bphysItems) {
322 sc = checkBphysEDM(bphysItem);
323 if ( sc.isFailure() ) {
324 msg(MSG::ERROR) << "Could not finish checkBphysEDM test for chain " << bphysItem << endmsg;
325 // return sc; try not to return for other tests to run
326 }
327 if(m_checkBits) {
328 if(checkEDM<xAOD::TrigBphysContainer>(bphysItem).isFailure())
329 ATH_MSG_ERROR("Could not finish checkJetEDM test for chain " << bphysItem);
330 }
331 }
332
333 for(const auto& electronItem : m_electronItems) {
334 ATH_MSG_INFO("Check Electron items " << electronItem);
335 sc = checkElectronEDM(electronItem);
336 if ( sc.isFailure() ) {
337 msg(MSG::ERROR) << "Could not finish checkElectronEDM test for chain " << electronItem << endmsg;
338 }
339 if(m_checkBits) {
340 if(checkEDM<xAOD::ElectronContainer>(electronItem).isFailure())
341 ATH_MSG_ERROR("Could not finish checkElectronEDM test for chain " << electronItem);
342 if(checkEDM<xAOD::CaloClusterContainer>(electronItem).isFailure())
343 ATH_MSG_ERROR("Could not finish checkElectronEDM test for chain " << electronItem);
344 if(checkEDM<xAOD::TrigElectronContainer>(electronItem).isFailure())
345 ATH_MSG_ERROR("Could not finish checkElectronEDM test for chain " << electronItem);
346 }
347 }
348
349 for(const auto& photonItem : m_photonItems) {
350 sc = checkPhotonEDM(photonItem);
351 if ( sc.isFailure() ) {
352 ATH_MSG_ERROR("Could not finish checkPhotonEDM test for chain " << photonItem);
353 }
354 if(m_checkBits) {
355 if(checkEDM<xAOD::PhotonContainer>(photonItem).isFailure())
356 ATH_MSG_ERROR("Could not finish checkPhotonEDM test for chain " << photonItem);
357 if(checkEDM<xAOD::CaloClusterContainer>(photonItem).isFailure())
358 ATH_MSG_ERROR("Could not finish checkPhotonEDM test for chain " << photonItem);
359 }
360 }
361
362 for(const auto& minBiasItem : m_minBiasItems) {
363 sc = checkMinBiasEDM(minBiasItem);
364 if ( sc.isFailure() ) {
365 msg(MSG::ERROR) << "Could not finish checkMinBiasEDM test for chain " << minBiasItem << endmsg;
366 return sc;
367 }
368 }
369
370 ATH_MSG_INFO("REGTEST ==========START of Jet EDM/Navigation check===========");
371 for(const auto& jetItem : m_jetItems) {
372 sc = checkJetEDM(jetItem);
373 if ( sc.isFailure() ) {
374 ATH_MSG_INFO("REGTEST Could not finish checkJetEDM test for chain " << jetItem);
375 return sc;
376 }
377 if(m_checkBits) {
378 if(checkEDM<xAOD::JetContainer>(jetItem).isFailure())
379 ATH_MSG_ERROR("Could not finish checkJetEDM test for chain " << jetItem);
380 }
381 }
382 ATH_MSG_INFO("REGTEST ==========END of Jet EDM/Navigation check===========");
383
384 ATH_MSG_INFO("REGTEST ==========START of Met EDM/Navigation check===========");
385 for(const auto& metItem : m_metItems) {
386 sc = checkMetEDM(metItem);
387 if ( sc.isFailure() ) {
388 ATH_MSG_INFO("REGTEST Could not finish checkMetEDM test for chain " << metItem);
389 return sc;
390 }
391 }
392 ATH_MSG_INFO("REGTEST =========END of Met EDM/Navigation check============");
393
394 if (m_eventDecisionPrintout) {
395 msg(MSG::INFO) << "TrigDecisionChecker::execute" << endmsg;
396
397 msg(MSG::INFO) << "Pass state = " << m_trigDec->isPassed("EF_.*") << endmsg;
398 msg(MSG::INFO) << "Pass state L1 = " << m_trigDec->isPassed("L1_.*") << endmsg;
399 msg(MSG::INFO) << "Pass state L2 = " << m_trigDec->isPassed("L2_.*") << endmsg;
400 msg(MSG::INFO) << "Pass state EF = " << m_trigDec->isPassed("EF_.*") << endmsg;
401 msg(MSG::INFO) << "Pass state HLT = " << m_trigDec->isPassed("HLT_.*") << endmsg;
402 }
403
404 // L1
405 std::vector<std::string> allItems = m_trigDec->getListOfTriggers("L1_.*");
406 if (!allItems.empty()) {
407 if (m_eventDecisionPrintout) msg(MSG::INFO) << "Items : " << allItems.size() << endmsg;
408
409 for (std::vector<std::string>::const_iterator itemIt = allItems.begin();
410 itemIt != allItems.end(); ++itemIt) {
411
412 const LVL1CTP::Lvl1Item* aItem = m_trigDec->ExperimentalAndExpertMethods().getItemDetails(*itemIt);
413
414 if (!aItem) continue;
415 if (aItem->name()=="") continue;
416
417 if (m_eventDecisionPrintout) msg(MSG::INFO) << "Item " << aItem->name() << " : Item ID " << aItem->hashId() << " : " << aItem->isPassed() << endmsg;
418
419 // fill bookkeeping map with zeros if first event
420 std::string item_name = aItem->name();
421 if (m_first_event) m_L1Summary[item_name] = 0;
422
423 // increment counter for L1 summary
424 if (aItem->isPassed()) m_L1Summary[item_name] = (m_L1Summary[item_name]+1);
425 int count = (m_L1Summary.find(item_name))->second;
426 if (m_eventDecisionPrintout) msg(MSG::INFO) << "L1_map[" << item_name << "] = " << count << endmsg;
427
428
429 }
430 } else {
431 ATH_MSG_WARNING("Could not retrieve L1 Items !!");
432 }
433
434
435 // HLT Chains
436
437 // Get all configured chain names from config
438 std::vector<std::string> confChains = m_trigDec->getListOfTriggers("L2_.*, EF_.*, HLT_.*");
439 msg(MSG::INFO) << "Configuring for " << confChains.size() << " HLT chain counters" << endmsg;
440
441 // resize & initialise counters in first event
442 if (m_first_event) {
443 m_summary.resize(0); // vector for chain names
444 m_summaryPassRaw.resize(confChains.size(),0);
445 m_summaryPass.resize(confChains.size(),0);
446 m_summaryPassPhys.resize(confChains.size(),0);
447 m_summaryChainPassRaw.resize(confChains.size(),0);
448 m_summaryChainPass.resize(confChains.size(),0);
449 m_summaryChainPassPhys.resize(confChains.size(),0);
450 m_summaryChainPT.resize(confChains.size(),0);
451 m_summaryChainPS.resize(confChains.size(),0);
452 m_chainPrescales.resize(confChains.size(),0);
453 m_chainPrescalesCalculated.resize(confChains.size(),0);
454 m_chain_passthrough.resize(confChains.size(),0);
455 m_chain_passthrough_calculated.resize(confChains.size(),0);
456 m_lower_chain_accept.resize(confChains.size(),0);
457
458 // make vector of names and sort alphabetically
459 std::map<std::string,float> t_pt_map;
460 std::map<std::string,float> t_ps_map;
461
462 for(std::vector<std::string>::iterator chIter = confChains.begin(); chIter != confChains.end(); ++chIter) {
463 const TrigConf::HLTChain * ch = m_trigDec->ExperimentalAndExpertMethods().getChainConfigurationDetails(*chIter);
464 std::string name = *chIter;
465 m_summary.push_back(name);
466 t_pt_map[name] = ch->pass_through();
467 t_ps_map[name] = ch->prescale();
468 m_lowerChainMap[name] = ch->lower_chain_name();
469 ATH_MSG_DEBUG("Configured chain: " << name
470 << "; prescale=" << ch->prescale()
471 << "; passthrough=" << ch->pass_through()
472 << "; lower chain=" << ch->lower_chain_name());
473 }
474 // sort by chain names to group together L2 and EF chains: do this for
475 // first event only and use ordering in m_summary for later processing
476 std::sort(m_summary.begin(),m_summary.end());
477
478 // store prescaled factor from *configuration* chain
479 for (unsigned int k=0; k<m_summary.size(); ++k) {
480 // prescales
481 std::map<std::string,float>::iterator psIt=t_ps_map.find(m_summary[k]);
482 float ps = -1;
483 if (psIt!=t_ps_map.end()) ps = (*psIt).second;
484 m_chainPrescales[k]=ps;
485 // passthrough
486 std::map<std::string,float>::iterator ptIt=t_pt_map.find(m_summary[k]);
487 float pt = -1;
488 if (ptIt!=t_pt_map.end()) pt = (*ptIt).second;
489 m_chain_passthrough[k]=pt;
490 }
491 }
492
493 // all events: loop over names of configured chains, find their status,
494 // increment counters
495 for (unsigned int i=0; i<m_summary.size(); ++i){
496 std::string name = m_summary[i];
497 ATH_MSG_VERBOSE("Testing chain: " << name);
498
499 const HLT::Chain* aChain = m_trigDec->ExperimentalAndExpertMethods().getChainDetails(name);
500 if (! aChain) { // inactive chain
501 continue;
502 }
503
504 // use TrigDecisionTool methods directly
505 if ( m_trigDec->isPassed(name, TrigDefs::allowResurrectedDecision | TrigDefs::requireDecision) ) {
506 ATH_MSG_VERBOSE("chain: " << name << " Passed RAW");
507 ++m_summaryPassRaw[i];
508 }
509 if ( m_trigDec->isPassed(name) ) {
510 ATH_MSG_VERBOSE("chain: " << name << " Passed");
511 ++m_summaryPass[i];
512 }
513 if ( m_trigDec->isPassed(name) ) {
514 ATH_MSG_VERBOSE("chain: " << name << " Passed PHYSICS");
515 ++m_summaryPassPhys[i];
516 }
517
518
519 // Reproduce the definitions of raw, with PS, with PT, as used in monitoring:
520 // http://alxr.usatlas.bnl.gov/lxr/source/atlas/Trigger/TrigMonitoring/TrigSteerMonitor/src/TrigChainMoni.cxx#380
521 // chainPassed == (chainPassedRaw() && !aChain->isPrescaled()) || isPassedThrough
522 if (aChain->chainPassedRaw()){
523 ++m_summaryChainPassRaw[i];
524 }
525 if (aChain->chainPassedRaw() && !aChain->isPrescaled()){
526 ++m_summaryChainPS[i];
527 }
528 if (aChain->chainPassed()){
529 ++m_summaryChainPT[i];
530 }
531 if (!(aChain->isPrescaled())){ // get prescale fraction by counting events
532 ++m_chainPrescalesCalculated[i];
533 }
534 if (aChain->isPassedThrough()){ // get passthrough fraction by counting events
535 ++m_chain_passthrough_calculated[i];
536 }
537 // events accepted by the lower chain
538 std::map<std::string,std::string>::iterator lcIt=m_lowerChainMap.find(m_summary[i]);
539 if (lcIt!=m_lowerChainMap.end()) {
540 if ( !m_trigDec->getListOfTriggers((*lcIt).second).empty() &&m_trigDec->isPassed((*lcIt).second) ) {
541 ++m_lower_chain_accept[i];
542 }
543 }
544 // print info for each event
545 if (m_eventDecisionPrintout){
546 msg(MSG::INFO) << "chain " << name << " = "
547 << m_summaryChainPassRaw[i] << endmsg;
548 }
549 }
550
551 // TrigDecisionTool tests on a few specific sigs:
552 for (unsigned int i=0; i < m_countSigNames.size(); ++i) {
553 ATH_MSG_DEBUG("Monitoring " << m_countSigNames[i]);
554 if ( !m_trigDec->getListOfTriggers(m_countSigNames[i]).empty() ) {
555 if ( m_trigDec->isPassed(m_countSigNames[i]) )
556 m_runCountSigs[i] = m_runCountSigs[i]+1;
557 } else {
558 msg(MSG::WARNING) << m_countSigNames[i] << " not configured!" << endmsg;
559 }
560 }
561
562 if (m_eventNumber%m_monitoringBlockSize == 0) {
563 m_countEvent.push_back(m_eventNumber);
564
565 for (unsigned int i=0; i < m_countSigNames.size(); ++i) {
566 (m_countSigs[i])->push_back(m_runCountSigs[i]);
567 m_runCountSigs[i]=0;
568 }
569 }
570
571 // reset first event flag
572 if (m_first_event) m_first_event = false;
573
574 return StatusCode::SUCCESS;
575}
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition AthMsgStreamMacros.h:28
sc
static Double_t sc
Definition LArPhysWaveHECTool.cxx:37
HLT::Chain::chainPassed
bool chainPassed() const
Definition Chain.cxx:46
HLT::Chain::isPassedThrough
bool isPassedThrough() const
is chain passed through ?
Definition Chain.h:85
HLT::Chain::isPrescaled
bool isPrescaled() const
is chain prescaled ?
Definition Chain.h:86
HLT::Chain::chainPassedRaw
bool chainPassedRaw() const
Definition Chain.h:81
LVL1CTP::Lvl1Item::hashId
unsigned int hashId() const
Definition Lvl1Item.h:47
LVL1CTP::Lvl1Item::isPassed
bool isPassed() const
Definition Lvl1Item.h:53
LVL1CTP::Lvl1Item::name
const std::string & name() const
Definition Lvl1Item.h:46
TrigDecisionChecker::checkMuonEDM
StatusCode checkMuonEDM(const std::string &trigItem)
Definition TrigDecisionChecker.cxx:798
TrigDecisionChecker::m_summaryChainPass
std::vector< int > m_summaryChainPass
Definition TrigDecisionChecker.h:96
TrigDecisionChecker::m_jetItems
Gaudi::Property< std::vector< std::string > > m_jetItems
Definition TrigDecisionChecker.h:136
TrigDecisionChecker::m_countSigs
std::vector< std::vector< int > * > m_countSigs
Definition TrigDecisionChecker.h:108
TrigDecisionChecker::m_chainPrescalesCalculated
std::vector< float > m_chainPrescalesCalculated
Definition TrigDecisionChecker.h:143
TrigDecisionChecker::m_photonItems
Gaudi::Property< std::vector< std::string > > m_photonItems
Definition TrigDecisionChecker.h:127
TrigDecisionChecker::m_countEvent
std::vector< int > m_countEvent
Definition TrigDecisionChecker.h:106
TrigDecisionChecker::checkPhotonEDM
StatusCode checkPhotonEDM(const std::string &trigItem)
Definition TrigDecisionChecker.cxx:981
TrigDecisionChecker::checkEDM
StatusCode checkEDM(const std::string &trigItem)
Definition TrigDecisionChecker.cxx:578
TrigDecisionChecker::m_muonItems
Gaudi::Property< std::vector< std::string > > m_muonItems
Muon triggers to test output for.
Definition TrigDecisionChecker.h:116
TrigDecisionChecker::m_chain_passthrough
std::vector< float > m_chain_passthrough
Definition TrigDecisionChecker.h:144
TrigDecisionChecker::checkMetEDM
StatusCode checkMetEDM(const std::string &trigItem)
Definition TrigDecisionChecker.cxx:1193
TrigDecisionChecker::checkMinBiasEDM
StatusCode checkMinBiasEDM(const std::string &trigItem)
Definition TrigDecisionChecker.cxx:1024
TrigDecisionChecker::m_minBiasItems
Gaudi::Property< std::vector< std::string > > m_minBiasItems
Definition TrigDecisionChecker.h:133
TrigDecisionChecker::checkBphysEDM
StatusCode checkBphysEDM(const std::string &trigItem)
Bphysics EDM checker.
Definition TrigDecisionChecker.cxx:887
TrigDecisionChecker::m_bjetItems
Gaudi::Property< std::vector< std::string > > m_bjetItems
Definition TrigDecisionChecker.h:119
TrigDecisionChecker::m_summaryChainPassPhys
std::vector< int > m_summaryChainPassPhys
Definition TrigDecisionChecker.h:98
TrigDecisionChecker::m_countSigNames
Gaudi::Property< std::vector< std::string > > m_countSigNames
Definition TrigDecisionChecker.h:109
TrigDecisionChecker::m_lower_chain_accept
std::vector< int > m_lower_chain_accept
Definition TrigDecisionChecker.h:146
TrigDecisionChecker::m_bphysItems
Gaudi::Property< std::vector< std::string > > m_bphysItems
Definition TrigDecisionChecker.h:121
TrigDecisionChecker::m_summaryPassRaw
std::vector< int > m_summaryPassRaw
Definition TrigDecisionChecker.h:94
TrigDecisionChecker::m_metItems
Gaudi::Property< std::vector< std::string > > m_metItems
Definition TrigDecisionChecker.h:139
TrigDecisionChecker::m_lowerChainMap
std::map< std::string, std::string > m_lowerChainMap
Definition TrigDecisionChecker.h:147
TrigDecisionChecker::checkBjetEDM
StatusCode checkBjetEDM(const std::string &trigItem)
Definition TrigDecisionChecker.cxx:644
TrigDecisionChecker::m_runCountSigs
std::vector< int > m_runCountSigs
Definition TrigDecisionChecker.h:107
TrigDecisionChecker::m_summaryPassPhys
std::vector< int > m_summaryPassPhys
Definition TrigDecisionChecker.h:95
TrigDecisionChecker::checkElectronEDM
StatusCode checkElectronEDM(const std::string &trigItem)
Definition TrigDecisionChecker.cxx:926
TrigDecisionChecker::m_monitoringBlockSize
Gaudi::Property< int > m_monitoringBlockSize
Definition TrigDecisionChecker.h:104
TrigDecisionChecker::m_TauItems
Gaudi::Property< std::vector< std::string > > m_TauItems
Definition TrigDecisionChecker.h:130
TrigDecisionChecker::m_summary
std::vector< std::string > m_summary
Definition TrigDecisionChecker.h:92
TrigDecisionChecker::checkTauEDM
StatusCode checkTauEDM(const std::string &trigItem)
Definition TrigDecisionChecker.cxx:841
TrigDecisionChecker::m_checkBits
Gaudi::Property< bool > m_checkBits
Definition TrigDecisionChecker.h:153
TrigDecisionChecker::m_eventDecisionPrintout
Gaudi::Property< bool > m_eventDecisionPrintout
Definition TrigDecisionChecker.h:80
TrigDecisionChecker::m_chain_passthrough_calculated
std::vector< float > m_chain_passthrough_calculated
Definition TrigDecisionChecker.h:145
TrigDecisionChecker::m_summaryChainPS
std::vector< int > m_summaryChainPS
Definition TrigDecisionChecker.h:100
TrigDecisionChecker::checkJetEDM
StatusCode checkJetEDM(const std::string &trigItem)
Definition TrigDecisionChecker.cxx:1141
TrigDecisionChecker::m_electronItems
Gaudi::Property< std::vector< std::string > > m_electronItems
Bphysics chains to test.
Definition TrigDecisionChecker.h:124
TrigDecisionChecker::m_chainPrescales
std::vector< float > m_chainPrescales
Definition TrigDecisionChecker.h:142
TrigDecisionChecker::m_L1Summary
std::map< std::string, int > m_L1Summary
Definition TrigDecisionChecker.h:91
TrigDecisionChecker::m_summaryChainPassRaw
std::vector< int > m_summaryChainPassRaw
Definition TrigDecisionChecker.h:97
TrigDecisionChecker::m_summaryPass
std::vector< int > m_summaryPass
Definition TrigDecisionChecker.h:93
TrigDecisionChecker::m_summaryChainPT
std::vector< int > m_summaryChainPT
Definition TrigDecisionChecker.h:99
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
xAOD::EventInfo_v1::averageInteractionsPerCrossing
float averageInteractionsPerCrossing() const
Average interactions per crossing for all BCIDs - for out-of-time pile-up.
Definition EventInfo_v1.cxx:397
xAOD::EventInfo_v1::actualInteractionsPerCrossing
float actualInteractionsPerCrossing() const
Average interactions per crossing for the current BCID - for in-time pile-up.
Definition EventInfo_v1.cxx:380
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
count
int count(std::string s, const std::string &regx)
count how many occurances of a regx are in a string
Definition hcg.cxx:146
CaloNoise_fillDB.mu
mu
Definition CaloNoise_fillDB.py:51
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
sendEI_SPB.ch
ch
Definition sendEI_SPB.py:35
std::sort
void sort(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end)
Specialization of sort for DataVector/List.
Definition DVL_algorithms.h:554
test_pyathena.pt
pt
Definition test_pyathena.py:11
xAOD::EventInfo
EventInfo_v1 EventInfo
Definition of the latest event info version.
Definition IEventInfoCnvTool.h:18

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< 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 & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 50 of file AthAlgorithm.cxx.

51{
52 // If we didn't find any symlinks to add, just return the collection
53 // from the base class. Otherwise, return the extended collection.
54 if (!m_extendedExtraObjects.empty()) {
55 return m_extendedExtraObjects;
56 }
57 return Algorithm::extraOutputDeps();
58}
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition AthAlgorithm.h:79

◆ finalize()

StatusCode TrigDecisionChecker::finalize ( )

std Gaudi finalize method

m_lower_chain_accept[i]

m_lower_chain_accept[i]

Definition at line 137 of file TrigDecisionChecker.cxx.

138{
139
140 // print summary of trigger decisions for each level
141 msg(MSG::INFO) << "==========================================================" << endmsg;
142 msg(MSG::INFO) << "TrigDecisionTool summary:" << endmsg;
143 msg(MSG::INFO) << "==========================================================" << endmsg;
144
145 // LVL1
146 std::map<std::string,int>::iterator itL1,itL1End=m_L1Summary.end();
147 for ( itL1=m_L1Summary.begin(); itL1!=itL1End; ++itL1 ) {
148 msg(MSG::INFO) << "REGTEST item " << (*itL1).first << " accepted events=" << (*itL1).second << endmsg;
149 }
150
151 // HLT
152 for ( unsigned int i=0; i<m_summary.size(); ++i) {
153 msg(MSG::INFO) << "REGTEST chain " << m_summary[i] << " accepted events= " << m_summaryPassPhys[i]
154 <<" ( PS: " << m_summaryChainPS[i] << " , PT: " << m_summaryChainPT[i] << ")" << endmsg;
155 }
156
157 // print out nr. of events passed in blocks of N events for specific chains (configurable)
158 ATH_MSG_INFO(" ");
159 ATH_MSG_INFO("TrigDecisionTool tests: monitored chain efficiency");
160 ATH_MSG_INFO("==================================================");
161 msg(MSG::INFO) << "REGTEST Nr.events: ";
162 for (unsigned int k=0; k<m_countEvent.size();++k) {
163 msg() << m_countEvent[k] << " ";
164 }
165 msg() << endmsg;
166 for (unsigned int i=0; i<m_countSigNames.size();++i) {
167 msg(MSG::INFO) << "REGTEST " << m_countSigNames[i] << " : ";
168 for (unsigned int j=0; j<(m_countSigs[i])->size();++j) {
169 msg() << (*m_countSigs[i])[j] << " ";
170 }
171 msg() << endmsg;
172 }
173
174 // compare prescale and passthrough fractions from configuration and by counting events
175 ATH_MSG_INFO(" ");
176 ATH_MSG_INFO("TrigDecisionTool tests: chain prescale/passthrough ");
177 ATH_MSG_INFO("==================================================");
178 // HLT
179 msg(MSG::INFO) << "REGTEST Chain (passed raw) PS(conf) PS(counts) PT(conf) PT(counts) (Lower chain)";
180 for ( unsigned int i=0; i<m_summary.size(); ++i) {
181 if (m_lower_chain_accept[i]!=0) {
182 msg(MSG::INFO) << "REGTEST " << m_summary[i] << " (" << m_summaryChainPT[i] << ") \t"
183 << " \t" << m_chainPrescales[i] << " \t" << m_chainPrescalesCalculated[i]
184 << " \t" << m_chain_passthrough[i] << " \t" << m_chain_passthrough_calculated[i]
185 << " (" << m_lower_chain_accept[i] << ")" << endmsg;
186 } else {
187 msg(MSG::INFO) << "REGTEST " << m_summary[i] << " (" << m_summaryChainPT[i] << ") \t"
188 << " \t" << m_chainPrescales[i] << " --- "
189 << " \t" << m_chain_passthrough[i] << " --- "
190 << " (lower chain passed no events)" << endmsg;
191 }
192 }
193 ATH_MSG_INFO("REGTEST ran on " << m_eventNumber << " events");
194 ATH_MSG_INFO("Average mu value " << m_muSum/float(m_eventNumber));
195
196 // open output file and write out counts
197 if (not m_printoutFileName.empty()) {
198 ATH_MSG_INFO("==================================================");
199 ATH_MSG_INFO("Opening " << m_printoutFileName << " for writing trigger counts");
200 std::ofstream printoutFile(m_printoutFileName);
201
202 /*
203 m_L1Summary - isPassed for L[1
204 m_summaryChainPassRaw - chainPassedRaw for HLT
205 m_summaryPass - chain Passed for HLT
206 m_summaryPassPhys - chain Physics Passed for HLT
207 m_summaryChainPS - chainPassedRaw && !isPrescaled for HLT
208 m_summaryChainPT - (chainPassedRaw && !isPrescaled) || isPassedThrough for HLT
209 */
210
211 printoutFile << std::setiosflags(std::ios::left) << std::setw(25) << "* L1 item"
212 << std::setw(15) << " #Passed " << std::endl;
213 std::map<std::string,int>::iterator l1,l1End=m_L1Summary.end();
214 for ( l1=m_L1Summary.begin(); l1!=l1End; ++l1 ) {
215 printoutFile << std::setiosflags(std::ios::left) << (*l1).first
216 << std::setw(10) << (*l1).second << std::endl;
217 }
218
219 printoutFile << std::setiosflags(std::ios::left) << std::setw(25) << "* Chain name"
220 << std::setw(15) << " #Passed Raw "
221 << std::setw(15) << " #passed "
222 << std::setw(15) << " #Physics Passed "<< std::endl;
223 for ( unsigned int i=0; i<m_summary.size(); ++i) {
224 printoutFile << std::setiosflags(std::ios::left) << std::setw(25) << m_summary[i]
225 << std::setw(15) << m_summaryPassRaw[i]
226 << std::setw(15) << m_summaryPass[i]
227 << std::setw(15) << m_summaryPassPhys[i] << std::endl;
228
229 // std::cout << std::setiosflags(std::ios::dec) << std::setw(6) << i << "|"
230 // << std::setiosflags(std::ios::dec) << std::setw(4) << (*(m_elink_vec[i]))->algorithmId() << "|"
231 // << std::setw(11) << *(m_elink_vec[i]) << "|";
232 }
233 ATH_MSG_INFO("Closing output file " << m_printoutFileName);
234 printoutFile.close();
235 }
236
237 // cleanup newed vectors
238 ATH_MSG_INFO("==================================================");
239 ATH_MSG_INFO("Cleaning up counters...");
240 for (unsigned int i=0; i<m_countSigs.size(); ++i) {
241 delete m_countSigs[i];
242 }
243 ATH_MSG_INFO("Finalised successfully");
244
245 return StatusCode::SUCCESS;
246}
TrigDecisionChecker::m_printoutFileName
Gaudi::Property< std::string > m_printoutFileName
Definition TrigDecisionChecker.h:83

◆ initialize()

StatusCode TrigDecisionChecker::initialize ( )

std Gaudi initialize method

Definition at line 85 of file TrigDecisionChecker.cxx.

86{
87 // reset event counters
88 m_first_event=true;
89 m_eventNumber=0;
90 m_muSum=0.0;
91
92 // Reset keys
93
94 // print out properties
95 ATH_MSG_INFO("Initializing...");
96 ATH_MSG_INFO("MonitoredChains: " << m_countSigNames);
97 //ATH_MSG_INFO("MonitoredTauItem: " << m_tauItem);
98 ATH_MSG_INFO("MonitoringBlock: " << m_monitoringBlockSize);
99 if (not m_printoutFileName.empty()) {
100 ATH_MSG_INFO("PrintOutFilename: " << m_printoutFileName);
101 }
102
103 // get handle to TrigDecisionTool
104 ATH_CHECK(m_trigDec.retrieve());
105
106 // reserve space for vectors
107 m_summary.reserve(700);
108 m_summaryChainPassRaw.reserve(700);
109 m_summaryChainPassRaw.reserve(700);
110 m_summaryChainPT.reserve(700);
111 m_summaryChainPS.reserve(700);
112 m_summaryPassRaw.reserve(700);
113 m_summaryPass.reserve(700);
114 m_summaryPassPhys.reserve(700);
115 m_chainPrescales.reserve(700);
116 m_chainPrescalesCalculated.reserve(700);
117 m_chain_passthrough.reserve(700);
118 m_chain_passthrough_calculated.reserve(700);
119 m_lower_chain_accept.reserve(700);
120
121 // initialize vectors for chains to monitor
122 ATH_MSG_INFO("Monitoring number of events passing these chains (blocks of "
123 << m_monitoringBlockSize << " events):");
124 for (unsigned int i=0; i < m_countSigNames.size(); ++i) {
125 ATH_MSG_INFO("Initializing monitoring counters for " << m_countSigNames[i]);
126 m_countSigs.push_back(new std::vector<int>());
127 m_runCountSigs.push_back(0);
128 }
129
130
131 ATH_MSG_INFO("Initialization successful");
132
133 return StatusCode::SUCCESS;
134}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< 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.

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

24 {
25 return this->msgStream();
26 }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30 {
31 return this->msgLevel(lvl);
32 }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< 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< Algorithm > >::renounce ( T & h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381 {
382 h.renounce();
383 PBASE::renounce (h);
384 }
AthCommonDataStore::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 > renounce(T &h)
Definition AthCommonDataStore.h:380

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364 {
365 handlesArray.renounce();
366 }

◆ sysInitialize()

StatusCode AthAlgorithm::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< Algorithm > >.

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

Definition at line 66 of file AthAlgorithm.cxx.

66 {
67 StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68
69 if (sc.isFailure()) {
70 return sc;
71 }
72 ServiceHandle<ICondSvc> cs("CondSvc",name());
73 for (auto h : outputHandles()) {
74 if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75 // do this inside the loop so we don't create the CondSvc until needed
76 if ( cs.retrieve().isFailure() ) {
77 ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78 return StatusCode::SUCCESS;
79 }
80 if (cs->regHandle(this,*h).isFailure()) {
81 sc = StatusCode::FAILURE;
82 ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83 << " with CondSvc");
84 }
85 }
86 }
87 return sc;
88}
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition AthAlgorithm.cxx:66
AthCommonDataStore< AthCommonMsg< Algorithm > >::AthCommonDataStore
AthCommonDataStore(const std::string &name, T... args)
Definition AthCommonDataStore.h:55
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< 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< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308 {
309 // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310 // << " size: " << m_vhka.size() << endmsg;
311 for (auto &a : m_vhka) {
312 std::vector<SG::VarHandleKey*> keys = a->keys();
313 for (auto k : keys) {
314 k->setOwner(this);
315 }
316 }
317 }
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition AthCommonDataStore.h:398

Member Data Documentation

◆ m_bjetItems

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

Definition at line 119 of file TrigDecisionChecker.h.

119{ this, "BjetItems", {} };

◆ m_bphysItems

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

Definition at line 121 of file TrigDecisionChecker.h.

121{ this, "BphysicsItems", {} };

◆ m_chain_passthrough

std::vector<float> TrigDecisionChecker::m_chain_passthrough
private

Definition at line 144 of file TrigDecisionChecker.h.

◆ m_chain_passthrough_calculated

std::vector<float> TrigDecisionChecker::m_chain_passthrough_calculated
private

Definition at line 145 of file TrigDecisionChecker.h.

◆ m_chainPrescales

std::vector<float> TrigDecisionChecker::m_chainPrescales
private

Definition at line 142 of file TrigDecisionChecker.h.

◆ m_chainPrescalesCalculated

std::vector<float> TrigDecisionChecker::m_chainPrescalesCalculated
private

Definition at line 143 of file TrigDecisionChecker.h.

◆ m_checkBits

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

Definition at line 153 of file TrigDecisionChecker.h.

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

◆ m_countEvent

std::vector<int> TrigDecisionChecker::m_countEvent
private

Definition at line 106 of file TrigDecisionChecker.h.

◆ m_countSigNames

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

Definition at line 109 of file TrigDecisionChecker.h.

109{ this, "MonitoredChains", {} };

◆ m_countSigs

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

Definition at line 108 of file TrigDecisionChecker.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< 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 124 of file TrigDecisionChecker.h.

124{ this, "ElectronItems", {} };

◆ m_eventDecisionPrintout

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

Definition at line 80 of file TrigDecisionChecker.h.

80{this, "WriteEventDecision", true};

◆ m_eventInfoName

std::string TrigDecisionChecker::m_eventInfoName
private

Definition at line 150 of file TrigDecisionChecker.h.

◆ m_eventNumber

int TrigDecisionChecker::m_eventNumber = 0
private

Definition at line 110 of file TrigDecisionChecker.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_first_event

bool TrigDecisionChecker::m_first_event
private

Definition at line 101 of file TrigDecisionChecker.h.

◆ m_jetItems

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

Definition at line 136 of file TrigDecisionChecker.h.

136{ this, "JetItems", {} };

◆ m_L1Summary

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

Definition at line 91 of file TrigDecisionChecker.h.

◆ m_lower_chain_accept

std::vector<int> TrigDecisionChecker::m_lower_chain_accept
private

Definition at line 146 of file TrigDecisionChecker.h.

◆ m_lowerChainMap

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

Definition at line 147 of file TrigDecisionChecker.h.

◆ m_metItems

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

Definition at line 139 of file TrigDecisionChecker.h.

139{ this, "MetItems", {} };

◆ m_minBiasItems

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

Definition at line 133 of file TrigDecisionChecker.h.

133{ this, "MinBiasItems", {} };

◆ m_monitoringBlockSize

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

Definition at line 104 of file TrigDecisionChecker.h.

104{ 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 116 of file TrigDecisionChecker.h.

116{ this, "MuonItems", {} };

◆ m_muSum

float TrigDecisionChecker::m_muSum = 0
private

Definition at line 111 of file TrigDecisionChecker.h.

◆ m_photonItems

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

Definition at line 127 of file TrigDecisionChecker.h.

127{ 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.

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

◆ m_runCountSigs

std::vector<int> TrigDecisionChecker::m_runCountSigs
private

Definition at line 107 of file TrigDecisionChecker.h.

◆ m_summary

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

Definition at line 92 of file TrigDecisionChecker.h.

◆ m_summaryChainPass

std::vector<int> TrigDecisionChecker::m_summaryChainPass
private

Definition at line 96 of file TrigDecisionChecker.h.

◆ m_summaryChainPassPhys

std::vector<int> TrigDecisionChecker::m_summaryChainPassPhys
private

Definition at line 98 of file TrigDecisionChecker.h.

◆ m_summaryChainPassRaw

std::vector<int> TrigDecisionChecker::m_summaryChainPassRaw
private

Definition at line 97 of file TrigDecisionChecker.h.

◆ m_summaryChainPS

std::vector<int> TrigDecisionChecker::m_summaryChainPS
private

Definition at line 100 of file TrigDecisionChecker.h.

◆ m_summaryChainPT

std::vector<int> TrigDecisionChecker::m_summaryChainPT
private

Definition at line 99 of file TrigDecisionChecker.h.

◆ m_summaryPass

std::vector<int> TrigDecisionChecker::m_summaryPass
private

Definition at line 93 of file TrigDecisionChecker.h.

◆ m_summaryPassPhys

std::vector<int> TrigDecisionChecker::m_summaryPassPhys
private

Definition at line 95 of file TrigDecisionChecker.h.

◆ m_summaryPassRaw

std::vector<int> TrigDecisionChecker::m_summaryPassRaw
private

Definition at line 94 of file TrigDecisionChecker.h.

◆ m_TauItems

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

Definition at line 130 of file TrigDecisionChecker.h.

130{ 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 113 of file TrigDecisionChecker.h.

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

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0