#include <Chi2VertexFitter.h>

Inheritance diagram for tauImpactParameter::Chi2VertexFitter:

Public Member Functions
	Chi2VertexFitter (const std::vector< TrackParticle > &particles, const TVector3 &vguess, double nsigma=4.0)

bool	fit () override

	~Chi2VertexFitter () override

Public Member Functions inherited from tauImpactParameter::TrackHelixVertexFitter
virtual double	chiSquare ()

LorentzVectorParticle	getMother (int pdgid)

std::vector< LorentzVectorParticle >	getRefitLorentzVectorParticles ()

virtual std::vector< TrackParticle >	getRefitTracks ()

virtual TVector3	getVertex ()

virtual TMatrixTSym< double >	getVertexError ()

virtual double	ndf ()

	TrackHelixVertexFitter (const std::vector< TrackParticle > &particles, const TVector3 &vguess)

virtual double	updateChisquare (const TVectorT< double > &inpar)

virtual	~TrackHelixVertexFitter ()

Private Attributes
double	nsigma_

Additional Inherited Members
Public Types inherited from tauImpactParameter::TrackHelixVertexFitter
enum	ExtraPar { BField0 = 0, MassOffSet = 1, NExtraPar = 1 }

enum	FreeTrackPar { kappa0 = 3, lambda0, phi0, NFreeTrackPar }

enum	FreeVertexPar { x0 = 0, y0, z0, NFreeVertexPar }

Static Public Member Functions inherited from tauImpactParameter::TrackHelixVertexFitter
static void	computedxydz (const TVectorT< double > &inpar, int particle, double &kappa, double &lam, double &phi, double &x, double &y, double &z, double &s, double &dxy, double &dz)

static TVectorT< double >	computeLorentzVectorPar (const TVectorT< double > &inpar)

Protected Member Functions inherited from tauImpactParameter::TrackHelixVertexFitter
virtual TString	freeParName (int Par)

Protected Attributes inherited from tauImpactParameter::TrackHelixVertexFitter
double	chi2_

bool	isConfigured_

bool	isFit_

double	ndf_

TVectorT< double >	par_

TMatrixTSym< double >	parcov_

Detailed Description

Definition at line 16 of file Chi2VertexFitter.h.

Constructor & Destructor Documentation

◆ Chi2VertexFitter()

tauImpactParameter::Chi2VertexFitter::Chi2VertexFitter	(	const std::vector< TrackParticle > &	particles,
		const TVector3 &	vguess,
		double	nsigma = `4.0`
	)

inline

Definition at line 18 of file Chi2VertexFitter.h.

19 : TrackHelixVertexFitter(particles, vguess), nsigma_(nsigma){};

◆ ~Chi2VertexFitter()

tauImpactParameter::Chi2VertexFitter::~Chi2VertexFitter ( )

inlineoverride

Definition at line 20 of file Chi2VertexFitter.h.

20 {};

Member Function Documentation

◆ fit()

bool Chi2VertexFitter::fit ( void )

overridevirtual

Implements tauImpactParameter::TrackHelixVertexFitter.

Definition at line 26 of file Chi2VertexFitter.cc.

                            {
   if (isFit_ == true)
     return true;  // do not refit
   if (!isConfigured_)
     return false;  // do not fit if configuration failed
   ChiSquareFunctionUpdator updator(this);
   ROOT::Minuit2::MnUserParameters MnPar;
   for (int i = 0; i < par_.GetNrows(); i++) {
     TString name = freeParName(i);
     // if not limited (vhigh <= vlow)
     MnPar.Add(name.Data(),
               par_(i),
               sqrt(fabs(parcov_(i, i))),
               par_(i) - nsigma_ * sqrt(fabs(parcov_(i, i))),
               par_(i) + nsigma_ * sqrt(fabs(parcov_(i, i))));
   }
  
   unsigned int max = 10;
   int numberofcalls = 200 + par_.GetNrows() * 100 + par_.GetNrows() * par_.GetNrows() * 5;
   double tolerance(0.01);
   double edmMin(0.001 * updator.Up() * tolerance);
  
   ROOT::Minuit2::MnMinimize minimize(updator, MnPar);
   ROOT::Minuit2::FunctionMinimum min = minimize(numberofcalls, tolerance);
   for (unsigned int i = 0; i <= max && min.Edm() > edmMin; i++) {
     if (i == max)
       return false;
     min = minimize(i * numberofcalls, tolerance);
   }
   // give return flag based on status
   if (min.IsAboveMaxEdm()) {
     edm::LogWarning("Chi2VertexFitter::Fit") << "Found Vertex that is above EDM " << std::endl;
     return false;
   }
   if (!min.IsValid()) {
     edm::LogWarning("Chi2VertexFitter::Fit") << "Failed min.IsValid()" << std::endl;
     if (!min.HasValidParameters()) {
       edm::LogWarning("Chi2VertexFitter::Fit") << "Failed min.HasValidParameters()" << std::endl;
     }
     if (!min.HasValidCovariance()) {
       edm::LogWarning("Chi2VertexFitter::Fit") << "Failed min.HasValidCovariance()" << std::endl;
     }
     if (!min.HesseFailed()) {
       edm::LogWarning("Chi2VertexFitter::Fit") << "Failed min.HesseFailed()" << std::endl;
     }
     if (!min.HasReachedCallLimit()) {
       edm::LogWarning("Chi2VertexFitter::Fit") << "Failed min.HasReachedCallLimit()" << std::endl;
     }
     return false;
   }
   chi2_ = min.Fval();
   // Get output parameters
   for (int i = 0; i < par_.GetNrows(); i++) {
     par_(i) = min.UserParameters().Value(i);
   }
   // Get output covariance
   for (int i = 0; i < par_.GetNrows(); i++) {
     for (int j = 0; j < par_.GetNrows(); j++) {
       parcov_(i, j) = min.UserCovariance()(i, j);
     }
   }
  
   isFit_ = true;
   return isFit_;
 }