ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
TrigDecisionChecker Class Reference

#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 More...
 
 ~TrigDecisionChecker ()
 std deconstructor More...
 
StatusCode initialize ()
 std Gaudi initialize method More...
 
StatusCode execute ()
 std Gaudi execute method -> use TrigDecisionTool to 'look' at the trigger data More...
 
StatusCode finalize ()
 std Gaudi finalize method More...
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
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. More...
 

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. More...
 
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 > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

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 More...
 
Gaudi::Property< std::vector< std::string > > m_muonItems { this, "MuonItems", {} }
 Muon triggers to test output for. More...
 
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. More...
 
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) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
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 }

◆ ~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

◆ 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

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  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  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  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  }

◆ 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() [1/2]

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

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ 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  }

◆ 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, PyAthena::Alg, and AthHistogramAlgorithm.

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 }

◆ 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  }

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.

◆ m_bphysItems

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

Definition at line 121 of file TrigDecisionChecker.h.

◆ 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.

◆ 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.

◆ 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.

◆ m_eventDecisionPrintout

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

Definition at line 80 of file TrigDecisionChecker.h.

◆ 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.

◆ 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.

◆ m_minBiasItems

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

Definition at line 133 of file TrigDecisionChecker.h.

◆ m_monitoringBlockSize

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

Definition at line 104 of file TrigDecisionChecker.h.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
xAOD::TrigSpacePointCounts_v1::pixelClusSizeBins
unsigned int pixelClusSizeBins() const
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
xAOD::TrigSpacePointCounts_v1::contentsPixelClusEndcapC
const std::vector< float > & contentsPixelClusEndcapC() const
getters
xAOD::TrigMissingET_v1::sumEt
float sumEt() const
Get the sum of the ET of the missing energy.
python.BuildSignatureFlags.bjet
AthConfigFlags bjet(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:335
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
generateReferenceFile.fun
fun
Definition: generateReferenceFile.py:18
xAOD::TrigSpacePointCounts_v1::sctSpBarrel
unsigned int sctSpBarrel() const
xAOD::TrigTrackCounts_v1
Definition: TrigTrackCounts_v1.h:12
xAOD::TrigSpacePointCounts_v1::pixelClusTotBins
unsigned int pixelClusTotBins() const
TrigDecisionChecker::m_jetItems
Gaudi::Property< std::vector< std::string > > m_jetItems
Definition: TrigDecisionChecker.h:136
xAOD::TrigPassBits_v1::isPassing
bool isPassing(const OBJ *obj, const CONT *container) const
Check if an element of a container is passing/failing.
TrigDecisionChecker::m_chain_passthrough
std::vector< float > m_chain_passthrough
Definition: TrigDecisionChecker.h:144
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
TrigDecisionChecker::checkTrigSpacePointCounts
void checkTrigSpacePointCounts(const Trig::FeatureContainer &fc)
Definition: TrigDecisionChecker.cxx:1040
xAOD::TrigVertexCounts_v1::vtxTrkPtSqSum
const std::vector< float > & vtxTrkPtSqSum() const
TrigDecisionChecker::m_countEvent
std::vector< int > m_countEvent
Definition: TrigDecisionChecker.h:106
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
TrigDecisionChecker::checkTrigT2MBTSBits
void checkTrigT2MBTSBits(const Trig::FeatureContainer &fc)
Definition: TrigDecisionChecker.cxx:1071
xAOD::TrigTrackCounts_v1::ptBins
unsigned int ptBins() const
TrigDecisionChecker::m_monitoringBlockSize
Gaudi::Property< int > m_monitoringBlockSize
Definition: TrigDecisionChecker.h:104
LVL1CTP::Lvl1Item::isPassed
bool isPassed() const
Definition: Lvl1Item.h:53
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
ParticleTest.eg
eg
Definition: ParticleTest.py:29
xAOD::TrigTrackCounts_v1::z0Max
float z0Max() const
TrigDecisionChecker::m_eventDecisionPrintout
Gaudi::Property< bool > m_eventDecisionPrintout
Definition: TrigDecisionChecker.h:80
TrigDecisionChecker::checkMetEDM
StatusCode checkMetEDM(const std::string &trigItem)
Definition: TrigDecisionChecker.cxx:1193
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TrigDecisionChecker::m_chain_passthrough_calculated
std::vector< float > m_chain_passthrough_calculated
Definition: TrigDecisionChecker.h:145
PlotCalibFromCool.label
label
Definition: PlotCalibFromCool.py:78
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
TrigDecisionChecker::checkMinBiasEDM
StatusCode checkMinBiasEDM(const std::string &trigItem)
Definition: TrigDecisionChecker.cxx:1024
xAOD::JetConstituentVector::end
iterator end() const
iterator after the last constituent
Definition: JetConstituentVector.cxx:104
TrigDecisionChecker::checkElectronEDM
StatusCode checkElectronEDM(const std::string &trigItem)
Definition: TrigDecisionChecker.cxx:926
TrigDecisionChecker::m_countSigs
std::vector< std::vector< int > * > m_countSigs
Definition: TrigDecisionChecker.h:108
xAOD::TrigTrackCounts_v1::z0Bins
unsigned int z0Bins() const
TrigPassBits::size
unsigned int size() const
gets size of the bits array
Definition: Trigger/TrigEvent/TrigSteeringEvent/TrigSteeringEvent/TrigPassBits.h:44
test_pyathena.pt
pt
Definition: test_pyathena.py:11
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
xAOD::TrigTrackCounts_v1::etaBins
unsigned int etaBins() const
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
xAOD::TrigMissingET_v1::ex
float ex() const
Get the x component of the missing energy.
xAOD::TrigSpacePointCounts_v1::sctSpEndcapA
unsigned int sctSpEndcapA() const
xAOD::TrigVertexCounts_v1::vtxNtrks
const std::vector< unsigned int > & vtxNtrks() const
getters
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:259
TrigDecisionChecker::m_summaryPassRaw
std::vector< int > m_summaryPassRaw
Definition: TrigDecisionChecker.h:94
TrigDecisionChecker::m_summaryChainPassRaw
std::vector< int > m_summaryChainPassRaw
Definition: TrigDecisionChecker.h:97
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:12
HLT::Chain::isPrescaled
bool isPrescaled() const
is chain prescaled ?
Definition: Chain.h:86
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
TrigConf::HLTChain
HLT chain configuration information.
Definition: TrigConfHLTData/TrigConfHLTData/HLTChain.h:35
TrigDecisionChecker::m_chainPrescalesCalculated
std::vector< float > m_chainPrescalesCalculated
Definition: TrigDecisionChecker.h:143
xAOD::TrigTrackCounts_v1::etaMin
float etaMin() const
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
TrigDecisionChecker::m_bphysItems
Gaudi::Property< std::vector< std::string > > m_bphysItems
Definition: TrigDecisionChecker.h:121
HLT::Chain::chainPassed
bool chainPassed() const
Definition: Chain.cxx:46
LVL1CTP::Lvl1Item::name
std::string name() const
Definition: Lvl1Item.h:46
TrigDecisionChecker::m_checkBits
Gaudi::Property< bool > m_checkBits
Definition: TrigDecisionChecker.h:153
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TrigDecisionChecker::m_electronItems
Gaudi::Property< std::vector< std::string > > m_electronItems
Bphysics chains to test.
Definition: TrigDecisionChecker.h:124
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
TrigDecisionChecker::checkBjetEDM
StatusCode checkBjetEDM(const std::string &trigItem)
Definition: TrigDecisionChecker.cxx:644
Trig::FeatureContainer
Definition: FeatureContainer.h:54
TrigDecisionChecker::m_minBiasItems
Gaudi::Property< std::vector< std::string > > m_minBiasItems
Definition: TrigDecisionChecker.h:133
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
CxxUtils::vec
typename vecDetail::vec_typedef< T, N >::type vec
Define a nice alias for the vectorized type.
Definition: vec.h:207
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
uint
unsigned int uint
Definition: LArOFPhaseFill.cxx:20
TrigDecisionChecker::checkJetEDM
StatusCode checkJetEDM(const std::string &trigItem)
Definition: TrigDecisionChecker.cxx:1141
xAOD::JetConstituentVector::begin
iterator begin() const
iterator on the first constituent
Definition: JetConstituentVector.cxx:103
LVL1CTP::Lvl1Item
Definition: Lvl1Item.h:37
TrigDecisionChecker::checkMuonEDM
StatusCode checkMuonEDM(const std::string &trigItem)
Definition: TrigDecisionChecker.cxx:798
AthCommonDataStore
Definition: AthCommonDataStore.h:52
TrigDecisionChecker::m_summaryChainPT
std::vector< int > m_summaryChainPT
Definition: TrigDecisionChecker.h:99
TrigDecisionChecker::m_lowerChainMap
std::map< std::string, std::string > m_lowerChainMap
Definition: TrigDecisionChecker.h:147
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
TrigDecisionChecker::m_summaryPass
std::vector< int > m_summaryPass
Definition: TrigDecisionChecker.h:93
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::TrigSpacePointCounts_v1::contentsPixelClusEndcapA
const std::vector< float > & contentsPixelClusEndcapA() const
convertTimingResiduals.sum
sum
Definition: convertTimingResiduals.py:55
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
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
TrigDecisionChecker::m_summaryPassPhys
std::vector< int > m_summaryPassPhys
Definition: TrigDecisionChecker.h:95
lumiFormat.i
int i
Definition: lumiFormat.py:92
z
#define z
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Trig::Combination
Definition: Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/Combination.h:55
xAOD::TrigT2MbtsBits_v1
Definition: TrigT2MbtsBits_v1.h:14
TrigDecisionChecker::m_summaryChainPS
std::vector< int > m_summaryChainPS
Definition: TrigDecisionChecker.h:100
TrigDecisionChecker::m_summary
std::vector< std::string > m_summary
Definition: TrigDecisionChecker.h:92
xAOD::TrigPassBits_v1::size
uint32_t size() const
The size of the target container.
xAOD::TrigPassBits_v1
Type describing which elements in a container passed a trigger chain.
Definition: TrigPassBits_v1.h:38
xAOD::TrigVertexCounts_v1
Definition: TrigVertexCounts_v1.h:12
ClassID_traits
Default, invalid implementation of ClassID_traits.
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:40
xAOD::TrigSpacePointCounts_v1::pixelClusSizeMin
float pixelClusSizeMin() const
TrigDecisionChecker::m_runCountSigs
std::vector< int > m_runCountSigs
Definition: TrigDecisionChecker.h:107
DataVector::front
const T * front() const
Access the first element in the collection as an rvalue.
TrigDecisionChecker::m_lower_chain_accept
std::vector< int > m_lower_chain_accept
Definition: TrigDecisionChecker.h:146
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TrigDecisionChecker::checkBphysEDM
StatusCode checkBphysEDM(const std::string &trigItem)
Bphysics EDM checker.
Definition: TrigDecisionChecker.cxx:887
TrigDecisionChecker::checkPhotonEDM
StatusCode checkPhotonEDM(const std::string &trigItem)
Definition: TrigDecisionChecker.cxx:981
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
TrigDecisionChecker::checkTrigTrackCounts
void checkTrigTrackCounts(const Trig::FeatureContainer &fc)
Definition: TrigDecisionChecker.cxx:1111
xAOD::TrigTrackCounts_v1::etaMax
float etaMax() const
xAOD::TrigMissingET_v1::sumE
float sumE() const
Get the sum of the E of the missing energy.
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
HLT::Chain
Definition: Chain.h:64
xAOD::TrigTrackCounts_v1::z0_pt
const std::vector< float > & z0_pt() const
getters
TrigDecisionChecker::m_chainPrescales
std::vector< float > m_chainPrescales
Definition: TrigDecisionChecker.h:142
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
TrigDecisionChecker::m_summaryChainPassPhys
std::vector< int > m_summaryChainPassPhys
Definition: TrigDecisionChecker.h:98
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
TrigDecisionChecker::checkTauEDM
StatusCode checkTauEDM(const std::string &trigItem)
Definition: TrigDecisionChecker.cxx:841
xAOD::numberOfNextToInnermostPixelLayerHits
@ numberOfNextToInnermostPixelLayerHits
these are the hits in the 1st pixel barrel layer
Definition: TrackingPrimitives.h:248
TrigDecisionChecker::checkTrigVertexCounts
void checkTrigVertexCounts(const Trig::FeatureContainer &fc)
Definition: TrigDecisionChecker.cxx:1091
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
TrigDecisionChecker::m_bjetItems
Gaudi::Property< std::vector< std::string > > m_bjetItems
Definition: TrigDecisionChecker.h:119
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
xAOD::TrigTrackCounts_v1::ptMin
float ptMin() const
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
TrigDecisionChecker::m_TauItems
Gaudi::Property< std::vector< std::string > > m_TauItems
Definition: TrigDecisionChecker.h:130
TrigPassBits
Definition: Trigger/TrigEvent/TrigSteeringEvent/TrigSteeringEvent/TrigPassBits.h:17
xAOD::EgammaParameters::deltaPhi2
@ deltaPhi2
difference between the cluster phi (second sampling) and the phi of the track extrapolated to the sec...
Definition: EgammaEnums.h:204
xAOD::CaloCluster_v1::PHICALOFRAME
@ PHICALOFRAME
Phi in the calo frame (for egamma)
Definition: CaloCluster_v1.h:188
xAOD::TrigTrackCounts_v1::z0Min
float z0Min() const
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
TrigDecisionChecker::m_eventInfoName
std::string m_eventInfoName
Definition: TrigDecisionChecker.h:150
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
a
TList * a
Definition: liststreamerinfos.cxx:10
h
TrigDecisionChecker::m_muSum
float m_muSum
Definition: TrigDecisionChecker.h:111
xAOD::TrigSpacePointCounts_v1::sctSpEndcapC
unsigned int sctSpEndcapC() const
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
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
xAOD::TrigMissingET_v1
Class holding the Missing ET trigger fex results.
Definition: TrigMissingET_v1.h:32
TrigDecisionChecker::m_countSigNames
Gaudi::Property< std::vector< std::string > > m_countSigNames
Definition: TrigDecisionChecker.h:109
xAOD::TrigSpacePointCounts_v1
Definition: TrigSpacePointCounts_v1.h:12
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
xAOD::TrigMissingET_v1::ey
float ey() const
Get the y component of the missing energy.
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
TrigDecisionChecker::m_metItems
Gaudi::Property< std::vector< std::string > > m_metItems
Definition: TrigDecisionChecker.h:139
TrigDecisionChecker::m_muonItems
Gaudi::Property< std::vector< std::string > > m_muonItems
Muon triggers to test output for.
Definition: TrigDecisionChecker.h:116
xAOD::TrigSpacePointCounts_v1::pixelClusTotMin
float pixelClusTotMin() const
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
xAOD::TrigMissingET_v1::ez
float ez() const
Get the z component of the missing energy.
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
TrigDecisionChecker::m_printoutFileName
Gaudi::Property< std::string > m_printoutFileName
Definition: TrigDecisionChecker.h:83
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
xAOD::JetConstituentVector::iterator
Definition: JetConstituentVector.h:121
TrigDecisionChecker::m_first_event
bool m_first_event
Definition: TrigDecisionChecker.h:101
LVL1CTP::Lvl1Item::hashId
unsigned int hashId() const
Definition: Lvl1Item.h:47
Trig::FeatureContainer::getCombinations
const std::vector< Trig::Combination > & getCombinations() const
gives back reference to combinations collected through append
Definition: FeatureContainer.h:135
xAOD::TrigMissingET_v1::getNumberOfComponents
unsigned int getNumberOfComponents() const
Get the number of components.
Definition: TrigMissingET_v1.cxx:103
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
xAOD::TrigSpacePointCounts_v1::pixelClusSizeMax
float pixelClusSizeMax() const
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
skel.l1
l1
Definition: skel.GENtoEVGEN.py:425
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:805
TrigDecisionChecker::m_photonItems
Gaudi::Property< std::vector< std::string > > m_photonItems
Definition: TrigDecisionChecker.h:127
xAOD::EgammaParameters::deltaEta1
@ deltaEta1
difference between the cluster eta (first sampling) and the eta of the track extrapolated to the firs...
Definition: EgammaEnums.h:184
TrigDecisionChecker::m_trigDec
ToolHandle< Trig::TrigDecisionTool > m_trigDec
interface to use the trigger data: TriggerTool
Definition: TrigDecisionChecker.h:113
xAOD::TrigT2MbtsBits_v1::triggerTimes
const std::vector< float > & triggerTimes() const
Return the relative times of the triggers.
xAOD::CaloCluster_v1::ETACALOFRAME
@ ETACALOFRAME
Eta in the calo frame (for egamma)
Definition: CaloCluster_v1.h:187
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
TrigDecisionChecker::m_summaryChainPass
std::vector< int > m_summaryChainPass
Definition: TrigDecisionChecker.h:96
xAOD::TrigSpacePointCounts_v1::pixelClusTotMax
float pixelClusTotMax() const
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
TrigDecisionChecker::m_eventNumber
int m_eventNumber
Definition: TrigDecisionChecker.h:110
xAOD::TrigT2MbtsBits_v1::triggerEnergies
const std::vector< float > & triggerEnergies() const
Return the trigger energies of each counter.
HLT::Chain::chainPassedRaw
bool chainPassedRaw() const
Definition: Chain.h:81
xAOD::TrigTrackCounts_v1::eta_phi
const std::vector< float > & eta_phi() const
TrigDecisionChecker::m_L1Summary
std::map< std::string, int > m_L1Summary
Definition: TrigDecisionChecker.h:91
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
HLT::Chain::isPassedThrough
bool isPassedThrough() const
is chain passed through ?
Definition: Chain.h:85
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
xAOD::TrigSpacePointCounts_v1::contentsPixelClusBarrel
const std::vector< float > & contentsPixelClusBarrel() const
fitman.k
k
Definition: fitman.py:528
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition: TrackingPrimitives.h:237
xAOD::TrigTrackCounts_v1::ptMax
float ptMax() const
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
ServiceHandle< ICondSvc >
Generated on Tue Jul 2 2024 22:04:29 for ATLAS Offline Software by   doxygen 1.8.18