Abstract base class for constraints of kinematic fits. More...

#include <BaseHardConstraint.h>

Inheritance diagram for BaseHardConstraint:

[legend]

Collaboration diagram for BaseHardConstraint:

[legend]

Public Member Functions
virtual	~BaseHardConstraint ()
	Virtual destructor.

virtual void	add1stDerivativesToMatrix (double *M, int idim) const
	Adds first order derivatives to global covariance matrix M.

virtual void	add2ndDerivativesToMatrix (double *M, int idim, double lambda) const
	Adds second order derivatives to global covariance matrix M.

virtual void	addToGlobalChi2DerVector (double *y, int idim, double lambda) const
	Add lambda times derivatives of chi squared to global derivative vector.

virtual double	dirDer (double p, double w, int idim, double mu=1)
	Calculate directional derivative.

virtual double	dirDerAbs (double p, double w, int idim, double mu=1)
	Calculate directional derivative for abs(c)

virtual bool	secondDerivatives (int i, int j, double *derivatives) const =0
	Second derivatives with respect to the meta-variables of Fit objects i and j; result false if all derivatives are zero.

virtual bool	firstDerivatives (int i, double *derivatives) const =0
	First derivatives with respect to the meta-variables of Fit objects i; result false if all derivatives are zero.

virtual int	getVarBasis () const =0

virtual double	getValue () const override=0
	Returns the value of the constraint.

virtual double	getError () const override
	Returns the error on the value of the constraint.

virtual void	getDerivatives (int idim, double der[]) const override=0
	Get first order derivatives.

virtual int	getGlobalNum () const
	Accesses position of constraint in global constraint list.

virtual void	setGlobalNum (int iglobal)
	Sets position of constraint in global constraint list.

virtual void	printFirstDerivatives () const

virtual void	printSecondDerivatives () const

virtual void	test1stDerivatives ()

virtual void	test2ndDerivatives ()

virtual double	num1stDerivative (int ifo, int ilocal, double eps)
	Evaluates numerically the 1st derivative w.r.t. a parameter.

virtual double	num2ndDerivative (int ifo1, int ilocal1, double eps1, int ifo2, int ilocal2, double eps2)
	Evaluates numerically the 2nd derivative w.r.t. 2 parameters.

virtual const char *	getName () const
	Returns the name of the constraint.

void	setName (const char *name_)
	Set object's name.

virtual std::ostream &	print (std::ostream &os) const
	print object to ostream

Protected Types
typedef std::vector< BaseFitObject * >	FitObjectContainer
	Vector of pointers to ParticleFitObjects.

typedef FitObjectContainer::iterator	FitObjectIterator
	Iterator through vector of pointers to ParticleFitObjects.

typedef FitObjectContainer::const_iterator	ConstFitObjectIterator
	Constant iterator through vector of pointers to ParticleFitObjects.

Protected Attributes
FitObjectContainer	fitobjects
	The FitObjectContainer.

std::vector< double >	derivatives
	The derivatives.

std::vector< int >	flags
	The flags can be used to divide the FitObjectContainer into several subsets used for example to implement an equal mass constraint (see MassConstraint).

int	globalNum
	Position of constraint in global constraint list.

char *	name

Related Functions
(Note that these are not member functions.)
std::ostream &	operator<< (std::ostream &os, const BaseConstraint &bc)
	Prints out a BaseConstraint, using its print method.

Detailed Description

Abstract base class for constraints of kinematic fits.

This class defines the minimal functionality any constraint class must provide. First of all a constraint should know on with particles (or FitObject) it is applied. Where as for example a constraint on the total transvese momentum takes into account all particles in the event, an invariant mass constraint usually applies only to a subset of particles.

The particle list is implemented as a vector containing pointers to objects derived from BaseFitObject and can be either set a whole (setFOList) or enlarged by adding a single BaseFitObject (addToFOList).

From the four–momenta of all concerned fit objects the constraint has to be able to calculate its current value (getValue). Constraints should be formulated such that a value of zero corresponds to a perfectly fulfilled constraint.

In order to find a solution to the constrained minimisation problem, fit algorithms usually need the first order derivatives of the constraint with respect to the fit parameters. Since many constraints can be most easily expressed in terms of E, px, py, pz, the constraints supply their derivatives w.r.t. these parameters. If a FitObject uses a different parametrisation, it is its own task to provide the additional derivatives of E, px, py, pz w.r.t. the parameters of the FitObject. Thus it is easily possible to use FitObjects with different kinds of parametrisations under the same constraint. Some fit algorithms also need the second derivatives of the constraint, i.e. the NewtonFitter.

First and second order derivatives of each constraint can be added directly to the global covariance matrix containing the derivatives of all constraints w.r.t. to all parameters (add1stDerivativesToMatrix, add2ndDerivativesToMatrix). This requires the constraint to know its position in the overall list of constraints (globalNum).

Author: Jenny List, Benno List Last update:

Date: 2011/03/03 15:03:02

by:

Author: blist

Definition at line 75 of file BaseHardConstraint.h.

Member Typedef Documentation

◆ ConstFitObjectIterator

typedef FitObjectContainer::const_iterator ConstFitObjectIterator

protected

Constant iterator through vector of pointers to ParticleFitObjects.

Definition at line 175 of file BaseHardConstraint.h.

◆ FitObjectContainer

typedef std::vector<BaseFitObject*> FitObjectContainer

protected

Vector of pointers to ParticleFitObjects.

Definition at line 171 of file BaseHardConstraint.h.

◆ FitObjectIterator

typedef FitObjectContainer::iterator FitObjectIterator

protected

Iterator through vector of pointers to ParticleFitObjects.

Definition at line 173 of file BaseHardConstraint.h.

Constructor & Destructor Documentation

◆ BaseHardConstraint()

BaseHardConstraint ( )

inline

Definition at line 189 of file BaseHardConstraint.h.

      : fitobjects(FitObjectContainer()), derivatives(std::vector <double> ()), flags(std::vector <int> ()), globalNum(0)
    {
    }

Member Function Documentation

◆ add1stDerivativesToMatrix()

void add1stDerivativesToMatrix	(	double *	M,
		int	idim
	)		const

virtual

Adds first order derivatives to global covariance matrix M.

Parameters

M	Global covariance matrix, dimension at least idim x idim
idim	First dimension of array der

Definition at line 37 of file BaseHardConstraint.cc.

    {
      double dgdpi[BaseDefs::MAXINTERVARS];
      for (unsigned int i = 0; i < fitobjects.size(); ++i) {
        const BaseFitObject* foi = fitobjects[i];
        assert(foi);
        if (firstDerivatives(i, dgdpi)) {
          foi->addTo1stDerivatives(M, idim, dgdpi, getGlobalNum(), getVarBasis());
        }
      }
    }

◆ add2ndDerivativesToMatrix()

void add2ndDerivativesToMatrix	(	double *	M,
		int	idim,
		double	lambda
	)		const

virtual

Adds second order derivatives to global covariance matrix M.

Calculates the second derivative of the constraint g w.r.t.

the various parameters, multiplies it by lambda and adds it to the global covariance matrix

in case of particlefitobject: We denote with P_i the 4-vector of the i-th ParticleFitObject, then

$\frac{\partial ^2 g}{\partial a_k \partial a_l} = \sum_i \sum_j \frac{\partial ^2 g}{\partial P_i \partial P_j} \cdot \frac{\partial P_i}{\partial a_k} \cdot \frac{\partial P_j}{\partial a_l} + \sum_i \frac{\partial g}{\partial P_i} \cdot \frac{\partial^2 P_i}{\partial a_k \partial a_l}$

Here, $\frac{\partial P_i}{\partial a_k}$ is a $4 \times n_i$ Matrix, where is the number of parameters of FitObject i; Correspondingly, $\frac{\partial^2 P_i}{\partial a_k \partial a_l}$ is a $4 \times n_i \times n_i$ matrix. Also, $\frac{\partial ^2 g}{\partial P_i \partial P_j}$ is a $4\times 4$ matrix for a given i and j, and $\frac{\partial g}{\partial P_i}$ is a 4-vector (though not a Lorentz-vector!).

but here it's been generalised

First, treat the part

$\frac{\partial ^2 g}{\partial P_i \partial P_j} \cdot \frac{\partial P_i}{\partial a_k} \cdot \frac{\partial P_j}{\partial a_l}$

Second, treat the part

$\sum_i \frac{\partial g}{\partial P_i} \cdot \frac{\partial^2 P_i}{\partial a_k \partial a_l}$

Here, $\frac{\partial g}{\partial P_i}$ is a 4-vector, which we pass on to the FitObject

Parameters

M	Global covariance matrix, dimension at least idim x idim
idim	First dimension of array der
lambda	Lagrange multiplier for this constraint

Definition at line 76 of file BaseHardConstraint.cc.

    {
 
      // Derivatives \f$\frac{\partial ^2 g}{\partial P_i \partial P_j}\f$ at fixed i, j
      // d2GdPidPj[4*ii+jj] is derivative w.r.t. P_i,ii and P_j,jj, where ii=0,1,2,3 for E,px,py,pz
      double d2GdPidPj[BaseDefs::MAXINTERVARS * BaseDefs::MAXINTERVARS];
 
      // Derivatives \f$\frac {\partial P_i}{\partial a_k}\f$ for all i;
      // k is local parameter number
      // dPidAk[KMAX*4*i + 4*k + ii] is \f$\frac {\partial P_{i,ii}}{\partial a_k}\f$,
      // with ii=0, 1, 2, 3 for E, px, py, pz
      const int n = fitobjects.size();
      auto* dPidAk = new double[n * BaseDefs::MAXPAR * BaseDefs::MAXINTERVARS];
      bool* dPidAkval = new bool[n];
 
      for (int i = 0; i < n; ++i) dPidAkval[i] = false;
 
      // Derivatives \f$\frac{\partial ^2 g}{\partial P_i \partial a_l}\f$ at fixed i
      // d2GdPdAl[4*l + ii] is \f$\frac{\partial ^2 g}{\partial P_{i,ii} \partial a_l}\f$
      double d2GdPdAl[static_cast<int>(BaseDefs::MAXINTERVARS) * BaseDefs::MAXPAR];
      // Derivatives \f$\frac{\partial ^2 g}{\partial a_k \partial a_l}\f$
      double d2GdAkdAl[BaseDefs::MAXPAR * BaseDefs::MAXPAR] = {0};
 
      // Global parameter numbers: parglobal[BaseDefs::MAXPAR*i+klocal]
      // is global parameter number of local parameter klocal of i-th Fit object
      int* parglobal = new int[BaseDefs::MAXPAR * n];
 
      for (int i = 0; i < n; ++i) {
        const BaseFitObject* foi =  fitobjects[i];
        assert(foi);
        for (int klocal = 0; klocal < foi->getNPar(); ++klocal) {
          parglobal [BaseDefs::MAXPAR * i + klocal] = foi->getGlobalParNum(klocal);
        }
      }
 
 
      for (int i = 0; i < n; ++i) {
        const BaseFitObject* foi =  fitobjects[i];
        assert(foi);
        for (int j = 0; j < n; ++j) {
          const BaseFitObject* foj =  fitobjects[j];
          assert(foj);
          if (secondDerivatives(i, j, d2GdPidPj)) {
            if (!dPidAkval[i]) {
              foi->getDerivatives(dPidAk + i * (static_cast<int>(BaseDefs::MAXPAR) * BaseDefs::MAXINTERVARS),
                                  static_cast<int>(BaseDefs::MAXPAR) * BaseDefs::MAXINTERVARS);
              dPidAkval[i] = true;
            }
            if (!dPidAkval[j]) {
              foj->getDerivatives(dPidAk + j * (static_cast<int>(BaseDefs::MAXPAR) * BaseDefs::MAXINTERVARS),
                                  static_cast<int>(BaseDefs::MAXPAR) * BaseDefs::MAXINTERVARS);
              dPidAkval[j] = true;
            }
            // Now sum over E/px/Py/Pz for object j:
            // \f[
            //   \frac{\partial ^2 g}{\partial P_{i,ii} \partial a_l}
            //   = (sum_{j}) sum_{jj} frac{\partial ^2 g}{\partial P_{i,ii} \partial P_{j,jj}}
            //     \cdot \frac{\partial P_{j,jj}}{\partial a_l}
            // \f]
            // We're summing over jj here
            for (int llocal = 0; llocal < foj->getNPar(); ++llocal) {
              for (int ii = 0; ii < BaseDefs::MAXINTERVARS; ++ii) {
                int ind1 = BaseDefs::MAXINTERVARS * ii;
                int ind2 = (static_cast<int>(BaseDefs::MAXPAR) * BaseDefs::MAXINTERVARS) * j + BaseDefs::MAXINTERVARS * llocal;
                double& r = d2GdPdAl[BaseDefs::MAXINTERVARS * llocal + ii];
                r  = d2GdPidPj[  ind1] * dPidAk[  ind2];   // E
                r += d2GdPidPj[++ind1] * dPidAk[++ind2];   // px
                r += d2GdPidPj[++ind1] * dPidAk[++ind2];   // py
                r += d2GdPidPj[++ind1] * dPidAk[++ind2];   // pz
              }
            }
            // Now sum over E/px/Py/Pz for object i, i.e. sum over ii:
            // \f[
            // \frac{\partial ^2 g}{\partial a_k \partial a_l}
            //      = \sum_{ii} \frac{\partial ^2 g}{\partial P_{i,ii} \partial a_l} \cdot
            //        \frac{\partial P_{i,ii}}{\partial a_k}
            // \f]
            for (int klocal = 0; klocal < foi->getNPar(); ++klocal) {
              for (int llocal = 0; llocal < foj->getNPar(); ++llocal) {
                int ind1 = BaseDefs::MAXINTERVARS * llocal;
                int ind2 = (static_cast<int>(BaseDefs::MAXPAR) * BaseDefs::MAXINTERVARS) * i + BaseDefs::MAXINTERVARS * klocal;
                double& r = d2GdAkdAl[BaseDefs::MAXPAR * klocal + llocal];
                r  = d2GdPdAl[  ind1] * dPidAk[  ind2];    //E
                r += d2GdPdAl[++ind1] * dPidAk[++ind2];   // px
                r += d2GdPdAl[++ind1] * dPidAk[++ind2];   // py
                r += d2GdPdAl[++ind1] * dPidAk[++ind2];   // pz
              }
            }
            // Now expand the local parameter numbers to global ones
            for (int klocal = 0; klocal < foi->getNPar(); ++klocal) {
              int kglobal = parglobal [BaseDefs::MAXPAR * i + klocal];
              for (int llocal = 0; llocal < foj->getNPar(); ++llocal) {
                int lglobal = parglobal [BaseDefs::MAXPAR * j + llocal];
                M [idim * kglobal + lglobal] += lambda * d2GdAkdAl[BaseDefs::MAXPAR * klocal + llocal];
              }
            }
          }
        }
      }
      double dgdpi[BaseDefs::MAXINTERVARS];
      for (int i = 0; i < n; ++i) {
        const BaseFitObject* foi = fitobjects[i];
        assert(foi);
        if (firstDerivatives(i, dgdpi)) {
          foi->addTo2ndDerivatives(M, idim, lambda, dgdpi, getVarBasis());
        }
      }
 
      delete[] dPidAk;
      delete[] dPidAkval;
      delete[] parglobal;
    }

◆ addToGlobalChi2DerVector()

void addToGlobalChi2DerVector	(	double *	y,
		int	idim,
		double	lambda
	)		const

virtual

Add lambda times derivatives of chi squared to global derivative vector.

Parameters

y	Vector of chi2 derivatives
idim	Vector size

Definition at line 204 of file BaseHardConstraint.cc.

    {
      double dgdpi[BaseDefs::MAXINTERVARS];
      for (unsigned int i = 0; i < fitobjects.size(); ++i) {
        const BaseFitObject* foi = fitobjects[i];
        assert(foi);
        if (firstDerivatives(i, dgdpi)) {
          foi->addToGlobalChi2DerVector(y, idim, lambda, dgdpi, getVarBasis());
        }
      }
    }

◆ dirDer()

double dirDer	(	double *	p,
		double *	w,
		int	idim,
		double	mu = `1`
	)

virtual

Calculate directional derivative.

Parameters

p	Vector of direction
w	Work vector
idim	Vector size
mu	optional multiplier

Definition at line 232 of file BaseHardConstraint.cc.

    {
      double* pw, *pp;
      for (pw = w; pw < w + idim; * (pw++) = 0);
      addToGlobalChi2DerVector(w, idim, mu);
      double result = 0;
      for (pw = w, pp = p; pw < w + idim; result += *(pp++) * *(pw++));
      return mu * result;
    }

◆ dirDerAbs()

double dirDerAbs	(	double *	p,
		double *	w,
		int	idim,
		double	mu = `1`
	)

virtual

Calculate directional derivative for abs(c)

Parameters

p	Vector of direction
w	Work vector
idim	Vector size
mu	optional multiplier

Definition at line 242 of file BaseHardConstraint.cc.

    {
      double val = getValue();
      if (val == 0) return mu * std::fabs(dirDer(p, w, idim, 1));
      else if (val > 0) return mu * dirDer(p, w, idim, 1);
      else return -mu * dirDer(p, w, idim, 1);
    }

◆ firstDerivatives()

virtual bool firstDerivatives	(	int	i,
		double *	derivatives
	)		const

pure virtual

First derivatives with respect to the meta-variables of Fit objects i; result false if all derivatives are zero.

Parameters

i	number of 1st FitObject
derivatives	The result 4-vector

Implemented in MassConstraint, MomentumConstraint, and RecoilMassConstraint.

◆ getDerivatives()

virtual void getDerivatives	(	int	idim,
		double	der[]
	)		const

overridepure virtual

Get first order derivatives.

Call this with a predefined array "der" with the necessary number of entries!

Parameters

idim	First dimension of the array
der	Array of derivatives, at least idim x idim

Implements BaseConstraint.

Implemented in MassConstraint, MomentumConstraint, and RecoilMassConstraint.

◆ getError()

double getError ( ) const

overridevirtual

Returns the error on the value of the constraint.

Reimplemented from BaseConstraint.

Definition at line 217 of file BaseHardConstraint.cc.

    {
      double dgdpi[BaseDefs::MAXINTERVARS];
      double error2 = 0;
      for (unsigned int i = 0; i < fitobjects.size(); ++i) {
        const BaseFitObject* foi = fitobjects[i];
        assert(foi);
        if (firstDerivatives(i, dgdpi)) {
          error2 += foi->getError2(dgdpi, getVarBasis());
        }
      }
      return std::sqrt(std::abs(error2));
    }

◆ getGlobalNum()

virtual int getGlobalNum ( ) const

inlinevirtual

Accesses position of constraint in global constraint list.

Definition at line 137 of file BaseHardConstraint.h.

138 {return globalNum;}

◆ getName()

const char * getName ( ) const

virtualinherited

Returns the name of the constraint.

Definition at line 56 of file BaseConstraint.cc.

    {
      return name;
    }

◆ getValue()

virtual double getValue ( ) const

overridepure virtual

Returns the value of the constraint.

Implements BaseConstraint.

Implemented in MassConstraint, MomentumConstraint, and RecoilMassConstraint.

◆ num1stDerivative()

double num1stDerivative	(	int	ifo,
		int	ilocal,
		double	eps
	)

virtual

Evaluates numerically the 1st derivative w.r.t. a parameter.

Parameters

ifo	Number of FitObject
ilocal	Local parameter number
eps	variation of local parameter

Definition at line 307 of file BaseHardConstraint.cc.

    {
      BaseFitObject* fo =  fitobjects[ifo];
      assert(fo);
      double save = fo->getParam(ilocal);
      fo->setParam(ilocal, save + eps);
      double v1 = getValue();
      fo->setParam(ilocal, save - eps);
      double v2 = getValue();
      double result = (v1 - v2) / (2 * eps);
      fo->setParam(ilocal, save);
      return result;
    }

◆ num2ndDerivative()

double num2ndDerivative	(	int	ifo1,
		int	ilocal1,
		double	eps1,
		int	ifo2,
		int	ilocal2,
		double	eps2
	)

virtual

Evaluates numerically the 2nd derivative w.r.t. 2 parameters.

Parameters

ifo1	Number of 1st FitObject
ilocal1	1st local parameter number
eps1	variation of 1st local parameter
ifo2	Number of 1st FitObject
ilocal2	1st local parameter number
eps2	variation of 2nd local parameter

Definition at line 321 of file BaseHardConstraint.cc.

    {
      double result;
 
      if (ifo1 == ifo2 && ilocal1 == ilocal2) {
        BaseFitObject* fo =  fitobjects[ifo1];
        assert(fo);
        double save = fo->getParam(ilocal1);
        double v0 = getValue();
        fo->setParam(ilocal1, save + eps1);
        double v1 = getValue();
        fo->setParam(ilocal1, save - eps1);
        double v2 = getValue();
        result = (v1 + v2 - 2 * v0) / (eps1 * eps1);
        fo->setParam(ilocal1, save);
      } else {
        BaseFitObject* fo1 =  fitobjects[ifo1];
        assert(fo1);
        BaseFitObject* fo2 =  fitobjects[ifo2];
        assert(fo2);
        double save1 = fo1->getParam(ilocal1);
        double save2 = fo2->getParam(ilocal2);
        fo1->setParam(ilocal1, save1 + eps1);
        fo2->setParam(ilocal2, save2 + eps2);
        double v11 = getValue();
        fo2->setParam(ilocal2, save2 - eps2);
        double v12 = getValue();
        fo1->setParam(ilocal1, save1 - eps1);
        double v22 = getValue();
        fo2->setParam(ilocal2, save2 + eps2);
        double v21 = getValue();
        result = (v11 + v22 - v12 - v21) / (4 * eps1 * eps2);
        fo1->setParam(ilocal1, save1);
        fo2->setParam(ilocal2, save2);
      }
      return result;
    }

◆ print()

std::ostream & print ( std::ostream & os ) const

virtualinherited

print object to ostream

Parameters

os	The output stream

Definition at line 76 of file BaseConstraint.cc.

    {
      os << getName() << "=" << getValue();
      return os;
    }

◆ printFirstDerivatives()

void printFirstDerivatives ( ) const

virtual

Definition at line 360 of file BaseHardConstraint.cc.

    {
 
      B2INFO("BaseHardConstraint::printFirstDerivatives " << fitobjects.size());
 
      double dgdpi[BaseDefs::MAXINTERVARS];
      for (unsigned int i = 0; i < fitobjects.size(); ++i) {
        const BaseFitObject* foi = fitobjects[i];
        assert(foi);
        if (firstDerivatives(i, dgdpi)) {
          B2INFO("first derivs for obj " << i << " : ");
          for (double j : dgdpi)
            B2INFO(j << " ");
        }
      }
 
      return;
    }

◆ printSecondDerivatives()

void printSecondDerivatives ( ) const

virtual

Definition at line 379 of file BaseHardConstraint.cc.

    {
 
      double d2GdPidPj[BaseDefs::MAXINTERVARS * BaseDefs::MAXINTERVARS];
 
      int n = fitobjects.size();
 
      for (int i = 0; i < n; ++i) {
        const BaseFitObject* foi =  fitobjects[i];
        assert(foi);
        for (int j = 0; j < n; ++j) {
          const BaseFitObject* foj =  fitobjects[j];
          assert(foj);
          if (secondDerivatives(i, j, d2GdPidPj)) {
 
            B2INFO("second derivs for objs " << i << " " << j);
 
            int k(0);
            for (int k1 = 0; k1 < BaseDefs::MAXINTERVARS; k1++) {
              for (int k2 = 0; k2 < BaseDefs::MAXINTERVARS; k2++) {
                B2INFO(d2GdPidPj[k++] << " ");
              }
            }
          }
        }
      }
 
      return;
    }

◆ secondDerivatives()

virtual bool secondDerivatives	(	int	i,
		int	j,
		double *	derivatives
	)		const

pure virtual

Second derivatives with respect to the meta-variables of Fit objects i and j; result false if all derivatives are zero.

Parameters

i	number of 1st FitObject
j	number of 2nd FitObject
derivatives	The result 4x4 matrix

Implemented in MassConstraint, MomentumConstraint, and RecoilMassConstraint.

◆ setGlobalNum()

virtual void setGlobalNum ( int iglobal )

inlinevirtual

Sets position of constraint in global constraint list.

Parameters

iglobal Global constraint number

Definition at line 140 of file BaseHardConstraint.h.

142 {globalNum = iglobal;}

◆ setName()

void setName ( const char * name_ )

inherited

Set object's name.

Definition at line 61 of file BaseConstraint.cc.

    {
      if (name_ == nullptr) return;
      size_t l = strlen(name_);
      if (name) delete[] name;
      name = new char[l + 1];
      strcpy(name, name_);
    }

◆ test1stDerivatives()

void test1stDerivatives ( )

virtual

Definition at line 251 of file BaseHardConstraint.cc.

    {
      B2INFO("BaseConstraint::test1stDerivatives for " << getName());
      double y[100];
      for (double& i : y) i = 0;
      addToGlobalChi2DerVector(y, 100, 1);
      double eps = 0.00001;
      for (unsigned int ifo = 0; ifo < fitobjects.size(); ++ifo) {
        BaseFitObject* fo =  fitobjects[ifo];
        assert(fo);
        for (int ilocal = 0; ilocal < fo->getNPar(); ++ilocal) {
          int iglobal = fo->getGlobalParNum(ilocal);
          double calc = y[iglobal];
          double num = num1stDerivative(ifo, ilocal, eps);
          B2INFO("fo: " << fo->getName() << " par " << ilocal << "/"
                 << iglobal << " (" << fo->getParamName(ilocal)
                 << ") calc: " << calc << " - num: " << num << " = " << calc - num);
        }
      }
    }

◆ test2ndDerivatives()

void test2ndDerivatives ( )

virtual

Definition at line 272 of file BaseHardConstraint.cc.

    {
      B2INFO("BaseConstraint::test2ndDerivatives for " << getName());
      const int idim = 100;
      auto* M = new double[idim * idim];
      for (int i = 0; i < idim * idim; ++i) M[i] = 0;
      add2ndDerivativesToMatrix(M, idim, 1);
      double eps = 0.0001;
      B2INFO("eps=" << eps);
 
      for (unsigned int ifo1 = 0; ifo1 < fitobjects.size(); ++ifo1) {
        BaseFitObject* fo1 =  fitobjects[ifo1];
        assert(fo1);
        for (unsigned int ifo2 = ifo1; ifo2 < fitobjects.size(); ++ifo2) {
          BaseFitObject* fo2 = fitobjects[ifo2];
          assert(fo2);
          for (int ilocal1 = 0; ilocal1 < fo1->getNPar(); ++ilocal1) {
            int iglobal1 = fo1->getGlobalParNum(ilocal1);
            for (int ilocal2 = (ifo1 == ifo2 ? ilocal1 : 0); ilocal2 < fo2->getNPar(); ++ilocal2) {
              int iglobal2 = fo2->getGlobalParNum(ilocal2);
              double calc = M[idim * iglobal1 + iglobal2];
              double num = num2ndDerivative(ifo1, ilocal1, eps, ifo2, ilocal2, eps);
              B2INFO("fo1: " << fo1->getName() << " par " << ilocal1 << "/"
                     << iglobal1 << " (" << fo1->getParamName(ilocal1)
                     << "), fo2: " << fo2->getName() << " par " << ilocal2 << "/"
                     << iglobal2 << " (" << fo2->getParamName(ilocal2)
                     << ") calc: " << calc << " - num: " << num << " = " << calc - num);
            }
          }
        }
      }
      delete[] M;
    }

Friends And Related Function Documentation

◆ operator<<()

std::ostream & operator<<	(	std::ostream &	os,
		const BaseConstraint &	bc
	)

Parameters

os	The output stream
bc	The object to print

Definition at line 114 of file BaseConstraint.h.

    {
      return bc.print(os);
    }

Member Data Documentation

◆ derivatives

std::vector<double> derivatives

protected

The derivatives.

Definition at line 179 of file BaseHardConstraint.h.

◆ fitobjects

FitObjectContainer fitobjects

protected

The FitObjectContainer.

Definition at line 177 of file BaseHardConstraint.h.

◆ flags

std::vector<int> flags

protected

The flags can be used to divide the FitObjectContainer into several subsets used for example to implement an equal mass constraint (see MassConstraint).

Definition at line 182 of file BaseHardConstraint.h.

◆ globalNum

int globalNum

protected

Position of constraint in global constraint list.

Definition at line 185 of file BaseHardConstraint.h.

◆ name

char* name

protectedinherited

Definition at line 108 of file BaseConstraint.h.

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

analysis/OrcaKinFit/include/BaseHardConstraint.h
analysis/OrcaKinFit/src/BaseHardConstraint.cc

Public Member Functions

Protected Types

Protected Attributes

Related Functions

Detailed Description

Member Typedef Documentation

◆ ConstFitObjectIterator

◆ FitObjectContainer

◆ FitObjectIterator

Constructor & Destructor Documentation

◆ BaseHardConstraint()

Member Function Documentation

◆ add1stDerivativesToMatrix()

◆ add2ndDerivativesToMatrix()

◆ addToGlobalChi2DerVector()

◆ dirDer()

◆ dirDerAbs()

◆ firstDerivatives()

◆ getDerivatives()

◆ getError()

◆ getGlobalNum()

◆ getName()

◆ getValue()

◆ num1stDerivative()

◆ num2ndDerivative()

◆ print()

◆ printFirstDerivatives()

◆ printSecondDerivatives()

◆ secondDerivatives()

◆ setGlobalNum()

◆ setName()

◆ test1stDerivatives()

◆ test2ndDerivatives()

Friends And Related Function Documentation

◆ operator<<()

Member Data Documentation

◆ derivatives

◆ fitobjects

◆ flags

◆ globalNum

◆ name