InDet::InDetConversionFinderTools Class Reference

#include <InDetConversionFinderTools.h>

Inheritance diagram for InDet::InDetConversionFinderTools:

Collaboration diagram for InDet::InDetConversionFinderTools:

Public Member Functions
	InDetConversionFinderTools (const std::string &t, const std::string &n, const IInterface *p)
	~InDetConversionFinderTools ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * >	findVertex (const EventContext &ctx, const TrackCollection *trk_coll) const override
	Find vertex from Trk::TrackCollection.
virtual std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * >	findVertex (const EventContext &ctx, const xAOD::TrackParticleContainer *trk_coll) const override
	Conversion candidate reconstruction for Trk::TrackParticle (default).
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 ()

Public Attributes
BooleanProperty	m_removeTrt {this, "RemoveTrtTracks", false, "Remove standalone TRT tracks"}
BooleanProperty	m_isConversion {this, "IsConversion", true, "Conversions or V0s"}
BooleanProperty	m_decorateVertices {this, "DecorateVertices", true, "Decorate vertices with values used for vertex selection"}
	Conversion candidate reconstruction for Trk::Tracks.

Protected Member Functions
bool	passPreSelection (TrackPairsSelector::Cache &cache, const xAOD::TrackParticle *track_pos, const xAOD::TrackParticle *track_neg, std::vector< Amg::Vector3D > &trackList, Amg::Vector3D &initPos, int &flag, std::map< std::string, float > &intersectionDecors) 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
ToolHandle< Trk::IVertexFitter >	m_iVertexFitter
	Vertex fitter interface.
ToolHandle< InDet::TrackPairsSelector >	m_trackPairsSelector
	Initial conversion vertex estimator tool.
ToolHandle< InDet::VertexPointEstimator >	m_vertexEstimator
	Initial conversion vertex estimator tool.
ToolHandle< InDet::ConversionPostSelector >	m_postSelector
	Conversion post-fit selector tool.
ToolHandle< InDet::SingleTrackConversionTool >	m_singleTrkConvTool
	Single track conversion tool.
ToolHandle< Trk::ITrackSelectorTool >	m_trkSelector
	Track Selector Tool.
DoubleProperty	m_mindR
	Cuts.
DoubleProperty	m_maxdR
DoubleProperty	m_MinInitVtxR
DoubleProperty	m_MinFlightAngle

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

Definition at line 48 of file InDetConversionFinderTools.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

InDetConversionFinderTools()

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

Definition at line 25 of file InDetConversionFinderTools.cxx.

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

~InDetConversionFinderTools()

InDet::InDetConversionFinderTools::~InDetConversionFinderTools ( )

default

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

overridevirtual

Definition at line 88 of file InDetConversionFinderTools.cxx.

  {
    return StatusCode::SUCCESS;
  }

findVertex() [1/2]

std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * > InDet::InDetConversionFinderTools::findVertex ( const EventContext & ctx, const TrackCollection * trackTES ) const

overridevirtual

Find vertex from Trk::TrackCollection.

Parameters

EventContext
input	track container

Returns

a pair of newly created container and auxiliary store

Implements InDet::IVertexFinder.

Definition at line 95 of file InDetConversionFinderTools.cxx.

  {
    
    ATH_MSG_ERROR("Using Track Container not currently supported returning an empty conatiner");
 
    // Make collection for conversions.
    xAOD::VertexContainer* InDetConversionContainer = new xAOD::VertexContainer();
    xAOD::VertexAuxContainer* InDetConversionContainerAux = new xAOD::VertexAuxContainer();
    InDetConversionContainer->setStore( InDetConversionContainerAux ); 
 
    return std::make_pair(InDetConversionContainer,InDetConversionContainerAux); 
  }

findVertex() [2/2]

std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * > InDet::InDetConversionFinderTools::findVertex ( const EventContext & ctx, const xAOD::TrackParticleContainer * trk_coll ) const

overridevirtual

Conversion candidate reconstruction for Trk::TrackParticle (default).

Implements InDet::IVertexFinder.

Definition at line 111 of file InDetConversionFinderTools.cxx.

  {
    // Make collection for conversions.
    xAOD::VertexContainer* InDetConversionContainer =
      new xAOD::VertexContainer();
    xAOD::VertexAuxContainer* InDetConversionContainerAux =
      new xAOD::VertexAuxContainer();
    InDetConversionContainer->setStore(InDetConversionContainerAux);
    // Count for number of successful conversions
    int numConversions = 0;
 
    // have to be used for the vertex fit
    Amg::Vector3D pos(0., 0., 0.);
    Amg::Vector3D initPos(0., 0., 0.);
 
    // Make seperate lists of positive and negative tracks (after presection
    // cuts)
    std::vector<const xAOD::TrackParticle*> negSelectedTracks;
    negSelectedTracks.clear();
    std::vector<const xAOD::TrackParticle*> posSelectedTracks;
    posSelectedTracks.clear();
    std::vector<int> negIndx;
    std::vector<int> posIndx;
 
    TrackPairsSelector::Cache cache{};
    // track preselection -->pt-cut
    xAOD::TrackParticleContainer::const_iterator iter;
    for (iter = (*trk_coll).begin(); iter != (*trk_coll).end(); ++iter) {
      if (m_trkSelector->decision(
            **iter,
            nullptr)) { // Only save if track passes the pt, d0, z0 and TRT PID cuts
        ATH_MSG_DEBUG("Track passed preselection");
        if ((*iter)->charge() < 0) {
          negSelectedTracks.push_back(*iter);
          negIndx.push_back(0);
        } else {
          posSelectedTracks.push_back(*iter);
          posIndx.push_back(0);
        }
      } else
        ATH_MSG_DEBUG("Track failed preselection");
    } // end pt,d0.z0-cuts
 
    // Make track pairs. To be used for double leg conversions
    std::vector<const xAOD::TrackParticle*>::const_iterator iter_pos;
    std::vector<const xAOD::TrackParticle*>::const_iterator iter_neg;
    std::vector<Amg::Vector3D> positionList;
    positionList.clear();
    std::vector<const xAOD::TrackParticle*> trackParticleList;
    trackParticleList.clear();
    std::vector<const xAOD::TrackParticle*> singleTrackConvList;
    singleTrackConvList.clear();
    int ipos = -1;
    int ineg = -1;
    // Outer loop: Loop over positive tracks
    for (iter_pos = posSelectedTracks.begin();
         iter_pos != posSelectedTracks.end();
         ++iter_pos) {
      ineg = -1;
      ipos++;
      // Inner loop: Loop over negative tracks
      for (iter_neg = negSelectedTracks.begin();
           iter_neg != negSelectedTracks.end();
           ++iter_neg) {
        ineg++;
        int flag = 0;
 
        std::map<std::string, float> intersectionDecors;
        if (!passPreSelection(cache,
                              *iter_pos,
                              *iter_neg,
                              positionList,
                              initPos,
                              flag,
                              intersectionDecors)) {
          positionList.clear();
          continue;
        }
 
        // Do the fit
        if (positionList.size() < 2) {
          ATH_MSG_DEBUG("No tracks to fit ");
          positionList.clear();
          continue;
        }
 
        trackParticleList.push_back(*iter_pos);
        trackParticleList.push_back(*iter_neg);
 
        std::unique_ptr<xAOD::Vertex> myVertex =
          m_iVertexFitter->fit(ctx, trackParticleList, initPos);
        trackParticleList.clear();
 
        // We have a new vertex
        if (myVertex) {
          ATH_MSG_DEBUG("VertexFit successful!");
          int type = -1;
          if ((m_isConversion && m_postSelector->selectConversionCandidate(
                                   myVertex.get(), flag, positionList)) ||
              (!m_isConversion &&
               m_postSelector->selectSecVtxCandidate(
                 myVertex.get(), flag, positionList, type))) {
 
            ATH_MSG_DEBUG(" Conversion passed postselection cuts");
            // Remove old element links
            myVertex->clearTracks();
 
            // If we do not have a valid type just reset
            if (!m_isConversion && !(type == 101) && !(type == 110) &&
                !(type == 11)) {
              myVertex.reset();
            }
 
            // If we have the right type (not reset above) lets fill information
            // and then push to the containers
            if (myVertex) {
              if (m_decorateVertices) {
                ATH_MSG_DEBUG(
                  "Decorating vertex with values used in track pair selector");
                for (const auto& kv :
                     InDet::TrackPairsSelector::getLastValues(cache)) {
                  SG::Accessor<float> acc (kv.first);
                  acc (*myVertex) = kv.second;
                }
                ATH_MSG_DEBUG("Decorating vertex with values used in vertex "
                              "point estimator");
                for (const auto& kv : intersectionDecors) {
                  SG::Accessor<float> acc (kv.first);
                  acc (*myVertex) = kv.second;
                }
              }
 
              ElementLink<xAOD::TrackParticleContainer> newLinkPos(*iter_pos,
                                                                   *trk_coll,
                                                                   ctx);
              ElementLink<xAOD::TrackParticleContainer> newLinkNeg(*iter_neg,
                                                                   *trk_coll,
                                                                   ctx);
              myVertex->addTrackAtVertex(newLinkPos);
              myVertex->addTrackAtVertex(newLinkNeg);
 
              // Now fill in the containers depending on the 2 possible
              // cases
              if (m_isConversion) {
                myVertex->setVertexType(xAOD::VxType::ConvVtx);
                InDetConversionContainer->push_back(std::move(myVertex));
              }
              else if (type == 101 || type == 110 || type == 11) { // V0
                myVertex->setVertexType(xAOD::VxType::V0Vtx);
                InDetConversionContainer->push_back(std::move(myVertex));
              }
 
           } // End if on right type
 
            negIndx[ineg] = 1;
            posIndx[ipos] = 1;
            ++numConversions;
          } else {
            ATH_MSG_DEBUG("VxCandidate failed the post selection cuts!");
            myVertex.reset();
          }
        } else {
          ATH_MSG_DEBUG("VertexFit was NOT successful!");
        }
        positionList.clear();
      } // neg loop
    }   // pos loop
    ATH_MSG_DEBUG("Number of conversions found passing post selection cuts: "
                  << numConversions);
 
    // single track conversions
    if (m_isConversion) {
      for (int ip = 0; ip < int(posIndx.size()); ++ip) {
        if (posIndx[ip] == 0)
          singleTrackConvList.push_back(posSelectedTracks[ip]);
      }
      for (int in = 0; in < int(negIndx.size()); ++in) {
        if (negIndx[in] == 0)
          singleTrackConvList.push_back(negSelectedTracks[in]);
      }
 
      std::vector<const xAOD::TrackParticle*>::iterator itk;
      std::vector<const xAOD::TrackParticle*>::iterator itke = singleTrackConvList.end();
      int numSingle = 0;
      for (itk = singleTrackConvList.begin(); itk != itke; ++itk) {
        if (!m_singleTrkConvTool->selectSingleTrackParticleConversion((*itk)))
          ATH_MSG_DEBUG("Track failed single track conversion selection");
        else {
          xAOD::Vertex* sConver(nullptr);
          sConver = m_singleTrkConvTool->buildSingleTrackParticleConversion(
            (*itk), InDetConversionContainer);
          if (sConver) {
            sConver->clearTracks();
 
            ElementLink<xAOD::TrackParticleContainer> newLink;
            newLink.toContainedElement(*trk_coll, *itk, ctx);
            sConver->addTrackAtVertex(newLink);
            sConver->setVertexType(xAOD::VxType::ConvVtx);
            numSingle++;
 
            if (m_decorateVertices) {
              ATH_MSG_DEBUG("Decorating single track vertex with dummy values "
                            "used in track pair selector");
              for (const auto& kv : InDet::TrackPairsSelector::getLastValues(cache)) {
                SG::Accessor<float> acc (kv.first);
                acc (*sConver) = 0.;
              }
 
              ATH_MSG_DEBUG("Decorating single track vertex with dummy values "
                            "used in vertex point estimator");
              for (const std::string& k : InDet::VertexPointEstimator::decorKeys()) {
                SG::Accessor<float> acc (k);
                acc (*sConver) = 0.;
              }
 
              ATH_MSG_DEBUG("Decorating single track vertex with dummy values "
                            "used in post selector");
              InDet::ConversionPostSelector::decorateVertex(*sConver, 0., 0., 0., 0., 0.);
            }
          }
        }
      }
      ATH_MSG_DEBUG("Number successful reconstructed single track conversion: "
                    << numSingle);
    }
 
    return std::make_pair(InDetConversionContainer,
                          InDetConversionContainerAux);
  }

initialize()

StatusCode InDet::InDetConversionFinderTools::initialize ( )

overridevirtual

Definition at line 35 of file InDetConversionFinderTools.cxx.

  {
    StatusCode sc = AthAlgTool::initialize();
    if (sc.isFailure()) {
      ATH_MSG_FATAL("Unable to initialize InDetConversionFinderTools");
      return StatusCode::FAILURE;
    }
    /* Get the right vertex fitting tool from ToolSvc */
    if (m_iVertexFitter.retrieve().isFailure()) {
      ATH_MSG_FATAL("Failed to retrieve tool " << m_iVertexFitter);
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("Retrieved tool " << m_iVertexFitter);
 
    /* Get the track pairs selector tool from ToolSvc */
    if (m_trackPairsSelector.retrieve().isFailure()) {
      ATH_MSG_FATAL("Failed to retrieve tool " << m_trackPairsSelector);
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("Retrieved tool " << m_trackPairsSelector);
 
    /* Get the vertex point estimator tool from ToolSvc */
    if (m_vertexEstimator.retrieve().isFailure()) {
      ATH_MSG_FATAL("Failed to retrieve tool " << m_vertexEstimator);
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("Retrieved tool " << m_vertexEstimator);
 
    /* Get the postselector tool from ToolSvc */
    if (m_postSelector.retrieve().isFailure()) {
      ATH_MSG_FATAL("Failed to retrieve tool " << m_postSelector);
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("Retrieved tool " << m_postSelector);
 
    /* Get the single track conversion tool from ToolSvc */
    if (m_singleTrkConvTool.retrieve().isFailure()) {
      ATH_MSG_FATAL("Failed to retrieve tool " << m_singleTrkConvTool);
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("Retrieved tool " << m_singleTrkConvTool);
 
    /* Get the track selector tool from ToolSvc */
    if (m_trkSelector.retrieve().isFailure()) {
      ATH_MSG_FATAL("Failed to retrieve tool " << m_trkSelector);
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("Retrieved tool " << m_trkSelector);
 
    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::IVertexFinder::interfaceID ( )

inlinestaticinherited

Definition at line 55 of file IVertexFinder.h.

{ return IID_IVertexFinder; }

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.

passPreSelection()

bool InDet::InDetConversionFinderTools::passPreSelection ( TrackPairsSelector::Cache & cache, const xAOD::TrackParticle * track_pos, const xAOD::TrackParticle * track_neg, std::vector< Amg::Vector3D > & trackList, Amg::Vector3D & initPos, int & flag, std::map< std::string, float > & intersectionDecors ) const

protected

Definition at line 343 of file InDetConversionFinderTools.cxx.

  {
    //Track summary information
  
    uint8_t nclusPos(0);
    uint8_t dummy(0);
    if(track_pos->summaryValue(dummy,xAOD::numberOfSCTHits)){
      nclusPos += dummy;
    } 
    if(track_pos->summaryValue(dummy,xAOD::numberOfPixelHits)){
      nclusPos += dummy;
    } 
  
    uint8_t nclusNeg(0);
    if(track_neg->summaryValue(dummy,xAOD::numberOfSCTHits)){
      nclusNeg += dummy;
    } 
    if(track_neg->summaryValue(dummy,xAOD::numberOfPixelHits)){
      nclusNeg += dummy;
    } 
  
  
    if(nclusNeg>0 && nclusPos>0) flag= 0;
    if((nclusNeg>0 && nclusPos==0) || (nclusNeg==0 && nclusPos>0)) flag = 1;
    if(nclusNeg==0 && nclusPos==0) flag = 2;
    if(m_removeTrt && (flag==1 || flag==2)) return false;
 
    if (m_trackPairsSelector->selectTrackParticlePair( track_pos,track_neg,cache)){
  
      const Trk::Perigee& perPos = track_pos->perigeeParameters();
      const Trk::Perigee& perNeg = track_neg->perigeeParameters();
      int errorcode = 0;
      Amg::Vector3D startingPoint(
        m_vertexEstimator->getCirclesIntersectionPoint(
          &perPos, &perNeg, flag, errorcode, intersectionDecors));
      if(m_isConversion && errorcode != 0) return false;
      if(!m_isConversion){ 
        Amg::Vector3D v_direction = perPos.momentum() + perNeg.momentum();
        double d_alpha = (startingPoint.adjoint()*v_direction)[0]/(startingPoint.mag()*v_direction.mag());
        if(d_alpha<m_MinFlightAngle) return false;
      }
      initPos = startingPoint;
      double startingPointR = startingPoint.perp(); 
      if(startingPointR<800.) {
        //Get measured track parameters at first track measurement.
        
        //Position of first hit in track particle
        Trk::CurvilinearParameters trkPar_pos; 
        Trk::CurvilinearParameters trkPar_neg; 
 
        int index(-1);
        for(unsigned int i(0); i< track_pos->numberOfParameters() ; ++i ){
          if( xAOD::FirstMeasurement == track_pos->parameterPosition(i) ){
            index = i;
            break;
          }
        }
        if(index!=-1){
          trkPar_pos = track_pos->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< track_neg->numberOfParameters() ; ++i ){
          if( xAOD::FirstMeasurement == track_neg->parameterPosition(i) ){
            index = i;
            break;
          }
        }
        if(index!=-1){
          trkPar_neg = track_neg->curvilinearParameters(index);
        } else {
          ATH_MSG_WARNING("Track Particle does not contain first Measurement track parameters");
          return false;
        }
 
        
        if(!m_isConversion){
          double posR = trkPar_pos.position().perp();
          double negR = trkPar_neg.position().perp();
          double diffR = 1000.;
          if((startingPointR-posR)<(startingPointR-negR)) diffR = startingPointR-posR;
          else                            diffR = startingPointR-negR;
          if(startingPointR<m_MinInitVtxR) return false;
          if(diffR<m_mindR || diffR>m_maxdR) return false;
        }
 
        //Alternative way to estimate the guess vertex
        initPos = trkPar_pos.position() + trkPar_neg.position();
        initPos *= 0.5;
        // Not correct but will do for now
        trackList.push_back(trkPar_pos.position());
        trackList.push_back(trkPar_neg.position());
        
      }
    }
    return true;
  }

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 368 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 352 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

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 >, and AthCheckedComponent<::AthAlgTool >.

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 298 of file AthCommonDataStore.h.

                                               {
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_decorateVertices

BooleanProperty InDet::InDetConversionFinderTools::m_decorateVertices {this, "DecorateVertices", true, "Decorate vertices with values used for vertex selection"}

Conversion candidate reconstruction for Trk::Tracks.

Definition at line 65 of file InDetConversionFinderTools.h.

{this, "DecorateVertices", true, "Decorate vertices with values used for vertex selection"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

m_isConversion

BooleanProperty InDet::InDetConversionFinderTools::m_isConversion {this, "IsConversion", true, "Conversions or V0s"}

Definition at line 63 of file InDetConversionFinderTools.h.

{this, "IsConversion", true, "Conversions or V0s"};

m_iVertexFitter

ToolHandle<Trk::IVertexFitter> InDet::InDetConversionFinderTools::m_iVertexFitter

protected

Initial value:

{ this,
                                                  "VertexFitterTool",
                                                  "Trk::TrkVKalVrtFitter",
                                                  "Vertex fitter Tool" }

Vertex fitter interface.

Track pair selection tool.

Definition at line 82 of file InDetConversionFinderTools.h.

                                              { this,
                                                  "VertexFitterTool",
                                                  "Trk::TrkVKalVrtFitter",
                                                  "Vertex fitter Tool" };

m_maxdR

DoubleProperty InDet::InDetConversionFinderTools::m_maxdR

protected

Initial value:

{this, "MaxDistVtxHit", 250.,
    "Maximum allowed radial distance between guess vertex and closest 1st hit of participating track"}

Definition at line 134 of file InDetConversionFinderTools.h.

                        {this, "MaxDistVtxHit", 250.,
    "Maximum allowed radial distance between guess vertex and closest 1st hit of participating track"};

m_mindR

DoubleProperty InDet::InDetConversionFinderTools::m_mindR

protected

Initial value:

{this, "MinDistVtxHit", -350.,
    "Minimum allowed radial distance beteeen guess vertex and closest 1st hit of participating track"}

Cuts.

Definition at line 132 of file InDetConversionFinderTools.h.

                        {this, "MinDistVtxHit", -350.,
    "Minimum allowed radial distance beteeen guess vertex and closest 1st hit of participating track"};

m_MinFlightAngle

DoubleProperty InDet::InDetConversionFinderTools::m_MinFlightAngle

protected

Initial value:

{this, "MinFlightAngle", 0.,
    "Minimum allowed angular difference between V0 and children direction. Used only in V0 reconstruction."}

Definition at line 138 of file InDetConversionFinderTools.h.

                                 {this, "MinFlightAngle", 0.,
    "Minimum allowed angular difference between V0 and children direction. Used only in V0 reconstruction."};

m_MinInitVtxR

DoubleProperty InDet::InDetConversionFinderTools::m_MinInitVtxR

protected

Initial value:

{this, "MinInitVtxR", 0.,
    "Minimum allowed radial position for initial guess vertex. Used only in V0 reconstruction."}

Definition at line 136 of file InDetConversionFinderTools.h.

                              {this, "MinInitVtxR", 0.,
    "Minimum allowed radial position for initial guess vertex. Used only in V0 reconstruction."};

m_postSelector

ToolHandle<InDet::ConversionPostSelector> InDet::InDetConversionFinderTools::m_postSelector

protected

Initial value:

{
    this,
    "PostSelector",
    "InDet::ConversionPostSelector",
    "Tool for post selection of conversion candidates"
  }

Conversion post-fit selector tool.

Definition at line 101 of file InDetConversionFinderTools.h.

                                                        {
    this,
    "PostSelector",
    "InDet::ConversionPostSelector",
    "Tool for post selection of conversion candidates"
  };

m_removeTrt

BooleanProperty InDet::InDetConversionFinderTools::m_removeTrt {this, "RemoveTrtTracks", false, "Remove standalone TRT tracks"}

Definition at line 61 of file InDetConversionFinderTools.h.

{this, "RemoveTrtTracks", false, "Remove standalone TRT tracks"};

m_singleTrkConvTool

ToolHandle<InDet::SingleTrackConversionTool> InDet::InDetConversionFinderTools::m_singleTrkConvTool

protected

Initial value:

{
    this,
    "SingleTrackConversionTool",
    "InDet::SingleTrackConversionTool",
    "Tool for single track conversions"
  }

Single track conversion tool.

Definition at line 108 of file InDetConversionFinderTools.h.

                                                                {
    this,
    "SingleTrackConversionTool",
    "InDet::SingleTrackConversionTool",
    "Tool for single track conversions"
  };

m_trackPairsSelector

ToolHandle<InDet::TrackPairsSelector> InDet::InDetConversionFinderTools::m_trackPairsSelector

protected

Initial value:

{
    this,
    "TrackPairsSelector",
    "InDet::TrackPairsSelector",
    "Track Pair Selector Tool"
  }

Initial conversion vertex estimator tool.

Definition at line 87 of file InDetConversionFinderTools.h.

                                                          {
    this,
    "TrackPairsSelector",
    "InDet::TrackPairsSelector",
    "Track Pair Selector Tool"
  };

m_trkSelector

ToolHandle<Trk::ITrackSelectorTool> InDet::InDetConversionFinderTools::m_trkSelector

protected

Initial value:

{
    this,
    "TrackSelectorTool",
    "InDet::TrackSelectorTool",
    "Tool for track Selection"
  }

Track Selector Tool.

Definition at line 116 of file InDetConversionFinderTools.h.

                                                 {
    this,
    "TrackSelectorTool",
    "InDet::TrackSelectorTool",
    "Tool for track Selection"
  };

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 387 of file AthCommonDataStore.h.

m_vertexEstimator

ToolHandle<InDet::VertexPointEstimator> InDet::InDetConversionFinderTools::m_vertexEstimator

protected

Initial value:

{
    this,
    "VertexPointEstimator",
    "InDet::VertexPointEstimator",
    "Vertex point estimator"
  }

Initial conversion vertex estimator tool.

Definition at line 94 of file InDetConversionFinderTools.h.

                                                         {
    this,
    "VertexPointEstimator",
    "InDet::VertexPointEstimator",
    "Vertex point estimator"
  };

m_vhka

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

privateinherited

Definition at line 386 of file AthCommonDataStore.h.

---

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

• InDetConversionFinderTools.h
• InDetConversionFinderTools.cxx