Belle II Software  release-05-01-25
MuidBuilderTest.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2020 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Giacomo De Pietro *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 /* KLM headers. */
12 #include <klm/dataobjects/bklm/BKLMElementNumbers.h>
13 #include <klm/dataobjects/eklm/EKLMElementNumbers.h>
14 #include <klm/dataobjects/KLMMuidLikelihood.h>
15 #include <klm/muid/MuidBuilder.h>
16 #include <klm/muid/MuidElementNumbers.h>
17 
18 /* Belle 2 headers. */
19 #include <framework/database/Database.h>
20 #include <framework/database/DBStore.h>
21 #include <framework/dataobjects/EventMetaData.h>
22 #include <framework/datastore/StoreArray.h>
23 #include <framework/datastore/StoreObjPtr.h>
24 
25 /* C++ headers. */
26 #include <bitset>
27 #include <string>
28 
29 /* Google Test headers. */
30 #include <gtest/gtest.h>
31 
32 using namespace std;
33 
34 namespace Belle2 {
41  class MuidBuilderTest : public ::testing::Test {
42 
43  protected:
44 
46  void SetUp() override
47  {
48  /* DataStore. */
49  DataStore::Instance().setInitializeActive(true);
50  StoreArray<KLMMuidLikelihood> muids;
51  muids.registerInDataStore();
52  StoreObjPtr<EventMetaData> eventMetaData;
53  eventMetaData.registerInDataStore();
54  DataStore::Instance().setInitializeActive(false);
55  /* Database. */
56  eventMetaData.construct(1, 0, 0);
57  DBStore& dbStore = DBStore::Instance();
58  dbStore.update();
59  dbStore.updateEvent();
60  }
61 
63  void TearDown() override
64  {
65  DataStore::Instance().reset();
66  Database::reset();
67  }
68 
70  KLMMuidLikelihood* m_muid = nullptr;
71 
73  MuidBuilder* m_muidBuilder = nullptr;
74 
76  std::vector<int> m_pdgVectorMinus = MuidElementNumbers::getPDGVector(-1);
77 
79  std::vector<int> m_pdgVectorPlus = MuidElementNumbers::getPDGVector(1);
80  };
81 
83  TEST_F(MuidBuilderTest, MuidBuilder01)
84  {
85  StoreArray<KLMMuidLikelihood> muids;
86  int pdg = 13;
87  std::bitset<30> bitExtPattern(std::string("11111111111111"));
88  unsigned int extPattern = static_cast<unsigned int>(bitExtPattern.to_ulong());
89  unsigned int hitPattern = static_cast<unsigned int>(bitExtPattern.to_ulong());
90  bool isForward = true;
91  bool escaped = false;
92  int lastBarrelLayer = 13;
93  int lastEndcapLayer = -1;
94  unsigned int outcome = MuidElementNumbers::calculateExtrapolationOutcome(isForward, escaped, lastBarrelLayer, lastEndcapLayer);
95  double chiSquared = 29.5;
96  int degreesOfFreedom = 28;
97  m_muid = muids.appendNew();
98  m_muid->setPDGCode(pdg);
99  m_muid->setExtLayerPattern(extPattern);
100  m_muid->setHitLayerPattern(hitPattern);
101  m_muid->setIsForward(isForward);
102  m_muid->setBarrelExtLayer(lastBarrelLayer);
103  m_muid->setEndcapExtLayer(lastBarrelLayer);
104  m_muid->setOutcome(outcome);
105  m_muid->setChiSquared(chiSquared);
106  m_muid->setDegreesOfFreedom(degreesOfFreedom);
107  std::vector<float> logLVector = { -169.215, -0.288937, -46.5124, -49.7292, -72.7715, -96.2517};
108  for (size_t i = 0; i < m_pdgVectorMinus.size(); ++i) {
109  m_muidBuilder = new MuidBuilder(m_pdgVectorMinus.at(i));
110  float logL = std::log(m_muidBuilder->getPDF(m_muid));
111  EXPECT_LT(std::abs(logL - logLVector.at(i)), 10E-4);
112  delete m_muidBuilder;
113  }
114  logLVector.clear();
115  /* Test for the positive-charged hypotheses. */
116  m_pdgVectorPlus = MuidElementNumbers::getPDGVector(1);
117  logLVector = { -169.215, -0.284881, -45.7914, -42.7717, -95.9839, -118.769};
118  for (size_t i = 0; i < m_pdgVectorPlus.size(); ++i) {
119  m_muidBuilder = new MuidBuilder(m_pdgVectorPlus.at(i));
120  float logL = std::log(m_muidBuilder->getPDF(m_muid));
121  EXPECT_LT(std::abs(logL - logLVector.at(i)), 10E-4);
122  delete m_muidBuilder;
123  }
124  }
125 
127  TEST_F(MuidBuilderTest, MuidBuilder02)
128  {
129  StoreArray<KLMMuidLikelihood> muids;
130  int pdg = 13;
131  std::bitset<30> bitExtPattern(std::string("11111111111111"));
132  unsigned int extPattern = static_cast<unsigned int>(bitExtPattern.to_ulong());
133  std::bitset<30> bitHitPattern(std::string("11011111111101"));
134  unsigned int hitPattern = static_cast<unsigned int>(bitHitPattern.to_ulong());
135  bool isForward = true;
136  bool escaped = false;
137  int lastBarrelLayer = 13;
138  int lastEndcapLayer = -1;
139  unsigned int outcome = MuidElementNumbers::calculateExtrapolationOutcome(isForward, escaped, lastBarrelLayer, lastEndcapLayer);
140  double chiSquared = 23.5;
141  int degreesOfFreedom = 24;
142  m_muid = muids.appendNew();
143  m_muid->setPDGCode(pdg);
144  m_muid->setExtLayerPattern(extPattern);
145  m_muid->setHitLayerPattern(hitPattern);
146  m_muid->setIsForward(isForward);
147  m_muid->setBarrelExtLayer(lastBarrelLayer);
148  m_muid->setEndcapExtLayer(lastBarrelLayer);
149  m_muid->setOutcome(outcome);
150  m_muid->setChiSquared(chiSquared);
151  m_muid->setDegreesOfFreedom(degreesOfFreedom);
152  std::vector<float> logLVector = { -147.07, -6.37567, -40.9424, -43.8204, -63.8973, -84.6684};
153  for (size_t i = 0; i < m_pdgVectorMinus.size(); ++i) {
154  m_muidBuilder = new MuidBuilder(m_pdgVectorMinus.at(i));
155  float logL = std::log(m_muidBuilder->getPDF(m_muid));
156  EXPECT_LT(std::abs(logL - logLVector.at(i)), 10E-4);
157  delete m_muidBuilder;
158  }
159  }
160 
162  TEST_F(MuidBuilderTest, MuidBuilder03)
163  {
164  StoreArray<KLMMuidLikelihood> muids;
165  int pdg = 13;
166  std::bitset<30> bitExtPattern(std::string("11111111111111"));
167  unsigned int extPattern = static_cast<unsigned int>(bitExtPattern.to_ulong());
168  std::bitset<30> bitHitPattern(std::string("11"));
169  unsigned int hitPattern = static_cast<unsigned int>(bitHitPattern.to_ulong());
170  bool isForward = true;
171  bool escaped = false;
172  int lastBarrelLayer = 1;
173  int lastEndcapLayer = -1;
174  unsigned int outcome = MuidElementNumbers::calculateExtrapolationOutcome(isForward, escaped, lastBarrelLayer, lastEndcapLayer);
175  double chiSquared = 7.5;
176  int degreesOfFreedom = 4;
177  m_muid = muids.appendNew();
178  m_muid->setPDGCode(pdg);
179  m_muid->setExtLayerPattern(extPattern);
180  m_muid->setHitLayerPattern(hitPattern);
181  m_muid->setIsForward(isForward);
182  m_muid->setBarrelExtLayer(lastBarrelLayer);
183  m_muid->setEndcapExtLayer(lastBarrelLayer);
184  m_muid->setOutcome(outcome);
185  m_muid->setChiSquared(chiSquared);
186  m_muid->setDegreesOfFreedom(degreesOfFreedom);
187  std::vector<float> logLVector = { -13.0068, -1.82853, -4.78739, -6.44048, -6.67272, -6.8342};
188  for (size_t i = 0; i < m_pdgVectorMinus.size(); ++i) {
189  m_muidBuilder = new MuidBuilder(m_pdgVectorMinus.at(i));
190  float logL = std::log(m_muidBuilder->getPDF(m_muid));
191  EXPECT_LT(std::abs(logL - logLVector.at(i)), 10E-4);
192  delete m_muidBuilder;
193  }
194  }
195 
197  TEST_F(MuidBuilderTest, MuidBuilder04)
198  {
199  StoreArray<KLMMuidLikelihood> muids;
200  int pdg = 13;
201  std::bitset<30> bitExtPattern(std::string("1111111000000000000111"));
202  unsigned int extPattern = static_cast<unsigned int>(bitExtPattern.to_ulong());
203  unsigned int hitPattern = static_cast<unsigned int>(bitExtPattern.to_ulong());
204  /* Test the forward endcap. */
205  bool isForward = true;
206  bool escaped = false;
207  int lastBarrelLayer = 2;
208  int lastEndcapLayer = 6;
209  unsigned int outcome = MuidElementNumbers::calculateExtrapolationOutcome(isForward, escaped, lastBarrelLayer, lastEndcapLayer);
210  double chiSquared = 19.5;
211  int degreesOfFreedom = 20;
212  m_muid = muids.appendNew();
213  m_muid->setPDGCode(pdg);
214  m_muid->setExtLayerPattern(extPattern);
215  m_muid->setHitLayerPattern(hitPattern);
216  m_muid->setIsForward(isForward);
217  m_muid->setBarrelExtLayer(lastBarrelLayer);
218  m_muid->setEndcapExtLayer(lastBarrelLayer);
219  m_muid->setOutcome(outcome);
220  m_muid->setChiSquared(chiSquared);
221  m_muid->setDegreesOfFreedom(degreesOfFreedom);
222  std::vector<float> logLVector = { -44.4325, -0.746618, -17.3903, -18.7434, -25.4178, -34.7886};
223  for (size_t i = 0; i < m_pdgVectorMinus.size(); ++i) {
224  m_muidBuilder = new MuidBuilder(m_pdgVectorMinus.at(i));
225  float logL = std::log(m_muidBuilder->getPDF(m_muid));
226  EXPECT_LT(std::abs(logL - logLVector.at(i)), 10E-4);
227  delete m_muidBuilder;
228  }
229  logLVector.clear();
230  /* Test the backward endcap. */
231  isForward = false;
232  outcome = MuidElementNumbers::calculateExtrapolationOutcome(isForward, escaped, lastBarrelLayer, lastEndcapLayer);
233  m_muid->setIsForward(isForward);
234  m_muid->setOutcome(outcome);
235  logLVector = { -50.7005, -1.11268, -18.3302, -20.7392, -26.5815, -33.6206};
236  for (size_t i = 0; i < m_pdgVectorMinus.size(); ++i) {
237  m_muidBuilder = new MuidBuilder(m_pdgVectorMinus.at(i));
238  float logL = std::log(m_muidBuilder->getPDF(m_muid));
239  EXPECT_LT(std::abs(logL - logLVector.at(i)), 10E-4);
240  delete m_muidBuilder;
241  }
242  }
243 
245  TEST_F(MuidBuilderTest, MuidBuilder05)
246  {
247  StoreArray<KLMMuidLikelihood> muids;
248  int pdg = 13;
249  std::bitset<30> bitExtPattern(std::string("1111111000000000000111"));
250  unsigned int extPattern = static_cast<unsigned int>(bitExtPattern.to_ulong());
251  std::bitset<30> bitHitPattern(std::string("1100111000000000000101"));
252  unsigned int hitPattern = static_cast<unsigned int>(bitHitPattern.to_ulong());
253  /* Test the forward endcap. */
254  bool isForward = true;
255  bool escaped = false;
256  int lastBarrelLayer = 2;
257  int lastEndcapLayer = 6;
258  unsigned int outcome = MuidElementNumbers::calculateExtrapolationOutcome(isForward, escaped, lastBarrelLayer, lastEndcapLayer);
259  double chiSquared = 15.5;
260  int degreesOfFreedom = 14;
261  float efficiency = 0.8437;
262  m_muid = muids.appendNew();
263  m_muid->setPDGCode(pdg);
264  m_muid->setExtLayerPattern(extPattern);
265  m_muid->setHitLayerPattern(hitPattern);
266  m_muid->setIsForward(isForward);
267  m_muid->setBarrelExtLayer(lastBarrelLayer);
268  m_muid->setEndcapExtLayer(lastBarrelLayer);
269  m_muid->setOutcome(outcome);
270  m_muid->setChiSquared(chiSquared);
271  m_muid->setDegreesOfFreedom(degreesOfFreedom);
272  for (int layer = 0; layer < BKLMElementNumbers::getMaximalLayerNumber(); ++layer)
273  m_muid->setExtBKLMEfficiencyValue(layer, efficiency);
274  for (int layer = 0; layer < EKLMElementNumbers::getMaximalLayerNumber(); ++layer)
275  m_muid->setExtEKLMEfficiencyValue(layer, efficiency);
276  std::vector<float> logLVector = { -38.1205, -2.43391, -16.0512, -17.094, -23.4617, -31.9516};
277  for (size_t i = 0; i < m_pdgVectorMinus.size(); ++i) {
278  m_muidBuilder = new MuidBuilder(m_pdgVectorMinus.at(i));
279  float logL = std::log(m_muidBuilder->getPDF(m_muid));
280  EXPECT_LT(std::abs(logL - logLVector.at(i)), 10E-4);
281  delete m_muidBuilder;
282  }
283  logLVector.clear();
284  /* Test the backward endcap. */
285  isForward = false;
286  outcome = MuidElementNumbers::calculateExtrapolationOutcome(isForward, escaped, lastBarrelLayer, lastEndcapLayer);
287  m_muid->setIsForward(isForward);
288  m_muid->setOutcome(outcome);
289  logLVector = { -43.7474, -2.51744, -16.6359, -18.5523, -23.8643, -29.9728};
290  for (size_t i = 0; i < m_pdgVectorMinus.size(); ++i) {
291  m_muidBuilder = new MuidBuilder(m_pdgVectorMinus.at(i));
292  float logL = std::log(m_muidBuilder->getPDF(m_muid));
293  EXPECT_LT(std::abs(logL - logLVector.at(i)), 10E-4);
294  delete m_muidBuilder;
295  }
296  }
297 
299 }
Belle2::StoreArray::appendNew
T * appendNew()
Construct a new T object at the end of the array.
Definition: StoreArray.h:256
Belle2::MuidBuilder
Build the Muid likelihoods starting from the hit pattern and the transverse scattering in the KLM.
Definition: MuidBuilder.h:39
Belle2::TEST_F
TEST_F(MuidBuilderTest, MuidBuilder05)
Test for a muon with hits in both barrel and endcaps.
Definition: MuidBuilderTest.cc:245
Belle2::MuidBuilderTest::SetUp
void SetUp() override
Register the necessary objects in the DataStore and setup the Database.
Definition: MuidBuilderTest.cc:46
Belle2::MuidBuilderTest::TearDown
void TearDown() override
Clear the DataStore and reset the Database.
Definition: MuidBuilderTest.cc:63
Belle2::MuidBuilderTest
Test for the MuidBuilder class, using the payloads in the default Global Tag.
Definition: MuidBuilderTest.cc:41
Belle2::DBStore
Singleton class to cache database objects.
Definition: DBStore.h:42
Belle2::StoreObjPtr::construct
bool construct(Args &&... params)
Construct an object of type T in this StoreObjPtr, using the provided constructor arguments.
Definition: StoreObjPtr.h:128
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: ParticleList.h:33
Belle2::DBStore::updateEvent
void updateEvent()
Updates all intra-run dependent objects.
Definition: DBStore.cc:150
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition: ECLMatchingPerformanceExpertModule.h:33
Belle2::KLMMuidLikelihood
Class to store the likelihoods from KLM with additional informations related to the extrapolation.
Definition: KLMMuidLikelihood.h:38
Belle2::DBStore::update
void update()
Updates all objects that are outside their interval of validity.
Definition: DBStore.cc:87