#include <KinematicConstrainedVertexFitterT.h>

Public Member Functions
RefCountedKinematicTree	fit (const std::vector< RefCountedKinematicParticle > &part)

RefCountedKinematicTree	fit (const std::vector< RefCountedKinematicParticle > &part, MultiTrackKinematicConstraintT< nTrk, nConstraint > *cs)

RefCountedKinematicTree	fit (const std::vector< RefCountedKinematicParticle > &part, MultiTrackKinematicConstraintT< nTrk, nConstraint > cs, GlobalPoint pt)

float	getCSum () const

int	getNit () const

	KinematicConstrainedVertexFitterT (const MagneticField *ifield)

	KinematicConstrainedVertexFitterT (const MagneticField *ifield, const LinearizationPointFinder &fnd)

void	setParameters (const edm::ParameterSet &pSet)

	~KinematicConstrainedVertexFitterT ()

Private Member Functions
void	defaultParameters ()

Private Attributes
float	csum

const MagneticField *	field

LinearizationPointFinder *	finder

int	iterations

ConstrainedTreeBuilderT *	tBuilder

float	theMaxDelta

float	theMaxReducedChiSq

int	theMaxStep

float	theMinChiSqImprovement

KinematicConstrainedVertexUpdatorT< nTrk, nConstraint > *	updator

VertexKinematicConstraintT *	vCons

Detailed Description

template<int nTrk, int nConstraint>
class KinematicConstrainedVertexFitterT< nTrk, nConstraint >

Class fitting the veretx out of set of tracks via usual LMS with Lagrange multipliers. Additional constraints can be applyed to the tracks during the vertex fit (solves non-factorizabele cases). Since the vertex constraint is included by default, do not add a separate VertexKinematicConstraint! Example: Vertex fit with collinear tracks..

Definition at line 25 of file KinematicConstrainedVertexFitterT.h.

Constructor & Destructor Documentation

◆ KinematicConstrainedVertexFitterT() [1/2]

template<int nTrk, int nConstraint>

KinematicConstrainedVertexFitterT< nTrk, nConstraint >::KinematicConstrainedVertexFitterT ( const MagneticField * ifield )

explicit

Default constructor using LMSLinearizationPointFinder

Definition at line 96 of file KinematicConstrainedVertexFitterT.h.

References KinematicConstrainedVertexFitterT< nTrk, nConstraint >::csum, KinematicConstrainedVertexFitterT< nTrk, nConstraint >::defaultParameters(), KinematicConstrainedVertexFitterT< nTrk, nConstraint >::finder, KinematicConstrainedVertexFitterT< nTrk, nConstraint >::iterations, KinematicConstrainedVertexFitterT< nTrk, nConstraint >::tBuilder, KinematicConstrainedVertexFitterT< nTrk, nConstraint >::updator, and KinematicConstrainedVertexFitterT< nTrk, nConstraint >::vCons.

     : field(ifield) {
   finder = new DefaultLinearizationPointFinder();
   vCons = new VertexKinematicConstraintT();
   updator = new KinematicConstrainedVertexUpdatorT<nTrk, nConstraint>();
   tBuilder = new ConstrainedTreeBuilderT;
   defaultParameters();
   iterations = -1;
   csum = -1000.0;
 }

◆ KinematicConstrainedVertexFitterT() [2/2]

template<int nTrk, int nConstraint>

KinematicConstrainedVertexFitterT< nTrk, nConstraint >::KinematicConstrainedVertexFitterT	(	const MagneticField *	ifield,
		const LinearizationPointFinder &	fnd
	)

Constructor with user-provided LinearizationPointFinder

Definition at line 108 of file KinematicConstrainedVertexFitterT.h.

References LinearizationPointFinder::clone(), KinematicConstrainedVertexFitterT< nTrk, nConstraint >::csum, KinematicConstrainedVertexFitterT< nTrk, nConstraint >::defaultParameters(), KinematicConstrainedVertexFitterT< nTrk, nConstraint >::finder, KinematicConstrainedVertexFitterT< nTrk, nConstraint >::iterations, KinematicConstrainedVertexFitterT< nTrk, nConstraint >::tBuilder, KinematicConstrainedVertexFitterT< nTrk, nConstraint >::updator, and KinematicConstrainedVertexFitterT< nTrk, nConstraint >::vCons.

     : field(ifield) {
   finder = fnd.clone();
   vCons = new VertexKinematicConstraintT();
   updator = new KinematicConstrainedVertexUpdatorT<nTrk, nConstraint>();
   tBuilder = new ConstrainedTreeBuilderT;
   defaultParameters();
   iterations = -1;
   csum = -1000.0;
 }

◆ ~KinematicConstrainedVertexFitterT()

template<int nTrk, int nConstraint>

KinematicConstrainedVertexFitterT< nTrk, nConstraint >::~KinematicConstrainedVertexFitterT ( )

Definition at line 121 of file KinematicConstrainedVertexFitterT.h.

References HLT_2024v14_cff::finder, and HLT_2024v14_cff::updator.

                                                                                          {
   delete finder;
   delete vCons;
   delete updator;
   delete tBuilder;
 }

Member Function Documentation

◆ defaultParameters()

template<int nTrk, int nConstraint>

void KinematicConstrainedVertexFitterT< nTrk, nConstraint >::defaultParameters ( )

private

Definition at line 137 of file KinematicConstrainedVertexFitterT.h.

Referenced by KinematicConstrainedVertexFitterT< nTrk, nConstraint >::KinematicConstrainedVertexFitterT().

                                                                              {
   theMaxDelta = 0.01;
   theMaxStep = 1000;
   theMaxReducedChiSq = 225.;
   theMinChiSqImprovement = 50.;
 }

◆ fit() [1/3]

template<int nTrk, int nConstraint>

RefCountedKinematicTree KinematicConstrainedVertexFitterT< nTrk, nConstraint >::fit ( const std::vector< RefCountedKinematicParticle > & part )

inline

Without additional constraint, this will perform a simple vertex fit using LMS with Lagrange multipliers method (by definition valid only if nConstraint=0)

Definition at line 50 of file KinematicConstrainedVertexFitterT.h.

References KinematicConstrainedVertexFitterT< nTrk, nConstraint >::fit().

Referenced by KinematicConstrainedVertexFitterT< nTrk, nConstraint >::fit(), trackingPlots.Iteration::modules(), and ConversionVertexFinder::run().

50 { return fit(part, 0, 0); }

part

Definition: HCALResponse.h:20

KinematicConstrainedVertexFitterT::fit

RefCountedKinematicTree fit(const std::vector< RefCountedKinematicParticle > &part)

Definition: KinematicConstrainedVertexFitterT.h:50

◆ fit() [2/3]

template<int nTrk, int nConstraint>

RefCountedKinematicTree KinematicConstrainedVertexFitterT< nTrk, nConstraint >::fit	(	const std::vector< RefCountedKinematicParticle > &	part,
		MultiTrackKinematicConstraintT< nTrk, nConstraint > *	cs
	)

inline

LMS with Lagrange multipliers fit of vertex constraint and user-specified constraint.

Definition at line 55 of file KinematicConstrainedVertexFitterT.h.

References callgraph::cs, and KinematicConstrainedVertexFitterT< nTrk, nConstraint >::fit().

Referenced by trackingPlots.Iteration::modules().

                                                                                      {
     return fit(part, cs, nullptr);
   };

◆ fit() [3/3]

template<int nTrk, int nConstraint>

RefCountedKinematicTree KinematicConstrainedVertexFitterT< nTrk, nConstraint >::fit	(	const std::vector< RefCountedKinematicParticle > &	part,
		MultiTrackKinematicConstraintT< nTrk, nConstraint > *	cs,
		GlobalPoint *	pt
	)

LMS with Lagrange multipliers fit of vertex constraint, user-specified constraint and user-specified starting point.

Definition at line 145 of file KinematicConstrainedVertexFitterT.h.

References cms::cuda::assert(), callgraph::cs, dumpMFGeometry_cfg::delta, HLT_2024v14_cff::finder, mps_fire::i, input, LogDebug, allConversions_cfi::maxDelta, primaryVertexAssociation_cfi::particles, DiDispStaMuonMonitor_cfi::pt, InputSort::sort(), HLT_2024v14_cff::updator, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by trackingPlots.Iteration::modules().

                      {
   assert(nConstraint == 0 || cs != nullptr);
   if (part.size() != nTrk)
     throw VertexException("KinematicConstrainedVertexFitterT::input states are not nTrk");
 
   //sorting out the input particles
   InputSort iSort;
   std::pair<std::vector<RefCountedKinematicParticle>, std::vector<FreeTrajectoryState> > input = iSort.sort(part);
   const std::vector<RefCountedKinematicParticle>& particles = input.first;
   const std::vector<FreeTrajectoryState>& fStates = input.second;
 
   // linearization point:
   GlobalPoint linPoint = (pt != nullptr) ? *pt : finder->getLinearizationPoint(fStates);
 
   //initial parameters:
   ROOT::Math::SVector<double, 3 + 7 * nTrk> inPar;   //3+ 7*ntracks
   ROOT::Math::SVector<double, 3 + 7 * nTrk> finPar;  //3+ 7*ntracks
 
   ROOT::Math::SMatrix<double, 3 + 7 * nTrk, 3 + 7 * nTrk, ROOT::Math::MatRepSym<double, 3 + 7 * nTrk> > inCov;
 
   //making initial vector of parameters and initial particle-related covariance
   int nSt = 0;
   std::vector<KinematicState> lStates(nTrk);
   for (std::vector<RefCountedKinematicParticle>::const_iterator i = particles.begin(); i != particles.end(); i++) {
     lStates[nSt] = (*i)->stateAtPoint(linPoint);
     KinematicState const& state = lStates[nSt];
     if (!state.isValid()) {
       LogDebug("KinematicConstrainedVertexFitter") << "State is invalid at point: " << linPoint << std::endl;
       return ReferenceCountingPointer<KinematicTree>(new KinematicTree());
     }
     inPar.Place_at(state.kinematicParameters().vector(), 3 + 7 * nSt);
     inCov.Place_at(state.kinematicParametersError().matrix(), 3 + 7 * nSt, 3 + 7 * nSt);
     ++nSt;
   }
 
   //initial vertex error matrix components (huge error method)
   //and vertex related initial vector components
   double in_er = 100.;
   inCov(0, 0) = in_er;
   inCov(1, 1) = in_er;
   inCov(2, 2) = in_er;
 
   inPar(0) = linPoint.x();
   inPar(1) = linPoint.y();
   inPar(2) = linPoint.z();
 
   //constraint equations value and number of iterations
   double eq;
   int nit = 0;
   iterations = 0;
   csum = 0.0;
 
   GlobalPoint lPoint = linPoint;
   RefCountedKinematicVertex rVtx;
   ROOT::Math::SMatrix<double, 3 + 7 * nTrk, 3 + 7 * nTrk, ROOT::Math::MatRepSym<double, 3 + 7 * nTrk> > refCCov =
       ROOT::Math::SMatrixNoInit();
 
   double chisq = 1e6;
   bool convergence = false;
 
   //iterarions over the updator: each time updated parameters
   //are taken as new linearization point
   do {
     eq = 0.;
     refCCov = inCov;
     std::vector<KinematicState> oldStates = lStates;
     GlobalVector mf = field->inInverseGeV(lPoint);
     rVtx = updator->update(inPar, refCCov, lStates, lPoint, mf, cs);
     if (particles.size() != lStates.size() || rVtx == nullptr) {
       LogDebug("KinematicConstrainedVertexFitter") << "updator failure\n";
       return ReferenceCountingPointer<KinematicTree>(new KinematicTree());
     }
 
     double newchisq = rVtx->chiSquared();
     if (nit > 2 && newchisq > theMaxReducedChiSq * rVtx->degreesOfFreedom() &&
         (newchisq - chisq) > (-theMinChiSqImprovement)) {
       LogDebug("KinematicConstrainedVertexFitter") << "bad chisq and insufficient improvement, bailing\n";
       return ReferenceCountingPointer<KinematicTree>(new KinematicTree());
     }
     chisq = newchisq;
 
     const GlobalPoint& newPoint = rVtx->position();
 
     double maxDelta = 0.0;
 
     double deltapos[3];
     deltapos[0] = newPoint.x() - lPoint.x();
     deltapos[1] = newPoint.y() - lPoint.y();
     deltapos[2] = newPoint.z() - lPoint.z();
     for (int i = 0; i < 3; ++i) {
       double delta = deltapos[i] * deltapos[i] / rVtx->error().matrix()(i, i);
       if (delta > maxDelta)
         maxDelta = delta;
     }
 
     for (std::vector<KinematicState>::const_iterator itold = oldStates.begin(), itnew = lStates.begin();
          itnew != lStates.end();
          ++itold, ++itnew) {
       for (int i = 0; i < 7; ++i) {
         double deltapar = itnew->kinematicParameters()(i) - itold->kinematicParameters()(i);
         double delta = deltapar * deltapar / itnew->kinematicParametersError().matrix()(i, i);
         if (delta > maxDelta)
           maxDelta = delta;
       }
     }
 
     lPoint = newPoint;
 
     nit++;
     convergence = maxDelta < theMaxDelta || (nit == theMaxStep && maxDelta < 4.0 * theMaxDelta);
 
   } while (nit < theMaxStep && !convergence);
 
   if (!convergence) {
     return ReferenceCountingPointer<KinematicTree>(new KinematicTree());
   }
 
   // std::cout << "new full cov matrix" << std::endl;
   // std::cout << refCCov << std::endl;
 
   iterations = nit;
   csum = eq;
 
   return tBuilder->buildTree<nTrk>(particles, lStates, rVtx, refCCov);
 }

◆ getCSum()

template<int nTrk, int nConstraint>

float KinematicConstrainedVertexFitterT< nTrk, nConstraint >::getCSum ( ) const

Definition at line 280 of file KinematicConstrainedVertexFitterT.h.

                                                                           {
   return csum;
 }

◆ getNit()

template<int nTrk, int nConstraint>

int KinematicConstrainedVertexFitterT< nTrk, nConstraint >::getNit ( ) const

Definition at line 275 of file KinematicConstrainedVertexFitterT.h.

Referenced by ConversionVertexFinder::run().

                                                                        {
   return iterations;
 }

◆ setParameters()

template<int nTrk, int nConstraint>

void KinematicConstrainedVertexFitterT< nTrk, nConstraint >::setParameters ( const edm::ParameterSet & pSet )

Configuration through PSet: number of iterations(maxDistance) and stopping condition (maxNbrOfIterations)

Definition at line 129 of file KinematicConstrainedVertexFitterT.h.

References edm::ParameterSet::getParameter().

Referenced by ConversionVertexFinder::run().

                                                                                                     {
   theMaxDelta = pSet.getParameter<double>("maxDelta");
   theMaxStep = pSet.getParameter<int>("maxNbrOfIterations");
   theMaxReducedChiSq = pSet.getParameter<double>("maxReducedChiSq");
   theMinChiSqImprovement = pSet.getParameter<double>("minChiSqImprovement");
 }