Belle II Software development
timeline.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#include <alignment/dbobjects/VXDAlignment.h>
10#include <alignment/GlobalTimeLine.h>
11#include <alignment/Manager.h>
12#include <cdc/dbobjects/CDCAlignment.h>
13#include <framework/database/Configuration.h>
14#include <framework/database/Database.h>
15#include <framework/database/EventDependency.h>
16#include <framework/database/TestingPayloadStorage.h>
17#include <framework/dataobjects/EventMetaData.h>
18#include <vxd/dataobjects/VxdID.h>
19
20#include <gtest/gtest.h>
21
22#include <TFile.h>
23
24#include <filesystem>
25#include <string>
26
27using namespace std;
28using namespace Belle2;
29using namespace alignment;
30using namespace timeline;
31
32namespace {
33 template<int UID>
34 class MockDBObj {
35 public:
36 MockDBObj(double value = 0.) : m_param(value) {}
37 // ------------- Interface to global Millepede calibration ----------------
39 static unsigned short getGlobalUniqueID()
40 {
41 static_assert(UID != 0, "Non-zero UID required");
42 return UID;
43 }
45 double getGlobalParam(unsigned short element, unsigned short param) {return m_param;}
47 void setGlobalParam(double value, unsigned short element, unsigned short param) {m_param = value;}
49 std::vector<std::pair<unsigned short, unsigned short>> listGlobalParams() {return {{0, 0}};}
50 private:
51 double m_param{0.};
52 };
53
54
55 class TimeLineTest : public ::testing::Test {
56 protected:
57
58 IntraIoVPayloads beamspotRun0 = {
59 {EventMetaData(0, 0, 0), std::make_shared<GlobalParamSet<BeamSpot>>()}
60 };
61
62 IntraIoVPayloads beamspotRun1 = {
63 {EventMetaData(0, 1, 0), std::make_shared<GlobalParamSet<BeamSpot>>()}
64 };
65
66 IntraIoVPayloads beamspotRun2 = {
67 {EventMetaData(0, 2, 0), std::make_shared<GlobalParamSet<BeamSpot>>()},
68 {EventMetaData(530532, 2, 0), std::make_shared<GlobalParamSet<BeamSpot>>()}
69 };
70
71 IntraIoVPayloads beamspotRun3 = {
72 {EventMetaData(0, 3, 0), std::make_shared<GlobalParamSet<BeamSpot>>()}
73 };
74
75 IntraIoVPayloads beamspotRun4 = {
76 {EventMetaData(0, 4, 0), std::make_shared<GlobalParamSet<BeamSpot>>()}
77 };
78
79 PayloadIovBlockRow beamspotRow = {
80 {IntervalOfValidity(0, 0, 0, 0), beamspotRun0},
81 {IntervalOfValidity(0, 1, 0, 1), beamspotRun1},
82 {IntervalOfValidity(0, 2, 0, 2), beamspotRun2},
83 {IntervalOfValidity(0, 3, 0, 3), beamspotRun3},
84 {IntervalOfValidity(0, 4, 0, 4), beamspotRun4}
85 };
86
87 IntraIoVPayloads vxdRun0to2 = {
88 {EventMetaData(0, 0, 0), std::make_shared<GlobalParamSet<VXDAlignment>>()},
89 };
90
91 IntraIoVPayloads vxdRun3toInf = {
92 {EventMetaData(0, 3, 0), std::make_shared<GlobalParamSet<VXDAlignment>>()},
93 };
94
95 PayloadIovBlockRow vxdRow = {
96 {IntervalOfValidity(0, 0, 0, 2), vxdRun0to2},
97 {IntervalOfValidity(0, 3, 0, 4), vxdRun3toInf}
98
99 };
100
101 IntraIoVPayloads cdcBlock = {
102 {EventMetaData(0, 0, 0), std::make_shared<GlobalParamSet<CDCAlignment>>()}
103
104 };
105 PayloadIovBlockRow cdcRow = {
106 {IntervalOfValidity(0, 0, 0, 4), cdcBlock}
107 };
108
109 PayloadsTable payloadsTable = {
110 {BeamSpot::getGlobalUniqueID(), beamspotRow},
111 {VXDAlignment::getGlobalUniqueID(), vxdRow},
112 {CDCAlignment::getGlobalUniqueID(), cdcRow}
113 };
114
115 std::vector<int> head0 = {0, 1, 2, 3, 4, 5};
116 std::vector<int> head1 = {0, 1, 2, 2, 3, 4};
117 std::vector<int> row0 = {0, 1, 2, 3, 4, 5};
118 std::vector<int> row1 = {0, 0, 0, 0, 1, 1};
119 std::vector<int> row2 = {0, 0, 0, 0, 0, 0};
120
121 EventHeader eventHeader = {
122 EventMetaData(0, 0, 0),
123 EventMetaData(0, 1, 0),
124 EventMetaData(0, 2, 0),
125 EventMetaData(530532, 2, 0),
126 EventMetaData(0, 3, 0),
127 EventMetaData(0, 4, 0)
128 };
129
130 RunHeader runHeader = {
131 {0, 0},
132 {0, 1},
133 {0, 2},
134 {0, 2},
135 {0, 3},
136 {0, 4}
137 };
138
139 TableData tableData = {
140 { 1, row0},
141 {10, row1},
142 {27, row2}
143 };
144
145 TimeTable timeTable = std::make_tuple(eventHeader, runHeader, tableData);
146
147 std::vector<int> irow0 = {0, 1, 1, 1, 1, 1};
148 std::vector<int> irow1 = {0, 0, 0, 0, 1, 0};
149 std::vector<int> irow2 = {0, 0, 0, 0, 0, 0};
150
151 TableData initTableData = {
152 { 1, irow0},
153 {10, irow1},
154 {27, irow2}
155 };
156
157 TimeTable initTimeTable = std::make_tuple(eventHeader, runHeader, initTableData);
158
160 virtual void SetUp()
161 {
162 StoreObjPtr<EventMetaData> evtPtr;
163 DataStore::Instance().setInitializeActive(true);
164 evtPtr.registerInDataStore();
165 DataStore::Instance().setInitializeActive(false);
166 // Event 0 run 0 exp 0
167 evtPtr.construct(0, 0, 0);
168
169 auto& c = Conditions::Configuration::getInstance();
170 c.setNewPayloadLocation("testPayloads/TestDatabase.txt");
171
172 GlobalLabel::setCurrentTimeInterval(0);
173 GlobalLabel::clearTimeDependentParamaters();
174
175 auto beamspotX = GlobalLabel::construct<BeamSpot>(0, 1);
176 auto beamspotZ = GlobalLabel::construct<BeamSpot>(0, 3);
177 auto yingZ = GlobalLabel::construct<VXDAlignment>(VxdID(1, 0, 0, 1).getID(), 3);
178
179 yingZ.registerTimeDependent(4);
180
181 // should be banned:
182 //beamspotX.registerTimeDependent(3);
183 // -> instead:
184 beamspotX.registerTimeDependent(2);
185 beamspotX.registerTimeDependent(3);
186 beamspotX.registerTimeDependent(4);
187
188 beamspotZ.registerTimeDependent(1);
189 beamspotZ.registerTimeDependent(2);
190 beamspotZ.registerTimeDependent(3);
191 beamspotZ.registerTimeDependent(4);
192 beamspotZ.registerTimeDependent(5);
193
194 }
195
197 virtual void TearDown()
198 {
199 GlobalLabel::clearTimeDependentParamaters();
200 GlobalLabel::setCurrentTimeInterval(0);
201
202 std::filesystem::remove_all("testPayloads");
203 Database::reset();
204 DataStore::Instance().reset();
205 }
206
207 };
208
210 TEST_F(TimeLineTest, InitialTimeTable)
211 {
212 GlobalLabel label;
213 auto table = makeInitialTimeTable(eventHeader, label);
214
215 std::vector<int> myrow0 = {0, 1, 1, 1, 1, 1};
216 std::vector<int> myrow1 = {0, 0, 0, 0, 1, 0};
217
218 TableData myInitTableData = {
219 { 1, myrow0},
220 {10, myrow1}
221 };
222
223 TimeTable myInitTimeTable = std::make_tuple(eventHeader, runHeader, myInitTableData);
224
225
226 EXPECT_EQ(table, myInitTimeTable);
227
228 }
229
231 TEST_F(TimeLineTest, TimeTable)
232 {
233 finalizeTimeTable(initTimeTable);
234 EXPECT_EQ(initTimeTable, timeTable);
235
236 EXPECT_EQ(getContinuousIndexByTimeID(timeTable, 1, 3), 3);
237 EXPECT_EQ(getContinuousIndexByTimeID(timeTable, 10, 3), 0);
238 EXPECT_EQ(getContinuousIndexByTimeID(timeTable, 27, 3), 0);
239
240 }
241
243 TEST_F(TimeLineTest, PayloadTable)
244 {
245
246 getPayloadByContinuousIndex(payloadsTable, 1, 3).second->setGlobalParam(42., 0, 1);
247 EXPECT_EQ(getPayloadByContinuousIndex(payloadsTable, 1, 3).second->getGlobalParam(0, 1), 42.);
248
249
250 EXPECT_EQ(getPayloadByContinuousIndex(payloadsTable, 1, 0).first, EventMetaData(0, 0, 0));
251 EXPECT_EQ(getPayloadByContinuousIndex(payloadsTable, 1, 1).first, EventMetaData(0, 1, 0));
252 EXPECT_EQ(getPayloadByContinuousIndex(payloadsTable, 1, 2).first, EventMetaData(0, 2, 0));
253 EXPECT_EQ(getPayloadByContinuousIndex(payloadsTable, 1, 3).first, EventMetaData(530532, 2, 0));
254 EXPECT_EQ(getPayloadByContinuousIndex(payloadsTable, 1, 4).first, EventMetaData(0, 3, 0));
255 EXPECT_EQ(getPayloadByContinuousIndex(payloadsTable, 1, 5).first, EventMetaData(0, 4, 0));
256
257 EXPECT_EQ(getPayloadByContinuousIndex(payloadsTable, 10, 0).first, EventMetaData(0, 0, 0));
258 EXPECT_EQ(getPayloadByContinuousIndex(payloadsTable, 10, 1).first, EventMetaData(0, 3, 0));
259
260 EXPECT_EQ(getPayloadByContinuousIndex(payloadsTable, 27, 0).first, EventMetaData(0, 0, 0));
261
262
263 }
264
266 TEST_F(TimeLineTest, TimeTable2PayloadsTable)
267 {
268 GlobalParamVector vector({"BeamSpot", "VXDAlignment", "CDCAlignment"});
269 GlobalCalibrationManager::initGlobalVector(vector);
270
271 int timeid = 0;
272 EventMetaData ev;
273
274 // vxd
275 timeid = 0;
276 ev = gotoNextChangeInRun(timeTable, 10, timeid);
277 EXPECT_EQ(timeid, 0);
278 EXPECT_EQ(ev, EventMetaData(0, 0, 0));
279
280 timeid = 1;
281 ev = gotoNextChangeInRun(timeTable, 10, timeid);
282 EXPECT_EQ(timeid, 1);
283 EXPECT_EQ(ev, EventMetaData(0, 1, 0));
284
285 timeid = 4;
286 ev = gotoNextChangeInRun(timeTable, 10, timeid);
287 EXPECT_EQ(timeid, 4);
288 EXPECT_EQ(ev, EventMetaData(0, 3, 0));
289
290 timeid = 5;
291 ev = gotoNextChangeInRun(timeTable, 10, timeid);
292 EXPECT_EQ(timeid, 5);
293 EXPECT_EQ(ev, EventMetaData(0, 4, 0));
294
295 // beam
296 timeid = 0;
297 ev = gotoNextChangeInRun(timeTable, 1, timeid);
298 EXPECT_EQ(timeid, 0);
299 EXPECT_EQ(ev, EventMetaData(0, 0, 0));
300
301 timeid = 1;
302 ev = gotoNextChangeInRun(timeTable, 1, timeid);
303 EXPECT_EQ(timeid, 1);
304 EXPECT_EQ(ev, EventMetaData(0, 1, 0));
305
306 timeid = 2;
307 ev = gotoNextChangeInRun(timeTable, 1, timeid);
308 EXPECT_EQ(timeid, 3);
309 EXPECT_EQ(ev, EventMetaData(530532, 2, 0));
310
311 timeid = 3;
312 ev = gotoNextChangeInRun(timeTable, 1, timeid);
313 EXPECT_EQ(timeid, 3);
314 EXPECT_EQ(ev, EventMetaData(530532, 2, 0));
315
316 timeid = 4;
317 ev = gotoNextChangeInRun(timeTable, 1, timeid);
318 EXPECT_EQ(timeid, 4);
319 EXPECT_EQ(ev, EventMetaData(0, 3, 0));
320
321 timeid = 5;
322 ev = gotoNextChangeInRun(timeTable, 1, timeid);
323 EXPECT_EQ(timeid, 5);
324 EXPECT_EQ(ev, EventMetaData(0, 4, 0));
325
326
327
328 timeid = 0;
329 ev = gotoNextChangeRunWise(timeTable, 1, timeid);
330 EXPECT_EQ(timeid, 0);
331 EXPECT_EQ(ev, EventMetaData(0, 1, 0));
332
333 timeid = 1;
334 ev = gotoNextChangeRunWise(timeTable, 1, timeid);
335 EXPECT_EQ(timeid, 1);
336 EXPECT_EQ(ev, EventMetaData(0, 2, 0));
337
338 timeid = 2;
339 ev = gotoNextChangeRunWise(timeTable, 1, timeid);
340 EXPECT_EQ(timeid, 3);
341 EXPECT_EQ(ev, EventMetaData(0, 3, 0));
342
343 timeid = 3;
344 ev = gotoNextChangeRunWise(timeTable, 1, timeid);
345 EXPECT_EQ(timeid, 3);
346 EXPECT_EQ(ev, EventMetaData(0, 3, 0));
347
348 timeid = 4;
349 ev = gotoNextChangeRunWise(timeTable, 1, timeid);
350 EXPECT_EQ(timeid, 4);
351 EXPECT_EQ(ev, EventMetaData(0, 4, 0));
352
353 timeid = 5;
354 ev = gotoNextChangeRunWise(timeTable, 1, timeid);
355 EXPECT_EQ(timeid, 5);
356 EXPECT_EQ(ev, EventMetaData(0, 4, 0));
357
358
359
360 timeid = 0;
361 ev = gotoNextChangeRunWise(timeTable, 10, timeid);
362 EXPECT_EQ(timeid, 3);
363 EXPECT_EQ(ev, EventMetaData(0, 3, 0));
364 ev = gotoNextChangeRunWise(timeTable, 10, timeid);
365 EXPECT_EQ(timeid, 3);
366 EXPECT_EQ(ev, EventMetaData(0, 3, 0));
367
368 timeid = 4;
369 ev = gotoNextChangeRunWise(timeTable, 10, timeid);
370 EXPECT_EQ(timeid, 5);
371 EXPECT_EQ(ev, EventMetaData(0, 4, 0));
372
373
374
375
376 auto table = TimeIdsTable2PayloadsTable(timeTable, vector);
377
378
379 EXPECT_EQ(getPayloadByContinuousIndex(table, 27, 0).first.getExperiment(), getPayloadByContinuousIndex(payloadsTable, 27,
380 0).first.getExperiment());
381
382
383 B2INFO(table.at(27).at(0).second.at(0).first.getEvent() << " " << table.at(27).at(0).second.at(0).first.getRun() << " " << table.at(
384 27).at(0).second.at(0).first.getExperiment());
385 EXPECT_EQ(table.at(27).at(0).second.at(0).first, payloadsTable.at(27).at(0).second.at(0).first);
386 B2INFO(table.at(27).at(0).second.at(0).second->getGlobalUniqueID());
387 EXPECT_EQ(table.at(27).at(0).second.at(0).second->getGlobalUniqueID(),
388 payloadsTable.at(27).at(0).second.at(0).second->getGlobalUniqueID());
389
390 B2INFO(table.at(10).at(0).second.at(0).first.getEvent() << " " << table.at(10).at(0).second.at(0).first.getRun() << " " << table.at(
391 10).at(0).second.at(0).first.getExperiment());
392 EXPECT_EQ(table.at(10).at(0).second.at(0).first, payloadsTable.at(10).at(0).second.at(0).first);
393 B2INFO(table.at(10).at(0).second.at(0).second->getGlobalUniqueID());
394 EXPECT_EQ(table.at(10).at(0).second.at(0).second->getGlobalUniqueID(),
395 payloadsTable.at(10).at(0).second.at(0).second->getGlobalUniqueID());
396
397 B2INFO(table.at(1).at(0).second.at(0).first.getEvent() << " " << table.at(1).at(0).second.at(0).first.getRun() << " " << table.at(
398 1).at(0).second.at(0).first.getExperiment());
399 EXPECT_EQ(table.at(1).at(0).second.at(0).first, payloadsTable.at(1).at(0).second.at(0).first);
400 B2INFO(table.at(1).at(0).second.at(0).second->getGlobalUniqueID());
401 EXPECT_EQ(table.at(1).at(0).second.at(0).second->getGlobalUniqueID(),
402 payloadsTable.at(1).at(0).second.at(0).second->getGlobalUniqueID());
403
404 B2INFO(table.at(1).at(2).second.at(1).first.getEvent() << " " << table.at(1).at(2).second.at(1).first.getRun() << " " << table.at(
405 1).at(2).second.at(1).first.getExperiment());
406 EXPECT_EQ(table.at(1).at(2).second.at(1).first, payloadsTable.at(1).at(2).second.at(1).first);
407 B2INFO(table.at(1).at(2).second.at(1).second->getGlobalUniqueID());
408 EXPECT_EQ(table.at(1).at(2).second.at(1).second->getGlobalUniqueID(),
409 payloadsTable.at(1).at(2).second.at(1).second->getGlobalUniqueID());
410
411
412 }
413
415 TEST_F(TimeLineTest, GlobalParamTimeLine)
416 {
417
418 GlobalParamVector vector({"BeamSpot", "VXDAlignment", "CDCAlignment"});
419 GlobalCalibrationManager::initGlobalVector(vector);
420 GlobalLabel label;
421 GlobalParamTimeLine timeline(eventHeader, label, vector);
422
423 timeline.loadFromDB();
424
425 GlobalLabel::setCurrentTimeInterval(4);
426 auto beamX0 = GlobalLabel::construct<BeamSpot>(0, 1).label();
427 timeline.updateGlobalParam(GlobalLabel(beamX0), 3.);
428
429 GlobalLabel::setCurrentTimeInterval(3);
430 auto beamZ = GlobalLabel::construct<BeamSpot>(0, 3).label();
431 auto beamX = GlobalLabel::construct<BeamSpot>(0, 1).label();
432
433 GlobalLabel::setCurrentTimeInterval(4);
434 auto yingZ = GlobalLabel::construct<VXDAlignment>(VxdID(1, 0, 0, 1).getID(), 3).label();
435
436
437 timeline.updateGlobalParam(GlobalLabel(beamZ), 42.);
438 timeline.updateGlobalParam(GlobalLabel(beamX), 43.);
439 timeline.updateGlobalParam(GlobalLabel(yingZ), 44.);
440
441 auto objects = timeline.releaseObjects();
442 EXPECT_EQ(objects.size(), 8);
443
444 for (auto iov_obj : objects)
445 Database::Instance().storeData(DataStore::objectName(iov_obj.second->IsA(), ""), iov_obj.second, iov_obj.first);
446
447 // Ok let's open these payload files manually to see what's in them but at least we use the framework functions to
448 // find the correct payload for any given iov
449 Conditions::TestingPayloadStorage payloads("testPayloads/TestDatabase.txt");
450 {
451 EventMetaData eventMetaData(0, 2);
452 Conditions::PayloadMetadata payloadInfo{"EventDependency"};
453 ASSERT_TRUE(payloads.get(eventMetaData, payloadInfo));
454 ASSERT_FALSE(payloadInfo.filename.empty());
455 TFile file(payloadInfo.filename.c_str());
456 ASSERT_TRUE(file.IsOpen());
457 auto evdep = (EventDependency*) file.Get("EventDependency");
458 ASSERT_TRUE(evdep);
459
460 auto beam = dynamic_cast<BeamSpot*>(evdep->getObject(EventMetaData(530532, 2, 0)));
461 EXPECT_EQ(beam->getIPPosition()[2], 42.);
462
463 beam = dynamic_cast<BeamSpot*>(evdep->getObject(EventMetaData(530532, 2, 0)));
464 EXPECT_EQ(beam->getIPPosition()[0], 43.);
465
466 beam = dynamic_cast<BeamSpot*>(evdep->getObject(EventMetaData(530532 - 1, 2, 0)));
467 EXPECT_EQ(beam->getIPPosition()[2], 0.);
468
469 beam = dynamic_cast<BeamSpot*>(evdep->getObject(EventMetaData(530532 - 1, 2, 0)));
470 EXPECT_EQ(beam->getIPPosition()[0], 0.);
471 }
472 {
473 EventMetaData eventMetaData(0, 3);
474 Conditions::PayloadMetadata payloadInfo{"BeamSpot"};
475 ASSERT_TRUE(payloads.get(eventMetaData, payloadInfo));
476 ASSERT_FALSE(payloadInfo.filename.empty());
477 TFile file(payloadInfo.filename.c_str());
478 ASSERT_TRUE(file.IsOpen());
479
480 auto beam2 = (BeamSpot*) file.Get("BeamSpot");
481 ASSERT_TRUE(beam2);
482 beam2->getIPPosition().Print();
483 EXPECT_EQ(beam2->getIPPosition()[0], 3.);
484 }
485 {
486 EventMetaData eventMetaData(0, 4);
487 Conditions::PayloadMetadata payloadInfo{"VXDAlignment"};
488 ASSERT_TRUE(payloads.get(eventMetaData, payloadInfo));
489 ASSERT_FALSE(payloadInfo.filename.empty());
490 TFile file(payloadInfo.filename.c_str());
491 ASSERT_TRUE(file.IsOpen());
492
493 auto vxd = (VXDAlignment*) file.Get("VXDAlignment");
494 ASSERT_TRUE(vxd);
495 EXPECT_EQ(vxd->getGlobalParam(VxdID(1, 0, 0, 1).getID(), 3), 44.);
496 }
497 // --------------------------------------------------------------------
498 }
499} // namespace
Belle2::BeamSpot
This class contains the beam spot position and size modeled as a gaussian distribution in space.
Definition: BeamSpot.h:22
Belle2::BeamSpot::getGlobalUniqueID
static unsigned short getGlobalUniqueID()
Return unique ID of BeamSpot in global Millepede calibration (1)
Definition: BeamSpot.h:91
Belle2::CDCAlignment::getGlobalUniqueID
static unsigned short getGlobalUniqueID()
Get global unique id.
Definition: CDCAlignment.h:109
Belle2::Conditions::Configuration::getInstance
static Configuration & getInstance()
Get a reference to the instance which will be used when the Database is initialized.
Belle2::Conditions::TestingPayloadStorage
Class to store and retrieve temporary payloads.
Definition: TestingPayloadStorage.h:39
Belle2::DataStore::objectName
static std::string objectName(const TClass *t, const std::string &name)
Return the storage name for an object of the given TClass and name.
Definition: DataStore.cc:150
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::EventDependency
Class for handling changing conditions as a function of event number.
Definition: EventDependency.h:22
Belle2::EventMetaData
Store event, run, and experiment numbers.
Definition: EventMetaData.h:33
Belle2::GlobalLabel
Class to convert to/from global labels for Millepede II to/from detector & parameter identificators.
Definition: GlobalLabel.h:41
Belle2::GlobalLabel::clearTimeDependentParamaters
static void clearTimeDependentParamaters()
Forget all previously registered time dependent parameters.
Definition: GlobalLabel.cc:66
Belle2::GlobalLabel::setCurrentTimeInterval
static void setCurrentTimeInterval(gidTYPE time)
Sets current time id.
Definition: GlobalLabel.h:207
Belle2::IntervalOfValidity
A class that describes the interval of experiments/runs for which an object in the database is valid.
Definition: IntervalOfValidity.h:25
Belle2::StoreAccessorBase::registerInDataStore
bool registerInDataStore(DataStore::EStoreFlags storeFlags=DataStore::c_WriteOut)
Register the object/array in the DataStore.
Definition: StoreAccessorBase.h:52
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::VXDAlignment
VXD alignment (and maybe some calibration) parameters.
Definition: VXDAlignment.h:19
Belle2::VXDAlignment::getGlobalUniqueID
static unsigned short getGlobalUniqueID()
Get global unique id.
Definition: VXDAlignment.h:47
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:33
Belle2::Database::Instance
static Database & Instance()
Instance of a singleton Database.
Definition: Database.cc:41
Belle2::Database::storeData
bool storeData(const std::string &name, TObject *object, const IntervalOfValidity &iov)
Store an object in the database.
Definition: Database.cc:140
Belle2::Database::reset
static void reset(bool keepConfig=false)
Reset the database instance.
Definition: Database.cc:49
Belle2::getID
int getID(const std::vector< double > &breaks, double t)
get id of the time point t
Definition: calibTools.h:60
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17
std
STL namespace.
Belle2::Conditions::PayloadMetadata
Simple struct to group all information necessary for a single payload.
Definition: PayloadMetadata.h:15