#include <SeedToTrackConversionTool.h>

Inheritance diagram for InDet::SeedToTrackConversionTool:

Collaboration diagram for InDet::SeedToTrackConversionTool:

Public Member Functions
Constructor
	SeedToTrackConversionTool (const std::string &, const std::string &, const IInterface *)

Default destructor
virtual	~SeedToTrackConversionTool ()=default

Standard Athena-Algorithm initialize method
virtual StatusCode	initialize () override

virtual StatusCode	finalize () override

Main methods for seeds conversion
virtual void	executeSiSPSeedSegments (SeedToTrackConversionData &data, const Trk::TrackParameters , const int &, const std::vector< const Trk::SpacePoint > &) const override
	seed trackparameters, number of tracks found:m_track.size(), list of spacepoints More...

virtual void	newEvent (SeedToTrackConversionData &data, const Trk::TrackInfo &, const std::string &) const override

virtual void	endEvent (SeedToTrackConversionData &data) const override

Print internal tool parameters and status
virtual MsgStream &	dump (SeedToTrackConversionData &data, MsgStream &out) const override

Private Member Functions
Messaging methods
MsgStream &	dumpconditions (SeedToTrackConversionData &data, MsgStream &out) const

MsgStream &	dumpevent (SeedToTrackConversionData &data, MsgStream &out) const

Private Attributes
Tool handles
PublicToolHandle< Trk::IExtrapolator >	m_extrapolator {this, "Extrapolator","Trk::Extrapolator", "extrapolator"}

ToolHandle< Trk::IRIO_OnTrackCreator >	m_rotcreator {this, "RIO_OnTrackCreator", "Trk::RIO_OnTrackCreator/InDetRotCreator", "Creator ROT"}

Data handles
SG::WriteHandleKey< TrackCollection >	m_seedsegmentsOutput {this, "OutputName", "SiSPSeedSegments", "SiSpSeedSegments Output Collection"}

Counters
std::atomic_int	m_nprint {0}
	Kind output information. More...

std::atomic_int	m_totseed {0}
	number of total seeds in the pass More...

std::atomic_int	m_survived {0}
	number of survived seeds More...

Detailed Description

InDet::SeedToTrackConversionTool is tool that converts the seeds into track collection.

In AthenaMT, event dependent cache inside SeedToTrackConversionTool is not preferred. SeedToTrackConversionData class holds event dependent data for SeedToTrackConversionTool. Its object is instantiated in SiSPSeededTrackFinder::execute through SiTrackMakerEventData_xk.

Author: Weiming Yao <Weiming.Yao>

Definition at line 46 of file SeedToTrackConversionTool.h.

Constructor & Destructor Documentation

◆ SeedToTrackConversionTool()

InDet::SeedToTrackConversionTool::SeedToTrackConversionTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 23 of file SeedToTrackConversionTool.cxx.

   : base_class(t, n, p)
 {
 }

◆ ~SeedToTrackConversionTool()

virtual InDet::SeedToTrackConversionTool::~SeedToTrackConversionTool ( )

virtualdefault

Member Function Documentation

◆ dump()

MsgStream & InDet::SeedToTrackConversionTool::dump	(	SeedToTrackConversionData &	data,
		MsgStream &	out
	)		const

overridevirtual

Definition at line 147 of file SeedToTrackConversionTool.cxx.

 {
   out << std::endl;
   if (m_nprint) dumpevent(data, out);
   return dumpconditions(data, out);
 }

◆ dumpconditions()

MsgStream & InDet::SeedToTrackConversionTool::dumpconditions	(	SeedToTrackConversionData &	data,
		MsgStream &	out
	)		const

private

Definition at line 157 of file SeedToTrackConversionTool.cxx.

 {
   out << "|----------------------------------------------------------------------"
       << "-------------------|"
       << std::endl;
   out << "| Output Collection Name   | " << m_seedsegmentsOutput << std::endl;
   out << "} Name of pattern recognition | " << data.patternName() << std::endl;
   out << "|----------------------------------------------------------------------"
       << "-------------------|"
       << std::endl;
   return out;
 }

◆ dumpevent()

MsgStream & InDet::SeedToTrackConversionTool::dumpevent	(	SeedToTrackConversionData &	data,
		MsgStream &	out
	)		const

private

Definition at line 173 of file SeedToTrackConversionTool.cxx.

 {
   out << "|---------------------------------------------------------------------|"
       << std::endl;
   out << "| Name of SeedFinder          | " << data.patternName()
       << "                              | " << std::endl;
   out << "| Number of All seeds         | " << std::setw(12) << m_totseed 
       << "                              | " << std::endl;
   out << "| Number of survived seeds    | " << std::setw(12) << m_survived  
       << "                              | " << std::endl;
   out << "|---------------------------------------------------------------------|"
       << std::endl;
   return out;
 }

◆ endEvent()

void InDet::SeedToTrackConversionTool::endEvent ( SeedToTrackConversionData & data ) const

overridevirtual

Definition at line 78 of file SeedToTrackConversionTool.cxx.

 {
   // Print event information
   //
   if (msgLevel()<=0) {
     m_nprint=1;
     dump(data, msg(MSG::DEBUG));
   }
  
   ATH_MSG_DEBUG(" Check SiSPSeedSegments Collection (" << m_seedsegmentsOutput << ") " << data.seedSegmentsCollection()->size() << " trackinfo: "
                << data.trackInfo());
   SG::WriteHandle<TrackCollection> seedsegmentsOutput{m_seedsegmentsOutput};
   if (seedsegmentsOutput.record(std::move(data.seedSegmentsCollection())).isFailure()) {
     ATH_MSG_ERROR("Could not save converted SiSPSeedSegments tracks");
   }
 }

◆ executeSiSPSeedSegments()

void InDet::SeedToTrackConversionTool::executeSiSPSeedSegments	(	SeedToTrackConversionData &	data,
		const Trk::TrackParameters *	Tp,
		const int &	mtrk,
		const std::vector< const Trk::SpacePoint * > &	Sp
	)		const

overridevirtual

seed trackparameters, number of tracks found:m_track.size(), list of spacepoints

Definition at line 95 of file SeedToTrackConversionTool.cxx.

 {
   const EventContext& ctx = Gaudi::Hive::currentContext();
   ++m_totseed; // accumulate all seeds
   if (mtrk>0) ++m_survived; // survided seeds 
   std::vector<const Trk::PrepRawData*> prdsInSp;
   for (const Trk::SpacePoint* s: Sp) {
     const std::pair<const Trk::PrepRawData*, const Trk::PrepRawData*>& prds = s->clusterList();
     if (prds.first) prdsInSp.push_back(prds.first);
     if (prds.second && prds.first != prds.second) prdsInSp.push_back(prds.second);
   }
   Trk::PerigeeSurface persurf;
   std::unique_ptr<Trk::TrackParameters> per(m_extrapolator->extrapolate(ctx,*Tp, persurf, Trk::anyDirection, false, Trk::nonInteracting));
   std::unique_ptr<Trk::TrackParameters> prevpar(Tp->uniqueClone());
   if (per) {
     std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern;
     typePattern.set(Trk::TrackStateOnSurface::Perigee);
     const Trk::TrackStateOnSurface* pertsos = new Trk::TrackStateOnSurface(nullptr, std::move(per), nullptr, typePattern);
     auto traj = std::make_unique<Trk::TrackStates>();
     traj->push_back(pertsos);
     for (const Trk::PrepRawData* prd: prdsInSp) {
       const Trk::Surface& surf = prd->detectorElement()->surface(prd->identify());
       std::unique_ptr<Trk::TrackParameters> thispar(m_extrapolator->extrapolate(ctx,*prevpar, surf, Trk::alongMomentum, false, Trk::nonInteracting));
       if (thispar) {
         std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern;
         typePattern.set(Trk::TrackStateOnSurface::Measurement);
         std::unique_ptr<Trk::RIO_OnTrack> rot(m_rotcreator->correct(*prd, *thispar, ctx));
         if (rot) {
           const Trk::TrackStateOnSurface* tsos = new Trk::TrackStateOnSurface(std::move(rot), thispar->uniqueClone(), nullptr, typePattern);
           traj->push_back(tsos);
           prevpar = std::move(thispar);
         }
       }
     }
     
     if (mtrk>0) { // survived seeds set as  
       data.trackInfo().setTrackFitter(Trk::TrackInfo::xKalman); // xkalman
     } else {
       data.trackInfo().setTrackFitter(Trk::TrackInfo::Unknown);
     }
     Trk::Track* t = new Trk::Track(data.trackInfo(), std::move(traj), nullptr);
     if (t) data.seedSegmentsCollection()->push_back(t);
   }
 }

◆ finalize()

StatusCode InDet::SeedToTrackConversionTool::finalize ( )

overridevirtual

Definition at line 60 of file SeedToTrackConversionTool.cxx.

 {
   return AlgTool::finalize();
 }

◆ initialize()

StatusCode InDet::SeedToTrackConversionTool::initialize ( )

overridevirtual

Definition at line 32 of file SeedToTrackConversionTool.cxx.

 {
  
   StatusCode sc = AlgTool::initialize();
   if (sc.isFailure()) return sc;
  
   if (m_extrapolator.retrieve().isFailure()) {
     ATH_MSG_FATAL ("Could not retrieve "<< m_extrapolator);
     return StatusCode::FAILURE;
   } else {
     ATH_MSG_VERBOSE( "initialize() Retrieved service " << m_extrapolator);
   }
  
   // Retrieve the Track RotCreator tool
   if (m_rotcreator.retrieve().isFailure()) {
     ATH_MSG_FATAL ("Could not retrieve "<< m_rotcreator);
     return StatusCode::FAILURE;
   } else {
     ATH_MSG_VERBOSE( "initialize() Retrieved service " << m_rotcreator);
   }  
  
   ATH_CHECK(m_seedsegmentsOutput.initialize());
  
   return StatusCode::SUCCESS;
 }

◆ newEvent()

void InDet::SeedToTrackConversionTool::newEvent	(	SeedToTrackConversionData &	data,
		const Trk::TrackInfo &	info,
		const std::string &	patternName
	)		const

overridevirtual

Definition at line 65 of file SeedToTrackConversionTool.cxx.

 {
   data.seedSegmentsCollection() = std::make_unique<TrackCollection>();
   m_totseed = 0;
   m_survived = 0;
  
   data.trackInfo() = info;
   data.patternName() = patternName;
   if (static_cast<int>(data.patternName().find("Forward"))>-1) {
     data.trackInfo().setPatternRecognitionInfo(Trk::TrackInfo::SiSpacePointsSeedMaker_ForwardTracks);
   }
 }

Member Data Documentation

◆ m_extrapolator

PublicToolHandle<Trk::IExtrapolator> InDet::SeedToTrackConversionTool::m_extrapolator {this, "Extrapolator","Trk::Extrapolator", "extrapolator"}

private

Definition at line 85 of file SeedToTrackConversionTool.h.

◆ m_nprint

std::atomic_int InDet::SeedToTrackConversionTool::m_nprint {0}

mutableprivate

Kind output information.

Definition at line 98 of file SeedToTrackConversionTool.h.

◆ m_rotcreator

ToolHandle<Trk::IRIO_OnTrackCreator > InDet::SeedToTrackConversionTool::m_rotcreator {this, "RIO_OnTrackCreator", "Trk::RIO_OnTrackCreator/InDetRotCreator", "Creator ROT"}

private

Definition at line 87 of file SeedToTrackConversionTool.h.

◆ m_seedsegmentsOutput

SG::WriteHandleKey<TrackCollection> InDet::SeedToTrackConversionTool::m_seedsegmentsOutput {this, "OutputName", "SiSPSeedSegments", "SiSpSeedSegments Output Collection"}

private

Definition at line 93 of file SeedToTrackConversionTool.h.

◆ m_survived

std::atomic_int InDet::SeedToTrackConversionTool::m_survived {0}

mutableprivate

number of survived seeds

Definition at line 100 of file SeedToTrackConversionTool.h.

◆ m_totseed

std::atomic_int InDet::SeedToTrackConversionTool::m_totseed {0}

mutableprivate

number of total seeds in the pass

Definition at line 99 of file SeedToTrackConversionTool.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SeedToTrackConversionTool()

◆ ~SeedToTrackConversionTool()

Member Function Documentation

◆ dump()

◆ dumpconditions()

◆ dumpevent()

◆ endEvent()

◆ executeSiSPSeedSegments()

◆ finalize()

◆ initialize()

◆ newEvent()

Member Data Documentation

◆ m_extrapolator

◆ m_nprint

◆ m_rotcreator

◆ m_seedsegmentsOutput

◆ m_survived

◆ m_totseed