ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
InDet::InDetTrackHoleSearchTool Class Reference

#include <InDetTrackHoleSearchTool.h>

Inheritance diagram for InDet::InDetTrackHoleSearchTool:
Collaboration diagram for InDet::InDetTrackHoleSearchTool:

Public Member Functions

 InDetTrackHoleSearchTool (const std::string &, const std::string &, const IInterface *)
 
virtual ~InDetTrackHoleSearchTool ()
 default destructor More...
 
virtual StatusCode initialize ()
 standard Athena-Algorithm method More...
 
virtual StatusCode finalize ()
 standard Athena-Algorithm method More...
 
virtual void countHoles (const Trk::Track &track, std::vector< int > &information, const Trk::ParticleHypothesis partHyp=Trk::pion) const
 Input : track, partHyp Output: Changes in information This method first calls the method getMapOfHits to isolate the relevant hits on the track before calling the method performHoleSearchStepWise which then performs the actual hole search. More...
 
virtual const Trk::TrackStates * getHolesOnTrack (const Trk::Track &track, const Trk::ParticleHypothesis partHyp=Trk::pion) const
 Input : track, parthyp Return: A DataVector containing pointers to TrackStateOnSurfaces which each represent an identified hole on the track. More...
 
virtual const Trk::Track * getTrackWithHoles (const Trk::Track &track, const Trk::ParticleHypothesis partHyp=Trk::pion) const
 Input : track, parthyp Return: A pointer to a new Trk::Track which containes the information of the input track plus the tsos of the identified holes The parthyp argument is relevant for the extrapolation steps in the hole search. More...
 
virtual const Trk::Track * getTrackWithHolesAndOutliers (const Trk::Track &track, const Trk::ParticleHypothesis partHyp=Trk::pion) const
 Input : track, parthyp Return: A pointer to a new Trk::Track which containes the information of the input track plus the tsos of the identified holes or outliers The parthyp argument is relevant for the extrapolation steps in the hole search. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

void searchForHoles (const Trk::Track &track, std::vector< int > *information, std::vector< const Trk::TrackStateOnSurface * > *listOfHoles, const Trk::ParticleHypothesis partHyp=Trk::pion) const
 Input : track, parthyp Return: Changes in information and/or listOfHoles The interfacing method to the step wise hole search. More...
 
bool getMapOfHits (const EventContext &ctx, const Trk::Track &track, const Trk::ParticleHypothesis partHyp, std::map< const Identifier, const Trk::TrackStateOnSurface * > &mapOfHits, std::map< const Identifier, std::pair< const Trk::TrackParameters *, const bool >> &mapOfPredictions) const
 Input: track Output: changes in mapOfHits (filling it) and hasTRT Return value: True if filling was successful, false otherwise This method distills the relevant hits out of a given track. More...
 
void performHoleSearchStepWise (std::map< const Identifier, const Trk::TrackStateOnSurface * > &mapOfHits, std::map< const Identifier, std::pair< const Trk::TrackParameters *, const bool > > &mapOfPredictions, std::vector< int > *information, std::vector< const Trk::TrackStateOnSurface * > *listOfHoles) const
 This method searches for holes in a track. More...
 
const Trk::Track * addHolesToTrack (const Trk::Track &oldTrack, std::vector< const Trk::TrackStateOnSurface * > *listOfHoles) const
 This Method creates a new Track from the TSOS of the input track combined with the TSOS from listOfHoles. More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Static Private Member Functions

static const Trk::TrackStateOnSurface * createHoleTSOS (const Trk::TrackParameters *trackPar)
 This method creates a TSOS to represent a detected hole. More...
 

Private Attributes

const AtlasDetectorID * m_atlasId
 ID pixel helper. More...
 
ToolHandle< Trk::IExtrapolator > m_extrapolator
 Pointer to Extrapolator AlgTool. More...
 
ToolHandle< Trk::IBoundaryCheckTool > m_boundaryCheckTool
 
bool m_extendedListOfHoles
 Configure outwards hole search. More...
 
bool m_cosmic
 
int m_minSiHits
 Min number of hits. More...
 
bool m_countDeadModulesAfterLastHit
 
std::atomic_int m_warning
 number of warnings printed when no track parameters available More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

This is for the Doxygen-Documentation.
Please delete these lines and fill in information about the Algorithm! Please precede every member function declaration with a short Doxygen comment stating the purpose of this function.

Author
Markus Elsing

Definition at line 48 of file InDetTrackHoleSearchTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ InDetTrackHoleSearchTool()

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

Definition at line 32 of file InDetTrackHoleSearchTool.cxx.

34  :
35  AthAlgTool(t,n,p),
36  m_atlasId(nullptr),
37  m_extendedListOfHoles(false),
38  m_cosmic(false),
39  m_warning(0) {
40  declareInterface<ITrackHoleSearchTool>(this);
41  declareProperty("ExtendedListOfHoles" , m_extendedListOfHoles = false);
42  declareProperty("Cosmics" , m_cosmic);
43  declareProperty("minSiHits" , m_minSiHits = 3);
44  declareProperty("CountDeadModulesAfterLastHit", m_countDeadModulesAfterLastHit = true);
45 }

◆ ~InDetTrackHoleSearchTool()

InDet::InDetTrackHoleSearchTool::~InDetTrackHoleSearchTool ( )
virtualdefault

default destructor

Member Function Documentation

◆ addHolesToTrack()

const Trk::Track * InDet::InDetTrackHoleSearchTool::addHolesToTrack ( const Trk::Track &  oldTrack,
std::vector< const Trk::TrackStateOnSurface * > *  listOfHoles 
) const
private

This Method creates a new Track from the TSOS of the input track combined with the TSOS from listOfHoles.

Definition at line 710 of file InDetTrackHoleSearchTool.cxx.

711  {
712  auto trackTSOS = std::make_unique<Trk::TrackStates>();
713 
714  // get states from track
715  for (const auto *it : *oldTrack.trackStateOnSurfaces()) {
716  // veto old holes
717  if (!it->type(Trk::TrackStateOnSurface::Hole)) trackTSOS->push_back(new Trk::TrackStateOnSurface(*it));
718  }
719 
720  // if we have no holes on the old track and no holes found by search, then we just copy the track
721  if (oldTrack.trackStateOnSurfaces()->size() == trackTSOS->size() && listOfHoles->empty()) {
722  ATH_MSG_DEBUG("No holes on track, copy input track to new track");
723  // create copy of track
724  const Trk::Track* newTrack = new Trk::Track(
725  oldTrack.info(),
726  std::move(trackTSOS),
727  oldTrack.fitQuality() ? oldTrack.fitQuality()->uniqueClone() : nullptr);
728  return newTrack;
729  }
730 
731  // add new holes
732  for (const auto *listOfHole : *listOfHoles) {
733  trackTSOS->push_back(listOfHole);
734  }
735 
736  // sort
737  const Trk::TrackParameters* perigee = oldTrack.perigeeParameters();
738  if (!perigee) perigee = (*(oldTrack.trackStateOnSurfaces()->begin()))->trackParameters();
739 
740  if (perigee) {
741 
742  Trk::TrackStateOnSurfaceComparisonFunction CompFunc(perigee->momentum());
743 
744  // we always have to sort holes in
745  // if (!is_sorted(trackTSOS->begin(),trackTSOS->end(), CompFunc)) {
746 
747  if (fabs(perigee->parameters()[Trk::qOverP]) > 0.002) {
748  /* invest n*(logN)**2 sorting time for lowPt, coping with a possibly
749  not 100% transitive comparison functor.
750  */
751  ATH_MSG_DEBUG("sorting vector with stable_sort ");
752  std::stable_sort(trackTSOS->begin(), trackTSOS->end(), CompFunc);
753  } else {
754  trackTSOS->sort(CompFunc); // respects DV object ownership
755  }
756 
757  }
758 
759  // create copy of track
760  const Trk::Track* newTrack = new Trk::Track(
761  oldTrack.info(),
762  std::move(trackTSOS),
763  oldTrack.fitQuality() ? oldTrack.fitQuality()->uniqueClone() : nullptr);
764 
765  return newTrack;
766 }

◆ countHoles()

void InDet::InDetTrackHoleSearchTool::countHoles ( const Trk::Track &  track,
std::vector< int > &  information,
const Trk::ParticleHypothesis  partHyp = Trk::pion 
) const
virtual

Input : track, partHyp Output: Changes in information This method first calls the method getMapOfHits to isolate the relevant hits on the track before calling the method performHoleSearchStepWise which then performs the actual hole search.

Additionally the Layers of the Pixel Detector which contribute measurements to the track are counted
If problems occur, the information counters for Holes and PixelLayers are reset to -1 flagging them as not set.

Implements Trk::ITrackHoleSearchTool.

Definition at line 72 of file InDetTrackHoleSearchTool.cxx.

74  {
75  std::vector<const Trk::TrackStateOnSurface*>* listOfHoles = nullptr;
76  searchForHoles(track,&information,listOfHoles,partHyp);
77  if (listOfHoles) {
78  ATH_MSG_ERROR("listOfHoles is leaking in countHoles !!!");
79  for (const auto *listOfHole : *listOfHoles) {
80  delete listOfHole;
81  }
82  delete listOfHoles;
83  listOfHoles = nullptr;
84  }
85  }

◆ createHoleTSOS()

const Trk::TrackStateOnSurface * InDet::InDetTrackHoleSearchTool::createHoleTSOS ( const Trk::TrackParameters *  trackPar)
staticprivate

This method creates a TSOS to represent a detected hole.

I creates a new TP from the input and returns a (pointer to a) new TSOS containing the TP and the typeset 'Hole'

Definition at line 702 of file InDetTrackHoleSearchTool.cxx.

702  {
703  std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern;
704  typePattern.set(Trk::TrackStateOnSurface::Hole);
705  const Trk::TrackStateOnSurface* tsos = new Trk::TrackStateOnSurface(nullptr,trackPar->uniqueClone(),nullptr,typePattern);
706  return tsos;
707 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

◆ finalize()

StatusCode InDet::InDetTrackHoleSearchTool::finalize ( )
virtual

standard Athena-Algorithm method

Definition at line 66 of file InDetTrackHoleSearchTool.cxx.

66  {
67  StatusCode sc = AlgTool::finalize();
68  return sc;
69 }

◆ getHolesOnTrack()

const Trk::TrackStates * InDet::InDetTrackHoleSearchTool::getHolesOnTrack ( const Trk::Track &  track,
const Trk::ParticleHypothesis  partHyp = Trk::pion 
) const
virtual

Input : track, parthyp Return: A DataVector containing pointers to TrackStateOnSurfaces which each represent an identified hole on the track.

The parthyp argument is relevant for the extrapolation steps in the hole search. Attention: This is a factory, ownership of the return vector is passed to the calling method.

Implements Trk::ITrackHoleSearchTool.

Definition at line 88 of file InDetTrackHoleSearchTool.cxx.

89  {
90  std::vector<const Trk::TrackStateOnSurface*>* listOfHoles = new std::vector<const Trk::TrackStateOnSurface*>;
91  searchForHoles(track, nullptr, listOfHoles,partHyp);
92 
93  Trk::TrackStates* output = new Trk::TrackStates;
94  for (const auto *listOfHole : *listOfHoles)
95  output->push_back(listOfHole);
96 
97  delete listOfHoles;
98  listOfHoles = nullptr;
99  return output;
100 }

◆ getMapOfHits()

bool InDet::InDetTrackHoleSearchTool::getMapOfHits ( const EventContext &  ctx,
const Trk::Track &  track,
const Trk::ParticleHypothesis  partHyp,
std::map< const Identifier, const Trk::TrackStateOnSurface * > &  mapOfHits,
std::map< const Identifier, std::pair< const Trk::TrackParameters *, const bool >> &  mapOfPredictions 
) const
private

Input: track Output: changes in mapOfHits (filling it) and hasTRT Return value: True if filling was successful, false otherwise This method distills the relevant hits out of a given track.

Definition at line 171 of file InDetTrackHoleSearchTool.cxx.

175  {
176 
177  /* find all Si TSOS
178  - all of the above have to have identifiers
179  - keep outliers and holes
180  - mark tracks with TRT
181  - sort into map by identifier
182  */
183  //std::cout << "track: " << track << std::endl;
184  int imeas = 0;
185  const Trk::TrackParameters* firstsipar = nullptr;
186 
187  for (const auto *iterTSOS : *track.trackStateOnSurfaces()) {
188  // type of state is measurement, hole or outlier ?
189  if (iterTSOS->type(Trk::TrackStateOnSurface::Measurement) ||
190  iterTSOS->type(Trk::TrackStateOnSurface::Outlier)) {
191  Identifier id ;
192  bool hasID = false;
193  if (iterTSOS->measurementOnTrack() != nullptr
194  && iterTSOS->measurementOnTrack()->associatedSurface().associatedDetectorElement() != nullptr
195  && iterTSOS->measurementOnTrack()->associatedSurface().associatedDetectorElement()->identify() != 0) {
196  id = iterTSOS->measurementOnTrack()->associatedSurface().associatedDetectorElement()->identify();
197  hasID = true;
198  } else if (iterTSOS->trackParameters() != nullptr
199  && iterTSOS->trackParameters()->associatedSurface().associatedDetectorElement() != nullptr
200  && iterTSOS->trackParameters()->associatedSurface().associatedDetectorElement()->identify() != 0) {
201  id = iterTSOS->trackParameters()->associatedSurface().associatedDetectorElement()->identify();
202  hasID = true;
203  }
204  // copy all Si track states, including the holes and outliers
205  if (hasID && (m_atlasId->is_pixel(id) || m_atlasId->is_sct(id))) {
206  // sort the state according to the id
207  mapOfHits.insert(std::pair<const Identifier, const Trk::TrackStateOnSurface*>(id,iterTSOS));
208  if (!iterTSOS->type(Trk::TrackStateOnSurface::Outlier)) {
209  ++imeas;
210  if (!iterTSOS->trackParameters() && m_warning<10) {
211  m_warning++;
212  ATH_MSG_WARNING("No track parameters available for state of type measurement");
213  ATH_MSG_WARNING("Don't run this tool on slimmed tracks!");
214  if (m_warning==10) ATH_MSG_WARNING("(last message!)");
215  }
216  }
217  // for cosmics: remember parameters of first SI TSOS
218  if (m_cosmic && !firstsipar && iterTSOS->trackParameters()) firstsipar=iterTSOS->trackParameters();
219  if (iterTSOS->trackParameters()) {
220  ATH_MSG_VERBOSE("TSOS pos: " << iterTSOS->trackParameters()->position()
221  << " r: " << sqrt(pow(iterTSOS->trackParameters()->position().x(),2)
222  +pow(iterTSOS->trackParameters()->position().y(),2))
223  << " Si measurement");
224  }
225  } else {
226  if (iterTSOS->trackParameters()) {
227  ATH_MSG_VERBOSE("TSOS pos: " << iterTSOS->trackParameters()->position()
228  << " r: " << sqrt(pow(iterTSOS->trackParameters()->position().x(),2)
229  +pow(iterTSOS->trackParameters()->position().y(),2))
230  << " TRT measurement");
231  }
232  }
233  }
234  }
235 
236  ATH_MSG_DEBUG("Number of Si hits + outliers on original track: " << mapOfHits.size() << " , hits only: " << imeas);
237  if ((imeas<m_minSiHits && ! m_extendedListOfHoles) || imeas==0 || (!firstsipar && m_cosmic)) {
238  ATH_MSG_DEBUG("Less than "<< m_minSiHits << " Si measurements " << "on track, abort ID hole search");
239  mapOfHits.clear();
240  return false;
241  }
242 
243  // find starting point for 2nd iteration to find predictions
244  std::unique_ptr<const Trk::TrackParameters> startParameters;
245 
246  // ------- special logic for cosmics to obtain start point for hole search
247 
248  if (m_cosmic) {
249  // retrieve surface, from which hole search should start
250  // retrieve tracking geometry
251  const Trk::TrackingGeometry* trackingGeometry = m_extrapolator->trackingGeometry();
252  // get sct volume
253  const Trk::TrackingVolume* sctVolume = trackingGeometry->trackingVolume("InDet::Detectors::SCT::Barrel");
254  //get BoundarySurface for cylinder between sct and trt
255  const Trk::CylinderSurface* sctCylinder = nullptr;
256  const Trk::Surface* sctSurface= &(sctVolume->boundarySurfaces()[Trk::tubeOuterCover]->surfaceRepresentation());
257  if(sctSurface->type()==Trk::SurfaceType::Cylinder){
258  sctCylinder= static_cast<const Trk::CylinderSurface*> (sctSurface);
259  }
260  if (!sctCylinder) {
261  ATH_MSG_ERROR ("cast to CylinderSurface failed, should never happen !");
262  return false;
263  }
264  // extrapolate track to cylinder; take this as starting point for hole search
265 
266  if (firstsipar) {
267  //std::cout << "firstsipar: " << *firstsipar << " pos: " << firstsipar->position() << std::endl;
268  startParameters = m_extrapolator->extrapolate(
269  ctx, *firstsipar, *sctCylinder, Trk::oppositeMomentum, true, partHyp);
270  }
271 
272  // if track can't be extrapolated to this cylinder (EC track!), extrapolate to disc outside TRT/SCT EC
273  if (!startParameters) {
274  ATH_MSG_DEBUG("no start parameters on SCT cylinder, try TRT ec disc");
275  // get BoundarySurface for disk which encloses TRT ECs
276  // depending on track origin use neg or pos EC
277  const Trk::DiscSurface* trtDisc=nullptr;
278  // inverse logic: tracks with theta < M_PI/2 have origin in negative EC
279  if (firstsipar->parameters()[Trk::theta] < M_PI/2.) {
280  const Trk::TrackingVolume* trtVolume = trackingGeometry->trackingVolume("InDet::Detectors::TRT::NegativeEndcap");
281  const Trk::Surface* trtSurface = &(trtVolume->boundarySurfaces()[Trk::negativeFaceXY]->surfaceRepresentation());
282  if(trtSurface->type()==Trk::SurfaceType::Disc){
283  trtDisc = static_cast<const Trk::DiscSurface*> (trtSurface);
284  }
285  } else {
286  const Trk::TrackingVolume* trtVolume = trackingGeometry->trackingVolume("InDet::Detectors::TRT::PositiveEndcap");
287  const Trk::Surface* trtSurface = &(trtVolume->boundarySurfaces()[Trk::positiveFaceXY]->surfaceRepresentation());
288  if(trtSurface->type()==Trk::SurfaceType::Disc){
289  trtDisc = static_cast<const Trk::DiscSurface*> (trtSurface);
290  }
291  }
292 
293  if (trtDisc) {
294  // extrapolate track to disk
295  startParameters = m_extrapolator->extrapolate(
296  ctx, *firstsipar, *trtDisc, Trk::oppositeMomentum, true, partHyp);
297  }
298  }
299  } else { // no cosmics
300 
301  if (track.perigeeParameters()) {
302  startParameters.reset( track.perigeeParameters()->clone());
303  } else if (track.trackParameters()->front()) {
304  ATH_MSG_DEBUG("No perigee, extrapolate to 0,0,0");
305  // go back to perigee
306  startParameters =
307  m_extrapolator->extrapolate(ctx,
308  *(track.trackParameters()->front()),
309  Trk::PerigeeSurface(),
310  Trk::anyDirection,
311  false,
312  partHyp);
313  }
314  }
315 
316  if (!startParameters) {
317  ATH_MSG_DEBUG("No start point obtained, hole search not performed.");
318  mapOfHits.clear();
319  return false;
320  }
321 
322  bool foundFirst = false;
323  // ME - if we look for an extended list of holes, we take the first module, otherwise we searchfor the first measurment
324  // if we have a cosmics track, we want to get the extended list as well!
325  if (m_extendedListOfHoles || m_cosmic) {
326  ATH_MSG_DEBUG("We are looking for an extended list of holes, so add eventual holes before first hits");
327  foundFirst = true;
328  }
329 
330  Identifier id(0);
331  const Trk::Surface* surf = nullptr;
332  bool hasID = false;
333 
334  // 2nd iteration to find predictions
335  Trk::TrackStates::const_iterator iterTSOS = track.trackStateOnSurfaces()->begin();
336 
337  // for cosmics: go to the first si mearsurement on track
338  // for cosmics: add perigee as intermediate state, as the extrapolator does nothing if the starting layer and destination layer are the same
339  if (m_cosmic) {
340  while (iterTSOS!=track.trackStateOnSurfaces()->end()
341  && (!(*iterTSOS)->type(Trk::TrackStateOnSurface::Measurement)
342  || (*iterTSOS)->measurementOnTrack()->associatedSurface().type()!=Trk::SurfaceType::Plane)) {
343  ++iterTSOS;
344  }
345  }
346 
347  ATH_MSG_VERBOSE("start position: " << startParameters->position()
348  << " r: " << sqrt(pow(startParameters->position().x(),2)
349  +pow(startParameters->position().y(),2)));
350 
351  int measno=0;
352  int nmeas=(int)track.measurementsOnTrack()->size();
353  for (; iterTSOS!=track.trackStateOnSurfaces()->end();++iterTSOS) {
354  const Trk::Perigee *per=nullptr;
355  // type of state is measurement ?
356  if ((*iterTSOS)->type(Trk::TrackStateOnSurface::Measurement) ||
357  (*iterTSOS)->type(Trk::TrackStateOnSurface::Outlier) ||
358  ((*iterTSOS)->type(Trk::TrackStateOnSurface::Perigee) && m_cosmic)) {
359  hasID=false;
360  per=nullptr;
361  const Trk::TrackParameters* tmpParam= (*iterTSOS)->trackParameters();
362  if (m_cosmic && tmpParam) {
363  if(tmpParam->associatedSurface().type()==Trk::SurfaceType::Perigee){
364  per=static_cast<const Trk::Perigee*>(tmpParam) ;
365  }
366  }
367  if ((*iterTSOS)->measurementOnTrack() != nullptr
368  && (*iterTSOS)->measurementOnTrack()->associatedSurface().associatedDetectorElement() != nullptr
369  && (*iterTSOS)->measurementOnTrack()->associatedSurface().associatedDetectorElement()->identify() != 0) {
370  id = (*iterTSOS)->measurementOnTrack()->associatedSurface().associatedDetectorElement()->identify();
371  surf = &(*iterTSOS)->measurementOnTrack()->associatedSurface();
372  hasID = true;
373  } else if ((*iterTSOS)->trackParameters() != nullptr
374  && (*iterTSOS)->trackParameters()->associatedSurface().associatedDetectorElement() != nullptr
375  && (*iterTSOS)->trackParameters()->associatedSurface().associatedDetectorElement()->identify() != 0) {
376  id = (*iterTSOS)->trackParameters()->associatedSurface().associatedDetectorElement()->identify();
377  surf = &((*iterTSOS)->trackParameters()->associatedSurface());
378  hasID = true;
379  } else if (m_cosmic && per) {
380  surf=&((*iterTSOS)->trackParameters()->associatedSurface());
381  }
382 
383  // see if this is an Si state !
384  if ((m_cosmic && per) || (hasID && (m_atlasId->is_pixel(id) || m_atlasId->is_sct(id) || m_atlasId->is_trt(id)))) {
385 
386  if (m_atlasId->is_trt(id)) ATH_MSG_VERBOSE("Target is TRT, see if we can add something");
387 
388  // extrapolate stepwise to this parameter (be careful, sorting might be wrong)
389 
390  std::vector<std::unique_ptr<Trk::TrackParameters> > paramList =
391  m_extrapolator->extrapolateStepwise(ctx,
392  *startParameters,
393  *surf,
394  Trk::alongMomentum,
395  false, partHyp);
396 
397  if (paramList.empty()) {
398  ATH_MSG_VERBOSE("--> Did not manage to extrapolate to surface!!!");
399  continue;
400  }
401 
402  ATH_MSG_VERBOSE("Number of parameters in this step: " << paramList.size());
403 
404  // loop over the predictons and analyze them
405  for (std::unique_ptr<Trk::TrackParameters>& thisParameters : paramList) {
406  ATH_MSG_VERBOSE("extrapolated pos: " << thisParameters->position() << " r: " <<
407  sqrt(pow(thisParameters->position().x(),2)+pow(thisParameters->position().y(),2)));
408 
409  // check if surface has identifer !
410  Identifier id2;
411  if ((thisParameters->associatedSurface()).associatedDetectorElement() != nullptr &&
412  (thisParameters->associatedSurface()).associatedDetectorElement()->identify() != 0) {
413  id2 = (thisParameters->associatedSurface()).associatedDetectorElement()->identify();
414  } else {
415  ATH_MSG_VERBOSE("Surface has no detector element ID, skip it");
416  if(thisParameters->associatedSurface().type()==Trk::SurfaceType::Perigee){
417  startParameters = std::move(thisParameters);
418  }
419  continue;
420  }
421 
422  // check if it is Si or Pixel
423  if (!(m_atlasId->is_pixel(id2) || m_atlasId->is_sct(id2))) {
424  ATH_MSG_VERBOSE("Surface is not Pixel or SCT, stop loop over parameters in this step");
425  // for collisions, we want to stop at the first trt measurement; whereas for cosmics not
426  // here we will have trt measurements on the track before the first si measurement!
427  if(thisParameters->associatedSurface().type()==Trk::SurfaceType::Perigee){
428  startParameters = std::move(thisParameters);
429  }
430  if (m_cosmic) continue;
431  else break;
432  }
433 
434  // see if this surface is in the list
435  std::map<const Identifier, const Trk::TrackStateOnSurface*>::iterator iTSOS = mapOfHits.find(id2);
436 
437  if (iTSOS == mapOfHits.end() && !foundFirst) {
438  ATH_MSG_VERBOSE("Si surface before first Si measurement, skip it and continue");
439  continue;
440  }
441 
442  // this is a measurement on the track ?
443  if (iTSOS != mapOfHits.end()) {
444  if (!foundFirst && !(*iterTSOS)->type(Trk::TrackStateOnSurface::Outlier)) {
445  ATH_MSG_VERBOSE("Found first Si measurement !");
446  foundFirst = true;
447  }
448 
449  // is this a surface which might have a better prediction ?
450  if (iTSOS->second->trackParameters()) {
451  ATH_MSG_VERBOSE("Found track parameter on Si surface, take it");
452  startParameters.reset( iTSOS->second->trackParameters()->clone());
453  } else {
454  ATH_MSG_VERBOSE("No parameter, take extrapolation");
455  startParameters.reset(thisParameters->clone());
456  }
457  }
458 
459  // add surface, test insert !
460  std::pair<const Trk::TrackParameters*,const bool> trackparampair (thisParameters.release(),true);
461  if (mapOfPredictions.insert(std::pair<const Identifier, std::pair<const Trk::TrackParameters*,const bool> >(id2,trackparampair)).second) {
462  ATH_MSG_VERBOSE("Added Si surface to mapOfPredictions");
463  } else {
464  ATH_MSG_VERBOSE("Had this, it is a double, skipped");
465  delete trackparampair.first;
466  trackparampair.first=nullptr;
467  }
468  }
469 
470  if (!(m_atlasId->is_pixel(id) || m_atlasId->is_sct(id))) {
471  ATH_MSG_VERBOSE("Target was no longer an Si element, break loop");
472  break;
473  }
474 
475  }
476  }
477  if ((*iterTSOS)->type(Trk::TrackStateOnSurface::Measurement) && !(*iterTSOS)->type(Trk::TrackStateOnSurface::Outlier)) measno++;
478  if (measno==nmeas) break; // don't count holes after last measurement, this is done below...
479  }
480 
481 
482  // if last extrapolation is not TRT:
483  // - if countDeadModulesAfterLastHit (robustness): search for dead modules
484  // - if cosmics or extendedListOfHoles: search for more holes after the last measurement (and also dead modules)
485  if (!m_atlasId->is_trt(id) && (m_countDeadModulesAfterLastHit || m_extendedListOfHoles || m_cosmic)) {
486  ATH_MSG_DEBUG("Search for dead modules after the last Si measurement");
487  if (m_extendedListOfHoles || m_cosmic) ATH_MSG_DEBUG("Search for extended list of holes");
488 
489  Trk::CylinderVolumeBounds* cylinderBounds = new Trk::CylinderVolumeBounds(560, 2750);
490  // don't delete the cylinderBounds -> it's taken care of by Trk::VOlume (see Trk::SharedObject)
491  Trk::Volume* boundaryVol = new Trk::Volume(nullptr, cylinderBounds);
492  // extrapolate this parameter blindly to search for more Si hits (not very fast, I know)
493 
494  std::vector<std::unique_ptr<Trk::TrackParameters> > paramList =
495  m_extrapolator->extrapolateBlindly(ctx,
496  *startParameters,
497  Trk::alongMomentum,
498  false, partHyp,
499  boundaryVol);
500  if (paramList.empty()) {
501  ATH_MSG_VERBOSE("--> Did not manage to extrapolate to another surface, break loop");
502  } else {
503  ATH_MSG_VERBOSE("Number of parameters in this step: " << paramList.size());
504 
505  // loop over the predictions and analyze them
506  for (std::unique_ptr<Trk::TrackParameters>& thisParameter : paramList) {
507  // check if surface has identifer !
508  Identifier id2;
509  if (thisParameter->associatedSurface().associatedDetectorElement() != nullptr &&
510  thisParameter->associatedSurface().associatedDetectorElement()->identify() != 0) {
511  id2 = thisParameter->associatedSurface().associatedDetectorElement()->identify();
512 
513  // check if it is Si or Pixel
514  if (!(m_atlasId->is_pixel(id2) || m_atlasId->is_sct(id2))) {
515  ATH_MSG_VERBOSE("Surface is not Pixel or SCT, stop loop over parameters in this step");
516  break;
517  }
518 
519  // JEF: bool parameter in trackparampair: flag weather this hit should be considered as hole; if
520  // not, just cound dead modules
521  std::pair<Trk::TrackParameters*, const bool> trackparampair(
522  thisParameter.release(), m_extendedListOfHoles || m_cosmic);
523  if (mapOfPredictions
524  .insert(std::pair<const Identifier, std::pair<const Trk::TrackParameters*, const bool>>(
525  id2, trackparampair))
526  .second) {
527  thisParameter.reset(trackparampair.first->clone());
528  ATH_MSG_VERBOSE("Added Si surface");
529  } else {
530  thisParameter.reset(trackparampair.first);
531  ATH_MSG_VERBOSE("Had this, it is a double, skipped");
532  }
533  } else {
534  ATH_MSG_VERBOSE("Surface has no detector element ID, skip it");
535  }
536 
537  // keep going...
538  startParameters = std::move(thisParameter);
539  }
540  }
541 
542  // gotta clean up ...
543  delete boundaryVol;
544  boundaryVol = nullptr;
545  //delete cylinderBounds; cylinderBounds = 0; // Till : don't delete this guy, it's deleted already when the boundaryVol gets deleted !
546  }
547 
548  ATH_MSG_DEBUG("Number of Predictions found: " << mapOfPredictions.size());
549  return true;
550 
551 }

◆ getTrackWithHoles()

const Trk::Track * InDet::InDetTrackHoleSearchTool::getTrackWithHoles ( const Trk::Track &  track,
const Trk::ParticleHypothesis  partHyp = Trk::pion 
) const
virtual

Input : track, parthyp Return: A pointer to a new Trk::Track which containes the information of the input track plus the tsos of the identified holes The parthyp argument is relevant for the extrapolation steps in the hole search.

Attention: This is a factory, ownership of the return track is passed to the calling method.

Implements Trk::ITrackHoleSearchTool.

Definition at line 103 of file InDetTrackHoleSearchTool.cxx.

104  {
105  std::vector<const Trk::TrackStateOnSurface*>* listOfHoles = new std::vector<const Trk::TrackStateOnSurface*>;
106  searchForHoles(track, nullptr, listOfHoles,partHyp);
107  const Trk::Track* newTrack = addHolesToTrack(track,listOfHoles);
108  delete listOfHoles;
109  listOfHoles = nullptr;
110  return newTrack;
111 }

◆ getTrackWithHolesAndOutliers()

const Trk::Track * InDet::InDetTrackHoleSearchTool::getTrackWithHolesAndOutliers ( const Trk::Track &  track,
const Trk::ParticleHypothesis  partHyp = Trk::pion 
) const
virtual

Input : track, parthyp Return: A pointer to a new Trk::Track which containes the information of the input track plus the tsos of the identified holes or outliers The parthyp argument is relevant for the extrapolation steps in the hole search.

Attention: This is a factory, ownership of the return track is passed to the calling method.

Implements Trk::ITrackHoleSearchTool.

Definition at line 114 of file InDetTrackHoleSearchTool.cxx.

115  {
116  return getTrackWithHoles(track,partHyp);
117 }

◆ initialize()

StatusCode InDet::InDetTrackHoleSearchTool::initialize ( )
virtual

standard Athena-Algorithm method

Definition at line 51 of file InDetTrackHoleSearchTool.cxx.

51  {
52 
53  StatusCode sc = AlgTool::initialize();
54  if (sc.isFailure()) return sc;
55 
56  ATH_CHECK(detStore()->retrieve(m_atlasId, "AtlasID"));
57 
58  ATH_CHECK(m_extrapolator.retrieve());
59 
60  if (m_extendedListOfHoles) ATH_MSG_INFO("Search for extended list of holes ");
61 
62  return StatusCode::SUCCESS;
63 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ interfaceID()

const InterfaceID & Trk::ITrackHoleSearchTool::interfaceID ( )
inlinestaticinherited

Definition at line 78 of file ITrackHoleSearchTool.h.

79  {
80  return IID_ITrackHoleSearchTool;
81  }

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ performHoleSearchStepWise()

void InDet::InDetTrackHoleSearchTool::performHoleSearchStepWise ( std::map< const Identifier, const Trk::TrackStateOnSurface * > &  mapOfHits,
std::map< const Identifier, std::pair< const Trk::TrackParameters *, const bool > > &  mapOfPredictions,
std::vector< int > *  information,
std::vector< const Trk::TrackStateOnSurface * > *  listOfHoles 
) const
private

This method searches for holes in a track.

It receives a list of detector responses sorted along the track. The TSOS in the list of hits should contain TrackParameters or at least MeasurementOnTrack. The method extrapolates along the tracks, using the hit information to update the extrapolation procedure. Surface without detector responses, which are crossed by the extrapolation are counted as holes. The number of holes found is returned through the information array. Input: mapOfHits,mapOfPredicitons Output: Changes in information,listOfHoles

This function looks for holes in a given set of TrackStateOnSurface (TSOS) within the Si-detectors. In order to do so, an extrapolation is performed from detector element to the next and compared to the ones in the TSOS. If surfaces other than the ones in the track are crossed, these are possible holes or dead modules. Checks for sensitivity of struck material are performed.

The function requires the TSOS to have either TrackParameters (should have) or a MeasurementBase (must have). The startPoint of an extrapolation is required to be a TP. In case only a MB is present, the extrapolation Startpoint is set by the result TP of the last extrapolation, if possible.

Definition at line 554 of file InDetTrackHoleSearchTool.cxx.

557  {
568  // counters to steer first/last Si hit logic
569  unsigned int foundTSOS = 0;
570  int PixelHoles = 0, SctHoles = 0, SctDoubleHoles = 0, PixelDead=0, SctDead=0;
571  std::set<Identifier> SctHoleIds;
572 
573  ATH_MSG_DEBUG("Start iteration");
574  ATH_MSG_DEBUG("Number of hits+outliers: " << mapOfHits.size() << " and predicted parameters:" << mapOfPredictions.size());
575 
576  for (std::map<const Identifier,std::pair<const Trk::TrackParameters*,const bool> >::const_iterator it = mapOfPredictions.begin();
577  it != mapOfPredictions.end(); ++it) {
578 
579  const Trk::TrackParameters* nextParameters = (it->second).first;
580 
581  Identifier id = nextParameters->associatedSurface().associatedDetectorElement()->identify();
582 
583  // search for this ID in the list
584  std::map<const Identifier, const Trk::TrackStateOnSurface*>::iterator iTSOS = mapOfHits.find(id);
585 
586  if (iTSOS == mapOfHits.end()) {
587  switch (m_boundaryCheckTool->boundaryCheck(*nextParameters)) {
588  case Trk::BoundaryCheckResult::DeadElement:
589  if (m_atlasId->is_pixel(id)) {
590 
591  ATH_MSG_VERBOSE("Found element is a dead pixel module, add it to the list and continue");
592  ++PixelDead;
593  } else if (m_atlasId->is_sct(id)) {
594 
595  ATH_MSG_VERBOSE("Found element is a dead SCT module, add it to the list and continue");
596  ++SctDead;
597  }
598  case Trk::BoundaryCheckResult::Insensitive:
599  case Trk::BoundaryCheckResult::Outside:
600  case Trk::BoundaryCheckResult::OnEdge:
601  case Trk::BoundaryCheckResult::Error:
602  continue;
603  case Trk::BoundaryCheckResult::Candidate:
604  break;
605  }
606 
607  // increment tmp counters only if this detElement should be considered for a proper holesearch
608  // this info is the boolean in the (mapOfPredictions->second).second
609  if (((it->second).second)) {
610  if (m_atlasId->is_pixel(id)) {
611  ATH_MSG_VERBOSE("Found element is a Pixel hole, add it to the list and continue");
612  ++PixelHoles;
613  } else if (m_atlasId->is_sct(id)) {
614  ATH_MSG_VERBOSE("Found element is a SCT hole, add it to the list and continue");
615  ++SctHoles;
616 
617  // check double sct
618  // obtain backside of SCT module
619  const InDetDD::SiDetectorElement* thisElement =
620  dynamic_cast<const InDetDD::SiDetectorElement *> (nextParameters->associatedSurface().associatedDetectorElement());
621  if (!thisElement) {
622  ATH_MSG_ERROR ("cast to SiDetectorElement failed, should never happen !");
623  continue;
624  }
625 
626  const Identifier otherId = thisElement->otherSide()->identify();
627  // loop over holes and look for the other one
628  if (SctHoleIds.find(otherId) != SctHoleIds.end()) {
629  ATH_MSG_VERBOSE("Found an SCT double hole !!!");
630  ++SctDoubleHoles;
631  }
632  // keep this id for double side check
633  SctHoleIds.insert(id);
634 
635  }
636  // add to tmp list of holes
637  if (listOfHoles) listOfHoles->push_back(createHoleTSOS(nextParameters));
638  continue;
639  } else {
640  continue;
641  }
642  } // end (iTSOS == mapOfHits.end())
643 
644  if (iTSOS->second->type(Trk::TrackStateOnSurface::Outlier)) {
645  ++foundTSOS;
646  ATH_MSG_VERBOSE("Found TSOS is an outlier, not a hole, skip it and continue");
647  // remove this one from the map
648  mapOfHits.erase(iTSOS);
649  continue;
650  }
651 
652  if (iTSOS->second->type(Trk::TrackStateOnSurface::Measurement)) {
653  ++foundTSOS;
654  ATH_MSG_VERBOSE("Found TSOS is a measurement, continue");
655  // remove this one from the map
656  mapOfHits.erase(iTSOS);
657  continue;
658  }
659  } // end of loop
660 
661  ATH_MSG_DEBUG("==> Total number of holes found: "
662  << PixelHoles << " Pixel holes, "
663  << SctHoles << " Sct holes, "
664  << SctDoubleHoles << " Double holes");
665 
666  if (listOfHoles) ATH_MSG_DEBUG("==> Size of listOfHoles: " << listOfHoles->size());
667 
668  if (!mapOfHits.empty()) {
669  int ioutliers = 0, imeasurements = 0;
670  for (std::map<const Identifier, const Trk::TrackStateOnSurface*>::const_iterator iter = mapOfHits.begin();
671  iter != mapOfHits.end(); ++iter) {
672  if (iter->second->type(Trk::TrackStateOnSurface::Outlier)) ++ioutliers;
673  else if (iter->second->type(Trk::TrackStateOnSurface::Measurement)) ++imeasurements;
674  else ATH_MSG_ERROR("Found wrong TSOS in map !!!");
675  }
676 
677  if (imeasurements > 0) {
678  if (PixelHoles+SctHoles+SctDoubleHoles > 0) {
679  ATH_MSG_DEBUG("Not all measurements found, but holes. Left measurements: "
680  << imeasurements << " outliers: " << ioutliers << " found: " << foundTSOS
681  << " Pixel holes: " << PixelHoles << " Sct holes: " << SctHoles
682  << " Double holes: " << SctDoubleHoles);
683  } else {
684  ATH_MSG_DEBUG("Problem ? Not all measurements found. Left measurements: "
685  << imeasurements << " outliers: " << ioutliers << " found: " << foundTSOS);
686  }
687  }
688  }
689 
690  // update information and return
691  if (information) {
692  (*information)[Trk::numberOfPixelHoles] = PixelHoles;
693  (*information)[Trk::numberOfSCTHoles] = SctHoles;
694  (*information)[Trk::numberOfSCTDoubleHoles] = SctDoubleHoles;
695  (*information)[Trk::numberOfPixelDeadSensors] = PixelDead;
696  (*information)[Trk::numberOfSCTDeadSensors] = SctDead;
697  }
698 
699  }

◆ 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< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ searchForHoles()

void InDet::InDetTrackHoleSearchTool::searchForHoles ( const Trk::Track &  track,
std::vector< int > *  information,
std::vector< const Trk::TrackStateOnSurface * > *  listOfHoles,
const Trk::ParticleHypothesis  partHyp = Trk::pion 
) const
private

Input : track, parthyp Return: Changes in information and/or listOfHoles The interfacing method to the step wise hole search.

Information and listOfHoles have to be given as pointers, zeros can be given in order to suppress the connected functionality (counting holes / producing hole TSOSs). This Method is not a member of the ITrackHoleSearchTool interface.

Definition at line 122 of file InDetTrackHoleSearchTool.cxx.

125  {
126  ATH_MSG_DEBUG("starting searchForHoles()");
127 
128  if (information) {
129  (*information)[Trk::numberOfPixelHoles] = -1;
130  (*information)[Trk::numberOfSCTHoles] = -1;
131  (*information)[Trk::numberOfSCTDoubleHoles] = -1;
132  (*information)[Trk::numberOfPixelDeadSensors] = -1;
133  (*information)[Trk::numberOfSCTDeadSensors] = -1;
134  (*information)[Trk::numberOfTRTHoles] = -1;
135  (*information)[Trk::numberOfTRTDeadStraws] = -1;
136 
137  }
138 
139  std::map<const Identifier, const Trk::TrackStateOnSurface*> mapOfHits;
140 
141  // JEF: fix of [bug #44382] Poor Tracking Software Performance without SCT
142  // the mapOfPrediction needs the knowledge weather a holesearch should be carried out
143  // on this identifier or just the search for dead modules
144  // therefore: if the boolean is set to true, a holesearch will be caarried out, otherwise just
145  // the search for dead modules
146  // for identifiers BEFORE the last measurement (and after the first): holesearch will be carried out always
147  // for identifiers AFTER the last measurement (or before the first), we have to distiguish two different scenarios:
148  // 1) extendedListOfHoles==True: a hole search will be carried out for all identifiers
149  // 2) extendedListOfHoles==False (default for collisions): dead modules will be counted after the last
150  // measurement, but no holes
151  std::map<const Identifier, std::pair<const Trk::TrackParameters*,const bool> > mapOfPredictions;
152 
153  bool listOk = getMapOfHits(
154  Gaudi::Hive::currentContext(), track, partHyp, mapOfHits, mapOfPredictions);
155 
156  if (listOk) {
157  ATH_MSG_DEBUG("Perform stepwise hole search");
158  performHoleSearchStepWise(mapOfHits, mapOfPredictions, information, listOfHoles);
159  } else {
160  ATH_MSG_DEBUG("List of hits not properly obtained, abort hole search.");
161  }
162 
163  for (auto & mapOfPrediction : mapOfPredictions) {
164  delete (mapOfPrediction.second).first;
165  (mapOfPrediction.second).first = nullptr;
166  }
167 
168  }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_atlasId

const AtlasDetectorID* InDet::InDetTrackHoleSearchTool::m_atlasId
private

ID pixel helper.

Definition at line 110 of file InDetTrackHoleSearchTool.h.

◆ m_boundaryCheckTool

ToolHandle<Trk::IBoundaryCheckTool> InDet::InDetTrackHoleSearchTool::m_boundaryCheckTool
private
Initial value:
{
this,
"BoundaryCheckTool",
"InDet::InDetBoundaryCheckTool",
"Boundary checking tool for detector sensitivities"
}

Definition at line 119 of file InDetTrackHoleSearchTool.h.

◆ m_cosmic

bool InDet::InDetTrackHoleSearchTool::m_cosmic
private

Definition at line 127 of file InDetTrackHoleSearchTool.h.

◆ m_countDeadModulesAfterLastHit

bool InDet::InDetTrackHoleSearchTool::m_countDeadModulesAfterLastHit
private

Definition at line 133 of file InDetTrackHoleSearchTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedListOfHoles

bool InDet::InDetTrackHoleSearchTool::m_extendedListOfHoles
private

Configure outwards hole search.

Definition at line 127 of file InDetTrackHoleSearchTool.h.

◆ m_extrapolator

ToolHandle<Trk::IExtrapolator> InDet::InDetTrackHoleSearchTool::m_extrapolator
private
Initial value:
{
this,
"Extrapolator",
"Trk::Extrapolator/InDetExtrapolator",
"Extrapolator used to extrapolate to layers"
}

Pointer to Extrapolator AlgTool.

Definition at line 113 of file InDetTrackHoleSearchTool.h.

◆ m_minSiHits

int InDet::InDetTrackHoleSearchTool::m_minSiHits
private

Min number of hits.

Definition at line 130 of file InDetTrackHoleSearchTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_warning

std::atomic_int InDet::InDetTrackHoleSearchTool::m_warning
mutableprivate

number of warnings printed when no track parameters available

Definition at line 136 of file InDetTrackHoleSearchTool.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
AtlasDetectorID::is_pixel
bool is_pixel(Identifier id) const
Definition: AtlasDetectorID.h:760
Trk::anyDirection
@ anyDirection
Definition: PropDirection.h:22
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
InDet::InDetTrackHoleSearchTool::addHolesToTrack
const Trk::Track * addHolesToTrack(const Trk::Track &oldTrack, std::vector< const Trk::TrackStateOnSurface * > *listOfHoles) const
This Method creates a new Track from the TSOS of the input track combined with the TSOS from listOfHo...
Definition: InDetTrackHoleSearchTool.cxx:710
Trk::TrackStateOnSurface::Perigee
@ Perigee
This represents a perigee, and so will contain a Perigee object only.
Definition: TrackStateOnSurface.h:117
python.tests.PyTestsLib.finalize
def finalize(self)
_info( "content of StoreGate..." ) self.sg.dump()
Definition: PyTestsLib.py:53
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
Trk::Track::fitQuality
const FitQuality * fitQuality() const
return a pointer to the fit quality const-overload
Trk::Surface::associatedDetectorElement
const TrkDetElementBase * associatedDetectorElement() const
return associated Detector Element
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
Trk::BoundaryCheckResult::DeadElement
@ DeadElement
outside the element
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
InDet::InDetTrackHoleSearchTool::m_warning
std::atomic_int m_warning
number of warnings printed when no track parameters available
Definition: InDetTrackHoleSearchTool.h:136
Trk::BoundaryCheckResult::Insensitive
@ Insensitive
close to the edge of an active element
Trk::PerigeeSurface
Definition: PerigeeSurface.h:43
AtlasDetectorID::is_sct
bool is_sct(Identifier id) const
Definition: AtlasDetectorID.h:770
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
Trk::oppositeMomentum
@ oppositeMomentum
Definition: PropDirection.h:21
Trk::ParametersBase::associatedSurface
virtual const Surface & associatedSurface() const override=0
Access to the Surface associated to the Parameters.
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Trk::ParametersBase::uniqueClone
std::unique_ptr< ParametersBase< DIM, T > > uniqueClone() const
clone method for polymorphic deep copy returning unique_ptr; it is not overriden, but uses the existi...
Definition: ParametersBase.h:97
Trk::numberOfSCTDeadSensors
@ numberOfSCTDeadSensors
number of TRT hits
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:76
Trk::Track::trackStateOnSurfaces
const Trk::TrackStates * trackStateOnSurfaces() const
return a pointer to a const DataVector of const TrackStateOnSurfaces.
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
Trk::TrackingVolume::boundarySurfaces
std::vector< SharedObject< BoundarySurface< TrackingVolume > > > & boundarySurfaces()
Method to return the BoundarySurfaces.
Definition: TrackingVolume.cxx:982
Trk::Track::info
const TrackInfo & info() const
Returns a const ref to info of a const tracks.
initialize
void initialize()
Definition: run_EoverP.cxx:894
Trk::BoundaryCheckResult::Candidate
@ Candidate
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
xAOD::JetInput::Track
@ Track
Definition: JetContainerInfo.h:61
skel.it
it
Definition: skel.GENtoEVGEN.py:423
M_PI
#define M_PI
Definition: ActiveFraction.h:11
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
Trk::positiveFaceXY
@ positiveFaceXY
Definition: BoundarySurfaceFace.h:33
InDet::InDetTrackHoleSearchTool::m_extrapolator
ToolHandle< Trk::IExtrapolator > m_extrapolator
Pointer to Extrapolator AlgTool.
Definition: InDetTrackHoleSearchTool.h:113
Trk::alongMomentum
@ alongMomentum
Definition: PropDirection.h:20
Trk::DiscSurface
Definition: DiscSurface.h:54
AtlasDetectorID::is_trt
bool is_trt(Identifier id) const
Definition: AtlasDetectorID.h:782
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
Trk::TrkDetElementBase::identify
virtual Identifier identify() const =0
Identifier.
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
Trk::numberOfSCTHoles
@ numberOfSCTHoles
number of Holes in both sides of a SCT module
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:73
Trk::numberOfTRTHoles
@ numberOfTRTHoles
number of TRT hits which pass the high threshold (only xenon counted) total number of TRT hits which ...
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:83
std::stable_sort
void stable_sort(std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, std::reverse_iterator< DataModel_detail::iterator< DVL > > end, Compare comp)
Specialization of stable_sort for DataVector/List.
Definition: DVL_algorithms.h:711
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
Trk::TrackStateOnSurface::Outlier
@ Outlier
This TSoS contains an outlier, that is, it contains a MeasurementBase/RIO_OnTrack which was not used ...
Definition: TrackStateOnSurface.h:122
Trk::numberOfTRTDeadStraws
@ numberOfTRTDeadStraws
number of TRT tube hits
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:95
Trk::ParametersT::associatedSurface
virtual const S & associatedSurface() const override final
Access to the Surface method.
Trk::TrackStateOnSurfaceComparisonFunction
Class providing comparison function, or relational definition, for sorting MeasurementBase objects.
Definition: TrackStateOnSurfaceComparisonFunction.h:37
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
id2
HWIdentifier id2
Definition: LArRodBlockPhysicsV0.cxx:564
Trk::TrackStates
DataVector< const Trk::TrackStateOnSurface > TrackStates
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:30
Trk::TrackStateOnSurface::Hole
@ Hole
A hole on the track - this is defined in the following way.
Definition: TrackStateOnSurface.h:128
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
beamspotman.n
n
Definition: beamspotman.py:731
Trk::theta
@ theta
Definition: ParamDefs.h:72
Trk::TrackingGeometry
Definition: TrackingGeometry.h:67
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Trk::CylinderSurface
Definition: CylinderSurface.h:55
Trk::numberOfPixelDeadSensors
@ numberOfPixelDeadSensors
number of pixel hits with broad errors (width/sqrt(12))
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:65
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Trk::negativeFaceXY
@ negativeFaceXY
Definition: BoundarySurfaceFace.h:32
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Trk::ParametersBase
Definition: ParametersBase.h:55
Trk::BoundaryCheckResult::Outside
@ Outside
with the insensitive area of an active element
DataVector< const Trk::TrackStateOnSurface >
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
InDet::InDetTrackHoleSearchTool::m_boundaryCheckTool
ToolHandle< Trk::IBoundaryCheckTool > m_boundaryCheckTool
Definition: InDetTrackHoleSearchTool.h:119
Trk::numberOfPixelHoles
@ numberOfPixelHoles
number of pixels which have a ganged ambiguity.
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:59
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
merge.output
output
Definition: merge.py:17
Trk::CylinderVolumeBounds
Definition: CylinderVolumeBounds.h:70
Trk::Track::perigeeParameters
const Perigee * perigeeParameters() const
return Perigee.
Definition: Tracking/TrkEvent/TrkTrack/src/Track.cxx:163
Trk::SurfaceType::Perigee
@ Perigee
InDet::InDetTrackHoleSearchTool::getMapOfHits
bool getMapOfHits(const EventContext &ctx, const Trk::Track &track, const Trk::ParticleHypothesis partHyp, std::map< const Identifier, const Trk::TrackStateOnSurface * > &mapOfHits, std::map< const Identifier, std::pair< const Trk::TrackParameters *, const bool >> &mapOfPredictions) const
Input: track Output: changes in mapOfHits (filling it) and hasTRT Return value: True if filling was s...
Definition: InDetTrackHoleSearchTool.cxx:171
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
Trk::TrackStateOnSurface
represents the track state (measurement, material, fit parameters and quality) at a surface.
Definition: TrackStateOnSurface.h:71
InDetDD::SiDetectorElement::otherSide
const SiDetectorElement * otherSide() const
Useful for SCT only.
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:191
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
Trk::FitQuality::uniqueClone
std::unique_ptr< FitQuality > uniqueClone() const
NVI uniqueClone.
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
InDet::InDetTrackHoleSearchTool::searchForHoles
void searchForHoles(const Trk::Track &track, std::vector< int > *information, std::vector< const Trk::TrackStateOnSurface * > *listOfHoles, const Trk::ParticleHypothesis partHyp=Trk::pion) const
Input : track, parthyp Return: Changes in information and/or listOfHoles The interfacing method to th...
Definition: InDetTrackHoleSearchTool.cxx:122
InDet::InDetTrackHoleSearchTool::getTrackWithHoles
virtual const Trk::Track * getTrackWithHoles(const Trk::Track &track, const Trk::ParticleHypothesis partHyp=Trk::pion) const
Input : track, parthyp Return: A pointer to a new Trk::Track which containes the information of the i...
Definition: InDetTrackHoleSearchTool.cxx:103
InDet::InDetTrackHoleSearchTool::m_minSiHits
int m_minSiHits
Min number of hits.
Definition: InDetTrackHoleSearchTool.h:130
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
InDet::InDetTrackHoleSearchTool::performHoleSearchStepWise
void performHoleSearchStepWise(std::map< const Identifier, const Trk::TrackStateOnSurface * > &mapOfHits, std::map< const Identifier, std::pair< const Trk::TrackParameters *, const bool > > &mapOfPredictions, std::vector< int > *information, std::vector< const Trk::TrackStateOnSurface * > *listOfHoles) const
This method searches for holes in a track.
Definition: InDetTrackHoleSearchTool.cxx:554
a
TList * a
Definition: liststreamerinfos.cxx:10
h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
DeMoScan.first
bool first
Definition: DeMoScan.py:534
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:73
Trk::SurfaceType::Disc
@ Disc
Trk::SurfaceType::Cylinder
@ Cylinder
Trk::TrackingGeometry::trackingVolume
const TrackingVolume * trackingVolume(const std::string &name) const
return the tracking Volume by name, 0 if it doesn't exist
InDet::InDetTrackHoleSearchTool::m_countDeadModulesAfterLastHit
bool m_countDeadModulesAfterLastHit
Definition: InDetTrackHoleSearchTool.h:133
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
InDet::InDetTrackHoleSearchTool::m_atlasId
const AtlasDetectorID * m_atlasId
ID pixel helper.
Definition: InDetTrackHoleSearchTool.h:110
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
Trk::tubeOuterCover
@ tubeOuterCover
Definition: BoundarySurfaceFace.h:40
Trk::SurfaceType::Plane
@ Plane
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
InDet::InDetTrackHoleSearchTool::m_extendedListOfHoles
bool m_extendedListOfHoles
Configure outwards hole search.
Definition: InDetTrackHoleSearchTool.h:127
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
Trk::BoundaryCheckResult::Error
@ Error
within the nominally active area of a dead element
Trk::Surface
Definition: Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h:75
InDet::InDetTrackHoleSearchTool::createHoleTSOS
static const Trk::TrackStateOnSurface * createHoleTSOS(const Trk::TrackParameters *trackPar)
This method creates a TSOS to represent a detected hole.
Definition: InDetTrackHoleSearchTool.cxx:702
Trk::Volume
Definition: Volume.h:35
InDet::InDetTrackHoleSearchTool::m_cosmic
bool m_cosmic
Definition: InDetTrackHoleSearchTool.h:127
Trk::numberOfSCTDoubleHoles
@ numberOfSCTDoubleHoles
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:75
Trk::TrackingVolume
Definition: TrackingVolume.h:121
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
Trk::Surface::type
constexpr virtual SurfaceType type() const =0
Returns the Surface type to avoid dynamic casts.
InDetDD::SolidStateDetectorElementBase::identify
virtual Identifier identify() const override final
identifier of this detector element (inline)
Trk::TrackStateOnSurface::Measurement
@ Measurement
This is a measurement, and will at least contain a Trk::MeasurementBase.
Definition: TrackStateOnSurface.h:101
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
Trk::BoundaryCheckResult::OnEdge
@ OnEdge
within the sensitive area of an active element
Generated on Fri Jun 28 2024 22:18:22 for ATLAS Offline Software by   doxygen 1.8.18