ATLAS Offline Software
Loading...
Searching...
No Matches
Classes | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
InDet::SiSPSeededTrackFinder Class Reference

Class-algorithm for track finding in Pixels and SCT initiated by space points seeds. More...

#include <SiSPSeededTrackFinder.h>

Inheritance diagram for InDet::SiSPSeededTrackFinder:

Classes

class  Counter_t
 For counters. More...

Public Member Functions

virtual StatusCode sysInitialize () override
 Override sysInitialize.
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm.
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
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.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
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.
Print internal tool parameters and status
MsgStream & dump (MSG::Level lvl, const SiSPSeededTrackFinder::Counter_t *) const
MsgStream & dumptools (MsgStream &out) const
MsgStream & dumpevent (MsgStream &out, const SiSPSeededTrackFinder::Counter_t &counter) const
bool isGoodEvent (const EventContext &ctx) const
 EventContext is used to specify which event.
void filterSharedTracks (std::multimap< double, Trk::Track * > &scoredTracks) const
 cleans up the collection of quality filtered tracks.
void filterSharedTracksFast (std::multimap< double, Trk::Track * > &scoredTracks) const
void fillZHistogram (const Trk::Track *Tr, const Trk::PerigeeSurface &beamlinePerigee, std::vector< int > &numberWeightedhistogram, std::vector< double > &zWeightedHistogram, std::vector< double > &ptWeightedHistogram) const
 fills three z0 histograms (non-weighted, weighted by z, and weighted by pt) with the track z at the beam line estimated using the innermost measurement.
void findZvertex (std::list< Trk::Vertex > &vertexList, std::pair< double, double > &zBoundaries, const std::vector< int > &numberWeightedhistogram, const std::vector< double > &zWeightedHistogram, const std::vector< double > &ptWeightedHistogram) const
 estimates a set of vertex positions and a z interval for the second track finding pass using the input histograms populated using fillZHistogram.
StatusCode oldStrategy (const EventContext &ctx) const
 this method performs the track finding using the old strategy
StatusCode newStrategy (const EventContext &ctx) const
 this method performs the track finding using the new strategy
StatusCode itkFastTrackingStrategy (const EventContext &ctx) const
 EventContext is used to specify which event.
StatusCode itkConvStrategy (const EventContext &ctx) const
 EventContext is used to specify which event.
void magneticFieldInit ()
bool passEtaDepCuts (const Trk::Track *track, int nClusters, int nFreeClusters, int nPixels) const
void collectGBTSTrainingData (const Trk::Track *) const
void dumpGBTSTrainingData () const

Protected Attributes

Flags to configure SiSPSeededTrackFinder
BooleanProperty m_useZvertexTool {this, "useZvertexTool", true}
BooleanProperty m_writeHolesFromPattern {this, "writeHolesFromPattern", false,"Flag to activate writing hole info from the pattern recognition"}
BooleanProperty m_useMBTS {this, "useMBTSTimeDiff", false}
BooleanProperty m_useNewStrategy {this, "useNewStrategy", false}
BooleanProperty m_useZBoundaryFinding {this, "useZBoundFinding", false}
BooleanProperty m_ITKGeometry {this, "ITKGeometry", false, "Flag to specify if it is ITK geometry"}
BooleanProperty m_useITkConvSeeded {this, "useITkConvSeeded", false, "ITk EM-seeded conversion reco"}
BooleanProperty m_doFastTracking {this, "doFastTracking", false, "ITk fast tracking reco"}
IntegerProperty m_maxNumberSeeds {this, "maxNumberSeeds", 3000000, "Max. number used seeds"}
BooleanProperty m_alwaysProtectAgainstBusyEvent {this, "alwaysProtectAgainstBusyEvents", false, "Flag that enables checking always maxNumberPIXsp and maxNumberSCTsp"}
IntegerProperty m_maxPIXsp {this, "maxNumberPIXsp", 150000, "Max. number pixels space points"}
IntegerProperty m_maxSCTsp {this, "maxNumberSCTsp", 500000, "Max. number sct space points"}
IntegerProperty m_nfreeCut {this, "FreeClustersCut", 1, "Min number free clusters"}
IntegerProperty m_histsize {this, "HistSize", 1400}
IntegerProperty m_nvertex {this, "maxVertices", 4}
DoubleProperty m_zcut {this, "Zcut", 350.}
DoubleProperty m_deltaEta {this, "dEtaCaloRoI", .1}
DoubleProperty m_deltaPhi {this, "dPhiCaloRoI", .25}
DoubleProperty m_deltaZ {this, "dZCaloRoI", 300.}
StringProperty m_fieldmode {this, "MagneticFieldMode", "MapSolenoid"}
BooleanProperty m_doDumpGBTSTrainingData {this, "doDumpGBTSTrainingData", false, "write training data used to create GBTS connection table"}
BooleanProperty m_doDumpGBTSTrainingDataLRT {this, "doDumpGBTSTrainingDataLRT", false, "write LRT training data used to create GBTS connection table"}
BooleanProperty m_removeShortSegments {this, "removeShortSegments", false, "remove short segments from GBTS connection table"}
StringProperty m_GBTSTrainingDataFileName {this, "GBTSTrainingDataFileName", "layer_connection_table.csv", "file to write training data used to create GBTS connection table"}
Data members for new strategy reconstruction
double m_pTcut {500}
double m_imcut {2.}
double m_zstep {0.}
Data handles for StoreGate access in AthenaMT
SG::ReadHandleKey< xAOD::EventInfo > m_evtKey {this, "EventInfoKey", "EventInfo"}
SG::ReadHandleKey< SpacePointContainer > m_SpacePointsSCTKey {this, "SpacePointsSCTName", "SCT_SpacePoints"}
SG::ReadHandleKey< SpacePointContainer > m_SpacePointsPixelKey {this, "SpacePointsPixelName", "PixelSpacePoints"}
SG::ReadHandleKey< Trk::PRDtoTrackMap > m_prdToTrackMap {this,"PRDtoTrackMap",""}
SG::ReadHandleKey< ROIPhiRZContainer > m_caloClusterROIKey {this, "EMROIPhiRZContainer", "InDetCaloClusterROIPhiRZ15GeVUnordered", "Name of the calo cluster ROIs in Phi,R,Z parameterization"}
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"}
SG::ReadDecorHandleKey< xAOD::EventInfo > m_mbtsKey {this, "MBTSKey", m_evtKey, "MBTSBackground"}
SG::WriteHandleKey< TrackCollection > m_outputTracksKey {this, "TracksLocation", "SiSPSeededTracks"}
Tool handles
ToolHandle< ISiSpacePointsSeedMaker > m_seedsmaker {this, "SeedsTool", "InDet::SiSpacePointsSeedMaker_ATLxk/InDetSpSeedsMaker", "Space poins seed maker"}
ToolHandle< ISiZvertexMaker > m_zvertexmaker {this, "ZvertexTool", "InDet::SiZvertexMaker_xk/InDetSiZvertexMaker", "Space poins z-vertex maker"}
ToolHandle< ISiTrackMaker > m_trackmaker {this, "TrackTool", "InDet::SiTrackMaker_xk/InDetSiTrackMaker", "Track maker"}
PublicToolHandle< Trk::IPatternParametersPropagator > m_proptool {this, "PropagatorTool", "Trk::RungeKuttaPropagator/InDetPropagator"}
ToolHandle< Trk::IExtendedTrackSummaryTool > m_trackSummaryTool {this, "TrackSummaryTool", "InDetTrackSummaryToolNoHoleSearch"}
ToolHandle< IRegSelTool > m_regsel_strip { this, "RegSelTool_Strip", "RegSelTool/RegSelTool_SCT" }
Magnetic field properties
Trk::MagneticFieldProperties m_fieldprop
Service handles
ServiceHandle< IInDetEtaDependentCutsSvc > m_etaDependentCutsSvc {this, "InDetEtaDependentCutsSvc", "InDetEtaDependentCutsSvc"}
 service to get cut values depending on different variable
Counters
Counter_t m_counterTotal ATLAS_THREAD_SAFE {}
std::atomic_int m_neventsTotal {0}
 Number events.
std::atomic_int m_neventsTotalV {0}
 Number events.
std::atomic_int m_problemsTotal {0}
 Number events with number seeds > maxNumber.
std::atomic_int m_problemsTotalV {0}
 Number events with number seeds > maxNumber.
std::mutex m_GBTSTrainingDataMutex
std::map< int, std::map< int, unsigned long > > m_GBTSTrainingData ATLAS_THREAD_SAFE
std::atomic_ulong m_numGBTSTrainingData {0}

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes

DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default)
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Standard Algotithm methods

enum  ECounter { kNSeeds , kNTracks , kNCounter }
 enums for Counter_t More...
 SiSPSeededTrackFinder (const std::string &name, ISvcLocator *pSvcLocator)
 Constructor.
virtual ~SiSPSeededTrackFinder ()=default
virtual StatusCode initialize () override
 Initialisation.
virtual StatusCode execute (const EventContext &ctx) const override
 Execute.
virtual StatusCode finalize () override
virtual bool isClonable () const override
 Make this algorithm clonable.

Detailed Description

Class-algorithm for track finding in Pixels and SCT initiated by space points seeds.

Definition at line 49 of file SiSPSeededTrackFinder.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

◆ ECounter

enum InDet::SiSPSeededTrackFinder::ECounter
protected

enums for Counter_t

Enumerator
kNSeeds 
kNTracks 
kNCounter 

Definition at line 79 of file SiSPSeededTrackFinder.h.

79{kNSeeds, kNTracks, kNCounter};

Constructor & Destructor Documentation

◆ SiSPSeededTrackFinder()

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

Constructor.

Definition at line 69 of file SiSPSeededTrackFinder.cxx.

70 : AthReentrantAlgorithm(name, pSvcLocator)
71{
72}

◆ ~SiSPSeededTrackFinder()

virtual InDet::SiSPSeededTrackFinder::~SiSPSeededTrackFinder ( )
virtualdefault

Member Function Documentation

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const
overridevirtualinherited

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

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

64{
65 return 0;
66}

◆ collectGBTSTrainingData()

void InDet::SiSPSeededTrackFinder::collectGBTSTrainingData ( const Trk::Track * track) const
protected

Definition at line 1147 of file SiSPSeededTrackFinder.cxx.

1147 {
1148
1149 struct VLM_Data {
1150 int vol_id, lay_id, mod_id;
1151 float m_x, m_y, m_z;
1152 };
1153
1154 const PixelID* IDp = 0;
1155 const SCT_ID* IDs = 0;
1156
1157 if (detStore()->retrieve(IDp, "PixelID").isFailure()) {
1158 ATH_MSG_FATAL("Could not get Pixel ID helper");
1159 }
1160
1161 if (detStore()->retrieve(IDs, "SCT_ID").isFailure()) {
1162 ATH_MSG_FATAL("Could not get SCT ID helper");
1163 }
1164
1165 if (!IDs && !IDp) return;
1166
1167 ++m_numGBTSTrainingData;
1168
1169 std::vector<VLM_Data> vlm;
1170
1171 for (const auto* s : *track->trackStateOnSurfaces()) {
1172 if (!s->type(Trk::TrackStateOnSurface::Measurement)) continue;
1173
1174 const Trk::MeasurementBase* mb = s->measurementOnTrack();
1175 if (!mb) continue;
1176
1177 const Trk::RIO_OnTrack* ri = dynamic_cast<const Trk::RIO_OnTrack*>(mb);
1178 if (!ri) continue;
1179
1180 const Trk::PrepRawData* rd = ri->prepRawData();
1181 if (!rd) continue;
1182
1183 const InDet::SiCluster* si = dynamic_cast<const InDet::SiCluster*>(rd);
1184 if (!si) continue;
1185
1186 const Amg::Vector3D& pos = s->trackParameters()->position();
1187
1188 if (dynamic_cast<const InDet::PixelCluster*>(si)) { // Pixel
1189
1190 Identifier id = si->identify();
1191
1192 int bec = IDp->barrel_ec(id);
1193
1194 int vol_id = 8;
1195
1196 if (bec == -2) vol_id = 7;
1197 if (bec == 2) vol_id = 9;
1198
1199 if (bec < -2 || bec > 2) continue;
1200
1201 int lay_id = IDp->layer_disk(id);
1202 int eta_mod = IDp->eta_module(id);
1203 int phi_mod = IDp->phi_module(id);
1204
1205 Identifier wafer_id = IDp->wafer_id(bec, lay_id, phi_mod, eta_mod);
1206
1207 int mod_id = IDp->wafer_hash(wafer_id);
1208
1209 int new_vol = 0, new_lay = 0;
1210
1211 if (vol_id == 7 || vol_id == 9) {
1212 new_vol = 10 * vol_id + lay_id;
1213 new_lay = eta_mod;
1214 } else if (vol_id == 8) {
1215 new_lay = 0;
1216 new_vol = 10 * vol_id + lay_id;
1217 }
1218 if (vol_id != 0)
1219 vlm.emplace_back(new_vol, new_lay, mod_id, pos.x(), pos.y(), pos.z());
1220 }
1221
1222 if (dynamic_cast<const InDet::SCT_Cluster*>(si)) { // SCT
1223
1224 Identifier id = si->identify();
1225
1226 int bec = IDs->barrel_ec(id);
1227
1228 int vol_id = 13;
1229
1230 if (bec < 0) vol_id = 12;
1231 if (bec > 0) vol_id = 14;
1232
1233 int lay_id = IDs->layer_disk(id);
1234 int eta_mod = IDs->eta_module(id);
1235 int phi_mod = IDs->phi_module(id);
1236 int side = IDs->side(id);
1237
1238 Identifier wafer_id = IDs->wafer_id(bec, lay_id, phi_mod, eta_mod, side);
1239
1240 int mod_id = IDs->wafer_hash(wafer_id);
1241
1242 vlm.emplace_back(vol_id, lay_id, mod_id, pos.x(), pos.y(), pos.z());
1243 }
1244 }
1245
1246 // remove single-strip cases where no spacepoint exists
1247
1248 std::vector<VLM_Data> vlm2;
1249
1250 for (std::size_t it1 = 0; it1 < vlm.size() - 1; it1++) {
1251 if (vlm.at(it1).vol_id > 14) { // Pixels
1252 vlm2.push_back(vlm.at(it1));
1253 continue;
1254 }
1255
1256 std::size_t it2 = it1 + 1;
1257
1258 int src = vlm.at(it1).vol_id * 1000 + vlm.at(it1).lay_id;
1259 int dst = vlm.at(it2).vol_id * 1000 + vlm.at(it2).lay_id;
1260
1261 if (src == dst) { // a spacepoint can be formed
1262 vlm2.push_back(vlm.at(it1));
1263 vlm2.push_back(vlm.at(it2));
1264 it1 = it2;
1265 continue;
1266 }
1267 }
1268
1269 // remove track segments which are too short
1270 if (m_removeShortSegments) {
1271
1272 constexpr float minDist = 20.0;
1273
1274 for (auto it = std::next(vlm2.begin()); it != vlm2.end(); ) {
1275 auto jt = std::prev(it);
1276 float dx = it->m_x - jt->m_x;
1277 float dy = it->m_y - jt->m_y;
1278 float dz = it->m_z - jt->m_z;
1279
1280 float dist = std::sqrt(dx*dx + dy*dy + dz*dz);
1281
1282 if (dist < minDist) it = vlm2.erase(it);
1283 else ++it;
1284 }
1285 }
1286
1287 std::scoped_lock trainingDataLock(m_GBTSTrainingDataMutex);
1288
1289 for (std::size_t it1 = 0; it1 < vlm2.size() - 1; ++it1) {
1290 std::size_t it2 = it1 + 1;
1291
1292 int src = vlm2.at(it1).vol_id * 1000 + vlm2.at(it1).lay_id;
1293 int dst = vlm2.at(it2).vol_id * 1000 + vlm2.at(it2).lay_id;
1294
1295 if (src != dst) { // skip the same layer
1296 auto [im1, new1] = m_GBTSTrainingData.insert({src, {}});
1297 auto [im2, new2] = im1->second.insert({dst, 1ul});
1298 if (!new2) im2->second++;
1299 }
1300 }
1301}
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition AthMsgStreamMacros.h:34
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
Definition AthCommonDataStore.h:95
PixelID::layer_disk
int layer_disk(const Identifier &id) const
Definition PixelID.h:607
PixelID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module) const
For a single crystal.
Definition PixelID.h:360
PixelID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition PixelID.h:600
PixelID::wafer_hash
IdentifierHash wafer_hash(Identifier wafer_id) const
wafer hash from id
Definition PixelID.h:383
PixelID::eta_module
int eta_module(const Identifier &id) const
Definition PixelID.h:632
PixelID::phi_module
int phi_module(const Identifier &id) const
Definition PixelID.h:625
SCT_ID::layer_disk
int layer_disk(const Identifier &id) const
Definition SCT_ID.h:687
SCT_ID::side
int side(const Identifier &id) const
Definition SCT_ID.h:705
SCT_ID::wafer_hash
IdentifierHash wafer_hash(const Identifier &wafer_id) const
wafer hash from id - optimized
Definition SCT_ID.h:487
SCT_ID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module, int side) const
For a single side of module.
Definition SCT_ID.h:459
SCT_ID::phi_module
int phi_module(const Identifier &id) const
Definition SCT_ID.h:693
SCT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition SCT_ID.h:681
SCT_ID::eta_module
int eta_module(const Identifier &id) const
Definition SCT_ID.h:699
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
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.
Trk::TrackStateOnSurface::Measurement
@ Measurement
This is a measurement, and will at least contain a Trk::MeasurementBase.
Definition TrackStateOnSurface.h:101
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition GeoPrimitives.h:47
ParticleGun_SamplingFraction.bec
int bec
Definition ParticleGun_SamplingFraction.py:89
TRT_PAI_physicsConstants::mb
const double mb
1mb to cm2
Definition TRT_PAI_physicsConstants.h:17
python.PyKernel.retrieve
retrieve(aClass, aKey=None)
Definition PyKernel.py:110

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & 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 }
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & 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 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

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

◆ dump()

MsgStream & InDet::SiSPSeededTrackFinder::dump ( MSG::Level lvl,
const SiSPSeededTrackFinder::Counter_t * counter ) const
protected

Definition at line 739 of file SiSPSeededTrackFinder.cxx.

740{
741 msg(assign_level) <<std::endl;
742 MsgStream& out_msg=msg();
743 if (counter) dumpevent(out_msg ,*counter);
744 else dumptools(out_msg);
745 out_msg << endmsg;
746 return out_msg;
747}
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
InDet::SiSPSeededTrackFinder::dumptools
MsgStream & dumptools(MsgStream &out) const
Definition SiSPSeededTrackFinder.cxx:753
InDet::SiSPSeededTrackFinder::dumpevent
MsgStream & dumpevent(MsgStream &out, const SiSPSeededTrackFinder::Counter_t &counter) const
Definition SiSPSeededTrackFinder.cxx:793

◆ dumpevent()

MsgStream & InDet::SiSPSeededTrackFinder::dumpevent ( MsgStream & out,
const SiSPSeededTrackFinder::Counter_t & counter ) const
protected

Definition at line 793 of file SiSPSeededTrackFinder.cxx.

794{
795 out<<"|-------------------------------------------------------------------";
796 out<<"---------------------------------|"
797 <<std::endl;
798 out<<"| Investigated "
799 <<std::setw(9)<<counter[kNSeeds]<<" space points seeds and found ";
800 out<<std::setw(9)<<counter[kNTracks];
801 if (m_ITKGeometry ) out<<" tracks using new strategy for ITK |"<<std::endl;
802 else if (m_useNewStrategy ) out<<" tracks using new strategy ("<<std::setw(2)<< m_nvertex <<") |"<<std::endl;
803 else if (m_useZBoundaryFinding) out<<" tracks using old strategy with Zb |"<<std::endl;
804 else out<<" tracks using old strategy |"<<std::endl;
805
806 out<<"|-------------------------------------------------------------------";
807 out<<"---------------------------------|"
808 <<std::endl;
809 if (m_problemsTotal or m_problemsTotalV) {
810 out<<"| Events "
811 <<std::setw(7)<<m_neventsTotal <<" without Z-vertz "
812 <<std::setw(7)<<m_neventsTotalV <<" with Z-vertex |"
813 <<std::endl;
814 out<<"| Problems "
815 <<std::setw(7)<<m_problemsTotal <<" without Z-vertz "
816 <<std::setw(7)<<m_problemsTotalV <<" with Z-vertex |"
817 <<std::endl;
818 out<<"|-------------------------------------------------------------------";
819 out<<"-----------------------------|"
820 <<std::endl;
821 }
822 return out;
823}
InDet::SiSPSeededTrackFinder::m_problemsTotal
std::atomic_int m_problemsTotal
Number events with number seeds > maxNumber.
Definition SiSPSeededTrackFinder.h:171
InDet::SiSPSeededTrackFinder::m_problemsTotalV
std::atomic_int m_problemsTotalV
Number events with number seeds > maxNumber.
Definition SiSPSeededTrackFinder.h:172
InDet::SiSPSeededTrackFinder::m_neventsTotalV
std::atomic_int m_neventsTotalV
Number events.
Definition SiSPSeededTrackFinder.h:170
InDet::SiSPSeededTrackFinder::m_neventsTotal
std::atomic_int m_neventsTotal
Number events.
Definition SiSPSeededTrackFinder.h:169
test_pyathena.counter
counter
Definition test_pyathena.py:15

◆ dumpGBTSTrainingData()

void InDet::SiSPSeededTrackFinder::dumpGBTSTrainingData ( ) const
protected

Definition at line 1303 of file SiSPSeededTrackFinder.cxx.

1303 {
1304 std::ofstream tableFile(m_GBTSTrainingDataFileName);
1305 tableFile << "from,to,probability,flow\n";
1306
1307 unsigned long nTotal = 0;
1308 for (const auto& [src, conns] : m_GBTSTrainingData) {
1309 unsigned long nTotalDst = 0;
1310 for (const auto& [dst, n] : conns) {
1311 nTotalDst += n;
1312 }
1313 nTotal += nTotalDst;
1314 for (const auto& [dst, n] : conns) {
1315 double prob = double(n) / double(nTotalDst);
1316 tableFile << src << ", " << dst << ", " << std::fixed << std::setprecision(6) << prob << ", " << prob << '\n';
1317 }
1318 }
1319 ATH_MSG_INFO("GBTS training data from " << m_numGBTSTrainingData << " tracks with " << nTotal << " pairs written to " << m_GBTSTrainingDataFileName.value());
1320}
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31

◆ dumptools()

MsgStream & InDet::SiSPSeededTrackFinder::dumptools ( MsgStream & out) const
protected

Definition at line 753 of file SiSPSeededTrackFinder.cxx.

754{
755 int n = 65-m_zvertexmaker.type().size();
756 std::string s1; for (int i=0; i<n; ++i) s1.append(" "); s1.append("|");
757 n = 65-m_seedsmaker.type().size();
758 std::string s2; for (int i=0; i<n; ++i) s2.append(" "); s2.append("|");
759 n = 65-m_trackmaker.type().size();
760 std::string s3; for (int i=0; i<n; ++i) s3.append(" "); s3.append("|");
761 n = 65-m_outputTracksKey.key().size();
762 std::string s4; for (int i=0; i<n; ++i) s4.append(" "); s4.append("|");
763
764 std::string s5;
765 if (m_useZvertexTool) s5= "Yes"; else s5 = "No";
766 n = 65-s5.size(); for (int i=0; i<n; ++i) s5.append(" "); s5.append("|");
767
768 out<<"|----------------------------------------------------------------"
769 <<"----------------------------------------------------|"
770 <<std::endl;
771 out<<"| Use primary vertices z-coordinates finding?| "<<s5
772 <<std::endl;
773 if (m_useZvertexTool) {
774 out<<"| Tool for primary vertices z-coordinates finding | "<<m_zvertexmaker.type()<<s1
775 <<std::endl;
776 }
777 out<<"| Tool for space points seeds finding | "<<m_seedsmaker.type()<<s2
778 <<std::endl;
779 out<<"| Tool for space points seeded track finding | "<<m_trackmaker.type()<<s3
780 <<std::endl;
781 out<<"| Location of output tracks | "<<m_outputTracksKey.key()<<s4
782 <<std::endl;
783 out<<"|----------------------------------------------------------------"
784 <<"----------------------------------------------------|"
785 <<std::endl;
786 return out;
787}
InDet::SiSPSeededTrackFinder::m_trackmaker
ToolHandle< ISiTrackMaker > m_trackmaker
Definition SiSPSeededTrackFinder.h:148
InDet::SiSPSeededTrackFinder::m_outputTracksKey
SG::WriteHandleKey< TrackCollection > m_outputTracksKey
Definition SiSPSeededTrackFinder.h:141
InDet::SiSPSeededTrackFinder::m_zvertexmaker
ToolHandle< ISiZvertexMaker > m_zvertexmaker
Definition SiSPSeededTrackFinder.h:147
InDet::SiSPSeededTrackFinder::m_seedsmaker
ToolHandle< ISiSpacePointsSeedMaker > m_seedsmaker
Definition SiSPSeededTrackFinder.h:146

◆ evtStore()

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

◆ execute()

StatusCode InDet::SiSPSeededTrackFinder::execute ( const EventContext & ctx) const
overridevirtual

Execute.

Note that !m_useNewStrategy alone is NOT sufficient to trigger the oldStrategy call here! For example, run-3 central offline Si tracking has m_useNewStrategy=false, but m_useZBoundaryFinding true --> newStrategy

Definition at line 146 of file SiSPSeededTrackFinder.cxx.

147{
152 if (m_ITKGeometry and m_doFastTracking) return itkFastTrackingStrategy(ctx);
153 else if (m_useITkConvSeeded) return itkConvStrategy(ctx);
154 else if (not m_useNewStrategy and not m_useZBoundaryFinding and not m_ITKGeometry) {
155 return oldStrategy(ctx);
156 }
157 return newStrategy(ctx);
158}
InDet::SiSPSeededTrackFinder::itkFastTrackingStrategy
StatusCode itkFastTrackingStrategy(const EventContext &ctx) const
EventContext is used to specify which event.
Definition SiSPSeededTrackFinder.cxx:458
InDet::SiSPSeededTrackFinder::itkConvStrategy
StatusCode itkConvStrategy(const EventContext &ctx) const
EventContext is used to specify which event.
Definition SiSPSeededTrackFinder.cxx:574
InDet::SiSPSeededTrackFinder::newStrategy
StatusCode newStrategy(const EventContext &ctx) const
this method performs the track finding using the new strategy
Definition SiSPSeededTrackFinder.cxx:265
InDet::SiSPSeededTrackFinder::oldStrategy
StatusCode oldStrategy(const EventContext &ctx) const
this method performs the track finding using the old strategy
Definition SiSPSeededTrackFinder.cxx:180

◆ 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 ( ) const
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}
AthCommonReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition AthCommonReentrantAlgorithm.h:40

◆ fillZHistogram()

void InDet::SiSPSeededTrackFinder::fillZHistogram ( const Trk::Track * Tr,
const Trk::PerigeeSurface & beamlinePerigee,
std::vector< int > & numberWeightedhistogram,
std::vector< double > & zWeightedHistogram,
std::vector< double > & ptWeightedHistogram ) const
protected

fills three z0 histograms (non-weighted, weighted by z, and weighted by pt) with the track z at the beam line estimated using the innermost measurement.

the first two parameters are input, the other three output.

Parameters
[in]TrTrack candidate to fill
[in]beamlinePerigeePerigee surface corresponding to the beam spot
[out]numberWeightedhistogramvector representing a histogram in z, counting the tracks per bin
[out]zWeightedHistogramvector representing a histogram in z, counting the tracks per bin weighted by their z values
[out]ptWeightedHistogramvector representing a histogram in z, counting the tracks per bin weighted by their pt values

only take into accounts tracks with a hit inside r < 60mm

propagate from innermost hit to beam spot

determine bin number - m_zstep is the inverse bin width, where the histo axis extends from -m_zcut to +m_zcut

fill histograms if we are not in the over/underflow

simple z histogram, counting tracks per z

z weighted histogram binned in z - used for vertex z calculation

pt weighted histogram binned in z - used for vertex sumpt calculation

Definition at line 988 of file SiSPSeededTrackFinder.cxx.

993{
994
995 if (Tr->measurementsOnTrack()->size() < 10) return;
996
997 const Trk::TrackParameters* paramsAtFirstSurface = Tr->trackStateOnSurfaces()->front()->trackParameters();
998 Amg::Vector3D position = paramsAtFirstSurface->position() ;
999 Amg::Vector3D momentum = paramsAtFirstSurface->momentum() ;
1000
1002 constexpr double rSquare_max_forZHisto = 60.*60.;
1003 if (position.x()*position.x()+position.y()*position.y() >= rSquare_max_forZHisto) return;
1004
1005 double pT = sqrt(momentum.x()*momentum.x()+momentum.y()*momentum.y());
1006 if (pT < m_pTcut) return;
1007
1008 Trk::PatternTrackParameters TP;
1009 if (not TP.production(paramsAtFirstSurface)) return;
1010
1011 double step;
1013 if (not m_proptool->propagate(Gaudi::Hive::currentContext(),
1014 TP, beamPosPerigee, TP, Trk::anyDirection, m_fieldprop, step, Trk::pion)) return;
1015
1016 const AmgVector(5)& parsAtBeamSpot = TP.parameters();
1017 if (std::abs(parsAtBeamSpot[0]) > m_imcut) return;
1019 int z = static_cast<int>((parsAtBeamSpot[1]+m_zcut)*m_zstep);
1021 if (z >=0 and z < m_histsize) {
1023 ++numberHistogram[z];
1025 zWeightedHistogram[z] += parsAtBeamSpot[1];
1027 ptWeightedHistogram[z] += pT;
1028 }
1029
1030}
AmgVector
#define AmgVector(rows)
Definition EventPrimitives.h:55
z
#define z
DataVector::front
const T * front() const
Access the first element in the collection as an rvalue.
InDet::SiSPSeededTrackFinder::m_proptool
PublicToolHandle< Trk::IPatternParametersPropagator > m_proptool
Definition SiSPSeededTrackFinder.h:149
InDet::SiSPSeededTrackFinder::m_fieldprop
Trk::MagneticFieldProperties m_fieldprop
Definition SiSPSeededTrackFinder.h:156
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
Trk::PatternTrackParameters::production
bool production(const TrackParameters *)
Definition PatternTrackParameters.cxx:42
Trk::TrackStateOnSurface::trackParameters
const TrackParameters * trackParameters() const
return ptr to trackparameters const overload
Trk::Track::trackStateOnSurfaces
const Trk::TrackStates * trackStateOnSurfaces() const
return a pointer to a const DataVector of const TrackStateOnSurfaces.
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
ParticleGun_EoverP_Config.momentum
momentum
Definition ParticleGun_EoverP_Config.py:63
Trk::anyDirection
@ anyDirection
Definition PropDirection.h:22
Trk::TrackParameters
ParametersBase< TrackParametersDim, Charged > TrackParameters
Definition Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h:27

◆ 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 }
AthCommonReentrantAlgorithm::filterPassed
virtual bool filterPassed(const EventContext &ctx) const
Definition AthCommonReentrantAlgorithm.h:96

◆ filterSharedTracks()

void InDet::SiSPSeededTrackFinder::filterSharedTracks ( std::multimap< double, Trk::Track * > & scoredTracks) const
protected

cleans up the collection of quality filtered tracks.

Candidates which share most of their hits (steered by m_freeCut) with higher quality candidates are erased from the multimap

Parameters
[in,out]scoredTracksTrack candidates, sorted by by score, best scored first (implemented by assigning negative sign to scores)

loop over all track candidates, sorted by quality

loop over measurements on the track candidate

get the PRD from the measurement

increase cluster count

and check if the cluster was already used in a previous ( = higher quality) track

if not, record as a free (not prevously used) cluster

check if the track has the minimum number of free clusters or if it has no shared clusters

if this is fulfilled, we keep the candidate add the free clusters to our cluster set

if we do not keep the track, clean up candidate

Definition at line 880 of file SiSPSeededTrackFinder.cxx.

881{
882 std::set<const Trk::PrepRawData*> clusters;
883
884 std::vector<const Trk::PrepRawData*> freeClusters;
885 freeClusters.reserve(15);
886
887 std::multimap<double, Trk::Track*>::iterator it_qualityAndTrack = qualitySortedTracks.begin();
888
890 while (it_qualityAndTrack!=qualitySortedTracks.end()) {
891 freeClusters.clear();
892
893 std::set<const Trk::PrepRawData*>::iterator it_clustersEnd = clusters.end();
894
895 int nClusters = 0;
897 for (const Trk::MeasurementBase* m: *((*it_qualityAndTrack).second->measurementsOnTrack())) {
898
900 const Trk::PrepRawData* pr = (static_cast<const Trk::RIO_OnTrack*>(m))->prepRawData();
901 if (pr) {
903 ++nClusters;
905 if (clusters.find(pr)==it_clustersEnd) {
907 freeClusters.push_back(pr);
908 }
909 }
910 }
911
913 int nFreeClusters = static_cast<int>(freeClusters.size());
914 if (nFreeClusters >= m_nfreeCut || nFreeClusters==nClusters) {
917 clusters.insert(freeClusters.begin(), freeClusters.end());
918 ++it_qualityAndTrack;
919 } else {
921 delete (*it_qualityAndTrack).second;
922 qualitySortedTracks.erase(it_qualityAndTrack++);
923 }
924 }
925}

◆ filterSharedTracksFast()

void InDet::SiSPSeededTrackFinder::filterSharedTracksFast ( std::multimap< double, Trk::Track * > & scoredTracks) const
protected

loop over all track candidates, sorted by quality

loop over track states on surface of the track candidate

get the PRD from the measurement

increase cluster count

and check if the cluster was already used in a previous ( = higher quality) track

if not, record as a free (not prevously used) cluster

add the free clusters to our cluster set

if this is fulfilled, we keep the candidate

if we do not keep the track, clean up candidate

Definition at line 928 of file SiSPSeededTrackFinder.cxx.

929{
930 std::set<const Trk::PrepRawData*> clusters;
931
932 std::vector<const Trk::PrepRawData*> freeClusters;
933 freeClusters.reserve(15);
934
935 std::multimap<double, Trk::Track*>::iterator it_qualityAndTrack = qualitySortedTracks.begin();
936
938 while (it_qualityAndTrack!=qualitySortedTracks.end()) {
939 freeClusters.clear();
940
941 std::set<const Trk::PrepRawData*>::iterator it_clustersEnd = clusters.end();
942
943 int nClusters = 0;
944 int nPixels = 0;
946 for (const Trk::TrackStateOnSurface* tsos: *((*it_qualityAndTrack).second->trackStateOnSurfaces())) {
947
948 if(!tsos->type(Trk::TrackStateOnSurface::Measurement)) continue;
949 const Trk::FitQualityOnSurface fq = tsos->fitQualityOnSurface();
950 if(!fq) continue;
951 if(fq.numberDoF() == 2) ++nPixels;
952
954 const Trk::MeasurementBase* mb = tsos->measurementOnTrack();
955 const Trk::RIO_OnTrack* ri = dynamic_cast<const Trk::RIO_OnTrack*>(mb);
956 if(!ri) continue;
957 const Trk::PrepRawData* pr = ri->prepRawData();
958 if (pr) {
960 ++nClusters;
962 if (clusters.find(pr)==it_clustersEnd) {
964 freeClusters.push_back(pr);
965 }
966 }
967 }
968
970 clusters.insert(freeClusters.begin(), freeClusters.end());
971
972 int nFreeClusters = static_cast<int>(freeClusters.size());
973 if( passEtaDepCuts( (*it_qualityAndTrack).second, nClusters, nFreeClusters, nPixels) ){
975 ++it_qualityAndTrack;
976 } else {
978 delete (*it_qualityAndTrack).second;
979 qualitySortedTracks.erase(it_qualityAndTrack++);
980 }
981 }
982}
InDet::SiSPSeededTrackFinder::passEtaDepCuts
bool passEtaDepCuts(const Trk::Track *track, int nClusters, int nFreeClusters, int nPixels) const
Definition SiSPSeededTrackFinder.cxx:1126
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

◆ finalize()

StatusCode InDet::SiSPSeededTrackFinder::finalize ( )
overridevirtual

Definition at line 724 of file SiSPSeededTrackFinder.cxx.

725{
726
727 dump(MSG::INFO, &m_counterTotal);
728
729 if (m_doDumpGBTSTrainingData || m_doDumpGBTSTrainingDataLRT) {
730 dumpGBTSTrainingData();
731 }
732 return StatusCode::SUCCESS;
733}
InDet::SiSPSeededTrackFinder::dump
MsgStream & dump(MSG::Level lvl, const SiSPSeededTrackFinder::Counter_t *) const
Definition SiSPSeededTrackFinder.cxx:739

◆ findZvertex()

void InDet::SiSPSeededTrackFinder::findZvertex ( std::list< Trk::Vertex > & vertexList,
std::pair< double, double > & zBoundaries,
const std::vector< int > & numberWeightedhistogram,
const std::vector< double > & zWeightedHistogram,
const std::vector< double > & ptWeightedHistogram ) const
protected

estimates a set of vertex positions and a z interval for the second track finding pass using the input histograms populated using fillZHistogram.

the first two arguments serve as output, while the three histograms are input.

Parameters
[out]vertexList- will be populated with vertex candidates if m_useNewStrategy is set
[out]zBoundaries- will be populated with edges of a z interval corresponding to the estimated vertex locations
[in]numberWeightedhistogramvector representing a histogram in z, counting the tracks per bin
[in]zWeightedHistogramvector representing a histogram in z, counting the tracks per bin weighted by their z values
[in]ptWeightedHistogramvector representing a histogram in z, counting the tracks per bin weighted by their pt values

loop over the bins in z. Start with the second, end with the second to last, as we investigate triplets of bins

total entries in the three neighbouring bins

if we have at least 3 tracks in this z0 interval with the peak of the local triplet in the central bin, add a vertex candidate

vertex z estimate as the mean z0 of the tracks in the three bins

if this vertex is to the left of the lower edge or the right of the upper edge, broaden the z interval accordingly to include this vertex.

also get the sum(pt) of the vertex candidate

stop when we have collected the requested number of leading vertices

insert one vertex from the ntracks-sorted list and one from the pt-sorted list. If both are the same, only one insertion is performed

if we did not find any PV candidates, assume a very wide interval

otherwise, add a reasonable bit of space on each side of the first / last vertex candidate

Definition at line 1036 of file SiSPSeededTrackFinder.cxx.

1041{
1042 zBoundaries = {1000., -1000};
1043
1044 std::multimap<int ,double> vertexZ_sortedByNtracks;
1045 std::multimap<double,double> vertexZ_sortedBySumPt;
1046
1047 int lastBin = m_histsize-1;
1048 int minBinContentSum = 3;
1049
1051 for (int binIndex=1; binIndex<lastBin; ++binIndex) {
1052
1054 int vertexNtracks = numberHistogram.at(binIndex-1)+numberHistogram.at(binIndex)+numberHistogram.at(binIndex+1);
1055
1058 if (vertexNtracks>=minBinContentSum and (numberHistogram.at(binIndex) >= numberHistogram.at(binIndex-1) and numberHistogram.at(binIndex) >= numberHistogram.at(binIndex+1))) {
1060 double vertexZestimate = (zWeightedHistogram.at(binIndex-1)+zWeightedHistogram.at(binIndex)+zWeightedHistogram.at(binIndex+1))/static_cast<double>(vertexNtracks);
1061
1064 if (vertexZestimate < zBoundaries.first) zBoundaries.first = vertexZestimate;
1065 if (vertexZestimate > zBoundaries.second) zBoundaries.second = vertexZestimate;
1066
1067 if (m_useNewStrategy) {
1069 double vertexSumPt = ptWeightedHistogram.at(binIndex-1)+ptWeightedHistogram.at(binIndex)+ptWeightedHistogram.at(binIndex+1);
1070 vertexZ_sortedByNtracks.insert(std::make_pair(-vertexNtracks, vertexZestimate));
1071 vertexZ_sortedBySumPt.insert(std::make_pair(-vertexSumPt, vertexZestimate));
1072 }
1073 }
1074 }
1075
1076 if (m_useNewStrategy) {
1077
1078 std::set<double> leadingVertices;
1079 int n = 0;
1080 std::multimap<double, double>::iterator vertex_pt_and_z = vertexZ_sortedBySumPt.begin();
1081 for (std::pair<int, double> nTrackAndZ: vertexZ_sortedByNtracks) {
1083 if (n++ >= m_nvertex) break;
1086 leadingVertices.insert(nTrackAndZ.second);
1087 leadingVertices.insert((*vertex_pt_and_z++).second);
1088 }
1089
1090 for (double v: leadingVertices) {
1091 vertexZList.emplace_back(Amg::Vector3D{0.,0.,v});
1092 }
1093 }
1095 if (zBoundaries.first > zBoundaries.second) {
1096 zBoundaries.first = -1000.;
1097 zBoundaries.second = +1000.;
1098 } else {
1100 zBoundaries.first -= 20.;
1101 zBoundaries.second += 20.;
1102 }
1103}
IDPVM::binIndex
unsigned int binIndex(const T &val, const std::vector< T > &partitions)
general utility function to return bin index given a value and the upper endpoints of each bin
Definition InDetPhysValMonitoringUtilities.h:43
PESA::vertexSumPt
double vertexSumPt(const TrackCollection &tracks)
Definition T2Vertex.cxx:71

◆ initialize()

StatusCode InDet::SiSPSeededTrackFinder::initialize ( )
overridevirtual

Initialisation.

optional PRD to track association map

Get tool for space points seed maker

Get track-finding tool

Get RungeKutta propagator tool

Setup for magnetic field

Setup for Z-histograms

Get output print level

Definition at line 78 of file SiSPSeededTrackFinder.cxx.

79{
80 ATH_CHECK(m_evtKey.initialize());
81 ATH_CHECK(m_mbtsKey.initialize(m_useMBTS));
82 ATH_CHECK(m_SpacePointsPixelKey.initialize(SG::AllowEmpty));
83 ATH_CHECK(m_SpacePointsSCTKey.initialize(SG::AllowEmpty));
84 ATH_CHECK(m_outputTracksKey.initialize());
85
87 ATH_CHECK( m_prdToTrackMap.initialize( !m_prdToTrackMap.key().empty() ) );
88
89 ATH_CHECK( m_caloClusterROIKey.initialize(m_useITkConvSeeded) );
90
92 ATH_CHECK( m_seedsmaker.retrieve() );
93 ATH_CHECK( m_zvertexmaker.retrieve( DisableTool{ not m_useZvertexTool } ));
94
96 ATH_CHECK( m_trackmaker.retrieve());
97
98 ATH_CHECK( m_regsel_strip.retrieve( DisableTool{ not m_useITkConvSeeded } ) );
99
100 if (m_ITKGeometry and m_doFastTracking) ATH_CHECK(m_etaDependentCutsSvc.retrieve());
101
102 ATH_CHECK( m_trackSummaryTool.retrieve( DisableTool{ m_trackSummaryTool.name().empty()} ));
103
104 if (m_useNewStrategy and m_beamSpotKey.key().empty()) {
105 m_useNewStrategy = false;
106 m_useZBoundaryFinding = false;
107 }
108
109 ATH_CHECK(m_beamSpotKey.initialize( (m_useNewStrategy or m_useZBoundaryFinding or m_ITKGeometry or m_useITkConvSeeded) && not m_beamSpotKey.key().empty() ));
110 if (m_useNewStrategy or m_useZBoundaryFinding or m_ITKGeometry or m_useITkConvSeeded) {
111
112 if (not m_beamSpotKey.key().empty()) {
114 ATH_CHECK( m_proptool.retrieve() );
115
117 magneticFieldInit();
118
120 if (m_histsize < 100) m_histsize = 100;
121 m_zstep = static_cast<double>(m_histsize)/(2.*m_zcut);
122 } else {
123 m_proptool.disable();
124 m_useNewStrategy = false;
125 m_useZBoundaryFinding = false;
126 }
127 } else {
128 m_proptool.disable();
129 }
130
132 if (msgLvl(MSG::DEBUG)) {
133 dump(MSG::DEBUG, nullptr);
134 }
135 m_neventsTotal = 0;
136 m_neventsTotalV = 0;
137 m_problemsTotal = 0;
138 m_problemsTotalV = 0;
139 return StatusCode::SUCCESS;
140}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition AthCommonMsg.h:30
InDet::SiSPSeededTrackFinder::m_SpacePointsSCTKey
SG::ReadHandleKey< SpacePointContainer > m_SpacePointsSCTKey
Definition SiSPSeededTrackFinder.h:132
InDet::SiSPSeededTrackFinder::m_caloClusterROIKey
SG::ReadHandleKey< ROIPhiRZContainer > m_caloClusterROIKey
Definition SiSPSeededTrackFinder.h:135
InDet::SiSPSeededTrackFinder::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
Definition SiSPSeededTrackFinder.h:137
InDet::SiSPSeededTrackFinder::m_mbtsKey
SG::ReadDecorHandleKey< xAOD::EventInfo > m_mbtsKey
Definition SiSPSeededTrackFinder.h:139
InDet::SiSPSeededTrackFinder::m_regsel_strip
ToolHandle< IRegSelTool > m_regsel_strip
Definition SiSPSeededTrackFinder.h:151
InDet::SiSPSeededTrackFinder::m_prdToTrackMap
SG::ReadHandleKey< Trk::PRDtoTrackMap > m_prdToTrackMap
Definition SiSPSeededTrackFinder.h:134
InDet::SiSPSeededTrackFinder::m_evtKey
SG::ReadHandleKey< xAOD::EventInfo > m_evtKey
Definition SiSPSeededTrackFinder.h:131
InDet::SiSPSeededTrackFinder::m_SpacePointsPixelKey
SG::ReadHandleKey< SpacePointContainer > m_SpacePointsPixelKey
Definition SiSPSeededTrackFinder.h:133
InDet::SiSPSeededTrackFinder::m_trackSummaryTool
ToolHandle< Trk::IExtendedTrackSummaryTool > m_trackSummaryTool
Definition SiSPSeededTrackFinder.h:150
InDet::SiSPSeededTrackFinder::m_etaDependentCutsSvc
ServiceHandle< IInDetEtaDependentCutsSvc > m_etaDependentCutsSvc
service to get cut values depending on different variable
Definition SiSPSeededTrackFinder.h:162

◆ inputHandles()

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

Return this algorithm's input handles.

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

◆ isClonable()

virtual bool InDet::SiSPSeededTrackFinder::isClonable ( ) const
inlineoverridevirtual

Make this algorithm clonable.

Reimplemented from AthCommonReentrantAlgorithm< Gaudi::Algorithm >.

Definition at line 69 of file SiSPSeededTrackFinder.h.

69{ return true; };

◆ isGoodEvent()

bool InDet::SiSPSeededTrackFinder::isGoodEvent ( const EventContext & ctx) const
protected

EventContext is used to specify which event.

Definition at line 829 of file SiSPSeededTrackFinder.cxx.

829 {
830
831 if ( not m_alwaysProtectAgainstBusyEvent ) { // if not enabled the protection is only applied to specific events
832 // Test MBTS information from calorimeter
833 //
834 if (not m_useMBTS) return true;
835
836 SG::ReadHandle<xAOD::EventInfo> eventInfo{m_evtKey, ctx};
837 if (not eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background, xAOD::EventInfo::MBTSTimeDiffHalo) ) {
838 return true;
839 }
840 }
841
842 // Test total number pixels space points
843 //
844 unsigned int nsp = 0;
845 if (not m_SpacePointsPixelKey.empty()) {
846 SG::ReadHandle<SpacePointContainer> spacePointsPixel{m_SpacePointsPixelKey, ctx};
847 if (spacePointsPixel.isValid()) {
848 for (const SpacePointCollection* spc: *spacePointsPixel) {
849 nsp += spc->size();
850 }
851 if (static_cast<int>(nsp) > m_maxPIXsp) {
852 ATH_MSG_WARNING("Found more than "<<m_maxPIXsp<<" pixels space points in background event. Skip track finding");
853 return false;
854 }
855 }
856 }
857 // Test total number sct space points
858 //
859 nsp = 0;
860 if (not m_SpacePointsSCTKey.empty()) {
861 SG::ReadHandle<SpacePointContainer> spacePointsSCT{m_SpacePointsSCTKey, ctx};
862 if (spacePointsSCT.isValid()) {
863 for (const SpacePointCollection* spc: *spacePointsSCT) {
864 nsp += spc->size();
865 }
866 if (static_cast<int>(nsp) > m_maxSCTsp) {
867 ATH_MSG_WARNING("Found more than "<<m_maxSCTsp<<" sct space points in background event. Skip track finding");
868 return false;
869 }
870 }
871 }
872
873 return true;
874}
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
xAOD::EventInfo_v1::Background
@ Background
The beam background detectors.
Definition EventInfo_v1.h:340
xAOD::EventInfo_v1::MBTSTimeDiffHalo
@ MBTSTimeDiffHalo
Definition EventInfo_v1.h:354

◆ itkConvStrategy()

StatusCode InDet::SiSPSeededTrackFinder::itkConvStrategy ( const EventContext & ctx) const
protected

EventContext is used to specify which event.

For HI events we can use MBTS information from calorimeter

set up the seed maker for first pass

and run seeding - starting with an empty list of vertices for the first pass

set up the track maker

prepare a collection for the quality-sorted track canddiates

Get the value of the seed maker validation ntuple writing switch

Loop through all seeds from the first pass and attempt to form track candidates

copy all the tracks into trackList

record track candidates found, using combinatorial track finding, from the given seed

Call the ntuple writing method

Remove shared tracks with worse quality

Save good tracks in track collection

Note that for run-3 the tool here is configured to not perform a hole search, regardless of the 'false' argument below

Check if we have a hole search result for this guy

If yes: Write this information into the track summary.

Definition at line 574 of file SiSPSeededTrackFinder.cxx.

575{
576 ATH_MSG_DEBUG("Executing " << name() << "::itkConvStrategy");
577
578 SG::WriteHandle<TrackCollection> outputTracks{m_outputTracksKey, ctx};
579 ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
581 if (not isGoodEvent(ctx)) {
582 return StatusCode::SUCCESS;
583 }
584
585 SiSpacePointsSeedMakerEventData seedEventData;
586
587 SG::ReadHandle<ROIPhiRZContainer> calo_rois(m_caloClusterROIKey, ctx);
588 std::unique_ptr<RoiDescriptor> roiComp = std::make_unique<RoiDescriptor>(true);
589
590 if(calo_rois.isValid()) {
591 RoiDescriptor * roi =nullptr;
592 SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle{m_beamSpotKey, ctx};
593 double beamZ = beamSpotHandle->beamVtx().position().z();
594 roiComp->clear();
595 roiComp->setComposite();
596
597 const ROIPhiRZContainer &calo_rois_ref=*calo_rois;
598 for (const ROIPhiRZ &calo_roi : calo_rois_ref) {
599 double phi = calo_roi.phi();
600 if (std::abs(phi)>=M_PI && phi!=-M_PI) continue; // skip duplicates < -pi and >pi
601 double eta = calo_roi.eta();
602 double z = beamZ;
603 double roiPhiMin = phi - m_deltaPhi;
604 double roiPhiMax = phi + m_deltaPhi;
605 double roiEtaMin = eta - m_deltaEta;
606 double roiEtaMax = eta + m_deltaEta;
607 double roiZMin = beamZ - m_deltaZ;
608 double roiZMax = beamZ + m_deltaZ;
609 roi = new RoiDescriptor( eta, roiEtaMin, roiEtaMax,phi, roiPhiMin ,roiPhiMax,z,roiZMin,roiZMax);
610 roiComp->push_back(roi);
611 }
612 }
613 else {
614 ATH_MSG_ERROR("Calo RoI is not valid: " << m_caloClusterROIKey.key());
615 return StatusCode::FAILURE;
616 }
617
618 std::vector<IdentifierHash> listOfStripIds;
619 std::vector<IdentifierHash> listOfPixIds;
620
621 m_regsel_strip->lookup(ctx)->HashIDList( *roiComp, listOfStripIds );
622
624 m_seedsmaker->newRegion(ctx, seedEventData, listOfPixIds, listOfStripIds);
625 std::list<Trk::Vertex> vertexList;
627 m_seedsmaker->find3Sp(ctx, seedEventData, vertexList);
628
629 const bool PIX = true ;
630 const bool STRIP = true ;
631 InDet::ExtendedSiTrackMakerEventData_xk trackEventData(m_prdToTrackMap);
633 m_trackmaker->newEvent(ctx, trackEventData, PIX, STRIP);
634
635 bool ERR = false;
636 Counter_t counter{};
637 const InDet::SiSpacePointsSeed* seed = nullptr;
638
640 std::multimap<double, Trk::Track*> qualitySortedTrackCandidates;
641
643 bool doWriteNtuple = m_seedsmaker->getWriteNtupleBoolProperty();
644 long EvNumber = 0.; //Event number variable to be used for the validation ntuple
645
646 if (doWriteNtuple) {
647 SG::ReadHandle<xAOD::EventInfo> eventInfo(m_evtKey,ctx);
648 if(!eventInfo.isValid()) {EvNumber = -1.0;} else {EvNumber = eventInfo->eventNumber();}
649 }
650
652 while ((seed = m_seedsmaker->next(ctx, seedEventData))) {
653
654 ++counter[kNSeeds];
655
657 std::list<Trk::Track*> trackList = m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
659 for (Trk::Track* t: trackList) {
660 qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(t), t));
661 }
662
664 if(doWriteNtuple) { m_seedsmaker->writeNtuple(seed, !trackList.empty() ? trackList.front() : nullptr, ISiSpacePointsSeedMaker::StripSeed, EvNumber) ; }
665
666 if (counter[kNSeeds] >= m_maxNumberSeeds) {
667 ERR = true;
668 ++m_problemsTotal;
669 break;
670 }
671 }
672
673 m_trackmaker->endEvent(trackEventData);
674
676 filterSharedTracks(qualitySortedTrackCandidates);
677
679 for (const std::pair<const double, Trk::Track*> & qualityAndTrack: qualitySortedTrackCandidates) {
680 ++counter[kNTracks];
681 if (m_trackSummaryTool.isEnabled()) {
684 m_trackSummaryTool->computeAndReplaceTrackSummary(*qualityAndTrack.second,
685 false /* DO NOT suppress hole search*/);
686 InDet::PatternHoleSearchOutcome theOutcome;
688 if (m_writeHolesFromPattern && trackEventData.combinatorialData().findPatternHoleSearchOutcome(qualityAndTrack.second,theOutcome)){
690 qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelHoles, theOutcome.nPixelHoles);
691 qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTHoles, theOutcome.nSCTHoles);
692 qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDoubleHoles, theOutcome.nSCTDoubleHoles);
693 qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDeadSensors, theOutcome.nSCTDeads);
694 qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelDeadSensors, theOutcome.nPixelDeads);
695 }
696 }
697 outputTracks->push_back(qualityAndTrack.second);
698 }
699
700 m_counterTotal[kNSeeds] += counter[kNSeeds] ;
701
702 ++m_neventsTotal;
703
704 if (ERR) {
705 outputTracks->clear();
706 } else {
707 m_counterTotal[kNTracks] += counter[kNTracks];
708 }
709
710 // Print common event information
711 //
712 if (msgLvl(MSG::DEBUG)) {
713 dump(MSG::DEBUG, &counter);
714 }
715 return StatusCode::SUCCESS;
716}
M_PI
#define M_PI
Definition ActiveFraction.h:11
eta
Scalar eta() const
pseudorapidity method
Definition AmgMatrixBasePlugin.h:83
phi
Scalar phi() const
phi method
Definition AmgMatrixBasePlugin.h:67
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
InDet::SiSPSeededTrackFinder::Counter_t
For counters.
Definition SiSPSeededTrackFinder.h:84
InDet::SiSPSeededTrackFinder::filterSharedTracks
void filterSharedTracks(std::multimap< double, Trk::Track * > &scoredTracks) const
cleans up the collection of quality filtered tracks.
Definition SiSPSeededTrackFinder.cxx:880
InDet::SiSPSeededTrackFinder::isGoodEvent
bool isGoodEvent(const EventContext &ctx) const
EventContext is used to specify which event.
Definition SiSPSeededTrackFinder.cxx:829
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
Generate_dsid_ranseed.seed
seed
Definition Generate_dsid_ranseed.py:10
Trk::numberOfSCTHoles
@ numberOfSCTHoles
number of Holes in both sides of a SCT module
Definition Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:73
Trk::numberOfPixelHoles
@ numberOfPixelHoles
number of pixels which have a ganged ambiguity.
Definition Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:59
Trk::numberOfPixelDeadSensors
@ numberOfPixelDeadSensors
number of pixel hits with broad errors (width/sqrt(12))
Definition Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:65

◆ itkFastTrackingStrategy()

StatusCode InDet::SiSPSeededTrackFinder::itkFastTrackingStrategy ( const EventContext & ctx) const
protected

EventContext is used to specify which event.

set up the track maker

We run a single passe of seeding & track finding with PPP seeds

Set up the first pass (pixel seeds), and prepare to obtain a vertex Z estimate from the candidates we find

set up the seed maker for first pass

and run seeding - starting with an empty list of vertices for the first pass

prepare a collection for the quality-sorted track canddiates

Get the value of the seed maker validation ntuple writing switch

Loop through all seeds from the first pass and attempt to form track candidates

copy all the tracks into trackList

record track candidates found, using combinatorial track finding, from the given seed

Call the ntuple writing method

Remove shared tracks with worse quality

Save good tracks in track collection

Check if we have a hole search result for this guy

If yes: Write this information into the track summary.

Definition at line 458 of file SiSPSeededTrackFinder.cxx.

459{
460 SG::WriteHandle<TrackCollection> outputTracks{m_outputTracksKey, ctx};
461 ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
462
463 const bool PIX = true ;
464 const bool STRIP = true ;
465 InDet::ExtendedSiTrackMakerEventData_xk trackEventData(m_prdToTrackMap);
467 m_trackmaker->newTrigEvent(ctx, trackEventData, PIX, STRIP);
468
469 SiSpacePointsSeedMakerEventData seedEventData;
470
474
479
481 m_seedsmaker->newEvent(ctx, seedEventData, 0);
482 std::list<Trk::Vertex> vertexList;
484 m_seedsmaker->find3Sp(ctx, seedEventData, vertexList);
485
486 bool ERR = false;
487 Counter_t counter{};
488 const InDet::SiSpacePointsSeed* seed = nullptr;
489
491 std::multimap<double, Trk::Track*> qualitySortedTrackCandidates;
492
494 bool doWriteNtuple = m_seedsmaker->getWriteNtupleBoolProperty();
495 long EvNumber = 0.; //Event number variable to be used for the validation ntuple
496
497 if (doWriteNtuple) {
498 SG::ReadHandle<xAOD::EventInfo> eventInfo(m_evtKey,ctx);
499 if(!eventInfo.isValid()) {EvNumber = -1.0;} else {EvNumber = eventInfo->eventNumber();}
500 }
501
503 while ((seed = m_seedsmaker->next(ctx, seedEventData))) {
504
505 ++counter[kNSeeds];
506
508 std::list<Trk::Track*> trackList = m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
510 for (Trk::Track* t: trackList) {
511
512 qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(t), t));
513
514 }
516 if(doWriteNtuple) { m_seedsmaker->writeNtuple(seed, !trackList.empty() ? trackList.front() : nullptr, ISiSpacePointsSeedMaker::PixelSeed, EvNumber) ; }
517
518 if (counter[kNSeeds] >= m_maxNumberSeeds) {
519 ERR = true;
520 ++m_problemsTotal;
521 break;
522 }
523 }
524
525 m_trackmaker->endEvent(trackEventData);
526
528 filterSharedTracksFast(qualitySortedTrackCandidates);
529
531 for (const std::pair<const double, Trk::Track*> & qualityAndTrack: qualitySortedTrackCandidates) {
532 ++counter[kNTracks];
533
534 if (m_trackSummaryTool.isEnabled()) {
535 m_trackSummaryTool->computeAndReplaceTrackSummary(*qualityAndTrack.second);
536 InDet::PatternHoleSearchOutcome theOutcome;
538 if (m_writeHolesFromPattern && trackEventData.combinatorialData().findPatternHoleSearchOutcome(qualityAndTrack.second,theOutcome)){
540 qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelHoles, theOutcome.nPixelHoles);
541 qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTHoles, theOutcome.nSCTHoles);
542 qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDoubleHoles, theOutcome.nSCTDoubleHoles);
543 qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDeadSensors, theOutcome.nSCTDeads);
544 qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelDeadSensors, theOutcome.nPixelDeads);
545 }
546 }
547
548 outputTracks->push_back(qualityAndTrack.second);
549 }
550
551 m_counterTotal[kNSeeds] += counter[kNSeeds] ;
552
553 ++m_neventsTotal;
554
555 if (ERR) {
556 outputTracks->clear();
557 } else {
558 m_counterTotal[kNTracks] += counter[kNTracks];
559 }
560
561 // Print common event information
562 //
563 if (msgLvl(MSG::DEBUG)) {
564 dump(MSG::DEBUG, &counter);
565 }
566 return StatusCode::SUCCESS;
567}
InDet::SiSPSeededTrackFinder::filterSharedTracksFast
void filterSharedTracksFast(std::multimap< double, Trk::Track * > &scoredTracks) const
Definition SiSPSeededTrackFinder.cxx:928

◆ magneticFieldInit()

void InDet::SiSPSeededTrackFinder::magneticFieldInit ( )
protected

Definition at line 1110 of file SiSPSeededTrackFinder.cxx.

1111{
1112 // Build MagneticFieldProperties
1113 //
1114 if(m_fieldmode == "NoField") {
1115 m_fieldprop = Trk::MagneticFieldProperties(Trk::NoField);
1116 } else {
1117 m_fieldprop = Trk::MagneticFieldProperties(Trk::FastField);
1118 }
1119}
Trk::FastField
@ FastField
call the fast field access method of the FieldSvc
Definition MagneticFieldMode.h:20
Trk::NoField
@ NoField
Field is set to 0., 0., 0.,.
Definition MagneticFieldMode.h:18

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

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

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

◆ newStrategy()

StatusCode InDet::SiSPSeededTrackFinder::newStrategy ( const EventContext & ctx) const
protected

this method performs the track finding using the new strategy

EventContext is used to specify which event

For HI events we can use MBTS information from calorimeter

Get beam information and preparation for z -histogramming

We run two passes of seeding & track finding.

First, we use strip seeds, perform finding with them and obtain an estimate of the beam spot region from the found tracks.

Then, we run PPP-seeded tracking within the resulting z interval.

Set up the first pass (strip seeds), and prepare to obtain a vertex Z estimate from the candidates we find

set up the seed maker for first pass

and run seeding - starting with an empty list of vertices for the first pass

set up the track maker

initialize empty histograms for the vertex estimate

prepare a collection for the quality-sorted track canddiates

Get the value of the seed maker validation ntuple writing switch

Loop through all seeds from the first pass and attempt to form track candidates

we only want to fill the Z histo with the first candidate for each seed.

copy all the tracks into trackList

record track candidates found, using combinatorial track finding, from the given seed

For the first (highest quality) track from each seed, populate the vertex finding histograms

Call the ntuple writing method

Now set up the second seeding pass, using pixel seeds The seed maker will internally reconfigure itself based on the "1" argument for the "iteration" argument in this call.

perform vertex Z estimation and run second seeding pass

Estimate a Z vertex interval and, if running the new strategy, also a list of the HS candidates

pass the Z boundary pair c-array-style to satisfy existing interfaces of the seeds maker family. Trigger second seed finding pass (PPP)

Again, loop over the newly found seeds and attempt to form track candidates

Remove shared tracks with worse quality

Save good tracks in track collection

Note that for run-3 the tool here is configured to not perform a hole search, regardless of the 'false' argument below

Check if we have a hole search result for this guy

If yes: Write this information into the track summary.

Definition at line 265 of file SiSPSeededTrackFinder.cxx.

266{
267 SG::WriteHandle<TrackCollection> outputTracks{m_outputTracksKey, ctx};
268 ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
270 if (not isGoodEvent(ctx)) {
271 return StatusCode::SUCCESS;
272 }
273
275 SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle{m_beamSpotKey, ctx};
276 Trk::PerigeeSurface beamPosPerigee(beamSpotHandle->beamPos());
277
278 SiSpacePointsSeedMakerEventData seedEventData;
279
288
293
295 m_seedsmaker->newEvent(ctx, seedEventData, 0);
296 std::list<Trk::Vertex> vertexList;
298 m_seedsmaker->find3Sp(ctx, seedEventData, vertexList);
299
300 const bool PIX = true ;
301 const bool SCT = true ;
302 InDet::ExtendedSiTrackMakerEventData_xk trackEventData(m_prdToTrackMap);
304 m_trackmaker->newEvent(ctx, trackEventData, PIX, SCT);
305
307 std::vector<int> numberHistogram(m_histsize, 0);
308 std::vector<double> zWeightedHistogram(m_histsize, 0.);
309 std::vector<double> ptWeightedHistogram(m_histsize, 0.);
310
311 bool ERR = false;
312 Counter_t counter{};
313 const InDet::SiSpacePointsSeed* seed = nullptr;
314
316 std::multimap<double, Trk::Track*> qualitySortedTrackCandidates;
317
319 bool doWriteNtuple = m_seedsmaker->getWriteNtupleBoolProperty();
320 long EvNumber = 0.; //Event number variable to be used for the validation ntuple
321
322 if (doWriteNtuple) {
323 SG::ReadHandle<xAOD::EventInfo> eventInfo(m_evtKey,ctx);
324 if(!eventInfo.isValid()) {EvNumber = -1.0;} else {EvNumber = eventInfo->eventNumber();}
325 }
326
328 while ((seed = m_seedsmaker->next(ctx, seedEventData))) {
329
330 ++counter[kNSeeds];
332 bool firstTrack{true};
333
335 std::list<Trk::Track*> trackList = m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
337 for (Trk::Track* t: trackList) {
338
339 qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(t), t));
340
341 if (firstTrack && m_doDumpGBTSTrainingDataLRT) {
342 collectGBTSTrainingData(t);
343 }
344
346 if (firstTrack and not m_ITKGeometry) {
347 fillZHistogram(t, beamPosPerigee, numberHistogram, zWeightedHistogram, ptWeightedHistogram);
348 }
349 firstTrack = false;
350 }
352 if(doWriteNtuple) { m_seedsmaker->writeNtuple(seed, !trackList.empty() ? trackList.front() : nullptr, ISiSpacePointsSeedMaker::StripSeed, EvNumber) ; }
353
354
355 if (counter[kNSeeds] >= m_maxNumberSeeds) {
356 ERR = true;
357 ++m_problemsTotal;
358 break;
359 }
360 }
361
366 if(not m_SpacePointsPixelKey.empty()) {
367 m_seedsmaker->newEvent(ctx, seedEventData, 1);
368
370 std::pair<double,double> zBoundaries;
371 if (not m_ITKGeometry) {
373 findZvertex(vertexList, zBoundaries, numberHistogram, zWeightedHistogram, ptWeightedHistogram);
376 m_seedsmaker->find3Sp(ctx, seedEventData, vertexList, &(zBoundaries.first));
377 } else {
378 m_seedsmaker->find3Sp(ctx, seedEventData, vertexList);
379 }
380
382 while ((seed = m_seedsmaker->next(ctx, seedEventData))) {
383
384 ++counter[kNSeeds];
385
386 std::list<Trk::Track*> trackList = m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
387
388 for (Trk::Track* t: trackList) {
389 qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(t), t));
390 }
391
392 if(doWriteNtuple) { m_seedsmaker->writeNtuple(seed, !trackList.empty() ? trackList.front() : nullptr, ISiSpacePointsSeedMaker::PixelSeed, EvNumber); }
393
394 if (counter[kNSeeds] >= m_maxNumberSeeds) {
395 ERR = true;
396 ++m_problemsTotal;
397 break;
398 }
399 }
400 } else {
401 ATH_MSG_WARNING("SpacePointsPixelKey is empty. Skipping the second seeding pass that uses pixel seeds.");
402 }
403
404 m_trackmaker->endEvent(trackEventData);
405
407 filterSharedTracks(qualitySortedTrackCandidates);
408
410 for (const std::pair<const double, Trk::Track*> & qualityAndTrack: qualitySortedTrackCandidates) {
411 ++counter[kNTracks];
412 if (m_trackSummaryTool.isEnabled()) {
415 m_trackSummaryTool->computeAndReplaceTrackSummary(*qualityAndTrack.second,
416 false /* DO NOT suppress hole search*/);
417 InDet::PatternHoleSearchOutcome theOutcome;
419 if (m_writeHolesFromPattern && trackEventData.combinatorialData().findPatternHoleSearchOutcome(qualityAndTrack.second,theOutcome)){
421 qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelHoles, theOutcome.nPixelHoles);
422 qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTHoles, theOutcome.nSCTHoles);
423 qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDoubleHoles, theOutcome.nSCTDoubleHoles);
424 qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDeadSensors, theOutcome.nSCTDeads);
425 qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelDeadSensors, theOutcome.nPixelDeads);
426 }
427 }
428 outputTracks->push_back(qualityAndTrack.second);
429 if (m_doDumpGBTSTrainingData) {
430 collectGBTSTrainingData(qualityAndTrack.second);
431 }
432 }
433
434 m_counterTotal[kNSeeds] += counter[kNSeeds] ;
435
436 ++m_neventsTotal;
437
438 if (ERR) {
439 outputTracks->clear();
440 } else {
441 m_counterTotal[kNTracks] += counter[kNTracks];
442 }
443
444 // Print common event information
445 //
446 if (msgLvl(MSG::DEBUG)) {
447 dump(MSG::DEBUG, &counter);
448 }
449 return StatusCode::SUCCESS;
450}
SCT
@ SCT
Definition RegSelEnums.h:25
InDet::SiSPSeededTrackFinder::fillZHistogram
void fillZHistogram(const Trk::Track *Tr, const Trk::PerigeeSurface &beamlinePerigee, std::vector< int > &numberWeightedhistogram, std::vector< double > &zWeightedHistogram, std::vector< double > &ptWeightedHistogram) const
fills three z0 histograms (non-weighted, weighted by z, and weighted by pt) with the track z at the b...
Definition SiSPSeededTrackFinder.cxx:988
InDet::SiSPSeededTrackFinder::collectGBTSTrainingData
void collectGBTSTrainingData(const Trk::Track *) const
Definition SiSPSeededTrackFinder.cxx:1147
InDet::SiSPSeededTrackFinder::findZvertex
void findZvertex(std::list< Trk::Vertex > &vertexList, std::pair< double, double > &zBoundaries, const std::vector< int > &numberWeightedhistogram, const std::vector< double > &zWeightedHistogram, const std::vector< double > &ptWeightedHistogram) const
estimates a set of vertex positions and a z interval for the second track finding pass using the inpu...
Definition SiSPSeededTrackFinder.cxx:1036

◆ oldStrategy()

StatusCode InDet::SiSPSeededTrackFinder::oldStrategy ( const EventContext & ctx) const
protected

this method performs the track finding using the old strategy

EventContext is used to specify which event

For HI events we can use MBTS information from calorimeter

Definition at line 180 of file SiSPSeededTrackFinder.cxx.

181{
182 SG::WriteHandle<TrackCollection> outputTracks{m_outputTracksKey, ctx};
183 ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
185 if (not isGoodEvent(ctx)) {
186 return StatusCode::SUCCESS;
187 }
188
189 SiSpacePointsSeedMakerEventData seedEventData;
190 bool ZVE = false;
191 if (m_useZvertexTool) {
192 std::list<Trk::Vertex> vertices = m_zvertexmaker->newEvent(ctx, seedEventData);
193 if (not vertices.empty()) ZVE = true;
194 m_seedsmaker->find3Sp(ctx, seedEventData, vertices);
195 } else {
196 m_seedsmaker->newEvent(ctx, seedEventData, -1);
197 std::list<Trk::Vertex> vertexList;
198 m_seedsmaker->find3Sp(ctx, seedEventData, vertexList);
199 }
200
201 const bool PIX = true;
202 const bool SCT = true;
203 InDet::ExtendedSiTrackMakerEventData_xk trackEventData(m_prdToTrackMap);
204 m_trackmaker->newEvent(ctx, trackEventData, PIX, SCT);
205
206 bool ERR = false;
207 Counter_t counter{};
208 const InDet::SiSpacePointsSeed* seed = nullptr;
209 std::multimap<double, Trk::Track*> qualitySortedTrackCandidates;
210 // Loop through all seed and reconsrtucted tracks collection preparation
211 //
212 while ((seed = m_seedsmaker->next(ctx, seedEventData))) {
213 ++counter[kNSeeds];
214 std::list<Trk::Track*> trackList = m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
215 for (Trk::Track* t: trackList) {
216 qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(t), t));
217 }
218 if (not ZVE and (counter[kNSeeds] >= m_maxNumberSeeds)) {
219 ERR = true;
220 ++m_problemsTotal;
221 break;
222 }
223 }
224 m_trackmaker->endEvent(trackEventData);
225
226 // Remove shared tracks with worse quality
227 //
228 filterSharedTracks(qualitySortedTrackCandidates);
229
230 // Save good tracks in track collection
231 //
232 for (const std::pair<const double, Trk::Track*> & qualityAndTrack: qualitySortedTrackCandidates) {
233 ++counter[kNTracks];
234 if (m_trackSummaryTool.isEnabled()) {
235 m_trackSummaryTool->computeAndReplaceTrackSummary(*(qualityAndTrack.second),
236 false /* DO NOT suppress hole search*/);
237 }
238 outputTracks->push_back(qualityAndTrack.second);
239 }
240
241 m_counterTotal[kNSeeds] += counter[kNSeeds];
242
243 if (ZVE) ++m_neventsTotalV;
244 else ++m_neventsTotal;
245
246 if (ERR) {
247 outputTracks->clear();
248 } else {
249 m_counterTotal[kNTracks] += counter[kNTracks];
250 }
251
252 // Print common event information
253 //
254 if (msgLvl(MSG::DEBUG)) {
255 dump(MSG::DEBUG, &counter);
256 }
257
258 return StatusCode::SUCCESS;
259}

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

◆ passEtaDepCuts()

bool InDet::SiSPSeededTrackFinder::passEtaDepCuts ( const Trk::Track * track,
int nClusters,
int nFreeClusters,
int nPixels ) const
protected

Definition at line 1126 of file SiSPSeededTrackFinder.cxx.

1130{
1131 Trk::TrackStates::const_iterator m = track->trackStateOnSurfaces()->begin();
1132 const Trk::TrackParameters* par = (*m)->trackParameters();
1133 if(!par) return false;
1134
1135 double eta = std::abs(par->eta());
1136 if(nClusters < m_etaDependentCutsSvc->getMinSiHitsAtEta(eta)) return false;
1137 if(nFreeClusters < m_etaDependentCutsSvc->getMinSiNotSharedAtEta(eta)) return false;
1138 if(nClusters-nFreeClusters > m_etaDependentCutsSvc->getMaxSharedAtEta(eta)) return false;
1139 if(nPixels < m_etaDependentCutsSvc->getMinPixelHitsAtEta(eta)) return false;
1140
1141 if(par->pT() < m_etaDependentCutsSvc->getMinPtAtEta(eta)) return false;
1142 if(!(*m)->type(Trk::TrackStateOnSurface::Perigee)) return true ;
1143 if(std::abs(par->localPosition()[0]) > m_etaDependentCutsSvc->getMaxPrimaryImpactAtEta(eta)) return false;
1144 return true;
1145}
DataVector< const Trk::TrackStateOnSurface >::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:838
Trk::TrackStateOnSurface::Perigee
@ Perigee
This represents a perigee, and so will contain a Perigee object only.
Definition TrackStateOnSurface.h:117

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

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

◆ 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 }
AthCommonReentrantAlgorithm::setFilterPassed
virtual void setFilterPassed(bool state, const EventContext &ctx) const
Definition AthCommonReentrantAlgorithm.h:100

◆ 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 HypoBase, and InputMakerBase.

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}
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override

◆ sysStart()

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

Handle START transition.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/2]

Counter_t m_counterTotal InDet::SiSPSeededTrackFinder::ATLAS_THREAD_SAFE {}
mutableprotected

Definition at line 167 of file SiSPSeededTrackFinder.h.

167{};

◆ ATLAS_THREAD_SAFE [2/2]

std::map<int, std::map<int, unsigned long> > m_GBTSTrainingData InDet::SiSPSeededTrackFinder::ATLAS_THREAD_SAFE
mutableprotected

Definition at line 176 of file SiSPSeededTrackFinder.h.

◆ m_alwaysProtectAgainstBusyEvent

BooleanProperty InDet::SiSPSeededTrackFinder::m_alwaysProtectAgainstBusyEvent {this, "alwaysProtectAgainstBusyEvents", false, "Flag that enables checking always maxNumberPIXsp and maxNumberSCTsp"}
protected

Definition at line 105 of file SiSPSeededTrackFinder.h.

105{this, "alwaysProtectAgainstBusyEvents", false, "Flag that enables checking always maxNumberPIXsp and maxNumberSCTsp"};

◆ m_beamSpotKey

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

Definition at line 137 of file SiSPSeededTrackFinder.h.

137{this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"};

◆ m_caloClusterROIKey

SG::ReadHandleKey<ROIPhiRZContainer> InDet::SiSPSeededTrackFinder::m_caloClusterROIKey {this, "EMROIPhiRZContainer", "InDetCaloClusterROIPhiRZ15GeVUnordered", "Name of the calo cluster ROIs in Phi,R,Z parameterization"}
protected

Definition at line 135 of file SiSPSeededTrackFinder.h.

135{this, "EMROIPhiRZContainer", "InDetCaloClusterROIPhiRZ15GeVUnordered", "Name of the calo cluster ROIs in Phi,R,Z parameterization"};

◆ m_deltaEta

DoubleProperty InDet::SiSPSeededTrackFinder::m_deltaEta {this, "dEtaCaloRoI", .1}
protected

Definition at line 112 of file SiSPSeededTrackFinder.h.

112{this, "dEtaCaloRoI", .1};

◆ m_deltaPhi

DoubleProperty InDet::SiSPSeededTrackFinder::m_deltaPhi {this, "dPhiCaloRoI", .25}
protected

Definition at line 113 of file SiSPSeededTrackFinder.h.

113{this, "dPhiCaloRoI", .25};

◆ m_deltaZ

DoubleProperty InDet::SiSPSeededTrackFinder::m_deltaZ {this, "dZCaloRoI", 300.}
protected

Definition at line 114 of file SiSPSeededTrackFinder.h.

114{this, "dZCaloRoI", 300.};

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

BooleanProperty InDet::SiSPSeededTrackFinder::m_doDumpGBTSTrainingData {this, "doDumpGBTSTrainingData", false, "write training data used to create GBTS connection table"}
protected

Definition at line 116 of file SiSPSeededTrackFinder.h.

116{this, "doDumpGBTSTrainingData", false, "write training data used to create GBTS connection table"};

◆ m_doDumpGBTSTrainingDataLRT

BooleanProperty InDet::SiSPSeededTrackFinder::m_doDumpGBTSTrainingDataLRT {this, "doDumpGBTSTrainingDataLRT", false, "write LRT training data used to create GBTS connection table"}
protected

Definition at line 117 of file SiSPSeededTrackFinder.h.

117{this, "doDumpGBTSTrainingDataLRT", false, "write LRT training data used to create GBTS connection table"};

◆ m_doFastTracking

BooleanProperty InDet::SiSPSeededTrackFinder::m_doFastTracking {this, "doFastTracking", false, "ITk fast tracking reco"}
protected

Definition at line 103 of file SiSPSeededTrackFinder.h.

103{this, "doFastTracking", false, "ITk fast tracking reco"};

◆ m_etaDependentCutsSvc

ServiceHandle<IInDetEtaDependentCutsSvc> InDet::SiSPSeededTrackFinder::m_etaDependentCutsSvc {this, "InDetEtaDependentCutsSvc", "InDetEtaDependentCutsSvc"}
protected

service to get cut values depending on different variable

Definition at line 162 of file SiSPSeededTrackFinder.h.

162{this, "InDetEtaDependentCutsSvc", "InDetEtaDependentCutsSvc"};

◆ m_evtKey

SG::ReadHandleKey<xAOD::EventInfo> InDet::SiSPSeededTrackFinder::m_evtKey {this, "EventInfoKey", "EventInfo"}
protected

Definition at line 131 of file SiSPSeededTrackFinder.h.

131{this, "EventInfoKey", "EventInfo"};

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

StringProperty InDet::SiSPSeededTrackFinder::m_fieldmode {this, "MagneticFieldMode", "MapSolenoid"}
protected

Definition at line 115 of file SiSPSeededTrackFinder.h.

115{this, "MagneticFieldMode", "MapSolenoid"};

◆ m_fieldprop

Trk::MagneticFieldProperties InDet::SiSPSeededTrackFinder::m_fieldprop
protected

Definition at line 156 of file SiSPSeededTrackFinder.h.

◆ m_GBTSTrainingDataFileName

StringProperty InDet::SiSPSeededTrackFinder::m_GBTSTrainingDataFileName {this, "GBTSTrainingDataFileName", "layer_connection_table.csv", "file to write training data used to create GBTS connection table"}
protected

Definition at line 119 of file SiSPSeededTrackFinder.h.

119{this, "GBTSTrainingDataFileName", "layer_connection_table.csv", "file to write training data used to create GBTS connection table"};

◆ m_GBTSTrainingDataMutex

std::mutex InDet::SiSPSeededTrackFinder::m_GBTSTrainingDataMutex
mutableprotected

Definition at line 175 of file SiSPSeededTrackFinder.h.

◆ m_histsize

IntegerProperty InDet::SiSPSeededTrackFinder::m_histsize {this, "HistSize", 1400}
protected

Definition at line 109 of file SiSPSeededTrackFinder.h.

109{this, "HistSize", 1400};

◆ m_imcut

double InDet::SiSPSeededTrackFinder::m_imcut {2.}
protected

Definition at line 125 of file SiSPSeededTrackFinder.h.

125{2.};

◆ m_ITKGeometry

BooleanProperty InDet::SiSPSeededTrackFinder::m_ITKGeometry {this, "ITKGeometry", false, "Flag to specify if it is ITK geometry"}
protected

Definition at line 101 of file SiSPSeededTrackFinder.h.

101{this, "ITKGeometry", false, "Flag to specify if it is ITK geometry"};

◆ m_maxNumberSeeds

IntegerProperty InDet::SiSPSeededTrackFinder::m_maxNumberSeeds {this, "maxNumberSeeds", 3000000, "Max. number used seeds"}
protected

Definition at line 104 of file SiSPSeededTrackFinder.h.

104{this, "maxNumberSeeds", 3000000, "Max. number used seeds"};

◆ m_maxPIXsp

IntegerProperty InDet::SiSPSeededTrackFinder::m_maxPIXsp {this, "maxNumberPIXsp", 150000, "Max. number pixels space points"}
protected

Definition at line 106 of file SiSPSeededTrackFinder.h.

106{this, "maxNumberPIXsp", 150000, "Max. number pixels space points"};

◆ m_maxSCTsp

IntegerProperty InDet::SiSPSeededTrackFinder::m_maxSCTsp {this, "maxNumberSCTsp", 500000, "Max. number sct space points"}
protected

Definition at line 107 of file SiSPSeededTrackFinder.h.

107{this, "maxNumberSCTsp", 500000, "Max. number sct space points"};

◆ m_mbtsKey

SG::ReadDecorHandleKey<xAOD::EventInfo> InDet::SiSPSeededTrackFinder::m_mbtsKey {this, "MBTSKey", m_evtKey, "MBTSBackground"}
protected

Definition at line 139 of file SiSPSeededTrackFinder.h.

139{this, "MBTSKey", m_evtKey, "MBTSBackground"};

◆ m_neventsTotal

std::atomic_int InDet::SiSPSeededTrackFinder::m_neventsTotal {0}
mutableprotected

Number events.

Definition at line 169 of file SiSPSeededTrackFinder.h.

169{0};

◆ m_neventsTotalV

std::atomic_int InDet::SiSPSeededTrackFinder::m_neventsTotalV {0}
mutableprotected

Number events.

Definition at line 170 of file SiSPSeededTrackFinder.h.

170{0};

◆ m_nfreeCut

IntegerProperty InDet::SiSPSeededTrackFinder::m_nfreeCut {this, "FreeClustersCut", 1, "Min number free clusters"}
protected

Definition at line 108 of file SiSPSeededTrackFinder.h.

108{this, "FreeClustersCut", 1, "Min number free clusters"};

◆ m_numGBTSTrainingData

std::atomic_ulong InDet::SiSPSeededTrackFinder::m_numGBTSTrainingData {0}
mutableprotected

Definition at line 177 of file SiSPSeededTrackFinder.h.

177{0};

◆ m_nvertex

IntegerProperty InDet::SiSPSeededTrackFinder::m_nvertex {this, "maxVertices", 4}
protected

Definition at line 110 of file SiSPSeededTrackFinder.h.

110{this, "maxVertices", 4};

◆ m_outputTracksKey

SG::WriteHandleKey<TrackCollection> InDet::SiSPSeededTrackFinder::m_outputTracksKey {this, "TracksLocation", "SiSPSeededTracks"}
protected

Definition at line 141 of file SiSPSeededTrackFinder.h.

141{this, "TracksLocation", "SiSPSeededTracks"};

◆ m_prdToTrackMap

SG::ReadHandleKey<Trk::PRDtoTrackMap> InDet::SiSPSeededTrackFinder::m_prdToTrackMap {this,"PRDtoTrackMap",""}
protected

Definition at line 134 of file SiSPSeededTrackFinder.h.

134{this,"PRDtoTrackMap",""};

◆ m_problemsTotal

std::atomic_int InDet::SiSPSeededTrackFinder::m_problemsTotal {0}
mutableprotected

Number events with number seeds > maxNumber.

Definition at line 171 of file SiSPSeededTrackFinder.h.

171{0};

◆ m_problemsTotalV

std::atomic_int InDet::SiSPSeededTrackFinder::m_problemsTotalV {0}
mutableprotected

Number events with number seeds > maxNumber.

Definition at line 172 of file SiSPSeededTrackFinder.h.

172{0};

◆ m_proptool

PublicToolHandle<Trk::IPatternParametersPropagator> InDet::SiSPSeededTrackFinder::m_proptool {this, "PropagatorTool", "Trk::RungeKuttaPropagator/InDetPropagator"}
protected

Definition at line 149 of file SiSPSeededTrackFinder.h.

149{this, "PropagatorTool", "Trk::RungeKuttaPropagator/InDetPropagator"};

◆ m_pTcut

double InDet::SiSPSeededTrackFinder::m_pTcut {500}
protected

Definition at line 124 of file SiSPSeededTrackFinder.h.

124{500};

◆ m_regsel_strip

ToolHandle<IRegSelTool> InDet::SiSPSeededTrackFinder::m_regsel_strip { this, "RegSelTool_Strip", "RegSelTool/RegSelTool_SCT" }
protected

Definition at line 151 of file SiSPSeededTrackFinder.h.

151{ this, "RegSelTool_Strip", "RegSelTool/RegSelTool_SCT" };

◆ m_removeShortSegments

BooleanProperty InDet::SiSPSeededTrackFinder::m_removeShortSegments {this, "removeShortSegments", false, "remove short segments from GBTS connection table"}
protected

Definition at line 118 of file SiSPSeededTrackFinder.h.

118{this, "removeShortSegments", false, "remove short segments from GBTS connection table"};

◆ m_seedsmaker

ToolHandle<ISiSpacePointsSeedMaker> InDet::SiSPSeededTrackFinder::m_seedsmaker {this, "SeedsTool", "InDet::SiSpacePointsSeedMaker_ATLxk/InDetSpSeedsMaker", "Space poins seed maker"}
protected

Definition at line 146 of file SiSPSeededTrackFinder.h.

146{this, "SeedsTool", "InDet::SiSpacePointsSeedMaker_ATLxk/InDetSpSeedsMaker", "Space poins seed maker"};

◆ m_SpacePointsPixelKey

SG::ReadHandleKey<SpacePointContainer> InDet::SiSPSeededTrackFinder::m_SpacePointsPixelKey {this, "SpacePointsPixelName", "PixelSpacePoints"}
protected

Definition at line 133 of file SiSPSeededTrackFinder.h.

133{this, "SpacePointsPixelName", "PixelSpacePoints"};

◆ m_SpacePointsSCTKey

SG::ReadHandleKey<SpacePointContainer> InDet::SiSPSeededTrackFinder::m_SpacePointsSCTKey {this, "SpacePointsSCTName", "SCT_SpacePoints"}
protected

Definition at line 132 of file SiSPSeededTrackFinder.h.

132{this, "SpacePointsSCTName", "SCT_SpacePoints"};

◆ m_trackmaker

ToolHandle<ISiTrackMaker> InDet::SiSPSeededTrackFinder::m_trackmaker {this, "TrackTool", "InDet::SiTrackMaker_xk/InDetSiTrackMaker", "Track maker"}
protected

Definition at line 148 of file SiSPSeededTrackFinder.h.

148{this, "TrackTool", "InDet::SiTrackMaker_xk/InDetSiTrackMaker", "Track maker"};

◆ m_trackSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> InDet::SiSPSeededTrackFinder::m_trackSummaryTool {this, "TrackSummaryTool", "InDetTrackSummaryToolNoHoleSearch"}
protected

Definition at line 150 of file SiSPSeededTrackFinder.h.

150{this, "TrackSummaryTool", "InDetTrackSummaryToolNoHoleSearch"};

◆ m_useITkConvSeeded

BooleanProperty InDet::SiSPSeededTrackFinder::m_useITkConvSeeded {this, "useITkConvSeeded", false, "ITk EM-seeded conversion reco"}
protected

Definition at line 102 of file SiSPSeededTrackFinder.h.

102{this, "useITkConvSeeded", false, "ITk EM-seeded conversion reco"};

◆ m_useMBTS

BooleanProperty InDet::SiSPSeededTrackFinder::m_useMBTS {this, "useMBTSTimeDiff", false}
protected

Definition at line 98 of file SiSPSeededTrackFinder.h.

98{this, "useMBTSTimeDiff", false};

◆ m_useNewStrategy

BooleanProperty InDet::SiSPSeededTrackFinder::m_useNewStrategy {this, "useNewStrategy", false}
protected

Definition at line 99 of file SiSPSeededTrackFinder.h.

99{this, "useNewStrategy", false};

◆ m_useZBoundaryFinding

BooleanProperty InDet::SiSPSeededTrackFinder::m_useZBoundaryFinding {this, "useZBoundFinding", false}
protected

Definition at line 100 of file SiSPSeededTrackFinder.h.

100{this, "useZBoundFinding", false};

◆ m_useZvertexTool

BooleanProperty InDet::SiSPSeededTrackFinder::m_useZvertexTool {this, "useZvertexTool", true}
protected

Definition at line 96 of file SiSPSeededTrackFinder.h.

96{this, "useZvertexTool", true};

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_writeHolesFromPattern

BooleanProperty InDet::SiSPSeededTrackFinder::m_writeHolesFromPattern {this, "writeHolesFromPattern", false,"Flag to activate writing hole info from the pattern recognition"}
protected

Definition at line 97 of file SiSPSeededTrackFinder.h.

97{this, "writeHolesFromPattern", false,"Flag to activate writing hole info from the pattern recognition"};

◆ m_zcut

DoubleProperty InDet::SiSPSeededTrackFinder::m_zcut {this, "Zcut", 350.}
protected

Definition at line 111 of file SiSPSeededTrackFinder.h.

111{this, "Zcut", 350.};

◆ m_zstep

double InDet::SiSPSeededTrackFinder::m_zstep {0.}
protected

Definition at line 126 of file SiSPSeededTrackFinder.h.

126{0.};

◆ m_zvertexmaker

ToolHandle<ISiZvertexMaker> InDet::SiSPSeededTrackFinder::m_zvertexmaker {this, "ZvertexTool", "InDet::SiZvertexMaker_xk/InDetSiZvertexMaker", "Space poins z-vertex maker"}
protected

Definition at line 147 of file SiSPSeededTrackFinder.h.

147{this, "ZvertexTool", "InDet::SiZvertexMaker_xk/InDetSiZvertexMaker", "Space poins z-vertex maker"};
The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0