ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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
 
ToolHandle< ITrigInDetTrackSeedingTool > m_seedingTool {this, "TrackSeedingTool", ""}
 
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 96 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 117 of file TrigFastTrackFinder.h.

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

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

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

◆ ~TrigFastTrackFinder()

TrigFastTrackFinder::~TrigFastTrackFinder ( )
virtual

Definition at line 180 of file TrigFastTrackFinder.cxx.

180 {}

Member Function Documentation

◆ calcdEdx()

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

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality
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 75 of file AthCommonReentrantAlgorithm.cxx.

64 {
65  return 0;
66 }

◆ createEmptyUTTEDMs()

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

Definition at line 1518 of file TrigFastTrackFinder.cxx.

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

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ dEdx()

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

Definition at line 1744 of file TrigFastTrackFinder.cxx.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ disTrackQuality()

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

Definition at line 2093 of file TrigFastTrackFinder.cxx.

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

◆ disTrk_refit()

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

Definition at line 2792 of file TrigFastTrackFinder.cxx.

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

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

385  {
386 
387  SG::WriteHandle<TrackCollection> outputTracks(m_outputTracksKey, ctx);
388 
389  outputTracks = std::make_unique<TrackCollection>();
390 
391  const TrackCollection* inputTracks = nullptr;
392  if (m_LRTmode) {
393  if (!m_inputTracksKey.key().empty()){
394  SG::ReadHandle<TrackCollection> inputTrackHandle(m_inputTracksKey, ctx);
395  ATH_CHECK(inputTrackHandle.isValid());
396  inputTracks = inputTrackHandle.ptr();
397  }
398  }
399  InDet::ExtendedSiTrackMakerEventData_xk trackEventData(m_prdToTrackMap, ctx);
400 
401  //RoI preparation/update
402 
403  if (m_standaloneMode) {
404  //the default fullscan TrigRoiDescriptor settings for beamspot width (z-range) are incorrect
405  const TrigRoiDescriptor internalRoI = TrigRoiDescriptor(0, -4.5, 4.5, 0, -M_PI, M_PI, 0, -150.0, 150.0);
406 
407  ATH_CHECK(findTracks(trackEventData, internalRoI, inputTracks, *outputTracks, ctx));
408 
409  } else {
410  SG::ReadHandle<TrigRoiDescriptorCollection> roiCollection(m_roiCollectionKey, ctx);
411 
412  ATH_CHECK(roiCollection.isValid());
413 
414  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" );
415 
416  if ( roiCollection->size()==0) {
417  ATH_MSG_ERROR("No Roi found for " << m_roiCollectionKey.key() );
418  return StatusCode::FAILURE;
419  }
420 
421  TrigRoiDescriptor internalRoI = **roiCollection->begin();
422 
423  ATH_CHECK(findTracks(trackEventData, internalRoI, inputTracks, *outputTracks, ctx));
424  }
425 
427 
429  m_countTotalRoI++;
430 
431  return StatusCode::SUCCESS;
432 }

◆ extractClusterIds()

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

Definition at line 1081 of file TrigFastTrackFinder.cxx.

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

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

90 {
91  // If we didn't find any symlinks to add, just return the collection
92  // from the base class. Otherwise, return the extended collection.
93  if (!m_extendedExtraObjects.empty()) {
94  return m_extendedExtraObjects;
95  }
96  return BaseAlg::extraOutputDeps();
97 }

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

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

◆ fillDisTrkCand() [1/2]

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

Definition at line 2569 of file TrigFastTrackFinder.cxx.

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

◆ fillDisTrkCand() [2/2]

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

Definition at line 2575 of file TrigFastTrackFinder.cxx.

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

◆ fillMon()

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

Definition at line 1112 of file TrigFastTrackFinder.cxx.

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

◆ filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

96  {
97  return execState( ctx ).filterPassed();
98  }

◆ filterSharedDisTracks()

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

Definition at line 2325 of file TrigFastTrackFinder.cxx.

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

◆ filterSharedTracks()

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

Definition at line 1012 of file TrigFastTrackFinder.cxx.

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

◆ finalize()

StatusCode TrigFastTrackFinder::finalize ( )
overridevirtual

Definition at line 1047 of file TrigFastTrackFinder.cxx.

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

◆ finddEdxTrk()

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

Definition at line 1655 of file TrigFastTrackFinder.cxx.

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

◆ findDisTracks()

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

Definition at line 2362 of file TrigFastTrackFinder.cxx.

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

◆ findTracks()

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

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

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

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

◆ getDisTrkCategory()

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

Definition at line 2542 of file TrigFastTrackFinder.cxx.

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

◆ getSPLayer()

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

Definition at line 1535 of file TrigFastTrackFinder.cxx.

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

◆ getTrkBarrelLayerInfo()

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

Definition at line 2036 of file TrigFastTrackFinder.cxx.

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

◆ initialize()

StatusCode TrigFastTrackFinder::initialize ( )
overridevirtual

Definition at line 184 of file TrigFastTrackFinder.cxx.

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

◆ inputHandles()

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

Return this algorithm's input handles.

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

◆ isCleaningPassDisTrack()

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

Definition at line 1955 of file TrigFastTrackFinder.cxx.

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

◆ isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

52 {
53  // Reentrant algorithms are clonable.
54  return true;
55 }

◆ isGoodForDisTrackVertex()

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

Definition at line 2275 of file TrigFastTrackFinder.cxx.

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

◆ isPreselPassDisTrackAfterRefit()

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

Definition at line 2428 of file TrigFastTrackFinder.cxx.

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

◆ isPreselPassDisTrackBeforeRefit()

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

Definition at line 2475 of file TrigFastTrackFinder.cxx.

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

◆ makeSeedsOnGPU()

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

Definition at line 1487 of file TrigFastTrackFinder.cxx.

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

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ print_disTrk()

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

Definition at line 2845 of file TrigFastTrackFinder.cxx.

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

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

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

◆ recoVertexForDisTrack()

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

Definition at line 2130 of file TrigFastTrackFinder.cxx.

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

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ runResidualMonitoring()

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

Definition at line 1268 of file TrigFastTrackFinder.cxx.

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

◆ setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

100  {
101  execState( ctx ).setFilterPassed( state );
102  }

◆ start()

StatusCode TrigFastTrackFinder::start ( )
overridevirtual

Definition at line 364 of file TrigFastTrackFinder.cxx.

365 {
366  //getting magic numbers from the layer numbering tool
367 
368  m_tcs.m_maxBarrelPix = m_numberingTool->offsetBarrelSCT();
369  m_tcs.m_minEndcapPix = m_numberingTool->offsetEndcapPixels();
370  m_tcs.m_maxEndcapPix = m_numberingTool->offsetEndcapSCT();
371  m_tcs.m_maxSiliconLayer = m_numberingTool->maxSiliconLayerNum();
372  m_tcs.m_layerGeometry.clear();
373 
374  if(m_useNewLayerNumberScheme) {
375  const std::vector<TrigInDetSiLayer>* pVL = m_numberingTool->layerGeometry();
376  std::copy(pVL->begin(),pVL->end(),std::back_inserter(m_tcs.m_layerGeometry));
377  }
378 
379  m_tcs.m_tripletPtMin = m_tripletMinPtFrac*m_pTmin;
380 
381  return StatusCode::SUCCESS;
382 }

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 85 of file AthCommonReentrantAlgorithm.cxx.

77 {
78  return BaseAlg::sysExecute (ctx);
79 }

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 61 of file AthCommonReentrantAlgorithm.cxx.

107  {
108  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
109 
110  if (sc.isFailure()) {
111  return sc;
112  }
113 
114  ServiceHandle<ICondSvc> cs("CondSvc",name());
115  for (auto h : outputHandles()) {
116  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
117  // do this inside the loop so we don't create the CondSvc until needed
118  if ( cs.retrieve().isFailure() ) {
119  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
120  return StatusCode::SUCCESS;
121  }
122  if (cs->regHandle(this,*h).isFailure()) {
123  sc = StatusCode::FAILURE;
124  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
125  << " with CondSvc");
126  }
127  }
128  }
129  return sc;
130 }

◆ sysStart()

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

Handle START transition.

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

◆ trackQuality()

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

Definition at line 989 of file TrigFastTrackFinder.cxx.

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

◆ updateClusterMap()

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

Definition at line 1060 of file TrigFastTrackFinder.cxx.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

◆ usedByAnyTrack()

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

Definition at line 1089 of file TrigFastTrackFinder.cxx.

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

Member Data Documentation

◆ m_accelSvc

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

Definition at line 155 of file TrigFastTrackFinder.h.

◆ m_accelTool

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

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

◆ m_checkSeedRedundancy

bool TrigFastTrackFinder::m_checkSeedRedundancy
private

Definition at line 196 of file TrigFastTrackFinder.h.

◆ m_connectionFile

std::string TrigFastTrackFinder::m_connectionFile
private

Definition at line 235 of file TrigFastTrackFinder.h.

◆ m_countRoIwithEnoughHits

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

Definition at line 209 of file TrigFastTrackFinder.h.

◆ m_countRoIwithTracks

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

Definition at line 210 of file TrigFastTrackFinder.h.

◆ m_countTotalRoI

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

Definition at line 208 of file TrigFastTrackFinder.h.

◆ m_dEdxHitKey

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

Definition at line 166 of file TrigFastTrackFinder.h.

◆ m_dEdxTrkKey

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

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

◆ m_disTrkFitter

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

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

◆ m_dodEdxTrk

bool TrigFastTrackFinder::m_dodEdxTrk
private

Definition at line 244 of file TrigFastTrackFinder.h.

◆ m_doDisappearingTrk

bool TrigFastTrackFinder::m_doDisappearingTrk
private

Definition at line 251 of file TrigFastTrackFinder.h.

◆ m_doFastZVseeding

bool TrigFastTrackFinder::m_doFastZVseeding
private

Definition at line 180 of file TrigFastTrackFinder.h.

◆ m_doResMonitoring

bool TrigFastTrackFinder::m_doResMonitoring
private

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

◆ m_doZFinder

bool TrigFastTrackFinder::m_doZFinder
private

Definition at line 175 of file TrigFastTrackFinder.h.

◆ m_doZFinderOnly

bool TrigFastTrackFinder::m_doZFinderOnly
private

Definition at line 176 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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_extrapolator

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

Definition at line 150 of file TrigFastTrackFinder.h.

◆ m_idHelper

const AtlasDetectorID* TrigFastTrackFinder::m_idHelper
private

Definition at line 214 of file TrigFastTrackFinder.h.

◆ m_initialD0Max

float TrigFastTrackFinder::m_initialD0Max
private

Definition at line 194 of file TrigFastTrackFinder.h.

◆ m_inputTracksKey

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

Definition at line 159 of file TrigFastTrackFinder.h.

◆ m_ITkMode

bool TrigFastTrackFinder::m_ITkMode
private

Definition at line 276 of file TrigFastTrackFinder.h.

◆ m_LRTD0Min

float TrigFastTrackFinder::m_LRTD0Min
private

Definition at line 231 of file TrigFastTrackFinder.h.

◆ m_LRTHardMinPt

float TrigFastTrackFinder::m_LRTHardMinPt
private

Definition at line 232 of file TrigFastTrackFinder.h.

◆ m_LRTmode

bool TrigFastTrackFinder::m_LRTmode
private

Definition at line 230 of file TrigFastTrackFinder.h.

◆ m_minHits

int TrigFastTrackFinder::m_minHits
private

Definition at line 187 of file TrigFastTrackFinder.h.

◆ m_monTool

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

Definition at line 149 of file TrigFastTrackFinder.h.

◆ m_nfreeCut

int TrigFastTrackFinder::m_nfreeCut
private

Definition at line 189 of file TrigFastTrackFinder.h.

◆ m_numberingTool

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

Definition at line 143 of file TrigFastTrackFinder.h.

◆ m_outputTracksKey

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

Definition at line 160 of file TrigFastTrackFinder.h.

◆ m_particleHypothesis

Trk::ParticleHypothesis TrigFastTrackFinder::m_particleHypothesis
private

Definition at line 217 of file TrigFastTrackFinder.h.

◆ m_pixelId

const PixelID* TrigFastTrackFinder::m_pixelId
private

Definition at line 212 of file TrigFastTrackFinder.h.

◆ m_prdToTrackMap

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

Definition at line 162 of file TrigFastTrackFinder.h.

◆ m_pTmin

float TrigFastTrackFinder::m_pTmin
private

Definition at line 193 of file TrigFastTrackFinder.h.

◆ m_roiCollectionKey

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

Definition at line 158 of file TrigFastTrackFinder.h.

◆ m_sctId

const SCT_ID* TrigFastTrackFinder::m_sctId
private

Definition at line 213 of file TrigFastTrackFinder.h.

◆ m_seedingTool

ToolHandle<ITrigInDetTrackSeedingTool> TrigFastTrackFinder::m_seedingTool {this, "TrackSeedingTool", ""}
private

Definition at line 279 of file TrigFastTrackFinder.h.

◆ m_spacePointTool

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

Definition at line 144 of file TrigFastTrackFinder.h.

◆ m_standaloneMode

bool TrigFastTrackFinder::m_standaloneMode
private

Definition at line 277 of file TrigFastTrackFinder.h.

◆ m_storeZFinderVertices

bool TrigFastTrackFinder::m_storeZFinderVertices
private

Definition at line 178 of file TrigFastTrackFinder.h.

◆ m_tcs

TrigCombinatorialSettings TrigFastTrackFinder::m_tcs
private

Definition at line 185 of file TrigFastTrackFinder.h.

◆ m_trackMaker

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

Definition at line 145 of file TrigFastTrackFinder.h.

◆ m_trackSummaryTool

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

Definition at line 148 of file TrigFastTrackFinder.h.

◆ m_trigInDetTrackFitter

ToolHandle<ITrigInDetTrackFitter> TrigFastTrackFinder::m_trigInDetTrackFitter
private

Definition at line 146 of file TrigFastTrackFinder.h.

◆ m_trigseedML_LUT

std::string TrigFastTrackFinder::m_trigseedML_LUT
private

Definition at line 234 of file TrigFastTrackFinder.h.

◆ m_trigZFinder

ToolHandle<ITrigZFinder> TrigFastTrackFinder::m_trigZFinder
private

Definition at line 147 of file TrigFastTrackFinder.h.

◆ m_tripletMinPtFrac

float TrigFastTrackFinder::m_tripletMinPtFrac
private

Definition at line 192 of file TrigFastTrackFinder.h.

◆ m_useBeamSpot

bool TrigFastTrackFinder::m_useBeamSpot
private

Definition at line 171 of file TrigFastTrackFinder.h.

◆ m_useEtaBinning

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

Definition at line 281 of file TrigFastTrackFinder.h.

◆ m_useGPU

bool TrigFastTrackFinder::m_useGPU
private

Definition at line 223 of file TrigFastTrackFinder.h.

◆ m_useNewLayerNumberScheme

bool TrigFastTrackFinder::m_useNewLayerNumberScheme
private

Definition at line 219 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 284 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 173 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 195 of file TrigFastTrackFinder.h.

◆ N_BARREL_LAYERS

constexpr size_t TrigFastTrackFinder::N_BARREL_LAYERS {8}
staticconstexprprotected

Definition at line 127 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:68
TrigFastTrackFinder::m_disTrkCandKey
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_disTrkCandKey
Definition: TrigFastTrackFinder.h:167
TrigFastTrackFinder::m_LRTHardMinPt
float m_LRTHardMinPt
Definition: TrigFastTrackFinder.h:232
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:144
TrigFastTrackFinder::DisTrkCategory
DisTrkCategory
Definition: TrigFastTrackFinder.h:118
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:134
TrigInDetTrackSeedingResult::m_nStripSPs
int m_nStripSPs
Definition: TrigInDetTrackSeedingResult.h:12
Region::SctBarrel
@ SctBarrel
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
TrigAccel::DataExportBuffer
Definition: DataExportBuffer.h:14
TrigFastTrackFinder::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: TrigFastTrackFinder.h:149
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:193
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
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TrigCombinatorialSettings::m_zvErrorEndcap
float m_zvErrorEndcap
Definition: TrigCombinatorialSettings.h:72
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:436
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:2325
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
TrigFastTrackFinder::m_idHelper
const AtlasDetectorID * m_idHelper
Definition: TrigFastTrackFinder.h:214
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:59
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:67
ParticleGun_SamplingFraction.bec
int bec
Definition: ParticleGun_SamplingFraction.py:89
TrigCombinatorialSettings::m_maxSiliconLayer
int m_maxSiliconLayer
Definition: TrigCombinatorialSettings.h:52
TrigFastTrackFinder::m_trigInDetTrackFitter
ToolHandle< ITrigInDetTrackFitter > m_trigInDetTrackFitter
Definition: TrigFastTrackFinder.h:146
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:119
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
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:155
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:196
IRoiDescriptor::etaMinus
virtual double etaMinus() const =0
TrigFastTrackFinder::m_outputTracksKey
SG::WriteHandleKey< TrackCollection > m_outputTracksKey
Definition: TrigFastTrackFinder.h:160
CxxUtils::wrapToPi
T wrapToPi(T phi)
Wrap angle in radians to [-pi, pi].
Definition: phihelper.h:24
InDetAccessor::phi0
@ phi0
Definition: InDetAccessor.h:33
TrigFastTrackFinder::dEdx
float dEdx(const Trk::Track *, int &, int &, std::vector< float > &, std::vector< float > &, std::vector< float > &, std::vector< float > &, std::vector< int > &, std::vector< int > &, std::vector< int > &) const
Definition: TrigFastTrackFinder.cxx:1744
plotBeamSpotCompare.x2
x2
Definition: plotBeamSpotCompare.py:218
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:75
TrigFastTrackFinder::m_doTrackRefit
Gaudi::Property< bool > m_doTrackRefit
Definition: TrigFastTrackFinder.h:283
TrigCombinatorialSettings::m_maxBarrelPix
int m_maxBarrelPix
Definition: TrigCombinatorialSettings.h:52
TrigFastTrackFinder::makeSeedsOnGPU
void makeSeedsOnGPU(const TrigCombinatorialSettings &, const IRoiDescriptor *, const std::vector< TrigSiSpacePointBase > &, std::vector< TrigInDetTriplet > &) const
Definition: TrigFastTrackFinder.cxx:1487
AthCommonDataStore::renounce
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)
Definition: AthCommonDataStore.h:380
TrigAccel::Work::getOutput
virtual std::shared_ptr< OffloadBuffer > getOutput()=0
skel.it
it
Definition: skel.GENtoEVGEN.py:407
TrigCombinatorialSettings::m_layerGeometry
std::vector< TrigInDetSiLayer > m_layerGeometry
Definition: TrigCombinatorialSettings.h:76
test_pyathena.pt
pt
Definition: test_pyathena.py:11
TrigFastTrackFinder::m_doCloneRemoval
Gaudi::Property< bool > m_doCloneRemoval
Definition: TrigFastTrackFinder.h:282
M_PI
#define M_PI
Definition: ActiveFraction.h:11
TrigCombinatorialSettings::m_curv_delta
float m_curv_delta
Definition: TrigCombinatorialSettings.h:65
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:151
Trk::z0
@ z0
Definition: ParamDefs.h:64
TrigCombinatorialSettings::m_LRTmode
bool m_LRTmode
Definition: TrigCombinatorialSettings.h:73
RoiDescriptor::size
virtual unsigned size() const override final
number of constituents
Definition: RoiDescriptor.h:145
TrigCombinatorialSettings::m_tripletPtMin
float m_tripletPtMin
Definition: TrigCombinatorialSettings.h:60
TrigFastTrackFinder::Pix4l_Sct0
@ Pix4l_Sct0
Definition: TrigFastTrackFinder.h:120
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:260
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:175
TrigFastTrackFinder::m_extrapolator
ToolHandle< Trk::IExtrapolator > m_extrapolator
Definition: TrigFastTrackFinder.h:150
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:9
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:64
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:277
InDetAccessor::qOverP
@ qOverP
perigee
Definition: InDetAccessor.h:35
TrigFastTrackFinder::m_inputTracksKey
SG::ReadHandleKey< TrackCollection > m_inputTracksKey
Definition: TrigFastTrackFinder.h:159
xAOD::int16_t
setScaleOne setStatusOne setSaturated int16_t
Definition: gFexGlobalRoI_v1.cxx:55
TrigFastTrackFinder::m_useGPU
bool m_useGPU
Definition: TrigFastTrackFinder.h:223
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
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
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:74
TrigFastTrackFinder::extractClusterIds
void extractClusterIds(const Trk::SpacePoint *, std::vector< Identifier > &) const
Definition: TrigFastTrackFinder.cxx:1081
Region::PixEndcap
@ PixEndcap
TrigFastTrackFinder::Pix3l_Sct1p
@ Pix3l_Sct1p
Definition: TrigFastTrackFinder.h:123
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
TrigCombinatorialSettings::m_maxEC_len
float m_maxEC_len
Definition: TrigCombinatorialSettings.h:80
TrigFastTrackFinder::m_doDisappearingTrk
bool m_doDisappearingTrk
Definition: TrigFastTrackFinder.h:251
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:71
IRoiDescriptor::eta
virtual double eta() const =0
trackInfo::eta
float eta
Definition: TrigInDetUtils.h:15
AthCommonReentrantAlgorithm::extraOutputDeps
virtual const DataObjIDColl & extraOutputDeps() const override
Return the list of extra output dependencies.
Definition: AthCommonReentrantAlgorithm.cxx:89
TrigFastTrackFinder::updateClusterMap
void updateClusterMap(long int, const Trk::Track *, std::map< Identifier, std::vector< long int > > &) const
Definition: TrigFastTrackFinder.cxx:1060
TrigFastTrackFinder::m_initialD0Max
float m_initialD0Max
Definition: TrigFastTrackFinder.h:194
TrigFastTrackFinder::m_dEdxTrkKey
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_dEdxTrkKey
Definition: TrigFastTrackFinder.h:165
TrigFastTrackFinder::m_LRTmode
bool m_LRTmode
Definition: TrigFastTrackFinder.h:230
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
TrigCombinatorialSettings::m_doublet_dR_Max
float m_doublet_dR_Max
Definition: TrigCombinatorialSettings.h:55
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
TrigFastTrackFinder::getDisTrkCategory
TrigFastTrackFinder::DisTrkCategory getDisTrkCategory(Trk::Track *trk) const
Definition: TrigFastTrackFinder.cxx:2542
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
RoiDescriptor::push_back
void push_back(const IRoiDescriptor *roi)
add a RoiDescriptor
Definition: RoiDescriptor.h:157
TrigFastTrackFinder::disTrk_refit
std::unique_ptr< Trk::Track > disTrk_refit(Trk::Track *t, const EventContext &ctx) const
Definition: TrigFastTrackFinder.cxx:2792
TrigFastTrackFinder::runResidualMonitoring
void runResidualMonitoring(const Trk::Track &track, const EventContext &) const
Definition: TrigFastTrackFinder.cxx:1268
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py: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:190
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:209
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
TrigFastTrackFinder::m_vertexSeededMode
bool m_vertexSeededMode
Definition: TrigFastTrackFinder.h:173
TrigCombinatorialSettings::m_seedRadBinWidth
float m_seedRadBinWidth
Definition: TrigCombinatorialSettings.h:61
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:63
ReweightUtils.category
category
Definition: ReweightUtils.py:15
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
TrigFastTrackFinder::finddEdxTrk
StatusCode finddEdxTrk(const EventContext &, const TrackCollection &) const
Definition: TrigFastTrackFinder.cxx:1655
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
Trk::pion
@ pion
Definition: ParticleHypothesis.h:29
TrigFastTrackFinder::m_tcs
TrigCombinatorialSettings m_tcs
Definition: TrigFastTrackFinder.h:185
TrigFastTrackFinder::usedByAnyTrack
bool usedByAnyTrack(const std::vector< Identifier > &, std::map< Identifier, std::vector< long int > > &) const
Definition: TrigFastTrackFinder.cxx:1089
TileDCSDataPlotter.pr
pr
Definition: TileDCSDataPlotter.py:922
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:525
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:195
TrigFastTrackFinder::Pix4l_Sct1p
@ Pix4l_Sct1p
Definition: TrigFastTrackFinder.h:121
TrigFastTrackFinder::m_useBeamSpot
bool m_useBeamSpot
Definition: TrigFastTrackFinder.h:171
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:2093
TrigFastTrackFinder::m_dodEdxTrk
bool m_dodEdxTrk
Definition: TrigFastTrackFinder.h:244
TrigFastTrackFinder::findDisTracks
StatusCode findDisTracks(const EventContext &, TrackCollection &, std::vector< std::tuple< bool, double, Trk::Track * >> &, std::vector< std::tuple< bool, double, Trk::Track * >> &, TrackCollection &, const std::vector< double > &, const std::vector< double > &, const std::vector< double > &) const
Definition: TrigFastTrackFinder.cxx:2362
TrigFastTrackFinder::m_roiCollectionKey
SG::ReadHandleKey< TrigRoiDescriptorCollection > m_roiCollectionKey
Definition: TrigFastTrackFinder.h:158
TrigCombinatorialSettings::m_maxTripletBufferLength
unsigned int m_maxTripletBufferLength
Definition: TrigCombinatorialSettings.h:69
trackInfo
Definition: TrigInDetUtils.h:13
TrigFastTrackFinder::m_ITkMode
bool m_ITkMode
Definition: TrigFastTrackFinder.h:276
SCT
Definition: SCT_ChipUtils.h:14
TrigCombinatorialSettings::m_tripletDoPSS
bool m_tripletDoPSS
Definition: TrigCombinatorialSettings.h:62
TrigFastTrackFinder::trackQuality
double trackQuality(const Trk::Track *Tr) const
Definition: TrigFastTrackFinder.cxx:989
TrigFastTrackFinder::m_nfreeCut
int m_nfreeCut
Definition: TrigFastTrackFinder.h:189
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:231
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:235
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:148
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
TrigFastTrackFinder::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
Definition: TrigFastTrackFinder.h:198
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
TrigFastTrackFinder::m_seedingTool
ToolHandle< ITrigInDetTrackSeedingTool > m_seedingTool
Definition: TrigFastTrackFinder.h:279
xAOD::numberOfNextToInnermostPixelLayerHits
@ numberOfNextToInnermostPixelLayerHits
these are the hits in the 1st pixel barrel layer
Definition: TrackingPrimitives.h:249
Trk::SurfaceType::Perigee
@ Perigee
trackInfo::a0beam
float a0beam
Definition: TrigInDetUtils.h:15
TrigCombinatorialSettings::m_useTrigSeedML
int m_useTrigSeedML
Definition: TrigCombinatorialSettings.h:78
TrigFastTrackFinder::m_trackMaker
ToolHandle< InDet::ISiTrackMaker > m_trackMaker
Definition: TrigFastTrackFinder.h:145
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:2845
TrigFastTrackFinder::isPreselPassDisTrackBeforeRefit
bool isPreselPassDisTrackBeforeRefit(Trk::Track *, double, double) const
Definition: TrigFastTrackFinder.cxx:2475
TrigFastTrackFinder::m_accelTool
ToolHandle< ITrigInDetAccelerationTool > m_accelTool
Definition: TrigFastTrackFinder.h:154
RoiDescriptor::zed
virtual double zed() const override final
Definition: RoiDescriptor.h:102
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:239
TrigInDetTrackSeedingResult::m_nPixelSPs
int m_nPixelSPs
Definition: TrigInDetTrackSeedingResult.h:10
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
Trk::d0
@ d0
Definition: ParamDefs.h:63
TrigFastTrackFinder::m_dEdxHitKey
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_dEdxHitKey
Definition: TrigFastTrackFinder.h:166
TrigAccel::Work
Definition: Work.h:14
charge
double charge(const T &p)
Definition: AtlasPID.h:931
SCT_ID::layer_disk
int layer_disk(const Identifier &id) const
Definition: SCT_ID.h:734
Region::Undefined
@ Undefined
TrigInDetTrackSeedingResult
Definition: TrigInDetTrackSeedingResult.h:8
TrigFastTrackFinder::m_doFastZVseeding
bool m_doFastZVseeding
Definition: TrigFastTrackFinder.h:180
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
TrigFastTrackFinder::fillMon
void fillMon(const TrackCollection &tracks, const TrigVertexCollection &vertices, const TrigRoiDescriptor &roi, const EventContext &ctx) const
Definition: TrigFastTrackFinder.cxx:1112
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::RIO_OnTrack::prepRawData
virtual const Trk::PrepRawData * prepRawData() const =0
returns the PrepRawData (also known as RIO) object to which this RIO_OnTrack is associated.
TrigFastTrackFinder::m_prdToTrackMap
SG::ReadHandleKey< Trk::PRDtoTrackMap > m_prdToTrackMap
Definition: TrigFastTrackFinder.h:163
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:219
TrigFastTrackFinder::isGoodForDisTrackVertex
bool isGoodForDisTrackVertex(Trk::Track *, const EventContext &) const
Definition: TrigFastTrackFinder.cxx:2275
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:52
TrigCombinatorialSettings::m_doubletFilterRZ
bool m_doubletFilterRZ
Definition: TrigCombinatorialSettings.h:66
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
TrigFastTrackFinder::fillDisTrkCand
void fillDisTrkCand(xAOD::TrigComposite *, const std::string &, Trk::Track *, const std::unique_ptr< const Trk::TrackParameters > &) const
Definition: TrigFastTrackFinder.cxx:2569
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:79
TrigCombinatorialSettings::m_maxEndcapPix
int m_maxEndcapPix
Definition: TrigCombinatorialSettings.h:52
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:208
a
TList * a
Definition: liststreamerinfos.cxx:10
h
TrigFastTrackFinder::m_trigseedML_LUT
std::string m_trigseedML_LUT
Definition: TrigFastTrackFinder.h:234
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:176
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:56
TrigFastTrackFinder::Pix3l_Sct0
@ Pix3l_Sct0
Definition: TrigFastTrackFinder.h:122
TrigFastTrackFinder::createEmptyUTTEDMs
StatusCode createEmptyUTTEDMs(const EventContext &) const
Definition: TrigFastTrackFinder.cxx:1518
TrigFastTrackFinder::m_countRoIwithTracks
std::atomic< unsigned int > m_countRoIwithTracks
Definition: TrigFastTrackFinder.h:210
Trk::RIO_OnTrack::identify
Identifier identify() const
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:152
python.TrackLeptonConfig.quality
quality
Definition: TrackLeptonConfig.py:16
InDet::PixelCluster::totalCharge
float totalCharge() const
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/PixelCluster.h:213
TrigFastTrackFinder::isPreselPassDisTrackAfterRefit
bool isPreselPassDisTrackAfterRefit(Trk::Track *, Trk::Track *, double, double) const
Definition: TrigFastTrackFinder.cxx:2428
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:67
TrigFastTrackFinder::m_minHits
int m_minHits
Definition: TrigFastTrackFinder.h:187
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
TrigFastTrackFinder::m_storeZFinderVertices
bool m_storeZFinderVertices
Definition: TrigFastTrackFinder.h:178
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:2693
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
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
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
TrigCombinatorialSettings::m_tripletD0Max
float m_tripletD0Max
Definition: TrigCombinatorialSettings.h:58
RoiDescriptor::setComposite
void setComposite(bool b=true)
Definition: RoiDescriptor.h:138
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:269
TrigFastTrackFinder::filterSharedTracks
void filterSharedTracks(std::vector< std::tuple< bool, double, Trk::Track * >> &QT) const
Definition: TrigFastTrackFinder.cxx:1012
TrigFastTrackFinder::m_pixelId
const PixelID * m_pixelId
Definition: TrigFastTrackFinder.h:212
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:147
TrigFastTrackFinder::m_particleHypothesis
Trk::ParticleHypothesis m_particleHypothesis
Definition: TrigFastTrackFinder.h:217
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:213
TrigFastTrackFinder::m_useTracklets
Gaudi::Property< bool > m_useTracklets
Definition: TrigFastTrackFinder.h:284
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
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:143
Trk::TrackSummary::get
int get(const SummaryType &type) const
returns the summary information for the passed SummaryType.
trackInfo::n_hits_innermost
int n_hits_innermost
Definition: TrigInDetUtils.h:14
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
RoiDescriptor::phiPlus
virtual double phiPlus() const override final
gets phiPlus
Definition: RoiDescriptor.h:118
TrigFastTrackFinder::getTrkBarrelLayerInfo
std::array< OneLayerInfo_t, N_BARREL_LAYERS > getTrkBarrelLayerInfo(Trk::Track *aTrack) const
Definition: TrigFastTrackFinder.cxx:2036
TrigAccel::MAKE_SEEDS
@ MAKE_SEEDS
Definition: TrigInDetAccelCodes.h:29
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:200
DataVector::erase
iterator erase(iterator position)
Remove element at a given position.
RoiDescriptor::etaMinus
virtual double etaMinus() const override final
gets eta at zMinus
Definition: RoiDescriptor.h:116
test_pyathena.counter
counter
Definition: test_pyathena.py:15
set_intersection
Set * set_intersection(Set *set1, Set *set2)
Perform an intersection of two sets.
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
TrigFastTrackFinder::isCleaningPassDisTrack
bool isCleaningPassDisTrack(const TrigInDetTriplet &, Trk::Track *, bool) const
Definition: TrigFastTrackFinder.cxx:1955
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:182
TrigFastTrackFinder::recoVertexForDisTrack
void recoVertexForDisTrack(const EventContext &, TrackCollection &, std::vector< double > &, std::vector< double > &, std::vector< double > &) const
Definition: TrigFastTrackFinder.cxx:2130
InDet::SiCluster
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/SiCluster.h:40
Monitored::Timer
A monitored timer.
Definition: MonitoredTimer.h:32
Trk::FitQualityOnSurface::chiSquared
double chiSquared() const
returns the of the overall track fit
Definition: FitQuality.h:56
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
plotBeamSpotMon.nc
int nc
Definition: plotBeamSpotMon.py:83
Trk::phi0
@ phi0
Definition: ParamDefs.h: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:2514
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
Trk::FitQuality::doubleNumberDoF
double doubleNumberDoF() const
returns the number of degrees of freedom of the overall track or vertex fit as double
Definition: FitQuality.h:68
fitman.k
k
Definition: fitman.py:528
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition: TrackingPrimitives.h:238
InDet::SiClusterOnTrack
Definition: SiClusterOnTrack.h:39
InDet::SCT_ClusterOnTrack
Definition: SCT_ClusterOnTrack.h:44
TrigFastTrackFinder::m_tripletMinPtFrac
float m_tripletMinPtFrac
Definition: TrigFastTrackFinder.h:192
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 Sun Apr 20 2025 21:49:28 for ATLAS Offline Software by   doxygen 1.8.18