#include <ReVertex.h>

Inheritance diagram for DerivationFramework::ReVertex:

Collaboration diagram for DerivationFramework::ReVertex:

Public Member Functions
	ReVertex (const std::string &t, const std::string &n, const IInterface *p)

virtual StatusCode	initialize () override

virtual StatusCode	addBranches () const override

void	fitAndStore (xAOD::VertexContainer vtxContainer, const xAOD::Vertex v, const xAOD::VertexContainer InVtxContainer, const std::vector< const xAOD::TrackParticle > &inputTracks, const xAOD::TrackParticleContainer importedTrackCollection, const xAOD::VertexContainer pvContainer) const

xAOD::Vertex *	fit (const std::vector< const xAOD::TrackParticle * > &inputTracks, const xAOD::TrackParticleContainer importedTrackCollection, const xAOD::Vertex pv) const

Private Attributes
std::vector< int >	m_TrackIndices

ToolHandle< InDet::VertexPointEstimator >	m_vertexEstimator

ToolHandle< Trk::IVertexFitter >	m_iVertexFitter

Trk::TrkVKalVrtFitter *	m_VKVFitter {}

SG::WriteHandleKey< xAOD::VertexContainer >	m_OutputContainerName

SG::ReadHandleKey< xAOD::VertexContainer >	m_inputContainerName

SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_trackContainer

SG::WriteHandleKey< xAOD::VertexContainer >	m_refPVContainerName

SG::ReadHandleKey< xAOD::VertexContainer >	m_pvContainerName

std::vector< double >	m_trkMasses

std::vector< int >	m_indices

double	m_massConst {}

double	m_totalMassConst {}

std::vector< std::string >	m_hypoNames

ToolHandle< Trk::V0Tools >	m_v0Tools

ToolHandle< Analysis::PrimaryVertexRefitter >	m_pvRefitter

SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfo_key {this, "EventInfo", "EventInfo", "Input event information"}

int	m_PV_max {}

int	m_DoVertexType {}

size_t	m_PV_minNTracks {}

bool	m_do3d {}

bool	m_AddPVData {}

bool	m_refitPV {}

bool	m_doMassConst {}

bool	m_startingpoint0 {}

bool	m_vertexFittingWithPV {}

double	m_BMassUpper {}

double	m_BMassLower {}

double	m_chi2cut {}

double	m_trkDeltaZ {}

bool	m_useAdditionalTrack {}

SG::ReadHandleKeyArray< xAOD::VertexContainer >	m_CollectionsToCheck {this, "CheckVertexContainers", {}}

SG::ReadHandleKeyArray< xAOD::TrackParticleContainer >	m_RelinkContainers {this, "RelinkTracks", {}, "Track Containers if they need to be relinked through indirect use" }

Detailed Description

Definition at line 42 of file ReVertex.h.

Constructor & Destructor Documentation

◆ ReVertex()

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

Definition at line 27 of file ReVertex.cxx.

                                         :
     base_class(t,n,p), m_vertexEstimator("InDet::VertexPointEstimator"), m_iVertexFitter("Trk::TrkVKalVrtFitter"),
     m_massConst(0.),
     m_totalMassConst(0.),
     m_v0Tools("Trk::V0Tools"),
     m_pvRefitter("Analysis::PrimaryVertexRefitter", this),
     m_doMassConst(false),
     m_vertexFittingWithPV(false),
     m_chi2cut(-1.0),
     m_trkDeltaZ(-1.0),
     m_useAdditionalTrack(false)
 {
  
     declareProperty("TrackIndices", m_TrackIndices);
     declareProperty("TrkVertexFitterTool", m_iVertexFitter);
     declareProperty("VertexPointEstimator",m_vertexEstimator);
  
     declareProperty("OutputVtxContainerName", m_OutputContainerName);
     declareProperty("InputVtxContainerName", m_inputContainerName);
     declareProperty("TrackContainerName", m_trackContainer = "InDetTrackParticles");
     declareProperty("UseVertexFittingWithPV", m_vertexFittingWithPV);
  
     declareProperty("HypothesisNames",m_hypoNames);
    
     declareProperty("V0Tools"               , m_v0Tools);
     declareProperty("PVRefitter"            , m_pvRefitter);
     declareProperty("PVContainerName"       , m_pvContainerName        = "PrimaryVertices");
     declareProperty("RefPVContainerName"    , m_refPVContainerName     = "RefittedPrimaryVertices");
  
     declareProperty("UseMassConstraint", m_doMassConst);
     declareProperty("VertexMass", m_totalMassConst);
     declareProperty("SubVertexMass", m_massConst);
     declareProperty("MassInputParticles", m_trkMasses);
     declareProperty("SubVertexTrackIndices", m_indices);
    
     declareProperty("UseAdditionalTrack", m_useAdditionalTrack);
  
     declareProperty("RefitPV"               , m_refitPV                = false);
     //This parameter will allow us to optimize the number of PVs under consideration as the probability
     //of a useful primary vertex drops significantly the higher you go
     declareProperty("MaxPVrefit"            , m_PV_max                = 1000);
     declareProperty("DoVertexType"          , m_DoVertexType           = 7);
     // minimum number of tracks for PV to be considered for PV association
     declareProperty("MinNTracksInPV"        , m_PV_minNTracks          = 0);
     declareProperty("Do3d"        , m_do3d          = false);
     declareProperty("AddPVData"        , m_AddPVData          = true);
     declareProperty("StartingPoint0"        , m_startingpoint0     = false);
     declareProperty("BMassUpper",m_BMassUpper = std::numeric_limits<double>::max() );
     declareProperty("BMassLower",m_BMassLower = std::numeric_limits<double>::min() );
     declareProperty("Chi2Cut",m_chi2cut = std::numeric_limits<double>::max() );
     declareProperty("TrkDeltaZ",m_trkDeltaZ);
     
     
 }

Member Function Documentation

◆ addBranches()

StatusCode ReVertex::addBranches ( ) const

overridevirtual

Definition at line 108 of file ReVertex.cxx.

                                        {
     const EventContext& ctx = Gaudi::Hive::currentContext();
     SG::WriteHandle<xAOD::VertexContainer> vtxContainer(m_OutputContainerName);
     ATH_CHECK(vtxContainer.record(std::make_unique<xAOD::VertexContainer>(), std::make_unique<xAOD::VertexAuxContainer>()));
  
     const size_t Ntracks = m_TrackIndices.size();
  
     SG::ReadHandle<xAOD::VertexContainer> InVtxContainer(m_inputContainerName);
     SG::ReadHandle<xAOD::TrackParticleContainer> importedTrackCollection(m_trackContainer);
     ATH_CHECK(InVtxContainer.isValid());
     ATH_CHECK(importedTrackCollection.isValid());
     //----------------------------------------------------
     // retrieve primary vertices
     //----------------------------------------------------
     SG::ReadHandle<xAOD::VertexContainer> pvContainer(m_pvContainerName);
     ATH_CHECK(pvContainer.isValid());
  
     std::vector<const xAOD::TrackParticle*> fitpair(Ntracks + m_useAdditionalTrack);
     for(const xAOD::Vertex* v : *InVtxContainer)
     {
  
       bool passed = false;
       for(size_t i=0;i<m_hypoNames.size();i++) {
      xAOD::BPhysHypoHelper onia(m_hypoNames.at(i), v);
      passed |= onia.pass();
       }
       if (!passed && m_hypoNames.size()) continue;
        
         for(size_t i =0; i<Ntracks; i++)
         {
             size_t trackN = m_TrackIndices[i];
             if(trackN >= v->nTrackParticles())
             {
                 ATH_MSG_FATAL("Indices exceeds limit in particle");
                 return StatusCode::FAILURE;
             }
             fitpair[i] = v->trackParticle(trackN);
         }
  
        if (m_useAdditionalTrack) 
        {
       // Loop over ID tracks, call vertexing
       for (auto trkItr=importedTrackCollection->cbegin(); trkItr!=importedTrackCollection->cend(); ++trkItr) {
          const xAOD::TrackParticle* tp (*trkItr);
          fitpair.back() = nullptr;
          if (Analysis::JpsiUpsilonCommon::isContainedIn(tp,fitpair)) continue; // remove tracks which were used to build J/psi+2Tracks
          fitpair.back() = tp;
  
           // Daniel Scheirich: remove track too far from the Jpsi+2Tracks vertex (DeltaZ cut)
           if(m_trkDeltaZ>0 &&
          std::abs((tp)->z0() + (tp)->vz() - v->z()) > m_trkDeltaZ )
            continue;
          
          fitAndStore(vtxContainer.ptr(),v,InVtxContainer.cptr(),fitpair,importedTrackCollection.cptr(),pvContainer.cptr());
       }
        }
        else 
        {
       fitAndStore(vtxContainer.ptr(),v,InVtxContainer.cptr(),fitpair,importedTrackCollection.cptr(),pvContainer.cptr());
        }
     }
  
     if(m_AddPVData){
      // Give the helper class the ptr to v0tools and beamSpotsSvc to use
      SG::ReadHandle<xAOD::EventInfo> evt(m_eventInfo_key);
      if(not evt.isValid()) ATH_MSG_ERROR("Cannot Retrieve " << evt.key() );
      BPhysPVTools helper(&(*m_v0Tools), evt.cptr());
      helper.SetMinNTracksInPV(m_PV_minNTracks);
      helper.SetSave3d(m_do3d);
  
     if(m_refitPV) {
         //----------------------------------------------------
         // Try to retrieve refitted primary vertices
         //----------------------------------------------------
         SG::WriteHandle<xAOD::VertexContainer> refPvContainer(m_refPVContainerName);
         ATH_CHECK(refPvContainer.record(std::make_unique<xAOD::VertexContainer>(), std::make_unique<xAOD::VertexAuxContainer>()));
  
         if(vtxContainer->size() >0){
           ATH_CHECK(helper.FillCandwithRefittedVertices(vtxContainer.ptr(), pvContainer.cptr(), refPvContainer.ptr(), &(*m_pvRefitter) ,  m_PV_max, m_DoVertexType));
         }
      }else{
          if(vtxContainer->size() >0) ATH_CHECK(helper.FillCandExistingVertices(vtxContainer.ptr(), pvContainer.cptr(), m_DoVertexType));
      }
     }
  
     using Analysis::JpsiUpsilonCommon;
  
     std::vector<const xAOD::TrackParticleContainer*> trackCols;
     for(const auto &str : m_RelinkContainers){
       SG::ReadHandle<xAOD::TrackParticleContainer> handle(str,ctx);
       trackCols.push_back(handle.cptr());
     }
     if(not trackCols.empty()){
        for(xAOD::Vertex* vtx : *vtxContainer){
           try{
             JpsiUpsilonCommon::RelinkVertexTracks(trackCols, vtx);
           }catch(std::runtime_error const& e){
             ATH_MSG_ERROR(e.what());
             return StatusCode::FAILURE;
           }
        }
     }
     return StatusCode::SUCCESS;
 }

◆ fit()

xAOD::Vertex * ReVertex::fit	(	const std::vector< const xAOD::TrackParticle * > &	inputTracks,
		const xAOD::TrackParticleContainer *	importedTrackCollection,
		const xAOD::Vertex *	pv
	)		const

Definition at line 273 of file ReVertex.cxx.

 {
    std::unique_ptr<Trk::IVKalState> state = m_VKVFitter->makeState();
    if (m_doMassConst && (m_trkMasses.size()==inputTracks.size())) {
       m_VKVFitter->setMassInputParticles(m_trkMasses, *state);
       if (m_totalMassConst) m_VKVFitter->setMassForConstraint(m_totalMassConst, *state);
       if (m_massConst) m_VKVFitter->setMassForConstraint(m_massConst, m_indices, *state);
    }
    if (pv) {
       m_VKVFitter->setCnstType(8, *state);
       m_VKVFitter->setVertexForConstraint(pv->position().x(),
                       pv->position().y(),
                       pv->position().z(), *state);
       m_VKVFitter->setCovVrtForConstraint(pv->covariancePosition()(Trk::x,Trk::x),
                       pv->covariancePosition()(Trk::y,Trk::x),
                       pv->covariancePosition()(Trk::y,Trk::y),
                       pv->covariancePosition()(Trk::z,Trk::x),
                       pv->covariancePosition()(Trk::z,Trk::y),
                       pv->covariancePosition()(Trk::z,Trk::z), *state );
    }
  
    // Do the fit itself.......
    // Starting point (use the J/psi position)
    const Trk::Perigee& aPerigee1 = inputTracks[0]->perigeeParameters();
    const Trk::Perigee& aPerigee2 = inputTracks[1]->perigeeParameters();
    int sflag = 0;
    int errorcode = 0;
    Amg::Vector3D startingPoint = m_vertexEstimator->getCirclesIntersectionPoint(&aPerigee1,&aPerigee2,sflag,errorcode);
    if (errorcode != 0) {startingPoint(0) = 0.0; startingPoint(1) = 0.0; startingPoint(2) = 0.0;}
    xAOD::Vertex* theResult = m_VKVFitter->fit(inputTracks, startingPoint, *state);
  
    // Added by ASC
    if(theResult != 0){
       std::vector<ElementLink<DataVector<xAOD::TrackParticle> > > newLinkVector;
       for(unsigned int i=0; i< theResult->trackParticleLinks().size(); i++)
     {
        ElementLink<DataVector<xAOD::TrackParticle> > mylink=theResult->trackParticleLinks()[i]; //makes a copy (non-const)
        mylink.setStorableObject( *importedTrackCollection, true);
        newLinkVector.push_back( mylink );
     }
       theResult->clearTracks();
       theResult->setTrackParticleLinks( newLinkVector );
    }
    
    return theResult;
 }

◆ fitAndStore()

void ReVertex::fitAndStore	(	xAOD::VertexContainer *	vtxContainer,
		const xAOD::Vertex *	v,
		const xAOD::VertexContainer *	InVtxContainer,
		const std::vector< const xAOD::TrackParticle * > &	inputTracks,
		const xAOD::TrackParticleContainer *	importedTrackCollection,
		const xAOD::VertexContainer *	pvContainer
	)		const

Definition at line 213 of file ReVertex.cxx.

 {
    std::unique_ptr<xAOD::Vertex> ptr(fit(inputTracks, importedTrackCollection, nullptr));
    if(!ptr)return;
  
    double chi2DOF = ptr->chiSquared()/ptr->numberDoF();
    ATH_MSG_DEBUG("Candidate chi2/DOF is " << chi2DOF);
    bool chi2CutPassed = (m_chi2cut <= 0.0 || chi2DOF < m_chi2cut);
    if(!chi2CutPassed) { ATH_MSG_DEBUG("Chi Cut failed!");  return; }
    xAOD::BPhysHelper bHelper(ptr.get());//"get" does not "release" still automatically deleted
    bHelper.setRefTrks();
    if (m_trkMasses.size()==inputTracks.size()) {
       TLorentzVector bMomentum = bHelper.totalP(m_trkMasses);
       double bMass = bMomentum.M();
       bool passesCuts = (m_BMassUpper > bMass && bMass > m_BMassLower);
       if(!passesCuts)return;
    }
       
    DerivationFramework::BPhysPVTools::PrepareVertexLinks( ptr.get(), importedTrackCollection );
    std::vector<const xAOD::Vertex*> thePreceding;
    thePreceding.push_back(v);
    if(m_vertexFittingWithPV){
       //
       Analysis::CleanUpVertex closestRefPV = Analysis::JpsiUpsilonCommon::ClosestRefPV(bHelper, pvContainer, &(*m_pvRefitter));
       if (!closestRefPV.get()) return;
       std::unique_ptr<xAOD::Vertex> ptrPV(fit(inputTracks, importedTrackCollection, closestRefPV.get()));
       if(!ptrPV) return;
  
       double chi2DOFPV = ptrPV->chiSquared()/ptrPV->numberDoF();
       ATH_MSG_DEBUG("CandidatePV chi2/DOF is " << chi2DOFPV);
       bool chi2CutPassed = (m_chi2cut <= 0.0 || chi2DOFPV < m_chi2cut);
       if(!chi2CutPassed) { ATH_MSG_DEBUG("Chi Cut failed!");  return; }
       xAOD::BPhysHelper bHelperPV(ptrPV.get());//"get" does not "release" still automatically deleted
       bHelperPV.setRefTrks();
       if (m_trkMasses.size()==inputTracks.size()) {
      TLorentzVector bMomentumPV = bHelperPV.totalP(m_trkMasses);
      double bMass = bMomentumPV.M();
      bool passesCuts = (m_BMassUpper > bMass && bMass > m_BMassLower);
      if(!passesCuts)return;
       }
       
       bHelperPV.setPrecedingVertices(thePreceding, InVtxContainer);
       vtxContainer->push_back(ptrPV.release());
       return; //Don't store other vertex
    }
    bHelper.setPrecedingVertices(thePreceding, InVtxContainer);
    vtxContainer->push_back(ptr.release());
 }

◆ initialize()

StatusCode ReVertex::initialize ( )

overridevirtual

Definition at line 84 of file ReVertex.cxx.

                                 {
     ATH_MSG_DEBUG("in initialize()");
     if(m_TrackIndices.empty()) {
         ATH_MSG_FATAL("No Indices provided");
         return StatusCode::FAILURE;
     }
     ATH_CHECK(m_iVertexFitter.retrieve());
     ATH_CHECK(m_v0Tools.retrieve());
     ATH_CHECK(m_pvRefitter.retrieve());
     ATH_CHECK(m_vertexEstimator.retrieve());
     m_VKVFitter = dynamic_cast<Trk::TrkVKalVrtFitter*>(&(*m_iVertexFitter));
     if(m_VKVFitter==nullptr) return StatusCode::FAILURE;
     ATH_CHECK(m_OutputContainerName.initialize());
     ATH_CHECK(m_inputContainerName.initialize());
     ATH_CHECK(m_trackContainer.initialize());
     ATH_CHECK(m_pvContainerName.initialize());
     ATH_CHECK(m_refPVContainerName.initialize());
     ATH_CHECK(m_eventInfo_key.initialize());
     ATH_CHECK(m_RelinkContainers.initialize());
     ATH_CHECK(m_CollectionsToCheck.initialize());
     return StatusCode::SUCCESS;
 }

Member Data Documentation

◆ m_AddPVData

bool DerivationFramework::ReVertex::m_AddPVData {}

private

Definition at line 85 of file ReVertex.h.

◆ m_BMassLower

double DerivationFramework::ReVertex::m_BMassLower {}

private

Definition at line 93 of file ReVertex.h.

◆ m_BMassUpper

double DerivationFramework::ReVertex::m_BMassUpper {}

private

Definition at line 92 of file ReVertex.h.

◆ m_chi2cut

double DerivationFramework::ReVertex::m_chi2cut {}

private

Definition at line 94 of file ReVertex.h.

◆ m_CollectionsToCheck

SG::ReadHandleKeyArray<xAOD::VertexContainer> DerivationFramework::ReVertex::m_CollectionsToCheck {this, "CheckVertexContainers", {}}

private

Definition at line 99 of file ReVertex.h.

◆ m_do3d

bool DerivationFramework::ReVertex::m_do3d {}

private

Definition at line 84 of file ReVertex.h.

◆ m_doMassConst

bool DerivationFramework::ReVertex::m_doMassConst {}

private

Definition at line 87 of file ReVertex.h.

◆ m_DoVertexType

int DerivationFramework::ReVertex::m_DoVertexType {}

private

Definition at line 82 of file ReVertex.h.

◆ m_eventInfo_key

SG::ReadHandleKey<xAOD::EventInfo> DerivationFramework::ReVertex::m_eventInfo_key {this, "EventInfo", "EventInfo", "Input event information"}

private

Definition at line 80 of file ReVertex.h.

◆ m_hypoNames

std::vector<std::string> DerivationFramework::ReVertex::m_hypoNames

private

Definition at line 76 of file ReVertex.h.

◆ m_indices

std::vector<int> DerivationFramework::ReVertex::m_indices

private

Definition at line 73 of file ReVertex.h.

◆ m_inputContainerName

SG::ReadHandleKey<xAOD::VertexContainer> DerivationFramework::ReVertex::m_inputContainerName

private

Definition at line 66 of file ReVertex.h.

◆ m_iVertexFitter

ToolHandle< Trk::IVertexFitter > DerivationFramework::ReVertex::m_iVertexFitter

private

Definition at line 63 of file ReVertex.h.

◆ m_massConst

double DerivationFramework::ReVertex::m_massConst {}

private

Definition at line 74 of file ReVertex.h.

◆ m_OutputContainerName

SG::WriteHandleKey<xAOD::VertexContainer> DerivationFramework::ReVertex::m_OutputContainerName

private

Definition at line 65 of file ReVertex.h.

◆ m_PV_max

int DerivationFramework::ReVertex::m_PV_max {}

private

Definition at line 81 of file ReVertex.h.

◆ m_PV_minNTracks

size_t DerivationFramework::ReVertex::m_PV_minNTracks {}

private

Definition at line 83 of file ReVertex.h.

◆ m_pvContainerName

SG::ReadHandleKey<xAOD::VertexContainer> DerivationFramework::ReVertex::m_pvContainerName

private

Definition at line 69 of file ReVertex.h.

◆ m_pvRefitter

ToolHandle<Analysis::PrimaryVertexRefitter> DerivationFramework::ReVertex::m_pvRefitter

private

Definition at line 79 of file ReVertex.h.

◆ m_refitPV

bool DerivationFramework::ReVertex::m_refitPV {}

private

Definition at line 86 of file ReVertex.h.

◆ m_refPVContainerName

SG::WriteHandleKey<xAOD::VertexContainer> DerivationFramework::ReVertex::m_refPVContainerName

private

Definition at line 68 of file ReVertex.h.

◆ m_RelinkContainers

SG::ReadHandleKeyArray<xAOD::TrackParticleContainer> DerivationFramework::ReVertex::m_RelinkContainers {this, "RelinkTracks", {}, "Track Containers if they need to be relinked through indirect use" }

private

Definition at line 100 of file ReVertex.h.

◆ m_startingpoint0

bool DerivationFramework::ReVertex::m_startingpoint0 {}

private

Definition at line 88 of file ReVertex.h.

◆ m_totalMassConst

double DerivationFramework::ReVertex::m_totalMassConst {}

private

Definition at line 75 of file ReVertex.h.

◆ m_trackContainer

SG::ReadHandleKey<xAOD::TrackParticleContainer> DerivationFramework::ReVertex::m_trackContainer

private

Definition at line 67 of file ReVertex.h.

◆ m_TrackIndices

std::vector<int> DerivationFramework::ReVertex::m_TrackIndices

private

Definition at line 61 of file ReVertex.h.

◆ m_trkDeltaZ

double DerivationFramework::ReVertex::m_trkDeltaZ {}

private

Definition at line 95 of file ReVertex.h.

◆ m_trkMasses

std::vector<double> DerivationFramework::ReVertex::m_trkMasses

private

Definition at line 72 of file ReVertex.h.

◆ m_useAdditionalTrack

bool DerivationFramework::ReVertex::m_useAdditionalTrack {}

private

Definition at line 97 of file ReVertex.h.

◆ m_v0Tools

ToolHandle<Trk::V0Tools> DerivationFramework::ReVertex::m_v0Tools

private

Definition at line 78 of file ReVertex.h.

◆ m_vertexEstimator

ToolHandle< InDet::VertexPointEstimator > DerivationFramework::ReVertex::m_vertexEstimator

private

Definition at line 62 of file ReVertex.h.

◆ m_vertexFittingWithPV

bool DerivationFramework::ReVertex::m_vertexFittingWithPV {}

private

Definition at line 90 of file ReVertex.h.

◆ m_VKVFitter

Trk::TrkVKalVrtFitter* DerivationFramework::ReVertex::m_VKVFitter {}

private

Definition at line 64 of file ReVertex.h.

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

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ReVertex()

Member Function Documentation

◆ addBranches()

◆ fit()

◆ fitAndStore()

◆ initialize()

Member Data Documentation

◆ m_AddPVData

◆ m_BMassLower

◆ m_BMassUpper

◆ m_chi2cut

◆ m_CollectionsToCheck

◆ m_do3d

◆ m_doMassConst

◆ m_DoVertexType

◆ m_eventInfo_key

◆ m_hypoNames

◆ m_indices

◆ m_inputContainerName

◆ m_iVertexFitter

◆ m_massConst

◆ m_OutputContainerName

◆ m_PV_max

◆ m_PV_minNTracks

◆ m_pvContainerName

◆ m_pvRefitter

◆ m_refitPV

◆ m_refPVContainerName

◆ m_RelinkContainers

◆ m_startingpoint0

◆ m_totalMassConst

◆ m_trackContainer

◆ m_TrackIndices

◆ m_trkDeltaZ

◆ m_trkMasses

◆ m_useAdditionalTrack

◆ m_v0Tools

◆ m_vertexEstimator

◆ m_vertexFittingWithPV

◆ m_VKVFitter