Belle II Software  release-05-01-25
V0DaughterTrackVariables.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2014-2019 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Kota Nakagiri, Yuma Uematsu *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 // Own includes
12 #include <analysis/variables/V0DaughterTrackVariables.h>
13 #include <analysis/VariableManager/Manager.h>
14 
15 #include <analysis/variables/TrackVariables.h>// getTrackFitResultFromParticle
16 
17 // framework - DataStore
18 #include <framework/datastore/StoreObjPtr.h>
19 #include <framework/datastore/StoreArray.h>
20 #include <framework/dataobjects/Helix.h>
21 
22 // dataobjects from the MDST
23 #include <mdst/dataobjects/Track.h>
24 #include <mdst/dataobjects/MCParticle.h>
25 #include <mdst/dataobjects/TrackFitResult.h>
26 #include <mdst/dataobjects/V0.h>
27 #include <mdst/dataobjects/EventLevelTrackingInfo.h>
28 #include <mdst/dataobjects/HitPatternCDC.h>
29 #include <mdst/dataobjects/HitPatternVXD.h>
30 #include <mdst/dataobjects/ECLCluster.h>
31 
32 // framework aux
33 #include <framework/logging/Logger.h>
34 
35 #include <iostream>
36 #include <algorithm>
37 #include <cmath>
38 
39 using namespace std;
40 
41 namespace Belle2 {
46  namespace Variable {
47 
48  // An helper function to get track fit results
49  // Not registered in variable mananger
50  const TrackFitResult* getTrackFitResultFromV0DaughterParticle(const Particle* particle, const double daughterID)
51  {
52  const int dID = int(std::lround(daughterID));
53  if (not(dID == 0 || dID == 1))
54  return nullptr;
55 
56  const Particle* daughter = particle->getDaughter(dID);
57  if (!daughter)
58  return nullptr;
59 
60  const TrackFitResult* trackFit = daughter->getRelated<TrackFitResult>();
61 
62  return trackFit;
63  }
64 
65  // helper function to get the helix parameters of the V0 daughter tracks
66  // Not registered in variable mananger
67  double getV0DaughterTrackDetNHits(const Particle* particle, const double daughterID, const Const::EDetector& det)
68  {
69  auto trackFit = getTrackFitResultFromV0DaughterParticle(particle, daughterID);
70  if (!trackFit) {
71  return std::numeric_limits<double>::quiet_NaN();
72  }
73 
74  if (det == Const::EDetector::CDC) {
75  return trackFit->getHitPatternCDC().getNHits();
76  } else if (det == Const::EDetector::SVD) {
77  return trackFit->getHitPatternVXD().getNSVDHits();
78  } else if (det == Const::EDetector::PXD) {
79  return trackFit->getHitPatternVXD().getNPXDHits();
80  } else {
81  return std::numeric_limits<double>::quiet_NaN();
82  }
83  }
84 
85  double v0DaughterTrackNCDCHits(const Particle* part, const std::vector<double>& daughterID)
86  {
87  return getV0DaughterTrackDetNHits(part, daughterID[0], Const::EDetector::CDC);
88  }
89 
90  double v0DaughterTrackNSVDHits(const Particle* part, const std::vector<double>& daughterID)
91  {
92  return getV0DaughterTrackDetNHits(part, daughterID[0], Const::EDetector::SVD);
93  }
94 
95  double v0DaughterTrackNPXDHits(const Particle* part, const std::vector<double>& daughterID)
96  {
97  return getV0DaughterTrackDetNHits(part, daughterID[0], Const::EDetector::PXD);
98  }
99 
100  double v0DaughterTrackNVXDHits(const Particle* part, const std::vector<double>& daughterID)
101  {
102  return v0DaughterTrackNPXDHits(part, daughterID) + v0DaughterTrackNSVDHits(part, daughterID);
103  }
104 
105  double v0DaughterTrackFirstSVDLayer(const Particle* part, const std::vector<double>& daughterID)
106  {
107  auto trackFit = getTrackFitResultFromV0DaughterParticle(part, daughterID[0]);
108  if (!trackFit) {
109  return std::numeric_limits<double>::quiet_NaN();
110  }
111  return trackFit->getHitPatternVXD().getFirstSVDLayer();
112  }
113 
114  double v0DaughterTrackFirstPXDLayer(const Particle* part, const std::vector<double>& daughterID)
115  {
116  auto trackFit = getTrackFitResultFromV0DaughterParticle(part, daughterID[0]);
117  if (!trackFit) {
118  return std::numeric_limits<double>::quiet_NaN();
119  }
120  return trackFit->getHitPatternVXD().getFirstPXDLayer(HitPatternVXD::PXDMode::normal);
121  }
122 
123  double v0DaughterTrackFirstCDCLayer(const Particle* part, const std::vector<double>& daughterID)
124  {
125  auto trackFit = getTrackFitResultFromV0DaughterParticle(part, daughterID[0]);
126  if (!trackFit) {
127  return std::numeric_limits<double>::quiet_NaN();
128  }
129  return trackFit->getHitPatternCDC().getFirstLayer();
130  }
131 
132  double v0DaughterTrackLastCDCLayer(const Particle* part, const std::vector<double>& daughterID)
133  {
134  auto trackFit = getTrackFitResultFromV0DaughterParticle(part, daughterID[0]);
135  if (!trackFit) {
136  return std::numeric_limits<double>::quiet_NaN();
137  }
138  return trackFit->getHitPatternCDC().getLastLayer();
139  }
140 
141  double v0DaughterTrackPValue(const Particle* part, const std::vector<double>& daughterID)
142  {
143  auto trackFit = getTrackFitResultFromV0DaughterParticle(part, daughterID[0]);
144  if (!trackFit) {
145  return std::numeric_limits<float>::quiet_NaN();
146  }
147  return trackFit->getPValue();
148  }
149 
150  // helper function to get the helix parameters of the V0 daughter tracks
151  // Not registered in variable mananger
152  double getV0DaughterTrackParamAtIndex(const Particle* particle, const double daughterID, const int tauIndex)
153  {
154  auto trackFit = getTrackFitResultFromV0DaughterParticle(particle, daughterID);
155  if (!trackFit) {
156  return std::numeric_limits<double>::quiet_NaN();
157  }
158  return trackFit->getTau().at(tauIndex);
159  }
160 
161  double v0DaughterTrackD0(const Particle* part, const std::vector<double>& daughterID)
162  {
163  return getV0DaughterTrackParamAtIndex(part, daughterID[0], 0);
164  }
165 
166  double v0DaughterTrackPhi0(const Particle* part, const std::vector<double>& daughterID)
167  {
168  return getV0DaughterTrackParamAtIndex(part, daughterID[0], 1);
169  }
170 
171  double v0DaughterTrackOmega(const Particle* part, const std::vector<double>& daughterID)
172  {
173  return getV0DaughterTrackParamAtIndex(part, daughterID[0], 2);
174  }
175 
176  double v0DaughterTrackZ0(const Particle* part, const std::vector<double>& daughterID)
177  {
178  return getV0DaughterTrackParamAtIndex(part, daughterID[0], 3);
179  }
180 
181  double v0DaughterTrackTanLambda(const Particle* part, const std::vector<double>& daughterID)
182  {
183  return getV0DaughterTrackParamAtIndex(part, daughterID[0], 4);
184  }
185 
186  // helper function to get the error of the helix parameters of the V0 daughter tracks
187  // Not registered in variable mananger
188  double getV0DaughterTrackParamErrorAtIndex(const Particle* particle, const double daughterID, const int tauIndex)
189  {
190  auto trackFit = getTrackFitResultFromV0DaughterParticle(particle, daughterID);
191  if (!trackFit) {
192  return std::numeric_limits<double>::quiet_NaN();
193  }
194  double errorSquared = trackFit->getCovariance5()[tauIndex][tauIndex];
195  if (errorSquared > 0)
196  return sqrt(errorSquared);
197  else
198  return std::numeric_limits<double>::quiet_NaN();
199  }
200 
201  double v0DaughterTrackD0Error(const Particle* part, const std::vector<double>& daughterID)
202  {
203  return getV0DaughterTrackParamErrorAtIndex(part, daughterID[0], 0);
204  }
205 
206  double v0DaughterTrackPhi0Error(const Particle* part, const std::vector<double>& daughterID)
207  {
208  return getV0DaughterTrackParamErrorAtIndex(part, daughterID[0], 1);
209  }
210 
211  double v0DaughterTrackOmegaError(const Particle* part, const std::vector<double>& daughterID)
212  {
213  return getV0DaughterTrackParamErrorAtIndex(part, daughterID[0], 2);
214  }
215 
216  double v0DaughterTrackZ0Error(const Particle* part, const std::vector<double>& daughterID)
217  {
218  return getV0DaughterTrackParamErrorAtIndex(part, daughterID[0], 3);
219  }
220 
221  double v0DaughterTrackTanLambdaError(const Particle* part, const std::vector<double>& daughterID)
222  {
223  return getV0DaughterTrackParamErrorAtIndex(part, daughterID[0], 4);
224  }
225 
226  // helper function to get pull of the helix parameters of the V0 daughter tracks with the true vertex as the pivot.
227  // Not registered in variable mananger
228  double getHelixParameterPullOfV0DaughterWithTrueVertexAsPivotAtIndex(const Particle* particle, const double daughterID,
229  const int tauIndex)
230  {
231  if (!particle) { return std::numeric_limits<double>::quiet_NaN(); }
232 
233  const int dID = int(std::lround(daughterID));
234  if (not(dID == 0 || dID == 1)) { return std::numeric_limits<double>::quiet_NaN(); }
235 
236  const MCParticle* mcparticle_v0 = particle->getMCParticle();
237  if (!mcparticle_v0) { return std::numeric_limits<double>::quiet_NaN(); }
238 
239  if (!(particle->getDaughter(dID))) { return std::numeric_limits<double>::quiet_NaN(); }
240 
241  const MCParticle* mcparticle = particle->getDaughter(dID)->getMCParticle();
242  if (!mcparticle) { return std::numeric_limits<double>::quiet_NaN(); }
243 
244  const TrackFitResult* trackFit = getTrackFitResultFromV0DaughterParticle(particle, daughterID);
245  if (!trackFit) { return std::numeric_limits<double>::quiet_NaN(); }
246 
247  // MC information
248  const TVector3 mcProdVertex = mcparticle->getVertex();
249  const TVector3 mcMomentum = mcparticle->getMomentum();
250  const double mcParticleCharge = mcparticle->getCharge();
251  const double BzAtProdVertex = BFieldManager::getField(TVector3(mcProdVertex.X(), mcProdVertex.Y(),
252  mcProdVertex.Z())).Z() / Belle2::Unit::T;
253  Helix mcHelix = Helix(mcProdVertex, mcMomentum, mcParticleCharge, BzAtProdVertex);
254  mcHelix.passiveMoveBy(mcProdVertex);
255  const std::vector<double> mcHelixPars = { mcHelix.getD0(), mcHelix.getPhi0(), mcHelix.getOmega(),
256  mcHelix.getZ0(), mcHelix.getTanLambda()
257  };
258 
259  // measured information (from the rconstructed particle)
260  UncertainHelix measHelix = trackFit->getUncertainHelix();
261  measHelix.passiveMoveBy(mcProdVertex);
262  const TMatrixDSym measCovariance = measHelix.getCovariance();
263  const std::vector<double> measHelixPars = {measHelix.getD0(), measHelix.getPhi0(), measHelix.getOmega(),
264  measHelix.getZ0(), measHelix.getTanLambda()
265  };
266  const std::vector<double> measErrSquare = {measCovariance[0][0], measCovariance[1][1], measCovariance[2][2],
267  measCovariance[3][3], measCovariance[4][4]
268  };
269 
270  if (measErrSquare.at(tauIndex) > 0)
271  return (mcHelixPars.at(tauIndex) - measHelixPars.at(tauIndex)) / std::sqrt(measErrSquare.at(tauIndex));
272  else
273  return std::numeric_limits<double>::quiet_NaN();
274  }
275 
276  double v0DaughterHelixWithTrueVertexAsPivotD0Pull(const Particle* part, const std::vector<double>& daughterID)
277  {
278  return getHelixParameterPullOfV0DaughterWithTrueVertexAsPivotAtIndex(part, daughterID[0], 0);
279  }
280 
281  double v0DaughterHelixWithTrueVertexAsPivotPhi0Pull(const Particle* part, const std::vector<double>& daughterID)
282  {
283  return getHelixParameterPullOfV0DaughterWithTrueVertexAsPivotAtIndex(part, daughterID[0], 1);
284  }
285 
286  double v0DaughterHelixWithTrueVertexAsPivotOmegaPull(const Particle* part, const std::vector<double>& daughterID)
287  {
288  return getHelixParameterPullOfV0DaughterWithTrueVertexAsPivotAtIndex(part, daughterID[0], 2);
289  }
290 
291  double v0DaughterHelixWithTrueVertexAsPivotZ0Pull(const Particle* part, const std::vector<double>& daughterID)
292  {
293  return getHelixParameterPullOfV0DaughterWithTrueVertexAsPivotAtIndex(part, daughterID[0], 3);
294  }
295 
296  double v0DaughterHelixWithTrueVertexAsPivotTanLambdaPull(const Particle* part, const std::vector<double>& daughterID)
297  {
298  return getHelixParameterPullOfV0DaughterWithTrueVertexAsPivotAtIndex(part, daughterID[0], 4);
299  }
300 
301  // helper function to get pull of the helix parameters of the V0 daughter tracks with the origin as the pivot.
302  // Not registered in variable mananger
303  double getHelixParameterPullOfV0DaughterWithOriginAsPivotAtIndex(const Particle* particle, const double daughterID,
304  const int tauIndex)
305  {
306  if (!particle) { return std::numeric_limits<double>::quiet_NaN(); }
307 
308  const int dID = int(std::lround(daughterID));
309  if (not(dID == 0 || dID == 1)) { return std::numeric_limits<double>::quiet_NaN(); }
310 
311  const MCParticle* mcparticle_v0 = particle->getMCParticle();
312  if (!mcparticle_v0) { return std::numeric_limits<double>::quiet_NaN(); }
313 
314  if (!(particle->getDaughter(dID))) { return std::numeric_limits<double>::quiet_NaN(); }
315 
316  const MCParticle* mcparticle = particle->getDaughter(dID)->getMCParticle();
317  if (!mcparticle) { return std::numeric_limits<double>::quiet_NaN(); }
318 
319  const TrackFitResult* trackFit = getTrackFitResultFromV0DaughterParticle(particle, daughterID);
320  if (!trackFit) { return std::numeric_limits<double>::quiet_NaN(); }
321 
322  // MC information
323  const TVector3 mcProdVertex = mcparticle->getVertex();
324  const TVector3 mcMomentum = mcparticle->getMomentum();
325  const double mcParticleCharge = mcparticle->getCharge();
326  const double BzAtOrigin = BFieldManager::getField(TVector3(0, 0, 0)).Z() / Belle2::Unit::T;
327 
328  Helix mcHelix = Helix(mcProdVertex, mcMomentum, mcParticleCharge, BzAtOrigin);
329  const std::vector<double> mcHelixPars = { mcHelix.getD0(), mcHelix.getPhi0(), mcHelix.getOmega(),
330  mcHelix.getZ0(), mcHelix.getTanLambda()
331  };
332 
333  // measured information (from the rconstructed particle)
334  UncertainHelix measHelix = trackFit->getUncertainHelix();
335  const TMatrixDSym measCovariance = measHelix.getCovariance();
336  const std::vector<double> measHelixPars = {measHelix.getD0(), measHelix.getPhi0(), measHelix.getOmega(),
337  measHelix.getZ0(), measHelix.getTanLambda()
338  };
339  const std::vector<double> measErrSquare = {measCovariance[0][0], measCovariance[1][1], measCovariance[2][2],
340  measCovariance[3][3], measCovariance[4][4]
341  };
342 
343  if (measErrSquare.at(tauIndex) > 0)
344  return (mcHelixPars.at(tauIndex) - measHelixPars.at(tauIndex)) / std::sqrt(measErrSquare.at(tauIndex));
345  else
346  return std::numeric_limits<double>::quiet_NaN();
347  }
348 
349  double v0DaughterHelixWithOriginAsPivotD0Pull(const Particle* part, const std::vector<double>& daughterID)
350  {
351  return getHelixParameterPullOfV0DaughterWithOriginAsPivotAtIndex(part, daughterID[0], 0);
352  }
353 
354  double v0DaughterHelixWithOriginAsPivotPhi0Pull(const Particle* part, const std::vector<double>& daughterID)
355  {
356  return getHelixParameterPullOfV0DaughterWithOriginAsPivotAtIndex(part, daughterID[0], 1);
357  }
358 
359  double v0DaughterHelixWithOriginAsPivotOmegaPull(const Particle* part, const std::vector<double>& daughterID)
360  {
361  return getHelixParameterPullOfV0DaughterWithOriginAsPivotAtIndex(part, daughterID[0], 2);
362  }
363 
364  double v0DaughterHelixWithOriginAsPivotZ0Pull(const Particle* part, const std::vector<double>& daughterID)
365  {
366  return getHelixParameterPullOfV0DaughterWithOriginAsPivotAtIndex(part, daughterID[0], 3);
367  }
368 
369  double v0DaughterHelixWithOriginAsPivotTanLambdaPull(const Particle* part, const std::vector<double>& daughterID)
370  {
371  return getHelixParameterPullOfV0DaughterWithOriginAsPivotAtIndex(part, daughterID[0], 4);
372  }
373 
374  double v0DaughterTrackParam5AtIPPerigee(const Particle* part, const std::vector<double>& params)
375  {
376  auto trackFit = getTrackFitResultFromV0DaughterParticle(part, params[0]);
377  if (!trackFit) {
378  return std::numeric_limits<double>::quiet_NaN();
379  }
380 
381  const int paramID = int(std::lround(params[1]));
382  if (not(0 <= paramID && paramID < 5))
383  return std::numeric_limits<double>::quiet_NaN();
384 
385  std::vector<float> tau = trackFit->getTau();
386  return tau[paramID];
387  }
388 
389  double v0DaughterTrackParamCov5x5AtIPPerigee(const Particle* part, const std::vector<double>& params)
390  {
391  auto trackFit = getTrackFitResultFromV0DaughterParticle(part, params[0]);
392  if (!trackFit) {
393  return std::numeric_limits<double>::quiet_NaN();
394  }
395 
396  const int paramID = int(std::lround(params[1]));
397  if (not(0 <= paramID && paramID < 15))
398  return std::numeric_limits<double>::quiet_NaN();
399 
400  std::vector<float> cov = trackFit->getCov();
401  return cov[paramID];
402  }
403 
404 
405  VARIABLE_GROUP("V0Daughter");
406 
407  REGISTER_VARIABLE("v0DaughterNCDCHits(i)", v0DaughterTrackNCDCHits, "Number of CDC hits associated to the i-th daughter track");
408  REGISTER_VARIABLE("v0DaughterNSVDHits(i)", v0DaughterTrackNSVDHits, "Number of SVD hits associated to the i-th daughter track");
409  REGISTER_VARIABLE("v0DaughterNPXDHits(i)", v0DaughterTrackNPXDHits, "Number of PXD hits associated to the i-th daughter track");
410  REGISTER_VARIABLE("v0DaughterNVXDHits(i)", v0DaughterTrackNVXDHits, "Number of PXD+SVD hits associated to the i-th daughter track");
411  REGISTER_VARIABLE("v0DaughterFirstSVDLayer(i)", v0DaughterTrackFirstSVDLayer,
412  "First activated SVD layer associated to the i-th daughter track");
413  REGISTER_VARIABLE("v0DaughterFirstPXDLayer(i)", v0DaughterTrackFirstPXDLayer,
414  "First activated PXD layer associated to the i-th daughter track");
415  REGISTER_VARIABLE("v0DaughterFirstCDCLayer(i)", v0DaughterTrackFirstCDCLayer,
416  "First activated CDC layer associated to the i-th daughter track");
417  REGISTER_VARIABLE("v0DaughterLastCDCLayer(i)", v0DaughterTrackLastCDCLayer,
418  "Last CDC layer associated to the i-th daughter track");
419  REGISTER_VARIABLE("v0DaughterPValue(i)", v0DaughterTrackPValue,
420  "chi2 probalility of the i-th daughter track fit");
422  REGISTER_VARIABLE("v0DaughterD0(i)", v0DaughterTrackD0, "d0 of the i-th daughter track fit");
423  REGISTER_VARIABLE("v0DaughterPhi0(i)", v0DaughterTrackPhi0, "phi0 of the i-th daughter track fit");
424  REGISTER_VARIABLE("v0DaughterOmega(i)", v0DaughterTrackOmega, "omega of the i-th daughter track fit");
425  REGISTER_VARIABLE("v0DaughterZ0(i)", v0DaughterTrackZ0, "z0 of the i-th daughter track fit");
426  REGISTER_VARIABLE("v0DaughterTanLambda(i)", v0DaughterTrackTanLambda, "tan(lambda) of the i-th daughter track fit");
428  REGISTER_VARIABLE("v0DaughterD0Error(i)", v0DaughterTrackD0Error, "d0 error of the i-th daughter track fit");
429  REGISTER_VARIABLE("v0DaughterPhi0Error(i)", v0DaughterTrackPhi0Error, "phi0 error of the i-th daughter track fit");
430  REGISTER_VARIABLE("v0DaughterOmegaError(i)", v0DaughterTrackOmegaError, "omega error of the i-th daughter track fit");
431  REGISTER_VARIABLE("v0DaughterZ0Error(i)", v0DaughterTrackZ0Error, "z0 error of the i-th daughter track fit");
432  REGISTER_VARIABLE("v0DaughterTanLambdaError(i)", v0DaughterTrackTanLambdaError, "tan(lambda) error of the i-th daughter track fit");
434  REGISTER_VARIABLE("v0DaughterD0PullWithTrueVertexAsPivot(i)", v0DaughterHelixWithTrueVertexAsPivotD0Pull,
435  "d0 pull of the i-th daughter track with the true V0 vertex as the track pivot");
436  REGISTER_VARIABLE("v0DaughterPhi0PullWithTrueVertexAsPivot(i)", v0DaughterHelixWithTrueVertexAsPivotPhi0Pull,
437  "phi0 pull of the i-th daughter track with the true V0 vertex as the track pivot");
438  REGISTER_VARIABLE("v0DaughterOmegaPullWithTrueVertexAsPivot(i)", v0DaughterHelixWithTrueVertexAsPivotOmegaPull,
439  "omega pull of the i-th daughter track with the true V0 vertex as the track pivot");
440  REGISTER_VARIABLE("v0DaughterZ0PullWithTrueVertexAsPivot(i)", v0DaughterHelixWithTrueVertexAsPivotZ0Pull,
441  "z0 pull of the i-th daughter track with the true V0 vertex as the track pivot");
442  REGISTER_VARIABLE("v0DaughterTanLambdaPullWithTrueVertexAsPivot(i)", v0DaughterHelixWithTrueVertexAsPivotTanLambdaPull,
443  "tan(lambda) pull of the i-th daughter track with the true V0 vertex as the track pivot");
445  REGISTER_VARIABLE("v0DaughterD0PullWithOriginAsPivot(i)", v0DaughterHelixWithOriginAsPivotD0Pull,
446  "d0 pull of the i-th daughter track with the origin as the track pivot");
447  REGISTER_VARIABLE("v0DaughterPhi0PullWithOriginAsPivot(i)", v0DaughterHelixWithOriginAsPivotPhi0Pull,
448  "phi0 pull of the i-th daughter track with the origin as the track pivot");
449  REGISTER_VARIABLE("v0DaughterOmegaPullWithOriginAsPivot(i)", v0DaughterHelixWithOriginAsPivotOmegaPull,
450  "omega pull of the i-th daughter track with the origin as the track pivot");
451  REGISTER_VARIABLE("v0DaughterZ0PullWithOriginAsPivot(i)", v0DaughterHelixWithOriginAsPivotZ0Pull,
452  "z0 pull of the i-th daughter track with the origin as the track pivot");
453  REGISTER_VARIABLE("v0DaughterTanLambdaPullWithOriginAsPivot(i)", v0DaughterHelixWithOriginAsPivotTanLambdaPull,
454  "tan(lambda) pull of the i-th daughter track with the origin as the track pivot");
456  REGISTER_VARIABLE("v0DaughterTau(i,j)", v0DaughterTrackParam5AtIPPerigee,
457  "j-th track parameter (at IP perigee) of the i-th daughter track. "
458  "j: 0:d0, 1:phi0, 2:omega, 3:z0, 4:tanLambda");
459  REGISTER_VARIABLE("v0DaughterCov(i,j)", v0DaughterTrackParamCov5x5AtIPPerigee,
460  "j-th element of the 15 covariance matrix elements (at IP perigee) of the i-th daughter track. "
461  "(0,0), (0,1) ... (1,1), (1,2) ... (2,2) ...");
462  }
464 }
Belle2::Unit::T
static const double T
[tesla]
Definition: Unit.h:130
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19