SoftGaussMassConstraint Class Reference

Implements constraint 0 = mass1 - mass2 - m. More...

#include <SoftGaussMassConstraint.h>

Inheritance diagram for SoftGaussMassConstraint:

Collaboration diagram for SoftGaussMassConstraint:

Public Member Functions
	SoftGaussMassConstraint (double sigma_, double mass_=0.)
	Constructor.
virtual	~SoftGaussMassConstraint ()
	Virtual destructor.
virtual double	getValue () const override
	Returns the value of the constraint function.
virtual void	getDerivatives (int idim, double der[]) const override
	Get first order derivatives.
virtual double	getMass (int flag=1)
	Get the actual invariant mass of the fit objects with a given flag.
virtual void	setMass (double mass_)
	Sets the target mass of the constraint.
virtual void	setFOList (std::vector< ParticleFitObject * > *fitobjects_)
	Adds several ParticleFitObject objects to the list.
virtual void	addToFOList (ParticleFitObject &fitobject, int flag=1)
	Adds one ParticleFitObject objects to the list.
virtual void	resetFOList ()
	Resests ParticleFitObject list.
virtual double	getChi2 () const override
	Returns the chi2.
virtual double	getError () const override
	Returns the error on the value of the constraint.
virtual double	getSigma () const
	Returns the sigma.
virtual double	setSigma (double sigma_)
	Sets the sigma.
virtual void	add2ndDerivativesToMatrix (double *M, int idim) const override
	Adds second order derivatives to global covariance matrix M.
virtual void	addToGlobalChi2DerVector (double *y, int idim) const override
	Add derivatives of chi squared to global derivative matrix.
void	invalidateCache () const
	Invalidates any cached values for the next event.
void	test1stDerivatives ()
void	test2ndDerivatives ()
double	num1stDerivative (int ifo, int ilocal, double eps)
	Evaluates numerically the 1st derivative w.r.t. a parameter.
double	num2ndDerivative (int ifo1, int ilocal1, double eps1, int ifo2, int ilocal2, double eps2)
	Evaluates numerically the 2nd derivative w.r.t. 2 parameters.
int	getVarBasis () const
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
enum	{ VAR_BASIS = BaseDefs::VARBASIS_EPXYZ }
typedef std::vector< ParticleFitObject * >	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 Member Functions
virtual bool	secondDerivatives (int i, int j, double *derivatives) const override
	Second derivatives with respect to the 4-vectors of Fit objects i and j; result false if all derivatives are zero.
virtual bool	firstDerivatives (int i, double *derivatives) const override
	First derivatives with respect to the 4-vector of Fit objects i; result false if all derivatives are zero.

Protected Attributes
double	mass
	The mass difference between object sets 1 and 2.
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).
double	sigma
	The sigma of the Gaussian.
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

Implements constraint 0 = mass1 - mass2 - m.

This class implements different mass constraints:

• the invariant mass of several objects should be m
• the difference of the invariant masses between two sets of objects should be m (normally m=0 in this case).

Author: Jenny List, Benno List Last update:

Date

2008/02/12 16:43:26

by:

Author

blist

Definition at line 45 of file SoftGaussMassConstraint.h.

Member Typedef Documentation

ConstFitObjectIterator

typedef FitObjectContainer::const_iterator ConstFitObjectIterator

protectedinherited

Constant iterator through vector of pointers to ParticleFitObjects.

Definition at line 177 of file SoftGaussParticleConstraint.h.

FitObjectContainer

typedef std::vector<ParticleFitObject*> FitObjectContainer

protectedinherited

Vector of pointers to ParticleFitObjects.

Definition at line 173 of file SoftGaussParticleConstraint.h.

FitObjectIterator

typedef FitObjectContainer::iterator FitObjectIterator

protectedinherited

Iterator through vector of pointers to ParticleFitObjects.

Definition at line 175 of file SoftGaussParticleConstraint.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

protectedinherited

Definition at line 189 of file SoftGaussParticleConstraint.h.

{ VAR_BASIS = BaseDefs::VARBASIS_EPXYZ }; // this means that the constraint knows about E,px,py,pz

Constructor & Destructor Documentation

SoftGaussMassConstraint()

SoftGaussMassConstraint ( double  sigma_, double  mass_ = 0.  )

explicit

Constructor.

Parameters

sigma_	The sigma value
mass_	The mass difference between object sets 1 and 2

Definition at line 35 of file SoftGaussMassConstraint.cc.

      : SoftGaussParticleConstraint(sigma_),
        mass(mass_)
    {}

Member Function Documentation

add2ndDerivativesToMatrix()

void add2ndDerivativesToMatrix ( double *  M, int  idim  ) const

overridevirtualinherited

Adds second order derivatives to global covariance matrix M.

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

the various parameters and adds it to the global covariance matrix

We denote with P_i the 4-vector of the i-th ParticleFitObject, then

Here, is a Matrix, where is the number of parameters of FitObject i; Correspondingly, is a matrix. Also, is a matrix for a given i and j, and is a 4-vector (though not a Lorentz-vector!).

First, treat the part

Second, treat the parts

and

Here, is a 4-vector, which we pass on to the FitObject

Parameters

M	Covariance matrix, at least idim x idim
idim	First dimension of the array

Implements BaseSoftConstraint.

Definition at line 92 of file SoftGaussParticleConstraint.cc.

    {
 
      double s = getSigma();
      double fact = 2 * getValue() / (s * s);
 
      // 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[16];
      // 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 KMAX = 4;
      const int n = fitobjects.size();
      auto* dPidAk = new double[n * KMAX * 4];
      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[4 * KMAX];
      // Derivatives \f$\frac{\partial ^2 g}{\partial a_k \partial a_l}\f$
      double d2GdAkdAl[KMAX * KMAX] = {0};
 
      // Global parameter numbers: parglobal[KMAX*i+klocal]
      // is global parameter number of local parameter klocal of i-th Fit object
      int* parglobal = new int[KMAX * n];
 
      for (int i = 0; i < n; ++i) {
        const ParticleFitObject* foi = fitobjects[i];
        assert(foi);
        for (int klocal = 0; klocal < foi->getNPar(); ++klocal) {
          parglobal [KMAX * i + klocal] = foi->getGlobalParNum(klocal);
        }
      }
 
 
      for (int i = 0; i < n; ++i) {
        const ParticleFitObject* foi = fitobjects[i];
        assert(foi);
        for (int j = 0; j < n; ++j) {
          const ParticleFitObject* foj = fitobjects[j];
          assert(foj);
          if (secondDerivatives(i, j, d2GdPidPj)) {
            if (!dPidAkval[i]) {
              foi->getDerivatives(dPidAk + i * (KMAX * 4), KMAX * 4);
              dPidAkval[i] = true;
            }
            if (!dPidAkval[j]) {
              foj->getDerivatives(dPidAk + j * (KMAX * 4), KMAX * 4);
              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 < 4; ++ii) {
                int ind1 = 4 * ii;
                int ind2 = (KMAX * 4) * j + 4 * llocal;
                double& r = d2GdPdAl[4 * 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 = 4 * llocal;
                int ind2 = (KMAX * 4) * i + 4 * klocal;
                double& r = d2GdAkdAl[KMAX * 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 [KMAX * i + klocal];
              for (int llocal = 0; llocal < foj->getNPar(); ++llocal) {
                int lglobal = parglobal [KMAX * j + llocal];
                M [idim * kglobal + lglobal] += fact * d2GdAkdAl[KMAX * klocal + llocal];
              }
            }
          }
        }
      }
      auto* v = new double[idim];
      for (int i = 0; i < idim; ++i) v[i] = 0;
      double sqrtfact2 = sqrt(2.0) / s;
 
      double dgdpi[4];
      for (int i = 0; i < n; ++i) {
        const ParticleFitObject* foi = fitobjects[i];
        assert(foi);
        if (firstDerivatives(i, dgdpi)) {
          foi->addTo2ndDerivatives(M, idim, fact, dgdpi, getVarBasis());
          foi->addToGlobalChi2DerVector(v, idim, sqrtfact2, dgdpi, getVarBasis());
        }
      }
 
      for (int i = 0; i < idim; ++i) {
        if (double vi = v[i]) {
          int ioffs = i * idim;
          for (double* pvj = v; pvj < v + idim; ++pvj) {
            M[ioffs++] += vi * (*pvj);
          }
        }
      }
 
 
      delete[] dPidAk;
      delete[] dPidAkval;
      delete[] parglobal;
      delete[] v;
    }

addToFOList()

virtual void addToFOList ( ParticleFitObject &  fitobject, int  flag = 1  )

inlinevirtualinherited

Adds one ParticleFitObject objects to the list.

Definition at line 92 of file SoftGaussParticleConstraint.h.

      {
        fitobjects.push_back(&fitobject);
        flags.push_back(flag);
      };

addToGlobalChi2DerVector()

void addToGlobalChi2DerVector ( double *  y, int  idim  ) const

overridevirtualinherited

Add derivatives of chi squared to global derivative matrix.

Parameters

y	Vector of chi2 derivatives
idim	Vector size

Implements BaseSoftConstraint.

Definition at line 246 of file SoftGaussParticleConstraint.cc.

    {
      double dgdpi[4];
      double s = getSigma();
      double r = 2 * getValue() / (s * s);
      for (unsigned int i = 0; i < fitobjects.size(); ++i) {
        const ParticleFitObject* foi = fitobjects[i];
        assert(foi);
        if (firstDerivatives(i, dgdpi)) {
          foi->addToGlobalChi2DerVector(y, idim, r, dgdpi, getVarBasis());
        }
      }
    }

firstDerivatives()

bool firstDerivatives ( int  i, double *  derivatives  ) const

overrideprotectedvirtual

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

Parameters

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

Implements SoftGaussParticleConstraint.

Definition at line 191 of file SoftGaussMassConstraint.cc.

    {
      double totE = 0;
      double totpx = 0;
      double totpy = 0;
      double totpz = 0;
      int index = (flags[i] == 1) ? 0 : 1; // default is 1, but 2 may indicate fitobjects for a second W -> equal mass constraint!
      for (unsigned int j = 0; j < fitobjects.size(); ++j) {
        int jndex = (flags[j] == 1) ? 0 : 1; // default is 1, but 2 may indicate fitobjects for a second W -> equal mass constraint!
        const ParticleFitObject* foj = fitobjects[j];
        assert(foj);
        if (index == jndex) {
          totE  += foj->getE();
          totpx += foj->getPx();
          totpy += foj->getPy();
          totpz += foj->getPz();
        }
      }
 
      if (totE <= 0) {
        B2ERROR("SoftGaussMassConstraint::firstDerivatives: totE = " << totE);
      }
 
      double m = std::sqrt(std::abs(totE * totE - totpx * totpx - totpy * totpy - totpz * totpz));
      if (index) m = -m;
 
      dderivatives[0] = totE / m;
      dderivatives[1] = -totpx / m;
      dderivatives[2] = -totpy / m;
      dderivatives[3] = -totpz / m;
      return true;
    }

getChi2()

double getChi2 ( ) const

overridevirtualinherited

Returns the chi2.

Implements BaseSoftConstraint.

Definition at line 48 of file SoftGaussParticleConstraint.cc.

    {
      double r = getValue() / getSigma();
      return r * r;
    }

getDerivatives()

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

overridevirtual

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

Definition at line 68 of file SoftGaussMassConstraint.cc.

    {
      double totE[2] = {0, 0};
      double totpx[2] = {0, 0};
      double totpy[2] = {0, 0};
      double totpz[2] = {0, 0};
      bool valid[2] = {false, false};
      for (unsigned int i = 0; i < fitobjects.size(); i++) {
        int index = (flags[i] == 1) ? 0 : 1; // default is 1, but 2 may indicate fitobjects for a second W -> equal mass constraint!
        valid[index] = true;
        totE[index]  += fitobjects[i]->getE();
        totpx[index] += fitobjects[i]->getPx();
        totpy[index] += fitobjects[i]->getPy();
        totpz[index] += fitobjects[i]->getPz();
      }
      double m2[2];
      double m_inv[2] = {0, 0};
      for (int index = 0; index < 2; ++index) {
        m2[index] = totE[index] * totE[index] - totpx[index] * totpx[index]
                    - totpy[index] * totpy[index] - totpz[index] * totpz[index];
        if (m2[index] < 0 && m2[index] > -1E-9) m2[index] = 0;
        if (m2[index] < 0 && valid[index]) {
          B2ERROR("SoftGaussMassConstraint::getDerivatives: m2<0!");
          for (unsigned int j = 0; j < fitobjects.size(); j++) {
            int jndex = (flags[j] == 1) ? 0 : 1;
            if (jndex == index) {
              B2ERROR(fitobjects[j]->getName() << ": E=" << fitobjects[j]->getE() << ", px=" << fitobjects[j]->getPx()
                      << ", py=" << fitobjects[j]->getPy() << ", pz=" << fitobjects[j]->getPz());
            }
          }
          B2ERROR("sum: E=" << totE[index] << ", px=" << totpx[index]
                  << ", py=" << totpy[index] << ", pz=" << totpz[index] << ", m2=" << m2[index]);
        }
        if (m2[index] != 0) m_inv[index] = 1 / std::sqrt(std::abs(m2[index]));
      }
 
      for (unsigned int i = 0; i < fitobjects.size(); i++) {
        int index = (flags[i] == 1) ? 0 : 1; // default is 1, but 2 may indicate fitobjects for a second W -> equal mass constraint!
        for (int ilocal = 0; ilocal < fitobjects[i]->getNPar(); ilocal++) {
          if (!fitobjects[i]->isParamFixed(ilocal)) {
            int iglobal = fitobjects[i]->getGlobalParNum(ilocal);
            assert(iglobal >= 0 && iglobal < idim);
            if (m2[index] != 0) {
              der[iglobal] =   totE[index]  * fitobjects[i]->getDE(ilocal)
                               - totpx[index] * fitobjects[i]->getDPx(ilocal)
                               - totpy[index] * fitobjects[i]->getDPy(ilocal)
                               - totpz[index] * fitobjects[i]->getDPz(ilocal);
              der[iglobal] *= m_inv[index];
            } else der[iglobal] = 1;
            if (index == 1) der[iglobal] *= -1.;
          }
        }
      }
    }

getError()

double getError ( ) const

overridevirtualinherited

Returns the error on the value of the constraint.

Reimplemented from BaseConstraint.

Definition at line 54 of file SoftGaussParticleConstraint.cc.

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

getMass()

double getMass ( int  flag = 1 )

virtual

Get the actual invariant mass of the fit objects with a given flag.

Parameters

flag

The flag

Definition at line 123 of file SoftGaussMassConstraint.cc.

    {
      double totE = 0;
      double totpx = 0;
      double totpy = 0;
      double totpz = 0;
      for (unsigned int i = 0; i < fitobjects.size(); i++) {
        if (flags[i] == flag) {
          totE += fitobjects[i]->getE();
          totpx += fitobjects[i]->getPx();
          totpy += fitobjects[i]->getPy();
          totpz += fitobjects[i]->getPz();
        }
      }
      return std::sqrt(std::abs(totE * totE - totpx * totpx - totpy * totpy - totpz * totpz));
    }

getName()

const char * getName ( ) const

virtualinherited

Returns the name of the constraint.

Definition at line 56 of file BaseConstraint.cc.

    {
      return name;
    }

getSigma()

double getSigma ( ) const

virtualinherited

Returns the sigma.

Definition at line 37 of file SoftGaussParticleConstraint.cc.

    {
      return sigma;
    }

getValue()

double getValue ( ) const

overridevirtual

Returns the value of the constraint function.

Implements SoftGaussParticleConstraint.

Definition at line 44 of file SoftGaussMassConstraint.cc.

    {
      double totE[2] = {0, 0};
      double totpx[2] = {0, 0};
      double totpy[2] = {0, 0};
      double totpz[2] = {0, 0};
      for (unsigned int i = 0; i < fitobjects.size(); i++) {
        int index = (flags[i] == 1) ? 0 : 1; // default is 1, but 2 may indicate fitobjects for a second W -> equal mass constraint!
        totE[index] += fitobjects[i]->getE();
        totpx[index] += fitobjects[i]->getPx();
        totpy[index] += fitobjects[i]->getPy();
        totpz[index] += fitobjects[i]->getPz();
      }
      double result = -mass;
      result += std::sqrt(std::abs(totE[0] * totE[0] - totpx[0] * totpx[0] - totpy[0] * totpy[0] - totpz[0] * totpz[0]));
      result -= std::sqrt(std::abs(totE[1] * totE[1] - totpx[1] * totpx[1] - totpy[1] * totpy[1] - totpz[1] * totpz[1]));
      return result;
    }

getVarBasis()

int getVarBasis ( ) const

inherited

Definition at line 368 of file SoftGaussParticleConstraint.cc.

    {
      return VAR_BASIS;
    }

invalidateCache()

void invalidateCache ( ) const

inlineinherited

Invalidates any cached values for the next event.

Definition at line 138 of file SoftGaussParticleConstraint.h.

{}

num1stDerivative()

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

inherited

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 315 of file SoftGaussParticleConstraint.cc.

    {
      ParticleFitObject* fo = fitobjects[ifo];
      assert(fo);
      double save = fo->getParam(ilocal);
      fo->setParam(ilocal, save + eps);
      double v1 = getChi2();
      fo->setParam(ilocal, save - eps);
      double v2 = getChi2();
      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  )

inherited

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 329 of file SoftGaussParticleConstraint.cc.

    {
      double result;
 
      if (ifo1 == ifo2 && ilocal1 == ilocal2) {
        ParticleFitObject* fo = fitobjects[ifo1];
        assert(fo);
        double save = fo->getParam(ilocal1);
        double v0 = getChi2();
        fo->setParam(ilocal1, save + eps1);
        double v1 = getChi2();
        fo->setParam(ilocal1, save - eps1);
        double v2 = getChi2();
        result = (v1 + v2 - 2 * v0) / (eps1 * eps1);
        fo->setParam(ilocal1, save);
      } else {
        ParticleFitObject* fo1 = fitobjects[ifo1];
        assert(fo1);
        ParticleFitObject* 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 = getChi2();
        fo2->setParam(ilocal2, save2 - eps2);
        double v12 = getChi2();
        fo1->setParam(ilocal1, save1 - eps1);
        double v22 = getChi2();
        fo2->setParam(ilocal2, save2 + eps2);
        double v21 = getChi2();
        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;
    }

resetFOList()

virtual void resetFOList ( )

inlinevirtualinherited

Resests ParticleFitObject list.

Definition at line 99 of file SoftGaussParticleConstraint.h.

      {
        fitobjects.resize(0);
        flags.resize(0);
      };

secondDerivatives()

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

overrideprotectedvirtual

Second derivatives with respect to the 4-vectors 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

Implements SoftGaussParticleConstraint.

Definition at line 145 of file SoftGaussMassConstraint.cc.

    {
      B2DEBUG(14, "SoftGaussMassConstraint::secondDerivatives: i=" << i << ", j=" << j);
      int index = (flags[i] == 1) ? 0 : 1; // default is 1, but 2 may indicate fitobjects for a second W -> equal mass constraint!
      int jndex = (flags[j] == 1) ? 0 : 1; // default is 1, but 2 may indicate fitobjects for a second W -> equal mass constraint!
      if (index != jndex) return false;
      double totE = 0;
      double totpx = 0;
      double totpy = 0;
      double totpz = 0;
      for (unsigned int k = 0; k < fitobjects.size(); ++k) {
        int kndex = (flags[k] == 1) ? 0 : 1; // default is 1, but 2 may indicate fitobjects for a second W -> equal mass constraint!
        const ParticleFitObject* fok = fitobjects[k];
        assert(fok);
        if (index == kndex) {
          totE  += fok->getE();
          totpx += fok->getPx();
          totpy += fok->getPy();
          totpz += fok->getPz();
        }
      }
 
      if (totE <= 0) {
        B2ERROR("SoftGaussMassConstraint::secondDerivatives: totE = " << totE);
      }
 
      double m2 = std::abs(totE * totE - totpx * totpx - totpy * totpy - totpz * totpz);
      double m = std::sqrt(m2);
      if (index) m = -m;
      double minv3 = 1 / (m * m * m);
 
      assert(dderivatives);
      for (int k = 0; k < 16; ++k) dderivatives[k] = 0;
      dderivatives[4 * 0 + 0] = (m2 - totE * totE) * minv3;
      dderivatives[4 * 0 + 1] = dderivatives[4 * 1 + 0] =     totE * totpx * minv3;
      dderivatives[4 * 0 + 2] = dderivatives[4 * 2 + 0] =     totE * totpy * minv3;
      dderivatives[4 * 0 + 3] = dderivatives[4 * 3 + 0] =     totE * totpz * minv3;
      dderivatives[4 * 1 + 1] =                     -(m2 + totpx * totpx) * minv3;
      dderivatives[4 * 1 + 2] = dderivatives[4 * 2 + 1] =    -totpx * totpy * minv3;
      dderivatives[4 * 1 + 3] = dderivatives[4 * 3 + 1] =    -totpx * totpz * minv3;
      dderivatives[4 * 2 + 2] =                     -(m2 + totpy * totpy) * minv3;
      dderivatives[4 * 2 + 3] = dderivatives[4 * 3 + 2] =    -totpy * totpz * minv3;
      dderivatives[4 * 3 + 3] =                     -(m2 + totpz * totpz) * minv3;
      return true;
    }

setFOList()

virtual void setFOList ( std::vector< ParticleFitObject * > *  fitobjects_ )

inlinevirtualinherited

Adds several ParticleFitObject objects to the list.

Parameters

fitobjects_

A list of BaseFitObject objects

Definition at line 83 of file SoftGaussParticleConstraint.h.

      {
        for (int i = 0; i < (int) fitobjects_->size(); i++) {
          fitobjects.push_back((*fitobjects_)[i]);
          flags.push_back(1);
        }
      };

setMass()

void setMass ( double  mass_ )

virtual

Sets the target mass of the constraint.

Parameters

mass_

The new mass

Definition at line 140 of file SoftGaussMassConstraint.cc.

    {
      mass = mass_;
    }

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_);
    }

setSigma()

double setSigma ( double  sigma_ )

virtualinherited

Sets the sigma.

Parameters

sigma_

The new sigma value

Definition at line 42 of file SoftGaussParticleConstraint.cc.

    {
      if (sigma_ != 0) sigma = std::abs(sigma_);
      return sigma;
    }

test1stDerivatives()

void test1stDerivatives ( )

inherited

Definition at line 260 of file SoftGaussParticleConstraint.cc.

    {
      B2INFO("SoftGaussParticleConstraint::test1stDerivatives for " << getName());
      double y[100];
      for (double& i : y) i = 0;
      addToGlobalChi2DerVector(y, 100);
      double eps = 0.00001;
      for (unsigned int ifo = 0; ifo < fitobjects.size(); ++ifo) {
        ParticleFitObject* 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 ( )

inherited

Definition at line 280 of file SoftGaussParticleConstraint.cc.

    {
      B2INFO("SoftGaussParticleConstraint::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);
      double eps = 0.0001;
      B2INFO("eps=" << eps);
 
      for (unsigned int ifo1 = 0; ifo1 < fitobjects.size(); ++ifo1) {
        ParticleFitObject* fo1 = fitobjects[ifo1];
        assert(fo1);
        for (unsigned int ifo2 = ifo1; ifo2 < fitobjects.size(); ++ifo2) {
          ParticleFitObject* 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  )

related

Prints out a BaseConstraint, using its print method.

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

protectedinherited

The derivatives.

Definition at line 181 of file SoftGaussParticleConstraint.h.

fitobjects

FitObjectContainer fitobjects

protectedinherited

The FitObjectContainer.

Definition at line 179 of file SoftGaussParticleConstraint.h.

flags

std::vector<int> flags

protectedinherited

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 184 of file SoftGaussParticleConstraint.h.

mass

double mass

protected

The mass difference between object sets 1 and 2.

Definition at line 74 of file SoftGaussMassConstraint.h.

name

char* name

protectedinherited

Definition at line 108 of file BaseConstraint.h.

sigma

double sigma

protectedinherited

The sigma of the Gaussian.

Definition at line 187 of file SoftGaussParticleConstraint.h.

---

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

• analysis/OrcaKinFit/include/SoftGaussMassConstraint.h
• analysis/OrcaKinFit/src/SoftGaussMassConstraint.cc