Belle II Software  release-06-02-00
MCParticleTag.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/VariableManager/Manager.h>
10 #include <analysis/variables/MCParticleTag.h>
11 
12 // analysis utilities
13 #include <analysis/utility/GenBplusTag.h>
14 #include <analysis/utility/GenB0Tag.h>
15 #include <analysis/utility/GenBsTag.h>
16 #include <analysis/utility/GenDTag.h>
17 #include <analysis/utility/GenTauTag.h>
18 
19 // mdst dataobjects
20 #include <mdst/dataobjects/MCParticle.h>
21 
22 // framework
23 #include <framework/datastore/StoreArray.h>
24 #include <framework/gearbox/Const.h>
25 #include <framework/logging/Logger.h>
26 
27 #include <vector>
28 #include <iostream>
29 #include <cmath>
30 
31 
32 namespace Belle2 {
37  namespace Variable {
38 
39  double BplusMode(const Particle*)
40  {
41  GenBplusTag gBtag;
42  StoreArray<MCParticle> MC_Particle_list;
43  if (!MC_Particle_list) {
44  B2WARNING("GenMCTagTool::eval - missing MCParticles array");
45  return std::numeric_limits<double>::quiet_NaN();
46  }
47  int modeB = -99;
48 
49  for (const auto& iMCParticle : MC_Particle_list) {
50  if (iMCParticle.getPDG() != 521) continue;
51 
52  std::vector<int> DauPDG;
53  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
54  DauPDG.push_back(mcDaughter->getPDG());
55  }
56  modeB = gBtag.Mode_B_plus(DauPDG);
57  break;
58  }
59 
60  return modeB;
61  }
62 
63  double BminusMode(const Particle*)
64  {
65  GenBplusTag gBtag;
66  StoreArray<MCParticle> MC_Particle_list;
67  if (!MC_Particle_list) {
68  B2WARNING("GenMCTagTool::eval - missing MCParticles array");
69  return std::numeric_limits<double>::quiet_NaN();
70  }
71  int modeB = -99;
72 
73  for (const auto& iMCParticle : MC_Particle_list) {
74  if (iMCParticle.getPDG() != -521) continue;
75 
76  std::vector<int> DauPDG;
77  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
78  DauPDG.push_back(mcDaughter->getPDG());
79  }
80  modeB = gBtag.Mode_B_minus(DauPDG);
81  break;
82  }
83 
84  return modeB;
85  }
86 
87  double B0Mode(const Particle*)
88  {
89  GenB0Tag gBtag;
90  StoreArray<MCParticle> MC_Particle_list;
91  if (!MC_Particle_list) {
92  B2WARNING("GenMCTagTool::eval - missing MCParticles array");
93  return std::numeric_limits<double>::quiet_NaN();
94  }
95  int modeB1 = -99, modeB2 = -99, modeB = -99, nb1 = 0, nb2 = 0;
96 
97  for (const auto& iMCParticle : MC_Particle_list) {
98  if (iMCParticle.getPDG() == 511) {
99  nb1++;
100  if (nb1 == 1) {
101  std::vector<int> DauPDG1;
102  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
103  DauPDG1.push_back(mcDaughter->getPDG());
104  }
105  modeB1 = gBtag.Mode_B0(DauPDG1);
106  break;
107  }
108  }
109  if (iMCParticle.getPDG() == -511) {
110  nb2++;
111  if (nb2 == 2) {
112  std::vector<int> DauPDG2;
113  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
114  DauPDG2.push_back(mcDaughter->getPDG());
115  }
116  modeB2 = gBtag.Mode_anti_B0(DauPDG2);
117  break;
118  }
119  }
120  }
121 
122  if (modeB1 != -99) { modeB = modeB1;}
123  else if (modeB2 != -99) { modeB = modeB2;}
124 
125  return modeB;
126  }
127 
128  double Bbar0Mode(const Particle*)
129  {
130  GenB0Tag gBtag;
131  StoreArray<MCParticle> MC_Particle_list;
132  if (!MC_Particle_list) {
133  B2WARNING("GenMCTagTool::eval - missing MCParticles array");
134  return std::numeric_limits<double>::quiet_NaN();
135  }
136  int modeB1 = -99, modeB2 = -99, modeB = -99, nb1 = 0, nb2 = 0;
137 
138  for (const auto& iMCParticle : MC_Particle_list) {
139  if (iMCParticle.getPDG() == -511) {
140  nb1++;
141  if (nb1 == 1) {
142  std::vector<int> DauPDG1;
143  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
144  DauPDG1.push_back(mcDaughter->getPDG());
145  }
146  modeB1 = gBtag.Mode_anti_B0(DauPDG1);
147  break;
148  }
149  }
150  if (iMCParticle.getPDG() == 511) {
151  nb2++;
152  if (nb2 == 2) {
153  std::vector<int> DauPDG2;
154  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
155  DauPDG2.push_back(mcDaughter->getPDG());
156  }
157  modeB2 = gBtag.Mode_B0(DauPDG2);
158  break;
159  }
160  }
161  }
162 
163  if (modeB1 != -99) { modeB = modeB1;}
164  else if (modeB2 != -99) { modeB = modeB2;}
165 
166  return modeB;
167  }
168 
169  double Bs0Mode(const Particle*)
170  {
171  GenBsTag gBtag;
172  StoreArray<MCParticle> MC_Particle_list;
173  if (!MC_Particle_list) {
174  B2WARNING("GenMCTagTool::eval - missing MCParticles array");
175  return std::numeric_limits<double>::quiet_NaN();
176  }
177  int modeB1 = -99, modeB2 = -99, modeB = -99, nb1 = 0, nb2 = 0;
178 
179  for (const auto& iMCParticle : MC_Particle_list) {
180  if (iMCParticle.getPDG() == 531) {
181  nb1++;
182  if (nb1 == 1) {
183  std::vector<int> DauPDG1;
184  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
185  DauPDG1.push_back(mcDaughter->getPDG());
186  }
187  modeB1 = gBtag.Mode_Bs0(DauPDG1);
188  break;
189  }
190  }
191  if (iMCParticle.getPDG() == -531) {
192  nb2++;
193  if (nb2 == 2) {
194  std::vector<int> DauPDG2;
195  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
196  DauPDG2.push_back(mcDaughter->getPDG());
197  }
198  modeB2 = gBtag.Mode_anti_Bs0(DauPDG2);
199  break;
200  }
201  }
202  }
203 
204  if (modeB1 != -99) { modeB = modeB1;}
205  else if (modeB2 != -99) { modeB = modeB2;}
206 
207  return modeB;
208  }
209 
210  double Bsbar0Mode(const Particle*)
211  {
212  GenBsTag gBtag;
213  StoreArray<MCParticle> MC_Particle_list;
214  if (!MC_Particle_list) {
215  B2WARNING("GenMCTagTool::eval - missing MCParticles array");
216  return std::numeric_limits<double>::quiet_NaN();
217  }
218  int modeB1 = -99, modeB2 = -99, modeB = -99, nb1 = 0, nb2 = 0;
219 
220  for (const auto& iMCParticle : MC_Particle_list) {
221  if (iMCParticle.getPDG() == -531) {
222  nb1++;
223  if (nb1 == 1) {
224  std::vector<int> DauPDG1;
225  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
226  DauPDG1.push_back(mcDaughter->getPDG());
227  }
228  modeB1 = gBtag.Mode_anti_Bs0(DauPDG1);
229  break;
230  }
231  }
232  if (iMCParticle.getPDG() == 531) {
233  nb2++;
234  if (nb2 == 2) {
235  std::vector<int> DauPDG2;
236  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
237  DauPDG2.push_back(mcDaughter->getPDG());
238  }
239  modeB2 = gBtag.Mode_Bs0(DauPDG2);
240  break;
241  }
242  }
243  }
244 
245  if (modeB1 != -99) { modeB = modeB1;}
246  else if (modeB2 != -99) { modeB = modeB2;}
247 
248  return modeB;
249  }
250 
251  double DstplusMode(const Particle*)
252  {
253  GenDTag gDtag;
254  StoreArray<MCParticle> MC_Particle_list;
255  if (!MC_Particle_list) {
256  B2WARNING("GenMCTagTool::eval - missing MCParticles array");
257  return std::numeric_limits<double>::quiet_NaN();
258  }
259  int modeD = -99;
260 
261  for (const auto& iMCParticle : MC_Particle_list) {
262  if (iMCParticle.getPDG() != 413) continue;
263 
264  std::vector<int> DauPDG;
265  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
266  DauPDG.push_back(mcDaughter->getPDG());
267  }
268  modeD = gDtag.Mode_Dst_plus(DauPDG);
269  break;
270  }
271 
272  return modeD;
273  }
274 
275  double DstminusMode(const Particle*)
276  {
277  GenDTag gDtag;
278  StoreArray<MCParticle> MC_Particle_list;
279  if (!MC_Particle_list) {
280  B2WARNING("GenMCTagTool::eval - missing MCParticles array");
281  return std::numeric_limits<double>::quiet_NaN();
282  }
283  int modeD = -99;
284 
285  for (const auto& iMCParticle : MC_Particle_list) {
286  if (iMCParticle.getPDG() != -413) continue;
287 
288  std::vector<int> DauPDG;
289  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
290  DauPDG.push_back(mcDaughter->getPDG());
291  }
292  modeD = gDtag.Mode_Dst_minus(DauPDG);
293  break;
294  }
295 
296  return modeD;
297  }
298 
299  double DsplusMode(const Particle*)
300  {
301  GenDTag gDtag;
302  StoreArray<MCParticle> MC_Particle_list;
303  if (!MC_Particle_list) {
304  B2WARNING("GenMCTagTool::eval - missing MCParticles array");
305  return std::numeric_limits<double>::quiet_NaN();
306  }
307  int modeD = -99;
308 
309  for (const auto& iMCParticle : MC_Particle_list) {
310  if (iMCParticle.getPDG() != 431) continue;
311 
312  std::vector<int> DauPDG;
313  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
314  DauPDG.push_back(mcDaughter->getPDG());
315  }
316  modeD = gDtag.Mode_Ds_plus(DauPDG);
317  break;
318  }
319 
320  return modeD;
321  }
322 
323  double DsminusMode(const Particle*)
324  {
325  GenDTag gDtag;
326  StoreArray<MCParticle> MC_Particle_list;
327  if (!MC_Particle_list) {
328  B2WARNING("GenMCTagTool::eval - missing MCParticles array");
329  return std::numeric_limits<double>::quiet_NaN();
330  }
331  int modeD = -99;
332 
333  for (const auto& iMCParticle : MC_Particle_list) {
334  if (iMCParticle.getPDG() != -431) continue;
335 
336  std::vector<int> DauPDG;
337  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
338  DauPDG.push_back(mcDaughter->getPDG());
339  }
340  modeD = gDtag.Mode_Ds_minus(DauPDG);
341  break;
342  }
343 
344  return modeD;
345  }
346 
347  double DplusMode(const Particle*)
348  {
349  GenDTag gDtag;
350  StoreArray<MCParticle> MC_Particle_list;
351  if (!MC_Particle_list) {
352  B2WARNING("GenMCTagTool::eval - missing MCParticles array");
353  return std::numeric_limits<double>::quiet_NaN();
354  }
355  int modeD = -99;
356 
357  for (const auto& iMCParticle : MC_Particle_list) {
358  if (iMCParticle.getPDG() != 411) continue;
359 
360  std::vector<int> DauPDG;
361  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
362  DauPDG.push_back(mcDaughter->getPDG());
363  }
364  modeD = gDtag.Mode_D_plus(DauPDG);
365  break;
366  }
367 
368  return modeD;
369  }
370 
371  double DminusMode(const Particle*)
372  {
373  GenDTag gDtag;
374  StoreArray<MCParticle> MC_Particle_list;
375  if (!MC_Particle_list) {
376  B2WARNING("GenMCTagTool::eval - missing MCParticles array");
377  return std::numeric_limits<double>::quiet_NaN();
378  }
379  int modeD = -99;
380 
381  for (const auto& iMCParticle : MC_Particle_list) {
382  if (iMCParticle.getPDG() != -411) continue;
383 
384  std::vector<int> DauPDG;
385  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
386  DauPDG.push_back(mcDaughter->getPDG());
387  }
388  modeD = gDtag.Mode_D_minus(DauPDG);
389  break;
390  }
391 
392  return modeD;
393  }
394 
395  double D0Mode(const Particle*)
396  {
397  GenDTag gDtag;
398  StoreArray<MCParticle> MC_Particle_list;
399  if (!MC_Particle_list) {
400  B2WARNING("GenMCTagTool::eval - missing MCParticles array");
401  return std::numeric_limits<double>::quiet_NaN();
402  }
403  int modeD = -99;
404 
405  for (const auto& iMCParticle : MC_Particle_list) {
406  if (iMCParticle.getPDG() != 421) continue;
407 
408  std::vector<int> DauPDG;
409  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
410  DauPDG.push_back(mcDaughter->getPDG());
411  }
412  modeD = gDtag.Mode_D0(DauPDG);
413  break;
414  }
415 
416  return modeD;
417  }
418 
419  double Dbar0Mode(const Particle*)
420  {
421  GenDTag gDtag;
422  StoreArray<MCParticle> MC_Particle_list;
423  if (!MC_Particle_list) {
424  B2WARNING("GenMCTagTool::eval - missing MCParticles array");
425  return std::numeric_limits<double>::quiet_NaN();
426  }
427  int modeD = -99;
428 
429  for (const auto& iMCParticle : MC_Particle_list) {
430  if (iMCParticle.getPDG() != -421) continue;
431 
432  std::vector<int> DauPDG;
433  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
434  DauPDG.push_back(mcDaughter->getPDG());
435  }
436  modeD = gDtag.Mode_anti_D0(DauPDG);
437  break;
438  }
439 
440  return modeD;
441  }
442 
443  double TauplusMode(const Particle*)
444  {
445  GenTauTag gTKtag;
446  StoreArray<MCParticle> MC_Particle_list;
447  if (!MC_Particle_list) {
448  B2WARNING("GenMCTagTool::eval - missing MCParticles array");
449  return std::numeric_limits<double>::quiet_NaN();
450  }
451  int modeTau = -1;
452 
453  for (const auto& iMCParticle : MC_Particle_list) {
454  if (iMCParticle.getPDG() != -15) continue;
455 
456  std::vector<int> DauPDG;
457  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
458  if (mcDaughter->getPDG() == 24) {
459  for (auto const& WDaughter : mcDaughter->getDaughters()) {
460  DauPDG.push_back(WDaughter->getPDG());
461  }
462  } else DauPDG.push_back(mcDaughter->getPDG());
463  }
464  modeTau = gTKtag.Mode_tau_plus(DauPDG);
465  break;
466  }
467 
468  return modeTau;
469  }
470 
471  double TauminusMode(const Particle*)
472  {
473  GenTauTag gTKtag;
474  StoreArray<MCParticle> MC_Particle_list;
475  if (!MC_Particle_list) {
476  B2WARNING("GenMCTagTool::eval - missing MCParticles array");
477  return std::numeric_limits<double>::quiet_NaN();
478  }
479  int modeTau = -1;
480 
481  for (const auto& iMCParticle : MC_Particle_list) {
482  if (iMCParticle.getPDG() != 15) continue;
483 
484  std::vector<int> DauPDG;
485  for (auto const& mcDaughter : iMCParticle.getDaughters()) {
486  if (mcDaughter->getPDG() == -24) {
487  for (auto const& WDaughter : mcDaughter->getDaughters()) {
488  DauPDG.push_back(WDaughter->getPDG());
489  }
490  } else DauPDG.push_back(mcDaughter->getPDG());
491  }
492  modeTau = gTKtag.Mode_tau_minus(DauPDG);
493  break;
494  }
495 
496  return modeTau;
497  }
498 
499  VARIABLE_GROUP("MCParticle tag variables");
500  REGISTER_VARIABLE("BplusMode", BplusMode, "[Eventbased] It will return the decays mode of B+ particles");
501  REGISTER_VARIABLE("BminusMode", BminusMode, "[Eventbased] It will return the decays mode of B- particles");
502  REGISTER_VARIABLE("B0Mode", B0Mode, "[Eventbased] It will return the decays mode of B0 particles");
503  REGISTER_VARIABLE("Bbar0Mode", Bbar0Mode, "[Eventbased] It will return the decays mode of anti-B0 particles");
504  REGISTER_VARIABLE("Bs0Mode", Bs0Mode, "[Eventbased] It will return the decays mode of B_s0 particles");
505  REGISTER_VARIABLE("Bsbar0Mode", Bsbar0Mode, "[Eventbased] It will return the decays mode of anti-B_s0 particles");
506  REGISTER_VARIABLE("DstplusMode", DstplusMode, "[Eventbased] It will return the decays mode of D*+ particles");
507  REGISTER_VARIABLE("DstminusMode", DstminusMode, "[Eventbased] It will return the decays mode of D*- particles");
508  REGISTER_VARIABLE("DsplusMode", DsplusMode, "[Eventbased] It will return the decays mode of D_s+ particles");
509  REGISTER_VARIABLE("DsminusMode", DsminusMode, "[Eventbased] It will return the decays mode of D_s- particles");
510  REGISTER_VARIABLE("DplusMode", DplusMode, "[Eventbased] It will return the decays mode of D+ particles");
511  REGISTER_VARIABLE("DminusMode", DminusMode, "[Eventbased] It will return the decays mode of D- particles");
512  REGISTER_VARIABLE("D0Mode", D0Mode, "[Eventbased] It will return the decays mode of D0 particles");
513  REGISTER_VARIABLE("Dbar0Mode", Dbar0Mode, "[Eventbased] It will return the decays mode of anti-D0 particles");
514  REGISTER_VARIABLE("TauplusMode", TauplusMode, "[Eventbased] It will return the decays mode of tau+ particles");
515  REGISTER_VARIABLE("TauminusMode", TauminusMode, "[Eventbased] It will return the decays mode of tau- particles");
516  }
518 }
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17