Belle II Software development
TimeDependentVariables.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// Own header.
10#include <analysis/variables/TimeDependentVariables.h>
11
12#include <framework/dbobjects/BeamParameters.h>
13
14// dataobjects
15#include <analysis/dataobjects/Particle.h>
16#include <analysis/dataobjects/TagVertex.h>
17
18//utilities
19#include <analysis/utility/DistanceTools.h>
20#include <analysis/utility/PCmsLabTransform.h>
21#include <analysis/utility/RotationTools.h>
22#include <analysis/utility/ReferenceFrame.h>
23
24// framework aux
25#include <framework/gearbox/Const.h>
26#include <mdst/dataobjects/MCParticle.h>
27#include <mdst/dataobjects/TrackFitResult.h>
28
29#include <Math/VectorUtil.h>
30#include <TMatrixD.h>
31#include <TVectorD.h>
32
33//#include <iostream>
34#include <cmath>
35
36using namespace std;
37
38namespace Belle2 {
43 namespace Variable {
44
45 // from RotationTools.h
46 using RotationTools::getUnitOrthogonal;
47 using RotationTools::toVec;
48
49 static const ROOT::Math::XYZVector vecNaN(Const::doubleNaN, Const::doubleNaN, Const::doubleNaN);
50
51 // ############################################## Time Dependent CPV Analysis Variables ###############################################
52
53 // TagV x, y, z
54 double particleTagVx(const Particle* particle)
55 {
56 auto* vert = particle->getRelatedTo<TagVertex>();
57 if (!vert) return Const::doubleNaN;
58 return vert->getTagVertex().X();
59 }
60
61 double particleTagVy(const Particle* particle)
62 {
63 auto* vert = particle->getRelatedTo<TagVertex>();
64 if (!vert) return Const::doubleNaN;
65 return vert->getTagVertex().Y();
66 }
67
68 double particleTagVz(const Particle* particle)
69 {
70 auto* vert = particle->getRelatedTo<TagVertex>();
71 if (!vert) return Const::doubleNaN;
72 return vert->getTagVertex().Z();
73 }
74
75 double particleTruthTagVx(const Particle* particle)
76 {
77 auto* vert = particle->getRelatedTo<TagVertex>();
78 if (!vert) return Const::doubleNaN;
79 return vert->getMCTagVertex().X();
80 }
81
82 double particleTruthTagVy(const Particle* particle)
83 {
84 auto* vert = particle->getRelatedTo<TagVertex>();
85 if (!vert) return Const::doubleNaN;
86 return vert->getMCTagVertex().Y();
87 }
88
89 double particleTruthTagVz(const Particle* particle)
90 {
91 auto* vert = particle->getRelatedTo<TagVertex>();
92 if (!vert) return Const::doubleNaN;
93 return vert->getMCTagVertex().Z();
94 }
95
96 double particleTagVCov(const Particle* particle, const std::vector<double>& element)
97 {
98 int elementI = int(std::lround(element[0]));
99 int elementJ = int(std::lround(element[1]));
100
101 if (elementI < 0 || elementI > 2) {
102 B2WARNING("Index is out of boundaries [0 - 2]:" << LogVar("i", elementI));
103 return Const::doubleNaN;
104 }
105 if (elementJ < 0 || elementJ > 2) {
106 B2WARNING("Index is out of boundaries [0 - 2]:" << LogVar("j", elementJ));
107 return Const::doubleNaN;
108 }
109
110 auto* vert = particle->getRelatedTo<TagVertex>();
111 if (!vert) return Const::doubleNaN;
112 TMatrixDSym TagVErr = vert->getTagVertexErrMatrix();
113 return TagVErr(elementI, elementJ);
114 }
115
116 double particleTagVxErr(const Particle* particle)
117 {
118 auto* vert = particle->getRelatedTo<TagVertex>();
119 if (!vert) return Const::doubleNaN;
120 TMatrixDSym TagVErr = vert->getTagVertexErrMatrix();
121 return sqrt(TagVErr(0, 0));
122 }
123
124 double particleTagVyErr(const Particle* particle)
125 {
126 auto* vert = particle->getRelatedTo<TagVertex>();
127 if (!vert) return Const::doubleNaN;
128 TMatrixDSym TagVErr = vert->getTagVertexErrMatrix();
129 return sqrt(TagVErr(1, 1));
130 }
131
132 double particleTagVzErr(const Particle* particle)
133 {
134 auto* vert = particle->getRelatedTo<TagVertex>();
135 if (!vert) return Const::doubleNaN;
136 TMatrixDSym TagVErr = vert->getTagVertexErrMatrix();
137 return sqrt(TagVErr(2, 2));
138 }
139
140 double particleTagVpVal(const Particle* particle)
141 {
142 auto* vert = particle->getRelatedTo<TagVertex>();
143 if (!vert) return Const::doubleNaN;
144 return vert->getTagVertexPval();
145 }
146
147 double particleTagVNTracks(const Particle* particle)
148 {
149 auto* vert = particle->getRelatedTo<TagVertex>();
150 if (!vert) return Const::doubleNaN;
151 return vert->getNTracks();
152 }
153
154 double particleTagVNFitTracks(const Particle* particle)
155 {
156 auto* vert = particle->getRelatedTo<TagVertex>();
157 if (!vert) return Const::doubleNaN;
158 return vert->getNFitTracks();
159 }
160
161 double particleTagVType(const Particle* particle)
162 {
163 auto* vert = particle->getRelatedTo<TagVertex>();
164 if (!vert) return Const::doubleNaN;
165 return vert->getFitType();
166 }
167
168 double particleTagVNDF(const Particle* particle)
169 {
170 auto* vert = particle->getRelatedTo<TagVertex>();
171 if (!vert) return Const::doubleNaN;
172 return vert->getTagVNDF();
173 }
174
175 double particleTagVChi2(const Particle* particle)
176 {
177 auto* vert = particle->getRelatedTo<TagVertex>();
178 if (!vert) return Const::doubleNaN;
179 return vert->getTagVChi2();
180 }
181
182 double particleTagVChi2IP(const Particle* particle)
183 {
184 auto* vert = particle->getRelatedTo<TagVertex>();
185 if (!vert) return Const::doubleNaN;
186 return vert->getTagVChi2IP();
187 }
188
189 // Delta t and related
190
191 double particleDeltaT(const Particle* particle)
192 {
193 auto* vert = particle->getRelatedTo<TagVertex>();
194 if (!vert) return Const::doubleNaN;
195 return vert->getDeltaT();
196 }
197
198 double particleDeltaTErr(const Particle* particle)
199 {
200 auto* vert = particle->getRelatedTo<TagVertex>();
201 if (!vert) return Const::doubleNaN;
202 return vert->getDeltaTErr();
203 }
204
205 double particleDeltaTRes(const Particle* particle)
206 {
207 return particleDeltaT(particle) - particleMCDeltaT(particle);
208 }
209
210 double particleDeltaTBelle(const Particle* particle)
211 {
212 double beta = PCmsLabTransform().getBoostVector().R();
213 double bg = beta / sqrt(1 - beta * beta);
214 double c = Const::speedOfLight / 1000.; // cm ps-1
215 return particleDeltaZ(particle) / bg / c;
216 }
217
218 double particleMCDeltaTau(const Particle* particle)
219 {
220 auto* vert = particle->getRelatedTo<TagVertex>();
221 if (!vert) return Const::doubleNaN;
222 return vert->getMCDeltaTau();
223 }
224
225 double particleMCDeltaT(const Particle* particle)
226 {
227 auto* vert = particle->getRelatedTo<TagVertex>();
228 if (!vert) return Const::doubleNaN;
229 return vert->getMCDeltaT();
230 }
231
232 double particleMCDeltaBoost(const Particle* particle)
233 {
234 auto* vert = particle->getRelatedTo<TagVertex>();
235 if (!vert) return Const::doubleNaN;
236
237 double beta = PCmsLabTransform().getBoostVector().R();
238 double bg = beta / sqrt(1 - beta * beta);
239 double c = Const::speedOfLight / 1000.; // cm ps-1
240 return vert->getMCDeltaT() * bg * c;
241 }
242
243 double particleDeltaZ(const Particle* particle)
244 {
245 auto* vert = particle->getRelatedTo<TagVertex>();
246 if (!vert) return Const::doubleNaN;
247 return particle->getZ() - vert->getTagVertex().Z();
248 }
249
250 double particleDeltaZErr(const Particle* particle)
251 {
252 auto* vert = particle->getRelatedTo<TagVertex>();
253 if (!vert) return Const::doubleNaN;
254
255 double zVariance = particle->getVertexErrorMatrix()(2, 2);
256 double TagVZVariance = vert->getTagVertexErrMatrix()(2, 2);
257 double result = sqrt(zVariance + TagVZVariance);
258 if (!std::isfinite(result)) return Const::doubleNaN;
259
260 return result;
261 }
262
263 double particleDeltaB(const Particle* particle)
264 {
265 auto* vert = particle->getRelatedTo<TagVertex>();
266 if (!vert) return Const::doubleNaN;
267
268 double beta = PCmsLabTransform().getBoostVector().R();
269 double bg = beta / sqrt(1 - beta * beta);
270 double c = Const::speedOfLight / 1000.; // cm ps-1
271 return vert->getDeltaT() * bg * c;
272 }
273
274 double particleDeltaBErr(const Particle* particle)
275 {
276 auto* vert = particle->getRelatedTo<TagVertex>();
277 if (!vert) return Const::doubleNaN;
278
279 double beta = PCmsLabTransform().getBoostVector().R();
280 double bg = beta / sqrt(1 - beta * beta);
281 double c = Const::speedOfLight / 1000.; // cm ps-1
282 return vert->getDeltaTErr() * bg * c;
283 }
284
285 // Vertex boost direction
286
287 double vertexBoostDirection(const Particle* part)
288 {
289 ROOT::Math::XYZVector boostDir = PCmsLabTransform().getBoostVector().Unit();
290 ROOT::Math::XYZVector pos = part->getVertex();
291 return pos.Dot(boostDir);
292 }
293
294 double vertexOrthogonalBoostDirection(const Particle* part)
295 {
296 ROOT::Math::XYZVector boost = PCmsLabTransform().getBoostVector();
297 ROOT::Math::XYZVector orthBoostDir = getUnitOrthogonal(boost);
298
299 ROOT::Math::XYZVector pos = part->getVertex();
300 return pos.Dot(orthBoostDir);
301 }
302
303 double vertexTruthBoostDirection(const Particle* part)
304 {
305 static DBObjPtr<BeamParameters> beamParamsDB;
306 if (!beamParamsDB.isValid())
307 return Const::doubleNaN;
308 ROOT::Math::XYZVector boostDir = -(beamParamsDB->getHER() + beamParamsDB->getLER()).BoostToCM().Unit();
309 const MCParticle* mcPart = part->getMCParticle();
310 if (!mcPart) return Const::doubleNaN;
311 ROOT::Math::XYZVector pos = mcPart->getDecayVertex();
312 return pos.Dot(boostDir);
313 }
314
315 double vertexTruthOrthogonalBoostDirection(const Particle* part)
316 {
317 static DBObjPtr<BeamParameters> beamParamsDB;
318 if (!beamParamsDB.isValid())
319 return Const::doubleNaN;
320 ROOT::Math::XYZVector boost = -(beamParamsDB->getHER() + beamParamsDB->getLER()).BoostToCM();
321 ROOT::Math::XYZVector orthBoostDir = getUnitOrthogonal(boost);
322 const MCParticle* mcPart = part->getMCParticle();
323 if (!mcPart) return Const::doubleNaN;
324 ROOT::Math::XYZVector pos = mcPart->getDecayVertex();
325 return pos.Dot(orthBoostDir);
326 }
327
328 double vertexErrBoostDirection(const Particle* part)
329 {
330 TVectorD bDir = toVec(PCmsLabTransform().getBoostVector().Unit());
331 // sqrt(bDir^T * Mat * bDir)
332 return sqrt(part->getVertexErrorMatrix().Similarity(bDir));
333 }
334
335 double vertexErrOrthBoostDirection(const Particle* part)
336 {
337 TVectorD oDir = toVec(getUnitOrthogonal(PCmsLabTransform().getBoostVector()));
338 // sqrt(oDir^T * Mat * oDir)
339 return sqrt(part->getVertexErrorMatrix().Similarity(oDir));
340 }
341
342 // TagV boost direction
343
344 double tagVBoostDirection(const Particle* part)
345 {
346 auto* vert = part->getRelatedTo<TagVertex>();
347 if (!vert) return Const::doubleNaN;
348 return vert->getTagVl();
349 }
350
351 double tagVOrthogonalBoostDirection(const Particle* part)
352 {
353 auto* vert = part->getRelatedTo<TagVertex>();
354 if (!vert) return Const::doubleNaN;
355 return vert->getTagVol();
356 }
357
358 double tagVTruthBoostDirection(const Particle* part)
359 {
360 auto* vert = part->getRelatedTo<TagVertex>();
361 if (!vert) return Const::doubleNaN;
362 return vert->getTruthTagVl();
363 }
364
365 double tagVTruthOrthogonalBoostDirection(const Particle* part)
366 {
367 auto* vert = part->getRelatedTo<TagVertex>();
368 if (!vert) return Const::doubleNaN;
369 return vert->getTruthTagVol();
370 }
371
372 double tagVErrBoostDirection(const Particle* part)
373 {
374 auto* vert = part->getRelatedTo<TagVertex>();
375 if (!vert) return Const::doubleNaN;
376 return vert->getTagVlErr();
377 }
378
379 double tagVErrOrthogonalBoostDirection(const Particle* part)
380 {
381 auto* vert = part->getRelatedTo<TagVertex>();
382 if (!vert) return Const::doubleNaN;
383 return vert->getTagVolErr();
384 }
385
386 // cosTheta boost direction
387
388 double particleCosThetaBoostDirection(const Particle* part)
389 {
390 const auto& frame = ReferenceFrame::GetCurrent();
391 ROOT::Math::XYZVector boost = PCmsLabTransform().getBoostVector();
392 ROOT::Math::PxPyPzEVector pxpypze = frame.getMomentum(part);
393 return ROOT::Math::VectorUtil::CosTheta(pxpypze, boost);
394 }
395
396 double particleInternalTagVMCFlavor(const Particle* part)
397 {
398 auto* vert = part->getRelatedTo<TagVertex>();
399 if (!vert) return Const::doubleNaN;
400 return vert->getMCTagBFlavor();
401 }
402
403 double tagTrackMomentum(const Particle* part, const std::vector<double>& trackIndex)
404 {
405 auto* vert = part->getRelatedTo<TagVertex>();
406 if (!vert) return Const::doubleNaN;
407
408 if (trackIndex.size() != 1) return Const::doubleNaN;
409 unsigned trackIndexInt = trackIndex.at(0);
410
411 return vert->getVtxFitTrackP(trackIndexInt).R();
412 }
413
414 double tagTrackMomentumX(const Particle* part, const std::vector<double>& trackIndex)
415 {
416 auto* vert = part->getRelatedTo<TagVertex>();
417 if (!vert) return Const::doubleNaN;
418
419 if (trackIndex.size() != 1) return Const::doubleNaN;
420 unsigned trackIndexInt = trackIndex.at(0);
421
422 return vert->getVtxFitTrackP(trackIndexInt).X();
423 }
424
425 double tagTrackMomentumY(const Particle* part, const std::vector<double>& trackIndex)
426 {
427 auto* vert = part->getRelatedTo<TagVertex>();
428 if (!vert) return Const::doubleNaN;
429
430 if (trackIndex.size() != 1) return Const::doubleNaN;
431 unsigned trackIndexInt = trackIndex.at(0);
432
433 return vert->getVtxFitTrackP(trackIndexInt).Y();
434 }
435
436 double tagTrackMomentumZ(const Particle* part, const std::vector<double>& trackIndex)
437 {
438 auto* vert = part->getRelatedTo<TagVertex>();
439 if (!vert) return Const::doubleNaN;
440
441 if (trackIndex.size() != 1) return Const::doubleNaN;
442 unsigned trackIndexInt = trackIndex.at(0);
443
444 return vert->getVtxFitTrackP(trackIndexInt).Z();
445 }
446
447 double tagTrackZ0(const Particle* part, const std::vector<double>& trackIndex)
448 {
449 auto* vert = part->getRelatedTo<TagVertex>();
450 if (!vert) return Const::doubleNaN;
451
452 if (trackIndex.size() != 1) return Const::doubleNaN;
453 unsigned trackIndexInt = trackIndex.at(0);
454
455 return vert->getVtxFitTrackZ0(trackIndexInt);
456 }
457
458 double tagTrackD0(const Particle* part, const std::vector<double>& trackIndex)
459 {
460 auto* vert = part->getRelatedTo<TagVertex>();
461 if (!vert) return Const::doubleNaN;
462
463 if (trackIndex.size() != 1) return Const::doubleNaN;
464 unsigned trackIndexInt = trackIndex.at(0);
465
466 return vert->getVtxFitTrackD0(trackIndexInt);
467 }
468
469 double tagTrackRaveWeight(const Particle* part, const std::vector<double>& trackIndex)
470 {
471 auto* vert = part->getRelatedTo<TagVertex>();
472 if (!vert) return Const::doubleNaN;
473
474 if (trackIndex.size() != 1) return Const::doubleNaN;
475 unsigned trackIndexInt = trackIndex.at(0);
476
477 return vert->getRaveWeight(trackIndexInt);
478 }
479
480 double tagTrackDistanceToConstraint(const Particle* part, const std::vector<double>& trackIndex)
481 {
482 auto* vert = part->getRelatedTo<TagVertex>();
483 if (!vert) return Const::doubleNaN;
484
485 if (trackIndex.size() != 1) return Const::doubleNaN;
486 unsigned trackIndexInt = trackIndex.at(0);
487
488 if (vert->getConstraintType() == "noConstraint") return Const::doubleNaN;
489 const Particle* tagParticle(vert->getVtxFitParticle(trackIndexInt));
490 if (!tagParticle) return Const::doubleNaN;
491 const TrackFitResult* tagTrackFitResult = tagParticle->getTrackFitResult();
492 if (!tagTrackFitResult) return Const::doubleNaN;
493
494 return DistanceTools::trackToVtxDist(tagTrackFitResult->getPosition(),
495 tagParticle->getMomentum(),
496 vert->getConstraintCenter());
497 }
498
499 double getY4Sx(const Particle* part)
500 {
501 auto* vert = part->getRelatedTo<TagVertex>();
502 if (!vert) return Const::doubleNaN;
503 return vert->getConstraintCenter().X();
504 }
505
506 double getY4Sy(const Particle* part)
507 {
508 auto* vert = part->getRelatedTo<TagVertex>();
509 if (!vert) return Const::doubleNaN;
510 return vert->getConstraintCenter().Y();
511 }
512
513 double getY4Sz(const Particle* part)
514 {
515 auto* vert = part->getRelatedTo<TagVertex>();
516 if (!vert) return Const::doubleNaN;
517 return vert->getConstraintCenter().Z();
518 }
519
520 double getSigBdecayTime(const Particle* part)
521 {
522 auto* vert = part->getRelatedTo<TagVertex>();
523 if (!vert) return Const::doubleNaN;
524 ROOT::Math::XYZVector vtxY4S = vert->getConstraintCenter(); // Y4Svtx
525 ROOT::Math::XYZVector vtxSigB = part->getVertex(); // SignalB vertex
526 ROOT::Math::PxPyPzEVector p4Sig = part->get4Vector(); // SigB 4-momentum
527 ROOT::Math::XYZVector nSig = p4Sig.Vect().Unit(); // SigB momentum direction
528
529 // Notice that for beta*gamma we use p / m, not p / mPDG which has worse resolution
530 double betaSig = p4Sig.Beta();
531 double gammaSig = 1 / sqrt(1 - betaSig * betaSig);
532 double c = Const::speedOfLight / 1000.; // cm ps-1
533
534 // The projection of the flight path into the SigB momentum direction is used.
535 // I.e. the decay time can be negative
536 double tSig = (vtxSigB - vtxY4S).Dot(nSig) / (c * betaSig * gammaSig);
537 return tSig;
538 }
539
540 double getTagBdecayTime(const Particle* part)
541 {
542 auto* vert = part->getRelatedTo<TagVertex>();
543 if (!vert) return Const::doubleNaN;
544
545 ROOT::Math::XYZVector vtxY4S = vert->getConstraintCenter(); // Y4Svtx
546 ROOT::Math::XYZVector vtxTagB = vert->getTagVertex(); // TagB vertex
547 ROOT::Math::PxPyPzEVector p4Sig = part->get4Vector(); // SigB 4-momentum
548 ROOT::Math::PxPyPzEVector p4SigCms = PCmsLabTransform().labToCms(p4Sig);
549 // Assuming that pSigCms + pTagCms == 0
550 ROOT::Math::PxPyPzEVector p4TagCms(-p4SigCms.px(), -p4SigCms.py(), -p4SigCms.pz(), p4SigCms.E());
551 ROOT::Math::PxPyPzEVector p4Tag = PCmsLabTransform().cmsToLab(p4TagCms);
552 ROOT::Math::XYZVector nTag = p4Tag.Vect().Unit(); // TagB momentum direction
553
554 // Notice that for beta*gamma we use p / m, not p / mPDG which has worse resolution
555 double betaTag = p4Tag.Beta();
556 double gammaTag = 1 / sqrt(1 - betaTag * betaTag);
557 double c = Const::speedOfLight / 1000.; // cm ps-1
558
559 // The projection of the flight path into the TagB momentum direction is used.
560 // I.e. the decay time can be negative
561 double tTag = (vtxTagB - vtxY4S).Dot(nTag) / (c * betaTag * gammaTag);
562 return tTag;
563 }
564
565 double getDeltaT3D(const Particle* part)
566 {
567 return getSigBdecayTime(part) - getTagBdecayTime(part);
568 }
569
570 double tagTrackDistanceToConstraintErr(const Particle* part, const std::vector<double>& trackIndex)
571 {
572 auto* vert = part->getRelatedTo<TagVertex>();
573 if (!vert) return Const::doubleNaN;
574
575 if (trackIndex.size() != 1) return Const::doubleNaN;
576 unsigned trackIndexInt = trackIndex.at(0);
577
578 if (vert->getConstraintType() == "noConstraint") return Const::doubleNaN;
579 const Particle* tagParticle(vert->getVtxFitParticle(trackIndexInt));
580 if (!tagParticle) return Const::doubleNaN;
581 const TrackFitResult* tagTrackFitResult = tagParticle->getTrackFitResult();
582 if (!tagTrackFitResult) return Const::doubleNaN;
583
584 //recover the covariance matrix associated to the position of the tag track
585 TMatrixDSym trackPosCovMat = tagParticle->getVertexErrorMatrix();
586
587 return DistanceTools::trackToVtxDistErr(tagTrackFitResult->getPosition(),
588 tagParticle->getMomentum(),
589 vert->getConstraintCenter(),
590 trackPosCovMat,
591 vert->getConstraintCov());
592 }
593
594 double tagTrackDistanceToConstraintSignificance(const Particle* part, const std::vector<double>& trackIndex)
595 {
596 double val = tagTrackDistanceToConstraint(part, trackIndex);
597 if (isinf(val) || isnan(val)) return Const::doubleNaN;
598 double err = tagTrackDistanceToConstraintErr(part, trackIndex);
599 if (isinf(err) || isnan(err)) return Const::doubleNaN;
600
601 return val / err;
602 }
603
604 double tagVDistanceToConstraint(const Particle* part)
605 {
606 auto* vert = part->getRelatedTo<TagVertex>();
607 if (!vert) return Const::doubleNaN;
608
609 if (vert->getConstraintType() == "noConstraint") return Const::doubleNaN;
610
611 return DistanceTools::vtxToVtxDist(vert->getConstraintCenter(),
612 vert->getTagVertex());
613 }
614
615 double tagVDistanceToConstraintErr(const Particle* part)
616 {
617 auto* vert = part->getRelatedTo<TagVertex>();
618 if (!vert) return Const::doubleNaN;
619
620 if (vert->getConstraintType() == "noConstraint") return Const::doubleNaN;
621
622 //To compute the uncertainty, the tag vtx uncertainty is NOT taken into account
623 //The error computed is the the one used in the chi2.
624 //To change that, emptyMat has to be replaced by m_TagVertexErrMatrix
625 TMatrixDSym emptyMat(3);
626
627 return DistanceTools::vtxToVtxDistErr(vert->getConstraintCenter(),
628 vert->getTagVertex(),
629 vert->getConstraintCov(),
630 emptyMat);
631 }
632
633 double tagVDistanceToConstraintSignificance(const Particle* part)
634 {
635 double val = tagVDistanceToConstraint(part);
636 if (isinf(val) || isnan(val)) return Const::doubleNaN;
637 double err = tagVDistanceToConstraintErr(part);
638 if (isinf(err) || isnan(err)) return Const::doubleNaN;
639
640 return val / err;
641 }
642
643 double tagTrackDistanceToTagV(const Particle* part, const std::vector<double>& trackIndex)
644 {
645 auto* vert = part->getRelatedTo<TagVertex>();
646 if (!vert) return Const::doubleNaN;
647
648 if (trackIndex.size() != 1) return Const::doubleNaN;
649 unsigned trackIndexInt = trackIndex.at(0);
650
651 const Particle* particle = vert->getVtxFitParticle(trackIndexInt);
652 if (!particle) return Const::doubleNaN;
653 const TrackFitResult* trackFitResult = particle->getTrackFitResult();
654 if (!trackFitResult) return Const::doubleNaN;
655
656 return DistanceTools::trackToVtxDist(trackFitResult->getPosition(),
657 particle->getMomentum(),
658 vert->getTagVertex());
659 }
660
661 double tagTrackDistanceToTagVErr(const Particle* part, const std::vector<double>& trackIndex)
662 {
663 auto* vert = part->getRelatedTo<TagVertex>();
664 if (!vert) return Const::doubleNaN;
665
666 if (trackIndex.size() != 1) return Const::doubleNaN;
667 unsigned trackIndexInt = trackIndex.at(0);
668
669 const Particle* tagParticle(vert->getVtxFitParticle(trackIndexInt));
670 if (!tagParticle) return Const::doubleNaN;
671 const TrackFitResult* tagTrackFitResult = tagParticle->getTrackFitResult();
672 if (!tagTrackFitResult) return Const::doubleNaN;
673
674 //recover the covariance matrix associated to the position of the tag track
675 TMatrixDSym trackPosCovMat = tagParticle->getVertexErrorMatrix();
676
677 //To compute the uncertainty, the tag vtx uncertainty is NOT taken into account
678 //The error computed is then the one in the chi2.
679 //To change that, emptyMat has to be replaced by m_TagVertexErrMatrix
680
681 TMatrixDSym emptyMat(3);
682
683 return DistanceTools::trackToVtxDistErr(tagTrackFitResult->getPosition(),
684 tagParticle->getMomentum(),
685 vert->getTagVertex(),
686 trackPosCovMat,
687 emptyMat);
688
689 }
690
691 double tagTrackDistanceToTagVSignificance(const Particle* part, const std::vector<double>& trackIndex)
692 {
693 double val = tagTrackDistanceToTagV(part, trackIndex);
694 if (isinf(val) || isnan(val)) return Const::doubleNaN;
695 double err = tagTrackDistanceToTagVErr(part, trackIndex);
696 if (isinf(err) || isnan(err)) return Const::doubleNaN;
697
698 return val / err;
699 }
700
701 double tagTrackTrueDistanceToTagV(const Particle* part, const std::vector<double>& trackIndex)
702 {
703 auto* vert = part->getRelatedTo<TagVertex>();
704 if (!vert) return Const::doubleNaN;
705
706 if (trackIndex.size() != 1) return Const::doubleNaN;
707 unsigned trackIndexInt = trackIndex.at(0);
708
709 const MCParticle* mcParticle(vert->getVtxFitMCParticle(trackIndexInt));
710 if (!mcParticle) return Const::doubleNaN;
711
712 ROOT::Math::XYZVector mcTagV = vert->getMCTagVertex();
713 if (mcTagV.X() == Const::doubleNaN) return Const::doubleNaN;
714 if (mcTagV.X() == 0 && mcTagV.Y() == 0 && mcTagV.Z() == 0) return Const::doubleNaN;
715
716 return DistanceTools::trackToVtxDist(mcParticle->getProductionVertex(),
717 mcParticle->getMomentum(),
718 mcTagV);
719 }
720
721 ROOT::Math::XYZVector tagTrackTrueVecToTagV(const Particle* part, const std::vector<double>& trackIndex)
722 {
723 auto* vert = part->getRelatedTo<TagVertex>();
724 if (!vert) return vecNaN;
725
726 if (trackIndex.size() != 1) return vecNaN;
727 unsigned trackIndexInt = trackIndex.at(0);
728
729 const MCParticle* mcParticle(vert->getVtxFitMCParticle(trackIndexInt));
730 if (!mcParticle) return vecNaN;
731
732 ROOT::Math::XYZVector mcTagV = vert->getMCTagVertex();
733 if (mcTagV.X() == Const::doubleNaN) return vecNaN;
734 if (mcTagV.X() == 0 && mcTagV.Y() == 0 && mcTagV.Z() == 0) return vecNaN;
735
736 return DistanceTools::trackToVtxVec(mcParticle->getProductionVertex(),
737 mcParticle->getMomentum(),
738 mcTagV);
739 }
740
741 double tagTrackTrueVecToTagVX(const Particle* part, const std::vector<double>& trackIndex)
742 {
743 ROOT::Math::XYZVector result = tagTrackTrueVecToTagV(part, trackIndex);
744 return result.X();
745 }
746
747 double tagTrackTrueVecToTagVY(const Particle* part, const std::vector<double>& trackIndex)
748 {
749 ROOT::Math::XYZVector result = tagTrackTrueVecToTagV(part, trackIndex);
750 return result.Y();
751 }
752
753 double tagTrackTrueVecToTagVZ(const Particle* part, const std::vector<double>& trackIndex)
754 {
755 ROOT::Math::XYZVector result = tagTrackTrueVecToTagV(part, trackIndex);
756 return result.Z();
757 }
758
759 ROOT::Math::XYZVector tagTrackTrueMomentum(const Particle* part, const std::vector<double>& trackIndex)
760 {
761 auto* vert = part->getRelatedTo<TagVertex>();
762 if (!vert) return vecNaN;
763
764 if (trackIndex.size() != 1) return vecNaN;
765 unsigned trackIndexInt = trackIndex.at(0);
766
767 const MCParticle* mcParticle(vert->getVtxFitMCParticle(trackIndexInt));
768 if (!mcParticle) return vecNaN;
769
770 return mcParticle->getMomentum();
771 }
772
773 double tagTrackTrueMomentumX(const Particle* part, const std::vector<double>& trackIndex)
774 {
775 ROOT::Math::XYZVector pTrue = tagTrackTrueMomentum(part, trackIndex);
776 return pTrue.X();
777 }
778
779 double tagTrackTrueMomentumY(const Particle* part, const std::vector<double>& trackIndex)
780 {
781 ROOT::Math::XYZVector pTrue = tagTrackTrueMomentum(part, trackIndex);
782 return pTrue.Y();
783 }
784
785 double tagTrackTrueMomentumZ(const Particle* part, const std::vector<double>& trackIndex)
786 {
787 ROOT::Math::XYZVector pTrue = tagTrackTrueMomentum(part, trackIndex);
788 return pTrue.Z();
789 }
790
791 ROOT::Math::XYZVector tagTrackTrueOrigin(const Particle* part, const std::vector<double>& trackIndex)
792 {
793 auto* vert = part->getRelatedTo<TagVertex>();
794 if (!vert) return vecNaN;
795
796 if (trackIndex.size() != 1) return vecNaN;
797 unsigned trackIndexInt = trackIndex.at(0);
798
799 const MCParticle* mcParticle(vert->getVtxFitMCParticle(trackIndexInt));
800 if (!mcParticle) return vecNaN;
801
802 return mcParticle->getProductionVertex();
803 }
804
805 double tagTrackTrueOriginX(const Particle* part, const std::vector<double>& trackIndex)
806 {
807 ROOT::Math::XYZVector origin = tagTrackTrueOrigin(part, trackIndex);
808 return origin.X();
809 }
810
811 double tagTrackTrueOriginY(const Particle* part, const std::vector<double>& trackIndex)
812 {
813 ROOT::Math::XYZVector origin = tagTrackTrueOrigin(part, trackIndex);
814 return origin.Y();
815 }
816
817 double tagTrackTrueOriginZ(const Particle* part, const std::vector<double>& trackIndex)
818 {
819 ROOT::Math::XYZVector origin = tagTrackTrueOrigin(part, trackIndex);
820 return origin.Z();
821 }
822
823 int fitTruthStatus(const Particle* part)
824 {
825 auto* vert = part->getRelatedTo<TagVertex>();
826 if (!vert) return -1;
827 return vert->getFitTruthStatus();
828 }
829
830 int rollbackStatus(const Particle* part)
831 {
832 auto* vert = part->getRelatedTo<TagVertex>();
833 if (!vert) return -1;
834 return vert->getRollBackStatus();
835 }
836
837 //**********************************
838 //Meta variables
839 //**********************************
840
846 TagTrFPtr getTagTrackFunctionFromName(string const& name)
847 {
848 if (name == "TagTrackMomentum") return tagTrackMomentum;
849 else if (name == "TagTrackMomentumX") return tagTrackMomentumX;
850 else if (name == "TagTrackMomentumY") return tagTrackMomentumY;
851 else if (name == "TagTrackMomentumZ") return tagTrackMomentumZ;
852 else if (name == "TagTrackZ0") return tagTrackZ0;
853 else if (name == "TagTrackD0") return tagTrackD0;
854 else if (name == "TagTrackRaveWeight") return tagTrackRaveWeight;
855 else if (name == "TagTrackDistanceToConstraint") return tagTrackDistanceToConstraint;
856 else if (name == "TagTrackDistanceToConstraintErr") return tagTrackDistanceToConstraintErr;
857 else if (name == "TagTrackDistanceToConstraintSignificance") return tagTrackDistanceToConstraintSignificance;
858 else if (name == "TagTrackDistanceToTagV") return tagTrackDistanceToTagV;
859 else if (name == "TagTrackDistanceToTagVErr") return tagTrackDistanceToTagVErr;
860 else if (name == "TagTrackDistanceToTagVSignificance") return tagTrackDistanceToTagVSignificance;
861 else if (name == "TagTrackTrueDistanceToTagV") return tagTrackTrueDistanceToTagV;
862 else if (name == "TagTrackTrueVecToTagVX") return tagTrackTrueVecToTagVX;
863 else if (name == "TagTrackTrueVecToTagVY") return tagTrackTrueVecToTagVY;
864 else if (name == "TagTrackTrueVecToTagVZ") return tagTrackTrueVecToTagVZ;
865 else if (name == "TagTrackTrueMomentumX") return tagTrackTrueMomentumX;
866 else if (name == "TagTrackTrueMomentumY") return tagTrackTrueMomentumY;
867 else if (name == "TagTrackTrueMomentumZ") return tagTrackTrueMomentumZ;
868 else if (name == "TagTrackTrueOriginX") return tagTrackTrueOriginX;
869 else if (name == "TagTrackTrueOriginY") return tagTrackTrueOriginY;
870 else if (name == "TagTrackTrueOriginZ") return tagTrackTrueOriginZ;
871
872 B2ERROR("From TimeDependentVariables: Trying to access unknown tagTrack function");
873 return nullptr;
874 }
875
876 double cumulate(const Particle* part, const std::vector<std::string>& variable, double start,
877 std::function<double(double, double, double)> fun)
878 {
879 TagTrFPtr fptr(getTagTrackFunctionFromName(variable.at(0)));
880 auto* vert = part->getRelatedTo<TagVertex>();
881 if (!vert) return Const::doubleNaN;
882 int nTracks = vert->getNFitTracks();
883
884 //calculate cumulative quantity
885 double acum = start;
886 for (int i = 0; i < nTracks; ++i) {
887 vector<double> indx(1, i);
888 double w = tagTrackRaveWeight(part, indx);
889 double f = (*fptr)(part, indx);
890 if (w > 0) {
891 acum = fun(acum, f, w);
892 }
893 }
894 return acum;
895 }
896
897 Manager::FunctionPtr tagTrackAverage(const std::vector<std::string>& variable)
898 {
899 if (variable.size() != 1) {
900 B2FATAL("Wrong number of arguments for meta function tagTrackAverage");
901 return nullptr;
902 }
903
904 return [variable](const Particle * part) -> double {
905 double sum = cumulate(part, variable, 0, [](double s, double f, double) {return s + f;});
906 double tot = cumulate(part, variable, 0, [](double s, double, double) {return s + 1;});
907 return (tot > 0) ? sum / tot : Const::doubleNaN;
908 };
909 }
910
911 Manager::FunctionPtr tagTrackAverageSquares(const std::vector<std::string>& variable)
912 {
913 if (variable.size() != 1) {
914 B2FATAL("Wrong number of arguments for meta function tagTrackAverageSquares");
915 return nullptr;
916 }
917
918 return [variable](const Particle * part) -> double {
919 double sum = cumulate(part, variable, 0, [](double s, double f, double) {return s + f * f;});
920 double tot = cumulate(part, variable, 0, [](double s, double, double) {return s + 1;});
921 return (tot > 0) ? sum / tot : Const::doubleNaN;
922 };
923 }
924
925
926 Manager::FunctionPtr tagTrackMax(const std::vector<std::string>& variable)
927 {
928 if (variable.size() != 1) {
929 B2FATAL("Wrong number of arguments for meta function tagTrackMax");
930 return nullptr;
931 }
932
933 return [variable](const Particle * part) -> double {
934 double Max = cumulate(part, variable, -DBL_MAX, [](double s, double f, double) {return std::max(s, f);});
935 return (Max != -DBL_MAX) ? Max : Const::doubleNaN;
936 };
937 }
938
939 Manager::FunctionPtr tagTrackMin(const std::vector<std::string>& variable)
940 {
941 if (variable.size() != 1) {
942 B2FATAL("Wrong number of arguments for meta function tagTrackMin");
943 return nullptr;
944 }
945
946 return [variable](const Particle * part) -> double {
947 double Min = cumulate(part, variable, +DBL_MAX, [](double s, double f, double) {return std::min(s, f);});
948 return (Min != DBL_MAX) ? Min : Const::doubleNaN;
949 };
950 }
951
952 Manager::FunctionPtr tagTrackWeightedAverage(const std::vector<std::string>& variable)
953 {
954 if (variable.size() != 1) {
955 B2FATAL("Wrong number of arguments for meta function tagTrackWeightedAverage");
956 return nullptr;
957 }
958
959 return [variable](const Particle * part) -> double {
960 double num = cumulate(part, variable, 0, [](double s, double f, double w) {return s + w * f;});
961 double den = cumulate(part, variable, 0, [](double s, double, double w) {return s + w;});
962 return (den > 0) ? num / den : Const::doubleNaN;
963 };
964 }
965
966 Manager::FunctionPtr tagTrackWeightedAverageSquares(const std::vector<std::string>& variable)
967 {
968 if (variable.size() != 1) {
969 B2FATAL("Wrong number of arguments for meta function tagTrackWeightedAverageSquares");
970 return nullptr;
971 }
972
973 return [variable](const Particle * part) -> double {
974 double num = cumulate(part, variable, 0, [](double s, double f, double w) {return s + w * f * f;});
975 double den = cumulate(part, variable, 0, [](double s, double, double w) {return s + w;});
976 return (den > 0) ? num / den : Const::doubleNaN;
977 };
978 }
979
980 Manager::FunctionPtr tagTrackSum(const std::vector<std::string>& variable)
981 {
982 if (variable.size() != 1) {
983 B2FATAL("Wrong number of arguments for meta function tagTrackSum");
984 return nullptr;
985 }
986
987 return [variable](const Particle * part) -> double {
988 return cumulate(part, variable, 0, [](double s, double f, double) {return s + f;});
989 };
990 }
991
992 //**********************************
993 //VARIABLE REGISTRATION
994 //**********************************
995
996 VARIABLE_GROUP("Time Dependent CPV Analysis Variables");
997
998 REGISTER_VARIABLE("TagVx", particleTagVx, "Tag vertex X component\n\n", "cm");
999 REGISTER_VARIABLE("TagVy", particleTagVy, "Tag vertex Y component\n\n", "cm");
1000 REGISTER_VARIABLE("TagVz", particleTagVz, "Tag vertex Z component\n\n", "cm");
1001 REGISTER_VARIABLE("mcTagVx", particleTruthTagVx, "Generated Tag vertex X component\n\n", "cm");
1002 REGISTER_VARIABLE("mcTagVy", particleTruthTagVy, "Generated Tag vertex Y component\n\n", "cm");
1003 REGISTER_VARIABLE("mcTagVz", particleTruthTagVz, "Generated Tag vertex Z component\n\n", "cm");
1004 REGISTER_VARIABLE("TagVxErr", particleTagVxErr, "Tag vertex X component uncertainty\n\n", "cm");
1005 REGISTER_VARIABLE("TagVyErr", particleTagVyErr, "Tag vertex Y component uncertainty\n\n", "cm");
1006 REGISTER_VARIABLE("TagVzErr", particleTagVzErr, "Tag vertex Z component uncertainty\n\n", "cm");
1007 REGISTER_VARIABLE("TagVCov(i,j)", particleTagVCov,
1008 "returns the (i,j)-th element of the Tag vertex covariance matrix (3x3).\n"
1009 "Order of elements in the covariance matrix is: x, y, z.\n\n", "cm, cm, cm");
1010
1011 REGISTER_VARIABLE("TagVpVal", particleTagVpVal, "Tag vertex p-Value");
1012 REGISTER_VARIABLE("TagVNTracks", particleTagVNTracks, "Number of tracks in the tag vertex");
1013 REGISTER_VARIABLE("TagVType", particleTagVType,
1014 R"DOC(Type of algorithm for the tag vertex. -1: failed (1,2: single track, deprecated), 3: standard, 4: standard_PXD, 5: no constraint)DOC");
1015 REGISTER_VARIABLE("TagVNDF", particleTagVNDF, "Number of degrees of freedom in the tag vertex fit");
1016 REGISTER_VARIABLE("TagVChi2", particleTagVChi2, "chi2 value of the tag vertex fit");
1017 REGISTER_VARIABLE("TagVChi2IP", particleTagVChi2IP, "IP component of chi2 value of the tag vertex fit");
1018
1019 REGISTER_VARIABLE("DeltaT", particleDeltaT, R"DOC(
1020 Proper decay time difference :math:`\Delta t` between signal B-meson :math:`(B_{rec})` and tag B-meson :math:`(B_{tag})`.
1021
1022 )DOC", "ps");
1023 REGISTER_VARIABLE("DeltaTErr", particleDeltaTErr, R"DOC(
1024 Proper decay time difference :math:`\Delta t` uncertainty
1025
1026 )DOC", "ps");
1027 REGISTER_VARIABLE("DeltaTRes", particleDeltaTRes, R"DOC(
1028 :math:`\Delta t` residual, to be used for resolution function studies
1029
1030 )DOC", "ps");
1031 REGISTER_VARIABLE("DeltaTBelle", particleDeltaTBelle, R"DOC(
1032 [Legacy] :math:`\Delta t`, as it was used in Belle
1033
1034 )DOC", "ps");
1035 REGISTER_VARIABLE("mcDeltaTau", particleMCDeltaTau,
1036 R"DOC(Generated proper decay time difference :math:`\Delta t`: :math:`\tau(B_{\rm rec})-\tau(B_{\rm tag})`
1037
1038)DOC", "ps");
1039 REGISTER_VARIABLE("mcDeltaT", particleMCDeltaT,
1040 R"DOC(Generated proper decay time difference (in z-difference approximation) :math:`\Delta t`:
1041 :math:`(l(B_{\rm rec}) - l(B_{\rm tag}))/\beta_{\Upsilon(4S)}\gamma_{\Upsilon(4S)}`
1042
1043)DOC","ps");
1044 REGISTER_VARIABLE("mcDeltaBoost", particleMCDeltaBoost,
1045 R"DOC(True difference of decay vertex boost-direction components between signal B-meson :math:`(B_{rec})` and tag B-meson :math:`(B_{tag})`:
1046:math:`\Delta l = l(B_{rec}) - l(B_{tag})`
1047
1048)DOC", "cm");
1049 REGISTER_VARIABLE("DeltaZ", particleDeltaZ,
1050 R"DOC(Difference of decay vertex longitudinal components between signal B-meson :math:`(B_{rec})` and tag B-meson :math:`(B_{tag})`:
1051:math:`\Delta z = z(B_{rec}) - z(B_{tag})`
1052
1053)DOC", "cm");
1054 REGISTER_VARIABLE("DeltaZErr", particleDeltaZErr,
1055 R"DOC(Uncertainty of the difference :math:`z(B_{rec}) - z(B_{tag})`
1056
1057)DOC", "cm");
1058 REGISTER_VARIABLE("DeltaBoost", particleDeltaB, R"DOC(:math:`\Delta z` in the boost direction
1059
1060)DOC", "cm");
1061 REGISTER_VARIABLE("DeltaBoostErr", particleDeltaBErr, R"DOC(Uncertainty of :math:`\Delta z` in the boost direction
1062
1063)DOC", "cm");
1064
1065 REGISTER_VARIABLE("LBoost", vertexBoostDirection,
1066 "Returns the vertex component in the boost direction\n\n", "cm");
1067 REGISTER_VARIABLE("OBoost", vertexOrthogonalBoostDirection,
1068 "Returns the vertex component in the direction orthogonal to the boost\n\n", "cm");
1069 REGISTER_VARIABLE("mcLBoost", vertexTruthBoostDirection,
1070 "Returns the MC vertex component in the boost direction\n\n", "cm");
1071 REGISTER_VARIABLE("mcOBoost", vertexTruthOrthogonalBoostDirection,
1072 "Returns the MC vertex component in the direction orthogonal to the boost\n\n", "cm");
1073 REGISTER_VARIABLE("LBoostErr", vertexErrBoostDirection,
1074 "Returns the error of the vertex in the boost direction\n\n", "cm");
1075 REGISTER_VARIABLE("OBoostErr", vertexErrOrthBoostDirection,
1076 "Returns the error of the vertex in the direction orthogonal to the boost\n\n", "cm");
1077
1078 REGISTER_VARIABLE("Y4SvtxX", getY4Sx, "Returns X component of Y4S vertex.\n"
1079 "The result is meaningful and nontrivial when the signal B vertex "
1080 "is determined by `vertex.treeFit` with ``ipConstraint=True`` and the `vertex.TagV` is called with the ``tube`` constraint.\n\n", "cm");
1081
1082 REGISTER_VARIABLE("Y4SvtxY", getY4Sy, "Returns Y component of Y4S vertex.\n"
1083 "The result is meaningful and nontrivial when the signal B vertex "
1084 "is determined by `vertex.treeFit` with ``ipConstraint=True`` and the `vertex.TagV` is called with the ``tube`` constraint.\n\n", "cm");
1085
1086 REGISTER_VARIABLE("Y4SvtxZ", getY4Sz, "Returns Z component of Y4S vertex.\n"
1087 "The result is meaningful and nontrivial when the signal B vertex "
1088 "is determined by `vertex.treeFit` with ``ipConstraint=True`` and the `vertex.TagV` is called with the ``tube`` constraint.\n\n", "cm");
1089
1090
1091 REGISTER_VARIABLE("tSigB", getSigBdecayTime, "Returns the proper decay time of the fully reconstructed signal B meson.\n"
1092 "The result is meaningful and nontrivial when the signal B vertex "
1093 "is determined by `vertex.treeFit` with ``ipConstraint=True`` and the `vertex.TagV` is called with the ``tube`` constraint.\n\n", "ps");
1094
1095 REGISTER_VARIABLE("tTagB", getTagBdecayTime, "Returns the proper decay time of the tagged B meson.\n"
1096 "The result is meaningful and nontrivial when the signal B vertex "
1097 "is determined by `vertex.treeFit` with ``ipConstraint=True`` and the `vertex.TagV` is called with the ``tube`` constraint.\n\n", "ps");
1098
1099 REGISTER_VARIABLE("DeltaT3D", getDeltaT3D, R"DOC(
1100 Returns the :math:`\Delta t` variable calculated as a difference of :b2:var:`tSigB` and :b2:var:`tTagB`, i.e. not from the projection along boost vector axis.
1101
1102 The result is meaningful and nontrivial when the signal B vertex is determined by `vertex.treeFit` with ``ipConstraint=True`` and the `vertex.TagV` is called with the ``tube`` constraint.
1103
1104 )DOC", "ps");
1105
1106 REGISTER_VARIABLE("TagVLBoost", tagVBoostDirection,
1107 "Returns the TagV component in the boost direction\n\n", "cm");
1108 REGISTER_VARIABLE("TagVOBoost", tagVOrthogonalBoostDirection,
1109 "Returns the TagV component in the direction orthogonal to the boost\n\n", "cm");
1110 REGISTER_VARIABLE("mcTagVLBoost", tagVTruthBoostDirection,
1111 "Returns the MC TagV component in the boost direction\n\n", "cm");
1112 REGISTER_VARIABLE("mcTagVOBoost", tagVTruthOrthogonalBoostDirection,
1113 "Returns the MC TagV component in the direction orthogonal to the boost\n\n", "cm");
1114 REGISTER_VARIABLE("TagVLBoostErr", tagVErrBoostDirection,
1115 "Returns the error of TagV in the boost direction\n\n", "cm");
1116 REGISTER_VARIABLE("TagVOBoostErr", tagVErrOrthogonalBoostDirection,
1117 "Returns the error of TagV in the direction orthogonal to the boost\n\n", "cm");
1118
1119 REGISTER_VARIABLE("cosAngleBetweenMomentumAndBoostVector", particleCosThetaBoostDirection,
1120 "cosine of the angle between momentum and boost vector");
1121
1122 REGISTER_VARIABLE("internalTagVMCFlavor", particleInternalTagVMCFlavor,
1123 "[Expert] [Debugging] This variable is only for internal checks of the TagV module by developers. \n"
1124 "It returns the internal mc flavor information of the tag-side B provided by the TagV module.");
1125
1126 REGISTER_VARIABLE("TagTrackMomentum(i) ", tagTrackMomentum,
1127 "Returns the magnitude of the momentum of the ith track used in the tag vtx fit.\n\n", "GeV/c");
1128 REGISTER_VARIABLE("TagTrackMomentumX(i) ", tagTrackMomentumX,
1129 "Returns the X component of the momentum of the ith track used in the tag vtx fit.\n\n", "GeV/c");
1130 REGISTER_VARIABLE("TagTrackMomentumY(i) ", tagTrackMomentumY,
1131 "Returns the Y component of the momentum of the ith track used in the tag vtx fit.\n\n", "GeV/c");
1132 REGISTER_VARIABLE("TagTrackMomentumZ(i) ", tagTrackMomentumZ,
1133 "Returns the Z component of the momentum of the ith track used in the tag vtx fit.\n\n", "GeV/c");
1134
1135 REGISTER_VARIABLE("TagTrackZ0(i)", tagTrackZ0, "Returns the z0 parameter of the ith track used in the tag vtx fit\n\n", "cm");
1136 REGISTER_VARIABLE("TagTrackD0(i)", tagTrackD0, "Returns the d0 parameter of the ith track used in the tag vtx fit\n\n", "cm");
1137
1138
1139 REGISTER_VARIABLE("TagTrackRaveWeight(i)", tagTrackRaveWeight, "Returns the weight assigned by Rave to track i");
1140
1141 REGISTER_VARIABLE("TagVNFitTracks", particleTagVNFitTracks,
1142 "returns the number of tracks used by rave to fit the vertex (not counting the ones coming from Kshorts)");
1143
1144 REGISTER_VARIABLE("TagTrackDistanceToConstraint(i)", tagTrackDistanceToConstraint,
1145 "Returns the measured distance between the ith tag track and the centre of the constraint.\n\n", "cm");
1146
1147 REGISTER_VARIABLE("TagTrackDistanceToConstraintErr(i)", tagTrackDistanceToConstraintErr,
1148 "Returns the estimated error on the distance between the ith tag track and the centre of the constraint.\n\n", "cm");
1149
1150 REGISTER_VARIABLE("TagTrackDistanceToConstraintSignificance(i)", tagTrackDistanceToConstraintSignificance,
1151 "Returns the significance of the distance between the centre of the constraint and the tag track indexed by track index (computed as distance / uncertainty)");
1152
1153
1154 REGISTER_VARIABLE("TagVDistanceToConstraint", tagVDistanceToConstraint,
1155 "returns the measured distance between the tag vtx and the centre of the constraint.\n\n", "cm");
1156
1157 REGISTER_VARIABLE("TagVDistanceToConstraintErr", tagVDistanceToConstraintErr,
1158 "returns the estimated error on the distance between the tag vtx and the centre of the constraint.\n\n", "cm");
1159
1160 REGISTER_VARIABLE("TagVDistanceToConstraintSignificance", tagVDistanceToConstraintSignificance,
1161 "returns the significance of the distance between the tag vtx and the centre of the constraint (computed as distance / uncertainty)");
1162
1163 REGISTER_VARIABLE("TagTrackDistanceToTagV(i)", tagTrackDistanceToTagV,
1164 "Returns the measured distance between the ith tag track and the tag vtx.\n\n", "cm");
1165
1166 REGISTER_VARIABLE("TagTrackDistanceToTagVErr(i)", tagTrackDistanceToTagVErr, R"DOC(
1167Returns the estimated error on the distance between the ith tag track and the tag vtx.
1168
1169.. warning:: Only the uncertainties on the track position parameters are taken into account.
1170
1171)DOC", "cm");
1172
1173 REGISTER_VARIABLE("TagTrackDistanceToTagVSignificance(i)", tagTrackDistanceToTagVSignificance,
1174 "Returns the significance of the distance between the tag vtx and the tag track indexed by trackIndex (computed as distance / uncertainty)");
1175
1176 REGISTER_VARIABLE("TagTrackTrueDistanceToTagV(i)", tagTrackTrueDistanceToTagV,
1177 "Returns the true distance between the true B Tag decay vertex and the particle corresponding to the ith tag vtx track.\n\n", "cm");
1178
1179 REGISTER_VARIABLE("TagTrackTrueVecToTagVX(i)", tagTrackTrueVecToTagVX,
1180 "Returns the X coordinate of the vector between the mc particle corresponding to the ith tag vtx track and the true tag B decay vertex.\n\n",
1181 "cm");
1182
1183 REGISTER_VARIABLE("TagTrackTrueVecToTagVY(i)", tagTrackTrueVecToTagVY,
1184 "Returns the Y coordinate of the vector between the mc particle corresponding to the ith tag vtx track and the true tag B decay vertex.\n\n",
1185 "cm");
1186
1187 REGISTER_VARIABLE("TagTrackTrueVecToTagVZ(i)", tagTrackTrueVecToTagVZ,
1188 "Returns the Z coordinate of the vector between the mc particle corresponding to the ith tag vtx track and the true tag B decay vertex.\n\n",
1189 "cm");
1190
1191 REGISTER_VARIABLE("TagTrackTrueMomentumX(i)", tagTrackTrueMomentumX,
1192 "Returns the X component of the true momentum of the MC particle corresponding to the ith tag vtx track.\n\n", "GeV/c");
1193
1194 REGISTER_VARIABLE("TagTrackTrueMomentumY(i)", tagTrackTrueMomentumY,
1195 "Returns the Y component of the true momentum of the MC particle corresponding to the ith tag vtx track.\n\n", "GeV/c");
1196
1197 REGISTER_VARIABLE("TagTrackTrueMomentumZ(i)", tagTrackTrueMomentumZ,
1198 "Returns the Z component of the true momentum of the MC particle corresponding to the ith tag vtx track.\n\n", "GeV/c");
1199
1200 REGISTER_VARIABLE("TagTrackTrueOriginX(i)", tagTrackTrueOriginX,
1201 "Returns the X component of the true origin of the MC particle corresponding to the ith tag vtx track.\n\n", "cm");
1202
1203 REGISTER_VARIABLE("TagTrackTrueOriginY(i)", tagTrackTrueOriginY,
1204 "Returns the Y component of the true origin of the MC particle corresponding to the ith tag vtx track.\n\n", "cm");
1205
1206 REGISTER_VARIABLE("TagTrackTrueOriginZ(i)", tagTrackTrueOriginZ,
1207 "Returns the Z component of the true origin of the MC particle corresponding to the ith tag vtx track.\n\n", "cm");
1208
1209 REGISTER_VARIABLE("TagVFitTruthStatus", fitTruthStatus, R"DOC(
1210Returns the status of the fit performed with the truth info. Possible values are:
1211
1212- -1: no related TagVertex found
1213- 0: fit performed with measured parameters
1214- 1: fit performed with true parameters
1215- 2: unable to recover truth parameters
1216)DOC");
1217
1218 REGISTER_VARIABLE("TagVRollBackStatus", rollbackStatus, R"DOC(
1219Returns the status of the fit performed with rolled back tracks. Possible values are:
1220
1221- -1: no related TagVertex found
1222- 0: fit performed with measured parameters
1223- 1: fit performed with true parameters
1224- 2: unable to recover truth parameters
1225)DOC");
1226
1227 REGISTER_METAVARIABLE("TagTrackMax(var)", tagTrackMax,
1228 "return the maximum value of the variable ``var`` evaluated for each tag track. ``var`` must be one of the TagTrackXXX variables, for example: ``TagTrackMax(TagTrackDistanceToConstraint)``. The tracks that are assigned a zero weight are ignored.",
1229 Manager::VariableDataType::c_double);
1230
1231 REGISTER_METAVARIABLE("TagTrackMin(var)", tagTrackMin,
1232 "return the minimum value of the variable ``var`` evaluated for each tag track. ``var`` must be one of the TagTrackXXX variables, for example: ``TagTrackMin(TagTrackDistanceToConstraint)``. The tracks that are assigned a zero weight are ignored.",
1233 Manager::VariableDataType::c_double);
1234
1235 REGISTER_METAVARIABLE("TagTrackAverage(var)", tagTrackAverage,
1236 "return the average over the tag tracks of the variable ``var``. ``var`` must be one of the TagTrackXXX variables, for example: ``TagTrackAverage(TagTrackDistanceToConstraint)``. The tracks that are assigned a zero weight are ignored.",
1237 Manager::VariableDataType::c_double);
1238
1239 REGISTER_METAVARIABLE("TagTrackAverageSquares(var)", tagTrackAverageSquares,
1240 "return the average over the tag tracks of the square of the variable ``var``. ``var`` must be one of the TagTrackXXX variables, for example: ``TagTrackAverageSquares(TagTrackDistanceToConstraint)``. The tracks that are assigned a zero weight are ignored.",
1241 Manager::VariableDataType::c_double);
1242
1243 REGISTER_METAVARIABLE("TagTrackWeightedAverage(var)", tagTrackWeightedAverage,
1244 "return the average over the tag tracks of the variable ``var``, weighted by weights of the tag vertex fitter. ``var`` must be one of the TagTrackXXX variables, for example: ``TagTrackWeightedAverage(TagTrackDistanceToConstraint)``.",
1245 Manager::VariableDataType::c_double);
1246
1247 REGISTER_METAVARIABLE("TagTrackWeightedAverageSquares(var)", tagTrackWeightedAverageSquares,
1248 "return the average over the tag tracks of the variable ``var``, weighted by weights of the tag vertex fitter. ``var`` must be one of the TagTrackXXX variables, for example: ``TagTrackWeightedAverageSquares(TagTrackDistanceToConstraint)``.",
1249 Manager::VariableDataType::c_double);
1250
1251 REGISTER_METAVARIABLE("TagTrackSum(var)", tagTrackSum,
1252 "Returns the sum of the provided variable for all tag tracks. The variable must be one of the TagTrackXXX variables, "
1253 "for example ``TagTrackSum(TagTrackD0)``. The tracks that are assigned a zero weight are ignored.",
1254 Manager::VariableDataType::c_double);
1255 }
1257}
1258
1259
1260
1261
Belle2::Const::speedOfLight
static const double speedOfLight
[cm/ns]
Definition Const.h:695
Belle2::Const::doubleNaN
static const double doubleNaN
quiet_NaN
Definition Const.h:703
Belle2::ReferenceFrame::GetCurrent
static const ReferenceFrame & GetCurrent()
Get current rest frame.
Definition ReferenceFrame.cc:26
Belle2::Variable::Manager::FunctionPtr
std::function< VarVariant(const Particle *)> FunctionPtr
functions stored take a const Particle* and return VarVariant.
Definition Manager.h:112
Belle2::sqrt
double sqrt(double a)
sqrt for double
Definition beamHelpers.h:28
Belle2::DistanceTools::trackToVtxVec
ROOT::Math::XYZVector trackToVtxVec(ROOT::Math::XYZVector const &trackPos, ROOT::Math::XYZVector const &trackP, ROOT::Math::XYZVector const &vtxPos)
Returns the 3D vector between a vertex and a track's point of closest approach to that vertex.
Definition DistanceTools.cc:25
Belle2::DistanceTools::trackToVtxDist
double trackToVtxDist(ROOT::Math::XYZVector const &trackPos, ROOT::Math::XYZVector const &trackP, ROOT::Math::XYZVector const &vtxPos)
Returns the distance between a vertex and a track's point of closest approach to that vertex.
Definition DistanceTools.cc:33
Belle2::DistanceTools::vtxToVtxDistErr
double vtxToVtxDistErr(ROOT::Math::XYZVector const &vtx1Pos, ROOT::Math::XYZVector const &vtx2Pos, TMatrixDSym const &vtx1CovMat, TMatrixDSym const &vtx2CovMat)
Returns the estimated uncertainty on the distance between two vertices.
Definition DistanceTools.cc:113
Belle2::DistanceTools::vtxToVtxDist
double vtxToVtxDist(ROOT::Math::XYZVector const &vtx1Pos, ROOT::Math::XYZVector const &vtx2Pos)
Returns the distance between two vertices.
Definition DistanceTools.cc:98
Belle2::DistanceTools::trackToVtxDistErr
double trackToVtxDistErr(ROOT::Math::XYZVector const &trackPos, ROOT::Math::XYZVector const &trackP, ROOT::Math::XYZVector const &vtxPos, TMatrixDSym const &trackPosCovMat, TMatrixDSym const &vtxPosCovMat)
Returns the estimated uncertainty between a vertex and a track's point of closest approach to that ve...
Definition DistanceTools.cc:69
Belle2
Abstract base class for different kinds of events.
Definition MillepedeAlgorithm.h:17
std
STL namespace.