Belle II Software development
Public Member Functions | Protected Types | Protected Attributes | Related Symbols | List of all members
ParticleConstraint Class Referenceabstract

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

#include <ParticleConstraint.h>

Inheritance diagram for ParticleConstraint:
BaseHardConstraint BaseConstraint MassConstraint MomentumConstraint RecoilMassConstraint

Public Member Functions

 ParticleConstraint ()
 Creates an empty ParticleConstraint object.
 
virtual ~ParticleConstraint () override=default
 Virtual destructor.
 
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 void invalidateCache () const
 Invalidates any cached values for the next event.
 
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 Symbols

(Note that these are not member symbols.)

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 ParticleFitObject and can be either set a whole (setFOList) or enlarged by adding a single ParticleFitObject (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

Date
2008/02/12 16:43:26
Author
blist

Definition at line 73 of file ParticleConstraint.h.

Member Typedef Documentation

◆ ConstFitObjectIterator

typedef FitObjectContainer::const_iterator ConstFitObjectIterator
protectedinherited

Constant iterator through vector of pointers to ParticleFitObjects.

Definition at line 175 of file BaseHardConstraint.h.

◆ FitObjectContainer

typedef std::vector<BaseFitObject*> FitObjectContainer
protectedinherited

Vector of pointers to ParticleFitObjects.

Definition at line 171 of file BaseHardConstraint.h.

◆ FitObjectIterator

typedef FitObjectContainer::iterator FitObjectIterator
protectedinherited

Iterator through vector of pointers to ParticleFitObjects.

Definition at line 173 of file BaseHardConstraint.h.

Constructor & Destructor Documentation

◆ ParticleConstraint()

ParticleConstraint ( )
inline

Creates an empty ParticleConstraint object.

Definition at line 111 of file ParticleConstraint.h.

111{ }

Member Function Documentation

◆ add1stDerivativesToMatrix()

void add1stDerivativesToMatrix ( double * M,
int idim ) const
virtualinherited

Adds first order derivatives to global covariance matrix M.

Parameters
MGlobal covariance matrix, dimension at least idim x idim
idimFirst dimension of array der

Definition at line 37 of file BaseHardConstraint.cc.

38 {
39 double dgdpi[BaseDefs::MAXINTERVARS];
40 for (unsigned int i = 0; i < fitobjects.size(); ++i) {
41 const BaseFitObject* foi = fitobjects[i];
42 assert(foi);
43 if (firstDerivatives(i, dgdpi)) {
44 foi->addTo1stDerivatives(M, idim, dgdpi, getGlobalNum(), getVarBasis());
45 }
46 }
47 }

◆ add2ndDerivativesToMatrix()

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

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 $n_i$ 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
MGlobal covariance matrix, dimension at least idim x idim
idimFirst dimension of array der
lambdaLagrange multiplier for this constraint

Definition at line 76 of file BaseHardConstraint.cc.

77 {
78
85 // Derivatives \f$\frac{\partial ^2 g}{\partial P_i \partial P_j}\f$ at fixed i, j
86 // 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
87 double d2GdPidPj[BaseDefs::MAXINTERVARS * BaseDefs::MAXINTERVARS];
88
89 // Derivatives \f$\frac {\partial P_i}{\partial a_k}\f$ for all i;
90 // k is local parameter number
91 // dPidAk[KMAX*4*i + 4*k + ii] is \f$\frac {\partial P_{i,ii}}{\partial a_k}\f$,
92 // with ii=0, 1, 2, 3 for E, px, py, pz
93 const int n = fitobjects.size();
94 auto* dPidAk = new double[n * BaseDefs::MAXPAR * BaseDefs::MAXINTERVARS];
95 bool* dPidAkval = new bool[n];
96
97 for (int i = 0; i < n; ++i) dPidAkval[i] = false;
98
99 // Derivatives \f$\frac{\partial ^2 g}{\partial P_i \partial a_l}\f$ at fixed i
100 // d2GdPdAl[4*l + ii] is \f$\frac{\partial ^2 g}{\partial P_{i,ii} \partial a_l}\f$
101 double d2GdPdAl[static_cast<int>(BaseDefs::MAXINTERVARS) * BaseDefs::MAXPAR];
102 // Derivatives \f$\frac{\partial ^2 g}{\partial a_k \partial a_l}\f$
103 double d2GdAkdAl[BaseDefs::MAXPAR * BaseDefs::MAXPAR] = {0};
104
105 // Global parameter numbers: parglobal[BaseDefs::MAXPAR*i+klocal]
106 // is global parameter number of local parameter klocal of i-th Fit object
107 int* parglobal = new int[BaseDefs::MAXPAR * n];
108
109 for (int i = 0; i < n; ++i) {
110 const BaseFitObject* foi = fitobjects[i];
111 assert(foi);
112 for (int klocal = 0; klocal < foi->getNPar(); ++klocal) {
113 parglobal [BaseDefs::MAXPAR * i + klocal] = foi->getGlobalParNum(klocal);
114 }
115 }
116
117
118 for (int i = 0; i < n; ++i) {
119 const BaseFitObject* foi = fitobjects[i];
120 assert(foi);
121 for (int j = 0; j < n; ++j) {
122 const BaseFitObject* foj = fitobjects[j];
123 assert(foj);
124 if (secondDerivatives(i, j, d2GdPidPj)) {
125 if (!dPidAkval[i]) {
126 foi->getDerivatives(dPidAk + i * (static_cast<int>(BaseDefs::MAXPAR) * BaseDefs::MAXINTERVARS),
127 static_cast<int>(BaseDefs::MAXPAR) * BaseDefs::MAXINTERVARS);
128 dPidAkval[i] = true;
129 }
130 if (!dPidAkval[j]) {
131 foj->getDerivatives(dPidAk + j * (static_cast<int>(BaseDefs::MAXPAR) * BaseDefs::MAXINTERVARS),
132 static_cast<int>(BaseDefs::MAXPAR) * BaseDefs::MAXINTERVARS);
133 dPidAkval[j] = true;
134 }
135 // Now sum over E/px/Py/Pz for object j:
136 // \f[
137 // \frac{\partial ^2 g}{\partial P_{i,ii} \partial a_l}
138 // = (sum_{j}) sum_{jj} frac{\partial ^2 g}{\partial P_{i,ii} \partial P_{j,jj}}
139 // \cdot \frac{\partial P_{j,jj}}{\partial a_l}
140 // \f]
141 // We're summing over jj here
142 for (int llocal = 0; llocal < foj->getNPar(); ++llocal) {
143 for (int ii = 0; ii < BaseDefs::MAXINTERVARS; ++ii) {
144 int ind1 = BaseDefs::MAXINTERVARS * ii;
145 int ind2 = (static_cast<int>(BaseDefs::MAXPAR) * BaseDefs::MAXINTERVARS) * j + BaseDefs::MAXINTERVARS * llocal;
146 double& r = d2GdPdAl[BaseDefs::MAXINTERVARS * llocal + ii];
147 r = d2GdPidPj[ ind1] * dPidAk[ ind2]; // E
148 r += d2GdPidPj[++ind1] * dPidAk[++ind2]; // px
149 r += d2GdPidPj[++ind1] * dPidAk[++ind2]; // py
150 r += d2GdPidPj[++ind1] * dPidAk[++ind2]; // pz
151 }
152 }
153 // Now sum over E/px/Py/Pz for object i, i.e. sum over ii:
154 // \f[
155 // \frac{\partial ^2 g}{\partial a_k \partial a_l}
156 // = \sum_{ii} \frac{\partial ^2 g}{\partial P_{i,ii} \partial a_l} \cdot
157 // \frac{\partial P_{i,ii}}{\partial a_k}
158 // \f]
159 for (int klocal = 0; klocal < foi->getNPar(); ++klocal) {
160 for (int llocal = 0; llocal < foj->getNPar(); ++llocal) {
161 int ind1 = BaseDefs::MAXINTERVARS * llocal;
162 int ind2 = (static_cast<int>(BaseDefs::MAXPAR) * BaseDefs::MAXINTERVARS) * i + BaseDefs::MAXINTERVARS * klocal;
163 double& r = d2GdAkdAl[BaseDefs::MAXPAR * klocal + llocal];
164 r = d2GdPdAl[ ind1] * dPidAk[ ind2]; //E
165 r += d2GdPdAl[++ind1] * dPidAk[++ind2]; // px
166 r += d2GdPdAl[++ind1] * dPidAk[++ind2]; // py
167 r += d2GdPdAl[++ind1] * dPidAk[++ind2]; // pz
168 }
169 }
170 // Now expand the local parameter numbers to global ones
171 for (int klocal = 0; klocal < foi->getNPar(); ++klocal) {
172 int kglobal = parglobal [BaseDefs::MAXPAR * i + klocal];
173 for (int llocal = 0; llocal < foj->getNPar(); ++llocal) {
174 int lglobal = parglobal [BaseDefs::MAXPAR * j + llocal];
175 M [idim * kglobal + lglobal] += lambda * d2GdAkdAl[BaseDefs::MAXPAR * klocal + llocal];
176 }
177 }
178 }
179 }
180 }
189
190 double dgdpi[BaseDefs::MAXINTERVARS];
191 for (int i = 0; i < n; ++i) {
192 const BaseFitObject* foi = fitobjects[i];
193 assert(foi);
194 if (firstDerivatives(i, dgdpi)) {
195 foi->addTo2ndDerivatives(M, idim, lambda, dgdpi, getVarBasis());
196 }
197 }
198
199 delete[] dPidAk;
200 delete[] dPidAkval;
201 delete[] parglobal;
202 }

◆ addToFOList()

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

Adds one ParticleFitObject objects to the list.

Definition at line 90 of file ParticleConstraint.h.

92 {
93 fitobjects.push_back(reinterpret_cast < BaseFitObject* >(&fitobject));
94 flags.push_back(flag);
95 };

◆ addToGlobalChi2DerVector()

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

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

Parameters
yVector of chi2 derivatives
idimVector size
lambdaThe lambda value

Definition at line 204 of file BaseHardConstraint.cc.

205 {
206 double dgdpi[BaseDefs::MAXINTERVARS];
207 for (unsigned int i = 0; i < fitobjects.size(); ++i) {
208 const BaseFitObject* foi = fitobjects[i];
209 assert(foi);
210 if (firstDerivatives(i, dgdpi)) {
211 foi->addToGlobalChi2DerVector(y, idim, lambda, dgdpi, getVarBasis());
212 }
213 }
214 }

◆ dirDer()

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

Calculate directional derivative.

Parameters
pVector of direction
wWork vector
idimVector size
muoptional multiplier

Definition at line 232 of file BaseHardConstraint.cc.

233 {
234 double* pw;
235 const double* pp;
236 for (pw = w; pw < w + idim; * (pw++) = 0);
237 addToGlobalChi2DerVector(w, idim, mu);
238 double result = 0;
239 for (pw = w, pp = p; pw < w + idim; result += *(pp++) * *(pw++));
240 return mu * result;
241 }

◆ dirDerAbs()

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

Calculate directional derivative for abs(c)

Parameters
pVector of direction
wWork vector
idimVector size
muoptional multiplier

Definition at line 243 of file BaseHardConstraint.cc.

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

◆ firstDerivatives()

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

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

Parameters
inumber of 1st FitObject
derivativesThe result 4-vector

Implemented in MassConstraint, MomentumConstraint, and RecoilMassConstraint.

◆ getDerivatives()

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

Get first order derivatives.

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

Parameters
idimFirst dimension of the array
derArray of derivatives, at least idim x idim

Implements BaseConstraint.

Implemented in MassConstraint, MomentumConstraint, and RecoilMassConstraint.

◆ getError()

double getError ( ) const
overridevirtualinherited

Returns the error on the value of the constraint.

Reimplemented from BaseConstraint.

Definition at line 217 of file BaseHardConstraint.cc.

218 {
219 double dgdpi[BaseDefs::MAXINTERVARS];
220 double error2 = 0;
221 for (unsigned int i = 0; i < fitobjects.size(); ++i) {
222 const BaseFitObject* foi = fitobjects[i];
223 assert(foi);
224 if (firstDerivatives(i, dgdpi)) {
225 error2 += foi->getError2(dgdpi, getVarBasis());
226 }
227 }
228 return std::sqrt(std::abs(error2));
229 }

◆ getGlobalNum()

virtual int getGlobalNum ( ) const
inlinevirtualinherited

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.

57 {
58 return name;
59 }

◆ getValue()

virtual double getValue ( ) const
overridepure virtualinherited

Returns the value of the constraint.

Implements BaseConstraint.

Implemented in MassConstraint, MomentumConstraint, and RecoilMassConstraint.

◆ invalidateCache()

virtual void invalidateCache ( ) const
inlinevirtual

Invalidates any cached values for the next event.

Reimplemented in MomentumConstraint.

Definition at line 104 of file ParticleConstraint.h.

105 {}

◆ num1stDerivative()

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

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

Parameters
ifoNumber of FitObject
ilocalLocal parameter number
epsvariation of local parameter

Definition at line 308 of file BaseHardConstraint.cc.

309 {
310 BaseFitObject* fo = fitobjects[ifo];
311 assert(fo);
312 double save = fo->getParam(ilocal);
313 fo->setParam(ilocal, save + eps);
314 double v1 = getValue();
315 fo->setParam(ilocal, save - eps);
316 double v2 = getValue();
317 double result = (v1 - v2) / (2 * eps);
318 fo->setParam(ilocal, save);
319 return result;
320 }

◆ num2ndDerivative()

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

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

Parameters
ifo1Number of 1st FitObject
ilocal11st local parameter number
eps1variation of 1st local parameter
ifo2Number of 1st FitObject
ilocal21st local parameter number
eps2variation of 2nd local parameter

Definition at line 322 of file BaseHardConstraint.cc.

324 {
325 double result;
326
327 if (ifo1 == ifo2 && ilocal1 == ilocal2) {
328 BaseFitObject* fo = fitobjects[ifo1];
329 assert(fo);
330 double save = fo->getParam(ilocal1);
331 double v0 = getValue();
332 fo->setParam(ilocal1, save + eps1);
333 double v1 = getValue();
334 fo->setParam(ilocal1, save - eps1);
335 double v2 = getValue();
336 result = (v1 + v2 - 2 * v0) / (eps1 * eps1);
337 fo->setParam(ilocal1, save);
338 } else {
339 BaseFitObject* fo1 = fitobjects[ifo1];
340 assert(fo1);
341 BaseFitObject* fo2 = fitobjects[ifo2];
342 assert(fo2);
343 double save1 = fo1->getParam(ilocal1);
344 double save2 = fo2->getParam(ilocal2);
345 fo1->setParam(ilocal1, save1 + eps1);
346 fo2->setParam(ilocal2, save2 + eps2);
347 double v11 = getValue();
348 fo2->setParam(ilocal2, save2 - eps2);
349 double v12 = getValue();
350 fo1->setParam(ilocal1, save1 - eps1);
351 double v22 = getValue();
352 fo2->setParam(ilocal2, save2 + eps2);
353 double v21 = getValue();
354 result = (v11 + v22 - v12 - v21) / (4 * eps1 * eps2);
355 fo1->setParam(ilocal1, save1);
356 fo2->setParam(ilocal2, save2);
357 }
358 return result;
359 }

◆ print()

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

print object to ostream

Parameters
osThe output stream

Definition at line 76 of file BaseConstraint.cc.

77 {
78 os << getName() << "=" << getValue();
79 return os;
80 }
Belle2::ObjectInfo::getName
TString getName(const TObject *obj)
human-readable name (e.g.
Definition ObjectInfo.cc:45

◆ printFirstDerivatives()

void printFirstDerivatives ( ) const
virtualinherited

Definition at line 361 of file BaseHardConstraint.cc.

362 {
363
364 B2INFO("BaseHardConstraint::printFirstDerivatives " << fitobjects.size());
365
366 double dgdpi[BaseDefs::MAXINTERVARS];
367 for (unsigned int i = 0; i < fitobjects.size(); ++i) {
368 const BaseFitObject* foi = fitobjects[i];
369 assert(foi);
370 if (firstDerivatives(i, dgdpi)) {
371 B2INFO("first derivs for obj " << i << " : ");
372 for (double j : dgdpi)
373 B2INFO(j << " ");
374 }
375 }
376
377 return;
378 }

◆ printSecondDerivatives()

void printSecondDerivatives ( ) const
virtualinherited

Definition at line 380 of file BaseHardConstraint.cc.

381 {
382
383 double d2GdPidPj[BaseDefs::MAXINTERVARS * BaseDefs::MAXINTERVARS];
384
385 int n = fitobjects.size();
386
387 for (int i = 0; i < n; ++i) {
388 const BaseFitObject* foi = fitobjects[i];
389 assert(foi);
390 for (int j = 0; j < n; ++j) {
391 const BaseFitObject* foj = fitobjects[j];
392 assert(foj);
393 if (secondDerivatives(i, j, d2GdPidPj)) {
394
395 B2INFO("second derivs for objs " << i << " " << j);
396
397 int k(0);
398 for (int k1 = 0; k1 < BaseDefs::MAXINTERVARS; k1++) {
399 for (int k2 = 0; k2 < BaseDefs::MAXINTERVARS; k2++) {
400 B2INFO(d2GdPidPj[k++] << " ");
401 }
402 }
403 }
404 }
405 }
406
407 return;
408 }

◆ resetFOList()

virtual void resetFOList ( )
inlinevirtual

Resests ParticleFitObject list.

Definition at line 97 of file ParticleConstraint.h.

98 {
99 fitobjects.resize(0);
100 flags.resize(0);
101 };

◆ secondDerivatives()

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

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

Parameters
inumber of 1st FitObject
jnumber of 2nd FitObject
derivativesThe result 4x4 matrix

Implemented in MassConstraint, MomentumConstraint, and RecoilMassConstraint.

◆ setFOList()

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

Adds several ParticleFitObject objects to the list.

Parameters
fitobjects_A list of BaseFitObject objects

Definition at line 81 of file ParticleConstraint.h.

83 {
84 for (int i = 0; i < (int) fitobjects_->size(); i++) {
85 fitobjects.push_back(reinterpret_cast < BaseFitObject* >((*fitobjects_)[i]));
86 flags.push_back(1);
87 }
88 };

◆ setGlobalNum()

virtual void setGlobalNum ( int iglobal)
inlinevirtualinherited

Sets position of constraint in global constraint list.

Parameters
iglobalGlobal 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.

62 {
63 if (name_ == nullptr) return;
64 size_t l = strlen(name_);
65 if (name) delete[] name;
66 name = new char[l + 1];
67 strcpy(name, name_);
68 }

◆ test1stDerivatives()

void test1stDerivatives ( )
virtualinherited

Definition at line 252 of file BaseHardConstraint.cc.

253 {
254 B2INFO("BaseConstraint::test1stDerivatives for " << getName());
255 double y[100];
256 for (double& i : y) i = 0;
257 addToGlobalChi2DerVector(y, 100, 1);
258 double eps = 0.00001;
259 for (unsigned int ifo = 0; ifo < fitobjects.size(); ++ifo) {
260 BaseFitObject* fo = fitobjects[ifo];
261 assert(fo);
262 for (int ilocal = 0; ilocal < fo->getNPar(); ++ilocal) {
263 int iglobal = fo->getGlobalParNum(ilocal);
264 double calc = y[iglobal];
265 double num = num1stDerivative(ifo, ilocal, eps);
266 B2INFO("fo: " << fo->getName() << " par " << ilocal << "/"
267 << iglobal << " (" << fo->getParamName(ilocal)
268 << ") calc: " << calc << " - num: " << num << " = " << calc - num);
269 }
270 }
271 }

◆ test2ndDerivatives()

void test2ndDerivatives ( )
virtualinherited

Definition at line 273 of file BaseHardConstraint.cc.

274 {
275 B2INFO("BaseConstraint::test2ndDerivatives for " << getName());
276 const int idim = 100;
277 auto* M = new double[idim * idim];
278 for (int i = 0; i < idim * idim; ++i) M[i] = 0;
279 add2ndDerivativesToMatrix(M, idim, 1);
280 double eps = 0.0001;
281 B2INFO("eps=" << eps);
282
283 for (unsigned int ifo1 = 0; ifo1 < fitobjects.size(); ++ifo1) {
284 BaseFitObject* fo1 = fitobjects[ifo1];
285 assert(fo1);
286 for (unsigned int ifo2 = ifo1; ifo2 < fitobjects.size(); ++ifo2) {
287 BaseFitObject* fo2 = fitobjects[ifo2];
288 assert(fo2);
289 for (int ilocal1 = 0; ilocal1 < fo1->getNPar(); ++ilocal1) {
290 int iglobal1 = fo1->getGlobalParNum(ilocal1);
291 for (int ilocal2 = (ifo1 == ifo2 ? ilocal1 : 0); ilocal2 < fo2->getNPar(); ++ilocal2) {
292 int iglobal2 = fo2->getGlobalParNum(ilocal2);
293 double calc = M[idim * iglobal1 + iglobal2];
294 double num = num2ndDerivative(ifo1, ilocal1, eps, ifo2, ilocal2, eps);
295 B2INFO("fo1: " << fo1->getName() << " par " << ilocal1 << "/"
296 << iglobal1 << " (" << fo1->getParamName(ilocal1)
297 << "), fo2: " << fo2->getName() << " par " << ilocal2 << "/"
298 << iglobal2 << " (" << fo2->getParamName(ilocal2)
299 << ") calc: " << calc << " - num: " << num << " = " << calc - num);
300 }
301 }
302 }
303 }
304 delete[] M;
305 }

Friends And Related Symbol Documentation

◆ operator<<()

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

Prints out a BaseConstraint, using its print method.

Parameters
osThe output stream
bcThe object to print

Definition at line 114 of file BaseConstraint.h.

117 {
118 return bc.print(os);
119 }

Member Data Documentation

◆ derivatives

std::vector<double> derivatives
protectedinherited

The derivatives.

Definition at line 179 of file BaseHardConstraint.h.

◆ fitobjects

FitObjectContainer fitobjects
protectedinherited

The FitObjectContainer.

Definition at line 177 of file BaseHardConstraint.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 182 of file BaseHardConstraint.h.

◆ globalNum

int globalNum
protectedinherited

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 file: