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