Belle II Software light-2406-ragdoll
decaydescriptor.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/DecayDescriptor/DecayDescriptor.h>
10#include <analysis/dataobjects/Particle.h>
11
12#include <framework/datastore/StoreArray.h>
13#include <framework/utilities/TestHelpers.h>
14#include <framework/gearbox/Const.h>
15
16#include <gtest/gtest.h>
17#include <string>
18#include <vector>
19
20using namespace Belle2;
21
22namespace {
23 TEST(DecayDescriptorTest, TrivialUse)
24 {
25 // trivial decay descriptor == particle name
26 DecayDescriptor dd;
27 bool initok = dd.init(std::string{"K+"});
28 EXPECT_EQ(initok, true);
29 ASSERT_NE(dd.getMother(), nullptr);
30 EXPECT_EQ(dd.getMother()->getName(), "K+");
31 EXPECT_EQ(dd.getMother()->getLabel(), "");
32 EXPECT_EQ(dd.getMother()->getFullName(), "K+");
33 EXPECT_EQ(dd.getMother()->getPDGCode(), Const::kaon.getPDGCode());
34 EXPECT_EQ(dd.getNDaughters(), 0);
35 }
36
37 TEST(DecayDescriptorTest, NormalBehaviour)
38 {
39 DecayDescriptor dd;
40 bool initok = dd.init(std::string{"B0:cand -> K+:loose pi-:loose"});
41
42 EXPECT_EQ(initok, true);
43
44 // standard arrow, not an inclusive decay
45 EXPECT_EQ(dd.isIgnoreRadiatedPhotons(), true);
46 EXPECT_EQ(dd.isIgnoreIntermediate(), true);
47
48 ASSERT_NE(dd.getMother(), nullptr);
49 EXPECT_EQ(dd.getMother()->getName(), "B0");
50 EXPECT_EQ(dd.getMother()->getLabel(), "cand");
51 EXPECT_EQ(dd.getMother()->getPDGCode(), 511);
52 EXPECT_EQ(dd.getMother()->getFullName(), "B0:cand");
53 EXPECT_EQ(dd.getNDaughters(), 2);
54
55 EXPECT_EQ(dd.getDaughter(0)->getNDaughters(), 0);
56 EXPECT_EQ(dd.getDaughter(0)->getMother()->getName(), "K+");
57 EXPECT_EQ(dd.getDaughter(0)->getMother()->getLabel(), "loose");
58 EXPECT_EQ(dd.getDaughter(0)->getMother()->getPDGCode(), Const::kaon.getPDGCode());
59 EXPECT_EQ(dd.getDaughter(0)->getMother()->getFullName(), "K+:loose");
60
61 EXPECT_EQ(dd.getDaughter(1)->getNDaughters(), 0);
62 EXPECT_EQ(dd.getDaughter(1)->getMother()->getName(), "pi-");
63 EXPECT_EQ(dd.getDaughter(1)->getMother()->getLabel(), "loose");
64 EXPECT_EQ(dd.getDaughter(1)->getMother()->getPDGCode(), -Const::pion.getPDGCode());
65 EXPECT_EQ(dd.getDaughter(1)->getMother()->getFullName(), "pi-:loose");
66
67 ASSERT_EQ(dd.getDaughter(2), nullptr);
68 }
69
70 TEST(DecayDescriptorTest, Granddaughters)
71 {
72 DecayDescriptor dd;
73 bool initok = dd.init(
74 std::string{"B0:cand -> [D0:dau1 -> K+:grandau pi-:grandau] [pi0:dau2 -> gamma:grandau [gamma:converted -> e+:gtgrandau e-:gtgrandau]]"}
75 );
76 EXPECT_EQ(initok, true);
77 ASSERT_NE(dd.getMother(), nullptr);
78 EXPECT_EQ(dd.getNDaughters(), 2);
79
80 // D0 -> K pi
81 EXPECT_EQ(dd.getDaughter(0)->getMother()->getName(), "D0");
82 EXPECT_EQ(dd.getDaughter(0)->getMother()->getPDGCode(), 421);
83 EXPECT_EQ(dd.getDaughter(0)->getNDaughters(), 2);
84 EXPECT_EQ(dd.getDaughter(0)->getDaughter(0)->getMother()->getName(), "K+");
85 EXPECT_EQ(dd.getDaughter(0)->getDaughter(0)->getNDaughters(), 0);
86 EXPECT_EQ(dd.getDaughter(0)->getDaughter(1)->getMother()->getName(), "pi-");
87 EXPECT_EQ(dd.getDaughter(0)->getDaughter(1)->getNDaughters(), 0);
88 ASSERT_EQ(dd.getDaughter(0)->getDaughter(2), nullptr);
89
90 // pi0 -> gamma gamma; gamma -> ee
91 EXPECT_EQ(dd.getDaughter(1)->getMother()->getName(), "pi0");
92 EXPECT_EQ(dd.getDaughter(1)->getMother()->getPDGCode(), Const::pi0.getPDGCode());
93 EXPECT_EQ(dd.getDaughter(1)->getNDaughters(), 2);
94 EXPECT_EQ(dd.getDaughter(1)->getDaughter(0)->getMother()->getName(), "gamma");
95 EXPECT_EQ(dd.getDaughter(1)->getDaughter(0)->getMother()->getLabel(), "grandau");
96 EXPECT_EQ(dd.getDaughter(1)->getDaughter(0)->getMother()->getPDGCode(), Const::photon.getPDGCode());
97 EXPECT_EQ(dd.getDaughter(1)->getDaughter(0)->getNDaughters(), 0);
98 EXPECT_EQ(dd.getDaughter(1)->getDaughter(1)->getMother()->getName(), "gamma");
99 EXPECT_EQ(dd.getDaughter(1)->getDaughter(1)->getMother()->getLabel(), "converted");
100 EXPECT_EQ(dd.getDaughter(1)->getDaughter(1)->getMother()->getPDGCode(), Const::photon.getPDGCode());
101 EXPECT_EQ(dd.getDaughter(1)->getDaughter(1)->getNDaughters(), 2);
102 EXPECT_EQ(dd.getDaughter(1)->getDaughter(1)->getDaughter(0)->getMother()->getName(), "e+");
103 EXPECT_EQ(dd.getDaughter(1)->getDaughter(1)->getDaughter(0)->getMother()->getPDGCode(), -Const::electron.getPDGCode());
104 EXPECT_EQ(dd.getDaughter(1)->getDaughter(1)->getDaughter(1)->getMother()->getName(), "e-");
105 EXPECT_EQ(dd.getDaughter(1)->getDaughter(1)->getDaughter(1)->getMother()->getPDGCode(), Const::electron.getPDGCode());
106 ASSERT_EQ(dd.getDaughter(1)->getDaughter(1)->getDaughter(2), nullptr);
107 ASSERT_EQ(dd.getDaughter(1)->getDaughter(2), nullptr);
108
109 ASSERT_EQ(dd.getDaughter(2), nullptr);
110 }
111
112 TEST(DecayDescriptorTest, ArrowsDecaysGrammar)
113 {
114 // =direct=> means ignore intermediate resonances
115 DecayDescriptor dd1;
116 bool initok = dd1.init(std::string{"B0:candidates =direct=> K+:loose pi-:loose gamma:clean"});
117 EXPECT_EQ(initok, true);
118 EXPECT_EQ(dd1.isIgnoreRadiatedPhotons(), true);
119 EXPECT_EQ(dd1.isIgnoreIntermediate(), false);
120
121 // =norad=> means ignore photons
122 DecayDescriptor dd2;
123 initok = dd2.init(std::string{"B0:candidates =norad=> K+:loose pi-:loose gamma:clean"});
124 EXPECT_EQ(initok, true);
125 EXPECT_EQ(dd2.isIgnoreRadiatedPhotons(), false);
126 EXPECT_EQ(dd2.isIgnoreIntermediate(), true);
127
128 // =exact=> means ignore intermediate resonances *and* photons
129 DecayDescriptor dd3;
130 initok = dd3.init(std::string{"B0:candidates =exact=> K+:loose pi-:loose gamma:clean"});
131 EXPECT_EQ(initok, true);
132 EXPECT_EQ(dd3.isIgnoreRadiatedPhotons(), false);
133 EXPECT_EQ(dd3.isIgnoreIntermediate(), false);
134
135 }
136
137 TEST(DecayDescriptorTest, KeywordDecaysGrammar)
138 {
139 // ... means accept missing massive
140 DecayDescriptor dd1;
141 bool initok = dd1.init(std::string{"B0:candidates -> K+:loose gamma:clean ..."});
142 EXPECT_EQ(initok, true);
143 EXPECT_EQ(dd1.isIgnoreRadiatedPhotons(), true);
144 EXPECT_EQ(dd1.isIgnoreIntermediate(), true);
145 EXPECT_EQ(dd1.isIgnoreMassive(), true);
146 EXPECT_EQ(dd1.isIgnoreNeutrino(), false);
147 EXPECT_EQ(dd1.isIgnoreGamma(), false);
148 EXPECT_EQ(dd1.isIgnoreBrems(), false);
149
150 // ?nu means accept missing neutrino
151 DecayDescriptor dd2;
152 initok = dd2.init(std::string{"B0:candidates -> K+:loose pi-:loose ?nu"});
153 EXPECT_EQ(initok, true);
154 EXPECT_EQ(dd2.isIgnoreRadiatedPhotons(), true);
155 EXPECT_EQ(dd2.isIgnoreIntermediate(), true);
156 EXPECT_EQ(dd2.isIgnoreMassive(), false);
157 EXPECT_EQ(dd2.isIgnoreNeutrino(), true);
158 EXPECT_EQ(dd2.isIgnoreGamma(), false);
159 EXPECT_EQ(dd2.isIgnoreBrems(), false);
160
161 // !nu does not change anything. It is reserved for future updates.
162 DecayDescriptor dd3;
163 initok = dd3.init(std::string{"B0:candidates -> K+:loose pi-:loose !nu"});
164 EXPECT_EQ(initok, true);
165 EXPECT_EQ(dd3.isIgnoreRadiatedPhotons(), true);
166 EXPECT_EQ(dd3.isIgnoreIntermediate(), true);
167 EXPECT_EQ(dd3.isIgnoreMassive(), false);
168 EXPECT_EQ(dd3.isIgnoreNeutrino(), false);
169 EXPECT_EQ(dd3.isIgnoreGamma(), false);
170 EXPECT_EQ(dd3.isIgnoreBrems(), false);
171
172 // ?gamma means ignore missing gamma
173 DecayDescriptor dd4;
174 initok = dd4.init(std::string{"B0:candidates -> K+:loose pi-:loose ?gamma"});
175 EXPECT_EQ(initok, true);
176 EXPECT_EQ(dd4.isIgnoreRadiatedPhotons(), true);
177 EXPECT_EQ(dd4.isIgnoreIntermediate(), true);
178 EXPECT_EQ(dd4.isIgnoreMassive(), false);
179 EXPECT_EQ(dd4.isIgnoreNeutrino(), false);
180 EXPECT_EQ(dd4.isIgnoreGamma(), true);
181 EXPECT_EQ(dd4.isIgnoreBrems(), false);
182
183 // !gamma does not change anything. It is reserved for future updates.
184 DecayDescriptor dd5;
185 initok = dd5.init(std::string{"B0:candidates -> K+:loose pi-:loose !gamma"});
186 EXPECT_EQ(initok, true);
187 EXPECT_EQ(dd5.isIgnoreRadiatedPhotons(), true);
188 EXPECT_EQ(dd5.isIgnoreIntermediate(), true);
189 EXPECT_EQ(dd5.isIgnoreMassive(), false);
190 EXPECT_EQ(dd5.isIgnoreNeutrino(), false);
191 EXPECT_EQ(dd5.isIgnoreGamma(), false);
192 EXPECT_EQ(dd5.isIgnoreBrems(), false);
193
194 // ... ?nu ?gamma means accept missing massive
195 DecayDescriptor dd6;
196 initok = dd6.init(std::string{"B0:candidates -> e-:loose ... ?nu ?gamma"});
197 EXPECT_EQ(initok, true);
198 EXPECT_EQ(dd6.isIgnoreRadiatedPhotons(), true);
199 EXPECT_EQ(dd6.isIgnoreIntermediate(), true);
200 EXPECT_EQ(dd6.isIgnoreMassive(), true);
201 EXPECT_EQ(dd6.isIgnoreNeutrino(), true);
202 EXPECT_EQ(dd6.isIgnoreGamma(), true);
203 EXPECT_EQ(dd6.isIgnoreBrems(), false);
204
205 // ?addbrems means ignore photon added by Brems-correction tools (modularAnalysis.correctBrems / modularAnalysis.correctBremsBelle)
206 DecayDescriptor dd7;
207 initok = dd7.init(std::string{"B0:candidates -> K+:loose pi-:loose ?addbrems"});
208 EXPECT_EQ(initok, true);
209 EXPECT_EQ(dd7.isIgnoreRadiatedPhotons(), true);
210 EXPECT_EQ(dd7.isIgnoreIntermediate(), true);
211 EXPECT_EQ(dd7.isIgnoreMassive(), false);
212 EXPECT_EQ(dd7.isIgnoreNeutrino(), false);
213 EXPECT_EQ(dd7.isIgnoreGamma(), false);
214 EXPECT_EQ(dd7.isIgnoreBrems(), true);
215
216 }
217
218 TEST(DecayDescriptorTest, UnspecifiedParticleGrammar)
219 {
220 // @ means unspecified particle, for example @Xsd -> K+ pi-
221 DecayDescriptor dd1;
222 bool initok = dd1.init(std::string{"@Xsd:candidates -> K+:loose pi-:loose"});
223 EXPECT_EQ(initok, true);
224 ASSERT_NE(dd1.getMother(), nullptr);
225 EXPECT_EQ(dd1.getMother()->getName(), "Xsd");
226 EXPECT_EQ(dd1.getMother()->isUnspecified(), true);
227 EXPECT_EQ(dd1.getMother()->isSelected(), false);
228
229 // Both selectors, @ and ^, can be used at the same time
230 DecayDescriptor dd2;
231 initok = dd2.init(std::string{"^@Xsd:candidates -> K+:loose pi-:loose"});
232 EXPECT_EQ(initok, true);
233 EXPECT_EQ(dd2.getMother()->getName(), "Xsd");
234 EXPECT_EQ(dd2.getMother()->isUnspecified(), true);
235 EXPECT_EQ(dd2.getMother()->isSelected(), true);
236
237 DecayDescriptor dd3;
238 initok = dd3.init(std::string{"@^Xsd:candidates -> K+:loose pi-:loose"});
239 EXPECT_EQ(initok, true);
240 EXPECT_EQ(dd3.getMother()->getName(), "Xsd");
241 EXPECT_EQ(dd3.getMother()->isUnspecified(), true);
242 EXPECT_EQ(dd3.getMother()->isSelected(), true);
243
244 // @ can be attached to a daughter
245 DecayDescriptor dd4;
246 initok = dd4.init(std::string{"B0:Xsdee -> @Xsd e+:loose e-:loose"});
247 EXPECT_EQ(initok, true);
248 ASSERT_NE(dd4.getMother(), nullptr);
249 EXPECT_EQ(dd4.getMother()->isUnspecified(), false);
250 EXPECT_EQ(dd4.getMother()->isSelected(), false);
251 EXPECT_EQ(dd4.getDaughter(0)->getMother()->getName(), "Xsd");
252 EXPECT_EQ(dd4.getDaughter(0)->getMother()->isUnspecified(), true);
253 EXPECT_EQ(dd4.getDaughter(0)->getMother()->isSelected(), false);
254
255 // Both selectors, @ and ^, can be used at the same time
256 DecayDescriptor dd5;
257 initok = dd5.init(std::string{"B0:Xsdee -> ^@Xsd e+:loose e-:loose"});
258 EXPECT_EQ(initok, true);
259 EXPECT_EQ(dd5.getDaughter(0)->getMother()->getName(), "Xsd");
260 EXPECT_EQ(dd5.getDaughter(0)->getMother()->isUnspecified(), true);
261 EXPECT_EQ(dd5.getDaughter(0)->getMother()->isSelected(), true);
262
263 DecayDescriptor dd6;
264 initok = dd6.init(std::string{"B0:Xsdee -> @^Xsd e+:loose e-:loose"});
265 EXPECT_EQ(initok, true);
266 EXPECT_EQ(dd6.getDaughter(0)->getMother()->getName(), "Xsd");
267 EXPECT_EQ(dd6.getDaughter(0)->getMother()->isUnspecified(), true);
268 EXPECT_EQ(dd6.getDaughter(0)->getMother()->isSelected(), true);
269
270 }
271
272 TEST(DecayDescriptorTest, GrammarWithNestedDecay)
273 {
274 // ... means accept missing massive
275 DecayDescriptor dd1;
276 bool initok = dd1.init(std::string{"B0:candidates =direct=> [D-:pi =norad=> pi-:loose ... ?gamma] e+:loose ?nu ?addbrems"});
277 EXPECT_EQ(initok, true);
278 EXPECT_EQ(dd1.isIgnoreRadiatedPhotons(), true);
279 EXPECT_EQ(dd1.isIgnoreIntermediate(), false);
280 EXPECT_EQ(dd1.isIgnoreMassive(), false);
281 EXPECT_EQ(dd1.isIgnoreNeutrino(), true);
282 EXPECT_EQ(dd1.isIgnoreGamma(), false);
283 EXPECT_EQ(dd1.isIgnoreBrems(), true);
284
285 const DecayDescriptor* dd1_D = dd1.getDaughter(0);
286 EXPECT_EQ(dd1_D->getMother()->getName(), "D-");
287 EXPECT_EQ(dd1_D->isIgnoreRadiatedPhotons(), false);
288 EXPECT_EQ(dd1_D->isIgnoreIntermediate(), true);
289 EXPECT_EQ(dd1_D->isIgnoreMassive(), true);
290 EXPECT_EQ(dd1_D->isIgnoreNeutrino(), false);
291 EXPECT_EQ(dd1_D->isIgnoreGamma(), true);
292 EXPECT_EQ(dd1_D->isIgnoreBrems(), false);
293
294 }
295
296
297 TEST(DecayDescriptorTest, SelectionParticles)
298 {
299 DecayDescriptor dd1;
300 bool initok = dd1.init(std::string{"B0:B2Dzpipi -> [D0 -> ^K+:loose pi-:loose] pi+:loose pi-:loose"});
301 EXPECT_EQ(initok, true);
302 std::vector<std::string> names = dd1.getSelectionNames();
303 std::vector<int> pdgs = dd1.getSelectionPDGCodes();
304 ASSERT_EQ(names.size(), 1);
305 EXPECT_EQ(names[0], "B0_D0_K");
306 ASSERT_EQ(pdgs.size(), 1);
307 EXPECT_EQ(pdgs[0], 321);
308
309 // add another selection particle to an already existing decay descriptor
310 // not sure exactly who is using this feature, but might as well test it.
311 initok = dd1.init(std::string{"B0:B2Dzpipi -> [D0 -> K+:loose ^pi-:loose] pi+:loose pi-:loose"});
312 EXPECT_EQ(initok, true);
313 names = dd1.getSelectionNames();
314 pdgs = dd1.getSelectionPDGCodes();
315 ASSERT_EQ(names.size(), 2);
316 EXPECT_EQ(names[0], "B0_D0_K");
317 EXPECT_EQ(names[1], "B0_D0_pi");
318 ASSERT_EQ(pdgs.size(), 2);
319 EXPECT_EQ(pdgs[0], 321);
320 EXPECT_EQ(pdgs[1], -211);
321
322 // more complex decay string with multiple particles of the same type
323 DecayDescriptor dd2;
324 initok = dd2.init(std::string{"vpho:complex -> [D0 -> ^K+:loose pi-:loose] ^e+:loose ^e-:loose ^gamma:loose"});
325 EXPECT_EQ(initok, true);
326 names = dd2.getSelectionNames();
327 pdgs = dd2.getSelectionPDGCodes();
328 ASSERT_EQ(names.size(), 4);
329 EXPECT_EQ(names[0], "vpho_D0_K");
330 EXPECT_EQ(names[1], "vpho_e0");
331 EXPECT_EQ(names[2], "vpho_e1");
332 EXPECT_EQ(names[3], "vpho_gamma");
333 ASSERT_EQ(pdgs.size(), 4);
334 EXPECT_EQ(pdgs[0], 321);
335 EXPECT_EQ(pdgs[1], -11);
336 EXPECT_EQ(pdgs[2], 11);
337 EXPECT_EQ(pdgs[3], 22);
338 }
339
340 TEST(DecayDescriptorTest, MisIDandDecayInFlightGrammar)
341 {
342 // MisID is ignored for a daughter which has (misID) in the head
343 DecayDescriptor dd1;
344 bool initok = dd1.init(std::string{"B0:sig -> (misID)K+:loose pi-:loose"});
345 EXPECT_EQ(initok, true);
346 ASSERT_NE(dd1.getMother(), nullptr);
347 EXPECT_EQ(dd1.getMother()->getName(), "B0");
348 EXPECT_EQ(dd1.getMother()->isIgnoreMisID(), false);
349 EXPECT_EQ(dd1.getMother()->isIgnoreDecayInFlight(), false);
350 ASSERT_NE(dd1.getDaughter(0), nullptr);
351 EXPECT_EQ(dd1.getDaughter(0)->getMother()->getName(), "K+");
352 EXPECT_EQ(dd1.getDaughter(0)->getMother()->isIgnoreMisID(), true);
353 EXPECT_EQ(dd1.getDaughter(0)->getMother()->isIgnoreDecayInFlight(), false);
354 ASSERT_NE(dd1.getDaughter(1), nullptr);
355 EXPECT_EQ(dd1.getDaughter(1)->getMother()->getName(), "pi-");
356 EXPECT_EQ(dd1.getDaughter(1)->getMother()->isIgnoreMisID(), false);//
357 EXPECT_EQ(dd1.getDaughter(1)->getMother()->isIgnoreDecayInFlight(), false);
358
359 DecayDescriptor dd2;
360 initok = dd2.init(std::string{"B0:sig -> K+:loose (misID)pi-:loose"});
361 EXPECT_EQ(initok, true);
362 ASSERT_NE(dd2.getDaughter(0), nullptr);
363 EXPECT_EQ(dd2.getDaughter(0)->getMother()->getName(), "K+");
364 EXPECT_EQ(dd2.getDaughter(0)->getMother()->isIgnoreMisID(), false);//
365 EXPECT_EQ(dd2.getDaughter(0)->getMother()->isIgnoreDecayInFlight(), false);
366 ASSERT_NE(dd2.getDaughter(1), nullptr);
367 EXPECT_EQ(dd2.getDaughter(1)->getMother()->getName(), "pi-");
368 EXPECT_EQ(dd2.getDaughter(1)->getMother()->isIgnoreMisID(), true);
369 EXPECT_EQ(dd2.getDaughter(1)->getMother()->isIgnoreDecayInFlight(), false);
370
371 DecayDescriptor dd3;
372 initok = dd3.init(std::string{"B0:sig -> (misID)K+:loose (misID)pi-:loose"});
373 EXPECT_EQ(initok, true);
374 ASSERT_NE(dd3.getDaughter(0), nullptr);
375 EXPECT_EQ(dd3.getDaughter(0)->getMother()->getName(), "K+");
376 EXPECT_EQ(dd3.getDaughter(0)->getMother()->isIgnoreMisID(), true);
377 EXPECT_EQ(dd3.getDaughter(0)->getMother()->isIgnoreDecayInFlight(), false);
378 ASSERT_NE(dd3.getDaughter(1), nullptr);
379 EXPECT_EQ(dd3.getDaughter(1)->getMother()->getName(), "pi-");
380 EXPECT_EQ(dd3.getDaughter(1)->getMother()->isIgnoreMisID(), true);
381 EXPECT_EQ(dd3.getDaughter(1)->getMother()->isIgnoreDecayInFlight(), false);
382
383 // DecayInFlight is ignored for a daughter which has (decay) in the head
384 DecayDescriptor dd4;
385 initok = dd4.init(std::string{"B0:sig -> (decay)K+:loose pi-:loose"});
386 EXPECT_EQ(initok, true);
387 ASSERT_NE(dd4.getDaughter(0), nullptr);
388 EXPECT_EQ(dd4.getDaughter(0)->getMother()->getName(), "K+");
389 EXPECT_EQ(dd4.getDaughter(0)->getMother()->isIgnoreMisID(), false);
390 EXPECT_EQ(dd4.getDaughter(0)->getMother()->isIgnoreDecayInFlight(), true);
391 ASSERT_NE(dd4.getDaughter(1), nullptr);
392 EXPECT_EQ(dd4.getDaughter(1)->getMother()->getName(), "pi-");
393 EXPECT_EQ(dd4.getDaughter(1)->getMother()->isIgnoreMisID(), false);
394 EXPECT_EQ(dd4.getDaughter(1)->getMother()->isIgnoreDecayInFlight(), false);//
395
396 DecayDescriptor dd5;
397 initok = dd5.init(std::string{"B0:sig -> K+:loose (decay)pi-:loose"});
398 EXPECT_EQ(initok, true);
399 ASSERT_NE(dd5.getDaughter(0), nullptr);
400 EXPECT_EQ(dd5.getDaughter(0)->getMother()->getName(), "K+");
401 EXPECT_EQ(dd5.getDaughter(0)->getMother()->isIgnoreMisID(), false);
402 EXPECT_EQ(dd5.getDaughter(0)->getMother()->isIgnoreDecayInFlight(), false);//
403 ASSERT_NE(dd5.getDaughter(1), nullptr);
404 EXPECT_EQ(dd5.getDaughter(1)->getMother()->getName(), "pi-");
405 EXPECT_EQ(dd5.getDaughter(1)->getMother()->isIgnoreMisID(), false);
406 EXPECT_EQ(dd5.getDaughter(1)->getMother()->isIgnoreDecayInFlight(), true);
407
408 DecayDescriptor dd6;
409 initok = dd6.init(std::string{"B0:sig -> (decay)K+:loose (decay)pi-:loose"});
410 EXPECT_EQ(initok, true);
411 ASSERT_NE(dd6.getDaughter(0), nullptr);
412 EXPECT_EQ(dd6.getDaughter(0)->getMother()->getName(), "K+");
413 EXPECT_EQ(dd6.getDaughter(0)->getMother()->isIgnoreMisID(), false);
414 EXPECT_EQ(dd6.getDaughter(0)->getMother()->isIgnoreDecayInFlight(), true);
415 ASSERT_NE(dd6.getDaughter(1), nullptr);
416 EXPECT_EQ(dd6.getDaughter(1)->getMother()->getName(), "pi-");
417 EXPECT_EQ(dd6.getDaughter(1)->getMother()->isIgnoreMisID(), false);
418 EXPECT_EQ(dd6.getDaughter(1)->getMother()->isIgnoreDecayInFlight(), true);
419
420 // @, ^, (misID), and (decay) can be used at the same time
421 DecayDescriptor dd7;
422 initok = dd7.init(std::string{"B0:sig -> (misID)(decay)K+:loose (decay)(misID)pi-:loose"});
423 EXPECT_EQ(initok, true);
424 ASSERT_NE(dd7.getDaughter(0), nullptr);
425 EXPECT_EQ(dd7.getDaughter(0)->getMother()->getName(), "K+");
426 EXPECT_EQ(dd7.getDaughter(0)->getMother()->isSelected(), false);
427 EXPECT_EQ(dd7.getDaughter(0)->getMother()->isUnspecified(), false);
428 EXPECT_EQ(dd7.getDaughter(0)->getMother()->isIgnoreMisID(), true);
429 EXPECT_EQ(dd7.getDaughter(0)->getMother()->isIgnoreDecayInFlight(), true);
430 ASSERT_NE(dd7.getDaughter(1), nullptr);
431 EXPECT_EQ(dd7.getDaughter(1)->getMother()->getName(), "pi-");
432 EXPECT_EQ(dd7.getDaughter(1)->getMother()->isSelected(), false);
433 EXPECT_EQ(dd7.getDaughter(1)->getMother()->isUnspecified(), false);
434 EXPECT_EQ(dd7.getDaughter(1)->getMother()->isIgnoreMisID(), true);
435 EXPECT_EQ(dd7.getDaughter(1)->getMother()->isIgnoreDecayInFlight(), true);
436
437 DecayDescriptor dd8;
438 initok = dd8.init(std::string{"B0:sig -> ^(misID)K+:loose (decay)@pi-:loose"});
439 EXPECT_EQ(initok, true);
440 ASSERT_NE(dd8.getDaughter(0), nullptr);
441 EXPECT_EQ(dd8.getDaughter(0)->getMother()->getName(), "K+");
442 EXPECT_EQ(dd8.getDaughter(0)->getMother()->isSelected(), true);
443 EXPECT_EQ(dd8.getDaughter(0)->getMother()->isUnspecified(), false);
444 EXPECT_EQ(dd8.getDaughter(0)->getMother()->isIgnoreMisID(), true);
445 EXPECT_EQ(dd8.getDaughter(0)->getMother()->isIgnoreDecayInFlight(), false);
446 ASSERT_NE(dd8.getDaughter(1), nullptr);
447 EXPECT_EQ(dd8.getDaughter(1)->getMother()->getName(), "pi-");
448 EXPECT_EQ(dd8.getDaughter(1)->getMother()->isSelected(), false);
449 EXPECT_EQ(dd8.getDaughter(1)->getMother()->isUnspecified(), true);
450 EXPECT_EQ(dd8.getDaughter(1)->getMother()->isIgnoreMisID(), false);
451 EXPECT_EQ(dd8.getDaughter(1)->getMother()->isIgnoreDecayInFlight(), true);
452
453 DecayDescriptor dd9;
454 initok = dd9.init(std::string{"B0:sig -> ^@(misID)(decay)K+:loose (decay)@^(misID)pi-:loose"});
455 EXPECT_EQ(initok, true);
456 ASSERT_NE(dd9.getDaughter(0), nullptr);
457 EXPECT_EQ(dd9.getDaughter(0)->getMother()->getName(), "K+");
458 EXPECT_EQ(dd9.getDaughter(0)->getMother()->isSelected(), true);
459 EXPECT_EQ(dd9.getDaughter(0)->getMother()->isUnspecified(), true);
460 EXPECT_EQ(dd9.getDaughter(0)->getMother()->isIgnoreMisID(), true);
461 EXPECT_EQ(dd9.getDaughter(0)->getMother()->isIgnoreDecayInFlight(), true);
462 ASSERT_NE(dd9.getDaughter(1), nullptr);
463 EXPECT_EQ(dd9.getDaughter(1)->getMother()->getName(), "pi-");
464 EXPECT_EQ(dd9.getDaughter(1)->getMother()->isSelected(), true);
465 EXPECT_EQ(dd9.getDaughter(1)->getMother()->isUnspecified(), true);
466 EXPECT_EQ(dd9.getDaughter(1)->getMother()->isIgnoreMisID(), true);
467 EXPECT_EQ(dd9.getDaughter(1)->getMother()->isIgnoreDecayInFlight(), true);
468
469 }
470
471 TEST(DecayDescriptorTest, BadLabelTest)
472 {
473 // use of illegal characters in labels
474 DecayDescriptor dd1;
475 bool initok = dd1.init(std::string{"B0:lab[el -> K+:loose pi-:loose"});
476 EXPECT_EQ(initok, false);
477 EXPECT_EQ(dd1.getMother()->getName(), "");
478 EXPECT_EQ(dd1.getMother()->getLabel(), "");
479
480 DecayDescriptor dd2;
481 initok = dd2.init(std::string{"B0:lab^el -> K+:loose pi-:loose"});
482 EXPECT_EQ(initok, false);
483 EXPECT_EQ(dd2.getMother()->getName(), "");
484 EXPECT_EQ(dd2.getMother()->getLabel(), "");
485
486 DecayDescriptor dd3;
487 initok = dd3.init(std::string{"B0:lab]el -> K+:loose pi-:loose"});
488 EXPECT_EQ(initok, false);
489 EXPECT_EQ(dd3.getMother()->getName(), "");
490 EXPECT_EQ(dd3.getMother()->getLabel(), "");
491
492 DecayDescriptor dd4;
493 initok = dd4.init(std::string{"B0:lab>el -> K+:loose pi-:loose"});
494 EXPECT_EQ(initok, false);
495 EXPECT_EQ(dd4.getMother()->getName(), "");
496 EXPECT_EQ(dd4.getMother()->getLabel(), "");
497
498 DecayDescriptor dd5;
499 initok = dd5.init(std::string{"B0:lab:el -> K+:loose pi-:loose"});
500 EXPECT_EQ(initok, false);
501 EXPECT_EQ(dd5.getMother()->getName(), "");
502 EXPECT_EQ(dd5.getMother()->getLabel(), "");
503 }
504
505 TEST(DecayDescriptorTest, UnicodeTest)
506 {
507 // this is broken with boost 1.72, still need to investigate
508 return;
509 // use of unicode characters in labels
510 const std::string weird = "⨔π⁰=πŸ–ΌπŸ”°";
511 DecayDescriptor dd1;
512 bool initok = dd1.init(std::string{"B0:" + weird + " -> K+:πŸ’©πŸ˜œ pi-:πŸ’―πŸ†πŸ’¦"});
513 ASSERT_EQ(initok, true);
514 EXPECT_EQ(dd1.getMother()->getName(), "B0");
515 EXPECT_EQ(dd1.getMother()->getLabel(), weird);
516 ASSERT_EQ(dd1.getNDaughters(), 2);
517 EXPECT_EQ(dd1.getDaughter(0)->getMother()->getName(), "K+");
518 EXPECT_EQ(dd1.getDaughter(1)->getMother()->getName(), "pi-");
519 EXPECT_EQ(dd1.getDaughter(0)->getMother()->getLabel(), "πŸ’©πŸ˜œ");
520 EXPECT_EQ(dd1.getDaughter(1)->getMother()->getLabel(), "πŸ’―πŸ†πŸ’¦");
521 }
522
523 TEST(DecayDescriptorTest, BadGrammarTest)
524 {
525 DecayDescriptor dd1;
526 bool initok = dd1.init(std::string{"B0:label ---> K+:loose pi-:loose"});
527 EXPECT_EQ(initok, false);
528
529 DecayDescriptor dd2;
530 initok = dd2.init(std::string{"B0:label > K+:loose pi-:loose"});
531 EXPECT_EQ(initok, false);
532
533 DecayDescriptor dd3;
534 initok = dd3.init(std::string{"B0:label -> K+::loose pi-:loose"});
535 EXPECT_EQ(initok, false);
536
537 DecayDescriptor dd4;
538 initok = dd4.init(std::string{"B0:label K+:loose pi-:loose"});
539 EXPECT_EQ(initok, false);
540
541 DecayDescriptor dd5;
542 initok = dd5.init(std::string{"B0:label <- K+:loose pi-:loose"});
543 EXPECT_EQ(initok, false);
544
545 DecayDescriptor dd6;
546 initok = dd6.init(std::string{"B0:label => K+:loose pi-:loose"});
547 EXPECT_EQ(initok, false);
548
549 DecayDescriptor dd7;
550 initok = dd7.init(std::string{"B0:label --> K+:loose pi-:loose"});
551 EXPECT_EQ(initok, false);
552
553 DecayDescriptor dd8;
554 initok = dd8.init(std::string{"B0:label ==> K+:loose pi-:loose"});
555 EXPECT_EQ(initok, false);
556 }
557
558 TEST(DecayDescriptorTest, B2ParticleInterface)
559 {
560 // need datastore for the particles StoreArray
561 DataStore::Instance().setInitializeActive(true);
562 StoreArray<Particle> particles;
563 particles.registerInDataStore();
564 DataStore::Instance().setInitializeActive(false);
565
566 // mock up a composite Belle2::Particle
567 ROOT::Math::PxPyPzEVector zeroes(0, 0, 0, 0);
568 Particle* Kp = particles.appendNew(Particle(zeroes, 321)); // 0
569 Particle* pim1 = particles.appendNew(Particle(zeroes, -211)); // 1
570 Particle* pim2 = particles.appendNew(Particle(zeroes, -211)); // 2
571 Particle* pip = particles.appendNew(Particle(zeroes, 211)); // 3
572 Particle* D0 = particles.appendNew(Particle(zeroes, 421)); // 4
573 D0->appendDaughter(0);
574 D0->appendDaughter(1);
575 Particle* B0 = particles.appendNew(Particle(zeroes, 511)); // 5
576 B0->appendDaughter(4);
577 B0->appendDaughter(3);
578 B0->appendDaughter(2);
579
580 // ---
581 DecayDescriptor dd;
582 bool initok = dd.init(std::string{"B0:B2Dzpipi -> [D0 -> K+:loose ^pi-:loose] ^pi+:loose pi-:loose"});
583 ASSERT_EQ(initok, true);
584
585 std::vector<const Particle*> selectionparticles = dd.getSelectionParticles(B0);
586 EXPECT_EQ(selectionparticles.size(), 2);
587 EXPECT_EQ(selectionparticles[0], pim1);
588 EXPECT_EQ(selectionparticles[1], pip);
589
590 EXPECT_B2ERROR(dd.getSelectionParticles(D0));
591
592 EXPECT_B2WARNING(dd.getSelectionParticles(pip));
593 EXPECT_B2WARNING(dd.getSelectionParticles(Kp));
594 EXPECT_B2WARNING(dd.getSelectionParticles(pim1));
595 EXPECT_B2WARNING(dd.getSelectionParticles(pim2));
596
597 EXPECT_EQ(dd.getSelectionParticles(D0).size(), 0);
598
599 DataStore::Instance().reset();
600 }
601
602 TEST(DecayDescriptorTest, HierarchyDefinitionTest)
603 {
604 DecayDescriptor dd;
605 bool initok = dd.init(std::string{"B+ -> [ D+ -> ^K+ pi0 ] ^pi0"});
606 EXPECT_EQ(initok, true);
607
608 auto selected_hierarchies = dd.getHierarchyOfSelected();
609
610 std::vector<std::vector<std::pair<int, std::string>>> expected_hierarchies;
611 std::vector<std::pair<int, std::string>> K_path;
612 std::vector<std::pair<int, std::string>> pi0_path;
613
614 K_path.emplace_back(0, std::string("B"));
615 K_path.emplace_back(0, std::string("D"));
616 K_path.emplace_back(0, std::string("K"));
617
618 pi0_path.emplace_back(0, std::string("B"));
619 pi0_path.emplace_back(1, std::string("pi0"));
620
621 EXPECT_NE(expected_hierarchies, selected_hierarchies);
622 expected_hierarchies.push_back(K_path);
623 expected_hierarchies.push_back(pi0_path);
624 EXPECT_EQ(expected_hierarchies, selected_hierarchies);
625 }
626}
Belle2::Const::ParticleType::getPDGCode
int getPDGCode() const
PDG code.
Definition: Const.h:473
Belle2::Const::pi0
static const ParticleType pi0
neutral pion particle
Definition: Const.h:674
Belle2::Const::pion
static const ChargedStable pion
charged pion particle
Definition: Const.h:661
Belle2::Const::kaon
static const ChargedStable kaon
charged kaon particle
Definition: Const.h:662
Belle2::Const::photon
static const ParticleType photon
photon particle
Definition: Const.h:673
Belle2::Const::electron
static const ChargedStable electron
electron particle
Definition: Const.h:659
Belle2::DataStore::Instance
static DataStore & Instance()
Instance of singleton Store.
Definition: DataStore.cc:54
Belle2::DataStore::setInitializeActive
void setInitializeActive(bool active)
Setter for m_initializeActive.
Definition: DataStore.cc:94
Belle2::DataStore::reset
void reset(EDurability durability)
Frees memory occupied by data store items and removes all objects from the map.
Definition: DataStore.cc:86
Belle2::DecayDescriptorParticle::getPDGCode
int getPDGCode() const
Return PDG code.
Definition: DecayDescriptorParticle.h:79
Belle2::DecayDescriptorParticle::isUnspecified
bool isUnspecified() const
Is the particle unspecified?
Definition: DecayDescriptorParticle.h:89
Belle2::DecayDescriptorParticle::getFullName
std::string getFullName() const
returns the full name of the particle full_name = name:label
Definition: DecayDescriptorParticle.h:59
Belle2::DecayDescriptorParticle::isSelected
bool isSelected() const
Is the particle selected in the decay string?
Definition: DecayDescriptorParticle.h:69
Belle2::DecayDescriptorParticle::isIgnoreDecayInFlight
bool isIgnoreDecayInFlight() const
Check if decayInFlight shall be ignored.
Definition: DecayDescriptorParticle.h:99
Belle2::DecayDescriptorParticle::getName
std::string getName() const
evt.pdl name of the particle.
Definition: DecayDescriptorParticle.h:52
Belle2::DecayDescriptorParticle::getLabel
std::string getLabel() const
The label of this particle, "default" returned, when no label set.
Definition: DecayDescriptorParticle.h:74
Belle2::DecayDescriptorParticle::isIgnoreMisID
bool isIgnoreMisID() const
Check if misID shall be ignored.
Definition: DecayDescriptorParticle.h:94
Belle2::DecayDescriptor
The DecayDescriptor stores information about a decay tree or parts of a decay tree.
Definition: DecayDescriptor.h:33
Belle2::DecayDescriptor::isIgnoreBrems
bool isIgnoreBrems() const
Check if added Brems gammas shall be ignored.
Definition: DecayDescriptor.h:174
Belle2::DecayDescriptor::isIgnoreRadiatedPhotons
bool isIgnoreRadiatedPhotons() const
Check if additional radiated photons shall be ignored.
Definition: DecayDescriptor.h:149
Belle2::DecayDescriptor::init
bool init(const std::string &str)
Initialise the DecayDescriptor from given string.
Definition: DecayDescriptor.cc:46
Belle2::DecayDescriptor::getDaughter
const DecayDescriptor * getDaughter(int i) const
return i-th daughter (0 based index).
Definition: DecayDescriptor.h:139
Belle2::DecayDescriptor::isIgnoreNeutrino
bool isIgnoreNeutrino() const
Check if missing neutrinos shall be ignored.
Definition: DecayDescriptor.h:164
Belle2::DecayDescriptor::getSelectionPDGCodes
std::vector< int > getSelectionPDGCodes()
Return list of PDG codes of selected particles.
Definition: DecayDescriptor.cc:393
Belle2::DecayDescriptor::getNDaughters
int getNDaughters() const
return number of direct daughters.
Definition: DecayDescriptor.h:134
Belle2::DecayDescriptor::isIgnoreMassive
bool isIgnoreMassive() const
Check if missing massive final state particles shall be ignored.
Definition: DecayDescriptor.h:159
Belle2::DecayDescriptor::getHierarchyOfSelected
std::vector< std::vector< std::pair< int, std::string > > > getHierarchyOfSelected()
Function to get hierarchy of selected particles and their names (for python use)
Definition: DecayDescriptor.cc:405
Belle2::DecayDescriptor::isIgnoreGamma
bool isIgnoreGamma() const
Check if missing gammas shall be ignored.
Definition: DecayDescriptor.h:169
Belle2::DecayDescriptor::getSelectionNames
std::vector< std::string > getSelectionNames()
Return list of human readable names of selected particles.
Definition: DecayDescriptor.cc:342
Belle2::DecayDescriptor::getSelectionParticles
std::vector< const Particle * > getSelectionParticles(const Particle *particle)
Get a vector of pointers with selected daughters in the decay tree.
Definition: DecayDescriptor.cc:283
Belle2::DecayDescriptor::isIgnoreIntermediate
bool isIgnoreIntermediate() const
Check if intermediate resonances/particles shall be ignored.
Definition: DecayDescriptor.h:154
Belle2::DecayDescriptor::getMother
const DecayDescriptorParticle * getMother() const
return mother.
Definition: DecayDescriptor.h:129
Belle2::Particle
Class to store reconstructed particles.
Definition: Particle.h:75
Belle2::Particle::appendDaughter
void appendDaughter(const Particle *daughter, const bool updateType=true, const int daughterProperty=c_Ordinary)
Appends index of daughter to daughters index array.
Definition: Particle.cc:676
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition: StoreArray.h:113
Belle2
Abstract base class for different kinds of events.
Definition: ClusterUtils.h:24