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

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.

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

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

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

  {
    SG::ReadCondHandle< InDet::BeamSpotData > beamSpotHandle { m_beamSpotKey, ctx };
    
    const Amg::Vector3D &cb = beamSpotHandle->beamPos();
    double tx = std::tan(beamSpotHandle->beamTilt(0));
    double ty = std::tan(beamSpotHandle->beamTilt(1));
 
    double phi = std::atan2(ty, tx);
    double theta = std::acos(1. / std::sqrt(1. + tx * tx + ty * ty));
    double sinTheta = std::sin(theta);
    double cosTheta = std::cos(theta);
    double sinPhi = std::sin(phi);
    double cosPhi = std::cos(phi);
 
    data.xbeam[0] = static_cast<float>(cb.x());
    data.xbeam[1] = static_cast<float>(cosTheta * cosPhi * cosPhi + sinPhi * sinPhi);
    data.xbeam[2] = static_cast<float>(cosTheta * sinPhi * cosPhi - sinPhi * cosPhi);
    data.xbeam[3] = -static_cast<float>(sinTheta * cosPhi);
 
    data.ybeam[0] = static_cast<float>(cb.y());
    data.ybeam[1] = static_cast<float>(cosTheta * cosPhi * sinPhi - sinPhi * cosPhi);
    data.ybeam[2] = static_cast<float>(cosTheta * sinPhi * sinPhi + cosPhi * cosPhi);
    data.ybeam[3] = -static_cast<float>(sinTheta * sinPhi);
 
    data.zbeam[0] = static_cast<float>(cb.z());
    data.zbeam[1] = static_cast<float>(sinTheta * cosPhi);
    data.zbeam[2] = static_cast<float>(sinTheta * sinPhi);
    data.zbeam[3] = static_cast<float>(cosTheta);
 
    // Acts Seed Tool requires both MagneticFieldContext and BeamSpotData
    // we need to retrieve them both from StoreGate
    // Read the b-field information
    SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle { m_fieldCondObjInputKey, ctx };
    if ( not readHandle.isValid() ) {
      throw std::runtime_error("Error while retrieving Atlas Field Cache Cond DB");
    }
    const AtlasFieldCacheCondObj* fieldCondObj{ *readHandle };
    if (fieldCondObj == nullptr) {
      throw std::runtime_error("Failed to retrieve AtlasFieldCacheCondObj with key " + m_fieldCondObjInputKey.key());
    }
 
    // Get the magnetic field
    // Using ACTS classes in order to be sure we are consistent
    Acts::MagneticFieldContext magFieldContext(fieldCondObj);
 
    // Beam Spot Position
    Acts::Vector3 beamPos( data.xbeam[0] * Acts::UnitConstants::mm,
                           data.ybeam[0] * Acts::UnitConstants::mm,
                           0. );
 
    // Magnetic Field
    ATLASMagneticFieldWrapper magneticField;
    Acts::MagneticFieldProvider::Cache magFieldCache = magneticField.makeCache( magFieldContext );
    Acts::Vector3 bField = *magneticField.getField( beamPos,
                                                    magFieldCache );
 
    data.bField[0] = bField[0];
    data.bField[1] = bField[1];
    data.bField[2] = bField[2];
 
    data.K = 2. * s_toTesla / (300. * bField[2]);
 
  }

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.

                                                                   {
    // If the read handle key for clusters is not empty, that means the xAOD->InDet Cluster link is available
    // Else we can use xAOD->Trk Space Point link
    // If none of these is available, we have a JO misconfguration!
    static const SG::AuxElement::Accessor< ElementLink< InDet::PixelClusterCollection > > pixelLinkAcc("pixelClusterLink");
    static const SG::AuxElement::Accessor< ElementLink< ::SpacePointCollection > > linkAcc("pixelSpacePointLink");
 
    if (m_useClusters) {
      data.v_PixelSpacePointForSeed.clear();
    }
 
    data.v_PixelSiSpacePointForSeed.clear();
    data.v_PixelSiSpacePointForSeed.reserve(data.ns);
    std::unordered_map<std::size_t, std::size_t> bridge_idx_sispacepoints;
 
    std::array<const Trk::SpacePoint*, 3> spacePoints {nullptr, nullptr, nullptr};
    std::array<ITk::SiSpacePointForSeed*, 3> pixelSpacePointsForSeeds {nullptr, nullptr, nullptr};
 
    for (const ActsTrk::Seed seedProxy : seedPtrs) {
      const ActsTrk::Seed* seed = &seedProxy;  // keep old-style seed as pointer
      std::array<std::size_t, 3> indexes {
    seed->sp()[0]->index(),
      seed->sp()[1]->index(),
      seed->sp()[2]->index()
      };
 
      const auto [bottom_idx, medium_idx, top_idx] = indexes;
      std::size_t max_index = std::max(bottom_idx, std::max(medium_idx, top_idx));
      if (data.v_PixelSpacePointForSeed.size() < max_index + 1) {
    data.v_PixelSpacePointForSeed.resize( max_index + 1 );
      }
 
      // Retrieve/make the space points!
      if (not m_useClusters) {
    // Get the Space Point from the element link
    if (not linkAcc.isAvailable(*seed->sp()[0])){
      ATH_MSG_FATAL("no pixelSpacePointLink for bottom sp!");
      return false;
    }
    if (not linkAcc.isAvailable(*seed->sp()[1])){
      ATH_MSG_FATAL("no pixelSpacePointLink for middle sp!");
      return false;
    }
    if (not linkAcc.isAvailable(*seed->sp()[2])){
      ATH_MSG_FATAL("no pixelSpacePointLink for top sp!");
      return false;
    }
 
    spacePoints = {
      *linkAcc(*seed->sp()[0]),
      *linkAcc(*seed->sp()[1]),
      *linkAcc(*seed->sp()[2])
    };      
      }
      else {
    // Get the clusters from the xAOD::Clusters and then make the space points
    const xAOD::PixelCluster* bottom_cluster = reinterpret_cast<const xAOD::PixelCluster*>(seed->sp()[0]->measurements()[0]);
    const xAOD::PixelCluster* medium_cluster = reinterpret_cast<const xAOD::PixelCluster*>(seed->sp()[1]->measurements()[0]);
    const xAOD::PixelCluster* top_cluster = reinterpret_cast<const xAOD::PixelCluster*>(seed->sp()[2]->measurements()[0]);
 
    if (not pixelLinkAcc.isAvailable(*bottom_cluster)) {
      ATH_MSG_FATAL("no pixelClusterLink for cluster associated to bottom sp!");
      return false;
    }
    if (not pixelLinkAcc.isAvailable(*medium_cluster)) {
      ATH_MSG_FATAL("no pixelClusterLink for cluster associated to middle sp!");
      return false;
    }
    if (not pixelLinkAcc.isAvailable(*top_cluster)) {
      ATH_MSG_FATAL("no pixelClusterLink for cluster associated to top sp!");
      return false;
    }
 
    if (not data.v_PixelSpacePointForSeed[bottom_idx]) 
      data.v_PixelSpacePointForSeed[bottom_idx] = std::make_unique<InDet::PixelSpacePoint>(bottom_cluster->identifierHash(), *(pixelLinkAcc(*bottom_cluster)));
    if (not data.v_PixelSpacePointForSeed[medium_idx]) 
      data.v_PixelSpacePointForSeed[medium_idx] = std::make_unique<InDet::PixelSpacePoint>(medium_cluster->identifierHash(), *(pixelLinkAcc(*medium_cluster)));
    if (not data.v_PixelSpacePointForSeed[top_idx]) 
      data.v_PixelSpacePointForSeed[top_idx] = std::make_unique<InDet::PixelSpacePoint>(top_cluster->identifierHash(), *(pixelLinkAcc(*top_cluster)));
    
    spacePoints =  { 
      data.v_PixelSpacePointForSeed[bottom_idx].get(),
      data.v_PixelSpacePointForSeed[medium_idx].get(),
      data.v_PixelSpacePointForSeed[top_idx].get()
    };
 
      }
           
      for (int index = 0; index<3; ++index) {
    std::size_t sp_idx = indexes[index];
 
    // Try add an element. 
    // If already there just return the old value
    // If not present, we add a new element to it
    auto [itr, outcome] = bridge_idx_sispacepoints.try_emplace(sp_idx, data.v_PixelSiSpacePointForSeed.size());
    std::size_t mapped_idx = itr->second;
    // We added a new element
    if (outcome) { 
      std::array<float, 15> r;
      r[0] = seed->sp()[index]->x();
      r[1] = seed->sp()[index]->y();
      r[2] = seed->sp()[index]->z();
      pixInform(spacePoints[index], r.data());     
      data.v_PixelSiSpacePointForSeed.emplace_back( spacePoints[index], r );
 
    }
    data.v_PixelSiSpacePointForSeed[mapped_idx].setQuality(-seed->seedQuality());
    pixelSpacePointsForSeeds[index] = &data.v_PixelSiSpacePointForSeed[mapped_idx];
      }
      
      data.i_ITkSeeds.emplace_back(pixelSpacePointsForSeeds[0],
                   pixelSpacePointsForSeeds[1],
                   pixelSpacePointsForSeeds[2],
                   seed->z());
      data.i_ITkSeeds.back().setQuality(-seed->seedQuality());
    }    
    
    return true;
  }

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.

                                                                   {
    // If the read handle key for clusters is not empty, that means the xAOD->InDet Cluster link is available
    // Else we can use xAOD->Trk Space Point link
    // If none of these is available, we have a JO misconfguration!
    static const SG::AuxElement::Accessor< ElementLink< ::SpacePointCollection > > linkAcc("sctSpacePointLink");
    static const SG::AuxElement::Accessor< ElementLink< ::SpacePointOverlapCollection > > overlaplinkAcc("stripOverlapSpacePointLink");
    static const SG::AuxElement::Accessor< ElementLink< InDet::SCT_ClusterCollection > > stripLinkAcc("sctClusterLink");
 
    if (m_useClusters) {
      data.v_StripSpacePointForSeed.clear();
    }
 
    std::array<const Trk::SpacePoint*, 3> spacePoints {};
    std::array<ITk::SiSpacePointForSeed*, 3> stripSpacePointsForSeeds {};
 
    for (const ActsTrk::Seed seedProxy : seedPtrs) {
      const ActsTrk::Seed* seed = &seedProxy;  // keep old-style seed as pointer
      // Retrieve/make space points
      if (not m_useClusters) {
    // Get the space point from the element link
    if (not linkAcc.isAvailable(*seed->sp()[0]) and
        not overlaplinkAcc.isAvailable(*seed->sp()[0])) {
      ATH_MSG_FATAL("no sctSpacePointLink/stripOverlapSpacePointLink for bottom sp!");
      return false;
    }
    if (not linkAcc.isAvailable(*seed->sp()[1]) and
        not overlaplinkAcc.isAvailable(*seed->sp()[1])) {
      ATH_MSG_FATAL("no sctSpacePointLink/stripOverlapSpacePointLink for middle sp!");
      return false;
    }
    if (not linkAcc.isAvailable(*seed->sp()[2])  and
        not overlaplinkAcc.isAvailable(*seed->sp()[2])) {
      ATH_MSG_FATAL("no sctSpacePointLink/stripOverlapSpacePointLink for top sp!");
      return false;
    }
    
    for (std::size_t nsp(0ul); nsp < 3ul; ++nsp) {
      spacePoints[nsp] = linkAcc.isAvailable(*seed->sp()[nsp])
        ? *linkAcc(*seed->sp()[nsp])
        : *overlaplinkAcc(*seed->sp()[nsp]);
    }
      } 
      else {
    // Get the clusters from the xAOD::Clusters and then make the space points
    const auto& bottom_idx = seed->sp()[0]->measurements();
    const auto& medium_idx = seed->sp()[1]->measurements();
    const auto& top_idx    = seed->sp()[2]->measurements();
 
    std::array<const xAOD::StripCluster*, 6> strip_cluster { 
      reinterpret_cast<const xAOD::StripCluster*>(bottom_idx[0]),
      reinterpret_cast<const xAOD::StripCluster*>(bottom_idx[1]),
      reinterpret_cast<const xAOD::StripCluster*>(medium_idx[0]),
      reinterpret_cast<const xAOD::StripCluster*>(medium_idx[1]),
      reinterpret_cast<const xAOD::StripCluster*>(top_idx[0]),
      reinterpret_cast<const xAOD::StripCluster*>(top_idx[1])
        };
    
    if (not stripLinkAcc.isAvailable(*strip_cluster[0]) or 
        not stripLinkAcc.isAvailable(*strip_cluster[1])){
      ATH_MSG_FATAL("no sctClusterLink for clusters associated to bottom sp!");
      return false;
    }
    if (not stripLinkAcc.isAvailable(*strip_cluster[2]) or 
        not stripLinkAcc.isAvailable(*strip_cluster[3])){
      ATH_MSG_FATAL("no sctClusterLink for clusters associated to middle sp!");
      return false;
    }
    if (not stripLinkAcc.isAvailable(*strip_cluster[4]) or 
        not stripLinkAcc.isAvailable(*strip_cluster[5])){
      ATH_MSG_FATAL("no sctClusterLink for clusters associated to top sp!");
      return false;
    }
 
    std::pair<std::size_t, std::size_t> key_b = std::make_pair(strip_cluster[0]->index(), strip_cluster[1]->index());
    std::pair<std::size_t, std::size_t> key_m = std::make_pair(strip_cluster[2]->index(), strip_cluster[3]->index());
    std::pair<std::size_t, std::size_t> key_t = std::make_pair(strip_cluster[4]->index(), strip_cluster[5]->index());
 
        std::unique_ptr<InDet::SCT_SpacePoint>& ptr_b = data.v_StripSpacePointForSeed[key_b];
    if (!ptr_b) {
      ptr_b = std::make_unique<InDet::SCT_SpacePoint>(std::make_pair<IdentifierHash, IdentifierHash>(strip_cluster[0]->identifierHash(), strip_cluster[1]->identifierHash()),
                                             Amg::Vector3D(seed->sp()[0]->x(), seed->sp()[0]->y(), seed->sp()[0]->z()),
                                             std::make_pair<const Trk::PrepRawData*, const Trk::PrepRawData*>(*(stripLinkAcc(*strip_cluster[0])), *(stripLinkAcc(*strip_cluster[1]))));
    }
        std::unique_ptr<InDet::SCT_SpacePoint>& ptr_m = data.v_StripSpacePointForSeed[key_m];
    if (!ptr_m) {
      ptr_m = std::make_unique<InDet::SCT_SpacePoint>(std::make_pair<IdentifierHash, IdentifierHash>(strip_cluster[2]->identifierHash(), strip_cluster[3]->identifierHash()),
                                             Amg::Vector3D(seed->sp()[1]->x(), seed->sp()[1]->y(), seed->sp()[1]->z()),
                                             std::make_pair<const Trk::PrepRawData*, const Trk::PrepRawData*>(*(stripLinkAcc(*strip_cluster[2])), *(stripLinkAcc(*strip_cluster[3]))));
    }
        std::unique_ptr<InDet::SCT_SpacePoint>& ptr_t = data.v_StripSpacePointForSeed[key_t];
    if (!ptr_t) {
      ptr_t = std::make_unique<InDet::SCT_SpacePoint>(std::make_pair<IdentifierHash, IdentifierHash>(strip_cluster[4]->identifierHash(), strip_cluster[5]->identifierHash()),
                                             Amg::Vector3D(seed->sp()[2]->x(), seed->sp()[2]->y(), seed->sp()[2]->z()),
                                             std::make_pair<const Trk::PrepRawData*, const Trk::PrepRawData*>(*(stripLinkAcc(*strip_cluster[4])), *(stripLinkAcc(*strip_cluster[5]))));
    }
    
    spacePoints = {
      data.v_StripSpacePointForSeed[key_b].get(),
      data.v_StripSpacePointForSeed[key_m].get(),
      data.v_StripSpacePointForSeed[key_t].get()
    };
 
      }
 
      for (unsigned int index = 0; index<3; index++) {
    std::array<float, 15> r;
    r[0] = seed->sp()[index]->x();
    r[1] = seed->sp()[index]->y();
    r[2] = seed->sp()[index]->z();
    stripInform(data, spacePoints[index], r);
    stripSpacePointsForSeeds[index] = new ITk::SiSpacePointForSeed(spacePoints[index], r);
    stripSpacePointsForSeeds[index]->setQuality(-seed->seedQuality());
      }
      
      data.i_ITkSeeds.emplace_back(stripSpacePointsForSeeds[0], stripSpacePointsForSeeds[1],
                   stripSpacePointsForSeeds[2], seed->z());
      data.i_ITkSeeds.back().setQuality(-seed->seedQuality());
    }
    
    return true;
  }

dump()

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

overridevirtual

Definition at line 746 of file SiSpacePointsSeedMaker.cxx.

  {
    if (data.nprint)
      return dumpEvent(data, out);
    return dumpConditions(data, out);
  }

dumpConditions()

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

private

Definition at line 759 of file SiSpacePointsSeedMaker.cxx.

  {
    std::string s2, s3, s4, s5;
 
    int n = 42-m_actsSpacepointsPixel.key().size();
    s2.append(n,' ');
    s2.append("|");
    n     = 42-m_actsSpacepointsStrip.key().size();
    s3.append(n,' ');
    s3.append("|");
    n     = 42-m_actsSpacepointsOverlap.key().size();
    s4.append(n,' ');
    s4.append("|");
    n     = 42-m_beamSpotKey.key().size();
    s5.append(n,' ');
    s5.append("|");
 
    out<<"|---------------------------------------------------------------------|"
       <<endmsg;
    out<<"| Pixel    space points   | "<<m_actsSpacepointsPixel.key() <<s2
       <<endmsg;
    out<<"| Strip    space points   | "<<m_actsSpacepointsStrip.key()<<s3
       <<endmsg;
    out<<"| Overlap  space points   | "<<m_actsSpacepointsOverlap.key()<<s4
       <<endmsg;
    out<<"| BeamConditionsService   | "<<m_beamSpotKey.key()<<s5
       <<endmsg;
    out<<"| usePixel                | "
       <<std::setw(12)<<m_pixel 
       <<"                              |"<<endmsg;
    out<<"| useStrip                | "
       <<std::setw(12)<<m_strip
       <<"                              |"<<endmsg;
    out<<"| useStripOverlap         | "
       <<std::setw(12)<<m_useOverlap
       <<"                              |"<<endmsg;
    out<<"|---------------------------------------------------------------------|"
       <<endmsg;
    out<<"| Beam X center           | "
       <<std::setw(12)<<std::setprecision(5)<<data.xbeam[0]
       <<"                              |"<<endmsg;
    out<<"| Beam Y center           | "
       <<std::setw(12)<<std::setprecision(5)<<data.ybeam[0]
       <<"                              |"<<endmsg;
    out<<"| Beam Z center           | "
       <<std::setw(12)<<std::setprecision(5)<<data.zbeam[0]
       <<"                              |"<<endmsg;
    out<<"| Beam X-axis direction   | "
       <<std::setw(12)<<std::setprecision(5)<<data.xbeam[1]
       <<std::setw(12)<<std::setprecision(5)<<data.xbeam[2]
       <<std::setw(12)<<std::setprecision(5)<<data.xbeam[3]
       <<"      |"<<endmsg;
    out<<"| Beam Y-axis direction   | "
       <<std::setw(12)<<std::setprecision(5)<<data.ybeam[1]
       <<std::setw(12)<<std::setprecision(5)<<data.ybeam[2]
       <<std::setw(12)<<std::setprecision(5)<<data.ybeam[3]
       <<"      |"<<endmsg;
    out<<"| Beam Z-axis direction   | "
       <<std::setw(12)<<std::setprecision(5)<<data.zbeam[1]
       <<std::setw(12)<<std::setprecision(5)<<data.zbeam[2]
       <<std::setw(12)<<std::setprecision(5)<<data.zbeam[3]
       <<"      |"<<endmsg;
    out<<"|---------------------------------------------------------------------|"
       <<endmsg;
    return out;
 
  }

dumpEvent()

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

staticprivate

Definition at line 831 of file SiSpacePointsSeedMaker.cxx.

  {
    out<<"|---------------------------------------------------------------------|"
       <<endmsg;
    out<<"| ns                       | "
       <<std::setw(12)<<data.ns
       <<"                              |"<<endmsg;
    out<<"| nsaz                     | "
       <<std::setw(12)<<data.nsaz
       <<"                              |"<<endmsg;
    out<<"| seeds                    | "
       <<std::setw(12)<< data.nsazv
       <<"                              |"<<endmsg;
    out<<"|---------------------------------------------------------------------|"
       <<endmsg;
    return out;
 
  }

find2Sp()

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

inlineoverridevirtual

Definition at line 105 of file SiSpacePointsSeedMaker.h.

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

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.

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

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.

  {
    // Fast return if no sps are collected
    if ( data.v_ActsSpacePointForSeed.empty() )
      return;
 
    // select the ACTS seeding tool to call, if for PPP or SSS
    bool isPixel = (m_fastTracking or data.iteration == 1) and m_pixel;
 
    // this is use for a fast retrieval of the space points later
    std::vector<ITk::SiSpacePointForSeed*> sp_storage;
 
    // We can now run the Acts Seeding
    std::unique_ptr< ActsTrk::SeedContainer > seedPtrs = std::make_unique< ActsTrk::SeedContainer >();
    //cppcheck-suppress unreadVariable
    std::string combinationType = isPixel ? "PPP" : "SSS";
    ATH_MSG_DEBUG("Running Seed Finding (" << combinationType << ") ...");
 
    // Beam Spot Position
    Acts::Vector3 beamPos( data.xbeam[0] * Acts::UnitConstants::mm,
                           data.ybeam[0] * Acts::UnitConstants::mm,
                           data.zbeam[0] * Acts::UnitConstants::mm);
 
    Acts::Vector3 bField( data.bField[0], data.bField[1], data.bField[2] );
 
 
    ActsTrk::SpacePointCollector backEnd(data.v_ActsSpacePointForSeed);
 
    Acts::SpacePointContainerConfig spConfig;
    spConfig.useDetailedDoubleMeasurementInfo = not isPixel;
    // Options
    Acts::SpacePointContainerOptions spOptions;
    spOptions.beamPos = Acts::Vector2(beamPos.x(), beamPos.y());
    
    Acts::SpacePointContainer<decltype(backEnd), Acts::detail::RefHolder> collect(spConfig, spOptions, backEnd);
 
    
    StatusCode sc;
 
    if (isPixel)
      sc = m_seedsToolPixel->createSeeds( ctx,
                                          collect,
                                          beamPos,
                                          bField,
                                          *seedPtrs.get() );
    else {
      sc = m_seedsToolStrip->createSeeds( ctx,
                                          collect,
                                          beamPos,
                                          bField,
                                          *seedPtrs.get() );
    }
 
    if (sc == StatusCode::FAILURE) {
      ATH_MSG_ERROR("Error during seed production (" << combinationType << ")");
      return;
    }
 
    ATH_MSG_DEBUG("    \\__ Created " << seedPtrs->size() << " seeds");
    data.nsazv = seedPtrs->size();
 
    // Store seeds to data
    // We need now to convert the output to Athena object once again (i.e. ITk::SiSpacePointForSeed)
    // The seeds will be stored in data.i_ITkSeeds (both PPP and SSS seeds)
    if (m_doSeedConversion) {
      
      if (isPixel) {
    if (not convertPixelSeed(ctx, data, *seedPtrs.get())) {
      ATH_MSG_FATAL("Error in pixel seed conversion");
      return;
    }
      } else {
    if (not convertStripSeed(ctx, data, *seedPtrs.get())) {
      ATH_MSG_FATAL("Error in strip seed conversion");
      return;
    }
      }
    }
 
    data.i_ITkSeed = data.i_ITkSeeds.begin();
    data.nprint = 1;
    dump(data, msg(MSG::DEBUG));
  }

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.

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

getWriteNtupleBoolProperty()

bool ActsTrk::SiSpacePointsSeedMaker::getWriteNtupleBoolProperty ( ) const

overridevirtual

Definition at line 742 of file SiSpacePointsSeedMaker.cxx.

  { return m_writeNtuple; }

initialize()

StatusCode ActsTrk::SiSpacePointsSeedMaker::initialize ( )

overridevirtual

Definition at line 40 of file SiSpacePointsSeedMaker.cxx.

  {
    ATH_MSG_DEBUG( "Initializing " << name() << "..." );
 
    ATH_MSG_DEBUG( "Properties Summary:" );
    ATH_MSG_DEBUG( "   " << m_pixel );
    ATH_MSG_DEBUG( "   " << m_strip );
    ATH_MSG_DEBUG( "   " << m_useOverlap );
    ATH_MSG_DEBUG( "   " << m_writeNtuple );
    ATH_MSG_DEBUG( "   " << m_fastTracking );
 
    if (not m_pixel and not m_strip) {
      ATH_MSG_ERROR("Activate seeding on at least one between Pixel and Strip space point collections!");
      return StatusCode::FAILURE;
    }
 
    ATH_CHECK( m_actsSpacepointsPixel.initialize(m_pixel) );
    ATH_CHECK( m_actsSpacepointsStrip.initialize(m_strip) );
    ATH_CHECK( m_actsSpacepointsOverlap.initialize(m_strip and m_useOverlap) );
 
    ATH_CHECK( m_seedsToolPixel.retrieve(EnableTool{m_pixel}) );
    ATH_CHECK( m_seedsToolStrip.retrieve(EnableTool{m_strip}) );
 
    ATH_CHECK( m_prdToTrackMap.initialize(not m_prdToTrackMap.empty() ) );
    
    ATH_CHECK( m_beamSpotKey.initialize() );
    ATH_CHECK( m_fieldCondObjInputKey.initialize() );
 
    ATH_CHECK(m_pixelDetEleCollKey.initialize());
    ATH_CHECK(m_stripDetEleCollKey.initialize());
    
    // Validation
    if (m_writeNtuple) 
      ATH_CHECK( InitTree() );
 
    return StatusCode::SUCCESS;
  }

InitTree()

StatusCode ActsTrk::SiSpacePointsSeedMaker::InitTree ( )

private

Definition at line 81 of file SiSpacePointsSeedMaker.cxx.

  {
    ATH_CHECK( m_thistSvc.retrieve() );
    std::string tree_name = std::string("SeedTree_") + name();
    std::replace( tree_name.begin(), tree_name.end(), '.', '_' );
 
    m_outputTree = new TTree( tree_name.c_str() , "ActsSeedMakerValTool");
 
    m_outputTree->Branch("eventNumber",    &m_eventNumber,"eventNumber/L");
    m_outputTree->Branch("d0",             &m_d0);
    m_outputTree->Branch("z0",             &m_z0);
    m_outputTree->Branch("pt",             &m_pt);
    m_outputTree->Branch("eta",            &m_eta);
    m_outputTree->Branch("x1",             &m_x1);
    m_outputTree->Branch("x2",             &m_x2);
    m_outputTree->Branch("x3",             &m_x3);
    m_outputTree->Branch("y1",             &m_y1);
    m_outputTree->Branch("y2",             &m_y2);
    m_outputTree->Branch("y3",             &m_y3);
    m_outputTree->Branch("z1",             &m_z1);
    m_outputTree->Branch("z2",             &m_z2);
    m_outputTree->Branch("z3",             &m_z3);
    m_outputTree->Branch("r1",             &m_r1);
    m_outputTree->Branch("r2",             &m_r2);
    m_outputTree->Branch("r3",             &m_r3);
    m_outputTree->Branch("quality",        &m_quality);
    m_outputTree->Branch("seedType",       &m_type);
    m_outputTree->Branch("givesTrack",     &m_givesTrack);
    m_outputTree->Branch("dzdr_b",         &m_dzdr_b);
    m_outputTree->Branch("dzdr_t",         &m_dzdr_t);
    m_outputTree->Branch("track_pt",       &m_trackPt);
    m_outputTree->Branch("track_eta",      &m_trackEta);
 
    std::string full_tree_name = "/" + m_treeFolder + "/" + tree_name;
    ATH_CHECK( m_thistSvc->regTree( full_tree_name.c_str(), m_outputTree ) );
 
    return StatusCode::SUCCESS;
  }

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.

  {
    const Trk::PrepRawData* d = sp->clusterList().first;
    if (!d || !prd_to_track_map.isUsed(*d)) return false;
    
    d = sp->clusterList().second;
    if (!d || prd_to_track_map.isUsed(*d)) return true;
    
    return false;
  }

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.

  {
    static const SG::AuxElement::ConstAccessor< ElementLink< ::SpacePointCollection > > pixelLinkAcc("pixelSpacePointLink");
    static const SG::AuxElement::ConstAccessor< ElementLink< ::SpacePointCollection > > stripLinkAcc("sctSpacePointLink");
    static const SG::AuxElement::ConstAccessor< ElementLink< ::SpacePointOverlapCollection > > stripOverlapLinkacc("stripOverlapSpacePointLink");
 
    const Trk::SpacePoint *indetSp = nullptr;
    if ( pixelLinkAcc.isAvailable(*sp) ) {
      const ElementLink< ::SpacePointCollection > link = pixelLinkAcc( *sp );
      indetSp = *link;
    }
    else if ( stripLinkAcc.isAvailable(*sp) ) {
      const ElementLink< ::SpacePointCollection > link = stripLinkAcc( *sp );
      indetSp = *link;
    } else if ( stripOverlapLinkacc.isAvailable(*sp) ) {
      const ElementLink< ::SpacePointOverlapCollection > link = stripOverlapLinkacc( *sp );
      indetSp = *link;
    } else {
      return false;
    }
 
    return isUsed(indetSp, prd_to_track_map);
  }

newEvent()

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

overridevirtual

Definition at line 521 of file SiSpacePointsSeedMaker.cxx.

  {
    // Store iteration into data for use in other methods
    data.iteration = iteration;
    if (iteration < 0)
      data.iteration = 0;
 
    // At the beginning of each iteration
    // clearing list of space points to be used for seeding
    InDet::SiSpacePointsSeedMakerEventData::clearPoolList(data.l_ITkSpacePointForSeed);
    data.i_ITkSpacePointForSeed = data.l_ITkSpacePointForSeed.begin();
    data.v_ActsSpacePointForSeed.clear();
 
 
    // clearing list of produced seeds
    InDet::SiSpacePointsSeedMakerEventData::clearPoolList(data.i_ITkSeeds);
    data.i_ITkSeed = data.i_ITkSeeds.begin();
 
    // First iteration:
    // -- event-specific configuration, i.e. beamspot and magnetic field
    // -- for default case: producing SSS
    // -- for fast tracking: producing PPP
    // Second iteration:
    // -- for default case: producing PPP
    // -- no additional iteration is foreseen for fast tracking case
 
    bool isPixel = (m_fastTracking or data.iteration == 1) and m_pixel;
    bool isStrip = not m_fastTracking and data.iteration == 0 and m_strip;
 
    // The Acts Seed tool requires beamspot information for the space points already here
    if (data.iteration == 0) 
      buildBeamFrameWork(ctx, data);
 
    // initialising the number of space points as well
    data.ns = 0;
    data.nsaz = 0;
    data.nsazv = 0;
 
    // Retrieve the Trk::PRDtoTrackMap
    const Trk::PRDtoTrackMap *prd_to_track_map_cptr = nullptr;
    if ( not m_prdToTrackMap.empty() ) {
      SG::ReadHandle<Trk::PRDtoTrackMap> prd_handle = SG::makeHandle( m_prdToTrackMap, ctx );
      if ( not prd_handle.isValid() ) {
        ATH_MSG_ERROR("Failed to read PRD to track association map: " << m_prdToTrackMap.key());
      }
      prd_to_track_map_cptr = prd_handle.get();
    }
 
    // Only retrieving the collections needed for the seed formation,
    // depending on the tool configuration and iteration
 
    // Retrieve Pixels
    if (isPixel and not retrievePixel(ctx, data, prd_to_track_map_cptr).isSuccess() ) {
      ATH_MSG_ERROR("Error while retrieving Pixel space points with key " << m_actsSpacepointsPixel.key());
    }
 
    // Retrieve Strips
    if (isStrip and not retrieveStrip(ctx, data, prd_to_track_map_cptr).isSuccess() ) {
      ATH_MSG_ERROR("Error while retrieving Strip space points with key " << m_actsSpacepointsStrip.key());
    }
 
    // Retrieve Overlaps, will go into Strip collection
    if ((isStrip and m_useOverlap) and not retrieveOverlap(ctx, data, prd_to_track_map_cptr).isSuccess() ) {
      ATH_MSG_ERROR("Error while retrieving Strip Overlap space points with key " <<  m_actsSpacepointsOverlap.key());
    }    
 
    data.initialized = true;
  }

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.

  {
    ATH_MSG_DEBUG("Calling " << name() << "::newRegion");
    if (!m_pixel && !m_strip)
      return;
 
    InDet::SiSpacePointsSeedMakerEventData::clearPoolList(data.l_ITkSpacePointForSeed);
    data.i_ITkSpacePointForSeed = data.l_ITkSpacePointForSeed.begin();
    data.v_ActsSpacePointForSeed.clear();
    
    InDet::SiSpacePointsSeedMakerEventData::clearPoolList(data.i_ITkSeeds);
    data.i_ITkSeed = data.i_ITkSeeds.begin();
    
    buildBeamFrameWork(ctx, data); 
 
    data.ns = 0;
    data.nsaz = 0;
    data.nsazv = 0;
 
    const Trk::PRDtoTrackMap *prd_to_track_map_cptr = nullptr;
    if ( not m_prdToTrackMap.empty() ) {
      SG::ReadHandle<Trk::PRDtoTrackMap> prd_handle = SG::makeHandle( m_prdToTrackMap, ctx );
      if ( not prd_handle.isValid() ) {
        ATH_MSG_ERROR("Failed to read PRD to track association map: " << m_prdToTrackMap.key());
      }
      prd_to_track_map_cptr = prd_handle.get();
    }
    if (prd_to_track_map_cptr != nullptr) {
      ATH_MSG_DEBUG("Retrieved prd map with name " << m_prdToTrackMap.key());
    }
    
    if ( not retrievePixel(ctx, data, vPixel, prd_to_track_map_cptr).isSuccess() ) {
      ATH_MSG_ERROR("Error while retrieving Pixel space points with key " << m_actsSpacepointsPixel.key());
    }
 
    if ( not retrieveStrip(ctx, data, vStrip, prd_to_track_map_cptr).isSuccess() ) {
      ATH_MSG_ERROR("Error while retrieving Strip space points with key " << m_actsSpacepointsStrip.key());
    }
 
    if ( m_useOverlap and not retrieveOverlap(ctx, data, prd_to_track_map_cptr).isSuccess() ) {
      ATH_MSG_ERROR("Error while retrieving Strip Overlap space points with key " <<  m_actsSpacepointsOverlap.key());
    }
 
    data.initialized = true;
  }

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.

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

newSpacePoint()

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

private

Definition at line 121 of file SiSpacePointsSeedMaker.cxx.

  {
    
    data.v_ActsSpacePointForSeed.emplace_back(sp);
    data.ns++;
    data.nsaz++;
  }

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.

  {
 
    do {
      if (data.i_ITkSeed == data.i_ITkSeeds.end())
        return nullptr;
 
    // iterate until we find a valid seed satisfying certain quality cuts in set3
    } while (!(*data.i_ITkSeed++).set3(data.seedOutput, 1./(1000. * data.K)));

    return &data.seedOutput;
 
  }

pixInform()

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.

  {
    if (ids.empty()) return StatusCode::SUCCESS;
 
    ATH_MSG_DEBUG("Retrieving strip overlap space point collection " << m_actsSpacepointsOverlap.key());
    SG::ReadHandle< xAOD::SpacePointContainer > inputSpacePointContainer( m_actsSpacepointsOverlap, ctx );
    if (not inputSpacePointContainer.isValid()){
      ATH_MSG_FATAL("xAOD::SpacePointContainer with key " << m_actsSpacepointsOverlap.key() << " is not available...");
      return StatusCode::FAILURE;
    }
    const xAOD::SpacePointContainer *inputCollection = inputSpacePointContainer.cptr();
 
    ATH_MSG_DEBUG("Retrieving SiDetectorElementCollection with key `" << m_stripDetEleCollKey.key() << "`");
    SG::ReadCondHandle< InDetDD::SiDetectorElementCollection > detEleHandle = SG::makeHandle( m_stripDetEleCollKey, ctx );
    ATH_CHECK(detEleHandle.isValid());
    const InDetDD::SiDetectorElementCollection* detElements = detEleHandle.cptr();
 
    ContainerAccessor< xAOD::SpacePoint, IdentifierHash, 1>
      accessor ( *inputCollection,
                 [] (const xAOD::SpacePoint& coll) -> IdentifierHash
                 { return coll.elementIdList()[0]; },
                 detElements->size());
 
    for (const IdentifierHash id : ids) {
      if (not accessor.isIdentifierPresent(id)) {
        continue;
      }
 
      const auto& ranges = accessor.rangesForIdentifierDirect(id);
      for (auto [firstElement, lastElement] : ranges) {
        for (; firstElement != lastElement; ++firstElement) {
          const xAOD::SpacePoint *sp = *firstElement;
          if (prd_to_track_map_cptr != nullptr and isUsed(sp, *prd_to_track_map_cptr)) continue;
          newSpacePoint(data, sp);
        }
      }
    }
 
    return StatusCode::SUCCESS;
  }  

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.

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

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.

  {
    if (ids.empty()) return StatusCode::SUCCESS;
    
    ATH_MSG_DEBUG("Retrieving pixel space point collection " << m_actsSpacepointsPixel.key());
    SG::ReadHandle< xAOD::SpacePointContainer > inputSpacePointContainer( m_actsSpacepointsPixel, ctx );
    if (not inputSpacePointContainer.isValid()){
      ATH_MSG_FATAL("xAOD::SpacePointContainer with key " << m_actsSpacepointsPixel.key() << " is not available...");
      return StatusCode::FAILURE;
    }
    const xAOD::SpacePointContainer *inputCollection = inputSpacePointContainer.cptr();
 
    ATH_MSG_DEBUG("Retrieving SiDetectorElementCollection with key `" << m_pixelDetEleCollKey.key() << "`");
    SG::ReadCondHandle< InDetDD::SiDetectorElementCollection > detEleHandle = SG::makeHandle( m_pixelDetEleCollKey, ctx );
    ATH_CHECK(detEleHandle.isValid());    
    const InDetDD::SiDetectorElementCollection* detElements = detEleHandle.cptr();
    
    ContainerAccessor< xAOD::SpacePoint, IdentifierHash, 1>
      accessor ( *inputCollection,
         [] (const xAOD::SpacePoint& coll) -> IdentifierHash 
         { return coll.elementIdList()[0]; },
         detElements->size());    
    
    for (const IdentifierHash id : ids) {
      if (not accessor.isIdentifierPresent(id)) {
    continue;
      }
 
      const auto& ranges = accessor.rangesForIdentifierDirect(id);
      for (auto [firstElement, lastElement] : ranges) {
    for (; firstElement != lastElement; ++firstElement) {
      const xAOD::SpacePoint *sp = *firstElement;
      if (prd_to_track_map_cptr != nullptr and isUsed(sp, *prd_to_track_map_cptr)) continue;
      newSpacePoint(data, sp);
    }
      }
    }
    
    return StatusCode::SUCCESS;
  }

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.

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

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.

  {
    if (ids.empty()) return StatusCode::SUCCESS;
    
    ATH_MSG_DEBUG("Retrieving strip space point collection " << m_actsSpacepointsStrip.key());
    SG::ReadHandle< xAOD::SpacePointContainer > inputSpacePointContainer( m_actsSpacepointsStrip, ctx );
    if (not inputSpacePointContainer.isValid()){
      ATH_MSG_FATAL("xAOD::SpacePointContainer with key " << m_actsSpacepointsStrip.key() << " is not available...");
      return StatusCode::FAILURE;
    }
    const xAOD::SpacePointContainer *inputCollection = inputSpacePointContainer.cptr();
    
    ATH_MSG_DEBUG("Retrieving SiDetectorElementCollection with key `" << m_stripDetEleCollKey.key() << "`");
    SG::ReadCondHandle< InDetDD::SiDetectorElementCollection > detEleHandle = SG::makeHandle( m_stripDetEleCollKey, ctx );
    ATH_CHECK(detEleHandle.isValid());
    const InDetDD::SiDetectorElementCollection* detElements = detEleHandle.cptr();
    
    ContainerAccessor< xAOD::SpacePoint, IdentifierHash, 1>
      accessor ( *inputCollection,
         [] (const xAOD::SpacePoint& coll) -> IdentifierHash
         { return coll.elementIdList()[0]; },
         detElements->size());
    
    for (const IdentifierHash id : ids) {
      if (not accessor.isIdentifierPresent(id)) {
    continue;
      }
      
      const auto& ranges = accessor.rangesForIdentifierDirect(id);
      for (auto [firstElement, lastElement] : ranges) {
        for (; firstElement != lastElement; ++firstElement) {
          const xAOD::SpacePoint *sp = *firstElement;
      if (prd_to_track_map_cptr != nullptr and isUsed(sp, *prd_to_track_map_cptr)) continue;
          newSpacePoint(data, sp);
        }
      }
    }
    
    return StatusCode::SUCCESS;
  }

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.

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

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.

  {
    const InDet::SiCluster *c0 = static_cast<const InDet::SiCluster *>(sp->clusterList().first);
    const InDet::SiCluster *c1 = static_cast<const InDet::SiCluster *>(sp->clusterList().second);
    const InDetDD::SiDetectorElement *d0 = c0->detectorElement();
    const InDetDD::SiDetectorElement *d1 = c1->detectorElement();
 
    Amg::Vector2D lc0 = c0->localPosition();
    Amg::Vector2D lc1 = c1->localPosition();
 
    std::pair<Amg::Vector3D, Amg::Vector3D> e0 =
        (d0->endsOfStrip(InDetDD::SiLocalPosition(lc0.y(), lc0.x(), 0.)));
    std::pair<Amg::Vector3D, Amg::Vector3D> e1 =
        (d1->endsOfStrip(InDetDD::SiLocalPosition(lc1.y(), lc1.x(), 0.)));
 
    Amg::Vector3D s0(.5 * (e0.first + e0.second));
    Amg::Vector3D s1(.5 * (e1.first + e1.second));
 
    Amg::Vector3D b0(.5 * (e0.second - e0.first));
    Amg::Vector3D b1(.5 * (e1.second - e1.first));
    Amg::Vector3D d02(s0 - s1);
 
    // b0
    r[3] = static_cast<float>(b0[0]);
    r[4] = static_cast<float>(b0[1]);
    r[5] = static_cast<float>(b0[2]);
 
    // b1
    r[6] = static_cast<float>(b1[0]);
    r[7] = static_cast<float>(b1[1]);
    r[8] = static_cast<float>(b1[2]);
 
    // r0-r2
    r[9] = static_cast<float>(d02[0]);
    r[10] = static_cast<float>(d02[1]);
    r[11] = static_cast<float>(d02[2]);
 
    // r0
    r[12] = static_cast<float>(s0[0]) - data.xbeam[0];
    r[13] = static_cast<float>(s0[1]) - data.ybeam[0];
    r[14] = static_cast<float>(s0[2]) - data.zbeam[0];
  }

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.

  {
    if (not m_writeNtuple) return;
 
    std::lock_guard<std::mutex> lock(m_mutex);
 
    if(track != nullptr) {
      m_trackPt = (track->trackParameters()->front()->pT())/1000.f;
      m_trackEta = std::abs(track->trackParameters()->front()->eta());
    }
    else {
      m_trackPt = -1.;
      m_trackEta = -1.; 
    }
    m_d0           =   seed->d0();
    m_z0           =   seed->zVertex();
    m_eta          =   seed->eta();
    m_x1           =   seed->x1();
    m_x2           =   seed->x2();
    m_x3           =   seed->x3();
    m_y1           =   seed->y1();
    m_y2           =   seed->y2();
    m_y3           =   seed->y3();      
    m_z1           =   seed->z1();
    m_z2           =   seed->z2();
    m_z3           =   seed->z3();
    m_r1           =   seed->r1();
    m_r2           =   seed->r2();
    m_r3           =   seed->r3();
    m_type         =   seedType;
    m_dzdr_b       =   seed->dzdr_b();
    m_dzdr_t       =   seed->dzdr_t();
    m_pt           =   seed->pt();
    m_givesTrack   =   !(track == nullptr);
    m_eventNumber  =   eventNumber;
 
    // Ok: protected by mutex.
    TTree* outputTree ATLAS_THREAD_SAFE = m_outputTree;
    outputTree->Fill();
  }

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.

{this, "ActsSpacePointsOverlapName", "", "Strip overlap space points container"};

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.

{this, "ActsSpacePointsPixelName", "", "Pixel space points container"};

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.

{this, "ActsSpacePointsStripName", "", "Strip space points container"};

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.

{this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"};

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.

{this, "doSeedConversion", true, "Convert ActsTrk::Seed into ITk::SiSpacePointsProSeed"};

m_fastTracking

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

private

Definition at line 220 of file SiSpacePointsSeedMaker.h.

{this, "useFastTracking", false};

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.

                                                                         {this, "AtlasFieldCacheCondObj", "fieldCondObj",
        "Name of the Magnetic Field conditions object key"};

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.

{this, "usePixel", true};

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.

                                                                                   {this, "PixelDetectorElements", "ITkPixelDetectorElementCollection",
      "Key of input SiDetectorElementCollection"};

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.

{this, "PRDtoTrackMap", "", "option PRD-to-track association"};

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.

{this, "SeedToolPixel", "","Seed Tool for Pixel detector"};

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.

{this, "SeedToolStrip", "","Seed Tool for Strip detector"};

m_strip

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

private

Definition at line 218 of file SiSpacePointsSeedMaker.h.

{this, "useStrip", true };

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.

                                                                                   {this, "StripDetectorElements", "ITkStripDetectorElementCollection",
      "Key of input SiDetectorElementCollection"};

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.

{this, "useClustersForSeedConversion", false};

m_useOverlap

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

private

Definition at line 219 of file SiSpacePointsSeedMaker.h.

{this, "useOverlapSpCollection", true};

m_writeNtuple

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

private

Definition at line 226 of file SiSpacePointsSeedMaker.h.

{this, "WriteNtuple", false};

---

The documentation for this class was generated from the following files:

• SiSpacePointsSeedMaker.h
• SiSpacePointsSeedMaker.cxx