InDet::SiTrackMaker_xk Class Reference

#include <SiTrackMaker_xk.h>

Inheritance diagram for InDet::SiTrackMaker_xk:

Collaboration diagram for InDet::SiTrackMaker_xk:

Public Member Functions
Standard tool methods
	SiTrackMaker_xk (const std::string &, const std::string &, const IInterface *)
virtual	~SiTrackMaker_xk ()=default
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
Main methods for local track finding
virtual std::list< Trk::Track * >	getTracks (const EventContext &ctx, SiTrackMakerEventData_xk &data, const std::vector< const Trk::SpacePoint * > &Sp) const override
virtual std::list< Trk::Track * >	getTracks (const EventContext &ctx, SiTrackMakerEventData_xk &data, const Trk::TrackParameters &Tp, const std::vector< Amg::Vector3D > &Gp) const override
virtual void	newEvent (const EventContext &ctx, SiTrackMakerEventData_xk &data, bool PIX, bool SCT) const override
virtual void	newTrigEvent (const EventContext &ctx, SiTrackMakerEventData_xk &data, bool PIX, bool SCT) const override
virtual void	endEvent (SiTrackMakerEventData_xk &data) const override
Print internal tool parameters and status
MsgStream &	dump (SiTrackMakerEventData_xk &data, MsgStream &out) const override

Private Member Functions
Disallow default constructor, copy constructor and assignment operator
	SiTrackMaker_xk ()=delete
	SiTrackMaker_xk (const SiTrackMaker_xk &)=delete
SiTrackMaker_xk &	operator= (const SiTrackMaker_xk &)=delete

Private Attributes
Tool handles
ToolHandle< InDet::ISiDetElementsRoadMaker >	m_roadmaker {this, "RoadTool", "InDet::SiDetElementsRoadMaker_xk"}
ToolHandle< InDet::ISiCombinatorialTrackFinder >	m_tracksfinder {this, "CombinatorialTrackFinder", "InDet::SiCombinatorialTrackFinder_xk"}
ToolHandle< ITrigInDetTrackFollowingTool >	m_trigInDetTrackFollowingTool {this, "TrigTrackFollowingTool", "TrigInDetTrackFollowingTool"}
ToolHandle< ITrigInDetRoadPredictorTool >	m_trigInDetRoadPredictorTool {this, "TrigInDetRoadPredictorTool", "TrigInDetRoadPredictorTool_FTF"}
ToolHandle< InDet::ISeedToTrackConversionTool >	m_seedtrack {this, "SeedToTrackConversion", "InDet::SeedToTrackConversionTool"}
Data handles
SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"}
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"}
SG::ReadHandleKey< ROIPhiRZContainer >	m_caloCluster {this, "EMROIPhiRZContainer", ""}
SG::ReadHandleKey< ROIPhiRZContainer >	m_caloHad {this, "HadROIPhiRZContainer", ""}
Properties
BooleanProperty	m_seedsfilter {this, "UseSeedFilter", true, "Use seed filter"}
StringProperty	m_fieldmode {this, "MagneticFieldMode", "MapSolenoid", "Mode of magnetic field"}
StringProperty	m_patternName {this, "TrackPatternRecoInfo", "SiSPSeededFinder", "Name of the pattern recognition"}
BooleanProperty	m_usePix {this, "usePixel", true, "flags to set whether to use pixel/sct cluster, irrespective of what is in event"}
BooleanProperty	m_useSct {this, "useSCT", true}
BooleanProperty	m_useassoTool {this, "UseAssociationTool", false, "Use prd-track association tool"}
BooleanProperty	m_cosmicTrack {this, "CosmicTrack", false, "Is it cosmic track"}
BooleanProperty	m_multitracks {this, "doMultiTracksProd", false}
BooleanProperty	m_useBremModel {this, "useBremModel", false}
BooleanProperty	m_useCaloSeeds {this, "doCaloSeededBrem", false}
BooleanProperty	m_useSSSfilter {this, "useSSSseedsFilter", true}
BooleanProperty	m_useHClusSeed {this, "doHadCaloSeedSSS", false, "Hadronic Calorimeter Seeds"}
BooleanProperty	m_ITKGeometry {this, "ITKGeometry", false, "ITK geometry"}
BooleanProperty	m_seedsegmentsWrite {this, "SeedSegmentsWrite", false, "Call seed to track conversion"}
BooleanProperty	m_useTrigTrackFollowingTool {this, "useTrigTrackFollowingTool", false, "Option to use TrigInDetTrackFollowingTool instead of SiCombinatorialTrackFinder_xk"}
BooleanProperty	m_useTrigInDetRoadPredictorTool {this, "useTrigInDetRoadPredictorTool", false, "Option to use TrigInDetRoadPredictorTool instead of ISiDetElementsRoadMaker"}
BooleanProperty	m_LRTmode {this, "LRTMode", false}
DoubleProperty	m_xi2max {this, "Xi2max", 15., "max Xi2 for updators"}
DoubleProperty	m_xi2maxNoAdd {this, "Xi2maxNoAdd", 35., "max Xi2 for clusters"}
DoubleProperty	m_xi2maxlink {this, "Xi2maxlink", 200., "max Xi2 for clusters"}
DoubleProperty	m_pTmin {this, "pTmin", 500., "min pT"}
DoubleProperty	m_pTminBrem {this, "pTminBrem", 1000., "min pT for Brem mode"}
DoubleProperty	m_distmax {this, "MaxDistanceForSCTsp", 5.}
DoubleProperty	m_xi2multitracks {this, "Xi2maxMultiTracks", 3., "max Xi2 for multi tracks"}
IntegerProperty	m_nholesmax {this, "nHolesMax", 2, "Max number holes"}
IntegerProperty	m_dholesmax {this, "nHolesGapMax", 2, "Max holes gap"}
IntegerProperty	m_nclusmin {this, "nClustersMin", 6, "Min number clusters"}
IntegerProperty	m_nwclusmin {this, "nWeightedClustersMin", 6, "Min umber weighted clusters(pix=2 sct=1)"}
IntegerProperty	m_trackletPoints {this, "trackletPoints", 1, "Select which tracklet points to use"}
DoubleProperty	m_phiWidth {this, "phiWidth", 0.3}
DoubleProperty	m_etaWidth {this, "etaWidth", 0.3}
DoubleArrayProperty	m_etabins {this, "etaBins", {}, "eta bins"}
DoubleArrayProperty	m_ptbins {this, "pTBins", {}, "pT bins"}

Data members, which are updated only in initialize method
enum	statAllTypes {   kTotalInputSeeds, kTotalUsedSeeds, kTotalNoTrackPar, kTotalBremSeeds,   kTwoClusters, kWrongInit, kWrongRoad, kNoTrack,   kNotNewTrack, kBremAttempt, kOutputTracks, kExtraTracks,   kBremTracks, kDESize, kSeedsWithTracks }
enum	kNStatEtaTypes { kUsedSeedsEta, kSeedsWithTracksEta }
Trk::TrackInfo	m_trackinfo
bool	m_heavyion {false}
Trk::MagneticFieldMode	m_fieldModeEnum {Trk::FullField}
std::mutex	m_counterMutex
std::array< std::atomic< int >, SiCombinatorialTrackFinderData_xk::kNSeedTypes > m_totalInputSeeds	ATLAS_THREAD_SAFE {}
std::array< std::atomic< int >, SiCombinatorialTrackFinderData_xk::kNSeedTypes > m_totalUsedSeeds	ATLAS_THREAD_SAFE {}
std::array< std::atomic< int >, SiCombinatorialTrackFinderData_xk::kNSeedTypes > m_totalNoTrackPar	ATLAS_THREAD_SAFE {}
std::array< std::atomic< int >, SiCombinatorialTrackFinderData_xk::kNSeedTypes > m_totalBremSeeds	ATLAS_THREAD_SAFE {}
std::array< std::atomic< int >, SiCombinatorialTrackFinderData_xk::kNSeedTypes > m_twoClusters	ATLAS_THREAD_SAFE {}
std::array< std::atomic< int >, SiCombinatorialTrackFinderData_xk::kNSeedTypes > m_wrongRoad	ATLAS_THREAD_SAFE {}
std::array< std::atomic< int >, SiCombinatorialTrackFinderData_xk::kNSeedTypes > m_wrongInit	ATLAS_THREAD_SAFE {}
std::array< std::atomic< int >, SiCombinatorialTrackFinderData_xk::kNSeedTypes > m_noTrack	ATLAS_THREAD_SAFE {}
std::array< std::atomic< int >, SiCombinatorialTrackFinderData_xk::kNSeedTypes > m_notNewTrack	ATLAS_THREAD_SAFE {}
std::array< std::atomic< int >, SiCombinatorialTrackFinderData_xk::kNSeedTypes > m_bremAttempt	ATLAS_THREAD_SAFE {}
std::array< std::atomic< int >, SiCombinatorialTrackFinderData_xk::kNSeedTypes > m_outputTracks	ATLAS_THREAD_SAFE {}
std::array< std::atomic< int >, SiCombinatorialTrackFinderData_xk::kNSeedTypes > m_extraTracks	ATLAS_THREAD_SAFE {}
std::array< std::atomic< int >, SiCombinatorialTrackFinderData_xk::kNSeedTypes > m_bremTracks	ATLAS_THREAD_SAFE {}
std::array< std::atomic< int >, SiCombinatorialTrackFinderData_xk::kNSeedTypes > m_seedsWithTrack	ATLAS_THREAD_SAFE {}
std::array< std::atomic< double >, SiCombinatorialTrackFinderData_xk::kNSeedTypes > m_deSize	ATLAS_THREAD_SAFE {}
std::vector< std::vector< double > > m_usedSeedsEta	ATLAS_THREAD_SAFE
std::vector< std::vector< double > > m_seedsWithTracksEta	ATLAS_THREAD_SAFE
std::vector< statAllTypes >	m_indexToEnum {kTwoClusters,kWrongInit,kWrongRoad,kNoTrack,kNotNewTrack,kBremAttempt}
std::unique_ptr< Trk::TrackParameters >	getAtaPlane (MagField::AtlasFieldCache &fieldCache, SiTrackMakerEventData_xk &data, bool sss, const std::vector< const Trk::SpacePoint * > &SP, const EventContext &ctx) const
bool	globalPositions (const Trk::SpacePoint &s0, const Trk::SpacePoint &s1, const Trk::SpacePoint &s2, double *p0, double *p1, double *p2) const
bool	globalPosition (const Trk::SpacePoint &sp, const double *dir, double *p) const
	This is a refinement of the global position for strip space-points. More...
InDet::TrackQualityCuts	setTrackQualityCuts (bool simpleTrack) const
bool	newSeed (SiTrackMakerEventData_xk &data, const std::vector< const Trk::SpacePoint * > &Sp) const
bool	isCaloCompatible (SiTrackMakerEventData_xk &data) const
bool	isHadCaloCompatible (SiTrackMakerEventData_xk &data) const
double	pTmin (double eta) const
MsgStream &	dumpStatistics (MsgStream &out) const
MsgStream &	dumpconditions (MsgStream &out) const
template<typename T , size_t N, size_t M>
void	resetCounter (std::array< std::array< T, M >, N > &a) const
	helper for working with the stat arrays More...
template<typename T , size_t N>
void	resetCounter (std::array< T, N > &a) const
static void	globalDirections (const double *p0, const double *p1, const double *p2, double *d0, double *d1, double *d2)
	Here, we derive the local track direction in the space-points as the tangents to the estimated trajectory (assuming a circle in x-y and straight line in r-z) More...
static void	detectorElementsSelection (SiTrackMakerEventData_xk &data, std::vector< const InDetDD::SiDetectorElement * > &DE)
static int	kindSeed (const std::vector< const Trk::SpacePoint * > &Sp)
static int	rapidity (const std::vector< const Trk::SpacePoint * > &Sp)
static bool	isNewTrack (SiTrackMakerEventData_xk &data, Trk::Track *Tr)
static void	clusterTrackMap (SiTrackMakerEventData_xk &data, Trk::Track *Tr)
static MsgStream &	dumpevent (SiTrackMakerEventData_xk &data, MsgStream &out)

Detailed Description

InDet::SiTrackMaker_xk is algorithm which produce Trk::Track started from 3 space points information of SCT and Pixels in the road of InDetDD::SiDetectorElement* sorted in propagation order.

In AthenaMT, event dependent cache inside SiTrackMaker_xk is not preferred. SiTrackMakerEventData_xk class holds event dependent data for SiTrackMaker_xk. Its object is instantiated in SiSPSeededTrackFinder::execute.

Author

Igor..nosp@m.Gavr.nosp@m.ilenk.nosp@m.o@ce.nosp@m.rn.ch

Definition at line 63 of file SiTrackMaker_xk.h.

Member Enumeration Documentation

kNStatEtaTypes

enum InDet::SiTrackMaker_xk::kNStatEtaTypes

private

Enumerator
kUsedSeedsEta
kSeedsWithTracksEta

Definition at line 223 of file SiTrackMaker_xk.h.

                           {
        kUsedSeedsEta,
        kSeedsWithTracksEta
      };

statAllTypes

enum InDet::SiTrackMaker_xk::statAllTypes

private

Enumerator
kTotalInputSeeds
kTotalUsedSeeds
kTotalNoTrackPar
kTotalBremSeeds
kTwoClusters
kWrongInit
kWrongRoad
kNoTrack
kNotNewTrack
kBremAttempt
kOutputTracks
kExtraTracks
kBremTracks
kDESize
kSeedsWithTracks

Definition at line 205 of file SiTrackMaker_xk.h.

                         {
        kTotalInputSeeds,
        kTotalUsedSeeds,
        kTotalNoTrackPar,
        kTotalBremSeeds,
        kTwoClusters,
        kWrongInit,
        kWrongRoad,
        kNoTrack,
        kNotNewTrack,
        kBremAttempt,
        kOutputTracks,
        kExtraTracks,
        kBremTracks,
        kDESize,
        kSeedsWithTracks
      };

Constructor & Destructor Documentation

SiTrackMaker_xk() [1/3]

InDet::SiTrackMaker_xk::SiTrackMaker_xk	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 27 of file SiTrackMaker_xk.cxx.

  : base_class(t, n, p)
{
 
}

~SiTrackMaker_xk()

virtual InDet::SiTrackMaker_xk::~SiTrackMaker_xk ( )

virtualdefault

SiTrackMaker_xk() [2/3]

InDet::SiTrackMaker_xk::SiTrackMaker_xk ( )

privatedelete

SiTrackMaker_xk() [3/3]

InDet::SiTrackMaker_xk::SiTrackMaker_xk ( const SiTrackMaker_xk &  )

privatedelete

Member Function Documentation

clusterTrackMap()

void InDet::SiTrackMaker_xk::clusterTrackMap ( SiTrackMakerEventData_xk &  data, Trk::Track *  Tr  )

staticprivate

Definition at line 1208 of file SiTrackMaker_xk.cxx.

{
  DataVector<const Trk::MeasurementBase>::const_iterator
    m  = Tr->measurementsOnTrack()->begin(),
    me = Tr->measurementsOnTrack()->end  ();
 
  for (; m!=me; ++m) {
    const Trk::PrepRawData* prd = static_cast<const Trk::RIO_OnTrack*>(*m)->prepRawData();
    if (prd) data.clusterTrack().insert(std::make_pair(prd, Tr));
  }
}

detectorElementsSelection()

void InDet::SiTrackMaker_xk::detectorElementsSelection ( SiTrackMakerEventData_xk &  data, std::vector< const InDetDD::SiDetectorElement * > &  DE  )

staticprivate

Definition at line 1085 of file SiTrackMaker_xk.cxx.

{
  std::vector<const InDetDD::SiDetectorElement*>::iterator d = DE.begin();
  while (d!=DE.end()) {
    if ((*d)->isPixel()) {
      if (!data.pix()) {
        d = DE.erase(d);
        continue;
      }
    } else if (!data.sct()) {
      d = DE.erase(d);
      continue;
    }
    ++d;
  }
}

dump()

MsgStream & InDet::SiTrackMaker_xk::dump ( SiTrackMakerEventData_xk &  data, MsgStream &  out  ) const

override

Definition at line 399 of file SiTrackMaker_xk.cxx.

{
  out<<std::endl;
  if (data.nprint()) return dumpevent(data, out);
  return dumpconditions(out);
}

dumpconditions()

MsgStream & InDet::SiTrackMaker_xk::dumpconditions ( MsgStream &  out ) const

private

Definition at line 410 of file SiTrackMaker_xk.cxx.

{
 
  int n      = 62-m_tracksfinder.type().size();
  std::string s4; for (int i=0; i<n; ++i) s4.append(" "); s4.append("|");
 
  std::string fieldmode[9] ={"NoField"       ,"ConstantField","SolenoidalField",
                             "ToroidalField" ,"Grid3DField"  ,"RealisticField" ,
                             "UndefinedField","AthenaField"  , "?????"         };
 
  Trk::MagneticFieldMode fieldModeEnum(m_fieldModeEnum);
 
  // Get AtlasFieldCache
  SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCondObjInputKey};
  const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
  if (fieldCondObj) {
    MagField::AtlasFieldCache fieldCache;
    fieldCondObj->getInitializedCache(fieldCache);
    if (!fieldCache.solenoidOn()) fieldModeEnum = Trk::NoField;
  }
 
  Trk::MagneticFieldProperties fieldprop(fieldModeEnum);
  int mode = fieldprop.magneticFieldMode();
  if (mode<0 || mode>8 ) mode = 8;
 
  n     = 62-fieldmode[mode].size();
  std::string s3; for (int i=0; i<n; ++i) s3.append(" "); s3.append("|");
 
  n     = 62-m_roadmaker.type().size();
  std::string s6; for (int i=0; i<n; ++i) s6.append(" "); s6.append("|");
 
  out<<"|----------------------------------------------------------------------"
     <<"-------------------|"
     <<std::endl;
  out<<"| Tool for road builder   | "<<m_roadmaker  .type() <<s6<<std::endl;
  out<<"} Tool for track finding  | "<<m_tracksfinder.type()<<s4<<std::endl;
  out<<"| Use association tool ?  | "
     <<std::setw(12)<<m_useassoTool
     << std::endl;
  out<<"| Magnetic field mode     | "<<fieldmode[mode]      <<s3<<std::endl;
  out<<"| Use seeds filter ?      | "<<std::setw(12)<<m_seedsfilter
     <<"                                                  |"<<std::endl;
  out<<"| Min pT of track (MeV)   | "<<std::setw(12)<<std::setprecision(5)<<m_pTmin
     <<"                                                  |"<<std::endl;
  out<<"| Max Xi2 for cluster     | "<<std::setw(12)<<std::setprecision(5)<<m_xi2max
     <<"                                                  |"<<std::endl;
  out<<"| Max Xi2 for outlayer    | "<<std::setw(12)<<std::setprecision(5)<<m_xi2maxNoAdd
     <<"                                                  |"<<std::endl;
  out<<"| Max Xi2 for link        | "<<std::setw(12)<<std::setprecision(5)<<m_xi2maxlink
     <<"                                                  |"<<std::endl;
  out<<"| Min number of clusters  | "<<std::setw(12)<<m_nclusmin
     <<"                                                  |"<<std::endl;
  out<<"| Min number of wclusters | "<<std::setw(12)<<m_nwclusmin
     <<"                                                  |"<<std::endl;
  out<<"| Max number holes        | "<<std::setw(12)<<m_nholesmax
     <<"                                                  |"<<std::endl;
  out<<"| Max holes  gap          | "<<std::setw(12)<<m_dholesmax
     <<"                                                  |"<<std::endl;
  out<<"|----------------------------------------------------------------------"
     <<"-------------------|"
     <<std::endl;
  return out;
}

dumpevent()

MsgStream & InDet::SiTrackMaker_xk::dumpevent ( SiTrackMakerEventData_xk &  data, MsgStream &  out  )

staticprivate

Definition at line 479 of file SiTrackMaker_xk.cxx.

{
  out<<"|---------------------------------------------------------------------|"
     <<std::endl;
  out<<"| Number input seeds      | "<<std::setw(12)<<data.inputseeds()
     <<"                              |"<<std::endl;
  out<<"| Number good  seeds      | "<<std::setw(12)<<data.goodseeds()
     <<"                              |"<<std::endl;
  out<<"| Number output tracks    | "<<std::setw(12)<<data.findtracks()
     <<"                              |"<<std::endl;
  out<<"|---------------------------------------------------------------------|"
     <<std::endl;
  return out;
}

dumpStatistics()

MsgStream & InDet::SiTrackMaker_xk::dumpStatistics ( MsgStream &  out ) const

private

Definition at line 199 of file SiTrackMaker_xk.cxx.

{
 
  out<<"|----------------------|--------------|--------------|--------------|--------------|--------------|"
       <<std::endl;
  out<<"| Kind of seed         |     PPP      |     PPS      |     PSS      |     SSS      |     ALL      |"
       <<std::endl;
  out<<"|----------------------|--------------|--------------|--------------|--------------|--------------|"
       <<std::endl;
  out<<"| Input  seeds         | "
     <<std::setw(12)<<m_totalInputSeeds[0]<<" | "
     <<std::setw(12)<<m_totalInputSeeds[1]<<" | "
     <<std::setw(12)<<m_totalInputSeeds[2]<<" | "
     <<std::setw(12)<<m_totalInputSeeds[3]<<" | "
     <<std::setw(12)<<(m_totalInputSeeds[0]+m_totalInputSeeds[1]+m_totalInputSeeds[2]+m_totalInputSeeds[3])
     <<" |"<<std::endl;
 
  out<<"| No track parameters  | "
     <<std::setw(12)<<m_totalNoTrackPar[0]<<" | "
     <<std::setw(12)<<m_totalNoTrackPar[1]<<" | "
     <<std::setw(12)<<m_totalNoTrackPar[2]<<" | "
     <<std::setw(12)<<m_totalNoTrackPar[3]<<" | "
     <<std::setw(12)<<(m_totalNoTrackPar[0]+m_totalNoTrackPar[1]+ m_totalNoTrackPar[2]+m_totalNoTrackPar[3])
     <<" |"<<std::endl;
 
  out<<"| Used   seeds         | "
     <<std::setw(12)<<m_totalUsedSeeds[0]<<" | "
     <<std::setw(12)<<m_totalUsedSeeds[1]<<" | "
     <<std::setw(12)<<m_totalUsedSeeds[2]<<" | "
     <<std::setw(12)<<m_totalUsedSeeds[3]<<" | "
     <<std::setw(12)<<(m_totalUsedSeeds[0]+m_totalUsedSeeds[1]+ m_totalUsedSeeds[2]+m_totalUsedSeeds[3])
     <<" |"<<std::endl;
 
  out<<"| Used   seeds  brem   | "
     <<std::setw(12)<<m_totalBremSeeds[0]<<" | "
     <<std::setw(12)<<m_totalBremSeeds[1]<<" | "
     <<std::setw(12)<<m_totalBremSeeds[2]<<" | "
     <<std::setw(12)<<m_totalBremSeeds[3]<<" | "
     <<std::setw(12)<<(m_totalBremSeeds[0]+m_totalBremSeeds[1]+m_totalBremSeeds[2]+m_totalBremSeeds[3])
     <<" |"<<std::endl;
 
  double tdetsize = 0.;
  int    goodseed = 0;
  for(int i=0; i!=SiCombinatorialTrackFinderData_xk::kNSeedTypes; i++) {
    tdetsize+= m_deSize[i];
    goodseed+= m_totalUsedSeeds[i];
    if(m_totalUsedSeeds[i] > 0.) m_deSize[i]= m_deSize[i]/m_totalUsedSeeds[i];
  }
  if(goodseed > 0) tdetsize/=double(goodseed);
 
  out<<"| Det elements in road | "
     <<std::setw(12)<<std::setprecision(4)<<m_deSize[0]<<" | "
     <<std::setw(12)<<std::setprecision(5)<<m_deSize[1]<<" | "
     <<std::setw(12)<<std::setprecision(5)<<m_deSize[2]<<" | "
     <<std::setw(12)<<std::setprecision(5)<<m_deSize[3]<<" | "
     <<std::setw(12)<<std::setprecision(5)<<tdetsize
     <<" |"<<std::endl;
 
 
  out<<"| Two clusters on DE   | "
     <<std::setw(12)<<m_twoClusters[0]<<" | "
     <<std::setw(12)<<m_twoClusters[1]<<" | "
     <<std::setw(12)<<m_twoClusters[2]<<" | "
     <<std::setw(12)<<m_twoClusters[3]<<" | "
     <<std::setw(12)<<(m_twoClusters[0]+m_twoClusters[1]+m_twoClusters[2]+m_twoClusters[3])
     <<" |"<<std::endl;
 
  out<<"| Wrong DE road        | "
     <<std::setw(12)<<m_wrongRoad[0]<<" | "
     <<std::setw(12)<<m_wrongRoad[1]<<" | "
     <<std::setw(12)<<m_wrongRoad[2]<<" | "
     <<std::setw(12)<<m_wrongRoad[3]<<" | "
     <<std::setw(12)<<(m_wrongRoad[0]+m_wrongRoad[1]+m_wrongRoad[2]+m_wrongRoad[3])
     <<" |"<<std::endl;
 
  out<<"| Wrong initialization | "
     <<std::setw(12)<<m_wrongInit[0]<<" | "
     <<std::setw(12)<<m_wrongInit[1]<<" | "
     <<std::setw(12)<<m_wrongInit[2]<<" | "
     <<std::setw(12)<<m_wrongInit[3]<<" | "
     <<std::setw(12)<<(m_wrongInit[0]+m_wrongInit[1]+m_wrongInit[2]+m_wrongInit[3])
     <<" |"<<std::endl;
 
  out<<"| Can not find track   | "
     <<std::setw(12)<<m_noTrack[0]<<" | "
     <<std::setw(12)<<m_noTrack[1]<<" | "
     <<std::setw(12)<<m_noTrack[2]<<" | "
     <<std::setw(12)<<m_noTrack[3]<<" | "
     <<std::setw(12)<<(m_noTrack[0]+m_noTrack[1]+m_noTrack[2]+m_noTrack[3])
     <<" |"<<std::endl;
 
  out<<"| It is not new track  | "
     <<std::setw(12)<<m_notNewTrack[0]<<" | "
     <<std::setw(12)<<m_notNewTrack[1]<<" | "
     <<std::setw(12)<<m_notNewTrack[2]<<" | "
     <<std::setw(12)<<m_notNewTrack[3]<<" | "
     <<std::setw(12)<<(m_notNewTrack[0]+m_notNewTrack[1]+m_notNewTrack[2]+m_notNewTrack[3])
     <<" |"<<std::endl;
 
  out<<"| Attempts brem model  | "
     <<std::setw(12)<<m_bremAttempt[0]<<" | "
     <<std::setw(12)<<m_bremAttempt[1]<<" | "
     <<std::setw(12)<<m_bremAttempt[2]<<" | "
     <<std::setw(12)<<m_bremAttempt[3]<<" | "
     <<std::setw(12)<<(m_bremAttempt[0]+m_bremAttempt[1]+m_bremAttempt[2]+m_bremAttempt[3])
     <<" |"<<std::endl;
 
  out<<"| Output tracks        | "
     <<std::setw(12)<<m_outputTracks[0]<<" | "
     <<std::setw(12)<<m_outputTracks[1]<<" | "
     <<std::setw(12)<<m_outputTracks[2]<<" | "
     <<std::setw(12)<<m_outputTracks[3]<<" | "
     <<std::setw(12)<<(m_outputTracks[0]+m_outputTracks[1]+m_outputTracks[2]+m_outputTracks[3])
     <<" |"<<std::endl;
 
  out<<"| Output extra tracks  | "
     <<std::setw(12)<<m_extraTracks[0]<<" | "
     <<std::setw(12)<<m_extraTracks[1]<<" | "
     <<std::setw(12)<<m_extraTracks[2]<<" | "
     <<std::setw(12)<<m_extraTracks[3]<<" | "
     <<std::setw(12)<<(m_extraTracks[0]+m_extraTracks[1]+m_extraTracks[2]+m_extraTracks[3])
     <<" |"<<std::endl;
 
  out<<"| Output tracks brem   | "
     <<std::setw(12)<<m_bremTracks[0]<<" | "
     <<std::setw(12)<<m_bremTracks[1]<<" | "
     <<std::setw(12)<<m_bremTracks[2]<<" | "
     <<std::setw(12)<<m_bremTracks[3]<<" | "
     <<std::setw(12)<<(m_bremTracks[0]+m_bremTracks[1]+m_bremTracks[2]+m_bremTracks[3])
     <<" |"<<std::endl;
 
  out<<"|----------------------|--------------|--------------|--------------|--------------|--------------|--------------|"
     <<std::endl;
   out<<"| Seeds  with  track   | "
     <<std::setw(12)<<m_seedsWithTrack[0]<<" | "
     <<std::setw(12)<<m_seedsWithTrack[1]<<" | "
     <<std::setw(12)<<m_seedsWithTrack[2]<<" | "
     <<std::setw(12)<<m_seedsWithTrack[3]<<" | "
     <<std::setw(12)<<(m_seedsWithTrack[0]+m_seedsWithTrack[1]+m_seedsWithTrack[2]+m_seedsWithTrack[3])
     <<" | Number seeds |"<<std::endl;
  out<<"|----------------------|--------------|--------------|--------------|--------------|--------------|--------------|"
     <<std::endl;
 
  std::vector<std::pair<int,std::string>> rapidityTablePrint;
  //Defining the range values to be printed
  rapidityTablePrint.emplace_back(0,std::string("| Track/Used   0.0-0.5 | "));
  rapidityTablePrint.emplace_back(1,std::string("|              0.5-1.0 | "));
  rapidityTablePrint.emplace_back(2,std::string("|              1.0-1.5 | "));
  rapidityTablePrint.emplace_back(3,std::string("|              1.5-2.0 | "));
  rapidityTablePrint.emplace_back(4,std::string("|              2.0-2.5 | "));
  rapidityTablePrint.emplace_back(5,std::string("|              2.5-3.0 | "));
  rapidityTablePrint.emplace_back(6,std::string("|              3.0-3.5 | "));
  rapidityTablePrint.emplace_back(7,std::string("|              3.5-4.0 | "));
 
 
  for(int i=0; i!=SiCombinatorialTrackFinderData_xk::kNRapidityRanges; ++i) {
 
    std::array<double,SiCombinatorialTrackFinderData_xk::kNSeedTypes+1> pu{};
    pu.fill(0);
 
    double totalUsedSeedsEta = 0.;
 
    for(int j = 0; j != SiCombinatorialTrackFinderData_xk::kNSeedTypes; ++j){
 
      if(m_usedSeedsEta[j][i]!=0.) pu[j]=m_seedsWithTracksEta[j][i]/m_usedSeedsEta[j][i];
      totalUsedSeedsEta += m_usedSeedsEta[j][i];
 
    }
 
    if(totalUsedSeedsEta!=0.) {
 
      for(int j = 0; j != SiCombinatorialTrackFinderData_xk::kNSeedTypes; ++j){
 
        pu[SiCombinatorialTrackFinderData_xk::kNSeedTypes] += m_seedsWithTracksEta[j][i];
 
      }
      pu[SiCombinatorialTrackFinderData_xk::kNSeedTypes] /= totalUsedSeedsEta;
    }
 
    out<<rapidityTablePrint.at(i).second;
    out << std::setw(12) << std::setprecision(4) << pu[0] << " | "
        << std::setw(12) << std::setprecision(4) << pu[1] << " | "
        << std::setw(12) << std::setprecision(4) << pu[2] << " | "
        << std::setw(12) << std::setprecision(4) << pu[3] << " | "
        << std::setw(12) << std::setprecision(4) << pu[4] << " | "
        << std::setw(12)
        << static_cast<int>(m_seedsWithTracksEta[0][i]) +
               static_cast<int>(m_seedsWithTracksEta[1][i]) +
               static_cast<int>(m_seedsWithTracksEta[2][i]) +
               static_cast<int>(m_seedsWithTracksEta[3][i])
        << " |" << std::endl;
  }
 
  out<<"|----------------------|--------------|--------------|--------------|--------------|--------------|--------------|"
     <<std::endl;
 
  return out;
 
}

endEvent()

void InDet::SiTrackMaker_xk::endEvent ( SiTrackMakerEventData_xk &  data ) const

overridevirtual

End event for track finder tool

correction to exclude memory fragmentation

Definition at line 602 of file SiTrackMaker_xk.cxx.

{
  m_tracksfinder->endEvent(data.combinatorialData());
 
  data.clusterTrack().clear();
 
  // end event for seed to track tool
  if (m_seedsegmentsWrite) m_seedtrack->endEvent(data.conversionData());
 
  // fill statistics
  {
    std::lock_guard<std::mutex> lock(m_counterMutex);
 
    for(int K = 0; K != SiCombinatorialTrackFinderData_xk::kNSeedTypes; ++K) {
      for(int r = 0; r != 8; ++r) {
        m_usedSeedsEta[K][r] += data.summaryStatUsedInTrack()[kUsedSeedsEta][K][r];
        m_seedsWithTracksEta[K][r] += data.summaryStatUsedInTrack()[kSeedsWithTracksEta][K][r];
      }
    }
  }
  for (int K = 0; K != SiCombinatorialTrackFinderData_xk::kNSeedTypes; ++K) {
    m_totalInputSeeds[K] +=  data.summaryStatAll()[kTotalInputSeeds][K];
    m_totalUsedSeeds[K] = m_totalUsedSeeds[K] + data.summaryStatAll()[kTotalUsedSeeds][K];
    m_totalNoTrackPar[K] += data.summaryStatAll()[kTotalNoTrackPar][K];
    m_totalBremSeeds[K] += data.summaryStatAll()[kTotalBremSeeds][K];
    m_twoClusters[K] += data.summaryStatAll()[kTwoClusters][K];
    m_wrongRoad[K] += data.summaryStatAll()[kWrongRoad][K];
    m_wrongInit[K] += data.summaryStatAll()[kWrongInit][K];
    m_noTrack[K] += data.summaryStatAll()[kNoTrack][K];
    m_notNewTrack[K] += data.summaryStatAll()[kNotNewTrack][K];
    m_bremAttempt[K] += data.summaryStatAll()[kBremAttempt][K];
    m_outputTracks[K] += data.summaryStatAll()[kOutputTracks][K];
    m_extraTracks[K] += data.summaryStatAll()[kExtraTracks][K];
    m_bremTracks[K] += data.summaryStatAll()[kBremTracks][K];
    m_seedsWithTrack[K] += data.summaryStatAll()[kSeedsWithTracks][K];
    m_deSize[K] = m_deSize[K] + data.summaryStatAll()[kDESize][K];
  }
  // Print event information
  //
  if (msgLevel()<=0) {
    data.nprint() = 1;
    dump(data, msg(MSG::DEBUG));
  }
}

finalize()

StatusCode InDet::SiTrackMaker_xk::finalize ( )

overridevirtual

Definition at line 186 of file SiTrackMaker_xk.cxx.

{
  MsgStream &out = msg(MSG::INFO);
  out << "::finalize() -- statistics:" <<std::endl;
  dumpStatistics(out);
  out<<endmsg;
  return AlgTool::finalize();
}

getAtaPlane()

std::unique_ptr< Trk::TrackParameters > InDet::SiTrackMaker_xk::getAtaPlane ( MagField::AtlasFieldCache &  fieldCache, SiTrackMakerEventData_xk &  data, bool  sss, const std::vector< const Trk::SpacePoint * > &  SP, const EventContext &  ctx  ) const

private

we need at least three space points on the seed.

for tracklets we select first, middle, and last spacepoint of the seed to improve pT estimate

for tracklets we select middle, 3rd-quarter, and last spacepoint of the seed

for tracklets we select first, penultimate, and last spacepoint of the seed

for tracklets we select first, second, and third spacepoint of the seed

get the first cluster on the first hit

and use the surface from this cluster as our reference plane

write the global positions into arrays. This includes an improved position estimate for strip spacepoints. If this improvement fails, the method can return false -> then we abort

translate second and third SP w.r.t first one

distance of second SP to first in transverse plane Also happens to be u-coordinate of second SP in conformal mapping

denominator for conformal mapping

coordinate system for conformal mapping - this is local x

u-coordinate of third SP in conformal mapping

v-coordinate of third SP in conformal mapping

A,B are slope and intercept of the straight line in the u,v plane connecting the three points.

Keep in mind that v1 == 0

From inserting A into linear equation. Note that Igor sneaks in a factor two here

Curvature estimate. (2R)²=(1+A²)/b² => 1/2R = b/sqrt(1+A²) = B / sqrt(1+A²).

estimate of the track dz/dr (1/tanTheta), corrected for curvature effects

local x of the surface in the global frame

local y of the surface in the global frame

centre of the surface in the global frame

location of the first SP w.r.t centre of the surface

local x and y - project onto local axes

silently switch off field if solenoid is off

if we are not running with "no field":

get the field at our first SP

field is in kiloTesla. So here we check for more than 0.1 Tesla

phi estimate

theta estimate

inverse transverse momentum estimate

if we have low field, use a straight-line estimate

note: Now no curvature correction

no pt estimate, assume min pt

treat absence of solenoid like the low-field case

apply the pt on the initial parameter estimate, with some margin

update qoverp

qoverp from qoverpt and theta

ref point = first SP

never done in main ATLAS tracking. Would otherwise check if the seed is compatible with a hadronic ROI

now we can return the initial track parameters we built, parameterised using the ref surface. Pass a nullptr for the covariance

Definition at line 879 of file SiTrackMaker_xk.cxx.

{
  if (theSeed.size() < 3) return nullptr;
 
  std::vector<const Trk::SpacePoint*> SP;
 
  if (m_trackletPoints == 1) {
    unsigned int middleIdx = theSeed.size() == 3 ? 1 : theSeed.size()/2;
    SP = {theSeed[0], theSeed[middleIdx], theSeed.back()};
  }
  // for tracklets we select last 3 spacepoints of the seed
  else if (m_trackletPoints == 2) {
    SP = {theSeed[theSeed.size() - 3], theSeed[theSeed.size() - 2], theSeed.back()};
  }
  else if (m_trackletPoints == 3) {
    unsigned int middleIdx = theSeed.size() == 3 ? 0 : theSeed.size()/2;
    unsigned int quarterIdx = theSeed.size() == 3 ? 1 : 3*theSeed.size()/4;
    SP = {theSeed[middleIdx], theSeed[quarterIdx], theSeed.back()};
  }
  else if (m_trackletPoints == 4) {
    SP = {theSeed[0], theSeed[theSeed.size() - 2], theSeed.back()};
  }
  else if (m_trackletPoints == 5) {
    SP = {theSeed[0], theSeed[1], theSeed[2]};
  }
 
 
  const Trk::PrepRawData* cl  = SP[0]->clusterList().first;
  if (!cl) return nullptr;
  const Trk::PlaneSurface* pla =
    static_cast<const Trk::PlaneSurface*>(&cl->detectorElement()->surface());
  if (!pla) return nullptr;
 
  double p0[3],p1[3],p2[3];
  if (!globalPositions(*(SP[0]),*(SP[1]),*(SP[2]),p0,p1,p2)) return nullptr;
 
  double x0 = p0[0]   ;
  double y0 = p0[1]   ;
  double z0 = p0[2]   ;
  double x1 = p1[0]-x0;
  double y1 = p1[1]-y0;
  double x2 = p2[0]-x0;
  double y2 = p2[1]-y0;
  double z2 = p2[2]-z0;
 
  double u1 = 1./sqrt(x1*x1+y1*y1)       ;
  double rn = x2*x2+y2*y2                ;
  double r2 = 1./rn                      ;
  double a  = x1*u1                      ;
  double b  = y1*u1                      ;
  double u2 = (a*x2+b*y2)*r2             ;
  double v2 = (a*y2-b*x2)*r2             ;
  double A  = v2/(u2-u1)                 ;  
  double B  = 2.*(v2-A*u2)               ;  
  double C  = B/sqrt(1.+A*A)             ;  
  double T  = z2*sqrt(r2)/(1.+.04*C*C*rn);  
  if(m_ITKGeometry){
    T = std::abs(C) > 1.e-6 ? (z2*C)/asin(C*sqrt(rn)) : z2/sqrt(rn);
  }
 
  const Amg::Transform3D& Tp = pla->transform();
 
  double Ax[3] = {Tp(0,0),Tp(1,0),Tp(2,0)};
  double Ay[3] = {Tp(0,1),Tp(1,1),Tp(2,1)};
  double D [3] = {Tp(0,3),Tp(1,3),Tp(2,3)};
  double   d[3] = {x0-D[0],y0-D[1],z0-D[2]};
  data.par()[0] = d[0]*Ax[0]+d[1]*Ax[1]+d[2]*Ax[2];
  data.par()[1] = d[0]*Ay[0]+d[1]*Ay[1]+d[2]*Ay[2];
 
  Trk::MagneticFieldMode fieldModeEnum(m_fieldModeEnum);
  if (!fieldCache.solenoidOn()) fieldModeEnum = Trk::NoField;
 
  Trk::MagneticFieldProperties fieldprop(fieldModeEnum);
  if (fieldprop.magneticFieldMode() > 0) {
 
    double H[3],gP[3] ={x0,y0,z0};
    fieldCache.getFieldZR(gP, H);
 
    if (fabs(H[2])>.0001) {
      data.par()[2] = atan2(b+a*A,a-b*A);
      data.par()[3] = atan2(1.,T)       ;
      data.par()[5] = -C/(300.*H[2])    ;
    } else {
      T    =  z2*sqrt(r2)  ;  
      data.par()[2] = atan2(y2,x2);
      data.par()[3] = atan2(1.,T) ;
      data.par()[5] = m_ITKGeometry ? 0.9/m_pTmin : 1./m_pTmin  ; 
    }
  }
  else {
    T    = z2*sqrt(r2)   ;
    data.par()[2] = atan2(y2,x2);
    data.par()[3] = atan2(1.,T) ;
    data.par()[5] = m_ITKGeometry ? 0.9/m_pTmin : 1./m_pTmin  ;
  }
 
  double pTm = pTmin(SP[0]->eta());    // all spacepoints should have approx. same eta
 
  if (m_ITKGeometry){
    if(std::abs(data.par()[5])*pTm > 1) return nullptr;
  }
  else if(std::abs(data.par()[5])*m_pTmin > 1.1) return nullptr;
 
  data.par()[4] = data.par()[5]/sqrt(1.+T*T);   
  data.par()[6] = x0                              ;   
  data.par()[7] = y0                              ;
  data.par()[8] = z0                              ;
 
  if (sss && !isHadCaloCompatible(data)) return nullptr;
 
  std::unique_ptr<Trk::TrackParameters> T0 = pla->createUniqueTrackParameters(data.par()[0],
                                          data.par()[1],
                                          data.par()[2],
                                          data.par()[3],
                                          data.par()[4],
                                          std::nullopt);
 
  if(m_ITKGeometry && m_tracksfinder->pTseed(data.combinatorialData(),*T0,SP,ctx) < pTm) return nullptr;
  else return T0;
 
}

getTracks() [1/2]

std::list< Trk::Track * > InDet::SiTrackMaker_xk::getTracks ( const EventContext &  ctx, SiTrackMakerEventData_xk &  data, const std::vector< const Trk::SpacePoint * > &  Sp  ) const

overridevirtual

incremenet seed counter

0 or 3 typically (PPP or SSS), other numbers indicate PPS/PSS (1/2)

eta of the seed, rounded down to leading digit via int-conversion

more counter incrementation

prepare output list

if we run the SI track maker without using the Si, this becomes a trivial task...

check seed quality.

this checks if all of the clusters on the seed are already on one single existing track. If not, we consider the seed to be "good"

read the B-field cache

Get initial parameters estimation from our seed

if we failed to get the initial parameters, we bail out. Can happen in certain pathological cases (e.g. malformed strip hits), or if we would be running with calo-ROI strip seeds (we aren't)

otherwise, increment the 'good seeds' counter

Now, obtain a search road of detector elements. This is done by extrapolating our estimated starting parameters through the detector and collecting all detector elements reasonably close to the projected trajectory. This will populate the 'DE" list.

if we don't use all of pix and SCT, filter our list, erasing any that don't fit our requirements

if we did not find sufficient detector elements to fulfill the minimum cluster requirement, bail out. We will not be able to build a track satisfying the cuts.

update statistics tables - we have sufficient detector elements to have a chance of finding a track!

prepare a list of global positions

update another counter

Find possible list of tracks using space points space points information

Note: The branch below is the one taken in ATLAS default inside-out tracking for run-3

update stat tables

update the cluster-track-map to allow to filter any upcoming seeds with hits that are already taken

require sufficient free clusters on track

Definition at line 653 of file SiTrackMaker_xk.cxx.

{
  ++data.inputseeds();
 
  int K = kindSeed(Sp);
  int r = rapidity(Sp);
 
  ++data.summaryStatAll()[kTotalInputSeeds][K];
 
  std::list<Trk::Track*> tracks;
  if (!data.pix() && !data.sct()) return tracks;
 
  bool isGoodSeed{true};
  if (m_seedsfilter) isGoodSeed=newSeed(data, Sp);
  if (!m_seedsegmentsWrite && !isGoodSeed) {
    return tracks;
  }
 
  // Get AtlasFieldCache
  MagField::AtlasFieldCache fieldCache;
 
  SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCondObjInputKey, ctx};
  const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
  if (fieldCondObj == nullptr) {
      ATH_MSG_ERROR("InDet::SiTrackMaker_xk::getTracks: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
      return tracks;
  }
  fieldCondObj->getInitializedCache (fieldCache);
 
  std::unique_ptr<Trk::TrackParameters> Tp = nullptr;
  Tp = getAtaPlane(fieldCache, data, false, Sp, ctx);
  if (m_seedsegmentsWrite && Tp) {
    m_seedtrack->executeSiSPSeedSegments(data.conversionData(), Tp.get(), isGoodSeed, Sp);
  }
 
  if (m_seedsegmentsWrite && !isGoodSeed) {
    return tracks;
  }
  if (!Tp) {
     ++data.summaryStatAll()[kTotalNoTrackPar][K];
     return tracks;
  }
 
  ++data.goodseeds();
 
 
  std::vector<const InDetDD::SiDetectorElement*> DE;
 
  if(!m_useTrigInDetRoadPredictorTool) {
    if (!m_cosmicTrack){
      m_roadmaker->detElementsRoad(ctx, fieldCache, *Tp, Trk::alongMomentum, DE, data.roadMakerData());
    }
    else{
      m_roadmaker->detElementsRoad(ctx, fieldCache, *Tp, Trk::oppositeMomentum, DE, data.roadMakerData());
    }
  } else {
    int road_length = m_trigInDetRoadPredictorTool->getRoad(Sp, DE, ctx);
    if(road_length == 0) {
      return tracks;
    }
  }
 
  if (!data.pix() || !data.sct()) detectorElementsSelection(data, DE);
 
  if ( static_cast<int>(DE.size())  <   m_nclusmin) {
    return tracks;
  }
 
  data.summaryStatAll()[kDESize][K] += double(DE.size());
  ++data.summaryStatAll()[kTotalUsedSeeds][K];
 
  std::vector<Amg::Vector3D> Gp;
 
  ++data.summaryStatUsedInTrack()[kUsedSeedsEta][K][r];
 
  if (!m_useBremModel) {
    if(m_useTrigTrackFollowingTool) {
      Trk::Track* newTrack = m_trigInDetTrackFollowingTool->getTrack(Sp, DE, ctx);
      if(newTrack != nullptr) tracks.push_back(newTrack);
    }
    else {
      tracks = m_tracksfinder->getTracks(data.combinatorialData(), *Tp, Sp, Gp, DE, data.clusterTrack(),ctx);
    }
  } else if (!m_useCaloSeeds) {
    ++data.summaryStatAll()[kTotalBremSeeds][K];
    tracks = m_tracksfinder->getTracksWithBrem(data.combinatorialData(), *Tp, Sp, Gp, DE, data.clusterTrack(), false,ctx);
  }
  else if (isCaloCompatible(data)) {
 
    ++data.summaryStatAll()[kTotalBremSeeds][K];
    tracks = m_tracksfinder->getTracksWithBrem(data.combinatorialData(), *Tp, Sp, Gp, DE, data.clusterTrack(), true,ctx);
  } else {
    tracks = m_tracksfinder->getTracks        (data.combinatorialData(), *Tp, Sp, Gp, DE, data.clusterTrack(),ctx);
  }
 
  std::array<bool,SiCombinatorialTrackFinderData_xk::kNCombStats> inf{0,0,0,0,0,0};
  m_tracksfinder->fillStatistic(data.combinatorialData(),inf);
  for (size_t p =0; p<inf.size(); ++p){
    if(inf[p]) ++data.summaryStatAll()[m_indexToEnum[p]][K];
  }
 
  if (m_seedsfilter) {
    std::list<Trk::Track*>::iterator t = tracks.begin();
    while (t!=tracks.end()) {
      if (!isNewTrack(data, *t)) {
        delete (*t);
        tracks.erase(t++);
      } else {
        if((*t)->info().trackProperties(Trk::TrackInfo::BremFit)) ++data.summaryStatAll()[kBremTracks][K];
        clusterTrackMap(data, *t++);
      }
    }
  }
  data.findtracks() += tracks.size();
 
  if(!tracks.empty()) {
    ++data.summaryStatAll()[kSeedsWithTracks][K];
    ++data.summaryStatUsedInTrack()[kSeedsWithTracksEta][K][r];
    data.summaryStatAll()[kOutputTracks][K] += tracks.size();
    data.summaryStatAll()[kExtraTracks][K] += (tracks.size()-1);
  }
 
  return tracks;
 
}

getTracks() [2/2]

std::list< Trk::Track * > InDet::SiTrackMaker_xk::getTracks ( const EventContext &  ctx, SiTrackMakerEventData_xk &  data, const Trk::TrackParameters &  Tp, const std::vector< Amg::Vector3D > &  Gp  ) const

overridevirtual

Definition at line 816 of file SiTrackMaker_xk.cxx.

{
  ++data.inputseeds();
  std::list<Trk::Track*> tracks;
  if (!data.pix() && !data.sct()) return tracks;
 
  ++data.goodseeds();
 
  // Get AtlasFieldCache
  MagField::AtlasFieldCache fieldCache;
 
  SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCondObjInputKey, ctx};
  const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
  if (fieldCondObj == nullptr) {
      ATH_MSG_ERROR("InDet::SiTrackMaker_xk::getTracks: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
      return tracks;
  }
  fieldCondObj->getInitializedCache (fieldCache);
 
  // Get detector elements road
  //
  std::vector<const InDetDD::SiDetectorElement*> DE;
  if (!m_cosmicTrack) m_roadmaker->detElementsRoad(ctx, fieldCache, Tp,Trk::alongMomentum,   DE, data.roadMakerData());
  else                m_roadmaker->detElementsRoad(ctx, fieldCache, Tp,Trk::oppositeMomentum,DE, data.roadMakerData());
 
  if (!data.pix() || !data.sct()) detectorElementsSelection(data, DE);
 
  if (static_cast<int>(DE.size()) < m_nclusmin) return tracks;
 
  // Find possible list of tracks with trigger track parameters or global positions
  //
  std::vector<const Trk::SpacePoint*>  Sp;
 
  if (!m_useBremModel) {
    tracks = m_tracksfinder->getTracks        (data.combinatorialData(), Tp, Sp, Gp, DE, data.clusterTrack(),ctx);
  } else if (!m_useCaloSeeds) {
   tracks = m_tracksfinder->getTracksWithBrem(data.combinatorialData(), Tp, Sp, Gp, DE, data.clusterTrack(), false,ctx);
  } else if (isCaloCompatible(data)) {
    tracks = m_tracksfinder->getTracksWithBrem(data.combinatorialData(), Tp, Sp, Gp, DE, data.clusterTrack(), true,ctx);
  } else {
    tracks = m_tracksfinder->getTracks        (data.combinatorialData(), Tp, Sp, Gp, DE, data.clusterTrack(),ctx);
  }
 
  if (m_seedsfilter) {
    std::list<Trk::Track*>::iterator t = tracks.begin();
    while (t!=tracks.end()) {
      if (!isNewTrack(data, *t)) {
        delete (*t);
        tracks.erase(t++);
      } else {
        clusterTrackMap(data, *t++);
      }
    }
  }
  data.findtracks() += tracks.size();
  return tracks;
}

globalDirections()

void InDet::SiTrackMaker_xk::globalDirections ( const double *  p0, const double *  p1, const double *  p2, double *  d0, double *  d1, double *  d2  )

staticprivate

Here, we derive the local track direction in the space-points as the tangents to the estimated trajectory (assuming a circle in x-y and straight line in r-z)

transform transverse coordinates relative to the first SP

Now apply the same transform used in the seed maker: x,y --> u:=x/(x²+y²); v:=y/(x²+y²); in a frame centered around first SP

set x axis as direction unit vector in transverse plane, from first to second SP

reasoning: u = sqrt(d01)/d01, and v01 = 0

decompose the SP3-SP1 separation into components parallel...

and orthogonal to our new local x axis

squared distance third to first SP the transverse plane

u,v coordinates of third SP in the new frame

Now obtain A,B parameters from circle parameterisation in the new frame: V = (-x0/y0) x U + 1/(2y0) =: A x U + B. A ~= delta V / delta U, B = V - A x U, add a factor 2 for utility

v01 is 0, as the direction from SP 1 to 2 is the u-axis

Now we can resolve the related geometry. Note that A0, in the original frame, is related to the angle Phi1 between the tangent the central SP and the tendon between the first and second SP, alpha, as tan(alpha) = A0.

dz/dr along the seed = 1 / tan(theta)

1/sqrt(1+1/tan²(theta)) -> sin(theta)

cos theta (= sin(theta)/tan(theta))

multiply with cos(alpha) via A0

(a,b) parameterises the direction corresponding to the tendon between the first two SP. Now, go from there to the local tangents by removing or adding the angle 'alpha' from before, derived from A0. direction at first SP - rotated by - 1 x alpha w.r.t the tendon defining a and b The structure below comes from the formulae for sin / cos of a sum of two angles with (a,b) = r(cos phi / - sin phi)

px0: a sin theta cos alpha - b sin theta sin alpha

py0: b sin theta cos alpha + a sin theta sin alpha

pz0: cos theta

direction at second SP - rotated by + 1 x alpha w.r.t the tendon

px1: a sin theta cos alpha + b sin theta sin alpha

py1: b sin theta cos alpha - a sin theta sin alpha

pz1: cos theta

direction at third SP

px2: a sin theta cos alpha * C2 - b sin theta cos alpha S2

py2: b sin theta cos alpha * C2 + a sin theta cos alpha S2

Definition at line 1423 of file SiTrackMaker_xk.cxx.

{
  double x01 = p1[0]-p0[0]      ;
  double y01 = p1[1]-p0[1]      ;
  double x02 = p2[0]-p0[0]      ;
  double y02 = p2[1]-p0[1]      ;
 
 
  double d01 = x01*x01+y01*y01  ;
  double x1  = sqrt(d01)        ;
  double u01 = 1./x1            ; 
  double a   = x01*u01          ;
  double b   = y01*u01          ;
  double x2  = a*x02+b*y02      ;
  double y2  = a*y02-b*x02      ;
 
  double d02 = x2*x2+y2*y2      ;
  double u02 = x2/d02           ;
  double v02 = y2/d02           ;
  double A0  =  v02 /(u02-u01)  ; 
  double B0  = 2.*(v02-A0*u02)  ;
 
 
  double C2  = (1.-B0*y2)       ;
  double S2  = (A0+B0*x2)       ;
 
  double T   = (p2[2]-p0[2])/sqrt(d02);   
  double sinTheta  = 1./sqrt(1.+T*T)        ;   
  double cosTheta  = sinTheta*T                   ;   
  double sinThetaCosAlpha        = sinTheta / sqrt(1.+A0*A0)         ;    
  double Sa  = sinThetaCosAlpha*a                   ;
  double Sb  = sinThetaCosAlpha*b                   ;
 
  d0[0] = Sa   -Sb*A0;      
  d0[1]=  Sb   +Sa*A0;      
  d0[2]=cosTheta;           
 
  d1[0] = Sa   +Sb*A0;      
  d1[1]=  Sb   -Sa*A0;      
  d1[2]=cosTheta;           
 
  d2[0] = Sa*C2-Sb*S2;       
  d2[1]=  Sb*C2+Sa*S2;       
  d2[2]=cosTheta;
}

globalPosition()

bool InDet::SiTrackMaker_xk::globalPosition ( const Trk::SpacePoint &  sp, const double *  dir, double *  p  ) const

private

This is a refinement of the global position for strip space-points.

It uses the direction estimate to fix the hit position along the strip axis (non-sensitive direction).

pick up the two components of the space point

get the two ends of the strip in the global frame for each of the two clusters

get the "strip axis" in the global frame for each of the two clusters these define two planes in which the strips are sensitive

get the connection vector between the bottom ends of the two strips

divide max distance by the first strip length

Get the cross products of the direction vector and the strip axes. This gives us a normal representation of the planes containing both.

The two planes are still only defined up to a shift along the normal. Now, we fix this degree of freedom by requiring that the u-plane (perpendicular to momentum and second strip direction) should actually contain the second strip itself. To do so, we virtually 'hold' the u-plane at its intersection plane with the first strip, starting with it touching the very bottom of the first strip, and then move the intersection point along the strip. We can thus parameterise the shift by the distance we need to walk this way

Find the maximum distance we can go until we have walked past the full length of the first strip. Equivalent to the projection of the full strip length on the u-plane normal.

if no such component, bail out - no solution exists

The distance we need to walk to contain the second strip in the u-plane is is obtained by projecting the separation vector between the strip starting points onto the normal. (remember, we virtually start our shift with the u-plane intersecting the first strip at its starting point). We normalise the shifts to the maximum allowed shift.

this is playing the same game, but for shifting the v-plane w.r.t the version that intersects with the bottom of the second strip until we contain the first strip in it. du has the same length as dv (symmetry of the problem)

check that the result is valid. We want the final fixed planes to still intersect the respective other strip within some tolerance. Keep in mind that s=0 --> intersect start of strip, s == 1 --> intersect end of strip. We apply a tolerance beyond each end

now, update the position estimate as the intersection of the updated u-plane with the first strip.

Definition at line 1308 of file SiTrackMaker_xk.cxx.

{
  const Trk::PrepRawData*  c0  = sp.clusterList().first;
  const Trk::PrepRawData*  c1  = sp.clusterList().second;
 
  const InDetDD::SiDetectorElement* de0 = static_cast<const InDet::SiCluster*>(c0)->detectorElement();
  const InDetDD::SiDetectorElement* de1 = static_cast<const InDet::SiCluster*>(c1)->detectorElement();
 
  Amg::Vector2D localPos = c0->localPosition();
  std::pair<Amg::Vector3D,Amg::Vector3D> e0
    (de0->endsOfStrip(InDetDD::SiLocalPosition(localPos.y(),localPos.x(),0.)));
 
  localPos = c1->localPosition();
  std::pair<Amg::Vector3D,Amg::Vector3D> e1
    (de1->endsOfStrip(InDetDD::SiLocalPosition(localPos.y(),localPos.x(),0.)));
 
  double a0[3] = {e0.second.x()-e0.first.x(), e0.second.y()-e0.first.y(), e0.second.z()-e0.first.z()};
  double a1[3] = {e1.second.x()-e1.first.x(), e1.second.y()-e1.first.y(), e1.second.z()-e1.first.z()};
  double dr[3] = {e1.first .x()-e0.first.x(), e1.first .y()-e0.first.y(), e1.first .z()-e0.first.z()};
 
  double d0    = m_distmax/sqrt(a0[0]*a0[0]+a0[1]*a0[1]+a0[2]*a0[2]);
 
  double u[3]  = {a1[1]*dir[2]-a1[2]*dir[1],a1[2]*dir[0]-a1[0]*dir[2],a1[0]*dir[1]-a1[1]*dir[0]};
  double v[3]  = {a0[1]*dir[2]-a0[2]*dir[1],a0[2]*dir[0]-a0[0]*dir[2],a0[0]*dir[1]-a0[1]*dir[0]};
 
 
  double du    = a0[0]*u[0]+a0[1]*u[1]+a0[2]*u[2];
 
  if (du==0. ) return false;
 
  double s0 = (dr[0]*u[0]+dr[1]*u[1]+dr[2]*u[2])/du;
  double s1 = (dr[0]*v[0]+dr[1]*v[1]+dr[2]*v[2])/du;
 
  if (s0 < -d0 || s0 > 1.+d0 ||  s1 < -d0 || s1 > 1.+d0) return false;
 
  p[0] = e0.first.x()+s0*a0[0];
  p[1] = e0.first.y()+s0*a0[1];
  p[2] = e0.first.z()+s0*a0[2];
 
  return true;
}

globalPositions()

bool InDet::SiTrackMaker_xk::globalPositions ( const Trk::SpacePoint &  s0, const Trk::SpacePoint &  s1, const Trk::SpacePoint &  s2, double *  p0, double *  p1, double *  p2  ) const

private

first, fill the arrays with the global positions of the 3 points

for PPP seeds, we are done

for SSS, we need some extra work

try to refine the position estimate for strip SP using the cluster information in combination with the direction estimate

Definition at line 1266 of file SiTrackMaker_xk.cxx.

{
 
  p0[0] = s0.globalPosition().x();
  p0[1] = s0.globalPosition().y();
  p0[2] = s0.globalPosition().z();
 
  p1[0] = s1.globalPosition().x();
  p1[1] = s1.globalPosition().y();
  p1[2] = s1.globalPosition().z();
 
  p2[0] = s2.globalPosition().x();
  p2[1] = s2.globalPosition().y();
  p2[2] = s2.globalPosition().z();
 
  if (!s0.clusterList().second && !s1.clusterList().second && !s2.clusterList().second) return true;
 
  double dir0[3],dir1[3],dir2[3];
 
  globalDirections(p0,p1,p2,dir0,dir1,dir2);
 
  if (s0.clusterList().second && !globalPosition(s0,dir0,p0)) return false;
  if (s1.clusterList().second && !globalPosition(s1,dir1,p1)) return false;
  if (s2.clusterList().second && !globalPosition(s2,dir2,p2)) return false;
 
  return true;
}

initialize()

StatusCode InDet::SiTrackMaker_xk::initialize ( )

overridevirtual

Get beam geometry

read the config string for the field mode

this one is the default

Get detector elements road maker tool

Get combinatorial track finder tool

Get trigger track following tool

Get trigger road predictor tool

Get seed to track conversion tool This is used if we want to write out the seeds for performance studies

flag for HI running

this is on by default in offline tracking

useSSSfilter is on by default in offline, m_useHClusSeed is off by default.

pt cut can never be below 20 MeV

initialize counters

Definition at line 38 of file SiTrackMaker_xk.cxx.

{
  if (not m_beamSpotKey.empty()) {
    ATH_CHECK( m_beamSpotKey.initialize() );
  }
 
  if (m_fieldmode == "NoField") m_fieldModeEnum = Trk::NoField;
  else if (m_fieldmode == "MapSolenoid") m_fieldModeEnum = Trk::FastField;    
  else m_fieldModeEnum = Trk::FullField;
 
  if ( m_roadmaker.retrieve().isFailure() ) {
    ATH_MSG_FATAL( "Failed to retrieve tool " << m_roadmaker );
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG( "Retrieved tool " << m_roadmaker );
 
  if ( m_tracksfinder.retrieve().isFailure() ) {
    ATH_MSG_FATAL( "Failed to retrieve tool " << m_tracksfinder );
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG( "Retrieved tool " << m_tracksfinder );
 
  if ( m_useTrigTrackFollowingTool) {
    if ( m_trigInDetTrackFollowingTool.retrieve().isFailure() ) {
      ATH_MSG_FATAL( "Failed to retrieve tool " << m_trigInDetTrackFollowingTool );
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG( "Retrieved tool " << m_trigInDetTrackFollowingTool );
  } else {
    m_trigInDetTrackFollowingTool.disable();
  }
 
  if ( m_useTrigInDetRoadPredictorTool) {
    if ( m_trigInDetRoadPredictorTool.retrieve().isFailure() ) {
      ATH_MSG_FATAL( "Failed to retrieve tool " << m_trigInDetRoadPredictorTool );
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG( "Retrieved tool " << m_trigInDetRoadPredictorTool );
  } else {
    m_trigInDetRoadPredictorTool.disable();
  }
 
  if (m_seedsegmentsWrite) {
    if (m_seedtrack.retrieve().isFailure()) {
      ATH_MSG_FATAL( "Failed to retrieve tool " << m_seedtrack );
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG( "Retrieved tool " << m_seedtrack );
  } else {
    m_seedtrack.disable();
  }
 
  m_heavyion = false;
 
 
  // TrackpatternRecoInfo preparation
  //
  if        (m_patternName == "SiSpacePointsSeedMaker_Cosmic"     )  {
    m_trackinfo.setPatternRecognitionInfo(Trk::TrackInfo::SiSpacePointsSeedMaker_Cosmic     );
  } else if (m_patternName == "SiSpacePointsSeedMaker_HeavyIon"   )  {
    m_trackinfo.setPatternRecognitionInfo(Trk::TrackInfo::SiSpacePointsSeedMaker_HeavyIon   );
    m_heavyion = true;
  } else if (m_patternName == "SiSpacePointsSeedMaker_LowMomentum")  {
    m_trackinfo.setPatternRecognitionInfo(Trk::TrackInfo::SiSpacePointsSeedMaker_LowMomentum);
  } else if (m_patternName == "SiSpacePointsSeedMaker_BeamGas"    )  {
    m_trackinfo.setPatternRecognitionInfo(Trk::TrackInfo::SiSpacePointsSeedMaker_BeamGas    );
  } else if (m_patternName == "SiSpacePointsSeedMaker_ForwardTracks"    )  {
    m_trackinfo.setPatternRecognitionInfo(Trk::TrackInfo::SiSpacePointsSeedMaker_ForwardTracks);
  } else if (m_patternName == "SiSpacePointsSeedMaker_LargeD0"    )  {
    m_trackinfo.setPatternRecognitionInfo(Trk::TrackInfo::SiSpacePointsSeedMaker_LargeD0    );
  } else if (m_patternName == "SiSpacePointsSeedMaker_ITkConversionTracks")  {
    m_trackinfo.setPatternRecognitionInfo(Trk::TrackInfo::SiSpacePointsSeedMaker_ITkConversionTracks);
  } else {
    m_trackinfo.setPatternRecognitionInfo(Trk::TrackInfo::SiSPSeededFinder                  );
  }
 
  ATH_CHECK(m_caloCluster.initialize(m_useBremModel && m_useCaloSeeds));
  ATH_CHECK(m_caloHad.initialize( !m_useSSSfilter && m_useHClusSeed) );
 
  if (m_pTmin < 20.) m_pTmin = 20.;
 
  if (m_etabins.size()>0) {
    if (m_ptbins.size() > (m_etabins.size()-1)) {
      ATH_MSG_ERROR( "No. of cut values bigger than eta bins");
      return StatusCode::FAILURE;
    }
 
    if (m_ptbins.size() < (m_etabins.size()-1)) {
      ATH_MSG_DEBUG( "No. of cut values smaller than eta bins. Extending size..." );
      m_ptbins.value().resize(m_etabins.size()-1, m_ptbins.value().back());
    }
 
    for (auto& pt : m_ptbins) {
      if (pt < 20.) pt = 20.;
    }
  }
 
 
  resetCounter(m_totalInputSeeds);
  resetCounter(m_totalNoTrackPar);
  resetCounter(m_totalUsedSeeds);
  resetCounter(m_outputTracks);
  resetCounter(m_totalBremSeeds);
  resetCounter(m_bremTracks);
  resetCounter(m_twoClusters);
  resetCounter(m_wrongRoad);
  resetCounter(m_wrongInit);
  resetCounter(m_noTrack);
  resetCounter(m_notNewTrack);
  resetCounter(m_bremAttempt);
  resetCounter(m_seedsWithTrack);
  resetCounter(m_deSize);
  m_usedSeedsEta.resize(SiCombinatorialTrackFinderData_xk::kNSeedTypes);
  m_seedsWithTracksEta.resize(SiCombinatorialTrackFinderData_xk::kNSeedTypes);
  std::fill(m_usedSeedsEta.begin(), m_usedSeedsEta.end(),
            std::vector<double>(SiCombinatorialTrackFinderData_xk::kNRapidityRanges, 0.));
  std::fill(m_seedsWithTracksEta.begin(), m_seedsWithTracksEta.end(),
            std::vector<double>(SiCombinatorialTrackFinderData_xk::kNRapidityRanges, 0.));
 
  ATH_CHECK( m_fieldCondObjInputKey.initialize());
  return StatusCode::SUCCESS;
}

isCaloCompatible()

bool InDet::SiTrackMaker_xk::isCaloCompatible ( SiTrackMakerEventData_xk &  data ) const

private

Definition at line 1388 of file SiTrackMaker_xk.cxx.

{
  if (!data.caloClusterROIEM()) return false;
 
 
  double F = data.par()[2]                           ;
  double E = -log(tan(.5*data.par()[3]))             ;
  double R = sqrt(data.par()[6]*data.par()[6]+data.par()[7]*data.par()[7]);
  double Z = data.par()[8]                           ;
  return data.caloClusterROIEM()->hasMatchingROI(F, E,  R, Z, m_phiWidth, m_etaWidth);
}

isHadCaloCompatible()

bool InDet::SiTrackMaker_xk::isHadCaloCompatible ( SiTrackMakerEventData_xk &  data ) const

private

Definition at line 1404 of file SiTrackMaker_xk.cxx.

{
  if (!data.caloClusterROIHad()) return false;
 
  double F = data.par()[2]                           ;
  double E = -log(tan(.5*data.par()[3]))             ;
  double R = sqrt(data.par()[6]*data.par()[6]+data.par()[7]*data.par()[7]);
  double Z = data.par()[8]                           ;
 
  return data.caloClusterROIHad()->hasMatchingROI(F, E,  R, Z, m_phiWidth, m_etaWidth);
}

isNewTrack()

bool InDet::SiTrackMaker_xk::isNewTrack ( SiTrackMakerEventData_xk &  data, Trk::Track *  Tr  )

staticprivate

Definition at line 1224 of file SiTrackMaker_xk.cxx.

{
  const Trk::PrepRawData* prd   [100];
  std::multimap<const Trk::PrepRawData*,const Trk::Track*>::const_iterator
    ti,t[100],te = data.clusterTrack().end();
 
  int n = 0;
 
  DataVector<const Trk::MeasurementBase>::const_iterator
    m  = Tr->measurementsOnTrack()->begin(),
    me = Tr->measurementsOnTrack()->end  ();
 
  for (; m!=me; ++m) {
 
    const Trk::PrepRawData* pr = static_cast<const Trk::RIO_OnTrack*>(*m)->prepRawData();
    if (pr) {
      prd[n] =pr;
      t  [n] = data.clusterTrack().find(prd[n]);
      if (t[n]==te) return true;
      ++n;
    }
  }
 
  if (!n) return true;
  int nclt = n;
 
  for (int i=0; i!=n; ++i) {
    int nclmax = 0;
    for (ti=t[i]; ti!=te; ++ti) {
      if ( (*ti).first != prd[i] ) break;
      int ncl = (*ti).second->measurementsOnTrack()->size();
      if (ncl > nclmax) nclmax = ncl;
    }
    if (nclt > nclmax) return true;
  }
  return false;
}

kindSeed()

int InDet::SiTrackMaker_xk::kindSeed ( const std::vector< const Trk::SpacePoint * > &  Sp )

staticprivate

Definition at line 1181 of file SiTrackMaker_xk.cxx.

{
 
  if(Sp.size()!=3) return 0;//correct handling of Pixel-only ITk tracklets
 
  std::vector<const Trk::SpacePoint*>::const_iterator s=Sp.begin(),se=Sp.end();
 
  int n = 0;
  for(; s!=se; ++s) {if((*s)->clusterList().second) ++n;}
  return n;
}

newEvent()

void InDet::SiTrackMaker_xk::newEvent ( const EventContext &  ctx, SiTrackMakerEventData_xk &  data, bool  PIX, bool  SCT  ) const

overridevirtual

initialize beam position

propagate pixel / strip usage to the event data object

build a holder for the configured track quality cuts

Setup New event for track finder tool

Erase cluster to track association m_seedsfilter is true in the vast majority of all applications, so this is usually done

Erase statistic information

retrieve calo seeds for brem fit

retrieve hadronic seeds for SSS seed filter

if we want to write out the seeds, also call newEvent for the seed-to-track converter

Definition at line 498 of file SiTrackMaker_xk.cxx.

{
 
  data.xybeam()[0] = 0.;
  data.xybeam()[1] = 0.;
  if (not m_beamSpotKey.empty()) {
    SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx };
    if (beamSpotHandle.isValid()) {
      data.xybeam()[0] = beamSpotHandle->beamPos()[0];
      data.xybeam()[1] = beamSpotHandle->beamPos()[1];
    }
  }
  data.pix() = PIX and m_usePix;
  data.sct() = SCT and m_useSct;
 
  InDet::TrackQualityCuts trackquality = setTrackQualityCuts(false);
 
  m_tracksfinder->newEvent(ctx, data.combinatorialData(), m_trackinfo, trackquality);
 
  if (m_seedsfilter) data.clusterTrack().clear();
 
  data.inputseeds() = 0;
  data.goodseeds()  = 0;
  data.findtracks() = 0;
  resetCounter(data.summaryStatAll());
  resetCounter(data.summaryStatUsedInTrack());
 
  if (m_useBremModel && m_useCaloSeeds) {
     SG::ReadHandle<ROIPhiRZContainer> calo_rois(m_caloCluster, ctx);
     if (!calo_rois.isValid()) {
        ATH_MSG_FATAL("Failed to get EM Calo cluster collection " << m_caloCluster );
     }
     data.setCaloClusterROIEM(*calo_rois);
  }
 
  if (!m_useSSSfilter && m_useHClusSeed) {
       SG::ReadHandle<ROIPhiRZContainer> calo_rois(m_caloHad, ctx);
       if (!calo_rois.isValid()) {
          ATH_MSG_FATAL("Failed to get Had Calo cluster collection " << m_caloHad );
       }
       data.setCaloClusterROIHad(*calo_rois);
  }
  if (m_seedsegmentsWrite) m_seedtrack->newEvent(data.conversionData(), m_trackinfo, m_patternName);
}

newSeed()

bool InDet::SiTrackMaker_xk::newSeed ( SiTrackMakerEventData_xk &  data, const std::vector< const Trk::SpacePoint * > &  Sp  ) const

private

counter for clusters on track

start by checking the first cluster - always needed

lookup if the cluster is already used by another track

add tracks consuming our seed space-points to the trackseed list.

increment cluster counter

now, prepare to check also the second cluster on any strip seed

if we don't have one, nothing to do

otherwise, same game as before. Note that a track consuming both clusters on a strip hit is counted twice into the map

incremenent counter again

check if at least on cluster is not already used by any track. This works since the multiset allows adding the same track multiple times If this is the case, we accept the seed.

in the case of HI reco, we accept any 3-cluster (PPP) seed.

Now we look for the track consuming the largest number of clusters

This is done by looping over all tracks using any of our clusters, and counting the appearance of each track in the multiset. If one single track contains all of the clusters (--> is included n times), we reject this seed.

loop over the list of tracks

if this is a new track, reset the counter

otherwise increment the counter. If this track has all clusters from the seed on it, reject the event

If we have no single track 'eating' all of our clusters, we accept the seed

Definition at line 1112 of file SiTrackMaker_xk.cxx.

{
  std::multiset<const Trk::Track*> trackseed;
  std::multimap<const Trk::PrepRawData*,const Trk::Track*>::const_iterator iter_clusterOnTrack,iter_clusterOnTrackEnd = data.clusterTrack().end();
 
  size_t n = 0;
 
  for (const Trk::SpacePoint* spacePoint : Sp) {
 
    const Trk::PrepRawData* prd = spacePoint->clusterList().first;
 
    for (iter_clusterOnTrack = data.clusterTrack().find(prd); iter_clusterOnTrack!=iter_clusterOnTrackEnd; ++iter_clusterOnTrack) {
      if ((*iter_clusterOnTrack).first!=prd) break;
        trackseed.insert((*iter_clusterOnTrack).second);
    }
    ++n;
    prd = spacePoint->clusterList().second;
    if (!prd) continue;
    for (iter_clusterOnTrack = data.clusterTrack().find(prd); iter_clusterOnTrack!=iter_clusterOnTrackEnd; ++iter_clusterOnTrack) {
      if ((*iter_clusterOnTrack).first!=prd) break;
      trackseed.insert((*iter_clusterOnTrack).second);
    }
    ++n;
  }
  if(trackseed.size() < n) return true;
  if( m_heavyion && n==3 ) return true;
 
 
  const Trk::Track* currentTrack {nullptr};
  size_t clustersOnCurrent  = 1;
   for(const Trk::Track* track : trackseed) {
    if(track != currentTrack) {
      currentTrack = track;
      clustersOnCurrent =    1;
      continue ;
    }
    if(++clustersOnCurrent == n) return false;
  }
  return clustersOnCurrent!=n;
}

newTrigEvent()

void InDet::SiTrackMaker_xk::newTrigEvent ( const EventContext &  ctx, SiTrackMakerEventData_xk &  data, bool  PIX, bool  SCT  ) const

overridevirtual

Definition at line 559 of file SiTrackMaker_xk.cxx.

{
  data.pix()        = PIX && m_usePix;
  data.sct()        = SCT && m_useSct;
  bool simpleTrack  = true;
 
  InDet::TrackQualityCuts trackquality = setTrackQualityCuts(simpleTrack);
 
  // New event for track finder tool
  //
  m_tracksfinder->newEvent(ctx, data.combinatorialData(), m_trackinfo, trackquality);
 
  // Erase cluster to track association
  //
  if (m_seedsfilter) data.clusterTrack().clear();
 
  // Erase statistic information
  //
  data.inputseeds() = 0;
  data.goodseeds()  = 0;
  data.findtracks() = 0;
  for (int i = 0; i != SiCombinatorialTrackFinderData_xk::kNStatAllTypes; ++i) {
    for (int k = 0; k != SiCombinatorialTrackFinderData_xk::kNSeedTypes; ++k){
      data.summaryStatAll()[i][k] = 0.;
    }
  }
  for (int i = 0; i != SiCombinatorialTrackFinderData_xk::kNStatEtaTypes; ++i) {
    for (int k = 0; k != SiCombinatorialTrackFinderData_xk::kNSeedTypes; ++k) {
      for (int r = 0; r != SiCombinatorialTrackFinderData_xk::kNRapidityRanges;++r){
        data.summaryStatUsedInTrack()[i][k][r] = 0.;
      }
    }
  }
 
  // Add possibility to write seed segment information
  if (m_seedsegmentsWrite) m_seedtrack->newEvent(data.conversionData(), m_trackinfo, m_patternName);
 
}

operator=()

SiTrackMaker_xk& InDet::SiTrackMaker_xk::operator= ( const SiTrackMaker_xk &  )

privatedelete

pTmin()

double InDet::SiTrackMaker_xk::pTmin ( double  eta ) const

private

Definition at line 1496 of file SiTrackMaker_xk.cxx.

{
  if (m_ptbins.size() == 0) return m_pTmin;
  double aeta = std::abs(eta);
  for(int n = int(m_ptbins.size()-1); n>=0; --n) {
    if(aeta > m_etabins[n]) return m_ptbins[n];
  }
  return m_pTmin;
}

rapidity()

int InDet::SiTrackMaker_xk::rapidity ( const std::vector< const Trk::SpacePoint * > &  Sp )

staticprivate

Definition at line 1193 of file SiTrackMaker_xk.cxx.

{
  if(Sp.size() < 2) return 0;
 
  Amg::Vector3D delta_sp = Sp[0]->globalPosition() - Sp[1]->globalPosition();
  float eta = 2*std::abs(delta_sp.eta());
  int n = int(eta);
  if(n > 7) n = 7;
  return n;
}

resetCounter() [1/2]

template<typename T , size_t N, size_t M>

void InDet::SiTrackMaker_xk::resetCounter ( std::array< std::array< T, M >, N > &  a ) const

inlineprivate

helper for working with the stat arrays

Definition at line 265 of file SiTrackMaker_xk.h.

                                                                                                     {
        for (auto & subarr : a) resetCounter(subarr);
      }

resetCounter() [2/2]

template<typename T , size_t N>

void InDet::SiTrackMaker_xk::resetCounter ( std::array< T, N > &  a ) const

inlineprivate

Definition at line 268 of file SiTrackMaker_xk.h.

                                                                                {
        std::fill(a.begin(),a.end(),0);
      }

setTrackQualityCuts()

InDet::TrackQualityCuts InDet::SiTrackMaker_xk::setTrackQualityCuts ( bool  simpleTrack ) const

private

Definition at line 1050 of file SiTrackMaker_xk.cxx.

{
  InDet::TrackQualityCuts trackquality;
  // Integer cuts
  //
  trackquality.setIntCut("MinNumberOfClusters" ,m_nclusmin   );
  trackquality.setIntCut("MinNumberOfWClusters",m_nwclusmin  );
  trackquality.setIntCut("MaxNumberOfHoles"    ,m_nholesmax  );
  trackquality.setIntCut("MaxHolesGap"         ,m_dholesmax  );
 
  if (m_useassoTool)                  trackquality.setIntCut("UseAssociationTool",1);
  else                                trackquality.setIntCut("UseAssociationTool",0);
  if (m_cosmicTrack)                  trackquality.setIntCut("CosmicTrack"       ,1);
  else                                trackquality.setIntCut("CosmicTrack"       ,0);
  if (simpleTrack)                    trackquality.setIntCut("SimpleTrack"       ,1);
  else                                trackquality.setIntCut("SimpleTrack"       ,0);
  if (m_multitracks)                  trackquality.setIntCut("doMultiTracksProd" ,1);
  else                                trackquality.setIntCut("doMultiTracksProd" ,0);
 
  // Double cuts
  //
  trackquality.setDoubleCut("pTmin"              ,m_pTmin      );
  trackquality.setDoubleCut("pTminBrem"          ,m_pTminBrem  );
  trackquality.setDoubleCut("MaxXi2forCluster"   ,m_xi2max     );
  trackquality.setDoubleCut("MaxXi2forOutlier"   ,m_xi2maxNoAdd);
  trackquality.setDoubleCut("MaxXi2forSearch"    ,m_xi2maxlink );
  trackquality.setDoubleCut("MaxXi2MultiTracks"  ,m_xi2multitracks);
 
  return trackquality;
}

Member Data Documentation

ATLAS_THREAD_SAFE [1/17]

std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes> m_totalInputSeeds InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 186 of file SiTrackMaker_xk.h.

ATLAS_THREAD_SAFE [2/17]

std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes> m_totalUsedSeeds InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 187 of file SiTrackMaker_xk.h.

ATLAS_THREAD_SAFE [3/17]

std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes> m_totalNoTrackPar InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 188 of file SiTrackMaker_xk.h.

ATLAS_THREAD_SAFE [4/17]

std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes> m_totalBremSeeds InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 189 of file SiTrackMaker_xk.h.

ATLAS_THREAD_SAFE [5/17]

std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes> m_twoClusters InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 190 of file SiTrackMaker_xk.h.

ATLAS_THREAD_SAFE [6/17]

std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes> m_wrongRoad InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 191 of file SiTrackMaker_xk.h.

ATLAS_THREAD_SAFE [7/17]

std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes> m_wrongInit InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 192 of file SiTrackMaker_xk.h.

ATLAS_THREAD_SAFE [8/17]

std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes> m_noTrack InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 193 of file SiTrackMaker_xk.h.

ATLAS_THREAD_SAFE [9/17]

std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes> m_notNewTrack InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 194 of file SiTrackMaker_xk.h.

ATLAS_THREAD_SAFE [10/17]

std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes> m_bremAttempt InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 195 of file SiTrackMaker_xk.h.

ATLAS_THREAD_SAFE [11/17]

std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes> m_outputTracks InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 196 of file SiTrackMaker_xk.h.

ATLAS_THREAD_SAFE [12/17]

std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes> m_extraTracks InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 197 of file SiTrackMaker_xk.h.

ATLAS_THREAD_SAFE [13/17]

std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes> m_bremTracks InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 198 of file SiTrackMaker_xk.h.

ATLAS_THREAD_SAFE [14/17]

std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes> m_seedsWithTrack InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 199 of file SiTrackMaker_xk.h.

ATLAS_THREAD_SAFE [15/17]

std::array<std::atomic<double>,SiCombinatorialTrackFinderData_xk::kNSeedTypes> m_deSize InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 200 of file SiTrackMaker_xk.h.

ATLAS_THREAD_SAFE [16/17]

std::vector<std::vector<double> > m_usedSeedsEta InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 202 of file SiTrackMaker_xk.h.

ATLAS_THREAD_SAFE [17/17]

std::vector<std::vector<double> > m_seedsWithTracksEta InDet::SiTrackMaker_xk::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 203 of file SiTrackMaker_xk.h.

m_beamSpotKey

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

private

Definition at line 131 of file SiTrackMaker_xk.h.

m_caloCluster

SG::ReadHandleKey<ROIPhiRZContainer> InDet::SiTrackMaker_xk::m_caloCluster {this, "EMROIPhiRZContainer", ""}

private

Definition at line 133 of file SiTrackMaker_xk.h.

m_caloHad

SG::ReadHandleKey<ROIPhiRZContainer> InDet::SiTrackMaker_xk::m_caloHad {this, "HadROIPhiRZContainer", ""}

private

Definition at line 134 of file SiTrackMaker_xk.h.

m_cosmicTrack

BooleanProperty InDet::SiTrackMaker_xk::m_cosmicTrack {this, "CosmicTrack", false, "Is it cosmic track"}

private

Definition at line 145 of file SiTrackMaker_xk.h.

m_counterMutex

std::mutex InDet::SiTrackMaker_xk::m_counterMutex

mutableprivate

Definition at line 185 of file SiTrackMaker_xk.h.

m_dholesmax

IntegerProperty InDet::SiTrackMaker_xk::m_dholesmax {this, "nHolesGapMax", 2, "Max holes gap"}

private

Definition at line 164 of file SiTrackMaker_xk.h.

m_distmax

DoubleProperty InDet::SiTrackMaker_xk::m_distmax {this, "MaxDistanceForSCTsp", 5.}

private

Definition at line 161 of file SiTrackMaker_xk.h.

m_etabins

DoubleArrayProperty InDet::SiTrackMaker_xk::m_etabins {this, "etaBins", {}, "eta bins"}

private

Definition at line 170 of file SiTrackMaker_xk.h.

m_etaWidth

DoubleProperty InDet::SiTrackMaker_xk::m_etaWidth {this, "etaWidth", 0.3}

private

Definition at line 169 of file SiTrackMaker_xk.h.

m_fieldCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> InDet::SiTrackMaker_xk::m_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"}

private

Definition at line 132 of file SiTrackMaker_xk.h.

m_fieldmode

StringProperty InDet::SiTrackMaker_xk::m_fieldmode {this, "MagneticFieldMode", "MapSolenoid", "Mode of magnetic field"}

private

Definition at line 140 of file SiTrackMaker_xk.h.

m_fieldModeEnum

Trk::MagneticFieldMode InDet::SiTrackMaker_xk::m_fieldModeEnum {Trk::FullField}

private

Definition at line 178 of file SiTrackMaker_xk.h.

m_heavyion

bool InDet::SiTrackMaker_xk::m_heavyion {false}

private

Definition at line 177 of file SiTrackMaker_xk.h.

m_indexToEnum

std::vector<statAllTypes> InDet::SiTrackMaker_xk::m_indexToEnum {kTwoClusters,kWrongInit,kWrongRoad,kNoTrack,kNotNewTrack,kBremAttempt}

private

Definition at line 228 of file SiTrackMaker_xk.h.

m_ITKGeometry

BooleanProperty InDet::SiTrackMaker_xk::m_ITKGeometry {this, "ITKGeometry", false, "ITK geometry"}

private

Definition at line 151 of file SiTrackMaker_xk.h.

m_LRTmode

BooleanProperty InDet::SiTrackMaker_xk::m_LRTmode {this, "LRTMode", false}

private

Definition at line 155 of file SiTrackMaker_xk.h.

m_multitracks

BooleanProperty InDet::SiTrackMaker_xk::m_multitracks {this, "doMultiTracksProd", false}

private

Definition at line 146 of file SiTrackMaker_xk.h.

m_nclusmin

IntegerProperty InDet::SiTrackMaker_xk::m_nclusmin {this, "nClustersMin", 6, "Min number clusters"}

private

Definition at line 165 of file SiTrackMaker_xk.h.

m_nholesmax

IntegerProperty InDet::SiTrackMaker_xk::m_nholesmax {this, "nHolesMax", 2, "Max number holes"}

private

Definition at line 163 of file SiTrackMaker_xk.h.

m_nwclusmin

IntegerProperty InDet::SiTrackMaker_xk::m_nwclusmin {this, "nWeightedClustersMin", 6, "Min umber weighted clusters(pix=2 sct=1)"}

private

Definition at line 166 of file SiTrackMaker_xk.h.

m_patternName

StringProperty InDet::SiTrackMaker_xk::m_patternName {this, "TrackPatternRecoInfo", "SiSPSeededFinder", "Name of the pattern recognition"}

private

Definition at line 141 of file SiTrackMaker_xk.h.

m_phiWidth

DoubleProperty InDet::SiTrackMaker_xk::m_phiWidth {this, "phiWidth", 0.3}

private

Definition at line 168 of file SiTrackMaker_xk.h.

m_ptbins

DoubleArrayProperty InDet::SiTrackMaker_xk::m_ptbins {this, "pTBins", {}, "pT bins"}

private

Definition at line 171 of file SiTrackMaker_xk.h.

m_pTmin

DoubleProperty InDet::SiTrackMaker_xk::m_pTmin {this, "pTmin", 500., "min pT"}

private

Definition at line 159 of file SiTrackMaker_xk.h.

m_pTminBrem

DoubleProperty InDet::SiTrackMaker_xk::m_pTminBrem {this, "pTminBrem", 1000., "min pT for Brem mode"}

private

Definition at line 160 of file SiTrackMaker_xk.h.

m_roadmaker

ToolHandle<InDet::ISiDetElementsRoadMaker> InDet::SiTrackMaker_xk::m_roadmaker {this, "RoadTool", "InDet::SiDetElementsRoadMaker_xk"}

private

Definition at line 122 of file SiTrackMaker_xk.h.

m_seedsegmentsWrite

BooleanProperty InDet::SiTrackMaker_xk::m_seedsegmentsWrite {this, "SeedSegmentsWrite", false, "Call seed to track conversion"}

private

Definition at line 152 of file SiTrackMaker_xk.h.

m_seedsfilter

BooleanProperty InDet::SiTrackMaker_xk::m_seedsfilter {this, "UseSeedFilter", true, "Use seed filter"}

private

Definition at line 139 of file SiTrackMaker_xk.h.

m_seedtrack

ToolHandle<InDet::ISeedToTrackConversionTool> InDet::SiTrackMaker_xk::m_seedtrack {this, "SeedToTrackConversion", "InDet::SeedToTrackConversionTool"}

private

Definition at line 126 of file SiTrackMaker_xk.h.

m_trackinfo

Trk::TrackInfo InDet::SiTrackMaker_xk::m_trackinfo

private

Definition at line 176 of file SiTrackMaker_xk.h.

m_trackletPoints

IntegerProperty InDet::SiTrackMaker_xk::m_trackletPoints {this, "trackletPoints", 1, "Select which tracklet points to use"}

private

Definition at line 167 of file SiTrackMaker_xk.h.

m_tracksfinder

ToolHandle<InDet::ISiCombinatorialTrackFinder> InDet::SiTrackMaker_xk::m_tracksfinder {this, "CombinatorialTrackFinder", "InDet::SiCombinatorialTrackFinder_xk"}

private

Definition at line 123 of file SiTrackMaker_xk.h.

m_trigInDetRoadPredictorTool

ToolHandle<ITrigInDetRoadPredictorTool> InDet::SiTrackMaker_xk::m_trigInDetRoadPredictorTool {this, "TrigInDetRoadPredictorTool", "TrigInDetRoadPredictorTool_FTF"}

private

Definition at line 125 of file SiTrackMaker_xk.h.

m_trigInDetTrackFollowingTool

ToolHandle<ITrigInDetTrackFollowingTool> InDet::SiTrackMaker_xk::m_trigInDetTrackFollowingTool {this, "TrigTrackFollowingTool", "TrigInDetTrackFollowingTool"}

private

Definition at line 124 of file SiTrackMaker_xk.h.

m_useassoTool

BooleanProperty InDet::SiTrackMaker_xk::m_useassoTool {this, "UseAssociationTool", false, "Use prd-track association tool"}

private

Definition at line 144 of file SiTrackMaker_xk.h.

m_useBremModel

BooleanProperty InDet::SiTrackMaker_xk::m_useBremModel {this, "useBremModel", false}

private

Definition at line 147 of file SiTrackMaker_xk.h.

m_useCaloSeeds

BooleanProperty InDet::SiTrackMaker_xk::m_useCaloSeeds {this, "doCaloSeededBrem", false}

private

Definition at line 148 of file SiTrackMaker_xk.h.

m_useHClusSeed

BooleanProperty InDet::SiTrackMaker_xk::m_useHClusSeed {this, "doHadCaloSeedSSS", false, "Hadronic Calorimeter Seeds"}

private

Definition at line 150 of file SiTrackMaker_xk.h.

m_usePix

BooleanProperty InDet::SiTrackMaker_xk::m_usePix {this, "usePixel", true, "flags to set whether to use pixel/sct cluster, irrespective of what is in event"}

private

Definition at line 142 of file SiTrackMaker_xk.h.

m_useSct

BooleanProperty InDet::SiTrackMaker_xk::m_useSct {this, "useSCT", true}

private

Definition at line 143 of file SiTrackMaker_xk.h.

m_useSSSfilter

BooleanProperty InDet::SiTrackMaker_xk::m_useSSSfilter {this, "useSSSseedsFilter", true}

private

Definition at line 149 of file SiTrackMaker_xk.h.

m_useTrigInDetRoadPredictorTool

BooleanProperty InDet::SiTrackMaker_xk::m_useTrigInDetRoadPredictorTool {this, "useTrigInDetRoadPredictorTool", false, "Option to use TrigInDetRoadPredictorTool instead of ISiDetElementsRoadMaker"}

private

Definition at line 154 of file SiTrackMaker_xk.h.

m_useTrigTrackFollowingTool

BooleanProperty InDet::SiTrackMaker_xk::m_useTrigTrackFollowingTool {this, "useTrigTrackFollowingTool", false, "Option to use TrigInDetTrackFollowingTool instead of SiCombinatorialTrackFinder_xk"}

private

Definition at line 153 of file SiTrackMaker_xk.h.

m_xi2max

DoubleProperty InDet::SiTrackMaker_xk::m_xi2max {this, "Xi2max", 15., "max Xi2 for updators"}

private

Definition at line 156 of file SiTrackMaker_xk.h.

m_xi2maxlink

DoubleProperty InDet::SiTrackMaker_xk::m_xi2maxlink {this, "Xi2maxlink", 200., "max Xi2 for clusters"}

private

Definition at line 158 of file SiTrackMaker_xk.h.

m_xi2maxNoAdd

DoubleProperty InDet::SiTrackMaker_xk::m_xi2maxNoAdd {this, "Xi2maxNoAdd", 35., "max Xi2 for clusters"}

private

Definition at line 157 of file SiTrackMaker_xk.h.

m_xi2multitracks

DoubleProperty InDet::SiTrackMaker_xk::m_xi2multitracks {this, "Xi2maxMultiTracks", 3., "max Xi2 for multi tracks"}

private

Definition at line 162 of file SiTrackMaker_xk.h.

---

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

• SiTrackMaker_xk.h
• SiTrackMaker_xk.cxx