Belle II Software development
RaveKinematicVertexFitter.cc
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8
9#include <analysis/VertexFitting/RaveInterface/RaveKinematicVertexFitter.h>
10
11//root
12#include <Math/ProbFunc.h>
13#include <TMatrix.h>
14
15#include <rave/TransientTrackKinematicParticle.h>
16#include <rave/impl/RaveBase/Converters/interface/RaveStreamers.h>
17
18#include <rave/KinematicTreeFactory.h>
19#include <rave/KinematicConstraint.h>
20#include <rave/KinematicConstraintBuilder.h>
21#include <rave/VertexFactory.h>
22
23#include <analysis/dataobjects/Particle.h>
24
25//c++ std lib
26using std::string;
27#include <vector>
28using std::vector;
29#include <iostream>
30
31using namespace Belle2;
32using namespace analysis;
33
34
35
37 m_massConstFit(false), m_vertFit(true)
38{
39 if (RaveSetup::getRawInstance() == nullptr) {
40 B2FATAL("RaveSetup::initialize was not called. It has to be called before RaveSetup or RaveKinematicVertexFitter are used");
41 }
43}
44
50
51
53
54
56{
57 m_massConstFit = isConstFit;
58}
59
61{
62 m_vertFit = isVertFit;
63}
64
65
66
68{
69 rave::Vector7D raveState(aParticlePtr->getX(), aParticlePtr->getY(), aParticlePtr->getZ(), aParticlePtr->getPx(),
70 aParticlePtr->getPy(), aParticlePtr->getPz(), aParticlePtr->getMass());
71 TMatrixDSym covP = aParticlePtr->getMomentumVertexErrorMatrix();
72
73 TMatrixDSym covE(7);
74 for (int i = 0; i < 7; i++) {
75 for (int j = 0; j < 7; j++) {
76 if (i < 3 && j < 3) covE(i, j) = covP(i + 4, j + 4);
77 if (i > 2 && j > 2) covE(i, j) = covP(i - 3, j - 3);
78 if (i < 3 && j > 2) covE(i, j) = covP(i + 4, j - 3);
79 if (i > 2 && j < 3) covE(i, j) = covP(i - 3, j + 4);
80 }
81 }
82
83 TMatrixDSym cov = ErrorMatrixEnergyToMass(aParticlePtr->get4Vector(), covE);
84
85 rave::Covariance7D raveCov(cov(0, 0), cov(0, 1), cov(0, 2), // x x , x y, x z
86 cov(1, 1), cov(1, 2), cov(2, 2), // y y , y z, z z
87 cov(0, 3), cov(0, 4), cov(0, 5), // x px , x py, x pz
88 cov(1, 3), cov(1, 4), cov(1, 5), // y px , y py, y pz
89 cov(2, 3), cov(2, 4), cov(2, 5), // z px , z py, z pz
90 cov(3, 3), cov(3, 4), cov(3, 5), // px px , px py, px pz
91 cov(4, 4), cov(4, 5), cov(5, 5), // py py , py pz, pz pz
92 cov(0, 6), cov(1, 6), cov(2, 6), // x m , y m, z m
93 cov(3, 6), cov(4, 6), cov(5, 6), // px m, py m, pz m
94 cov(6, 6)); // mm
95
96 rave::TransientTrackKinematicParticle aRaveParticle(raveState, raveCov, rave::Charge(aParticlePtr->getCharge()), 1, 1);
97 // 1 and 1 are dummy values for chi2 and ndf. the are not used for the vertex fit
98
99 m_inputParticles.push_back(aRaveParticle);
100 m_belleDaughters.push_back(const_cast<Particle*>(aParticlePtr));
101
102}
103
104void RaveKinematicVertexFitter::addMother(const Particle* aMotherParticlePtr)
105{
106 vector<Particle*> daughters = aMotherParticlePtr->getDaughters();
107
108 int nDaughters = daughters.size();
109 for (int i = 0; i not_eq nDaughters; ++i) {
110 addTrack(daughters[i]);
111 }
112
113 //store input pointer so fit results can be written to the mother particle after the fit
114 auto* tmp = const_cast<Particle*>(aMotherParticlePtr);
116
117}
118
119
120void RaveKinematicVertexFitter::setMother(const Particle* aMotherParticlePtr)
121{
122 auto* tmp = const_cast<Particle*>(aMotherParticlePtr);
124}
125
126
127
129{
130 // make sure all output in this function is converted to log messages
131 auto output_capture = captureOutput();
132
133 if (m_inputParticles.size() < 2 && m_vertFit) {
134 return -1;
135 }
136 int nOfVertices = -100;
137 if (m_useBeamSpot == true) {
138 const ROOT::Math::XYZVector& bsPos = RaveSetup::getRawInstance()->m_beamSpot;
139 const TMatrixDSym& bsCov = RaveSetup::getRawInstance()->m_beamSpotCov;
140 const rave::Covariance3D bsCovRave(bsCov(0, 0), bsCov(0, 1), bsCov(0, 2), bsCov(1, 1), bsCov(1, 2), bsCov(2, 2));
141 RaveSetup::getRawInstance()->m_raveVertexFactory->setBeamSpot(rave::Ellipsoid3D(rave::Point3D(bsPos.X(), bsPos.Y(), bsPos.Z()),
142 bsCovRave));
143 }
144
145 if (m_vertFit && m_massConstFit) {
146
147 rave::KinematicConstraint cs2 = rave::KinematicConstraintBuilder().createMultiTrackMassKinematicConstraint(
148 m_motherParticlePtr->getPDGMass(), m_inputParticles.size());
149 try {
151 m_fittedParticle = m_fittedResult.topParticle();
152 } catch (...) {
153 nOfVertices = 0;
154 }
155 } else {
156
157 if (m_vertFit) {
158 if (!m_massConstFit) {
159 try {
161 m_fittedParticle = m_fittedResult.topParticle();
162 } catch (...) {
163 nOfVertices = 0;
164 }
165 }
166
167 }
168
169 if (!m_vertFit && m_massConstFit) {
170
171 try {
172
173 Particle* aParticlePtr = m_motherParticlePtr;
174
175 rave::Vector7D raveState(aParticlePtr->getX(), aParticlePtr->getY(), aParticlePtr->getZ(), aParticlePtr->getPx(),
176 aParticlePtr->getPy(), aParticlePtr->getPz(), aParticlePtr->getMass());
177 TMatrixFSym covP = aParticlePtr->getMomentumVertexErrorMatrix();
178
179 float chi2 = 1;
180 float ndf = 1.;
181
182 TMatrixDSym covE(7);
183 for (int i = 0; i < 7; i++) {
184 for (int j = 0; j < 7; j++) {
185 if (i < 3 && j < 3) covE(i, j) = covP(i + 4, j + 4);
186 if (i > 2 && j > 2) covE(i, j) = covP(i - 3, j - 3);
187 if (i < 3 && j > 2) covE(i, j) = covP(i + 4, j - 3);
188 if (i > 2 && j < 3) covE(i, j) = covP(i - 3, j + 4);
189 }
190 }
191
192 TMatrixDSym cov = ErrorMatrixEnergyToMass(aParticlePtr->get4Vector(), covE);
193
194 rave::Covariance7D raveCov(cov(0, 0), cov(0, 1), cov(0, 2), // x x , x y, x z
195 cov(1, 1), cov(1, 2), cov(2, 2), // y y , y z, z z
196 cov(0, 3), cov(0, 4), cov(0, 5), // x px , x py, x pz
197 cov(1, 3), cov(1, 4), cov(1, 5), // y px , y py, y pz
198 cov(2, 3), cov(2, 4), cov(2, 5), // z px , z py, z pz
199 cov(3, 3), cov(3, 4), cov(3, 5), // px px , px py, px pz
200 cov(4, 4), cov(4, 5), cov(5, 5), // py py , py pz, pz pz
201 cov(0, 6), cov(1, 6), cov(2, 6), // x m , y m, z m
202 cov(3, 6), cov(4, 6), cov(5, 6), // px m, py m, pz m
203 cov(6, 6)); // mm
204
205 rave::TransientTrackKinematicParticle aRaveParticle(raveState, raveCov, rave::Charge(aParticlePtr->getCharge()), chi2, ndf);
206
207 std::vector< rave::KinematicParticle > parts; parts.push_back(aRaveParticle);
208
209 rave::KinematicConstraint constraint = rave::KinematicConstraintBuilder().createMassKinematicConstraint(
210 m_motherParticlePtr->getPDGMass(), 0.);
211
212 if (m_motherParticlePtr->getMomentumVertexErrorMatrix().Determinant() != 0) {
213
214 std::vector< rave::KinematicParticle > refitted = RaveSetup::getRawInstance()->m_raveKinematicTreeFactory->useParticleFitter(parts,
215 constraint, "ppf:lppf");
216
217 m_fittedParticle = refitted[0];
218
219 } else {
220 B2ERROR("[RaveKinematicVertexFitter]: VertexException saying ParentParticleFitter::error inverting covariance matrix occurred");
221 nOfVertices = 0;
222 }
223
224
225 } catch (...) {
226 nOfVertices = 0;
227 }
228 }
229
230 }
231
232
233 rave::Vector7D fittedState;
234 rave::Covariance7D fittedCov;
235
236 try {
237 fittedState = m_fittedParticle.fullstate();
238 fittedCov = m_fittedParticle.fullerror();
239 } catch (...) {
240 nOfVertices = 0;
241 }
242
243
244 for (auto& i : m_inputParticles) i.unlink();
245 m_inputParticles.clear();
246 //
247
248 if (nOfVertices == 0) { // vertex fit not successful
249 return 0;
250 }
251
252 if (m_vertFit) {
253 rave::KinematicVertex fittedVertex = m_fittedResult.currentDecayVertex();
254
255 m_fittedNdf = fittedVertex.ndf();
256 m_fittedChi2 = fittedVertex.chiSquared();
257 m_fittedPValue = ROOT::Math::chisquared_cdf_c(m_fittedChi2, m_fittedNdf);
258 m_fittedPos.SetXYZ(fittedVertex.position().x(), fittedVertex.position().y(), fittedVertex.position().z());
259
260 } else {
263 m_fittedPValue = ROOT::Math::chisquared_cdf_c(m_fittedChi2, m_fittedNdf);
265 }
266
267
268 m_fitted4Vector.SetXYZT(fittedState.p4().p3().x(), fittedState.p4().p3().y(), fittedState.p4().p3().z(), fittedState.p4().energy());
269
270 m_fitted7Cov.ResizeTo(7, 7);
271
272 TMatrixDSym fitted7CovM(7);
273
274 fitted7CovM(3, 6) = fittedCov.dpxm(); fitted7CovM(6, 3) = fitted7CovM(3, 6);
275 fitted7CovM(4, 6) = fittedCov.dpym(); fitted7CovM(6, 4) = fitted7CovM(4, 6);
276 fitted7CovM(5, 6) = fittedCov.dpzm(); fitted7CovM(6, 5) = fitted7CovM(5, 6);
277 fitted7CovM(6, 6) = fittedCov.dmm(); fitted7CovM(6, 6) = fitted7CovM(6, 6);
278 fitted7CovM(0, 6) = fittedCov.dxm(); fitted7CovM(6, 0) = fitted7CovM(0, 6);
279 fitted7CovM(1, 6) = fittedCov.dym(); fitted7CovM(6, 1) = fitted7CovM(1, 6);
280 fitted7CovM(2, 6) = fittedCov.dzm(); fitted7CovM(6, 2) = fitted7CovM(2, 6);
281
282 fitted7CovM(3, 3) = fittedCov.dpxpx(); fitted7CovM(3, 3) = fitted7CovM(3, 3);
283 fitted7CovM(3, 4) = fittedCov.dpxpy(); fitted7CovM(4, 3) = fitted7CovM(3, 4);
284 fitted7CovM(3, 5) = fittedCov.dpxpz(); fitted7CovM(5, 3) = fitted7CovM(3, 5);
285 fitted7CovM(3, 0) = fittedCov.dxpx(); fitted7CovM(0, 3) = fitted7CovM(3, 0);
286 fitted7CovM(3, 1) = fittedCov.dypx(); fitted7CovM(1, 3) = fitted7CovM(3, 1);
287 fitted7CovM(3, 2) = fittedCov.dzpx(); fitted7CovM(2, 3) = fitted7CovM(3, 2);
288
289 fitted7CovM(4, 4) = fittedCov.dpypy(); fitted7CovM(4, 4) = fitted7CovM(4, 4);
290 fitted7CovM(4, 5) = fittedCov.dpypz(); fitted7CovM(5, 4) = fitted7CovM(4, 5);
291 fitted7CovM(4, 0) = fittedCov.dxpy(); fitted7CovM(0, 4) = fitted7CovM(4, 0);
292 fitted7CovM(4, 1) = fittedCov.dypy(); fitted7CovM(1, 4) = fitted7CovM(4, 1);
293 fitted7CovM(4, 2) = fittedCov.dzpy(); fitted7CovM(2, 4) = fitted7CovM(4, 2);
294
295 fitted7CovM(5, 5) = fittedCov.dpzpz(); fitted7CovM(5, 5) = fitted7CovM(5, 5);
296 fitted7CovM(5, 0) = fittedCov.dxpz(); fitted7CovM(0, 5) = fitted7CovM(5, 0);
297 fitted7CovM(5, 1) = fittedCov.dypz(); fitted7CovM(1, 5) = fitted7CovM(5, 1);
298 fitted7CovM(5, 2) = fittedCov.dzpz(); fitted7CovM(2, 5) = fitted7CovM(5, 2);
299
300 fitted7CovM(0, 0) = fittedCov.dxx(); fitted7CovM(0, 0) = fitted7CovM(0, 0);
301 fitted7CovM(0, 1) = fittedCov.dxy(); fitted7CovM(1, 0) = fitted7CovM(0, 1);
302 fitted7CovM(0, 2) = fittedCov.dxz(); fitted7CovM(2, 0) = fitted7CovM(0, 2);
303
304 fitted7CovM(1, 1) = fittedCov.dyy(); fitted7CovM(1, 1) = fitted7CovM(1, 1);
305 fitted7CovM(1, 2) = fittedCov.dyz(); fitted7CovM(2, 1) = fitted7CovM(1, 2);
306
307 fitted7CovM(2, 2) = fittedCov.dzz(); fitted7CovM(2, 2) = fitted7CovM(2, 2);
308
309 TMatrixDSym fitted7CovE = ErrorMatrixMassToEnergy(m_fitted4Vector, fitted7CovM);
310
311 for (int i = 0; i < 7; i++) {
312 for (int j = 0; j < 7; j++) {
313 if (i < 4 && j < 4) m_fitted7Cov(i, j) = fitted7CovE(i + 3, j + 3);
314 if (i > 3 && j > 3) m_fitted7Cov(i, j) = fitted7CovE(i - 4, j - 4);
315 if (i < 4 && j > 3) m_fitted7Cov(i, j) = fitted7CovE(i + 3, j - 4);
316 if (i > 3 && j < 4) m_fitted7Cov(i, j) = fitted7CovE(i - 4, j + 3);
317 }
318 }
319
320 return 1;
321}
322
327
329{
330
331 m_fittedResult.topParticle();
332 std::vector< rave::KinematicParticle > rDau = m_fittedResult.daughterParticles();
333 std::vector<Particle*> bDau = m_belleDaughters;
334 if (rDau.size() == bDau.size()) {
335 for (unsigned ii = 0; ii < bDau.size(); ii++) {
336 rave::Vector7D fittedState;
337 rave::Covariance7D fittedCov;
338 fittedState = rDau[ii].fullstate();
339 fittedCov = rDau[ii].fullerror();
340
341 ROOT::Math::PxPyPzEVector p4(fittedState.p4().p3().x(), fittedState.p4().p3().y(), fittedState.p4().p3().z(),
342 fittedState.p4().energy());
343
344 ROOT::Math::XYZVector x3(fittedState.x(), fittedState.y(), fittedState.z());
345
346
347 TMatrixDSym fitted7CovM(7);
348 fitted7CovM(3, 6) = fittedCov.dpxm(); fitted7CovM(6, 3) = fitted7CovM(3, 6);
349 fitted7CovM(4, 6) = fittedCov.dpym(); fitted7CovM(6, 4) = fitted7CovM(4, 6);
350 fitted7CovM(5, 6) = fittedCov.dpzm(); fitted7CovM(6, 5) = fitted7CovM(5, 6);
351 fitted7CovM(6, 6) = fittedCov.dmm(); fitted7CovM(6, 6) = fitted7CovM(6, 6);
352 fitted7CovM(0, 6) = fittedCov.dxm(); fitted7CovM(6, 0) = fitted7CovM(0, 6);
353 fitted7CovM(1, 6) = fittedCov.dym(); fitted7CovM(6, 1) = fitted7CovM(1, 6);
354 fitted7CovM(2, 6) = fittedCov.dzm(); fitted7CovM(6, 2) = fitted7CovM(2, 6);
355
356 fitted7CovM(3, 3) = fittedCov.dpxpx(); fitted7CovM(3, 3) = fitted7CovM(3, 3);
357 fitted7CovM(3, 4) = fittedCov.dpxpy(); fitted7CovM(4, 3) = fitted7CovM(3, 4);
358 fitted7CovM(3, 5) = fittedCov.dpxpz(); fitted7CovM(5, 3) = fitted7CovM(3, 5);
359 fitted7CovM(3, 0) = fittedCov.dxpx(); fitted7CovM(0, 3) = fitted7CovM(3, 0);
360 fitted7CovM(3, 1) = fittedCov.dypx(); fitted7CovM(1, 3) = fitted7CovM(3, 1);
361 fitted7CovM(3, 2) = fittedCov.dzpx(); fitted7CovM(2, 3) = fitted7CovM(3, 2);
362
363 fitted7CovM(4, 4) = fittedCov.dpypy(); fitted7CovM(4, 4) = fitted7CovM(4, 4);
364 fitted7CovM(4, 5) = fittedCov.dpypz(); fitted7CovM(5, 4) = fitted7CovM(4, 5);
365 fitted7CovM(4, 0) = fittedCov.dxpy(); fitted7CovM(0, 4) = fitted7CovM(4, 0);
366 fitted7CovM(4, 1) = fittedCov.dypy(); fitted7CovM(1, 4) = fitted7CovM(4, 1);
367 fitted7CovM(4, 2) = fittedCov.dzpy(); fitted7CovM(2, 4) = fitted7CovM(4, 2);
368
369 fitted7CovM(5, 5) = fittedCov.dpzpz(); fitted7CovM(5, 5) = fitted7CovM(5, 5);
370 fitted7CovM(5, 0) = fittedCov.dxpz(); fitted7CovM(0, 5) = fitted7CovM(5, 0);
371 fitted7CovM(5, 1) = fittedCov.dypz(); fitted7CovM(1, 5) = fitted7CovM(5, 1);
372 fitted7CovM(5, 2) = fittedCov.dzpz(); fitted7CovM(2, 5) = fitted7CovM(5, 2);
373
374 fitted7CovM(0, 0) = fittedCov.dxx(); fitted7CovM(0, 0) = fitted7CovM(0, 0);
375 fitted7CovM(0, 1) = fittedCov.dxy(); fitted7CovM(1, 0) = fitted7CovM(0, 1);
376 fitted7CovM(0, 2) = fittedCov.dxz(); fitted7CovM(2, 0) = fitted7CovM(0, 2);
377
378 fitted7CovM(1, 1) = fittedCov.dyy(); fitted7CovM(1, 1) = fitted7CovM(1, 1);
379 fitted7CovM(1, 2) = fittedCov.dyz(); fitted7CovM(2, 1) = fitted7CovM(1, 2);
380
381 fitted7CovM(2, 2) = fittedCov.dzz(); fitted7CovM(2, 2) = fitted7CovM(2, 2);
382
383 TMatrixDSym fitted7CovE = ErrorMatrixMassToEnergy(m_fitted4Vector, fitted7CovM);
384
385 TMatrixDSym fitted7CovDauM(7);
386 for (int i = 0; i < 7; i++) {
387 for (int j = 0; j < 7; j++) {
388 if (i < 4 && j < 4) fitted7CovDauM(i, j) = fitted7CovE(i + 3, j + 3);
389 if (i > 3 && j > 3) fitted7CovDauM(i, j) = fitted7CovE(i - 4, j - 4);
390 if (i < 4 && j > 3) fitted7CovDauM(i, j) = fitted7CovE(i + 3, j - 4);
391 if (i > 3 && j < 4) fitted7CovDauM(i, j) = fitted7CovE(i - 4, j + 3);
392 }
393 }
394
395 float pValDau = rDau[ii].chi2();
396
397 bDau[ii]->updateMomentum(p4, x3, fitted7CovDauM, pValDau);
398
399 }
400
401 } else B2ERROR("Error in Daughters update");
402
403}
404
409
411{
412 return m_fittedPos;
413}
414
419
421{
422 return m_fittedNdf;
423}
424
429
431{
432 return m_fitted7Cov;
433}
434
436{
437 TMatrixDSym posErr(3);
438 posErr(0, 0) = m_fitted7Cov(4, 4);
439 posErr(0, 1) = m_fitted7Cov(4, 5);
440 posErr(0, 2) = m_fitted7Cov(4, 6);
441 posErr(1, 0) = m_fitted7Cov(5, 4);
442 posErr(1, 1) = m_fitted7Cov(5, 5);
443 posErr(1, 2) = m_fitted7Cov(5, 6);
444 posErr(2, 0) = m_fitted7Cov(6, 4);
445 posErr(2, 1) = m_fitted7Cov(6, 5);
446 posErr(2, 2) = m_fitted7Cov(6, 6);
447
448 return posErr;
449}
450
451
452TMatrixDSym RaveKinematicVertexFitter::ErrorMatrixMassToEnergy(const ROOT::Math::PxPyPzEVector& p4, const TMatrixDSym& MassErr)
453{
454
455 TMatrix jac(7, 7);
456 for (int i = 0; i < 7; i++) {
457 for (int j = 0; j < 7; j++) {
458 if (i == j) jac(i, j) = 1;
459 else jac(i, j) = 0;
460 }
461 }
462 jac(6, 3) = p4.Px() / p4.E();
463 jac(6, 4) = p4.Py() / p4.E();
464 jac(6, 5) = p4.Pz() / p4.E();
465 jac(6, 6) = p4.M() / p4.E();
466
467
468 TMatrix jact(7, 7); jact.Transpose(jac);
469 TMatrix EnergyErrPart(7, 7); EnergyErrPart.Mult(jac, MassErr);
470 TMatrix EnergyErrTemp(7, 7); EnergyErrTemp.Mult(EnergyErrPart, jact);
471
472 TMatrixDSym EnergyErr(7);
473 for (int i = 0; i < 7; i++) {
474 for (int j = 0; j < 7; j++) {
475 EnergyErr(i, j) = EnergyErrTemp(i, j);
476 }
477 }
478
479 return EnergyErr;
480}
481
482TMatrixDSym RaveKinematicVertexFitter::ErrorMatrixEnergyToMass(const ROOT::Math::PxPyPzEVector& p4, const TMatrixDSym& EnergyErr)
483{
484
485 TMatrix jac(7, 7);
486 for (int i = 0; i < 7; i++) {
487 for (int j = 0; j < 7; j++) {
488 if (i == j) jac(i, j) = 1;
489 else jac(i, j) = 0;
490 }
491 }
492 jac(6, 3) = -1 * p4.Px() / p4.M();
493 jac(6, 4) = -1 * p4.Py() / p4.M();
494 jac(6, 5) = -1 * p4.Pz() / p4.M();
495 jac(6, 6) = p4.E() / p4.M();
496
497 TMatrix jact(7, 7); jact.Transpose(jac);
498 TMatrix MassErrPart(7, 7); MassErrPart.Mult(jac, EnergyErr);
499 TMatrix MassErrTemp(7, 7); MassErrTemp.Mult(MassErrPart, jact);
500
501 TMatrixDSym MassErr(7);
502 for (int i = 0; i < 7; i++) {
503 for (int j = 0; j < 7; j++) {
504 MassErr(i, j) = MassErrTemp(i, j);
505 }
506 }
507
508 return MassErr;
509}
Simple RAII guard for output interceptor.
Capture stdout and stderr and convert into log messages.
@ c_Debug
Debug: for code development.
Definition LogConfig.h:26
Class to store reconstructed particles.
Definition Particle.h:76
double getPx() const
Returns x component of momentum.
Definition Particle.h:607
double getPz() const
Returns z component of momentum.
Definition Particle.h:625
double getX() const
Returns x component of vertex position.
Definition Particle.h:660
double getPy() const
Returns y component of momentum.
Definition Particle.h:616
double getZ() const
Returns z component of vertex position.
Definition Particle.h:678
double getCharge(void) const
Returns particle charge.
Definition Particle.cc:653
ROOT::Math::PxPyPzEVector get4Vector() const
Returns Lorentz vector.
Definition Particle.h:567
double getY() const
Returns y component of vertex position.
Definition Particle.h:669
std::vector< Particle * > getDaughters() const
Returns a vector of pointers to daughter particles.
Definition Particle.cc:668
TMatrixFSym getMomentumVertexErrorMatrix() const
Returns 7x7 error matrix.
Definition Particle.cc:451
double getMass() const
Returns invariant mass (= nominal for FS particles)
Definition Particle.h:527
std::vector< Particle * > m_belleDaughters
Belle Particle pointers input.
std::string m_raveAlgorithm
Algorithm used by rave (kalman, avr, ...)
TMatrixDSym ErrorMatrixEnergyToMass(const ROOT::Math::PxPyPzEVector &p4, const TMatrixDSym &EnergyErr)
Convert the error matrix from P-E to P-M.
IOIntercept::InterceptorScopeGuard< IOIntercept::OutputToLogMessages > captureOutput()
Start capturing the output of rave and divert it to log messages.
ROOT::Math::PxPyPzEVector m_fitted4Vector
4 momentum of the mother particle after the fit
TMatrixFSym m_fitted7Cov
7x7 error matrix of the mother particle after the fit
TMatrixDSym getCov()
get the covariance matrix (7x7).
rave::KinematicParticle m_fittedParticle
Particle fit output.
bool m_useBeamSpot
flag determines if the beam spot will be used or not.
void addMother(const Particle *aMotherParticlePtr)
All daughters of the argument of this function will be used as input for the vertex fit.
ROOT::Math::XYZVector getPos()
get the position of the fitted vertex.
void addTrack(const Particle *aParticlePtr)
add a track (in the format of a Particle) to set of tracks that should be fitted to a vertex
bool m_massConstFit
flag determines if the mass fit is performed
TMatrixDSym ErrorMatrixMassToEnergy(const ROOT::Math::PxPyPzEVector &p4, const TMatrixDSym &MassErr)
Convert the error matrix from P-M to P-E.
void setMother(const Particle *aMotherParticlePtr)
Set Mother particle for Vertex/momentum update.
RaveKinematicVertexFitter()
The default constructor checks if RaveSetup was initialized and will set the attributes of RaveKinema...
rave::KinematicTree m_fittedResult
the output of the kinematic fit
int fit()
do the kinematic vertex fit with all tracks previously added with the addTrack or addMother function.
Particle * m_motherParticlePtr
pointer to the mother particle who's daughters will be used in the fit.
void setVertFit(bool isVertFit=true)
Set vertex fit: set false in case of mass fit only.
void setMassConstFit(bool isConstFit=true)
Set mass constrained fit.
Particle * getMother()
returns a pointer to the mother particle
double getPValue()
get the p value of the fitted vertex.
TMatrixDSym getVertexErrorMatrix()
get the covariance matrix (3x3) of the of the fitted vertex position.
double getChi2()
get the χ² of the fitted vertex.
std::vector< rave::KinematicParticle > m_inputParticles
input particles for vertex fit in rave format
double getNdf()
get the number of degrees of freedom (NDF) of the fitted vertex.
bool m_vertFit
flag determines if the vertex fit is performed
void updateDaughters()
update the Daughters particles
ROOT::Math::XYZVector m_fittedPos
Fitted vertex position.
TMatrixDSym m_beamSpotCov
beam spot position covariance matrix.
Definition RaveSetup.h:71
rave::KinematicTreeFactory * m_raveKinematicTreeFactory
< The RAVE Kinematic Tree factory is the principal interface offered by the RAVE for kinematic vertex...
Definition RaveSetup.h:78
bool m_useBeamSpot
flag determines if beam spot information should be used for vertex fit.
Definition RaveSetup.h:69
static RaveSetup * getRawInstance()
Same as getInstance(), but no check if the instance is initialised.
Definition RaveSetup.cc:29
ROOT::Math::XYZVector m_beamSpot
beam spot position.
Definition RaveSetup.h:70
rave::VertexFactory * m_raveVertexFactory
The RAVE vertex factory is the principal interface offered by the RAVE vertex fitting library.
Definition RaveSetup.h:74
InterceptorScopeGuard< T > start_intercept(T &interceptor)
Convenience wrapper to simplify use of InterceptorScopeGuard<T>.
Abstract base class for different kinds of events.