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

Implements Hypo selection on triggering displaced vertex. More...

#include <TrigHitDVHypoAlg.h>

Inheritance diagram for TrigHitDVHypoAlg:
Collaboration diagram for TrigHitDVHypoAlg:

Classes

struct  TMVAReader
 

Public Member Functions

 TrigHitDVHypoAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual StatusCode initialize () override
 
virtual StatusCode execute (const EventContext &context) const override
 
virtual StatusCode sysInitialize () override
 initialise this base class More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 
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
 

Static Public Member Functions

static StatusCode runtimeValidation (SG::WriteHandle< TrigCompositeUtils::DecisionContainer > &outputHandle, MsgStream &msg, bool onlyValidateOneStep=true, bool runTwoConversion=false)
 Executes all individual runtime tests. More...
 

Protected Member Functions

const SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > & decisionInput () const
 methods for derived classes to access handles of the base class input other read/write handles may be implemented by derived classes More...
 
const SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer > & decisionOutput () const
 methods for derived classes to access handles of the base class output other read/write handles may be implemented by derived classes
More...
 
StatusCode hypoBaseOutputProcessing (SG::WriteHandle< TrigCompositeUtils::DecisionContainer > &outputHandle, MSG::Level lvl=MSG::DEBUG) const
 Base class function to be called once slice specific code has finished. Handles debug printing and validation. More...
 
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

using SeedType = TrigHitDVHypoTool::SeedType
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode doMonitor (const xAOD::TrigCompositeContainer *) const
 
float deltaR2 (float, float, float, float) const
 
int getSPLayer (int, float) const
 
StatusCode findSPSeeds (const EventContext &, const std::vector< HitDVSpacePoint > &, std::vector< float > &, std::vector< float > &) const
 
StatusCode findJetSeeds (const xAOD::JetContainer *, const float, const float, std::vector< float > &, std::vector< float > &, std::vector< float > &) const
 
StatusCode selectSeedsNearby (const std::vector< HitDVSeed > &hitDVSeedsContainer, std::vector< float > &jetSeeds_eta, std::vector< float > &jetSeeds_phi, std::vector< float > &jetSeeds_pt) const
 
StatusCode calculateBDT (const EventContext &, const std::vector< HitDVSpacePoint > &, const std::vector< HitDVTrk > &, const std::vector< float > &, const std::vector< float > &, const std::vector< float > &, const float &, const int, xAOD::TrigCompositeContainer *, int &) const
 
StatusCode findSPSeeds (const EventContext &ctx, const std::vector< float > &v_sp_eta, const std::vector< float > &v_sp_phi, const std::vector< int > &v_sp_layer, const std::vector< int > &v_sp_usedTrkId, std::vector< float > &seeds_eta, std::vector< float > &seeds_phi) const
 
StatusCode findHitDV (const EventContext &ctx, const std::vector< TrigSiSpacePointBase > &convertedSpacePoints, const DataVector< Trk::Track > &tracks, std::vector< HitDVSeed > &hitDVSeedsContainer, std::vector< HitDVTrk > &hitDVTrksContainer, std::vector< HitDVSpacePoint > &hitDVSPContainer) const
 
StatusCode printDebugInformation (SG::WriteHandle< TrigCompositeUtils::DecisionContainer > &outputHandle, MSG::Level lvl) const
 Common base function to print information on chains passed by objects considered in the hypo. More...
 
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

ToolHandle< ITrigSpacePointConversionTool > m_spacePointTool {this, "SpacePointProviderTool", "TrigSpacePointConversionTool"}
 
ToolHandleArray< TrigHitDVHypoTool > m_hypoTools {this, "HypoTools", {}, "Tools to perform selection"}
 
SG::ReadHandleKey< xAOD::JetContainer > m_jetsKey {this, "Jets", "HLT_AntiKt4EMTopoJets_subjesIS", ""}
 
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_hitDVKey {this, "HitDV", "HLT_HitDV", ""}
 
SG::ReadHandleKey< TrackCollection > m_tracksKey {this, "HitDVTracks", "HLT_IDTrkTrack_FS_FTF", ""}
 
ToolHandle< ILumiBlockMuTool > m_lumiBlockMuTool
 
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey {this, "LuminosityCondDataKey", "LuminosityCondData", ""}
 
Gaudi::Property< bool > m_isMC {this, "isMC", false, "Real data or MC"}
 
Gaudi::Property< float > m_jetSeed_ptMin {this, "jetSeed_ptMin", 50.0, "Minimum pT for jet seed"}
 
Gaudi::Property< float > m_jetSeed_etaMax {this, "jetSeed_etaMin", 2.0, "Maximum eta for jet seed"}
 
Gaudi::Property< std::string > m_hitDVLinkName {this, "hitDVLinkName", "HitDVSeedLink", "Name of the link to HitDVContainer. Used by ViewCreatorROITool."}
 
ToolHandle< GenericMonitoringTool > m_monTool { this, "MonTool", "", "Monitoring tool" }
 
SG::SlotSpecificObj< TMVAReader > m_tmva_reader ATLAS_THREAD_SAFE
 
int m_tools_lowest_jetEt
 
int m_tools_loosest_wp
 
bool m_useBeamSpot
 
bool m_doHitDV_Seeding = true
 
SG::ReadHandleKey< xAOD::jFexSRJetRoIContainer > m_jetRoiCollectionKey {this, "jFexSRJetRoI", "", ""}
 
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }
 
SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > m_input { this, "HypoInputDecisions", "UNSPECIFIED_INPUT", "Input Decision (implicit)" }
 input decisions More...
 
SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer > m_output { this, "HypoOutputDecisions", "UNSPECIFIED_OUTPUT", "Ouput Decision" }
 output decisions More...
 
Gaudi::Property< bool > m_runtimeValidation { this, "RuntimeValidation", false, "Enable detailed runtime validation of HypoAlg output, and upstream Decisions." }
 Enabling of detailed validation checks for use during development. More...
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
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
 

Runtime validation methods


enum  LogicalFlowCheckMode { kRequireOne, kRequireAll }
 
static StatusCode validateHasLinks (const ElementLink< TrigCompositeUtils::DecisionContainer > &dEL, MsgStream &msg)
 Ensure all Decisions have the named ElementLink graph edges which they are required to by spec. More...
 
static StatusCode validateLogicalFlow (const ElementLink< TrigCompositeUtils::DecisionContainer > &dEL, MsgStream &msg, const LogicalFlowCheckMode mode)
 Ensure that all DecisionIDs have propagated correctly from their parent. More...
 
static StatusCode validateDuplicatedDecisionID (const ElementLink< TrigCompositeUtils::DecisionContainer > &dEL, MsgStream &msg)
 Ensure that no space is being wasted by duplicated DecisionIDs in any Decision objects. More...
 
static StatusCode validateDecisionIDs (const ElementLink< TrigCompositeUtils::DecisionContainer > &dEL, MsgStream &msg)
 Ensure that all present IDs correspond to configured chains. More...
 
static StatusCode validateParentLinking (const ElementLink< TrigCompositeUtils::DecisionContainer > &dEL, MsgStream &msg, bool runTwoConversion)
 Ensure that the Decision has at least one valid parent, unless it is a initial Decision from the HLTSeeding. More...
 
static StatusCode recursiveValidateGraph (const ElementLink< TrigCompositeUtils::DecisionContainer > &dEL, MsgStream &msg, bool onlyValidateOneStep, bool runTwoConversion, size_t callDepth, std::set< const TrigCompositeUtils::Decision * > &fullyExploredFrom)
 Execute all checks on one node in the graph, d, then recursive call self on all parent nodes up to L1. More...
 
static void printBangs (MsgStream &msg)
 Print header line. More...
 
static void printErrorHeader (const ElementLink< TrigCompositeUtils::DecisionContainer > &dEL, MsgStream &msg)
 A problem was found, print common output data. More...
 

Detailed Description

Implements Hypo selection on triggering displaced vertex.

Author
Kunihiro Nagano kunih.nosp@m.iro..nosp@m.nagan.nosp@m.o@ce.nosp@m.rn.ch - KEK

Definition at line 62 of file TrigHitDVHypoAlg.h.

Member Typedef Documentation

◆ SeedType

using TrigHitDVHypoAlg::SeedType = TrigHitDVHypoTool::SeedType
private

Definition at line 93 of file TrigHitDVHypoAlg.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ LogicalFlowCheckMode

enum HypoBase::LogicalFlowCheckMode
privateinherited
Enumerator
kRequireOne 

Require all DecisionIDs to be present in at least one of my parent Decision objects.

kRequireAll 

Definition at line 52 of file HypoBase.h.

52  {
53  kRequireOne,
54  kRequireAll //<! Require all DecisionIDs to be present in all of my parent Decision objects
55  };

Constructor & Destructor Documentation

◆ TrigHitDVHypoAlg()

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

Definition at line 43 of file TrigHitDVHypoAlg.cxx.

44  :
45  ::HypoBase( name, pSvcLocator ),
46  m_lumiBlockMuTool("LumiBlockMuTool/LumiBlockMuTool")
47 {}

Member Function Documentation

◆ calculateBDT()

StatusCode TrigHitDVHypoAlg::calculateBDT ( const EventContext &  context,
const std::vector< HitDVSpacePoint > &  spsContainer,
const std::vector< HitDVTrk > &  trksContainer,
const std::vector< float > &  seeds_pt,
const std::vector< float > &  seeds_eta,
const std::vector< float > &  seeds_phi,
const float &  cutBDTthreshold,
const int  seed_type,
xAOD::TrigCompositeContainer *  dvContainer,
int &  n_passed 
) const
private

Definition at line 565 of file TrigHitDVHypoAlg.cxx.

572 {
573  if( seeds_eta.size() != seeds_phi.size() ) return StatusCode::SUCCESS;
574  n_passed = 0;
575 
576  for(unsigned int iseed=0; iseed<seeds_eta.size(); iseed++) {
577 
578  float seed_eta = seeds_eta[iseed];
579  float seed_phi = seeds_phi[iseed];
580 
581  ATH_MSG_VERBOSE("+++++ seed eta: " << seed_eta << ", phi:" << seed_phi << " +++++");
582 
583  // loop on space points
584  const int N_LAYER = 8;
585  const float DR_SQUARED_TO_REF_CUT = 0.16; // const float DR_TO_REF_CUT = 0.4;
586 
587  int n_sp_injet = 0;
588  int n_sp_injet_usedByTrk = 0;
589  int v_n_sp_injet[N_LAYER];
590  int v_n_sp_injet_usedByTrk[N_LAYER];
591  for(int i=0; i<N_LAYER; i++) { v_n_sp_injet[i]=0; v_n_sp_injet_usedByTrk[i]=0; }
592 
593  for ( const auto & spData : spsContainer ) {
594  // match within dR
595  float sp_eta = spData.eta;
596  float sp_phi = spData.phi;
597  float dR2 = deltaR2(sp_eta,sp_phi,seed_eta,seed_phi);
598  if( dR2 > DR_SQUARED_TO_REF_CUT ) continue;
599 
600  //
601  int sp_layer = (int)spData.layer;
602  int sp_trkid = (int)spData.usedTrkId;
603  bool isUsedByTrk = (sp_trkid != -1);
604 
605  int ilayer = getSPLayer(sp_layer,sp_eta);
606 
607  if( ilayer<=7 ) { // Pixel barrel or Sct barrel
608  n_sp_injet++;
609  v_n_sp_injet[ilayer]++;
610  if( isUsedByTrk ) {
611  n_sp_injet_usedByTrk++;
612  v_n_sp_injet_usedByTrk[ilayer]++;
613  }
614  }
615  }
616  ATH_MSG_VERBOSE("nr of SPs in jet: usedByTrk / all = " << n_sp_injet_usedByTrk << " / " << n_sp_injet);
617  float v_ly_sp_frac[N_LAYER];
618  for(int i=0; i<N_LAYER; i++) {
619  float frac = 0.;
620  if( v_n_sp_injet[i] > 0 ) frac = 1.0 - static_cast<float>(v_n_sp_injet_usedByTrk[i]) / static_cast<float>(v_n_sp_injet[i]);
621  v_ly_sp_frac[i] = frac;
622  ATH_MSG_VERBOSE("Layer " << i << ": frac=" << v_ly_sp_frac[i] << ", n used / all = " << v_n_sp_injet_usedByTrk[i] << " / " << v_n_sp_injet[i]);
623  }
624 
625  // loop on tracks
626  const float TRK_PT_GEV_CUT = 2.0;
627 
628  unsigned int n_qtrk_injet = 0;
629  for ( const auto& trk : trksContainer ) {
630  float trk_ptGeV = trk.pt;
631  trk_ptGeV /= Gaudi::Units::GeV;
632  if( trk_ptGeV < TRK_PT_GEV_CUT ) continue;
633  float dR2 = deltaR2(trk.eta,trk.phi,seed_eta,seed_phi);
634  if( dR2 > DR_SQUARED_TO_REF_CUT ) continue;
635  n_qtrk_injet++;
636  }
637  ATH_MSG_DEBUG("nr of all / quality tracks matched = " << trksContainer.size() << " / " << n_qtrk_injet);
638 
639  // evaluate BDT
640  bool isSeedOutOfRange = false;
641  if( n_qtrk_injet == 0 ) {
642  isSeedOutOfRange = true;
643  for(int i=0; i<N_LAYER; i++) {
644  if( std::fabs(v_ly_sp_frac[i]) > 1e-3 ) {
645  isSeedOutOfRange = false; break;
646  }
647  }
648  }
649  float bdt_score = -2.0;
650  if( ! isSeedOutOfRange ) {
651  auto& reader = *m_tmva_reader.get(context);
652  reader.n_track_qual = static_cast<float>(n_qtrk_injet);
653  reader.ly0_sp_frac = v_ly_sp_frac[0];
654  reader.ly1_sp_frac = v_ly_sp_frac[1];
655  reader.ly2_sp_frac = v_ly_sp_frac[2];
656  reader.ly3_sp_frac = v_ly_sp_frac[3];
657  reader.ly4_sp_frac = v_ly_sp_frac[4];
658  reader.ly5_sp_frac = v_ly_sp_frac[5];
659  reader.ly6_sp_frac = v_ly_sp_frac[6];
660  reader.ly7_sp_frac = v_ly_sp_frac[7];
661 
662  if ( std::abs(seed_eta) < 1 ) {
663  bdt_score = reader.tmva_0eta1->EvaluateMVA("BDT method");
664  } else if ( std::abs(seed_eta) < 2 ) {
665  bdt_score = reader.tmva_1eta2->EvaluateMVA("BDT method");
666  }
667  }
668 
669  // BDT threshold
670  if( bdt_score < cutBDTthreshold ) continue;
671 
672  // passed selection
673  ATH_MSG_VERBOSE("Passed selection");
674  n_passed++;
675 
676  // create EDM object
677  xAOD::TrigComposite *dv = new xAOD::TrigComposite();
678  dv->makePrivateStore();
679  dvContainer->push_back(dv);
680 
681  float seed_pt = 0;
682  if ( seed_type == SeedType::HLTJet ) seed_pt = seeds_pt[iseed];
683  dv->setDetail<float>("hitDV_seed_pt", seed_pt);
684  dv->setDetail<float>("hitDV_seed_eta", seed_eta);
685  dv->setDetail<float>("hitDV_seed_phi", seed_phi);
686  dv->setDetail<int> ("hitDV_seed_type", seed_type);
687  dv->setDetail<int> ("hitDV_n_track_qual", n_qtrk_injet);
688  dv->setDetail<float>("hitDV_ly0_sp_frac", v_ly_sp_frac[0]);
689  dv->setDetail<float>("hitDV_ly1_sp_frac", v_ly_sp_frac[1]);
690  dv->setDetail<float>("hitDV_ly2_sp_frac", v_ly_sp_frac[2]);
691  dv->setDetail<float>("hitDV_ly3_sp_frac", v_ly_sp_frac[3]);
692  dv->setDetail<float>("hitDV_ly4_sp_frac", v_ly_sp_frac[4]);
693  dv->setDetail<float>("hitDV_ly5_sp_frac", v_ly_sp_frac[5]);
694  dv->setDetail<float>("hitDV_ly6_sp_frac", v_ly_sp_frac[6]);
695  dv->setDetail<float>("hitDV_ly7_sp_frac", v_ly_sp_frac[7]);
696  dv->setDetail<float>("hitDV_bdt_score", bdt_score);
697 
698  ATH_MSG_VERBOSE("Created a new entry EDM");
699  }
700  ATH_MSG_DEBUG("nr of BDT passed = " << n_passed);
701 
702  //
703  return StatusCode::SUCCESS;
704 }

◆ cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const
overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

56 {
57  return 0;
58 }

◆ decisionInput()

const SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > & HypoBase::decisionInput ( ) const
protectedinherited

methods for derived classes to access handles of the base class input other read/write handles may be implemented by derived classes

Definition at line 16 of file HypoBase.cxx.

16  {
17  return m_input;
18 }

◆ decisionOutput()

const SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer > & HypoBase::decisionOutput ( ) const
protectedinherited

methods for derived classes to access handles of the base class output other read/write handles may be implemented by derived classes

Definition at line 20 of file HypoBase.cxx.

20  {
21  return m_output;
22 }

◆ declareGaudiProperty() [1/4]

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

◆ deltaR2()

float TrigHitDVHypoAlg::deltaR2 ( float  eta_1,
float  phi_1,
float  eta_2,
float  phi_2 
) const
private

Definition at line 333 of file TrigHitDVHypoAlg.cxx.

333  {
334  float dPhi = CxxUtils::wrapToPi(phi_1 - phi_2);
335  float dEta = eta_1 - eta_2;
336  return (dPhi*dPhi)+(dEta*dEta);
337 }

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ doMonitor()

StatusCode TrigHitDVHypoAlg::doMonitor ( const xAOD::TrigCompositeContainer *  dvContainer) const
private

Definition at line 466 of file TrigHitDVHypoAlg.cxx.

467 {
468  std::vector<float> mnt_eta1_ly0_spfr;
469  std::vector<float> mnt_eta1_ly1_spfr;
470  std::vector<float> mnt_eta1_ly2_spfr;
471  std::vector<float> mnt_eta1_ly3_spfr;
472  std::vector<float> mnt_eta1_ly4_spfr;
473  std::vector<float> mnt_eta1_ly5_spfr;
474  std::vector<float> mnt_eta1_ly6_spfr;
475  std::vector<float> mnt_eta1_ly7_spfr;
476  std::vector<int> mnt_eta1_n_qtrk;
477  std::vector<float> mnt_eta1_bdtscore;
478  std::vector<float> mnt_1eta2_ly0_spfr;
479  std::vector<float> mnt_1eta2_ly1_spfr;
480  std::vector<float> mnt_1eta2_ly2_spfr;
481  std::vector<float> mnt_1eta2_ly3_spfr;
482  std::vector<float> mnt_1eta2_ly4_spfr;
483  std::vector<float> mnt_1eta2_ly5_spfr;
484  std::vector<float> mnt_1eta2_ly6_spfr;
485  std::vector<float> mnt_1eta2_ly7_spfr;
486  std::vector<int> mnt_1eta2_n_qtrk;
487  std::vector<float> mnt_1eta2_bdtscore;
488  auto mon_eta1_ly0_spfr = Monitored::Collection("eta1_ly0_spfr", mnt_eta1_ly0_spfr);
489  auto mon_eta1_ly1_spfr = Monitored::Collection("eta1_ly1_spfr", mnt_eta1_ly1_spfr);
490  auto mon_eta1_ly2_spfr = Monitored::Collection("eta1_ly2_spfr", mnt_eta1_ly2_spfr);
491  auto mon_eta1_ly3_spfr = Monitored::Collection("eta1_ly3_spfr", mnt_eta1_ly3_spfr);
492  auto mon_eta1_ly4_spfr = Monitored::Collection("eta1_ly4_spfr", mnt_eta1_ly4_spfr);
493  auto mon_eta1_ly5_spfr = Monitored::Collection("eta1_ly5_spfr", mnt_eta1_ly5_spfr);
494  auto mon_eta1_ly6_spfr = Monitored::Collection("eta1_ly6_spfr", mnt_eta1_ly6_spfr);
495  auto mon_eta1_ly7_spfr = Monitored::Collection("eta1_ly7_spfr", mnt_eta1_ly7_spfr);
496  auto mon_eta1_n_qtrk = Monitored::Collection("eta1_n_qtrk", mnt_eta1_n_qtrk);
497  auto mon_eta1_bdtscore = Monitored::Collection("eta1_bdtscore", mnt_eta1_bdtscore);
498  auto mon_1eta2_ly0_spfr = Monitored::Collection("1eta2_ly0_spfr", mnt_1eta2_ly0_spfr);
499  auto mon_1eta2_ly1_spfr = Monitored::Collection("1eta2_ly1_spfr", mnt_1eta2_ly1_spfr);
500  auto mon_1eta2_ly2_spfr = Monitored::Collection("1eta2_ly2_spfr", mnt_1eta2_ly2_spfr);
501  auto mon_1eta2_ly3_spfr = Monitored::Collection("1eta2_ly3_spfr", mnt_1eta2_ly3_spfr);
502  auto mon_1eta2_ly4_spfr = Monitored::Collection("1eta2_ly4_spfr", mnt_1eta2_ly4_spfr);
503  auto mon_1eta2_ly5_spfr = Monitored::Collection("1eta2_ly5_spfr", mnt_1eta2_ly5_spfr);
504  auto mon_1eta2_ly6_spfr = Monitored::Collection("1eta2_ly6_spfr", mnt_1eta2_ly6_spfr);
505  auto mon_1eta2_ly7_spfr = Monitored::Collection("1eta2_ly7_spfr", mnt_1eta2_ly7_spfr);
506  auto mon_1eta2_n_qtrk = Monitored::Collection("1eta2_n_qtrk", mnt_1eta2_n_qtrk);
507  auto mon_1eta2_bdtscore = Monitored::Collection("1eta2_bdtscore", mnt_1eta2_bdtscore);
508  auto monitorIt = Monitored::Group( m_monTool,
509  mon_eta1_ly0_spfr, mon_eta1_ly1_spfr, mon_eta1_ly2_spfr, mon_eta1_ly3_spfr,
510  mon_eta1_ly4_spfr, mon_eta1_ly5_spfr, mon_eta1_ly6_spfr, mon_eta1_ly7_spfr,
511  mon_eta1_n_qtrk, mon_eta1_bdtscore,
512  mon_1eta2_ly0_spfr, mon_1eta2_ly1_spfr, mon_1eta2_ly2_spfr, mon_1eta2_ly3_spfr,
513  mon_1eta2_ly4_spfr, mon_1eta2_ly5_spfr, mon_1eta2_ly6_spfr, mon_1eta2_ly7_spfr,
514  mon_1eta2_n_qtrk, mon_1eta2_bdtscore);
515 
516  //
517  for ( auto dv : *dvContainer ) {
518  int seed_type = dv->getDetail<int> ("hitDV_seed_type");
519  // do not fill sp-seeded candidates
520  if( seed_type == SeedType::SP ) continue;
521  float seed_eta = dv->getDetail<float>("hitDV_seed_eta");
522  int n_track_qual= dv->getDetail<int> ("hitDV_n_track_qual");
523  float bdt_score = dv->getDetail<float>("hitDV_bdt_score");
524  float ly0_sp_frac = dv->getDetail<float>("hitDV_ly0_sp_frac");
525  float ly1_sp_frac = dv->getDetail<float>("hitDV_ly1_sp_frac");
526  float ly2_sp_frac = dv->getDetail<float>("hitDV_ly2_sp_frac");
527  float ly3_sp_frac = dv->getDetail<float>("hitDV_ly3_sp_frac");
528  float ly4_sp_frac = dv->getDetail<float>("hitDV_ly4_sp_frac");
529  float ly5_sp_frac = dv->getDetail<float>("hitDV_ly5_sp_frac");
530  float ly6_sp_frac = dv->getDetail<float>("hitDV_ly6_sp_frac");
531  float ly7_sp_frac = dv->getDetail<float>("hitDV_ly7_sp_frac");
532  if( std::abs(seed_eta) < 1.0 ) {
533  mnt_eta1_ly0_spfr.push_back(ly0_sp_frac);
534  mnt_eta1_ly1_spfr.push_back(ly1_sp_frac);
535  mnt_eta1_ly2_spfr.push_back(ly2_sp_frac);
536  mnt_eta1_ly3_spfr.push_back(ly3_sp_frac);
537  mnt_eta1_ly4_spfr.push_back(ly4_sp_frac);
538  mnt_eta1_ly5_spfr.push_back(ly5_sp_frac);
539  mnt_eta1_ly6_spfr.push_back(ly6_sp_frac);
540  mnt_eta1_ly7_spfr.push_back(ly7_sp_frac);
541  mnt_eta1_n_qtrk.push_back(n_track_qual);
542  mnt_eta1_bdtscore.push_back(bdt_score);
543  }
544  else if( std::abs(seed_eta) < 2.0 ) {
545  mnt_1eta2_ly0_spfr.push_back(ly0_sp_frac);
546  mnt_1eta2_ly1_spfr.push_back(ly1_sp_frac);
547  mnt_1eta2_ly2_spfr.push_back(ly2_sp_frac);
548  mnt_1eta2_ly3_spfr.push_back(ly3_sp_frac);
549  mnt_1eta2_ly4_spfr.push_back(ly4_sp_frac);
550  mnt_1eta2_ly5_spfr.push_back(ly5_sp_frac);
551  mnt_1eta2_ly6_spfr.push_back(ly6_sp_frac);
552  mnt_1eta2_ly7_spfr.push_back(ly7_sp_frac);
553  mnt_1eta2_n_qtrk.push_back(n_track_qual);
554  mnt_1eta2_bdtscore.push_back(bdt_score);
555  }
556  }
557 
558  //
559  return StatusCode::SUCCESS;
560 }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::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 TrigHitDVHypoAlg::execute ( const EventContext &  context) const
overridevirtual

Definition at line 127 of file TrigHitDVHypoAlg.cxx.

128 {
129 
130  const TrigRoiDescriptor roi = TrigRoiDescriptor(0, -4.5, 4.5, 0, -M_PI, M_PI, 0, -168.0, 168.0);
131  std::vector<TrigSiSpacePointBase> convertedSpacePoints;
132  convertedSpacePoints.reserve(5000);
133  int mnt_roi_nSPsPIX;
134  int mnt_roi_nSPsSCT;
135  ATH_CHECK(m_spacePointTool->getSpacePoints(roi, convertedSpacePoints, mnt_roi_nSPsPIX, mnt_roi_nSPsSCT, context));
136 
137  // monitoring
138  auto mon_n_dvtrks = Monitored::Scalar<int>( "n_dvtrks", 0 );
139  auto mon_n_dvsps = Monitored::Scalar<int>( "n_dvsps", 0 );
140  auto mon_n_jetseeds = Monitored::Scalar<int>( "n_jetseeds", 0 );
141  auto mon_n_jetseedsdel= Monitored::Scalar<int>( "n_jetseedsdel",0 );
142  auto mon_n_spseeds = Monitored::Scalar<int>( "n_spseeds", 0 );
143  auto mon_n_spseedsdel = Monitored::Scalar<int>( "n_spseedsdel", 0 );
144  auto mon_average_mu = Monitored::Scalar<float>( "average_mu", 0.);
145  auto monitorIt = Monitored::Group( m_monTool, mon_n_dvtrks, mon_n_dvsps, mon_n_jetseeds, mon_n_jetseedsdel, mon_n_spseeds, mon_n_spseedsdel, mon_average_mu );
146 
147  // previous decisions
148  ATH_MSG_DEBUG( "Retrieving pervious decision: \"" << decisionInput().key() << "\"" );
149  auto previousDecisionsHandle = SG::makeHandle( decisionInput(), context );
150  ATH_CHECK( previousDecisionsHandle.isValid() );
151 
152  ATH_MSG_DEBUG( "Running with " << previousDecisionsHandle->size() << " previous decisions" );
153  if( previousDecisionsHandle->size()!=1 ) {
154  ATH_MSG_ERROR( "Previous decision handle size is not 1. It is" << previousDecisionsHandle->size() );
155  return StatusCode::FAILURE;
156  }
157  const Decision * previousDecision = previousDecisionsHandle->at(0);
158 
159  TrigCompositeUtils::DecisionIDContainer previousDecisionIDs;
160  TrigCompositeUtils::decisionIDs(previousDecision, previousDecisionIDs);
161  ATH_MSG_DEBUG( "IDs of active legs:" );
162  for(auto decisionID: previousDecisionIDs) { ATH_MSG_DEBUG( " " << decisionID ); }
163 
164  // new output decisions
165  ATH_MSG_DEBUG( "Creating new output decision handle" );
166  SG::WriteHandle<DecisionContainer> outputHandle = createAndStore(decisionOutput(), context );
167  auto outputDecisions = outputHandle.ptr();
168 
169  // input objects
170 
171  // jets
172  auto jetsHandle = SG::makeHandle(m_jetsKey, context );
173  ATH_CHECK( jetsHandle.isValid() );
174  ATH_MSG_DEBUG( "jet handle size: " << jetsHandle->size() );
175 
176  const xAOD::JetContainer* jetsContainer = jetsHandle.get();
177  if( jetsContainer == nullptr ) {
178  ATH_MSG_ERROR( "ERROR Cannot get jet container" );
179  return StatusCode::FAILURE;
180  }
181  bool isJetEtPassToolsCut = false;
182  float jetEtaToolsCut = 2.0;
183  if( m_tools_loosest_wp >= 3 ) jetEtaToolsCut = 1.0;
184  for ( const xAOD::Jet* jet : *jetsContainer ) {
185  float jet_pt = static_cast<float>(jet->pt() / Gaudi::Units::GeV );
186  float jet_eta = static_cast<float>(jet->eta());
187  if( jet_pt >= m_tools_lowest_jetEt && std::abs(jet_eta)<=jetEtaToolsCut ) {
188  isJetEtPassToolsCut = true;
189  break;
190  }
191  }
192 
193  auto tracks = SG::makeHandle( m_tracksKey, context );
194  ATH_CHECK(tracks.isValid());
195 
196  std::vector<HitDVSeed> hitDVSeedsContainer;
197  std::vector<HitDVTrk> hitDVTrksContainer;
198  std::vector<HitDVSpacePoint> hitDVSPsContainer;
199 
200 
201  ATH_CHECK( findHitDV(context, convertedSpacePoints, *tracks, hitDVSeedsContainer, hitDVTrksContainer, hitDVSPsContainer) );
202 
203  mon_n_dvtrks = hitDVTrksContainer.size();
204  mon_n_dvsps = hitDVSPsContainer.size();
205  const unsigned int N_MAX_SP_STORED = 100000;
206  bool isSPOverflow = false;
207  if( hitDVSPsContainer.size() >= N_MAX_SP_STORED ) isSPOverflow = true;
208  ATH_MSG_DEBUG( "hitDVSP size=" << mon_n_dvsps );
209 
210  // average mu
211  float averageMu = 0;
212  if( m_isMC ) {
213  if( m_lumiBlockMuTool ) {
214  averageMu = static_cast<float>(m_lumiBlockMuTool->averageInteractionsPerCrossing(context));
215  ATH_MSG_DEBUG( "offline averageMu = " << averageMu );
216  }
217  }
218  else {
219  SG::ReadCondHandle<LuminosityCondData> lcd (m_lumiDataKey,context);
220  averageMu = lcd.cptr()->lbAverageInteractionsPerCrossing();
221  ATH_MSG_DEBUG( "online averageMu = " << averageMu );
222  }
223  mon_average_mu = averageMu;
224 
225  // find seeds based on HLT jets
226  std::vector<float> jetSeeds_pt;
227  std::vector<float> jetSeeds_eta;
228  std::vector<float> jetSeeds_phi;
229  ATH_CHECK( findJetSeeds(jetsContainer, m_jetSeed_ptMin, m_jetSeed_etaMax, jetSeeds_pt, jetSeeds_eta, jetSeeds_phi) );
230  int n_alljetseeds = jetSeeds_eta.size();
231  ATH_CHECK( selectSeedsNearby(hitDVSeedsContainer, jetSeeds_eta, jetSeeds_phi, jetSeeds_pt) );
232  mon_n_jetseeds = jetSeeds_eta.size();
233  mon_n_jetseedsdel = n_alljetseeds - jetSeeds_eta.size();
234 
235  // find seeds based on SP frac itself
236  std::vector<float> spSeeds_eta;
237  std::vector<float> spSeeds_phi;
238  std::vector<float> void_pt;
239  int n_allspseeds = 0;
240  if( m_tools_loosest_wp <= 1 ) {
241  ATH_CHECK( findSPSeeds(context, hitDVSPsContainer, spSeeds_eta, spSeeds_phi) );
242  n_allspseeds = spSeeds_eta.size();
243  ATH_CHECK( selectSeedsNearby(hitDVSeedsContainer, spSeeds_eta, spSeeds_phi, void_pt) );
244  mon_n_spseeds = spSeeds_eta.size();
245  mon_n_spseedsdel = n_allspseeds - spSeeds_eta.size();
246  }
247  else {
248  mon_n_spseeds = 0;
249  mon_n_spseedsdel = 0;
250  }
251 
252  // output EDM object
253  auto hitDVContainer = std::make_unique<xAOD::TrigCompositeContainer>();
254  auto hitDVContainerAux = std::make_unique<xAOD::TrigCompositeAuxContainer>();
255  hitDVContainer->setStore(hitDVContainerAux.get());
256 
257  xAOD::TrigCompositeContainer* dvContainer = hitDVContainer.get();
258  std::vector<TrigHitDVHypoTool::HitDVHypoInfo> hitDVHypoInputs;
259  std::unordered_map<Decision*, size_t> mapDecIdx;
260 
261  // calculate BDT and create hitDVContainer EDM
262  if( isJetEtPassToolsCut ) {
263  const float preselBDTthreshold = -0.6;
264 
265  int n_passed_jet = 0;
266  int seed_type = SeedType::HLTJet;
267  ATH_CHECK( calculateBDT(context, hitDVSPsContainer, hitDVTrksContainer, jetSeeds_pt, jetSeeds_eta, jetSeeds_phi, preselBDTthreshold, seed_type, dvContainer, n_passed_jet) );
268 
269  int n_passed_sp = 0;
270  if( m_tools_loosest_wp <= 1 ) {
271  seed_type = SeedType::SP;
272  ATH_CHECK( calculateBDT(context, hitDVSPsContainer, hitDVTrksContainer, void_pt, spSeeds_eta, spSeeds_phi, preselBDTthreshold, seed_type, dvContainer, n_passed_sp) );
273  }
274 
275  ATH_MSG_DEBUG( "nr of dv container / jet-seeded / sp-seed candidates = " << dvContainer->size() << " / " << n_passed_jet << " / " << n_passed_sp );
276 
277  // Prepare inputs to HypoTool
278  for ( auto dv : *dvContainer ) {
279  Decision* newDecision = TrigCompositeUtils::newDecisionIn( outputDecisions, previousDecision, TrigCompositeUtils::hypoAlgNodeName(), context);
280  mapDecIdx.emplace( newDecision, dv->index() );
281  TrigHitDVHypoTool::HitDVHypoInfo hypoInfo{ newDecision, isSPOverflow, averageMu, dv, previousDecisionIDs };
282  hitDVHypoInputs.push_back( hypoInfo );
283  }
284  }
285 
286  // monitor
287  ATH_CHECK( doMonitor(dvContainer) );
288 
289  // Loop over all hypoToolinputs and get their decisions
290  for ( auto & tool: m_hypoTools ) {
291  ATH_MSG_DEBUG( "+++++ Now computing decision for " << tool->name() );
292  ATH_CHECK( tool->decide( hitDVHypoInputs ) );
293  }
294 
295  // record hitDV object
296  SG::WriteHandle<xAOD::TrigCompositeContainer> hitDVHandle(m_hitDVKey, context);
297  ATH_CHECK( hitDVHandle.record( std::move( hitDVContainer ), std::move( hitDVContainerAux ) ) );
298  ATH_MSG_DEBUG( "recorded hitDV object to SG" );
299 
300  DecisionContainer::iterator it = outputDecisions->begin();
301  while(it != outputDecisions->end()) {
302  ATH_MSG_DEBUG( "+++++ outputDecision: " << *it << " +++++" );
303  if ( allFailed( *it ) ) {
304  ATH_MSG_DEBUG( "---> all failed, erasing" );
305  it = outputDecisions->erase(it);
306  } else {
307  ATH_MSG_DEBUG( "---> not all failed" );
308 
309  // Link hitDV object
310  auto decision = *it;
311  size_t idx = mapDecIdx.at(*it);
312 
313  ElementLink<xAOD::TrigCompositeContainer> dvEL = ElementLink<xAOD::TrigCompositeContainer>(*hitDVHandle, idx, context);
314  ATH_CHECK( dvEL.isValid() );
315 
316  ATH_CHECK( decision->setObjectLink<xAOD::TrigCompositeContainer>(featureString(), dvEL) );
317 
318  ATH_MSG_DEBUG(*decision);
319  ++it;
320  }
321  }
322 
323  //
324  ATH_CHECK( hypoBaseOutputProcessing(outputHandle) );
325 
326  //
327  return StatusCode::SUCCESS;
328 }

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & AthReentrantAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.cxx.

80 {
81  // If we didn't find any symlinks to add, just return the collection
82  // from the base class. Otherwise, return the extended collection.
83  if (!m_extendedExtraObjects.empty()) {
84  return m_extendedExtraObjects;
85  }
86  return Algorithm::extraOutputDeps();
87 }

◆ filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

135  {
136  return execState( ctx ).filterPassed();
137  }

◆ findHitDV()

StatusCode TrigHitDVHypoAlg::findHitDV ( const EventContext &  ctx,
const std::vector< TrigSiSpacePointBase > &  convertedSpacePoints,
const DataVector< Trk::Track > &  tracks,
std::vector< HitDVSeed > &  hitDVSeedsContainer,
std::vector< HitDVTrk > &  hitDVTrksContainer,
std::vector< HitDVSpacePoint > &  hitDVSPContainer 
) const
private

Definition at line 1178 of file TrigHitDVHypoAlg.cxx.

1182 {
1183  std::vector<int> v_dvtrk_id;
1184  std::vector<float> v_dvtrk_pt;
1185  std::vector<float> v_dvtrk_eta;
1186  std::vector<float> v_dvtrk_phi;
1187  std::vector<int> v_dvtrk_n_hits_inner;
1188  std::vector<int> v_dvtrk_n_hits_pix;
1189  std::vector<int> v_dvtrk_n_hits_sct;
1190  std::vector<float> v_dvtrk_a0beam;
1191  std::unordered_map<Identifier, int> umap_fittedTrack_identifier;
1192  int fittedTrack_id = -1;
1193 
1194  static constexpr float TRKCUT_PTGEV_HITDV = 0.5;
1195 
1196  for (const auto track: tracks) {
1197  float shift_x = 0; float shift_y = 0;
1198  if(m_useBeamSpot) {
1199  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx };
1200  FTF::getBeamSpotShift(shift_x, shift_y, **beamSpotHandle);
1201  }
1202  trackInfo theTrackInfo;
1203  bool igt = FTF::isGoodTrackUTT(track, theTrackInfo, shift_x, shift_y, TRKCUT_PTGEV_HITDV);
1204  if (not igt) {continue;}
1205 
1206  fittedTrack_id++;
1207  ATH_MSG_DEBUG("Selected track pT = " << theTrackInfo.ptGeV << " GeV");
1208 
1209 
1210  DataVector<const Trk::MeasurementBase>::const_iterator
1211  m = track->measurementsOnTrack()->begin(),
1212  me = track->measurementsOnTrack()->end ();
1213  for(; m!=me; ++m ) {
1214  const Trk::PrepRawData* prd = ((const Trk::RIO_OnTrack*)(*m))->prepRawData();
1215  if( prd == nullptr ) continue;
1216  Identifier id_prd = prd->identify();
1217  if( umap_fittedTrack_identifier.find(id_prd) == umap_fittedTrack_identifier.end() ) {
1218  umap_fittedTrack_identifier.insert(std::make_pair(id_prd,fittedTrack_id));
1219  }
1220  }
1221  float phi = track->perigeeParameters()->parameters()[Trk::phi];
1222  v_dvtrk_id.push_back(fittedTrack_id);
1223  v_dvtrk_pt.push_back(theTrackInfo.ptGeV*Gaudi::Units::GeV);
1224  v_dvtrk_eta.push_back(theTrackInfo.eta);
1225  v_dvtrk_phi.push_back(phi);
1226  v_dvtrk_n_hits_inner.push_back(theTrackInfo.n_hits_inner);
1227  v_dvtrk_n_hits_pix.push_back(theTrackInfo.n_hits_pix);
1228  v_dvtrk_n_hits_sct.push_back(theTrackInfo.n_hits_sct);
1229  v_dvtrk_a0beam.push_back(theTrackInfo.a0beam);
1230  }
1231  ATH_MSG_DEBUG("Nr of selected tracks / all = " << fittedTrack_id << " / " << tracks.size());
1232  ATH_MSG_DEBUG("Nr of Identifiers used by selected tracks = " << umap_fittedTrack_identifier.size());
1233 
1234  // space points
1235  int n_sp = 0;
1236  int n_sp_usedByTrk = 0;
1237 
1238  std::unordered_map<Identifier, int> umap_sp_identifier;
1239  umap_sp_identifier.reserve(1.3*convertedSpacePoints.size());//up to 2 Identifiers per spacepoint, end up with 1.3 from measurements
1240 
1241  auto add_to_sp_map = [&](const Trk::PrepRawData* prd) {
1242  if (prd) {
1243  Identifier id_prd = prd->identify();
1244  if( umap_sp_identifier.find(id_prd) == umap_sp_identifier.end() ) {
1245  umap_sp_identifier.insert(std::make_pair(id_prd,-1));
1246  }
1247  }
1248  };
1249 
1250  for(unsigned int iSp=0; iSp<convertedSpacePoints.size(); ++iSp) {
1251  bool isPix = convertedSpacePoints[iSp].isPixel();
1252  bool isSct = convertedSpacePoints[iSp].isSCT();
1253  if( ! isPix && ! isSct ) continue;
1254  const Trk::SpacePoint* sp = convertedSpacePoints[iSp].offlineSpacePoint();
1255  add_to_sp_map(sp->clusterList().first);
1256  add_to_sp_map(sp->clusterList().second);
1257  }
1258  int n_id_usedByTrack = 0;
1259  for(auto it=umap_sp_identifier.begin(); it!=umap_sp_identifier.end(); ++it) {
1260  Identifier id_sp = it->first;
1261  if( umap_fittedTrack_identifier.find(id_sp) != umap_fittedTrack_identifier.end() ) {
1262  umap_sp_identifier[id_sp] = umap_fittedTrack_identifier[id_sp];
1263  ++n_id_usedByTrack;
1264  }
1265  }
1266  ATH_MSG_DEBUG("Nr of SPs / Identifiers (all) / Identifiers (usedByTrack) = " << convertedSpacePoints.size() << " / " << umap_sp_identifier.size() << " / " << n_id_usedByTrack);
1267 
1268  auto sp_map_used_id = [&](const Trk::PrepRawData* prd) {
1269  int usedTrack_id = -1;
1270  if (prd) {
1271  Identifier id_prd = prd->identify();
1272  if( umap_sp_identifier.find(id_prd) != umap_sp_identifier.end() ) {
1273  usedTrack_id = umap_sp_identifier[id_prd];
1274  }
1275  }
1276  return usedTrack_id;
1277  };
1278 
1279  std::vector<float> v_sp_eta;
1280  v_sp_eta.reserve(convertedSpacePoints.size());
1281  std::vector<float> v_sp_r;
1282  v_sp_r.reserve(convertedSpacePoints.size());
1283  std::vector<float> v_sp_phi;
1284  v_sp_phi.reserve(convertedSpacePoints.size());
1285  std::vector<int> v_sp_layer;
1286  v_sp_layer.reserve(convertedSpacePoints.size());
1287  std::vector<bool> v_sp_isPix;
1288  v_sp_isPix.reserve(convertedSpacePoints.size());
1289  std::vector<bool> v_sp_isSct;
1290  v_sp_isSct.reserve(convertedSpacePoints.size());
1291  std::vector<int> v_sp_usedTrkId;
1292  v_sp_usedTrkId.reserve(convertedSpacePoints.size());
1293 
1294  for(const auto& sp : convertedSpacePoints) {
1295  bool isPix = sp.isPixel();
1296  bool isSct = sp.isSCT();
1297  if( ! isPix && ! isSct ) continue;
1298  const Trk::SpacePoint* osp = sp.offlineSpacePoint();
1299 
1300  int usedTrack_id = -1;
1301  int usedTrack_id_first = sp_map_used_id(osp->clusterList().first);
1302  if (usedTrack_id_first != -1) {
1303  usedTrack_id = usedTrack_id_first;
1304  }
1305  int usedTrack_id_second = sp_map_used_id(osp->clusterList().second);
1306  if (usedTrack_id_second != -1) {
1307  usedTrack_id = usedTrack_id_second;
1308  }
1309 
1310  //
1311  n_sp++;
1312  if( usedTrack_id != -1 ) n_sp_usedByTrk++;
1313  int layer = sp.layer();
1314  float sp_r = sp.r();
1315 
1316  const Amg::Vector3D& pos_sp = osp->globalPosition();//Go back to globalPosition to get the non-shifted spacepoint positions
1317  float sp_eta = pos_sp.eta();
1318  float sp_phi = pos_sp.phi();
1319 
1320  v_sp_eta.push_back(sp_eta);
1321  v_sp_r.push_back(sp_r);
1322  v_sp_phi.push_back(sp_phi);
1323  v_sp_layer.push_back(layer);
1324  v_sp_isPix.push_back(isPix);
1325  v_sp_isSct.push_back(isSct);
1326  v_sp_usedTrkId.push_back(usedTrack_id);
1327 
1328  ATH_MSG_VERBOSE("+++ SP eta / phi / layer / ixPix / usedTrack_id = " << sp_eta << " / " << sp_phi << " / " << layer << " / " << isPix << " / " << usedTrack_id);
1329 
1330  }
1331  ATH_MSG_DEBUG("Nr of SPs / all = " << n_sp << " / " << convertedSpacePoints.size());
1332  ATH_MSG_DEBUG("Nr of SPs used by selected tracks = " << n_sp_usedByTrk);
1333 
1334  // Seed
1335  std::vector<float> v_seeds_eta;
1336  std::vector<float> v_seeds_phi;
1337  std::vector<int16_t> v_seeds_type;
1338 
1339  if( m_doHitDV_Seeding ) {
1340 
1341  // add L1 Jet seeds
1342  const unsigned int L1JET_ET_CUT = 27; // Mapping from legacy J30, make configurable?
1343 
1344  auto jetRoiCollectionHandle = SG::makeHandle( m_jetRoiCollectionKey, ctx );
1345  const DataVector<xAOD::jFexSRJetRoI> *jetRoiCollection = jetRoiCollectionHandle.cptr();
1346  if (!jetRoiCollectionHandle.isValid()){
1347  ATH_MSG_ERROR("ReadHandle for DataVector<xAOD::jFexSRJetRoI> key:" << m_jetRoiCollectionKey.key() << " isn't Valid");
1348  return StatusCode::FAILURE;
1349  }
1350  for (size_t size=0; size<jetRoiCollection->size(); ++size){
1351  const xAOD::jFexSRJetRoI* jetRoI = jetRoiCollection->at(size);
1352  if( jetRoI == nullptr ) continue;
1353  // Good seed
1354  if( jetRoI->et() >= L1JET_ET_CUT ) {
1355  v_seeds_eta.push_back(jetRoI->eta());
1356  v_seeds_phi.push_back(jetRoI->phi());
1357  v_seeds_type.push_back(0); // L1_J:0
1358  }
1359  }
1360  ATH_MSG_DEBUG("Nr of L1_J" << L1JET_ET_CUT << " seeds = " << v_seeds_eta.size());
1361 
1362  // space-point based (unseeded mode)
1363  std::vector<float> v_spseeds_eta;
1364  std::vector<float> v_spseeds_phi;
1365  ATH_CHECK( findSPSeeds(ctx, v_sp_eta, v_sp_phi, v_sp_layer, v_sp_usedTrkId, v_spseeds_eta, v_spseeds_phi) );
1366  ATH_MSG_DEBUG("Nr of SP seeds = " << v_spseeds_eta.size());
1367  for(size_t idx=0; idx<v_spseeds_eta.size(); ++idx) {
1368  v_seeds_eta.push_back(v_spseeds_eta[idx]);
1369  v_seeds_phi.push_back(v_spseeds_phi[idx]);
1370  v_seeds_type.push_back(1); // SP: 1
1371  }
1372  ATH_MSG_DEBUG("Nr of SP + L1_J" << L1JET_ET_CUT << " seeds = " << v_seeds_eta.size());
1373  }
1374 
1375  // fill objects
1376 
1377  // seeds
1378  const int N_MAX_SEEDS = 200;
1379  int n_seeds = std::min(N_MAX_SEEDS,(int)v_seeds_eta.size());
1380  hitDVSeedsContainer.reserve(n_seeds);
1381  for(auto iSeed=0; iSeed < n_seeds; ++iSeed) {
1382  HitDVSeed seed;
1383  seed.eta = v_seeds_eta[iSeed];
1384  seed.phi = v_seeds_phi[iSeed];
1385  seed.type = v_seeds_type[iSeed];
1386  hitDVSeedsContainer.push_back(seed);
1387  }
1388 
1389  // track
1390  const float TRKCUT_DELTA_R_TO_SEED = 1.0;
1391  hitDVTrksContainer.reserve(v_dvtrk_pt.size());
1392  for(unsigned int iTrk=0; iTrk<v_dvtrk_pt.size(); ++iTrk) {
1393  float trk_eta = v_dvtrk_eta[iTrk];
1394  float trk_phi = v_dvtrk_phi[iTrk];
1395  if( m_doHitDV_Seeding ) {
1396  bool isNearSeed = false;
1397  for (unsigned int iSeed=0; iSeed<v_seeds_eta.size(); ++iSeed) {
1398  float seed_eta = v_seeds_eta[iSeed];
1399  float seed_phi = v_seeds_phi[iSeed];
1400  float dR2 = deltaR2(trk_eta,trk_phi,seed_eta,seed_phi);
1401  if( dR2 <= TRKCUT_DELTA_R_TO_SEED*TRKCUT_DELTA_R_TO_SEED ) { isNearSeed = true; break; }
1402  }
1403  if( ! isNearSeed ) continue;
1404  }
1405  HitDVTrk hitDVTrk;
1406  hitDVTrk.id = v_dvtrk_id[iTrk];
1407  hitDVTrk.pt = v_dvtrk_pt[iTrk];
1408  hitDVTrk.eta = v_dvtrk_eta[iTrk];
1409  hitDVTrk.phi = v_dvtrk_phi[iTrk];
1410  hitDVTrk.n_hits_inner = v_dvtrk_n_hits_inner[iTrk];
1411  hitDVTrk.n_hits_pix = v_dvtrk_n_hits_pix[iTrk];
1412  hitDVTrk.n_hits_sct = v_dvtrk_n_hits_sct[iTrk];
1413  hitDVTrk.a0beam = v_dvtrk_a0beam[iTrk];
1414 
1415  hitDVTrksContainer.push_back(hitDVTrk);
1416  }
1417 
1418  // space points
1419  const float SPCUT_DELTA_R_TO_SEED = 1.0;
1420  const size_t n_sp_max = std::min<size_t>(100000, v_sp_eta.size());
1421  size_t n_sp_stored = 0;
1422 
1423  hitDVSPsContainer.reserve(n_sp_max);
1424 
1425  for(size_t iSp=0; iSp<v_sp_eta.size(); ++iSp) {
1426  if( m_doHitDV_Seeding ) {
1427  const float sp_eta = v_sp_eta[iSp];
1428  const float sp_phi = v_sp_phi[iSp];
1429  bool isNearSeed = false;
1430  for (size_t iSeed=0; iSeed<v_seeds_eta.size(); ++iSeed) {
1431  const float seed_eta = v_seeds_eta[iSeed];
1432  const float seed_phi = v_seeds_phi[iSeed];
1433  const float dR2 = deltaR2(sp_eta, sp_phi, seed_eta, seed_phi);
1434  if( dR2 <= SPCUT_DELTA_R_TO_SEED*SPCUT_DELTA_R_TO_SEED ) { isNearSeed = true; break; }
1435  }
1436  if( ! isNearSeed ) continue;
1437  }
1438  if( n_sp_stored >= n_sp_max ) break;
1439  HitDVSpacePoint hitDVSP;
1440  hitDVSP.eta = v_sp_eta[iSp];
1441  hitDVSP.r = v_sp_r[iSp];
1442  hitDVSP.phi = v_sp_phi[iSp];
1443  hitDVSP.layer = v_sp_layer[iSp];
1444  hitDVSP.isPix = v_sp_isPix[iSp];
1445  hitDVSP.isSct = v_sp_isSct[iSp];
1446  hitDVSP.usedTrkId = v_sp_usedTrkId[iSp];
1447  hitDVSPsContainer.push_back(hitDVSP);
1448  ++n_sp_stored;
1449  }
1450  ATH_MSG_DEBUG("Nr of SPs stored = " << n_sp_stored);
1451 
1452  return StatusCode::SUCCESS;
1453 }

◆ findJetSeeds()

StatusCode TrigHitDVHypoAlg::findJetSeeds ( const xAOD::JetContainer *  jetsContainer,
const float  cutJetPt,
const float  cutJetEta,
std::vector< float > &  jetSeeds_pt,
std::vector< float > &  jetSeeds_eta,
std::vector< float > &  jetSeeds_phi 
) const
private

Definition at line 709 of file TrigHitDVHypoAlg.cxx.

711 {
712  std::vector<float> mnt_jet_pt;
713  std::vector<float> mnt_jet_eta;
714  auto mon_jet_pt = Monitored::Collection("jet_pt", mnt_jet_pt);
715  auto mon_jet_eta = Monitored::Collection("jet_eta", mnt_jet_eta);
716  auto monitorIt = Monitored::Group( m_monTool, mon_jet_pt, mon_jet_eta );
717 
718  ATH_MSG_VERBOSE("looking for jet seed with pt cut=" << cutJetPt << ", eta cut=" << cutJetEta);
719  for ( const xAOD::Jet* jet : *jetsContainer ) {
720  float jet_pt = static_cast<float>(jet->pt() / Gaudi::Units::GeV );
721  if( jet_pt < cutJetPt ) {
722  ATH_MSG_VERBOSE("Fails jet pt cut, pt = " << jet_pt);
723  continue;
724  }
725  mnt_jet_pt.push_back(jet_pt);
726  float jet_eta = static_cast<float>(jet->eta());
727  mnt_jet_eta.push_back(jet_eta);
728  if( std::fabs(jet_eta) > cutJetEta ) {
729  ATH_MSG_VERBOSE("Fails jet eta cut, eta = " << jet_eta);
730  continue;
731  }
732  float jet_phi = static_cast<float>(jet->phi());
733  jetSeeds_pt.push_back(jet_pt);
734  jetSeeds_eta.push_back(jet_eta);
735  jetSeeds_phi.push_back(jet_phi);
736  }
737  ATH_MSG_VERBOSE("nr of jet seeds=" << jetSeeds_eta.size());
738 
739  return StatusCode::SUCCESS;
740 }

◆ findSPSeeds() [1/2]

StatusCode TrigHitDVHypoAlg::findSPSeeds ( const EventContext &  ctx,
const std::vector< HitDVSpacePoint > &  spsContainer,
std::vector< float > &  seeds_eta,
std::vector< float > &  seeds_phi 
) const
private

Definition at line 745 of file TrigHitDVHypoAlg.cxx.

747 {
748  seeds_eta.clear();
749  seeds_phi.clear();
750 
751  const int NBINS_ETA = 50;
752  const float ETA_MIN = -2.5;
753  const float ETA_MAX = 2.5;
754 
755  const int NBINS_PHI = 80;
756  const float PHI_MIN = -4.0;
757  const float PHI_MAX = 4.0;
758 
759  char hname[64];
760 
761  unsigned int slotnr = ctx.slot();
762  unsigned int subSlotnr = ctx.subSlot();
763 
764  sprintf(hname,"hitdv_s%u_ss%u_ly6_h2_nsp",slotnr,subSlotnr);
765  std::unique_ptr<TH2F> ly6_h2_nsp = std::make_unique<TH2F>(hname,hname,NBINS_ETA,ETA_MIN,ETA_MAX,NBINS_PHI,PHI_MIN,PHI_MAX);
766  sprintf(hname,"hitdv_s%u_ss%u_ly7_h2_nsp",slotnr,subSlotnr);
767  std::unique_ptr<TH2F> ly7_h2_nsp = std::make_unique<TH2F>(hname,hname,NBINS_ETA,ETA_MIN,ETA_MAX,NBINS_PHI,PHI_MIN,PHI_MAX);
768 
769  sprintf(hname,"hitdv_s%u_ss%u_ly6_h2_nsp_notrk",slotnr,subSlotnr);
770  std::unique_ptr<TH2F> ly6_h2_nsp_notrk = std::make_unique<TH2F>(hname,hname,NBINS_ETA,ETA_MIN,ETA_MAX,NBINS_PHI,PHI_MIN,PHI_MAX);
771  sprintf(hname,"hitdv_s%u_ss%u_ly7_h2_nsp_notrk",slotnr,subSlotnr);
772  std::unique_ptr<TH2F> ly7_h2_nsp_notrk = std::make_unique<TH2F>(hname,hname,NBINS_ETA,ETA_MIN,ETA_MAX,NBINS_PHI,PHI_MIN,PHI_MAX);
773 
774  for ( const auto& spData : spsContainer ) {
775  int16_t sp_layer = spData.layer;
776  float sp_eta = spData.eta;
777  int ilayer = getSPLayer(sp_layer,sp_eta);
778  if( ilayer<6 ) continue;
779 
780  int sp_trkid = (int)spData.usedTrkId;
781  bool isUsedByTrk = (sp_trkid != -1);
782  float sp_phi = spData.phi;
783 
784  bool fill_out_of_pi = false;
785  float sp_phi2 = 0;
786  if( sp_phi < 0 ) {
787  sp_phi2 = 2*TMath::Pi() + sp_phi;
788  if( sp_phi2 < PHI_MAX ) fill_out_of_pi = true;
789  }
790  else {
791  sp_phi2 = -2*TMath::Pi() + sp_phi;
792  if( PHI_MIN < sp_phi2 ) fill_out_of_pi = true;
793  }
794  if( ilayer==6 ) {
795  ly6_h2_nsp->Fill(sp_eta,sp_phi);
796  if( fill_out_of_pi ) ly6_h2_nsp->Fill(sp_eta,sp_phi2);
797  if( ! isUsedByTrk ) ly6_h2_nsp_notrk->Fill(sp_eta,sp_phi);
798  if( ! isUsedByTrk && fill_out_of_pi) ly6_h2_nsp_notrk->Fill(sp_eta,sp_phi2);
799  }
800  if( ilayer==7 ) {
801  ly7_h2_nsp->Fill(sp_eta,sp_phi);
802  if( fill_out_of_pi ) ly7_h2_nsp->Fill(sp_eta,sp_phi2);
803  if( ! isUsedByTrk ) ly7_h2_nsp_notrk->Fill(sp_eta,sp_phi);
804  if( ! isUsedByTrk && fill_out_of_pi) ly7_h2_nsp_notrk->Fill(sp_eta,sp_phi2);
805  }
806  }
807 
808  ATH_MSG_VERBOSE("looking for ly6/ly6 doublet seeds");
809 
810  // (idx, sort/weight, eta, phi)
811  std::vector<std::tuple<int,float,float,float>> QT;
812 
813  for(int ly6_ieta=1; ly6_ieta<=NBINS_ETA; ly6_ieta++) {
814  float ly6_eta = (ly6_h2_nsp->GetXaxis()->GetBinLowEdge(ly6_ieta) + ly6_h2_nsp->GetXaxis()->GetBinUpEdge(ly6_ieta))/2.0;
815  for(int ly6_iphi=1; ly6_iphi<=NBINS_PHI; ly6_iphi++) {
816  float ly6_phi = (ly6_h2_nsp->GetYaxis()->GetBinLowEdge(ly6_iphi) + ly6_h2_nsp->GetYaxis()->GetBinUpEdge(ly6_iphi))/2.0;
817 
818  float ly6_nsp = ly6_h2_nsp ->GetBinContent(ly6_ieta,ly6_iphi);
819  float ly6_nsp_notrk = ly6_h2_nsp_notrk->GetBinContent(ly6_ieta,ly6_iphi);
820  float ly6_frac = ( ly6_nsp > 0 ) ? ly6_nsp_notrk / ly6_nsp : 0;
821  if( ly6_nsp < 10 || ly6_frac < 0.85 ) continue;
822 
823  float ly7_frac_max = 0;
824  float ly7_eta_max = 0;
825  float ly7_phi_max = 0;
826  for(int ly7_ieta=std::max(1,ly6_ieta-1); ly7_ieta<std::min(NBINS_ETA,ly6_ieta+1); ly7_ieta++) {
827  for(int ly7_iphi=std::max(1,ly6_iphi-1); ly7_iphi<=std::min(NBINS_PHI,ly6_iphi+1); ly7_iphi++) {
828  float ly7_nsp = ly7_h2_nsp ->GetBinContent(ly7_ieta,ly7_iphi);
829  float ly7_nsp_notrk = ly7_h2_nsp_notrk->GetBinContent(ly7_ieta,ly7_iphi);
830  float ly7_frac = ( ly7_nsp > 0 ) ? ly7_nsp_notrk / ly7_nsp : 0;
831  if( ly7_nsp < 10 ) continue;
832  if( ly7_frac > ly7_frac_max ) {
833  ly7_frac_max = ly7_frac;
834  ly7_eta_max = (ly7_h2_nsp->GetXaxis()->GetBinLowEdge(ly7_ieta) + ly7_h2_nsp->GetXaxis()->GetBinUpEdge(ly7_ieta))/2.0;
835  ly7_phi_max = (ly7_h2_nsp->GetXaxis()->GetBinLowEdge(ly7_iphi) + ly7_h2_nsp->GetXaxis()->GetBinUpEdge(ly7_iphi))/2.0;
836  }
837  }
838  }
839  if( ly7_frac_max < 0.85 ) continue;
840  //
841  float wsum = ly6_frac + ly7_frac_max;
842  float weta = (ly6_eta*ly6_frac + ly7_eta_max*ly7_frac_max) / wsum;
843  float wphi = (ly6_phi*ly6_frac + ly7_phi_max*ly7_frac_max) / wsum;
844  float w = wsum / 2.0;
845  QT.push_back(std::make_tuple(-1,w,weta,wphi));
846  }
847  }
848  ATH_MSG_VERBOSE("nr of ly6/ly7 doublet candidate seeds=" << QT.size() << ", doing clustering...");
849 
850  // sort
851  std::sort(QT.begin(), QT.end(),
852  [](const std::tuple<int,float,float,float>& lhs, const std::tuple<int,float,float,float>& rhs) {
853  return std::get<1>(lhs) > std::get<1>(rhs); } );
854 
855  // clustering
856  const double CLUSTCUT_DIST_SQUARED = 0.04; // const double CLUSTCUT_DIST = 0.2;
857  const double CLUSTCUT_SEED_FRAC = 0.9;
858 
859  std::vector<float> seeds_wsum;
860 
861  for(unsigned int i=0; i<QT.size(); i++) {
862  float phi = std::get<3>(QT[i]);
863  float eta = std::get<2>(QT[i]);
864  float w = std::get<1>(QT[i]);
865  if(i==0) {
866  seeds_eta.push_back(w*eta); seeds_phi.push_back(w*phi);
867  seeds_wsum.push_back(w);
868  continue;
869  }
870  const int IDX_INITIAL = 100;
871  float dist2_min = 100.0;
872  int idx_min = IDX_INITIAL;
873  for(unsigned j=0; j<seeds_eta.size(); j++) {
874  float ceta = seeds_eta[j]/seeds_wsum[j];
875  float cphi = seeds_phi[j]/seeds_wsum[j];
876  // intentionally calculate in this way as phi is defined beyond -Pi/Pi (no boundary)
877  float deta = std::fabs(ceta-eta);
878  float dphi = std::fabs(cphi-phi);
879  float dist2 = dphi*dphi+deta*deta;
880  if( dist2 < dist2_min ) {
881  dist2_min = dist2;
882  idx_min = j;
883  }
884  }
885  int match_idx = IDX_INITIAL;
886  if( idx_min != IDX_INITIAL ) {
887  if( dist2_min < CLUSTCUT_DIST_SQUARED ) { match_idx = idx_min; }
888  }
889  if( match_idx == IDX_INITIAL ) {
890  if( w > CLUSTCUT_SEED_FRAC && dist2_min > CLUSTCUT_DIST_SQUARED ) {
891  seeds_eta.push_back(w*eta); seeds_phi.push_back(w*phi);
892  seeds_wsum.push_back(w);
893  }
894  continue;
895  }
896  float new_eta = seeds_eta[match_idx] + w*eta;
897  float new_phi = seeds_phi[match_idx] + w*phi;
898  float new_wsum = seeds_wsum[match_idx] + w;
899  seeds_eta[match_idx] = new_eta;
900  seeds_phi[match_idx] = new_phi;
901  seeds_wsum[match_idx] = new_wsum;
902  }
903  QT.clear();
904  for(unsigned int i=0; i<seeds_eta.size(); i++) {
905  float eta = seeds_eta[i] / seeds_wsum[i];
906  float phi = seeds_phi[i] / seeds_wsum[i];
907  seeds_eta[i] = eta;
908  seeds_phi[i] = phi;
909  if( phi < -TMath::Pi() ) phi = 2*TMath::Pi() + phi;
910  if( phi > TMath::Pi() ) phi = -2*TMath::Pi() + phi;
911  seeds_phi[i] = phi;
912  }
913  ATH_MSG_VERBOSE("after clustering, nr of seeds = " << seeds_eta.size());
914 
915  // delete overlap (can happen at phi=-Pi/Pi bounadry)
916  std::vector<unsigned int> idx_to_delete;
917  for(unsigned int i=0; i<seeds_eta.size(); i++) {
918  if( std::find(idx_to_delete.begin(),idx_to_delete.end(),i) != idx_to_delete.end() ) continue;
919  float eta_i = seeds_eta[i];
920  float phi_i = seeds_phi[i];
921  for(unsigned int j=i+1; j<seeds_eta.size(); j++) {
922  if( std::find(idx_to_delete.begin(),idx_to_delete.end(),j) != idx_to_delete.end() ) continue;
923  float eta_j = seeds_eta[j];
924  float phi_j = seeds_phi[j];
925  float dR2 = deltaR2(eta_i,phi_i,eta_j,phi_j);
926  if( dR2 < CLUSTCUT_DIST_SQUARED ) idx_to_delete.push_back(j);
927  }
928  }
929  ATH_MSG_VERBOSE("nr of duplicated seeds to be removed = " << idx_to_delete.size());
930  if( idx_to_delete.size() > 0 ) {
931  std::sort(idx_to_delete.begin(),idx_to_delete.end());
932  for(unsigned int j=idx_to_delete.size(); j>0; j--) {
933  unsigned int idx = idx_to_delete[j-1];
934  seeds_eta.erase(seeds_eta.begin()+idx);
935  seeds_phi.erase(seeds_phi.begin()+idx);
936  }
937  }
938 
939  ATH_MSG_VERBOSE("nr of ly6/ly7 seeds=" << seeds_eta.size());
940 
941  // return
942  return StatusCode::SUCCESS;
943 }

◆ findSPSeeds() [2/2]

StatusCode TrigHitDVHypoAlg::findSPSeeds ( const EventContext &  ctx,
const std::vector< float > &  v_sp_eta,
const std::vector< float > &  v_sp_phi,
const std::vector< int > &  v_sp_layer,
const std::vector< int > &  v_sp_usedTrkId,
std::vector< float > &  seeds_eta,
std::vector< float > &  seeds_phi 
) const
private

Definition at line 978 of file TrigHitDVHypoAlg.cxx.

982 {
983  const int NBINS_ETA = 50;
984  const float ETA_MIN = -2.5;
985  const float ETA_MAX = 2.5;
986 
987  const int NBINS_PHI = 80;
988  const float PHI_MIN = -4.0;
989  const float PHI_MAX = 4.0;
990 
991  char hname[64];
992 
993  unsigned int slotnr = ctx.slot();
994  unsigned int subSlotnr = ctx.subSlot();
995 
996  sprintf(hname,"ftf_s%u_ss%u_ly6_h2_nsp",slotnr,subSlotnr);
997  std::unique_ptr<TH2F> ly6_h2_nsp = std::make_unique<TH2F>(hname,hname,NBINS_ETA,ETA_MIN,ETA_MAX,NBINS_PHI,PHI_MIN,PHI_MAX);
998  sprintf(hname,"ftf_s%u_ss%u_ly7_h2_nsp",slotnr,subSlotnr);
999  std::unique_ptr<TH2F> ly7_h2_nsp = std::make_unique<TH2F>(hname,hname,NBINS_ETA,ETA_MIN,ETA_MAX,NBINS_PHI,PHI_MIN,PHI_MAX);
1000 
1001  sprintf(hname,"ftf_s%u_ss%u_ly6_h2_nsp_notrk",slotnr,subSlotnr);
1002  std::unique_ptr<TH2F> ly6_h2_nsp_notrk = std::make_unique<TH2F>(hname,hname,NBINS_ETA,ETA_MIN,ETA_MAX,NBINS_PHI,PHI_MIN,PHI_MAX);
1003  sprintf(hname,"ftf_s%u_ss%u_ly7_h2_nsp_notrk",slotnr,subSlotnr);
1004  std::unique_ptr<TH2F> ly7_h2_nsp_notrk = std::make_unique<TH2F>(hname,hname,NBINS_ETA,ETA_MIN,ETA_MAX,NBINS_PHI,PHI_MIN,PHI_MAX);
1005 
1006  for(unsigned int iSeed=0; iSeed<v_sp_eta.size(); ++iSeed) {
1007 
1008  int sp_layer = v_sp_layer[iSeed];
1009  float sp_eta = v_sp_eta[iSeed];
1010  int ilayer = getSPLayer(sp_layer,sp_eta);
1011  if( ilayer<6 ) continue;
1012 
1013  int sp_trkid = v_sp_usedTrkId[iSeed];
1014  bool isUsedByTrk = (sp_trkid != -1);
1015  float sp_phi = v_sp_phi[iSeed];
1016 
1017  bool fill_out_of_pi = false;
1018  float sp_phi2 = 0;
1019  if( sp_phi < 0 ) {
1020  sp_phi2 = 2*TMath::Pi() + sp_phi;
1021  if( sp_phi2 < PHI_MAX ) fill_out_of_pi = true;
1022  }
1023  else {
1024  sp_phi2 = -2*TMath::Pi() + sp_phi;
1025  if( PHI_MIN < sp_phi2 ) fill_out_of_pi = true;
1026  }
1027  if( ilayer==6 ) {
1028  ly6_h2_nsp->Fill(sp_eta,sp_phi);
1029  if( fill_out_of_pi ) ly6_h2_nsp->Fill(sp_eta,sp_phi2);
1030  if( ! isUsedByTrk ) ly6_h2_nsp_notrk->Fill(sp_eta,sp_phi);
1031  if( ! isUsedByTrk && fill_out_of_pi) ly6_h2_nsp_notrk->Fill(sp_eta,sp_phi2);
1032  }
1033  if( ilayer==7 ) {
1034  ly7_h2_nsp->Fill(sp_eta,sp_phi);
1035  if( fill_out_of_pi ) ly7_h2_nsp->Fill(sp_eta,sp_phi2);
1036  if( ! isUsedByTrk ) ly7_h2_nsp_notrk->Fill(sp_eta,sp_phi);
1037  if( ! isUsedByTrk && fill_out_of_pi) ly7_h2_nsp_notrk->Fill(sp_eta,sp_phi2);
1038  }
1039  }
1040 
1041  ATH_MSG_VERBOSE("looking for ly6/ly6 doublet seeds");
1042 
1043  // (idx, sort/weight, eta, phi)
1044  std::vector<std::tuple<int,float,float,float>> QT;
1045 
1046  for(int ly6_ieta=1; ly6_ieta<=NBINS_ETA; ly6_ieta++) {
1047  float ly6_eta = (ly6_h2_nsp->GetXaxis()->GetBinLowEdge(ly6_ieta) + ly6_h2_nsp->GetXaxis()->GetBinUpEdge(ly6_ieta))/2.0;
1048  for(int ly6_iphi=1; ly6_iphi<=NBINS_PHI; ly6_iphi++) {
1049  float ly6_phi = (ly6_h2_nsp->GetYaxis()->GetBinLowEdge(ly6_iphi) + ly6_h2_nsp->GetYaxis()->GetBinUpEdge(ly6_iphi))/2.0;
1050 
1051  float ly6_nsp = ly6_h2_nsp ->GetBinContent(ly6_ieta,ly6_iphi);
1052  float ly6_nsp_notrk = ly6_h2_nsp_notrk->GetBinContent(ly6_ieta,ly6_iphi);
1053  float ly6_frac = ( ly6_nsp > 0 ) ? ly6_nsp_notrk / ly6_nsp : 0;
1054  if( ly6_nsp < 10 || ly6_frac < 0.85 ) continue;
1055 
1056  float ly7_frac_max = 0;
1057  float ly7_eta_max = 0;
1058  float ly7_phi_max = 0;
1059  for(int ly7_ieta=std::max(1,ly6_ieta-1); ly7_ieta<std::min(NBINS_ETA,ly6_ieta+1); ly7_ieta++) {
1060  for(int ly7_iphi=std::max(1,ly6_iphi-1); ly7_iphi<=std::min(NBINS_PHI,ly6_iphi+1); ly7_iphi++) {
1061  float ly7_nsp = ly7_h2_nsp ->GetBinContent(ly7_ieta,ly7_iphi);
1062  float ly7_nsp_notrk = ly7_h2_nsp_notrk->GetBinContent(ly7_ieta,ly7_iphi);
1063  float ly7_frac = ( ly7_nsp > 0 ) ? ly7_nsp_notrk / ly7_nsp : 0;
1064  if( ly7_nsp < 10 ) continue;
1065  if( ly7_frac > ly7_frac_max ) {
1066  ly7_frac_max = ly7_frac;
1067  ly7_eta_max = (ly7_h2_nsp->GetXaxis()->GetBinLowEdge(ly7_ieta) + ly7_h2_nsp->GetXaxis()->GetBinUpEdge(ly7_ieta))/2.0;
1068  ly7_phi_max = (ly7_h2_nsp->GetXaxis()->GetBinLowEdge(ly7_iphi) + ly7_h2_nsp->GetXaxis()->GetBinUpEdge(ly7_iphi))/2.0;
1069  }
1070  }
1071  }
1072  if( ly7_frac_max < 0.85 ) continue;
1073  //
1074  float wsum = ly6_frac + ly7_frac_max;
1075  float weta = (ly6_eta*ly6_frac + ly7_eta_max*ly7_frac_max) / wsum;
1076  float wphi = (ly6_phi*ly6_frac + ly7_phi_max*ly7_frac_max) / wsum;
1077  float w = wsum / 2.0;
1078  QT.push_back(std::make_tuple(-1,w,weta,wphi));
1079  }
1080  }
1081  ATH_MSG_VERBOSE("nr of ly6/ly7 doublet candidate seeds=" << QT.size() << ", doing clustering...");
1082 
1083  // sort
1084  std::sort(QT.begin(), QT.end(),
1085  [](const std::tuple<int,float,float,float>& lhs, const std::tuple<int,float,float,float>& rhs) {
1086  return std::get<1>(lhs) > std::get<1>(rhs); } );
1087 
1088  // clustering
1089  const double CLUSTCUT_DIST_SQUARED = 0.04; // const double CLUSTCUT_DIST = 0.2;
1090  const double CLUSTCUT_SEED_FRAC = 0.9;
1091 
1092  std::vector<float> seeds_wsum;
1093 
1094  for(unsigned int i=0; i<QT.size(); i++) {
1095  float phi = std::get<3>(QT[i]);
1096  float eta = std::get<2>(QT[i]);
1097  float w = std::get<1>(QT[i]);
1098  if(i==0) {
1099  seeds_eta.push_back(w*eta); seeds_phi.push_back(w*phi);
1100  seeds_wsum.push_back(w);
1101  continue;
1102  }
1103  const int IDX_INITIAL = 100;
1104  float dist2_min = 100.0;
1105  int idx_min = IDX_INITIAL;
1106  for(unsigned j=0; j<seeds_eta.size(); j++) {
1107  float ceta = seeds_eta[j]/seeds_wsum[j];
1108  float cphi = seeds_phi[j]/seeds_wsum[j];
1109  // intentionally calculate in this way as phi is defined beyond -Pi/Pi (no boundary)
1110  float deta = std::fabs(ceta-eta);
1111  float dphi = std::fabs(cphi-phi);
1112  float dist2 = dphi*dphi+deta*deta;
1113  if( dist2 < dist2_min ) {
1114  dist2_min = dist2;
1115  idx_min = j;
1116  }
1117  }
1118  int match_idx = IDX_INITIAL;
1119  if( idx_min != IDX_INITIAL ) {
1120  if( dist2_min < CLUSTCUT_DIST_SQUARED ) { match_idx = idx_min; }
1121  }
1122  if( match_idx == IDX_INITIAL ) {
1123  if( w > CLUSTCUT_SEED_FRAC && dist2_min > CLUSTCUT_DIST_SQUARED ) {
1124  seeds_eta.push_back(w*eta); seeds_phi.push_back(w*phi);
1125  seeds_wsum.push_back(w);
1126  }
1127  continue;
1128  }
1129  float new_eta = seeds_eta[match_idx] + w*eta;
1130  float new_phi = seeds_phi[match_idx] + w*phi;
1131  float new_wsum = seeds_wsum[match_idx] + w;
1132  seeds_eta[match_idx] = new_eta;
1133  seeds_phi[match_idx] = new_phi;
1134  seeds_wsum[match_idx] = new_wsum;
1135  }
1136  QT.clear();
1137  for(unsigned int i=0; i<seeds_eta.size(); i++) {
1138  float eta = seeds_eta[i] / seeds_wsum[i];
1139  float phi = seeds_phi[i] / seeds_wsum[i];
1140  seeds_eta[i] = eta;
1141  seeds_phi[i] = phi;
1142  if( phi < -TMath::Pi() ) phi = 2*TMath::Pi() + phi;
1143  if( phi > TMath::Pi() ) phi = -2*TMath::Pi() + phi;
1144  seeds_phi[i] = phi;
1145  }
1146  ATH_MSG_VERBOSE("after clustering, nr of seeds = " << seeds_eta.size());
1147 
1148  // delete overlap (can happen at phi=-Pi/Pi bounadry)
1149  std::vector<unsigned int> idx_to_delete;
1150  for(unsigned int i=0; i<seeds_eta.size(); i++) {
1151  if( std::find(idx_to_delete.begin(),idx_to_delete.end(),i) != idx_to_delete.end() ) continue;
1152  float eta_i = seeds_eta[i];
1153  float phi_i = seeds_phi[i];
1154  for(unsigned int j=i+1; j<seeds_eta.size(); j++) {
1155  if( std::find(idx_to_delete.begin(),idx_to_delete.end(),j) != idx_to_delete.end() ) continue;
1156  float eta_j = seeds_eta[j];
1157  float phi_j = seeds_phi[j];
1158  float dR2 = deltaR2(eta_i,phi_i,eta_j,phi_j);
1159  if( dR2 < CLUSTCUT_DIST_SQUARED ) idx_to_delete.push_back(j);
1160  }
1161  }
1162  ATH_MSG_VERBOSE("nr of duplicated seeds to be removed = " << idx_to_delete.size());
1163  if( idx_to_delete.size() > 0 ) {
1164  std::sort(idx_to_delete.begin(),idx_to_delete.end());
1165  for(unsigned int j=idx_to_delete.size(); j>0; j--) {
1166  unsigned int idx = idx_to_delete[j-1];
1167  seeds_eta.erase(seeds_eta.begin()+idx);
1168  seeds_phi.erase(seeds_phi.begin()+idx);
1169  }
1170  }
1171 
1172  ATH_MSG_VERBOSE("nr of ly6/ly7 seeds=" << seeds_eta.size());
1173 
1174  // return
1175  return StatusCode::SUCCESS;
1176 }

◆ getSPLayer()

int TrigHitDVHypoAlg::getSPLayer ( int  layer,
float  eta 
) const
private

Definition at line 342 of file TrigHitDVHypoAlg.cxx.

343 {
344  float abseta = std::fabs(eta);
345 
346  // if Pixel/SCT barrel, layer number is as it is
347  if( 0<=layer && layer <=7 ) {
348  ATH_MSG_VERBOSE("layer=" << layer << ", eta=" << abseta);
349  return layer;
350  }
351 
352  // for Pixel/SCT endcap, assign layer number of 0-7 depending on eta range
353 
354  int base = 0;
355 
356  //
357  const float PixBR6limit = 1.29612;
358  const float PixBR5limit = 1.45204;
359  const float PixBR4limit = 1.64909;
360  const float PixBR3limit = 1.90036;
361  const float PixBR2limit = 2.2146;
362 
363  // Pixel Endcap #1
364  base = 8;
365  if( layer==base || layer==(base+12) ) {
366  ATH_MSG_VERBOSE("Pix EC1, eta=" << abseta);
367  if( abseta > PixBR2limit ) return 2;
368  return 3;
369  }
370 
371  // Pixel Endcap #2
372  base = 9;
373  if( layer==base || layer==(base+12) ) {
374  ATH_MSG_VERBOSE("Pix EC2, eta=" << abseta);
375  if( abseta > PixBR2limit ) return 2;
376  return 3;
377  }
378 
379  // Pixel Endcap #3
380  base = 10;
381  if( layer==base || layer==(base+12) ) {
382  ATH_MSG_VERBOSE("Pix EC3, eta=" << abseta);
383  return 3;
384  }
385 
386  // SCT Endcap #1
387  base = 11;
388  if( layer==base || layer==(base+12) ) {
389  ATH_MSG_VERBOSE("Sct EC1, eta=" << abseta);
390  if( abseta < PixBR6limit ) return 7;
391  else if( abseta < PixBR5limit ) return 6;
392  return 5;
393  }
394 
395  // SCT Endcap #2
396  base = 12;
397  if( layer==base || layer==(base+12) ) {
398  ATH_MSG_VERBOSE("Sct EC2, eta=" << abseta);
399  if( abseta < PixBR5limit ) return 7;
400  else if( abseta < PixBR4limit ) return 6;
401  return 4;
402  }
403 
404  // SCT Endcap #3
405  base = 13;
406  if( layer==base || layer==(base+12) ) {
407  ATH_MSG_VERBOSE("Sct EC3, eta=" << abseta);
408  if( abseta < PixBR4limit ) return 7;
409  return 5;
410  }
411 
412  // SCT Endcap #4
413  base = 14;
414  if( layer==base || layer==(base+12) ) {
415  ATH_MSG_VERBOSE("Sct EC4, eta=" << abseta);
416  if( abseta < PixBR4limit ) return 6;
417  else if( abseta < PixBR3limit ) return 6;
418  return 4;
419  }
420 
421  // SCT Endcap #5
422  base = 15;
423  if( layer==base || layer==(base+12) ) {
424  ATH_MSG_VERBOSE("Sct EC5, eta=" << abseta);
425  if( abseta < PixBR3limit ) return 7;
426  return 5;
427  }
428 
429  // SCT Endcap #6
430  base = 16;
431  if( layer==base || layer==(base+12) ) {
432  ATH_MSG_VERBOSE("Sct EC6, eta=" << abseta);
433  if( abseta < PixBR3limit ) return 6;
434  return 4;
435  }
436 
437  // SCT Endcap #7
438  base = 17;
439  if( layer==base || layer==(base+12) ) {
440  ATH_MSG_VERBOSE("Sct EC7, eta=" << abseta);
441  if( abseta < PixBR3limit ) return 7;
442  return 5;
443  }
444 
445  // SCT Endcap #8
446  base = 18;
447  if( layer==base || layer==(base+12) ) {
448  ATH_MSG_VERBOSE("Sct EC8, eta=" << abseta);
449  if( abseta < PixBR3limit ) return 7;
450  return 6;
451  }
452 
453  // SCT Endcap #9
454  base = 19;
455  if( layer==base || layer==(base+12) ) {
456  ATH_MSG_VERBOSE("Sct EC9, eta=" << abseta);
457  return 7;
458  }
459 
460  return 0;
461 }

◆ hypoBaseOutputProcessing()

StatusCode HypoBase::hypoBaseOutputProcessing ( SG::WriteHandle< TrigCompositeUtils::DecisionContainer > &  outputHandle,
MSG::Level  lvl = MSG::DEBUG 
) const
protectedinherited

Base class function to be called once slice specific code has finished. Handles debug printing and validation.

Definition at line 33 of file HypoBase.cxx.

33  {
34 
35  ATH_CHECK( printDebugInformation(outputHandle, lvl) );
36 
37  if (m_runtimeValidation) {
38  ATH_CHECK( runtimeValidation(outputHandle, msg()) );
39  }
40 
41  return StatusCode::SUCCESS;
42 }

◆ initialize()

StatusCode TrigHitDVHypoAlg::initialize ( )
overridevirtual

Definition at line 52 of file TrigHitDVHypoAlg.cxx.

53 {
54  m_tools_lowest_jetEt = 1000;
55  m_tools_loosest_wp = 0;
56  CHECK( m_hypoTools.retrieve() );
57  for ( auto & tool: m_hypoTools ) {
58  ATH_MSG_VERBOSE( "+++++ Hypo Tool name: " << tool->name() );
59  std::cmatch results;
60  if( std::regex_search(tool->name().c_str(),results,std::regex("hitdvjet(\\d+)_(\\w+)_")) ) {
61  std::string sth = results[1].str();
62  std::string swp = results[2].str();
63  ATH_MSG_VERBOSE( " thres = " << sth << ", wp = " << swp );
64  int thres = std::stoi(sth);
65  if( thres < m_tools_lowest_jetEt ) m_tools_lowest_jetEt = thres;
66  if( swp == "loose" && m_tools_loosest_wp >= 1 ) m_tools_loosest_wp = 1;
67  if( swp == "medium" && m_tools_loosest_wp >= 2 ) m_tools_loosest_wp = 2;
68  if( swp == "tight" && m_tools_loosest_wp >= 3 ) m_tools_loosest_wp = 3;
69  }
70  }
71  ATH_MSG_DEBUG( "Lowest jetEt used in hypo tools = " << m_tools_lowest_jetEt << " (GeV)" );
72  ATH_MSG_DEBUG( "Loosest WP used in hypo tools = " << m_tools_loosest_wp << " (loose=1,medium=2,tight=3)");
73  // loose : eta<2.0, SP seed=true, BDT eff=0.9
74  // medium: eta<2.0, SP seed=false, BDT eff=0.75
75  // tight : eta<1.0, SP seed=false, BDT eff=0.75
76 
77  CHECK( m_jetsKey.initialize() );
78  CHECK( m_hitDVKey.initialize());
79  CHECK( m_tracksKey.initialize());
80  CHECK( m_lumiDataKey.initialize(!m_isMC) );
81  ATH_CHECK( m_jetRoiCollectionKey.initialize(m_doHitDV_Seeding) );
82 
83  if ( !m_monTool.empty() ) CHECK( m_monTool.retrieve() );
84 
85  ATH_CHECK(m_beamSpotKey.initialize());
86  ATH_CHECK(m_spacePointTool.retrieve() );
87 
88 
89  for (auto& reader : m_tmva_reader) {
90  // Create two instances with same variables
91  auto tmva = std::array{std::make_unique<TMVA::Reader>( "!Color:!Silent" ),
92  std::make_unique<TMVA::Reader>( "!Color:!Silent" )};
93  for (auto& t : tmva) {
94  t->AddVariable("n_track_qual", &reader.n_track_qual);
95  t->AddVariable("ly0_sp_frac", &reader.ly0_sp_frac);
96  t->AddVariable("ly1_sp_frac", &reader.ly1_sp_frac);
97  t->AddVariable("ly2_sp_frac", &reader.ly2_sp_frac);
98  t->AddVariable("ly3_sp_frac", &reader.ly3_sp_frac);
99  t->AddVariable("ly4_sp_frac", &reader.ly4_sp_frac);
100  t->AddVariable("ly5_sp_frac", &reader.ly5_sp_frac);
101  t->AddVariable("ly6_sp_frac", &reader.ly6_sp_frac);
102  t->AddVariable("ly7_sp_frac", &reader.ly7_sp_frac);
103  };
104  reader.tmva_0eta1 = std::move(tmva[0]);
105  reader.tmva_1eta2 = std::move(tmva[1]);
106 
107  // --- Book the MVA methods specific to eta range
108  const std::string tuningVer = "v22a"; // "v21a";
109  const std::string methodName = "BDT method";
110 
111  const std::string weightfile_0eta1 = PathResolver::find_calib_file(
112  "TrigHitDVHypo/HitDV.BDT.weights.0eta1." + tuningVer + ".xml");
113  const std::string weightfile_1eta2 = PathResolver::find_calib_file(
114  "TrigHitDVHypo/HitDV.BDT.weights.1eta2." + tuningVer + ".xml");
115  ATH_MSG_DEBUG("opening weightfile = " << weightfile_0eta1);
116  ATH_MSG_DEBUG("opening weightfile = " << weightfile_1eta2);
117  reader.tmva_0eta1->BookMVA(methodName, weightfile_0eta1);
118  reader.tmva_1eta2->BookMVA(methodName, weightfile_1eta2);
119  }
120 
121  return StatusCode::SUCCESS;
122 }

◆ inputHandles()

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

Return this algorithm's input handles.

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

◆ isClonable()

bool AthReentrantAlgorithm::isClonable ( ) const
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in Simulation::BeamEffectsAlg, InDet::SiTrackerSpacePointFinder, InDet::SCT_Clusterization, InDet::SiSPSeededTrackFinder, SCTRawDataProvider, InDet::GNNSeedingTrackMaker, SCT_PrepDataToxAOD, RoIBResultToxAOD, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, InDet::SiSPGNNTrackMaker, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, ITkStripCablingAlg, SCTEventFlagWriter, SCT_ConditionsSummaryTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_TdaqEnabledTestAlg, SCT_SiliconConditionsTestAlg, SCTSiLorentzAngleTestAlg, SCT_ByteStreamErrorsTestAlg, SCT_ConditionsParameterTestAlg, SCT_FlaggedConditionTestAlg, SCT_StripVetoTestAlg, SCT_RawDataToxAOD, and SCTSiPropertiesTestAlg.

Definition at line 44 of file AthReentrantAlgorithm.cxx.

45 {
46  // Reentrant algorithms are clonable.
47  return true;
48 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< Gaudi::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< Gaudi::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< Gaudi::Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

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

◆ printBangs()

void HypoBase::printBangs ( MsgStream &  msg)
staticprivateinherited

Print header line.

Definition at line 388 of file HypoBase.cxx.

388  {
389  msg << MSG::ERROR << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endmsg;
390 }

◆ printDebugInformation()

StatusCode HypoBase::printDebugInformation ( SG::WriteHandle< TrigCompositeUtils::DecisionContainer > &  outputHandle,
MSG::Level  lvl 
) const
privateinherited

Common base function to print information on chains passed by objects considered in the hypo.

Definition at line 404 of file HypoBase.cxx.

404  {
405  if (msgLvl(lvl)) {
406  msg() << lvl;
407  msg() << "Exiting with " << outputHandle->size() <<" Decision objects" << endmsg;
408  size_t count = 0;
409  for (const Decision* d : *outputHandle){
410  DecisionIDContainer objDecisions;
411  decisionIDs( d, objDecisions );
412  msg() << "Number of positive decisions for Decision object #" << count++ << ": " << objDecisions.size() << endmsg;
413  for (const TrigCompositeUtils::DecisionID id : objDecisions ) {
414  msg() << " --- Passes: " << HLT::Identifier( id ) << endmsg;
415  }
416  }
417  }
418  return StatusCode::SUCCESS;
419 }

◆ printErrorHeader()

void HypoBase::printErrorHeader ( const ElementLink< TrigCompositeUtils::DecisionContainer > &  dEL,
MsgStream &  msg 
)
staticprivateinherited

A problem was found, print common output data.

Definition at line 393 of file HypoBase.cxx.

395 {
396  printBangs(msg);
397  msg << MSG::ERROR << "! RUNTIME TRIGGER NAVIGATION VALIDATION ERROR" << endmsg;
398  msg << MSG::ERROR << "! Caused by Decision with index:" << (*dEL)->index() << endmsg;
399  msg << MSG::ERROR << "! From collection:" << dEL.dataID() << endmsg;
400  msg << MSG::ERROR << "! " << **dEL << endmsg;
401 }

◆ recursiveValidateGraph()

StatusCode HypoBase::recursiveValidateGraph ( const ElementLink< TrigCompositeUtils::DecisionContainer > &  dEL,
MsgStream &  msg,
bool  onlyValidateOneStep,
bool  runTwoConversion,
size_t  callDepth,
std::set< const TrigCompositeUtils::Decision * > &  fullyExploredFrom 
)
staticprivateinherited

Execute all checks on one node in the graph, d, then recursive call self on all parent nodes up to L1.

Definition at line 69 of file HypoBase.cxx.

75 {
76  if (onlyValidateOneStep && callDepth > 0) {
77  if ((*dEL)->name() == hypoAlgNodeName()) {
78  // Validation is called from HypoAlg nodes. So if we have reached the _previous_ HypoAlg node, then we have already
79  // validated back from here in the past. Can stop at this point.
80  return StatusCode::SUCCESS;
81  }
82  }
83 
84  // Check logical flow at this place in the graph
85  if ((*dEL)->name() == hypoAlgNodeName()) {
86  // Check that all Hypo Decisions produced here satisfy the more-strict all-parent logical flow
87  if ( validateLogicalFlow(dEL, msg, kRequireAll).isFailure() ) {
88  return StatusCode::FAILURE;
89  }
90  } else {
91  // (looser requirement of one-valid-parent-with-decision than we had when we knew that d corresponded to a HypoAlg output)
92  if ( validateLogicalFlow(dEL, msg, kRequireOne).isFailure() ) {
93  return StatusCode::FAILURE;
94  }
95  }
96 
97  // Check my IDs
98  if ( validateDecisionIDs(dEL, msg).isFailure() ) {
99  return StatusCode::FAILURE;
100  }
101  if ( validateDuplicatedDecisionID(dEL, msg).isFailure() ) {
102  return StatusCode::FAILURE;
103  }
104 
105  // Check my linking
106  if( validateParentLinking(dEL, msg, runTwoConversion).isFailure() ) {
107  return StatusCode::FAILURE;
108  }
109  if ( validateHasLinks(dEL, msg).isFailure() ) {
110  return StatusCode::FAILURE;
111  }
112 
113  // Continue upstream
114  const std::vector<ElementLink<DecisionContainer>> seeds = (*dEL)->objectCollectionLinks<DecisionContainer>(seedString());
115  for (const ElementLink<DecisionContainer>& seed : seeds) {
116  if (fullyExploredFrom.count( (*seed) ) == 1) {
117  continue; // Already fully explored from this seed and up
118  }
119  if ( not seed.isValid() ) {
120  msg << MSG::ERROR << "Invalid seed element link in recursiveValidateGraph" << endmsg;
121  return StatusCode::FAILURE;
122  }
123  if ( recursiveValidateGraph(seed, msg, onlyValidateOneStep, runTwoConversion, callDepth + 1, fullyExploredFrom).isFailure() ) {
124  return StatusCode::FAILURE;
125  }
126  }
127 
128  fullyExploredFrom.insert( *dEL );
129  return StatusCode::SUCCESS;
130 }

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ runtimeValidation()

StatusCode HypoBase::runtimeValidation ( SG::WriteHandle< TrigCompositeUtils::DecisionContainer > &  outputHandle,
MsgStream &  msg,
bool  onlyValidateOneStep = true,
bool  runTwoConversion = false 
)
staticinherited

Executes all individual runtime tests.

Definition at line 45 of file HypoBase.cxx.

49 {
50  // Detailed checks on the output container of this HypoAlg
51  std::set<const Decision*> fullyExploredFrom; // Cache used to avoid exploring regions of the graph more than once
52  for (const Decision* d : *outputHandle) {
53  const DecisionContainer* dContainer = dynamic_cast<const DecisionContainer*>( d->container() );
54  const ElementLink<DecisionContainer> dEL = ElementLink<DecisionContainer>(*dContainer, d->index());
55  if (not dEL.isValid()) {
56  msg << MSG::ERROR << "Invalid seed element link in recursiveValidateGraph" << endmsg;
57  return StatusCode::FAILURE;
58  }
59  // Check that we can reach L1 along all navigation paths up from each Decision
60  // and validate these Decisions on the way up too.
61  if (recursiveValidateGraph(dEL, msg, onlyValidateOneStep, runTwoConversion, 0, fullyExploredFrom).isFailure()) {
62  return StatusCode::FAILURE;
63  }
64  }
65  return StatusCode::SUCCESS;
66 }

◆ selectSeedsNearby()

StatusCode TrigHitDVHypoAlg::selectSeedsNearby ( const std::vector< HitDVSeed > &  hitDVSeedsContainer,
std::vector< float > &  jetSeeds_eta,
std::vector< float > &  jetSeeds_phi,
std::vector< float > &  jetSeeds_pt 
) const
private

Definition at line 948 of file TrigHitDVHypoAlg.cxx.

950 {
951  std::vector<unsigned int> idx_to_delete;
952  for(unsigned int idx=0; idx<jetSeeds_eta.size(); ++idx) {
953  const float DR_SQUARED_CUT_TO_FTFSEED = 0.09; // const float DR_CUT_TO_FTFSEED = 0.3;
954  float eta = jetSeeds_eta[idx];
955  float phi = jetSeeds_phi[idx];
956  float dR2min = 9999;
957  for ( const auto& seed : hitDVSeedsContainer ) {
958  float dR2 = deltaR2(eta,phi,seed.eta,seed.phi);
959  if( dR2 < dR2min ) dR2min = dR2;
960  }
961  if( dR2min > DR_SQUARED_CUT_TO_FTFSEED ) idx_to_delete.push_back(idx);
962  }
963  if( idx_to_delete.size() > 0 ) {
964  std::sort(idx_to_delete.begin(),idx_to_delete.end());
965  for(unsigned int j=idx_to_delete.size(); j>0; j--) {
966  unsigned int idx = idx_to_delete[j-1];
967  jetSeeds_eta.erase(jetSeeds_eta.begin()+idx);
968  jetSeeds_phi.erase(jetSeeds_phi.begin()+idx);
969  if( jetSeeds_pt.size() > 0 ) jetSeeds_pt.erase(jetSeeds_pt.begin()+idx);
970  }
971  }
972  return StatusCode::SUCCESS;
973 }

◆ setFilterPassed()

virtual void AthReentrantAlgorithm::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

139  {
140  execState( ctx ).setFilterPassed( state );
141  }

◆ sysExecute()

StatusCode AthReentrantAlgorithm::sysExecute ( const EventContext &  ctx)
overridevirtualinherited

Execute an algorithm.

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

Definition at line 67 of file AthReentrantAlgorithm.cxx.

68 {
69  return Gaudi::Algorithm::sysExecute (ctx);
70 }

◆ sysInitialize()

StatusCode HypoBase::sysInitialize ( )
overridevirtualinherited

initialise this base class

Reimplemented from AthReentrantAlgorithm.

Definition at line 24 of file HypoBase.cxx.

24  {
25  CHECK( AthReentrantAlgorithm::sysInitialize() ); // initialise base class
26  CHECK( m_input.initialize() );
27  ATH_MSG_DEBUG("HypoBase::sysInitialize() Will consume decision: " << m_input.key() );
28  CHECK( m_output.initialize() );
29  ATH_MSG_DEBUG("HypoBase::sysInitialize() And produce decision: " << m_output.key() );
30  return StatusCode::SUCCESS;
31 }

◆ sysStart()

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

Handle START transition.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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  }

◆ validateDecisionIDs()

StatusCode HypoBase::validateDecisionIDs ( const ElementLink< TrigCompositeUtils::DecisionContainer > &  dEL,
MsgStream &  msg 
)
staticprivateinherited

Ensure that all present IDs correspond to configured chains.

Definition at line 207 of file HypoBase.cxx.

209 {
210  // All numeric IDs must correspond to a know, configured, HLT chain
211  DecisionIDContainer decisionIDSet;
212  decisionIDs(*dEL, decisionIDSet);
213  for (const DecisionID id : decisionIDSet) {
214  const std::string chain = HLT::Identifier( id ).name();
215  if (!isChainId(chain) and !isLegId(chain)) {
216  printErrorHeader(dEL, msg);
217  msg << MSG::ERROR << "! Decision contains an ID which does not correspond to a configured chain or a configured chain-leg: " << HLT::Identifier( id ) << endmsg;
218  msg << MSG::ERROR << "! SOLUTION: Locate the producer of the collection, investigate how this bad ID could have been added." << endmsg;
219  printBangs(msg);
220  return StatusCode::FAILURE;
221  }
222  }
223  return StatusCode::SUCCESS;
224 }

◆ validateDuplicatedDecisionID()

StatusCode HypoBase::validateDuplicatedDecisionID ( const ElementLink< TrigCompositeUtils::DecisionContainer > &  dEL,
MsgStream &  msg 
)
staticprivateinherited

Ensure that no space is being wasted by duplicated DecisionIDs in any Decision objects.

Definition at line 227 of file HypoBase.cxx.

229 {
230  // Persistent vector storage does not guarantee against duplicate entries
231  DecisionIDContainer decisionIDSet;
232  decisionIDs(*dEL, decisionIDSet);
233  if (decisionIDSet.size() != (*dEL)->decisions().size()) {
234  printErrorHeader(dEL, msg);
235  msg << MSG::ERROR << "! Decision contains duplicate DecisionIDs." << endmsg;
236  msg << MSG::ERROR << "! SOLUTION: If combining DecisionIDs from multiple parents, de-duplicate the internal std::vector<DecisionID> of 'Decision* d' with:" << endmsg;
237  msg << MSG::ERROR << "! TrigCompositeUtils::insertDecisionIDs(DecisionIDContainer(), d);" << endmsg;
238  printBangs(msg);
239  return StatusCode::FAILURE;
240  }
241  return StatusCode::SUCCESS;
242 }

◆ validateHasLinks()

StatusCode HypoBase::validateHasLinks ( const ElementLink< TrigCompositeUtils::DecisionContainer > &  dEL,
MsgStream &  msg 
)
staticprivateinherited

Ensure all Decisions have the named ElementLink graph edges which they are required to by spec.

Definition at line 336 of file HypoBase.cxx.

338 {
339  const std::string& name = (*dEL)->name();
340  if (name == hypoAlgNodeName()) {
341 
342  // Check that I have a "feature"
343  if ((*dEL)->hasObjectLink( featureString() )) {
344  return StatusCode::SUCCESS;
345  }
346  printErrorHeader(dEL, msg);
347  msg << MSG::ERROR << "! Decision has no '" << featureString() << "' ElementLink." << endmsg;
348  msg << MSG::ERROR << "! Every Decision created by a HypoAlg must correspond to some physics object, and be linked to the object." << endmsg;
349  msg << MSG::ERROR << "! SOLUTION: Ensure that all produced Decision objects are assigned their feature:" << endmsg;
350  msg << MSG::ERROR << "! SOLUTION: decision->setObjectLink<MY_FEATURE_CONTANER_TYPE>(featureString(), MY_FEATURE_ELEMENT_LINK);" << endmsg;
351  printBangs(msg);
352  return StatusCode::FAILURE;
353 
354  } else if (name == inputMakerNodeName()) {
355 
356  // This requirement is dropped for empty input makers to avoid unnecessary graph clutter.
357  bool exempt = false;
358  if ((*dEL)->hasDetail<int32_t>("isEmpty") and (*dEL)->getDetail<int32_t>("isEmpty") == 1) {
359  exempt = true;
360  }
361 
362  if (not (*dEL)->hasObjectLink( roiString() ) and not exempt) {
363  printErrorHeader(dEL, msg);
364  msg << MSG::ERROR << "! Decision has no '" << roiString() << "' ElementLink." << endmsg;
365  msg << MSG::ERROR << "! Every Decision created by a InputMaker must link to the ROI which reconstruction will run on for that Decision object in this Step." << endmsg;
366  msg << MSG::ERROR << "! It can be the FullScan ROI created by the HLTSeeding (FSNOSEED) if no other suitable ROI exists." << endmsg;
367  msg << MSG::ERROR << "! SOLUTION: Check the configuration of InputMakerForRoI or EventViewCreatorAlgorithm responsible for creating this Decision Object" << endmsg;
368  msg << MSG::ERROR << "! SOLUTION: The algorithm must have an ROITool which must attach an '"<< roiString() <<"' link to each Decision Object" << endmsg;
369  printBangs(msg);
370  }
371 
372  } else if (name == hltSeedingNodeName()) {
373 
374  if (not (*dEL)->hasObjectLink( initialRoIString() )) {
375  printErrorHeader(dEL, msg);
376  msg << MSG::ERROR << "! Decision has no '" << initialRoIString() << "' ElementLink." << endmsg;
377  msg << MSG::ERROR << "! Every Decision created by the HLTSeeding must link to the initial ROI which caused it to be created." << endmsg;
378  msg << MSG::ERROR << "! This includes the Decision Object created to represent the Full-Scan/NoSeed (FSNOSEED) ROI." << endmsg;
379  msg << MSG::ERROR << "! SOLUTION: Check the configuration of the HLTSeeding tool responsible for creating this Decision Object" << endmsg;
380  printBangs(msg);
381  }
382 
383  }
384  return StatusCode::SUCCESS;
385 }

◆ validateLogicalFlow()

StatusCode HypoBase::validateLogicalFlow ( const ElementLink< TrigCompositeUtils::DecisionContainer > &  dEL,
MsgStream &  msg,
const LogicalFlowCheckMode  mode 
)
staticprivateinherited

Ensure that all DecisionIDs have propagated correctly from their parent.

Definition at line 245 of file HypoBase.cxx.

248 {
249  // Do not need to validate for L1 Decisions as these have no parents
250  if ((*dEL)->name() == hltSeedingNodeName()) {
251  return StatusCode::SUCCESS;
252  }
253 
254  // Get all my passed DecisionIDs
255  DecisionIDContainer decisionIDSet;
256  decisionIDs(*dEL, decisionIDSet);
257  const std::vector<ElementLink<DecisionContainer>> seeds = (*dEL)->objectCollectionLinks<DecisionContainer>(seedString());
258  for (const DecisionID id : decisionIDSet) {
259  // For each chain that I'm passing, check how many of my parents were also passing the chain
260  size_t parentsWithDecision = 0;
261  for (const ElementLink<DecisionContainer>& seed : seeds) {
262  if ( not seed.isValid() ) {
263  msg << MSG::ERROR << "Invalid seed element link in recursiveValidateGraph" << endmsg;
264  return StatusCode::FAILURE;
265  }
266  DecisionIDContainer seedIDSet;
267  decisionIDs(*seed, seedIDSet);
268  // Id may be a chain-ID (represents a whole chain) or a leg-ID (represents just a single leg of a multi-leg chain)
269  // Is ID is in this parent's set of passed IDs?
270  // Or, (if ID is a leg-ID) is the chain-ID of leg-ID in the parent's set of passed IDs?
271  if (passed(id, seedIDSet) or passed(getIDFromLeg(id).numeric(), seedIDSet)) {
272  ++parentsWithDecision;
273  }
274  else{ // Or, for each of the seed IDs, if the seed ID is a leg-ID, is the seed chain-ID of the seed leg-ID the same as ID?
275  for (auto sid: seedIDSet){
276  if (getIDFromLeg(sid).numeric() == id){
277  ++parentsWithDecision;
278  break;
279  }
280  }
281  }
282  }
283 
284  if (mode == kRequireOne && parentsWithDecision == 0) {
285  // InputMakers may merge multiple of their input collections in order to run reconstruction on a common set of ROI (for example)
286  // So the DecisionIDs may have come from any one or more of the inputs. But zero is not allowed.
287  printErrorHeader(dEL, msg);
288  msg << MSG::ERROR << "! This Decision object is not respecting logical flow of DecisionIDs for chain: " << HLT::Identifier( id ) << endmsg;
289  msg << MSG::ERROR << "! This chain's DecisionID can not be found in any parents of this Decision object:" << endmsg;
290  size_t seed_n = 0;
291  for (const ElementLink<DecisionContainer>& seed : seeds) {
292  msg << MSG::ERROR << "! Index:" << (*seed)->index() << " from collection:" << seed.dataID() << endmsg;
293  msg << MSG::ERROR << "! " << **seed << endmsg;
294  DecisionIDContainer objDecisions;
295  decisionIDs(*seed, objDecisions);
296  for (const TrigCompositeUtils::DecisionID id : objDecisions ) {
297  msg << "! --- Passing in parent #" << seed_n << ": " << HLT::Identifier( id ) << endmsg;
298  }
299  ++seed_n;
300  }
301  msg << MSG::ERROR << "! SOLUTION: Ensure that the producer of this Decision object only adds DecisionIDs"
302  " which were present in at least one of its parents." << endmsg;
303  printBangs(msg);
304  return StatusCode::FAILURE;
305  } else if (mode == kRequireAll && parentsWithDecision != seeds.size()) {
306  // HypoAlgs may form a new physics object from multiple objects in the previous step
307  // (think a BPhysics object whose parents are two Decisions which each correspond to a different L1 MU RoI,
308  // both ROI need to be in active state for the chain, if the chain's HypoTool considers the BPhysics object)
309  // This case requires *all* of the physics objects which are being combined together to be active for the chain
310  // in order to preserve logical flow
311  printErrorHeader(dEL, msg);
312  msg << MSG::ERROR << "! This Decision object is not respecting logical flow of DecisionIDs for chain: " << HLT::Identifier( id ) << endmsg;
313  msg << MSG::ERROR << "! As this Decision object represents the output of a HypoAlg, it must respect logical flow on all "
314  << seeds.size() << " of its parent(s):" << endmsg;
315  size_t seed_n = 0;
316  for (const ElementLink<DecisionContainer>& seed : seeds) {
317  msg << MSG::ERROR << "! Index:" << (*seed)->index() << " from collection:" << seed.dataID() << endmsg;
318  msg << MSG::ERROR << "! " << **seed << endmsg;
319  DecisionIDContainer objDecisions;
320  decisionIDs(*seed, objDecisions);
321  for (const TrigCompositeUtils::DecisionID id : objDecisions ) {
322  msg << "! --- Passing in parent #" << seed_n << ": " << HLT::Identifier( id ) << endmsg;
323  }
324  ++seed_n;
325  }
326  msg << MSG::ERROR << "! SOLUTION: Ensure that the HypoTool responsible for " << HLT::Identifier( id )
327  << " in this HypoAlg only runs if this ID is present in all parent decisions." << endmsg;
328  printBangs(msg);
329  return StatusCode::FAILURE;
330  }
331  }
332  return StatusCode::SUCCESS;
333 }

◆ validateParentLinking()

StatusCode HypoBase::validateParentLinking ( const ElementLink< TrigCompositeUtils::DecisionContainer > &  dEL,
MsgStream &  msg,
bool  runTwoConversion 
)
staticprivateinherited

Ensure that the Decision has at least one valid parent, unless it is a initial Decision from the HLTSeeding.

Definition at line 133 of file HypoBase.cxx.

136 {
137  const std::vector<ElementLink<DecisionContainer>> seeds = (*dEL)->objectCollectionLinks<DecisionContainer>(seedString());
138  // All Decision object must have at least one parent, unless they are the initial set of objects created by the HLTSeeding
139  const std::string& name = (*dEL)->name();
140  if (seeds.size() == 0 && name != hltSeedingNodeName()) {
141  printErrorHeader(dEL, msg);
142  msg << MSG::ERROR << "! Decision has zero parents. This is only allowed for the initial Decisions created by the HLTSeeding." << endmsg;
143  msg << MSG::ERROR << "! SOLUTION: Attach parent Decision(s) with TrigCompositeUtils::linkToPrevious" << endmsg;
144  printBangs(msg);
145  return StatusCode::FAILURE;
146  }
147 
148  if (name == hltSeedingNodeName()) {
149  if (seeds.size() > 0) {
150  printErrorHeader(dEL, msg);
151  msg << MSG::ERROR << "! Decision has parents. This is not allowed for the initial Decisions created by the HLTSeeding." << endmsg;
152  msg << MSG::ERROR << "! SOLUTION: Check HLTSeeding, no where should it be adding a parent link." << endmsg;
153  printBangs(msg);
154  return StatusCode::FAILURE;
155  }
156  return StatusCode::SUCCESS;
157  }
158 
159  static const std::set<std::string> expectedParentsFilter = {hypoAlgNodeName(), comboHypoAlgNodeName(), hltSeedingNodeName()};
160  static const std::set<std::string> expectedParentsInputMaker = {filterNodeName()};
161  static const std::set<std::string> expectedParentsHypoAlg = {inputMakerNodeName()};
162  static const std::set<std::string> expectedParentsComboHypoAlg = {hypoAlgNodeName(), inputMakerNodeName(), hltSeedingNodeName()}; // TODO check hltSeedingNodeName(), needed for newJO
163  static const std::set<std::string> expectedParentsSummaryFilter = {hypoAlgNodeName(), comboHypoAlgNodeName(), hltSeedingNodeName()};
164  static const std::set<std::string> expectedParentsSummaryPassed = {"SF"}; // TODO change to summaryFilterNodeName() when merged
165 
166  const std::set<std::string>* expectedParentsPtr = nullptr;
167  if (name == filterNodeName()) {
168  expectedParentsPtr = &expectedParentsFilter;
169  } else if (name == inputMakerNodeName() and !runTwoConversion) {
170  expectedParentsPtr = &expectedParentsInputMaker;
171  } else if (name == inputMakerNodeName() and runTwoConversion) {
172  expectedParentsPtr = &expectedParentsFilter; // We don't have Filter nodes in the R2->R3 conversion
173  } else if (name == hypoAlgNodeName()) {
174  expectedParentsPtr = &expectedParentsHypoAlg;
175  } else if (name == comboHypoAlgNodeName()) {
176  expectedParentsPtr = &expectedParentsComboHypoAlg;
177  } else if (name == "SF") { // TODO change to summaryFilterNodeName() when merged
178  expectedParentsPtr = &expectedParentsSummaryFilter;
179  } else if (name == "HLTPassRaw") { // TODO change to summaryPassNodeNameString() when merged
180  expectedParentsPtr = &expectedParentsSummaryPassed;
181  } else {
182  printErrorHeader(dEL, msg);
183  msg << MSG::ERROR << "! Invalid Node name '" << name << "'." << endmsg;
184  msg << MSG::ERROR << "! SOLUTION: Find the alg which made a node with this name. Allowed named may be found in TrigCompositeUtils.h, See:'Constant string literals used within the HLT'." << endmsg;
185  printBangs(msg);
186  return StatusCode::FAILURE;
187  }
188 
189  for (const ElementLink<DecisionContainer>& seed : seeds) {
190  if (expectedParentsPtr->count( (*seed)->name() ) == 0) {
191  printErrorHeader(dEL, msg);
192  msg << MSG::ERROR << "! Invalid linking from node with name '" << name << "' to one with name '"<< (*seed)->name() << "'." << endmsg;
193  msg << MSG::ERROR << "! Allowed seed names are:" << endmsg;
194  for (const std::string& allowed : *expectedParentsPtr) {
195  msg << MSG::ERROR << "! " << allowed << endmsg;
196  }
197  msg << MSG::ERROR << "! SOLUTION: Find where this invalid parent was added and correct it." << endmsg;
198  printBangs(msg);
199  return StatusCode::FAILURE;
200  }
201  }
202 
203  return StatusCode::SUCCESS;
204 }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

SG::SlotSpecificObj<TMVAReader> m_tmva_reader TrigHitDVHypoAlg::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 124 of file TrigHitDVHypoAlg.h.

◆ m_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> TrigHitDVHypoAlg::m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }
private

Definition at line 138 of file TrigHitDVHypoAlg.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doHitDV_Seeding

bool TrigHitDVHypoAlg::m_doHitDV_Seeding = true
private

Definition at line 135 of file TrigHitDVHypoAlg.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthReentrantAlgorithm::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

◆ m_hitDVKey

SG::WriteHandleKey<xAOD::TrigCompositeContainer> TrigHitDVHypoAlg::m_hitDVKey {this, "HitDV", "HLT_HitDV", ""}
private

Definition at line 77 of file TrigHitDVHypoAlg.h.

◆ m_hitDVLinkName

Gaudi::Property<std::string> TrigHitDVHypoAlg::m_hitDVLinkName {this, "hitDVLinkName", "HitDVSeedLink", "Name of the link to HitDVContainer. Used by ViewCreatorROITool."}
private

Definition at line 90 of file TrigHitDVHypoAlg.h.

◆ m_hypoTools

ToolHandleArray< TrigHitDVHypoTool > TrigHitDVHypoAlg::m_hypoTools {this, "HypoTools", {}, "Tools to perform selection"}
private

Definition at line 73 of file TrigHitDVHypoAlg.h.

◆ m_input

SG::ReadHandleKey<TrigCompositeUtils::DecisionContainer> HypoBase::m_input { this, "HypoInputDecisions", "UNSPECIFIED_INPUT", "Input Decision (implicit)" }
privateinherited

input decisions

Definition at line 101 of file HypoBase.h.

◆ m_isMC

Gaudi::Property<bool> TrigHitDVHypoAlg::m_isMC {this, "isMC", false, "Real data or MC"}
private

Definition at line 85 of file TrigHitDVHypoAlg.h.

◆ m_jetRoiCollectionKey

SG::ReadHandleKey<xAOD::jFexSRJetRoIContainer> TrigHitDVHypoAlg::m_jetRoiCollectionKey {this, "jFexSRJetRoI", "", ""}
private

Definition at line 137 of file TrigHitDVHypoAlg.h.

◆ m_jetSeed_etaMax

Gaudi::Property<float> TrigHitDVHypoAlg::m_jetSeed_etaMax {this, "jetSeed_etaMin", 2.0, "Maximum eta for jet seed"}
private

Definition at line 88 of file TrigHitDVHypoAlg.h.

◆ m_jetSeed_ptMin

Gaudi::Property<float> TrigHitDVHypoAlg::m_jetSeed_ptMin {this, "jetSeed_ptMin", 50.0, "Minimum pT for jet seed"}
private

Definition at line 87 of file TrigHitDVHypoAlg.h.

◆ m_jetsKey

SG::ReadHandleKey< xAOD::JetContainer > TrigHitDVHypoAlg::m_jetsKey {this, "Jets", "HLT_AntiKt4EMTopoJets_subjesIS", ""}
private

Definition at line 76 of file TrigHitDVHypoAlg.h.

◆ m_lumiBlockMuTool

ToolHandle<ILumiBlockMuTool> TrigHitDVHypoAlg::m_lumiBlockMuTool
private

Definition at line 81 of file TrigHitDVHypoAlg.h.

◆ m_lumiDataKey

SG::ReadCondHandleKey<LuminosityCondData> TrigHitDVHypoAlg::m_lumiDataKey {this, "LuminosityCondDataKey", "LuminosityCondData", ""}
private

Definition at line 83 of file TrigHitDVHypoAlg.h.

◆ m_monTool

ToolHandle<GenericMonitoringTool> TrigHitDVHypoAlg::m_monTool { this, "MonTool", "", "Monitoring tool" }
private

Definition at line 96 of file TrigHitDVHypoAlg.h.

◆ m_output

SG::WriteHandleKey<TrigCompositeUtils::DecisionContainer> HypoBase::m_output { this, "HypoOutputDecisions", "UNSPECIFIED_OUTPUT", "Ouput Decision" }
privateinherited

output decisions

Definition at line 103 of file HypoBase.h.

◆ m_runtimeValidation

Gaudi::Property<bool> HypoBase::m_runtimeValidation { this, "RuntimeValidation", false, "Enable detailed runtime validation of HypoAlg output, and upstream Decisions." }
privateinherited

Enabling of detailed validation checks for use during development.

Definition at line 105 of file HypoBase.h.

◆ m_spacePointTool

ToolHandle<ITrigSpacePointConversionTool> TrigHitDVHypoAlg::m_spacePointTool {this, "SpacePointProviderTool", "TrigSpacePointConversionTool"}
private

Definition at line 72 of file TrigHitDVHypoAlg.h.

◆ m_tools_loosest_wp

int TrigHitDVHypoAlg::m_tools_loosest_wp
private

Definition at line 128 of file TrigHitDVHypoAlg.h.

◆ m_tools_lowest_jetEt

int TrigHitDVHypoAlg::m_tools_lowest_jetEt
private

Definition at line 127 of file TrigHitDVHypoAlg.h.

◆ m_tracksKey

SG::ReadHandleKey< TrackCollection> TrigHitDVHypoAlg::m_tracksKey {this, "HitDVTracks", "HLT_IDTrkTrack_FS_FTF", ""}
private

Definition at line 78 of file TrigHitDVHypoAlg.h.

◆ m_useBeamSpot

bool TrigHitDVHypoAlg::m_useBeamSpot
private

Definition at line 131 of file TrigHitDVHypoAlg.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
TrigHitDVHypoAlg::calculateBDT
StatusCode calculateBDT(const EventContext &, const std::vector< HitDVSpacePoint > &, const std::vector< HitDVTrk > &, const std::vector< float > &, const std::vector< float > &, const std::vector< float > &, const float &, const int, xAOD::TrigCompositeContainer *, int &) const
Definition: TrigHitDVHypoAlg.cxx:565
Trk::SpacePoint::clusterList
const std::pair< const PrepRawData *, const PrepRawData * > & clusterList() const
return the pair of cluster pointers by reference
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePoint.h:127
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
HitDVSpacePoint::isPix
bool isPix
Definition: TrigHitDVHypoAlg.h:57
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
base
std::string base
Definition: hcg.cxx:78
PathResolver::find_calib_file
static std::string find_calib_file(const std::string &logical_file_name)
Definition: PathResolver.cxx:384
Trk::SpacePoint
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePoint.h:35
HitDVTrk::n_hits_inner
int16_t n_hits_inner
Definition: TrigHitDVHypoAlg.h:46
xAOD::jFexSRJetRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexSRJetRoI_v1.h:22
verify_menu_config.results
results
Definition: verify_menu_config.py:67
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
trackInfo::ptGeV
float ptGeV
Definition: TrigInDetUtils.h:15
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
trackInfo::n_hits_inner
int n_hits_inner
Definition: TrigInDetUtils.h:14
HitDVSpacePoint::r
float r
Definition: TrigHitDVHypoAlg.h:54
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
max
#define max(a, b)
Definition: cfImp.cxx:41
TrigCompositeUtils::DecisionID
unsigned int DecisionID
Definition: TrigComposite_v1.h:27
PlotCalibFromCool.dv
dv
Definition: PlotCalibFromCool.py:762
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
TrigCompositeUtils::passed
bool passed(DecisionID id, const DecisionIDContainer &idSet)
checks if required decision ID is in the set of IDs in the container
Definition: TrigCompositeUtilsRoot.cxx:117
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
FTF::isGoodTrackUTT
bool isGoodTrackUTT(const Trk::Track *track, trackInfo &theTrackInfo, const float shift_x, const float shift_y, float trkcut_ptgev)
Definition: TrigInDetUtils.cxx:4
TrigHitDVHypoAlg::m_spacePointTool
ToolHandle< ITrigSpacePointConversionTool > m_spacePointTool
Definition: TrigHitDVHypoAlg.h:72
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
TrigCompositeUtils::hltSeedingNodeName
const std::string & hltSeedingNodeName()
Definition: TrigCompositeUtilsRoot.cxx:892
xAOD::TrigComposite
TrigComposite_v1 TrigComposite
Declare the latest version of the class.
Definition: Event/xAOD/xAODTrigger/xAODTrigger/TrigComposite.h:16
Trk::SpacePoint::globalPosition
virtual const Amg::Vector3D & globalPosition() const override final
Interface method to get the global Position.
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePoint.h:146
TrigL2MuonSA::N_LAYER
constexpr int N_LAYER
Definition: MuonRoad.h:17
HitDVSpacePoint
Definition: TrigHitDVHypoAlg.h:52
dqt_zlumi_pandas.hname
string hname
Definition: dqt_zlumi_pandas.py:279
TrigCompositeUtils::newDecisionIn
Decision * newDecisionIn(DecisionContainer *dc, const std::string &name)
Helper method to create a Decision object, place it in the container and return a pointer to it.
Definition: TrigCompositeUtilsRoot.cxx:46
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
hist_file_dump.d
d
Definition: hist_file_dump.py:137
TrigCompositeUtils::hypoAlgNodeName
const std::string & hypoAlgNodeName()
Definition: TrigCompositeUtilsRoot.cxx:904
CxxUtils::wrapToPi
T wrapToPi(T phi)
Wrap angle in radians to [-pi, pi].
Definition: phihelper.h:24
TrigHitDVHypoAlg::m_jetRoiCollectionKey
SG::ReadHandleKey< xAOD::jFexSRJetRoIContainer > m_jetRoiCollectionKey
Definition: TrigHitDVHypoAlg.h:137
AthCommonDataStore::renounce
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)
Definition: AthCommonDataStore.h:380
python.TrigCompositeUtils.isLegId
def isLegId(chainName)
Definition: DecisionHandling/python/TrigCompositeUtils.py:18
skel.it
it
Definition: skel.GENtoEVGEN.py:396
M_PI
#define M_PI
Definition: ActiveFraction.h:11
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
TrigHitDVHypoAlg::m_useBeamSpot
bool m_useBeamSpot
Definition: TrigHitDVHypoAlg.h:131
DataVector::get
const T * get(size_type n) const
Access an element, as an rvalue.
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
HypoBase::decisionInput
const SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > & decisionInput() const
methods for derived classes to access handles of the base class input other read/write handles may be...
Definition: HypoBase.cxx:16
TrigHitDVHypoAlg::m_tools_loosest_wp
int m_tools_loosest_wp
Definition: TrigHitDVHypoAlg.h:128
TrigHitDVHypoAlg::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: TrigHitDVHypoAlg.h:96
HypoBase::printBangs
static void printBangs(MsgStream &msg)
Print header line.
Definition: HypoBase.cxx:388
TrigCompositeUtils::comboHypoAlgNodeName
const std::string & comboHypoAlgNodeName()
Definition: TrigCompositeUtilsRoot.cxx:908
TrigCompositeUtils::createAndStore
SG::WriteHandle< DecisionContainer > createAndStore(const SG::WriteHandleKey< DecisionContainer > &key, const EventContext &ctx)
Creates and right away records the DecisionContainer with the key.
Definition: TrigCompositeUtilsRoot.cxx:30
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
TrigRoiDescriptor
nope - should be used for standalone also, perhaps need to protect the class def bits #ifndef XAOD_AN...
Definition: TrigRoiDescriptor.h:56
xAOD::jFexSRJetRoI_v1::eta
float eta() const
xAOD::jFexSRJetRoI_v1::phi
float phi() const
FTF::getBeamSpotShift
void getBeamSpotShift(float &shift_x, float &shift_y, const InDet::BeamSpotData &beamSpotHandle)
Definition: TrigInDetUtils.cxx:30
HitDVTrk::phi
float phi
Definition: TrigHitDVHypoAlg.h:45
HitDVTrk::pt
float pt
Definition: TrigHitDVHypoAlg.h:43
HypoBase::kRequireAll
@ kRequireAll
Definition: HypoBase.h:54
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
Trk::SpacePoint::r
double r() const
returns the r value of the SpacePoint's position (in cylindrical coordinates).
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePoint.h:137
HitDVSeed
Definition: TrigHitDVHypoAlg.h:35
xAOD::int16_t
setScaleOne setStatusOne setSaturated int16_t
Definition: gFexGlobalRoI_v1.cxx:55
HypoBase::decisionOutput
const SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer > & decisionOutput() const
methods for derived classes to access handles of the base class output other read/write handles may b...
Definition: HypoBase.cxx:20
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
HitDVTrk::a0beam
float a0beam
Definition: TrigHitDVHypoAlg.h:49
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
TrigHitDVHypoAlg::m_jetSeed_etaMax
Gaudi::Property< float > m_jetSeed_etaMax
Definition: TrigHitDVHypoAlg.h:88
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
TrigHitDVHypoTool::HitDVHypoInfo
Definition: TrigHitDVHypoTool.h:35
PrepareReferenceFile.regex
regex
Definition: PrepareReferenceFile.py:43
HitDVTrk::n_hits_pix
int16_t n_hits_pix
Definition: TrigHitDVHypoAlg.h:47
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
HypoBase::recursiveValidateGraph
static StatusCode recursiveValidateGraph(const ElementLink< TrigCompositeUtils::DecisionContainer > &dEL, MsgStream &msg, bool onlyValidateOneStep, bool runTwoConversion, size_t callDepth, std::set< const TrigCompositeUtils::Decision * > &fullyExploredFrom)
Execute all checks on one node in the graph, d, then recursive call self on all parent nodes up to L1...
Definition: HypoBase.cxx:69
trackInfo::eta
float eta
Definition: TrigInDetUtils.h:15
TrigHitDVHypoAlg::deltaR2
float deltaR2(float, float, float, float) const
Definition: TrigHitDVHypoAlg.cxx:333
HitDVSpacePoint::phi
float phi
Definition: TrigHitDVHypoAlg.h:55
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
TrigHitDVHypoAlg::m_doHitDV_Seeding
bool m_doHitDV_Seeding
Definition: TrigHitDVHypoAlg.h:135
trackInfo::n_hits_pix
int n_hits_pix
Definition: TrigInDetUtils.h:14
AthCommonDataStore
Definition: AthCommonDataStore.h:52
Generate_dsid_ranseed.seed
seed
Definition: Generate_dsid_ranseed.py:10
perfmonmt-refit.idx_min
idx_min
Definition: perfmonmt-refit.py:83
TrigHitDVHypoAlg::selectSeedsNearby
StatusCode selectSeedsNearby(const std::vector< HitDVSeed > &hitDVSeedsContainer, std::vector< float > &jetSeeds_eta, std::vector< float > &jetSeeds_phi, std::vector< float > &jetSeeds_pt) const
Definition: TrigHitDVHypoAlg.cxx:948
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
HitDVTrk::n_hits_sct
int16_t n_hits_sct
Definition: TrigHitDVHypoAlg.h:48
lumiFormat.i
int i
Definition: lumiFormat.py:85
HypoBase::validateDuplicatedDecisionID
static StatusCode validateDuplicatedDecisionID(const ElementLink< TrigCompositeUtils::DecisionContainer > &dEL, MsgStream &msg)
Ensure that no space is being wasted by duplicated DecisionIDs in any Decision objects.
Definition: HypoBase.cxx:227
TrigCompositeUtils::initialRoIString
const std::string & initialRoIString()
Definition: TrigCompositeUtilsRoot.cxx:868
HypoBase::hypoBaseOutputProcessing
StatusCode hypoBaseOutputProcessing(SG::WriteHandle< TrigCompositeUtils::DecisionContainer > &outputHandle, MSG::Level lvl=MSG::DEBUG) const
Base class function to be called once slice specific code has finished. Handles debug printing and va...
Definition: HypoBase.cxx:33
HypoBase::m_runtimeValidation
Gaudi::Property< bool > m_runtimeValidation
Enabling of detailed validation checks for use during development.
Definition: HypoBase.h:105
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
SG::WriteHandle::ptr
pointer_type ptr()
Dereference the pointer.
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
checkxAOD.frac
frac
Definition: Tools/PyUtils/bin/checkxAOD.py:257
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
TauGNNUtils::Variables::Track::dPhi
bool dPhi(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:538
HypoBase::m_input
SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > m_input
input decisions
Definition: HypoBase.h:101
TrigHitDVHypoAlg::m_lumiBlockMuTool
ToolHandle< ILumiBlockMuTool > m_lumiBlockMuTool
Definition: TrigHitDVHypoAlg.h:81
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Preparation.mode
mode
Definition: Preparation.py:94
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
HypoBase::validateLogicalFlow
static StatusCode validateLogicalFlow(const ElementLink< TrigCompositeUtils::DecisionContainer > &dEL, MsgStream &msg, const LogicalFlowCheckMode mode)
Ensure that all DecisionIDs have propagated correctly from their parent.
Definition: HypoBase.cxx:245
HypoBase::validateDecisionIDs
static StatusCode validateDecisionIDs(const ElementLink< TrigCompositeUtils::DecisionContainer > &dEL, MsgStream &msg)
Ensure that all present IDs correspond to configured chains.
Definition: HypoBase.cxx:207
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
trackInfo::n_hits_sct
int n_hits_sct
Definition: TrigInDetUtils.h:14
xAOD::TrigComposite_v1
Class used to describe composite objects in the HLT.
Definition: TrigComposite_v1.h:52
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
HLT::Identifier
Definition: TrigCompositeUtils/TrigCompositeUtils/HLTIdentifier.h:20
TrigHitDVHypoAlg::doMonitor
StatusCode doMonitor(const xAOD::TrigCompositeContainer *) const
Definition: TrigHitDVHypoAlg.cxx:466
TrigHitDVHypoAlg::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
Definition: TrigHitDVHypoAlg.h:138
trackInfo
Definition: TrigInDetUtils.h:13
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
min
#define min(a, b)
Definition: cfImp.cxx:40
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
lumiFormat.array
array
Definition: lumiFormat.py:91
Trk::PrepRawData
Definition: PrepRawData.h:62
TrigCompositeUtils::featureString
const std::string & featureString()
Definition: TrigCompositeUtilsRoot.cxx:884
keylayer_zslicemap.isPix
isPix
Definition: keylayer_zslicemap.py:127
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
TrigCompositeUtils::isChainId
bool isChainId(const HLT::Identifier &chainIdentifier)
Recognise whether the HLT identifier corresponds to a whole chain.
Definition: TrigCompositeUtilsRoot.cxx:212
TrigHitDVHypoAlg::findJetSeeds
StatusCode findJetSeeds(const xAOD::JetContainer *, const float, const float, std::vector< float > &, std::vector< float > &, std::vector< float > &) const
Definition: TrigHitDVHypoAlg.cxx:709
trackInfo::a0beam
float a0beam
Definition: TrigInDetUtils.h:15
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
TrigHitDVHypoAlg::m_tracksKey
SG::ReadHandleKey< TrackCollection > m_tracksKey
Definition: TrigHitDVHypoAlg.h:78
TrigCompositeUtils::Decision
xAOD::TrigComposite Decision
Definition: Event/xAOD/xAODTrigger/xAODTrigger/TrigComposite.h:20
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:453
HitDVTrk::eta
float eta
Definition: TrigHitDVHypoAlg.h:44
TrigHitDVHypoAlg::m_jetsKey
SG::ReadHandleKey< xAOD::JetContainer > m_jetsKey
Definition: TrigHitDVHypoAlg.h:76
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
TrigHitDVHypoAlg::m_hitDVKey
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_hitDVKey
Definition: TrigHitDVHypoAlg.h:77
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
TrigHitDVHypoAlg::m_lumiDataKey
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey
Definition: TrigHitDVHypoAlg.h:83
TrigHitDVHypoAlg::m_isMC
Gaudi::Property< bool > m_isMC
Definition: TrigHitDVHypoAlg.h:85
TrigCompositeUtils::filterNodeName
const std::string & filterNodeName()
Definition: TrigCompositeUtilsRoot.cxx:896
HitDVSpacePoint::layer
int16_t layer
Definition: TrigHitDVHypoAlg.h:56
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
TrigCompositeUtils::seedString
const std::string & seedString()
Definition: TrigCompositeUtilsRoot.cxx:888
a
TList * a
Definition: liststreamerinfos.cxx:10
TrigCompositeUtils::DecisionIDContainer
std::set< DecisionID > DecisionIDContainer
Definition: TrigComposite_v1.h:28
h
HypoBase::printDebugInformation
StatusCode printDebugInformation(SG::WriteHandle< TrigCompositeUtils::DecisionContainer > &outputHandle, MSG::Level lvl) const
Common base function to print information on chains passed by objects considered in the hypo.
Definition: HypoBase.cxx:404
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
HypoBase::validateParentLinking
static StatusCode validateParentLinking(const ElementLink< TrigCompositeUtils::DecisionContainer > &dEL, MsgStream &msg, bool runTwoConversion)
Ensure that the Decision has at least one valid parent, unless it is a initial Decision from the HLTS...
Definition: HypoBase.cxx:133
TrigHitDVHypoAlg::m_jetSeed_ptMin
Gaudi::Property< float > m_jetSeed_ptMin
Definition: TrigHitDVHypoAlg.h:87
HitDVSpacePoint::eta
float eta
Definition: TrigHitDVHypoAlg.h:53
TrigHitDVHypoAlg::findSPSeeds
StatusCode findSPSeeds(const EventContext &, const std::vector< HitDVSpacePoint > &, std::vector< float > &, std::vector< float > &) const
Definition: TrigHitDVHypoAlg.cxx:745
HypoBase::HypoBase
HypoBase(const std::string &name, ISvcLocator *pSvcLocator)
constructor, to be called by sub-class constructors
Definition: HypoBase.cxx:10
TrigCompositeUtils::allFailed
bool allFailed(const Decision *d)
return true if there is no positive decision stored
Definition: TrigCompositeUtilsRoot.cxx:103
AthCommonMsg< Gaudi::Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
TrigCompositeUtils::decisionIDs
void decisionIDs(const Decision *d, DecisionIDContainer &destination)
Extracts DecisionIDs stored in the Decision object.
Definition: TrigCompositeUtilsRoot.cxx:67
HLT::Identifier::name
std::string name() const
reports human redable name if it is enabled or, empty string
Definition: HLTIdentifier.cxx:14
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
HypoBase::m_output
SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer > m_output
output decisions
Definition: HypoBase.h:103
HitDVSpacePoint::usedTrkId
int16_t usedTrkId
Definition: TrigHitDVHypoAlg.h:59
TrigCompositeUtils::roiString
const std::string & roiString()
Definition: TrigCompositeUtilsRoot.cxx:876
Trk::jet_phi
@ jet_phi
Definition: JetVtxParamDefs.h:28
Trk::phi
@ phi
Definition: ParamDefs.h:75
TrigRoiDescriptor
Athena::TPCnvVers::Current TrigRoiDescriptor
Definition: TrigSteeringEventTPCnv.cxx:68
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
HypoBase::runtimeValidation
static StatusCode runtimeValidation(SG::WriteHandle< TrigCompositeUtils::DecisionContainer > &outputHandle, MsgStream &msg, bool onlyValidateOneStep=true, bool runTwoConversion=false)
Executes all individual runtime tests.
Definition: HypoBase.cxx:45
TrigCompositeUtils::getIDFromLeg
HLT::Identifier getIDFromLeg(const HLT::Identifier &legIdentifier)
Generate the HLT::Identifier which corresponds to the chain name from the leg name.
Definition: TrigCompositeUtilsRoot.cxx:180
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
TrigHitDVHypoAlg::m_hypoTools
ToolHandleArray< TrigHitDVHypoTool > m_hypoTools
Definition: TrigHitDVHypoAlg.h:73
collisions.reader
reader
read the goodrunslist xml file(s)
Definition: collisions.py:22
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:200
TrigHitDVHypoAlg::findHitDV
StatusCode findHitDV(const EventContext &ctx, const std::vector< TrigSiSpacePointBase > &convertedSpacePoints, const DataVector< Trk::Track > &tracks, std::vector< HitDVSeed > &hitDVSeedsContainer, std::vector< HitDVTrk > &hitDVTrksContainer, std::vector< HitDVSpacePoint > &hitDVSPContainer) const
Definition: TrigHitDVHypoAlg.cxx:1178
TauGNNUtils::Variables::Track::dEta
bool dEta(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:527
HypoBase::validateHasLinks
static StatusCode validateHasLinks(const ElementLink< TrigCompositeUtils::DecisionContainer > &dEL, MsgStream &msg)
Ensure all Decisions have the named ElementLink graph edges which they are required to by spec.
Definition: HypoBase.cxx:336
TrigHitDVHypoAlg::m_tools_lowest_jetEt
int m_tools_lowest_jetEt
Definition: TrigHitDVHypoAlg.h:127
HitDVTrk::id
int id
Definition: TrigHitDVHypoAlg.h:42
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
HypoBase::printErrorHeader
static void printErrorHeader(const ElementLink< TrigCompositeUtils::DecisionContainer > &dEL, MsgStream &msg)
A problem was found, print common output data.
Definition: HypoBase.cxx:393
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
HitDVSpacePoint::isSct
bool isSct
Definition: TrigHitDVHypoAlg.h:58
HypoBase::kRequireOne
@ kRequireOne
Require all DecisionIDs to be present in at least one of my parent Decision objects.
Definition: HypoBase.h:53
HitDVTrk
Definition: TrigHitDVHypoAlg.h:41
TrigCompositeUtils::inputMakerNodeName
const std::string & inputMakerNodeName()
Definition: TrigCompositeUtilsRoot.cxx:900
fitman.k
k
Definition: fitman.py:528
TrigHitDVHypoAlg::getSPLayer
int getSPLayer(int, float) const
Definition: TrigHitDVHypoAlg.cxx:342
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
xAOD::jFexSRJetRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition: jFexSRJetRoI_v1.cxx:138
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Nov 7 2024 22:03:27 for ATLAS Offline Software by   doxygen 1.8.18