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