Belle II Software development
Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Related Functions | List of all members
RecoilMassConstraint Class Reference
Inheritance diagram for RecoilMassConstraint:
ParticleConstraint BaseHardConstraint BaseConstraint

Public Member Functions

 RecoilMassConstraint (double recoilmass=0., double beampx=0., double beampy=0., double beampz=0, double beampe=0.)
 Constructor.
 
virtual ~RecoilMassConstraint ()
 Virtual destructor.
 
virtual double getValue () const override
 Returns the value of the constraint.
 
virtual void getDerivatives (int idim, double der[]) const override
 Get first order derivatives.
 
virtual double getRecoilMass ()
 Get the actual recoil mass of the fit objects.
 
virtual void setRecoilMass (double recoilmass)
 Sets the target recoil mass of the constraint.
 
virtual int getVarBasis () const override
 
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 double getError () const override
 Returns the error on the value of the constraint.
 
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

enum  { VAR_BASIS = 0 }
 
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 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 m_recoilMass
 
double m_beamPx
 
double m_beamPy
 
double m_beamPz
 
double m_beamE
 
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

Definition at line 23 of file RecoilMassConstraint.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.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
protected

Definition at line 68 of file RecoilMassConstraint.h.

68{ VAR_BASIS = 0 }; // this means that the constraint knows about E,px,py,pz

Constructor & Destructor Documentation

◆ RecoilMassConstraint()

RecoilMassConstraint ( double  recoilmass = 0.,
double  beampx = 0.,
double  beampy = 0.,
double  beampz = 0,
double  beampe = 0. 
)

Constructor.

Definition at line 26 of file RecoilMassConstraint.cc.

27 : m_recoilMass(recoilmass), m_beamPx(beampx), m_beamPy(beampy), m_beamPz(beampz), m_beamE(beampe)
28 {}

◆ ~RecoilMassConstraint()

~RecoilMassConstraint ( )
virtual

Virtual destructor.

Definition at line 31 of file RecoilMassConstraint.cc.

32 {
33 ;
34 }

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 }
Belle2::OrcaKinFit::BaseHardConstraint::getGlobalNum
virtual int getGlobalNum() const
Accesses position of constraint in global constraint list.
Definition: BaseHardConstraint.h:137
Belle2::OrcaKinFit::BaseHardConstraint::fitobjects
FitObjectContainer fitobjects
The FitObjectContainer.
Definition: BaseHardConstraint.h:177
Belle2::OrcaKinFit::BaseHardConstraint::firstDerivatives
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 derivative...

◆ 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 }
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 }
Belle2::OrcaKinFit::BaseHardConstraint::secondDerivatives
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 der...

◆ addToFOList()

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

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 };
Belle2::OrcaKinFit::BaseHardConstraint::flags
std::vector< int > flags
The flags can be used to divide the FitObjectContainer into several subsets used for example to imple...
Definition: BaseHardConstraint.h:182

◆ 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

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, *pp;
235 for (pw = w; pw < w + idim; * (pw++) = 0);
236 addToGlobalChi2DerVector(w, idim, mu);
237 double result = 0;
238 for (pw = w, pp = p; pw < w + idim; result += *(pp++) * *(pw++));
239 return mu * result;
240 }
Belle2::OrcaKinFit::BaseHardConstraint::addToGlobalChi2DerVector
virtual void addToGlobalChi2DerVector(double *y, int idim, double lambda) const
Add lambda times derivatives of chi squared to global derivative vector.
Definition: BaseHardConstraint.cc:204

◆ 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 242 of file BaseHardConstraint.cc.

243 {
244 double val = getValue();
245 if (val == 0) return mu * std::fabs(dirDer(p, w, idim, 1));
246 else if (val > 0) return mu * dirDer(p, w, idim, 1);
247 else return -mu * dirDer(p, w, idim, 1);
248 }
Belle2::OrcaKinFit::BaseHardConstraint::getValue
virtual double getValue() const override=0
Returns the value of the constraint.
Belle2::OrcaKinFit::BaseHardConstraint::dirDer
virtual double dirDer(double *p, double *w, int idim, double mu=1)
Calculate directional derivative.
Definition: BaseHardConstraint.cc:232

◆ 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
inumber of 1st FitObject
derivativesThe result 4-vector

Implements BaseHardConstraint.

Definition at line 172 of file RecoilMassConstraint.cc.

173 {
174 (void) i;
175
176 double totE = 0.;
177 double totpx = 0.;
178 double totpy = 0.;
179 double totpz = 0.;
180
181 for (auto fitobject : fitobjects) {
182 auto* pfo = dynamic_cast < ParticleFitObject* >(fitobject);
183 assert(pfo);
184 totE += pfo->getE();
185 totpx += pfo->getPx();
186 totpy += pfo->getPy();
187 totpz += pfo->getPz();
188 }
189
190 const double recoilE = (m_beamE - totE);
191 const double recoilpx = (m_beamPx - totpx);
192 const double recoilpy = (m_beamPy - totpy);
193 const double recoilpz = (m_beamPz - totpz);
194
195 dderivatives[0] = -2 * recoilE;
196 dderivatives[1] = 2 * recoilpx;
197 dderivatives[2] = 2 * recoilpy;
198 dderivatives[3] = 2 * recoilpz;
199
200 return true;
201 }

◆ 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
idimFirst dimension of the array
derArray of derivatives, at least idim x idim

Implements BaseHardConstraint.

Definition at line 72 of file RecoilMassConstraint.cc.

73 {
74
75 double totE = 0.;
76 double totpx = 0.;
77 double totpy = 0.;
78 double totpz = 0.;
79
80 for (auto fitobject : fitobjects) {
81 auto* pfo = dynamic_cast < ParticleFitObject* >(fitobject);
82 assert(pfo);
83 totE += pfo->getE();
84 totpx += pfo->getPx();
85 totpy += pfo->getPy();
86 totpz += pfo->getPz();
87 }
88
89 const double recoilE = (m_beamE - totE);
90 const double recoilpx = (m_beamPx - totpx);
91 const double recoilpy = (m_beamPy - totpy);
92 const double recoilpz = (m_beamPz - totpz);
93
94 for (auto fitobject : fitobjects) {
95 for (int ilocal = 0; ilocal < fitobject->getNPar(); ilocal++) {
96 if (!fitobject->isParamFixed(ilocal)) {
97 int iglobal = fitobject->getGlobalParNum(ilocal);
98 assert(iglobal >= 0 && iglobal < idim);
99
100 auto* pfo = dynamic_cast < ParticleFitObject* >(fitobject);
101 assert(pfo);
102 der[iglobal] = - recoilE * pfo->getDE(ilocal)
103 + recoilpx * pfo->getDPx(ilocal)
104 + recoilpy * pfo->getDPy(ilocal)
105 + recoilpz * pfo->getDPz(ilocal);
106 der[iglobal] *= 2;
107 }
108 }
109 }
110 }

◆ 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;}
Belle2::OrcaKinFit::BaseHardConstraint::globalNum
int globalNum
Position of constraint in global constraint list.
Definition: BaseHardConstraint.h:185

◆ 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 }

◆ getRecoilMass()

double getRecoilMass ( )
virtual

Get the actual recoil mass of the fit objects.

Definition at line 113 of file RecoilMassConstraint.cc.

114 {
115 double totE = 0.;
116 double totpx = 0.;
117 double totpy = 0.;
118 double totpz = 0.;
119
120 for (auto& fitobject : fitobjects) {
121 auto* pfo = dynamic_cast < ParticleFitObject* >(fitobject);
122 assert(pfo);
123 totE += pfo->getE();
124 totpx += pfo->getPx();
125 totpy += pfo->getPy();
126 totpz += pfo->getPz();
127 }
128
129 const double recoilE = (m_beamE - totE);
130 const double recoilE2 = recoilE * recoilE;
131 const double recoilpx = (m_beamPx - totpx);
132 const double recoilpx2 = recoilpx * recoilpx;
133 const double recoilpy = (m_beamPy - totpy);
134 const double recoilpy2 = recoilpy * recoilpy;
135 const double recoilpz = (m_beamPz - totpz);
136 const double recoilpz2 = recoilpz * recoilpz;
137 const double recoil2 = recoilE2 - recoilpx2 - recoilpy2 - recoilpz2;
138 const double recoil = std::sqrt(std::fabs(recoil2));
139
140 return recoil;
141 }

◆ getValue()

double getValue ( ) const
overridevirtual

Returns the value of the constraint.

Implements BaseHardConstraint.

Definition at line 37 of file RecoilMassConstraint.cc.

38 {
39 double totE = 0.;
40 double totpx = 0.;
41 double totpy = 0.;
42 double totpz = 0.;
43
44 for (auto fitobject : fitobjects) {
45 auto* pfo = dynamic_cast < ParticleFitObject* >(fitobject);
46 assert(pfo);
47 totE += pfo->getE();
48 totpx += pfo->getPx();
49 totpy += pfo->getPy();
50 totpz += pfo->getPz();
51 }
52
53 const double recoilE = (m_beamE - totE);
54 const double recoilE2 = recoilE * recoilE;
55 const double recoilpx = (m_beamPx - totpx);
56 const double recoilpx2 = recoilpx * recoilpx;
57 const double recoilpy = (m_beamPy - totpy);
58 const double recoilpy2 = recoilpy * recoilpy;
59 const double recoilpz = (m_beamPz - totpz);
60 const double recoilpz2 = recoilpz * recoilpz;
61 const double recoil2 = recoilE2 - recoilpx2 - recoilpy2 - recoilpz2;
62 const double result = recoil2 - m_recoilMass * m_recoilMass;
63 return result;
64 }

◆ getVarBasis()

int getVarBasis ( ) const
overridevirtual

Implements BaseHardConstraint.

Definition at line 203 of file RecoilMassConstraint.cc.

204 {
205 return VAR_BASIS;
206 }

◆ invalidateCache()

virtual void invalidateCache ( ) const
inlinevirtualinherited

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 307 of file BaseHardConstraint.cc.

308 {
309 BaseFitObject* fo = fitobjects[ifo];
310 assert(fo);
311 double save = fo->getParam(ilocal);
312 fo->setParam(ilocal, save + eps);
313 double v1 = getValue();
314 fo->setParam(ilocal, save - eps);
315 double v2 = getValue();
316 double result = (v1 - v2) / (2 * eps);
317 fo->setParam(ilocal, save);
318 return result;
319 }
VXDTFFilterTest::v2
const std::vector< double > v2
MATLAB generated random vector.
Definition: decorrelationMatrix.cc:42
VXDTFFilterTest::v1
const std::vector< double > v1
MATLAB generated random vector.
Definition: decorrelationMatrix.cc:28

◆ 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 321 of file BaseHardConstraint.cc.

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

◆ 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::OrcaKinFit::BaseConstraint::getValue
virtual double getValue() const =0
Returns the value of the constraint function.
Belle2::OrcaKinFit::BaseConstraint::getName
virtual const char * getName() const
Returns the name of the constraint.
Definition: BaseConstraint.cc:56

◆ printFirstDerivatives()

void printFirstDerivatives ( ) const
virtualinherited

Definition at line 360 of file BaseHardConstraint.cc.

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

◆ printSecondDerivatives()

void printSecondDerivatives ( ) const
virtualinherited

Definition at line 379 of file BaseHardConstraint.cc.

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

◆ resetFOList()

virtual void resetFOList ( )
inlinevirtualinherited

Resests ParticleFitObject list.

Definition at line 97 of file ParticleConstraint.h.

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

◆ 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
inumber of 1st FitObject
jnumber of 2nd FitObject
derivativesThe result 4x4 matrix

Implements BaseHardConstraint.

Definition at line 148 of file RecoilMassConstraint.cc.

149 {
150 (void) i;
151 (void) j;
152
153 assert(dderivatives);
154 for (int k = 0; k < 16; ++k) dderivatives[k] = 0;
155
156
157 dderivatives[4 * 0 + 0] = 2; //dE^2
158 dderivatives[4 * 0 + 1] = 0; //dEdpx
159 dderivatives[4 * 0 + 2] = 0; //dEdpy
160 dderivatives[4 * 0 + 3] = 0; //dEdpz
161 dderivatives[4 * 1 + 1] = -2;//dpx^2
162 dderivatives[4 * 1 + 2] = 0; //dpxdpy
163 dderivatives[4 * 1 + 3] = 0; //dpxdpz
164 dderivatives[4 * 2 + 2] = -2;//dpy^2
165 dderivatives[4 * 2 + 3] = 0; //dpydpz
166 dderivatives[4 * 3 + 3] = -2;//dpz^2
167
168 return true;
169
170 }

◆ 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 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 }

◆ setRecoilMass()

void setRecoilMass ( double  recoilmass)
virtual

Sets the target recoil mass of the constraint.

Definition at line 143 of file RecoilMassConstraint.cc.

144 {
145 m_recoilMass = recoilmass_;
146 }

◆ test1stDerivatives()

void test1stDerivatives ( )
virtualinherited

Definition at line 251 of file BaseHardConstraint.cc.

252 {
253 B2INFO("BaseConstraint::test1stDerivatives for " << getName());
254 double y[100];
255 for (double& i : y) i = 0;
256 addToGlobalChi2DerVector(y, 100, 1);
257 double eps = 0.00001;
258 for (unsigned int ifo = 0; ifo < fitobjects.size(); ++ifo) {
259 BaseFitObject* fo = fitobjects[ifo];
260 assert(fo);
261 for (int ilocal = 0; ilocal < fo->getNPar(); ++ilocal) {
262 int iglobal = fo->getGlobalParNum(ilocal);
263 double calc = y[iglobal];
264 double num = num1stDerivative(ifo, ilocal, eps);
265 B2INFO("fo: " << fo->getName() << " par " << ilocal << "/"
266 << iglobal << " (" << fo->getParamName(ilocal)
267 << ") calc: " << calc << " - num: " << num << " = " << calc - num);
268 }
269 }
270 }
Belle2::OrcaKinFit::BaseHardConstraint::num1stDerivative
virtual double num1stDerivative(int ifo, int ilocal, double eps)
Evaluates numerically the 1st derivative w.r.t. a parameter.
Definition: BaseHardConstraint.cc:307

◆ test2ndDerivatives()

void test2ndDerivatives ( )
virtualinherited

Definition at line 272 of file BaseHardConstraint.cc.

273 {
274 B2INFO("BaseConstraint::test2ndDerivatives for " << getName());
275 const int idim = 100;
276 auto* M = new double[idim * idim];
277 for (int i = 0; i < idim * idim; ++i) M[i] = 0;
278 add2ndDerivativesToMatrix(M, idim, 1);
279 double eps = 0.0001;
280 B2INFO("eps=" << eps);
281
282 for (unsigned int ifo1 = 0; ifo1 < fitobjects.size(); ++ifo1) {
283 BaseFitObject* fo1 = fitobjects[ifo1];
284 assert(fo1);
285 for (unsigned int ifo2 = ifo1; ifo2 < fitobjects.size(); ++ifo2) {
286 BaseFitObject* fo2 = fitobjects[ifo2];
287 assert(fo2);
288 for (int ilocal1 = 0; ilocal1 < fo1->getNPar(); ++ilocal1) {
289 int iglobal1 = fo1->getGlobalParNum(ilocal1);
290 for (int ilocal2 = (ifo1 == ifo2 ? ilocal1 : 0); ilocal2 < fo2->getNPar(); ++ilocal2) {
291 int iglobal2 = fo2->getGlobalParNum(ilocal2);
292 double calc = M[idim * iglobal1 + iglobal2];
293 double num = num2ndDerivative(ifo1, ilocal1, eps, ifo2, ilocal2, eps);
294 B2INFO("fo1: " << fo1->getName() << " par " << ilocal1 << "/"
295 << iglobal1 << " (" << fo1->getParamName(ilocal1)
296 << "), fo2: " << fo2->getName() << " par " << ilocal2 << "/"
297 << iglobal2 << " (" << fo2->getParamName(ilocal2)
298 << ") calc: " << calc << " - num: " << num << " = " << calc - num);
299 }
300 }
301 }
302 }
303 delete[] M;
304 }
Belle2::OrcaKinFit::BaseHardConstraint::add2ndDerivativesToMatrix
virtual void add2ndDerivativesToMatrix(double *M, int idim, double lambda) const
Adds second order derivatives to global covariance matrix M.
Definition: BaseHardConstraint.cc:76
Belle2::OrcaKinFit::BaseHardConstraint::num2ndDerivative
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.
Definition: BaseHardConstraint.cc:321

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

◆ m_beamE

double m_beamE
protected

Definition at line 55 of file RecoilMassConstraint.h.

◆ m_beamPx

double m_beamPx
protected

Definition at line 52 of file RecoilMassConstraint.h.

◆ m_beamPy

double m_beamPy
protected

Definition at line 53 of file RecoilMassConstraint.h.

◆ m_beamPz

double m_beamPz
protected

Definition at line 54 of file RecoilMassConstraint.h.

◆ m_recoilMass

double m_recoilMass
protected

Definition at line 51 of file RecoilMassConstraint.h.

◆ name

char* name
protectedinherited

Definition at line 108 of file BaseConstraint.h.

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