Belle II Software development
roe_variables.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#include <gtest/gtest.h>
9#include "utilities/TestParticleFactory.h"
10
11#include <analysis/VariableManager/Manager.h>
12#include <analysis/dataobjects/Particle.h>
13#include <analysis/dataobjects/ParticleList.h>
14#include <analysis/dataobjects/RestOfEvent.h>
15#include <analysis/utility/PCmsLabTransform.h>
16
17#include <mdst/dataobjects/Track.h>
18#include <mdst/dataobjects/ECLCluster.h>
19#include <mdst/dataobjects/KLMCluster.h>
20
21#include <framework/datastore/StoreArray.h>
22
23using namespace std;
24using namespace Belle2;
25using namespace Belle2::Variable;
26using namespace ROOT::Math;
27
28namespace {
29 class ROEVariablesTest : public ::testing::Test {
30 protected:
32 void SetUp() override
33 {
34
35 StoreObjPtr<ParticleList> pi0ParticleList("pi0:vartest");
36 StoreObjPtr<ParticleList> b0ParticleList("B0:vartest");
37 DataStore::Instance().setInitializeActive(true);
38 pi0ParticleList.registerInDataStore(DataStore::c_DontWriteOut);
39 b0ParticleList.registerInDataStore(DataStore::c_DontWriteOut);
40 StoreArray<ECLCluster> myECLClusters;
41 StoreArray<KLMCluster> myKLMClusters;
42 StoreArray<TrackFitResult> myTFRs;
43 StoreArray<Track> myTracks;
44 StoreArray<Particle> myParticles;
45 StoreArray<RestOfEvent> myROEs;
46 StoreObjPtr<RestOfEvent> roeobjptr;
47 StoreArray<PIDLikelihood> myPIDLikelihoods;
48 myECLClusters.registerInDataStore();
49 myKLMClusters.registerInDataStore();
50 myTFRs.registerInDataStore();
51 myTracks.registerInDataStore();
52 myParticles.registerInDataStore();
53 myROEs.registerInDataStore();
54 myPIDLikelihoods.registerInDataStore();
55 myParticles.registerRelationTo(myROEs);
56 myTracks.registerRelationTo(myPIDLikelihoods);
57 roeobjptr.registerInDataStore("RestOfEvent", DataStore::c_DontWriteOut);
58 DataStore::Instance().setInitializeActive(false);
59
60 pi0ParticleList.create();
61 pi0ParticleList->initialize(111, "pi0:vartest");
62 b0ParticleList.create();
63 b0ParticleList->initialize(521, "B0:vartest");
64
65 PCmsLabTransform T;
66
67 TestUtilities::TestParticleFactory factory;
68 ROOT::Math::XYZVector ipposition(0, 0, 0);
69 double halfEcms = T.getCMSEnergy() / 2;
70
71 PxPyPzEVector e_momentum(0., 0, halfEcms / 2, halfEcms / 2);
72 e_momentum = T.rotateCmsToLab() * e_momentum;
73 PxPyPzEVector p_momentum(0., 0, -halfEcms / 2, halfEcms / 2);
74 p_momentum = T.rotateCmsToLab() * p_momentum;
75
76 PxPyPzEVector b0_momentum(0, 0, 0, halfEcms);
77 b0_momentum = T.rotateCmsToLab() * b0_momentum;
78 factory.produceParticle(string("^B0 -> e- e+"), b0_momentum, ipposition);
79
80 myParticles[0]->set4Vector(e_momentum);
81 myParticles[1]->set4Vector(p_momentum);
82
83 myParticles[0]->print(); // e-
84 PxPyPzEVector fsp1_momentum(0., 0, halfEcms / 4, halfEcms / 4);
85 fsp1_momentum = T.rotateCmsToLab() * fsp1_momentum;
86 PxPyPzEVector fsp2_momentum(0., 0, -halfEcms / 4, halfEcms / 4);
87 fsp2_momentum = T.rotateCmsToLab() * fsp2_momentum;
88 PxPyPzEVector kl_momentum(0., 0, 0.1, 0.5);
89 kl_momentum = T.rotateCmsToLab() * fsp2_momentum;
90 factory.produceParticle(string("^B0 -> [pi0 -> gamma gamma] [K_S0 -> pi+ pi-]"), b0_momentum, ipposition);
91 KLMCluster myROEKLM;
92 KLMCluster* savedROEKLM = myKLMClusters.appendNew(myROEKLM);
93 Particle* roeKLMParticle = myParticles.appendNew(savedROEKLM);
94
95 // Set momentum of daughters
96 myParticles[3]->set4Vector(fsp1_momentum); // gamma
97 myParticles[4]->set4Vector(fsp2_momentum); // gamma
98 myECLClusters[0]->setEnergy(fsp1_momentum.E()); // gamma
99 myECLClusters[1]->setEnergy(fsp2_momentum.E()); // gamma
100 myParticles[6]->set4Vector(fsp1_momentum); // pi+
101 myParticles[7]->set4Vector(fsp2_momentum); // pi-
102 myParticles[3]->print(); // gamma
103 myParticles[4]->print(); // gamma
104 myParticles[7]->set4Vector(kl_momentum); // K_L0
105 myParticles[7]->print(); // K_L0
106 // Create ROE
107 RestOfEvent roe;
108 vector<const Particle*> roeParticlesToAdd;
109 // Add particles to the ROE
110 roeParticlesToAdd.push_back(myParticles[3]);
111 roeParticlesToAdd.push_back(myParticles[4]);
112 roeParticlesToAdd.push_back(myParticles[6]);
113 roeParticlesToAdd.push_back(myParticles[7]);
114 roeParticlesToAdd.push_back(roeKLMParticle);
115 roe.addParticles(roeParticlesToAdd);
116 RestOfEvent* savedROE = myROEs.appendNew(roe);
117 // Add relation ROE - particle (first B)
118 myParticles[2]->addRelationTo(savedROE); // B0
119 savedROE->print();
120 savedROE->initializeMask("my_mask", "test");
121 std::shared_ptr<Variable::Cut> chargedSelection = std::shared_ptr<Variable::Cut>
122 (Variable::Cut::compile("charge > 0")); // - exclude pi
123 std::shared_ptr<Variable::Cut> photonSelection = std::shared_ptr<Variable::Cut>
124 (Variable::Cut::compile("p > 1.5")); // - exclude gamma
125 std::shared_ptr<Variable::Cut> klSelection = std::shared_ptr<Variable::Cut>
126 (Variable::Cut::compile("E < 0")); // - exclude Klong
127 // Add mask, which should have 1 gamma, 1 pi+, 0 K_L0
128 savedROE->updateMaskWithCuts("my_mask", chargedSelection, photonSelection, klSelection);
129 savedROE->print("my_mask");
130 // Add pi0 from ROE to particle list
131 pi0ParticleList->addParticle(5, 111, Particle::c_Unflavored);
132 b0ParticleList->addParticle(2, 521, Particle::c_Unflavored);
133 }
134
136 void TearDown() override
137 {
138 DataStore::Instance().reset();
139 }
140 };
141
142 /*
143 * Test ROE particle composition variables
144 */
145 TEST_F(ROEVariablesTest, ROEParticleCompositionVariables)
146 {
147 StoreArray<Particle> myParticles{};
148 auto part = myParticles[2]; // B0
149 auto* var = Manager::Instance().getVariable("nROE_Charged()");
150 ASSERT_NE(var, nullptr);
151 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 2);
152
153 var = Manager::Instance().getVariable("nROE_Charged(my_mask)");
154 ASSERT_NE(var, nullptr);
155 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
156
157 var = Manager::Instance().getVariable("nROE_Charged(all)");
158 ASSERT_NE(var, nullptr);
159 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 2);
160
161 var = Manager::Instance().getVariable("nROE_Charged(my_mask, 13)");
162 ASSERT_NE(var, nullptr);
163 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 0);
164
165 var = Manager::Instance().getVariable("nROE_Charged(all, 13)");
166 ASSERT_NE(var, nullptr);
167 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 0);
168
169 var = Manager::Instance().getVariable("nROE_Charged(my_mask, 211)");
170 ASSERT_NE(var, nullptr);
171 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
172
173 var = Manager::Instance().getVariable("nROE_Photons()");
174 ASSERT_NE(var, nullptr);
175 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 2);
176
177 var = Manager::Instance().getVariable("nROE_Photons(my_mask)");
178 ASSERT_NE(var, nullptr);
179 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
180
181 var = Manager::Instance().getVariable("nROE_NeutralHadrons()");
182 ASSERT_NE(var, nullptr);
183 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
184
185 var = Manager::Instance().getVariable("nROE_NeutralHadrons(my_mask)");
186 ASSERT_NE(var, nullptr);
187 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 0);
188
189 }
190 /*
191 * Test ROE track/cluster composition variables
192 */
193 TEST_F(ROEVariablesTest, ROETrackClusterCompositionVariables)
194 {
195 StoreArray<Particle> myParticles{};
196 auto part = myParticles[2]; // B0
197
198 auto* var = Manager::Instance().getVariable("nROE_Tracks()");
199 ASSERT_NE(var, nullptr);
200 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 2);
201
202 var = Manager::Instance().getVariable("nROE_Tracks(my_mask)");
203 ASSERT_NE(var, nullptr);
204 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
205
206 var = Manager::Instance().getVariable("nROE_Tracks(all)");
207 ASSERT_NE(var, nullptr);
208 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 2);
209
210 var = Manager::Instance().getVariable("nROE_ECLClusters()");
211 ASSERT_NE(var, nullptr);
212 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 2);
213
214 var = Manager::Instance().getVariable("nROE_ECLClusters(my_mask)");
215 ASSERT_NE(var, nullptr);
216 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
217
218 var = Manager::Instance().getVariable("nROE_NeutralECLClusters()");
219 ASSERT_NE(var, nullptr);
220 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 2);
221
222 var = Manager::Instance().getVariable("nROE_NeutralECLClusters(my_mask)");
223 ASSERT_NE(var, nullptr);
224 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
225
226 var = Manager::Instance().getVariable("nROE_KLMClusters");
227 ASSERT_NE(var, nullptr);
228 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
229 }
230 /*
231 * Test ROE recoil frame variable
232 */
233 TEST_F(ROEVariablesTest, ROERecoilFrameVariable)
234 {
235 StoreArray<RestOfEvent> myROEs{};
236 StoreArray<Particle> myParticles{};
237 auto part = myParticles[2]; // B0
238 auto partNotROE = myParticles[0]; // electron has no ROE
239
240 auto* var = Manager::Instance().getVariable("useROERecoilFrame(E)");
241 ASSERT_NE(var, nullptr);
242 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), 5.2986979);
243
244 DataStore::StoreEntry& roeobjptr = DataStore::Instance().getStoreEntryMap(DataStore::c_Event).at("RestOfEvent");
245 roeobjptr.object = myROEs[0];
246 roeobjptr.ptr = myROEs[0];
247
248 var = Manager::Instance().getVariable("useROERecoilFrame(E)");
249 ASSERT_NE(var, nullptr);
250 EXPECT_FLOAT_EQ(std::get<double>(var->function(partNotROE)), 2.801749);
251
252 // Clear ptr at the end
253 roeobjptr.object = nullptr;
254 roeobjptr.ptr = nullptr;
255 }
256 /*
257 * Test ROE kinematics variables
258 */
259 TEST_F(ROEVariablesTest, ROEKinematicsVariables)
260 {
261 StoreArray<Particle> myParticles;
262 auto part = myParticles[2]; // B0
263
264 // Tag side 4 vector
265 PxPyPzEVector roe4Vec(0, 0, 0, 0);
266 roe4Vec += myParticles[3]->get4Vector();
267 roe4Vec += myParticles[4]->get4Vector();
268 roe4Vec += myParticles[6]->get4Vector();
269 roe4Vec += myParticles[7]->get4Vector();
270 // Tag side 4 vector in mask
271 PxPyPzEVector mask4Vec(0, 0, 0, 0);
272 mask4Vec += myParticles[3]->get4Vector();
273 mask4Vec += myParticles[6]->get4Vector();
274 // Signal side 4 vector
275 PxPyPzEVector sig4Vec = part->get4Vector();
276
277 PCmsLabTransform T;
278 double E0 = T.getCMSEnergy() / 2;
279 auto roe4VecCMS = T.rotateLabToCms() * roe4Vec;
280 auto mask4VecCMS = T.rotateLabToCms() * mask4Vec;
281 auto sig4VecCMS = T.rotateLabToCms() * sig4Vec;
282
283 auto* var = Manager::Instance().getVariable("roeCharge()");
284 ASSERT_NE(var, nullptr);
285 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), 0.0);
286
287 var = Manager::Instance().getVariable("roeCharge(all)");
288 ASSERT_NE(var, nullptr);
289 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), 0.0);
290
291 var = Manager::Instance().getVariable("roeCharge(my_mask)");
292 ASSERT_NE(var, nullptr);
293 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), 1.0);
294
295 var = Manager::Instance().getVariable("roeEextra()");
296 ASSERT_NE(var, nullptr);
297 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), myParticles[3]->getEnergy() + myParticles[4]->getEnergy());
298
299 var = Manager::Instance().getVariable("roeE()");
300 ASSERT_NE(var, nullptr);
301 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), roe4Vec.E());
302
303 var = Manager::Instance().getVariable("useCMSFrame(roeE())");
304 ASSERT_NE(var, nullptr);
305 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), roe4VecCMS.E());
306
307 var = Manager::Instance().getVariable("roeM()");
308 ASSERT_NE(var, nullptr);
309 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), roe4Vec.mag());
310
311 var = Manager::Instance().getVariable("roeP()");
312 ASSERT_NE(var, nullptr);
313 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), roe4Vec.P());
314
315 var = Manager::Instance().getVariable("useCMSFrame(roeP())");
316 ASSERT_NE(var, nullptr);
317 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), roe4VecCMS.P());
318
319 var = Manager::Instance().getVariable("roePTheta()");
320 ASSERT_NE(var, nullptr);
321 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), roe4Vec.Theta());
322
323 var = Manager::Instance().getVariable("useCMSFrame(roePTheta())");
324 ASSERT_NE(var, nullptr);
325 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), roe4VecCMS.Theta());
326
327 var = Manager::Instance().getVariable("roeDeltae()");
328 ASSERT_NE(var, nullptr);
329 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), roe4VecCMS.E() - E0);
330
331 var = Manager::Instance().getVariable("roeDeltae(my_mask)");
332 ASSERT_NE(var, nullptr);
333 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), mask4VecCMS.E() - E0);
334
335 var = Manager::Instance().getVariable("roeMbc()");
336 ASSERT_NE(var, nullptr);
337 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), TMath::Sqrt(E0 * E0 - roe4VecCMS.P2()));
338
339 var = Manager::Instance().getVariable("roeMbc(my_mask)");
340 ASSERT_NE(var, nullptr);
341 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), TMath::Sqrt(E0 * E0 - mask4VecCMS.P2()));
342
343 var = Manager::Instance().getVariable("weDeltae(my_mask,0)");
344 ASSERT_NE(var, nullptr);
345 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), mask4VecCMS.E() + sig4VecCMS.E() - E0);
346
347 var = Manager::Instance().getVariable("weMbc(my_mask,0)");
348 ASSERT_NE(var, nullptr);
349 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), TMath::Sqrt(E0 * E0 - mask4VecCMS.P2()));
350
351 var = Manager::Instance().getVariable("weMbc(all,0)");
352 ASSERT_NE(var, nullptr);
353 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), TMath::Sqrt(E0 * E0 - roe4VecCMS.P2()));
354
355 PxPyPzEVector miss4VecCMS = - (sig4VecCMS + mask4VecCMS);
356 miss4VecCMS.SetE(2 * E0 - (sig4VecCMS.E() + mask4VecCMS.E()));
357
358 var = Manager::Instance().getVariable("weMissM2(my_mask,0)");
359 ASSERT_NE(var, nullptr);
360 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), miss4VecCMS.mag2());
361
362 var = Manager::Instance().getVariable("weMissP(my_mask,0)");
363 ASSERT_NE(var, nullptr);
364 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), miss4VecCMS.P());
365
366 var = Manager::Instance().getVariable("weMissE(my_mask,0)");
367 ASSERT_NE(var, nullptr);
368 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), miss4VecCMS.E());
369
370 }
371 /*
372 * Test specific kinematic variables
373 */
374 TEST_F(ROEVariablesTest, ROESpecificKinematicVariables)
375 {
376 StoreArray<Particle> myParticles{};
377 auto part = myParticles[2]; // B0
378
379 auto* var = Manager::Instance().getVariable("weCosThetaEll()");
380 ASSERT_NE(var, nullptr);
381 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), -0.99899036);
382
383 var = Manager::Instance().getVariable("weXiZ()");
384 ASSERT_NE(var, nullptr);
385 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), 0.31122509);
386
387 var = Manager::Instance().getVariable("weQ2lnuSimple(my_mask,0)");
388 ASSERT_NE(var, nullptr);
389 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), -1.7763568e-14);
390
391 // FIXME: This value is the same as for weQ2lnuSimple
392 // More complicated test setup is required to pass abs(cos_angle_nu) < 1
393 var = Manager::Instance().getVariable("weQ2lnu(my_mask,0)");
394 ASSERT_NE(var, nullptr);
395 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), -1.7763568e-14);
396 }
397 /*
398 * Test isInROE variables
399 */
400 TEST_F(ROEVariablesTest, IsInROEVariables)
401 {
402 StoreArray<Particle> myParticles{};
403 auto part = myParticles[2]; // B0
404 StoreArray<RestOfEvent> myROEs{};
405
406 DataStore::StoreEntry& roeobjptr = DataStore::Instance().getStoreEntryMap(DataStore::c_Event).at("RestOfEvent");
407 roeobjptr.object = myROEs[0];
408 roeobjptr.ptr = myROEs[0];
409
410 auto partROE1 = myParticles[3]; // gamma from ROE
411 auto partROE2 = myParticles[5]; // pi from ROE
412 auto partROE3 = myParticles[10]; // K_L0 from ROE
413 auto partROEnotFromMask = myParticles[7]; // pi from ROE not from mask
414 partROEnotFromMask->print(); // gamma
415
416 auto partNotROE = myParticles[0]; // e NOT from ROE
417
418 auto* var = Manager::Instance().getVariable("isInRestOfEvent");
419 ASSERT_NE(var, nullptr);
420 EXPECT_EQ(std::get<bool>(var->function(partROE1)), 1);
421
422 var = Manager::Instance().getVariable("isInRestOfEvent");
423 ASSERT_NE(var, nullptr);
424 EXPECT_EQ(std::get<bool>(var->function(partROE2)), 1);
425
426 var = Manager::Instance().getVariable("isInRestOfEvent");
427 ASSERT_NE(var, nullptr);
428 EXPECT_EQ(std::get<bool>(var->function(partROE3)), 1);
429
430 var = Manager::Instance().getVariable("isInRestOfEvent");
431 ASSERT_NE(var, nullptr);
432 EXPECT_EQ(std::get<bool>(var->function(partNotROE)), 0);
433
434 var = Manager::Instance().getVariable("isInRestOfEvent");
435 ASSERT_NE(var, nullptr);
436 EXPECT_EQ(std::get<bool>(var->function(partNotROE)), 0);
437
438 var = Manager::Instance().getVariable("passesROEMask(my_mask)");
439 ASSERT_NE(var, nullptr);
440 EXPECT_FLOAT_EQ(std::get<bool>(var->function(partROE1)), 1);
441
442 var = Manager::Instance().getVariable("passesROEMask(all)");
443 ASSERT_NE(var, nullptr);
444 EXPECT_FLOAT_EQ(std::get<bool>(var->function(partROE1)), 1);
445
446 var = Manager::Instance().getVariable("passesROEMask(all)");
447 ASSERT_NE(var, nullptr);
448 EXPECT_FLOAT_EQ(std::get<bool>(var->function(partNotROE)), 0);
449
450 var = Manager::Instance().getVariable("passesROEMask(my_mask)");
451 ASSERT_NE(var, nullptr);
452 EXPECT_FLOAT_EQ(std::get<bool>(var->function(partROEnotFromMask)), 0);
453
454 var = Manager::Instance().getVariable("nROE_ParticlesInList(pi0:vartest)");
455 ASSERT_NE(var, nullptr);
456 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
457
458 var = Manager::Instance().getVariable("currentROEIsInList(B0:vartest)");
459 ASSERT_NE(var, nullptr);
460 EXPECT_FLOAT_EQ(std::get<bool>(var->function(partROE1)), 1);
461
462 var = Manager::Instance().getVariable("currentROEIsInList(pi0:vartest)");
463 ASSERT_NE(var, nullptr);
464 EXPECT_FLOAT_EQ(std::get<bool>(var->function(partROE1)), 0);
465
466 var = Manager::Instance().getVariable("particleRelatedToCurrentROE(PDG)");
467 ASSERT_NE(var, nullptr);
468 EXPECT_FLOAT_EQ(std::get<double>(var->function(partROE1)), 511.0);
469
470 // Clear ptr at the end
471 roeobjptr.object = nullptr;
472 roeobjptr.ptr = nullptr;
473 }
474}
Belle2::DataStore::c_DontWriteOut
@ c_DontWriteOut
Object/array should be NOT saved by output modules.
Definition: DataStore.h:71
Belle2::DataStore::getStoreEntryMap
StoreEntryMap & getStoreEntryMap(EDurability durability)
Get a reference to the object/array map.
Definition: DataStore.h:325
Belle2::DataStore::c_Event
@ c_Event
Different object in each event, all objects/arrays are invalidated after event() function has been ca...
Definition: DataStore.h:59
Belle2::DataStore::Instance
static DataStore & Instance()
Instance of singleton Store.
Definition: DataStore.cc:53
Belle2::DataStore::setInitializeActive
void setInitializeActive(bool active)
Setter for m_initializeActive.
Definition: DataStore.cc:93
Belle2::DataStore::reset
void reset(EDurability durability)
Frees memory occupied by data store items and removes all objects from the map.
Definition: DataStore.cc:85
Belle2::GeneralCut::compile
static std::unique_ptr< GeneralCut > compile(const std::string &cut)
Creates an instance of a cut and returns a unique_ptr to it, if you need a copy-able object instead y...
Definition: GeneralCut.h:84
Belle2::KLMCluster
KLM cluster data.
Definition: KLMCluster.h:28
Belle2::PCmsLabTransform
Class to hold Lorentz transformations from/to CMS and boost vector.
Definition: PCmsLabTransform.h:30
Belle2::PCmsLabTransform::getCMSEnergy
double getCMSEnergy() const
Returns CMS energy of e+e- (aka.
Definition: PCmsLabTransform.h:50
Belle2::PCmsLabTransform::rotateLabToCms
const ROOT::Math::LorentzRotation rotateLabToCms() const
Returns Lorentz transformation from Lab to CMS.
Definition: PCmsLabTransform.h:67
Belle2::PCmsLabTransform::rotateCmsToLab
const ROOT::Math::LorentzRotation rotateCmsToLab() const
Returns Lorentz transformation from CMS to Lab.
Definition: PCmsLabTransform.h:76
Belle2::Particle
Class to store reconstructed particles.
Definition: Particle.h:76
Belle2::Particle::c_Unflavored
@ c_Unflavored
Is its own antiparticle or we don't know whether it is a particle/antiparticle.
Definition: Particle.h:97
Belle2::RestOfEvent
This is a general purpose class for collecting reconstructed MDST data objects that are not used in r...
Definition: RestOfEvent.h:57
Belle2::RestOfEvent::print
void print(const std::string &maskName=c_defaultMaskName, bool unpackComposite=true) const
Prints the contents of a RestOfEvent object to screen.
Definition: RestOfEvent.cc:386
Belle2::RestOfEvent::initializeMask
void initializeMask(const std::string &name, const std::string &origin="unknown")
Initialize new mask.
Definition: RestOfEvent.cc:129
Belle2::RestOfEvent::updateMaskWithCuts
void updateMaskWithCuts(const std::string &name, const std::shared_ptr< Variable::Cut > &trackCut=nullptr, const std::shared_ptr< Variable::Cut > &eclCut=nullptr, const std::shared_ptr< Variable::Cut > &klmCut=nullptr, bool updateExisting=false)
Update mask with cuts.
Definition: RestOfEvent.cc:186
Belle2::RestOfEvent::addParticles
void addParticles(const std::vector< const Particle * > &particle)
Add StoreArray indices of given Particles to the list of unused particles in the event.
Definition: RestOfEvent.cc:19
Belle2::StoreAccessorBase::registerInDataStore
bool registerInDataStore(DataStore::EStoreFlags storeFlags=DataStore::c_WriteOut)
Register the object/array in the DataStore.
Definition: StoreAccessorBase.h:52
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition: StoreArray.h:113
Belle2::StoreArray::appendNew
T * appendNew()
Construct a new T object at the end of the array.
Definition: StoreArray.h:246
Belle2::StoreArray::registerRelationTo
bool registerRelationTo(const StoreArray< TO > &toArray, DataStore::EDurability durability=DataStore::c_Event, DataStore::EStoreFlags storeFlags=DataStore::c_WriteOut, const std::string &namedRelation="") const
Register a relation to the given StoreArray.
Definition: StoreArray.h:140
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: StoreObjPtr.h:95
Belle2::Variable::Manager::getVariable
const Var * getVariable(std::string name)
Get the variable belonging to the given key.
Definition: Manager.cc:58
Belle2::Variable::Manager::Instance
static Manager & Instance()
get singleton instance.
Definition: Manager.cc:26
TestUtilities::TestParticleFactory
This is a class, which generates DataStore particles, according to the provided decay string e....
Definition: TestParticleFactory.h:27
TestUtilities::TestParticleFactory::produceParticle
const Belle2::Particle * produceParticle(const std::string &decayString, const ROOT::Math::PxPyPzEVector &momentum, const ROOT::Math::XYZVector &vertex)
Main method to produce particles.
Definition: TestParticleFactory.h:41
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17
std
STL namespace.
Belle2::StoreEntry
Wraps a stored array/object, stored under unique (name, durability) key.
Definition: StoreEntry.h:22
Belle2::StoreEntry::ptr
TObject * ptr
The pointer to the returned object, either equal to 'object' or null, depending on whether the object...
Definition: StoreEntry.h:51
Belle2::StoreEntry::object
TObject * object
The pointer to the actual object.
Definition: StoreEntry.h:48