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< DataVector< LVL1::RecJetRoI > > m_recJetRoiCollectionKey {this, "RecJetRoI", "", ""}
 
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 42 of file TrigHitDVHypoAlg.cxx.

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

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 564 of file TrigHitDVHypoAlg.cxx.

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

◆ 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 332 of file TrigHitDVHypoAlg.cxx.

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

◆ 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 465 of file TrigHitDVHypoAlg.cxx.

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

◆ 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 126 of file TrigHitDVHypoAlg.cxx.

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

◆ 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 1177 of file TrigHitDVHypoAlg.cxx.

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

◆ 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 708 of file TrigHitDVHypoAlg.cxx.

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

◆ 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 744 of file TrigHitDVHypoAlg.cxx.

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

◆ 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 977 of file TrigHitDVHypoAlg.cxx.

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

◆ getSPLayer()

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

Definition at line 341 of file TrigHitDVHypoAlg.cxx.

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

◆ 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 51 of file TrigHitDVHypoAlg.cxx.

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

◆ 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, 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 947 of file TrigHitDVHypoAlg.cxx.

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

◆ 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_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_recJetRoiCollectionKey

SG::ReadHandleKey<DataVector<LVL1::RecJetRoI> > TrigHitDVHypoAlg::m_recJetRoiCollectionKey {this, "RecJetRoI", "", ""}
private

Definition at line 137 of file TrigHitDVHypoAlg.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:564
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
LVL1::RecJetRoI::triggerThreshold
unsigned int triggerThreshold(unsigned int thresh) const
returns the value of the trigger threshold for the threshold passed.
Definition: RecJetRoI.cxx:379
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
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
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
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
HLTSeedingRoIToolDefs::roiPhi
constexpr float roiPhi(const AnyRoIPointer &roi)
Definition: HLTSeedingRoIToolDefs.h:167
PlotCalibFromCool.dv
dv
Definition: PlotCalibFromCool.py:762
LVL1::RecJetRoI
This class defines the reconstructed em/tau hadron ROI.
Definition: RecJetRoI.h:39
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
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:894
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:272
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:79
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:906
CxxUtils::wrapToPi
T wrapToPi(T phi)
Wrap angle in radians to [-pi, pi].
Definition: phihelper.h:24
LVL1::RecJetRoI::thresholdsPassed
std::vector< unsigned int > thresholdsPassed() const
returns a vector of thresholds passed.
Definition: RecJetRoI.cxx:352
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:423
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:910
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
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
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
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
TrigHitDVHypoAlg::m_recJetRoiCollectionKey
SG::ReadHandleKey< DataVector< LVL1::RecJetRoI > > m_recJetRoiCollectionKey
Definition: TrigHitDVHypoAlg.h:137
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
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:332
HitDVSpacePoint::phi
float phi
Definition: TrigHitDVHypoAlg.h:55
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:947
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:92
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:870
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
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:256
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:530
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:95
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
ETA_MAX
#define ETA_MAX
Definition: InDetGlobalMotherMonTool.h:20
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
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
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:465
TrigHitDVHypoAlg::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
Definition: TrigHitDVHypoAlg.h:138
trackInfo
Definition: TrigInDetUtils.h:13
TH2F::GetBinContent
double GetBinContent(int) const
Definition: rootspy.cxx:425
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:98
Trk::PrepRawData
Definition: PrepRawData.h:62
TrigCompositeUtils::featureString
const std::string & featureString()
Definition: TrigCompositeUtilsRoot.cxx:886
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:708
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:195
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
python.ami.results
def results
Definition: ami.py:386
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:898
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:890
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
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:744
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:616
HypoBase::m_output
SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer > m_output
output decisions
Definition: HypoBase.h:103
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
HitDVSpacePoint::usedTrkId
int16_t usedTrkId
Definition: TrigHitDVHypoAlg.h:59
TrigCompositeUtils::roiString
const std::string & roiString()
Definition: TrigCompositeUtilsRoot.cxx:878
Trk::jet_phi
@ jet_phi
Definition: JetVtxParamDefs.h:28
Trk::phi
@ phi
Definition: ParamDefs.h:81
TrigRoiDescriptor
Athena::TPCnvVers::Current TrigRoiDescriptor
Definition: TrigSteeringEventTPCnv.cxx:68
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
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.
LVL1::RecJetRoI::eta
virtual double eta() const
returns eta coord of ROI
Definition: RecJetRoI.cxx:253
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:1177
TauGNNUtils::Variables::Track::dEta
bool dEta(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:525
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
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
xAOD::thrValue
thrValue
Definition: MuonRoI_v1.cxx:54
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:902
fitman.k
k
Definition: fitman.py:528
TrigHitDVHypoAlg::getSPLayer
int getSPLayer(int, float) const
Definition: TrigHitDVHypoAlg.cxx:341
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
LVL1::RecJetRoI::phi
virtual double phi() const
returns phi coord of ROI
Definition: RecJetRoI.cxx:243
Generated on Fri Jul 5 2024 22:05:17 for ATLAS Offline Software by   doxygen 1.8.18