InDet::TRT_SeededTrackFinder Class Reference

InDet::TRT_SeededTrackFinde is an algorithm which produces tracks moving outside-in in the Inner Detector. More...

#include <TRT_SeededTrackFinder.h>

Inheritance diagram for InDet::TRT_SeededTrackFinder:

Collaboration diagram for InDet::TRT_SeededTrackFinder:

Classes
struct	Stat_t
	Global Counters for final algorithm statistics. More...

Public Member Functions
	TRT_SeededTrackFinder (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Algorithm methods.
virtual	~TRT_SeededTrackFinder ()
StatusCode	initialize () override
StatusCode	execute (const EventContext &ctx) const override
StatusCode	finalize () override
MsgStream &	dump (MsgStream &out) const
	Print internal tool parameters and status.
std::ostream &	dump (std::ostream &out) const
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
Trk::Track *	mergeSegments (const Trk::Track &, const Trk::TrackSegment &) const
	Protected methods.
Trk::Track *	mergeExtension (const Trk::Track &, std::vector< const Trk::MeasurementBase * > &) const
	Merge a TRT track extension and a Si track component into one global ID track.
Trk::Track *	segToTrack (const EventContext &, const Trk::TrackSegment &) const
	Transform a TRT track segment into a track.
void	Analyze (TrackCollection *) const
	Do some statistics analysis at the end of each event.
MsgStream &	dumptools (MsgStream &out) const
MsgStream &	dumpevent (MsgStream &out, const InDet::TRT_SeededTrackFinder::Stat_t &stat) const
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
BooleanProperty	m_doRefit {this, "FinalRefit", false, "Do a final careful refit of tracks"}
BooleanProperty	m_doExtension {this, "TrtExtension", false, "Find the TRT extension of the track"}
BooleanProperty	m_rejectShortExten {this, "RejectShortExtension", false, "Reject short extensions"}
BooleanProperty	m_doStat {this, "FinalStatistics", false, "Statistics of final tracks"}
BooleanProperty	m_saveTRT {this, "OutputSegments", true, "Save stand-alone TRT segments"}
IntegerProperty	m_MaxSegNum
UnsignedIntegerProperty	m_minTRTonSegment {this, "MinTRTonSegment", 10, "Minimum Number of TRT Hits on segment"}
UnsignedIntegerProperty	m_minTRTonly {this, "MinTRTonly", 15, "Minimum number of TRT hits on TRT only"}
ToolHandle< ITRT_SeededTrackFinder >	m_trackmaker
ToolHandle< Trk::ITrackFitter >	m_fitterTool
ToolHandle< ITRT_TrackExtensionTool >	m_trtExtension
SG::ReadHandleKey< Trk::SegmentCollection >	m_SegmentsKey {this, "InputSegmentsLocation", "TRTSegments", "TRT segments to use"}
SG::WriteHandleKey< TrackCollection >	m_outTracksKey
SG::ReadHandleKey< Trk::PRDtoTrackMap >	m_prdToTrackMap {this, "PRDtoTrackMap", "" }
ToolHandle< Trk::IExtendedTrackSummaryTool >	m_trackSummaryTool {this, "TrackSummaryTool", "InDetTrackSummaryToolNoHoleSearch"}
ToolHandle< Trk::IExtrapolator >	m_extrapolator {this, "Extrapolator", ""}
SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"}
BooleanProperty	m_SiExtensionCuts {this, "SiExtensionCuts", false, "enable cuts after Si segment finding"}
DoubleProperty	m_minPt {this, "minPt", 500., "minimal Pt cut"}
DoubleProperty	m_maxEta {this, "maxEta", 2.7, "maximal Eta cut"}
DoubleProperty	m_maxRPhiImp {this, "maxRPhiImp", 10., "maximal RPhi impact parameter cut"}
DoubleProperty	m_maxZImp {this, "maxZImp", 250., "maximal z impact parameter cut"}
BooleanProperty	m_caloSeededRoI {this, "CaloSeededRoI", false}
SG::ReadHandleKey< ROIPhiRZContainer >	m_caloClusterROIKey
ToolHandle< IRegSelTool >	m_regionSelector
FloatProperty	m_deltaEta {this, "dEtaCaloRoI", 0.1, "delta Eta used for RoI creation"}
FloatProperty	m_deltaPhi {this, "dPhiCaloRoI", 0.25, "delta Phi used for RoI creation"}
FloatProperty	m_deltaZ {this, "dZCaloRoI", 300., "delta Z used for RoI creation"}
std::mutex m_statMutex	ATLAS_THREAD_SAFE
Stat_t m_totalStat	ATLAS_THREAD_SAFE

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

InDet::TRT_SeededTrackFinde is an algorithm which produces tracks moving outside-in in the Inner Detector.

Definition at line 54 of file TRT_SeededTrackFinder.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

TRT_SeededTrackFinder()

InDet::TRT_SeededTrackFinder::TRT_SeededTrackFinder	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Standard Algorithm methods.

Definition at line 38 of file TRT_SeededTrackFinder.cxx.

  : AthReentrantAlgorithm(name, pSvcLocator)
{ }

~TRT_SeededTrackFinder()

virtual InDet::TRT_SeededTrackFinder::~TRT_SeededTrackFinder ( )

inlinevirtual

Definition at line 67 of file TRT_SeededTrackFinder.h.

{}

Member Function Documentation

Analyze()

void InDet::TRT_SeededTrackFinder::Analyze ( TrackCollection * tC ) const

protected

Do some statistics analysis at the end of each event.

Loop over tracks in track collection

Concentrate on the Si component of the track

Definition at line 673 of file TRT_SeededTrackFinder.cxx.

                                                            {
  if(msgLvl(MSG::DEBUG)) {
    ATH_MSG_DEBUG( "Analyzing tracks..." );
    ATH_MSG_DEBUG( "Number of back tracks " << (tC->size()) );
    int nsct1{}, nsct2{}, nsct3{}, nsct4{}; //SCT layer counters
    int nsctTot1{}, nsctTot2{}, nsctTot3{}, nsctTot4{}; //SCT layer counters
    int npix1{}, npix2{}, npix3{}; //Pixel layer counters
    int npixTot1{}, npixTot2{}, npixTot3{}; //Pixel layer counters
    TrackCollection::const_iterator r    = tC->begin();
    TrackCollection::const_iterator re = tC->end();
    for (; r != re ; ++r){
      nsct1=nsct2=nsct3=nsct4=0; npix1=npix2=npix3=0; 
      const Trk::TrackStates* newtsos = (*r)->trackStateOnSurfaces();
      if(!newtsos) continue;
      Trk::TrackStates::const_iterator itp, itpe=newtsos->end();
      for(itp=newtsos->begin(); itp!=itpe; ++itp){
        const InDet::SiClusterOnTrack* clus = dynamic_cast<const InDet::SiClusterOnTrack*>((*itp)->measurementOnTrack());
        if(clus && ((*itp)->type(Trk::TrackStateOnSurface::Measurement))){  //Count the number of hits used in the track
          double rc = clus->globalPosition().perp();
          if((40.<=rc)&&(rc<80.)){npix1++;}    //1st pixel layer
          if((80.<=rc)&&(rc<100.)){npix2++;}   //2nd pixel layer
          if((100.<=rc)&&(rc<150.)){npix3++;}  //3rd pixel layer
          if((280.<=rc)&&(rc<340.)){nsct1++;}  //1st SCT layer
          if((340.<=rc)&&(rc<390.)){nsct2++;}  //2nd SCT layer
          if((390.<=rc)&&(rc<460.)){nsct3++;}  //3rd SCT layer
          if((460.<=rc)&&(rc<550.)){nsct4++;}  //4th SCT layer
        }
      }
      nsctTot1+=nsct1; nsctTot2+=nsct2; nsctTot3+=nsct3; nsctTot4+=nsct4;
      npixTot1+=npix1; npixTot2+=npix2; npixTot3+=npix3;
    }
    ATH_MSG_DEBUG("Total hits on 1st SCT: "<<nsctTot1<<" 2nd SCT: "<<nsctTot2<<" 3rd SCT: "<<nsctTot3<<" 4th SCT: "<<nsctTot4);
    ATH_MSG_DEBUG("Total hits on 1st Pixel: "<<npixTot1<<" 2nd Pixel: "<<npixTot2<<" 3rd Pixel: "<<npixTot3);
  }
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

dump() [1/2]

MsgStream & InDet::TRT_SeededTrackFinder::dump

(

MsgStream &

out

)

const

Print internal tool parameters and status.

dump() [2/2]

std::ostream & InDet::TRT_SeededTrackFinder::dump

(

std::ostream &

out

)

const

dumpevent()

MsgStream & InDet::TRT_SeededTrackFinder::dumpevent ( MsgStream & out, const InDet::TRT_SeededTrackFinder::Stat_t & stat ) const

protected

Definition at line 463 of file TRT_SeededTrackFinder.cxx.

{
  out<<"|-------------------------------------------------------------------"<<std::endl;
  out<<"|  Investigated :"<<std::endl
     <<"| "<<std::setw(7)<<stat.m_counter[Stat_t::kNTrtSeg]       <<" TRT Segments on input"<<std::endl
     <<"| "<<std::setw(7)<<stat.m_counter[Stat_t::kNTrtFailSel]   <<" TRT Segments fail selection on input"<<std::endl
     <<"| "<<std::setw(7)<<stat.m_counter[Stat_t::Stat_t::kNTrtSegGood]   <<" TRT Segments after selection"<<std::endl;
  if (stat.m_counter[Stat_t::kNTrtLimit]>0) {
    out<<"|-------------------------------------------------------------------"<<std::endl;
    out<<"| "<<std::setw(7)<<stat.m_counter[Stat_t::kNTrtLimit]   <<" TRT segments lost because of processing limit"<<std::endl;
  }
  out<<"|-------------------------------------------------------------------"<<std::endl;
  out<<"| "<<std::setw(7)<<stat.m_counter[Stat_t::kNTrtNoSiExt]   <<" TRT segments without Si extension"<<std::endl;
  if (m_SiExtensionCuts) {
    out<<"| "<<std::setw(7)<<stat.m_counter[Stat_t::kNExtCut]     <<" number of Si extension failing cuts"<<std::endl;
  }
  if (stat.m_counter[Stat_t::Stat_t::kNBckTrkTrt]>0) {
    out<<"| "<<std::setw(7)<<stat.m_counter[Stat_t::Stat_t::kNBckTrkTrt]  <<" number ot TRT only tracks created"<<std::endl;
  }
  if (m_doExtension) {
    out<<"|-------------------------------------------------------------------"<<std::endl;
    out<<"| "<<std::setw(7)<<stat.m_counter[Stat_t::Stat_t::kNTrtExtCalls]<<" number of times TRT extension is called"<<std::endl
       <<"| "<<std::setw(7)<<stat.m_counter[Stat_t::kNTrtExt]     <<" number of good TRT extension"<<std::endl;
    if (m_rejectShortExten) {
      out<<"| "<<std::setw(7)<<stat.m_counter[Stat_t::Stat_t::kNTrtExtBad]<<" number of bad TRT extension"<<std::endl;
    }
    out<<"| "<<std::setw(7)<<stat.m_counter[Stat_t::Stat_t::kNTrtExtFail]<<" number of failed TRT extension and fallback"<<std::endl;
  }
  out<<"|-------------------------------------------------------------------"<<std::endl;
  out<<"| "<<std::setw(7)<<stat.m_counter[Stat_t::Stat_t::kNBckTrkSi]    <<" TRT+Si tracks created of output"<<std::endl;
  if (stat.m_counter[Stat_t::kNBckTrkSi] != stat.m_counter[Stat_t::kNBckTrk]) {
    out<<"| "<<std::setw(7)<<stat.m_counter[Stat_t::kNBckTrk]    <<" total number of tracks on output"<<std::endl;
  }
  out<<"|-------------------------------------------------------------------";
  return out;
}

dumptools()

MsgStream & InDet::TRT_SeededTrackFinder::dumptools ( MsgStream & out ) const

protected

Definition at line 432 of file TRT_SeededTrackFinder.cxx.

{
  int n = 65-m_trackmaker.type().size();
  std::string s1; for(int i=0; i<n; ++i) s1.append(" "); s1.append("|");
  n     = 65-m_fitterTool.type().size();
  std::string s2; for(int i=0; i<n; ++i) s2.append(" "); s2.append("|");
  n     = 65-m_trtExtension.type().size();
  std::string s3; for(int i=0; i<n; ++i) s3.append(" "); s3.append("|");
  n     = 65-m_SegmentsKey.key().size();
  std::string s4; for(int i=0; i<n; ++i) s4.append(" "); s4.append("|");
  n     = 65-m_outTracksKey.key().size();
  std::string s5; for(int i=0; i<n; ++i) s5.append(" "); s5.append("|");
 
  out<<"|----------------------------------------------------------------------"
     <<"-------------------|"
       <<std::endl;
  out<<"| Tool for TRT seeded track finding | "<<m_trackmaker.type()    <<s1<<std::endl;
  out<<"| Tool for final track refitting    | "<<m_fitterTool.type()    <<s2<<std::endl;
  out<<"| Tool for TRT trac extension       | "<<m_trtExtension.type()  <<s3<<std::endl;
  out<<"| Location of input tracks          | "<<m_SegmentsKey.key()      <<s4<<std::endl;
  out<<"| Location of output tracks         | "<<m_outTracksKey.key()     <<s5<<std::endl;
  out<<"|----------------------------------------------------------------------"
     <<"-------------------|"
      <<std::endl;
  return out;
}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode InDet::TRT_SeededTrackFinder::execute ( const EventContext & ctx ) const

override

Transform the original TRT segment into a track

Definition at line 118 of file TRT_SeededTrackFinder.cxx.

                                                                {
  //Counters. See the include file for definitions
  Stat_t ev_stat;
  // counter
  int nTrtSegCur = 0;
  SG::ReadHandle<Trk::SegmentCollection>  segments(m_SegmentsKey,ctx);
  if(!segments.isValid()){
    ATH_MSG_FATAL ("No segment with name " << segments.name() << " found in StoreGate!");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_DEBUG ("Found segments collection " << segments.name() << " in StoreGate!");
  }
  // number of segments + statistics
  ev_stat.m_counter[Stat_t::kNTrtSeg] = int(segments->size());
  ATH_MSG_DEBUG ("TRT track container size " << ev_stat.m_counter[Stat_t::kNTrtSeg]);
  if(ev_stat.m_counter[Stat_t::kNTrtSeg]>m_MaxSegNum) {
    ATH_MSG_DEBUG ("TRT track container size huge; will process event partially if number of max segments reached !!!");
  }
  // Event dependent data of SiCombinatorialTrackFinder_xk
  //Total stack use for this function is 828640 bytes.
  //coverity[STACK_USE]
  InDet::ExtendedSiCombinatorialTrackFinderData_xk combinatorialData(m_prdToTrackMap);
  std::unique_ptr<InDet::ITRT_SeededTrackFinder::IEventData> event_data_p;
  if(m_caloSeededRoI ) {
    SG::ReadHandle<ROIPhiRZContainer> calo_rois(m_caloClusterROIKey, ctx);
    std::unique_ptr<RoiDescriptor> roiComp = std::make_unique<RoiDescriptor>(true);
    if (calo_rois.isValid()) {
      RoiDescriptor * roi =nullptr;
      SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx };
      double beamZ = beamSpotHandle->beamVtx().position().z();
      roiComp->clear();
      roiComp->setComposite();
      for (const ROIPhiRZ &the_roi : *calo_rois) {
          double eta = the_roi.eta();
          double phi = the_roi.phi();
          double roiPhiMin = phi -m_deltaPhi;
          double roiPhiMax = phi +m_deltaPhi;
          double roiEtaMin = eta -m_deltaEta;
          double roiEtaMax = eta +m_deltaEta;
          double roiZMin = beamZ -m_deltaZ;
          double roiZMax = beamZ +m_deltaZ;
          roi = new RoiDescriptor( eta, roiEtaMin, roiEtaMax,phi, roiPhiMin ,roiPhiMax, beamZ, roiZMin,roiZMax);
          roiComp->push_back(roi);
      }
 
    }
    std::vector<IdentifierHash> listOfSCTIds;
    std::vector<IdentifierHash> listOfPixIds;
    
    m_regionSelector->lookup(ctx)->HashIDList( *roiComp, listOfSCTIds );
 
    event_data_p = m_trackmaker->newRegion(ctx, combinatorialData, listOfPixIds, listOfSCTIds);
  } else {
    event_data_p = m_trackmaker->newEvent(ctx, combinatorialData);
  }
 
  std::unique_ptr<InDet::ITRT_TrackExtensionTool::IEventData> ext_event_data_p( m_trtExtension->newEvent(ctx) );
  std::unique_ptr<TrackCollection> outTracks = std::make_unique<TrackCollection>();
  std::vector<Trk::Track*> tempTracks;                           //Temporary track collection
  tempTracks.reserve(128);
  // loop over event
  ATH_MSG_DEBUG ("Begin looping over all TRT segments in the event");
  Trk::SegmentCollection::const_iterator iseg    = segments->begin();
  Trk::SegmentCollection::const_iterator isegEnd = segments->end();
  InDet::TRT_DetElementLink_xk::TRT_DetElemUsedMap map;
  for(; iseg != isegEnd; ++ iseg) {
    // Get the track segment
    const Trk::TrackSegment *trackTRT = dynamic_cast<const Trk::TrackSegment*>(*iseg);
    if(!trackTRT){
      ATH_MSG_ERROR ("No pointer to segment !");
      continue;
    } else {
      // the segment finder is applying a TRT(eta) cut and a pt preselection, so we don't do that here
      //Ask for at least 10 TRT hits in order to process
      if(trackTRT->numberOfMeasurementBases() < m_minTRTonSegment) {
        ATH_MSG_DEBUG ("TRT segment fails nTRT hit cut, reject.");
        // statistics
        ev_stat.m_counter[Stat_t::kNTrtFailSel]++;
      } else {
        // do we continue to process ?
        nTrtSegCur++;
        if(nTrtSegCur>=m_MaxSegNum) {
          ATH_MSG_DEBUG ("====> Reached maximal number of segments in event, stop !!!");
          // statistics
          ev_stat.m_counter[Stat_t::kNTrtLimit]++;
          break;
        }
        // Get the number of the TRT track segment ROTs
        ATH_MSG_DEBUG ("=> New segment to process, number Of TRT ROTs : " << (trackTRT->numberOfMeasurementBases()));
        // statistics
        ev_stat.m_counter[Stat_t::Stat_t::kNTrtSegGood]++;
        // ok, call track maker and get list of possible track candidates
        std::list<Trk::Track*> trackSi = m_trackmaker->getTrack(ctx, *event_data_p, *trackTRT); //Get the possible Si extensions
        if (trackSi.empty()) {
          ATH_MSG_DEBUG ("No Si track candidates associated to the TRT track ");
          // statistics
          ev_stat.m_counter[Stat_t::kNTrtNoSiExt]++;
          // obsolete backup of TRT only
          if(m_saveTRT && trackTRT->numberOfMeasurementBases() > m_minTRTonly){
            Trk::Track* trtSeg = nullptr;trtSeg = segToTrack(ctx, *trackTRT);
            if(!trtSeg) {
              ATH_MSG_DEBUG ("Failed to make a track out of the TRT segment!");
              continue;
            }
            // statistics
            ev_stat.m_counter[Stat_t::kNBckTrk]++; ev_stat.m_counter[Stat_t::Stat_t::kNBckTrkTrt]++;
            // add track to output list
            outTracks->push_back(trtSeg);
          }
          continue;
        } else {
          // Found useful extensions
          ATH_MSG_DEBUG ("Found " << (trackSi.size()) << " Si tracks associated to the TRT track ");
          // Merge the resolved Si extensions with the original TRT track segment
          std::list<Trk::Track*>::const_iterator itt    = trackSi.begin();
          std::list<Trk::Track*>::const_iterator ittEnd = trackSi.end();
          for (; itt != ittEnd ; ++itt){
            tempTracks.push_back(*itt);
            // get list of TSOS
            const Trk::TrackStates* temptsos = (*itt)->trackStateOnSurfaces();
            if (!temptsos) {
              ATH_MSG_DEBUG ("Silicon extension empty ???");
              continue;
            }
            // Add the track to the list of tracks in the event
            ATH_MSG_DEBUG ("Silicon extension found has length of : " << temptsos->size());
            // do we do a preselection ?
            if (m_SiExtensionCuts) {
              // get parameters without errors
              auto input = (*itt)->trackParameters()->front()->uniqueClone();
              // cuts on parameters
              if (std::abs(input->pT()) < m_minPt) {
                ATH_MSG_DEBUG ("Track pt < "<<m_minPt<<", reject it");
                // statistics
                ev_stat.m_counter[Stat_t::kNExtCut]++;
                continue;
              }
              if (std::abs(input->eta()) > m_maxEta) {
                ATH_MSG_DEBUG ("Track eta > "<<m_maxEta<<", reject it");
                // statistics
                ev_stat.m_counter[Stat_t::kNExtCut]++;
                continue;
              }
              // --- beam spot position
              Amg::Vector3D beamSpotPosition(0,0,0);
              if (m_SiExtensionCuts){
                       SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx };
                       beamSpotPosition = beamSpotHandle->beamVtx().position();
              }
              // --- create surface
              Trk::PerigeeSurface perigeeSurface(beamSpotPosition);
 
              // uses perigee on track or extrapolates, no material in any case, we cut on impacts
              std::unique_ptr<const Trk::TrackParameters> parm =
                m_extrapolator->extrapolateDirectly(
                  ctx, *input, perigeeSurface);
              std::unique_ptr<const Trk::Perigee> extrapolatedPerigee = nullptr;
              if (parm && parm->associatedSurface().type() == Trk::SurfaceType::Perigee) {
                extrapolatedPerigee.reset(static_cast<const Trk::Perigee*>(parm.release()));
              }
              if (!extrapolatedPerigee) {
                ATH_MSG_WARNING("Extrapolation of perigee failed, this should never happen" );
                // statistics
                ev_stat.m_counter[Stat_t::kNExtCut]++;
                continue;
              }
 
              ATH_MSG_VERBOSE ("extrapolated perigee: "<<*extrapolatedPerigee);
              if (std::abs(extrapolatedPerigee->parameters()[Trk::d0]) > m_maxRPhiImp) {
                ATH_MSG_DEBUG ("Track Rphi impact > "<<m_maxRPhiImp<<", reject it");
                // statistics
                ev_stat.m_counter[Stat_t::kNExtCut]++;
                continue;
              }
              if (std::abs(extrapolatedPerigee->parameters()[Trk::z0]) > m_maxZImp) {
                ATH_MSG_DEBUG ("Track Z impact > "<<m_maxZImp<<", reject it");
                // statistics
                ev_stat.m_counter[Stat_t::kNExtCut]++;
                continue;
              }
            }
 
            // do re run a Track extension into TRT ?
            Trk::Track* globalTrackNew = nullptr;
            // do we have 4 and extension is enabled ?
            if(int(temptsos->size())>=4 && m_doExtension){
              // Add the track to the list of tracks in the event
              ATH_MSG_DEBUG ("Try to improve TRT calling extension tool.");
              // statistics
              ev_stat.m_counter[Stat_t::Stat_t::kNTrtExtCalls]++;
              // call extension tool
              std::vector<const Trk::MeasurementBase*>& tn =
                  m_trtExtension->extendTrack(ctx, *(*itt), *ext_event_data_p, map);
              if (tn.empty()) {
                // Fallback if extension failed
                ATH_MSG_DEBUG ("No new segment found, use input segment as fallback.");
                // statistics
                ev_stat.m_counter[Stat_t::Stat_t::kNTrtExtFail]++;
                // merge Si with input track segments
                globalTrackNew = mergeSegments(**itt,*trackTRT);
              } else if (!m_rejectShortExten ||
                         tn.size() >= trackTRT->numberOfMeasurementBases()) {
                // Use the extension to instead of the segment
                ATH_MSG_DEBUG ("Successful extension, number of TRT hits : " << tn.size() << " was : " << (trackTRT->numberOfMeasurementBases()));
                // merge the extension with the Si track
                globalTrackNew = mergeExtension(**itt,tn);
                // Add the track to the list of tracks in the event
                ATH_MSG_DEBUG ("Merged extension with Si segment");
                // statistics
                ev_stat.m_counter[Stat_t::kNTrtExt]++;
                // clean up
                std::vector<const Trk::MeasurementBase*>::const_iterator iv, ive=tn.end();
                for(iv=tn.begin(); iv!=ive; ++iv) delete (*iv);
              } else {
                // Extension is shorter, let's fall back onto the original
                ATH_MSG_DEBUG ("Extension too short, number of TRT hits : " << tn.size() << " was : " << (trackTRT->numberOfMeasurementBases()) << ". Use Segement !");
                // merge segments
                globalTrackNew = mergeSegments(**itt,*trackTRT);
                // Add the track to the list of tracks in the event
                ATH_MSG_DEBUG ("Merged TRT segment with Si segment");
                // statistics
                ev_stat.m_counter[Stat_t::Stat_t::kNTrtExtBad]++;
                // clean up
                std::vector<const Trk::MeasurementBase*>::const_iterator iv, ive=tn.end();
                for(iv=tn.begin(); iv!=ive; ++iv) delete (*iv);
              }
            } else {
              // no extension tool, jsut add the two
              ATH_MSG_DEBUG ("Do not try to extend Si track, merging it with input TRT.");
              // merge segments
              globalTrackNew = mergeSegments(**itt,*trackTRT);
            }
            // do we have an track candidate ?
            if(!globalTrackNew){
              ATH_MSG_DEBUG ("Failed to merge TRT+Si track segment !");
              if(m_saveTRT && trackTRT->numberOfMeasurementBases() > m_minTRTonly) {
                Trk::Track* trtSeg = nullptr;trtSeg = segToTrack(ctx, *trackTRT);
                if(!trtSeg){
                  ATH_MSG_DEBUG ("Failed to make a track out of the  TRT segment!");
                  continue;
                }
                ATH_MSG_DEBUG ("Add TRT only to output list");
                // statistis
                ev_stat.m_counter[Stat_t::kNBckTrk]++; ev_stat.m_counter[Stat_t::Stat_t::kNBckTrkTrt]++;
                // add it to output list
                if (m_trackSummaryTool.isEnabled()) {
                  m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *trtSeg,
                                      false /* DO NOT suppress hole search*/);
                }
                outTracks->push_back(trtSeg);
              }
            } else {
              ATH_MSG_DEBUG ("Save merged TRT+Si track segment!");
              // statistics
              ev_stat.m_counter[Stat_t::kNBckTrk]++; ev_stat.m_counter[Stat_t::Stat_t::kNBckTrkSi]++;
              // add it to output list
              if (m_trackSummaryTool.isEnabled()) {
                m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *globalTrackNew,
                                    false /* DO NOT suppress hole search*/);
              }
              outTracks->push_back(globalTrackNew);
            }
          }
        }
      }
    }
  }
  // further debugging of results
  if(m_doStat){
    Analyze(outTracks.get());
  }
  if (SG::WriteHandle<TrackCollection>(m_outTracksKey,ctx).record(std::move(outTracks)).isFailure()){
     ATH_MSG_ERROR("Failed to record " << m_outTracksKey.key());
     return StatusCode::FAILURE;
  }
  // Update the total counters
  {
     std::lock_guard<std::mutex> lock(m_statMutex);
     m_totalStat += ev_stat;
  }
 
  for (auto *p : tempTracks){
    delete p;
  }
  m_trackmaker->endEvent(*event_data_p);
 
  //Print common event information
  if(msgLvl(MSG::DEBUG)){
     dumpevent(msg(MSG::DEBUG), ev_stat);
  }
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 89 of file AthCommonAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

finalize()

StatusCode InDet::TRT_SeededTrackFinder::finalize ( )

override

Definition at line 417 of file TRT_SeededTrackFinder.cxx.

{
  if(msgLvl(MSG::INFO)){
     msg(MSG::INFO) << "\n";
     dumpevent(msg(MSG::INFO), m_totalStat);
     msg(MSG::INFO) << endmsg;
  }
  return StatusCode::SUCCESS;
}

initialize()

StatusCode InDet::TRT_SeededTrackFinder::initialize ( )

override

TRT segments to use

Definition at line 47 of file TRT_SeededTrackFinder.cxx.

{
 
  //Get the TRT seeded track maker tool
  //
  ATH_CHECK(m_trackmaker.retrieve());
 
  //Get the refitting tool
  //
  ATH_CHECK( m_fitterTool.retrieve(      DisableTool{ !m_doRefit } ));
  ATH_CHECK( m_extrapolator.retrieve(    DisableTool{ !m_SiExtensionCuts } ));
  ATH_CHECK( m_beamSpotKey.initialize(   m_SiExtensionCuts) );
 
  // optional PRD to track association map
  ATH_CHECK( m_prdToTrackMap.initialize( !m_prdToTrackMap.key().empty() ) );
 
  ATH_CHECK( m_trackSummaryTool.retrieve( DisableTool{ m_trackSummaryTool.name().empty() } ) );
 
  // Get tool for track extension to TRT
  //
  ATH_CHECK( m_trtExtension.retrieve(    DisableTool{ !m_doExtension} ));
 
 
  ATH_CHECK(  m_SegmentsKey.initialize()) ;  
  ATH_CHECK( m_outTracksKey.initialize());
 
  ATH_CHECK( m_caloClusterROIKey.initialize(m_caloSeededRoI) );
 
  if(m_caloSeededRoI){
    ATH_CHECK( m_regionSelector.retrieve());
  } else {
    m_regionSelector.disable();
  }
 
  // Get output print level
  //
  if(msgLvl(MSG::DEBUG)) {
     dumptools(msg(MSG::DEBUG));
  }
   //Global counters. See the include file for definitions
  m_totalStat = Stat_t();
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

mergeExtension()

Trk::Track * InDet::TRT_SeededTrackFinder::mergeExtension ( const Trk::Track & tT, std::vector< const Trk::MeasurementBase * > & tS ) const

protected

Merge a TRT track extension and a Si track component into one global ID track.

Construct the new track

Definition at line 623 of file TRT_SeededTrackFinder.cxx.

                                                                                   {
  // TSOS from the track
  const Trk::TrackStates* stsos = tT.trackStateOnSurfaces();
  // fitQuality from track
  auto fq = tT.fitQuality()->uniqueClone();
  // output datavector of TSOS
  auto ntsos = std::make_unique<Trk::TrackStates>();
  // copy track Si states into track
  Trk::TrackStates::const_iterator p_stsos;
  for (p_stsos = stsos->begin(); p_stsos != stsos->end(); ++p_stsos) {
    ntsos->push_back((*p_stsos)->clone());
  }
  // loop over TRT track extension
  for (auto & it : tS) {
    std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern;
    typePattern.set(Trk::TrackStateOnSurface::Measurement);
    const Trk::TrackStateOnSurface* seg_tsos = new Trk::TrackStateOnSurface(it->uniqueClone(), nullptr, nullptr, typePattern);
    ntsos->push_back(seg_tsos);
  }
  Trk::TrackInfo info;
  info.setPatternRecognitionInfo(Trk::TrackInfo::TRTSeededTrackFinder);
  std::unique_ptr<Trk::Track> newTrack( std::make_unique<Trk::Track>(info, std::move(ntsos), std::move(fq)) );
  //Careful refitting at the end
  if (m_doRefit) {
    newTrack = (m_fitterTool->fit(Gaudi::Hive::currentContext(),*newTrack, false, Trk::pion) ) ;
    //coverity[REVERSE_INULL:FALSE]
    if (!newTrack) {
      ATH_MSG_DEBUG ("Refit of TRT+Si track segment failed!");
      return nullptr;
    }
    //Protect for tracks that have no really defined locz and theta parameters
    const Trk::Perigee* perTrack=newTrack->perigeeParameters();
    if (perTrack) {
      const AmgSymMatrix(5)* CM = perTrack->covariance();
      if (!CM || std::sqrt((*CM)(1,1)) == 0. || std::sqrt((*CM)(3,3)) == 0.) {
        return nullptr;
      }
    }
  }
 
  return newTrack.release();
}

mergeSegments()

Trk::Track * InDet::TRT_SeededTrackFinder::mergeSegments ( const Trk::Track & tT, const Trk::TrackSegment & tS ) const

protected

Protected methods.

Merge a TRT track segment and a Si track component into one global ID track

Construct the new track

Definition at line 505 of file TRT_SeededTrackFinder.cxx.

                                                                                                       {
  // TSOS from the track
  const Trk::TrackStates* stsos = tT.trackStateOnSurfaces();
  // fitQuality from track
  auto fq = tT.fitQuality()->uniqueClone();
  // output datavector of TSOS
  auto ntsos = std::make_unique<Trk::TrackStates>();
  int siHits = 0;
  // copy track Si states into track
  Trk::TrackStates::const_iterator p_stsos;
  for (p_stsos=stsos->begin(); p_stsos != stsos->end(); ++p_stsos) {
    ntsos->push_back( (*p_stsos)->clone() );
    if ((*p_stsos)->type(Trk::TrackStateOnSurface::Measurement)) siHits++;
  }
  // loop over segment
  for (int it = 0; it < int(tS.numberOfMeasurementBases()); it++) {
    //test if it is a pseudo measurement
    if ( dynamic_cast<const Trk::PseudoMeasurementOnTrack*>(tS.measurement(it)) ) {
      if (siHits < 4) {
        ATH_MSG_DEBUG ("Too few Si hits.Will keep pseudomeasurement...");
        const Trk::TrackStateOnSurface* seg_tsos = new Trk::TrackStateOnSurface(tS.measurement(it)->uniqueClone(), nullptr);
        ntsos->push_back(seg_tsos);
      }
    } else {
      std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern;
      typePattern.set(Trk::TrackStateOnSurface::Measurement);
      const Trk::TrackStateOnSurface* seg_tsos = new Trk::TrackStateOnSurface(tS.measurement(it)->uniqueClone(), nullptr, nullptr, typePattern);
      ntsos->push_back(seg_tsos);
    }
  }

  Trk::TrackInfo info;
  info.setPatternRecognitionInfo(Trk::TrackInfo::TRTSeededTrackFinder);
  std::unique_ptr<Trk::Track> newTrack(std::make_unique<Trk::Track>(info, std::move(ntsos), std::move(fq)));
 
  //Careful refitting at the end
  if (m_doRefit) {
    newTrack=m_fitterTool->fit(Gaudi::Hive::currentContext(),*newTrack, false, Trk::pion);
    //coverity[REVERSE_INULL:FALSE]
    if (!newTrack) {
      ATH_MSG_DEBUG ("Refit of TRT+Si track segment failed!");
      return nullptr;
    }
    const Trk::Perigee* perTrack=newTrack->perigeeParameters();
    if (perTrack) {
      const AmgSymMatrix(5)* CM = perTrack->covariance();
      if (!CM || std::sqrt((*CM)(1,1)) == 0. || std::sqrt((*CM)(3,3)) == 0.) {
        return nullptr;
      }
    }
  }
  return newTrack.release();
}

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

segToTrack()

Trk::Track * InDet::TRT_SeededTrackFinder::segToTrack ( const EventContext & ctx, const Trk::TrackSegment & tS ) const

protected

Transform a TRT track segment into a track.

Definition at line 564 of file TRT_SeededTrackFinder.cxx.

                                                                                                         {
  ATH_MSG_DEBUG ("Transforming the TRT segment into a track...");
 
  //Get the track segment information and build the initial track parameters
  const Trk::StraightLineSurface* surf = dynamic_cast<const Trk::StraightLineSurface*>(&(tS.associatedSurface()));
  if (!surf) {
    throw std::logic_error("Unhandled surface.");
  }
  const AmgVector(5)& p = tS.localParameters();
  AmgSymMatrix(5) ep = AmgSymMatrix(5)(tS.localCovariance());
  auto ntsos = std::make_unique<Trk::TrackStates>();
  std::unique_ptr<Trk::TrackParameters> segPar =
    surf->createUniqueParameters<5, Trk::Charged>(
      p(0), p(1), p(2), p(3), p(4), std::move(ep));
  if (segPar) {
    ATH_MSG_DEBUG( "Initial TRT Segment Parameters for refitting " << (*segPar) );
  } else {
    ATH_MSG_DEBUG( "Could not get initial TRT segment parameters! " );
    return nullptr;
  }
  for (int it = 0; it < int(tS.numberOfMeasurementBases()); it++) {
    // on first measurement add parameters
    const Trk::TrackStateOnSurface* seg_tsos = nullptr;
    std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern;
    typePattern.set(Trk::TrackStateOnSurface::Measurement);
    if (it == 0){
      seg_tsos = new Trk::TrackStateOnSurface(tS.measurement(it)->uniqueClone(), std::move(segPar), nullptr, typePattern);
    } else {
      seg_tsos = new Trk::TrackStateOnSurface(tS.measurement(it)->uniqueClone(), nullptr, nullptr, typePattern);
    }
    ntsos->push_back(seg_tsos);
  }
  Trk::TrackInfo info;
  info.setPatternRecognitionInfo(Trk::TrackInfo::TRTSeededTrackFinder);
  std::unique_ptr<Trk::Track> newTrack = std::make_unique<Trk::Track>(info, std::move(ntsos), nullptr);
  // Careful refitting of the TRT stand alone track
  if (m_doRefit) {
    newTrack = m_fitterTool->fit(ctx,*newTrack, false, Trk::pion);
    //coverity[REVERSE_INULL:FALSE]
    if (!newTrack) {
      ATH_MSG_DEBUG ("Refit of TRT track segment failed!");
      return nullptr;
    }
    //Protect for tracks that have no really defined locz and theta parameters
    const Trk::Perigee* perTrack=newTrack->perigeeParameters();
    if (perTrack) {
      const AmgSymMatrix(5)* CM = perTrack->covariance();
      if (!CM || std::sqrt((*CM)(1,1)) == 0. || std::sqrt((*CM)(3,3)) == 0.) {
         return nullptr;
      }
    }
  }
  return newTrack.release();
}

setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

                                                      {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

Stat_t m_totalStat InDet::TRT_SeededTrackFinder::ATLAS_THREAD_SAFE

mutableprotected

Definition at line 187 of file TRT_SeededTrackFinder.h.

ATLAS_THREAD_SAFE [2/2]

std::mutex m_statMutex InDet::TRT_SeededTrackFinder::ATLAS_THREAD_SAFE

mutableprotected

Definition at line 186 of file TRT_SeededTrackFinder.h.

m_beamSpotKey

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

protected

Definition at line 124 of file TRT_SeededTrackFinder.h.

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

m_caloClusterROIKey

SG::ReadHandleKey<ROIPhiRZContainer> InDet::TRT_SeededTrackFinder::m_caloClusterROIKey

protected

Initial value:

{this, "EMROIPhiRZContainer", "",
     "Name of the calo cluster ROIs in Phi,R,Z parameterization"}

Definition at line 137 of file TRT_SeededTrackFinder.h.

    {this, "EMROIPhiRZContainer", "",
     "Name of the calo cluster ROIs in Phi,R,Z parameterization"};

m_caloSeededRoI

BooleanProperty InDet::TRT_SeededTrackFinder::m_caloSeededRoI {this, "CaloSeededRoI", false}

protected

Definition at line 136 of file TRT_SeededTrackFinder.h.

{this, "CaloSeededRoI", false};

m_deltaEta

FloatProperty InDet::TRT_SeededTrackFinder::m_deltaEta {this, "dEtaCaloRoI", 0.1, "delta Eta used for RoI creation"}

protected

Definition at line 145 of file TRT_SeededTrackFinder.h.

{this, "dEtaCaloRoI", 0.1, "delta Eta used for RoI creation"};

m_deltaPhi

FloatProperty InDet::TRT_SeededTrackFinder::m_deltaPhi {this, "dPhiCaloRoI", 0.25, "delta Phi used for RoI creation"}

protected

Definition at line 147 of file TRT_SeededTrackFinder.h.

{this, "dPhiCaloRoI", 0.25, "delta Phi used for RoI creation"};

m_deltaZ

FloatProperty InDet::TRT_SeededTrackFinder::m_deltaZ {this, "dZCaloRoI", 300., "delta Z used for RoI creation"}

protected

Definition at line 149 of file TRT_SeededTrackFinder.h.

{this, "dZCaloRoI", 300., "delta Z used for RoI creation"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_doExtension

BooleanProperty InDet::TRT_SeededTrackFinder::m_doExtension {this, "TrtExtension", false, "Find the TRT extension of the track"}

protected

Definition at line 86 of file TRT_SeededTrackFinder.h.

{this, "TrtExtension", false, "Find the TRT extension of the track"};

m_doRefit

BooleanProperty InDet::TRT_SeededTrackFinder::m_doRefit {this, "FinalRefit", false, "Do a final careful refit of tracks"}

protected

Definition at line 84 of file TRT_SeededTrackFinder.h.

{this, "FinalRefit", false, "Do a final careful refit of tracks"};

m_doStat

BooleanProperty InDet::TRT_SeededTrackFinder::m_doStat {this, "FinalStatistics", false, "Statistics of final tracks"}

protected

Definition at line 90 of file TRT_SeededTrackFinder.h.

{this, "FinalStatistics", false, "Statistics of final tracks"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_extrapolator

ToolHandle<Trk::IExtrapolator> InDet::TRT_SeededTrackFinder::m_extrapolator {this, "Extrapolator", ""}

protected

Definition at line 123 of file TRT_SeededTrackFinder.h.

{this, "Extrapolator", ""};

m_fitterTool

ToolHandle<Trk::ITrackFitter> InDet::TRT_SeededTrackFinder::m_fitterTool

protected

Initial value:

{this, "RefitterTool", "Trk::GlobalChi2Fitter/InDetTrackFitter",
     "Track refit tool"}

Definition at line 105 of file TRT_SeededTrackFinder.h.

    {this, "RefitterTool", "Trk::GlobalChi2Fitter/InDetTrackFitter",
     "Track refit tool"};

m_maxEta

DoubleProperty InDet::TRT_SeededTrackFinder::m_maxEta {this, "maxEta", 2.7, "maximal Eta cut"}

protected

Definition at line 130 of file TRT_SeededTrackFinder.h.

{this, "maxEta", 2.7, "maximal Eta cut"};

m_maxRPhiImp

DoubleProperty InDet::TRT_SeededTrackFinder::m_maxRPhiImp {this, "maxRPhiImp", 10., "maximal RPhi impact parameter cut"}

protected

Definition at line 131 of file TRT_SeededTrackFinder.h.

{this, "maxRPhiImp", 10., "maximal RPhi impact parameter cut"};

m_MaxSegNum

IntegerProperty InDet::TRT_SeededTrackFinder::m_MaxSegNum

protected

Initial value:

{this, "MaxNumberSegments", 5000,
     "Maximum number of segments to be handled"}

Definition at line 94 of file TRT_SeededTrackFinder.h.

    {this, "MaxNumberSegments", 5000,
     "Maximum number of segments to be handled"};

m_maxZImp

DoubleProperty InDet::TRT_SeededTrackFinder::m_maxZImp {this, "maxZImp", 250., "maximal z impact parameter cut"}

protected

Definition at line 133 of file TRT_SeededTrackFinder.h.

{this, "maxZImp", 250., "maximal z impact parameter cut"};

m_minPt

DoubleProperty InDet::TRT_SeededTrackFinder::m_minPt {this, "minPt", 500., "minimal Pt cut"}

protected

Definition at line 129 of file TRT_SeededTrackFinder.h.

{this, "minPt", 500., "minimal Pt cut"};

m_minTRTonly

UnsignedIntegerProperty InDet::TRT_SeededTrackFinder::m_minTRTonly {this, "MinTRTonly", 15, "Minimum number of TRT hits on TRT only"}

protected

Definition at line 99 of file TRT_SeededTrackFinder.h.

{this, "MinTRTonly", 15, "Minimum number of TRT hits on TRT only"};

m_minTRTonSegment

UnsignedIntegerProperty InDet::TRT_SeededTrackFinder::m_minTRTonSegment {this, "MinTRTonSegment", 10, "Minimum Number of TRT Hits on segment"}

protected

Definition at line 97 of file TRT_SeededTrackFinder.h.

{this, "MinTRTonSegment", 10, "Minimum Number of TRT Hits on segment"};

m_outTracksKey

SG::WriteHandleKey<TrackCollection> InDet::TRT_SeededTrackFinder::m_outTracksKey

protected

Initial value:

{this, "OutputTracksLocation", "TRTSeededTracks",
     "Output track collection"}

Definition at line 114 of file TRT_SeededTrackFinder.h.

    {this, "OutputTracksLocation", "TRTSeededTracks",
     "Output track collection"};

m_prdToTrackMap

SG::ReadHandleKey<Trk::PRDtoTrackMap> InDet::TRT_SeededTrackFinder::m_prdToTrackMap {this, "PRDtoTrackMap", "" }

protected

Definition at line 118 of file TRT_SeededTrackFinder.h.

{this, "PRDtoTrackMap", "" };

m_regionSelector

ToolHandle<IRegSelTool> InDet::TRT_SeededTrackFinder::m_regionSelector

protected

Initial value:

{this, "RegSelTool", "RegSelTool/RegSel_SCT",
     "Region selector service instance"}

Definition at line 141 of file TRT_SeededTrackFinder.h.

    {this, "RegSelTool", "RegSelTool/RegSel_SCT",
     "Region selector service instance"};

m_rejectShortExten

BooleanProperty InDet::TRT_SeededTrackFinder::m_rejectShortExten {this, "RejectShortExtension", false, "Reject short extensions"}

protected

Definition at line 88 of file TRT_SeededTrackFinder.h.

{this, "RejectShortExtension", false, "Reject short extensions"};

m_saveTRT

BooleanProperty InDet::TRT_SeededTrackFinder::m_saveTRT {this, "OutputSegments", true, "Save stand-alone TRT segments"}

protected

Definition at line 92 of file TRT_SeededTrackFinder.h.

{this, "OutputSegments", true, "Save stand-alone TRT segments"};

m_SegmentsKey

SG::ReadHandleKey<Trk::SegmentCollection> InDet::TRT_SeededTrackFinder::m_SegmentsKey {this, "InputSegmentsLocation", "TRTSegments", "TRT segments to use"}

protected

Definition at line 112 of file TRT_SeededTrackFinder.h.

{this, "InputSegmentsLocation", "TRTSegments", "TRT segments to use"};

m_SiExtensionCuts

BooleanProperty InDet::TRT_SeededTrackFinder::m_SiExtensionCuts {this, "SiExtensionCuts", false, "enable cuts after Si segment finding"}

protected

Definition at line 127 of file TRT_SeededTrackFinder.h.

{this, "SiExtensionCuts", false, "enable cuts after Si segment finding"};

m_trackmaker

ToolHandle<ITRT_SeededTrackFinder> InDet::TRT_SeededTrackFinder::m_trackmaker

protected

Initial value:

{this, "TrackTool", "InDet::TRT_SeededTrackFinderTool",
     "Back tracking tool"}

Definition at line 102 of file TRT_SeededTrackFinder.h.

    {this, "TrackTool", "InDet::TRT_SeededTrackFinderTool",
     "Back tracking tool"};

m_trackSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> InDet::TRT_SeededTrackFinder::m_trackSummaryTool {this, "TrackSummaryTool", "InDetTrackSummaryToolNoHoleSearch"}

protected

Definition at line 120 of file TRT_SeededTrackFinder.h.

{this, "TrackSummaryTool", "InDetTrackSummaryToolNoHoleSearch"};

m_trtExtension

ToolHandle<ITRT_TrackExtensionTool> InDet::TRT_SeededTrackFinder::m_trtExtension

protected

Initial value:

{this, "TrackExtensionTool", "InDet::TRT_TrackExtensionTool_xk",
     "TRT track extension tool "}

Definition at line 108 of file TRT_SeededTrackFinder.h.

    {this, "TrackExtensionTool", "InDet::TRT_TrackExtensionTool_xk",
     "TRT track extension tool "};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• TRT_SeededTrackFinder.h
• TRT_SeededTrackFinder.cxx