ATLAS Offline Software
Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
DerivationFramework::TrackStateOnSurfaceDecorator Class Reference

#include <TrackStateOnSurfaceDecorator.h>

Inheritance diagram for DerivationFramework::TrackStateOnSurfaceDecorator:
Collaboration diagram for DerivationFramework::TrackStateOnSurfaceDecorator:

Public Member Functions

 TrackStateOnSurfaceDecorator (const std::string &t, const std::string &n, const IInterface *p)
 
StatusCode initialize ()
 
StatusCode finalize ()
 
virtual StatusCode addBranches () const
 

Private Types

enum  ETRTFloatDecor {
  kTRTdEdxDecor, kTRTusedHitsDecor, kTRTdEdx_noHT_divByLDecor, kTRTusedHits_noHT_divByLDecor,
  kNTRTFloatDecor
}
 
enum  EPixFloatDecorKeys {
  kTrkIBLXDecor, kTrkIBLYDecor, kTrkIBLZDecor, kTrkBLXDecor,
  kTrkBLYDecor, kTrkBLZDecor, kTrkL1XDecor, kTrkL1YDecor,
  kTrkL1ZDecor, kTrkL2XDecor, kTrkL2YDecor, kTrkL2ZDecor,
  kNPixFloatDecor
}
 

Private Member Functions

ElementLink< xAOD::TrackMeasurementValidationContainer > buildElementLink (const Trk::PrepRawData *, const std::vector< unsigned int > *, const xAOD::TrackMeasurementValidationContainer *) const
 

Private Attributes

bool m_isSimulation
 
bool m_storeHoles
 
bool m_storeOutliers
 
bool m_storeTRT
 
bool m_storeSCT
 
bool m_storePixel
 
bool m_addPulls
 
bool m_addSurfaceInfo
 
bool m_addPRD
 
bool m_addExtraEventInfo
 
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey { this, "EventInfoKey", "EventInfo", "" }
 
Gaudi::Property< std::string > m_sgName { this, "DecorationPrefix", "IDDET1_",""}
 
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_containerName { this, "ContainerName", "InDetTrackParticles", "" }
 
SG::ReadHandleKey< ComTime > m_trtPhaseKey { this,"TRTPhaseKey","TRT_Phase", ""}
 
StringProperty m_selectionString { this, "SelectionString", "", "track selections"}
 
SG::ReadHandleKey< std::vector< unsigned int > > m_pixelMapName { this, "PixelMapName", "PixelClustersOffsets" , ""}
 
SG::ReadHandleKey< std::vector< unsigned int > > m_sctMapName { this, "SctMapName", "SCT_ClustersOffsets" , ""}
 
SG::ReadHandleKey< std::vector< unsigned int > > m_trtMapName { this, "TrtMapName", "TRT_DriftCirclesOffsets" , ""}
 
SG::ReadHandleKey< xAOD::TrackMeasurementValidationContainer > m_pixelClustersName {this, "PixelClustersName", "PixelClusters" ,"" }
 
SG::ReadHandleKey< xAOD::TrackMeasurementValidationContainer > m_sctClustersName {this, "SctClustersName", "SCT_Clusters" ,"" }
 
SG::ReadHandleKey< xAOD::TrackMeasurementValidationContainer > m_trtDCName {this, "TrtDriftCirclesName", "TRT_DriftCircles" ,"" }
 
SG::ReadHandleKey< Trk::PRDtoTrackMap > m_prdToTrackMap { this,"PRDtoTrackMap","","option PRD-to-track association"}
 
SG::WriteHandleKey< xAOD::TrackStateValidationContainer > m_pixelMsosName { this, "PixelMsosName", "PixelMSOSs", "" }
 
SG::WriteHandleKey< xAOD::TrackStateValidationContainer > m_sctMsosName { this, "SctMsosName", "SCT_MSOSs", "" }
 
SG::WriteHandleKey< xAOD::TrackStateValidationContainer > m_trtMsosName { this, "TrtMsosName", "TRT_MSOSs", ""}
 
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
 
const AtlasDetectorID * m_idHelper
 
const PixelID * m_pixId
 
const SCT_ID * m_sctId
 
const TRT_ID * m_trtId
 
ToolHandle< Trk::IUpdator > m_updator
 
ToolHandle< Trk::IResidualPullCalculator > m_residualPullCalculator
 
ToolHandle< Trk::ITrackHoleSearchTool > m_holeSearchTool
 
ToolHandle< Trk::IExtrapolator > m_extrapolator
 
ToolHandle< ITRT_CalDbTool > m_trtcaldbTool
 
ToolHandle< ITRT_ToT_dEdx > m_TRTdEdxTool
 
std::vector< SG::WriteDecorHandleKey< xAOD::EventInfo > > m_trtPhaseDecorKey
 
std::vector< SG::WriteDecorHandleKey< xAOD::TrackParticleContainer > > m_trackTRTFloatDecorKeys
 
std::vector< SG::WriteDecorHandleKey< xAOD::TrackParticleContainer > > m_trackPixFloatDecorKeys
 
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer > m_trackTSOSMOSLinkDecorKey
 
Gaudi::Property< std::vector< float > > m_pixelLayerRadii {this, "PixelLayerRadii", {29.5,50.5,88.5,122.5}, "Radii to extrapolate to for estimating track position on layers" }
 

Detailed Description

Definition at line 54 of file TrackStateOnSurfaceDecorator.h.

Member Enumeration Documentation

◆ EPixFloatDecorKeys

enum DerivationFramework::TrackStateOnSurfaceDecorator::EPixFloatDecorKeys
private
Enumerator
kTrkIBLXDecor 
kTrkIBLYDecor 
kTrkIBLZDecor 
kTrkBLXDecor 
kTrkBLYDecor 
kTrkBLZDecor 
kTrkL1XDecor 
kTrkL1YDecor 
kTrkL1ZDecor 
kTrkL2XDecor 
kTrkL2YDecor 
kTrkL2ZDecor 
kNPixFloatDecor 

Definition at line 145 of file TrackStateOnSurfaceDecorator.h.

145  {kTrkIBLXDecor, kTrkIBLYDecor, kTrkIBLZDecor,
146  kTrkBLXDecor, kTrkBLYDecor, kTrkBLZDecor,
147  kTrkL1XDecor, kTrkL1YDecor, kTrkL1ZDecor,
148  kTrkL2XDecor, kTrkL2YDecor, kTrkL2ZDecor,
149  kNPixFloatDecor };

◆ ETRTFloatDecor

enum DerivationFramework::TrackStateOnSurfaceDecorator::ETRTFloatDecor
private
Enumerator
kTRTdEdxDecor 
kTRTusedHitsDecor 
kTRTdEdx_noHT_divByLDecor 
kTRTusedHits_noHT_divByLDecor 
kNTRTFloatDecor 

Definition at line 139 of file TrackStateOnSurfaceDecorator.h.

139  {kTRTdEdxDecor,
140  kTRTusedHitsDecor,
141  kTRTdEdx_noHT_divByLDecor,
142  kTRTusedHits_noHT_divByLDecor,
143  kNTRTFloatDecor};

Constructor & Destructor Documentation

◆ TrackStateOnSurfaceDecorator()

DerivationFramework::TrackStateOnSurfaceDecorator::TrackStateOnSurfaceDecorator ( const std::string &  t,
const std::string &  n,
const IInterface *  p 
)

Definition at line 65 of file TrackStateOnSurfaceDecorator.cxx.

67  :
68  base_class(t, n, p),
69  m_idHelper(nullptr),
70  m_pixId(nullptr),
71  m_sctId(nullptr),
72  m_trtId(nullptr),
73  m_updator("Trk::KalmanUpdator"),
74  m_residualPullCalculator("Trk::ResidualPullCalculator/ResidualPullCalculator"),
75  m_holeSearchTool("InDet::InDetTrackHoleSearchTool/InDetHoleSearchTool"),
76  m_extrapolator("Trk::Extrapolator/AtlasExtrapolator"),
77  m_trtcaldbTool("TRT_CalDbTool",this),
78  m_TRTdEdxTool("InDet::TRT_ElectronPidTools/TRT_ToT_dEdx")
79  {
80  // --- Steering and configuration flags
81  declareProperty("IsSimulation", m_isSimulation=true);
82 
83  declareProperty("StoreHoles", m_storeHoles =true);
84  declareProperty("StoreOutliers", m_storeOutliers = true);
85  declareProperty("StoreTRT", m_storeTRT =false);
86  declareProperty("StoreSCT", m_storeSCT = true);
87  declareProperty("StorePixel", m_storePixel =true);
88  declareProperty("AddPulls", m_addPulls =true);
89  declareProperty("AddSurfaceInfo", m_addSurfaceInfo =true);
90  declareProperty("AddPRD", m_addPRD =true);
91  declareProperty("AddExtraEventInfo", m_addExtraEventInfo=true);
92 
93  // -- Tools
94  declareProperty("Updator", m_updator);
95  declareProperty("ResidualPullCalculator", m_residualPullCalculator);
96  declareProperty("HoleSearch", m_holeSearchTool);
97  declareProperty("TRT_CalDbTool", m_trtcaldbTool);
98  declareProperty("TRT_ToT_dEdx", m_TRTdEdxTool);
99  declareProperty("TrackExtrapolator", m_extrapolator);
100  }

Member Function Documentation

◆ addBranches()

StatusCode DerivationFramework::TrackStateOnSurfaceDecorator::addBranches ( ) const
virtual

Definition at line 220 of file TrackStateOnSurfaceDecorator.cxx.

221  {
222  const EventContext& ctx = Gaudi::Hive::currentContext();
223  ATH_MSG_DEBUG("Adding TSOS decorations the track particles");
224 
225  SG::WriteDecorHandle<xAOD::TrackParticleContainer,std::vector< ElementLink< xAOD::TrackStateValidationContainer > > > dectsos_msosLink(m_trackTSOSMOSLinkDecorKey);
226 
227  // --- Retrieve track container (absolutely needed for decoration)
228  SG::ReadHandle<xAOD::TrackParticleContainer> tracks(m_containerName,ctx);
229  if( ! tracks.isValid() ) {
230  ATH_MSG_ERROR ("Couldn't retrieve TrackParticles with key: " << m_containerName.key() );
231  return StatusCode::FAILURE;
232  }
233  size_t nTracks = tracks->size();
234 
235 
236  SG::ReadHandle<std::vector<unsigned int> > pixelClusterOffsets;
237  SG::ReadHandle<std::vector<unsigned int> > sctClusterOffsets;
238  SG::ReadHandle<std::vector<unsigned int> > trtDCOffsets;
239 
240  SG::ReadHandle<xAOD::TrackMeasurementValidationContainer> pixelClusters;
241  SG::ReadHandle<xAOD::TrackMeasurementValidationContainer> sctClusters;
242  SG::ReadHandle<xAOD::TrackMeasurementValidationContainer> trtDCs;
243 
244 
245  // Create the xAOD container and its auxiliary store
246  SG::WriteHandle<xAOD::TrackStateValidationContainer> msosPixel;
247  SG::WriteHandle<xAOD::TrackStateValidationContainer> msosSCT;
248  SG::WriteHandle<xAOD::TrackStateValidationContainer> msosTRT;
249 
250  int nPixelMSOS(0);
251  int nSCT_MSOS(0);
252  int nTRT_MSOS(0);
253 
254  // --- Add event-level information
255  if (m_addExtraEventInfo) {
256  ATH_MSG_DEBUG("Adding EventInfo decorations");
257  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey,ctx);
258  if (!eventInfo.isValid()) {
259  ATH_MSG_ERROR(" Cannot access to event info.");
260  return StatusCode::FAILURE;
261  }
262 
263  //Add TRT event phase
264  SG::ReadHandle<ComTime> trtPhase(m_trtPhaseKey, ctx);
265  float trtPhase_time=0.;
266  if (!trtPhase.isValid()) {
267  ATH_MSG_DEBUG("Failed to retrieve TRT phase information.");
268  } else {
269  trtPhase_time = trtPhase->getTime();
270  } //TRT phase
271  SG::WriteDecorHandle<xAOD::EventInfo,float> decorTRTPhase(*(m_trtPhaseDecorKey.begin()),ctx);
272  decorTRTPhase(*eventInfo) = trtPhase_time;
273  } //extra event info
274 
275  // --- Add track states containers
276  if(m_addPRD){
277  // Get clusters and the mapping between xAOD::PRD and Trk::PRD
278  // Store the MSOS's in a conatiner based on the type of the detector
279  if(m_storePixel){
280  ATH_MSG_DEBUG("Creating Pixel track state container");
281  pixelClusterOffsets=SG::ReadHandle<std::vector<unsigned int> >(m_pixelMapName,ctx);
282  pixelClusters=SG::ReadHandle<xAOD::TrackMeasurementValidationContainer >(m_pixelClustersName,ctx);
283 
284  msosPixel = SG::WriteHandle<xAOD::TrackStateValidationContainer>(m_pixelMsosName,ctx);
285  if (msosPixel.record(std::make_unique<xAOD::TrackStateValidationContainer>(),
286  std::make_unique<xAOD::TrackStateValidationAuxContainer>()).isFailure()) {
287  ATH_MSG_ERROR("Failed to record " << m_pixelMsosName.key() );
288  return StatusCode::FAILURE;
289  }
290  }
291  if(m_storeSCT){
292  ATH_MSG_DEBUG("Creating SCT track state container");
293  sctClusterOffsets=SG::ReadHandle<std::vector<unsigned int> >(m_sctMapName,ctx);
294  sctClusters=SG::ReadHandle<xAOD::TrackMeasurementValidationContainer >(m_sctClustersName,ctx);
295 
296  msosSCT = SG::WriteHandle<xAOD::TrackStateValidationContainer>(m_sctMsosName,ctx);
297  if (msosSCT.record(std::make_unique<xAOD::TrackStateValidationContainer>(),
298  std::make_unique<xAOD::TrackStateValidationAuxContainer>()).isFailure()) {
299  ATH_MSG_ERROR("Failed to record " << m_sctMsosName.key() );
300  return StatusCode::FAILURE;
301  }
302  }
303  if(m_storeTRT){
304  ATH_MSG_DEBUG("Creating TRT track state container");
305  trtDCOffsets=SG::ReadHandle<std::vector<unsigned int> >(m_trtMapName,ctx);
306  trtDCs=SG::ReadHandle<xAOD::TrackMeasurementValidationContainer >(m_trtDCName,ctx);
307 
308  msosTRT = SG::WriteHandle<xAOD::TrackStateValidationContainer>(m_trtMsosName,ctx);
309  if (msosTRT.record(std::make_unique<xAOD::TrackStateValidationContainer>(),
310  std::make_unique<xAOD::TrackStateValidationAuxContainer>()).isFailure()) {
311  ATH_MSG_ERROR("Failed to record " << m_trtMsosName.key() );
312  return StatusCode::FAILURE;
313  }
314  }
315  }
316 
317  SG::ReadHandle<Trk::PRDtoTrackMap> prd_to_track_map;
318  const Trk::PRDtoTrackMap *prd_to_track_map_cptr = nullptr;
319  if (!m_prdToTrackMap.key().empty()) {
320  prd_to_track_map=SG::ReadHandle<Trk::PRDtoTrackMap>(m_prdToTrackMap);
321  if (!prd_to_track_map.isValid()) {
322  ATH_MSG_ERROR("Failed to read PRD to track association map: " << m_prdToTrackMap.key());
323  }
324  prd_to_track_map_cptr = prd_to_track_map.cptr();
325  }
326 
327  // Set up a mask with the same entries as the full TrackParticle collection
328  std::vector<bool> mask;
329  mask.assign(nTracks,true); // default: keep all the tracks
330  if (m_parser) {
331  std::vector<int> entries = m_parser->evaluateAsVector();
332  unsigned int nEntries = entries.size();
333  // check the sizes are compatible
334  if (nTracks != nEntries ) {
335  ATH_MSG_ERROR("Sizes incompatible! Are you sure your selection string used ID TrackParticles?");
336  return StatusCode::FAILURE;
337  } else {
338  // set mask
339  for (unsigned int i=0; i<nTracks; ++i) if (entries[i]!=1) mask[i]=false;
340  }
341  }
342 
343  std::vector<SG::WriteDecorHandle<xAOD::TrackParticleContainer,float> > trackTRTFloatDecorators;
344  if (m_storeTRT && m_TRTdEdxTool.isEnabled()) {
345  trackTRTFloatDecorators = createDecorators<xAOD::TrackParticleContainer,float>(m_trackTRTFloatDecorKeys,ctx);
346  }
347  std::vector<SG::WriteDecorHandle<xAOD::TrackParticleContainer,float> >
348  trackPixFloatDecorators = createDecorators<xAOD::TrackParticleContainer,float>(m_trackPixFloatDecorKeys,ctx);
349  // -- Run over each track and decorate it
350  unsigned i_track = 0;
351  for (const auto *const track : *tracks) {
352  //-- Start with things that do not need a Trk::Track object
353 
354  // mask bit check
355  if(!mask[i_track]) {
356  ++i_track;
357  continue;
358  }
359 
360  // -- Now things that require a Trk::Track object
361  if( !track->trackLink().isValid() || track->track() == nullptr ) {
362  ATH_MSG_WARNING("Track particle without Trk::Track");
363  continue;
364  }
365  ATH_MSG_DEBUG("We have a Trk::Track");
366 
367  // We now have a valid Trk::Track
368  const Trk::Track* trkTrack = track->track();
369 
370  // This is the vector in which we will store the element links to the MSOS's
371  std::vector< ElementLink< xAOD::TrackStateValidationContainer > > msosLink;
372 
373  if ( m_storeTRT && m_TRTdEdxTool.isEnabled() ) {
374  // for dEdx studies
375  trackTRTFloatDecorators[kTRTdEdxDecor] (*track) = m_TRTdEdxTool->dEdx(trkTrack,true);
376  trackTRTFloatDecorators[kTRTusedHitsDecor] (*track) = m_TRTdEdxTool->usedHits(trkTrack);
377  trackTRTFloatDecorators[kTRTdEdx_noHT_divByLDecor] (*track) = m_TRTdEdxTool->dEdx(trkTrack, false);
378  trackTRTFloatDecorators[kTRTusedHits_noHT_divByLDecor] (*track) = m_TRTdEdxTool->usedHits(trkTrack, false);
379  }
380 
381  if(m_storePixel){
382  if ( trkTrack->perigeeParameters() ){
383 
384  if(m_pixelLayerRadii.size() < 4) ATH_MSG_WARNING("Too few layer radii set! Should be at least 4!");
385 
386  Trk::CylinderSurface cylSurfIBL(m_pixelLayerRadii[0], 3000.0);
387  Trk::CylinderSurface cylSurfBL(m_pixelLayerRadii[1], 3000.0);
388  Trk::CylinderSurface cylSurfL1(m_pixelLayerRadii[2], 3000.0);
389  Trk::CylinderSurface cylSurfL2(m_pixelLayerRadii[3], 3000.0);
390 
391  bool allExtrapolationsSucceded = true;
392  Trk::PropDirection whichDir = Trk::alongMomentum;
393  Trk::MaterialUpdateMode whichMode = Trk::removeNoise;
394  //check the radius of the start parameters, to see which direction we need to go to the target surface
395  float startRadius = trkTrack->perigeeParameters()->associatedSurface().center().perp();
396  ATH_MSG_VERBOSE("Start radius for extrapolating to layers: "<<startRadius);
397  //see if we go along or opposite momentum
398  if(startRadius>m_pixelLayerRadii[0]) {whichDir = Trk::oppositeMomentum; whichMode = Trk::addNoise;}
399  std::unique_ptr<const Trk::TrackParameters> outputParamsIBL
400  (m_extrapolator->extrapolate(ctx,
401  *(trkTrack->perigeeParameters()),
402  cylSurfIBL,
403  whichDir,
404  true,
405  Trk::pion,
406  whichMode));
407  if(startRadius>m_pixelLayerRadii[1]){
408  whichDir = Trk::oppositeMomentum;
409  whichMode = Trk::addNoise;
410  }
411  std::unique_ptr<const Trk::TrackParameters> outputParamsBL
412  (m_extrapolator->extrapolate(ctx,
413  *(trkTrack->perigeeParameters()),
414  cylSurfBL,
415  whichDir,
416  true,
417  Trk::pion,
418  whichMode));
419  if(startRadius>m_pixelLayerRadii[2]){
420  whichDir = Trk::oppositeMomentum;
421  whichMode = Trk::addNoise;
422  }
423  std::unique_ptr<const Trk::TrackParameters> outputParamsL1
424  (m_extrapolator->extrapolate(ctx,
425  *(trkTrack->perigeeParameters()),
426  cylSurfL1,
427  whichDir,
428  true,
429  Trk::pion,
430  whichMode));
431  if(startRadius>m_pixelLayerRadii[2]){
432  whichDir = Trk::oppositeMomentum;
433  whichMode = Trk::addNoise;
434  }
435  std::unique_ptr<const Trk::TrackParameters> outputParamsL2
436  (m_extrapolator->extrapolate(ctx,
437  *(trkTrack->perigeeParameters()),
438  cylSurfL2,
439  whichDir,
440  true,
441  Trk::pion,
442  whichMode));
443 
444  if (outputParamsIBL.get()) {
445  trackPixFloatDecorators[kTrkIBLXDecor](*track) = outputParamsIBL->position().x();
446  trackPixFloatDecorators[kTrkIBLYDecor](*track) = outputParamsIBL->position().y();
447  trackPixFloatDecorators[kTrkIBLZDecor](*track) = outputParamsIBL->position().z();
448  }
449  else {
450  allExtrapolationsSucceded = false;
451  ATH_MSG_VERBOSE("Extrapolation to IBL failed...");
452  trackPixFloatDecorators[kTrkIBLXDecor](*track) = 0.0;
453  trackPixFloatDecorators[kTrkIBLYDecor](*track) = 0.0;
454  trackPixFloatDecorators[kTrkIBLZDecor](*track) = 0.0;
455  }
456 
457  if (outputParamsBL.get()) {
458  trackPixFloatDecorators[kTrkBLXDecor](*track) = outputParamsBL->position().x();
459  trackPixFloatDecorators[kTrkBLYDecor](*track) = outputParamsBL->position().y();
460  trackPixFloatDecorators[kTrkBLZDecor](*track) = outputParamsBL->position().z();
461  }
462  else {
463  allExtrapolationsSucceded = false;
464  ATH_MSG_VERBOSE("Extrapolation to BLayer failed...");
465  trackPixFloatDecorators[kTrkBLXDecor](*track) = 0.0;
466  trackPixFloatDecorators[kTrkBLYDecor](*track) = 0.0;
467  trackPixFloatDecorators[kTrkBLZDecor](*track) = 0.0;
468  }
469 
470  if (outputParamsL1.get()) {
471  trackPixFloatDecorators[kTrkL1XDecor](*track) = outputParamsL1->position().x();
472  trackPixFloatDecorators[kTrkL1YDecor](*track) = outputParamsL1->position().y();
473  trackPixFloatDecorators[kTrkL1ZDecor](*track) = outputParamsL1->position().z();
474  }
475  else {
476  allExtrapolationsSucceded = false;
477  ATH_MSG_VERBOSE("Extrapolation to L1 failed...");
478  trackPixFloatDecorators[kTrkL1XDecor](*track) = 0.0;
479  trackPixFloatDecorators[kTrkL1YDecor](*track) = 0.0;
480  trackPixFloatDecorators[kTrkL1ZDecor](*track) = 0.0;
481  }
482 
483  if (outputParamsL2.get()) {
484  trackPixFloatDecorators[kTrkL2XDecor](*track) = outputParamsL2->position().x();
485  trackPixFloatDecorators[kTrkL2YDecor](*track) = outputParamsL2->position().y();
486  trackPixFloatDecorators[kTrkL2ZDecor](*track) = outputParamsL2->position().z();
487  }
488  else {
489  allExtrapolationsSucceded = false;
490  ATH_MSG_VERBOSE("Extrapolation to L2 failed...");
491  trackPixFloatDecorators[kTrkL2XDecor](*track) = 0.0;
492  trackPixFloatDecorators[kTrkL2YDecor](*track) = 0.0;
493  trackPixFloatDecorators[kTrkL2ZDecor](*track) = 0.0;
494  }
495  if(!allExtrapolationsSucceded) ATH_MSG_WARNING("At least one extrapolation to a Pixel layer failed!");
496  }
497  else{
498  ATH_MSG_WARNING("No perigee TrackParameters found - filling positions on layers to (0,0,0)!");
499  //should decorate nonetheless, to make sure decorations are consistent across events
500  trackPixFloatDecorators[kTrkIBLXDecor](*track) = 0.0;
501  trackPixFloatDecorators[kTrkIBLYDecor](*track) = 0.0;
502  trackPixFloatDecorators[kTrkIBLZDecor](*track) = 0.0;
503  trackPixFloatDecorators[kTrkBLXDecor](*track) = 0.0;
504  trackPixFloatDecorators[kTrkBLYDecor](*track) = 0.0;
505  trackPixFloatDecorators[kTrkBLZDecor](*track) = 0.0;
506  trackPixFloatDecorators[kTrkL1XDecor](*track) = 0.0;
507  trackPixFloatDecorators[kTrkL1YDecor](*track) = 0.0;
508  trackPixFloatDecorators[kTrkL1ZDecor](*track) = 0.0;
509  trackPixFloatDecorators[kTrkL2XDecor](*track) = 0.0;
510  trackPixFloatDecorators[kTrkL2YDecor](*track) = 0.0;
511  trackPixFloatDecorators[kTrkL2ZDecor](*track) = 0.0;
512  }
513  }
514 
515  // -- Add Track states to the current track, filtering on their type
516  std::vector<const Trk::TrackStateOnSurface*> tsoss;
517  for (const auto *const trackState: *(trkTrack->trackStateOnSurfaces())){
518  //Get rid of any holes that already exist -- we are doing the search again
519  if( trackState->types()[Trk::TrackStateOnSurface::Hole] )
520  continue;
521  tsoss.push_back(trackState);
522  }
523 
524  std::unique_ptr<const Trk::TrackStates> holes;
525  if(m_storeHoles){
526  holes = std::unique_ptr<const Trk::TrackStates>( m_holeSearchTool->getHolesOnTrack(*trkTrack, trkTrack->info().particleHypothesis()) );
527  for (const auto *hole: *holes){
528  tsoss.push_back(hole);
529  }
530  if(trkTrack->perigeeParameters()){
531  Trk::TrackStateOnSurfaceComparisonFunction CompFunc( trkTrack->perigeeParameters()->momentum() );
532  stable_sort( tsoss.begin(), tsoss.end(), CompFunc );
533  } else {
534  ATH_MSG_ERROR("Track has no perigee parameters");
535  }
536  }
537 
538  //Loop over the TrkStateOnSurfaces
539  for (const auto& trackState: tsoss){
540 
541  //Only store Holes, Measurement & Outliers
542  if( !trackState->types()[Trk::TrackStateOnSurface::Hole] &&
543  !trackState->types()[Trk::TrackStateOnSurface::Measurement] &&
544  !trackState->types()[Trk::TrackStateOnSurface::Outlier] ) {
545  continue;
546  }
547 
548  // Check if we want to store this types of TSOS
549  if(!m_storeOutliers && trackState->types()[Trk::TrackStateOnSurface::Outlier] )
550  continue;
551 
552 
553  if(!m_storeHoles && trackState->types()[Trk::TrackStateOnSurface::Hole] )
554  continue;
555 
556  // Check that the surface has detector element
557  if(!trackState->surface().associatedDetectorElement()){
558  continue;
559  }
560 
561  // Check that the surface ID is valid
562  Identifier surfaceID = trackState->surface().associatedDetectorElement()->identify();
563  if( !surfaceID.is_valid() ){
564  ATH_MSG_WARNING("Invalid surface ID");
565  continue;
566  }
567 
568  //Determine what detector the hit is in
569  bool isPixel(false);
570  bool isSCT(false);
571  bool isTRT(false);
572 
573  if( m_idHelper->is_trt(surfaceID) ){
574  isTRT = true;
575  if(!m_storeTRT)
576  continue;
577  }else if( m_idHelper->is_sct(surfaceID) ){
578  isSCT = true;
579  if(!m_storeSCT)
580  continue;
581  }else if( m_idHelper->is_pixel(surfaceID) ){
582  isPixel = true;
583  if(!m_storePixel)
584  continue;
585  }
586 
587  if( !isPixel && !isSCT && !isTRT ){
588  continue;
589  }
590 
591  //Create new MSOS to fill with information
592  xAOD::TrackStateValidation* msos = new xAOD::TrackStateValidation();
593 
594  //Put it in the obeject in the correct conatiner - one for each detector type.
595  if(isTRT){
596  //Add the msos to the container
597  msosTRT->push_back( msos );
598  //Set the det id
599  msos->setDetType( Trk::TrackState::TRT );
600  //Build the element link to the MSOS
601  ElementLink< xAOD::TrackStateValidationContainer > elink( *msosTRT, nTRT_MSOS );
602  elink.toPersistent();
603  msosLink.push_back(elink);
604  ++nTRT_MSOS;
605  }else if(isSCT){
606  //Add the msos to the container
607  msosSCT->push_back( msos );
608  //Set the det id
609  msos->setDetType( Trk::TrackState::SCT );
610  //Build the element link to the MSOS
611  ElementLink< xAOD::TrackStateValidationContainer > elink( *msosSCT, nSCT_MSOS );
612  elink.toPersistent();
613  msosLink.push_back(elink);
614  ++nSCT_MSOS;
615  }else if(isPixel){
616  //Add the msos to the container
617  msosPixel->push_back( msos );
618  //Set the det id
619  msos->setDetType( Trk::TrackState::Pixel );
620  //Build the element link to the MSOS
621  ElementLink< xAOD::TrackStateValidationContainer > elink( *msosPixel, nPixelMSOS );
622  elink.toPersistent();
623  msosLink.push_back(elink);
624  ++nPixelMSOS;
625  }
626  else {
627  ATH_MSG_WARNING("NOT a pixel, SCT or TRT track state on surface.");
628  delete msos;
629  continue;
630  }
631 
632  //fill type
633  if( trackState->types()[Trk::TrackStateOnSurface::Hole] ){
634  msos->setType( Trk::TrackStateOnSurface::Hole );
635  } else if (trackState->types()[Trk::TrackStateOnSurface::Measurement]){
636  msos->setType( Trk::TrackStateOnSurface::Measurement );
637  } else if ( trackState->types()[Trk::TrackStateOnSurface::Outlier] ) {
638  msos->setType( Trk::TrackStateOnSurface::Outlier );
639  }
640 
641  //Fill surface id
642  msos->setDetElementId( surfaceID.get_compact() );
643 
644 
645  const Trk::TrackParameters* tp = trackState->trackParameters();
646 
647  // some more detailed hit info
648  double lTheta=-1000., lPhi=-1000.;
649  //Get the measurement base object
650  const Trk::MeasurementBase* measurement=trackState->measurementOnTrack();
651  static const SG::Accessor<float> errDCAcc("errDC");
652  errDCAcc(*msos) = -1 ;
653  const Trk::RIO_OnTrack* rotp = dynamic_cast<const Trk::RIO_OnTrack*>(measurement) ;
654  if (rotp) errDCAcc(*msos) = sqrt(rotp->localCovariance()(Trk::driftRadius, Trk::driftRadius)) ;
655 
656  if (m_storeTRT) {
657  const InDet::TRT_DriftCircleOnTrack *driftcircle = dynamic_cast<const InDet::TRT_DriftCircleOnTrack*>(measurement);
658  static const SG::Accessor<float> HitZAcc("HitZ");
659  static const SG::Accessor<float> HitRAcc("HitR");
660  static const SG::Accessor<float> rTrkWireAcc("rTrkWire");
661  if (!measurement) {
662  HitZAcc(*msos)=-3000;
663  HitRAcc(*msos)=-1;
664  rTrkWireAcc(*msos)=-1;
665  }
666  else {
667  if (!driftcircle) {
668  HitZAcc(*msos)=-3000;
669  HitRAcc(*msos)=-1;
670  rTrkWireAcc(*msos)=-1;
671  }
672  else {
673  if (tp) {
674  const Amg::Vector3D& gp = driftcircle->globalPosition();
675  HitZAcc(*msos)=gp.z();
676  HitRAcc(*msos)=gp.perp();
677  rTrkWireAcc(*msos)= fabs(trackState->trackParameters()->parameters()[Trk::driftRadius]);
678  lTheta = trackState->trackParameters()->parameters()[Trk::theta];
679  lPhi = trackState->trackParameters()->parameters()[Trk::phi];
680  }
681  else {
682  HitZAcc(*msos) =driftcircle->associatedSurface().center().z();
683  HitRAcc(*msos) =driftcircle->associatedSurface().center().perp();
684  rTrkWireAcc(*msos)=0;
685  }
686  }
687  }
688  msos->setLocalAngles(lTheta, lPhi);
689 
690  bool isShared=false;
691  if (prd_to_track_map_cptr) {
692  const Trk::RIO_OnTrack* hit_trt = measurement ? dynamic_cast<const Trk::RIO_OnTrack*>(measurement) : nullptr;
693  if (hit_trt) {
694  if (prd_to_track_map_cptr->isShared(*(hit_trt->prepRawData())) ) isShared=true;
695  static const SG::Accessor<bool> isSharedAcc("isShared");
696  isSharedAcc(*msos) = isShared;
697  }
698  }
699  }
700 
701  // Track extrapolation
702  std::unique_ptr<const Trk::TrackParameters> extrap( m_extrapolator->extrapolateTrack(ctx,*trkTrack,trackState->surface()) );
703 
704  // Set local positions on the surface
705  if (tp) {
706  msos->setLocalPosition( tp->parameters()[0], tp->parameters()[1] );
707 
708  if (extrap.get()) {
709  ATH_MSG_DEBUG(" Original position " << tp->parameters()[0] << " " << tp->parameters()[1]);
710  ATH_MSG_DEBUG("Extrapolated position " << extrap->parameters()[0] << " " << extrap->parameters()[1]);
711  }
712 
713  }
714  else {
715  if (extrap.get()) {
716  msos->setLocalPosition( extrap->parameters()[0], extrap->parameters()[1] );
717  }
718  else {
719  ATH_MSG_DEBUG("Track extrapolation failed.");
720  }
721  }
722 
723  // Set calculate local incident angles
724  const Trk::TrkDetElementBase *de = trackState->surface().associatedDetectorElement();
725  const InDetDD::SiDetectorElement *side = dynamic_cast<const InDetDD::SiDetectorElement *>(de);
726  if (side && (isSCT || isPixel)) {
727  const Amg::Vector3D& mynormal = side->normal();
728  const Amg::Vector3D& myphiax = side->phiAxis();
729  const Amg::Vector3D& myetaax = side->etaAxis();
730  if (tp) {
731  Amg::Vector3D mytrack = tp->momentum();
732  float trketacomp = mytrack.dot(myetaax);
733  float trkphicomp = mytrack.dot(myphiax);
734  float trknormcomp = mytrack.dot(mynormal);
735 
736  ATH_MSG_DEBUG(" Original incident angle " << trketacomp << " " << trkphicomp << " " << trknormcomp);
737  if (extrap.get()) {
738  Amg::Vector3D metrack = extrap->momentum();
739  float trketacompX = metrack.dot(myetaax);
740  float trkphicompX = metrack.dot(myphiax);
741  float trknormcompX = metrack.dot(mynormal);
742  ATH_MSG_DEBUG("Extrapolated incident angle " << trketacompX << " " << trkphicompX << " " << trknormcompX);
743  }
744  msos->setLocalAngles( atan2(trketacomp,trknormcomp), atan2(trkphicomp,trknormcomp) );
745  }
746  else {
747  if (extrap.get()) {
748  Amg::Vector3D metrack = extrap->momentum();
749  float trketacompX = metrack.dot(myetaax);
750  float trkphicompX = metrack.dot(myphiax);
751  float trknormcompX = metrack.dot(mynormal);
752  msos->setLocalAngles( atan2(trketacompX,trknormcompX), atan2(trkphicompX,trknormcompX) );
753  }
754  }
755  }
756 
757  if(!measurement) { continue; }
758 
759  if (isTRT && !trtDCOffsets.isValid() && !trtDCs.isValid()) { continue; }
760  if (isSCT && !sctClusterOffsets.isValid() && !sctClusters.isValid()) { continue; }
761  if (isPixel && !pixelClusterOffsets.isValid() && !pixelClusters.isValid()) { continue; }
762 
763  const Trk::RIO_OnTrack* hit = measurement ? dynamic_cast<const Trk::RIO_OnTrack*>(measurement) : nullptr;
764 
765  if(!hit){
766  const Trk::CompetingRIOsOnTrack *crot = dynamic_cast<const Trk::CompetingRIOsOnTrack*>(measurement);
767  if(crot){
768  hit = &crot->rioOnTrack( crot->indexOfMaxAssignProb() );
769  }
770  }
771 
772  if(m_addPRD && hit){
773  // Build an element link to the xAOD PRD
774  const Trk::PrepRawData* prd = hit->prepRawData();
775  if(prd && prd->getHashAndIndex().isValid() ){
776  if(isTRT){
777  msos->setTrackMeasurementValidationLink( buildElementLink( prd, trtDCOffsets.cptr(), trtDCs.cptr()) );
778  }else if(isSCT){
779  msos->setTrackMeasurementValidationLink( buildElementLink( prd, sctClusterOffsets.cptr(), sctClusters.cptr()) );
780  }else if(isPixel){
781  msos->setTrackMeasurementValidationLink( buildElementLink( prd, pixelClusterOffsets.cptr(), pixelClusters.cptr()) );
782  }
783  }
784  }
785 
786  if (m_storeSCT && isSCT) {
787  // We use accessors because the aux variable is added directly in the TrackMeasurementValidation cluster producer
788  // and we are decorating the MSOS in the TrackStateValidationContainer producer here
789  static const SG::Accessor<int> SiWidthAcc("SiWidth");
790  static const SG::Accessor<int> firstStripAcc("first_strip");
791  static const SG::Accessor<std::vector<int>> rdoStripAcc("rdo_strip");
792 
793  if( msos->trackMeasurementValidationLink().isValid() && *(msos->trackMeasurementValidationLink()) ){
794  const xAOD::TrackMeasurementValidation* sctCluster = *(msos->trackMeasurementValidationLink());
795  SiWidthAcc(*msos) = SiWidthAcc(*sctCluster);
796  firstStripAcc(*msos) = (rdoStripAcc(*sctCluster)).at(0);
797  } else {
798  SiWidthAcc(*msos) = -1;
799  firstStripAcc(*msos) = -1;
800  }
801  }
802 
803  // Add the drift time for the tracks position -- note the position is biased
804  if (isTRT) {
805  TRTCond::RtRelation const *rtr = m_trtcaldbTool->getRtRelation(surfaceID);
806  if(rtr) {
807  static const SG::Accessor<float> driftTimeAcc("driftTime");
808  if (tp){
809  driftTimeAcc(*msos) = rtr->drifttime(fabs(tp->parameters()[0]));
810  }
811  else {
812  if (extrap.get()) {
813  driftTimeAcc(*msos) = rtr->drifttime(fabs(extrap->parameters()[0]));
814  }
815  }
816  }
817  }
818 
819  static const SG::Accessor<float> TrackError_biasedAcc("TrackError_biased");
820  static const SG::Accessor<float> TrackError_unbiasedAcc("TrackError_unbiased");
821  if (m_addPulls) {
822 
823  std::optional<Trk::ResidualPull> biased;
824  std::optional<Trk::ResidualPull> unbiased;
825  if (tp) {
826  biased= m_residualPullCalculator->residualPull(measurement, tp, Trk::ResidualPull::Biased);
827  if (m_storeTRT) TrackError_biasedAcc(*msos) = sqrt(fabs((*tp->covariance())(Trk::locX,Trk::locX)));
828 
829  if (m_storeTRT) TrackError_biasedAcc(*msos) = sqrt(fabs((*tp->covariance())(Trk::locX,Trk::locX)));
830  std::unique_ptr<const Trk::TrackParameters> unbiasedTp( m_updator->removeFromState(*tp, measurement->localParameters(), measurement->localCovariance()) );
831  if(unbiasedTp.get()) {
832  if (m_storeTRT) TrackError_unbiasedAcc(*msos) = sqrt(fabs((*unbiasedTp.get()->covariance())(Trk::locX,Trk::locX)));
833  unbiased = m_residualPullCalculator->residualPull(measurement, unbiasedTp.get(), Trk::ResidualPull::Unbiased);
834  }
835  }
836  else {
837  if (extrap.get()) {
838  if (m_storeTRT) TrackError_unbiasedAcc(*msos) = sqrt(fabs((*extrap.get()->covariance())(Trk::locX,Trk::locX)));
839  biased = m_residualPullCalculator->residualPull(measurement, extrap.get(), Trk::ResidualPull::Biased);
840  unbiased = m_residualPullCalculator->residualPull(measurement, extrap.get(), Trk::ResidualPull::Unbiased);
841  }
842  }
843 
844  if (biased) {
845  if(biased->dimension()>Trk::locY){
846  msos->setBiasedResidual( biased->residual()[Trk::locX], biased->residual()[Trk::locY] );
847  msos->setBiasedPull( biased->pull()[Trk::locX], biased->pull()[Trk::locY] );
848  } else {
849  msos->setBiasedResidual( biased->residual()[Trk::locX], 0 );
850  msos->setBiasedPull( biased->pull()[Trk::locX], 0 );
851  }
852  }
853 
854  if (unbiased) {
855  if(unbiased->dimension()>Trk::locY){
856  msos->setUnbiasedResidual( unbiased->residual()[Trk::locX], unbiased->residual()[Trk::locY] );
857  msos->setUnbiasedPull( unbiased->pull()[Trk::locX], unbiased->pull()[Trk::locY] );
858  } else {
859  msos->setUnbiasedResidual( unbiased->residual()[Trk::locX], 0 );
860  msos->setUnbiasedPull( unbiased->pull()[Trk::locX], 0 );
861  }
862  }
863 
864  }
865 
866  } //end loop over TSOS's
867 
868  ATH_MSG_DEBUG("The number of TSOS's " << msosLink.size() );
869 
870  dectsos_msosLink( *track ) = msosLink;
871 
872  ATH_MSG_DEBUG("Finished dressing TrackParticle");
873 
874  ++i_track;
875  } // end of loop over tracks
876 
877  return StatusCode::SUCCESS;
878  }

◆ buildElementLink()

ElementLink< xAOD::TrackMeasurementValidationContainer > DerivationFramework::TrackStateOnSurfaceDecorator::buildElementLink ( const Trk::PrepRawData *  prd,
const std::vector< unsigned int > *  offsets,
const xAOD::TrackMeasurementValidationContainer *  xaodPrdCont 
) const
private

Definition at line 881 of file TrackStateOnSurfaceDecorator.cxx.

884  {
885 
886  const IdentContIndex& contIndex = prd->getHashAndIndex();
887  if( contIndex.collHash() >= offsets->size() ){
888  ATH_MSG_ERROR(" Offsets are incorrect " << contIndex.collHash() << " " << offsets->size() <<" "<< contIndex.objIndex());
889  return {0,0};
890  }
891 
892  unsigned int xaodIndex = offsets->at( contIndex.collHash() ) + contIndex.objIndex();
893  ElementLink< xAOD::TrackMeasurementValidationContainer > el( *xaodPrdCont, xaodIndex );
894  el.toPersistent();
895 
896  return el;
897 
898  }

◆ finalize()

StatusCode DerivationFramework::TrackStateOnSurfaceDecorator::finalize ( )

Definition at line 214 of file TrackStateOnSurfaceDecorator.cxx.

215  {
216  ATH_MSG_DEBUG("Finalize");
217  return StatusCode::SUCCESS;
218  }

◆ initialize()

StatusCode DerivationFramework::TrackStateOnSurfaceDecorator::initialize ( )

Definition at line 102 of file TrackStateOnSurfaceDecorator.cxx.

103  {
104  ATH_MSG_DEBUG("Initialize");
105 
106  if (m_sgName.value() == "notSet") {
107  ATH_MSG_ERROR("No decoration prefix name provided for the output of TrackStateOnSurfaceDecorator! Use the variable DecorationPrefix to properly set a prefix.");
108  return StatusCode::FAILURE;
109  }
110  ATH_MSG_DEBUG("Prefix for decoration: " << m_sgName);
111 
112  ATH_CHECK(m_eventInfoKey.initialize( m_addExtraEventInfo ));
113  if (m_containerName.key().empty()) {
114  ATH_MSG_ERROR("No TrackParticle collection provided for TrackStateOnSurfaceDecorator!");
115  return StatusCode::FAILURE;
116  }
117  ATH_MSG_DEBUG("Input TrackParticle container: " << m_containerName.key());
118  ATH_CHECK( m_containerName.initialize() );
119 
120  if (!m_selectionString.empty()) {
121  ATH_CHECK(initializeParser(m_selectionString));
122  }
123 
124  // need Atlas id-helpers to identify sub-detectors, take them from detStore
125  if (detStore()->retrieve(m_idHelper, "AtlasID").isFailure()) {
126  ATH_MSG_ERROR("Could not get AtlasDetectorID helper");
127  return StatusCode::FAILURE;
128  }
129 
130  if( m_storePixel && detStore()->retrieve(m_pixId,"PixelID").isFailure() ){
131  ATH_MSG_ERROR("Unable to retrieve pixel ID helper");
132  return StatusCode::FAILURE;
133  }
134 
135  if( m_storeSCT && detStore()->retrieve(m_sctId,"SCT_ID").isFailure() ){
136  ATH_MSG_ERROR("Could not retrieve SCT helper");
137  return StatusCode::FAILURE;
138  }
139 
140  if( m_storeTRT && detStore()->retrieve(m_trtId,"TRT_ID").isFailure() ){
141  ATH_MSG_ERROR("Could not retrieve TRT helper");
142  return StatusCode::FAILURE;
143  }
144 
145  ATH_CHECK( m_trtcaldbTool.retrieve(DisableTool{ !m_storeTRT }));
146  ATH_CHECK( m_prdToTrackMap.initialize( !m_prdToTrackMap.key().empty() && m_storeTRT) );
147 
148  ATH_CHECK( m_updator.retrieve(DisableTool{ !m_addPulls }));
149  ATH_CHECK( m_residualPullCalculator.retrieve(DisableTool{ !m_addPulls }));
150 
151  ATH_CHECK( m_holeSearchTool.retrieve( DisableTool{ !m_storeHoles}) );
152 
153  ATH_CHECK( m_TRTdEdxTool.retrieve( DisableTool{!m_storeTRT || m_TRTdEdxTool.empty()}) );
154 
155  ATH_CHECK(m_extrapolator.retrieve());
156 
157 
158  ATH_CHECK( m_SCTDetEleCollKey.initialize( m_storeSCT ));
159 
160  if (m_addExtraEventInfo) {
161  std::vector<std::string> decor_names{"TrtPhaseTime"};
162  std::vector<SG::WriteDecorHandleKey<xAOD::EventInfo> > decor_key_out;
163  createDecoratorKeys(*this,m_eventInfoKey, m_sgName, decor_names,m_trtPhaseDecorKey);
164  assert(m_trtPhaseDecorKey.size() == 1);
165  }
166  if (m_storeTRT && m_TRTdEdxTool.isEnabled()) {
167  std::vector<std::string> names;
168  names.resize(kNTRTFloatDecor);
169  names[kTRTdEdxDecor]="ToT_dEdx";
170  names[kTRTusedHitsDecor]="ToT_usedHits";
171  names[kTRTdEdx_noHT_divByLDecor]="ToT_dEdx_noHT_divByL";
172  names[kTRTusedHits_noHT_divByLDecor]="ToT_usedHits_noHT_divByL";
173  createDecoratorKeys(*this,m_containerName, m_sgName, names, m_trackTRTFloatDecorKeys);
174  }
175  ATH_CHECK( m_trtPhaseKey.initialize(m_addExtraEventInfo) );
176  ATH_CHECK( m_pixelMapName.initialize(m_storePixel && m_addPRD) );
177  ATH_CHECK( m_sctMapName.initialize(m_storeSCT && m_addPRD) );
178  ATH_CHECK( m_trtMapName.initialize(m_storeTRT && m_addPRD) );
179 
180  ATH_CHECK( m_pixelClustersName.initialize(m_storePixel && m_addPRD) );
181  ATH_CHECK( m_sctClustersName.initialize(m_storeSCT && m_addPRD) );
182  ATH_CHECK( m_trtDCName.initialize(m_storeTRT && m_addPRD) );
183 
184  ATH_CHECK( m_pixelMsosName.initialize(m_storePixel && m_addPRD) );
185  ATH_CHECK( m_sctMsosName.initialize(m_storeSCT && m_addPRD) );
186  ATH_CHECK( m_trtMsosName.initialize(m_storeTRT && m_addPRD) );
187 
188  if (m_storePixel){
189  std::vector<std::string> names;
190  names.resize(kNPixFloatDecor);
191  names[kTrkIBLXDecor]="TrkIBLX";
192  names[kTrkIBLYDecor]="TrkIBLY";
193  names[kTrkIBLZDecor]="TrkIBLZ";
194  names[kTrkBLXDecor]="TrkBLX";
195  names[kTrkBLYDecor]="TrkBLY";
196  names[kTrkBLZDecor]="TrkBLZ";
197  names[kTrkL1XDecor]="TrkL1X";
198  names[kTrkL1YDecor]="TrkL1Y";
199  names[kTrkL1ZDecor]="TrkL1Z";
200  names[kTrkL2XDecor]="TrkL2X";
201  names[kTrkL2YDecor]="TrkL2Y";
202  names[kTrkL2ZDecor]="TrkL2Z";
203  createDecoratorKeys(*this,m_containerName, m_sgName, names, m_trackPixFloatDecorKeys);
204  }
205 
206  m_trackTSOSMOSLinkDecorKey = m_containerName.key() + "." + m_sgName + "msosLink";
207  ATH_CHECK( m_trackTSOSMOSLinkDecorKey.initialize() );
208 
209  ATH_MSG_DEBUG("Initialization finished.");
210 
211  return StatusCode::SUCCESS;
212  }

Member Data Documentation

◆ m_addExtraEventInfo

bool DerivationFramework::TrackStateOnSurfaceDecorator::m_addExtraEventInfo
private

Definition at line 80 of file TrackStateOnSurfaceDecorator.h.

◆ m_addPRD

bool DerivationFramework::TrackStateOnSurfaceDecorator::m_addPRD
private

Definition at line 79 of file TrackStateOnSurfaceDecorator.h.

◆ m_addPulls

bool DerivationFramework::TrackStateOnSurfaceDecorator::m_addPulls
private

Definition at line 77 of file TrackStateOnSurfaceDecorator.h.

◆ m_addSurfaceInfo

bool DerivationFramework::TrackStateOnSurfaceDecorator::m_addSurfaceInfo
private

Definition at line 78 of file TrackStateOnSurfaceDecorator.h.

◆ m_containerName

SG::ReadHandleKey<xAOD::TrackParticleContainer> DerivationFramework::TrackStateOnSurfaceDecorator::m_containerName { this, "ContainerName", "InDetTrackParticles", "" }
private

Definition at line 87 of file TrackStateOnSurfaceDecorator.h.

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> DerivationFramework::TrackStateOnSurfaceDecorator::m_eventInfoKey { this, "EventInfoKey", "EventInfo", "" }
private

Definition at line 83 of file TrackStateOnSurfaceDecorator.h.

◆ m_extrapolator

ToolHandle<Trk::IExtrapolator> DerivationFramework::TrackStateOnSurfaceDecorator::m_extrapolator
private

Definition at line 133 of file TrackStateOnSurfaceDecorator.h.

◆ m_holeSearchTool

ToolHandle<Trk::ITrackHoleSearchTool> DerivationFramework::TrackStateOnSurfaceDecorator::m_holeSearchTool
private

Definition at line 132 of file TrackStateOnSurfaceDecorator.h.

◆ m_idHelper

const AtlasDetectorID* DerivationFramework::TrackStateOnSurfaceDecorator::m_idHelper
private

Definition at line 125 of file TrackStateOnSurfaceDecorator.h.

◆ m_isSimulation

bool DerivationFramework::TrackStateOnSurfaceDecorator::m_isSimulation
private

Definition at line 70 of file TrackStateOnSurfaceDecorator.h.

◆ m_pixelClustersName

SG::ReadHandleKey<xAOD::TrackMeasurementValidationContainer > DerivationFramework::TrackStateOnSurfaceDecorator::m_pixelClustersName {this, "PixelClustersName", "PixelClusters" ,"" }
private

Definition at line 101 of file TrackStateOnSurfaceDecorator.h.

◆ m_pixelLayerRadii

Gaudi::Property< std::vector<float> > DerivationFramework::TrackStateOnSurfaceDecorator::m_pixelLayerRadii {this, "PixelLayerRadii", {29.5,50.5,88.5,122.5}, "Radii to extrapolate to for estimating track position on layers" }
private

Definition at line 152 of file TrackStateOnSurfaceDecorator.h.

◆ m_pixelMapName

SG::ReadHandleKey<std::vector<unsigned int> > DerivationFramework::TrackStateOnSurfaceDecorator::m_pixelMapName { this, "PixelMapName", "PixelClustersOffsets" , ""}
private

Definition at line 94 of file TrackStateOnSurfaceDecorator.h.

◆ m_pixelMsosName

SG::WriteHandleKey<xAOD::TrackStateValidationContainer> DerivationFramework::TrackStateOnSurfaceDecorator::m_pixelMsosName { this, "PixelMsosName", "PixelMSOSs", "" }
private

Definition at line 111 of file TrackStateOnSurfaceDecorator.h.

◆ m_pixId

const PixelID* DerivationFramework::TrackStateOnSurfaceDecorator::m_pixId
private

Definition at line 126 of file TrackStateOnSurfaceDecorator.h.

◆ m_prdToTrackMap

SG::ReadHandleKey<Trk::PRDtoTrackMap> DerivationFramework::TrackStateOnSurfaceDecorator::m_prdToTrackMap { this,"PRDtoTrackMap","","option PRD-to-track association"}
private

Definition at line 108 of file TrackStateOnSurfaceDecorator.h.

◆ m_residualPullCalculator

ToolHandle<Trk::IResidualPullCalculator> DerivationFramework::TrackStateOnSurfaceDecorator::m_residualPullCalculator
private

Definition at line 131 of file TrackStateOnSurfaceDecorator.h.

◆ m_sctClustersName

SG::ReadHandleKey<xAOD::TrackMeasurementValidationContainer > DerivationFramework::TrackStateOnSurfaceDecorator::m_sctClustersName {this, "SctClustersName", "SCT_Clusters" ,"" }
private

Definition at line 103 of file TrackStateOnSurfaceDecorator.h.

◆ m_SCTDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> DerivationFramework::TrackStateOnSurfaceDecorator::m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
private

Definition at line 121 of file TrackStateOnSurfaceDecorator.h.

◆ m_sctId

const SCT_ID* DerivationFramework::TrackStateOnSurfaceDecorator::m_sctId
private

Definition at line 127 of file TrackStateOnSurfaceDecorator.h.

◆ m_sctMapName

SG::ReadHandleKey<std::vector<unsigned int> > DerivationFramework::TrackStateOnSurfaceDecorator::m_sctMapName { this, "SctMapName", "SCT_ClustersOffsets" , ""}
private

Definition at line 96 of file TrackStateOnSurfaceDecorator.h.

◆ m_sctMsosName

SG::WriteHandleKey<xAOD::TrackStateValidationContainer> DerivationFramework::TrackStateOnSurfaceDecorator::m_sctMsosName { this, "SctMsosName", "SCT_MSOSs", "" }
private

Definition at line 113 of file TrackStateOnSurfaceDecorator.h.

◆ m_selectionString

StringProperty DerivationFramework::TrackStateOnSurfaceDecorator::m_selectionString { this, "SelectionString", "", "track selections"}
private

Definition at line 91 of file TrackStateOnSurfaceDecorator.h.

◆ m_sgName

Gaudi::Property<std::string> DerivationFramework::TrackStateOnSurfaceDecorator::m_sgName { this, "DecorationPrefix", "IDDET1_",""}
private

Definition at line 85 of file TrackStateOnSurfaceDecorator.h.

◆ m_storeHoles

bool DerivationFramework::TrackStateOnSurfaceDecorator::m_storeHoles
private

Definition at line 72 of file TrackStateOnSurfaceDecorator.h.

◆ m_storeOutliers

bool DerivationFramework::TrackStateOnSurfaceDecorator::m_storeOutliers
private

Definition at line 73 of file TrackStateOnSurfaceDecorator.h.

◆ m_storePixel

bool DerivationFramework::TrackStateOnSurfaceDecorator::m_storePixel
private

Definition at line 76 of file TrackStateOnSurfaceDecorator.h.

◆ m_storeSCT

bool DerivationFramework::TrackStateOnSurfaceDecorator::m_storeSCT
private

Definition at line 75 of file TrackStateOnSurfaceDecorator.h.

◆ m_storeTRT

bool DerivationFramework::TrackStateOnSurfaceDecorator::m_storeTRT
private

Definition at line 74 of file TrackStateOnSurfaceDecorator.h.

◆ m_trackPixFloatDecorKeys

std::vector<SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> > DerivationFramework::TrackStateOnSurfaceDecorator::m_trackPixFloatDecorKeys
private

Definition at line 150 of file TrackStateOnSurfaceDecorator.h.

◆ m_trackTRTFloatDecorKeys

std::vector<SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> > DerivationFramework::TrackStateOnSurfaceDecorator::m_trackTRTFloatDecorKeys
private

Definition at line 144 of file TrackStateOnSurfaceDecorator.h.

◆ m_trackTSOSMOSLinkDecorKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> DerivationFramework::TrackStateOnSurfaceDecorator::m_trackTSOSMOSLinkDecorKey
private

Definition at line 151 of file TrackStateOnSurfaceDecorator.h.

◆ m_trtcaldbTool

ToolHandle<ITRT_CalDbTool> DerivationFramework::TrackStateOnSurfaceDecorator::m_trtcaldbTool
private

Definition at line 134 of file TrackStateOnSurfaceDecorator.h.

◆ m_trtDCName

SG::ReadHandleKey<xAOD::TrackMeasurementValidationContainer> DerivationFramework::TrackStateOnSurfaceDecorator::m_trtDCName {this, "TrtDriftCirclesName", "TRT_DriftCircles" ,"" }
private

Definition at line 105 of file TrackStateOnSurfaceDecorator.h.

◆ m_TRTdEdxTool

ToolHandle<ITRT_ToT_dEdx> DerivationFramework::TrackStateOnSurfaceDecorator::m_TRTdEdxTool
private

Definition at line 136 of file TrackStateOnSurfaceDecorator.h.

◆ m_trtId

const TRT_ID* DerivationFramework::TrackStateOnSurfaceDecorator::m_trtId
private

Definition at line 128 of file TrackStateOnSurfaceDecorator.h.

◆ m_trtMapName

SG::ReadHandleKey<std::vector<unsigned int> > DerivationFramework::TrackStateOnSurfaceDecorator::m_trtMapName { this, "TrtMapName", "TRT_DriftCirclesOffsets" , ""}
private

Definition at line 98 of file TrackStateOnSurfaceDecorator.h.

◆ m_trtMsosName

SG::WriteHandleKey<xAOD::TrackStateValidationContainer> DerivationFramework::TrackStateOnSurfaceDecorator::m_trtMsosName { this, "TrtMsosName", "TRT_MSOSs", ""}
private

Definition at line 115 of file TrackStateOnSurfaceDecorator.h.

◆ m_trtPhaseDecorKey

std::vector<SG::WriteDecorHandleKey<xAOD::EventInfo> > DerivationFramework::TrackStateOnSurfaceDecorator::m_trtPhaseDecorKey
private

Definition at line 138 of file TrackStateOnSurfaceDecorator.h.

◆ m_trtPhaseKey

SG::ReadHandleKey<ComTime> DerivationFramework::TrackStateOnSurfaceDecorator::m_trtPhaseKey { this,"TRTPhaseKey","TRT_Phase", ""}
private

Definition at line 89 of file TrackStateOnSurfaceDecorator.h.

◆ m_updator

ToolHandle<Trk::IUpdator> DerivationFramework::TrackStateOnSurfaceDecorator::m_updator
private

Definition at line 130 of file TrackStateOnSurfaceDecorator.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
AtlasDetectorID::is_pixel
bool is_pixel(Identifier id) const
Definition: AtlasDetectorID.h:760
DerivationFramework::TrackStateOnSurfaceDecorator::m_residualPullCalculator
ToolHandle< Trk::IResidualPullCalculator > m_residualPullCalculator
Definition: TrackStateOnSurfaceDecorator.h:131
DerivationFramework::TrackStateOnSurfaceDecorator::kNPixFloatDecor
@ kNPixFloatDecor
Definition: TrackStateOnSurfaceDecorator.h:149
DerivationFramework::TrackStateOnSurfaceDecorator::kTrkIBLYDecor
@ kTrkIBLYDecor
Definition: TrackStateOnSurfaceDecorator.h:145
Trk::TrackState::Pixel
@ Pixel
Definition: TrackStateDefs.h:28
DerivationFramework::TrackStateOnSurfaceDecorator::m_pixelMapName
SG::ReadHandleKey< std::vector< unsigned int > > m_pixelMapName
Definition: TrackStateOnSurfaceDecorator.h:95
DerivationFramework::TrackStateOnSurfaceDecorator::kTRTusedHitsDecor
@ kTRTusedHitsDecor
Definition: TrackStateOnSurfaceDecorator.h:140
xAOD::TrackStateValidation_v1::setUnbiasedResidual
void setUnbiasedResidual(float unbiasedResidualX, float unbiasedResidualY)
Sets the unbiased residual.
Definition: TrackStateValidation_v1.cxx:47
Trk::Surface::associatedDetectorElement
const TrkDetElementBase * associatedDetectorElement() const
return associated Detector Element
DerivationFramework::createDecoratorKeys
void createDecoratorKeys(T_Parent &parent, const SG::ReadHandleKey< T_Cont > &container_key, const std::string &prefix, const std::vector< std::string > &decor_names, std::vector< SG::WriteDecorHandleKey< T_Cont > > &decor_out)
Definition: DecoratorUtils.h:20
DerivationFramework::TrackStateOnSurfaceDecorator::kTRTdEdx_noHT_divByLDecor
@ kTRTdEdx_noHT_divByLDecor
Definition: TrackStateOnSurfaceDecorator.h:141
Trk::TrackState::TRT
@ TRT
Definition: TrackStateDefs.h:30
Trk::locX
@ locX
Definition: ParamDefs.h:37
Trk::locY
@ locY
local cartesian
Definition: ParamDefs.h:38
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
SG::Accessor< float >
xAOD::TrackStateValidation_v1::setDetType
void setDetType(char detType)
Sets the detector type.
AtlasDetectorID::is_sct
bool is_sct(Identifier id) const
Definition: AtlasDetectorID.h:770
Trk::PRDtoTrackMap
Definition: PRDtoTrackMap.h:17
Trk::oppositeMomentum
@ oppositeMomentum
Definition: PropDirection.h:21
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
InDetDD::holes
@ holes
Definition: InDetDD_Defs.h:17
Trk::Track::trackStateOnSurfaces
const Trk::TrackStates * trackStateOnSurfaces() const
return a pointer to a const DataVector of const TrackStateOnSurfaces.
DerivationFramework::TrackStateOnSurfaceDecorator::m_trtPhaseKey
SG::ReadHandleKey< ComTime > m_trtPhaseKey
Definition: TrackStateOnSurfaceDecorator.h:90
Trk::Track::info
const TrackInfo & info() const
Returns a const ref to info of a const tracks.
DerivationFramework::TrackStateOnSurfaceDecorator::m_trtMapName
SG::ReadHandleKey< std::vector< unsigned int > > m_trtMapName
Definition: TrackStateOnSurfaceDecorator.h:99
xAOD::TrackStateValidation
TrackStateValidation_v1 TrackStateValidation
Reference the current persistent version:
Definition: TrackStateValidation.h:13
Trk::ResidualPull::Unbiased
@ Unbiased
RP with track state that has measurement not included.
Definition: ResidualPull.h:57
InDet::TRT_DriftCircleOnTrack::associatedSurface
virtual const Trk::Surface & associatedSurface() const override final
returns the surface for the local to global transformation
Definition: TRT_DriftCircleOnTrack.cxx:154
DerivationFramework::TrackStateOnSurfaceDecorator::kTrkL2XDecor
@ kTrkL2XDecor
Definition: TrackStateOnSurfaceDecorator.h:148
ParticleTest.tp
tp
Definition: ParticleTest.py:25
xAOD::TrackStateValidation_v1
Class describing a TrackStateValidation.
Definition: TrackStateValidation_v1.h:28
Identifier::get_compact
value_type get_compact() const
Get the compact id.
DerivationFramework::TrackStateOnSurfaceDecorator::m_isSimulation
bool m_isSimulation
Definition: TrackStateOnSurfaceDecorator.h:70
IdentContIndex
Identifiable container index to a contained object.
Definition: IdentContIndex.h:23
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
Trk::MaterialUpdateMode
MaterialUpdateMode
This is a steering enum to force the material update it can be: (1) addNoise (-1) removeNoise Second ...
Definition: MaterialUpdateMode.h:18
DerivationFramework::TrackStateOnSurfaceDecorator::m_trtcaldbTool
ToolHandle< ITRT_CalDbTool > m_trtcaldbTool
Definition: TrackStateOnSurfaceDecorator.h:134
xAOD::TrackStateValidation_v1::trackMeasurementValidationLink
ElementLink< xAOD::TrackMeasurementValidationContainer > trackMeasurementValidationLink() const
Trk::alongMomentum
@ alongMomentum
Definition: PropDirection.h:20
Trk::TrkDetElementBase
Definition: TrkDetElementBase.h:52
xAOD::TrackStateValidation_v1::setUnbiasedPull
void setUnbiasedPull(float unbiasedPullX, float unbiasedPullY)
Sets the unbiased pull.
Definition: TrackStateValidation_v1.cxx:57
DerivationFramework::TrackStateOnSurfaceDecorator::m_extrapolator
ToolHandle< Trk::IExtrapolator > m_extrapolator
Definition: TrackStateOnSurfaceDecorator.h:133
AtlasDetectorID::is_trt
bool is_trt(Identifier id) const
Definition: AtlasDetectorID.h:782
DerivationFramework::TrackStateOnSurfaceDecorator::m_sctClustersName
SG::ReadHandleKey< xAOD::TrackMeasurementValidationContainer > m_sctClustersName
Definition: TrackStateOnSurfaceDecorator.h:104
DerivationFramework::TrackStateOnSurfaceDecorator::buildElementLink
ElementLink< xAOD::TrackMeasurementValidationContainer > buildElementLink(const Trk::PrepRawData *, const std::vector< unsigned int > *, const xAOD::TrackMeasurementValidationContainer *) const
Definition: TrackStateOnSurfaceDecorator.cxx:881
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
Trk::Surface::center
const Amg::Vector3D & center() const
Returns the center position of the Surface.
DerivationFramework::TrackStateOnSurfaceDecorator::m_trtId
const TRT_ID * m_trtId
Definition: TrackStateOnSurfaceDecorator.h:128
InDet::TRT_DriftCircleOnTrack
Definition: TRT_DriftCircleOnTrack.h:53
Identifier::is_valid
bool is_valid() const
Check if id is in a valid state.
DerivationFramework::TrackStateOnSurfaceDecorator::kTrkL1XDecor
@ kTrkL1XDecor
Definition: TrackStateOnSurfaceDecorator.h:147
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:460
DerivationFramework::TrackStateOnSurfaceDecorator::m_sctMapName
SG::ReadHandleKey< std::vector< unsigned int > > m_sctMapName
Definition: TrackStateOnSurfaceDecorator.h:97
DerivationFramework::TrackStateOnSurfaceDecorator::kTrkL2ZDecor
@ kTrkL2ZDecor
Definition: TrackStateOnSurfaceDecorator.h:148
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
TRT::Hit::side
@ side
Definition: HitInfo.h:83
DerivationFramework::TrackStateOnSurfaceDecorator::m_idHelper
const AtlasDetectorID * m_idHelper
Definition: TrackStateOnSurfaceDecorator.h:125
DerivationFramework::TrackStateOnSurfaceDecorator::m_sctMsosName
SG::WriteHandleKey< xAOD::TrackStateValidationContainer > m_sctMsosName
Definition: TrackStateOnSurfaceDecorator.h:114
Trk::ParametersT::associatedSurface
virtual const S & associatedSurface() const override final
Access to the Surface method.
TRTCond::RtRelation
Definition: RtRelation.h:27
DerivationFramework::TrackStateOnSurfaceDecorator::kNTRTFloatDecor
@ kNTRTFloatDecor
Definition: TrackStateOnSurfaceDecorator.h:143
xAOD::TrackMeasurementValidation_v1
Class describing a TrackMeasurementValidation.
Definition: TrackMeasurementValidation_v1.h:27
Trk::CompetingRIOsOnTrack::rioOnTrack
virtual const RIO_OnTrack & rioOnTrack(unsigned int) const =0
returns the RIO_OnTrack (also known as ROT) objects depending on the integer.
Trk::TrackStateOnSurfaceComparisonFunction
Class providing comparison function, or relational definition, for sorting MeasurementBase objects.
Definition: TrackStateOnSurfaceComparisonFunction.h:37
DerivationFramework::TrackStateOnSurfaceDecorator::m_addExtraEventInfo
bool m_addExtraEventInfo
Definition: TrackStateOnSurfaceDecorator.h:80
Trk::PropDirection
PropDirection
Definition: PropDirection.h:19
DerivationFramework::TrackStateOnSurfaceDecorator::m_prdToTrackMap
SG::ReadHandleKey< Trk::PRDtoTrackMap > m_prdToTrackMap
Definition: TrackStateOnSurfaceDecorator.h:109
DerivationFramework::TrackStateOnSurfaceDecorator::kTRTusedHits_noHT_divByLDecor
@ kTRTusedHits_noHT_divByLDecor
Definition: TrackStateOnSurfaceDecorator.h:142
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
DerivationFramework::TrackStateOnSurfaceDecorator::kTrkBLYDecor
@ kTrkBLYDecor
Definition: TrackStateOnSurfaceDecorator.h:146
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Trk::TrackStateOnSurface::Hole
@ Hole
A hole on the track - this is defined in the following way.
Definition: TrackStateOnSurface.h:128
lumiFormat.i
int i
Definition: lumiFormat.py:85
DerivationFramework::TrackStateOnSurfaceDecorator::kTrkBLZDecor
@ kTrkBLZDecor
Definition: TrackStateOnSurfaceDecorator.h:146
beamspotman.n
n
Definition: beamspotman.py:731
TRTCond::RtRelation::drifttime
virtual float drifttime(float radius) const =0
drifttime for given radius
Trk::theta
@ theta
Definition: ParamDefs.h:66
DerivationFramework::TrackStateOnSurfaceDecorator::kTrkL1ZDecor
@ kTrkL1ZDecor
Definition: TrackStateOnSurfaceDecorator.h:147
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
python.subdetectors.mmg.names
names
Definition: mmg.py:8
Trk::CylinderSurface
Definition: CylinderSurface.h:55
Trk::driftRadius
@ driftRadius
trt, straws
Definition: ParamDefs.h:53
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:100
Trk::pion
@ pion
Definition: ParticleHypothesis.h:29
DerivationFramework::TrackStateOnSurfaceDecorator::m_storeOutliers
bool m_storeOutliers
Definition: TrackStateOnSurfaceDecorator.h:73
DerivationFramework::TrackStateOnSurfaceDecorator::kTrkBLXDecor
@ kTrkBLXDecor
Definition: TrackStateOnSurfaceDecorator.h:146
Trk::CompetingRIOsOnTrack
Base class for all CompetingRIOsOnTack implementations, extends the common MeasurementBase.
Definition: CompetingRIOsOnTrack.h:64
Trk::TrkDetElementBase::surface
virtual const Surface & surface() const =0
Return surface associated with this detector element.
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
DerivationFramework::TrackStateOnSurfaceDecorator::m_pixelLayerRadii
Gaudi::Property< std::vector< float > > m_pixelLayerRadii
Definition: TrackStateOnSurfaceDecorator.h:152
DerivationFramework::TrackStateOnSurfaceDecorator::m_TRTdEdxTool
ToolHandle< ITRT_ToT_dEdx > m_TRTdEdxTool
Definition: TrackStateOnSurfaceDecorator.h:136
Trk::ParametersBase
Definition: ParametersBase.h:55
DerivationFramework::TrackStateOnSurfaceDecorator::kTrkIBLXDecor
@ kTrkIBLXDecor
Definition: TrackStateOnSurfaceDecorator.h:145
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
DerivationFramework::TrackStateOnSurfaceDecorator::kTRTdEdxDecor
@ kTRTdEdxDecor
Definition: TrackStateOnSurfaceDecorator.h:139
DerivationFramework::TrackStateOnSurfaceDecorator::m_trackTRTFloatDecorKeys
std::vector< SG::WriteDecorHandleKey< xAOD::TrackParticleContainer > > m_trackTRTFloatDecorKeys
Definition: TrackStateOnSurfaceDecorator.h:144
DerivationFramework::TrackStateOnSurfaceDecorator::m_storeHoles
bool m_storeHoles
Definition: TrackStateOnSurfaceDecorator.h:72
DerivationFramework::TrackStateOnSurfaceDecorator::m_updator
ToolHandle< Trk::IUpdator > m_updator
Definition: TrackStateOnSurfaceDecorator.h:130
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
DerivationFramework::TrackStateOnSurfaceDecorator::m_SCTDetEleCollKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_SCTDetEleCollKey
Definition: TrackStateOnSurfaceDecorator.h:121
Trk::MeasurementBase::localCovariance
const Amg::MatrixX & localCovariance() const
Interface method to get the localError.
Definition: MeasurementBase.h:138
DerivationFramework::TrackStateOnSurfaceDecorator::m_addPRD
bool m_addPRD
Definition: TrackStateOnSurfaceDecorator.h:79
Trk::PrepRawData
Definition: PrepRawData.h:62
DerivationFramework::TrackStateOnSurfaceDecorator::m_trackTSOSMOSLinkDecorKey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer > m_trackTSOSMOSLinkDecorKey
Definition: TrackStateOnSurfaceDecorator.h:151
Trk::MeasurementBase
Definition: MeasurementBase.h:58
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
IdentContIndex::objIndex
unsigned short objIndex() const
object index in collection
Definition: IdentContIndex.h:92
DerivationFramework::TrackStateOnSurfaceDecorator::m_addSurfaceInfo
bool m_addSurfaceInfo
Definition: TrackStateOnSurfaceDecorator.h:78
Trk::Track::perigeeParameters
const Perigee * perigeeParameters() const
return Perigee.
Definition: Tracking/TrkEvent/TrkTrack/src/Track.cxx:163
xAOD::TrackStateValidation_v1::setBiasedPull
void setBiasedPull(float biasedPullX, float biasedPullY)
Sets the biased pull.
Definition: TrackStateValidation_v1.cxx:77
DerivationFramework::TrackStateOnSurfaceDecorator::m_storeSCT
bool m_storeSCT
Definition: TrackStateOnSurfaceDecorator.h:75
DerivationFramework::TrackStateOnSurfaceDecorator::m_storeTRT
bool m_storeTRT
Definition: TrackStateOnSurfaceDecorator.h:74
xAOD::TrackStateValidation_v1::setBiasedResidual
void setBiasedResidual(float biasedResidualX, float biasedResidualY)
Sets the biased residual.
Definition: TrackStateValidation_v1.cxx:67
DerivationFramework::TrackStateOnSurfaceDecorator::m_holeSearchTool
ToolHandle< Trk::ITrackHoleSearchTool > m_holeSearchTool
Definition: TrackStateOnSurfaceDecorator.h:132
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
IdentContIndex::isValid
bool isValid() const
check that both fields are set
Definition: IdentContIndex.h:108
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::RIO_OnTrack::prepRawData
virtual const Trk::PrepRawData * prepRawData() const =0
returns the PrepRawData (also known as RIO) object to which this RIO_OnTrack is associated.
std::stable_sort
void stable_sort(DataModel_detail::iterator< DVL > beg, DataModel_detail::iterator< DVL > end)
Specialization of stable_sort for DataVector/List.
Definition: DVL_algorithms.h:644
DerivationFramework::TrackStateOnSurfaceDecorator::m_sctId
const SCT_ID * m_sctId
Definition: TrackStateOnSurfaceDecorator.h:127
columnar::ContainerId::eventInfo
@ eventInfo
Trk::MeasurementBase::localParameters
const LocalParameters & localParameters() const
Interface method to get the LocalParameters.
Definition: MeasurementBase.h:132
DerivationFramework::TrackStateOnSurfaceDecorator::m_addPulls
bool m_addPulls
Definition: TrackStateOnSurfaceDecorator.h:77
Trk::PrepRawData::getHashAndIndex
const IdentContIndex & getHashAndIndex() const
xAOD::TrackStateValidation_v1::setLocalAngles
void setLocalAngles(float localTheta, float localPhi)
Sets the local angles.
Definition: TrackStateValidation_v1.cxx:37
xAOD::TrackStateValidation_v1::setLocalPosition
void setLocalPosition(float localX, float localY)
Sets the local position.
Definition: TrackStateValidation_v1.cxx:27
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
DerivationFramework::TrackStateOnSurfaceDecorator::m_sgName
Gaudi::Property< std::string > m_sgName
Definition: TrackStateOnSurfaceDecorator.h:86
DerivationFramework::TrackStateOnSurfaceDecorator::m_trtMsosName
SG::WriteHandleKey< xAOD::TrackStateValidationContainer > m_trtMsosName
Definition: TrackStateOnSurfaceDecorator.h:116
DerivationFramework::TrackStateOnSurfaceDecorator::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: TrackStateOnSurfaceDecorator.h:84
Trk::ResidualPull::Biased
@ Biased
RP with track state including the hit.
Definition: ResidualPull.h:55
SG::WriteDecorHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Trk::addNoise
@ addNoise
Definition: MaterialUpdateMode.h:19
xAOD::TrackStateValidation_v1::setDetElementId
void setDetElementId(uint64_t detElementId)
Sets the detector element identifier.
DerivationFramework::TrackStateOnSurfaceDecorator::m_trackPixFloatDecorKeys
std::vector< SG::WriteDecorHandleKey< xAOD::TrackParticleContainer > > m_trackPixFloatDecorKeys
Definition: TrackStateOnSurfaceDecorator.h:150
entries
double entries
Definition: listroot.cxx:49
DerivationFramework::TrackStateOnSurfaceDecorator::m_pixelMsosName
SG::WriteHandleKey< xAOD::TrackStateValidationContainer > m_pixelMsosName
Definition: TrackStateOnSurfaceDecorator.h:112
DerivationFramework::TrackStateOnSurfaceDecorator::m_pixelClustersName
SG::ReadHandleKey< xAOD::TrackMeasurementValidationContainer > m_pixelClustersName
Definition: TrackStateOnSurfaceDecorator.h:102
Trk::hole
@ hole
Definition: MeasurementType.h:36
xAOD::TrackStateValidation_v1::setType
void setType(int type)
Sets the type (measurement, outlier, hole)
Trk::phi
@ phi
Definition: ParamDefs.h:75
DerivationFramework::TrackStateOnSurfaceDecorator::m_trtPhaseDecorKey
std::vector< SG::WriteDecorHandleKey< xAOD::EventInfo > > m_trtPhaseDecorKey
Definition: TrackStateOnSurfaceDecorator.h:138
xAOD::TrackStateValidation_v1::setTrackMeasurementValidationLink
void setTrackMeasurementValidationLink(ElementLink< xAOD::TrackMeasurementValidationContainer > trackMeasurementValidationLink)
sets the link to the TrackMeasurementValidationContainer
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
Trk::TrackState::SCT
@ SCT
Definition: TrackStateDefs.h:29
InDet::TRT_DriftCircleOnTrack::globalPosition
virtual const Amg::Vector3D & globalPosition() const override final
return the global position of this RIO_OnTrack
Definition: TRT_DriftCircleOnTrack.cxx:160
DerivationFramework::TrackStateOnSurfaceDecorator::m_selectionString
StringProperty m_selectionString
Definition: TrackStateOnSurfaceDecorator.h:92
Trk::CompetingRIOsOnTrack::indexOfMaxAssignProb
unsigned int indexOfMaxAssignProb() const
Index of the ROT with the highest assignment probability.
Definition: CompetingRIOsOnTrack.cxx:101
dqBeamSpot.nEntries
int nEntries
Definition: dqBeamSpot.py:73
Trk::removeNoise
@ removeNoise
Definition: MaterialUpdateMode.h:20
DerivationFramework::TrackStateOnSurfaceDecorator::kTrkIBLZDecor
@ kTrkIBLZDecor
Definition: TrackStateOnSurfaceDecorator.h:145
DerivationFramework::TrackStateOnSurfaceDecorator::kTrkL2YDecor
@ kTrkL2YDecor
Definition: TrackStateOnSurfaceDecorator.h:148
DerivationFramework::TrackStateOnSurfaceDecorator::m_storePixel
bool m_storePixel
Definition: TrackStateOnSurfaceDecorator.h:76
DerivationFramework::TrackStateOnSurfaceDecorator::m_trtDCName
SG::ReadHandleKey< xAOD::TrackMeasurementValidationContainer > m_trtDCName
Definition: TrackStateOnSurfaceDecorator.h:106
IdentContIndex::collHash
unsigned short collHash() const
Accessor to hash, obj index and combined index.
Definition: IdentContIndex.h:85
Trk::PRDtoTrackMap::isShared
bool isShared(const PrepRawData &prd) const
does this PRD belong to more than one track?
DerivationFramework::TrackStateOnSurfaceDecorator::m_containerName
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_containerName
Definition: TrackStateOnSurfaceDecorator.h:88
Trk::TrackStateOnSurface::Measurement
@ Measurement
This is a measurement, and will at least contain a Trk::MeasurementBase.
Definition: TrackStateOnSurface.h:101
DerivationFramework::TrackStateOnSurfaceDecorator::kTrkL1YDecor
@ kTrkL1YDecor
Definition: TrackStateOnSurfaceDecorator.h:147
Trk::TrackInfo::particleHypothesis
ParticleHypothesis particleHypothesis() const
Returns the particle hypothesis used for Track fitting.
DerivationFramework::TrackStateOnSurfaceDecorator::m_pixId
const PixelID * m_pixId
Definition: TrackStateOnSurfaceDecorator.h:126
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Fri Apr 18 2025 22:02:04 for ATLAS Offline Software by   doxygen 1.8.18