8#include <gtest/gtest.h>
9#include "utilities/TestParticleFactory.h"
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>
17#include <mdst/dataobjects/Track.h>
18#include <mdst/dataobjects/ECLCluster.h>
19#include <mdst/dataobjects/KLMCluster.h>
20#include <mdst/dataobjects/PIDLikelihood.h>
22#include <framework/datastore/StoreArray.h>
26using namespace Belle2::Variable;
27using namespace ROOT::Math;
30 class ROEVariablesTest :
public ::testing::Test {
36 StoreObjPtr<ParticleList> pi0ParticleList(
"pi0:vartest");
37 StoreObjPtr<ParticleList> b0ParticleList(
"B0:vartest");
41 StoreArray<ECLCluster> myECLClusters;
42 StoreArray<KLMCluster> myKLMClusters;
43 StoreArray<TrackFitResult> myTFRs;
44 StoreArray<Track> myTracks;
45 StoreArray<Particle> myParticles;
46 StoreArray<RestOfEvent> myROEs;
47 StoreObjPtr<RestOfEvent> roeobjptr;
48 StoreArray<PIDLikelihood> myPIDLikelihoods;
61 pi0ParticleList.create();
62 pi0ParticleList->initialize(111,
"pi0:vartest");
63 b0ParticleList.create();
64 b0ParticleList->initialize(521,
"B0:vartest");
68 TestUtilities::TestParticleFactory factory;
69 ROOT::Math::XYZVector ipposition(0, 0, 0);
72 PxPyPzEVector e_momentum(0., 0, halfEcms / 2, halfEcms / 2);
74 PxPyPzEVector p_momentum(0., 0, -halfEcms / 2, halfEcms / 2);
77 PxPyPzEVector b0_momentum(0, 0, 0, halfEcms);
79 factory.
produceParticle(
string(
"^B0 -> e- e+"), b0_momentum, ipposition);
81 myParticles[0]->set4Vector(e_momentum);
82 myParticles[1]->set4Vector(p_momentum);
84 myParticles[0]->print();
85 PxPyPzEVector fsp1_momentum(0., 0, halfEcms / 4, halfEcms / 4);
87 PxPyPzEVector fsp2_momentum(0., 0, -halfEcms / 4, halfEcms / 4);
89 PxPyPzEVector kl_momentum(0., 0, 0.1, 0.5);
91 factory.
produceParticle(
string(
"^B0 -> [pi0 -> gamma gamma] [K_S0 -> pi+ pi-]"), b0_momentum, ipposition);
93 KLMCluster* savedROEKLM = myKLMClusters.
appendNew(myROEKLM);
94 Particle* roeKLMParticle = myParticles.
appendNew(savedROEKLM);
97 myParticles[3]->set4Vector(fsp1_momentum);
98 myParticles[4]->set4Vector(fsp2_momentum);
99 myECLClusters[0]->setEnergy(fsp1_momentum.E());
100 myECLClusters[1]->setEnergy(fsp2_momentum.E());
101 myParticles[6]->set4Vector(fsp1_momentum);
102 myParticles[7]->set4Vector(fsp2_momentum);
103 myParticles[3]->print();
104 myParticles[4]->print();
105 myParticles[7]->set4Vector(kl_momentum);
106 myParticles[7]->print();
109 vector<const Particle*> roeParticlesToAdd;
111 roeParticlesToAdd.push_back(myParticles[3]);
112 roeParticlesToAdd.push_back(myParticles[4]);
113 roeParticlesToAdd.push_back(myParticles[6]);
114 roeParticlesToAdd.push_back(myParticles[7]);
115 roeParticlesToAdd.push_back(roeKLMParticle);
117 RestOfEvent* savedROE = myROEs.
appendNew(roe);
119 myParticles[2]->addRelationTo(savedROE);
122 std::shared_ptr<Variable::Cut> chargedSelection = std::shared_ptr<Variable::Cut>
124 std::shared_ptr<Variable::Cut> photonSelection = std::shared_ptr<Variable::Cut>
126 std::shared_ptr<Variable::Cut> klSelection = std::shared_ptr<Variable::Cut>
129 savedROE->
updateMaskWithCuts(
"my_mask", chargedSelection, photonSelection, klSelection);
130 savedROE->
print(
"my_mask");
137 void TearDown()
override
146 TEST_F(ROEVariablesTest, ROEParticleCompositionVariables)
149 auto part = myParticles[2];
151 ASSERT_NE(var,
nullptr);
152 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 2);
155 ASSERT_NE(var,
nullptr);
156 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
159 ASSERT_NE(var,
nullptr);
160 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 2);
163 ASSERT_NE(var,
nullptr);
164 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 0);
167 ASSERT_NE(var,
nullptr);
168 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 0);
171 ASSERT_NE(var,
nullptr);
172 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
175 ASSERT_NE(var,
nullptr);
176 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 2);
179 ASSERT_NE(var,
nullptr);
180 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
183 ASSERT_NE(var,
nullptr);
184 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
187 ASSERT_NE(var,
nullptr);
188 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 0);
194 TEST_F(ROEVariablesTest, ROETrackClusterCompositionVariables)
197 auto part = myParticles[2];
200 ASSERT_NE(var,
nullptr);
201 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 2);
204 ASSERT_NE(var,
nullptr);
205 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
208 ASSERT_NE(var,
nullptr);
209 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 2);
212 ASSERT_NE(var,
nullptr);
213 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 2);
216 ASSERT_NE(var,
nullptr);
217 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
220 ASSERT_NE(var,
nullptr);
221 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 2);
224 ASSERT_NE(var,
nullptr);
225 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
228 ASSERT_NE(var,
nullptr);
229 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
234 TEST_F(ROEVariablesTest, ROERecoilFrameVariable)
238 auto part = myParticles[2];
239 auto partNotROE = myParticles[0];
242 ASSERT_NE(var,
nullptr);
243 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), 5.2986979);
246 roeobjptr.
object = myROEs[0];
247 roeobjptr.
ptr = myROEs[0];
250 ASSERT_NE(var,
nullptr);
251 EXPECT_FLOAT_EQ(std::get<double>(var->function(partNotROE)), 2.801749);
254 roeobjptr.
object =
nullptr;
255 roeobjptr.
ptr =
nullptr;
260 TEST_F(ROEVariablesTest, ROEKinematicsVariables)
263 auto part = myParticles[2];
266 PxPyPzEVector roe4Vec(0, 0, 0, 0);
267 roe4Vec += myParticles[3]->get4Vector();
268 roe4Vec += myParticles[4]->get4Vector();
269 roe4Vec += myParticles[6]->get4Vector();
270 roe4Vec += myParticles[7]->get4Vector();
272 PxPyPzEVector mask4Vec(0, 0, 0, 0);
273 mask4Vec += myParticles[3]->get4Vector();
274 mask4Vec += myParticles[6]->get4Vector();
276 PxPyPzEVector sig4Vec = part->get4Vector();
280 auto roe4VecCMS = T.rotateLabToCms() * roe4Vec;
281 auto mask4VecCMS = T.rotateLabToCms() * mask4Vec;
282 auto sig4VecCMS = T.rotateLabToCms() * sig4Vec;
285 ASSERT_NE(var,
nullptr);
286 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), 0.0);
289 ASSERT_NE(var,
nullptr);
290 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), 0.0);
293 ASSERT_NE(var,
nullptr);
294 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), 1.0);
297 ASSERT_NE(var,
nullptr);
298 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), myParticles[3]->getEnergy() + myParticles[4]->getEnergy());
301 ASSERT_NE(var,
nullptr);
302 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), roe4Vec.E());
305 ASSERT_NE(var,
nullptr);
306 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), roe4VecCMS.E());
309 ASSERT_NE(var,
nullptr);
310 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), roe4Vec.mag());
313 ASSERT_NE(var,
nullptr);
314 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), roe4Vec.P());
317 ASSERT_NE(var,
nullptr);
318 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), roe4VecCMS.P());
321 ASSERT_NE(var,
nullptr);
322 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), roe4Vec.Theta());
325 ASSERT_NE(var,
nullptr);
326 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), roe4VecCMS.Theta());
329 ASSERT_NE(var,
nullptr);
330 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), roe4VecCMS.E() - E0);
333 ASSERT_NE(var,
nullptr);
334 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), mask4VecCMS.E() - E0);
337 ASSERT_NE(var,
nullptr);
338 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), TMath::Sqrt(E0 * E0 - roe4VecCMS.P2()));
341 ASSERT_NE(var,
nullptr);
342 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), TMath::Sqrt(E0 * E0 - mask4VecCMS.P2()));
345 ASSERT_NE(var,
nullptr);
346 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), mask4VecCMS.E() + sig4VecCMS.E() - E0);
349 ASSERT_NE(var,
nullptr);
350 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), TMath::Sqrt(E0 * E0 - mask4VecCMS.P2()));
353 ASSERT_NE(var,
nullptr);
354 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), TMath::Sqrt(E0 * E0 - roe4VecCMS.P2()));
356 PxPyPzEVector miss4VecCMS = - (sig4VecCMS + mask4VecCMS);
357 miss4VecCMS.SetE(2 * E0 - (sig4VecCMS.E() + mask4VecCMS.E()));
360 ASSERT_NE(var,
nullptr);
361 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), 5.3290705e-15);
364 ASSERT_NE(var,
nullptr);
365 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), miss4VecCMS.P());
368 ASSERT_NE(var,
nullptr);
369 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), 0.);
372 ASSERT_NE(var,
nullptr);
373 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), 0.);
376 ASSERT_NE(var,
nullptr);
377 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), - E0 / 2);
380 ASSERT_NE(var,
nullptr);
381 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), miss4VecCMS.E());
387 TEST_F(ROEVariablesTest, ROESpecificKinematicVariables)
390 auto part = myParticles[2];
393 ASSERT_NE(var,
nullptr);
394 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), -0.99899036);
397 ASSERT_NE(var,
nullptr);
398 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), 0.31122509);
401 ASSERT_NE(var,
nullptr);
402 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), 0.);
406 ASSERT_NE(var,
nullptr);
407 EXPECT_FLOAT_EQ(std::get<double>(var->function(part)), 1.9539925e-14);
412 TEST_F(ROEVariablesTest, IsInROEVariables)
415 auto part = myParticles[2];
419 roeobjptr.
object = myROEs[0];
420 roeobjptr.
ptr = myROEs[0];
422 auto partROE1 = myParticles[3];
423 auto partROE2 = myParticles[5];
424 auto partROE3 = myParticles[10];
425 auto partROEnotFromMask = myParticles[7];
426 partROEnotFromMask->print();
428 auto partNotROE = myParticles[0];
431 ASSERT_NE(var,
nullptr);
432 EXPECT_EQ(std::get<bool>(var->function(partROE1)), 1);
435 ASSERT_NE(var,
nullptr);
436 EXPECT_EQ(std::get<bool>(var->function(partROE2)), 1);
439 ASSERT_NE(var,
nullptr);
440 EXPECT_EQ(std::get<bool>(var->function(partROE3)), 1);
443 ASSERT_NE(var,
nullptr);
444 EXPECT_EQ(std::get<bool>(var->function(partNotROE)), 0);
447 ASSERT_NE(var,
nullptr);
448 EXPECT_EQ(std::get<bool>(var->function(partNotROE)), 0);
451 ASSERT_NE(var,
nullptr);
452 EXPECT_FLOAT_EQ(std::get<bool>(var->function(partROE1)), 1);
455 ASSERT_NE(var,
nullptr);
456 EXPECT_FLOAT_EQ(std::get<bool>(var->function(partROE1)), 1);
459 ASSERT_NE(var,
nullptr);
460 EXPECT_FLOAT_EQ(std::get<bool>(var->function(partNotROE)), 0);
463 ASSERT_NE(var,
nullptr);
464 EXPECT_FLOAT_EQ(std::get<bool>(var->function(partROEnotFromMask)), 0);
467 ASSERT_NE(var,
nullptr);
468 EXPECT_FLOAT_EQ(std::get<int>(var->function(part)), 1);
471 ASSERT_NE(var,
nullptr);
472 EXPECT_FLOAT_EQ(std::get<bool>(var->function(partROE1)), 1);
475 ASSERT_NE(var,
nullptr);
476 EXPECT_FLOAT_EQ(std::get<bool>(var->function(partROE1)), 0);
479 ASSERT_NE(var,
nullptr);
480 EXPECT_FLOAT_EQ(std::get<double>(var->function(partROE1)), 511.0);
483 roeobjptr.
object =
nullptr;
484 roeobjptr.
ptr =
nullptr;
@ c_DontWriteOut
Object/array should be NOT saved by output modules.
StoreEntryMap & getStoreEntryMap(EDurability durability)
Get a reference to the object/array map.
@ c_Event
Different object in each event, all objects/arrays are invalidated after event() function has been ca...
Belle2::StoreEntry StoreEntry
Wraps a stored array/object, stored under unique (name, durability) key.
static DataStore & Instance()
Instance of singleton Store.
void setInitializeActive(bool active)
Setter for m_initializeActive.
void reset(EDurability durability)
Frees memory occupied by data store items and removes all objects from the map.
static std::unique_ptr< GeneralCut > compile(const std::string &cut)
@ c_Unflavored
Is its own antiparticle or we don't know whether it is a particle/antiparticle.
void print(const std::string &maskName=c_defaultMaskName, bool unpackComposite=true) const
Prints the contents of a RestOfEvent object to screen.
void initializeMask(const std::string &name, const std::string &origin="unknown")
Initialize new mask.
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.
void addParticles(const std::vector< const Particle * > &particle)
Add StoreArray indices of given Particles to the list of unused particles in the event.
bool registerInDataStore(DataStore::EStoreFlags storeFlags=DataStore::c_WriteOut)
Register the object/array in the DataStore.
Accessor to arrays stored in the data store.
T * appendNew()
Construct a new T object at the end of the array.
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.
const Var * getVariable(std::string name)
Get the variable belonging to the given key.
static Manager & Instance()
get singleton instance.
const Belle2::Particle * produceParticle(const std::string &decayString, const ROOT::Math::PxPyPzEVector &momentum, const ROOT::Math::XYZVector &vertex)
Main method to produce particles.
Abstract base class for different kinds of events.
TObject * ptr
The pointer to the returned object, either equal to 'object' or null, depending on whether the object...
TObject * object
The pointer to the actual object.