Belle II Software  release-05-01-25
KLMMuidLikelihoodVariables.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2019 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Alberto Martini, Giacomo De Pietro *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 /* KLM headers. */
12 #include <klm/dataobjects/KLMMuidLikelihood.h>
13 
14 /* Belle 2 headers. */
15 #include <analysis/dataobjects/Particle.h>
16 #include <analysis/VariableManager/Manager.h>
17 #include <mdst/dataobjects/Track.h>
18 
19 using namespace std;
20 
21 namespace Belle2 {
26  namespace Variable {
27 
29  KLMMuidLikelihood* getMuid(const Particle* particle)
30  {
31  const Track* track = particle->getTrack();
32  if (!track)
33  return nullptr;
34  return track->getRelatedTo<KLMMuidLikelihood>();
35  }
36 
38  double muidMuonProbability(const Particle* particle)
39  {
40  KLMMuidLikelihood* muid = getMuid(particle);
41  if (!muid)
42  return std::numeric_limits<double>::quiet_NaN();
43  return muid->getMuonPDFValue();
44  }
45 
47  double muidPionProbability(const Particle* particle)
48  {
49  KLMMuidLikelihood* muid = getMuid(particle);
50  if (!muid)
51  return std::numeric_limits<double>::quiet_NaN();
52  return muid->getPionPDFValue();
53  }
54 
56  double muidKaonProbability(const Particle* particle)
57  {
58  KLMMuidLikelihood* muid = getMuid(particle);
59  if (!muid)
60  return std::numeric_limits<double>::quiet_NaN();
61  return muid->getKaonPDFValue();
62  }
63 
65  double muidElectronProbability(const Particle* particle)
66  {
67  KLMMuidLikelihood* muid = getMuid(particle);
68  if (!muid)
69  return std::numeric_limits<double>::quiet_NaN();
70  return muid->getElectronPDFValue();
71  }
72 
74  double muidProtonProbability(const Particle* particle)
75  {
76  KLMMuidLikelihood* muid = getMuid(particle);
77  if (!muid)
78  return std::numeric_limits<double>::quiet_NaN();
79  return muid->getProtonPDFValue();
80  }
81 
83  double muidDeuteronProbability(const Particle* particle)
84  {
85  KLMMuidLikelihood* muid = getMuid(particle);
86  if (!muid)
87  return std::numeric_limits<double>::quiet_NaN();
88  return muid->getDeuteronPDFValue();
89  }
90 
92  double muidMuonLogLikelihood(const Particle* particle)
93  {
94  KLMMuidLikelihood* muid = getMuid(particle);
95  if (!muid)
96  return std::numeric_limits<double>::quiet_NaN();
97  return muid->getLogL_mu();
98  }
99 
101  double muidPionLogLikelihood(const Particle* particle)
102  {
103  KLMMuidLikelihood* muid = getMuid(particle);
104  if (!muid)
105  return std::numeric_limits<double>::quiet_NaN();
106  return muid->getLogL_pi();
107  }
108 
110  double muidKaonLogLikelihood(const Particle* particle)
111  {
112  KLMMuidLikelihood* muid = getMuid(particle);
113  if (!muid)
114  return std::numeric_limits<double>::quiet_NaN();
115  return muid->getLogL_K();
116  }
117 
119  double muidElectronLogLikelihood(const Particle* particle)
120  {
121  KLMMuidLikelihood* muid = getMuid(particle);
122  if (!muid)
123  return std::numeric_limits<double>::quiet_NaN();
124  return muid->getLogL_e();
125  }
126 
128  double muidProtonLogLikelihood(const Particle* particle)
129  {
130  KLMMuidLikelihood* muid = getMuid(particle);
131  if (!muid)
132  return std::numeric_limits<double>::quiet_NaN();
133  return muid->getLogL_p();
134  }
135 
137  double muidDeuteronLogLikelihood(const Particle* particle)
138  {
139  KLMMuidLikelihood* muid = getMuid(particle);
140  if (!muid)
141  return std::numeric_limits<double>::quiet_NaN();
142  return muid->getLogL_d();
143  }
144 
146  double muidOutcomeExtTrack(const Particle* particle)
147  {
148  KLMMuidLikelihood* muid = getMuid(particle);
149  if (!muid)
150  return std::numeric_limits<double>::quiet_NaN();
151  return muid->getOutcome();
152  }
153 
155  double muidChiSquared(const Particle* particle)
156  {
157  KLMMuidLikelihood* muid = getMuid(particle);
158  if (!muid)
159  return std::numeric_limits<double>::quiet_NaN();
160  return muid->getChiSquared();
161  }
162 
164  double muidDegreesOfFreedom(const Particle* particle)
165  {
166  KLMMuidLikelihood* muid = getMuid(particle);
167  if (!muid)
168  return std::numeric_limits<double>::quiet_NaN();
169  return muid->getDegreesOfFreedom();
170  }
171 
173  double muidEndcapExtLayer(const Particle* particle)
174  {
175  KLMMuidLikelihood* muid = getMuid(particle);
176  if (!muid)
177  return std::numeric_limits<double>::quiet_NaN();
178  return muid->getEndcapExtLayer();
179  }
180 
182  double muidBarrelExtLayer(const Particle* particle)
183  {
184  KLMMuidLikelihood* muid = getMuid(particle);
185  if (!muid)
186  return std::numeric_limits<double>::quiet_NaN();
187  return muid->getBarrelExtLayer();
188  }
189 
191  double muidExtLayer(const Particle* particle)
192  {
193  KLMMuidLikelihood* muid = getMuid(particle);
194  if (!muid)
195  return std::numeric_limits<double>::quiet_NaN();
196  return muid->getExtLayer();
197  }
198 
200  double muidEndcapHitLayer(const Particle* particle)
201  {
202  KLMMuidLikelihood* muid = getMuid(particle);
203  if (!muid)
204  return std::numeric_limits<double>::quiet_NaN();
205  return muid->getEndcapHitLayer();
206  }
207 
209  double muidBarrelHitLayer(const Particle* particle)
210  {
211  KLMMuidLikelihood* muid = getMuid(particle);
212  if (!muid)
213  return std::numeric_limits<double>::quiet_NaN();
214  return muid->getBarrelHitLayer();
215  }
216 
218  double muidHitLayer(const Particle* particle)
219  {
220  KLMMuidLikelihood* muid = getMuid(particle);
221  if (!muid)
222  return std::numeric_limits<double>::quiet_NaN();
223  return muid->getHitLayer();
224  }
225 
227  double muidExtLayerPattern(const Particle* particle)
228  {
229  KLMMuidLikelihood* muid = getMuid(particle);
230  if (!muid)
231  return std::numeric_limits<double>::quiet_NaN();
232  return muid->getExtLayerPattern();
233  }
234 
236  double muidHitLayerPattern(const Particle* particle)
237  {
238  KLMMuidLikelihood* muid = getMuid(particle);
239  if (!muid)
240  return std::numeric_limits<double>::quiet_NaN();
241  return muid->getHitLayerPattern();
242  }
243 
245  double muidTotalBarrelHits(const Particle* particle)
246  {
247  KLMMuidLikelihood* muid = getMuid(particle);
248  if (!muid)
249  return std::numeric_limits<double>::quiet_NaN();
250  return muid->getTotalBarrelHits();
251  }
252 
254  double muidTotalEndcapHits(const Particle* particle)
255  {
256  KLMMuidLikelihood* muid = getMuid(particle);
257  if (!muid)
258  return std::numeric_limits<double>::quiet_NaN();
259  return muid->getTotalEndcapHits();
260  }
261 
263  double muidTotalHits(const Particle* particle)
264  {
265  return muidTotalBarrelHits(particle) + muidTotalEndcapHits(particle);
266  }
267 
268  VARIABLE_GROUP("KLMMuidLikelihood calibration");
269  REGISTER_VARIABLE("muidMuonProbability", muidMuonProbability,
270  "[Calibration] Returns the muon probability stored in the KLMMuidLikelihood dataobject");
271  REGISTER_VARIABLE("muidPionProbability", muidPionProbability,
272  "[Calibration] Returns the pion probability stored in the KLMMuidLikelihood dataobject");
273  REGISTER_VARIABLE("muidKaonProbability", muidKaonProbability,
274  "[Calibration] Returns the kaon probability stored in the KLMMuidLikelihood dataobject");
275  REGISTER_VARIABLE("muidElectronProbability", muidElectronProbability,
276  "[Calibration] Returns the electron probability stored in the KLMMuidLikelihood dataobject");
277  REGISTER_VARIABLE("muidProtonProbability", muidProtonProbability,
278  "[Calibration] Returns the proton probability stored in the KLMMuidLikelihood dataobject");
279  REGISTER_VARIABLE("muidDeuteronProbability", muidDeuteronProbability,
280  "[Calibration] Returns the deuteron probability stored in the KLMMuidLikelihood dataobject");
281  REGISTER_VARIABLE("muidMuonLogLikelihood", muidMuonLogLikelihood,
282  "[Calibration] Returns the muon log-likelihood stored in the KLMMuidLikelihood dataobject");
283  REGISTER_VARIABLE("muidPionLogLikelihood", muidPionLogLikelihood,
284  "[Calibration] Returns the pion log-likelihood stored in the KLMMuidLikelihood dataobject");
285  REGISTER_VARIABLE("muidKaonLogLikelihood", muidKaonLogLikelihood,
286  "[Calibration] Returns the kaon log-likelihood stored in the KLMMuidLikelihood dataobject");
287  REGISTER_VARIABLE("muidElectronLogLikelihood", muidElectronLogLikelihood,
288  "[Calibration] Returns the electron log-likelihood stored in the KLMMuidLikelihood dataobject");
289  REGISTER_VARIABLE("muidProtonLogLikelihood", muidProtonLogLikelihood,
290  "[Calibration] Returns the proton log-likelihood stored in the KLMMuidLikelihood dataobject");
291  REGISTER_VARIABLE("muidDeuteronLogLikelihood", muidDeuteronLogLikelihood,
292  "[Calibration] Returns the deuteron log-likelihood stored in the KLMMuidLikelihood dataobject");
293  REGISTER_VARIABLE("muidOutcomeExtTrack", muidOutcomeExtTrack,
294  "[Calibration] Returns outcome of muon extrapolation (see MuidElementNumbers for the complete list of the outcome values)");
295  REGISTER_VARIABLE("muidChiSquared", muidChiSquared,
296  "[Calibration] Returns chi-squared for this extrapolation");
297  REGISTER_VARIABLE("muidDegreesOfFreedom", muidDegreesOfFreedom,
298  "[Calibration] Returns number of degrees of freedom in chi-squared calculation");
299  REGISTER_VARIABLE("muidEndcapExtLayer", muidEndcapExtLayer,
300  "[Calibration] Returns outermost EKLM layer crossed by track during extrapolation");
301  REGISTER_VARIABLE("muidBarrelExtLayer", muidBarrelExtLayer,
302  "[Calibration] Returns outermost BKLM layer crossed by track during extrapolation");
303  REGISTER_VARIABLE("muidExtLayer", muidExtLayer,
304  "[Calibration] Returns outermost BKLM or EKLM layer crossed by track during extrapolation");
305  REGISTER_VARIABLE("muidEndcapHitLayer", muidEndcapHitLayer, "[Calibration] Returns outermost EKLM layer with a matching hit");
306  REGISTER_VARIABLE("muidBarrelHitLayer", muidBarrelHitLayer, "[Calibration] Returns outermost BKLM layer with a matching hit");
307  REGISTER_VARIABLE("muidHitLayer", muidHitLayer, "[Calibration] Return outermost BKLM or EKLM layer with a matching hit");
308  REGISTER_VARIABLE("muidExtLayerPattern", muidExtLayerPattern,
309  "[Calibration] Returns layer-crossing bit pattern during extrapolation");
310  REGISTER_VARIABLE("muidHitLayerPattern", muidHitLayerPattern, "[Calibration] Returns matching-hit bit pattern");
311  REGISTER_VARIABLE("muidTotalBarrelHits", muidTotalBarrelHits, "[Calibration] Returns total number of matching BKLM hits");
312  REGISTER_VARIABLE("muidTotalEndcapHits", muidTotalEndcapHits, "[Calibration] Returns total number of matching EKLM hits");
313  REGISTER_VARIABLE("muidTotalHits", muidTotalHits, "[Calibration] Returns total number of matching KLM hits");
314  }
316 }
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19