Loading [MathJax]/jax/output/SVG/config.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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 *const &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 *const &sp, float *r)
 
static void stripInform (InDet::SiSpacePointsSeedMakerEventData &data, const Trk::SpacePoint *const &sp, float *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_GbtsSeeding {this, "GbtsSeeding", 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 44 of file SiSpacePointsSeedMaker.h.

Member Enumeration Documentation

◆ SeedStrategy

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

Definition at line 47 of file SiSpacePointsSeedMaker.h.

47 : short {PPP, SSS};

Constructor & Destructor Documentation

◆ SiSpacePointsSeedMaker()

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

Definition at line 36 of file SiSpacePointsSeedMaker.cxx.

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

◆ ~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 398 of file SiSpacePointsSeedMaker.cxx.

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

◆ 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* seed : seedPtrs) {
998  std::array<std::size_t, 3> indexes {
999  seed->sp()[0]->index(),
1000  seed->sp()[1]->index(),
1001  seed->sp()[2]->index()
1002  };
1003 
1004  const auto [bottom_idx, medium_idx, top_idx] = indexes;
1005  std::size_t max_index = std::max(bottom_idx, std::max(medium_idx, top_idx));
1006  if (data.v_PixelSpacePointForSeed.size() < max_index + 1) {
1007  data.v_PixelSpacePointForSeed.resize( max_index + 1 );
1008  }
1009 
1010  // Retrieve/make the space points!
1011  if (not m_useClusters) {
1012  // Get the Space Point from the element link
1013  if (not linkAcc.isAvailable(*seed->sp()[0])){
1014  ATH_MSG_FATAL("no pixelSpacePointLink for bottom sp!");
1015  return false;
1016  }
1017  if (not linkAcc.isAvailable(*seed->sp()[1])){
1018  ATH_MSG_FATAL("no pixelSpacePointLink for middle sp!");
1019  return false;
1020  }
1021  if (not linkAcc.isAvailable(*seed->sp()[2])){
1022  ATH_MSG_FATAL("no pixelSpacePointLink for top sp!");
1023  return false;
1024  }
1025 
1026  spacePoints = {
1027  *linkAcc(*seed->sp()[0]),
1028  *linkAcc(*seed->sp()[1]),
1029  *linkAcc(*seed->sp()[2])
1030  };
1031  }
1032  else {
1033  // Get the clusters from the xAOD::Clusters and then make the space points
1034  const xAOD::PixelCluster* bottom_cluster = reinterpret_cast<const xAOD::PixelCluster*>(seed->sp()[0]->measurements()[0]);
1035  const xAOD::PixelCluster* medium_cluster = reinterpret_cast<const xAOD::PixelCluster*>(seed->sp()[1]->measurements()[0]);
1036  const xAOD::PixelCluster* top_cluster = reinterpret_cast<const xAOD::PixelCluster*>(seed->sp()[2]->measurements()[0]);
1037 
1038  if (not pixelLinkAcc.isAvailable(*bottom_cluster)) {
1039  ATH_MSG_FATAL("no pixelClusterLink for cluster associated to bottom sp!");
1040  return false;
1041  }
1042  if (not pixelLinkAcc.isAvailable(*medium_cluster)) {
1043  ATH_MSG_FATAL("no pixelClusterLink for cluster associated to middle sp!");
1044  return false;
1045  }
1046  if (not pixelLinkAcc.isAvailable(*top_cluster)) {
1047  ATH_MSG_FATAL("no pixelClusterLink for cluster associated to top sp!");
1048  return false;
1049  }
1050 
1051  if (not data.v_PixelSpacePointForSeed[bottom_idx])
1052  data.v_PixelSpacePointForSeed[bottom_idx] = std::make_unique<InDet::PixelSpacePoint>(bottom_cluster->identifierHash(), *(pixelLinkAcc(*bottom_cluster)));
1053  if (not data.v_PixelSpacePointForSeed[medium_idx])
1054  data.v_PixelSpacePointForSeed[medium_idx] = std::make_unique<InDet::PixelSpacePoint>(medium_cluster->identifierHash(), *(pixelLinkAcc(*medium_cluster)));
1055  if (not data.v_PixelSpacePointForSeed[top_idx])
1056  data.v_PixelSpacePointForSeed[top_idx] = std::make_unique<InDet::PixelSpacePoint>(top_cluster->identifierHash(), *(pixelLinkAcc(*top_cluster)));
1057 
1058  spacePoints = {
1059  data.v_PixelSpacePointForSeed[bottom_idx].get(),
1060  data.v_PixelSpacePointForSeed[medium_idx].get(),
1061  data.v_PixelSpacePointForSeed[top_idx].get()
1062  };
1063 
1064  }
1065 
1066  for (int index = 0; index<3; ++index) {
1067  std::size_t sp_idx = indexes[index];
1068 
1069  // Try add an element.
1070  // If already there just return the old value
1071  // If not present, we add a new element to it
1072  auto [itr, outcome] = bridge_idx_sispacepoints.try_emplace(sp_idx, data.v_PixelSiSpacePointForSeed.size());
1073  std::size_t mapped_idx = itr->second;
1074  // We added a new element
1075  if (outcome) {
1076  float r[15];
1077  r[0] = seed->sp()[index]->x();
1078  r[1] = seed->sp()[index]->y();
1079  r[2] = seed->sp()[index]->z();
1080  pixInform(spacePoints[index], r);
1081  data.v_PixelSiSpacePointForSeed.emplace_back( spacePoints[index], r );
1082 
1083  }
1084  data.v_PixelSiSpacePointForSeed[mapped_idx].setQuality(-seed->seedQuality());
1085  pixelSpacePointsForSeeds[index] = &data.v_PixelSiSpacePointForSeed[mapped_idx];
1086  }
1087 
1088  data.i_ITkSeeds.emplace_back(pixelSpacePointsForSeeds[0],
1089  pixelSpacePointsForSeeds[1],
1090  pixelSpacePointsForSeeds[2],
1091  seed->z());
1092  data.i_ITkSeeds.back().setQuality(-seed->seedQuality());
1093  }
1094 
1095  return true;
1096  }

◆ convertStripSeed()

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

Definition at line 853 of file SiSpacePointsSeedMaker.cxx.

855  {
856  // If the read handle key for clusters is not empty, that means the xAOD->InDet Cluster link is available
857  // Else we can use xAOD->Trk Space Point link
858  // If none of these is available, we have a JO misconfguration!
859  static const SG::AuxElement::Accessor< ElementLink< ::SpacePointCollection > > linkAcc("sctSpacePointLink");
860  static const SG::AuxElement::Accessor< ElementLink< ::SpacePointOverlapCollection > > overlaplinkAcc("stripOverlapSpacePointLink");
861  static const SG::AuxElement::Accessor< ElementLink< InDet::SCT_ClusterCollection > > stripLinkAcc("sctClusterLink");
862 
863  if (m_useClusters) {
864  data.v_StripSpacePointForSeed.clear();
865  }
866 
867  std::array<const Trk::SpacePoint*, 3> spacePoints {};
868  std::array<ITk::SiSpacePointForSeed*, 3> stripSpacePointsForSeeds {};
869 
870  for (const ActsTrk::Seed* seed : seedPtrs) {
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  float r[15];
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 747 of file SiSpacePointsSeedMaker.cxx.

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

◆ dumpConditions()

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

Definition at line 760 of file SiSpacePointsSeedMaker.cxx.

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

◆ dumpEvent()

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

Definition at line 832 of file SiSpacePointsSeedMaker.cxx.

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

◆ find2Sp()

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

Definition at line 104 of file SiSpacePointsSeedMaker.h.

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

◆ 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 113 of file SiSpacePointsSeedMaker.h.

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

◆ find3Sp() [2/2]

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

Definition at line 594 of file SiSpacePointsSeedMaker.cxx.

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

◆ 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 124 of file SiSpacePointsSeedMaker.h.

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

◆ getWriteNtupleBoolProperty()

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

Definition at line 743 of file SiSpacePointsSeedMaker.cxx.

744  { return m_writeNtuple; }

◆ initialize()

StatusCode ActsTrk::SiSpacePointsSeedMaker::initialize ( )
overridevirtual

Definition at line 41 of file SiSpacePointsSeedMaker.cxx.

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

◆ InitTree()

StatusCode ActsTrk::SiSpacePointsSeedMaker::InitTree ( )
private

Definition at line 82 of file SiSpacePointsSeedMaker.cxx.

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

◆ 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 522 of file SiSpacePointsSeedMaker.cxx.

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

◆ 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 470 of file SiSpacePointsSeedMaker.cxx.

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

◆ 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 94 of file SiSpacePointsSeedMaker.h.

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

◆ newSpacePoint()

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

Definition at line 122 of file SiSpacePointsSeedMaker.cxx.

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

◆ next()

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

then return this next seed candidate

Definition at line 681 of file SiSpacePointsSeedMaker.cxx.

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

◆ pixInform()

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

Definition at line 131 of file SiSpacePointsSeedMaker.cxx.

133  {
134  const InDet::SiCluster *cl = static_cast<const InDet::SiCluster *>(sp->clusterList().first);
135  const InDetDD::SiDetectorElement *de = cl->detectorElement();
136  const Amg::Transform3D &Tp = de->surface().transform();
137  r[3] = static_cast<float>(Tp(0, 2));
138  r[4] = static_cast<float>(Tp(1, 2));
139  r[5] = static_cast<float>(Tp(2, 2));
140  }

◆ 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 353 of file SiSpacePointsSeedMaker.cxx.

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

◆ 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 329 of file SiSpacePointsSeedMaker.cxx.

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

◆ 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 213 of file SiSpacePointsSeedMaker.cxx.

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

◆ 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 189 of file SiSpacePointsSeedMaker.cxx.

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

◆ 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 282 of file SiSpacePointsSeedMaker.cxx.

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

◆ 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 258 of file SiSpacePointsSeedMaker.cxx.

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

◆ stripInform()

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

Definition at line 143 of file SiSpacePointsSeedMaker.cxx.

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

◆ writeNtuple()

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

Definition at line 698 of file SiSpacePointsSeedMaker.cxx.

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

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 205 of file SiSpacePointsSeedMaker.h.

◆ m_actsSpacepointsPixel

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

Definition at line 203 of file SiSpacePointsSeedMaker.h.

◆ m_actsSpacepointsStrip

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

Definition at line 204 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 207 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 220 of file SiSpacePointsSeedMaker.h.

◆ m_fastTracking

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

Definition at line 219 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 208 of file SiSpacePointsSeedMaker.h.

◆ m_GbtsSeeding

Gaudi::Property< bool > ActsTrk::SiSpacePointsSeedMaker::m_GbtsSeeding {this, "GbtsSeeding", false}
private

Definition at line 222 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 216 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 211 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 201 of file SiSpacePointsSeedMaker.h.

◆ m_seedsToolPixel

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

Definition at line 198 of file SiSpacePointsSeedMaker.h.

◆ m_seedsToolStrip

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

Definition at line 199 of file SiSpacePointsSeedMaker.h.

◆ m_strip

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

Definition at line 217 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 213 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 221 of file SiSpacePointsSeedMaker.h.

◆ m_useOverlap

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

Definition at line 218 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:307
ActsTrk::SpacePointCollector
Definition: SpacePointCollector.h:20
Trk::SpacePoint
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePoint.h:35
beamspotman.r
def r
Definition: beamspotman.py:676
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:198
ReadCellNoiseFromCoolCompare.s1
s1
Definition: ReadCellNoiseFromCoolCompare.py:378
ActsTrk::SiSpacePointsSeedMaker::m_useOverlap
Gaudi::Property< bool > m_useOverlap
Definition: SiSpacePointsSeedMaker.h:218
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
ATLASMagneticFieldWrapper
Definition: ATLASMagneticFieldWrapper.h:15
ContainerAccessor
Definition: ContainerAccessor.h:25
InDetDD::SiDetectorElementCollection
Definition: SiDetectorElementCollection.h:30
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ActsTrk::SiSpacePointsSeedMaker::stripInform
static void stripInform(InDet::SiSpacePointsSeedMakerEventData &data, const Trk::SpacePoint *const &sp, float *r)
Definition: SiSpacePointsSeedMaker.cxx:143
AtlasFieldCacheCondObj
Definition: AtlasFieldCacheCondObj.h:19
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:220
hist_file_dump.d
d
Definition: hist_file_dump.py:143
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
ActsTrk::SiSpacePointsSeedMaker::m_writeNtuple
Gaudi::Property< bool > m_writeNtuple
Definition: SiSpacePointsSeedMaker.h:226
extractSporadic.c1
c1
Definition: extractSporadic.py:134
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
ActsTrk::SiSpacePointsSeedMaker::pixInform
static void pixInform(const Trk::SpacePoint *const &sp, float *r)
Definition: SiSpacePointsSeedMaker.cxx:131
InDetDD::SolidStateDetectorElementBase::surface
Trk::Surface & surface()
Element Surface.
SG::ReadCondHandle::isValid
bool isValid()
Definition: ReadCondHandle.h:210
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:47
ActsTrk::SiSpacePointsSeedMaker::m_actsSpacepointsStrip
SG::ReadHandleKey< xAOD::SpacePointContainer > m_actsSpacepointsStrip
Definition: SiSpacePointsSeedMaker.h:204
ReadCellNoiseFromCoolCompare.s4
s4
Definition: ReadCellNoiseFromCoolCompare.py:381
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
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:216
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
ActsTrk::SiSpacePointsSeedMaker::m_GbtsSeeding
Gaudi::Property< bool > m_GbtsSeeding
Definition: SiSpacePointsSeedMaker.h:222
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:207
ActsTrk::SiSpacePointsSeedMaker::m_strip
Gaudi::Property< bool > m_strip
Definition: SiSpacePointsSeedMaker.h:217
xAOD::SpacePoint_v1::elementIdList
const std::vector< DetectorIDHashType > & elementIdList() const
Returns the IdentifierHash of the spacepoint (corresponds to the detector element IdentifierHash)
xAOD::phi
setEt phi
Definition: TrigEMCluster_v1.cxx:29
InDetDD::SiLocalPosition
Definition: SiLocalPosition.h:31
ActsTrk::SiSpacePointsSeedMaker::m_prdToTrackMap
SG::ReadHandleKey< Trk::PRDtoTrackMap > m_prdToTrackMap
Definition: SiSpacePointsSeedMaker.h:201
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:274
m_type
TokenType m_type
the type
Definition: TProperty.cxx:44
hotSpotInTAG.c0
c0
Definition: hotSpotInTAG.py:192
ActsTrk::SiSpacePointsSeedMaker::m_fieldCondObjInputKey
SG::ReadCondHandleKey< AtlasFieldCacheCondObj > m_fieldCondObjInputKey
Definition: SiSpacePointsSeedMaker.h:208
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
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:258
ActsTrk::SiSpacePointsSeedMaker::m_fastTracking
Gaudi::Property< bool > m_fastTracking
Definition: SiSpacePointsSeedMaker.h:219
beamspotman.n
n
Definition: beamspotman.py:731
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::newSpacePoint
void newSpacePoint(InDet::SiSpacePointsSeedMakerEventData &data, const xAOD::SpacePoint *const &sp) const
Definition: SiSpacePointsSeedMaker.cxx:122
ActsTrk::SiSpacePointsSeedMaker::m_seedsToolStrip
ToolHandle< ActsTrk::ISeedingTool > m_seedsToolStrip
Definition: SiSpacePointsSeedMaker.h:199
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
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:398
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:141
ActsTrk::Seed
Acts::Seed< xAOD::SpacePoint, 3ul > Seed
Definition: Seed.h:12
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
xAOD::eventNumber
eventNumber
Definition: EventInfo_v1.cxx:124
detail::ul
unsigned long ul
Definition: PrimitiveHelpers.h:46
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
jobOption.theta
theta
Definition: jobOption.ParticleGun_fwd_sequence.py:13
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
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:203
Trk::PrepRawData
Definition: PrepRawData.h:62
ActsTrk::SiSpacePointsSeedMaker::m_useClusters
Gaudi::Property< bool > m_useClusters
Definition: SiSpacePointsSeedMaker.h:221
ActsTrk::SiSpacePointsSeedMaker::retrieveOverlap
StatusCode retrieveOverlap(const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, const Trk::PRDtoTrackMap *prd_to_track_map_cptr) const
Definition: SiSpacePointsSeedMaker.cxx:329
ActsTrk::SiSpacePointsSeedMaker::dumpConditions
MsgStream & dumpConditions(InDet::SiSpacePointsSeedMakerEventData &data, MsgStream &out) const
Definition: SiSpacePointsSeedMaker.cxx:760
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:228
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:82
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
DeMoScan.index
string index
Definition: DeMoScan.py:364
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
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:213
ActsTrk::SiSpacePointsSeedMaker::dump
virtual MsgStream & dump(InDet::SiSpacePointsSeedMakerEventData &data, MsgStream &out) const override
Definition: SiSpacePointsSeedMaker.cxx:747
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
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:47
ActsTrk::SiSpacePointsSeedMaker::dumpEvent
static MsgStream & dumpEvent(InDet::SiSpacePointsSeedMakerEventData &data, MsgStream &out)
Definition: SiSpacePointsSeedMaker.cxx:832
python.FPGATrackSimAnalysisConfig.spacePoints
spacePoints
Definition: FPGATrackSimAnalysisConfig.py:563
ActsTrk::SiSpacePointsSeedMaker::m_pixelDetEleCollKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_pixelDetEleCollKey
Definition: SiSpacePointsSeedMaker.h:211
Trk::Surface::transform
const Amg::Transform3D & transform() const
Returns HepGeom::Transform3D by reference.
dq_make_web_display.cl
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
Definition: dq_make_web_display.py:26
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:878
ActsTrk::SiSpacePointsSeedMaker::convertStripSeed
bool convertStripSeed(const EventContext &ctx, InDet::SiSpacePointsSeedMakerEventData &data, const ActsTrk::SeedContainer &seedPtrs) const
Definition: SiSpacePointsSeedMaker.cxx:853
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:189
ActsTrk::SiSpacePointsSeedMaker::m_actsSpacepointsOverlap
SG::ReadHandleKey< xAOD::SpacePointContainer > m_actsSpacepointsOverlap
Definition: SiSpacePointsSeedMaker.h:205
ITk::SiSpacePointForSeed
Definition: ITkSiSpacePointForSeed.h:33
SG::ReadCondHandle::cptr
const_pointer_type cptr()
Definition: ReadCondHandle.h:71
Generated on Thu Mar 13 2025 21:51:05 for ATLAS Offline Software by   doxygen 1.8.18