InDet::TRT_SeededTrackFinder_ATL Class Reference

InDet::TRT_SeededTrackFinderATL is an algorithm which produces tracks along the road of InDetDD::SiDetectorElement* sorted in propagation order. More...

#include <TRT_SeededTrackFinder_ATL.h>

Inheritance diagram for InDet::TRT_SeededTrackFinder_ATL:

Collaboration diagram for InDet::TRT_SeededTrackFinder_ATL:

Classes
class	EventData

Public Member Functions
	TRT_SeededTrackFinder_ATL (const std::string &, const std::string &, const IInterface *)
	Standard tool methods.
virtual	~TRT_SeededTrackFinder_ATL ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual std::list< Trk::Track * >	getTrack (const EventContext &ctx, InDet::ITRT_SeededTrackFinder::IEventData &event_data, const Trk::TrackSegment &) const override
	Main methods for local track finding.
virtual std::unique_ptr< InDet::ITRT_SeededTrackFinder::IEventData >	newEvent (const EventContext &ctx, SiCombinatorialTrackFinderData_xk &combinatorialData) const override
	New event initialization.
virtual std::unique_ptr< InDet::ITRT_SeededTrackFinder::IEventData >	newRegion (const EventContext &ctx, SiCombinatorialTrackFinderData_xk &combinatorialData, const std::vector< IdentifierHash > &, const std::vector< IdentifierHash > &) const override
	New region intialization.
virtual void	endEvent (InDet::ITRT_SeededTrackFinder::IEventData &event_data) const override
	End of event tasks.
MsgStream &	dump (MsgStream &out) const override
	Print internal tool parameters and status.
std::ostream &	dump (std::ostream &out) const override
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	sysInitialize () override
	Perform system initialization for an algorithm.
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

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	magneticFieldInit ()
	Private Methods.
std::unique_ptr< const Trk::TrackParameters >	getTP (MagField::AtlasFieldCache &fieldCache, const Trk::SpacePoint *, const Trk::TrackParameters &, bool &, InDet::TRT_SeededTrackFinder_ATL::EventData &event_data) const
	Update track parameters through space point propagation.
std::list< Trk::Track * >	findTrack (const EventContext &ctx, MagField::AtlasFieldCache &fieldCache, InDet::TRT_SeededTrackFinder_ATL::EventData &event_data, const Trk::TrackParameters &, const Trk::TrackSegment &) const
	Find the corresponding list of Si tracks.
std::unique_ptr< const Trk::TrackParameters >	addNoise (const SiNoise_bt &, const Trk::TrackParameters &, int) const
	Add material effects.
bool	checkSeed (std::vector< const Trk::SpacePoint * > &, const Trk::TrackSegment &, const Trk::TrackParameters &) const
	Check consistency of seed and TRT track segment.
void	setTrackQualityCuts ()
	Set the track quality cuts for combinatorial track finding.
std::list< Trk::Track * >	cleanTrack (std::list< Trk::Track * >) const
	Eliminate spurious Pixel clusters in track.
bool	isCaloCompatible (const Trk::TrackParameters &, const InDet::TRT_SeededTrackFinder_ATL::EventData &event_data) const
	Only propagate to the Si if the TRT segment is compatible with a calo measurement.
MsgStream &	dumpconditions (MsgStream &out) 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.

Static Protected Member Functions
static std::unique_ptr< const Trk::TrackParameters >	modifyTrackParameters (const Trk::TrackParameters &, int)
	Modify track parameters if brem correction.
static void	clusterTrackMap (Trk::Track *, InDet::TRT_SeededTrackFinder_ATL::EventData &event_data)
	Map PRDs-tracks.
static bool	newClusters (const std::vector< const Trk::SpacePoint * > &, InDet::TRT_SeededTrackFinder_ATL::EventData &event_data)
	Seed used by another track?
static bool	newSeed (const std::vector< const Trk::SpacePoint * > &, InDet::TRT_SeededTrackFinder_ATL::EventData &event_data)
	Seed SPs used by other high quality tracks?
static bool	isNewTrack (Trk::Track *, InDet::TRT_SeededTrackFinder_ATL::EventData &event_data)
	Clean-up duplicate tracks.

Protected Attributes
StringProperty	m_fieldmode
	Protected Data.
Trk::MagneticFieldProperties	m_fieldprop
ToolHandle< InDet::ISiDetElementsRoadMaker >	m_roadmaker {this, "RoadTool", "InDet::SiDetElementsRoadMaker_xk"}
	Magnetic field properties.
ToolHandle< InDet::ITRT_SeededSpacePointFinder >	m_seedmaker {this, "SeedTool", ""}
ToolHandle< Trk::IPropagator >	m_proptool {this, "PropagatorTool", "Trk::RungeKuttaPropagator/InDetPropagator"}
ToolHandle< Trk::IUpdator >	m_updatorTool {this, "UpdatorTool", "Trk::KalmanUpdator_xk/InDetPatternUpdator"}
ToolHandle< InDet::ISiCombinatorialTrackFinder >	m_tracksfinder {this, "CombinatorialTrackFinder", "InDet::SiCombinatorialTrackFinder_xk"}
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCondObjInputKey
const TRT_ID *	m_trtId = nullptr
	ID TRT helper.
DoubleProperty	m_xi2max {this, "Xi2max", 15., "max Xi2 for updators"}
	Track quality cuts to be passed to the combinatorial track finder.
DoubleProperty	m_xi2maxNoAdd
DoubleProperty	m_xi2maxlink
DoubleProperty	m_pTmin {this, "pTmin", 500., "min pT"}
IntegerProperty	m_nholesmax {this, "nHolesMax", 1, "Max number holes"}
IntegerProperty	m_dholesmax
IntegerProperty	m_nclusmin {this, "nClustersMin", 4, "Min number clusters"}
IntegerProperty	m_nwclusmin
BooleanProperty	m_bremCorrect
BooleanProperty	m_propR
BooleanProperty	m_useassoTool
InDet::TrackQualityCuts	m_trackquality
DoubleArrayProperty	m_errorScale
DoubleProperty	m_outlierCut
BooleanProperty	m_searchInCaloROI
SG::ReadHandleKey< ROIPhiRZContainer >	m_caloClusterROIKey {this, "EMROIPhiRZContainer", ""}
DoubleProperty	m_phiWidth {this, "phiWidth", 0.3}

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
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_SeededTrackFinderATL is an algorithm which produces tracks along the road of InDetDD::SiDetectorElement* sorted in propagation order.

Author

Thoma.nosp@m.s.Ko.nosp@m.ffas@.nosp@m.cern.nosp@m..ch

Definition at line 81 of file TRT_SeededTrackFinder_ATL.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

TRT_SeededTrackFinder_ATL()

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

Standard tool methods.

Definition at line 76 of file TRT_SeededTrackFinder_ATL.cxx.

  : AthAlgTool(t,n,p)
{
  declareInterface<ITRT_SeededTrackFinder>(this);
}

~TRT_SeededTrackFinder_ATL()

InDet::TRT_SeededTrackFinder_ATL::~TRT_SeededTrackFinder_ATL ( )

virtualdefault

Member Function Documentation

addNoise()

std::unique_ptr< const Trk::TrackParameters > InDet::TRT_SeededTrackFinder_ATL::addNoise ( const SiNoise_bt & noise, const Trk::TrackParameters & P1, int isSmooth ) const

protected

Add material effects.

Definition at line 661 of file TRT_SeededTrackFinder_ATL.cxx.

                                                                                                                  {
  ATH_MSG_DEBUG( "Adding noise to track parameters... " );
  const double covAzim=noise.covarianceAzim();
  const double covPola=noise.covariancePola();
  const double covIMom=noise.covarianceIMom();
  const double corIMom=noise.correctionIMom();
  //Get the noise augmented parameters and the 15 lower half covariance matrix elements from the first input track parameters
  const AmgVector(5)& Vp1 = P1.parameters();
  double M[5]={Vp1[0],Vp1[1],Vp1[2],Vp1[3],Vp1[4]};
  if(!isSmooth){
    M[4] *= corIMom;
  }else{
    M[4] /= corIMom;
  }
  const AmgSymMatrix(5)* C = P1.covariance();
  if(C){
    AmgSymMatrix(5) nC;
    nC = (*C);
    nC(2,2)+=covAzim;
    nC(3,3)+=covPola;
    nC(4,4)+=covIMom;
    return P1.associatedSurface().createUniqueTrackParameters(M[0],M[1],M[2],M[3],M[4],nC);
  }
  return nullptr;
}

checkSeed()

bool InDet::TRT_SeededTrackFinder_ATL::checkSeed ( std::vector< const Trk::SpacePoint * > & vsp, const Trk::TrackSegment & tS, const Trk::TrackParameters & tP ) const

protected

Check consistency of seed and TRT track segment.

Get TRT segment track parameters

Process only if endcap-transition region

Find the global z position of first endcap hit on TRT segment

Propagate at the z position of 1st endcap hit on TRT segment

Definition at line 694 of file TRT_SeededTrackFinder_ATL.cxx.

                                                                                                         {
  bool isGood = true;
  int nEC = 0; double gz = 0.;
  const AmgVector(5)& pTS=tP.parameters();
  if(std::abs(std::log(std::tan(pTS[3]/2.)))>0.8){
    for(int it=0; it<int(tS.numberOfMeasurementBases()); it++){
      //Check if it is a pseudo measurement and move on
      if ( dynamic_cast<const Trk::PseudoMeasurementOnTrack*>(tS.measurement(it)) ) continue;
      const InDet::TRT_DriftCircleOnTrack* trtcircle = dynamic_cast<const InDet::TRT_DriftCircleOnTrack*>(tS.measurement(it));
      if(trtcircle){
        Identifier id=trtcircle->detectorElement()->identify();
        int isB = m_trtId->barrel_ec(id);
        if(isB==2 || isB==-2) nEC++;
        if(nEC==1){
          gz = trtcircle->globalPosition().z();
          break;
        }
      }
    }
    double tanTheta = std::tan(thetaFromSpacePoints(vsp[0], vsp[1]));
    double propR = getRadius(vsp[1]) + (gz-getZ(vsp[1]))*tanTheta;
    if(propR<620. || propR>1010.) isGood=false;
    double zIn = gz-propR/tanTheta;
    if(zIn>300.) isGood = false;
  }
  return isGood;
}

cleanTrack()

std::list< Trk::Track * > InDet::TRT_SeededTrackFinder_ATL::cleanTrack ( std::list< Trk::Track * > lTrk ) const

protected

Eliminate spurious Pixel clusters in track.

Concentrate on the Si component of the track

Throw out any spurious pixel hits.Need to rebuild the vector of track states on surface from scratch, since it's const in EDM

Construct the new track

Definition at line 984 of file TRT_SeededTrackFinder_ATL.cxx.

                                                                       {
  std::list<Trk::Track*> cleanSiTrack; // List of clean Si tracks per TRT segment
  std::list<Trk::Track*>::const_iterator it    = lTrk.begin();
  std::list<Trk::Track*>::const_iterator itEnd = lTrk.end();
  for (; it != itEnd ; ++it){
    int nPixHits = 0;  //Number of Pixel PRDs
    int nSctHits = 0;  //Number of SCT PRDs
    double pixR = 0.;  //Radial position of last pixel PRD
    double sctR = 0.;  //Radial position of first SCT PRD
 
    const Trk::TrackStates* newtsos = (*it)->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
        const InDet::SiCluster* RawDataClus=dynamic_cast<const InDet::SiCluster*>(clus->prepRawData());
        if(RawDataClus==nullptr){
            ATH_MSG_DEBUG( "Si Cluster without PrepRawData!!!" );
          continue;
        }
        if(RawDataClus->detectorElement()->isPixel()){
          nPixHits++;
          pixR = RawDataClus->globalPosition().perp();
        }
        if((RawDataClus->detectorElement()->isSCT()) && (nSctHits==0)) {
          sctR = RawDataClus->globalPosition().perp();
          nSctHits++;
          break;
        }
      }
    }

    if(nPixHits==1 && (sctR-pixR)>200.){
      auto cltsos = std::make_unique<Trk::TrackStates>();
      auto fq = (*it)->fitQuality()->uniqueClone();
      // copy track Si states into track
      Trk::TrackStates::const_iterator p_tsos;
      for(p_tsos=newtsos->begin()+nPixHits;p_tsos!=newtsos->end();++p_tsos){
        cltsos->push_back( (*p_tsos)->clone() );
      }
      Trk::TrackInfo info;
 //     info.setPatternRecognitionInfo(Trk::TrackInfo::TRTSeededTrackFinder);
      Trk::Track* nTrack = new Trk::Track(info, std::move(cltsos), std::move(fq));
      cleanSiTrack.push_back(nTrack);
      delete (*it);
    }else{
      cleanSiTrack.push_back((*it));
    }
  }
 
  return cleanSiTrack;
}

clusterTrackMap()

void InDet::TRT_SeededTrackFinder_ATL::clusterTrackMap ( Trk::Track * Tr, InDet::TRT_SeededTrackFinder_ATL::EventData & event_data )

staticprotected

Map PRDs-tracks.

Definition at line 783 of file TRT_SeededTrackFinder_ATL.cxx.

{
  DataVector<const Trk::MeasurementBase>::const_iterator
    m  = Tr->measurementsOnTrack()->begin(),
    me = Tr->measurementsOnTrack()->end  ();
 
  for(; m!=me; ++m) {
    const Trk::PrepRawData* prd = ((const Trk::RIO_OnTrack*)(*m))->prepRawData();
    if(prd) event_data.clusterTrack().insert(std::make_pair(prd,Tr));
  }
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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_ATL::dump ( MsgStream & out ) const

overridevirtual

Print internal tool parameters and status.

Implements InDet::ITRT_SeededTrackFinder.

Definition at line 141 of file TRT_SeededTrackFinder_ATL.cxx.

                                                          {
  out<<"\n";
  return dumpconditions(out);
}

dump() [2/2]

std::ostream & InDet::TRT_SeededTrackFinder_ATL::dump ( std::ostream & out ) const

overridevirtual

Implements InDet::ITRT_SeededTrackFinder.

Definition at line 201 of file TRT_SeededTrackFinder_ATL.cxx.

                                                           {
  return out;
}

dumpconditions()

MsgStream & InDet::TRT_SeededTrackFinder_ATL::dumpconditions ( MsgStream & out ) const

protected

Definition at line 151 of file TRT_SeededTrackFinder_ATL.cxx.

                                                                    {
  auto paddedName=[](const auto & str)->std::string{
    const auto n = 62-std::size(str);
    std::string result(n,' '); //padding
    result+='|';
    result+='\n';
    return std::string(str)+result;
  };
  
  auto format = [](MsgStream& m)->MsgStream&{
    m<<std::setw(12)<<std::setprecision(5);
    return m;
  };
  
  constexpr std::string_view  fieldmode[9] ={"NoField"       ,"ConstantField","SolenoidalField",
                 "ToroidalField" ,"Grid3DField"  ,"RealisticField" ,
                 "UndefinedField","AthenaField"  , "?????"         };
 
  int mode = m_fieldprop.magneticFieldMode();
  if(mode<0 || mode>8 ) mode = 8;
  
  constexpr auto horizontalRule{
    "|-----------------------------------------------------------------------------------------|\n"
  }; 
  
  constexpr auto padding{"                                                  |\n"};
  out<<horizontalRule;
  out<<"| Tool for propagation    | "<<paddedName(m_proptool.type());
  out<<"| Tool for updator        | "<<paddedName(m_updatorTool.type());
  out<<"| Tool for road maker     | "<<paddedName(m_roadmaker.type());
  out<<"| Tool for seed maker     | "<<paddedName(m_seedmaker.type());
  out<<"| Tool for track finding  | "<<paddedName(m_tracksfinder.type());
  out<<"| Magnetic field mode     | "<<paddedName(fieldmode[mode]);
  out<<"| Min pT of track (MeV)   | "<<format<<m_pTmin<<padding;
  out<<"| Max Xi2 for cluster     | "<<format<<m_xi2max<<padding;
  out<<"| Max Xi2 for outlayer    | "<<format<<m_xi2maxNoAdd<<padding;
  out<<"| Max Xi2 for link        | "<<format<<m_xi2maxlink<<padding;
  out<<"| Min number of clusters  | "<<std::setw(12)<<m_nclusmin<<padding;
  out<<"| Max number holes        | "<<std::setw(12)<<m_nholesmax<<padding;
  out<<"| Max holes  gap          | "<<std::setw(12)<<m_dholesmax<<padding;
  out<<horizontalRule;
  return out;
}

endEvent()

void InDet::TRT_SeededTrackFinder_ATL::endEvent ( InDet::ITRT_SeededTrackFinder::IEventData & event_data ) const

overridevirtual

End of event tasks.

Implements InDet::ITRT_SeededTrackFinder.

Definition at line 262 of file TRT_SeededTrackFinder_ATL.cxx.

                                                                                                    {
  //event_data cannot be const if passed to m_tracksfinder->endEvent
  InDet::TRT_SeededTrackFinder_ATL::EventData &event_data = EventData::getPrivateEventData(virt_event_data);
  // End event for track finder tool
  m_tracksfinder->endEvent(event_data.combinatorialData());
 
}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::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; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

finalize()

StatusCode InDet::TRT_SeededTrackFinder_ATL::finalize ( )

overridevirtual

Implements InDet::ITRT_SeededTrackFinder.

Definition at line 132 of file TRT_SeededTrackFinder_ATL.cxx.

                                        {
   return StatusCode::SUCCESS;
}

findTrack()

std::list< Trk::Track * > InDet::TRT_SeededTrackFinder_ATL::findTrack ( const EventContext & ctx, MagField::AtlasFieldCache & fieldCache, InDet::TRT_SeededTrackFinder_ATL::EventData & event_data, const Trk::TrackParameters & initTP, const Trk::TrackSegment & tS ) const

protected

Find the corresponding list of Si tracks.

List of space points in the current seed, starting from the one at the smaller radius

end of loop over seeds for this TRT segment

Definition at line 355 of file TRT_SeededTrackFinder_ATL.cxx.

                                 {
  SiCombinatorialTrackFinderData_xk& combinatorialData=event_data.combinatorialData();
  //Return list copied by value (fix!!)
  std::list<Trk::Track*> associatedSiTrack; // List of found tracks per TRT segment
  constexpr double pi2 = 2.*M_PI;
  constexpr double pi=M_PI;
 
  //Get the seeds
  std::list<std::pair<const Trk::SpacePoint*,const Trk::SpacePoint*> >
      SpE = m_seedmaker->find2Sp(ctx, initTP,event_data.spacePointFinderEventData());                //Get a list of SP pairs
 
  ATH_MSG_DEBUG("---------------> SP SEED LIST SIZE " << SpE.size() );
  if(SpE.empty()){return associatedSiTrack;}
 
  //
  // --------------- loop over the found seeds
  //
 
  //Get the track states on surface that correspond to each SP pair that came from the seeding
  std::vector<const Trk::SpacePoint*> SpVec{nullptr, nullptr};
 
  std::list<std::pair<const Trk::SpacePoint*,const Trk::SpacePoint*> >::iterator r,re=SpE.end();
  for(r=SpE.begin();r!=re; ++r){
    std::list<Trk::Track*>         aTracks   ; // List of tracks found per seed
    std::list<Trk::Track*>         cTracks   ; // List of cleaned tracks found per seed
    event_data.noise().reset();  //Initiate the noise production tool at the beginning of each seed
 
    //
    // --------------- filter SP to improve prediction, scale errors
    //
 
    //Get the track parameters to use to get the detector elements for each SP pair
    std::pair<const Trk::SpacePoint*, const Trk::SpacePoint*>& pSP = *r;
    if (pSP.first != pSP.second){
      ATH_MSG_DEBUG( "----> Seed Pair: SP 1 " << (pSP.first)->r() << " SP 2 " << (pSP.second)->r() );
    } else {
      if(msgLvl(MSG::DEBUG)) {
        msg(MSG::DEBUG) << "----> Seed Single: SP 1 " << (pSP.first)->r() << "\n";
        msg(MSG::DEBUG) << "      Will not process for the time being ! A special module is needed\n" ;
        msg(MSG::DEBUG) << "      to deal with late conversion (no search and stablized input fit ).\n";
        msg(MSG::DEBUG) << "      Current version is unstable in the SP updates and gets unpredictable results." << endmsg;
      }
      continue;
    }

    SpVec[0]=(pSP.second); 
    SpVec[1]=(pSP.first);
    if(!newClusters(SpVec,event_data)) {
      ATH_MSG_DEBUG( "Seed SPs already used by a single track. Ignore..." );
      continue;
    }
    if(!newSeed(SpVec,event_data)) {
      ATH_MSG_DEBUG( "Seed SPs already used by other tracks. Ignore..." );
      continue;
    }
 
    //
    // ----------------Check the SP seed if field is ON
    //
    if(fieldCache.solenoidOn()){
      bool seedGood = checkSeed(SpVec,tS,initTP);
      if(!seedGood && m_propR) {
          ATH_MSG_DEBUG( "Seed not consistent with TRT segment. Ignore..." );
          continue;
      }
    }
 
    //
    // ----------------Get new better track parameters using the SP seed
    //
    ATH_MSG_DEBUG( "Get better track parameters using the seed" );
    double newTheta = thetaFromSpacePoints(SpVec[0], SpVec[1]);
    const AmgVector(5)& iv = initTP.parameters();
    double newPhi = iv[2];
    //Protect for theta and phi being out of range
    if     (newTheta > pi) newTheta = fmod(newTheta+pi,pi2)-pi;
    else if(newTheta <-pi) newTheta = fmod(newTheta-pi,pi2)+pi;
    if(newTheta<0.){ newTheta = -newTheta; newPhi+=pi; }
    if     (newPhi > pi) newPhi = fmod(newPhi+pi,pi2)-pi;
    else if(newPhi <-pi) newPhi = fmod(newPhi-pi,pi2)+pi;
    if(newTheta<0.27) {
      ATH_MSG_DEBUG("Pseudorapidity greater than 2.Ignore" );
      continue;
    }
 
    const AmgSymMatrix(5) * vCM = initTP.covariance();
    AmgSymMatrix(5) nvCM;
     nvCM<<
      m_errorScale[0]*m_errorScale[0]*(*vCM)(0,0),0.,0.,0.,0.,
      0.,m_errorScale[1]*m_errorScale[1]*(*vCM)(1,1),0.,0.,0.,
      0.,0.,m_errorScale[2]*m_errorScale[2]*(*vCM)(2,2),0.,0.,
      0.,0.,0.,m_errorScale[3]*m_errorScale[3]*(*vCM)(3,3),0.,
      //cppcheck-suppress constStatement
      0.,0.,0.,0.,m_errorScale[4]*m_errorScale[4]*(*vCM)(4,4);
 
 
    //New intial track parameters saved as MeasuredAtaStraightLine
    std::unique_ptr<const Trk::TrackParameters> niTP =
      initTP.associatedSurface().createUniqueTrackParameters(
        iv[0], iv[1], newPhi, newTheta, iv[4], nvCM);
 
    if (niTP) {
      ATH_MSG_DEBUG("Initial Track Parameters created and scaled from TRT segment, ");
      ATH_MSG_VERBOSE(*niTP);
    } else {
      ATH_MSG_DEBUG("Could not get initial TRT track parameters! " );
      continue;
    }
 
    //
    // ----------------Propagate through the SP seed
    //
    ATH_MSG_DEBUG( "Propagating through the seed" );
    bool outl = false;
 
    //update with first SP
    ATH_MSG_DEBUG( "Update with 1st SP from seed" );
    std::unique_ptr<const Trk::TrackParameters> upTP = getTP(fieldCache, pSP.first,*niTP,outl,event_data);
    //If no track parameters are found, go to the next seed
    if(!upTP){
      ATH_MSG_DEBUG( "Extrapolation through seed failed!Seed bogus.Move to next seed" );
      continue;
    }
    //Not good if SP pair has outliers. Clean up the memory and move to next seed
    if(outl){
      ATH_MSG_DEBUG("Seed with outliers. Will not process!");
      continue;
    }
 
    //update with second SP ?
    if (pSP.first != pSP.second) {
      //update with second SP
      ATH_MSG_DEBUG( "Update with 2nd SP from seed" );
      std::unique_ptr<const Trk::TrackParameters> newTP = getTP(fieldCache, pSP.second,*upTP,outl,event_data);
      //If no track parameters are found, go to the next seed
      if(!newTP){
          ATH_MSG_DEBUG( "Extrapolation through seed failed!Seed bogus.Move to next seed" );
          continue;
      }
      //Not good if SP pair has outliers. Clean up the memory and move to next seed
      if(outl){
          ATH_MSG_DEBUG("Seed with outliers.Will not process!");
          continue;
      }
      // copy the newTP to upTP
      upTP = std::move(newTP);
    }
 
    //Protect the road maker tool when the momentum is too low since the particle will spiral inside the tracker
    if(upTP->momentum().perp()<m_pTmin){
      ATH_MSG_DEBUG("Low pT.Stop! ");
      continue;
    }
 
    //
    // --------------- get Si detector element road
    //
    const Trk::PerigeeSurface persurf (Amg::Vector3D(0,0,0));
 
    //Get track parameters at the end of SCT to start backwards propagation
    auto per = m_proptool->propagate(ctx,*upTP,persurf,Trk::oppositeMomentum,false,
                                     m_fieldprop,Trk::nonInteracting); //Propagate
    if(!per){
      ATH_MSG_DEBUG("No extrapolated track parameters!");
      continue;
    }
 
    if(msgLvl(MSG::VERBOSE)) {
      msg(MSG::VERBOSE) << "Perigee after SP updates at same surface" << endmsg;
      msg(MSG::VERBOSE) << *per << endmsg;
    }
 
    //Get list of InDet Elements
    std::vector<const InDetDD::SiDetectorElement*> DE;
    m_roadmaker->detElementsRoad(ctx, fieldCache, *per,Trk::alongMomentum,DE,event_data.roadMakerData());
    if( int(DE.size()) < m_nclusmin){ //Not enough detector elements to satisfy the minimum number of clusters requirement. Stop
      ATH_MSG_DEBUG( "Too few detector elements, not expected" );
      continue;
    }
 
    //
    // --------------- Cast it to measured parameters at 2nd SP with diagonal error matrix
    //
    const AmgVector(5)& piv = upTP->parameters();
 
    //Get the intial Error matrix, diagonalize it and scale the errors
    std::unique_ptr<const Trk::TrackParameters> mesTP{};
    const AmgSymMatrix(5)* pvCM  = upTP->covariance();
    if(pvCM){
      AmgSymMatrix(5) pnvCM;
      pnvCM<<
        m_errorScale[0]*m_errorScale[0]*(*pvCM)(0,0),0.,0.,0.,0.,
        0.,m_errorScale[1]*m_errorScale[1]*(*pvCM)(1,1),0.,0.,0.,
        0.,0.,m_errorScale[2]*m_errorScale[2]*(*pvCM)(2,2),0.,0.,
        0.,0.,0.,m_errorScale[3]*m_errorScale[3]*(*pvCM)(3,3),0.,
        //cppcheck-suppress constStatement
        0.,0.,0.,0.,m_errorScale[4]*m_errorScale[4]*(*pvCM)(4,4);
 
      mesTP = upTP->associatedSurface().createUniqueTrackParameters(piv[0],piv[1],piv[2],piv[3],piv[4],pnvCM);
      if(mesTP){
          ATH_MSG_DEBUG( "Initial Track Parameters at 1st SP created and scaled from TRT segment, " );
          ATH_MSG_VERBOSE( *mesTP );
      }else{
        continue;
      }
    }else{
      continue;
    }
 
    //
    // --------------- Get the Si extensions using the combinatorial track finding tool
    //
    std::vector<Amg::Vector3D> Gp;
    aTracks = m_tracksfinder->getTracks(combinatorialData, *mesTP, SpVec, Gp, DE, m_trackquality, ctx);
    if(aTracks.empty()) {
      ATH_MSG_DEBUG("No tracks found by the combinatorial track finder!");
    }
 
    //
    // --------------- Drop spurious pixel hits
    //
    cTracks=cleanTrack(aTracks);
 
    //
    // --------------- Add tracks in the track multimap and in the overall list of TRT segment associated tracks
    //
    std::list<Trk::Track*>::iterator t = cTracks.begin();
    while(t!=cTracks.end()) {
      if(!isNewTrack((*t),event_data)) {
        delete (*t);
        cTracks.erase(t++);
      } else {
        clusterTrackMap((*t),event_data);
        associatedSiTrack.push_back((*t++));
      }
    }
  }  
 
  return  associatedSiTrack;
}

getTP()

std::unique_ptr< const Trk::TrackParameters > InDet::TRT_SeededTrackFinder_ATL::getTP ( MagField::AtlasFieldCache & fieldCache, const Trk::SpacePoint * SP, const Trk::TrackParameters & startTP, bool & outl, InDet::TRT_SeededTrackFinder_ATL::EventData & event_data ) const

protected

Update track parameters through space point propagation.

Definition at line 604 of file TRT_SeededTrackFinder_ATL.cxx.

                                                                                                  {
  std::unique_ptr<const Trk::TrackParameters> iTP{};
  outl = false;
  const Trk::Surface&  surf  = SP->associatedSurface();//Get the associated surface
  Trk::PropDirection  dir   = Trk::oppositeMomentum;   //Propagate backwards i.e. opposite momentum when filtering
  Trk::ParticleHypothesis  part  = Trk::nonInteracting;//Choose a non interacting particle
  auto  eTP   = m_proptool->propagate(Gaudi::Hive::currentContext(),
                                      startTP,surf,dir,false,m_fieldprop,part); //Propagate
 
  if(!eTP){
    ATH_MSG_DEBUG( "Extrapolation to Si element failed");
    ATH_MSG_VERBOSE( surf );
    return nullptr;
  }else{
    //Based on the hit information update the track parameters and the error matrix
    Trk::FitQualityOnSurface*   sct_fitChi2 = nullptr;
    std::unique_ptr<const Trk::TrackParameters> uTP = m_updatorTool->addToState(*eTP,SP->localParameters(),SP->localCovariance(),sct_fitChi2);
    if(!uTP) { //The updator failed
      if (sct_fitChi2) {
          ATH_MSG_DEBUG( "Updator returned no update, but a DitQuality object, a leak !");
          delete sct_fitChi2;
      }
      event_data.noise().production(-1,1,*eTP);
     
      iTP = addNoise(event_data.noise(),*eTP,0);
      ATH_MSG_DEBUG("The updator failed! Count an outlier ");
      outl = true;
    }else{
      //Keep as a measurement only if fit chi2 less than 25.Otherwise outlier
      float outlierCut = m_outlierCut;
      if(!fieldCache.solenoidOn()) outlierCut = 1000000.; // Increase the outlier chi2 cut if solenoid field is OFF
      if( sct_fitChi2->chiSquared() < outlierCut && std::abs(uTP->parameters()[Trk::theta]) > 0.17 ){
        ATH_MSG_DEBUG("Update worked, will update return track parameters, chi2: "<<(sct_fitChi2->chiSquared()));
        event_data.noise().production(-1,1,*uTP);
        iTP = addNoise(event_data.noise(),*uTP,0);
      }else{
        ATH_MSG_DEBUG("Outlier, did not satisfy cuts, chi2: "<<(sct_fitChi2->chiSquared())<<" "<<std::abs(uTP->parameters()[Trk::theta]));
        event_data.noise().production(-1,1,*eTP);
        iTP = addNoise(event_data.noise(),*eTP,0);
        outl = true;
      }
      // Clean up
      delete sct_fitChi2;
    }
  }
  return iTP;
}

getTrack()

std::list< Trk::Track * > InDet::TRT_SeededTrackFinder_ATL::getTrack ( const EventContext & ctx, InDet::ITRT_SeededTrackFinder::IEventData & event_data, const Trk::TrackSegment & tS ) const

overridevirtual

Main methods for local track finding.

Main method. Calls private methods and returns a list of Si tracks

Implements InDet::ITRT_SeededTrackFinder.

Definition at line 276 of file TRT_SeededTrackFinder_ATL.cxx.

                                                                                         {
  //non-const because findTrack alters event_data
  InDet::TRT_SeededTrackFinder_ATL::EventData &event_data = EventData::getPrivateEventData(virt_event_data);
  // return list, will be copied by value (fix!)
  std::list<Trk::Track*> aSiTrack;
 
  // protection for having the expected type of segment parameters
  if ( tS.localParameters().parameterKey() != 31 ){
    ATH_MSG_WARNING("Wrong type of TRT segment, rejected !" );
    return aSiTrack;
  }
 
  //Get the track segment information and build the initial track parameters
  const Trk::LocalParameters&     Vp   = tS.localParameters();
  if (tS.associatedSurface().type() != Trk::SurfaceType::Line) {
    throw std::logic_error("Unhandled surface.");
  }
 
  const AmgSymMatrix(5)& locCov = tS.localCovariance();
  AmgSymMatrix(5) ie  = locCov;
 
  std::unique_ptr<Trk::TrackParameters> newPerPar =
    tS.associatedSurface().createUniqueTrackParameters(Vp.get(Trk::loc1),
                                      Vp.get(Trk::loc2),
                                      Vp.get(Trk::phi),
                                      Vp.get(Trk::theta),
                                      Vp.get(Trk::qOverP),
                                      ie);
 
  if(newPerPar){
    ATH_MSG_DEBUG("Initial Track Parameters created from TRT segment, ");
    ATH_MSG_VERBOSE(*newPerPar) ;
  }else{
    ATH_MSG_WARNING( "Could not get initial TRT track parameters, rejected! " );
    return aSiTrack;
  }
  constexpr auto horizontalRule{"==============================================================\n"};
  //Do the actual tracking and smoothing and get the Si track states on surface
  ATH_MSG_DEBUG(horizontalRule << "Start initial search with 3-4 SCT layer combinations ");
 
  if (m_searchInCaloROI && !isCaloCompatible( *newPerPar, event_data )) {
    return aSiTrack;
  }
 
  // Get AtlasFieldCache
  SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCondObjInputKey, ctx};
  const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
  if (fieldCondObj == nullptr) {
      ATH_MSG_ERROR("TRT_SeededTrackFinder_ATL::getTracks: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
      return aSiTrack;
  }
  MagField::AtlasFieldCache fieldCache;
  fieldCondObj->getInitializedCache (fieldCache);
 
  aSiTrack = findTrack(ctx, fieldCache, event_data, *newPerPar, tS);
  if((aSiTrack.empty())&&(m_bremCorrect)){
    ATH_MSG_DEBUG(horizontalRule << "Could not create track states on surface for this track!Try to add brem correction.");
    
    std::unique_ptr<const Trk::TrackParameters> modTP = modifyTrackParameters(*newPerPar,0);
    ATH_MSG_VERBOSE("Modified TRT Track Parameters for brem. \n"<<(*modTP));
    aSiTrack = findTrack(ctx, fieldCache, event_data, *modTP, tS);
    if(aSiTrack.empty()){
      ATH_MSG_DEBUG("Could not create track states on surface for this track after all!");
      return aSiTrack;
    }
    ATH_MSG_DEBUG(horizontalRule);
  }
 
  //Return list of tracks (by value !?)
  return aSiTrack;
}

initialize()

StatusCode InDet::TRT_SeededTrackFinder_ATL::initialize ( )

overridevirtual

Implements InDet::ITRT_SeededTrackFinder.

Definition at line 91 of file TRT_SeededTrackFinder_ATL.cxx.

                                          {
 
  ATH_MSG_DEBUG("Initializing TRT_SeededTrackFinder_ATL");
  magneticFieldInit();
  ATH_CHECK( m_fieldCondObjInputKey.initialize());
 
  // Get propagator tool
  ATH_CHECK(m_proptool.retrieve());
  
  // Get updator tool
  ATH_CHECK(m_updatorTool.retrieve());
  
  // Get detector elements road maker tool
  ATH_CHECK(m_roadmaker.retrieve());
 
  // Get seeds maker tool
  ATH_CHECK(m_seedmaker.retrieve());
 
  // Get combinatorial track finder tool
  ATH_CHECK( m_tracksfinder.retrieve());
 
  // Set track quality cuts for track finding tool
  setTrackQualityCuts();
 
  ATH_CHECK( detStore()->retrieve(m_trtId, "TRT_ID"));
  
  // Get output print level
  if(msgLvl(MSG::DEBUG)){ dumpconditions(msg(MSG::DEBUG));  msg(MSG::DEBUG) << endmsg;}
 
  //initlialize readhandlekey
  ATH_CHECK(m_caloClusterROIKey.initialize(m_searchInCaloROI));
 
  return StatusCode::SUCCESS;
 
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

interfaceID()

const InterfaceID & InDet::ITRT_SeededTrackFinder::interfaceID ( )

inlinestaticinherited

Definition at line 91 of file ITRT_SeededTrackFinder.h.

    {
      return IID_ITRT_SeededTrackFinder;
    }

isCaloCompatible()

bool InDet::TRT_SeededTrackFinder_ATL::isCaloCompatible ( const Trk::TrackParameters & Tp, const InDet::TRT_SeededTrackFinder_ATL::EventData & event_data ) const

protected

Only propagate to the Si if the TRT segment is compatible with a calo measurement.

Definition at line 1046 of file TRT_SeededTrackFinder_ATL.cxx.

                                                                  {
   if(!event_data.caloClusterROIEM()) return false;
   const AmgVector(5)& Vp = Tp.parameters();
   const double F = Vp[2];
   ROIPhiRZContainer::const_iterator roi_iter = event_data.caloClusterROIEM()->lowerPhiBound( F, m_phiWidth);
   return roi_iter != event_data.caloClusterROIEM()->end();
}

isNewTrack()

bool InDet::TRT_SeededTrackFinder_ATL::isNewTrack ( Trk::Track * Tr, InDet::TRT_SeededTrackFinder_ATL::EventData & event_data )

staticprotected

Clean-up duplicate tracks.

Definition at line 944 of file TRT_SeededTrackFinder_ATL.cxx.

                                                                                 {
 
  const Trk::PrepRawData* prd   [100];
  std::multimap<const Trk::PrepRawData*,const Trk::Track*>::const_iterator
     ti,t[100],te = event_data.clusterTrack().end();
  int n = 0    ;
  DataVector<const Trk::MeasurementBase>::const_iterator
    m  = Tr->measurementsOnTrack()->begin(),
    me = Tr->measurementsOnTrack()->end  ();
 
  for(; m!=me; ++m) {
    const Trk::PrepRawData* pr = ((const Trk::RIO_OnTrack*)(*m))->prepRawData();
    if(pr) {
      prd[n] =pr;
      t[n] = event_data.clusterTrack().find(prd[n]); 
      if(t[n]==te) return true; 
      ++n;
    }
  }
 
  int nclt = n;
 
  for(int i=0; i!=n; ++i) {
    int nclmax = 0;
    for(ti=t[i]; ti!=te; ++ti) {
      if( (*ti).first != prd[i] ) break;
      int ncl = (*ti).second->trackStateOnSurfaces()->size();
      if(ncl > nclmax) nclmax = ncl;
    }
    if(nclt > nclmax) return true;
  }
  return false;
}

magneticFieldInit()

void InDet::TRT_SeededTrackFinder_ATL::magneticFieldInit ( )

protected

Private Methods.

Get Magnetic field properties

Definition at line 1060 of file TRT_SeededTrackFinder_ATL.cxx.

                                                 {
 if(m_fieldmode == "NoField") m_fieldprop = Trk::MagneticFieldProperties(Trk::NoField  );
 else if(m_fieldmode == "MapSolenoid") m_fieldprop = Trk::MagneticFieldProperties(Trk::FastField);
 else m_fieldprop = Trk::MagneticFieldProperties(Trk::FullField);
}

modifyTrackParameters()

std::unique_ptr< const Trk::TrackParameters > InDet::TRT_SeededTrackFinder_ATL::modifyTrackParameters ( const Trk::TrackParameters & TP, int mode )

staticprotected

Modify track parameters if brem correction.

The mode corresponds to whether the track parameters are modified before the seed (0) or before the pixel propagation (1)
Get the track parameters

Correct inverse momentum and covariance. Inverse momentum halved, i.e. momentum doubled

Definition at line 733 of file TRT_SeededTrackFinder_ATL.cxx.

                                                                                           {
  const AmgVector(5)& pV = TP.parameters();
  double ip[5] = {pV[0], pV[1], pV[2], pV[3], pV[4]};

  const double & q = ip[4]; //no need to take std::abs, its squared next
  const double covarianceIMom = 0.25*q*q;
  ip[4] *= 0.5;
 
  const AmgSymMatrix(5) * CM = TP.covariance();
  AmgSymMatrix(5)        nM = (*CM);
 
  if(mode==0){ //Modification initiated before seed propagation
    nM(4,4) = 10.*(0.1*((*CM)(4,4))+covarianceIMom);
  }
  if(mode==1){  //Modification initiated before pixel propagation
    nM(4,4)+=covarianceIMom;
  }
  return TP.associatedSurface().createUniqueTrackParameters(ip[0], ip[1], ip[2], ip[3], ip[4], nM);  
}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

newClusters()

bool InDet::TRT_SeededTrackFinder_ATL::newClusters ( const std::vector< const Trk::SpacePoint * > & Sp, InDet::TRT_SeededTrackFinder_ATL::EventData & event_data )

staticprotected

Seed used by another track?

Definition at line 802 of file TRT_SeededTrackFinder_ATL.cxx.

                                                                                        {
  const Trk::PrepRawData* prd   [ 40];
  const Trk::Track*       trk[2][200];
  std::multimap<const Trk::PrepRawData*,const Trk::Track*>::const_iterator
     t[40],te = event_data.clusterTrack().end();
  std::vector<const Trk::SpacePoint*>::const_iterator s=Sp.begin(),se=Sp.end();
  int n = 0;
 
  //If at least one of the clusters in the seed is not used by a track the seed is good
  for(; s!=se; ++s) {
     if((*s)->clusterList().first ) {
       prd[n] = (*s)->clusterList().first;
       t  [n] = event_data.clusterTrack().find(prd[n]); 
       if(t[n]==te) return true; 
       ++n;
     }
     if((*s)->clusterList().second) {
       prd[n] = (*s)->clusterList().second;
       t  [n] = event_data.clusterTrack().find(prd[n]); 
       if(t[n]==te) return true; 
       ++n;
     }
     if(n==40) break;
  }
  if(!n) return false;
 
  //Array of pointers to the different tracks that the first used cluster belongs to
  int m = 0;
  auto & pTracks=t[0];
  for(; pTracks!=te; ++pTracks) {
    if (m==30) return false;
    if( (*pTracks).first != prd[0] ) break;
    trk[0][m++] = (*pTracks).second;
    if(m==200) break;
  }
 
  //For a seed to be declared bad, all other clusters should belong to the same track as that of the first used cluster
  int in=0, ou=1;
  for(int i=1; i!=n; ++i) {
    int l = 0; //Number of tracks that share the same clusters
    auto & pTheseTracks=t[i];
    for(; pTheseTracks!=te; ++pTheseTracks) {
      if( (*pTheseTracks).first != prd[i] ) break;
      for(int j=0; j!=m; ++j) {
        if((*pTheseTracks).second == trk[in][j]) {trk[ou][l++]= trk[in][j]; 
          break;
        }
      }
    }
    if(l==0) return true; //At least one of the seed clusters belongs to a track different from that of the first used clusters
    m=l; 
    if(in==0) {
      in=1; ou=0;
    } else {
      in=0; ou=1;
    }
  }
 
  return false;
}

newEvent()

std::unique_ptr< InDet::ITRT_SeededTrackFinder::IEventData > InDet::TRT_SeededTrackFinder_ATL::newEvent ( const EventContext & ctx, SiCombinatorialTrackFinderData_xk & combinatorialData ) const

overridevirtual

New event initialization.

Get the seeds

Implements InDet::ITRT_SeededTrackFinder.

Definition at line 210 of file TRT_SeededTrackFinder_ATL.cxx.

{

  auto event_data_p = std::make_unique<InDet::TRT_SeededTrackFinder_ATL::EventData>(combinatorialData,
                                                                                  m_seedmaker->newEvent());
  // New event for track finder tool
  m_tracksfinder->newEvent(ctx, event_data_p->combinatorialData());
 
  // Print event information
  if(msgLvl(MSG::DEBUG)) {
     dumpconditions(msg(MSG::DEBUG)); 
     msg(MSG::DEBUG) << endmsg;
  }
 
  //  Get the calo ROI:
  if(m_searchInCaloROI ) {
    SG::ReadHandle<ROIPhiRZContainer> calo_rois(m_caloClusterROIKey, ctx);
    if (!calo_rois.isValid()) {
       ATH_MSG_FATAL("Failed to get EM Calo cluster collection " << m_caloClusterROIKey );
    }
    event_data_p->setCaloClusterROIEM(*calo_rois);
  }
  return event_data_p;
}

newRegion()

std::unique_ptr< InDet::ITRT_SeededTrackFinder::IEventData > InDet::TRT_SeededTrackFinder_ATL::newRegion ( const EventContext & ctx, SiCombinatorialTrackFinderData_xk & combinatorialData, const std::vector< IdentifierHash > & listOfPixIds, const std::vector< IdentifierHash > & listOfSCTIds ) const

overridevirtual

New region intialization.

Implements InDet::ITRT_SeededTrackFinder.

Definition at line 238 of file TRT_SeededTrackFinder_ATL.cxx.

                                                                                                {
  auto event_data_p = std::make_unique<InDet::TRT_SeededTrackFinder_ATL::EventData>(combinatorialData,
                                                      m_seedmaker->newRegion(listOfPixIds,listOfSCTIds));
 
  // New event for track finder tool
  m_tracksfinder->newEvent(ctx, event_data_p->combinatorialData());
 
 
  // Print event information
  if(msgLvl(MSG::DEBUG)) {
     dumpconditions(msg(MSG::DEBUG)); 
     msg(MSG::DEBUG) << endmsg;
  }
 
  return event_data_p;
}

newSeed()

bool InDet::TRT_SeededTrackFinder_ATL::newSeed ( const std::vector< const Trk::SpacePoint * > & Sp, InDet::TRT_SeededTrackFinder_ATL::EventData & event_data )

staticprotected

Seed SPs used by other high quality tracks?

Definition at line 870 of file TRT_SeededTrackFinder_ATL.cxx.

                                                                                    {
  const Trk::PrepRawData* prd   [ 40];
  const Trk::Track*       trk[2][200];
  std::multimap<const Trk::PrepRawData*,const Trk::Track*>::const_iterator
     tt,t[40],te = event_data.clusterTrack().end();
 
  std::vector<const Trk::SpacePoint*>::const_iterator s=Sp.begin(),se=Sp.end();
  int n  = 0;
  int nc = 0;
  for(; s!=se; ++s) {
     if((*s)->clusterList().first ) {
       prd[n] = (*s)->clusterList().first;
       t  [n] = event_data.clusterTrack().find(prd[n]); if(t[n]!=te) ++nc; ++n;
     }
     if((*s)->clusterList().second) {
       prd[n] = (*s)->clusterList().second;
       t  [n] = event_data.clusterTrack().find(prd[n]); if(t[n]!=te) ++nc; ++n;
     }
     if(n>=40) break;
  }
  if(!nc) return true;
  if(n==nc) {
    int m = 0;
    for(tt=t[0]; tt!=te; ++tt) {
      if( (*tt).first != prd[0] ) break;
      trk[0][m++] = (*tt).second;
      if(m==200) break;
    }
    int in=0, ou=1, i=1;
    for(; i!=n; ++i) {
      int l = 0;
      for(tt=t[i]; t[i]!=te; ++tt) {
          if( (*tt).first != prd[i] ) break;
          for(int j=0; j!=m; ++j) {
            if((*tt).second == trk[in][j]) {
              trk[ou][l++]= trk[in][j]; 
              break;
            }
          }
      }
      if(l==0) break;
      m=l; 
      if(in==0) {
        in=1; 
        ou=0;
      } else {
        in=0;
        ou=1;
      }
    }
    if(i==n) return false;
  }
 
  //if(!(*Sp.rbegin())->clusterList().second) return true;
 
  int h = 0;
  for(int i=0; i!=n; ++i) {
    for(tt=t[i]; t[i]!=te; ++tt) {
      if( (*tt).first != prd[i] ) break;
      if((*tt).second->trackStateOnSurfaces()->size() >= 10) {
        ++h; 
        break;
      }
    }
  }
  return h == 0;
}

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setTrackQualityCuts()

void InDet::TRT_SeededTrackFinder_ATL::setTrackQualityCuts ( )

protected

Set the track quality cuts for combinatorial track finding.

Definition at line 761 of file TRT_SeededTrackFinder_ATL.cxx.

                                                   {
  // Integer cuts
  //
  m_trackquality.setIntCut   ("MinNumberOfClusters",  m_nclusmin   );
  m_trackquality.setIntCut   ("MinNumberOfWClusters", m_nwclusmin  );
  m_trackquality.setIntCut   ("MaxNumberOfHoles"   ,  m_nholesmax  );
  m_trackquality.setIntCut   ("MaxHolesGap"        ,  m_dholesmax  );
  if( m_useassoTool ) m_trackquality.setIntCut   ("UseAssociationTool",1);
  else                m_trackquality.setIntCut   ("UseAssociationTool",0);
 
  // Double cuts
  //
  m_trackquality.setDoubleCut("pTmin"              ,m_pTmin      );
  m_trackquality.setDoubleCut("MaxXi2forCluster"   ,m_xi2max     );
  m_trackquality.setDoubleCut("MaxXi2forOutlier"   ,m_xi2maxNoAdd);
  m_trackquality.setDoubleCut("MaxXi2forSearch"    ,m_xi2maxlink );
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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

m_bremCorrect

BooleanProperty InDet::TRT_SeededTrackFinder_ATL::m_bremCorrect

protected

Initial value:

{this, "BremCorrection", false,
    "Optional Brem correction"}

Definition at line 199 of file TRT_SeededTrackFinder_ATL.h.

                                   {this, "BremCorrection", false,
    "Optional Brem correction"};

m_caloClusterROIKey

SG::ReadHandleKey<ROIPhiRZContainer> InDet::TRT_SeededTrackFinder_ATL::m_caloClusterROIKey {this, "EMROIPhiRZContainer", ""}

protected

Definition at line 213 of file TRT_SeededTrackFinder_ATL.h.

{this, "EMROIPhiRZContainer", ""};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_dholesmax

IntegerProperty InDet::TRT_SeededTrackFinder_ATL::m_dholesmax

protected

Initial value:

{this, "nHolesGapMax", 1,
    "Max gap between holes"}

Definition at line 194 of file TRT_SeededTrackFinder_ATL.h.

                                 {this, "nHolesGapMax", 1,
    "Max gap between holes"};

m_errorScale

DoubleArrayProperty InDet::TRT_SeededTrackFinder_ATL::m_errorScale

protected

Initial value:

{this, "ErrorScaling", {1., 1., 1., 1., 1.},
     "Optional error scaling of track parameters"}

Definition at line 206 of file TRT_SeededTrackFinder_ATL.h.

    {this, "ErrorScaling", {1., 1., 1., 1., 1.},
     "Optional error scaling of track parameters"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_fieldCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> InDet::TRT_SeededTrackFinder_ATL::m_fieldCondObjInputKey

protected

Initial value:

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

Definition at line 180 of file TRT_SeededTrackFinder_ATL.h.

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

m_fieldmode

StringProperty InDet::TRT_SeededTrackFinder_ATL::m_fieldmode

protected

Initial value:

{this, "MagneticFieldMode", "MapSolenoid",
    "Magnetic field mode"}

Protected Data.

Definition at line 162 of file TRT_SeededTrackFinder_ATL.h.

                                {this, "MagneticFieldMode", "MapSolenoid",
    "Magnetic field mode"};

m_fieldprop

Trk::MagneticFieldProperties InDet::TRT_SeededTrackFinder_ATL::m_fieldprop

protected

Definition at line 165 of file TRT_SeededTrackFinder_ATL.h.

m_nclusmin

IntegerProperty InDet::TRT_SeededTrackFinder_ATL::m_nclusmin {this, "nClustersMin", 4, "Min number clusters"}

protected

Definition at line 196 of file TRT_SeededTrackFinder_ATL.h.

{this, "nClustersMin", 4, "Min number clusters"};

m_nholesmax

IntegerProperty InDet::TRT_SeededTrackFinder_ATL::m_nholesmax {this, "nHolesMax", 1, "Max number holes"}

protected

Definition at line 193 of file TRT_SeededTrackFinder_ATL.h.

{this, "nHolesMax", 1, "Max number holes"};

m_nwclusmin

IntegerProperty InDet::TRT_SeededTrackFinder_ATL::m_nwclusmin

protected

Initial value:

{this, "nWClustersMin", 4,
    "Min number weighted clusters"}

Definition at line 197 of file TRT_SeededTrackFinder_ATL.h.

                                 {this, "nWClustersMin", 4,
    "Min number weighted clusters"};

m_outlierCut

DoubleProperty InDet::TRT_SeededTrackFinder_ATL::m_outlierCut

protected

Initial value:

{this, "OutlierCut", 25.,
    "Outlier chi2 cut when propagating through the seed"}

Definition at line 209 of file TRT_SeededTrackFinder_ATL.h.

                                 {this, "OutlierCut", 25.,
    "Outlier chi2 cut when propagating through the seed"};

m_phiWidth

DoubleProperty InDet::TRT_SeededTrackFinder_ATL::m_phiWidth {this, "phiWidth", 0.3}

protected

Definition at line 277 of file TRT_SeededTrackFinder_ATL.h.

{this, "phiWidth", 0.3};

m_propR

BooleanProperty InDet::TRT_SeededTrackFinder_ATL::m_propR

protected

Initial value:

{this, "ConsistentSeeds", false,
    "Check seed-TRT segment consistency at large eta"}

Definition at line 201 of file TRT_SeededTrackFinder_ATL.h.

                             {this, "ConsistentSeeds", false,
    "Check seed-TRT segment consistency at large eta"};

m_proptool

ToolHandle<Trk::IPropagator> InDet::TRT_SeededTrackFinder_ATL::m_proptool {this, "PropagatorTool", "Trk::RungeKuttaPropagator/InDetPropagator"}

protected

Definition at line 173 of file TRT_SeededTrackFinder_ATL.h.

{this, "PropagatorTool", "Trk::RungeKuttaPropagator/InDetPropagator"};

m_pTmin

DoubleProperty InDet::TRT_SeededTrackFinder_ATL::m_pTmin {this, "pTmin", 500., "min pT"}

protected

Definition at line 192 of file TRT_SeededTrackFinder_ATL.h.

{this, "pTmin", 500., "min pT"};

m_roadmaker

ToolHandle<InDet::ISiDetElementsRoadMaker> InDet::TRT_SeededTrackFinder_ATL::m_roadmaker {this, "RoadTool", "InDet::SiDetElementsRoadMaker_xk"}

protected

Magnetic field properties.

Tools used

Definition at line 169 of file TRT_SeededTrackFinder_ATL.h.

{this, "RoadTool", "InDet::SiDetElementsRoadMaker_xk"};

m_searchInCaloROI

BooleanProperty InDet::TRT_SeededTrackFinder_ATL::m_searchInCaloROI

protected

Initial value:

{this, "SearchInCaloROI", false,
    "Outlier chi2 cut when propagating through the seed"}

Definition at line 211 of file TRT_SeededTrackFinder_ATL.h.

                                       {this, "SearchInCaloROI", false,
    "Outlier chi2 cut when propagating through the seed"};

m_seedmaker

ToolHandle<InDet::ITRT_SeededSpacePointFinder> InDet::TRT_SeededTrackFinder_ATL::m_seedmaker {this, "SeedTool", ""}

protected

Definition at line 171 of file TRT_SeededTrackFinder_ATL.h.

{this, "SeedTool", ""};

m_trackquality

InDet::TrackQualityCuts InDet::TRT_SeededTrackFinder_ATL::m_trackquality

protected

Definition at line 205 of file TRT_SeededTrackFinder_ATL.h.

m_tracksfinder

ToolHandle<InDet::ISiCombinatorialTrackFinder> InDet::TRT_SeededTrackFinder_ATL::m_tracksfinder {this, "CombinatorialTrackFinder", "InDet::SiCombinatorialTrackFinder_xk"}

protected

Definition at line 177 of file TRT_SeededTrackFinder_ATL.h.

{this, "CombinatorialTrackFinder", "InDet::SiCombinatorialTrackFinder_xk"};

m_trtId

const TRT_ID* InDet::TRT_SeededTrackFinder_ATL::m_trtId = nullptr

protected

ID TRT helper.

Definition at line 184 of file TRT_SeededTrackFinder_ATL.h.

m_updatorTool

ToolHandle<Trk::IUpdator> InDet::TRT_SeededTrackFinder_ATL::m_updatorTool {this, "UpdatorTool", "Trk::KalmanUpdator_xk/InDetPatternUpdator"}

protected

Definition at line 175 of file TRT_SeededTrackFinder_ATL.h.

{this, "UpdatorTool", "Trk::KalmanUpdator_xk/InDetPatternUpdator"};

m_useassoTool

BooleanProperty InDet::TRT_SeededTrackFinder_ATL::m_useassoTool

protected

Initial value:

{this, "UseAssociationTool", false,
    "Use prd-track association tool"}

Definition at line 203 of file TRT_SeededTrackFinder_ATL.h.

                                   {this, "UseAssociationTool", false,
    "Use prd-track association tool"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_xi2max

DoubleProperty InDet::TRT_SeededTrackFinder_ATL::m_xi2max {this, "Xi2max", 15., "max Xi2 for updators"}

protected

Track quality cuts to be passed to the combinatorial track finder.

Definition at line 187 of file TRT_SeededTrackFinder_ATL.h.

{this, "Xi2max", 15., "max Xi2 for updators"};

m_xi2maxlink

DoubleProperty InDet::TRT_SeededTrackFinder_ATL::m_xi2maxlink

protected

Initial value:

{this, "Xi2maxlink", 100.,
    "max Xi2 for clusters"}

Definition at line 190 of file TRT_SeededTrackFinder_ATL.h.

                                 {this, "Xi2maxlink", 100.,
    "max Xi2 for clusters"};

m_xi2maxNoAdd

DoubleProperty InDet::TRT_SeededTrackFinder_ATL::m_xi2maxNoAdd

protected

Initial value:

{this, "Xi2maxNoAdd", 50.,
    "max Xi2 for outliers"}

Definition at line 188 of file TRT_SeededTrackFinder_ATL.h.

                                  {this, "Xi2maxNoAdd", 50.,
    "max Xi2 for outliers"};

---

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

• TRT_SeededTrackFinder_ATL.h
• TRT_SeededTrackFinder_ATL.cxx