InDet::TrackPairsSelector Class Reference

This class selects track pairs for conversion finder. More...

#include <TrackPairsSelector.h>

Inheritance diagram for InDet::TrackPairsSelector:

Collaboration diagram for InDet::TrackPairsSelector:

Classes
struct	Cache

Public Member Functions
	TrackPairsSelector (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~TrackPairsSelector ()=default
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
bool	selectTrackParticlePair (const xAOD::TrackParticle *trkPpos, const xAOD::TrackParticle *trkPneg, Cache &cache) const
	Track pair selectors.Return true if the argument track fulfills the selection.
bool	selectTrackPair (const Trk::Track *trkpos, const Trk::Track *trkneg) const
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 ()
static std::map< std::string, float >	getLastValues (const Cache &cache)
	Return a map with the values calculated for the last pair to decorate the vertex once it is created.

Protected Member Functions
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.

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
ToolHandle< InDet::ConversionFinderUtils >	m_helpertool
	Conversion helper tool.
ToolHandle< Trk::ITrkDistanceFinder >	m_distanceTool
	Distance of minimum approach tool.
DoubleProperty	m_maxR
	Properties for track selection: all cuts are ANDed.
DoubleProperty	m_MinTrkAngle
DoubleArrayProperty	m_maxDist
DoubleArrayProperty	m_etaCut
DoubleArrayProperty	m_initCut
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

This class selects track pairs for conversion finder.

Author

Tatjana Lenz, Thomas Koffas

Definition at line 26 of file TrackPairsSelector.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

TrackPairsSelector()

InDet::TrackPairsSelector::TrackPairsSelector	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 40 of file TrackPairsSelector.cxx.

    : AthAlgTool(type, name, parent)
  {
    declareInterface<TrackPairsSelector>(this);
  }

~TrackPairsSelector()

virtual InDet::TrackPairsSelector::~TrackPairsSelector ( )

virtualdefault

Member Function Documentation

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

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::TrackPairsSelector::finalize ( )

overridevirtual

Definition at line 75 of file TrackPairsSelector.cxx.

                                          {
    return StatusCode::SUCCESS;
  }

getLastValues()

std::map< std::string, float > InDet::TrackPairsSelector::getLastValues ( const Cache & cache )

static

Return a map with the values calculated for the last pair to decorate the vertex once it is created.

Definition at line 291 of file TrackPairsSelector.cxx.

  {
    return {{"minimumDistanceTrk", cache.m_distance},
            {"deltaCotThetaTrk", cache.m_deltaCotTheta},
            {"deltaInitRadius", cache.m_deltaInit} };
  }

initialize()

StatusCode InDet::TrackPairsSelector::initialize ( )

overridevirtual

Definition at line 54 of file TrackPairsSelector.cxx.

                                            {
 
    /* Get the track selector tool from ToolSvc */
    if ( m_helpertool.retrieve().isFailure() ) {
      ATH_MSG_ERROR("Failed to retrieve tool " << m_helpertool);
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("Retrieved tool " << m_helpertool);
 
    /* Get the distance tool from ToolsSvc */
    if(m_distanceTool.retrieve().isFailure()) {
      ATH_MSG_ERROR("Could not get " << m_distanceTool);
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("Got the distance tool " << m_distanceTool);
 
    ATH_MSG_DEBUG("Initialization successful");
    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::TrackPairsSelector::interfaceID ( )

static

Definition at line 49 of file TrackPairsSelector.cxx.

                                                     {
    return IID_ITrackPairsSelector;
  }

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);
  }

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();
  }

selectTrackPair()

bool InDet::TrackPairsSelector::selectTrackPair	(	const Trk::Track *	trkpos,
		const Trk::Track *	trkneg ) const

Getting the track perigee parameters

Position of initial hit of the two tracks

Definition at line 211 of file TrackPairsSelector.cxx.

  {
 
    bool pass = true;
    const Trk::Perigee* perPos = trkpos->perigeeParameters();
    const Trk::Perigee* perNeg = trkneg->perigeeParameters();
    if (!(InDet::ConversionFinderUtils::momFraction(perPos, perNeg))) pass = false;

    double init_pos = 0.; double init_neg = 0.;
    const DataVector<const Trk::MeasurementBase>* mb_pos = trkpos->measurementsOnTrack();
    const DataVector<const Trk::MeasurementBase>* mb_neg = trkneg->measurementsOnTrack();
    if(!mb_pos || !mb_neg) {pass = false; return pass;}
    DataVector<const Trk::MeasurementBase>::const_iterator itp_pos=mb_pos->begin();
    init_pos = (*itp_pos)->globalPosition().perp();
    DataVector<const Trk::MeasurementBase>::const_iterator itp_neg=mb_neg->begin();
    init_neg = (*itp_neg)->globalPosition().perp();
    int sCase = 100;
    if (init_neg<=m_maxR && init_pos<=m_maxR)  sCase = 0;
    if ((init_neg<=m_maxR && init_pos>m_maxR) || (init_neg>m_maxR && init_pos<=m_maxR))   sCase = 1;
    if (init_neg>m_maxR && init_pos>m_maxR) sCase = 2;
 
    //Cut on Deta
    double detaCut = 0.0;
    if(sCase == 0) {
      detaCut = m_etaCut[0];
    } else if(sCase == 1) {
      detaCut = m_etaCut[1];
    } else if(sCase == 2) {
      detaCut = m_etaCut[2];
    }
 
    if (fabs(1. / tan(perPos->parameters()[Trk::theta]) -
             1. / tan(perNeg->parameters()[Trk::theta])) > detaCut)
      pass = false;
 
    //Cut on distance between the initial hit position of the two tracks.
    double dinit = 1000.;
    if(sCase == 0) {
      dinit = m_initCut[0];
    } else if(sCase == 1) {
      dinit = m_initCut[1];
    } else if(sCase == 2) {
      dinit = m_initCut[2];
    }
    if(fabs(init_pos - init_neg) > dinit) pass = false;
 
    //Cut on distance of minimum approach between the two tracks.
    double maxDist = 1000.;
    if(sCase == 0) {
      maxDist = m_maxDist[0];
    } else if(sCase == 1) {
      maxDist = m_maxDist[1];
    } else if(sCase == 2) {
      maxDist = m_maxDist[2];
    }
 
    double newDistance = 1000000.;
    std::optional<Trk::ITrkDistanceFinder::TwoPoints> result
      = m_distanceTool->CalculateMinimumDistance(*trkpos, *trkneg);
    if (!result) {
      pass = false;
    }
    else {
      newDistance = dist (result.value());
      if (newDistance>maxDist) pass = false;
    }
 
    //3D angle cut in the case of V0s, not used in the case of conversions
    double d_beta = (perPos->momentum().dot(perNeg->momentum())) /
                    (perPos->momentum().mag() * perNeg->momentum().mag());
    if(d_beta <m_MinTrkAngle) pass = false;
 
    return pass;
  }

selectTrackParticlePair()

bool InDet::TrackPairsSelector::selectTrackParticlePair	(	const xAOD::TrackParticle *	trkPpos,
		const xAOD::TrackParticle *	trkPneg,
		TrackPairsSelector::Cache &	cache ) const

Track pair selectors.Return true if the argument track fulfills the selection.

Definition at line 81 of file TrackPairsSelector.cxx.

  {
 
    bool pass = true;
    //Getting the track perigee parameters
    const Trk::TrackParameters* perPos = &(trkPpos->perigeeParameters());
    const Trk::TrackParameters* perNeg = &(trkPneg->perigeeParameters());
    if (!(InDet::ConversionFinderUtils::momFraction(perPos, perNeg))) pass = false;
 
    //Track summary information
 
 
    uint8_t nclusPos(0);
    uint8_t dummy(0);
    if(trkPpos->summaryValue(dummy,xAOD::numberOfSCTHits)){
      nclusPos += dummy;
    }
    if(trkPpos->summaryValue(dummy,xAOD::numberOfPixelHits)){
      nclusPos += dummy;
    }
 
    uint8_t nclusNeg(0);
    if(trkPneg->summaryValue(dummy,xAOD::numberOfSCTHits)){
      nclusNeg += dummy;
    }
    if(trkPneg->summaryValue(dummy,xAOD::numberOfPixelHits)){
      nclusNeg += dummy;
    }
 
 
    int sCase = 100;
    if(nclusNeg>0 && nclusPos>0)                                   sCase = 0;
    if((nclusNeg>0 && nclusPos==0) || (nclusNeg==0 && nclusPos>0)) sCase = 1;
    if(nclusNeg==0 && nclusPos==0)                                 sCase = 2;
 
    //Position of first hit in track particle
    Trk::CurvilinearParameters parPos;
    Trk::CurvilinearParameters parNeg;
 
    int index(-1);
    for(unsigned int i(0); i< trkPpos->numberOfParameters() ; ++i ){
      if( xAOD::FirstMeasurement == trkPpos->parameterPosition(i) ){
        index = i;
        break;
      }
    }
    if(index!=-1){
      parPos = trkPpos->curvilinearParameters(index);
    } else {
      ATH_MSG_WARNING("Track Particle does not contain first Measurement track parameters");
      return false;
    }
 
    index = -1;
    for(unsigned int i(0); i< trkPneg->numberOfParameters() ; ++i ){
      if( xAOD::FirstMeasurement == trkPneg->parameterPosition(i) ){
        index = i;
        break;
      }
    }
    if(index!=-1){
      parNeg = trkPneg->curvilinearParameters(index);
    } else {
      ATH_MSG_WARNING("Track Particle does not contain first Measurement track parameters");
      return false;
    }
 
    double firstRpos = parPos.position().perp();
    double firstRneg = parNeg.position().perp();
 
    //Cut on Deta
    double detaCut = 0.0;
    if(sCase == 0) {
      detaCut = m_etaCut[0];
    } else if(sCase == 1) {
      detaCut = m_etaCut[1];
    } else if(sCase == 2) {
      if(fabs(perPos->eta())<0.6 && fabs(perNeg->eta())<0.6) detaCut = 10000.; // No eta cut for barrel TRT tracks
      else                                                   detaCut = m_etaCut[2];
    }
 
    cache.m_deltaCotTheta = fabs(1. / tan(perPos->parameters()[Trk::theta]) -
                                 1. / tan(perNeg->parameters()[Trk::theta]));
    if (cache.m_deltaCotTheta > detaCut)
      return false;
 
    //Cut on distance between the initial hit position of the two tracks.
    double dinit = 1000.;
    if(sCase == 0) {
      dinit = m_initCut[0];
    } else if(sCase == 1) {
      dinit = m_initCut[1];
    } else if(sCase == 2) {
      dinit = m_initCut[2];
    }
 
    cache.m_deltaInit = fabs(firstRpos - firstRneg);
    if (cache.m_deltaInit > dinit) return false;
 
    //Cut on distance of minimum approach between the two tracks.
    double maxDist = 1000.;
    if(sCase == 0) {
      maxDist = m_maxDist[0];
    } else if(sCase == 1) {
      maxDist = m_maxDist[1];
    } else if(sCase == 2) {
      maxDist = m_maxDist[2];
    }
 
    cache.m_distance = 1000000.;
    std::optional<Trk::ITrkDistanceFinder::TwoPoints> result
      = m_distanceTool->CalculateMinimumDistance(trkPneg->perigeeParameters(),
                                                 trkPpos->perigeeParameters() );
    if (!result) return false;
    cache.m_distance = dist (result.value());
    if (cache.m_distance>maxDist) return false;
 
    //3D angle cut in the case of V0s, not used in the case of conversions
    double d_beta = (perPos->momentum().dot(perNeg->momentum())) /
                    (perPos->momentum().mag() * perNeg->momentum().mag());
    if(d_beta <m_MinTrkAngle) pass = false;
 
    return pass;
  }

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

ToolHandle<Trk::ITrkDistanceFinder> InDet::TrackPairsSelector::m_distanceTool

private

Initial value:

{
    this,
    "DistanceTool",
    "Trk::SeedNewtonTrkDistanceFinder",
    "Distance of minimum approach tool"
  }

Distance of minimum approach tool.

Definition at line 73 of file TrackPairsSelector.h.

                                                  {
    this,
    "DistanceTool",
    "Trk::SeedNewtonTrkDistanceFinder",
    "Distance of minimum approach tool"
  };

m_etaCut

DoubleArrayProperty InDet::TrackPairsSelector::m_etaCut

private

Initial value:

{this, "MaxEta", {0.8, 1.2, 1.2},
     "Maximum eta difference between tracks in pair"}

Definition at line 90 of file TrackPairsSelector.h.

    {this, "MaxEta", {0.8, 1.2, 1.2},
     "Maximum eta difference between tracks in pair"};

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_helpertool

ToolHandle<InDet::ConversionFinderUtils> InDet::TrackPairsSelector::m_helpertool

private

Initial value:

{
    this,
    "ConversionFinderHelperTool",
    "InDet::ConversionFinderUtils",
    "Conversion helper tool"
  }

Conversion helper tool.

Definition at line 66 of file TrackPairsSelector.h.

                                                     {
    this,
    "ConversionFinderHelperTool",
    "InDet::ConversionFinderUtils",
    "Conversion helper tool"
  };

m_initCut

DoubleArrayProperty InDet::TrackPairsSelector::m_initCut

private

Initial value:

{this, "MaxInitDistance", {10000., 10000., 10000.},
     "Maximum distance difference between initial  hits of tracks in pair"}

Definition at line 93 of file TrackPairsSelector.h.

    {this, "MaxInitDistance", {10000., 10000., 10000.},
     "Maximum distance difference between initial  hits of tracks in pair"};

m_maxDist

DoubleArrayProperty InDet::TrackPairsSelector::m_maxDist

private

Initial value:

{this, "MaxDistBetweenTracks", {8., 80., 45.},
     "Maximum allowed distance of minimum approach"}

Definition at line 87 of file TrackPairsSelector.h.

    {this, "MaxDistBetweenTracks", {8., 80., 45.},
     "Maximum allowed distance of minimum approach"};

m_maxR

DoubleProperty InDet::TrackPairsSelector::m_maxR

private

Initial value:

{this, "MaxFirstHitRadius", 500.,
     "Maximum initial hit radius in order to apply the impact point cut"}

Properties for track selection: all cuts are ANDed.

Definition at line 81 of file TrackPairsSelector.h.

    {this, "MaxFirstHitRadius", 500.,
     "Maximum initial hit radius in order to apply the impact point cut"};

m_MinTrkAngle

DoubleProperty InDet::TrackPairsSelector::m_MinTrkAngle

private

Initial value:

{this, "MinTrackAngle", 0.,
     "Minimum allowed angle between decay tracks. Used only in V0 reconstruction."}

Definition at line 84 of file TrackPairsSelector.h.

    {this, "MinTrackAngle", 0.,
     "Minimum allowed angle between decay tracks. Used only in V0 reconstruction."};

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.

---

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

• TrackPairsSelector.h
• TrackPairsSelector.cxx