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 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
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
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 EventContext &ctx, 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 48 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 78 of file SiSPSeededTrackFinder.h.

{kNSeeds, kNTracks, kNCounter};

Constructor & Destructor Documentation

SiSPSeededTrackFinder()

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

Constructor.

Definition at line 70 of file SiSPSeededTrackFinder.cxx.

                                                 : AthReentrantAlgorithm(name, pSvcLocator)
{
}

~SiSPSeededTrackFinder()

virtual InDet::SiSPSeededTrackFinder::~SiSPSeededTrackFinder ( )

virtualdefault

Member Function Documentation

collectGBTSTrainingData()

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

protected

Definition at line 1157 of file SiSPSeededTrackFinder.cxx.

                                                                                    {
 
  struct VLM_Data {
    int vol_id, lay_id, mod_id;
    float m_x, m_y, m_z;
  };
 
  const PixelID* IDp = 0;
  const SCT_ID* IDs = 0;
 
  if (detStore()->retrieve(IDp, "PixelID").isFailure()) {
    ATH_MSG_FATAL("Could not get Pixel ID helper");
  }
 
  if (detStore()->retrieve(IDs, "SCT_ID").isFailure()) {
    ATH_MSG_FATAL("Could not get SCT ID helper");
  }
 
  if (!IDs && !IDp) return;
 
  ++m_numGBTSTrainingData;
 
  std::vector<VLM_Data> vlm;
 
  for (const auto* s : *track->trackStateOnSurfaces()) {
    if (!s->type(Trk::TrackStateOnSurface::Measurement)) continue;
 
    const Trk::MeasurementBase* mb = s->measurementOnTrack();
    if (!mb) continue;
 
    const Trk::RIO_OnTrack* ri = dynamic_cast<const Trk::RIO_OnTrack*>(mb);
    if (!ri) continue;
 
    const Trk::PrepRawData* rd = ri->prepRawData();
    if (!rd) continue;
 
    const InDet::SiCluster* si = dynamic_cast<const InDet::SiCluster*>(rd);
    if (!si) continue;
 
    const Amg::Vector3D& pos = s->trackParameters()->position();
 
    if (dynamic_cast<const InDet::PixelCluster*>(si)) {  // Pixel
 
      Identifier id = si->identify();
 
      int bec = IDp->barrel_ec(id);
 
      int vol_id = 8;
 
      if (bec == -2) vol_id = 7;
      if (bec == 2) vol_id = 9;
 
      if (bec < -2 || bec > 2) continue;
 
      int lay_id = IDp->layer_disk(id);
      int eta_mod = IDp->eta_module(id);
      int phi_mod = IDp->phi_module(id);
 
      Identifier wafer_id = IDp->wafer_id(bec, lay_id, phi_mod, eta_mod);
 
      int mod_id = IDp->wafer_hash(wafer_id);
 
      int new_vol = 0, new_lay = 0;
 
      if (vol_id == 7 || vol_id == 9) {
        new_vol = 10 * vol_id + lay_id;
        new_lay = eta_mod;
      } else if (vol_id == 8) {
        new_lay = 0;
        new_vol = 10 * vol_id + lay_id;
      }
      if (vol_id != 0)
        vlm.emplace_back(new_vol, new_lay, mod_id, pos.x(), pos.y(), pos.z());
    }
 
    if (IDs && dynamic_cast<const InDet::SCT_Cluster*>(si)) {  // SCT
 
      Identifier id = si->identify();
 
      int bec = IDs->barrel_ec(id);
 
      int vol_id = 13;
 
      if (bec < 0) vol_id = 12;
      if (bec > 0) vol_id = 14;
 
      int lay_id = IDs->layer_disk(id);
      int eta_mod = IDs->eta_module(id);
      int phi_mod = IDs->phi_module(id);
      int side = IDs->side(id);
 
      Identifier wafer_id = IDs->wafer_id(bec, lay_id, phi_mod, eta_mod, side);
 
      int mod_id = IDs->wafer_hash(wafer_id);
 
      vlm.emplace_back(vol_id, lay_id, mod_id, pos.x(), pos.y(), pos.z());
    }
  }
 
  // remove single-strip cases where no spacepoint exists
 
  std::vector<VLM_Data> vlm2;
 
  for (std::size_t it1 = 0; it1 < vlm.size() - 1; it1++) {
    if (vlm.at(it1).vol_id > 14) {  // Pixels
      vlm2.push_back(vlm.at(it1));
      continue;
    }
 
    std::size_t it2 = it1 + 1;
 
    int src = vlm.at(it1).vol_id * 1000 + vlm.at(it1).lay_id;
    int dst = vlm.at(it2).vol_id * 1000 + vlm.at(it2).lay_id;
 
    if (src == dst) {  // a spacepoint can be formed
      vlm2.push_back(vlm.at(it1));
      vlm2.push_back(vlm.at(it2));
      it1 = it2;
      continue;
    }
  }
 
  // remove track segments which are too short
  if (m_removeShortSegments) {
 
    constexpr float minDist = 20.0;
 
    for (auto it = std::next(vlm2.begin()); it != vlm2.end(); ) {
      auto jt = std::prev(it);
      float dx = it->m_x - jt->m_x;
      float dy = it->m_y - jt->m_y;
      float dz = it->m_z - jt->m_z;
 
      float dist = std::sqrt(dx*dx + dy*dy + dz*dz);
 
      if (dist < minDist) it = vlm2.erase(it);
      else ++it;
    }
  }
 
  std::scoped_lock trainingDataLock(m_GBTSTrainingDataMutex);
 
  for (std::size_t it1 = 0; it1 < vlm2.size() - 1; ++it1) {
    std::size_t it2 = it1 + 1;
 
    int src = vlm2.at(it1).vol_id * 1000 + vlm2.at(it1).lay_id;
    int dst = vlm2.at(it2).vol_id * 1000 + vlm2.at(it2).lay_id;
 
    if (src != dst) {  // skip the same layer
      auto [im1, new1] = m_GBTSTrainingData.insert({src, {}});
      auto [im2, new2] = im1->second.insert({dst, 1ul});
      if (!new2) im2->second++;
    }
  }
}

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.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

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.

{ return m_detStore; }

dump()

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

protected

Definition at line 748 of file SiSPSeededTrackFinder.cxx.

{
  msg(assign_level) <<std::endl;
  MsgStream& out_msg=msg();
  if (counter) dumpevent(out_msg ,*counter);
  else dumptools(out_msg);
  out_msg << endmsg;
  return out_msg;
}

dumpevent()

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

protected

Definition at line 802 of file SiSPSeededTrackFinder.cxx.

{
  out<<"|-------------------------------------------------------------------";
  out<<"---------------------------------|"
     <<std::endl;
  out<<"|  Investigated "
     <<std::setw(9)<<counter[kNSeeds]<<" space points seeds and found ";
  out<<std::setw(9)<<counter[kNTracks];
  if      (m_ITKGeometry        ) out<<" tracks using new strategy for ITK   |"<<std::endl; 
  else if (m_useNewStrategy     ) out<<" tracks using new strategy ("<<std::setw(2)<<  m_nvertex <<")      |"<<std::endl;
  else if (m_useZBoundaryFinding) out<<" tracks using old strategy with Zb   |"<<std::endl;
  else                            out<<" tracks using old strategy           |"<<std::endl;
 
  out<<"|-------------------------------------------------------------------";
  out<<"---------------------------------|"
     <<std::endl;
  if (m_problemsTotal or m_problemsTotalV) {
    out<<"|  Events       "
       <<std::setw(7)<<m_neventsTotal   <<"            without Z-vertz   "
       <<std::setw(7)<<m_neventsTotalV  <<"            with    Z-vertex         |"
       <<std::endl;
    out<<"|  Problems     "
       <<std::setw(7)<<m_problemsTotal  <<"            without Z-vertz   "
       <<std::setw(7)<<m_problemsTotalV <<"            with    Z-vertex         |"
       <<std::endl;
    out<<"|-------------------------------------------------------------------";
    out<<"-----------------------------|"
       <<std::endl;
  }
  return out;
}

dumpGBTSTrainingData()

void InDet::SiSPSeededTrackFinder::dumpGBTSTrainingData ( ) const

protected

Definition at line 1313 of file SiSPSeededTrackFinder.cxx.

                                                            {
  std::ofstream tableFile(m_GBTSTrainingDataFileName);
  tableFile << "from,to,probability,flow\n";
 
  unsigned long nTotal = 0;
  for (const auto& [src, conns] : m_GBTSTrainingData) {
    unsigned long nTotalDst = 0;
    for (const auto& [dst, n] : conns) {
      nTotalDst += n;
    }
    nTotal += nTotalDst;
    if (nTotalDst == 0) [[unlikely]] {
      throw std::runtime_error("InDet::SiSPSeededTrackFinder::dumpGBTSTrainingData: nTotalDst divisor is zero");
    }
    for (const auto& [dst, n] : conns) {
      double prob = double(n) / double(nTotalDst);
      tableFile << src << ", " << dst << ", " << std::fixed << std::setprecision(6) << prob << ", " << prob << '\n';
    }
  }
  ATH_MSG_INFO("GBTS training data from " << m_numGBTSTrainingData << " tracks with " << nTotal << " pairs written to " << m_GBTSTrainingDataFileName.value());
}

dumptools()

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

protected

Definition at line 762 of file SiSPSeededTrackFinder.cxx.

{
  int n = 65-m_zvertexmaker.type().size();
  std::string s1; for (int i=0; i<n; ++i) s1.append(" "); s1.append("|");
  n     = 65-m_seedsmaker.type().size();
  std::string s2; for (int i=0; i<n; ++i) s2.append(" "); s2.append("|");
  n     = 65-m_trackmaker.type().size();
  std::string s3; for (int i=0; i<n; ++i) s3.append(" "); s3.append("|");
  n     = 65-m_outputTracksKey.key().size();
  std::string s4; for (int i=0; i<n; ++i) s4.append(" "); s4.append("|");
 
  std::string s5; 
  if (m_useZvertexTool) s5= "Yes"; else s5 = "No";
  n     = 65-s5.size(); for (int i=0; i<n; ++i) s5.append(" "); s5.append("|");
  
  out<<"|----------------------------------------------------------------"
     <<"----------------------------------------------------|"
     <<std::endl;
  out<<"| Use primary vertices z-coordinates      finding?| "<<s5
     <<std::endl;
  if (m_useZvertexTool) {
    out<<"| Tool for primary vertices z-coordinates finding | "<<m_zvertexmaker.type()<<s1
       <<std::endl;
  }
  out<<"| Tool for space points seeds             finding | "<<m_seedsmaker.type()<<s2
     <<std::endl;
  out<<"| Tool for space points seeded track      finding | "<<m_trackmaker.type()<<s3
     <<std::endl;
  out<<"| Location of output tracks                       | "<<m_outputTracksKey.key()<<s4
     <<std::endl;
  out<<"|----------------------------------------------------------------"
     <<"----------------------------------------------------|"
     <<std::endl;
  return out;
}

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.

{ 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 147 of file SiSPSeededTrackFinder.cxx.

{ 
  if (m_ITKGeometry and m_doFastTracking) return itkFastTrackingStrategy(ctx);
  else if (m_useITkConvSeeded) return itkConvStrategy(ctx);
  else if (not m_useNewStrategy and not m_useZBoundaryFinding and not m_ITKGeometry) {
    return oldStrategy(ctx);
  }
  return newStrategy(ctx);
}

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 & AthCommonAlgorithm< 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 89 of file AthCommonAlgorithm.cxx.

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

fillZHistogram()

void InDet::SiSPSeededTrackFinder::fillZHistogram ( const EventContext & ctx, 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]	ctx	current EventContext
[in]	Tr	Track candidate to fill
[in]	beamlinePerigee	Perigee surface corresponding to the beam spot
[out]	numberWeightedhistogram	vector representing a histogram in z, counting the tracks per bin
[out]	zWeightedHistogram	vector representing a histogram in z, counting the tracks per bin weighted by their z values
[out]	ptWeightedHistogram	vector 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 997 of file SiSPSeededTrackFinder.cxx.

{
  
  if (Tr->measurementsOnTrack()->size() < 10) return;
    
  const Trk::TrackParameters* paramsAtFirstSurface = Tr->trackStateOnSurfaces()->front()->trackParameters();
  Amg::Vector3D              position = paramsAtFirstSurface->position()          ;
  Amg::Vector3D              momentum = paramsAtFirstSurface->momentum()          ;
  
  constexpr double rSquare_max_forZHisto = 60.*60.; 
  if (position.x()*position.x()+position.y()*position.y() >= rSquare_max_forZHisto) return;
 
  double pT = sqrt(momentum.x()*momentum.x()+momentum.y()*momentum.y());
  if (pT < m_pTcut) return;
 
  Trk::PatternTrackParameters TP;
  if (not TP.production(paramsAtFirstSurface)) return;
      
  double step;
  if (not m_proptool->propagate(ctx,
                                TP, beamPosPerigee, TP, Trk::anyDirection, m_fieldprop, step, Trk::pion)) return;
          
  const AmgVector(5)& parsAtBeamSpot = TP.parameters();
  if (std::abs(parsAtBeamSpot[0]) > m_imcut) return;
  int z = static_cast<int>((parsAtBeamSpot[1]+m_zcut)*m_zstep);
  if (z >=0 and z < m_histsize) {
    ++numberHistogram[z];
    zWeightedHistogram[z] += parsAtBeamSpot[1];
    ptWeightedHistogram[z] += pT;
  }
  
}

filterPassed()

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

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

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]

scoredTracks

Track 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 889 of file SiSPSeededTrackFinder.cxx.

{
  std::set<const Trk::PrepRawData*> clusters;
  
  std::vector<const Trk::PrepRawData*> freeClusters;
  freeClusters.reserve(15);    
  
  std::multimap<double, Trk::Track*>::iterator it_qualityAndTrack = qualitySortedTracks.begin();

  while (it_qualityAndTrack!=qualitySortedTracks.end()) {
    freeClusters.clear();
 
    std::set<const Trk::PrepRawData*>::iterator it_clustersEnd = clusters.end();
 
    int nClusters = 0; 
    for (const Trk::MeasurementBase* m: *((*it_qualityAndTrack).second->measurementsOnTrack())) {

      const Trk::PrepRawData* pr = (static_cast<const Trk::RIO_OnTrack*>(m))->prepRawData();
      if (pr) {
        ++nClusters;
        if (clusters.find(pr)==it_clustersEnd) {
          freeClusters.push_back(pr); 
        }
      }
    }

    int nFreeClusters = static_cast<int>(freeClusters.size()); 
    if (nFreeClusters >= m_nfreeCut || nFreeClusters==nClusters) {
      clusters.insert(freeClusters.begin(), freeClusters.end());
      ++it_qualityAndTrack;
    } else {
      delete (*it_qualityAndTrack).second;
      qualitySortedTracks.erase(it_qualityAndTrack++);
    }
  }
}

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 937 of file SiSPSeededTrackFinder.cxx.

{
  std::set<const Trk::PrepRawData*> clusters;
 
  std::vector<const Trk::PrepRawData*> freeClusters;
  freeClusters.reserve(15);
 
  std::multimap<double, Trk::Track*>::iterator it_qualityAndTrack = qualitySortedTracks.begin();

  while (it_qualityAndTrack!=qualitySortedTracks.end()) {
    freeClusters.clear();
 
    std::set<const Trk::PrepRawData*>::iterator it_clustersEnd = clusters.end();
 
    int nClusters = 0;
    int nPixels = 0;
    for (const Trk::TrackStateOnSurface* tsos: *((*it_qualityAndTrack).second->trackStateOnSurfaces())) {
 
      if(!tsos->type(Trk::TrackStateOnSurface::Measurement)) continue;
      const Trk::FitQualityOnSurface fq =  tsos->fitQualityOnSurface();
      if(!fq) continue;
      if(fq.numberDoF() == 2) ++nPixels;

      const Trk::MeasurementBase* mb = tsos->measurementOnTrack();
      const Trk::RIO_OnTrack*     ri = dynamic_cast<const Trk::RIO_OnTrack*>(mb);
      if(!ri) continue;
      const Trk::PrepRawData* pr = ri->prepRawData();
      if (pr) {
        ++nClusters;
        if (clusters.find(pr)==it_clustersEnd) {
          freeClusters.push_back(pr);
        }
      }
    }

    clusters.insert(freeClusters.begin(), freeClusters.end());
 
    int nFreeClusters = static_cast<int>(freeClusters.size());
    if( passEtaDepCuts( (*it_qualityAndTrack).second, nClusters, nFreeClusters, nPixels) ){
      ++it_qualityAndTrack;
    } else {
      delete (*it_qualityAndTrack).second;
      qualitySortedTracks.erase(it_qualityAndTrack++);
    }
  }
}

finalize()

StatusCode InDet::SiSPSeededTrackFinder::finalize ( )

overridevirtual

Definition at line 733 of file SiSPSeededTrackFinder.cxx.

{
  
    dump(MSG::INFO, &m_counterTotal);
 
  if (m_doDumpGBTSTrainingData || m_doDumpGBTSTrainingDataLRT) {
    dumpGBTSTrainingData();
  }
  return StatusCode::SUCCESS;
}

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]	numberWeightedhistogram	vector representing a histogram in z, counting the tracks per bin
[in]	zWeightedHistogram	vector representing a histogram in z, counting the tracks per bin weighted by their z values
[in]	ptWeightedHistogram	vector 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 1046 of file SiSPSeededTrackFinder.cxx.

{
  zBoundaries = {1000., -1000};
 
  std::multimap<int   ,double> vertexZ_sortedByNtracks;
  std::multimap<double,double> vertexZ_sortedBySumPt;
 
  int lastBin = m_histsize-1;
  int minBinContentSum = 3;

  for (int binIndex=1; binIndex<lastBin; ++binIndex) { 

    int vertexNtracks = numberHistogram.at(binIndex-1)+numberHistogram.at(binIndex)+numberHistogram.at(binIndex+1);

    if (vertexNtracks>=minBinContentSum and (numberHistogram.at(binIndex) >= numberHistogram.at(binIndex-1) and numberHistogram.at(binIndex) >= numberHistogram.at(binIndex+1))) {
      double vertexZestimate = (zWeightedHistogram.at(binIndex-1)+zWeightedHistogram.at(binIndex)+zWeightedHistogram.at(binIndex+1))/static_cast<double>(vertexNtracks);

      if (vertexZestimate < zBoundaries.first) zBoundaries.first = vertexZestimate;
      if (vertexZestimate > zBoundaries.second) zBoundaries.second = vertexZestimate;
 
      if (m_useNewStrategy) { 
        double vertexSumPt = ptWeightedHistogram.at(binIndex-1)+ptWeightedHistogram.at(binIndex)+ptWeightedHistogram.at(binIndex+1);
        vertexZ_sortedByNtracks.insert(std::make_pair(-vertexNtracks, vertexZestimate));
        vertexZ_sortedBySumPt.insert(std::make_pair(-vertexSumPt, vertexZestimate));
      }
    }
  }
 
  if (m_useNewStrategy) {
 
    std::set<double> leadingVertices;
    int n = 0;
    std::multimap<double, double>::iterator vertex_pt_and_z = vertexZ_sortedBySumPt.begin();
    for (std::pair<int, double> nTrackAndZ: vertexZ_sortedByNtracks) {
      if (n++ >= m_nvertex) break; 
      leadingVertices.insert(nTrackAndZ.second);
      leadingVertices.insert((*vertex_pt_and_z++).second);
    }
 
    for (double v: leadingVertices) {
      vertexZList.emplace_back(Amg::Vector3D{0.,0.,v});
    }
  }
  if (zBoundaries.first > zBoundaries.second) {
    zBoundaries.first = -1000.;
    zBoundaries.second = +1000.;
  } else {
    zBoundaries.first -= 20.;
    zBoundaries.second += 20.;
  }
} 

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 79 of file SiSPSeededTrackFinder.cxx.

{
  ATH_CHECK(m_evtKey.initialize());
  ATH_CHECK(m_mbtsKey.initialize(m_useMBTS));
  ATH_CHECK(m_SpacePointsPixelKey.initialize(SG::AllowEmpty));
  ATH_CHECK(m_SpacePointsSCTKey.initialize(SG::AllowEmpty));
  ATH_CHECK(m_outputTracksKey.initialize());

  ATH_CHECK( m_prdToTrackMap.initialize( !m_prdToTrackMap.key().empty() ) );
 
  ATH_CHECK( m_caloClusterROIKey.initialize(m_useITkConvSeeded) );

  ATH_CHECK( m_seedsmaker.retrieve() );
  ATH_CHECK( m_zvertexmaker.retrieve( DisableTool{ not m_useZvertexTool } ));

  ATH_CHECK( m_trackmaker.retrieve());
 
  ATH_CHECK( m_regsel_strip.retrieve( DisableTool{ not m_useITkConvSeeded } ) );
 
  if (m_ITKGeometry and m_doFastTracking) ATH_CHECK(m_etaDependentCutsSvc.retrieve());
 
  ATH_CHECK( m_trackSummaryTool.retrieve( DisableTool{ m_trackSummaryTool.name().empty()} ));
 
  if (m_useNewStrategy and m_beamSpotKey.key().empty()) {
    m_useNewStrategy = false;
    m_useZBoundaryFinding = false;
  }
 
  ATH_CHECK(m_beamSpotKey.initialize( (m_useNewStrategy or m_useZBoundaryFinding or m_ITKGeometry or m_useITkConvSeeded) && not m_beamSpotKey.key().empty() ));
  if (m_useNewStrategy or m_useZBoundaryFinding or m_ITKGeometry or m_useITkConvSeeded) {
 
    if (not m_beamSpotKey.key().empty()) {
      ATH_CHECK( m_proptool.retrieve() );

      magneticFieldInit();
      
      if (m_histsize < 100) m_histsize = 100;
      m_zstep = static_cast<double>(m_histsize)/(2.*m_zcut);
    } else {
      m_proptool.disable();
      m_useNewStrategy = false;
      m_useZBoundaryFinding = false;
    }
  } else {
    m_proptool.disable();
  }

  if (msgLvl(MSG::DEBUG)) {
    dump(MSG::DEBUG, nullptr);
  }
  m_neventsTotal   = 0;
  m_neventsTotalV  = 0;
  m_problemsTotal  = 0;
  m_problemsTotalV = 0;
  return StatusCode::SUCCESS;
}

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 AthCommonAlgorithm< Gaudi::Algorithm >.

Definition at line 68 of file SiSPSeededTrackFinder.h.

{ return true; };

isGoodEvent()

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

protected

EventContext is used to specify which event.

Definition at line 838 of file SiSPSeededTrackFinder.cxx.

                                                                          {
 
  if ( not m_alwaysProtectAgainstBusyEvent ) { // if not enabled the protection is only applied to specific events
    // Test MBTS information from calorimeter
    //
    if (not m_useMBTS) return true;
 
    SG::ReadHandle<xAOD::EventInfo> eventInfo{m_evtKey, ctx};
    if (not eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background, xAOD::EventInfo::MBTSTimeDiffHalo) ) {
      return true;
    }
  }
 
  // Test total number pixels space points
  //
  unsigned int nsp = 0;
  if (not m_SpacePointsPixelKey.empty()) {
    SG::ReadHandle<SpacePointContainer> spacePointsPixel{m_SpacePointsPixelKey, ctx};
    if (spacePointsPixel.isValid()) {
      for (const SpacePointCollection* spc: *spacePointsPixel) {
        nsp += spc->size();
      }
      if (static_cast<int>(nsp) > m_maxPIXsp) {
        ATH_MSG_WARNING("Found more than "<<m_maxPIXsp<<" pixels space points in background event. Skip track finding");
        return false;
      }
    }
  }
  // Test total number sct space points
  //
  nsp = 0;
  if (not m_SpacePointsSCTKey.empty()) {
    SG::ReadHandle<SpacePointContainer> spacePointsSCT{m_SpacePointsSCTKey, ctx};
    if (spacePointsSCT.isValid()) {
      for (const SpacePointCollection* spc: *spacePointsSCT) {
        nsp += spc->size();
      }
      if (static_cast<int>(nsp) > m_maxSCTsp) {
        ATH_MSG_WARNING("Found more than "<<m_maxSCTsp<<" sct space points in background event. Skip track finding");
        return false;
      }
    }
  }
 
  return true;
}

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 581 of file SiSPSeededTrackFinder.cxx.

{
  ATH_MSG_DEBUG("Executing " << name() << "::itkConvStrategy");
 
  SG::WriteHandle<TrackCollection> outputTracks{m_outputTracksKey, ctx};
  ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
  if (not isGoodEvent(ctx)) {
    return StatusCode::SUCCESS;
  }
 
  SiSpacePointsSeedMakerEventData seedEventData;
 
  SG::ReadHandle<ROIPhiRZContainer> calo_rois(m_caloClusterROIKey, ctx);
  std::unique_ptr<RoiDescriptor> roiComp = std::make_unique<RoiDescriptor>(true);
 
  if(calo_rois.isValid()) {
    RoiDescriptor * roi =nullptr;
    SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle{m_beamSpotKey, ctx};
    double beamZ = beamSpotHandle->beamVtx().position().z();
    roiComp->clear();
    roiComp->setComposite();
 
    const ROIPhiRZContainer &calo_rois_ref=*calo_rois;
    for (const ROIPhiRZ &calo_roi : calo_rois_ref) {
        double phi = calo_roi.phi();
        if (std::abs(phi)>=M_PI && phi!=-M_PI) continue; // skip duplicates < -pi and >pi
        double eta = calo_roi.eta();
        double z = beamZ;
        double roiPhiMin = phi - m_deltaPhi;
        double roiPhiMax = phi + m_deltaPhi;
        double roiEtaMin = eta - m_deltaEta;
        double roiEtaMax = eta + m_deltaEta;
        double roiZMin = beamZ - m_deltaZ;
        double roiZMax = beamZ + m_deltaZ;
        roi = new RoiDescriptor( eta, roiEtaMin, roiEtaMax,phi, roiPhiMin ,roiPhiMax,z,roiZMin,roiZMax);
        roiComp->push_back(roi);
    }
  }
  else {
    ATH_MSG_ERROR("Calo RoI is not valid: " << m_caloClusterROIKey.key());
    return StatusCode::FAILURE;
  }
 
  std::vector<IdentifierHash> listOfStripIds;
  std::vector<IdentifierHash> listOfPixIds;
 
  m_regsel_strip->lookup(ctx)->HashIDList( *roiComp, listOfStripIds );
  
  m_seedsmaker->newRegion(ctx, seedEventData, listOfPixIds, listOfStripIds);
  std::list<Trk::Vertex> vertexList;
  m_seedsmaker->find3Sp(ctx, seedEventData, vertexList);
 
  const bool PIX = true ;
  const bool STRIP = true ;
  //Local variable trackEventData uses 814592 bytes of stack space
  //coverity[STACK_USE]
  InDet::ExtendedSiTrackMakerEventData_xk trackEventData(m_prdToTrackMap);
  m_trackmaker->newEvent(ctx, trackEventData, PIX, STRIP);
 
  bool ERR = false;
  Counter_t counter{};
  const InDet::SiSpacePointsSeed* seed = nullptr;

  std::multimap<double, Trk::Track*> qualitySortedTrackCandidates;

  bool doWriteNtuple = m_seedsmaker->getWriteNtupleBoolProperty();
  long EvNumber = 0.;            //Event number variable to be used for the validation ntuple
 
  if (doWriteNtuple) {
    SG::ReadHandle<xAOD::EventInfo> eventInfo(m_evtKey,ctx);
    if(!eventInfo.isValid()) {EvNumber = -1.0;} else {EvNumber = eventInfo->eventNumber();}
  }

  while ((seed = m_seedsmaker->next(ctx, seedEventData))) {
 
    ++counter[kNSeeds];

    std::list<Trk::Track*> trackList = m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
    for (Trk::Track* t: trackList) {
      qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(t), t));
    }

    if(doWriteNtuple) { m_seedsmaker->writeNtuple(seed, !trackList.empty() ? trackList.front() : nullptr, ISiSpacePointsSeedMaker::StripSeed, EvNumber) ; }
 
    if (counter[kNSeeds] >= m_maxNumberSeeds) {
      ERR = true;
      ++m_problemsTotal;
      break;
    }
  }
 
  m_trackmaker->endEvent(trackEventData);

  filterSharedTracks(qualitySortedTrackCandidates);

  for (const std::pair<const double, Trk::Track*> & qualityAndTrack: qualitySortedTrackCandidates) {
    ++counter[kNTracks];
    if (m_trackSummaryTool.isEnabled()) {
      m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *qualityAndTrack.second,
                            false /* DO NOT suppress hole search*/);
      InDet::PatternHoleSearchOutcome theOutcome;
      if (m_writeHolesFromPattern && trackEventData.combinatorialData().findPatternHoleSearchOutcome(qualityAndTrack.second,theOutcome)){
    qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelHoles, theOutcome.nPixelHoles);
    qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTHoles, theOutcome.nSCTHoles);
    qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDoubleHoles, theOutcome.nSCTDoubleHoles);
    qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDeadSensors, theOutcome.nSCTDeads);
    qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelDeadSensors, theOutcome.nPixelDeads);
      }
    }
    outputTracks->push_back(qualityAndTrack.second);
  }
 
  m_counterTotal[kNSeeds] += counter[kNSeeds] ;
 
  ++m_neventsTotal;
 
  if (ERR) {
    outputTracks->clear();
  } else {
    m_counterTotal[kNTracks] += counter[kNTracks];
  }
 
  // Print common event information
  //
  if (msgLvl(MSG::DEBUG)) {
    dump(MSG::DEBUG, &counter);
  }
  return StatusCode::SUCCESS;
}

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 463 of file SiSPSeededTrackFinder.cxx.

{
  SG::WriteHandle<TrackCollection> outputTracks{m_outputTracksKey, ctx};
  ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
 
  const bool PIX = true ;
  const bool STRIP = true ;
  // Local variable trackEventData uses 814592 bytes of stack space
  //coverity[STACK_USE]
  InDet::ExtendedSiTrackMakerEventData_xk trackEventData(m_prdToTrackMap);
  m_trackmaker->newTrigEvent(ctx, trackEventData, PIX, STRIP);
 
  SiSpacePointsSeedMakerEventData seedEventData;



  m_seedsmaker->newEvent(ctx, seedEventData, 0);
  std::list<Trk::Vertex> vertexList;
  m_seedsmaker->find3Sp(ctx, seedEventData, vertexList);
 
  bool ERR = false;
  Counter_t counter{};
  const InDet::SiSpacePointsSeed* seed = nullptr;

  std::multimap<double, Trk::Track*> qualitySortedTrackCandidates;

  bool doWriteNtuple = m_seedsmaker->getWriteNtupleBoolProperty();
  long EvNumber = 0.;            //Event number variable to be used for the validation ntuple
 
  if (doWriteNtuple) {
    SG::ReadHandle<xAOD::EventInfo> eventInfo(m_evtKey,ctx);
    if(!eventInfo.isValid()) {EvNumber = -1.0;} else {EvNumber = eventInfo->eventNumber();}
  }

  while ((seed = m_seedsmaker->next(ctx, seedEventData))) {
 
    ++counter[kNSeeds];

    std::list<Trk::Track*> trackList = m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
    for (Trk::Track* t: trackList) {
 
      qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(t), t));
 
    }
    if(doWriteNtuple) { m_seedsmaker->writeNtuple(seed, !trackList.empty() ? trackList.front() : nullptr, ISiSpacePointsSeedMaker::PixelSeed, EvNumber) ; }
 
    if (counter[kNSeeds] >= m_maxNumberSeeds) {
      ERR = true;
      ++m_problemsTotal;
      break;
    }
  }
 
  m_trackmaker->endEvent(trackEventData);

  filterSharedTracksFast(qualitySortedTrackCandidates);

  for (const std::pair<const double, Trk::Track*> & qualityAndTrack: qualitySortedTrackCandidates) {
    ++counter[kNTracks];
 
    if (m_trackSummaryTool.isEnabled()) {
      m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *qualityAndTrack.second);
      InDet::PatternHoleSearchOutcome theOutcome;
      if (m_writeHolesFromPattern && trackEventData.combinatorialData().findPatternHoleSearchOutcome(qualityAndTrack.second,theOutcome)){
        qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelHoles, theOutcome.nPixelHoles);
        qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTHoles, theOutcome.nSCTHoles);
        qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDoubleHoles, theOutcome.nSCTDoubleHoles);
        qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDeadSensors, theOutcome.nSCTDeads);
        qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelDeadSensors, theOutcome.nPixelDeads);
      }
    }
 
    outputTracks->push_back(qualityAndTrack.second);
  }
 
  m_counterTotal[kNSeeds] += counter[kNSeeds] ;
 
  ++m_neventsTotal;
 
  if (ERR) {
    outputTracks->clear();
  } else {
    m_counterTotal[kNTracks] += counter[kNTracks];
  }
 
  // Print common event information
  //
  if (msgLvl(MSG::DEBUG)) {
    dump(MSG::DEBUG, &counter);
  }
  return StatusCode::SUCCESS;
}

magneticFieldInit()

void InDet::SiSPSeededTrackFinder::magneticFieldInit ( )

protected

Definition at line 1120 of file SiSPSeededTrackFinder.cxx.

{
  // Build MagneticFieldProperties 
  //
  if(m_fieldmode == "NoField") {
    m_fieldprop = Trk::MagneticFieldProperties(Trk::NoField);
  } else {
    m_fieldprop = Trk::MagneticFieldProperties(Trk::FastField);
  }
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

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 268 of file SiSPSeededTrackFinder.cxx.

{
  SG::WriteHandle<TrackCollection> outputTracks{m_outputTracksKey, ctx};
  ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
  if (not isGoodEvent(ctx)) {
    return StatusCode::SUCCESS;
  }

  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle{m_beamSpotKey, ctx};
  Trk::PerigeeSurface beamPosPerigee(beamSpotHandle->beamPos());
 
  SiSpacePointsSeedMakerEventData seedEventData;
   
 

  m_seedsmaker->newEvent(ctx, seedEventData, 0);
  std::list<Trk::Vertex> vertexList;
  m_seedsmaker->find3Sp(ctx, seedEventData, vertexList);
 
  const bool PIX = true ;
  const bool SCT = true ;
  //Total stack use for this function is 831736 bytes.
  //coverity[STACK_USE]
  InDet::ExtendedSiTrackMakerEventData_xk trackEventData(m_prdToTrackMap);
  m_trackmaker->newEvent(ctx, trackEventData, PIX, SCT);

  std::vector<int> numberHistogram(m_histsize, 0);
  std::vector<double> zWeightedHistogram(m_histsize, 0.);
  std::vector<double> ptWeightedHistogram(m_histsize, 0.);
 
  bool ERR = false;
  Counter_t counter{};
  const InDet::SiSpacePointsSeed* seed = nullptr;

  std::multimap<double, Trk::Track*> qualitySortedTrackCandidates;

  bool doWriteNtuple = m_seedsmaker->getWriteNtupleBoolProperty();
  long EvNumber = 0.;            //Event number variable to be used for the validation ntuple 
 
  if (doWriteNtuple) {
    SG::ReadHandle<xAOD::EventInfo> eventInfo(m_evtKey,ctx);
    if(!eventInfo.isValid()) {EvNumber = -1.0;} else {EvNumber = eventInfo->eventNumber();}
  }

  while ((seed = m_seedsmaker->next(ctx, seedEventData))) {
 
    ++counter[kNSeeds];
    bool firstTrack{true};

      std::list<Trk::Track*> trackList = m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
      for (Trk::Track* t: trackList) {
 
        qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(t), t));
 
        if (firstTrack && m_doDumpGBTSTrainingDataLRT) {
          collectGBTSTrainingData(t);
        }

        if (firstTrack and not m_ITKGeometry) {
          fillZHistogram(ctx, t, beamPosPerigee, numberHistogram, zWeightedHistogram, ptWeightedHistogram);
        }
        firstTrack = false;
      }  
      if(doWriteNtuple) { m_seedsmaker->writeNtuple(seed, !trackList.empty() ? trackList.front() : nullptr, ISiSpacePointsSeedMaker::StripSeed, EvNumber) ; } 
        
 
    if (counter[kNSeeds] >= m_maxNumberSeeds) {
      ERR = true;
      ++m_problemsTotal;
      break;
    }
  }
 
  if(not m_SpacePointsPixelKey.empty()) {
    m_seedsmaker->newEvent(ctx, seedEventData, 1);

    std::pair<double,double> zBoundaries;
    if (not m_ITKGeometry) {
      findZvertex(vertexList, zBoundaries, numberHistogram, zWeightedHistogram, ptWeightedHistogram);
      m_seedsmaker->find3Sp(ctx, seedEventData, vertexList, &(zBoundaries.first));
    } else {
      m_seedsmaker->find3Sp(ctx, seedEventData, vertexList);
    }

    while ((seed = m_seedsmaker->next(ctx, seedEventData))) {
 
      ++counter[kNSeeds];
 
      std::list<Trk::Track*> trackList = m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
 
      for (Trk::Track* t: trackList) {
        qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(t), t));
      }
 
      if(doWriteNtuple) { m_seedsmaker->writeNtuple(seed, !trackList.empty() ? trackList.front() : nullptr, ISiSpacePointsSeedMaker::PixelSeed, EvNumber); }
 
      if (counter[kNSeeds] >= m_maxNumberSeeds) {
        ERR = true;
        ++m_problemsTotal;
        break;
      }
    }
  } else {
    ATH_MSG_WARNING("SpacePointsPixelKey is empty. Skipping the second seeding pass that uses pixel seeds.");
  }
 
  m_trackmaker->endEvent(trackEventData);

  filterSharedTracks(qualitySortedTrackCandidates);

  for (const std::pair<const double, Trk::Track*> & qualityAndTrack: qualitySortedTrackCandidates) {
    ++counter[kNTracks];
    if (m_trackSummaryTool.isEnabled()) {
       m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *qualityAndTrack.second,
                                                         false /* DO NOT suppress hole search*/);
       InDet::PatternHoleSearchOutcome theOutcome; 
       if (m_writeHolesFromPattern && trackEventData.combinatorialData().findPatternHoleSearchOutcome(qualityAndTrack.second,theOutcome)){
         qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelHoles, theOutcome.nPixelHoles); 
         qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTHoles, theOutcome.nSCTHoles); 
         qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDoubleHoles, theOutcome.nSCTDoubleHoles); 
         qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDeadSensors, theOutcome.nSCTDeads); 
         qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelDeadSensors, theOutcome.nPixelDeads); 
       }
    }
    outputTracks->push_back(qualityAndTrack.second);
    if (m_doDumpGBTSTrainingData) {
      collectGBTSTrainingData(qualityAndTrack.second);
    }
  }
 
  m_counterTotal[kNSeeds] += counter[kNSeeds] ;
 
  ++m_neventsTotal;
 
  if (ERR) {
    outputTracks->clear();
  } else {
    m_counterTotal[kNTracks] += counter[kNTracks];
  }
 
  // Print common event information
  //
  if (msgLvl(MSG::DEBUG)) {
    dump(MSG::DEBUG, &counter);
  }
  return StatusCode::SUCCESS;
}

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 181 of file SiSPSeededTrackFinder.cxx.

{
  SG::WriteHandle<TrackCollection> outputTracks{m_outputTracksKey, ctx};
  ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
  if (not isGoodEvent(ctx)) {
    return StatusCode::SUCCESS;
  }
 
  SiSpacePointsSeedMakerEventData seedEventData;
  bool ZVE = false;
  if (m_useZvertexTool) {
    std::list<Trk::Vertex> vertices = m_zvertexmaker->newEvent(ctx, seedEventData);
    if (not vertices.empty()) ZVE = true;
    m_seedsmaker->find3Sp(ctx, seedEventData, vertices);
  } else {
    m_seedsmaker->newEvent(ctx, seedEventData, -1);
    std::list<Trk::Vertex> vertexList;
    m_seedsmaker->find3Sp(ctx, seedEventData, vertexList);
  }
 
  const bool PIX = true;
  const bool SCT = true;
  //Total stack use for this function is 831124 bytes
  //coverity[STACK_USE]
  InDet::ExtendedSiTrackMakerEventData_xk trackEventData(m_prdToTrackMap);
  m_trackmaker->newEvent(ctx, trackEventData, PIX, SCT);
 
  bool ERR = false;
  Counter_t counter{};
  const InDet::SiSpacePointsSeed* seed = nullptr;
  std::multimap<double, Trk::Track*> qualitySortedTrackCandidates;
  // Loop through all seed and reconsrtucted tracks collection preparation
  //
  while ((seed = m_seedsmaker->next(ctx, seedEventData))) {
    ++counter[kNSeeds];
    std::list<Trk::Track*> trackList = m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
    for (Trk::Track* t: trackList) {
      qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(t), t));
    }
    if (not ZVE and (counter[kNSeeds] >= m_maxNumberSeeds)) {
      ERR = true;
      ++m_problemsTotal;
      break;
    }
  }
  m_trackmaker->endEvent(trackEventData);
 
  // Remove shared tracks with worse quality
  //
  filterSharedTracks(qualitySortedTrackCandidates);
 
  // Save good tracks in track collection
  //
  for (const std::pair<const double, Trk::Track*> & qualityAndTrack: qualitySortedTrackCandidates) {
    ++counter[kNTracks];
    if (m_trackSummaryTool.isEnabled()) {
       m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *(qualityAndTrack.second),
                                                         false /* DO NOT suppress hole search*/);
    }
    outputTracks->push_back(qualityAndTrack.second);
  }
 
  m_counterTotal[kNSeeds] += counter[kNSeeds];
 
  if (ZVE) ++m_neventsTotalV;
  else     ++m_neventsTotal;
 
  if (ERR) {
    outputTracks->clear();
  } else {
    m_counterTotal[kNTracks] += counter[kNTracks];
  }
 
  // Print common event information
  //
  if (msgLvl(MSG::DEBUG)) {
    dump(MSG::DEBUG, &counter);
  }
 
  return StatusCode::SUCCESS;
}

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 1136 of file SiSPSeededTrackFinder.cxx.

{
  Trk::TrackStates::const_iterator  m = track->trackStateOnSurfaces()->begin();
  const Trk::TrackParameters* par = (*m)->trackParameters();
  if(!par) return false;
 
  double eta = std::abs(par->eta());
  if(nClusters               < m_etaDependentCutsSvc->getMinSiHitsAtEta(eta)) return false;
  if(nFreeClusters           < m_etaDependentCutsSvc->getMinSiNotSharedAtEta(eta)) return false;
  if(nClusters-nFreeClusters > m_etaDependentCutsSvc->getMaxSharedAtEta(eta)) return false;
  if(nPixels                 < m_etaDependentCutsSvc->getMinPixelHitsAtEta(eta)) return false;
 
  if(par->pT() < m_etaDependentCutsSvc->getMinPtAtEta(eta)) return false;
  if(!(*m)->type(Trk::TrackStateOnSurface::Perigee)) return true ;
  if(std::abs(par->localPosition()[0]) > m_etaDependentCutsSvc->getMaxPrimaryImpactAtEta(eta)) return false;
  return true;
}

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.

  {
    h.renounce();
    PBASE::renounce (h);
  }

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.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

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

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonAlgorithm< 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.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonAlgorithm< 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 AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

                                                      {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

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.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

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

mutableprotected

Definition at line 175 of file SiSPSeededTrackFinder.h.

ATLAS_THREAD_SAFE [2/2]

Counter_t m_counterTotal InDet::SiSPSeededTrackFinder::ATLAS_THREAD_SAFE {}

mutableprotected

Definition at line 166 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 104 of file SiSPSeededTrackFinder.h.

{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 136 of file SiSPSeededTrackFinder.h.

{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 134 of file SiSPSeededTrackFinder.h.

{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 111 of file SiSPSeededTrackFinder.h.

{this, "dEtaCaloRoI", .1};

m_deltaPhi

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

protected

Definition at line 112 of file SiSPSeededTrackFinder.h.

{this, "dPhiCaloRoI", .25};

m_deltaZ

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

protected

Definition at line 113 of file SiSPSeededTrackFinder.h.

{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 115 of file SiSPSeededTrackFinder.h.

{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 116 of file SiSPSeededTrackFinder.h.

{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 102 of file SiSPSeededTrackFinder.h.

{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 161 of file SiSPSeededTrackFinder.h.

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

m_evtKey

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

protected

Definition at line 130 of file SiSPSeededTrackFinder.h.

{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 AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_fieldmode

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

protected

Definition at line 114 of file SiSPSeededTrackFinder.h.

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

m_fieldprop

Trk::MagneticFieldProperties InDet::SiSPSeededTrackFinder::m_fieldprop

protected

Definition at line 155 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 118 of file SiSPSeededTrackFinder.h.

{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 174 of file SiSPSeededTrackFinder.h.

m_histsize

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

protected

Definition at line 108 of file SiSPSeededTrackFinder.h.

{this, "HistSize", 1400};

m_imcut

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

protected

Definition at line 124 of file SiSPSeededTrackFinder.h.

{2.};

m_ITKGeometry

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

protected

Definition at line 100 of file SiSPSeededTrackFinder.h.

{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 103 of file SiSPSeededTrackFinder.h.

{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 105 of file SiSPSeededTrackFinder.h.

{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 106 of file SiSPSeededTrackFinder.h.

{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 138 of file SiSPSeededTrackFinder.h.

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

m_neventsTotal

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

mutableprotected

Number events.

Definition at line 168 of file SiSPSeededTrackFinder.h.

{0}; 

m_neventsTotalV

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

mutableprotected

Number events.

Definition at line 169 of file SiSPSeededTrackFinder.h.

{0}; 

m_nfreeCut

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

protected

Definition at line 107 of file SiSPSeededTrackFinder.h.

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

m_numGBTSTrainingData

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

mutableprotected

Definition at line 176 of file SiSPSeededTrackFinder.h.

{0};

m_nvertex

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

protected

Definition at line 109 of file SiSPSeededTrackFinder.h.

{this, "maxVertices", 4};

m_outputTracksKey

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

protected

Definition at line 140 of file SiSPSeededTrackFinder.h.

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

m_prdToTrackMap

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

protected

Definition at line 133 of file SiSPSeededTrackFinder.h.

{this,"PRDtoTrackMap",""};

m_problemsTotal

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

mutableprotected

Number events with number seeds > maxNumber.

Definition at line 170 of file SiSPSeededTrackFinder.h.

{0}; 

m_problemsTotalV

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

mutableprotected

Number events with number seeds > maxNumber.

Definition at line 171 of file SiSPSeededTrackFinder.h.

{0}; 

m_proptool

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

protected

Definition at line 148 of file SiSPSeededTrackFinder.h.

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

m_pTcut

double InDet::SiSPSeededTrackFinder::m_pTcut {500}

protected

Definition at line 123 of file SiSPSeededTrackFinder.h.

{500};

m_regsel_strip

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

protected

Definition at line 150 of file SiSPSeededTrackFinder.h.

{ 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 117 of file SiSPSeededTrackFinder.h.

{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 145 of file SiSPSeededTrackFinder.h.

{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 132 of file SiSPSeededTrackFinder.h.

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

m_SpacePointsSCTKey

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

protected

Definition at line 131 of file SiSPSeededTrackFinder.h.

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

m_trackmaker

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

protected

Definition at line 147 of file SiSPSeededTrackFinder.h.

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

m_trackSummaryTool

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

protected

Definition at line 149 of file SiSPSeededTrackFinder.h.

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

m_useITkConvSeeded

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

protected

Definition at line 101 of file SiSPSeededTrackFinder.h.

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

m_useMBTS

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

protected

Definition at line 97 of file SiSPSeededTrackFinder.h.

{this, "useMBTSTimeDiff", false};

m_useNewStrategy

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

protected

Definition at line 98 of file SiSPSeededTrackFinder.h.

{this, "useNewStrategy", false};

m_useZBoundaryFinding

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

protected

Definition at line 99 of file SiSPSeededTrackFinder.h.

{this, "useZBoundFinding", false};

m_useZvertexTool

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

protected

Definition at line 95 of file SiSPSeededTrackFinder.h.

{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 96 of file SiSPSeededTrackFinder.h.

{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 110 of file SiSPSeededTrackFinder.h.

{this, "Zcut", 350.};

m_zstep

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

protected

Definition at line 125 of file SiSPSeededTrackFinder.h.

{0.};

m_zvertexmaker

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

protected

Definition at line 146 of file SiSPSeededTrackFinder.h.

{this, "ZvertexTool", "InDet::SiZvertexMaker_xk/InDetSiZvertexMaker", "Space poins z-vertex maker"};

---

The documentation for this class was generated from the following files:

• SiSPSeededTrackFinder.h
• SiSPSeededTrackFinder.cxx