Belle II Software  release-06-02-00
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/variables/SpecificKinematicVariables.h>
13 #include <analysis/variables/Variables.h>
14 #include <analysis/variables/ROEVariables.h>
15 #include <analysis/dataobjects/Particle.h>
16 #include <analysis/dataobjects/ParticleList.h>
17 #include <analysis/utility/PCmsLabTransform.h>
18 
19 #include <mdst/dataobjects/Track.h>
20 #include <mdst/dataobjects/ECLCluster.h>
21 #include <mdst/dataobjects/KLMCluster.h>
22 
23 #include <framework/datastore/StoreArray.h>
24 #include <framework/logging/Logger.h>
25 #include <framework/gearbox/Gearbox.h>
26 #include <framework/utilities/TestHelpers.h>
27 
28 #include <TLorentzVector.h>
29 
30 using namespace std;
31 using namespace Belle2;
32 using namespace Belle2::Variable;
33 
34 namespace {
35  class ROEVariablesTest : public ::testing::Test {
36  protected:
38  void SetUp() override
39  {
40 
41  StoreObjPtr<ParticleList> pi0ParticleList("pi0:vartest");
42  StoreObjPtr<ParticleList> b0ParticleList("B0:vartest");
43  DataStore::Instance().setInitializeActive(true);
44  pi0ParticleList.registerInDataStore(DataStore::c_DontWriteOut);
45  b0ParticleList.registerInDataStore(DataStore::c_DontWriteOut);
46  StoreArray<ECLCluster> myECLClusters;
47  StoreArray<KLMCluster> myKLMClusters;
48  StoreArray<TrackFitResult> myTFRs;
49  StoreArray<Track> myTracks;
50  StoreArray<Particle> myParticles;
51  StoreArray<RestOfEvent> myROEs;
52  StoreObjPtr<RestOfEvent> roeobjptr;
53  StoreArray<PIDLikelihood> myPIDLikelihoods;
54  myECLClusters.registerInDataStore();
55  myKLMClusters.registerInDataStore();
56  myTFRs.registerInDataStore();
57  myTracks.registerInDataStore();
58  myParticles.registerInDataStore();
59  myROEs.registerInDataStore();
60  myPIDLikelihoods.registerInDataStore();
61  myParticles.registerRelationTo(myROEs);
62  myTracks.registerRelationTo(myPIDLikelihoods);
63  roeobjptr.registerInDataStore("RestOfEvent", DataStore::c_DontWriteOut);
64  DataStore::Instance().setInitializeActive(false);
65 
66  pi0ParticleList.create();
67  pi0ParticleList->initialize(111, "pi0:vartest");
68  b0ParticleList.create();
69  b0ParticleList->initialize(521, "B0:vartest");
70 
71  PCmsLabTransform T;
72 
73  TestUtilities::TestParticleFactory factory;
74  TVector3 ipposition(0, 0, 0);
75  double halfEcms = T.getCMSEnergy() / 2;
76 
77  TLorentzVector e_momentum(0., 0, halfEcms / 2, halfEcms / 2);
78  e_momentum = T.rotateCmsToLab() * e_momentum;
79  TLorentzVector p_momentum(0., 0, -halfEcms / 2, halfEcms / 2);
80  p_momentum = T.rotateCmsToLab() * p_momentum;
81 
82  TLorentzVector b0_momentum(0, 0, 0, halfEcms);
83  b0_momentum = T.rotateCmsToLab() * b0_momentum;
84  factory.produceParticle(string("^B0 -> e- e+"), b0_momentum, ipposition);
85 
86  myParticles[0]->set4Vector(e_momentum);
87  myParticles[1]->set4Vector(p_momentum);
88 
89  myParticles[0]->print(); // e-
90  TLorentzVector fsp1_momentum(0., 0, halfEcms / 4, halfEcms / 4);
91  fsp1_momentum = T.rotateCmsToLab() * fsp1_momentum;
92  TLorentzVector fsp2_momentum(0., 0, -halfEcms / 4, halfEcms / 4);
93  fsp2_momentum = T.rotateCmsToLab() * fsp2_momentum;
94  TLorentzVector kl_momentum(0., 0, 0.1, 0.5);
95  kl_momentum = T.rotateCmsToLab() * fsp2_momentum;
96  factory.produceParticle(string("^B0 -> [pi0 -> gamma gamma] [K_S0 -> pi+ pi-]"), b0_momentum, ipposition);
97  KLMCluster myROEKLM;
98  KLMCluster* savedROEKLM = myKLMClusters.appendNew(myROEKLM);
99  Particle* roeKLMParticle = myParticles.appendNew(savedROEKLM);
100 
101  // Set momentum of daughters
102  myParticles[3]->set4Vector(fsp1_momentum); // gamma
103  myParticles[4]->set4Vector(fsp2_momentum); // gamma
104  myECLClusters[0]->setEnergy(fsp1_momentum.E()); // gamma
105  myECLClusters[1]->setEnergy(fsp2_momentum.E()); // gamma
106  myParticles[6]->set4Vector(fsp1_momentum); // pi+
107  myParticles[7]->set4Vector(fsp2_momentum); // pi-
108  myParticles[3]->print(); // gamma
109  myParticles[4]->print(); // gamma
110  myParticles[7]->set4Vector(kl_momentum); // K_L0
111  myParticles[7]->print(); // K_L0
112  // Create ROE
113  RestOfEvent roe;
114  vector<const Particle*> roeParticlesToAdd;
115  // Add particles to the ROE
116  roeParticlesToAdd.push_back(myParticles[3]);
117  roeParticlesToAdd.push_back(myParticles[4]);
118  roeParticlesToAdd.push_back(myParticles[6]);
119  roeParticlesToAdd.push_back(myParticles[7]);
120  roeParticlesToAdd.push_back(roeKLMParticle);
121  roe.addParticles(roeParticlesToAdd);
122  RestOfEvent* savedROE = myROEs.appendNew(roe);
123  // Add relation ROE - particle (first B)
124  myParticles[2]->addRelationTo(savedROE); // B0
125  savedROE->print();
126  savedROE->initializeMask("my_mask", "test");
127  std::shared_ptr<Variable::Cut> chargedSelection = std::shared_ptr<Variable::Cut>
128  (Variable::Cut::compile("charge > 0")); // - exclude pi
129  std::shared_ptr<Variable::Cut> photonSelection = std::shared_ptr<Variable::Cut>
130  (Variable::Cut::compile("p > 1.5")); // - exclude gamma
131  std::shared_ptr<Variable::Cut> klSelection = std::shared_ptr<Variable::Cut>
132  (Variable::Cut::compile("E < 0")); // - exclude Klong
133  // Add mask, which should have 1 gamma, 1 pi+, 0 K_L0
134  savedROE->updateMaskWithCuts("my_mask", chargedSelection, photonSelection, klSelection);
135  savedROE->print("my_mask");
136  // Add pi0 from ROE to particle list
137  pi0ParticleList->addParticle(5, 111, Particle::c_Unflavored);
138  b0ParticleList->addParticle(2, 521, Particle::c_Unflavored);
139  }
140 
142  void TearDown() override
143  {
144  DataStore::Instance().reset();
145  }
146  };
147 
148  /*
149  * Test ROE particle composition variables
150  */
151  TEST_F(ROEVariablesTest, ROEParticleCompositionVariables)
152  {
153  StoreArray<Particle> myParticles{};
154  auto part = myParticles[2]; // B0
155  auto* var = Manager::Instance().getVariable("nROE_Charged()");
156  ASSERT_NE(var, nullptr);
157  EXPECT_FLOAT_EQ(var->function(part), 2.0);
158 
159  var = Manager::Instance().getVariable("nROE_Charged(my_mask)");
160  ASSERT_NE(var, nullptr);
161  EXPECT_FLOAT_EQ(var->function(part), 1.0);
162 
163  var = Manager::Instance().getVariable("nROE_Charged(my_mask, 13)");
164  ASSERT_NE(var, nullptr);
165  EXPECT_FLOAT_EQ(var->function(part), 0.0);
166 
167  var = Manager::Instance().getVariable("nROE_Charged(my_mask, 211)");
168  ASSERT_NE(var, nullptr);
169  EXPECT_FLOAT_EQ(var->function(part), 1.0);
170 
171  var = Manager::Instance().getVariable("nROE_Photons()");
172  ASSERT_NE(var, nullptr);
173  EXPECT_FLOAT_EQ(var->function(part), 2.0);
174 
175  var = Manager::Instance().getVariable("nROE_Photons(my_mask)");
176  ASSERT_NE(var, nullptr);
177  EXPECT_FLOAT_EQ(var->function(part), 1.0);
178 
179  var = Manager::Instance().getVariable("nROE_NeutralHadrons()");
180  ASSERT_NE(var, nullptr);
181  EXPECT_FLOAT_EQ(var->function(part), 1.0);
182 
183  var = Manager::Instance().getVariable("nROE_NeutralHadrons(my_mask)");
184  ASSERT_NE(var, nullptr);
185  EXPECT_FLOAT_EQ(var->function(part), 0.0);
186 
187  }
188  /*
189  * Test ROE track/cluster composition variables
190  */
191  TEST_F(ROEVariablesTest, ROETrackClusterCompositionVariables)
192  {
193  StoreArray<Particle> myParticles{};
194  auto part = myParticles[2]; // B0
195 
196  auto* var = Manager::Instance().getVariable("nROE_Tracks()");
197  ASSERT_NE(var, nullptr);
198  EXPECT_FLOAT_EQ(var->function(part), 2.0);
199 
200  var = Manager::Instance().getVariable("nROE_Tracks(my_mask)");
201  ASSERT_NE(var, nullptr);
202  EXPECT_FLOAT_EQ(var->function(part), 1.0);
203 
204  var = Manager::Instance().getVariable("nROE_ECLClusters()");
205  ASSERT_NE(var, nullptr);
206  EXPECT_FLOAT_EQ(var->function(part), 2.0);
207 
208  var = Manager::Instance().getVariable("nROE_ECLClusters(my_mask)");
209  ASSERT_NE(var, nullptr);
210  EXPECT_FLOAT_EQ(var->function(part), 1.0);
211 
212  var = Manager::Instance().getVariable("nROE_NeutralECLClusters()");
213  ASSERT_NE(var, nullptr);
214  EXPECT_FLOAT_EQ(var->function(part), 2.0);
215 
216  var = Manager::Instance().getVariable("nROE_NeutralECLClusters(my_mask)");
217  ASSERT_NE(var, nullptr);
218  EXPECT_FLOAT_EQ(var->function(part), 1.0);
219 
220  var = Manager::Instance().getVariable("nROE_KLMClusters");
221  ASSERT_NE(var, nullptr);
222  EXPECT_FLOAT_EQ(var->function(part), 1.0);
223  }
224  /*
225  * Test ROE recoil frame variable
226  */
227  TEST_F(ROEVariablesTest, ROERecoilFrameVariable)
228  {
229  StoreArray<RestOfEvent> myROEs{};
230  StoreArray<Particle> myParticles{};
231  auto part = myParticles[2]; // B0
232  auto partNotROE = myParticles[0]; // electron has no ROE
233 
234  auto* var = Manager::Instance().getVariable("useROERecoilFrame(E)");
235  ASSERT_NE(var, nullptr);
236  EXPECT_FLOAT_EQ(var->function(part), 5.2959199);
237 
238  DataStore::StoreEntry& roeobjptr = DataStore::Instance().getStoreEntryMap(DataStore::c_Event).at("RestOfEvent");
239  roeobjptr.object = myROEs[0];
240  roeobjptr.ptr = myROEs[0];
241 
242  var = Manager::Instance().getVariable("useROERecoilFrame(E)");
243  ASSERT_NE(var, nullptr);
244  EXPECT_FLOAT_EQ(var->function(partNotROE), 2.8002837);
245 
246  // Clear ptr at the end
247  roeobjptr.object = nullptr;
248  roeobjptr.ptr = nullptr;
249  }
250  /*
251  * Test ROE kinematics variables
252  */
253  TEST_F(ROEVariablesTest, ROEKinematicsVariables)
254  {
255  StoreArray<Particle> myParticles;
256  auto part = myParticles[2]; // B0
257 
258  // Tag side 4 vector
259  TLorentzVector roe4Vec(0, 0, 0, 0);
260  roe4Vec += myParticles[3]->get4Vector();
261  roe4Vec += myParticles[4]->get4Vector();
262  roe4Vec += myParticles[6]->get4Vector();
263  roe4Vec += myParticles[7]->get4Vector();
264  // Tag side 4 vector in mask
265  TLorentzVector mask4Vec(0, 0, 0, 0);
266  mask4Vec += myParticles[3]->get4Vector();
267  mask4Vec += myParticles[6]->get4Vector();
268  // Signal side 4 vector
269  TLorentzVector sig4Vec = part->get4Vector();
270 
271  PCmsLabTransform T;
272  double E0 = T.getCMSEnergy() / 2;
273  auto roe4VecCMS = T.rotateLabToCms() * roe4Vec;
274  auto mask4VecCMS = T.rotateLabToCms() * mask4Vec;
275  auto sig4VecCMS = T.rotateLabToCms() * sig4Vec;
276 
277  auto* var = Manager::Instance().getVariable("roeCharge()");
278  ASSERT_NE(var, nullptr);
279  EXPECT_FLOAT_EQ(var->function(part), 0.0);
280 
281  var = Manager::Instance().getVariable("roeCharge(my_mask)");
282  ASSERT_NE(var, nullptr);
283  EXPECT_FLOAT_EQ(var->function(part), 1.0);
284 
285  var = Manager::Instance().getVariable("roeEextra()");
286  ASSERT_NE(var, nullptr);
287  EXPECT_FLOAT_EQ(var->function(part), myParticles[3]->getEnergy() + myParticles[4]->getEnergy());
288 
289  var = Manager::Instance().getVariable("roeE()");
290  ASSERT_NE(var, nullptr);
291  EXPECT_FLOAT_EQ(var->function(part), roe4Vec.E());
292 
293  var = Manager::Instance().getVariable("useCMSFrame(roeE())");
294  ASSERT_NE(var, nullptr);
295  EXPECT_FLOAT_EQ(var->function(part), roe4VecCMS.E());
296 
297  var = Manager::Instance().getVariable("roeM()");
298  ASSERT_NE(var, nullptr);
299  EXPECT_FLOAT_EQ(var->function(part), roe4Vec.Mag());
300 
301  var = Manager::Instance().getVariable("roeP()");
302  ASSERT_NE(var, nullptr);
303  EXPECT_FLOAT_EQ(var->function(part), roe4Vec.P());
304 
305  var = Manager::Instance().getVariable("useCMSFrame(roeP())");
306  ASSERT_NE(var, nullptr);
307  EXPECT_FLOAT_EQ(var->function(part), roe4VecCMS.P());
308 
309  var = Manager::Instance().getVariable("roePTheta()");
310  ASSERT_NE(var, nullptr);
311  EXPECT_FLOAT_EQ(var->function(part), roe4Vec.Theta());
312 
313  var = Manager::Instance().getVariable("useCMSFrame(roePTheta())");
314  ASSERT_NE(var, nullptr);
315  EXPECT_FLOAT_EQ(var->function(part), roe4VecCMS.Theta());
316 
317  var = Manager::Instance().getVariable("roeDeltae()");
318  ASSERT_NE(var, nullptr);
319  EXPECT_FLOAT_EQ(var->function(part), roe4VecCMS.E() - E0);
320 
321  var = Manager::Instance().getVariable("roeDeltae(my_mask)");
322  ASSERT_NE(var, nullptr);
323  EXPECT_FLOAT_EQ(var->function(part), mask4VecCMS.E() - E0);
324 
325  var = Manager::Instance().getVariable("roeMbc()");
326  ASSERT_NE(var, nullptr);
327  EXPECT_FLOAT_EQ(var->function(part), TMath::Sqrt(E0 * E0 - roe4VecCMS.Vect().Mag2()));
328 
329  var = Manager::Instance().getVariable("roeMbc(my_mask)");
330  ASSERT_NE(var, nullptr);
331  EXPECT_FLOAT_EQ(var->function(part), TMath::Sqrt(E0 * E0 - mask4VecCMS.Vect().Mag2()));
332 
333  var = Manager::Instance().getVariable("weDeltae(my_mask,0)");
334  ASSERT_NE(var, nullptr);
335  EXPECT_FLOAT_EQ(var->function(part), mask4VecCMS.E() + sig4VecCMS.E() - E0);
336 
337  var = Manager::Instance().getVariable("weMbc(my_mask,0)");
338  ASSERT_NE(var, nullptr);
339  EXPECT_FLOAT_EQ(var->function(part), TMath::Sqrt(E0 * E0 - mask4VecCMS.Vect().Mag2()));
340 
341  TLorentzVector miss4VecCMS(0, 0, 0, 0);
342  miss4VecCMS.SetVect(- (sig4VecCMS.Vect() + mask4VecCMS.Vect()));
343  miss4VecCMS.SetE(2 * E0 - (sig4VecCMS.E() + mask4VecCMS.E()));
344 
345  var = Manager::Instance().getVariable("weMissM2(my_mask,0)");
346  ASSERT_NE(var, nullptr);
347  EXPECT_FLOAT_EQ(var->function(part), miss4VecCMS.Mag2());
348 
349  var = Manager::Instance().getVariable("weMissP(my_mask,0)");
350  ASSERT_NE(var, nullptr);
351  EXPECT_FLOAT_EQ(var->function(part), miss4VecCMS.P());
352 
353  var = Manager::Instance().getVariable("weMissE(my_mask,0)");
354  ASSERT_NE(var, nullptr);
355  EXPECT_FLOAT_EQ(var->function(part), miss4VecCMS.E());
356 
357  }
358  /*
359  * Test specific kinematic variables
360  */
361  TEST_F(ROEVariablesTest, ROESpecificKinematicVariables)
362  {
363  StoreArray<Particle> myParticles{};
364  auto part = myParticles[2]; // B0
365  // Signal side 4 vector
366  TLorentzVector sig4Vec = part->get4Vector();
367 
368  auto* var = Manager::Instance().getVariable("bssMassDifference()");
369  ASSERT_NE(var, nullptr);
370  EXPECT_FLOAT_EQ(var->function(part), sig4Vec.M());
371 
372  var = Manager::Instance().getVariable("weCosThetaEll()");
373  ASSERT_NE(var, nullptr);
374  EXPECT_FLOAT_EQ(var->function(part), -0.99858648);
375 
376  var = Manager::Instance().getVariable("weXiZ()");
377  ASSERT_NE(var, nullptr);
378  EXPECT_FLOAT_EQ(var->function(part), 0.31121328);
379 
380  var = Manager::Instance().getVariable("weQ2lnuSimple(my_mask,0)");
381  ASSERT_NE(var, nullptr);
382  EXPECT_FLOAT_EQ(var->function(part), -2.1852231e-06);
383 
384  // FIXME: This value is the same as for weQ2lnuSimple
385  // More complicated test setup is required to pass abs(cos_angle_nu) < 1
386  var = Manager::Instance().getVariable("weQ2lnu(my_mask,0)");
387  ASSERT_NE(var, nullptr);
388  EXPECT_FLOAT_EQ(var->function(part), -2.1852231e-06);
389  }
390  /*
391  * Test isInROE variables
392  */
393  TEST_F(ROEVariablesTest, IsInROEVariables)
394  {
395  StoreArray<Particle> myParticles{};
396  auto part = myParticles[2]; // B0
397  StoreArray<RestOfEvent> myROEs{};
398 
399  DataStore::StoreEntry& roeobjptr = DataStore::Instance().getStoreEntryMap(DataStore::c_Event).at("RestOfEvent");
400  roeobjptr.object = myROEs[0];
401  roeobjptr.ptr = myROEs[0];
402 
403  auto partROE1 = myParticles[3]; // gamma from ROE
404  auto partROE2 = myParticles[5]; // pi from ROE
405  auto partROE3 = myParticles[10]; // K_L0 from ROE
406  auto partROEnotFromMask = myParticles[7]; // pi from ROE not from mask
407  partROEnotFromMask->print(); // gamma
408 
409  auto partNotROE = myParticles[0]; // e NOT from ROE
410 
411  auto* var = Manager::Instance().getVariable("isInRestOfEvent");
412  ASSERT_NE(var, nullptr);
413  EXPECT_FLOAT_EQ(var->function(partROE1), 1.0);
414 
415  var = Manager::Instance().getVariable("isInRestOfEvent");
416  ASSERT_NE(var, nullptr);
417  EXPECT_FLOAT_EQ(var->function(partROE2), 1.0);
418 
419  var = Manager::Instance().getVariable("isInRestOfEvent");
420  ASSERT_NE(var, nullptr);
421  EXPECT_FLOAT_EQ(var->function(partROE3), 1.0);
422 
423  var = Manager::Instance().getVariable("isInRestOfEvent");
424  ASSERT_NE(var, nullptr);
425  EXPECT_FLOAT_EQ(var->function(partNotROE), 0.0);
426 
427  var = Manager::Instance().getVariable("isInRestOfEvent");
428  ASSERT_NE(var, nullptr);
429  EXPECT_FLOAT_EQ(var->function(partNotROE), 0.0);
430 
431  var = Manager::Instance().getVariable("passesROEMask(my_mask)");
432  ASSERT_NE(var, nullptr);
433  EXPECT_FLOAT_EQ(var->function(partROE1), 1.0);
434 
435  var = Manager::Instance().getVariable("passesROEMask(my_mask)");
436  ASSERT_NE(var, nullptr);
437  EXPECT_FLOAT_EQ(var->function(partROEnotFromMask), 0.0);
438 
439  var = Manager::Instance().getVariable("nROE_ParticlesInList(pi0:vartest)");
440  ASSERT_NE(var, nullptr);
441  EXPECT_FLOAT_EQ(var->function(part), 1.0);
442 
443  var = Manager::Instance().getVariable("currentROEIsInList(B0:vartest)");
444  ASSERT_NE(var, nullptr);
445  EXPECT_FLOAT_EQ(var->function(partROE1), 1.0);
446 
447  var = Manager::Instance().getVariable("currentROEIsInList(pi0:vartest)");
448  ASSERT_NE(var, nullptr);
449  EXPECT_FLOAT_EQ(var->function(partROE1), 0.0);
450 
451  var = Manager::Instance().getVariable("particleRelatedToCurrentROE(PDG)");
452  ASSERT_NE(var, nullptr);
453  EXPECT_FLOAT_EQ(var->function(partROE1), 511.0);
454 
455  // Clear ptr at the end
456  roeobjptr.object = nullptr;
457  roeobjptr.ptr = nullptr;
458  }
459 }
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:27
Belle2::PCmsLabTransform::getCMSEnergy
double getCMSEnergy() const
Returns CMS energy of e+e- (aka.
Definition: PCmsLabTransform.h:47
Belle2::PCmsLabTransform::rotateLabToCms
const TLorentzRotation rotateLabToCms() const
Returns Lorentz transformation from Lab to CMS.
Definition: PCmsLabTransform.h:64
Belle2::PCmsLabTransform::rotateCmsToLab
const TLorentzRotation rotateCmsToLab() const
Returns Lorentz transformation from CMS to Lab.
Definition: PCmsLabTransform.h:74
Belle2::Particle
Class to store reconstructed particles.
Definition: Particle.h:74
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::initializeMask
void initializeMask(const std::string &name, const std::string &origin="unknown")
Initialize new mask.
Definition: RestOfEvent.cc:135
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:180
Belle2::RestOfEvent::print
void print(const std::string &maskName="", bool unpackComposite=true) const
Prints the contents of a RestOfEvent object to screen.
Definition: RestOfEvent.cc:368
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:25
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
TestUtilities::TestParticleFactory
This is a class, which generates DataStore particles, according to the provided decay string e....
Definition: TestParticleFactory.h:29
TestUtilities::TestParticleFactory::produceParticle
const Belle2::Particle * produceParticle(const std::string &decayString, const TLorentzVector &momentum, const TVector3 &vertex)
Main method to produce particles.
Definition: TestParticleFactory.h:43
Belle2::TEST_F
TEST_F(GlobalLabelTest, LargeNumberOfTimeDependentParameters)
Test large number of time-dep params for registration and retrieval.
Definition: globalLabel.cc:72
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17
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 wether the object ...
Definition: StoreEntry.h:51
Belle2::StoreEntry::object
TObject * object
The pointer to the actual object.
Definition: StoreEntry.h:48