ATLAS Offline Software
Public Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
ActsTrk::SiSpacePointsSeedMaker Class Reference

#include <SiSpacePointsSeedMaker.h>

Inheritance diagram for ActsTrk::SiSpacePointsSeedMaker:
Collaboration diagram for ActsTrk::SiSpacePointsSeedMaker:

Public Member Functions

 SiSpacePointsSeedMaker (const std::string &t, const std::string &n, const IInterface *p)
 
virtual ~SiSpacePointsSeedMaker () override=default
 
virtual StatusCode initialize () override
 
virtual void newEvent (const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, int iteration=-1) const override
 
virtual void find3Sp (const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, const std::list< Trk::Vertex > &lv) const override
 
virtual const InDet::SiSpacePointsSeed * next (const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data) const override
 
virtual void writeNtuple (const InDet::SiSpacePointsSeed *seed, const Trk::Track *track, int seedType, long eventNumber) const override
 
virtual bool getWriteNtupleBoolProperty () const override
 
virtual MsgStream & dump (InDet::SiSpacePointsSeedMakerEventData &data, MsgStream &out) const override
 
virtual void newRegion (const EventContext &, InDet::SiSpacePointsSeedMakerEventData &, const std::vector< IdentifierHash > &, const std::vector< IdentifierHash > &) const override
 
virtual void newRegion (const EventContext &, InDet::SiSpacePointsSeedMakerEventData &, const std::vector< IdentifierHash > &, const std::vector< IdentifierHash > &, const IRoiDescriptor &) const override
 
virtual void find2Sp (InDet::SiSpacePointsSeedMakerEventData &, const std::list< Trk::Vertex > &) const override
 
virtual void find3Sp (const EventContext &, InDet::SiSpacePointsSeedMakerEventData &, const std::list< Trk::Vertex > &, const double *) const override
 with three space points with or without vertex constraint with information about min and max Z of the vertex More...
 
virtual void findVSp (const EventContext &, InDet::SiSpacePointsSeedMakerEventData &, const std::list< Trk::Vertex > &) const override
 with variable number space points with or without vertex constraint Variable means (2,3,4,....) any number space points More...
 

Private Types

enum  SeedStrategy : short { PPP, SSS }
 

Private Member Functions

MsgStream & dumpConditions (InDet::SiSpacePointsSeedMakerEventData &data, MsgStream &out) const
 
void buildBeamFrameWork (const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data) const
 
void newSpacePoint (InDet::SiSpacePointsSeedMakerEventData &data, const xAOD::SpacePoint *sp) const
 
bool convertPixelSeed (const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, const ActsTrk::SeedContainer &seedPtrs) const
 
bool convertStripSeed (const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, const ActsTrk::SeedContainer &seedPtrs) const
 
StatusCode retrievePixel (const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, const Trk::PRDtoTrackMap *prd_to_track_map_cptr) const
 
StatusCode retrieveStrip (const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, const Trk::PRDtoTrackMap *prd_to_track_map_cptr) const
 
StatusCode retrieveOverlap (const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, const Trk::PRDtoTrackMap *prd_to_track_map_cptr) const
 
StatusCode retrievePixel (const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, const std::vector< IdentifierHash > &ids, const Trk::PRDtoTrackMap *prd_to_track_map_cptr=nullptr) const
 
StatusCode retrieveStrip (const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, const std::vector< IdentifierHash > &ids, const Trk::PRDtoTrackMap *prd_to_track_map_cptr=nullptr) const
 
StatusCode retrieveOverlap (const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, const std::vector< IdentifierHash > &ids, const Trk::PRDtoTrackMap *prd_to_track_map_cptr) const
 
StatusCode InitTree ()
 
bool isUsed (const Trk::SpacePoint *, const Trk::PRDtoTrackMap &prd_to_track_map) const
 
bool isUsed (const xAOD::SpacePoint *, const Trk::PRDtoTrackMap &prd_to_track_map) const
 

Static Private Member Functions

static MsgStream & dumpEvent (InDet::SiSpacePointsSeedMakerEventData &data, MsgStream &out)
 
static void pixInform (const Trk::SpacePoint *sp, float *r)
 
static void stripInform (InDet::SiSpacePointsSeedMakerEventData &data, const Trk::SpacePoint *sp, std::span< float, 15 > r)
 

Private Attributes

ToolHandle< ActsTrk::ISeedingTool > m_seedsToolPixel {this, "SeedToolPixel", "","Seed Tool for Pixel detector"}
 
ToolHandle< ActsTrk::ISeedingTool > m_seedsToolStrip {this, "SeedToolStrip", "","Seed Tool for Strip detector"}
 
SG::ReadHandleKey< Trk::PRDtoTrackMap > m_prdToTrackMap {this, "PRDtoTrackMap", "", "option PRD-to-track association"}
 
SG::ReadHandleKey< xAOD::SpacePointContainer > m_actsSpacepointsPixel {this, "ActsSpacePointsPixelName", "", "Pixel space points container"}
 
SG::ReadHandleKey< xAOD::SpacePointContainer > m_actsSpacepointsStrip {this, "ActsSpacePointsStripName", "", "Strip space points container"}
 
SG::ReadHandleKey< xAOD::SpacePointContainer > m_actsSpacepointsOverlap {this, "ActsSpacePointsOverlapName", "", "Strip overlap space points container"}
 
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"}
 
SG::ReadCondHandleKey< AtlasFieldCacheCondObj > m_fieldCondObjInputKey
 
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_pixelDetEleCollKey
 
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_stripDetEleCollKey
 
Gaudi::Property< bool > m_pixel {this, "usePixel", true}
 
Gaudi::Property< bool > m_strip {this, "useStrip", true }
 
Gaudi::Property< bool > m_useOverlap {this, "useOverlapSpCollection", true}
 
Gaudi::Property< bool > m_fastTracking {this, "useFastTracking", false}
 
Gaudi::Property< bool > m_doSeedConversion {this, "doSeedConversion", true, "Convert ActsTrk::Seed into ITk::SiSpacePointsProSeed"}
 
Gaudi::Property< bool > m_useClusters {this, "useClustersForSeedConversion", false}
 
Gaudi::Property< bool > m_writeNtuple {this, "WriteNtuple", false}
 
std::mutex m_mutex
 
ServiceHandle< ITHistSvc > m_thistSvc
 
TTree * m_outputTree = nullptr
 
std::string m_treeName ATLAS_THREAD_SAFE = ""
 
std::string m_treeFolder ATLAS_THREAD_SAFE = "/valNtuples/"
 
float m_d0 ATLAS_THREAD_SAFE = 0
 
float m_z0 ATLAS_THREAD_SAFE = 0
 
float m_pt ATLAS_THREAD_SAFE = 0
 
float m_eta ATLAS_THREAD_SAFE = 0
 
double m_x1 ATLAS_THREAD_SAFE = 0
 
double m_x2 ATLAS_THREAD_SAFE = 0
 
double m_x3 ATLAS_THREAD_SAFE = 0
 
double m_y1 ATLAS_THREAD_SAFE = 0
 
double m_y2 ATLAS_THREAD_SAFE = 0
 
double m_y3 ATLAS_THREAD_SAFE = 0
 
double m_z1 ATLAS_THREAD_SAFE = 0
 
double m_z2 ATLAS_THREAD_SAFE = 0
 
double m_z3 ATLAS_THREAD_SAFE = 0
 
double m_r1 ATLAS_THREAD_SAFE = 0
 
double m_r2 ATLAS_THREAD_SAFE = 0
 
double m_r3 ATLAS_THREAD_SAFE = 0
 
float m_quality ATLAS_THREAD_SAFE = 0
 
int m_type ATLAS_THREAD_SAFE = 0
 
double m_dzdr_t ATLAS_THREAD_SAFE = 0
 
double m_dzdr_b ATLAS_THREAD_SAFE = 0
 
bool m_givesTrack ATLAS_THREAD_SAFE = false
 
float m_trackPt ATLAS_THREAD_SAFE = 0
 
float m_trackEta ATLAS_THREAD_SAFE = 0
 
long m_eventNumber ATLAS_THREAD_SAFE = 0
 

Detailed Description

Definition at line 45 of file SiSpacePointsSeedMaker.h.

Member Enumeration Documentation

◆ SeedStrategy

enum ActsTrk::SiSpacePointsSeedMaker::SeedStrategy : short
private
Enumerator
PPP 
SSS 

Definition at line 48 of file SiSpacePointsSeedMaker.h.

48 : short {PPP, SSS};

Constructor & Destructor Documentation

◆ SiSpacePointsSeedMaker()

ActsTrk::SiSpacePointsSeedMaker::SiSpacePointsSeedMaker ( const std::string &  t,
const std::string &  n,
const IInterface *  p 
)

Definition at line 35 of file SiSpacePointsSeedMaker.cxx.

36  : base_class(t, n, p),
37  m_thistSvc("THistSvc", n)
38  {}

◆ ~SiSpacePointsSeedMaker()

virtual ActsTrk::SiSpacePointsSeedMaker::~SiSpacePointsSeedMaker ( )
overridevirtualdefault

Member Function Documentation

◆ buildBeamFrameWork()

void ActsTrk::SiSpacePointsSeedMaker::buildBeamFrameWork ( const EventContext &  ctx,
InDet::SiSpacePointsSeedMakerEventData &  data 
) const
private

Definition at line 397 of file SiSpacePointsSeedMaker.cxx.

399  {
400  SG::ReadCondHandle< InDet::BeamSpotData > beamSpotHandle { m_beamSpotKey, ctx };
401 
402  const Amg::Vector3D &cb = beamSpotHandle->beamPos();
403  double tx = std::tan(beamSpotHandle->beamTilt(0));
404  double ty = std::tan(beamSpotHandle->beamTilt(1));
405 
406  double phi = std::atan2(ty, tx);
407  double theta = std::acos(1. / std::sqrt(1. + tx * tx + ty * ty));
408  double sinTheta = std::sin(theta);
409  double cosTheta = std::cos(theta);
410  double sinPhi = std::sin(phi);
411  double cosPhi = std::cos(phi);
412 
413  data.xbeam[0] = static_cast<float>(cb.x());
414  data.xbeam[1] = static_cast<float>(cosTheta * cosPhi * cosPhi + sinPhi * sinPhi);
415  data.xbeam[2] = static_cast<float>(cosTheta * sinPhi * cosPhi - sinPhi * cosPhi);
416  data.xbeam[3] = -static_cast<float>(sinTheta * cosPhi);
417 
418  data.ybeam[0] = static_cast<float>(cb.y());
419  data.ybeam[1] = static_cast<float>(cosTheta * cosPhi * sinPhi - sinPhi * cosPhi);
420  data.ybeam[2] = static_cast<float>(cosTheta * sinPhi * sinPhi + cosPhi * cosPhi);
421  data.ybeam[3] = -static_cast<float>(sinTheta * sinPhi);
422 
423  data.zbeam[0] = static_cast<float>(cb.z());
424  data.zbeam[1] = static_cast<float>(sinTheta * cosPhi);
425  data.zbeam[2] = static_cast<float>(sinTheta * sinPhi);
426  data.zbeam[3] = static_cast<float>(cosTheta);
427 
428  // Acts Seed Tool requires both MagneticFieldContext and BeamSpotData
429  // we need to retrieve them both from StoreGate
430  // Read the b-field information
431  SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle { m_fieldCondObjInputKey, ctx };
432  if ( not readHandle.isValid() ) {
433  throw std::runtime_error("Error while retrieving Atlas Field Cache Cond DB");
434  }
435  const AtlasFieldCacheCondObj* fieldCondObj{ *readHandle };
436  if (fieldCondObj == nullptr) {
437  throw std::runtime_error("Failed to retrieve AtlasFieldCacheCondObj with key " + m_fieldCondObjInputKey.key());
438  }
439 
440  // Get the magnetic field
441  // Using ACTS classes in order to be sure we are consistent
442  Acts::MagneticFieldContext magFieldContext(fieldCondObj);
443 
444  // Beam Spot Position
445  Acts::Vector3 beamPos( data.xbeam[0] * Acts::UnitConstants::mm,
446  data.ybeam[0] * Acts::UnitConstants::mm,
447  0. );
448 
449  // Magnetic Field
450  ATLASMagneticFieldWrapper magneticField;
451  Acts::MagneticFieldProvider::Cache magFieldCache = magneticField.makeCache( magFieldContext );
452  Acts::Vector3 bField = *magneticField.getField( beamPos,
453  magFieldCache );
454 
455  data.bField[0] = bField[0];
456  data.bField[1] = bField[1];
457  data.bField[2] = bField[2];
458 
459  data.K = 2. * s_toTesla / (300. * bField[2]);
460 
461  }

◆ convertPixelSeed()

bool ActsTrk::SiSpacePointsSeedMaker::convertPixelSeed ( const EventContext &  ctx,
InDet::SiSpacePointsSeedMakerEventData &  data,
const ActsTrk::SeedContainer &  seedPtrs 
) const
private

Definition at line 977 of file SiSpacePointsSeedMaker.cxx.

979  {
980  // If the read handle key for clusters is not empty, that means the xAOD->InDet Cluster link is available
981  // Else we can use xAOD->Trk Space Point link
982  // If none of these is available, we have a JO misconfguration!
983  static const SG::AuxElement::Accessor< ElementLink< InDet::PixelClusterCollection > > pixelLinkAcc("pixelClusterLink");
984  static const SG::AuxElement::Accessor< ElementLink< ::SpacePointCollection > > linkAcc("pixelSpacePointLink");
985 
986  if (m_useClusters) {
987  data.v_PixelSpacePointForSeed.clear();
988  }
989 
990  data.v_PixelSiSpacePointForSeed.clear();
991  data.v_PixelSiSpacePointForSeed.reserve(data.ns);
992  std::unordered_map<std::size_t, std::size_t> bridge_idx_sispacepoints;
993 
994  std::array<const Trk::SpacePoint*, 3> spacePoints {nullptr, nullptr, nullptr};
995  std::array<ITk::SiSpacePointForSeed*, 3> pixelSpacePointsForSeeds {nullptr, nullptr, nullptr};
996 
997  for (const ActsTrk::Seed seedProxy : seedPtrs) {
998  const ActsTrk::Seed* seed = &seedProxy; // keep old-style seed as pointer
999  std::array<std::size_t, 3> indexes {
1000  seed->sp()[0]->index(),
1001  seed->sp()[1]->index(),
1002  seed->sp()[2]->index()
1003  };
1004 
1005  const auto [bottom_idx, medium_idx, top_idx] = indexes;
1006  std::size_t max_index = std::max(bottom_idx, std::max(medium_idx, top_idx));
1007  if (data.v_PixelSpacePointForSeed.size() < max_index + 1) {
1008  data.v_PixelSpacePointForSeed.resize( max_index + 1 );
1009  }
1010 
1011  // Retrieve/make the space points!
1012  if (not m_useClusters) {
1013  // Get the Space Point from the element link
1014  if (not linkAcc.isAvailable(*seed->sp()[0])){
1015  ATH_MSG_FATAL("no pixelSpacePointLink for bottom sp!");
1016  return false;
1017  }
1018  if (not linkAcc.isAvailable(*seed->sp()[1])){
1019  ATH_MSG_FATAL("no pixelSpacePointLink for middle sp!");
1020  return false;
1021  }
1022  if (not linkAcc.isAvailable(*seed->sp()[2])){
1023  ATH_MSG_FATAL("no pixelSpacePointLink for top sp!");
1024  return false;
1025  }
1026 
1027  spacePoints = {
1028  *linkAcc(*seed->sp()[0]),
1029  *linkAcc(*seed->sp()[1]),
1030  *linkAcc(*seed->sp()[2])
1031  };
1032  }
1033  else {
1034  // Get the clusters from the xAOD::Clusters and then make the space points
1035  const xAOD::PixelCluster* bottom_cluster = reinterpret_cast<const xAOD::PixelCluster*>(seed->sp()[0]->measurements()[0]);
1036  const xAOD::PixelCluster* medium_cluster = reinterpret_cast<const xAOD::PixelCluster*>(seed->sp()[1]->measurements()[0]);
1037  const xAOD::PixelCluster* top_cluster = reinterpret_cast<const xAOD::PixelCluster*>(seed->sp()[2]->measurements()[0]);
1038 
1039  if (not pixelLinkAcc.isAvailable(*bottom_cluster)) {
1040  ATH_MSG_FATAL("no pixelClusterLink for cluster associated to bottom sp!");
1041  return false;
1042  }
1043  if (not pixelLinkAcc.isAvailable(*medium_cluster)) {
1044  ATH_MSG_FATAL("no pixelClusterLink for cluster associated to middle sp!");
1045  return false;
1046  }
1047  if (not pixelLinkAcc.isAvailable(*top_cluster)) {
1048  ATH_MSG_FATAL("no pixelClusterLink for cluster associated to top sp!");
1049  return false;
1050  }
1051 
1052  if (not data.v_PixelSpacePointForSeed[bottom_idx])
1053  data.v_PixelSpacePointForSeed[bottom_idx] = std::make_unique<InDet::PixelSpacePoint>(bottom_cluster->identifierHash(), *(pixelLinkAcc(*bottom_cluster)));
1054  if (not data.v_PixelSpacePointForSeed[medium_idx])
1055  data.v_PixelSpacePointForSeed[medium_idx] = std::make_unique<InDet::PixelSpacePoint>(medium_cluster->identifierHash(), *(pixelLinkAcc(*medium_cluster)));
1056  if (not data.v_PixelSpacePointForSeed[top_idx])
1057  data.v_PixelSpacePointForSeed[top_idx] = std::make_unique<InDet::PixelSpacePoint>(top_cluster->identifierHash(), *(pixelLinkAcc(*top_cluster)));
1058 
1059  spacePoints = {
1060  data.v_PixelSpacePointForSeed[bottom_idx].get(),
1061  data.v_PixelSpacePointForSeed[medium_idx].get(),
1062  data.v_PixelSpacePointForSeed[top_idx].get()
1063  };
1064 
1065  }
1066 
1067  for (int index = 0; index<3; ++index) {
1068  std::size_t sp_idx = indexes[index];
1069 
1070  // Try add an element.
1071  // If already there just return the old value
1072  // If not present, we add a new element to it
1073  auto [itr, outcome] = bridge_idx_sispacepoints.try_emplace(sp_idx, data.v_PixelSiSpacePointForSeed.size());
1074  std::size_t mapped_idx = itr->second;
1075  // We added a new element
1076  if (outcome) {
1077  std::array<float, 15> r;
1078  r[0] = seed->sp()[index]->x();
1079  r[1] = seed->sp()[index]->y();
1080  r[2] = seed->sp()[index]->z();
1081  pixInform(spacePoints[index], r.data());
1082  data.v_PixelSiSpacePointForSeed.emplace_back( spacePoints[index], r );
1083 
1084  }
1085  data.v_PixelSiSpacePointForSeed[mapped_idx].setQuality(-seed->seedQuality());
1086  pixelSpacePointsForSeeds[index] = &data.v_PixelSiSpacePointForSeed[mapped_idx];
1087  }
1088 
1089  data.i_ITkSeeds.emplace_back(pixelSpacePointsForSeeds[0],
1090  pixelSpacePointsForSeeds[1],
1091  pixelSpacePointsForSeeds[2],
1092  seed->z());
1093  data.i_ITkSeeds.back().setQuality(-seed->seedQuality());
1094  }
1095 
1096  return true;
1097  }

◆ convertStripSeed()

bool ActsTrk::SiSpacePointsSeedMaker::convertStripSeed ( const EventContext &  ctx,
InDet::SiSpacePointsSeedMakerEventData &  data,
const ActsTrk::SeedContainer &  seedPtrs 
) const
private

Definition at line 852 of file SiSpacePointsSeedMaker.cxx.

854  {
855  // If the read handle key for clusters is not empty, that means the xAOD->InDet Cluster link is available
856  // Else we can use xAOD->Trk Space Point link
857  // If none of these is available, we have a JO misconfguration!
858  static const SG::AuxElement::Accessor< ElementLink< ::SpacePointCollection > > linkAcc("sctSpacePointLink");
859  static const SG::AuxElement::Accessor< ElementLink< ::SpacePointOverlapCollection > > overlaplinkAcc("stripOverlapSpacePointLink");
860  static const SG::AuxElement::Accessor< ElementLink< InDet::SCT_ClusterCollection > > stripLinkAcc("sctClusterLink");
861 
862  if (m_useClusters) {
863  data.v_StripSpacePointForSeed.clear();
864  }
865 
866  std::array<const Trk::SpacePoint*, 3> spacePoints {};
867  std::array<ITk::SiSpacePointForSeed*, 3> stripSpacePointsForSeeds {};
868 
869  for (const ActsTrk::Seed seedProxy : seedPtrs) {
870  const ActsTrk::Seed* seed = &seedProxy; // keep old-style seed as pointer
871  // Retrieve/make space points
872  if (not m_useClusters) {
873  // Get the space point from the element link
874  if (not linkAcc.isAvailable(*seed->sp()[0]) and
875  not overlaplinkAcc.isAvailable(*seed->sp()[0])) {
876  ATH_MSG_FATAL("no sctSpacePointLink/stripOverlapSpacePointLink for bottom sp!");
877  return false;
878  }
879  if (not linkAcc.isAvailable(*seed->sp()[1]) and
880  not overlaplinkAcc.isAvailable(*seed->sp()[1])) {
881  ATH_MSG_FATAL("no sctSpacePointLink/stripOverlapSpacePointLink for middle sp!");
882  return false;
883  }
884  if (not linkAcc.isAvailable(*seed->sp()[2]) and
885  not overlaplinkAcc.isAvailable(*seed->sp()[2])) {
886  ATH_MSG_FATAL("no sctSpacePointLink/stripOverlapSpacePointLink for top sp!");
887  return false;
888  }
889 
890  for (std::size_t nsp(0ul); nsp < 3ul; ++nsp) {
891  spacePoints[nsp] = linkAcc.isAvailable(*seed->sp()[nsp])
892  ? *linkAcc(*seed->sp()[nsp])
893  : *overlaplinkAcc(*seed->sp()[nsp]);
894  }
895  }
896  else {
897  // Get the clusters from the xAOD::Clusters and then make the space points
898  const auto& bottom_idx = seed->sp()[0]->measurements();
899  const auto& medium_idx = seed->sp()[1]->measurements();
900  const auto& top_idx = seed->sp()[2]->measurements();
901 
902  std::array<const xAOD::StripCluster*, 6> strip_cluster {
903  reinterpret_cast<const xAOD::StripCluster*>(bottom_idx[0]),
904  reinterpret_cast<const xAOD::StripCluster*>(bottom_idx[1]),
905  reinterpret_cast<const xAOD::StripCluster*>(medium_idx[0]),
906  reinterpret_cast<const xAOD::StripCluster*>(medium_idx[1]),
907  reinterpret_cast<const xAOD::StripCluster*>(top_idx[0]),
908  reinterpret_cast<const xAOD::StripCluster*>(top_idx[1])
909  };
910 
911  if (not stripLinkAcc.isAvailable(*strip_cluster[0]) or
912  not stripLinkAcc.isAvailable(*strip_cluster[1])){
913  ATH_MSG_FATAL("no sctClusterLink for clusters associated to bottom sp!");
914  return false;
915  }
916  if (not stripLinkAcc.isAvailable(*strip_cluster[2]) or
917  not stripLinkAcc.isAvailable(*strip_cluster[3])){
918  ATH_MSG_FATAL("no sctClusterLink for clusters associated to middle sp!");
919  return false;
920  }
921  if (not stripLinkAcc.isAvailable(*strip_cluster[4]) or
922  not stripLinkAcc.isAvailable(*strip_cluster[5])){
923  ATH_MSG_FATAL("no sctClusterLink for clusters associated to top sp!");
924  return false;
925  }
926 
927  std::pair<std::size_t, std::size_t> key_b = std::make_pair(strip_cluster[0]->index(), strip_cluster[1]->index());
928  std::pair<std::size_t, std::size_t> key_m = std::make_pair(strip_cluster[2]->index(), strip_cluster[3]->index());
929  std::pair<std::size_t, std::size_t> key_t = std::make_pair(strip_cluster[4]->index(), strip_cluster[5]->index());
930 
931  std::unique_ptr<InDet::SCT_SpacePoint>& ptr_b = data.v_StripSpacePointForSeed[key_b];
932  if (!ptr_b) {
933  ptr_b = std::make_unique<InDet::SCT_SpacePoint>(std::make_pair<IdentifierHash, IdentifierHash>(strip_cluster[0]->identifierHash(), strip_cluster[1]->identifierHash()),
934  Amg::Vector3D(seed->sp()[0]->x(), seed->sp()[0]->y(), seed->sp()[0]->z()),
935  std::make_pair<const Trk::PrepRawData*, const Trk::PrepRawData*>(*(stripLinkAcc(*strip_cluster[0])), *(stripLinkAcc(*strip_cluster[1]))));
936  }
937  std::unique_ptr<InDet::SCT_SpacePoint>& ptr_m = data.v_StripSpacePointForSeed[key_m];
938  if (!ptr_m) {
939  ptr_m = std::make_unique<InDet::SCT_SpacePoint>(std::make_pair<IdentifierHash, IdentifierHash>(strip_cluster[2]->identifierHash(), strip_cluster[3]->identifierHash()),
940  Amg::Vector3D(seed->sp()[1]->x(), seed->sp()[1]->y(), seed->sp()[1]->z()),
941  std::make_pair<const Trk::PrepRawData*, const Trk::PrepRawData*>(*(stripLinkAcc(*strip_cluster[2])), *(stripLinkAcc(*strip_cluster[3]))));
942  }
943  std::unique_ptr<InDet::SCT_SpacePoint>& ptr_t = data.v_StripSpacePointForSeed[key_t];
944  if (!ptr_t) {
945  ptr_t = std::make_unique<InDet::SCT_SpacePoint>(std::make_pair<IdentifierHash, IdentifierHash>(strip_cluster[4]->identifierHash(), strip_cluster[5]->identifierHash()),
946  Amg::Vector3D(seed->sp()[2]->x(), seed->sp()[2]->y(), seed->sp()[2]->z()),
947  std::make_pair<const Trk::PrepRawData*, const Trk::PrepRawData*>(*(stripLinkAcc(*strip_cluster[4])), *(stripLinkAcc(*strip_cluster[5]))));
948  }
949 
950  spacePoints = {
951  data.v_StripSpacePointForSeed[key_b].get(),
952  data.v_StripSpacePointForSeed[key_m].get(),
953  data.v_StripSpacePointForSeed[key_t].get()
954  };
955 
956  }
957 
958  for (unsigned int index = 0; index<3; index++) {
959  std::array<float, 15> r;
960  r[0] = seed->sp()[index]->x();
961  r[1] = seed->sp()[index]->y();
962  r[2] = seed->sp()[index]->z();
963  stripInform(data, spacePoints[index], r);
964  stripSpacePointsForSeeds[index] = new ITk::SiSpacePointForSeed(spacePoints[index], r);
965  stripSpacePointsForSeeds[index]->setQuality(-seed->seedQuality());
966  }
967 
968  data.i_ITkSeeds.emplace_back(stripSpacePointsForSeeds[0], stripSpacePointsForSeeds[1],
969  stripSpacePointsForSeeds[2], seed->z());
970  data.i_ITkSeeds.back().setQuality(-seed->seedQuality());
971  }
972 
973  return true;
974  }

◆ dump()

MsgStream & ActsTrk::SiSpacePointsSeedMaker::dump ( InDet::SiSpacePointsSeedMakerEventData &  data,
MsgStream &  out 
) const
overridevirtual

Definition at line 746 of file SiSpacePointsSeedMaker.cxx.

748  {
749  if (data.nprint)
750  return dumpEvent(data, out);
751  return dumpConditions(data, out);
752  }

◆ dumpConditions()

MsgStream & ActsTrk::SiSpacePointsSeedMaker::dumpConditions ( InDet::SiSpacePointsSeedMakerEventData &  data,
MsgStream &  out 
) const
private

Definition at line 759 of file SiSpacePointsSeedMaker.cxx.

760  {
761  std::string s2, s3, s4, s5;
762 
763  int n = 42-m_actsSpacepointsPixel.key().size();
764  s2.append(n,' ');
765  s2.append("|");
766  n = 42-m_actsSpacepointsStrip.key().size();
767  s3.append(n,' ');
768  s3.append("|");
769  n = 42-m_actsSpacepointsOverlap.key().size();
770  s4.append(n,' ');
771  s4.append("|");
772  n = 42-m_beamSpotKey.key().size();
773  s5.append(n,' ');
774  s5.append("|");
775 
776  out<<"|---------------------------------------------------------------------|"
777  <<endmsg;
778  out<<"| Pixel space points | "<<m_actsSpacepointsPixel.key() <<s2
779  <<endmsg;
780  out<<"| Strip space points | "<<m_actsSpacepointsStrip.key()<<s3
781  <<endmsg;
782  out<<"| Overlap space points | "<<m_actsSpacepointsOverlap.key()<<s4
783  <<endmsg;
784  out<<"| BeamConditionsService | "<<m_beamSpotKey.key()<<s5
785  <<endmsg;
786  out<<"| usePixel | "
787  <<std::setw(12)<<m_pixel
788  <<" |"<<endmsg;
789  out<<"| useStrip | "
790  <<std::setw(12)<<m_strip
791  <<" |"<<endmsg;
792  out<<"| useStripOverlap | "
793  <<std::setw(12)<<m_useOverlap
794  <<" |"<<endmsg;
795  out<<"|---------------------------------------------------------------------|"
796  <<endmsg;
797  out<<"| Beam X center | "
798  <<std::setw(12)<<std::setprecision(5)<<data.xbeam[0]
799  <<" |"<<endmsg;
800  out<<"| Beam Y center | "
801  <<std::setw(12)<<std::setprecision(5)<<data.ybeam[0]
802  <<" |"<<endmsg;
803  out<<"| Beam Z center | "
804  <<std::setw(12)<<std::setprecision(5)<<data.zbeam[0]
805  <<" |"<<endmsg;
806  out<<"| Beam X-axis direction | "
807  <<std::setw(12)<<std::setprecision(5)<<data.xbeam[1]
808  <<std::setw(12)<<std::setprecision(5)<<data.xbeam[2]
809  <<std::setw(12)<<std::setprecision(5)<<data.xbeam[3]
810  <<" |"<<endmsg;
811  out<<"| Beam Y-axis direction | "
812  <<std::setw(12)<<std::setprecision(5)<<data.ybeam[1]
813  <<std::setw(12)<<std::setprecision(5)<<data.ybeam[2]
814  <<std::setw(12)<<std::setprecision(5)<<data.ybeam[3]
815  <<" |"<<endmsg;
816  out<<"| Beam Z-axis direction | "
817  <<std::setw(12)<<std::setprecision(5)<<data.zbeam[1]
818  <<std::setw(12)<<std::setprecision(5)<<data.zbeam[2]
819  <<std::setw(12)<<std::setprecision(5)<<data.zbeam[3]
820  <<" |"<<endmsg;
821  out<<"|---------------------------------------------------------------------|"
822  <<endmsg;
823  return out;
824 
825  }

◆ dumpEvent()

MsgStream & ActsTrk::SiSpacePointsSeedMaker::dumpEvent ( InDet::SiSpacePointsSeedMakerEventData &  data,
MsgStream &  out 
)
staticprivate

Definition at line 831 of file SiSpacePointsSeedMaker.cxx.

833  {
834  out<<"|---------------------------------------------------------------------|"
835  <<endmsg;
836  out<<"| ns | "
837  <<std::setw(12)<<data.ns
838  <<" |"<<endmsg;
839  out<<"| nsaz | "
840  <<std::setw(12)<<data.nsaz
841  <<" |"<<endmsg;
842  out<<"| seeds | "
843  <<std::setw(12)<< data.nsazv
844  <<" |"<<endmsg;
845  out<<"|---------------------------------------------------------------------|"
846  <<endmsg;
847  return out;
848 
849  }

◆ find2Sp()

virtual void ActsTrk::SiSpacePointsSeedMaker::find2Sp ( InDet::SiSpacePointsSeedMakerEventData &  ,
const std::list< Trk::Vertex > &   
) const
inlineoverridevirtual

Definition at line 105 of file SiSpacePointsSeedMaker.h.

107  {
108  ATH_MSG_ERROR("Method `findfind2Sp` is not implemented.");
109  }

◆ find3Sp() [1/2]

virtual void ActsTrk::SiSpacePointsSeedMaker::find3Sp ( const EventContext &  ,
InDet::SiSpacePointsSeedMakerEventData &  ,
const std::list< Trk::Vertex > &  ,
const double *   
) const
inlineoverridevirtual

with three space points with or without vertex constraint with information about min and max Z of the vertex

Definition at line 114 of file SiSpacePointsSeedMaker.h.

118  {
119  ATH_MSG_ERROR("Method `find3Sp` is not implemented.");
120  }

◆ find3Sp() [2/2]

void ActsTrk::SiSpacePointsSeedMaker::find3Sp ( const EventContext &  ctx,
InDet::SiSpacePointsSeedMakerEventData &  data,
const std::list< Trk::Vertex > &  lv 
) const
overridevirtual

Definition at line 593 of file SiSpacePointsSeedMaker.cxx.

596  {
597  // Fast return if no sps are collected
598  if ( data.v_ActsSpacePointForSeed.empty() )
599  return;
600 
601  // select the ACTS seeding tool to call, if for PPP or SSS
602  bool isPixel = (m_fastTracking or data.iteration == 1) and m_pixel;
603 
604  // this is use for a fast retrieval of the space points later
605  std::vector<ITk::SiSpacePointForSeed*> sp_storage;
606 
607  // We can now run the Acts Seeding
608  std::unique_ptr< ActsTrk::SeedContainer > seedPtrs = std::make_unique< ActsTrk::SeedContainer >();
609  //cppcheck-suppress unreadVariable
610  std::string combinationType = isPixel ? "PPP" : "SSS";
611  ATH_MSG_DEBUG("Running Seed Finding (" << combinationType << ") ...");
612 
613  // Beam Spot Position
614  Acts::Vector3 beamPos( data.xbeam[0] * Acts::UnitConstants::mm,
615  data.ybeam[0] * Acts::UnitConstants::mm,
616  data.zbeam[0] * Acts::UnitConstants::mm);
617 
618  Acts::Vector3 bField( data.bField[0], data.bField[1], data.bField[2] );
619 
620 
621  ActsTrk::SpacePointCollector backEnd(data.v_ActsSpacePointForSeed);
622 
623  Acts::SpacePointContainerConfig spConfig;
624  spConfig.useDetailedDoubleMeasurementInfo = not isPixel;
625  // Options
626  Acts::SpacePointContainerOptions spOptions;
627  spOptions.beamPos = Acts::Vector2(beamPos.x(), beamPos.y());
628 
629  Acts::SpacePointContainer<decltype(backEnd), Acts::detail::RefHolder> collect(spConfig, spOptions, backEnd);
630 
631 
632  StatusCode sc;
633 
634  if (isPixel)
635  sc = m_seedsToolPixel->createSeeds( ctx,
636  collect,
637  beamPos,
638  bField,
639  *seedPtrs.get() );
640  else {
641  sc = m_seedsToolStrip->createSeeds( ctx,
642  collect,
643  beamPos,
644  bField,
645  *seedPtrs.get() );
646  }
647 
648  if (sc == StatusCode::FAILURE) {
649  ATH_MSG_ERROR("Error during seed production (" << combinationType << ")");
650  return;
651  }
652 
653  ATH_MSG_DEBUG(" \\__ Created " << seedPtrs->size() << " seeds");
654  data.nsazv = seedPtrs->size();
655 
656  // Store seeds to data
657  // We need now to convert the output to Athena object once again (i.e. ITk::SiSpacePointForSeed)
658  // The seeds will be stored in data.i_ITkSeeds (both PPP and SSS seeds)
659  if (m_doSeedConversion) {
660 
661  if (isPixel) {
662  if (not convertPixelSeed(ctx, data, *seedPtrs.get())) {
663  ATH_MSG_FATAL("Error in pixel seed conversion");
664  return;
665  }
666  } else {
667  if (not convertStripSeed(ctx, data, *seedPtrs.get())) {
668  ATH_MSG_FATAL("Error in strip seed conversion");
669  return;
670  }
671  }
672  }
673 
674  data.i_ITkSeed = data.i_ITkSeeds.begin();
675  data.nprint = 1;
676  dump(data, msg(MSG::DEBUG));
677  }

◆ findVSp()

virtual void ActsTrk::SiSpacePointsSeedMaker::findVSp ( const EventContext &  ,
InDet::SiSpacePointsSeedMakerEventData &  ,
const std::list< Trk::Vertex > &   
) const
inlineoverridevirtual

with variable number space points with or without vertex constraint Variable means (2,3,4,....) any number space points

Definition at line 125 of file SiSpacePointsSeedMaker.h.

128  {
129  ATH_MSG_ERROR("Method `findVSp` is not implemented.");
130  }

◆ getWriteNtupleBoolProperty()

bool ActsTrk::SiSpacePointsSeedMaker::getWriteNtupleBoolProperty ( ) const
overridevirtual

Definition at line 742 of file SiSpacePointsSeedMaker.cxx.

743  { return m_writeNtuple; }

◆ initialize()

StatusCode ActsTrk::SiSpacePointsSeedMaker::initialize ( )
overridevirtual

Definition at line 40 of file SiSpacePointsSeedMaker.cxx.

41  {
42  ATH_MSG_DEBUG( "Initializing " << name() << "..." );
43 
44  ATH_MSG_DEBUG( "Properties Summary:" );
45  ATH_MSG_DEBUG( " " << m_pixel );
46  ATH_MSG_DEBUG( " " << m_strip );
47  ATH_MSG_DEBUG( " " << m_useOverlap );
48  ATH_MSG_DEBUG( " " << m_writeNtuple );
49  ATH_MSG_DEBUG( " " << m_fastTracking );
50 
51  if (not m_pixel and not m_strip) {
52  ATH_MSG_ERROR("Activate seeding on at least one between Pixel and Strip space point collections!");
53  return StatusCode::FAILURE;
54  }
55 
56  ATH_CHECK( m_actsSpacepointsPixel.initialize(m_pixel) );
57  ATH_CHECK( m_actsSpacepointsStrip.initialize(m_strip) );
58  ATH_CHECK( m_actsSpacepointsOverlap.initialize(m_strip and m_useOverlap) );
59 
60  ATH_CHECK( m_seedsToolPixel.retrieve(EnableTool{m_pixel}) );
61  ATH_CHECK( m_seedsToolStrip.retrieve(EnableTool{m_strip}) );
62 
63  ATH_CHECK( m_prdToTrackMap.initialize(not m_prdToTrackMap.empty() ) );
64 
65  ATH_CHECK( m_beamSpotKey.initialize() );
66  ATH_CHECK( m_fieldCondObjInputKey.initialize() );
67 
68  ATH_CHECK(m_pixelDetEleCollKey.initialize());
69  ATH_CHECK(m_stripDetEleCollKey.initialize());
70 
71  // Validation
72  if (m_writeNtuple)
73  ATH_CHECK( InitTree() );
74 
75  return StatusCode::SUCCESS;
76  }

◆ InitTree()

StatusCode ActsTrk::SiSpacePointsSeedMaker::InitTree ( )
private

Definition at line 81 of file SiSpacePointsSeedMaker.cxx.

82  {
83  ATH_CHECK( m_thistSvc.retrieve() );
84  std::string tree_name = std::string("SeedTree_") + name();
85  std::replace( tree_name.begin(), tree_name.end(), '.', '_' );
86 
87  m_outputTree = new TTree( tree_name.c_str() , "ActsSeedMakerValTool");
88 
89  m_outputTree->Branch("eventNumber", &m_eventNumber,"eventNumber/L");
90  m_outputTree->Branch("d0", &m_d0);
91  m_outputTree->Branch("z0", &m_z0);
92  m_outputTree->Branch("pt", &m_pt);
93  m_outputTree->Branch("eta", &m_eta);
94  m_outputTree->Branch("x1", &m_x1);
95  m_outputTree->Branch("x2", &m_x2);
96  m_outputTree->Branch("x3", &m_x3);
97  m_outputTree->Branch("y1", &m_y1);
98  m_outputTree->Branch("y2", &m_y2);
99  m_outputTree->Branch("y3", &m_y3);
100  m_outputTree->Branch("z1", &m_z1);
101  m_outputTree->Branch("z2", &m_z2);
102  m_outputTree->Branch("z3", &m_z3);
103  m_outputTree->Branch("r1", &m_r1);
104  m_outputTree->Branch("r2", &m_r2);
105  m_outputTree->Branch("r3", &m_r3);
106  m_outputTree->Branch("quality", &m_quality);
107  m_outputTree->Branch("seedType", &m_type);
108  m_outputTree->Branch("givesTrack", &m_givesTrack);
109  m_outputTree->Branch("dzdr_b", &m_dzdr_b);
110  m_outputTree->Branch("dzdr_t", &m_dzdr_t);
111  m_outputTree->Branch("track_pt", &m_trackPt);
112  m_outputTree->Branch("track_eta", &m_trackEta);
113 
114  std::string full_tree_name = "/" + m_treeFolder + "/" + tree_name;
115  ATH_CHECK( m_thistSvc->regTree( full_tree_name.c_str(), m_outputTree ) );
116 
117  return StatusCode::SUCCESS;
118  }

◆ isUsed() [1/2]

bool ActsTrk::SiSpacePointsSeedMaker::isUsed ( const Trk::SpacePoint *  sp,
const Trk::PRDtoTrackMap &  prd_to_track_map 
) const
inlineprivate

Definition at line 267 of file SiSpacePointsSeedMaker.h.

269  {
270  const Trk::PrepRawData* d = sp->clusterList().first;
271  if (!d || !prd_to_track_map.isUsed(*d)) return false;
272 
273  d = sp->clusterList().second;
274  if (!d || prd_to_track_map.isUsed(*d)) return true;
275 
276  return false;
277  }

◆ isUsed() [2/2]

bool ActsTrk::SiSpacePointsSeedMaker::isUsed ( const xAOD::SpacePoint *  sp,
const Trk::PRDtoTrackMap &  prd_to_track_map 
) const
inlineprivate

Definition at line 280 of file SiSpacePointsSeedMaker.h.

281  {
282  static const SG::AuxElement::ConstAccessor< ElementLink< ::SpacePointCollection > > pixelLinkAcc("pixelSpacePointLink");
283  static const SG::AuxElement::ConstAccessor< ElementLink< ::SpacePointCollection > > stripLinkAcc("sctSpacePointLink");
284  static const SG::AuxElement::ConstAccessor< ElementLink< ::SpacePointOverlapCollection > > stripOverlapLinkacc("stripOverlapSpacePointLink");
285 
286  const Trk::SpacePoint *indetSp = nullptr;
287  if ( pixelLinkAcc.isAvailable(*sp) ) {
288  const ElementLink< ::SpacePointCollection > link = pixelLinkAcc( *sp );
289  indetSp = *link;
290  }
291  else if ( stripLinkAcc.isAvailable(*sp) ) {
292  const ElementLink< ::SpacePointCollection > link = stripLinkAcc( *sp );
293  indetSp = *link;
294  } else if ( stripOverlapLinkacc.isAvailable(*sp) ) {
295  const ElementLink< ::SpacePointOverlapCollection > link = stripOverlapLinkacc( *sp );
296  indetSp = *link;
297  } else {
298  return false;
299  }
300 
301  return isUsed(indetSp, prd_to_track_map);
302  }

◆ newEvent()

void ActsTrk::SiSpacePointsSeedMaker::newEvent ( const EventContext &  ctx,
InDet::SiSpacePointsSeedMakerEventData &  data,
int  iteration = -1 
) const
overridevirtual

Definition at line 521 of file SiSpacePointsSeedMaker.cxx.

524  {
525  // Store iteration into data for use in other methods
526  data.iteration = iteration;
527  if (iteration < 0)
528  data.iteration = 0;
529 
530  // At the beginning of each iteration
531  // clearing list of space points to be used for seeding
532  InDet::SiSpacePointsSeedMakerEventData::clearPoolList(data.l_ITkSpacePointForSeed);
533  data.i_ITkSpacePointForSeed = data.l_ITkSpacePointForSeed.begin();
534  data.v_ActsSpacePointForSeed.clear();
535 
536 
537  // clearing list of produced seeds
538  InDet::SiSpacePointsSeedMakerEventData::clearPoolList(data.i_ITkSeeds);
539  data.i_ITkSeed = data.i_ITkSeeds.begin();
540 
541  // First iteration:
542  // -- event-specific configuration, i.e. beamspot and magnetic field
543  // -- for default case: producing SSS
544  // -- for fast tracking: producing PPP
545  // Second iteration:
546  // -- for default case: producing PPP
547  // -- no additional iteration is foreseen for fast tracking case
548 
549  bool isPixel = (m_fastTracking or data.iteration == 1) and m_pixel;
550  bool isStrip = not m_fastTracking and data.iteration == 0 and m_strip;
551 
552  // The Acts Seed tool requires beamspot information for the space points already here
553  if (data.iteration == 0)
554  buildBeamFrameWork(ctx, data);
555 
556  // initialising the number of space points as well
557  data.ns = 0;
558  data.nsaz = 0;
559  data.nsazv = 0;
560 
561  // Retrieve the Trk::PRDtoTrackMap
562  const Trk::PRDtoTrackMap *prd_to_track_map_cptr = nullptr;
563  if ( not m_prdToTrackMap.empty() ) {
564  SG::ReadHandle<Trk::PRDtoTrackMap> prd_handle = SG::makeHandle( m_prdToTrackMap, ctx );
565  if ( not prd_handle.isValid() ) {
566  ATH_MSG_ERROR("Failed to read PRD to track association map: " << m_prdToTrackMap.key());
567  }
568  prd_to_track_map_cptr = prd_handle.get();
569  }
570 
571  // Only retrieving the collections needed for the seed formation,
572  // depending on the tool configuration and iteration
573 
574  // Retrieve Pixels
575  if (isPixel and not retrievePixel(ctx, data, prd_to_track_map_cptr).isSuccess() ) {
576  ATH_MSG_ERROR("Error while retrieving Pixel space points with key " << m_actsSpacepointsPixel.key());
577  }
578 
579  // Retrieve Strips
580  if (isStrip and not retrieveStrip(ctx, data, prd_to_track_map_cptr).isSuccess() ) {
581  ATH_MSG_ERROR("Error while retrieving Strip space points with key " << m_actsSpacepointsStrip.key());
582  }
583 
584  // Retrieve Overlaps, will go into Strip collection
585  if ((isStrip and m_useOverlap) and not retrieveOverlap(ctx, data, prd_to_track_map_cptr).isSuccess() ) {
586  ATH_MSG_ERROR("Error while retrieving Strip Overlap space points with key " << m_actsSpacepointsOverlap.key());
587  }
588 
589  data.initialized = true;
590  }

◆ newRegion() [1/2]

void ActsTrk::SiSpacePointsSeedMaker::newRegion ( const EventContext &  ctx,
InDet::SiSpacePointsSeedMakerEventData &  data,
const std::vector< IdentifierHash > &  vPixel,
const std::vector< IdentifierHash > &  vStrip 
) const
overridevirtual

Definition at line 469 of file SiSpacePointsSeedMaker.cxx.

473  {
474  ATH_MSG_DEBUG("Calling " << name() << "::newRegion");
475  if (!m_pixel && !m_strip)
476  return;
477 
478  InDet::SiSpacePointsSeedMakerEventData::clearPoolList(data.l_ITkSpacePointForSeed);
479  data.i_ITkSpacePointForSeed = data.l_ITkSpacePointForSeed.begin();
480  data.v_ActsSpacePointForSeed.clear();
481 
482  InDet::SiSpacePointsSeedMakerEventData::clearPoolList(data.i_ITkSeeds);
483  data.i_ITkSeed = data.i_ITkSeeds.begin();
484 
485  buildBeamFrameWork(ctx, data);
486 
487  data.ns = 0;
488  data.nsaz = 0;
489  data.nsazv = 0;
490 
491  const Trk::PRDtoTrackMap *prd_to_track_map_cptr = nullptr;
492  if ( not m_prdToTrackMap.empty() ) {
493  SG::ReadHandle<Trk::PRDtoTrackMap> prd_handle = SG::makeHandle( m_prdToTrackMap, ctx );
494  if ( not prd_handle.isValid() ) {
495  ATH_MSG_ERROR("Failed to read PRD to track association map: " << m_prdToTrackMap.key());
496  }
497  prd_to_track_map_cptr = prd_handle.get();
498  }
499  if (prd_to_track_map_cptr != nullptr) {
500  ATH_MSG_DEBUG("Retrieved prd map with name " << m_prdToTrackMap.key());
501  }
502 
503  if ( not retrievePixel(ctx, data, vPixel, prd_to_track_map_cptr).isSuccess() ) {
504  ATH_MSG_ERROR("Error while retrieving Pixel space points with key " << m_actsSpacepointsPixel.key());
505  }
506 
507  if ( not retrieveStrip(ctx, data, vStrip, prd_to_track_map_cptr).isSuccess() ) {
508  ATH_MSG_ERROR("Error while retrieving Strip space points with key " << m_actsSpacepointsStrip.key());
509  }
510 
511  if ( m_useOverlap and not retrieveOverlap(ctx, data, prd_to_track_map_cptr).isSuccess() ) {
512  ATH_MSG_ERROR("Error while retrieving Strip Overlap space points with key " << m_actsSpacepointsOverlap.key());
513  }
514 
515  data.initialized = true;
516  }

◆ newRegion() [2/2]

virtual void ActsTrk::SiSpacePointsSeedMaker::newRegion ( const EventContext &  ,
InDet::SiSpacePointsSeedMakerEventData &  ,
const std::vector< IdentifierHash > &  ,
const std::vector< IdentifierHash > &  ,
const IRoiDescriptor &   
) const
inlineoverridevirtual

Definition at line 95 of file SiSpacePointsSeedMaker.h.

100  {
101  ATH_MSG_ERROR("Method `newRegion` is not implemented.");
102  }

◆ newSpacePoint()

void ActsTrk::SiSpacePointsSeedMaker::newSpacePoint ( InDet::SiSpacePointsSeedMakerEventData &  data,
const xAOD::SpacePoint *  sp 
) const
private

Definition at line 121 of file SiSpacePointsSeedMaker.cxx.

123  {
124 
125  data.v_ActsSpacePointForSeed.emplace_back(sp);
126  data.ns++;
127  data.nsaz++;
128  }

◆ next()

const InDet::SiSpacePointsSeed * ActsTrk::SiSpacePointsSeedMaker::next ( const EventContext &  ctx,
InDet::SiSpacePointsSeedMakerEventData &  data 
) const
overridevirtual

then return this next seed candidate

Definition at line 680 of file SiSpacePointsSeedMaker.cxx.

682  {
683 
684  do {
685  if (data.i_ITkSeed == data.i_ITkSeeds.end())
686  return nullptr;
687 
688  // iterate until we find a valid seed satisfying certain quality cuts in set3
689  } while (!(*data.i_ITkSeed++).set3(data.seedOutput, 1./(1000. * data.K)));
690 
692  return &data.seedOutput;
693 
694  }

◆ pixInform()

static void ActsTrk::SiSpacePointsSeedMaker::pixInform ( const Trk::SpacePoint *  sp,
float *  r 
)
staticprivate

◆ retrieveOverlap() [1/2]

StatusCode ActsTrk::SiSpacePointsSeedMaker::retrieveOverlap ( const EventContext &  ctx,
InDet::SiSpacePointsSeedMakerEventData &  data,
const std::vector< IdentifierHash > &  ids,
const Trk::PRDtoTrackMap *  prd_to_track_map_cptr 
) const
private

Definition at line 352 of file SiSpacePointsSeedMaker.cxx.

356  {
357  if (ids.empty()) return StatusCode::SUCCESS;
358 
359  ATH_MSG_DEBUG("Retrieving strip overlap space point collection " << m_actsSpacepointsOverlap.key());
360  SG::ReadHandle< xAOD::SpacePointContainer > inputSpacePointContainer( m_actsSpacepointsOverlap, ctx );
361  if (not inputSpacePointContainer.isValid()){
362  ATH_MSG_FATAL("xAOD::SpacePointContainer with key " << m_actsSpacepointsOverlap.key() << " is not available...");
363  return StatusCode::FAILURE;
364  }
365  const xAOD::SpacePointContainer *inputCollection = inputSpacePointContainer.cptr();
366 
367  ATH_MSG_DEBUG("Retrieving SiDetectorElementCollection with key `" << m_stripDetEleCollKey.key() << "`");
368  SG::ReadCondHandle< InDetDD::SiDetectorElementCollection > detEleHandle = SG::makeHandle( m_stripDetEleCollKey, ctx );
369  ATH_CHECK(detEleHandle.isValid());
370  const InDetDD::SiDetectorElementCollection* detElements = detEleHandle.cptr();
371 
372  ContainerAccessor< xAOD::SpacePoint, IdentifierHash, 1>
373  accessor ( *inputCollection,
374  [] (const xAOD::SpacePoint& coll) -> IdentifierHash
375  { return coll.elementIdList()[0]; },
376  detElements->size());
377 
378  for (const IdentifierHash id : ids) {
379  if (not accessor.isIdentifierPresent(id)) {
380  continue;
381  }
382 
383  const auto& ranges = accessor.rangesForIdentifierDirect(id);
384  for (auto [firstElement, lastElement] : ranges) {
385  for (; firstElement != lastElement; ++firstElement) {
386  const xAOD::SpacePoint *sp = *firstElement;
387  if (prd_to_track_map_cptr != nullptr and isUsed(sp, *prd_to_track_map_cptr)) continue;
388  newSpacePoint(data, sp);
389  }
390  }
391  }
392 
393  return StatusCode::SUCCESS;
394  }

◆ retrieveOverlap() [2/2]

StatusCode ActsTrk::SiSpacePointsSeedMaker::retrieveOverlap ( const EventContext &  ctx,
InDet::SiSpacePointsSeedMakerEventData &  data,
const Trk::PRDtoTrackMap *  prd_to_track_map_cptr 
) const
private

Definition at line 328 of file SiSpacePointsSeedMaker.cxx.

331  {
332  // get the xAOD::SpacePointContainer and loop on entries to check which space point
333  // you want to use for seeding
334  ATH_MSG_DEBUG("Retrieving strip overlap space point collection " << m_actsSpacepointsOverlap.key());
335  SG::ReadHandle< xAOD::SpacePointContainer > inputSpacePointContainer( m_actsSpacepointsOverlap, ctx );
336  if (!inputSpacePointContainer.isValid()){
337  ATH_MSG_FATAL("xAOD::SpacePointContainer with key " << m_actsSpacepointsOverlap.key() << " is not available...");
338  return StatusCode::FAILURE;
339  }
340  const xAOD::SpacePointContainer* inputSpacePointCollection = inputSpacePointContainer.cptr();
341  // TODO: here you need to write some lines to implement the
342  // check on the used PDRs in previous tracking passes
343  for (const xAOD::SpacePoint * sp : *inputSpacePointCollection) {
344  if (prd_to_track_map_cptr != nullptr and isUsed(sp, *prd_to_track_map_cptr)) continue;
345  newSpacePoint(data, sp);
346  }
347 
348  return StatusCode::SUCCESS;
349  }

◆ retrievePixel() [1/2]

StatusCode ActsTrk::SiSpacePointsSeedMaker::retrievePixel ( const EventContext &  ctx,
InDet::SiSpacePointsSeedMakerEventData &  data,
const std::vector< IdentifierHash > &  ids,
const Trk::PRDtoTrackMap *  prd_to_track_map_cptr = nullptr 
) const
private

Definition at line 212 of file SiSpacePointsSeedMaker.cxx.

216  {
217  if (ids.empty()) return StatusCode::SUCCESS;
218 
219  ATH_MSG_DEBUG("Retrieving pixel space point collection " << m_actsSpacepointsPixel.key());
220  SG::ReadHandle< xAOD::SpacePointContainer > inputSpacePointContainer( m_actsSpacepointsPixel, ctx );
221  if (not inputSpacePointContainer.isValid()){
222  ATH_MSG_FATAL("xAOD::SpacePointContainer with key " << m_actsSpacepointsPixel.key() << " is not available...");
223  return StatusCode::FAILURE;
224  }
225  const xAOD::SpacePointContainer *inputCollection = inputSpacePointContainer.cptr();
226 
227  ATH_MSG_DEBUG("Retrieving SiDetectorElementCollection with key `" << m_pixelDetEleCollKey.key() << "`");
228  SG::ReadCondHandle< InDetDD::SiDetectorElementCollection > detEleHandle = SG::makeHandle( m_pixelDetEleCollKey, ctx );
229  ATH_CHECK(detEleHandle.isValid());
230  const InDetDD::SiDetectorElementCollection* detElements = detEleHandle.cptr();
231 
232  ContainerAccessor< xAOD::SpacePoint, IdentifierHash, 1>
233  accessor ( *inputCollection,
234  [] (const xAOD::SpacePoint& coll) -> IdentifierHash
235  { return coll.elementIdList()[0]; },
236  detElements->size());
237 
238  for (const IdentifierHash id : ids) {
239  if (not accessor.isIdentifierPresent(id)) {
240  continue;
241  }
242 
243  const auto& ranges = accessor.rangesForIdentifierDirect(id);
244  for (auto [firstElement, lastElement] : ranges) {
245  for (; firstElement != lastElement; ++firstElement) {
246  const xAOD::SpacePoint *sp = *firstElement;
247  if (prd_to_track_map_cptr != nullptr and isUsed(sp, *prd_to_track_map_cptr)) continue;
248  newSpacePoint(data, sp);
249  }
250  }
251  }
252 
253  return StatusCode::SUCCESS;
254  }

◆ retrievePixel() [2/2]

StatusCode ActsTrk::SiSpacePointsSeedMaker::retrievePixel ( const EventContext &  ctx,
InDet::SiSpacePointsSeedMakerEventData &  data,
const Trk::PRDtoTrackMap *  prd_to_track_map_cptr 
) const
private

Definition at line 188 of file SiSpacePointsSeedMaker.cxx.

191  {
192  // get the xAOD::SpacePointContainer and loop on entries to check which space point
193  // you want to use for seeding
194  ATH_MSG_DEBUG("Retrieving pixel space point collection " << m_actsSpacepointsPixel.key());
195  SG::ReadHandle< xAOD::SpacePointContainer > inputSpacePointContainer( m_actsSpacepointsPixel, ctx );
196  if (not inputSpacePointContainer.isValid()){
197  ATH_MSG_FATAL("xAOD::SpacePointContainer with key " << m_actsSpacepointsPixel.key() << " is not available...");
198  return StatusCode::FAILURE;
199  }
200  const xAOD::SpacePointContainer* inputSpacePointCollection = inputSpacePointContainer.cptr();
201  // TODO: here you need to write some lines to implement the
202  // check on the used PDRs in previous tracking passes
203  for (const xAOD::SpacePoint * sp : *inputSpacePointCollection) {
204  if (prd_to_track_map_cptr != nullptr and isUsed(sp, *prd_to_track_map_cptr)) continue;
205  newSpacePoint(data, sp);
206  }
207 
208  return StatusCode::SUCCESS;
209  }

◆ retrieveStrip() [1/2]

StatusCode ActsTrk::SiSpacePointsSeedMaker::retrieveStrip ( const EventContext &  ctx,
InDet::SiSpacePointsSeedMakerEventData &  data,
const std::vector< IdentifierHash > &  ids,
const Trk::PRDtoTrackMap *  prd_to_track_map_cptr = nullptr 
) const
private

Definition at line 281 of file SiSpacePointsSeedMaker.cxx.

286  {
287  if (ids.empty()) return StatusCode::SUCCESS;
288 
289  ATH_MSG_DEBUG("Retrieving strip space point collection " << m_actsSpacepointsStrip.key());
290  SG::ReadHandle< xAOD::SpacePointContainer > inputSpacePointContainer( m_actsSpacepointsStrip, ctx );
291  if (not inputSpacePointContainer.isValid()){
292  ATH_MSG_FATAL("xAOD::SpacePointContainer with key " << m_actsSpacepointsStrip.key() << " is not available...");
293  return StatusCode::FAILURE;
294  }
295  const xAOD::SpacePointContainer *inputCollection = inputSpacePointContainer.cptr();
296 
297  ATH_MSG_DEBUG("Retrieving SiDetectorElementCollection with key `" << m_stripDetEleCollKey.key() << "`");
298  SG::ReadCondHandle< InDetDD::SiDetectorElementCollection > detEleHandle = SG::makeHandle( m_stripDetEleCollKey, ctx );
299  ATH_CHECK(detEleHandle.isValid());
300  const InDetDD::SiDetectorElementCollection* detElements = detEleHandle.cptr();
301 
302  ContainerAccessor< xAOD::SpacePoint, IdentifierHash, 1>
303  accessor ( *inputCollection,
304  [] (const xAOD::SpacePoint& coll) -> IdentifierHash
305  { return coll.elementIdList()[0]; },
306  detElements->size());
307 
308  for (const IdentifierHash id : ids) {
309  if (not accessor.isIdentifierPresent(id)) {
310  continue;
311  }
312 
313  const auto& ranges = accessor.rangesForIdentifierDirect(id);
314  for (auto [firstElement, lastElement] : ranges) {
315  for (; firstElement != lastElement; ++firstElement) {
316  const xAOD::SpacePoint *sp = *firstElement;
317  if (prd_to_track_map_cptr != nullptr and isUsed(sp, *prd_to_track_map_cptr)) continue;
318  newSpacePoint(data, sp);
319  }
320  }
321  }
322 
323  return StatusCode::SUCCESS;
324  }

◆ retrieveStrip() [2/2]

StatusCode ActsTrk::SiSpacePointsSeedMaker::retrieveStrip ( const EventContext &  ctx,
InDet::SiSpacePointsSeedMakerEventData &  data,
const Trk::PRDtoTrackMap *  prd_to_track_map_cptr 
) const
private

Definition at line 257 of file SiSpacePointsSeedMaker.cxx.

260  {
261  // get the xAOD::SpacePointContainer and loop on entries to check which space point
262  // you want to use for seeding
263  ATH_MSG_DEBUG("Retrieving strip space point collection " << m_actsSpacepointsStrip.key());
264  SG::ReadHandle< xAOD::SpacePointContainer > inputSpacePointContainer( m_actsSpacepointsStrip, ctx );
265  if (!inputSpacePointContainer.isValid()){
266  ATH_MSG_FATAL("xAOD::SpacePointContainer with key " << m_actsSpacepointsStrip.key() << " is not available...");
267  return StatusCode::FAILURE;
268  }
269  const xAOD::SpacePointContainer* inputSpacePointCollection = inputSpacePointContainer.cptr();
270  // TODO: here you need to write some lines to implement the
271  // check on the used PDRs in previous tracking passes
272  for (const xAOD::SpacePoint * sp : *inputSpacePointCollection) {
273  if (prd_to_track_map_cptr != nullptr and isUsed(sp, *prd_to_track_map_cptr)) continue;
274  newSpacePoint(data, sp);
275  }
276 
277  return StatusCode::SUCCESS;
278  }

◆ stripInform()

void ActsTrk::SiSpacePointsSeedMaker::stripInform ( InDet::SiSpacePointsSeedMakerEventData &  data,
const Trk::SpacePoint *  sp,
std::span< float, 15 >  r 
)
staticprivate

Definition at line 142 of file SiSpacePointsSeedMaker.cxx.

145  {
146  const InDet::SiCluster *c0 = static_cast<const InDet::SiCluster *>(sp->clusterList().first);
147  const InDet::SiCluster *c1 = static_cast<const InDet::SiCluster *>(sp->clusterList().second);
148  const InDetDD::SiDetectorElement *d0 = c0->detectorElement();
149  const InDetDD::SiDetectorElement *d1 = c1->detectorElement();
150 
151  Amg::Vector2D lc0 = c0->localPosition();
152  Amg::Vector2D lc1 = c1->localPosition();
153 
154  std::pair<Amg::Vector3D, Amg::Vector3D> e0 =
155  (d0->endsOfStrip(InDetDD::SiLocalPosition(lc0.y(), lc0.x(), 0.)));
156  std::pair<Amg::Vector3D, Amg::Vector3D> e1 =
157  (d1->endsOfStrip(InDetDD::SiLocalPosition(lc1.y(), lc1.x(), 0.)));
158 
159  Amg::Vector3D s0(.5 * (e0.first + e0.second));
160  Amg::Vector3D s1(.5 * (e1.first + e1.second));
161 
162  Amg::Vector3D b0(.5 * (e0.second - e0.first));
163  Amg::Vector3D b1(.5 * (e1.second - e1.first));
164  Amg::Vector3D d02(s0 - s1);
165 
166  // b0
167  r[3] = static_cast<float>(b0[0]);
168  r[4] = static_cast<float>(b0[1]);
169  r[5] = static_cast<float>(b0[2]);
170 
171  // b1
172  r[6] = static_cast<float>(b1[0]);
173  r[7] = static_cast<float>(b1[1]);
174  r[8] = static_cast<float>(b1[2]);
175 
176  // r0-r2
177  r[9] = static_cast<float>(d02[0]);
178  r[10] = static_cast<float>(d02[1]);
179  r[11] = static_cast<float>(d02[2]);
180 
181  // r0
182  r[12] = static_cast<float>(s0[0]) - data.xbeam[0];
183  r[13] = static_cast<float>(s0[1]) - data.ybeam[0];
184  r[14] = static_cast<float>(s0[2]) - data.zbeam[0];
185  }

◆ writeNtuple()

void ActsTrk::SiSpacePointsSeedMaker::writeNtuple ( const InDet::SiSpacePointsSeed *  seed,
const Trk::Track *  track,
int  seedType,
long  eventNumber 
) const
overridevirtual

Definition at line 697 of file SiSpacePointsSeedMaker.cxx.

701  {
702  if (not m_writeNtuple) return;
703 
704  std::lock_guard<std::mutex> lock(m_mutex);
705 
706  if(track != nullptr) {
707  m_trackPt = (track->trackParameters()->front()->pT())/1000.f;
708  m_trackEta = std::abs(track->trackParameters()->front()->eta());
709  }
710  else {
711  m_trackPt = -1.;
712  m_trackEta = -1.;
713  }
714  m_d0 = seed->d0();
715  m_z0 = seed->zVertex();
716  m_eta = seed->eta();
717  m_x1 = seed->x1();
718  m_x2 = seed->x2();
719  m_x3 = seed->x3();
720  m_y1 = seed->y1();
721  m_y2 = seed->y2();
722  m_y3 = seed->y3();
723  m_z1 = seed->z1();
724  m_z2 = seed->z2();
725  m_z3 = seed->z3();
726  m_r1 = seed->r1();
727  m_r2 = seed->r2();
728  m_r3 = seed->r3();
729  m_type = seedType;
730  m_dzdr_b = seed->dzdr_b();
731  m_dzdr_t = seed->dzdr_t();
732  m_pt = seed->pt();
733  m_givesTrack = !(track == nullptr);
734  m_eventNumber = eventNumber;
735 
736  // Ok: protected by mutex.
737  TTree* outputTree ATLAS_THREAD_SAFE = m_outputTree;
738  outputTree->Fill();
739  }

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/26]

std::string m_treeName ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = ""
mutableprivate

Definition at line 233 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [2/26]

std::string m_treeFolder ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = "/valNtuples/"
mutableprivate

Definition at line 234 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [3/26]

float m_d0 ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 236 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [4/26]

float m_z0 ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 237 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [5/26]

float m_pt ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 238 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [6/26]

float m_eta ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 239 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [7/26]

double m_x1 ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 240 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [8/26]

double m_x2 ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 241 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [9/26]

double m_x3 ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 242 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [10/26]

double m_y1 ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 243 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [11/26]

double m_y2 ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 244 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [12/26]

double m_y3 ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 245 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [13/26]

double m_z1 ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 246 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [14/26]

double m_z2 ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 247 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [15/26]

double m_z3 ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 248 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [16/26]

double m_r1 ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 249 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [17/26]

double m_r2 ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 250 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [18/26]

double m_r3 ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 251 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [19/26]

float m_quality ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 252 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [20/26]

int m_type ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 253 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [21/26]

double m_dzdr_t ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 254 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [22/26]

double m_dzdr_b ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 255 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [23/26]

bool m_givesTrack ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = false
mutableprivate

Definition at line 256 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [24/26]

float m_trackPt ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 257 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [25/26]

float m_trackEta ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 258 of file SiSpacePointsSeedMaker.h.

◆ ATLAS_THREAD_SAFE [26/26]

long m_eventNumber ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0
mutableprivate

Definition at line 259 of file SiSpacePointsSeedMaker.h.

◆ m_actsSpacepointsOverlap

SG::ReadHandleKey< xAOD::SpacePointContainer > ActsTrk::SiSpacePointsSeedMaker::m_actsSpacepointsOverlap {this, "ActsSpacePointsOverlapName", "", "Strip overlap space points container"}
private

Definition at line 206 of file SiSpacePointsSeedMaker.h.

◆ m_actsSpacepointsPixel

SG::ReadHandleKey< xAOD::SpacePointContainer > ActsTrk::SiSpacePointsSeedMaker::m_actsSpacepointsPixel {this, "ActsSpacePointsPixelName", "", "Pixel space points container"}
private

Definition at line 204 of file SiSpacePointsSeedMaker.h.

◆ m_actsSpacepointsStrip

SG::ReadHandleKey< xAOD::SpacePointContainer > ActsTrk::SiSpacePointsSeedMaker::m_actsSpacepointsStrip {this, "ActsSpacePointsStripName", "", "Strip space points container"}
private

Definition at line 205 of file SiSpacePointsSeedMaker.h.

◆ m_beamSpotKey

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

Definition at line 208 of file SiSpacePointsSeedMaker.h.

◆ m_doSeedConversion

Gaudi::Property< bool > ActsTrk::SiSpacePointsSeedMaker::m_doSeedConversion {this, "doSeedConversion", true, "Convert ActsTrk::Seed into ITk::SiSpacePointsProSeed"}
private

Definition at line 221 of file SiSpacePointsSeedMaker.h.

◆ m_fastTracking

Gaudi::Property< bool > ActsTrk::SiSpacePointsSeedMaker::m_fastTracking {this, "useFastTracking", false}
private

Definition at line 220 of file SiSpacePointsSeedMaker.h.

◆ m_fieldCondObjInputKey

SG::ReadCondHandleKey< AtlasFieldCacheCondObj > ActsTrk::SiSpacePointsSeedMaker::m_fieldCondObjInputKey
private
Initial value:
{this, "AtlasFieldCacheCondObj", "fieldCondObj",
"Name of the Magnetic Field conditions object key"}

Definition at line 209 of file SiSpacePointsSeedMaker.h.

◆ m_mutex

std::mutex ActsTrk::SiSpacePointsSeedMaker::m_mutex
mutableprivate

Definition at line 228 of file SiSpacePointsSeedMaker.h.

◆ m_outputTree

TTree* ActsTrk::SiSpacePointsSeedMaker::m_outputTree = nullptr
private

Definition at line 231 of file SiSpacePointsSeedMaker.h.

◆ m_pixel

Gaudi::Property< bool > ActsTrk::SiSpacePointsSeedMaker::m_pixel {this, "usePixel", true}
private

Definition at line 217 of file SiSpacePointsSeedMaker.h.

◆ m_pixelDetEleCollKey

SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > ActsTrk::SiSpacePointsSeedMaker::m_pixelDetEleCollKey
private
Initial value:
{this, "PixelDetectorElements", "ITkPixelDetectorElementCollection",
"Key of input SiDetectorElementCollection"}

Definition at line 212 of file SiSpacePointsSeedMaker.h.

◆ m_prdToTrackMap

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

Definition at line 202 of file SiSpacePointsSeedMaker.h.

◆ m_seedsToolPixel

ToolHandle< ActsTrk::ISeedingTool > ActsTrk::SiSpacePointsSeedMaker::m_seedsToolPixel {this, "SeedToolPixel", "","Seed Tool for Pixel detector"}
private

Definition at line 199 of file SiSpacePointsSeedMaker.h.

◆ m_seedsToolStrip

ToolHandle< ActsTrk::ISeedingTool > ActsTrk::SiSpacePointsSeedMaker::m_seedsToolStrip {this, "SeedToolStrip", "","Seed Tool for Strip detector"}
private

Definition at line 200 of file SiSpacePointsSeedMaker.h.

◆ m_strip

Gaudi::Property< bool > ActsTrk::SiSpacePointsSeedMaker::m_strip {this, "useStrip", true }
private

Definition at line 218 of file SiSpacePointsSeedMaker.h.

◆ m_stripDetEleCollKey

SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > ActsTrk::SiSpacePointsSeedMaker::m_stripDetEleCollKey
private
Initial value:
{this, "StripDetectorElements", "ITkStripDetectorElementCollection",
"Key of input SiDetectorElementCollection"}

Definition at line 214 of file SiSpacePointsSeedMaker.h.

◆ m_thistSvc

ServiceHandle<ITHistSvc> ActsTrk::SiSpacePointsSeedMaker::m_thistSvc
private

Definition at line 230 of file SiSpacePointsSeedMaker.h.

◆ m_useClusters

Gaudi::Property< bool > ActsTrk::SiSpacePointsSeedMaker::m_useClusters {this, "useClustersForSeedConversion", false}
private

Definition at line 222 of file SiSpacePointsSeedMaker.h.

◆ m_useOverlap

Gaudi::Property< bool > ActsTrk::SiSpacePointsSeedMaker::m_useOverlap {this, "useOverlapSpCollection", true}
private

Definition at line 219 of file SiSpacePointsSeedMaker.h.

◆ m_writeNtuple

Gaudi::Property< bool > ActsTrk::SiSpacePointsSeedMaker::m_writeNtuple {this, "WriteNtuple", false}
private

Definition at line 226 of file SiSpacePointsSeedMaker.h.

The documentation for this class was generated from the following files:
Trk::SpacePoint::clusterList
const std::pair< const PrepRawData *, const PrepRawData * > & clusterList() const
return the pair of cluster pointers by reference
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePoint.h:127
replace
std::string replace(std::string s, const std::string &s2, const std::string &s3)
Definition: hcg.cxx:310
ActsTrk::SpacePointCollector
Definition: SpacePointCollector.h:20
Trk::SpacePoint
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePoint.h:35
beamspotman.r
def r
Definition: beamspotman.py:672
xAOD::UncalibratedMeasurement_v1::identifierHash
DetectorIDHashType identifierHash() const
Returns the IdentifierHash of the measurement (corresponds to the detector element IdentifierHash)
trigbs_pickEvents.ranges
ranges
Definition: trigbs_pickEvents.py:60
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
ActsTrk::SiSpacePointsSeedMaker::m_seedsToolPixel
ToolHandle< ActsTrk::ISeedingTool > m_seedsToolPixel
Definition: SiSpacePointsSeedMaker.h:199
ReadCellNoiseFromCoolCompare.s1
s1
Definition: ReadCellNoiseFromCoolCompare.py:378
ActsTrk::SiSpacePointsSeedMaker::newSpacePoint
void newSpacePoint(InDet::SiSpacePointsSeedMakerEventData &data, const xAOD::SpacePoint *sp) const
Definition: SiSpacePointsSeedMaker.cxx:121
ActsTrk::SiSpacePointsSeedMaker::m_useOverlap
Gaudi::Property< bool > m_useOverlap
Definition: SiSpacePointsSeedMaker.h:219
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
ActsTrk::SiSpacePointsSeedMaker::pixInform
static void pixInform(const Trk::SpacePoint *sp, float *r)
ATLASMagneticFieldWrapper
Definition: ATLASMagneticFieldWrapper.h:15
python.SystemOfUnits.mm
float mm
Definition: SystemOfUnits.py:98
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
ContainerAccessor
Definition: ContainerAccessor.h:25
InDetDD::SiDetectorElementCollection
Definition: SiDetectorElementCollection.h:27
SG::ReadCondHandle
Definition: ReadCondHandle.h:40
AtlasFieldCacheCondObj
Definition: AtlasFieldCacheCondObj.h:19
xAOD::SpacePoint_v1::elementIdList
const std::vector< DetectorIDHashType > & elementIdList() const
Returns the IdentifierHash of the spacepoint (corresponds to the detector element IdentifierHash)
Definition: SpacePoint_v1.cxx:14
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:68
ActsTrk::SiSpacePointsSeedMaker::m_mutex
std::mutex m_mutex
Definition: SiSpacePointsSeedMaker.h:228
InDet::SiSpacePointsSeedMakerEventData::clearPoolList
static void clearPoolList(std::list< T, SG::ArenaPoolSTLAllocator< T >> &poolList)
Definition: SiSpacePointsSeedMakerEventData.h:219
egammaEnergyPositionAllSamples::e1
double e1(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 1st sampling
Trk::PRDtoTrackMap
Definition: PRDtoTrackMap.h:17
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
SG::ReadHandle< Trk::PRDtoTrackMap >
index
Definition: index.py:1
ActsTrk::SiSpacePointsSeedMaker::m_doSeedConversion
Gaudi::Property< bool > m_doSeedConversion
Definition: SiSpacePointsSeedMaker.h:221
hist_file_dump.d
d
Definition: hist_file_dump.py:142
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:75
ActsTrk::SiSpacePointsSeedMaker::m_writeNtuple
Gaudi::Property< bool > m_writeNtuple
Definition: SiSpacePointsSeedMaker.h:226
extractSporadic.c1
c1
Definition: extractSporadic.py:133
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:70
SG::ReadCondHandle::isValid
bool isValid()
Definition: ReadCondHandle.h:206
ActsTrk::SiSpacePointsSeedMaker::m_outputTree
TTree * m_outputTree
Definition: SiSpacePointsSeedMaker.h:231
MCP::ScaleSmearParam::s0
@ s0
dq_defect_virtual_defect_validation.d1
d1
Definition: dq_defect_virtual_defect_validation.py:79
xAOD::SpacePoint_v1
Definition: SpacePoint_v1.h:29
ActsTrk::SiSpacePointsSeedMaker::PPP
@ PPP
Definition: SiSpacePointsSeedMaker.h:48
ActsTrk::SiSpacePointsSeedMaker::m_actsSpacepointsStrip
SG::ReadHandleKey< xAOD::SpacePointContainer > m_actsSpacepointsStrip
Definition: SiSpacePointsSeedMaker.h:205
ReadCellNoiseFromCoolCompare.s4
s4
Definition: ReadCellNoiseFromCoolCompare.py:381
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
python.RatesEmulationExample.lock
lock
Definition: RatesEmulationExample.py:148
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
ActsTrk::SiSpacePointsSeedMaker::convertPixelSeed
bool convertPixelSeed(const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, const ActsTrk::SeedContainer &seedPtrs) const
Definition: SiSpacePointsSeedMaker.cxx:977
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
ActsTrk::SiSpacePointsSeedMaker::m_pixel
Gaudi::Property< bool > m_pixel
Definition: SiSpacePointsSeedMaker.h:217
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
ATLASMagneticFieldWrapper::makeCache
MagneticFieldProvider::Cache makeCache(const Acts::MagneticFieldContext &mctx) const override
Definition: ATLASMagneticFieldWrapper.h:34
ActsTrk::SiSpacePointsSeedMaker::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
Definition: SiSpacePointsSeedMaker.h:208
ActsTrk::SiSpacePointsSeedMaker::m_strip
Gaudi::Property< bool > m_strip
Definition: SiSpacePointsSeedMaker.h:218
InDetDD::SiLocalPosition
Definition: SiLocalPosition.h:31
ActsTrk::SiSpacePointsSeedMaker::m_prdToTrackMap
SG::ReadHandleKey< Trk::PRDtoTrackMap > m_prdToTrackMap
Definition: SiSpacePointsSeedMaker.h:202
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
m_type
TokenType m_type
the type
Definition: TProperty.cxx:44
hotSpotInTAG.c0
c0
Definition: hotSpotInTAG.py:191
ActsTrk::SiSpacePointsSeedMaker::m_fieldCondObjInputKey
SG::ReadCondHandleKey< AtlasFieldCacheCondObj > m_fieldCondObjInputKey
Definition: SiSpacePointsSeedMaker.h:209
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
Generate_dsid_ranseed.seed
seed
Definition: Generate_dsid_ranseed.py:10
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ActsTrk::SiSpacePointsSeedMaker::retrieveStrip
StatusCode retrieveStrip(const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, const Trk::PRDtoTrackMap *prd_to_track_map_cptr) const
Definition: SiSpacePointsSeedMaker.cxx:257
ActsTrk::SiSpacePointsSeedMaker::m_fastTracking
Gaudi::Property< bool > m_fastTracking
Definition: SiSpacePointsSeedMaker.h:220
beamspotman.n
n
Definition: beamspotman.py:727
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
SG::ReadHandle::get
const_pointer_type get() const
Dereference the pointer, but don't cache anything.
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ActsTrk::SiSpacePointsSeedMaker::m_seedsToolStrip
ToolHandle< ActsTrk::ISeedingTool > m_seedsToolStrip
Definition: SiSpacePointsSeedMaker.h:200
ActsTrk::SiSpacePointsSeedMaker::m_thistSvc
ServiceHandle< ITHistSvc > m_thistSvc
Definition: SiSpacePointsSeedMaker.h:230
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
ActsTrk::SiSpacePointsSeedMaker::buildBeamFrameWork
void buildBeamFrameWork(const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data) const
Definition: SiSpacePointsSeedMaker.cxx:397
xAOD::StripCluster_v1
Definition: StripCluster_v1.h:17
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
hist_file_dump.f
f
Definition: hist_file_dump.py:140
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
xAOD::eventNumber
eventNumber
Definition: EventInfo_v1.cxx:124
detail::ul
unsigned long ul
Definition: PrimitiveHelpers.h:47
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
F600IntegrationConfig.spacePoints
spacePoints
Definition: F600IntegrationConfig.py:122
DataVector
Derived DataVector<T>.
Definition: DataVector.h:795
Trk::PRDtoTrackMap::isUsed
bool isUsed(const PrepRawData &prd) const
does this PRD belong to at least one track?
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
ActsTrk::SiSpacePointsSeedMaker::m_actsSpacepointsPixel
SG::ReadHandleKey< xAOD::SpacePointContainer > m_actsSpacepointsPixel
Definition: SiSpacePointsSeedMaker.h:204
Trk::PrepRawData
Definition: PrepRawData.h:62
ActsTrk::SiSpacePointsSeedMaker::m_useClusters
Gaudi::Property< bool > m_useClusters
Definition: SiSpacePointsSeedMaker.h:222
ActsTrk::SiSpacePointsSeedMaker::retrieveOverlap
StatusCode retrieveOverlap(const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, const Trk::PRDtoTrackMap *prd_to_track_map_cptr) const
Definition: SiSpacePointsSeedMaker.cxx:328
ActsTrk::SiSpacePointsSeedMaker::dumpConditions
MsgStream & dumpConditions(InDet::SiSpacePointsSeedMakerEventData &data, MsgStream &out) const
Definition: SiSpacePointsSeedMaker.cxx:759
dumpTgcDigiThreshold.isStrip
list isStrip
Definition: dumpTgcDigiThreshold.py:33
ReadCellNoiseFromCoolCompare.s3
s3
Definition: ReadCellNoiseFromCoolCompare.py:380
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
python.subdetectors.mmg.ids
ids
Definition: mmg.py:8
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
xAOD::JetAttributeAccessor::accessor
const AccessorWrapper< T > * accessor(xAOD::JetAttribute::AttributeID id)
Returns an attribute accessor corresponding to an AttributeID.
Definition: JetAccessorMap.h:26
ActsTrk::SiSpacePointsSeedMaker::InitTree
StatusCode InitTree()
Definition: SiSpacePointsSeedMaker.cxx:81
DeMoScan.index
string index
Definition: DeMoScan.py:362
xAOD::PixelCluster_v1
Definition: PixelCluster_v1.h:17
xAOD::SpacePointContainer
SpacePointContainer_v1 SpacePointContainer
Define the version of the space point container.
Definition: Event/xAOD/xAODInDetMeasurement/xAODInDetMeasurement/SpacePointContainer.h:14
ATLASMagneticFieldWrapper::getField
Acts::Result< Acts::Vector3 > getField(const Acts::Vector3 &position, Acts::MagneticFieldProvider::Cache &gcache) const override
Definition: ATLASMagneticFieldWrapper.h:39
ActsTrk::Seed
Definition: SeedContainer.h:75
DEBUG
#define DEBUG
Definition: page_access.h:11
ReadCellNoiseFromCoolCompare.s2
s2
Definition: ReadCellNoiseFromCoolCompare.py:379
ActsTrk::SiSpacePointsSeedMaker::isUsed
bool isUsed(const Trk::SpacePoint *, const Trk::PRDtoTrackMap &prd_to_track_map) const
Definition: SiSpacePointsSeedMaker.h:267
Trig::FeatureAccessImpl::collect
void collect(const HLT::TriggerElement *te, std::vector< Trig::Feature< T > > &data, const std::string &label, unsigned int condition, const std::string &teName, const HLT::TrigNavStructure *navstructure)
actual feature acceess implementation It has (thanks to the ClassTraits) functionality to flatten con...
Definition: FeatureCollectAthena.h:299
ActsTrk::SiSpacePointsSeedMaker::m_stripDetEleCollKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_stripDetEleCollKey
Definition: SiSpacePointsSeedMaker.h:214
ActsTrk::SiSpacePointsSeedMaker::dump
virtual MsgStream & dump(InDet::SiSpacePointsSeedMakerEventData &data, MsgStream &out) const override
Definition: SiSpacePointsSeedMaker.cxx:746
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
ActsTrk::SiSpacePointsSeedMaker::stripInform
static void stripInform(InDet::SiSpacePointsSeedMakerEventData &data, const Trk::SpacePoint *sp, std::span< float, 15 > r)
Definition: SiSpacePointsSeedMaker.cxx:142
egammaEnergyPositionAllSamples::e0
double e0(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in pre-sampler
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
ActsTrk::SiSpacePointsSeedMaker::SSS
@ SSS
Definition: SiSpacePointsSeedMaker.h:48
ActsTrk::SiSpacePointsSeedMaker::dumpEvent
static MsgStream & dumpEvent(InDet::SiSpacePointsSeedMakerEventData &data, MsgStream &out)
Definition: SiSpacePointsSeedMaker.cxx:831
ActsTrk::SiSpacePointsSeedMaker::m_pixelDetEleCollKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_pixelDetEleCollKey
Definition: SiSpacePointsSeedMaker.h:212
ActsTrk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE
std::string m_treeName ATLAS_THREAD_SAFE
Definition: SiSpacePointsSeedMaker.h:233
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
TileDCSDataPlotter.tx
tx
Definition: TileDCSDataPlotter.py:880
ActsTrk::SiSpacePointsSeedMaker::convertStripSeed
bool convertStripSeed(const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, const ActsTrk::SeedContainer &seedPtrs) const
Definition: SiSpacePointsSeedMaker.cxx:852
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
InDet::SiCluster
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/SiCluster.h:40
ActsTrk::SiSpacePointsSeedMaker::retrievePixel
StatusCode retrievePixel(const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, const Trk::PRDtoTrackMap *prd_to_track_map_cptr) const
Definition: SiSpacePointsSeedMaker.cxx:188
ActsTrk::SiSpacePointsSeedMaker::m_actsSpacepointsOverlap
SG::ReadHandleKey< xAOD::SpacePointContainer > m_actsSpacepointsOverlap
Definition: SiSpacePointsSeedMaker.h:206
ITk::SiSpacePointForSeed
Definition: ITkSiSpacePointForSeed.h:34
SG::ReadCondHandle::cptr
const_pointer_type cptr()
Definition: ReadCondHandle.h:67
Generated on Sun Nov 16 2025 21:52:08 for ATLAS Offline Software by   doxygen 1.8.18