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 EventContext &) const
 
void print_disTrk (const Trk::Track *t) const
 
std::unique_ptr< Trk::Track > disTrk_refit (Trk::Track *t, const EventContext &ctx) 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 EventContext &) const
 
std::unique_ptr< const Trk::TrackParameters > extrapolateDisTrackToBS (Trk::Track *, const std::vector< double > &, const std::vector< double > &, const std::vector< double > &, const EventContext &) 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
 
std::string m_connectionFile
 
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  declareProperty( "ConnectionFileName", m_connectionFile = "binTables_ITK_RUN4.txt");
126 
128  declareProperty("UseTrigSeedML", m_tcs.m_useTrigSeedML = 0,"set ML-based seed selection mode (0 disables)" );
129  declareProperty("TrigSeedML_LUT", m_trigseedML_LUT = "trigseed_ml_pixel_barrel_kde.lut","LUT used by ML-based seed selection");
130  declareProperty("maxEC_Pixel_cluster_length", m_tcs.m_maxEC_len = 1.5,"Maximum Endcap Pixel cluster length for ML-based seed selection" );
131 
132 
133  //* Clone removal (removal of tracks sharing too many hits */
134 
135  declareProperty( "FreeClustersCut" ,m_nfreeCut,"Minimum number of unshared clusters");
136 
137  //** Cuts applied to final tracks after Fit
138  declareProperty("TrackInitialD0Max", m_initialD0Max = 10.0,"Maximum d0 of track");
139  declareProperty("TrackZ0Max", m_Z0Max = 300.0,"Maximum z0 of track");
140 
141 
142  /* Monitoring */
143  declareProperty( "doResMon", m_doResMonitoring = true,"enable unbiased residual monitoring");
144  declareProperty( "UseBeamSpot", m_useBeamSpot = true,"Monitor d0 with respect to beamspot");
145 
146  //* Collection Names */
147  declareProperty("TracksName",
148  m_outputTracksKey = std::string("TrigFastTrackFinder_Tracks"),
149  "TrackCollection name");
150 
151  declareProperty("inputTracksName",
152  m_inputTracksKey = std::string(""),
153  "TrackCollection name");
154 
155  declareProperty("RoIs", m_roiCollectionKey = std::string("OutputRoIs"), "RoIs to read in");
156 
157  //* Tools */
158  declareProperty( "initialTrackMaker", m_trackMaker);
159  declareProperty( "trigInDetTrackFitter", m_trigInDetTrackFitter );
160  declareProperty( "trigZFinder", m_trigZFinder );
161  declareProperty("TrackSummaryTool", m_trackSummaryTool);
162 
163  // Accleration
164  declareProperty("useGPU", m_useGPU = false,"Use GPU acceleration");
165 
166  // Large Radius Tracking
167  declareProperty("LRT_Mode", m_LRTmode,"Enable Large Radius Tracking mode" );
168  declareProperty("LRT_D0Min", m_LRTD0Min=0.0,"Minimum d0 for tracks to be saved in LRT Mode" );
169  declareProperty("LRT_HardMinPt", m_LRTHardMinPt=0.0,"Minimum pT for tracks to be saved in LRT Mode");
170 
171  // UTT
172  declareProperty("dodEdxTrk", m_dodEdxTrk = false);
173  declareProperty("doDisappearingTrk", m_doDisappearingTrk = false);
174  declareProperty("DisTrackFitter", m_disTrkFitter );
175 
176  // Phase II
177  declareProperty("ITkMode", m_ITkMode = false);
178  declareProperty("StandaloneMode", m_standaloneMode = false);
179 
180 }

◆ ~TrigFastTrackFinder()

TrigFastTrackFinder::~TrigFastTrackFinder ( )
virtual

Definition at line 184 of file TrigFastTrackFinder.cxx.

184 {}

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 1531 of file TrigFastTrackFinder.cxx.

1532 {
1533  if( m_dodEdxTrk ) {
1534  SG::WriteHandle<xAOD::TrigCompositeContainer> dEdxTrkHandle(m_dEdxTrkKey, ctx);
1535  ATH_CHECK( dEdxTrkHandle.record(std::make_unique<xAOD::TrigCompositeContainer>(), std::make_unique<xAOD::TrigCompositeAuxContainer>()) );
1536 
1537  SG::WriteHandle<xAOD::TrigCompositeContainer> dEdxHitHandle(m_dEdxHitKey, ctx);
1538  ATH_CHECK( dEdxHitHandle.record(std::make_unique<xAOD::TrigCompositeContainer>(), std::make_unique<xAOD::TrigCompositeAuxContainer>()) );
1539  }
1540  if( m_doDisappearingTrk ) {
1541  SG::WriteHandle<xAOD::TrigCompositeContainer> disTrkCandHandle(m_disTrkCandKey, ctx);
1542  ATH_CHECK( disTrkCandHandle.record(std::make_unique<xAOD::TrigCompositeContainer>(), std::make_unique<xAOD::TrigCompositeAuxContainer>()) );
1543  }
1544  return StatusCode::SUCCESS;
1545 }

◆ 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 1757 of file TrigFastTrackFinder.cxx.

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

◆ 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 2106 of file TrigFastTrackFinder.cxx.

2107 {
2108  Trk::TrackStates::const_iterator
2109  m = Tr->trackStateOnSurfaces()->begin(),
2110  me = Tr->trackStateOnSurfaces()->end ();
2111 
2112  double quality_pixel = 0. ;
2113  double quality_sct = 0. ;
2114 
2115  const double W = 17.;
2116 
2117  for(; m!=me; ++m) {
2118  const Trk::FitQualityOnSurface fq = (*m)->fitQualityOnSurface();
2119  if(!fq) continue;
2120 
2121  double x2 = fq.chiSquared();
2122  double q;
2123  if(fq.numberDoF() == 2) q = (1.2*(W-x2*.5));
2124  else q = (W-x2 );
2125  if(q < 0.) q = 0.;
2126 
2127  const Trk::MeasurementBase *measurement = (*m)->measurementOnTrack();
2128  if (measurement) {
2129  const InDet::PixelClusterOnTrack *pixclus = dynamic_cast<const InDet::PixelClusterOnTrack*>(measurement);
2130  if( pixclus !=0 ) quality_pixel += q;
2131  else quality_sct += q;
2132  }
2133  }
2134 
2135  //
2136  double quality = quality_pixel;
2137  quality -= quality_sct;
2138  if( quality < 0. ) quality = 0.;
2139 
2140  return quality;
2141 }

◆ disTrk_refit()

std::unique_ptr< Trk::Track > TrigFastTrackFinder::disTrk_refit ( Trk::Track *  t,
const EventContext &  ctx 
) const
private

Definition at line 2805 of file TrigFastTrackFinder.cxx.

2806 {
2807  std::unique_ptr<Trk::Track> newtrack = nullptr;
2808 
2809  if( t == nullptr ) return newtrack;
2810  if( t->trackSummary() == nullptr ) m_trackSummaryTool->updateTrack(ctx, *t);
2811 
2812  ATH_MSG_VERBOSE("refitting - input track:");
2813  print_disTrk(t);
2814 
2815  const Trk::Perigee* origPerigee = t->perigeeParameters();
2816  if( origPerigee == nullptr ) return newtrack;
2817  ATH_MSG_VERBOSE("... origPerigee is there");
2818 
2819  // remove SCT hits
2820  std::vector<const Trk::MeasurementBase*> vec;
2821  int n_measurements = 0;
2822  int n_measurements_refit = 0;
2823  const Trk::TrackStates* recoTrackStates = t->trackStateOnSurfaces();
2824  if (recoTrackStates) {
2825  Trk::TrackStates::const_iterator tsosIter = recoTrackStates->begin();
2826  Trk::TrackStates::const_iterator tsosIterEnd = recoTrackStates->end();
2827  for ( ; tsosIter != tsosIterEnd; ++tsosIter) {
2828  const Trk::MeasurementBase *measurement = (*tsosIter)->measurementOnTrack();
2829  if (measurement) {
2830  n_measurements++;
2831  const InDet::PixelClusterOnTrack *pixclus = dynamic_cast<const InDet::PixelClusterOnTrack*>(measurement);
2832  const InDet::SCT_ClusterOnTrack *sctclus = dynamic_cast<const InDet::SCT_ClusterOnTrack*>(measurement);
2833  bool to_add = true;
2834  if ( !pixclus && sctclus ) to_add = false;
2835  if( to_add ) {
2836  vec.push_back(measurement);
2837  n_measurements_refit++;
2838  }
2839  }
2840  }
2841  }
2842  ATH_MSG_VERBOSE("... Nr of measurments / refit = " << n_measurements << " / " << n_measurements_refit);
2843 
2844  // perform refit
2845  newtrack = m_disTrkFitter->fit(ctx,vec, *origPerigee, false, m_particleHypothesis); // false to run outlier switch
2846  ATH_MSG_VERBOSE("... ---> refit track:");
2847  if( newtrack!=0 && newtrack.get() ) {
2848  print_disTrk(dynamic_cast<const Trk::Track*>(newtrack.get()));
2849  }
2850  else {
2851  ATH_MSG_VERBOSE("... refit failed");
2852  }
2853 
2854  //
2855  return newtrack;
2856 }

◆ 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 403 of file TrigFastTrackFinder.cxx.

403  {
404 
405  SG::WriteHandle<TrackCollection> outputTracks(m_outputTracksKey, ctx);
406  outputTracks = std::make_unique<TrackCollection>();
407 
408  const TrackCollection* inputTracks = nullptr;
409  if (m_LRTmode) {
410  if (!m_inputTracksKey.key().empty()){
411  SG::ReadHandle<TrackCollection> inputTrackHandle(m_inputTracksKey, ctx);
412  ATH_CHECK(inputTrackHandle.isValid());
413  inputTracks = inputTrackHandle.ptr();
414  }
415  }
416  InDet::ExtendedSiTrackMakerEventData_xk trackEventData(m_prdToTrackMap, ctx);
417 
418  //RoI preparation/update
419 
420  if (m_standaloneMode) {
421  //the default fullscan TrigRoiDescriptor settings for beamspot width (z-range) are incorrect
422  const TrigRoiDescriptor internalRoI = TrigRoiDescriptor(0, -4.5, 4.5, 0, -M_PI, M_PI, 0, -150.0, 150.0);
423 
424  ATH_CHECK(findTracks(trackEventData, internalRoI, inputTracks, *outputTracks, ctx));
425 
426  } else {
427  SG::ReadHandle<TrigRoiDescriptorCollection> roiCollection(m_roiCollectionKey, ctx);
428 
429  ATH_CHECK(roiCollection.isValid());
430 
431  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" );
432 
433  if ( roiCollection->size()==0) {
434  ATH_MSG_ERROR("No Roi found for " << m_roiCollectionKey.key() );
435  return StatusCode::FAILURE;
436  }
437 
438  TrigRoiDescriptor internalRoI = **roiCollection->begin();
439 
440  ATH_CHECK(findTracks(trackEventData, internalRoI, inputTracks, *outputTracks, ctx));
441  }
442 
444 
446  m_countTotalRoI++;
447 
448  return StatusCode::SUCCESS;
449 }

◆ extractClusterIds()

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

Definition at line 1094 of file TrigFastTrackFinder.cxx.

1094  {
1095  const InDet::SiCluster* pCL = dynamic_cast<const InDet::SiCluster*>(pSP->clusterList().first);
1096  if(pCL!=nullptr) vIds.push_back(pCL->identify());
1097  //check second cluster : SCT uv clusters only !
1098  pCL = dynamic_cast<const InDet::SiCluster*>(pSP->clusterList().second);
1099  if(pCL!=nullptr) vIds.push_back(pCL->identify());
1100 }

◆ 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 EventContext &  ctx 
) const
private

Definition at line 2527 of file TrigFastTrackFinder.cxx.

2529 {
2530  float vtx_x = 0;
2531  float vtx_y = 0;
2532  float vtx_z = 9999;
2533  float trk_z0 = t->perigeeParameters()->parameters()[Trk::z0];
2534  float z0_min = 9999;
2535  for(unsigned int i_vtx=0; i_vtx<v_zvtx.size(); i_vtx++) {
2536  float z = v_zvtx[i_vtx];
2537  if( std::abs(trk_z0-z) < z0_min ) {
2538  z0_min = std::abs(trk_z0-z);
2539  vtx_z = z;
2540  vtx_x = v_xvtx[i_vtx];
2541  vtx_y = v_yvtx[i_vtx];
2542  }
2543  }
2544 
2545  Amg::Vector3D gp(vtx_x, vtx_y, vtx_z);
2546  Trk::PerigeeSurface persf(gp);
2547  std::unique_ptr<const Trk::TrackParameters> tmp =
2548  m_extrapolator->extrapolateDirectly(ctx, (*(t->perigeeParameters())), persf);
2549  if (tmp && tmp->associatedSurface().type() == Trk::SurfaceType::Perigee) {
2550  return tmp;
2551  }
2552  return nullptr;
2553 }

◆ 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 2582 of file TrigFastTrackFinder.cxx.

2583 {
2584  std::vector<Trk::Track*> vtmp;
2585  fillDisTrkCand(comp,prefix,trk,vertexPerigee,false,vtmp);
2586 }

◆ 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 2588 of file TrigFastTrackFinder.cxx.

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

◆ fillMon()

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

Definition at line 1125 of file TrigFastTrackFinder.cxx.

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

◆ 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 2338 of file TrigFastTrackFinder.cxx.

2339 {
2340  const int N_FREE_PIX_HITS_CUT = 2;
2341 
2342  std::set<const Trk::PrepRawData*> clusters;
2343 
2344  const Trk::PrepRawData* prd[100];
2345 
2346  std::sort(QT.begin(), QT.end(),
2347  [](const std::tuple<bool, double, Trk::Track*>& lhs, const std::tuple<bool, double, Trk::Track*>& rhs) {
2348  return std::get<1>(lhs) < std::get<1>(rhs); } );
2349 
2350  for (auto& q : QT) {
2351  DataVector<const Trk::MeasurementBase>::const_iterator
2352  m = std::get<2>(q)->measurementsOnTrack()->begin(),
2353  me = std::get<2>(q)->measurementsOnTrack()->end ();
2354 
2355  int nf = 0, nc = 0;
2356  for(; m!=me; ++m ) {
2357  const Trk::PrepRawData* pr = ((const Trk::RIO_OnTrack*)(*m))->prepRawData();
2358  if(pr) {
2359  const InDet::PixelClusterOnTrack *pixclus = dynamic_cast<const InDet::PixelClusterOnTrack*>((*m));
2360  if (pixclus) {
2361  ++nc;
2362  if(clusters.find(pr)==clusters.end()) {prd[nf++]=pr; if(nf==100) break;}
2363  }
2364  }
2365  }
2366  if((nf >= N_FREE_PIX_HITS_CUT) || (nf == nc) ) {
2367  for(int n=0; n!=nf; ++n) clusters.insert(prd[n]);
2368  }
2369  else {
2370  std::get<0>(q) = false;
2371  }
2372  }
2373 }

◆ filterSharedTracks()

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

Definition at line 1025 of file TrigFastTrackFinder.cxx.

1025  {
1026 
1027  std::set<const Trk::PrepRawData*> clusters;
1028 
1029  const Trk::PrepRawData* prd[100];
1030 
1031  std::sort(QT.begin(), QT.end(),
1032  [](const std::tuple<bool, double, Trk::Track*>& lhs, const std::tuple<bool, double, Trk::Track*>& rhs) {
1033  return std::get<1>(lhs) < std::get<1>(rhs); } );
1034 
1035  for (auto& q : QT) {
1036  DataVector<const Trk::MeasurementBase>::const_iterator
1037  m = std::get<2>(q)->measurementsOnTrack()->begin(),
1038  me = std::get<2>(q)->measurementsOnTrack()->end ();
1039 
1040  int nf = 0, nc = 0;
1041  for(; m!=me; ++m ) {
1042 
1043  const Trk::PrepRawData* pr = ((const Trk::RIO_OnTrack*)(*m))->prepRawData();
1044  if(pr) {
1045  ++nc;
1046  if(clusters.find(pr)==clusters.end()) {prd[nf++]=pr; if(nf==100) break;}
1047  }
1048  }
1049  if((nf >= m_nfreeCut) || (nf == nc) ) {
1050  for(int n=0; n!=nf; ++n) clusters.insert(prd[n]);
1051  }
1052  else {
1053  std::get<0>(q) = false;
1054  }
1055  }
1056 }

◆ finalize()

StatusCode TrigFastTrackFinder::finalize ( )
overridevirtual

Definition at line 1060 of file TrigFastTrackFinder.cxx.

1061 {
1062 
1063  ATH_MSG_INFO("=========================================================");
1064  ATH_MSG_INFO("TrigFastTrackFinder::finalize() - TrigFastTrackFinder Statistics: ");
1065  ATH_MSG_INFO("RoI processed: " << m_countTotalRoI);
1066  ATH_MSG_INFO("RoI with enough SPs : " << m_countRoIwithEnoughHits);
1067  ATH_MSG_INFO("RoI with Track(s) : " << m_countRoIwithTracks);
1068  ATH_MSG_INFO("=========================================================");
1069 
1070  return StatusCode::SUCCESS;
1071 }

◆ finddEdxTrk()

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

Definition at line 1668 of file TrigFastTrackFinder.cxx.

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

◆ 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 2375 of file TrigFastTrackFinder.cxx.

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

◆ 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 453 of file TrigFastTrackFinder.cxx.

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

◆ getDisTrkCategory()

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

Definition at line 2555 of file TrigFastTrackFinder.cxx.

2556 {
2557  const auto & result = getTrkBarrelLayerInfo(trk);
2558 
2559  int n_good_brlayers_pix = 0;
2560  int n_hits_sct = 0;
2561  for(unsigned int ily=0; ily<8; ily++) {
2562  if( ily<=3 && result[ily].nGood >= 1 ) n_good_brlayers_pix++;
2563  if( 4<=ily ) {
2564  n_hits_sct += result[ily].nHits;
2565  }
2566  }
2567  if( trk->trackSummary()!=0 ) { n_hits_sct = trk->trackSummary()->get(Trk::SummaryType::numberOfSCTHits); }
2568 
2569  // category
2570  DisTrkCategory cat = DisTrkCategory::Other;
2571  if( n_good_brlayers_pix == 4 ) {
2572  if( n_hits_sct==0 ) { cat=DisTrkCategory::Pix4l_Sct0; }
2573  else { cat=DisTrkCategory::Pix4l_Sct1p; }
2574  }
2575  else if( n_good_brlayers_pix == 3 ) {
2576  if( n_hits_sct==0 ) { cat=DisTrkCategory::Pix3l_Sct0; }
2577  else { cat=DisTrkCategory::Pix3l_Sct1p; }
2578  }
2579  return cat;
2580 }

◆ getSPLayer()

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

Definition at line 1548 of file TrigFastTrackFinder.cxx.

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

◆ getTrkBarrelLayerInfo()

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

Definition at line 2049 of file TrigFastTrackFinder.cxx.

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

◆ initialize()

StatusCode TrigFastTrackFinder::initialize ( )
overridevirtual

Definition at line 188 of file TrigFastTrackFinder.cxx.

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

◆ 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 1968 of file TrigFastTrackFinder.cxx.

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

◆ isClonable()

bool AthReentrantAlgorithm::isClonable ( ) const
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

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

Definition at line 44 of file AthReentrantAlgorithm.cxx.

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

◆ isGoodForDisTrackVertex()

bool TrigFastTrackFinder::isGoodForDisTrackVertex ( Trk::Track *  t,
const EventContext &  ctx 
) const
private

Definition at line 2288 of file TrigFastTrackFinder.cxx.

2289 {
2290  const double TRKCUT_CHI2_OV_NDOF = 3.0;
2291  const double TRKCUT_PT = 1.0;
2292  const double TRKCUT_D0 = 2.0;
2293  const int TRKCUT_N_HITS_INNER = 1;
2294  const int TRKCUT_N_HITS_PIX = 3;
2295  const int TRKCUT_N_HITS = 7;
2296 
2297  // sanity check
2298  if ( ! t->perigeeParameters() ) return false;
2299  if ( ! t->fitQuality() ) return false;
2300  if ( t->trackSummary()==0 ) {
2301  m_trackSummaryTool->updateTrack(ctx, *t);
2302  if ( t->trackSummary()==0 ) return false;
2303  }
2304 
2305  // chi2
2306  double chi2 = t->fitQuality()->chiSquared();
2307  double ndof = t->fitQuality()->doubleNumberDoF();
2308  if( std::abs(ndof) < 1e-2 ) return false;
2309  double chi2_ov_ndof = chi2/ndof;
2310  if( chi2_ov_ndof > TRKCUT_CHI2_OV_NDOF ) return false;
2311 
2312  // pt
2313  double theta = t->perigeeParameters()->parameters()[Trk::theta];
2314  double qOverP = std::abs(t->perigeeParameters()->parameters()[Trk::qOverP]);
2315  if ( qOverP < 1e-12 ) qOverP = 1e-12;
2316  double pt = std::sin(theta)/qOverP;
2317  pt /= 1000.0;
2318  if( pt < TRKCUT_PT ) return false;
2319 
2320  // d0
2321  double d0 = t->perigeeParameters()->parameters()[Trk::d0];
2322  if( std::abs(d0) > TRKCUT_D0 ) return false;
2323 
2324  // nr hits
2325  int n_hits_innermost = t->trackSummary()->get(Trk::SummaryType::numberOfInnermostPixelLayerHits);
2326  int n_hits_next_to_innermost = t->trackSummary()->get(Trk::SummaryType::numberOfNextToInnermostPixelLayerHits);
2327  int n_hits_inner = n_hits_innermost + n_hits_next_to_innermost;
2328  int n_hits_pix = t->trackSummary()->get(Trk::SummaryType::numberOfPixelHits);
2329  int n_hits_sct = t->trackSummary()->get(Trk::SummaryType::numberOfSCTHits);
2330  if( n_hits_inner < TRKCUT_N_HITS_INNER ) return false;
2331  if( n_hits_pix < TRKCUT_N_HITS_PIX ) return false;
2332  if( (n_hits_pix+n_hits_sct) < TRKCUT_N_HITS ) return false;
2333 
2334  // ok
2335  return true;
2336 }

◆ isPreselPassDisTrackAfterRefit()

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

Definition at line 2441 of file TrigFastTrackFinder.cxx.

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

◆ isPreselPassDisTrackBeforeRefit()

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

Definition at line 2488 of file TrigFastTrackFinder.cxx.

2489 {
2490  const double PRESEL_D0_WRTVTX = 5.0;
2491  const double PRESEL_Z0_WRTVTX = 50.0;
2492  const int PRESEL_N_GOOD_BR_LAYERS_PIX = 3;
2493  const double PRESEL_CHI2_OV_NDOF_PIX_BR_CUT = 5.0;
2494 
2495  // sanity check
2496  if( trk == nullptr ) return false;
2497  if( trk->perigeeParameters() == nullptr ) return false;
2498 
2499  // barrel hits
2500  const auto & barrelLayerInfo = getTrkBarrelLayerInfo(trk);
2501 
2502  // PIX cuts
2503  double chi2_pixbr = 0.0;
2504  int ndof_pixbr = 0;
2505  int n_good_brlayers_pix = 0;
2506  for(unsigned int ily=0; ily<=3; ily++) {
2507  if( barrelLayerInfo[ily].nGood >= 1 ) n_good_brlayers_pix++;
2508  chi2_pixbr += barrelLayerInfo[ily].chiSq;
2509  ndof_pixbr += barrelLayerInfo[ily].nDof;
2510  }
2511  if( n_good_brlayers_pix < PRESEL_N_GOOD_BR_LAYERS_PIX ) return false;
2512 
2513  if( ndof_pixbr < 1 ) return false;
2514  double chi2_ov_ndof_pixbr = chi2_pixbr / ndof_pixbr;
2515  if( chi2_ov_ndof_pixbr > PRESEL_CHI2_OV_NDOF_PIX_BR_CUT ) return false;
2516 
2517  // d0
2518  if( std::abs(d0_wrtVtx) > PRESEL_D0_WRTVTX ) return false;
2519 
2520  // z0
2521  if( std::abs(z0_wrtVtx) > PRESEL_Z0_WRTVTX ) return false;
2522 
2523  // cut passed
2524  return true;
2525 }

◆ makeSeedsOnGPU()

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

Definition at line 1500 of file TrigFastTrackFinder.cxx.

1501  {
1502 
1503  output.clear();
1504 
1505  TrigAccel::DATA_EXPORT_BUFFER* dataBuffer = new TrigAccel::DATA_EXPORT_BUFFER(5000);//i.e. 5KB
1506 
1507  size_t actualSize = m_accelTool->exportSeedMakingJob(tcs, roi, vsp, *dataBuffer);
1508 
1509  ATH_MSG_DEBUG("SeedMakingJob is ready, data size for transfer = " <<actualSize);
1510 
1511  std::shared_ptr<TrigAccel::OffloadBuffer> pBuff = std::make_shared<TrigAccel::OffloadBuffer>(dataBuffer);
1512 
1513  TrigAccel::Work* pJob = m_accelSvc->createWork(TrigAccel::InDetJobControlCode::MAKE_SEEDS, pBuff);
1514 
1515  if(pJob) {
1516  ATH_MSG_DEBUG("Work item created for task "<<TrigAccel::InDetJobControlCode::MAKE_SEEDS);
1517 
1518  pJob->run();
1519 
1520  std::shared_ptr<TrigAccel::OffloadBuffer> pOB = pJob->getOutput();
1521 
1522  int nTriplets = m_accelTool->extractTripletsFromOutput(pOB,vsp, output);
1523 
1524  ATH_MSG_DEBUG("Found "<<nTriplets<<" triplets on GPU");
1525  }
1526 
1527  delete pJob;
1528  delete dataBuffer;
1529 }

◆ 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 2858 of file TrigFastTrackFinder.cxx.

2859 {
2860  float chi2=0; float ndof=0; float d0=0; float z0=0; float phi=0; float theta=0; float pt=0;
2861  if( t!=nullptr ) {
2862  chi2 = t->fitQuality()->chiSquared();
2863  ndof = t->fitQuality()->doubleNumberDoF();
2864  d0 = t->perigeeParameters()->parameters()[Trk::d0];
2865  z0 = t->perigeeParameters()->parameters()[Trk::z0];
2866  phi = t->perigeeParameters()->parameters()[Trk::phi];
2867  theta = t->perigeeParameters()->parameters()[Trk::theta];
2868  float qOverP = std::abs(t->perigeeParameters()->parameters()[Trk::qOverP]);
2869  if ( qOverP < 1e-12 ) qOverP = 1e-12;
2870  pt = sin(theta)/qOverP;
2871  pt /= Gaudi::Units::GeV;
2872  }
2873  ATH_MSG_DEBUG("... pt / theta / phi / d0 / z0 = " << pt << " / " << theta << " / " << phi << " / " << d0 << " / " << z0);
2874  ATH_MSG_DEBUG("... chi2 / ndof = " << chi2 << " / " << ndof);
2875 }

◆ 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 EventContext &  ctx 
) const
private

Definition at line 2706 of file TrigFastTrackFinder.cxx.

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

◆ 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 2143 of file TrigFastTrackFinder.cxx.

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

◆ 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 1281 of file TrigFastTrackFinder.cxx.

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

◆ 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 377 of file TrigFastTrackFinder.cxx.

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

◆ 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 1002 of file TrigFastTrackFinder.cxx.

1002  {
1003 
1004  Trk::TrackStates::const_iterator
1005  m = Tr->trackStateOnSurfaces()->begin(),
1006  me = Tr->trackStateOnSurfaces()->end ();
1007 
1008  double quality = 0. ;
1009  const double W = 17.;
1010 
1011  for(; m!=me; ++m) {
1012  const Trk::FitQualityOnSurface fq = (*m)->fitQualityOnSurface();
1013  if(!fq) continue;
1014 
1015  double x2 = fq.chiSquared();
1016  double q;
1017  if(fq.numberDoF() == 2) q = (1.2*(W-x2*.5));
1018  else q = (W-x2 );
1019  if(q < 0.) q = 0.;
1020  quality+=q;
1021  }
1022  return quality;
1023 }

◆ updateClusterMap()

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

Definition at line 1073 of file TrigFastTrackFinder.cxx.

1073  {
1074  //loop over clusters
1075 
1076  for(auto tMOT = pTrack->measurementsOnTrack()->begin(); tMOT != pTrack->measurementsOnTrack()->end(); ++tMOT) {
1077 
1078  const InDet::SiClusterOnTrack* siCLOT = dynamic_cast<const InDet::SiClusterOnTrack*>(*tMOT);
1079  if (siCLOT==nullptr) continue;
1080  const InDet::SiCluster* siCL = dynamic_cast<const InDet::SiCluster*>(siCLOT->prepRawData());
1081  if (siCL==nullptr) continue;
1082 
1083  if(m_ITkMode) {
1084  //skip non-pixel clusters because all seeds are PPP in ITK mode
1085  const InDet::PixelCluster* pixCL = dynamic_cast<const InDet::PixelCluster*>(siCL);
1086  if(pixCL==nullptr) continue;
1087  }
1088 
1089  Identifier id = siCL->identify();
1090  clusterMap[id].push_back(trackIdx);
1091  }
1092 }

◆ 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 1102 of file TrigFastTrackFinder.cxx.

1102  {
1103 
1104  std::vector<long int> xSection;
1105  //initializing
1106  std::map<Identifier, std::vector<long int> >::iterator itm0 = clusterMap.find(*vIds.begin());
1107  if(itm0 == clusterMap.end()) return false;
1108  xSection.reserve((*itm0).second.size());
1109  std::copy((*itm0).second.begin(), (*itm0).second.end(), std::back_inserter(xSection));
1110  std::vector<Identifier>::const_iterator it = vIds.begin();++it;
1111  for(;it!=vIds.end();++it) {
1112  std::map<Identifier, std::vector<long int> >::iterator itm1 = clusterMap.find(*it);
1113  if(itm1 == clusterMap.end()) return false;
1114  std::vector<long int> tmp;
1115  std::set_intersection(xSection.begin(), xSection.end(), (*itm1).second.begin(),(*itm1).second.end(), std::back_inserter(tmp));
1116  if(tmp.empty()) return false;
1117  //update xSection
1118  xSection.clear();
1119  xSection.reserve(tmp.size());
1120  std::copy(tmp.begin(), tmp.end(), std::back_inserter(xSection));
1121  }
1122  return !xSection.empty();
1123 }

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_connectionFile

std::string TrigFastTrackFinder::m_connectionFile
private

Definition at line 234 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 279 of file TrigFastTrackFinder.h.

◆ m_dodEdxTrk

bool TrigFastTrackFinder::m_dodEdxTrk
private

Definition at line 243 of file TrigFastTrackFinder.h.

◆ m_doDisappearingTrk

bool TrigFastTrackFinder::m_doDisappearingTrk
private

Definition at line 250 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 280 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 275 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 276 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 278 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 281 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:23
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
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:132
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.
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
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:453
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
TrigFastTrackFinder::filterSharedDisTracks
void filterSharedDisTracks(std::vector< std::tuple< bool, double, Trk::Track * >> &) const
Definition: TrigFastTrackFinder.cxx:2338
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
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:37
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:38
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:83
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:1757
plotBeamSpotCompare.x2
x2
Definition: plotBeamSpotCompare.py:218
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:75
TrigFastTrackFinder::m_doTrackRefit
Gaudi::Property< bool > m_doTrackRefit
Definition: TrigFastTrackFinder.h:280
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:1500
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:396
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:279
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:64
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:276
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:1094
Region::PixEndcap
@ PixEndcap
TrigFastTrackFinder::Pix3l_Sct1p
@ Pix3l_Sct1p
Definition: TrigFastTrackFinder.h:122
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
TrigCombinatorialSettings::m_maxEC_len
float m_maxEC_len
Definition: TrigCombinatorialSettings.h:82
TrigFastTrackFinder::m_doDisappearingTrk
bool m_doDisappearingTrk
Definition: TrigFastTrackFinder.h:250
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:1073
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
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
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:2555
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
TrigFastTrackFinder::disTrk_refit
std::unique_ptr< Trk::Track > disTrk_refit(Trk::Track *t, const EventContext &ctx) const
Definition: TrigFastTrackFinder.cxx:2805
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:1281
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:182
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:183
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:85
z
#define z
TrigFastTrackFinder::m_vertexSeededMode
bool m_vertexSeededMode
Definition: TrigFastTrackFinder.h:172
TrigCombinatorialSettings::m_seedRadBinWidth
float m_seedRadBinWidth
Definition: TrigCombinatorialSettings.h:60
beamspotman.n
n
Definition: beamspotman.py:731
Trk::theta
@ theta
Definition: ParamDefs.h:66
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:1668
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:1102
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
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:2106
TrigFastTrackFinder::m_dodEdxTrk
bool m_dodEdxTrk
Definition: TrigFastTrackFinder.h:243
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:2375
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:275
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:1002
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
TrigFastTrackFinder::m_connectionFile
std::string m_connectionFile
Definition: TrigFastTrackFinder.h:234
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
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:2858
TrigFastTrackFinder::isPreselPassDisTrackBeforeRefit
bool isPreselPassDisTrackBeforeRefit(Trk::Track *, double, double) const
Definition: TrigFastTrackFinder.cxx:2488
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:220
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
Trk::d0
@ d0
Definition: ParamDefs.h:63
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:538
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:1125
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
TrigFastTrackFinder::isGoodForDisTrackVertex
bool isGoodForDisTrackVertex(Trk::Track *, const EventContext &) const
Definition: TrigFastTrackFinder.cxx:2288
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:2582
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
TrigFastTrackFinder::m_countTotalRoI
std::atomic< unsigned int > m_countTotalRoI
Definition: TrigFastTrackFinder.h:207
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::Pix3l_Sct0
@ Pix3l_Sct0
Definition: TrigFastTrackFinder.h:121
TrigFastTrackFinder::createEmptyUTTEDMs
StatusCode createEmptyUTTEDMs(const EventContext &) const
Definition: TrigFastTrackFinder.cxx:1531
TrigFastTrackFinder::m_countRoIwithTracks
std::atomic< unsigned int > m_countRoIwithTracks
Definition: TrigFastTrackFinder.h:209
Trk::RIO_OnTrack::identify
Identifier identify() const
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:152
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:2441
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:67
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
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
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 EventContext &) const
Definition: TrigFastTrackFinder.cxx:2706
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
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
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:1025
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:75
TrigRoiDescriptor
Athena::TPCnvVers::Current TrigRoiDescriptor
Definition: TrigSteeringEventTPCnv.cxx:68
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
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:281
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:2049
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:278
TrigFastTrackFinder::isCleaningPassDisTrack
bool isCleaningPassDisTrack(const TrigInDetTriplet &, Trk::Track *, bool) const
Definition: TrigFastTrackFinder.cxx:1968
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:2143
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:65
TrigFastTrackFinder::extrapolateDisTrackToBS
std::unique_ptr< const Trk::TrackParameters > extrapolateDisTrackToBS(Trk::Track *, const std::vector< double > &, const std::vector< double > &, const std::vector< double > &, const EventContext &) const
Definition: TrigFastTrackFinder.cxx:2527
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 >
Identifier
Definition: IdentifierFieldParser.cxx:14
RoiDescriptor::zedPlus
virtual double zedPlus() const override final
z at the most forward end of the RoI
Definition: RoiDescriptor.h:112
Generated on Thu Nov 7 2024 22:03:12 for ATLAS Offline Software by   doxygen 1.8.18