class to manage the order of constraints and their filtering More...

#include <Constraint.h>

Inheritance diagram for Constraint:

Collaboration diagram for Constraint:

[legend]

Public Types
enum	Type { unknown = 0 , beamenergy , beamspot , beam , origin , lifetime , resonance , composite , track , photon , klong , conversion , kinematic , geometric , mass , massEnergy , merged , ntypes , helix }
	type of constraints the order of these constraints is important: it is the order in which they are applied.

Public Member Functions
bool	operator< (const Constraint &rhs) const
	operator used to sort the constraints

bool	operator== (const Constraint &rhs) const
	operator

Type	type () const
	get type of constraint

unsigned int	dim () const
	get dimension of constraint

bool	isLinear () const
	is this a linear constraint

unsigned int	nIter () const
	get maximum number of iterations for non in constraint

	Constraint ()
	constructor

	Constraint (const ParticleBase *node, Type type, int depth, unsigned int dim, int maxniter=1)
	constructor

virtual	~Constraint ()
	destructor

virtual ErrCode	project (const FitParams &fitpar, Projection &p) const
	call the constraints projection function

virtual ErrCode	filter (FitParams &fitpar)
	filter this constraint More...

virtual ErrCode	filterWithReference (FitParams &fitpar, const FitParams &oldState)
	filter this constraint More...

std::string	name () const
	get name of constraint

void	setWeight (int w)
	used to be able to weight the constraints

Protected Member Functions
	Constraint (Constraint::Type type)
	constructor

void	setDim (unsigned int d)
	set dimension of constraint

void	setNIter (unsigned int d)
	set max number of iterations for non lin constraint

Private Attributes
const ParticleBase *	m_node
	particle behind the constraint

int	m_depth
	chi2 coming from the constraint More...

Type	m_type
	type of constraint

unsigned int	m_dim
	dimension of constraint

int	m_weight
	weight of this constraint currently we set them all to unity

int	m_maxNIter
	maximum number of iterations for non-linear constraints

Detailed Description

class to manage the order of constraints and their filtering

Definition at line 20 of file Constraint.h.

Member Function Documentation

◆ filter()

ErrCode filter ( FitParams & fitpar )

virtual

filter this constraint

We don't have reference state yet so we use the k-1 last state to linearize non-linear constraints

Definition at line 28 of file Constraint.cc.

   {
     ErrCode status;
     Projection p(fitpar.getDimensionOfState(), m_dim);
     KalmanCalculator kalman(m_dim, fitpar.getDimensionOfState());
  
     double chisq(0);
     int iter(0);
     bool finished(false) ;
  
     double accumulated_chi2 = 0;
     while (!finished && !status.failure()) {
  
       p.resetProjection();
       status |= project(fitpar, p);
  
       if (!status.failure()) {
  
         status |= kalman.calculateGainMatrix(
                     p.getResiduals(),
                     p.getH(),
                     fitpar,
                     &p.getV(),
                     1
                   );
  
         if (!status.failure()) {
           kalman.updateState(fitpar);
  
           // r R^-1 r
           double newchisq = kalman.getChiSquare();
  
           double dchisqconverged = 0.001 ;
  
           double dchisq = newchisq - chisq;
           bool diverging = iter > 0 && dchisq > 0;
           bool converged = std::abs(dchisq) < dchisqconverged;
           finished  = ++iter >= m_maxNIter || diverging || converged;
           chisq = newchisq;
           accumulated_chi2 += newchisq;
         }
       }
     }
  
     const unsigned int number_of_constraints = kalman.getConstraintDim();
     fitpar.addChiSquare(accumulated_chi2, number_of_constraints);
  
     kalman.updateCovariance(fitpar);
     return status;
   }

◆ filterWithReference()

ErrCode filterWithReference	(	FitParams &	fitpar,
		const FitParams &	oldState
	)

virtual

filter this constraint

We now linearise around the last iteration \alpha (const FitParams& oldState) In this implementation we can no longer linearize non-linear constraints but we ensured by the linearisation around the last state that the step size is small enough so we just use them as if they were linear

here we project the old state and use only the change with respect to the new state instead of the new state in the update . the advantage is more stable fit Downside: non-linear constraints can't be filtered multiple times anymore.

Definition at line 83 of file Constraint.cc.

Member Data Documentation

◆ m_depth

int m_depth

private

chi2 coming from the constraint

depth of the constraint in the tree (determines for example the order of the track constraints)

Definition at line 137 of file Constraint.h.

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

analysis/VertexFitting/TreeFitter/include/Constraint.h
analysis/VertexFitting/TreeFitter/src/Constraint.cc

Public Types

Public Member Functions