#include <ReVertex.h>

Inheritance 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 EventContext &ctx) 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
SG::ReadHandleKey< xAOD::VertexContainer >	m_defaultPVContainerName
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("DefaultPVContainerName", m_defaultPVContainerName = "PrimaryVertices");
    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 EventContext & ctx ) const

overridevirtual

Definition at line 110 of file ReVertex.cxx.

                                                              {
    SG::WriteHandle<xAOD::VertexContainer> vtxContainer(m_OutputContainerName, ctx);
    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, ctx);
    SG::ReadHandle<xAOD::TrackParticleContainer> importedTrackCollection(m_trackContainer, ctx);
    ATH_CHECK(InVtxContainer.isValid());
    ATH_CHECK(importedTrackCollection.isValid());
    //----------------------------------------------------
    // retrieve primary vertices
    //----------------------------------------------------
    SG::ReadHandle<xAOD::VertexContainer> defaultPVContainer(m_defaultPVContainerName, ctx);
    ATH_CHECK(defaultPVContainer.isValid());
 
    SG::ReadHandle<xAOD::VertexContainer> pvContainer(m_pvContainerName, ctx);
    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, ctx);
     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, ctx);
        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(pvContainer->size()==0) {
    if(vtxContainer->size() >0) ATH_CHECK(helper.FillCandExistingVertices(vtxContainer.ptr(), defaultPVContainer.cptr(), 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 282 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 222 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 85 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_defaultPVContainerName.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.

85{};

◆ m_BMassLower

double DerivationFramework::ReVertex::m_BMassLower {}

private

Definition at line 93 of file ReVertex.h.

93{};

◆ m_BMassUpper

double DerivationFramework::ReVertex::m_BMassUpper {}

private

Definition at line 92 of file ReVertex.h.

92{};

◆ m_chi2cut

double DerivationFramework::ReVertex::m_chi2cut {}

private

Definition at line 94 of file ReVertex.h.

94{}; // chi2/Ndof of the final veretx

◆ m_CollectionsToCheck

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

private

Definition at line 99 of file ReVertex.h.

99{this, "CheckVertexContainers", {}};

◆ m_defaultPVContainerName

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

private

Definition at line 70 of file ReVertex.h.

◆ m_do3d

bool DerivationFramework::ReVertex::m_do3d {}

private

Definition at line 84 of file ReVertex.h.

84{};

◆ m_doMassConst

bool DerivationFramework::ReVertex::m_doMassConst {}

private

Definition at line 87 of file ReVertex.h.

87{};

◆ m_DoVertexType

int DerivationFramework::ReVertex::m_DoVertexType {}

private

Definition at line 82 of file ReVertex.h.

82{};

◆ 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.

80{this, "EventInfo", "EventInfo", "Input event information"};

◆ 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.

74{};

◆ 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.

81{};

◆ m_PV_minNTracks

size_t DerivationFramework::ReVertex::m_PV_minNTracks {}

private

Definition at line 83 of file ReVertex.h.

83{};

◆ 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.

86{};

◆ 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.

100{this, "RelinkTracks", {}, "Track Containers if they need to be relinked through indirect use" };

◆ m_startingpoint0

bool DerivationFramework::ReVertex::m_startingpoint0 {}

private

Definition at line 88 of file ReVertex.h.

88{};

◆ m_totalMassConst

double DerivationFramework::ReVertex::m_totalMassConst {}

private

Definition at line 75 of file ReVertex.h.

75{};

◆ 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.

95{}; // DeltaZ between the JPsi vertex and hadronic tracks Z0

◆ 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.

97{};

◆ 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.

90{};

◆ m_VKVFitter

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

private

Definition at line 64 of file ReVertex.h.

64{};

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_defaultPVContainerName

◆ 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