InDet::SeedToTrackConversionTool Class Reference

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

#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
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.
std::atomic_int	m_totseed {0}
	number of total seeds in the pass
std::atomic_int	m_survived {0}
	number of survived seeds

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.

{this, "Extrapolator","Trk::Extrapolator", "extrapolator"};

m_nprint

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

mutableprivate

Kind output information.

Definition at line 98 of file SeedToTrackConversionTool.h.

{0}; 

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.

{this, "RIO_OnTrackCreator", "Trk::RIO_OnTrackCreator/InDetRotCreator", "Creator ROT"};

m_seedsegmentsOutput

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

private

Definition at line 93 of file SeedToTrackConversionTool.h.

{this, "OutputName", "SiSPSeedSegments", "SiSpSeedSegments Output Collection"};

m_survived

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

mutableprivate

number of survived seeds

Definition at line 100 of file SeedToTrackConversionTool.h.

{0}; 

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.

{0}; 

---

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

• SeedToTrackConversionTool.h
• SeedToTrackConversionTool.cxx