ATLAS Offline Software
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...
 
 DeclareInterfaceID (ITrackHoleSearchTool, 1, 0)
 
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
 

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
 
BooleanProperty m_extendedListOfHoles {this, "ExtendedListOfHoles", false}
 Configure outwards hole search. More...
 
BooleanProperty m_cosmic {this, "Cosmics", false}
 
IntegerProperty m_minSiHits {this, "minSiHits", 3}
 Min number of hits. More...
 
BooleanProperty m_countDeadModulesAfterLastHit {this, "CountDeadModulesAfterLastHit", true}
 
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_warning(0) {
38  declareInterface<ITrackHoleSearchTool>(this);
39 }

◆ ~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 711 of file InDetTrackHoleSearchTool.cxx.

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

◆ 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 66 of file InDetTrackHoleSearchTool.cxx.

68  {
69  std::vector<const Trk::TrackStateOnSurface*>* listOfHoles = nullptr;
70  searchForHoles(track,&information,listOfHoles,partHyp);
71  if (listOfHoles) {
72  ATH_MSG_ERROR("listOfHoles is leaking in countHoles !!!");
73  for (const auto *listOfHole : *listOfHoles) {
74  delete listOfHole;
75  }
76  delete listOfHoles;
77  listOfHoles = nullptr;
78  }
79  }

◆ 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 703 of file InDetTrackHoleSearchTool.cxx.

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

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

◆ DeclareInterfaceID()

Trk::ITrackHoleSearchTool::DeclareInterfaceID ( ITrackHoleSearchTool  ,
1  ,
0   
)
inherited

◆ 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 60 of file InDetTrackHoleSearchTool.cxx.

60  {
61  StatusCode sc = AlgTool::finalize();
62  return sc;
63 }

◆ 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 82 of file InDetTrackHoleSearchTool.cxx.

83  {
84  std::vector<const Trk::TrackStateOnSurface*>* listOfHoles = new std::vector<const Trk::TrackStateOnSurface*>;
85  searchForHoles(track, nullptr, listOfHoles,partHyp);
86 
87  Trk::TrackStates* output = new Trk::TrackStates;
88  for (const auto *listOfHole : *listOfHoles)
89  output->push_back(listOfHole);
90 
91  delete listOfHoles;
92  listOfHoles = nullptr;
93  return output;
94 }

◆ 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 165 of file InDetTrackHoleSearchTool.cxx.

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

◆ 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 97 of file InDetTrackHoleSearchTool.cxx.

98  {
99  std::vector<const Trk::TrackStateOnSurface*>* listOfHoles = new std::vector<const Trk::TrackStateOnSurface*>;
100  searchForHoles(track, nullptr, listOfHoles,partHyp);
101  const Trk::Track* newTrack = addHolesToTrack(track,listOfHoles);
102  delete listOfHoles;
103  listOfHoles = nullptr;
104  return newTrack;
105 }

◆ 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 108 of file InDetTrackHoleSearchTool.cxx.

109  {
110  return getTrackWithHoles(track,partHyp);
111 }

◆ initialize()

StatusCode InDet::InDetTrackHoleSearchTool::initialize ( )
virtual

standard Athena-Algorithm method

Definition at line 45 of file InDetTrackHoleSearchTool.cxx.

45  {
46 
47  StatusCode sc = AlgTool::initialize();
48  if (sc.isFailure()) return sc;
49 
50  ATH_CHECK(detStore()->retrieve(m_atlasId, "AtlasID"));
51 
52  ATH_CHECK(m_extrapolator.retrieve());
53 
54  if (m_extendedListOfHoles) ATH_MSG_INFO("Search for extended list of holes ");
55 
56  return StatusCode::SUCCESS;
57 }

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

◆ 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 555 of file InDetTrackHoleSearchTool.cxx.

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

◆ 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 116 of file InDetTrackHoleSearchTool.cxx.

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

◆ 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

BooleanProperty InDet::InDetTrackHoleSearchTool::m_cosmic {this, "Cosmics", false}
private

Definition at line 128 of file InDetTrackHoleSearchTool.h.

◆ m_countDeadModulesAfterLastHit

BooleanProperty InDet::InDetTrackHoleSearchTool::m_countDeadModulesAfterLastHit {this, "CountDeadModulesAfterLastHit", true}
private

Definition at line 134 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

BooleanProperty InDet::InDetTrackHoleSearchTool::m_extendedListOfHoles {this, "ExtendedListOfHoles", false}
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

IntegerProperty InDet::InDetTrackHoleSearchTool::m_minSiHits {this, "minSiHits", 3}
private

Min number of hits.

Definition at line 131 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 138 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:711
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:50
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
InDet::InDetTrackHoleSearchTool::m_cosmic
BooleanProperty m_cosmic
Definition: InDetTrackHoleSearchTool.h:128
Trk::Surface::associatedDetectorElement
const TrkDetElementBase * associatedDetectorElement() const
return associated Detector Element
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:138
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::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
xAOD::JetInput::Track
@ Track
Definition: JetContainerInfo.h:61
InDet::InDetTrackHoleSearchTool::m_extendedListOfHoles
BooleanProperty m_extendedListOfHoles
Configure outwards hole search.
Definition: InDetTrackHoleSearchTool.h:127
skel.it
it
Definition: skel.GENtoEVGEN.py:396
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
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
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
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
id2
HWIdentifier id2
Definition: LArRodBlockPhysicsV0.cxx:562
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
beamspotman.n
n
Definition: beamspotman.py:731
Trk::theta
@ theta
Definition: ParamDefs.h:66
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:165
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:227
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
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:116
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:97
InDet::InDetTrackHoleSearchTool::m_minSiHits
IntegerProperty m_minSiHits
Min number of hits.
Definition: InDetTrackHoleSearchTool.h:131
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:555
a
TList * a
Definition: liststreamerinfos.cxx:10
h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
InDet::InDetTrackHoleSearchTool::m_countDeadModulesAfterLastHit
BooleanProperty m_countDeadModulesAfterLastHit
Definition: InDetTrackHoleSearchTool.h:135
DeMoScan.first
bool first
Definition: DeMoScan.py:536
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:67
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
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
InDet::InDetTrackHoleSearchTool::m_atlasId
const AtlasDetectorID * m_atlasId
ID pixel helper.
Definition: InDetTrackHoleSearchTool.h:110
Trk::tubeOuterCover
@ tubeOuterCover
Definition: BoundarySurfaceFace.h:40
Trk::SurfaceType::Plane
@ Plane
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
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:703
Trk::Volume
Definition: Volume.h:35
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
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
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Sun Dec 22 2024 22:00:39 for ATLAS Offline Software by   doxygen 1.8.18