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

#include <TrigFastTrackFinder.h>

Inheritance diagram for TrigFastTrackFinder:
Collaboration diagram for TrigFastTrackFinder:

Classes

struct  OneLayerInfo_t
 

Public Types

enum  DisTrkCategory {
  Other = 0, Pix4l_Sct0 = 1, Pix4l_Sct1p = 2, Pix3l_Sct0 = 3,
  Pix3l_Sct1p = 4
}
 

Public Member Functions

 TrigFastTrackFinder (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~TrigFastTrackFinder ()
 
virtual StatusCode initialize () override
 
virtual StatusCode finalize () override
 
virtual StatusCode start () override
 
virtual StatusCode execute (const EventContext &ctx) const override
 
StatusCode findTracks (InDet::SiTrackMakerEventData_xk &event_data, const TrigRoiDescriptor &roi, const TrackCollection *inputTracks, TrackCollection &outputTracks, const EventContext &ctx) const
 
double trackQuality (const Trk::Track *Tr) const
 
void filterSharedTracks (std::vector< std::tuple< bool, double, Trk::Track * >> &QT) const
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. 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
 

Protected Member Functions

void updateClusterMap (long int, const Trk::Track *, std::map< Identifier, std::vector< long int > > &) const
 
void extractClusterIds (const Trk::SpacePoint *, std::vector< Identifier > &) const
 
bool usedByAnyTrack (const std::vector< Identifier > &, std::map< Identifier, std::vector< long int > > &) const
 
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...
 

Static Protected Attributes

static constexpr size_t N_BARREL_LAYERS {8}
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

void fillMon (const TrackCollection &tracks, const TrigVertexCollection &vertices, const TrigRoiDescriptor &roi, const EventContext &ctx) const
 
void runResidualMonitoring (const Trk::Track &track, const EventContext &) const
 
void makeSeedsOnGPU (const TrigCombinatorialSettings &, const IRoiDescriptor *, const std::vector< TrigSiSpacePointBase > &, std::vector< TrigInDetTriplet > &) const
 
StatusCode createEmptyUTTEDMs (const EventContext &) const
 
int getSPLayer (int, float) const
 
StatusCode calcdEdx (const EventContext &, const TrackCollection &) const
 
StatusCode finddEdxTrk (const EventContext &, const TrackCollection &) const
 
float dEdx (const Trk::Track *, int &, int &, std::vector< float > &, std::vector< float > &, std::vector< float > &, std::vector< float > &, std::vector< int > &, std::vector< int > &, std::vector< int > &) const
 
int recoAndFillDisTrkCand (const std::string &, TrackCollection *, std::vector< Trk::Track * > &, xAOD::TrigCompositeContainer *, const std::vector< double > &, const std::vector< double > &, const std::vector< double > &, bool) const
 
void print_disTrk (const Trk::Track *t) const
 
std::unique_ptr< Trk::Track > disTrk_refit (Trk::Track *t) const
 
std::array< OneLayerInfo_t, N_BARREL_LAYERS > getTrkBarrelLayerInfo (Trk::Track *aTrack) const
 
bool isCleaningPassDisTrack (const TrigInDetTriplet &, Trk::Track *, bool) const
 
double disTrackQuality (const Trk::Track *) const
 
void recoVertexForDisTrack (const EventContext &, TrackCollection &, std::vector< double > &, std::vector< double > &, std::vector< double > &) const
 
bool isPreselPassDisTrackBeforeRefit (Trk::Track *, double, double) const
 
bool isPreselPassDisTrackAfterRefit (Trk::Track *, Trk::Track *, double, double) const
 
bool isGoodForDisTrackVertex (Trk::Track *) const
 
std::unique_ptr< const Trk::TrackParameters > extrapolateDisTrackToBS (Trk::Track *, const std::vector< double > &, const std::vector< double > &, const std::vector< double > &) const
 
void filterSharedDisTracks (std::vector< std::tuple< bool, double, Trk::Track * >> &) const
 
void fillDisTrkCand (xAOD::TrigComposite *, const std::string &, Trk::Track *, const std::unique_ptr< const Trk::TrackParameters > &) const
 
void fillDisTrkCand (xAOD::TrigComposite *, const std::string &, Trk::Track *, const std::unique_ptr< const Trk::TrackParameters > &, bool, std::vector< Trk::Track * > &) const
 
TrigFastTrackFinder::DisTrkCategory getDisTrkCategory (Trk::Track *trk) const
 
StatusCode findDisTracks (const EventContext &, TrackCollection &, std::vector< std::tuple< bool, double, Trk::Track * >> &, std::vector< std::tuple< bool, double, Trk::Track * >> &, TrackCollection &, const std::vector< double > &, const std::vector< double > &, const std::vector< double > &) const
 
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< ITrigL2LayerNumberTool > m_numberingTool {this, "LayerNumberTool", "TrigL2LayerNumberTool"}
 
ToolHandle< ITrigSpacePointConversionTool > m_spacePointTool {this, "SpacePointProviderTool", "TrigSpacePointConversionTool"}
 
ToolHandle< InDet::ISiTrackMaker > m_trackMaker
 
ToolHandle< ITrigInDetTrackFitter > m_trigInDetTrackFitter
 
ToolHandle< ITrigZFinder > m_trigZFinder
 
ToolHandle< Trk::ITrackSummaryTool > m_trackSummaryTool
 
ToolHandle< GenericMonitoringTool > m_monTool { this, "MonTool", "", "Monitoring tool" }
 
ToolHandle< Trk::IExtrapolator > m_extrapolator { this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator" }
 
ToolHandle< Trk::ITrackFitter > m_disTrkFitter
 
ToolHandle< ITrigInDetAccelerationTool > m_accelTool {this, "TrigAccelerationTool", ""}
 
ServiceHandle< ITrigInDetAccelerationSvc > m_accelSvc {this, "TrigAccelerationSvc", ""}
 
SG::ReadHandleKey< TrigRoiDescriptorCollection > m_roiCollectionKey
 
SG::ReadHandleKey< TrackCollection > m_inputTracksKey
 
SG::WriteHandleKey< TrackCollection > m_outputTracksKey
 
SG::ReadHandleKey< Trk::PRDtoTrackMap > m_prdToTrackMap {this,"PRDtoTrackMap",""}
 
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_dEdxTrkKey {this, "dEdxTrk", "", ""}
 
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_dEdxHitKey {this, "dEdxHit", "", ""}
 
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_disTrkCandKey {this, "DisTrkCand","", ""}
 
bool m_useBeamSpot
 
bool m_vertexSeededMode
 
bool m_doZFinder
 
bool m_doZFinderOnly
 
bool m_storeZFinderVertices
 
bool m_doFastZVseeding
 
bool m_doResMonitoring
 
TrigCombinatorialSettings m_tcs
 
int m_minHits
 
int m_nfreeCut
 
float m_tripletMinPtFrac
 
float m_pTmin
 
float m_initialD0Max
 
float m_Z0Max
 
bool m_checkSeedRedundancy
 
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }
 
std::atomic< unsigned int > m_countTotalRoI
 
std::atomic< unsigned int > m_countRoIwithEnoughHits
 
std::atomic< unsigned int > m_countRoIwithTracks
 
const PixelID * m_pixelId
 
const SCT_ID * m_sctId
 
const AtlasDetectorID * m_idHelper
 
Trk::ParticleHypothesis m_particleHypothesis
 
bool m_useNewLayerNumberScheme
 
bool m_useGPU
 
bool m_LRTmode
 
float m_LRTD0Min
 
float m_LRTHardMinPt
 
std::string m_trigseedML_LUT
 
bool m_dodEdxTrk
 
bool m_doDisappearingTrk
 
bool m_ITkMode
 
bool m_standaloneMode
 
Gaudi::Property< bool > m_useEtaBinning {this, "UseEtaBinning", true, "Split layers into eta bins"}
 
Gaudi::Property< bool > m_doCloneRemoval {this, "doCloneRemoval", true, "Remove tracks sharing too many hits"}
 
Gaudi::Property< bool > m_doTrackRefit {this, "doTrackRefit", true, "Refit tracks after the combinatorial track following"}
 
Gaudi::Property< bool > m_useTracklets {this, "UseTracklets", false, "Use tracklet seeds from ITk track seeding"}
 
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
 

Detailed Description

Definition at line 95 of file TrigFastTrackFinder.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ DisTrkCategory

enum TrigFastTrackFinder::DisTrkCategory
Enumerator
Other 
Pix4l_Sct0 
Pix4l_Sct1p 
Pix3l_Sct0 
Pix3l_Sct1p 

Definition at line 116 of file TrigFastTrackFinder.h.

117  {
118  Other = 0,
119  Pix4l_Sct0 = 1,
120  Pix4l_Sct1p = 2,
121  Pix3l_Sct0 = 3,
122  Pix3l_Sct1p = 4
123  };

Constructor & Destructor Documentation

◆ TrigFastTrackFinder()

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

Initial cut

SeedMaker

Doublet finding properties.

Triplet finding properties.

settings for the ML-enhanced track seeding

Definition at line 58 of file TrigFastTrackFinder.cxx.

58  :
59 
60  AthReentrantAlgorithm(name, pSvcLocator),
61  m_trackMaker("InDet::SiTrackMaker_xk/InDetTrigSiTrackMaker"),
62  m_trigInDetTrackFitter("TrigInDetTrackFitter"),
63  m_trigZFinder("TrigZFinder/TrigZFinder", this ),
64  m_trackSummaryTool("Trk::ITrackSummaryTool/ITrackSummaryTool"),
65  m_disTrkFitter("Trk::GlobalChi2Fitter/InDetTrackFitter"),
66  m_useBeamSpot(true),
67  m_doZFinder(false),
68  m_doZFinderOnly(false),
69  m_storeZFinderVertices(false),
70  m_nfreeCut(5),
71  m_countTotalRoI(0),
72  m_countRoIwithEnoughHits(0),
73  m_countRoIwithTracks(0),
74  m_pixelId(0),
75  m_sctId(0),
76  m_idHelper(0),
77  m_particleHypothesis(Trk::pion),
78  m_useNewLayerNumberScheme(false),
79  m_useGPU(false),
80  m_LRTmode(false),
81  m_LRTD0Min(0.0),
82  m_LRTHardMinPt(0.0),
83  m_trigseedML_LUT(""),
84  m_dodEdxTrk(false),
85  m_doDisappearingTrk(false),
86  m_ITkMode(false),
87  m_standaloneMode(false)
88 {
89 
91  declareProperty( "MinHits", m_minHits = 5,"Minimum number of hits needed to perform tracking" );
92 
93  //** Zfinder mode
94  declareProperty( "doZFinder", m_doZFinder = true,"Use fast ZFinder to find z of primary vertices");
95  declareProperty( "doZFinderOnly", m_doZFinderOnly = false,"stop processing after ZFinder - no tracking performed");
96  declareProperty( "VertexSeededMode", m_vertexSeededMode = false); //** NOT USED Obsolete? ATR-24242
97  declareProperty( "doFastZVertexSeeding", m_doFastZVseeding = true,"Use ZFinder vertex information to filter seeds");
98  declareProperty( "zVertexResolution", m_tcs.m_zvError = 10.0," Half-width (mm) in z of z region used to filter seeds when doFastZVertexSeeding enabled" );
99  declareProperty( "zVertexResolutionEndcap", m_tcs.m_zvErrorEndcap = -1," Half-width (mm) in z of region used to filter seeds when doFastZVertexSeeding enabled, for endcap pixels; set to zVertexResolution value later if left negative" );
100  declareProperty( "StoreZFinderVertices", m_storeZFinderVertices = false ); //** NOT USED - to be implemented ATR-24242
101 
102 
104  declareProperty("useNewLayerNumberScheme", m_useNewLayerNumberScheme = false,"Use LayerNumberTool for layer numbers");
105 
107  declareProperty("Doublet_FilterRZ", m_tcs.m_doubletFilterRZ = true,"Enable check that doublet is consistent with the RoI in the RZ plane");
108  declareProperty("DoubletDR_Max", m_tcs.m_doublet_dR_Max = 270.0,"Maximum Radial distance between spacepoints forming Doublets");
109  declareProperty("SeedRadBinWidth", m_tcs.m_seedRadBinWidth = 2.0);
110 
112  declareProperty("Triplet_D0Max", m_tcs.m_tripletD0Max = 4.0,"Maximum d0 for triplet");
113  declareProperty("Triplet_D0_PPS_Max", m_tcs.m_tripletD0_PPS_Max = 1.7,"Maximin d0 for PPS doublets");
114  declareProperty("Triplet_nMaxPhiSlice", m_tcs.m_nMaxPhiSlice = 53,"Number of phi-slices used for seeding");
115  declareProperty("Triplet_MaxBufferLength", m_tcs.m_maxTripletBufferLength = 3,"Maximum number of triplets sharing a common middle spacepoint");
116  declareProperty("TripletDoPSS", m_tcs.m_tripletDoPSS = false,"Allow PSS Triplet seeds");
117  declareProperty("TripletDoPPS", m_tcs.m_tripletDoPPS = true,"Allow PPS triplet seeds");
118  declareProperty("TripletDoConfirm", m_tcs.m_tripletDoConfirm = false,"Enable triplet confirmation");
119  declareProperty("DoubletDR_Max_Confirm", m_tcs.m_doublet_dR_Max_Confirm = 150.0,"doublet max DR when TripletDoConfirm enabled");
120  declareProperty("TripletMaxCurvatureDiff", m_tcs.m_curv_delta = 0.001,"Maximum curvature difference allowed in seed confirmation");//for the triplet confirmation
121  declareProperty("Triplet_DtCut", m_tcs.m_tripletDtCut = 10.0);//i.e. 10*sigma_MS
122  declareProperty("pTmin", m_pTmin = 1000.0,"Triplet pT threshold is pTmin*Triplet_MinPtFrac" );
123  declareProperty("Triplet_MinPtFrac", m_tripletMinPtFrac = 0.3,"Triplet pT threshold is pTmin*Triplet_MinPtFrac");
124  declareProperty("doSeedRedundancyCheck", m_checkSeedRedundancy = false,"skip Triplets already used in a track");
125 
127  declareProperty("UseTrigSeedML", m_tcs.m_useTrigSeedML = 0,"set ML-based seed selection mode (0 disables)" );
128  declareProperty("TrigSeedML_LUT", m_trigseedML_LUT = "trigseed_ml_pixel_barrel_kde.lut","LUT used by ML-based seed selection");
129  declareProperty("maxEC_Pixel_cluster_length", m_tcs.m_maxEC_len = 1.5,"Maximum Endcap Pixel cluster length for ML-based seed selection" );
130 
131 
132  //* Clone removal (removal of tracks sharing too many hits */
133 
134  declareProperty( "FreeClustersCut" ,m_nfreeCut,"Minimum number of unshared clusters");
135 
136  //** Cuts applied to final tracks after Fit
137  declareProperty("TrackInitialD0Max", m_initialD0Max = 10.0,"Maximum d0 of track");
138  declareProperty("TrackZ0Max", m_Z0Max = 300.0,"Maximum z0 of track");
139 
140 
141  /* Monitoring */
142  declareProperty( "doResMon", m_doResMonitoring = true,"enable unbiased residual monitoring");
143  declareProperty( "UseBeamSpot", m_useBeamSpot = true,"Monitor d0 with respect to beamspot");
144 
145  //* Collection Names */
146  declareProperty("TracksName",
147  m_outputTracksKey = std::string("TrigFastTrackFinder_Tracks"),
148  "TrackCollection name");
149 
150  declareProperty("inputTracksName",
151  m_inputTracksKey = std::string(""),
152  "TrackCollection name");
153 
154  declareProperty("RoIs", m_roiCollectionKey = std::string("OutputRoIs"), "RoIs to read in");
155 
156  //* Tools */
157  declareProperty( "initialTrackMaker", m_trackMaker);
158  declareProperty( "trigInDetTrackFitter", m_trigInDetTrackFitter );
159  declareProperty( "trigZFinder", m_trigZFinder );
160  declareProperty("TrackSummaryTool", m_trackSummaryTool);
161 
162  // Accleration
163  declareProperty("useGPU", m_useGPU = false,"Use GPU acceleration");
164 
165  // Large Radius Tracking
166  declareProperty("LRT_Mode", m_LRTmode,"Enable Large Radius Tracking mode" );
167  declareProperty("LRT_D0Min", m_LRTD0Min=0.0,"Minimum d0 for tracks to be saved in LRT Mode" );
168  declareProperty("LRT_HardMinPt", m_LRTHardMinPt=0.0,"Minimum pT for tracks to be saved in LRT Mode");
169 
170  // UTT
171  declareProperty("dodEdxTrk", m_dodEdxTrk = false);
172  declareProperty("doDisappearingTrk", m_doDisappearingTrk = false);
173  declareProperty("DisTrackFitter", m_disTrkFitter );
174 
175  // Phase II
176  declareProperty("ITkMode", m_ITkMode = false);
177  declareProperty("StandaloneMode", m_standaloneMode = false);
178 
179 }

◆ ~TrigFastTrackFinder()

TrigFastTrackFinder::~TrigFastTrackFinder ( )
virtual

Definition at line 183 of file TrigFastTrackFinder.cxx.

183 {}

Member Function Documentation

◆ calcdEdx()

StatusCode TrigFastTrackFinder::calcdEdx ( const EventContext &  ,
const TrackCollection &   
) const
private

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

◆ createEmptyUTTEDMs()

StatusCode TrigFastTrackFinder::createEmptyUTTEDMs ( const EventContext &  ctx) const
private

Definition at line 1518 of file TrigFastTrackFinder.cxx.

1519 {
1520  if( m_dodEdxTrk ) {
1521  SG::WriteHandle<xAOD::TrigCompositeContainer> dEdxTrkHandle(m_dEdxTrkKey, ctx);
1522  ATH_CHECK( dEdxTrkHandle.record(std::make_unique<xAOD::TrigCompositeContainer>(), std::make_unique<xAOD::TrigCompositeAuxContainer>()) );
1523 
1524  SG::WriteHandle<xAOD::TrigCompositeContainer> dEdxHitHandle(m_dEdxHitKey, ctx);
1525  ATH_CHECK( dEdxHitHandle.record(std::make_unique<xAOD::TrigCompositeContainer>(), std::make_unique<xAOD::TrigCompositeAuxContainer>()) );
1526  }
1527  if( m_doDisappearingTrk ) {
1528  SG::WriteHandle<xAOD::TrigCompositeContainer> disTrkCandHandle(m_disTrkCandKey, ctx);
1529  ATH_CHECK( disTrkCandHandle.record(std::make_unique<xAOD::TrigCompositeContainer>(), std::make_unique<xAOD::TrigCompositeAuxContainer>()) );
1530  }
1531  return StatusCode::SUCCESS;
1532 }

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

◆ dEdx()

float TrigFastTrackFinder::dEdx ( const Trk::Track *  track,
int &  pixelhits,
int &  n_usedhits,
std::vector< float > &  v_pixhit_dedx,
std::vector< float > &  v_pixhit_tot,
std::vector< float > &  v_pixhit_trkchi2,
std::vector< float > &  v_pixhit_trkndof,
std::vector< int > &  v_pixhit_iblovfl,
std::vector< int > &  v_pixhit_loc,
std::vector< int > &  v_pixhit_layer 
) const
private

Definition at line 1744 of file TrigFastTrackFinder.cxx.

1748 {
1749  const float Pixel_sensorthickness=.025; // 250 microns Pixel Planars
1750  const float IBL_3D_sensorthickness=.023; // 230 microns IBL 3D
1751  const float IBL_PLANAR_sensorthickness=.020; // 200 microns IBL Planars
1752 
1753  const float energyPair = 3.68e-6; // Energy in MeV to create an electron-hole pair in silicon
1754  const float sidensity = 2.329; // silicon density in g cm^-3
1755 
1756  float conversion_factor=energyPair/sidensity;
1757 
1758  // Loop over pixel hits on track, and calculate dE/dx:
1759 
1760  pixelhits = 0;
1761  n_usedhits = 0;
1762 
1763  v_pixhit_dedx.clear();
1764  v_pixhit_tot.clear();
1765  v_pixhit_trkchi2.clear();
1766  v_pixhit_trkndof.clear();
1767  v_pixhit_iblovfl.clear();
1768  v_pixhit_loc.clear();
1769  v_pixhit_layer.clear();
1770 
1771  const int PIXLOC_IBL_PL = 0;
1772  const int PIXLOC_IBL_3D = 1;
1773  const int PIXLOC_PIX_LY = 2;
1774  const int PIXLOC_PIX_EC = 3;
1775  const int PIXLOC_IBL_UNKNOWN = 4;
1776  const int PIXLOC_PIX_UNKNOWN = 5;
1777 
1778  std::multimap<float,int> dEdxMap;
1779  float dEdxValue = 0;
1780 
1781  // Check for track states:
1782  const Trk::TrackStates* recoTrackStates = track->trackStateOnSurfaces();
1783  if (recoTrackStates) {
1784 
1785  Trk::TrackStates::const_iterator tsosIter = recoTrackStates->begin();
1786  Trk::TrackStates::const_iterator tsosIterEnd = recoTrackStates->end();
1787 
1788  int i_tsos=0;
1789 
1790  // Loop over track states on surfaces (i.e. generalized hits):
1791  for ( ; tsosIter != tsosIterEnd; ++tsosIter) {
1792 
1793  ATH_MSG_VERBOSE("-------- TSoS: " << i_tsos++ << " --------");
1794 
1795  const Trk::MeasurementBase *measurement = (*tsosIter)->measurementOnTrack();
1796  if ( measurement == nullptr ) {
1797  ATH_MSG_VERBOSE("no measurement on this TSoS, skip it");
1798  continue;
1799  }
1800  const Trk::TrackParameters* tp = (*tsosIter)->trackParameters();
1801  if( tp == nullptr ) {
1802  ATH_MSG_VERBOSE("no trackParameters() to this TSoS, skip it");
1803  continue;
1804  }
1805  const InDet::PixelClusterOnTrack *pixclus = dynamic_cast<const InDet::PixelClusterOnTrack*>(measurement);
1806  if ( pixclus == nullptr ) {
1807  ATH_MSG_VERBOSE("this TSoS is not Pixel, skip it");
1808  continue;
1809  }
1810  const InDet::PixelCluster* prd = pixclus->prepRawData();
1811  if( prd == nullptr ) {
1812  ATH_MSG_VERBOSE("no PrepRawData(), skip it");
1813  continue;
1814  }
1815 
1816  float dotProd = tp->momentum().dot(tp->associatedSurface().normal());
1817  float cosalpha = std::abs(dotProd/tp->momentum().mag());
1818  ATH_MSG_VERBOSE("dotProd / cosalpha = " << dotProd << " / " << cosalpha);
1819  if (std::abs(cosalpha)<.16) continue;
1820 
1821  const std::vector<int>& v_tots = prd->totList();
1822  float charge = prd->totalCharge();
1823  float tot = prd->totalToT();
1824  ATH_MSG_VERBOSE("charge / ToT = " << charge << " / " << tot);
1825  charge *= cosalpha; // path length correction
1826 
1827  double locx = pixclus->localParameters()[Trk::locX];
1828  double locy = pixclus->localParameters()[Trk::locY];
1829  int bec = m_pixelId->barrel_ec(pixclus->identify());
1830  int layer = m_pixelId->layer_disk(pixclus->identify());
1831  int eta_module = m_pixelId->eta_module(pixclus->identify()); //check eta module to select thickness
1832 
1833  float chi2 = 0.;
1834  float ndof = 0.;
1835  const Trk::FitQualityOnSurface fq = (*tsosIter)->fitQualityOnSurface();
1836  if(fq) {
1837  chi2 = fq.chiSquared();
1838  ndof = fq.doubleNumberDoF();
1839  }
1840 
1841  int iblOverflow=0; // keep track if this is IBL overflow
1842  float thickness=0;
1843  int loc=-1;
1844 
1845  if ( (bec==0) and (layer==0) ){ // IBL
1846  const float overflowIBLToT = 16; // m_overflowIBLToT = m_offlineCalibSvc->getIBLToToverflow();
1847  for (int pixToT : v_tots) {
1848  if (pixToT >= overflowIBLToT) {
1849  iblOverflow = 1; // overflow pixel hit -- flag cluster
1850  break; //no need to check other hits of this cluster
1851  }
1852  }
1853  if(iblOverflow==1) ATH_MSG_VERBOSE("IBL overflow");
1854 
1855  if(((eta_module>=-10 && eta_module<=-7)||(eta_module>=6 && eta_module<=9)) && (std::abs(locy)<10. && (locx>-8.33 && locx <8.3)) ){ // IBL 3D
1856  thickness = IBL_3D_sensorthickness;
1857  loc = PIXLOC_IBL_3D;
1858  }
1859  else if((eta_module>=-6 && eta_module<=5) && (std::abs(locy)<20. &&( locx >-8.33 && locx <8.3 )) ){ // IBL planer
1860  thickness = IBL_PLANAR_sensorthickness;
1861  loc = PIXLOC_IBL_PL;
1862  }
1863  else {
1864  ATH_MSG_VERBOSE("unknown IBL module");
1865  loc = PIXLOC_IBL_UNKNOWN;
1866  }
1867  }
1868  else if(bec==0 && std::abs(locy)<30. && (( locx > -8.20 && locx < -0.60 ) || ( locx > 0.50 && locx < 8.10 ) ) ){ //PIXEL layer
1869  thickness = Pixel_sensorthickness;
1870  loc = PIXLOC_PIX_LY;
1871  }
1872  else if(std::abs(bec) == 2 && std::abs(locy)<30. && ( ( locx > -8.15 && locx < -0.55 ) || ( locx > 0.55 && locx < 8.15 ) ) ) { //PIXEL endcap
1873  thickness = Pixel_sensorthickness;
1874  loc = PIXLOC_PIX_EC;
1875  }
1876  else {
1877  ATH_MSG_VERBOSE("unknown Pixel module");
1878  loc = PIXLOC_IBL_UNKNOWN;
1879  }
1880 
1881  dEdxValue = 0;
1882  if( loc != PIXLOC_IBL_UNKNOWN && loc != PIXLOC_PIX_UNKNOWN ) {
1883  dEdxValue = charge*conversion_factor/thickness;
1884  dEdxMap.insert(std::pair<float,int>(dEdxValue, iblOverflow));
1885  pixelhits++;
1886  }
1887  ATH_MSG_VERBOSE("dEdx=" << dEdxValue);
1888  v_pixhit_dedx.push_back(dEdxValue); v_pixhit_tot.push_back(tot);
1889  v_pixhit_trkchi2.push_back(chi2); v_pixhit_trkndof.push_back(ndof);
1890  v_pixhit_iblovfl.push_back(iblOverflow); v_pixhit_loc.push_back(loc); v_pixhit_layer.push_back(layer);
1891  }
1892  }
1893 
1894  // Now calculate dEdx, multimap is already sorted in ascending order
1895  // float averageCharge=-1;
1896 
1897  float averagedEdx=0.;
1898  int IBLOverflow=0;
1899 
1900  int i_map=0;
1901 
1902  for (std::pair<float,int> itdEdx : dEdxMap) {
1903  ATH_MSG_VERBOSE("++++++++ i_map: " << i_map++ << " ++++++++");
1904  if(itdEdx.second==0){
1905  ATH_MSG_VERBOSE("usedhits, dEdx=" << itdEdx.first);
1906  averagedEdx += itdEdx.first;
1907  n_usedhits++;
1908  }
1909  if(itdEdx.second > 0){
1910  ATH_MSG_VERBOSE("IBLOverflow");
1911  IBLOverflow++;
1912  }
1913  // break, skipping last or the two last elements depending on total measurements
1914  if (((int)pixelhits >= 5) and ((int)n_usedhits >= (int)pixelhits-2)) {
1915  ATH_MSG_VERBOSE("break, skipping last or two last elements");
1916  break;
1917  }
1918 
1919  // break, IBL Overflow case pixelhits==3 and 4
1920  if((int)IBLOverflow>0 and ((int)pixelhits==3) and (int)n_usedhits==1) {
1921  ATH_MSG_VERBOSE("break, IBL overflow case, pixel hits=3");
1922  break;
1923  }
1924  if((int)IBLOverflow>0 and ((int)pixelhits==4) and (int)n_usedhits==2) {
1925  ATH_MSG_VERBOSE("break, IBL overflow case, pixel hits=4");
1926  break;
1927  }
1928 
1929  if (((int)pixelhits > 1) and ((int)n_usedhits >=(int)pixelhits-1)) {
1930  ATH_MSG_VERBOSE("break, skipping last??");
1931  break;
1932  }
1933 
1934  if((int)IBLOverflow>0 and (int)pixelhits==1){ // only IBL in overflow
1935  ATH_MSG_VERBOSE("break, only IBL in overflow");
1936  averagedEdx=itdEdx.first;
1937  break;
1938  }
1939  }
1940 
1941  if (n_usedhits > 0 or (n_usedhits==0 and(int)IBLOverflow>0 and (int)pixelhits==1)) {
1942  if(n_usedhits > 0) averagedEdx = averagedEdx / n_usedhits;
1943  //if(n_usedhits == 0 and (int)IBLOverflow > 0 and (int)pixelhits == 1) averagedEdx = averagedEdx; //no-op
1944  ATH_MSG_DEBUG("=====> averaged dEdx = " << averagedEdx << " =====>");;
1945  ATH_MSG_DEBUG(" +++ Used hits: " << n_usedhits << ", IBL overflows: " << IBLOverflow );;
1946  ATH_MSG_DEBUG(" +++ Original number of measurements = " << pixelhits << " (map size = " << dEdxMap.size() << ") ");
1947  return averagedEdx;
1948  }
1949 
1950  // -- false return
1951  ATH_MSG_DEBUG("dEdx not calculated, return 0");
1952  return 0.;
1953 }

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

◆ disTrackQuality()

double TrigFastTrackFinder::disTrackQuality ( const Trk::Track *  Tr) const
private

Definition at line 2093 of file TrigFastTrackFinder.cxx.

2094 {
2095  Trk::TrackStates::const_iterator
2096  m = Tr->trackStateOnSurfaces()->begin(),
2097  me = Tr->trackStateOnSurfaces()->end ();
2098 
2099  double quality_pixel = 0. ;
2100  double quality_sct = 0. ;
2101 
2102  const double W = 17.;
2103 
2104  for(; m!=me; ++m) {
2105  const Trk::FitQualityOnSurface fq = (*m)->fitQualityOnSurface();
2106  if(!fq) continue;
2107 
2108  double x2 = fq.chiSquared();
2109  double q;
2110  if(fq.numberDoF() == 2) q = (1.2*(W-x2*.5));
2111  else q = (W-x2 );
2112  if(q < 0.) q = 0.;
2113 
2114  const Trk::MeasurementBase *measurement = (*m)->measurementOnTrack();
2115  if (measurement) {
2116  const InDet::PixelClusterOnTrack *pixclus = dynamic_cast<const InDet::PixelClusterOnTrack*>(measurement);
2117  if( pixclus !=0 ) quality_pixel += q;
2118  else quality_sct += q;
2119  }
2120  }
2121 
2122  //
2123  double quality = quality_pixel;
2124  quality -= quality_sct;
2125  if( quality < 0. ) quality = 0.;
2126 
2127  return quality;
2128 }

◆ disTrk_refit()

std::unique_ptr< Trk::Track > TrigFastTrackFinder::disTrk_refit ( Trk::Track *  t) const
private

Definition at line 2791 of file TrigFastTrackFinder.cxx.

2792 {
2793  std::unique_ptr<Trk::Track> newtrack = nullptr;
2794 
2795  if( t == nullptr ) return newtrack;
2796  if( t->trackSummary() == nullptr ) m_trackSummaryTool->updateTrack(*t);
2797 
2798  ATH_MSG_VERBOSE("refitting - input track:");
2799  print_disTrk(t);
2800 
2801  const Trk::Perigee* origPerigee = t->perigeeParameters();
2802  if( origPerigee == nullptr ) return newtrack;
2803  ATH_MSG_VERBOSE("... origPerigee is there");
2804 
2805  // remove SCT hits
2806  std::vector<const Trk::MeasurementBase*> vec;
2807  int n_measurements = 0;
2808  int n_measurements_refit = 0;
2809  const Trk::TrackStates* recoTrackStates = t->trackStateOnSurfaces();
2810  if (recoTrackStates) {
2811  Trk::TrackStates::const_iterator tsosIter = recoTrackStates->begin();
2812  Trk::TrackStates::const_iterator tsosIterEnd = recoTrackStates->end();
2813  for ( ; tsosIter != tsosIterEnd; ++tsosIter) {
2814  const Trk::MeasurementBase *measurement = (*tsosIter)->measurementOnTrack();
2815  if (measurement) {
2816  n_measurements++;
2817  const InDet::PixelClusterOnTrack *pixclus = dynamic_cast<const InDet::PixelClusterOnTrack*>(measurement);
2818  const InDet::SCT_ClusterOnTrack *sctclus = dynamic_cast<const InDet::SCT_ClusterOnTrack*>(measurement);
2819  bool to_add = true;
2820  if ( !pixclus && sctclus ) to_add = false;
2821  if( to_add ) {
2822  vec.push_back(measurement);
2823  n_measurements_refit++;
2824  }
2825  }
2826  }
2827  }
2828  ATH_MSG_VERBOSE("... Nr of measurments / refit = " << n_measurements << " / " << n_measurements_refit);
2829 
2830  // perform refit
2831  newtrack = m_disTrkFitter->fit(Gaudi::Hive::currentContext(),vec, *origPerigee, false, m_particleHypothesis); // false to run outlier switch
2832  ATH_MSG_VERBOSE("... ---> refit track:");
2833  if( newtrack!=0 && newtrack.get() ) {
2834  print_disTrk(dynamic_cast<const Trk::Track*>(newtrack.get()));
2835  }
2836  else {
2837  ATH_MSG_VERBOSE("... refit failed");
2838  }
2839 
2840  //
2841  return newtrack;
2842 }

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

internalRoI.manageConstituents(false);//Don't try to delete RoIs at the end

updating this class member counter is not going to be thread safe ...

Definition at line 399 of file TrigFastTrackFinder.cxx.

399  {
400 
401  SG::WriteHandle<TrackCollection> outputTracks(m_outputTracksKey, ctx);
402  outputTracks = std::make_unique<TrackCollection>();
403 
404  const TrackCollection* inputTracks = nullptr;
405  if (m_LRTmode) {
406  if (!m_inputTracksKey.key().empty()){
407  SG::ReadHandle<TrackCollection> inputTrackHandle(m_inputTracksKey, ctx);
408  ATH_CHECK(inputTrackHandle.isValid());
409  inputTracks = inputTrackHandle.ptr();
410  }
411  }
412  InDet::ExtendedSiTrackMakerEventData_xk trackEventData(m_prdToTrackMap, ctx);
413 
414  //RoI preparation/update
415 
416  if (m_standaloneMode) {
417  //the default fullscan TrigRoiDescriptor settings for beamspot width (z-range) are incorrect
418  const TrigRoiDescriptor internalRoI = TrigRoiDescriptor(0, -4.5, 4.5, 0, -M_PI, M_PI, 0, -150.0, 150.0);
419 
420  ATH_CHECK(findTracks(trackEventData, internalRoI, inputTracks, *outputTracks, ctx));
421 
422  } else {
423  SG::ReadHandle<TrigRoiDescriptorCollection> roiCollection(m_roiCollectionKey, ctx);
424 
425  ATH_CHECK(roiCollection.isValid());
426 
427  if ( roiCollection->size()>1 ) ATH_MSG_WARNING( "More than one Roi in the collection: " << m_roiCollectionKey << ", this is not supported - use a composite Roi: Using the first Roi ONLY" );
428 
429  if ( roiCollection->size()==0) {
430  ATH_MSG_ERROR("No Roi found for " << m_roiCollectionKey.key() );
431  return StatusCode::FAILURE;
432  }
433 
434  TrigRoiDescriptor internalRoI = **roiCollection->begin();
435 
436  ATH_CHECK(findTracks(trackEventData, internalRoI, inputTracks, *outputTracks, ctx));
437  }
438 
440 
442  m_countTotalRoI++;
443 
444  return StatusCode::SUCCESS;
445 }

◆ extractClusterIds()

void TrigFastTrackFinder::extractClusterIds ( const Trk::SpacePoint *  pSP,
std::vector< Identifier > &  vIds 
) const
protected

Definition at line 1081 of file TrigFastTrackFinder.cxx.

1081  {
1082  const InDet::SiCluster* pCL = dynamic_cast<const InDet::SiCluster*>(pSP->clusterList().first);
1083  if(pCL!=nullptr) vIds.push_back(pCL->identify());
1084  //check second cluster : SCT uv clusters only !
1085  pCL = dynamic_cast<const InDet::SiCluster*>(pSP->clusterList().second);
1086  if(pCL!=nullptr) vIds.push_back(pCL->identify());
1087 }

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

◆ extrapolateDisTrackToBS()

std::unique_ptr< const Trk::TrackParameters > TrigFastTrackFinder::extrapolateDisTrackToBS ( Trk::Track *  t,
const std::vector< double > &  v_xvtx,
const std::vector< double > &  v_yvtx,
const std::vector< double > &  v_zvtx 
) const
private

Definition at line 2514 of file TrigFastTrackFinder.cxx.

2516 {
2517  float vtx_x = 0;
2518  float vtx_y = 0;
2519  float vtx_z = 9999;
2520  float trk_z0 = t->perigeeParameters()->parameters()[Trk::z0];
2521  float z0_min = 9999;
2522  for(unsigned int i_vtx=0; i_vtx<v_zvtx.size(); i_vtx++) {
2523  float z = v_zvtx[i_vtx];
2524  if( std::abs(trk_z0-z) < z0_min ) {
2525  z0_min = std::abs(trk_z0-z);
2526  vtx_z = z;
2527  vtx_x = v_xvtx[i_vtx];
2528  vtx_y = v_yvtx[i_vtx];
2529  }
2530  }
2531 
2532  Amg::Vector3D gp(vtx_x, vtx_y, vtx_z);
2533  Trk::PerigeeSurface persf(gp);
2534  std::unique_ptr<const Trk::TrackParameters> tmp =
2535  m_extrapolator->extrapolateDirectly(Gaudi::Hive::currentContext(), (*(t->perigeeParameters())), persf);
2536  if (tmp && tmp->associatedSurface().type() == Trk::SurfaceType::Perigee) {
2537  return tmp;
2538  }
2539  return nullptr;
2540 }

◆ fillDisTrkCand() [1/2]

void TrigFastTrackFinder::fillDisTrkCand ( xAOD::TrigComposite *  comp,
const std::string &  prefix,
Trk::Track *  trk,
const std::unique_ptr< const Trk::TrackParameters > &  vertexPerigee 
) const
private

Definition at line 2569 of file TrigFastTrackFinder.cxx.

2570 {
2571  std::vector<Trk::Track*> vtmp;
2572  fillDisTrkCand(comp,prefix,trk,vertexPerigee,false,vtmp);
2573 }

◆ fillDisTrkCand() [2/2]

void TrigFastTrackFinder::fillDisTrkCand ( xAOD::TrigComposite *  comp,
const std::string &  prefix,
Trk::Track *  trk,
const std::unique_ptr< const Trk::TrackParameters > &  vertexPerigee,
bool  fillIso,
std::vector< Trk::Track * > &  tracksForIso 
) const
private

Definition at line 2575 of file TrigFastTrackFinder.cxx.

2577 {
2578  // category
2579  int category = (trk != nullptr) ? (int)getDisTrkCategory(trk) : -1;
2580  if( prefix.find("refit") == std::string::npos ) comp->setDetail<int16_t>(prefix+"_category",(int16_t)category);
2581 
2582  // track
2583  float theta=0; float eta=0; float pt=0; float d0=0; float z0=0; float phi=0; float chi2=0; float ndof=0;
2584  int n_hits_innermost=-1; int n_hits_next_to_innermost=-1; int n_hits_inner=-1; int n_hits_pix=-1; int n_hits_sct=-1;
2585  if( trk != nullptr ) {
2586  theta = trk->perigeeParameters()->parameters()[Trk::theta];
2587  eta = -std::log(std::tan(0.5*theta));
2588  float qOverP = std::abs(trk->perigeeParameters()->parameters()[Trk::qOverP]);
2589  if ( qOverP < 1e-12 ) qOverP = 1e-12;
2590  pt = sin(theta)/qOverP;
2591  d0 = trk->perigeeParameters()->parameters()[Trk::d0];
2592  z0 = trk->perigeeParameters()->parameters()[Trk::z0];
2593  phi = trk->perigeeParameters()->parameters()[Trk::phi];
2594  chi2 = trk->fitQuality()->chiSquared();
2595  ndof = trk->fitQuality()->doubleNumberDoF();
2596  if( trk->trackSummary()!=0 ) {
2597  n_hits_pix = trk->trackSummary()->get(Trk::SummaryType::numberOfPixelHits);
2598  n_hits_sct = trk->trackSummary()->get(Trk::SummaryType::numberOfSCTHits);
2599  n_hits_innermost = trk->trackSummary()->get(Trk::SummaryType::numberOfInnermostPixelLayerHits);
2600  n_hits_next_to_innermost = trk->trackSummary()->get(Trk::SummaryType::numberOfNextToInnermostPixelLayerHits);
2601  n_hits_inner = n_hits_innermost + n_hits_next_to_innermost;
2602  }
2603  }
2604  comp->setDetail<float>(prefix+"_pt", pt);
2605  comp->setDetail<float>(prefix+"_eta", eta);
2606  comp->setDetail<float>(prefix+"_phi", phi);
2607  comp->setDetail<float>(prefix+"_d0", d0);
2608  comp->setDetail<float>(prefix+"_z0", z0);
2609  comp->setDetail<float>(prefix+"_chi2", chi2);
2610  comp->setDetail<float>(prefix+"_ndof", ndof);
2611  comp->setDetail<int16_t>(prefix+"_n_hits_innermost", (int16_t)n_hits_innermost);
2612  comp->setDetail<int16_t>(prefix+"_n_hits_inner", (int16_t)n_hits_inner);
2613  comp->setDetail<int16_t>(prefix+"_n_hits_pix", (int16_t)n_hits_pix);
2614  comp->setDetail<int16_t>(prefix+"_n_hits_sct", (int16_t)n_hits_sct);
2615 
2616  // extrapolate
2617  float theta_wrtVtx=0; float eta_wrtVtx=0; float pt_wrtVtx=0; float d0_wrtVtx=0; float z0_wrtVtx=0; float phi_wrtVtx=0;
2618  if( vertexPerigee != nullptr ) {
2619  theta_wrtVtx = vertexPerigee->parameters()[Trk::theta];
2620  eta_wrtVtx = -std::log(std::tan(0.5*theta_wrtVtx));
2621  float qOverP_wrtVtx = std::abs(vertexPerigee->parameters()[Trk::qOverP]);
2622  if ( qOverP_wrtVtx < 1e-12 ) qOverP_wrtVtx = 1e-12;
2623  pt_wrtVtx = std::sin(theta_wrtVtx)/qOverP_wrtVtx;
2624  d0_wrtVtx = vertexPerigee->parameters()[Trk::d0];
2625  z0_wrtVtx = vertexPerigee->parameters()[Trk::z0];
2626  phi_wrtVtx = vertexPerigee->parameters()[Trk::phi];
2627  }
2628  comp->setDetail<float>(prefix+"_pt_wrtVtx", pt_wrtVtx);
2629  comp->setDetail<float>(prefix+"_eta_wrtVtx", eta_wrtVtx);
2630  comp->setDetail<float>(prefix+"_phi_wrtVtx", phi_wrtVtx);
2631  comp->setDetail<float>(prefix+"_d0_wrtVtx", d0_wrtVtx);
2632  comp->setDetail<float>(prefix+"_z0_wrtVtx", z0_wrtVtx);
2633 
2634  // barrel hits
2635  std::array<OneLayerInfo_t, N_BARREL_LAYERS> barrelInfo{};
2636  barrelInfo = getTrkBarrelLayerInfo(trk);
2637  comp->setDetail<float>(prefix+"_chi2sum_br_ibl", barrelInfo[0].chiSq);
2638  comp->setDetail<float>(prefix+"_chi2sum_br_pix1", barrelInfo[1].chiSq);
2639  comp->setDetail<float>(prefix+"_chi2sum_br_pix2", barrelInfo[2].chiSq);
2640  comp->setDetail<float>(prefix+"_chi2sum_br_pix3", barrelInfo[3].chiSq);
2641  comp->setDetail<float>(prefix+"_chi2sum_br_sct1", barrelInfo[4].chiSq);
2642  comp->setDetail<float>(prefix+"_chi2sum_br_sct2", barrelInfo[5].chiSq);
2643  comp->setDetail<float>(prefix+"_chi2sum_br_sct3", barrelInfo[6].chiSq);
2644  comp->setDetail<float>(prefix+"_chi2sum_br_sct4", barrelInfo[7].chiSq);
2645  comp->setDetail<float>(prefix+"_ndofsum_br_ibl", barrelInfo[0].nDof);
2646  comp->setDetail<float>(prefix+"_ndofsum_br_pix1", barrelInfo[1].nDof);
2647  comp->setDetail<float>(prefix+"_ndofsum_br_pix2", barrelInfo[2].nDof);
2648  comp->setDetail<float>(prefix+"_ndofsum_br_pix3", barrelInfo[3].nDof);
2649  comp->setDetail<float>(prefix+"_ndofsum_br_sct1", barrelInfo[4].nDof);
2650  comp->setDetail<float>(prefix+"_ndofsum_br_sct2", barrelInfo[5].nDof);
2651  comp->setDetail<float>(prefix+"_ndofsum_br_sct3", barrelInfo[6].nDof);
2652  comp->setDetail<float>(prefix+"_ndofsum_br_sct4", barrelInfo[7].nDof);
2653 
2654  // isolation
2655  if( fillIso ) {
2656  const float ISOL_CALC_Z0_DIFF_CUT = 2.5;
2657  const float ISOL_CALC_DR_CUT_TO_AVOID_ZERO = 0.015;
2658  float iso1_dr01=0; float iso1_dr02=0;
2659  float iso2_dr01=0; float iso2_dr02=0;
2660  float iso3_dr01=0; float iso3_dr02=0;
2661  for(auto t=tracksForIso.begin(); t!=tracksForIso.end(); t++) {
2662  float z0_t = (*t)->perigeeParameters()->parameters()[Trk::z0];
2663  if( std::abs(z0_t - z0) <= ISOL_CALC_Z0_DIFF_CUT ) {
2664  float theta_t = (*t)->perigeeParameters()->parameters()[Trk::theta];
2665  float qOverP_t= std::abs((*t)->perigeeParameters()->parameters()[Trk::qOverP]);
2666  if ( qOverP_t < 1e-12 ) qOverP_t = 1e-12;
2667  float pt_t = std::sin(theta_t)/qOverP_t;
2668  float phi_t = (*t)->perigeeParameters()->parameters()[Trk::phi];
2669  float eta_t = -std::log(std::tan(theta_t/2.0));
2670  float deta = eta_t - eta;
2671  float dphi = std::abs(phi_t - phi);
2672  if( dphi > CLHEP::pi ) dphi = CLHEP::pi*2 - dphi;
2673  float dr = std::sqrt(deta*deta + dphi*dphi);
2674  if( dr > ISOL_CALC_DR_CUT_TO_AVOID_ZERO && dr<0.1 && pt_t > 1.0*Gaudi::Units::GeV ) iso1_dr01 += pt_t;
2675  if( dr > ISOL_CALC_DR_CUT_TO_AVOID_ZERO && dr<0.2 && pt_t > 1.0*Gaudi::Units::GeV ) iso1_dr02 += pt_t;
2676  //
2677  if( dr > ISOL_CALC_DR_CUT_TO_AVOID_ZERO && dr<0.1 && pt_t > 2.0*Gaudi::Units::GeV ) iso2_dr01 += pt_t;
2678  if( dr > ISOL_CALC_DR_CUT_TO_AVOID_ZERO && dr<0.2 && pt_t > 2.0*Gaudi::Units::GeV ) iso2_dr02 += pt_t;
2679  //
2680  if( dr > ISOL_CALC_DR_CUT_TO_AVOID_ZERO && dr<0.1 && pt_t > 3.0*Gaudi::Units::GeV ) iso3_dr01 += pt_t;
2681  if( dr > ISOL_CALC_DR_CUT_TO_AVOID_ZERO && dr<0.2 && pt_t > 3.0*Gaudi::Units::GeV ) iso3_dr02 += pt_t;
2682  }
2683  }
2684  comp->setDetail<float>(prefix+"_iso1_dr01", iso1_dr01);
2685  comp->setDetail<float>(prefix+"_iso1_dr02", iso1_dr02);
2686  comp->setDetail<float>(prefix+"_iso2_dr01", iso2_dr01);
2687  comp->setDetail<float>(prefix+"_iso2_dr02", iso2_dr02);
2688  comp->setDetail<float>(prefix+"_iso3_dr01", iso3_dr01);
2689  comp->setDetail<float>(prefix+"_iso3_dr02", iso3_dr02);
2690  }
2691 }

◆ fillMon()

void TrigFastTrackFinder::fillMon ( const TrackCollection &  tracks,
const TrigVertexCollection &  vertices,
const TrigRoiDescriptor &  roi,
const EventContext &  ctx 
) const
private

Definition at line 1112 of file TrigFastTrackFinder.cxx.

1113  {
1114  float shift_x = 0;
1115  float shift_y = 0;
1116  if(m_useBeamSpot) {
1117  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx };
1118  FTF::getBeamSpotShift(shift_x, shift_y, **beamSpotHandle);
1119  }
1120  auto mnt_roi_eta = Monitored::Scalar<float>("roi_eta", 0.0);
1121  auto mnt_roi_phi = Monitored::Scalar<float>("roi_phi", 0.0);
1122  auto mnt_roi_etaWidth = Monitored::Scalar<float>("roi_etaWidth", 0.0);
1123  auto mnt_roi_phiWidth = Monitored::Scalar<float>("roi_phiWidth", 0.0);
1124  auto mnt_roi_z = Monitored::Scalar<float>("roi_z", 0.0);
1125  auto mnt_roi_zWidth = Monitored::Scalar<float>("roi_zWidth", 0.0);
1126  auto monRoI = Monitored::Group(m_monTool, mnt_roi_eta, mnt_roi_phi, mnt_roi_etaWidth, mnt_roi_phiWidth, mnt_roi_z, mnt_roi_zWidth);
1127 
1128  if (roi.composite()){
1129  for(unsigned int i=0; i<roi.size(); i++) {
1130  const IRoiDescriptor *subroi = roi.at(i);
1131  if (subroi){
1132  mnt_roi_eta = subroi->eta();
1133  mnt_roi_phi = subroi->phi();
1134  mnt_roi_etaWidth = subroi->etaPlus() - subroi->etaMinus();
1135  mnt_roi_phiWidth = CxxUtils::wrapToPi(subroi->phiPlus() - subroi->phiMinus());
1136  mnt_roi_z = subroi->zed();
1137  mnt_roi_zWidth = subroi->zedPlus() - subroi->zedMinus();
1138  monRoI.fill();
1139  }
1140  }
1141  }
1142  else {
1143  mnt_roi_eta = roi.eta();
1144  mnt_roi_phi = roi.phi();
1145  mnt_roi_etaWidth = roi.etaPlus() - roi.etaMinus();
1146  mnt_roi_phiWidth = CxxUtils::wrapToPi(roi.phiPlus() - roi.phiMinus());
1147  mnt_roi_z = roi.zed();
1148  mnt_roi_zWidth = roi.zedPlus() - roi.zedMinus();
1149  }
1150 
1151  std::vector<float> mnt_trk_pt;
1152  std::vector<float> mnt_trk_a0;
1153  std::vector<float> mnt_trk_z0;
1154  std::vector<float> mnt_trk_phi0;
1155  std::vector<float> mnt_trk_eta;
1156  std::vector<float> mnt_trk_chi2dof;
1157  std::vector<float> mnt_trk_nSiHits;
1158  std::vector<float> mnt_trk_nPIXHits;
1159  std::vector<float> mnt_trk_nSCTHits;
1160  std::vector<float> mnt_trk_a0beam;
1161  std::vector<float> mnt_trk_z0beam;
1162  std::vector<float> mnt_trk_dPhi0;
1163  std::vector<float> mnt_trk_dEta;
1164 
1165  auto mon_pt = Monitored::Collection("trk_pt", mnt_trk_pt);
1166  auto mon_a0 = Monitored::Collection("trk_a0", mnt_trk_a0);
1167  auto mon_z0 = Monitored::Collection("trk_z0", mnt_trk_z0);
1168  auto mon_phi0 = Monitored::Collection("trk_phi0", mnt_trk_phi0);
1169  auto mon_eta = Monitored::Collection("trk_eta", mnt_trk_eta);
1170  auto mon_chi2dof = Monitored::Collection("trk_chi2dof", mnt_trk_chi2dof);
1171  auto mon_nSiHits = Monitored::Collection("trk_nSiHits", mnt_trk_nSiHits);
1172  auto mon_nPIXHits = Monitored::Collection("trk_nPIXHits", mnt_trk_nPIXHits);
1173  auto mon_nSCTHits = Monitored::Collection("trk_nSCTHits", mnt_trk_nSCTHits);
1174  auto mon_a0beam = Monitored::Collection("trk_a0beam", mnt_trk_a0beam);
1175  auto mon_z0beam = Monitored::Collection("trk_z0beam", mnt_trk_z0beam);
1176  auto mon_dPhi0 = Monitored::Collection("trk_dPhi0", mnt_trk_dPhi0);
1177  auto mon_dEta = Monitored::Collection("trk_dEta", mnt_trk_dEta);
1178  auto monTrk = Monitored::Group(m_monTool, mon_pt, mon_a0, mon_z0, mon_phi0, mon_eta, mon_chi2dof,
1179  mon_nSiHits, mon_nPIXHits, mon_nSCTHits, mon_a0beam, mon_z0beam, mon_dPhi0, mon_dEta);
1180 
1181  std::vector<float> mnt_roi_zVertices;
1182  auto mon_roi_nZvertices = Monitored::Scalar<int>("roi_nZvertices", 0);
1183  auto mon_roi_zVertices = Monitored::Collection("roi_zVertices", mnt_roi_zVertices);
1184  auto monVtx = Monitored::Group(m_monTool, mon_roi_nZvertices, mon_roi_zVertices);
1185  mon_roi_nZvertices = vertices.size();
1186  for (const auto vertex : vertices) {
1187  mnt_roi_zVertices.push_back(vertex->z());
1188  }
1189 
1190  for (auto track : tracks) {
1191  const Trk::TrackParameters* trackPars = track->perigeeParameters();
1192  if(trackPars==nullptr) {
1193  continue;
1194  }
1195 
1196  if(trackPars->covariance()==nullptr) {
1197  continue;
1198  }
1199 
1200  float a0 = trackPars->parameters()[Trk::d0];
1201  float z0 = trackPars->parameters()[Trk::z0];
1202  float phi0 = trackPars->parameters()[Trk::phi0];
1203  float theta = trackPars->parameters()[Trk::theta];
1204  float eta = -log(tan(0.5*theta));
1205  mnt_trk_a0.push_back(a0);
1206  mnt_trk_z0.push_back(z0);
1207  mnt_trk_phi0.push_back(phi0);
1208  mnt_trk_a0beam.push_back(a0+shift_x*std::sin(phi0)-shift_y*std::cos(phi0));
1209  mnt_trk_z0beam.push_back(z0+(shift_x*std::cos(phi0)+shift_y*std::sin(phi0))/std::tan(theta));
1210  mnt_trk_eta.push_back(eta);
1211  for(unsigned int i=0; i<roi.size(); i++) {
1212  mnt_trk_dPhi0.push_back(CxxUtils::wrapToPi(phi0 - (roi.at(i))->phi()));
1213  mnt_trk_dEta.push_back(eta - (roi.at(i))->eta());
1214  }
1215 
1216  float qOverP = trackPars->parameters()[Trk::qOverP];
1217  if (qOverP==0) {
1218  ATH_MSG_DEBUG("REGTEST / q/p == 0, adjusting to 1e-12");
1219  qOverP = 1e-12;
1220  }
1221  float pT=sin(theta)/qOverP;
1222 
1223  const Trk::FitQuality* fq = track->fitQuality();
1224  float chi2 = 1e8;
1225  if (fq) {
1226  ATH_MSG_VERBOSE("Fitted chi2: " << fq->chiSquared());
1227  ATH_MSG_VERBOSE("Fitted ndof: " << fq->numberDoF());
1228  if(fq->numberDoF()!=0) {
1229  chi2 = fq->chiSquared()/fq->numberDoF();
1230  }
1231  }
1232  mnt_trk_pt.push_back(pT);
1233  mnt_trk_chi2dof.push_back(chi2);
1234 
1235  int nPix=0, nSct=0;
1236 
1237  for(auto tSOS = track->trackStateOnSurfaces()->begin();
1238  tSOS!=track->trackStateOnSurfaces()->end(); ++tSOS) {
1239  if ((*tSOS)->type(Trk::TrackStateOnSurface::Perigee) == false) {
1240  const Trk::FitQualityOnSurface fq = (*tSOS)->fitQualityOnSurface();
1241  if(!fq) continue;
1242  int nd = fq.numberDoF();
1243  if(nd==2) nPix++;
1244  if(nd==1) nSct++;
1245  }
1246  }
1247  mnt_trk_nPIXHits.push_back(nPix);
1248  mnt_trk_nSCTHits.push_back(nSct/2);
1249  mnt_trk_nSiHits.push_back(nPix + nSct/2);
1250 
1251  ATH_MSG_DEBUG("REGTEST / track npix/nsct/phi0/pt/eta/d0/z0/chi2: " <<
1252  nPix << " / " <<
1253  nSct/2 << " / " <<
1254  phi0 << " / " <<
1255  pT << " / " <<
1256  eta << " / " <<
1257  a0 << " / " <<
1258  z0 << " / " <<
1259  chi2);
1260  // tighter selection for unbiased residuals
1261  bool goodTrack = std::fabs(pT)>1000. && (nPix + nSct/2) > 3 && nSct > 0;
1262  if (goodTrack && m_doResMonitoring) {
1263  runResidualMonitoring(*track, ctx);
1264  }
1265  }
1266 }

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

◆ filterSharedDisTracks()

void TrigFastTrackFinder::filterSharedDisTracks ( std::vector< std::tuple< bool, double, Trk::Track * >> &  QT) const
private

Definition at line 2325 of file TrigFastTrackFinder.cxx.

2326 {
2327  const int N_FREE_PIX_HITS_CUT = 2;
2328 
2329  std::set<const Trk::PrepRawData*> clusters;
2330 
2331  const Trk::PrepRawData* prd[100];
2332 
2333  std::sort(QT.begin(), QT.end(),
2334  [](const std::tuple<bool, double, Trk::Track*>& lhs, const std::tuple<bool, double, Trk::Track*>& rhs) {
2335  return std::get<1>(lhs) < std::get<1>(rhs); } );
2336 
2337  for (auto& q : QT) {
2338  DataVector<const Trk::MeasurementBase>::const_iterator
2339  m = std::get<2>(q)->measurementsOnTrack()->begin(),
2340  me = std::get<2>(q)->measurementsOnTrack()->end ();
2341 
2342  int nf = 0, nc = 0;
2343  for(; m!=me; ++m ) {
2344  const Trk::PrepRawData* pr = ((const Trk::RIO_OnTrack*)(*m))->prepRawData();
2345  if(pr) {
2346  const InDet::PixelClusterOnTrack *pixclus = dynamic_cast<const InDet::PixelClusterOnTrack*>((*m));
2347  if (pixclus) {
2348  ++nc;
2349  if(clusters.find(pr)==clusters.end()) {prd[nf++]=pr; if(nf==100) break;}
2350  }
2351  }
2352  }
2353  if((nf >= N_FREE_PIX_HITS_CUT) || (nf == nc) ) {
2354  for(int n=0; n!=nf; ++n) clusters.insert(prd[n]);
2355  }
2356  else {
2357  std::get<0>(q) = false;
2358  }
2359  }
2360 }

◆ filterSharedTracks()

void TrigFastTrackFinder::filterSharedTracks ( std::vector< std::tuple< bool, double, Trk::Track * >> &  QT) const

Definition at line 1012 of file TrigFastTrackFinder.cxx.

1012  {
1013 
1014  std::set<const Trk::PrepRawData*> clusters;
1015 
1016  const Trk::PrepRawData* prd[100];
1017 
1018  std::sort(QT.begin(), QT.end(),
1019  [](const std::tuple<bool, double, Trk::Track*>& lhs, const std::tuple<bool, double, Trk::Track*>& rhs) {
1020  return std::get<1>(lhs) < std::get<1>(rhs); } );
1021 
1022  for (auto& q : QT) {
1023  DataVector<const Trk::MeasurementBase>::const_iterator
1024  m = std::get<2>(q)->measurementsOnTrack()->begin(),
1025  me = std::get<2>(q)->measurementsOnTrack()->end ();
1026 
1027  int nf = 0, nc = 0;
1028  for(; m!=me; ++m ) {
1029 
1030  const Trk::PrepRawData* pr = ((const Trk::RIO_OnTrack*)(*m))->prepRawData();
1031  if(pr) {
1032  ++nc;
1033  if(clusters.find(pr)==clusters.end()) {prd[nf++]=pr; if(nf==100) break;}
1034  }
1035  }
1036  if((nf >= m_nfreeCut) || (nf == nc) ) {
1037  for(int n=0; n!=nf; ++n) clusters.insert(prd[n]);
1038  }
1039  else {
1040  std::get<0>(q) = false;
1041  }
1042  }
1043 }

◆ finalize()

StatusCode TrigFastTrackFinder::finalize ( )
overridevirtual

Definition at line 1047 of file TrigFastTrackFinder.cxx.

1048 {
1049 
1050  ATH_MSG_INFO("=========================================================");
1051  ATH_MSG_INFO("TrigFastTrackFinder::finalize() - TrigFastTrackFinder Statistics: ");
1052  ATH_MSG_INFO("RoI processed: " << m_countTotalRoI);
1053  ATH_MSG_INFO("RoI with enough SPs : " << m_countRoIwithEnoughHits);
1054  ATH_MSG_INFO("RoI with Track(s) : " << m_countRoIwithTracks);
1055  ATH_MSG_INFO("=========================================================");
1056 
1057  return StatusCode::SUCCESS;
1058 }

◆ finddEdxTrk()

StatusCode TrigFastTrackFinder::finddEdxTrk ( const EventContext &  ctx,
const TrackCollection &  outputTracks 
) const
private

Definition at line 1655 of file TrigFastTrackFinder.cxx.

1656 {
1657  SG::WriteHandle<xAOD::TrigCompositeContainer> dEdxTrkHandle(m_dEdxTrkKey, ctx);
1658  ATH_CHECK( dEdxTrkHandle.record(std::make_unique<xAOD::TrigCompositeContainer>(), std::make_unique<xAOD::TrigCompositeAuxContainer>()) );
1659  auto dEdxTrkContainer = dEdxTrkHandle.ptr();
1660  dEdxTrkContainer->reserve(outputTracks.size());
1661 
1662  SG::WriteHandle<xAOD::TrigCompositeContainer> dEdxHitHandle(m_dEdxHitKey, ctx);
1663  ATH_CHECK( dEdxHitHandle.record(std::make_unique<xAOD::TrigCompositeContainer>(), std::make_unique<xAOD::TrigCompositeAuxContainer>()) );
1664  auto dEdxHitContainer = dEdxHitHandle.ptr();
1665 
1666  std::vector<float> mnt_dedx;
1667  std::vector<int> mnt_dedx_nusedhits;
1668  auto mon_dedx = Monitored::Collection("trk_dedx", mnt_dedx);
1669  auto mon_dedx_nusedhits = Monitored::Collection("trk_dedx_nusedhits", mnt_dedx_nusedhits);
1670  auto mondEdx = Monitored::Group(m_monTool, mon_dedx, mon_dedx_nusedhits);
1671 
1672  int i_track=0;
1673 
1674  ATH_MSG_VERBOSE("========== in finddEdxTrk ==========");
1675 
1676 
1677  static constexpr float TRKCUT_PTGEV_LOOSE = 3.0;
1678  static constexpr float TRKCUT_PTGEV_TIGHT = 10.0;
1679  static constexpr float TRKCUT_DEDX_LOOSE = 1.25;
1680  static constexpr float TRKCUT_DEDX_TIGHT = 1.55;
1681 
1682  for (const auto track: outputTracks) {
1683 
1684  float shift_x = 0; float shift_y = 0;
1685  if(m_useBeamSpot) {
1686  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx };
1687  FTF::getBeamSpotShift(shift_x, shift_y, **beamSpotHandle);
1688  }
1689 
1690  ATH_MSG_VERBOSE("+++++++ i_track: " << i_track << " +++++++");
1691  i_track++;
1692 
1693  trackInfo theTrackInfo;
1694  bool igt = FTF::isGoodTrackUTT(track, theTrackInfo, shift_x, shift_y, TRKCUT_PTGEV_LOOSE);
1695  if (not igt) {continue;}
1696 
1697  ATH_MSG_VERBOSE("calculate dEdx -->");
1698  int pixelhits=0; int n_usedhits=0;
1699  std::vector<float> v_pixhit_dedx; std::vector<float> v_pixhit_tot; std::vector<float> v_pixhit_trkchi2; std::vector<float> v_pixhit_trkndof;
1700  std::vector<int> v_pixhit_iblovfl; std::vector<int> v_pixhit_loc; std::vector<int> v_pixhit_layer;
1701  float dedx = dEdx(track,pixelhits,n_usedhits,v_pixhit_dedx,v_pixhit_tot,v_pixhit_trkchi2,v_pixhit_trkndof,
1702  v_pixhit_iblovfl,v_pixhit_loc,v_pixhit_layer);
1703  ATH_MSG_VERBOSE("--> dedx = " << dedx);
1704 
1705  mnt_dedx.push_back(dedx);
1706  mnt_dedx_nusedhits.push_back(n_usedhits);
1707 
1708  bool hpt = (theTrackInfo.ptGeV >= TRKCUT_PTGEV_TIGHT && dedx >= TRKCUT_DEDX_LOOSE);
1709  bool lpt = (theTrackInfo.ptGeV >= TRKCUT_PTGEV_LOOSE && dedx >= TRKCUT_DEDX_TIGHT);
1710  if( ! hpt && ! lpt ) continue;
1711 
1712  xAOD::TrigComposite *dEdxTrk = new xAOD::TrigComposite();
1713  dEdxTrkContainer->push_back(dEdxTrk);
1714  dEdxTrk->setDetail<int> ("dEdxTrk_id", i_track);
1715  dEdxTrk->setDetail<float>("dEdxTrk_pt", theTrackInfo.ptGeV*Gaudi::Units::GeV);
1716  dEdxTrk->setDetail<float>("dEdxTrk_eta", theTrackInfo.eta);
1717  dEdxTrk->setDetail<float>("dEdxTrk_phi", theTrackInfo.phi0);
1718  dEdxTrk->setDetail<float>("dEdxTrk_a0beam", theTrackInfo.a0beam);
1719  dEdxTrk->setDetail<float>("dEdxTrk_dedx", dedx);
1720  dEdxTrk->setDetail<int> ("dEdxTrk_dedx_n_usedhits", n_usedhits);
1721  dEdxTrk->setDetail<int> ("dEdxTrk_n_hits_innermost", theTrackInfo.n_hits_innermost);
1722  dEdxTrk->setDetail<int> ("dEdxTrk_n_hits_inner", theTrackInfo.n_hits_inner);
1723  dEdxTrk->setDetail<int> ("dEdxTrk_n_hits_pix", theTrackInfo.n_hits_pix);
1724  dEdxTrk->setDetail<int> ("dEdxTrk_n_hits_sct", theTrackInfo.n_hits_sct);
1725 
1726  for(unsigned int i=0; i<v_pixhit_dedx.size(); i++) {
1727  xAOD::TrigComposite *dEdxHit = new xAOD::TrigComposite();
1728  dEdxHitContainer->push_back(dEdxHit);
1729  dEdxHit->setDetail<int> ("dEdxHit_trkid", i_track);
1730  dEdxHit->setDetail<float>("dEdxHit_dedx", v_pixhit_dedx[i]);
1731  dEdxHit->setDetail<float>("dEdxHit_tot", v_pixhit_tot[i]);
1732  dEdxHit->setDetail<float>("dEdxHit_trkchi2", v_pixhit_trkchi2[i]);
1733  dEdxHit->setDetail<float>("dEdxHit_trkndof", v_pixhit_trkndof[i]);
1734  dEdxHit->setDetail<int> ("dEdxHit_iblovfl", v_pixhit_iblovfl[i]);
1735  dEdxHit->setDetail<int> ("dEdxHit_loc", v_pixhit_loc[i]);
1736  dEdxHit->setDetail<int> ("dEdxHit_layer", v_pixhit_layer[i]);
1737  }
1738  }
1739  return StatusCode::SUCCESS;
1740 }

◆ findDisTracks()

StatusCode TrigFastTrackFinder::findDisTracks ( const EventContext &  ctx,
TrackCollection &  tracks,
std::vector< std::tuple< bool, double, Trk::Track * >> &  qualityDisFailTrks,
std::vector< std::tuple< bool, double, Trk::Track * >> &  qualityDisCombTrks,
TrackCollection &  fittedDisCombTrks,
const std::vector< double > &  v_xvtx,
const std::vector< double > &  v_yvtx,
const std::vector< double > &  v_zvtx 
) const
private

Definition at line 2362 of file TrigFastTrackFinder.cxx.

2370 {
2371  SG::WriteHandle<xAOD::TrigCompositeContainer> disTrkCandHandle(m_disTrkCandKey, ctx);
2372  ATH_CHECK( disTrkCandHandle.record(std::make_unique<xAOD::TrigCompositeContainer>(), std::make_unique<xAOD::TrigCompositeAuxContainer>()) );
2373  auto disTrkCandContainer = disTrkCandHandle.ptr();
2374 
2375  // monitoring
2376  auto mnt_disFailTrk_n = Monitored::Scalar<int>("disFailTrk_n", 0);
2377  auto mnt_disFailTrk_nclone = Monitored::Scalar<int>("disFailTrk_nclone", 0);
2378  auto mnt_disFailTrk_ncand = Monitored::Scalar<int>("disFailTrk_ncand", 0);
2379  auto mnt_disCombTrk_n = Monitored::Scalar<int>("disCombTrk_n", 0);
2380  auto mnt_disCombTrk_nclone = Monitored::Scalar<int>("disCombTrk_nclone", 0);
2381  auto mnt_disCombTrk_ncand = Monitored::Scalar<int>("disCombTrk_ncand", 0);
2382  auto monDisTrk = Monitored::Group(m_monTool, mnt_disFailTrk_n, mnt_disFailTrk_nclone, mnt_disFailTrk_ncand, mnt_disCombTrk_n, mnt_disCombTrk_nclone, mnt_disCombTrk_ncand);
2383 
2384  // select tracks to be used for isolation calculation
2385  std::vector<Trk::Track*> tracksForIso;
2386  for (auto t=tracks.begin(); t!=tracks.end(); ++t) {
2387  if( isGoodForDisTrackVertex(*t) ) tracksForIso.push_back(*t);
2388  }
2389 
2390  //
2391  const std::string prefix = "disTrkCand";
2392 
2393  // disFailTrk
2394  TrackCollection initialDisFailTrks;
2395  initialDisFailTrks.reserve(qualityDisFailTrks.size());
2396  std::vector<int> resultCodes;
2397  for(const auto& q : qualityDisFailTrks) {
2398  if (std::get<0>(q)==true) {
2399  initialDisFailTrks.emplace_back(std::get<2>(q));
2400  }
2401  else {
2402  delete std::get<2>(q);
2403  }
2404  }
2405  ATH_MSG_VERBOSE("===> nr of disFailTrk=" << qualityDisFailTrks.size() << " -> clone removal=" << initialDisFailTrks.size());
2406 
2407  TrackCollection fittedDisFailTrks;
2408  m_trigInDetTrackFitter->fit(initialDisFailTrks, fittedDisFailTrks, ctx, m_particleHypothesis);
2409  int n_disFailTrkCands = recoAndFillDisTrkCand(prefix, &fittedDisFailTrks, tracksForIso, disTrkCandContainer, v_xvtx, v_yvtx, v_zvtx, true);
2410  ATH_MSG_VERBOSE("disFailTrk: nr of cands = " << n_disFailTrkCands);
2411 
2412  mnt_disFailTrk_n = qualityDisFailTrks.size();
2413  mnt_disFailTrk_nclone = initialDisFailTrks.size();
2414  mnt_disFailTrk_ncand = n_disFailTrkCands;
2415 
2416  // disCombTrk
2417  ATH_MSG_VERBOSE("===> nr of disCombTrk=" << qualityDisCombTrks.size() << " -> clone removal=" << fittedDisCombTrks.size());
2418  int n_disCombTrkCands = recoAndFillDisTrkCand(prefix, &fittedDisCombTrks, tracksForIso, disTrkCandContainer, v_xvtx, v_yvtx, v_zvtx, false);
2419  ATH_MSG_VERBOSE("disCombTrk: nr of cands = " << n_disCombTrkCands);
2420 
2421  mnt_disCombTrk_n = qualityDisCombTrks.size();
2422  mnt_disCombTrk_nclone = fittedDisCombTrks.size();
2423  mnt_disCombTrk_ncand = n_disCombTrkCands;
2424 
2425  return StatusCode::SUCCESS;
2426 }

◆ findTracks()

StatusCode TrigFastTrackFinder::findTracks ( InDet::SiTrackMakerEventData_xk &  event_data,
const TrigRoiDescriptor &  roi,
const TrackCollection *  inputTracks,
TrackCollection &  outputTracks,
const EventContext &  ctx 
) const

this uses move semantics so doesn't do a deep copy, so ...

need to disable managment of the constituents

create a new internal superRoi - should really record this

write vertex collection ... TODO: add vertices collection handling here, should not be 0 at this point unless fastZVseeding is enabled

Definition at line 449 of file TrigFastTrackFinder.cxx.

453  {
454  ATH_MSG_DEBUG( "Input RoI " << roi );
455 
456  auto mnt_roi_nTracks = Monitored::Scalar<int>("roi_nTracks", 0);
457  auto mnt_roi_nSPs = Monitored::Scalar<int>("roi_nSPs", 0);
458  auto mnt_roi_nSPsPIX = Monitored::Scalar<int>("roi_nSPsPIX", 0);
459  auto mnt_roi_nSPsSCT = Monitored::Scalar<int>("roi_nSPsSCT", 0);
460  auto monSP = Monitored::Group(m_monTool, mnt_roi_nSPsPIX, mnt_roi_nSPsSCT);
461 
462  auto mnt_timer_Total = Monitored::Timer<std::chrono::milliseconds>("TIME_Total");
463  auto mnt_timer_SpacePointConversion = Monitored::Timer<std::chrono::milliseconds>("TIME_SpacePointConversion");
464  auto mnt_timer_PatternReco = Monitored::Timer<std::chrono::milliseconds>("TIME_PattReco");
465  auto mnt_timer_TripletMaking = Monitored::Timer<std::chrono::milliseconds>("TIME_Triplets");
466  auto mnt_timer_CombTracking = Monitored::Timer<std::chrono::milliseconds>("TIME_CmbTrack");
467  auto mnt_timer_TrackFitter = Monitored::Timer<std::chrono::milliseconds>("TIME_TrackFitter");
468  auto mnt_timer_dEdxTrk = Monitored::Timer<std::chrono::milliseconds>("TIME_dEdxTrk");
469  auto mnt_timer_disTrkZVertex = Monitored::Timer<std::chrono::milliseconds>("TIME_disTrkZVertex");
470  auto mnt_timer_disTrk = Monitored::Timer<std::chrono::milliseconds>("TIME_disappearingTrack");
471  auto monTime = Monitored::Group(m_monTool, mnt_roi_nTracks, mnt_roi_nSPs, mnt_timer_Total, mnt_timer_SpacePointConversion,
472  mnt_timer_PatternReco, mnt_timer_TripletMaking, mnt_timer_CombTracking, mnt_timer_TrackFitter,
473  mnt_timer_dEdxTrk, mnt_timer_disTrkZVertex, mnt_timer_disTrk);
474 
475  auto mnt_roi_lastStageExecuted = Monitored::Scalar<int>("roi_lastStageExecuted", 0);
476  auto monDataError = Monitored::Group(m_monTool, mnt_roi_lastStageExecuted);
477 
478  mnt_timer_Total.start();
479  mnt_timer_SpacePointConversion.start();
480 
481 
482  mnt_roi_lastStageExecuted = 1;
483 
484  std::vector<TrigSiSpacePointBase> convertedSpacePoints;
485  convertedSpacePoints.reserve(5000);
486 
487  std::map<Identifier, std::vector<long int> > siClusterMap;
488 
489  if (m_LRTmode) {
490  // In LRT mode read the input track collection and enter the clusters on track into the cluster map so these are not used for seeding
491  if (!m_inputTracksKey.key().empty()) {
492  ATH_MSG_DEBUG("LRT Mode: Got input track collection with "<<inputTracks->size()<< "tracks");
493  long int trackIndex=0;
494  for (auto t:*inputTracks) {
495  updateClusterMap(trackIndex++, t, siClusterMap);
496  }
497  }
498  ATH_CHECK(m_spacePointTool->getSpacePoints(roi, convertedSpacePoints, mnt_roi_nSPsPIX, mnt_roi_nSPsSCT, ctx, &siClusterMap));
499  } else {
500  ATH_CHECK(m_spacePointTool->getSpacePoints(roi, convertedSpacePoints, mnt_roi_nSPsPIX, mnt_roi_nSPsSCT, ctx));
501  }
502 
503 
504  mnt_timer_SpacePointConversion.stop();
505  mnt_roi_nSPs = mnt_roi_nSPsPIX + mnt_roi_nSPsSCT;
506 
507  if( mnt_roi_nSPs >= m_minHits ) {
508  ATH_MSG_DEBUG("REGTEST / Found " << mnt_roi_nSPs << " space points.");
509  ATH_MSG_DEBUG("REGTEST / Found " << mnt_roi_nSPsPIX << " Pixel space points.");
510  ATH_MSG_DEBUG("REGTEST / Found " << mnt_roi_nSPsSCT << " SCT space points.");
511  ATH_MSG_DEBUG("REGTEST / converted space points size = " << convertedSpacePoints.size());
512  m_countRoIwithEnoughHits++;
513  }
514  else {
515  ATH_MSG_DEBUG("No tracks found - too few hits in ROI to run " << mnt_roi_nSPs);
516  ATH_CHECK( createEmptyUTTEDMs(ctx) );
517  return StatusCode::SUCCESS;
518  }
519 
520  mnt_roi_lastStageExecuted = 2;
521 
522 
524  std::unique_ptr<TrigRoiDescriptor> tmpRoi = std::make_unique<TrigRoiDescriptor>(roi);
526  tmpRoi->manageConstituents(false);
527  auto vertices = std::make_unique<TrigVertexCollection>();
528  std::vector<float> vZv;
529 
530  if (m_doZFinder) {
531  auto mnt_timer_ZFinder = Monitored::Timer<std::chrono::milliseconds>("TIME_ZFinder");
532  auto monTimeZFinder = Monitored::Group(m_monTool, mnt_timer_ZFinder);
533  mnt_timer_ZFinder.start();
534 
536  tmpRoi = std::make_unique<TrigRoiDescriptor>(true);
537  tmpRoi->setComposite(true);
538 
539  vertices = std::make_unique<TrigVertexCollection>(*m_trigZFinder->findZ( convertedSpacePoints, roi));
540 
541  ATH_MSG_DEBUG("vertices->size(): " << vertices->size());
542 
543 
544  if ( m_doFastZVseeding ) {
545  vZv.reserve(vertices->size());
546  for (const auto vertex : *vertices) {
547  ATH_MSG_DEBUG("REGTEST / ZFinder vertex: " << *vertex);
548  float z = vertex->z();
549  float zMinus = z - 7.0;
550  float zPlus = z + 7.0;
551  TrigRoiDescriptor* newRoi = new TrigRoiDescriptor(roi.eta(), roi.etaMinus(), roi.etaPlus(),
552  roi.phi(), roi.phiMinus(), roi.phiPlus(), z, zMinus, zPlus);
553  tmpRoi->push_back(newRoi);
554  vZv.push_back(z);
555  }
556 
557  ATH_MSG_DEBUG("REGTEST / tmpRoi: " << *tmpRoi);
558  }
559 
560  mnt_timer_ZFinder.stop();
561 
562  if ( m_doZFinderOnly ) {
567  ATH_CHECK( createEmptyUTTEDMs(ctx) );
568  return StatusCode::SUCCESS;
569  }
570  }
571 
572 
573  mnt_roi_lastStageExecuted = 3;
574 
575  mnt_timer_PatternReco.start();
576 
577  mnt_timer_TripletMaking.start();
578 
579  std::vector<TrigInDetTriplet> triplets;
580  std::vector<GNN_TrigTracklet> tracklets;
581 
582  if(!m_useGPU) {
583  if (m_ITkMode) {
584  TRIG_TRACK_SEED_GENERATOR_ITK seedGen(m_tcs);
585  seedGen.loadSpacePoints(convertedSpacePoints);
586 
587  if (m_doZFinder && m_doFastZVseeding) seedGen.createSeedsZv();
588  else {
589 
590  std::vector<GNN_TrigTracklet> vGNN_Tracks;
591 
592  seedGen.getTracklets(tmpRoi.get(), tracklets, !m_useTracklets);
593  if(!m_useTracklets) {
594  for(auto& track : tracklets) {
595  for(auto& seed : track.m_seeds) {
596  triplets.emplace_back(seed);
597  }
598  ATH_MSG_DEBUG("GNN tracklet has " << track.m_track.size()<<" spacepoints");
599  }
600  }
601  }
602  } else {
603  TRIG_TRACK_SEED_GENERATOR seedGen(m_tcs);
604 
605  seedGen.loadSpacePoints(convertedSpacePoints);
606 
607  if (m_doZFinder && m_doFastZVseeding) {
608  seedGen.createSeeds(tmpRoi.get(), vZv);
609  }
610  else {
611  seedGen.createSeeds(tmpRoi.get());
612  }
613 
614  seedGen.getSeeds(triplets);
615  }
616  }
617  else {
618  //GPU offloading begins ...
619 
620  makeSeedsOnGPU(m_tcs, tmpRoi.get(), convertedSpacePoints, triplets);
621 
622  //GPU offloading ends ...
623  }
624 
625  unsigned int nTrackSeeds = m_useTracklets ? tracklets.size() : triplets.size();
626 
627  ATH_MSG_DEBUG("number of triplets: " << nTrackSeeds);
628 
629  mnt_timer_TripletMaking.stop();
630  mnt_roi_lastStageExecuted = 4;
631 
632  mnt_timer_CombTracking.start();
633 
634  // 8. Combinatorial tracking
635 
636  std::vector<std::tuple<bool, double,Trk::Track*>> qualityTracks; //bool used for later filtering
637  qualityTracks.reserve(nTrackSeeds);
638 
639  auto mnt_roi_nSeeds = Monitored::Scalar<int>("roi_nSeeds", 0);
640  auto monTrk_seed = Monitored::Group(m_monTool, mnt_roi_nSeeds);
641 
642  long int trackIndex=0;
643 
644  bool PIX = true;
645  bool SCT = true;
646 
647  m_trackMaker->newTrigEvent(ctx, trackEventData, PIX, SCT);
648  if( m_doDisappearingTrk ) trackEventData.combinatorialData().setFlagToReturnFailedTrack(true);
649 
650  std::vector<Trk::Track*> disFailTrks;
651  std::vector<Trk::Track*> disCombTrks;
652  std::vector<std::tuple<bool, double, Trk::Track*>> qualityDisFailTrks;
653  std::vector<std::tuple<bool, double, Trk::Track*>> qualityDisCombTrks;
654  int disTrk_n_disCombTrks=0;
655  int disTrk_n_disCombTrks_cleaning=0;
656  int disTrk_n_disFailTrks=0;
657  int disTrk_n_disFailTrks_cleaning=0;
658 
659 
660 
661  for(unsigned int seedIdx=0;seedIdx!=nTrackSeeds;seedIdx++) {
662 
663  std::vector<const Trk::SpacePoint*> spVec;
664 
665  if( m_useTracklets && (!tracklets.empty())) { //create an n-SP seed
666  for(const auto& sp : tracklets[seedIdx].m_track) {
667  spVec.push_back(sp->offlineSpacePoint());
668  }
669  }
670  else {
671 
672  const TrigInDetTriplet &seed = triplets[seedIdx];
673  const Trk::SpacePoint* osp1 = seed.s1().offlineSpacePoint();
674  const Trk::SpacePoint* osp2 = seed.s2().offlineSpacePoint();
675  const Trk::SpacePoint* osp3 = seed.s3().offlineSpacePoint();
676 
677  spVec = {osp1, osp2, osp3};//create a 3-SP seed
678  }
679 
680  if(m_checkSeedRedundancy) {
681  //check if clusters do not belong to any track
682  std::vector<Identifier> clusterIds;
683  extractClusterIds(spVec.at(0), clusterIds);
684  extractClusterIds(spVec.at(1), clusterIds);
685  extractClusterIds(spVec.at(2), clusterIds);
686  if(usedByAnyTrack(clusterIds, siClusterMap)) {
687  continue;
688  }
689  }
690  ++mnt_roi_nSeeds;
691 
692  std::list<Trk::Track*> tracks;
693  std::list<Trk::Track*> tracksFail;
694  std::list<Trk::Track*> tracksAll = m_trackMaker->getTracks(ctx, trackEventData, spVec);
695  auto resultCode = trackEventData.combinatorialData().resultCode();
696  if( ! m_doDisappearingTrk || (m_doDisappearingTrk && resultCode==InDet::SiCombinatorialTrackFinderData_xk::ResultCode::Success) ) {
697  tracks = tracksAll;
698  }
699  else {
700  tracksFail = tracksAll;
701  }
702 
703  if( m_doDisappearingTrk ) {
704  ATH_MSG_VERBOSE("size of tracks=" << tracks.size() << ", tracksFail=" << tracksFail.size() << ": resultCode=" << resultCode);
705  const TrigInDetTriplet &seed = triplets[seedIdx];
706  for(std::list<Trk::Track*>::const_iterator t=tracks.begin(); t!=tracks.end(); ++t) {
707  if( ! (*t) ) continue;
708  m_trackSummaryTool->updateTrack(**t);
709  disTrk_n_disCombTrks++;
710  if( (*t)->perigeeParameters()!=0 && isCleaningPassDisTrack(seed, (*t), false) ) {
711  ATH_MSG_VERBOSE("... combTrk, cleaningPass");
712  disTrk_n_disCombTrks_cleaning++;
713  disCombTrks.push_back((*t));
714  qualityDisCombTrks.emplace_back(std::make_tuple(true, -disTrackQuality((*t)), (*t)));
715  }
716  }
717  for(std::list<Trk::Track*>::const_iterator t=tracksFail.begin(); t!=tracksFail.end(); ++t) {
718  if( ! (*t) ) continue;
719  m_trackSummaryTool->updateTrack(**t);
720  disTrk_n_disFailTrks++;
721  if( (*t)->perigeeParameters()!=0 && isCleaningPassDisTrack(seed, (*t), true) ) {
722  ATH_MSG_VERBOSE("... failTrk, cleaningPass");
723  disTrk_n_disFailTrks_cleaning++;
724  disFailTrks.push_back((*t));
725  qualityDisFailTrks.emplace_back(std::make_tuple(true, -disTrackQuality((*t)), (*t)));
726  }
727  else {
728  delete(*t); // delete failed trk but not disFailTrk candidate
729  }
730  }
731  }
732 
733  for(std::list<Trk::Track*>::const_iterator t=tracks.begin(); t!=tracks.end(); ++t) {
734  if((*t)) {
735  float d0 = (*t)->perigeeParameters()==0 ? 10000.0 : (*t)->perigeeParameters()->parameters()[Trk::d0];
736  if (std::abs(d0) > m_initialD0Max) {
737  ATH_MSG_DEBUG("REGTEST / Reject track with d0 = " << d0 << " > " << m_initialD0Max);
738  qualityTracks.push_back(std::make_tuple(false,0,(*t)));//Flag track as bad, but keep in vector for later deletion
739  continue;
740  }
741  if(m_checkSeedRedundancy) {
742  //update clusterMap
743  updateClusterMap(trackIndex++, (*t), siClusterMap);
744  }
745  if(m_doCloneRemoval) {
746  qualityTracks.push_back(std::make_tuple(true, -trackQuality((*t)), (*t)));
747  }
748  else {
749  qualityTracks.push_back(std::make_tuple(true, 0, (*t)));
750  }
751  }
752  }
753  ATH_MSG_VERBOSE("Found "<<tracks.size()<<" tracks using triplet");
754  }
755 
756  if( m_doDisappearingTrk ) {
757  ATH_MSG_DEBUG("===> nr of disFailTrks=" << disTrk_n_disFailTrks << " -> cleaning pass=" << disTrk_n_disFailTrks_cleaning);
758  ATH_MSG_DEBUG("===> nr of disCombTrks=" << disTrk_n_disCombTrks << " -> cleaning pass=" << disTrk_n_disCombTrks_cleaning);
759  }
760 
761  m_trackMaker->endEvent(trackEventData);
762 
763  //clone removal
764  if(m_doCloneRemoval) {
765  filterSharedTracks(qualityTracks);
766  }
767 
768  // filter shared hits
769  if( m_doDisappearingTrk ) {
770  filterSharedDisTracks(qualityDisFailTrks);
771  filterSharedDisTracks(qualityDisCombTrks);
772  }
773 
774  TrackCollection initialTracks;
775  initialTracks.reserve(qualityTracks.size());
776 
777  TrackCollection extraDisCombTracks;
778  // if( m_doDisappearingTrk ) extraDisCombTracks.reserve(qualityTracks.size());
779 
780  unsigned int idx=0;
781  std::vector<unsigned int> indexDisCombTrk;
782  for(const auto& q : qualityTracks) {
783  bool needed_for_disCombTrk = false;
784  if( m_doDisappearingTrk ) {
785  Trk::Track* trk_q = std::get<2>(q);
786  for(const auto& qdis : qualityDisCombTrks ) {
787  if( std::get<2>(qdis) == trk_q ) {
788  needed_for_disCombTrk = std::get<0>(qdis);
789  break;
790  }
791  }
792  if( needed_for_disCombTrk) ATH_MSG_VERBOSE("idx=" << idx << " ===> neded for disCombTrk");
793  }
794  if (std::get<0>(q)==true) {
795  initialTracks.push_back(std::get<2>(q));
796  if( m_doDisappearingTrk && needed_for_disCombTrk ) indexDisCombTrk.push_back(idx);
797  }
798  else {
799  if( ! m_doDisappearingTrk ) {
800  delete std::get<2>(q);
801  }
802  else {
803  if( needed_for_disCombTrk ) {
804  ATH_MSG_VERBOSE("... adding to extraDisCombTracks");
805  extraDisCombTracks.push_back(std::get<2>(q));
806  }
807  else {
808  delete std::get<2>(q);
809  }
810  }
811  }
812  idx++;
813  }
814  qualityTracks.clear();
815 
816  ATH_MSG_DEBUG("After clone removal "<<initialTracks.size()<<" tracks left");
817 
818 
819  mnt_timer_CombTracking.stop();
820  mnt_timer_PatternReco.stop();
821 
822  mnt_roi_lastStageExecuted = 5;
823 
824  mnt_timer_TrackFitter.start();
825 
826  if( ! m_dodEdxTrk ) {
827 
828  if(m_doTrackRefit) {
829  m_trigInDetTrackFitter->fit(initialTracks, outputTracks, ctx, m_particleHypothesis);
830  }
831  else {
832  outputTracks = std::move(initialTracks);
833  }
834  }
835  else {
836  TrackCollection outputTrackswTP;
837  m_trigInDetTrackFitter->fit(initialTracks, outputTracks, outputTrackswTP, ctx, m_particleHypothesis, true); // add TP to TSoS for dEdx
838 
839  // large dEdx finding
840  mnt_timer_dEdxTrk.start();
841  for(auto t=outputTrackswTP.begin(); t!=outputTrackswTP.end();t++) { m_trackSummaryTool->updateTrack(**t); }
842  ATH_CHECK( finddEdxTrk(ctx,outputTrackswTP) );
843  }
844 
845  if( m_dodEdxTrk ) mnt_timer_dEdxTrk.stop(); // to include timing to destroy TrackCollection object
846 
847  if( outputTracks.empty() ) {
848  ATH_MSG_DEBUG("REGTEST / No tracks fitted");
849  }
850 
851 
852  bool do_recoverDisCombTrk = true;
853  if( m_doDisappearingTrk && (initialTracks.size()!=outputTracks.size()) ) {
854  ATH_MSG_DEBUG("part of initialTracks fails in fitting. do not try to recover DisCombTracks");
855  do_recoverDisCombTrk = false;
856  }
857 
858  TrackCollection fittedExtraDisCombTracks;
859  fittedExtraDisCombTracks.reserve(extraDisCombTracks.size());
860  TrackCollection fittedDisCombTrks(SG::VIEW_ELEMENTS);
861  if( m_doDisappearingTrk ) {
862  ATH_MSG_VERBOSE("nr of extraDisCombTracks=" << extraDisCombTracks.size());
863  if( extraDisCombTracks.size() > 0 ) {
864  ATH_MSG_VERBOSE("fitting extraDisCombTracks ...");
865  m_trigInDetTrackFitter->fit(extraDisCombTracks, fittedExtraDisCombTracks, ctx, m_particleHypothesis);
866  for (auto fittedTrack = fittedExtraDisCombTracks.begin(); fittedTrack!=fittedExtraDisCombTracks.end(); ++fittedTrack) {
867  (*fittedTrack)->info().setPatternRecognitionInfo(Trk::TrackInfo::FastTrackFinderSeed);
868  m_trackSummaryTool->updateTrack(**fittedTrack);
869  fittedDisCombTrks.push_back(*fittedTrack);
870  }
871  }
872  }
873 
874  //check track parameters
875 
876  for ( auto fittedTrack = outputTracks.begin(); fittedTrack!=outputTracks.end(); ) {
877  if ((*fittedTrack)->perigeeParameters()) {
878  float d0 = (*fittedTrack)->perigeeParameters()->parameters()[Trk::d0];
879  float z0 = (*fittedTrack)->perigeeParameters()->parameters()[Trk::z0];
880  if (std::abs(d0) > m_initialD0Max || std::abs(z0) > m_Z0Max) {
881  if(m_LRTmode){
882  ATH_MSG_DEBUG("REGTEST / Reject track after fit with d0 = " << d0 << " z0= " << z0
883  << " larger than limits (" << m_initialD0Max << ", " << m_Z0Max << ")");
884  }else{
885  ATH_MSG_WARNING("REGTEST / Reject track after fit with d0 = " << d0 << " z0= " << z0
886  << " larger than limits (" << m_initialD0Max << ", " << m_Z0Max << ")");
887  }
888  ATH_MSG_DEBUG(**fittedTrack);
889  fittedTrack = outputTracks.erase(fittedTrack);
890  continue;
891  }
892 
893  if(m_LRTmode){
894  //reject tracks which have a d0 below a cut but only when an input track collection (from ftf) is also present
895  if(m_LRTD0Min>0.0){
896  if(std::abs(d0) < m_LRTD0Min && !m_inputTracksKey.key().empty()){
897  ATH_MSG_DEBUG("REGTEST / Reject track after fit for min d0 (" << d0 << " < " << m_LRTD0Min <<")");
898  fittedTrack = outputTracks.erase(fittedTrack);
899  continue;
900  }
901  }
902 
903  //calculate pt
904  float trkPt = 0.0;
905  if(m_LRTHardMinPt > 0.0){
906  //avoid a floating poitn error
907  if(std::abs((*fittedTrack)->perigeeParameters()->parameters()[Trk::qOverP]) >= 1e-9){
908  trkPt = std::sin((*fittedTrack)->perigeeParameters()->parameters()[Trk::theta])/std::abs((*fittedTrack)->perigeeParameters()->parameters()[Trk::qOverP]);
909 
910  if(trkPt < m_LRTHardMinPt){
911  ATH_MSG_DEBUG("REGTEST / Reject track after fit for min pt (" << trkPt << " < " << m_LRTHardMinPt <<")");
912  fittedTrack = outputTracks.erase(fittedTrack);
913  continue;
914  }
915  }
916  }
917  }
918  }
919  ++fittedTrack;
920  }
921 
922  mnt_timer_TrackFitter.stop();
923 
924  //make track summary
925 
926  size_t counter(1);
927  idx = 0;
928 
929  for ( auto fittedTrack = outputTracks.begin();fittedTrack!=outputTracks.end();++fittedTrack) {
930 
931  (*fittedTrack)->info().setPatternRecognitionInfo(Trk::TrackInfo::FastTrackFinderSeed);
932  ATH_MSG_VERBOSE("Updating fitted track: " << counter);
933  ATH_MSG_VERBOSE(**fittedTrack);
934  m_trackSummaryTool->updateTrack(**fittedTrack);
935  ATH_MSG_VERBOSE("Updated track: " << counter);
936  ATH_MSG_VERBOSE(**fittedTrack);
937 
938  if( m_doDisappearingTrk && do_recoverDisCombTrk ) {
939  if( std::find(indexDisCombTrk.begin(),indexDisCombTrk.end(),idx)!=indexDisCombTrk.end() ) {
940  ATH_MSG_VERBOSE("fittedTrack idx=" << idx << ": recovers also for DisCombTrack");
941  fittedDisCombTrks.push_back(*fittedTrack);
942  }
943  }
944 
945  ++counter;
946  idx++;
947  }
948 
949  if( outputTracks.empty() ) {
950  ATH_MSG_DEBUG("REGTEST / No tracks reconstructed");
951  }
952  mnt_roi_lastStageExecuted = 6;
953 
954  mnt_roi_nTracks = outputTracks.size();
955 
956  // z-vertex for UTT
957  std::vector<double> disTrk_v_xVtx;
958  std::vector<double> disTrk_v_yVtx;
959  std::vector<double> disTrk_v_zVtx;
960  if( m_doDisappearingTrk ) {
961  mnt_timer_disTrkZVertex.start();
962  recoVertexForDisTrack(ctx, outputTracks, disTrk_v_xVtx, disTrk_v_yVtx, disTrk_v_zVtx);
963  mnt_timer_disTrkZVertex.stop();
964  }
965 
966  // disappearing track reco
967  if( m_doDisappearingTrk ) {
968  mnt_timer_disTrk.start();
969  ATH_CHECK( findDisTracks(ctx,outputTracks,qualityDisFailTrks,qualityDisCombTrks,fittedDisCombTrks,disTrk_v_xVtx,disTrk_v_yVtx,disTrk_v_zVtx) );
970  mnt_timer_disTrk.stop();
971  }
972  //monitor Z-vertexing
973 
974  //monitor number of tracks
975  ATH_MSG_DEBUG("REGTEST / Found " << outputTracks.size() << " tracks");
976  if( !outputTracks.empty() )
977  m_countRoIwithTracks++;
978 
980  fillMon(outputTracks, *vertices, roi, ctx);
981 
982  mnt_roi_lastStageExecuted = 7;
983 
984  mnt_timer_Total.stop();
985 
986  return StatusCode::SUCCESS;
987 }

◆ getDisTrkCategory()

TrigFastTrackFinder::DisTrkCategory TrigFastTrackFinder::getDisTrkCategory ( Trk::Track *  trk) const
private

Definition at line 2542 of file TrigFastTrackFinder.cxx.

2543 {
2544  const auto & result = getTrkBarrelLayerInfo(trk);
2545 
2546  int n_good_brlayers_pix = 0;
2547  int n_hits_sct = 0;
2548  for(unsigned int ily=0; ily<8; ily++) {
2549  if( ily<=3 && result[ily].nGood >= 1 ) n_good_brlayers_pix++;
2550  if( 4<=ily ) {
2551  n_hits_sct += result[ily].nHits;
2552  }
2553  }
2554  if( trk->trackSummary()!=0 ) { n_hits_sct = trk->trackSummary()->get(Trk::SummaryType::numberOfSCTHits); }
2555 
2556  // category
2557  DisTrkCategory cat = DisTrkCategory::Other;
2558  if( n_good_brlayers_pix == 4 ) {
2559  if( n_hits_sct==0 ) { cat=DisTrkCategory::Pix4l_Sct0; }
2560  else { cat=DisTrkCategory::Pix4l_Sct1p; }
2561  }
2562  else if( n_good_brlayers_pix == 3 ) {
2563  if( n_hits_sct==0 ) { cat=DisTrkCategory::Pix3l_Sct0; }
2564  else { cat=DisTrkCategory::Pix3l_Sct1p; }
2565  }
2566  return cat;
2567 }

◆ getSPLayer()

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

Definition at line 1535 of file TrigFastTrackFinder.cxx.

1536 {
1537  float abseta = std::fabs(eta);
1538 
1539  // Pixel barrel or SCT barrel
1540  if( 0<=layer && layer <=7 ) {
1541  ATH_MSG_VERBOSE("layer=" << layer << ", eta=" << abseta);
1542  return layer;
1543  }
1544 
1545  int base = 0;
1546 
1547  //
1548  const float PixBR6limit = 1.29612;
1549  const float PixBR5limit = 1.45204;
1550  const float PixBR4limit = 1.64909;
1551  const float PixBR3limit = 1.90036;
1552  const float PixBR2limit = 2.2146;
1553 
1554  // Pixel Endcap #1
1555  base = 8;
1556  if( layer==base || layer==(base+12) ) {
1557  ATH_MSG_VERBOSE("Pix EC1, eta=" << abseta);
1558  if( abseta > PixBR2limit ) return 2;
1559  return 3;
1560  }
1561 
1562  // Pixel Endcap #2
1563  base = 9;
1564  if( layer==base || layer==(base+12) ) {
1565  ATH_MSG_VERBOSE("Pix EC2, eta=" << abseta);
1566  if( abseta > PixBR2limit ) return 2;
1567  return 3;
1568  }
1569 
1570  // Pixel Endcap #3
1571  base = 10;
1572  if( layer==base || layer==(base+12) ) {
1573  ATH_MSG_VERBOSE("Pix EC3, eta=" << abseta);
1574  return 3;
1575  }
1576 
1577  // SCT Endcap #1
1578  base = 11;
1579  if( layer==base || layer==(base+12) ) {
1580  ATH_MSG_VERBOSE("Sct EC1, eta=" << abseta);
1581  if( abseta < PixBR6limit ) return 7;
1582  else if( abseta < PixBR5limit ) return 6;
1583  return 5;
1584  }
1585 
1586  // SCT Endcap #2
1587  base = 12;
1588  if( layer==base || layer==(base+12) ) {
1589  ATH_MSG_VERBOSE("Sct EC2, eta=" << abseta);
1590  if( abseta < PixBR5limit ) return 7;
1591  else if( abseta < PixBR4limit ) return 6;
1592  return 4;
1593  }
1594 
1595  // SCT Endcap #3
1596  base = 13;
1597  if( layer==base || layer==(base+12) ) {
1598  ATH_MSG_VERBOSE("Sct EC3, eta=" << abseta);
1599  if( abseta < PixBR4limit ) return 7;
1600  return 5;
1601  }
1602 
1603  // SCT Endcap #4
1604  base = 14;
1605  if( layer==base || layer==(base+12) ) {
1606  ATH_MSG_VERBOSE("Sct EC4, eta=" << abseta);
1607  if( abseta < PixBR4limit ) return 6;
1608  else if( abseta < PixBR3limit ) return 6;
1609  return 4;
1610  }
1611 
1612  // SCT Endcap #5
1613  base = 15;
1614  if( layer==base || layer==(base+12) ) {
1615  ATH_MSG_VERBOSE("Sct EC5, eta=" << abseta);
1616  if( abseta < PixBR3limit ) return 7;
1617  return 5;
1618  }
1619 
1620  // SCT Endcap #6
1621  base = 16;
1622  if( layer==base || layer==(base+12) ) {
1623  ATH_MSG_VERBOSE("Sct EC6, eta=" << abseta);
1624  if( abseta < PixBR3limit ) return 6;
1625  return 4;
1626  }
1627 
1628  // SCT Endcap #7
1629  base = 17;
1630  if( layer==base || layer==(base+12) ) {
1631  ATH_MSG_VERBOSE("Sct EC7, eta=" << abseta);
1632  if( abseta < PixBR3limit ) return 7;
1633  return 5;
1634  }
1635 
1636  // SCT Endcap #8
1637  base = 18;
1638  if( layer==base || layer==(base+12) ) {
1639  ATH_MSG_VERBOSE("Sct EC8, eta=" << abseta);
1640  if( abseta < PixBR3limit ) return 7;
1641  return 6;
1642  }
1643 
1644  // SCT Endcap #9
1645  base = 19;
1646  if( layer==base || layer==(base+12) ) {
1647  ATH_MSG_VERBOSE("Sct EC9, eta=" << abseta);
1648  return 7;
1649  }
1650 
1651  return 0;
1652 }

◆ getTrkBarrelLayerInfo()

std::array< TrigFastTrackFinder::OneLayerInfo_t, TrigFastTrackFinder::N_BARREL_LAYERS > TrigFastTrackFinder::getTrkBarrelLayerInfo ( Trk::Track *  aTrack) const
private

Definition at line 2036 of file TrigFastTrackFinder.cxx.

2037 {
2038  static constexpr double CHI2_GOOD_CUT = 3.0;
2039  //nHits, chiSq, nDof, nGood in array
2040  std::array<TrigFastTrackFinder::OneLayerInfo_t, TrigFastTrackFinder::N_BARREL_LAYERS> result{};
2041  if (not t) return result;
2042 
2043  const Trk::TrackStates* recoTrackStates = t->trackStateOnSurfaces();
2044  if (recoTrackStates) {
2045  Trk::TrackStates::const_iterator tsosIter = recoTrackStates->begin();
2046  Trk::TrackStates::const_iterator tsosIterEnd = recoTrackStates->end();
2047  for ( ; tsosIter != tsosIterEnd; ++tsosIter) {
2048  const Trk::FitQualityOnSurface fq = (*tsosIter)->fitQualityOnSurface();
2049  double x2 = 0;
2050  int ndof = 0;
2051  if(fq) {
2052  x2 = fq.chiSquared();
2053  ndof = fq.numberDoF();
2054  }
2055  bool chi2_good = (x2 <= CHI2_GOOD_CUT);
2056  const Trk::MeasurementBase *measurement = (*tsosIter)->measurementOnTrack();
2057  const InDet::PixelClusterOnTrack *pixclus = dynamic_cast<const InDet::PixelClusterOnTrack*>(measurement);
2058  if (pixclus!=nullptr) {
2059  int bec = m_pixelId->barrel_ec(pixclus->identify());
2060  int layer = m_pixelId->layer_disk(pixclus->identify());
2061  if ( bec==0 ) {
2062  if( layer < 0 || 3 < layer ) {
2063  ATH_MSG_WARNING("Pixel layer out of range, layer=" << layer);
2064  continue;
2065  }
2066  result[layer].nHits++;
2067  result[layer].chiSq += x2;
2068  result[layer].nDof += ndof;
2069  if(chi2_good) result[layer].nGood++;
2070  }
2071  }
2072  const InDet::SCT_ClusterOnTrack *sctclus = dynamic_cast<const InDet::SCT_ClusterOnTrack*>(measurement);
2073  if (sctclus!=nullptr) {
2074  int bec = m_sctId->barrel_ec(sctclus->identify());
2075  int layer = m_sctId->layer_disk(sctclus->identify());
2076  if ( bec==0 ) {
2077  if( layer < 0 || 3 < layer ) {
2078  ATH_MSG_WARNING("SCT layer out of range, layer=" << layer);
2079  continue;
2080  }
2081  layer += 4;
2082  result[layer].nHits++;
2083  result[layer].chiSq += x2;
2084  result[layer].nDof += ndof;
2085  if(chi2_good) result[layer].nGood++;
2086  }
2087  }
2088  }//end loop on TSoS
2089  }
2090  return result;
2091 }

◆ initialize()

StatusCode TrigFastTrackFinder::initialize ( )
overridevirtual

Definition at line 187 of file TrigFastTrackFinder.cxx.

187  {
188 
189  ATH_CHECK(m_roiCollectionKey.initialize(!m_standaloneMode) );
190  ATH_CHECK(m_outputTracksKey.initialize() );
191 
192  // optional input tracks collection if present the clusters on previously found tracks are not used to form seeds
193  if (m_LRTmode) {
194  ATH_CHECK(m_inputTracksKey.initialize( !m_inputTracksKey.key().empty() ) );
195  }
196  // optional PRD to track association map
197  ATH_CHECK(m_prdToTrackMap.initialize( !m_prdToTrackMap.key().empty() ));
198 
199 
200  ATH_CHECK(m_beamSpotKey.initialize());
201 
202 
203 
204  ATH_MSG_DEBUG(" TrigFastTrackFinder : MinHits set to " << m_minHits);
205 
206  ATH_CHECK(m_numberingTool.retrieve());
207 
208  ATH_CHECK(m_spacePointTool.retrieve());
209 
210  ATH_CHECK(m_trackMaker.retrieve());
211 
212  ATH_CHECK(m_trigInDetTrackFitter.retrieve());
213 
214  if (m_doZFinder) {
215  ATH_CHECK(m_trigZFinder.retrieve());
216  // If m_tcs.m_zvErrorEndcap has negative default value, it was not set by user,
217  // so set it to the same value as m_tcs.m_zvError
218  if (m_tcs.m_zvErrorEndcap < 0) m_tcs.m_zvErrorEndcap = m_tcs.m_zvError;
219  } else {
220  m_trigZFinder.disable();
221  }
222 
223  ATH_CHECK(m_trackSummaryTool.retrieve());
224 
225  //Get ID helper
226  ATH_CHECK(detStore()->retrieve(m_idHelper, "AtlasID"));
227 
228  ATH_CHECK(detStore()->retrieve(m_pixelId, "PixelID"));
229 
230  ATH_CHECK(detStore()->retrieve(m_sctId, "SCT_ID"));
231 
232  // monitoring
233  if ( !m_monTool.empty() ) {
234  ATH_CHECK(m_monTool.retrieve() );
235  }
236  else {
237  ATH_MSG_INFO("Monitoring tool is empty");
238  }
239 
240  ATH_MSG_DEBUG(" doResMon " << m_doResMonitoring);
241 
242  if(m_useGPU) {//for GPU acceleration
243  ATH_CHECK(m_accelSvc.retrieve());
244  ATH_CHECK(m_accelSvc->isReady());
245  ATH_CHECK(m_accelTool.retrieve());
246  }
247 
248  ATH_MSG_INFO("Use GPU acceleration : "<<std::boolalpha<<m_useGPU);
249 
250  if (m_LRTmode) {
251  ATH_MSG_INFO(" FTF configures in Large Radius Tracking Mode");
252  // set TrigTrackSeedGenerator to LRTmode
253  m_tcs.m_LRTmode=m_LRTmode;
254 
255  }
256 
257  if(m_tcs.m_useTrigSeedML > 0) {
258  //LUT params
259  int lut_w = 30;
260  int lut_h = 45;
261  float lut_range[4] = {0.0,3.0,0.0,9.0};
262  TrigSeedML_LUT L(1,lut_w,lut_h,lut_range);
263  //read data from LUT file
264  std::string lut_fileName = PathResolver::find_file(m_trigseedML_LUT, "DATAPATH");
265  if (lut_fileName.empty()) {
266  ATH_MSG_ERROR("Cannot find TrigSeedML LUT file " << lut_fileName);
267  return StatusCode::FAILURE;
268  }
269  else {
270  ATH_MSG_INFO(lut_fileName);
271  std::ifstream ifs(lut_fileName.c_str());
272  int row, col0, col1;
273  while(!ifs.eof()) {
274  ifs >> row >> col0 >> col1;
275  if(ifs.eof()) break;
276  for(int c=col0;c<=col1;c++) L.setBin(row, c);
277  }
278  ifs.close();
279  ATH_MSG_INFO("TrigSeedML LUT initialized from file " << m_trigseedML_LUT);
280  m_tcs.m_vLUT.push_back(L);
281  }
282  }
283  if (m_ITkMode) {
284  //read data from layer connections file
285  std::string conn_fileName = PathResolver::find_file("binTables_ITK_RUN4.txt", "DATAPATH");
286  if (conn_fileName.empty()) {
287  ATH_MSG_WARNING("Cannot find layer connections file " << conn_fileName);
288  }
289  else {
290  ATH_MSG_INFO(conn_fileName);
291  std::ifstream ifs(conn_fileName.c_str());
292 
293  m_tcs.m_conn = new FASTRACK_CONNECTOR(ifs);
294  m_tcs.m_useEtaBinning = m_useEtaBinning;
295  ATH_MSG_INFO("Layer connections are initialized from file " << conn_fileName);
296  }
297  }
298 
299  // UTT tools
300  if( m_doDisappearingTrk ) {
301  ATH_CHECK(m_extrapolator.retrieve());
302  ATH_MSG_DEBUG("Retrieved tool " << m_extrapolator);
303 
304  ATH_CHECK(m_disTrkFitter.retrieve());
305  ATH_MSG_DEBUG("Retrieved tool " << m_disTrkFitter);
306  } else {
307  m_extrapolator.disable();
308  m_disTrkFitter.disable();
309  }
310 
311  // UTT read/write handles
312  ATH_CHECK( m_dEdxTrkKey.initialize(m_dodEdxTrk) );
313  ATH_CHECK( m_dEdxHitKey.initialize(m_dodEdxTrk) );
314  ATH_CHECK( m_disTrkCandKey.initialize(m_doDisappearingTrk) );
315 
316  //
317  ATH_MSG_DEBUG("FTF : " << name() );
318  ATH_MSG_DEBUG(" m_tcs.m_doubletFilterRZ : " << m_tcs.m_doubletFilterRZ );
319  ATH_MSG_DEBUG(" m_tcs.m_doublet_dR_Max : " << m_tcs.m_doublet_dR_Max );
320  ATH_MSG_DEBUG(" m_tcs.m_doublet_dR_Max_Confirm : " << m_tcs.m_doublet_dR_Max_Confirm );
321  ATH_MSG_DEBUG(" m_tcs.m_seedRadBinWidth : " << m_tcs.m_seedRadBinWidth );
322  ATH_MSG_DEBUG(" m_tcs.m_tripletD0Max : " << m_tcs.m_tripletD0Max );
323  ATH_MSG_DEBUG(" m_tcs.m_tripletD0_PPS_Max : " << m_tcs.m_tripletD0_PPS_Max );
324  ATH_MSG_DEBUG(" m_tcs.m_nMaxPhiSlice : " << m_tcs.m_nMaxPhiSlice );
325  ATH_MSG_DEBUG(" m_tcs.m_maxTripletBufferLength : " << m_tcs.m_maxTripletBufferLength );
326  ATH_MSG_DEBUG(" m_tcs.m_tripletDoPSS : " << m_tcs.m_tripletDoPSS );
327  ATH_MSG_DEBUG(" m_tcs.m_tripletDoPPS : " << m_tcs.m_tripletDoPPS );
328  ATH_MSG_DEBUG(" m_tcs.m_tripletDoConfirm : " << m_tcs.m_tripletDoConfirm );
329  ATH_MSG_DEBUG(" m_tcs.m_curv_delta : " << m_tcs.m_curv_delta );
330  ATH_MSG_DEBUG(" m_tcs.m_tripletDtCut : " << m_tcs.m_tripletDtCut );
331  ATH_MSG_DEBUG(" m_tcs.m_useTrigSeedML : " << m_tcs.m_useTrigSeedML );
332  ATH_MSG_DEBUG(" m_trigseedML_LUT : " << m_trigseedML_LUT );
333  ATH_MSG_DEBUG(" m_tcs.m_maxEC_len : " << m_tcs.m_maxEC_len );
334  ATH_MSG_DEBUG(" m_vertexSeededMode : " << m_vertexSeededMode );
335  ATH_MSG_DEBUG(" m_doZFinder : " << m_doZFinder );
336  ATH_MSG_DEBUG(" m_doZFinderOnly : " << m_doZFinderOnly );
337  ATH_MSG_DEBUG(" m_doFastZVseeding : " << m_doFastZVseeding );
338  ATH_MSG_DEBUG(" m_tcs.m_zvError : " << m_tcs.m_zvError );
339  ATH_MSG_DEBUG(" m_tcs.m_zvErrorEndcap : " << m_tcs.m_zvErrorEndcap );
340  ATH_MSG_DEBUG(" m_storeZFinderVertices : " << m_storeZFinderVertices );
341  ATH_MSG_DEBUG(" m_tripletMinPtFrac : " << m_tripletMinPtFrac );
342  ATH_MSG_DEBUG(" m_pTmin : " << m_pTmin );
343  ATH_MSG_DEBUG(" m_initialD0Max : " << m_initialD0Max );
344  ATH_MSG_DEBUG(" m_Z0Max : " << m_Z0Max );
345  ATH_MSG_DEBUG(" m_checkSeedRedundancy : " << m_checkSeedRedundancy );
346  ATH_MSG_DEBUG(" m_minHits : " << m_minHits );
347  ATH_MSG_DEBUG(" " );
348  ATH_MSG_DEBUG(" m_useBeamSpot : " << m_useBeamSpot );
349  ATH_MSG_DEBUG(" m_nfreeCut : " << m_nfreeCut );
350  ATH_MSG_DEBUG(" m_spacePointTool : " << m_spacePointTool );
351  ATH_MSG_DEBUG(" m_numberingTool : " << m_numberingTool );
352  ATH_MSG_DEBUG(" m_trackMaker : " << m_trackMaker );
353  ATH_MSG_DEBUG(" m_trigInDetTrackFitter : " << m_trigInDetTrackFitter );
354  ATH_MSG_DEBUG(" m_trigZFinder : " << m_trigZFinder );
355  ATH_MSG_DEBUG(" m_trackSummaryTool : " << m_trackSummaryTool );
356  ATH_MSG_DEBUG(" m_doResMonitoring : " << m_doResMonitoring );
357  ATH_MSG_DEBUG(" m_doCloneRemoval : " << m_doCloneRemoval );
358  ATH_MSG_DEBUG(" m_useNewLayerNumberScheme : " << m_useNewLayerNumberScheme );
359  ATH_MSG_DEBUG(" m_useGPU : " << m_useGPU );
360  ATH_MSG_DEBUG(" m_LRTmode : " << m_LRTmode );
361  ATH_MSG_DEBUG(" m_dodEdxTrk : " << m_dodEdxTrk );
362  ATH_MSG_DEBUG(" m_ITkMode : " << m_ITkMode );
363 
364  ATH_MSG_DEBUG(" Initialized successfully");
365 
366 
367  return StatusCode::SUCCESS;
368 }

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

◆ isCleaningPassDisTrack()

bool TrigFastTrackFinder::isCleaningPassDisTrack ( const TrigInDetTriplet &  seed,
Trk::Track *  trk,
bool  isFail 
) const
private

Definition at line 1955 of file TrigFastTrackFinder.cxx.

1956 {
1957  const float PT_CUT = 3.0;
1958  //
1959  const double FAIL_CHI2_OV_NDOF_CUT = 20.0;
1960  //
1961  const int COMB_N_HITS_IBL_OR_BL_CUT = 1;
1962  const int COMB_N_HITS_PIX_BR_CUT = 3;
1963  const double COMB_CHI2_OV_NDOF_PIX_BR_CUT = 3.0;
1964  const int COMB_N_GOOD_HITS_SCT_BR_CUT = 2;
1965  const int COMB_N_GOOD_DOUBLEHITS_SCT_BR_CUT = 0;
1966 
1967  // sanity check
1968  if( trk==nullptr ) return false;
1969  if( trk->perigeeParameters()==nullptr ) return false;
1970  if( trk->fitQuality()==nullptr ) return false;
1971 
1972  // if allpix/barrel
1973  if( !seed.s1().isPixel() || !seed.s2().isPixel() || !seed.s3().isPixel() ) return false;
1974  float s1_z = seed.s1().z();
1975  float s2_z = seed.s2().z();
1976  float s3_z = seed.s3().z();
1977  const float PIXEL_BARREL_Z = 410.0;
1978  if( std::abs(s1_z) > PIXEL_BARREL_Z || std::abs(s2_z) > PIXEL_BARREL_Z || std::abs(s3_z) > PIXEL_BARREL_Z ) return false;
1979  ATH_MSG_VERBOSE("FTF::isCleaningPassDisTrack> ... barrel cut passed");
1980 
1981  // pt cut
1982  double theta = trk->perigeeParameters()->parameters()[Trk::theta];
1983  double qOverP = std::abs(trk->perigeeParameters()->parameters()[Trk::qOverP]);
1984  if ( qOverP < 1e-12 ) qOverP = 1e-12;
1985  double pt = sin(theta)/qOverP;
1986  if( pt/1000.0 < PT_CUT ) return false;
1987  ATH_MSG_VERBOSE("FTF::isCleaningPassDisTrack> ... pT cut passed");
1988 
1989  // fail/comb dependent cuts
1990  if( isFail ) {
1991  double chi2 = trk->fitQuality()->chiSquared();
1992  double ndof = trk->fitQuality()->doubleNumberDoF();
1993  if( std::abs(ndof) < 1e-12 ) return false;
1994  if( chi2/ndof > FAIL_CHI2_OV_NDOF_CUT ) return false;
1995  ATH_MSG_VERBOSE("FTF::isCleaningPassDisTrack> ... (failTrk) Chi2 cut passed");
1996  }
1997  else {
1998 
1999  const auto & barrelInfo = getTrkBarrelLayerInfo(trk);
2000 
2001  int n_hits_iblbl = barrelInfo[0].nHits + barrelInfo[1].nHits;
2002  if( n_hits_iblbl < COMB_N_HITS_IBL_OR_BL_CUT ) return false;
2003 
2004  // PIX cuts
2005  int n_hits_pixbr = 0;
2006  double chi2_pixbr = 0;
2007  int ndof_pixbr = 0;
2008  for(unsigned int ily=0; ily<=3; ily++) {
2009  n_hits_pixbr += barrelInfo[ily].nHits;
2010  chi2_pixbr += barrelInfo[ily].chiSq;
2011  ndof_pixbr += barrelInfo[ily].nDof;
2012  }
2013  if( n_hits_pixbr < COMB_N_HITS_PIX_BR_CUT ) return false;
2014  if( ndof_pixbr < 1 ) return false;
2015  double chi2_ov_ndof_pixbr = chi2_pixbr / ndof_pixbr;
2016  if( chi2_ov_ndof_pixbr > COMB_CHI2_OV_NDOF_PIX_BR_CUT ) return false;
2017  ATH_MSG_VERBOSE("FTF::isCleaningPassDisTrack> ... (combTrk) Pix cut passed");
2018 
2019  // SCT cuts
2020  int n_hits_sctbr_good = 0;
2021  int n_doublehits_sctbr_good = 0;
2022  for(unsigned int ily=4; ily<=7; ily++) {
2023  n_hits_sctbr_good += barrelInfo[ily].nGood;
2024  if( barrelInfo[ily].nGood >= 2 ) n_doublehits_sctbr_good++;
2025  }
2026  if( n_hits_sctbr_good > COMB_N_GOOD_HITS_SCT_BR_CUT ) return false;
2027  if( n_doublehits_sctbr_good > COMB_N_GOOD_DOUBLEHITS_SCT_BR_CUT ) return false;
2028  ATH_MSG_VERBOSE("FTF::isCleaningPassDisTrack> ... (combTrk) SCT cut passed");
2029  }
2030 
2031  // cut passed
2032  return true;
2033 }

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

◆ isGoodForDisTrackVertex()

bool TrigFastTrackFinder::isGoodForDisTrackVertex ( Trk::Track *  t) const
private

Definition at line 2275 of file TrigFastTrackFinder.cxx.

2276 {
2277  const double TRKCUT_CHI2_OV_NDOF = 3.0;
2278  const double TRKCUT_PT = 1.0;
2279  const double TRKCUT_D0 = 2.0;
2280  const int TRKCUT_N_HITS_INNER = 1;
2281  const int TRKCUT_N_HITS_PIX = 3;
2282  const int TRKCUT_N_HITS = 7;
2283 
2284  // sanity check
2285  if ( ! t->perigeeParameters() ) return false;
2286  if ( ! t->fitQuality() ) return false;
2287  if ( t->trackSummary()==0 ) {
2288  m_trackSummaryTool->updateTrack(*t);
2289  if ( t->trackSummary()==0 ) return false;
2290  }
2291 
2292  // chi2
2293  double chi2 = t->fitQuality()->chiSquared();
2294  double ndof = t->fitQuality()->doubleNumberDoF();
2295  if( std::abs(ndof) < 1e-2 ) return false;
2296  double chi2_ov_ndof = chi2/ndof;
2297  if( chi2_ov_ndof > TRKCUT_CHI2_OV_NDOF ) return false;
2298 
2299  // pt
2300  double theta = t->perigeeParameters()->parameters()[Trk::theta];
2301  double qOverP = std::abs(t->perigeeParameters()->parameters()[Trk::qOverP]);
2302  if ( qOverP < 1e-12 ) qOverP = 1e-12;
2303  double pt = std::sin(theta)/qOverP;
2304  pt /= 1000.0;
2305  if( pt < TRKCUT_PT ) return false;
2306 
2307  // d0
2308  double d0 = t->perigeeParameters()->parameters()[Trk::d0];
2309  if( std::abs(d0) > TRKCUT_D0 ) return false;
2310 
2311  // nr hits
2312  int n_hits_innermost = t->trackSummary()->get(Trk::SummaryType::numberOfInnermostPixelLayerHits);
2313  int n_hits_next_to_innermost = t->trackSummary()->get(Trk::SummaryType::numberOfNextToInnermostPixelLayerHits);
2314  int n_hits_inner = n_hits_innermost + n_hits_next_to_innermost;
2315  int n_hits_pix = t->trackSummary()->get(Trk::SummaryType::numberOfPixelHits);
2316  int n_hits_sct = t->trackSummary()->get(Trk::SummaryType::numberOfSCTHits);
2317  if( n_hits_inner < TRKCUT_N_HITS_INNER ) return false;
2318  if( n_hits_pix < TRKCUT_N_HITS_PIX ) return false;
2319  if( (n_hits_pix+n_hits_sct) < TRKCUT_N_HITS ) return false;
2320 
2321  // ok
2322  return true;
2323 }

◆ isPreselPassDisTrackAfterRefit()

bool TrigFastTrackFinder::isPreselPassDisTrackAfterRefit ( Trk::Track *  trk,
Trk::Track *  refitTrk,
double  refit_d0_wrtVtx,
double  refit_z0_wrtVtx 
) const
private

Definition at line 2428 of file TrigFastTrackFinder.cxx.

2429 {
2430  const float PRESEL_PT_GEV = 5.0;
2431  const float PRESEL_REFIT_PT_GEV_P3S1 = 10.0;
2432  const double PRESEL_D0_WRTVTX = 5.0;
2433  const double PRESEL_Z0_WRTVTX = 50.0;
2434 
2435  // sanity check
2436  if( trk == nullptr ) return false;
2437 
2438  DisTrkCategory cat = getDisTrkCategory(trk);
2439  if( cat==DisTrkCategory::Pix4l_Sct1p || cat==DisTrkCategory::Pix3l_Sct1p ) { if( refitTrk == nullptr ) return false; }
2440 
2441  // refit d0
2442  if( std::abs(refit_d0_wrtVtx) > PRESEL_D0_WRTVTX ) return false;
2443 
2444  // refit z0
2445  if( std::abs(refit_z0_wrtVtx) > PRESEL_Z0_WRTVTX ) return false;
2446 
2447  // pt (either trk or refit trk should have pt beyond cut)
2448  std::vector<float> v_ptGeV;
2449  std::vector<Trk::Track*> v_trk;
2450  v_trk.push_back(trk);
2451  if( refitTrk != nullptr ) v_trk.push_back(refitTrk);
2452  for(auto t : v_trk) {
2453  float theta = t->perigeeParameters()->parameters()[Trk::theta];
2454  float qOverP = std::abs(t->perigeeParameters()->parameters()[Trk::qOverP]);
2455  if ( qOverP < 1e-12 ) qOverP = 1e-12;
2456  float ptGeV = sin(theta)/qOverP/Gaudi::Units::GeV;
2457  v_ptGeV.push_back(ptGeV);
2458  }
2459  bool isLowPt = true;
2460  for(auto pt : v_ptGeV) {
2461  if( pt > PRESEL_PT_GEV ) { isLowPt = false; break; }
2462  }
2463  if( isLowPt ) return false;
2464 
2465  // refit pt cut for Pix3l_Sct1p which dominates rates
2466  if( cat==DisTrkCategory::Pix3l_Sct1p ) {
2467  float refitPt = v_ptGeV[1];
2468  if( refitPt < PRESEL_REFIT_PT_GEV_P3S1 ) return false;
2469  }
2470 
2471  // cut passed
2472  return true;
2473 }

◆ isPreselPassDisTrackBeforeRefit()

bool TrigFastTrackFinder::isPreselPassDisTrackBeforeRefit ( Trk::Track *  trk,
double  d0_wrtVtx,
double  z0_wrtVtx 
) const
private

Definition at line 2475 of file TrigFastTrackFinder.cxx.

2476 {
2477  const double PRESEL_D0_WRTVTX = 5.0;
2478  const double PRESEL_Z0_WRTVTX = 50.0;
2479  const int PRESEL_N_GOOD_BR_LAYERS_PIX = 3;
2480  const double PRESEL_CHI2_OV_NDOF_PIX_BR_CUT = 5.0;
2481 
2482  // sanity check
2483  if( trk == nullptr ) return false;
2484  if( trk->perigeeParameters() == nullptr ) return false;
2485 
2486  // barrel hits
2487  const auto & barrelLayerInfo = getTrkBarrelLayerInfo(trk);
2488 
2489  // PIX cuts
2490  double chi2_pixbr = 0.0;
2491  int ndof_pixbr = 0;
2492  int n_good_brlayers_pix = 0;
2493  for(unsigned int ily=0; ily<=3; ily++) {
2494  if( barrelLayerInfo[ily].nGood >= 1 ) n_good_brlayers_pix++;
2495  chi2_pixbr += barrelLayerInfo[ily].chiSq;
2496  ndof_pixbr += barrelLayerInfo[ily].nDof;
2497  }
2498  if( n_good_brlayers_pix < PRESEL_N_GOOD_BR_LAYERS_PIX ) return false;
2499 
2500  if( ndof_pixbr < 1 ) return false;
2501  double chi2_ov_ndof_pixbr = chi2_pixbr / ndof_pixbr;
2502  if( chi2_ov_ndof_pixbr > PRESEL_CHI2_OV_NDOF_PIX_BR_CUT ) return false;
2503 
2504  // d0
2505  if( std::abs(d0_wrtVtx) > PRESEL_D0_WRTVTX ) return false;
2506 
2507  // z0
2508  if( std::abs(z0_wrtVtx) > PRESEL_Z0_WRTVTX ) return false;
2509 
2510  // cut passed
2511  return true;
2512 }

◆ makeSeedsOnGPU()

void TrigFastTrackFinder::makeSeedsOnGPU ( const TrigCombinatorialSettings &  ,
const IRoiDescriptor *  ,
const std::vector< TrigSiSpacePointBase > &  ,
std::vector< TrigInDetTriplet > &   
) const
private

Definition at line 1487 of file TrigFastTrackFinder.cxx.

1488  {
1489 
1490  output.clear();
1491 
1492  TrigAccel::DATA_EXPORT_BUFFER* dataBuffer = new TrigAccel::DATA_EXPORT_BUFFER(5000);//i.e. 5KB
1493 
1494  size_t actualSize = m_accelTool->exportSeedMakingJob(tcs, roi, vsp, *dataBuffer);
1495 
1496  ATH_MSG_DEBUG("SeedMakingJob is ready, data size for transfer = " <<actualSize);
1497 
1498  std::shared_ptr<TrigAccel::OffloadBuffer> pBuff = std::make_shared<TrigAccel::OffloadBuffer>(dataBuffer);
1499 
1500  TrigAccel::Work* pJob = m_accelSvc->createWork(TrigAccel::InDetJobControlCode::MAKE_SEEDS, pBuff);
1501 
1502  if(pJob) {
1503  ATH_MSG_DEBUG("Work item created for task "<<TrigAccel::InDetJobControlCode::MAKE_SEEDS);
1504 
1505  pJob->run();
1506 
1507  std::shared_ptr<TrigAccel::OffloadBuffer> pOB = pJob->getOutput();
1508 
1509  int nTriplets = m_accelTool->extractTripletsFromOutput(pOB,vsp, output);
1510 
1511  ATH_MSG_DEBUG("Found "<<nTriplets<<" triplets on GPU");
1512  }
1513 
1514  delete pJob;
1515  delete dataBuffer;
1516 }

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

◆ print_disTrk()

void TrigFastTrackFinder::print_disTrk ( const Trk::Track *  t) const
private

Definition at line 2844 of file TrigFastTrackFinder.cxx.

2845 {
2846  float chi2=0; float ndof=0; float d0=0; float z0=0; float phi=0; float theta=0; float pt=0;
2847  if( t!=nullptr ) {
2848  chi2 = t->fitQuality()->chiSquared();
2849  ndof = t->fitQuality()->doubleNumberDoF();
2850  d0 = t->perigeeParameters()->parameters()[Trk::d0];
2851  z0 = t->perigeeParameters()->parameters()[Trk::z0];
2852  phi = t->perigeeParameters()->parameters()[Trk::phi];
2853  theta = t->perigeeParameters()->parameters()[Trk::theta];
2854  float qOverP = std::abs(t->perigeeParameters()->parameters()[Trk::qOverP]);
2855  if ( qOverP < 1e-12 ) qOverP = 1e-12;
2856  pt = sin(theta)/qOverP;
2857  pt /= Gaudi::Units::GeV;
2858  }
2859  ATH_MSG_DEBUG("... pt / theta / phi / d0 / z0 = " << pt << " / " << theta << " / " << phi << " / " << d0 << " / " << z0);
2860  ATH_MSG_DEBUG("... chi2 / ndof = " << chi2 << " / " << ndof);
2861 }

◆ recoAndFillDisTrkCand()

int TrigFastTrackFinder::recoAndFillDisTrkCand ( const std::string &  base_prefix,
TrackCollection *  tracks,
std::vector< Trk::Track * > &  tracksForIso,
xAOD::TrigCompositeContainer *  trigCompositeContainer,
const std::vector< double > &  v_xvtx,
const std::vector< double > &  v_yvtx,
const std::vector< double > &  v_zvtx,
bool  isFail 
) const
private

Definition at line 2693 of file TrigFastTrackFinder.cxx.

2700 {
2701  std::string prefix;
2702 
2703  int n_stored_tracks = 0;
2704 
2705  for (auto trk = tracks->begin(); trk!=tracks->end(); ++trk) {
2706 
2707  Trk::Track* ptrk = *trk;
2708 
2709  if( ptrk == nullptr ) continue;
2710  if( ptrk->perigeeParameters()==nullptr ) continue;
2711 
2712  // extrapolate to vertex
2713  std::unique_ptr<const Trk::TrackParameters> vertexPerigee = extrapolateDisTrackToBS(ptrk,v_xvtx,v_yvtx,v_zvtx);
2714  double d0 = ptrk->perigeeParameters()->parameters()[Trk::d0];
2715  double z0 = ptrk->perigeeParameters()->parameters()[Trk::z0];
2716  double d0_wrtVtx = 0;
2717  double z0_wrtVtx = 0;
2718  if( vertexPerigee != nullptr ) {
2719  d0_wrtVtx = vertexPerigee->parameters()[Trk::d0];
2720  z0_wrtVtx = vertexPerigee->parameters()[Trk::z0];
2721  ATH_MSG_VERBOSE("d0 : " << d0 << " -> extrapolate -> " << d0_wrtVtx);
2722  ATH_MSG_VERBOSE("z0 : " << z0 << " -> extrapolate -> " << z0_wrtVtx);
2723  }
2724 
2725  m_trackSummaryTool->updateTrack(*ptrk);
2726 
2727  // pre-selection before refit
2728  if( ! isPreselPassDisTrackBeforeRefit(ptrk,d0_wrtVtx,z0_wrtVtx) ) continue;
2729 
2730  // refit
2731  std::unique_ptr<Trk::Track> refit_trk = disTrk_refit(ptrk);
2732  if( refit_trk != nullptr ) m_trackSummaryTool->updateTrack(*refit_trk);
2733 
2734  // extrapolate refitted track to vertex
2735  double refit_d0 = 0;
2736  double refit_z0 = 0;
2737  double refit_d0_wrtVtx = 0;
2738  double refit_z0_wrtVtx = 0;
2739  std::unique_ptr<const Trk::TrackParameters> refitVertexPerigee = nullptr;
2740  if( refit_trk != nullptr ) {
2741  refitVertexPerigee = extrapolateDisTrackToBS(refit_trk.get(),v_xvtx,v_yvtx,v_zvtx);
2742  if( refitVertexPerigee == nullptr ) {
2743  ATH_MSG_VERBOSE("extrapote to BS fails for refit track");
2744  }
2745  else {
2746  refit_d0 = refit_trk.get()->perigeeParameters()->parameters()[Trk::d0];
2747  refit_z0 = refit_trk.get()->perigeeParameters()->parameters()[Trk::z0];
2748  refit_d0_wrtVtx = refitVertexPerigee->parameters()[Trk::d0];
2749  refit_z0_wrtVtx = refitVertexPerigee->parameters()[Trk::z0];
2750  ATH_MSG_VERBOSE("refit trk d0 : " << refit_d0 << " -> extrapolate -> " << refit_d0_wrtVtx);
2751  ATH_MSG_VERBOSE("refit trk z0 : " << refit_z0 << " -> extrapolate -> " << refit_z0_wrtVtx);
2752  }
2753  }
2754 
2755  // pre-selection after refit
2756  if( ! isPreselPassDisTrackAfterRefit(ptrk,refit_trk.get(),refit_d0_wrtVtx,refit_z0_wrtVtx) ) continue;
2757 
2758  // store it!
2759  n_stored_tracks++;
2760 
2761  xAOD::TrigComposite *comp = new xAOD::TrigComposite();
2762  comp->makePrivateStore();
2763  trigCompositeContainer->push_back(comp);
2764 
2765  //
2766  int is_fail = isFail ? 1 : 0;
2767  comp->setDetail<int16_t>(base_prefix+"_is_fail",(int16_t)is_fail);
2768 
2769  // store trk info
2770  prefix = base_prefix;
2771  fillDisTrkCand(comp,prefix,ptrk,vertexPerigee,true,tracksForIso);
2772 
2773  // store refit trk info
2774  prefix = base_prefix + "_refit";
2775  if( refit_trk != nullptr ) {
2776  fillDisTrkCand(comp,prefix,refit_trk.get(),refitVertexPerigee);
2777  }
2778  else {
2779  fillDisTrkCand(comp,prefix,nullptr,refitVertexPerigee);
2780  }
2781  }
2782 
2783  //
2784  ATH_MSG_VERBOSE("========> filling trigcomposite for " << prefix << " end");
2785  ATH_MSG_VERBOSE("nr of " << prefix << " tracks / stored = " << tracks->size() << " / " << n_stored_tracks);
2786 
2787  //
2788  return n_stored_tracks;
2789 }

◆ recoVertexForDisTrack()

void TrigFastTrackFinder::recoVertexForDisTrack ( const EventContext &  ctx,
TrackCollection &  tracks,
std::vector< double > &  v_xvtx,
std::vector< double > &  v_yvtx,
std::vector< double > &  v_zvtx 
) const
private

Definition at line 2130 of file TrigFastTrackFinder.cxx.

2131 {
2132  v_xvtx.clear();
2133  v_yvtx.clear();
2134  v_zvtx.clear();
2135 
2136  // beamspot and tilt
2137  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx };
2138  Amg::Vector3D vertex = beamSpotHandle->beamPos();
2139  double xVTX = vertex.x();
2140  double yVTX = vertex.y();
2141  double tiltXZ = beamSpotHandle->beamTilt(0);
2142  double tiltYZ = beamSpotHandle->beamTilt(1);
2143 
2144  // zvertex
2145  const double CLUSTCUT_DIST_SIGMA = 5.0;
2146  const double CLUSTCUT_DIST = 2.5;
2147  const double CLUSTCUT_SEED_PT = 3.0;
2148 
2149  const int VTXCUT_N_TRACKS = 3;
2150  const int VTXCUT_ALGO = 1; // 0: highest pT track, 1: sumPt
2151 
2152  std::vector<std::tuple<int,double,double,Trk::Track*>> QT;
2153  QT.reserve(tracks.size());
2154 
2155  for (auto t=tracks.begin(); t!=tracks.end(); ++t) {
2156  if( ! isGoodForDisTrackVertex(*t) ) continue;
2157  // consider for vertex fitting (idx, sort, weight, Trk)
2158  double theta = (*t)->perigeeParameters()->parameters()[Trk::theta];
2159  double qOverP = std::abs((*t)->perigeeParameters()->parameters()[Trk::qOverP]);
2160  if ( qOverP < 1e-12 ) qOverP = 1e-12;
2161  double pt = sin(theta)/qOverP;
2162  pt /= 1000.0;
2163  QT.emplace_back(std::make_tuple(-1,pt,pt,(*t)));
2164  }
2165 
2166  // sort
2167  std::sort(QT.begin(), QT.end(),
2168  [](const std::tuple<int,double,double,Trk::Track*>& lhs, const std::tuple<int,double,double,Trk::Track*>& rhs) {
2169  return std::get<1>(lhs) > std::get<1>(rhs); } );
2170 
2171  // clustering
2172  std::vector<int> cluster_ntrk;
2173  std::vector<double> cluster_ptsum;
2174  std::vector<double> cluster_z;
2175  std::vector<double> cluster_wsum;
2176  std::vector<double> cluster_zerr;
2177  std::vector<double> cluster_w2sum;
2178 
2179  for(unsigned int i=0; i<QT.size(); ++i) {
2180  Trk::Track* t = std::get<3>(QT[i]);
2181  double z = t->perigeeParameters()->parameters()[Trk::z0];
2182  double zerr = sqrt((*(t->perigeeParameters()->covariance()))(Trk::z0,Trk::z0));
2183  double w = std::get<2>(QT[i]);
2184  double pt = std::get<1>(QT[i]);
2185  if(i==0) {
2186  cluster_ntrk.push_back(1); cluster_ptsum.push_back(pt);
2187  cluster_z.push_back(w*z); cluster_wsum.push_back(w);
2188  cluster_zerr.push_back(w*zerr*w*zerr); cluster_w2sum.push_back(w*w);
2189  continue;
2190  }
2191  //
2192  const int IDX_INITIAL = 100;
2193  double dist_min = 100.0;
2194  int idx_min = IDX_INITIAL;
2195  for(unsigned j=0; j<cluster_z.size(); ++j) {
2196  double dist = std::abs(z - cluster_z[j]/cluster_wsum[j]);
2197  if( dist < dist_min ) {
2198  dist_min = dist;
2199  idx_min = j;
2200  }
2201  }
2202  int match_idx = IDX_INITIAL;
2203  if( idx_min != IDX_INITIAL ) {
2204  double c_zerr_min = std::sqrt(cluster_zerr[idx_min]/cluster_w2sum[idx_min]);
2205  double err = std::sqrt(zerr*zerr+c_zerr_min*c_zerr_min);
2206  if( std::abs(err) < 1e-12 ) err = 1e-12;
2207  double dist = dist_min / err;
2208  if( dist < CLUSTCUT_DIST_SIGMA && dist_min < CLUSTCUT_DIST ) { match_idx = idx_min; }
2209  }
2210  //
2211  if( match_idx == IDX_INITIAL ) {
2212  if( pt > CLUSTCUT_SEED_PT && dist_min > CLUSTCUT_DIST ) {
2213  cluster_ntrk.push_back(1); cluster_ptsum.push_back(pt);
2214  cluster_z.push_back(w*z); cluster_wsum.push_back(w);
2215  cluster_zerr.push_back(w*zerr*w*zerr); cluster_w2sum.push_back(w*w);
2216  }
2217  continue;
2218  }
2219  int new_n = cluster_ntrk[match_idx] + 1;
2220  double new_ptsum = cluster_ptsum[match_idx] + pt;
2221  double new_z = cluster_z[match_idx] + w*z;
2222  double new_wsum = cluster_wsum[match_idx] + w;
2223  double new_zerr = cluster_zerr[match_idx] + w*zerr*w*zerr;
2224  double new_w2sum = cluster_w2sum[match_idx] + w*w;
2225  cluster_ntrk[match_idx] = new_n;
2226  cluster_ptsum[match_idx] = new_ptsum;
2227  cluster_z[match_idx] = new_z;
2228  cluster_wsum[match_idx] = new_wsum;
2229  cluster_zerr[match_idx] = new_zerr;
2230  cluster_w2sum[match_idx] = new_w2sum;
2231  }
2232  QT.clear();
2233 
2234  // determine zvtx (pt sort)
2235  std::vector<std::tuple<double,double,double,int>> zVtx;
2236  zVtx.reserve(tracks.size());
2237  for(unsigned int i=0; i<cluster_z.size(); i++) {
2238  if( cluster_ntrk[i] < VTXCUT_N_TRACKS ) continue;
2239  double z = cluster_z[i] / cluster_wsum[i];
2240  double zerr = std::sqrt(cluster_zerr[i] / cluster_w2sum[i]);
2241  zVtx.push_back(std::make_tuple(cluster_ptsum[i],z,zerr,cluster_ntrk[i]));
2242  }
2243  // ptsum sort
2244  if( VTXCUT_ALGO == 1 ) {
2245  std::sort(zVtx.begin(), zVtx.end(),
2246  [](const std::tuple<double,double,double,int>& lhs, const std::tuple<double,double,double,int>& rhs) {
2247  return std::get<0>(lhs) > std::get<0>(rhs); } );
2248  }
2249  ATH_MSG_VERBOSE("disTrkZVtertex> ===== looping zVtx size: " << zVtx.size());
2250  for(unsigned int i=0; i<zVtx.size(); i++) {
2251  double z = std::get<1>(zVtx[i]);
2252  double zerr = std::get<2>(zVtx[i]);
2253  double pt = std::get<0>(zVtx[i]);
2254  int n = std::get<3>(zVtx[i]);
2255  v_zvtx.push_back(z);
2256  v_xvtx.push_back(xVTX - tiltXZ*z); //correction for tilt
2257  v_yvtx.push_back(yVTX - tiltYZ*z); //correction for tilt
2258  ATH_MSG_VERBOSE("disTrkZVtertex> Vertex cand i=" << i << ": z = " << z << " +- " << zerr << ", sum n / pt = " << n << " / " << pt);
2259  }
2260 
2261  // monitoring
2262  auto mnt_disTrk_nVtx = Monitored::Scalar<int> ("disTrk_nVtx", 0);
2263  auto mnt_disTrk_xVtx = Monitored::Scalar<float>("disTrk_xVtx", 0);
2264  auto mnt_disTrk_yVtx = Monitored::Scalar<float>("disTrk_yVtx", 0);
2265  auto mnt_disTrk_zVtx = Monitored::Scalar<float>("disTrk_zVtx", 0);
2266  auto monDisTrk = Monitored::Group(m_monTool, mnt_disTrk_nVtx, mnt_disTrk_xVtx, mnt_disTrk_yVtx, mnt_disTrk_zVtx);
2267  mnt_disTrk_nVtx = v_zvtx.size();
2268  if(v_zvtx.size()>0) {
2269  mnt_disTrk_xVtx = v_xvtx[0];
2270  mnt_disTrk_yVtx = v_yvtx[0];
2271  mnt_disTrk_zVtx = v_zvtx[0];
2272  }
2273 }

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

◆ runResidualMonitoring()

void TrigFastTrackFinder::runResidualMonitoring ( const Trk::Track &  track,
const EventContext &  ctx 
) const
private

Definition at line 1268 of file TrigFastTrackFinder.cxx.

1268  {
1269 
1270  std::vector<float> mnt_layer_IBL;
1271  std::vector<float> mnt_layer_PixB;
1272  std::vector<float> mnt_layer_PixE;
1273  std::vector<float> mnt_layer_SCTB;
1274  std::vector<float> mnt_layer_SCTE;
1275  std::vector<float> mnt_hit_IBLPhiResidual;
1276  std::vector<float> mnt_hit_IBLEtaResidual;
1277  std::vector<float> mnt_hit_IBLPhiPull;
1278  std::vector<float> mnt_hit_IBLEtaPull;
1279  std::vector<float> mnt_hit_PIXBarrelPhiResidual;
1280  std::vector<float> mnt_hit_PIXBarrelEtaResidual;
1281  std::vector<float> mnt_hit_PIXBarrelPhiPull;
1282  std::vector<float> mnt_hit_PIXBarrelEtaPull;
1283  std::vector<float> mnt_hit_SCTBarrelResidual;
1284  std::vector<float> mnt_hit_SCTBarrelPull;
1285  std::vector<float> mnt_hit_PIXEndcapPhiResidual;
1286  std::vector<float> mnt_hit_PIXEndcapEtaResidual;
1287  std::vector<float> mnt_hit_PIXEndcapPhiPull;
1288  std::vector<float> mnt_hit_PIXEndcapEtaPull;
1289  std::vector<float> mnt_hit_SCTEndcapResidual;
1290  std::vector<float> mnt_hit_SCTEndcapPull;
1291  std::vector<float> mnt_hit_PIXBarrelL1PhiResidual;
1292  std::vector<float> mnt_hit_PIXBarrelL1EtaResidual;
1293  std::vector<float> mnt_hit_PIXBarrelL2PhiResidual;
1294  std::vector<float> mnt_hit_PIXBarrelL2EtaResidual;
1295  std::vector<float> mnt_hit_PIXBarrelL3PhiResidual;
1296  std::vector<float> mnt_hit_PIXBarrelL3EtaResidual;
1297  std::vector<float> mnt_hit_PIXEndcapL1PhiResidual;
1298  std::vector<float> mnt_hit_PIXEndcapL1EtaResidual;
1299  std::vector<float> mnt_hit_PIXEndcapL2PhiResidual;
1300  std::vector<float> mnt_hit_PIXEndcapL2EtaResidual;
1301  std::vector<float> mnt_hit_PIXEndcapL3PhiResidual;
1302  std::vector<float> mnt_hit_PIXEndcapL3EtaResidual;
1303  std::vector<float> mnt_hit_SCTBarrelL1PhiResidual;
1304  std::vector<float> mnt_hit_SCTBarrelL2PhiResidual;
1305  std::vector<float> mnt_hit_SCTBarrelL3PhiResidual;
1306  std::vector<float> mnt_hit_SCTBarrelL4PhiResidual;
1307  std::vector<float> mnt_hit_SCTEndcapL1PhiResidual;
1308  std::vector<float> mnt_hit_SCTEndcapL2PhiResidual;
1309  std::vector<float> mnt_hit_SCTEndcapL3PhiResidual;
1310  std::vector<float> mnt_hit_SCTEndcapL4PhiResidual;
1311  std::vector<float> mnt_hit_SCTEndcapL5PhiResidual;
1312  std::vector<float> mnt_hit_SCTEndcapL6PhiResidual;
1313  std::vector<float> mnt_hit_SCTEndcapL7PhiResidual;
1314  std::vector<float> mnt_hit_SCTEndcapL8PhiResidual;
1315  std::vector<float> mnt_hit_SCTEndcapL9PhiResidual;
1316  auto mon_layer_IBL = Monitored::Collection("layer_IBL", mnt_layer_IBL);
1317  auto mon_layer_PixB = Monitored::Collection("layer_PixB",mnt_layer_PixB);
1318  auto mon_layer_PixE = Monitored::Collection("layer_PixE",mnt_layer_PixE);
1319  auto mon_layer_SCTB = Monitored::Collection("layer_SCTB",mnt_layer_SCTB);
1320  auto mon_layer_SCTE = Monitored::Collection("layer_SCTE",mnt_layer_SCTE);
1321  auto mon_hit_IBLPhiResidual = Monitored::Collection("hit_IBLPhiResidual",mnt_hit_IBLPhiResidual);
1322  auto mon_hit_IBLEtaResidual = Monitored::Collection("hit_IBLEtaResidual",mnt_hit_IBLEtaResidual);
1323  auto mon_hit_IBLPhiPull = Monitored::Collection("hit_IBLPhiPull",mnt_hit_IBLPhiPull);
1324  auto mon_hit_IBLEtaPull = Monitored::Collection("hit_IBLEtaPull",mnt_hit_IBLEtaPull);
1325  auto mon_hit_PIXBarrelPhiResidual = Monitored::Collection("hit_PIXBarrelPhiResidual",mnt_hit_PIXBarrelPhiResidual);
1326  auto mon_hit_PIXBarrelEtaResidual = Monitored::Collection("hit_PIXBarrelEtaResidual",mnt_hit_PIXBarrelEtaResidual);
1327  auto mon_hit_PIXBarrelPhiPull = Monitored::Collection("hit_PIXBarrelPhiPull",mnt_hit_PIXBarrelPhiPull);
1328  auto mon_hit_PIXBarrelEtaPull = Monitored::Collection("hit_PIXBarrelEtaPull",mnt_hit_PIXBarrelEtaPull);
1329  auto mon_hit_SCTBarrelResidual = Monitored::Collection("hit_SCTBarrelResidual",mnt_hit_SCTBarrelResidual);
1330  auto mon_hit_SCTBarrelPull = Monitored::Collection("hit_SCTBarrelPull",mnt_hit_SCTBarrelPull);
1331  auto mon_hit_PIXEndcapPhiResidual = Monitored::Collection("hit_PIXEndcapPhiResidual",mnt_hit_PIXEndcapPhiResidual);
1332  auto mon_hit_PIXEndcapEtaResidual = Monitored::Collection("hit_PIXEndcapEtaResidual",mnt_hit_PIXEndcapEtaResidual);
1333  auto mon_hit_PIXEndcapPhiPull = Monitored::Collection("hit_PIXEndcapPhiPull",mnt_hit_PIXEndcapPhiPull);
1334  auto mon_hit_PIXEndcapEtaPull = Monitored::Collection("hit_PIXEndcapEtaPull",mnt_hit_PIXEndcapEtaPull);
1335  auto mon_hit_SCTEndcapResidual = Monitored::Collection("hit_SCTEndcapResidual",mnt_hit_SCTEndcapResidual);
1336  auto mon_hit_SCTEndcapPull = Monitored::Collection("hit_SCTEndcapPull",mnt_hit_SCTEndcapPull);
1337  auto mon_hit_PIXBarrelL1PhiResidual = Monitored::Collection("hit_PIXBarrelL1PhiResidual",mnt_hit_PIXBarrelL1PhiResidual);
1338  auto mon_hit_PIXBarrelL1EtaResidual = Monitored::Collection("hit_PIXBarrelL1EtaResidual",mnt_hit_PIXBarrelL1EtaResidual);
1339  auto mon_hit_PIXBarrelL2PhiResidual = Monitored::Collection("hit_PIXBarrelL2PhiResidual",mnt_hit_PIXBarrelL2PhiResidual);
1340  auto mon_hit_PIXBarrelL2EtaResidual = Monitored::Collection("hit_PIXBarrelL2EtaResidual",mnt_hit_PIXBarrelL2EtaResidual);
1341  auto mon_hit_PIXBarrelL3PhiResidual = Monitored::Collection("hit_PIXBarrelL3PhiResidual",mnt_hit_PIXBarrelL3PhiResidual);
1342  auto mon_hit_PIXBarrelL3EtaResidual = Monitored::Collection("hit_PIXBarrelL3EtaResidual",mnt_hit_PIXBarrelL3EtaResidual);
1343  auto mon_hit_PIXEndcapL1PhiResidual = Monitored::Collection("hit_PIXEndcapL1PhiResidual",mnt_hit_PIXEndcapL1PhiResidual);
1344  auto mon_hit_PIXEndcapL1EtaResidual = Monitored::Collection("hit_PIXEndcapL1EtaResidual",mnt_hit_PIXEndcapL1EtaResidual);
1345  auto mon_hit_PIXEndcapL2PhiResidual = Monitored::Collection("hit_PIXEndcapL2PhiResidual",mnt_hit_PIXEndcapL2PhiResidual);
1346  auto mon_hit_PIXEndcapL2EtaResidual = Monitored::Collection("hit_PIXEndcapL2EtaResidual",mnt_hit_PIXEndcapL2EtaResidual);
1347  auto mon_hit_PIXEndcapL3PhiResidual = Monitored::Collection("hit_PIXEndcapL3PhiResidual",mnt_hit_PIXEndcapL3PhiResidual);
1348  auto mon_hit_PIXEndcapL3EtaResidual = Monitored::Collection("hit_PIXEndcapL3EtaResidual",mnt_hit_PIXEndcapL3EtaResidual);
1349  auto mon_hit_SCTBarrelL1PhiResidual = Monitored::Collection("hit_SCTBarrelL1PhiResidual",mnt_hit_SCTBarrelL1PhiResidual);
1350  auto mon_hit_SCTBarrelL2PhiResidual = Monitored::Collection("hit_SCTBarrelL2PhiResidual",mnt_hit_SCTBarrelL2PhiResidual);
1351  auto mon_hit_SCTBarrelL3PhiResidual = Monitored::Collection("hit_SCTBarrelL3PhiResidual",mnt_hit_SCTBarrelL3PhiResidual);
1352  auto mon_hit_SCTBarrelL4PhiResidual = Monitored::Collection("hit_SCTBarrelL4PhiResidual",mnt_hit_SCTBarrelL4PhiResidual);
1353  auto mon_hit_SCTEndcapL1PhiResidual = Monitored::Collection("hit_SCTEndcapL1PhiResidual",mnt_hit_SCTEndcapL1PhiResidual);
1354  auto mon_hit_SCTEndcapL2PhiResidual = Monitored::Collection("hit_SCTEndcapL2PhiResidual",mnt_hit_SCTEndcapL2PhiResidual);
1355  auto mon_hit_SCTEndcapL3PhiResidual = Monitored::Collection("hit_SCTEndcapL3PhiResidual",mnt_hit_SCTEndcapL3PhiResidual);
1356  auto mon_hit_SCTEndcapL4PhiResidual = Monitored::Collection("hit_SCTEndcapL4PhiResidual",mnt_hit_SCTEndcapL4PhiResidual);
1357  auto mon_hit_SCTEndcapL5PhiResidual = Monitored::Collection("hit_SCTEndcapL5PhiResidual",mnt_hit_SCTEndcapL5PhiResidual);
1358  auto mon_hit_SCTEndcapL6PhiResidual = Monitored::Collection("hit_SCTEndcapL6PhiResidual",mnt_hit_SCTEndcapL6PhiResidual);
1359  auto mon_hit_SCTEndcapL7PhiResidual = Monitored::Collection("hit_SCTEndcapL7PhiResidual",mnt_hit_SCTEndcapL7PhiResidual);
1360  auto mon_hit_SCTEndcapL8PhiResidual = Monitored::Collection("hit_SCTEndcapL8PhiResidual",mnt_hit_SCTEndcapL8PhiResidual);
1361  auto mon_hit_SCTEndcapL9PhiResidual = Monitored::Collection("hit_SCTEndcapL9PhiResidual",mnt_hit_SCTEndcapL9PhiResidual);
1362 
1363  auto monRes = Monitored::Group(m_monTool, mon_layer_IBL, mon_layer_PixB, mon_layer_PixE, mon_layer_SCTB, mon_layer_SCTE, mon_hit_IBLPhiResidual, mon_hit_IBLEtaResidual, mon_hit_IBLPhiPull, mon_hit_IBLEtaPull, mon_hit_PIXBarrelPhiResidual, mon_hit_PIXBarrelEtaResidual, mon_hit_PIXBarrelPhiPull, mon_hit_PIXBarrelEtaPull, mon_hit_SCTBarrelResidual, mon_hit_SCTBarrelPull, mon_hit_PIXEndcapPhiResidual, mon_hit_PIXEndcapEtaResidual, mon_hit_PIXEndcapPhiPull, mon_hit_PIXEndcapEtaPull, mon_hit_SCTEndcapResidual, mon_hit_SCTEndcapPull, mon_hit_PIXBarrelL1PhiResidual, mon_hit_PIXBarrelL1EtaResidual, mon_hit_PIXBarrelL2PhiResidual, mon_hit_PIXBarrelL2EtaResidual, mon_hit_PIXBarrelL3PhiResidual, mon_hit_PIXBarrelL3EtaResidual, mon_hit_PIXEndcapL1PhiResidual, mon_hit_PIXEndcapL1EtaResidual, mon_hit_PIXEndcapL2PhiResidual, mon_hit_PIXEndcapL2EtaResidual, mon_hit_PIXEndcapL3PhiResidual, mon_hit_PIXEndcapL3EtaResidual, mon_hit_SCTBarrelL1PhiResidual, mon_hit_SCTBarrelL2PhiResidual, mon_hit_SCTBarrelL3PhiResidual, mon_hit_SCTBarrelL4PhiResidual, mon_hit_SCTEndcapL1PhiResidual, mon_hit_SCTEndcapL2PhiResidual, mon_hit_SCTEndcapL3PhiResidual, mon_hit_SCTEndcapL4PhiResidual, mon_hit_SCTEndcapL5PhiResidual, mon_hit_SCTEndcapL6PhiResidual, mon_hit_SCTEndcapL7PhiResidual, mon_hit_SCTEndcapL8PhiResidual, mon_hit_SCTEndcapL9PhiResidual);
1364 
1365  std::vector<TrigL2HitResidual> vResid;
1366  vResid.clear();
1367  StatusCode scRes = m_trigInDetTrackFitter->getUnbiasedResiduals(track,vResid, ctx);
1368  if(!scRes.isSuccess()) return;
1369  for(std::vector<TrigL2HitResidual>::iterator it=vResid.begin();it!=vResid.end();++it) {
1370  Identifier id = it->identify();
1371  int pixlayer= (m_pixelId->layer_disk(id) );
1372  int sctlayer= (m_sctId->layer_disk(id) );
1373 
1374  switch(it->regionId()) {
1375  case Region::PixBarrel :
1376  mnt_layer_PixB.push_back(pixlayer);
1377  mnt_hit_PIXBarrelPhiResidual.push_back(it->phiResidual());
1378  mnt_hit_PIXBarrelPhiPull.push_back(it->phiPull());
1379  mnt_hit_PIXBarrelEtaResidual.push_back(it->etaResidual());
1380  mnt_hit_PIXBarrelEtaPull.push_back(it->etaPull());
1381  if (pixlayer == 1) {
1382  mnt_hit_PIXBarrelL1PhiResidual.push_back(it->phiResidual());
1383  mnt_hit_PIXBarrelL1EtaResidual.push_back(it->etaResidual());
1384  }
1385  if (pixlayer == 2) {
1386  mnt_hit_PIXBarrelL2PhiResidual.push_back(it->phiResidual());
1387  mnt_hit_PIXBarrelL2EtaResidual.push_back(it->etaResidual());
1388  }
1389  if (pixlayer == 3) {
1390  mnt_hit_PIXBarrelL3PhiResidual.push_back(it->phiResidual());
1391  mnt_hit_PIXBarrelL3EtaResidual.push_back(it->etaResidual());
1392  }
1393  break;
1394  case Region::PixEndcap :
1395  ATH_MSG_DEBUG("Pixel Endcap " );
1396  mnt_layer_PixE.push_back(pixlayer);
1397  mnt_hit_PIXEndcapPhiResidual.push_back(it->phiResidual());
1398  mnt_hit_PIXEndcapPhiPull.push_back(it->phiPull());
1399  mnt_hit_PIXEndcapEtaResidual.push_back(it->etaResidual());
1400  mnt_hit_PIXEndcapEtaPull.push_back(it->etaPull());
1401  if (pixlayer == 0) {
1402  mnt_hit_PIXEndcapL1PhiResidual.push_back(it->phiResidual());
1403  mnt_hit_PIXEndcapL1EtaResidual.push_back(it->etaResidual());
1404  }
1405  if (pixlayer == 1) {
1406  mnt_hit_PIXEndcapL2PhiResidual.push_back(it->phiResidual());
1407  mnt_hit_PIXEndcapL2EtaResidual.push_back(it->etaResidual());
1408  }
1409  if (pixlayer == 2) {
1410  mnt_hit_PIXEndcapL3PhiResidual.push_back(it->phiResidual());
1411  mnt_hit_PIXEndcapL3EtaResidual.push_back(it->etaResidual());
1412  }
1413  break;
1414  case Region::SctBarrel :
1415  mnt_layer_SCTB.push_back(sctlayer);
1416  mnt_hit_SCTBarrelResidual.push_back(it->phiResidual());
1417  mnt_hit_SCTBarrelPull.push_back(it->phiPull());
1418  if (sctlayer == 0) {
1419  mnt_hit_SCTBarrelL1PhiResidual.push_back(it->phiResidual());
1420  }
1421  if (sctlayer == 1) {
1422  mnt_hit_SCTBarrelL2PhiResidual.push_back(it->phiResidual());
1423  }
1424  if (sctlayer == 2) {
1425  mnt_hit_SCTBarrelL3PhiResidual.push_back(it->phiResidual());
1426  }
1427  if (sctlayer == 3) {
1428  mnt_hit_SCTBarrelL4PhiResidual.push_back(it->phiResidual());
1429  }
1430  break;
1431  case Region::SctEndcap :
1432  ATH_MSG_DEBUG("SCT Endcap" );
1433  mnt_layer_SCTE.push_back(sctlayer);
1434  mnt_hit_SCTEndcapResidual.push_back(it->phiResidual());
1435  mnt_hit_SCTEndcapPull.push_back(it->phiPull());
1436  if (sctlayer == 0) {
1437  mnt_hit_SCTEndcapL1PhiResidual.push_back(it->phiResidual());
1438  }
1439  if (sctlayer == 1) {
1440  mnt_hit_SCTEndcapL2PhiResidual.push_back(it->phiResidual());
1441  }
1442  if (sctlayer == 2) {
1443  mnt_hit_SCTEndcapL3PhiResidual.push_back(it->phiResidual());
1444  }
1445  if (sctlayer == 3) {
1446  mnt_hit_SCTEndcapL4PhiResidual.push_back(it->phiResidual());
1447  }
1448  if (sctlayer == 4) {
1449  mnt_hit_SCTEndcapL5PhiResidual.push_back(it->phiResidual());
1450  }
1451  if (sctlayer == 5) {
1452  mnt_hit_SCTEndcapL6PhiResidual.push_back(it->phiResidual());
1453  }
1454  if (sctlayer == 6) {
1455  mnt_hit_SCTEndcapL7PhiResidual.push_back(it->phiResidual());
1456  }
1457  if (sctlayer == 7) {
1458  mnt_hit_SCTEndcapL8PhiResidual.push_back(it->phiResidual());
1459  }
1460  if (sctlayer == 8) {
1461  mnt_hit_SCTEndcapL9PhiResidual.push_back(it->phiResidual());
1462  }
1463  break;
1464  case Region::IBL :
1465  mnt_layer_IBL.push_back(pixlayer);
1466  if (m_tcs.m_maxSiliconLayer==32) {
1467  mnt_hit_IBLPhiResidual.push_back(it->phiResidual());
1468  mnt_hit_IBLPhiPull.push_back(it->phiPull());
1469  mnt_hit_IBLEtaResidual.push_back(it->etaResidual());
1470  mnt_hit_IBLEtaPull.push_back(it->etaPull());
1471  }
1472  else {//No IBL, fill pixel histograms instead
1473  ATH_MSG_DEBUG("IBL wrong region" );
1474  mnt_hit_PIXBarrelPhiResidual.push_back(it->phiResidual());
1475  mnt_hit_PIXBarrelPhiPull.push_back(it->phiPull());
1476  mnt_hit_PIXBarrelEtaResidual.push_back(it->etaResidual());
1477  mnt_hit_PIXBarrelEtaPull.push_back(it->etaPull());
1478  }
1479  break;
1480  case Region::Undefined :
1481  ATH_MSG_DEBUG("Undefined ID region");
1482  break;
1483  }
1484  }
1485 }

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

◆ start()

StatusCode TrigFastTrackFinder::start ( )
overridevirtual

Definition at line 373 of file TrigFastTrackFinder.cxx.

374 {
375  //getting magic numbers from the layer numbering tool
376 
377  m_tcs.m_maxBarrelPix = m_numberingTool->offsetBarrelSCT();
378  m_tcs.m_minEndcapPix = m_numberingTool->offsetEndcapPixels();
379  m_tcs.m_maxEndcapPix = m_numberingTool->offsetEndcapSCT();
380  m_tcs.m_maxSiliconLayer = m_numberingTool->maxSiliconLayerNum();
381  m_tcs.m_layerGeometry.clear();
382 
383  if(m_useNewLayerNumberScheme) {
384  const std::vector<TrigInDetSiLayer>* pVL = m_numberingTool->layerGeometry();
385  std::copy(pVL->begin(),pVL->end(),std::back_inserter(m_tcs.m_layerGeometry));
386 
387  if (m_ITkMode) {
388  TrigFTF_GNN_Geometry* pG = new TrigFTF_GNN_Geometry(m_tcs.m_layerGeometry, m_tcs.m_conn);
389  m_tcs.m_geo = pG;
390  }
391  }
392 
393  m_tcs.m_tripletPtMin = m_tripletMinPtFrac*m_pTmin;
394 
395  return StatusCode::SUCCESS;
396 }

◆ 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 AthReentrantAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

96  {
97  StatusCode sc=AthCommonDataStore<AthCommonMsg<Gaudi::Algorithm>>::sysInitialize();
98 
99  if (sc.isFailure()) {
100  return sc;
101  }
102 
103  ServiceHandle<ICondSvc> cs("CondSvc",name());
104  for (auto h : outputHandles()) {
105  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
106  // do this inside the loop so we don't create the CondSvc until needed
107  if ( cs.retrieve().isFailure() ) {
108  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
109  return StatusCode::SUCCESS;
110  }
111  if (cs->regHandle(this,*h).isFailure()) {
112  sc = StatusCode::FAILURE;
113  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
114  << " with CondSvc");
115  }
116  }
117  }
118  return sc;
119 }

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

◆ trackQuality()

double TrigFastTrackFinder::trackQuality ( const Trk::Track *  Tr) const

Definition at line 989 of file TrigFastTrackFinder.cxx.

989  {
990 
991  Trk::TrackStates::const_iterator
992  m = Tr->trackStateOnSurfaces()->begin(),
993  me = Tr->trackStateOnSurfaces()->end ();
994 
995  double quality = 0. ;
996  const double W = 17.;
997 
998  for(; m!=me; ++m) {
999  const Trk::FitQualityOnSurface fq = (*m)->fitQualityOnSurface();
1000  if(!fq) continue;
1001 
1002  double x2 = fq.chiSquared();
1003  double q;
1004  if(fq.numberDoF() == 2) q = (1.2*(W-x2*.5));
1005  else q = (W-x2 );
1006  if(q < 0.) q = 0.;
1007  quality+=q;
1008  }
1009  return quality;
1010 }

◆ updateClusterMap()

void TrigFastTrackFinder::updateClusterMap ( long int  trackIdx,
const Trk::Track *  pTrack,
std::map< Identifier, std::vector< long int > > &  clusterMap 
) const
protected

Definition at line 1060 of file TrigFastTrackFinder.cxx.

1060  {
1061  //loop over clusters
1062 
1063  for(auto tMOT = pTrack->measurementsOnTrack()->begin(); tMOT != pTrack->measurementsOnTrack()->end(); ++tMOT) {
1064 
1065  const InDet::SiClusterOnTrack* siCLOT = dynamic_cast<const InDet::SiClusterOnTrack*>(*tMOT);
1066  if (siCLOT==nullptr) continue;
1067  const InDet::SiCluster* siCL = dynamic_cast<const InDet::SiCluster*>(siCLOT->prepRawData());
1068  if (siCL==nullptr) continue;
1069 
1070  if(m_ITkMode) {
1071  //skip non-pixel clusters because all seeds are PPP in ITK mode
1072  const InDet::PixelCluster* pixCL = dynamic_cast<const InDet::PixelCluster*>(siCL);
1073  if(pixCL==nullptr) continue;
1074  }
1075 
1076  Identifier id = siCL->identify();
1077  clusterMap[id].push_back(trackIdx);
1078  }
1079 }

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

◆ usedByAnyTrack()

bool TrigFastTrackFinder::usedByAnyTrack ( const std::vector< Identifier > &  vIds,
std::map< Identifier, std::vector< long int > > &  clusterMap 
) const
protected

Definition at line 1089 of file TrigFastTrackFinder.cxx.

1089  {
1090 
1091  std::vector<long int> xSection;
1092  //initializing
1093  std::map<Identifier, std::vector<long int> >::iterator itm0 = clusterMap.find(*vIds.begin());
1094  if(itm0 == clusterMap.end()) return false;
1095  xSection.reserve((*itm0).second.size());
1096  std::copy((*itm0).second.begin(), (*itm0).second.end(), std::back_inserter(xSection));
1097  std::vector<Identifier>::const_iterator it = vIds.begin();++it;
1098  for(;it!=vIds.end();++it) {
1099  std::map<Identifier, std::vector<long int> >::iterator itm1 = clusterMap.find(*it);
1100  if(itm1 == clusterMap.end()) return false;
1101  std::vector<long int> tmp;
1102  std::set_intersection(xSection.begin(), xSection.end(), (*itm1).second.begin(),(*itm1).second.end(), std::back_inserter(tmp));
1103  if(tmp.empty()) return false;
1104  //update xSection
1105  xSection.clear();
1106  xSection.reserve(tmp.size());
1107  std::copy(tmp.begin(), tmp.end(), std::back_inserter(xSection));
1108  }
1109  return !xSection.empty();
1110 }

Member Data Documentation

◆ m_accelSvc

ServiceHandle<ITrigInDetAccelerationSvc> TrigFastTrackFinder::m_accelSvc {this, "TrigAccelerationSvc", ""}
private

Definition at line 154 of file TrigFastTrackFinder.h.

◆ m_accelTool

ToolHandle<ITrigInDetAccelerationTool> TrigFastTrackFinder::m_accelTool {this, "TrigAccelerationTool", ""}
private

Definition at line 153 of file TrigFastTrackFinder.h.

◆ m_beamSpotKey

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

Definition at line 197 of file TrigFastTrackFinder.h.

◆ m_checkSeedRedundancy

bool TrigFastTrackFinder::m_checkSeedRedundancy
private

Definition at line 195 of file TrigFastTrackFinder.h.

◆ m_countRoIwithEnoughHits

std::atomic<unsigned int> TrigFastTrackFinder::m_countRoIwithEnoughHits
mutableprivate

Definition at line 208 of file TrigFastTrackFinder.h.

◆ m_countRoIwithTracks

std::atomic<unsigned int> TrigFastTrackFinder::m_countRoIwithTracks
mutableprivate

Definition at line 209 of file TrigFastTrackFinder.h.

◆ m_countTotalRoI

std::atomic<unsigned int> TrigFastTrackFinder::m_countTotalRoI
mutableprivate

Definition at line 207 of file TrigFastTrackFinder.h.

◆ m_dEdxHitKey

SG::WriteHandleKey<xAOD::TrigCompositeContainer> TrigFastTrackFinder::m_dEdxHitKey {this, "dEdxHit", "", ""}
private

Definition at line 165 of file TrigFastTrackFinder.h.

◆ m_dEdxTrkKey

SG::WriteHandleKey<xAOD::TrigCompositeContainer> TrigFastTrackFinder::m_dEdxTrkKey {this, "dEdxTrk", "", ""}
private

Definition at line 164 of file TrigFastTrackFinder.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_disTrkCandKey

SG::WriteHandleKey<xAOD::TrigCompositeContainer> TrigFastTrackFinder::m_disTrkCandKey {this, "DisTrkCand","", ""}
private

Definition at line 166 of file TrigFastTrackFinder.h.

◆ m_disTrkFitter

ToolHandle< Trk::ITrackFitter > TrigFastTrackFinder::m_disTrkFitter
private

Definition at line 150 of file TrigFastTrackFinder.h.

◆ m_doCloneRemoval

Gaudi::Property<bool> TrigFastTrackFinder::m_doCloneRemoval {this, "doCloneRemoval", true, "Remove tracks sharing too many hits"}
private

Definition at line 278 of file TrigFastTrackFinder.h.

◆ m_dodEdxTrk

bool TrigFastTrackFinder::m_dodEdxTrk
private

Definition at line 242 of file TrigFastTrackFinder.h.

◆ m_doDisappearingTrk

bool TrigFastTrackFinder::m_doDisappearingTrk
private

Definition at line 249 of file TrigFastTrackFinder.h.

◆ m_doFastZVseeding

bool TrigFastTrackFinder::m_doFastZVseeding
private

Definition at line 179 of file TrigFastTrackFinder.h.

◆ m_doResMonitoring

bool TrigFastTrackFinder::m_doResMonitoring
private

Definition at line 181 of file TrigFastTrackFinder.h.

◆ m_doTrackRefit

Gaudi::Property<bool> TrigFastTrackFinder::m_doTrackRefit {this, "doTrackRefit", true, "Refit tracks after the combinatorial track following"}
private

Definition at line 279 of file TrigFastTrackFinder.h.

◆ m_doZFinder

bool TrigFastTrackFinder::m_doZFinder
private

Definition at line 174 of file TrigFastTrackFinder.h.

◆ m_doZFinderOnly

bool TrigFastTrackFinder::m_doZFinderOnly
private

Definition at line 175 of file TrigFastTrackFinder.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_extrapolator

ToolHandle< Trk::IExtrapolator > TrigFastTrackFinder::m_extrapolator { this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator" }
private

Definition at line 149 of file TrigFastTrackFinder.h.

◆ m_idHelper

const AtlasDetectorID* TrigFastTrackFinder::m_idHelper
private

Definition at line 213 of file TrigFastTrackFinder.h.

◆ m_initialD0Max

float TrigFastTrackFinder::m_initialD0Max
private

Definition at line 193 of file TrigFastTrackFinder.h.

◆ m_inputTracksKey

SG::ReadHandleKey<TrackCollection> TrigFastTrackFinder::m_inputTracksKey
private

Definition at line 158 of file TrigFastTrackFinder.h.

◆ m_ITkMode

bool TrigFastTrackFinder::m_ITkMode
private

Definition at line 274 of file TrigFastTrackFinder.h.

◆ m_LRTD0Min

float TrigFastTrackFinder::m_LRTD0Min
private

Definition at line 230 of file TrigFastTrackFinder.h.

◆ m_LRTHardMinPt

float TrigFastTrackFinder::m_LRTHardMinPt
private

Definition at line 231 of file TrigFastTrackFinder.h.

◆ m_LRTmode

bool TrigFastTrackFinder::m_LRTmode
private

Definition at line 229 of file TrigFastTrackFinder.h.

◆ m_minHits

int TrigFastTrackFinder::m_minHits
private

Definition at line 186 of file TrigFastTrackFinder.h.

◆ m_monTool

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

Definition at line 148 of file TrigFastTrackFinder.h.

◆ m_nfreeCut

int TrigFastTrackFinder::m_nfreeCut
private

Definition at line 188 of file TrigFastTrackFinder.h.

◆ m_numberingTool

ToolHandle<ITrigL2LayerNumberTool> TrigFastTrackFinder::m_numberingTool {this, "LayerNumberTool", "TrigL2LayerNumberTool"}
private

Definition at line 142 of file TrigFastTrackFinder.h.

◆ m_outputTracksKey

SG::WriteHandleKey<TrackCollection> TrigFastTrackFinder::m_outputTracksKey
private

Definition at line 159 of file TrigFastTrackFinder.h.

◆ m_particleHypothesis

Trk::ParticleHypothesis TrigFastTrackFinder::m_particleHypothesis
private

Definition at line 216 of file TrigFastTrackFinder.h.

◆ m_pixelId

const PixelID* TrigFastTrackFinder::m_pixelId
private

Definition at line 211 of file TrigFastTrackFinder.h.

◆ m_prdToTrackMap

SG::ReadHandleKey<Trk::PRDtoTrackMap> TrigFastTrackFinder::m_prdToTrackMap {this,"PRDtoTrackMap",""}
private

Definition at line 161 of file TrigFastTrackFinder.h.

◆ m_pTmin

float TrigFastTrackFinder::m_pTmin
private

Definition at line 192 of file TrigFastTrackFinder.h.

◆ m_roiCollectionKey

SG::ReadHandleKey<TrigRoiDescriptorCollection> TrigFastTrackFinder::m_roiCollectionKey
private

Definition at line 157 of file TrigFastTrackFinder.h.

◆ m_sctId

const SCT_ID* TrigFastTrackFinder::m_sctId
private

Definition at line 212 of file TrigFastTrackFinder.h.

◆ m_spacePointTool

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

Definition at line 143 of file TrigFastTrackFinder.h.

◆ m_standaloneMode

bool TrigFastTrackFinder::m_standaloneMode
private

Definition at line 275 of file TrigFastTrackFinder.h.

◆ m_storeZFinderVertices

bool TrigFastTrackFinder::m_storeZFinderVertices
private

Definition at line 177 of file TrigFastTrackFinder.h.

◆ m_tcs

TrigCombinatorialSettings TrigFastTrackFinder::m_tcs
private

Definition at line 184 of file TrigFastTrackFinder.h.

◆ m_trackMaker

ToolHandle<InDet::ISiTrackMaker> TrigFastTrackFinder::m_trackMaker
private

Definition at line 144 of file TrigFastTrackFinder.h.

◆ m_trackSummaryTool

ToolHandle< Trk::ITrackSummaryTool > TrigFastTrackFinder::m_trackSummaryTool
private

Definition at line 147 of file TrigFastTrackFinder.h.

◆ m_trigInDetTrackFitter

ToolHandle<ITrigInDetTrackFitter> TrigFastTrackFinder::m_trigInDetTrackFitter
private

Definition at line 145 of file TrigFastTrackFinder.h.

◆ m_trigseedML_LUT

std::string TrigFastTrackFinder::m_trigseedML_LUT
private

Definition at line 233 of file TrigFastTrackFinder.h.

◆ m_trigZFinder

ToolHandle<ITrigZFinder> TrigFastTrackFinder::m_trigZFinder
private

Definition at line 146 of file TrigFastTrackFinder.h.

◆ m_tripletMinPtFrac

float TrigFastTrackFinder::m_tripletMinPtFrac
private

Definition at line 191 of file TrigFastTrackFinder.h.

◆ m_useBeamSpot

bool TrigFastTrackFinder::m_useBeamSpot
private

Definition at line 170 of file TrigFastTrackFinder.h.

◆ m_useEtaBinning

Gaudi::Property<bool> TrigFastTrackFinder::m_useEtaBinning {this, "UseEtaBinning", true, "Split layers into eta bins"}
private

Definition at line 277 of file TrigFastTrackFinder.h.

◆ m_useGPU

bool TrigFastTrackFinder::m_useGPU
private

Definition at line 222 of file TrigFastTrackFinder.h.

◆ m_useNewLayerNumberScheme

bool TrigFastTrackFinder::m_useNewLayerNumberScheme
private

Definition at line 218 of file TrigFastTrackFinder.h.

◆ m_useTracklets

Gaudi::Property<bool> TrigFastTrackFinder::m_useTracklets {this, "UseTracklets", false, "Use tracklet seeds from ITk track seeding"}
private

Definition at line 280 of file TrigFastTrackFinder.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vertexSeededMode

bool TrigFastTrackFinder::m_vertexSeededMode
private

Definition at line 172 of file TrigFastTrackFinder.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_Z0Max

float TrigFastTrackFinder::m_Z0Max
private

Definition at line 194 of file TrigFastTrackFinder.h.

◆ N_BARREL_LAYERS

constexpr size_t TrigFastTrackFinder::N_BARREL_LAYERS {8}
staticconstexprprotected

Definition at line 126 of file TrigFastTrackFinder.h.

The documentation for this class was generated from the following files:
DataVector::reserve
void reserve(size_type n)
Attempt to preallocate enough memory for a specified number of elements.
TrigCombinatorialSettings::m_nMaxPhiSlice
int m_nMaxPhiSlice
Definition: TrigCombinatorialSettings.h:67
TrigFastTrackFinder::m_disTrkCandKey
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_disTrkCandKey
Definition: TrigFastTrackFinder.h:166
TrigFastTrackFinder::m_LRTHardMinPt
float m_LRTHardMinPt
Definition: TrigFastTrackFinder.h:231
TrigInDetTriplet
Definition: TrigInDetTriplet.h:13
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
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
TrigFastTrackFinder::m_spacePointTool
ToolHandle< ITrigSpacePointConversionTool > m_spacePointTool
Definition: TrigFastTrackFinder.h:143
TrigFastTrackFinder::DisTrkCategory
DisTrkCategory
Definition: TrigFastTrackFinder.h:117
plotting.yearwise_luminosity_vs_mu.comp
comp
Definition: yearwise_luminosity_vs_mu.py:24
base
std::string base
Definition: hcg.cxx:78
query_example.row
row
Definition: query_example.py:24
IRoiDescriptor::phi
virtual double phi() const =0
Methods to retrieve data members.
Trk::SpacePoint
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePoint.h:35
IDTPM::ndof
float ndof(const U &p)
Definition: TrackParametersHelper.h:142
Region::SctBarrel
@ SctBarrel
TRIG_TRACK_SEED_GENERATOR_ITK
class TrigTrackSeedGeneratorITk TRIG_TRACK_SEED_GENERATOR_ITK
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
TrigAccel::DataExportBuffer
Definition: DataExportBuffer.h:14
TrigFastTrackFinder::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: TrigFastTrackFinder.h:148
Trk::TrackStateOnSurface::Perigee
@ Perigee
This represents a perigee, and so will contain a Perigee object only.
Definition: TrackStateOnSurface.h:117
TrigAccel::DATA_EXPORT_BUFFER
struct TrigAccel::DataExportBuffer DATA_EXPORT_BUFFER
TrigFastTrackFinder::m_pTmin
float m_pTmin
Definition: TrigFastTrackFinder.h:192
xAOD::TrigComposite_v1::setDetail
bool setDetail(const std::string &name, const TYPE &value)
Set an TYPE detail on the object.
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TrigCombinatorialSettings::m_zvErrorEndcap
float m_zvErrorEndcap
Definition: TrigCombinatorialSettings.h:71
trackInfo::ptGeV
float ptGeV
Definition: TrigInDetUtils.h:15
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
Region::PixBarrel
@ PixBarrel
Trk::Track::fitQuality
const FitQuality * fitQuality() const
return a pointer to the fit quality const-overload
TrigFastTrackFinder::findTracks
StatusCode findTracks(InDet::SiTrackMakerEventData_xk &event_data, const TrigRoiDescriptor &roi, const TrackCollection *inputTracks, TrackCollection &outputTracks, const EventContext &ctx) const
Definition: TrigFastTrackFinder.cxx:449
trackInfo::n_hits_inner
int n_hits_inner
Definition: TrigInDetUtils.h:14
get_generator_info.result
result
Definition: get_generator_info.py:21
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
TrigFastTrackFinder::filterSharedDisTracks
void filterSharedDisTracks(std::vector< std::tuple< bool, double, Trk::Track * >> &) const
Definition: TrigFastTrackFinder.cxx:2325
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
TrigFastTrackFinder::m_idHelper
const AtlasDetectorID * m_idHelper
Definition: TrigFastTrackFinder.h:213
DataVector::emplace_back
value_type emplace_back(value_type pElem)
Add an element to the end of the collection.
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
RoiDescriptor::zedMinus
virtual double zedMinus() const override final
z at the most backward end of the RoI
Definition: RoiDescriptor.h:113
Trk::locX
@ locX
Definition: ParamDefs.h:43
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
PathResolver::find_file
static std::string find_file(const std::string &logical_file_name, const std::string &search_path, SearchType search_type=LocalSearch)
Definition: PathResolver.cxx:251
Trk::locY
@ locY
local cartesian
Definition: ParamDefs.h:44
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
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
TrigCombinatorialSettings::m_tripletD0_PPS_Max
float m_tripletD0_PPS_Max
Definition: TrigCombinatorialSettings.h:58
TRIG_TRACK_SEED_GENERATOR
class TrigTrackSeedGenerator TRIG_TRACK_SEED_GENERATOR
xAOD::TrigComposite
TrigComposite_v1 TrigComposite
Declare the latest version of the class.
Definition: Event/xAOD/xAODTrigger/xAODTrigger/TrigComposite.h:16
TrigCombinatorialSettings::m_tripletDtCut
float m_tripletDtCut
Definition: TrigCombinatorialSettings.h:66
ParticleGun_SamplingFraction.bec
int bec
Definition: ParticleGun_SamplingFraction.py:89
TrigCombinatorialSettings::m_maxSiliconLayer
int m_maxSiliconLayer
Definition: TrigCombinatorialSettings.h:51
TrigFastTrackFinder::m_trigInDetTrackFitter
ToolHandle< ITrigInDetTrackFitter > m_trigInDetTrackFitter
Definition: TrigFastTrackFinder.h:145
SG::VIEW_ELEMENTS
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
Definition: OwnershipPolicy.h:18
Trk::PerigeeSurface
Definition: PerigeeSurface.h:43
PixelID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: PixelID.h:619
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
TrigAccel::Work::run
virtual bool run()=0
TrigFastTrackFinder::Other
@ Other
Definition: TrigFastTrackFinder.h:118
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
JetTiledMap::W
@ W
Definition: TiledEtaPhiMap.h:44
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TrigFastTrackFinder::m_accelSvc
ServiceHandle< ITrigInDetAccelerationSvc > m_accelSvc
Definition: TrigFastTrackFinder.h:154
Trk::Track::trackStateOnSurfaces
const Trk::TrackStates * trackStateOnSurfaces() const
return a pointer to a const DataVector of const TrackStateOnSurfaces.
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
Region::SctEndcap
@ SctEndcap
TrigFastTrackFinder::m_checkSeedRedundancy
bool m_checkSeedRedundancy
Definition: TrigFastTrackFinder.h:195
IRoiDescriptor::etaMinus
virtual double etaMinus() const =0
TrigFastTrackFinder::m_outputTracksKey
SG::WriteHandleKey< TrackCollection > m_outputTracksKey
Definition: TrigFastTrackFinder.h:159
CxxUtils::wrapToPi
T wrapToPi(T phi)
Wrap angle in radians to [-pi, pi].
Definition: phihelper.h:24
InDetAccessor::phi0
@ phi0
Definition: InDetAccessor.h:33
TrigFastTrackFinder::dEdx
float dEdx(const Trk::Track *, int &, int &, std::vector< float > &, std::vector< float > &, std::vector< float > &, std::vector< float > &, std::vector< int > &, std::vector< int > &, std::vector< int > &) const
Definition: TrigFastTrackFinder.cxx:1744
plotBeamSpotCompare.x2
x2
Definition: plotBeamSpotCompare.py:218
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:71
TrigFastTrackFinder::m_doTrackRefit
Gaudi::Property< bool > m_doTrackRefit
Definition: TrigFastTrackFinder.h:279
TrigCombinatorialSettings::m_maxBarrelPix
int m_maxBarrelPix
Definition: TrigCombinatorialSettings.h:51
TrigFastTrackFinder::makeSeedsOnGPU
void makeSeedsOnGPU(const TrigCombinatorialSettings &, const IRoiDescriptor *, const std::vector< TrigSiSpacePointBase > &, std::vector< TrigInDetTriplet > &) const
Definition: TrigFastTrackFinder.cxx:1487
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
TrigAccel::Work::getOutput
virtual std::shared_ptr< OffloadBuffer > getOutput()=0
skel.it
it
Definition: skel.GENtoEVGEN.py:423
TrigCombinatorialSettings::m_layerGeometry
std::vector< TrigInDetSiLayer > m_layerGeometry
Definition: TrigCombinatorialSettings.h:78
test_pyathena.pt
pt
Definition: test_pyathena.py:11
TrigFastTrackFinder::m_doCloneRemoval
Gaudi::Property< bool > m_doCloneRemoval
Definition: TrigFastTrackFinder.h:278
M_PI
#define M_PI
Definition: ActiveFraction.h:11
TrigCombinatorialSettings::m_curv_delta
float m_curv_delta
Definition: TrigCombinatorialSettings.h:64
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
RoiDescriptor::composite
virtual bool composite() const override final
SuperRoI compatability methods.
Definition: RoiDescriptor.h:137
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
ParticleTest.tp
tp
Definition: ParticleTest.py:25
TrigFastTrackFinder::m_disTrkFitter
ToolHandle< Trk::ITrackFitter > m_disTrkFitter
Definition: TrigFastTrackFinder.h:150
Trk::z0
@ z0
Definition: ParamDefs.h:70
TrigCombinatorialSettings::m_LRTmode
bool m_LRTmode
Definition: TrigCombinatorialSettings.h:72
RoiDescriptor::size
virtual unsigned size() const override final
number of constituents
Definition: RoiDescriptor.h:145
TrigCombinatorialSettings::m_tripletPtMin
float m_tripletPtMin
Definition: TrigCombinatorialSettings.h:59
TrigFastTrackFinder::Pix4l_Sct0
@ Pix4l_Sct0
Definition: TrigFastTrackFinder.h:119
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:259
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
TrigFastTrackFinder::m_doZFinder
bool m_doZFinder
Definition: TrigFastTrackFinder.h:174
TrigFastTrackFinder::m_extrapolator
ToolHandle< Trk::IExtrapolator > m_extrapolator
Definition: TrigFastTrackFinder.h:149
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:12
Trk::FitQualityOnSurface::doubleNumberDoF
double doubleNumberDoF() const
returns the number of degrees of freedom of the overall track or vertex fit as double
Definition: FitQuality.h:68
SCT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: SCT_ID.h:728
FTF::getBeamSpotShift
void getBeamSpotShift(float &shift_x, float &shift_y, const InDet::BeamSpotData &beamSpotHandle)
Definition: TrigInDetUtils.cxx:30
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:112
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
TrigCombinatorialSettings::m_tripletDoConfirm
bool m_tripletDoConfirm
Definition: TrigCombinatorialSettings.h:63
IRoiDescriptor::etaPlus
virtual double etaPlus() const =0
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
TrigFastTrackFinder::m_standaloneMode
bool m_standaloneMode
Definition: TrigFastTrackFinder.h:275
InDetAccessor::qOverP
@ qOverP
perigee
Definition: InDetAccessor.h:35
TrigFastTrackFinder::m_inputTracksKey
SG::ReadHandleKey< TrackCollection > m_inputTracksKey
Definition: TrigFastTrackFinder.h:158
xAOD::int16_t
setScaleOne setStatusOne setSaturated int16_t
Definition: gFexGlobalRoI_v1.cxx:55
TrigFastTrackFinder::m_useGPU
bool m_useGPU
Definition: TrigFastTrackFinder.h:222
TrigSeedML_LUT
Definition: TrigSeedML_LUT.h:10
InDet::PixelCluster::totList
const std::vector< int > & totList() const
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/PixelCluster.h:201
pi
#define pi
Definition: TileMuonFitter.cxx:65
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
FASTRACK_CONNECTOR
class FasTrackConnector FASTRACK_CONNECTOR
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
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
TrigFastTrackFinder::extractClusterIds
void extractClusterIds(const Trk::SpacePoint *, std::vector< Identifier > &) const
Definition: TrigFastTrackFinder.cxx:1081
Region::PixEndcap
@ PixEndcap
TrigFastTrackFinder::Pix3l_Sct1p
@ Pix3l_Sct1p
Definition: TrigFastTrackFinder.h:122
TrigCombinatorialSettings::m_maxEC_len
float m_maxEC_len
Definition: TrigCombinatorialSettings.h:82
TrigFastTrackFinder::m_doDisappearingTrk
bool m_doDisappearingTrk
Definition: TrigFastTrackFinder.h:249
Trk::FitQualityOnSurface
Definition: FitQualityOnSurface.h:19
CxxUtils::vec
typename vecDetail::vec_typedef< T, N >::type vec
Define a nice alias for the vectorized type.
Definition: vec.h:207
TrigCombinatorialSettings::m_zvError
float m_zvError
Definition: TrigCombinatorialSettings.h:70
IRoiDescriptor::eta
virtual double eta() const =0
trackInfo::eta
float eta
Definition: TrigInDetUtils.h:15
TrigFastTrackFinder::updateClusterMap
void updateClusterMap(long int, const Trk::Track *, std::map< Identifier, std::vector< long int > > &) const
Definition: TrigFastTrackFinder.cxx:1060
TrigFastTrackFinder::m_initialD0Max
float m_initialD0Max
Definition: TrigFastTrackFinder.h:193
TrigFastTrackFinder::m_dEdxTrkKey
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_dEdxTrkKey
Definition: TrigFastTrackFinder.h:164
TrigFastTrackFinder::m_LRTmode
bool m_LRTmode
Definition: TrigFastTrackFinder.h:229
TrigCombinatorialSettings::m_doublet_dR_Max
float m_doublet_dR_Max
Definition: TrigCombinatorialSettings.h:54
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
AthReentrantAlgorithm::AthReentrantAlgorithm
AthReentrantAlgorithm()
Default constructor:
TrigFastTrackFinder::getDisTrkCategory
TrigFastTrackFinder::DisTrkCategory getDisTrkCategory(Trk::Track *trk) const
Definition: TrigFastTrackFinder.cxx:2542
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
RoiDescriptor::push_back
void push_back(const IRoiDescriptor *roi)
add a RoiDescriptor
Definition: RoiDescriptor.h:157
TrigCombinatorialSettings::m_conn
const FASTRACK_CONNECTOR * m_conn
Definition: TrigCombinatorialSettings.h:75
TrigFastTrackFinder::runResidualMonitoring
void runResidualMonitoring(const Trk::Track &track, const EventContext &) const
Definition: TrigFastTrackFinder.cxx:1268
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:193
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
python.TrigInDetConfig.inputTracks
inputTracks
Definition: TrigInDetConfig.py:168
RoiDescriptor::at
virtual const IRoiDescriptor * at(int i) const override final
find an RoiDescriptor constituent
Definition: RoiDescriptor.h:148
TrigFastTrackFinder::m_countRoIwithEnoughHits
std::atomic< unsigned int > m_countRoIwithEnoughHits
Definition: TrigFastTrackFinder.h:208
lumiFormat.i
int i
Definition: lumiFormat.py:92
z
#define z
TrigFastTrackFinder::m_vertexSeededMode
bool m_vertexSeededMode
Definition: TrigFastTrackFinder.h:172
TrigCombinatorialSettings::m_seedRadBinWidth
float m_seedRadBinWidth
Definition: TrigCombinatorialSettings.h:60
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
beamspotman.n
n
Definition: beamspotman.py:731
Trk::theta
@ theta
Definition: ParamDefs.h:72
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
InDet::PixelCluster::totalToT
int totalToT() const
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/PixelCluster.h:205
IRoiDescriptor
Describes the API of the Region of Ineterest geometry.
Definition: IRoiDescriptor.h:23
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TrigCombinatorialSettings::m_tripletDoPPS
bool m_tripletDoPPS
Definition: TrigCombinatorialSettings.h:62
ReweightUtils.category
category
Definition: ReweightUtils.py:15
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
TrigFastTrackFinder::finddEdxTrk
StatusCode finddEdxTrk(const EventContext &, const TrackCollection &) const
Definition: TrigFastTrackFinder.cxx:1655
Trk::pion
@ pion
Definition: ParticleHypothesis.h:29
TrigFastTrackFinder::m_tcs
TrigCombinatorialSettings m_tcs
Definition: TrigFastTrackFinder.h:184
TrigFastTrackFinder::usedByAnyTrack
bool usedByAnyTrack(const std::vector< Identifier > &, std::map< Identifier, std::vector< long int > > &) const
Definition: TrigFastTrackFinder.cxx:1089
TileDCSDataPlotter.pr
pr
Definition: TileDCSDataPlotter.py:922
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:522
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
checkCorrelInHIST.prefix
dictionary prefix
Definition: checkCorrelInHIST.py:391
TrigFastTrackFinder::m_Z0Max
float m_Z0Max
Definition: TrigFastTrackFinder.h:194
TrigFastTrackFinder::Pix4l_Sct1p
@ Pix4l_Sct1p
Definition: TrigFastTrackFinder.h:120
TrigFastTrackFinder::m_useBeamSpot
bool m_useBeamSpot
Definition: TrigFastTrackFinder.h:170
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
IRoiDescriptor::phiMinus
virtual double phiMinus() const =0
TrigFastTrackFinder::recoAndFillDisTrkCand
int recoAndFillDisTrkCand(const std::string &, TrackCollection *, std::vector< Trk::Track * > &, xAOD::TrigCompositeContainer *, const std::vector< double > &, const std::vector< double > &, const std::vector< double > &, bool) const
Definition: TrigFastTrackFinder.cxx:2693
Region::IBL
@ IBL
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
Trk::FitQuality
Class to represent and store fit qualities from track reconstruction in terms of and number of degre...
Definition: FitQuality.h:97
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Trk::ParametersBase
Definition: ParametersBase.h:55
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
TRT::Track::z0
@ z0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:63
Trk::FitQualityOnSurface::numberDoF
int numberDoF() const
returns the number of degrees of freedom of the overall track or vertex fit as integer
Definition: FitQuality.h:60
xAOD::TrigComposite_v1
Class used to describe composite objects in the HLT.
Definition: TrigComposite_v1.h:52
python.compareNtuple.nGood
nGood
Definition: compareNtuple.py:55
a0
double a0
Definition: globals.cxx:27
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
DataVector< const Trk::TrackStateOnSurface >
TrigFastTrackFinder::disTrackQuality
double disTrackQuality(const Trk::Track *) const
Definition: TrigFastTrackFinder.cxx:2093
TrigFastTrackFinder::m_dodEdxTrk
bool m_dodEdxTrk
Definition: TrigFastTrackFinder.h:242
TrigFastTrackFinder::findDisTracks
StatusCode findDisTracks(const EventContext &, TrackCollection &, std::vector< std::tuple< bool, double, Trk::Track * >> &, std::vector< std::tuple< bool, double, Trk::Track * >> &, TrackCollection &, const std::vector< double > &, const std::vector< double > &, const std::vector< double > &) const
Definition: TrigFastTrackFinder.cxx:2362
TrigFastTrackFinder::m_roiCollectionKey
SG::ReadHandleKey< TrigRoiDescriptorCollection > m_roiCollectionKey
Definition: TrigFastTrackFinder.h:157
LB_AnalMapSplitter.tot
tot
Definition: LB_AnalMapSplitter.py:46
TrigCombinatorialSettings::m_maxTripletBufferLength
unsigned int m_maxTripletBufferLength
Definition: TrigCombinatorialSettings.h:68
trackInfo
Definition: TrigInDetUtils.h:13
TrigCombinatorialSettings::m_useEtaBinning
bool m_useEtaBinning
Definition: TrigCombinatorialSettings.h:73
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
TrigFastTrackFinder::m_ITkMode
bool m_ITkMode
Definition: TrigFastTrackFinder.h:274
SCT
Definition: SCT_ChipUtils.h:14
TrigCombinatorialSettings::m_tripletDoPSS
bool m_tripletDoPSS
Definition: TrigCombinatorialSettings.h:61
TrigFastTrackFinder::trackQuality
double trackQuality(const Trk::Track *Tr) const
Definition: TrigFastTrackFinder.cxx:989
TrigFastTrackFinder::m_nfreeCut
int m_nfreeCut
Definition: TrigFastTrackFinder.h:188
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
IRoiDescriptor::phiPlus
virtual double phiPlus() const =0
extreme phi values
TrigFastTrackFinder::m_LRTD0Min
float m_LRTD0Min
Definition: TrigFastTrackFinder.h:230
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
InDet::ExtendedSiTrackMakerEventData_xk
Definition: SiSPSeededTrackFinder.cxx:161
merge.output
output
Definition: merge.py:17
Trk::PrepRawData
Definition: PrepRawData.h:62
Trk::MeasurementBase
Definition: MeasurementBase.h:58
TrigFastTrackFinder::m_trackSummaryTool
ToolHandle< Trk::ITrackSummaryTool > m_trackSummaryTool
Definition: TrigFastTrackFinder.h:147
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
TrigFastTrackFinder::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
Definition: TrigFastTrackFinder.h:197
PixelID::layer_disk
int layer_disk(const Identifier &id) const
Definition: PixelID.h:626
TrigFastTrackFinder::disTrk_refit
std::unique_ptr< Trk::Track > disTrk_refit(Trk::Track *t) const
Definition: TrigFastTrackFinder.cxx:2791
Trk::Track::perigeeParameters
const Perigee * perigeeParameters() const
return Perigee.
Definition: Tracking/TrkEvent/TrkTrack/src/Track.cxx:163
PixelID::eta_module
int eta_module(const Identifier &id) const
Definition: PixelID.h:651
xAOD::numberOfNextToInnermostPixelLayerHits
@ numberOfNextToInnermostPixelLayerHits
these are the hits in the 1st pixel barrel layer
Definition: TrackingPrimitives.h:248
Trk::SurfaceType::Perigee
@ Perigee
trackInfo::a0beam
float a0beam
Definition: TrigInDetUtils.h:15
TrigCombinatorialSettings::m_useTrigSeedML
int m_useTrigSeedML
Definition: TrigCombinatorialSettings.h:80
TrigFastTrackFinder::m_trackMaker
ToolHandle< InDet::ISiTrackMaker > m_trackMaker
Definition: TrigFastTrackFinder.h:144
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
TrigFastTrackFinder::print_disTrk
void print_disTrk(const Trk::Track *t) const
Definition: TrigFastTrackFinder.cxx:2844
TrigFastTrackFinder::isPreselPassDisTrackBeforeRefit
bool isPreselPassDisTrackBeforeRefit(Trk::Track *, double, double) const
Definition: TrigFastTrackFinder.cxx:2475
TrigFastTrackFinder::m_accelTool
ToolHandle< ITrigInDetAccelerationTool > m_accelTool
Definition: TrigFastTrackFinder.h:153
RoiDescriptor::zed
virtual double zed() const override final
Definition: RoiDescriptor.h:102
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:194
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
Trk::d0
@ d0
Definition: ParamDefs.h:69
TrigFastTrackFinder::m_dEdxHitKey
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_dEdxHitKey
Definition: TrigFastTrackFinder.h:165
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
TrigAccel::Work
Definition: Work.h:14
charge
double charge(const T &p)
Definition: AtlasPID.h:494
SCT_ID::layer_disk
int layer_disk(const Identifier &id) const
Definition: SCT_ID.h:734
Region::Undefined
@ Undefined
TrigFastTrackFinder::m_doFastZVseeding
bool m_doFastZVseeding
Definition: TrigFastTrackFinder.h:179
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)
TrigFastTrackFinder::fillMon
void fillMon(const TrackCollection &tracks, const TrigVertexCollection &vertices, const TrigRoiDescriptor &roi, const EventContext &ctx) const
Definition: TrigFastTrackFinder.cxx:1112
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::RIO_OnTrack::prepRawData
virtual const Trk::PrepRawData * prepRawData() const =0
returns the PrepRawData (also known as RIO) object to which this RIO_OnTrack is associated.
TrigFastTrackFinder::m_prdToTrackMap
SG::ReadHandleKey< Trk::PRDtoTrackMap > m_prdToTrackMap
Definition: TrigFastTrackFinder.h:162
TrigFTF_GNN_Geometry
Definition: GNN_Geometry.h:50
Trk::MeasurementBase::localParameters
const LocalParameters & localParameters() const
Interface method to get the LocalParameters.
Definition: MeasurementBase.h:132
TrigFastTrackFinder::m_useNewLayerNumberScheme
bool m_useNewLayerNumberScheme
Definition: TrigFastTrackFinder.h:218
InDet::PixelCluster
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/PixelCluster.h:49
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
Trk::Track::measurementsOnTrack
const DataVector< const MeasurementBase > * measurementsOnTrack() const
return a pointer to a vector of MeasurementBase (NOT including any that come from outliers).
Definition: Tracking/TrkEvent/TrkTrack/src/Track.cxx:178
TrigCombinatorialSettings::m_minEndcapPix
int m_minEndcapPix
Definition: TrigCombinatorialSettings.h:51
TrigCombinatorialSettings::m_doubletFilterRZ
bool m_doubletFilterRZ
Definition: TrigCombinatorialSettings.h:65
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
TrigFastTrackFinder::fillDisTrkCand
void fillDisTrkCand(xAOD::TrigComposite *, const std::string &, Trk::Track *, const std::unique_ptr< const Trk::TrackParameters > &) const
Definition: TrigFastTrackFinder.cxx:2569
TrigCombinatorialSettings::m_geo
const TrigFTF_GNN_Geometry * m_geo
Definition: TrigCombinatorialSettings.h:76
RoiDescriptor::etaPlus
virtual double etaPlus() const override final
gets eta at zedPlus
Definition: RoiDescriptor.h:115
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
TrigCombinatorialSettings::m_vLUT
std::vector< TrigSeedML_LUT > m_vLUT
Definition: TrigCombinatorialSettings.h:81
TrigCombinatorialSettings::m_maxEndcapPix
int m_maxEndcapPix
Definition: TrigCombinatorialSettings.h:51
InDet::PixelClusterOnTrack::prepRawData
virtual const PixelCluster * prepRawData() const override final
returns the PrepRawData - is a SiCluster in this scope
Definition: PixelClusterOnTrack.h:179
compileRPVLLRates.nf
nf
Definition: compileRPVLLRates.py:89
TrigFastTrackFinder::m_countTotalRoI
std::atomic< unsigned int > m_countTotalRoI
Definition: TrigFastTrackFinder.h:207
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
a
TList * a
Definition: liststreamerinfos.cxx:10
h
TrigFastTrackFinder::m_trigseedML_LUT
std::string m_trigseedML_LUT
Definition: TrigFastTrackFinder.h:233
IRoiDescriptor::zedPlus
virtual double zedPlus() const =0
the zed and eta values at the most forward and most rear ends of the RoI
Trk::TrackInfo::FastTrackFinderSeed
@ FastTrackFinderSeed
for tracks seeded by the FastTrackFinder
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/TrackInfo.h:252
InDet::PixelClusterOnTrack
Definition: PixelClusterOnTrack.h:51
TrigFastTrackFinder::m_doZFinderOnly
bool m_doZFinderOnly
Definition: TrigFastTrackFinder.h:175
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
RoiDescriptor::phi
virtual double phi() const override final
Methods to retrieve data members.
Definition: RoiDescriptor.h:100
Trk::Track::trackSummary
const Trk::TrackSummary * trackSummary() const
Returns a pointer to the const Trk::TrackSummary owned by this const track (could be nullptr)
trackInfo::phi0
float phi0
Definition: TrigInDetUtils.h:15
TrigCombinatorialSettings::m_doublet_dR_Max_Confirm
float m_doublet_dR_Max_Confirm
Definition: TrigCombinatorialSettings.h:55
TrigFastTrackFinder::isGoodForDisTrackVertex
bool isGoodForDisTrackVertex(Trk::Track *) const
Definition: TrigFastTrackFinder.cxx:2275
TrigFastTrackFinder::Pix3l_Sct0
@ Pix3l_Sct0
Definition: TrigFastTrackFinder.h:121
TrigFastTrackFinder::createEmptyUTTEDMs
StatusCode createEmptyUTTEDMs(const EventContext &) const
Definition: TrigFastTrackFinder.cxx:1518
TrigFastTrackFinder::m_countRoIwithTracks
std::atomic< unsigned int > m_countRoIwithTracks
Definition: TrigFastTrackFinder.h:209
InDet::PixelCluster::totalCharge
float totalCharge() const
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/PixelCluster.h:213
TrigFastTrackFinder::isPreselPassDisTrackAfterRefit
bool isPreselPassDisTrackAfterRefit(Trk::Track *, Trk::Track *, double, double) const
Definition: TrigFastTrackFinder.cxx:2428
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:73
TrigFastTrackFinder::m_minHits
int m_minHits
Definition: TrigFastTrackFinder.h:186
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
TrigFastTrackFinder::m_storeZFinderVertices
bool m_storeZFinderVertices
Definition: TrigFastTrackFinder.h:177
Trk::RIO_OnTrack::identify
virtual Identifier identify() const final
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:155
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
RoiDescriptor::begin
virtual roi_iterator begin() const override final
iterators
Definition: RoiDescriptor.h:160
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
RoiDescriptor::eta
virtual double eta() const override final
Definition: RoiDescriptor.h:101
extractSporadic.q
list q
Definition: extractSporadic.py:98
IRoiDescriptor::zed
virtual double zed() const =0
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
IRoiDescriptor::zedMinus
virtual double zedMinus() const =0
TrigCombinatorialSettings::m_tripletD0Max
float m_tripletD0Max
Definition: TrigCombinatorialSettings.h:57
RoiDescriptor::setComposite
void setComposite(bool b=true)
Definition: RoiDescriptor.h:138
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
TrigFastTrackFinder::filterSharedTracks
void filterSharedTracks(std::vector< std::tuple< bool, double, Trk::Track * >> &QT) const
Definition: TrigFastTrackFinder.cxx:1012
TrigFastTrackFinder::m_pixelId
const PixelID * m_pixelId
Definition: TrigFastTrackFinder.h:211
Trk::FitQuality::chiSquared
double chiSquared() const
returns the of the overall track fit
Definition: FitQuality.h:56
TrigFastTrackFinder::m_trigZFinder
ToolHandle< ITrigZFinder > m_trigZFinder
Definition: TrigFastTrackFinder.h:146
TrigFastTrackFinder::m_particleHypothesis
Trk::ParticleHypothesis m_particleHypothesis
Definition: TrigFastTrackFinder.h:216
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
Trk::FitQuality::numberDoF
int numberDoF() const
returns the number of degrees of freedom of the overall track or vertex fit as integer
Definition: FitQuality.h:60
TrigFastTrackFinder::m_sctId
const SCT_ID * m_sctId
Definition: TrigFastTrackFinder.h:212
TrigFastTrackFinder::m_useTracklets
Gaudi::Property< bool > m_useTracklets
Definition: TrigFastTrackFinder.h:280
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
calibdata.copy
bool copy
Definition: calibdata.py:27
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
TrigFastTrackFinder::m_numberingTool
ToolHandle< ITrigL2LayerNumberTool > m_numberingTool
Definition: TrigFastTrackFinder.h:142
RoiDescriptor::manageConstituents
bool manageConstituents() const
always manage constituents ???
Definition: RoiDescriptor.h:141
Trk::TrackSummary::get
int get(const SummaryType &type) const
returns the summary information for the passed SummaryType.
trackInfo::n_hits_innermost
int n_hits_innermost
Definition: TrigInDetUtils.h:14
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
RoiDescriptor::phiPlus
virtual double phiPlus() const override final
gets phiPlus
Definition: RoiDescriptor.h:118
TrigFastTrackFinder::getTrkBarrelLayerInfo
std::array< OneLayerInfo_t, N_BARREL_LAYERS > getTrkBarrelLayerInfo(Trk::Track *aTrack) const
Definition: TrigFastTrackFinder.cxx:2036
TrigAccel::MAKE_SEEDS
@ MAKE_SEEDS
Definition: TrigInDetAccelCodes.h:29
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:200
DataVector::erase
iterator erase(iterator position)
Remove element at a given position.
RoiDescriptor::etaMinus
virtual double etaMinus() const override final
gets eta at zMinus
Definition: RoiDescriptor.h:116
test_pyathena.counter
counter
Definition: test_pyathena.py:15
set_intersection
Set * set_intersection(Set *set1, Set *set2)
Perform an intersection of two sets.
TrigFastTrackFinder::m_useEtaBinning
Gaudi::Property< bool > m_useEtaBinning
Definition: TrigFastTrackFinder.h:277
TrigFastTrackFinder::isCleaningPassDisTrack
bool isCleaningPassDisTrack(const TrigInDetTriplet &, Trk::Track *, bool) const
Definition: TrigFastTrackFinder.cxx:1955
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
RoiDescriptor::phiMinus
virtual double phiMinus() const override final
gets phiMinus
Definition: RoiDescriptor.h:119
python.compressB64.c
def c
Definition: compressB64.py:93
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
TrigFastTrackFinder::m_doResMonitoring
bool m_doResMonitoring
Definition: TrigFastTrackFinder.h:181
TrigFastTrackFinder::recoVertexForDisTrack
void recoVertexForDisTrack(const EventContext &, TrackCollection &, std::vector< double > &, std::vector< double > &, std::vector< double > &) const
Definition: TrigFastTrackFinder.cxx:2130
InDet::SiCluster
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/SiCluster.h:40
Monitored::Timer
A monitored timer.
Definition: MonitoredTimer.h:32
Trk::FitQualityOnSurface::chiSquared
double chiSquared() const
returns the of the overall track fit
Definition: FitQuality.h:56
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
plotBeamSpotMon.nc
int nc
Definition: plotBeamSpotMon.py:83
Trk::phi0
@ phi0
Definition: ParamDefs.h:71
TrigFastTrackFinder::extrapolateDisTrackToBS
std::unique_ptr< const Trk::TrackParameters > extrapolateDisTrackToBS(Trk::Track *, const std::vector< double > &, const std::vector< double > &, const std::vector< double > &) const
Definition: TrigFastTrackFinder.cxx:2514
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
Trk::FitQuality::doubleNumberDoF
double doubleNumberDoF() const
returns the number of degrees of freedom of the overall track or vertex fit as double
Definition: FitQuality.h:68
fitman.k
k
Definition: fitman.py:528
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition: TrackingPrimitives.h:237
InDet::SiClusterOnTrack
Definition: SiClusterOnTrack.h:39
InDet::SCT_ClusterOnTrack
Definition: SCT_ClusterOnTrack.h:44
TrigFastTrackFinder::m_tripletMinPtFrac
float m_tripletMinPtFrac
Definition: TrigFastTrackFinder.h:191
ServiceHandle< ICondSvc >
RoiDescriptor::zedPlus
virtual double zedPlus() const override final
z at the most forward end of the RoI
Definition: RoiDescriptor.h:112
Generated on Fri Jul 5 2024 22:05:01 for ATLAS Offline Software by   doxygen 1.8.18