Belle II Software development
globalLabel.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/GlobalLabel.h>
11#include <alignment/PedeResult.h>
12#include <cdc/dataobjects/WireID.h>
13#include <cdc/dbobjects/CDCAlignment.h>
14#include <vxd/dataobjects/VxdID.h>
15
16#include <gtest/gtest.h>
17
18using namespace std;
19using namespace Belle2;
20using namespace alignment;
21
22namespace Belle2 {
28 class GlobalLabelTest : public ::testing::Test {
29 protected:
31 short vxdSensor;
33 short cdcWire;
36
38 virtual void SetUp()
39 {
40 vxdSensor = VxdID(1, 2, 1).getID();
41 cdcWire = WireID(1, 4, 60).getEWire();
42 paramid = 9;
43 }
44
52
54 void setTime(unsigned int timeid)
55 {
56 unsigned int& subrun = GlobalLabel::getCurrentTimeIntervalRef();
57 subrun = timeid;
58 }
59
65
66 };
67
69 TEST_F(GlobalLabelTest, LargeNumberOfTimeDependentParameters)
70 {
71 for (int ilayer = 1; ilayer < 6; ilayer++) {
72 for (unsigned int subrun = 0; subrun <= GlobalLabel::maxTID; subrun++) {
73 VxdID id(ilayer, 0, 0);
75 lab.registerTimeDependent(subrun, subrun);
76 lab.setParameterId(2);
77 lab.registerTimeDependent(subrun, subrun);
78 lab.setParameterId(3);
79 lab.registerTimeDependent(subrun, subrun);
80 }
81 }
82 // Ask 1000-times for time dep.label (could be in a single track)
83 for (int ilayer = 1; ilayer < 6; ilayer++) {
84 for (unsigned int i = 0; i <= GlobalLabel::maxTID; i++) {
85 setTime(i);
86 GlobalLabel movingLayer = GlobalLabel::construct<VXDAlignment>(VxdID(ilayer, 0, 0).getID(), 2);
87 GlobalLabel movingLayerStaticParam = GlobalLabel::construct<VXDAlignment>(VxdID(ilayer, 0, 0).getID(), 4);
89
90 EXPECT_EQ(i, movingLayer.getTimeId());
91 EXPECT_EQ(0, movingLayerStaticParam.getTimeId());
92 EXPECT_EQ(0, staticLayer.getTimeId());
93 }
94 }
95
96 }
97
99 TEST_F(GlobalLabelTest, TimeSettingWorkflow)
100 {
101 GlobalLabel vxdlabel1 = GlobalLabel::construct<VXDAlignment>(vxdSensor, paramid);
102 GlobalLabel Cvxdlabel1 = GlobalLabel::construct<VXDAlignment>(vxdSensor, 2);
103 EXPECT_EQ(0, vxdlabel1.getTimeId());
104 EXPECT_EQ(0, Cvxdlabel1.getTimeId());
105
106 registerSomeTimeDepParams();
107 GlobalLabel vxdlabel2 = GlobalLabel::construct<VXDAlignment>(vxdSensor, paramid);
108 GlobalLabel Cvxdlabel2 = GlobalLabel::construct<VXDAlignment>(vxdSensor, 2);
109 EXPECT_EQ(0, vxdlabel2.getTimeId());
110 EXPECT_EQ(0, Cvxdlabel2.getTimeId());
111
112 setTime(80);
113 GlobalLabel vxdlabel3 = GlobalLabel::construct<VXDAlignment>(vxdSensor, paramid);
114 GlobalLabel Cvxdlabel3 = GlobalLabel::construct<VXDAlignment>(vxdSensor, 2);
115 EXPECT_EQ(1, vxdlabel3.getTimeId());
116 EXPECT_EQ(0, Cvxdlabel3.getTimeId());
117
118 }
119
121 TEST_F(GlobalLabelTest, GettersSettersOperators)
122 {
123 GlobalLabel vxdlabel1 = GlobalLabel::construct<VXDAlignment>(vxdSensor, paramid);
124 GlobalLabel vxdlabel2(100873609);
125
126 // getters
128 EXPECT_EQ(paramid, vxdlabel1.getParameterId());
129 EXPECT_EQ(0, vxdlabel1.getTimeFlag());
130 EXPECT_EQ(0, vxdlabel1.getTimeId());
131 EXPECT_EQ(vxdSensor, vxdlabel1.getElementId());
132
133 // cast operators
134 EXPECT_EQ(100873609, (int)vxdlabel1);
135 EXPECT_EQ(100873609, (unsigned int)vxdlabel1);
136
137 // getters (GlobalLabel from label)
139 EXPECT_EQ(paramid, vxdlabel2.getParameterId());
140 EXPECT_EQ(0, vxdlabel2.getTimeFlag());
141 EXPECT_EQ(0, vxdlabel2.getTimeId());
142 EXPECT_EQ(vxdSensor, vxdlabel2.getElementId());
143
144 // no detector mismatch (GlobalLabel from label)
145 // cats operator (GlobalLabel from label)
146 EXPECT_EQ(100873609, (int)vxdlabel2);
147 EXPECT_EQ(100873609, (unsigned int)vxdlabel2);
148
149 // Assignment
151 EXPECT_EQ(270620402, other.label());
152 other = vxdlabel1;
153 EXPECT_EQ(100873609, other.label());
154 }
155
157 TEST_F(GlobalLabelTest, QickTestNormalOperation)
158 {
159
160 // Test time indep. detector constructors
161 GlobalLabel vxdlabel = GlobalLabel::construct<VXDAlignment>(vxdSensor, paramid);
162 GlobalLabel cdclabel = GlobalLabel::construct<CDCAlignment>(cdcWire, paramid);
163 EXPECT_EQ(100873609, vxdlabel.label());
164 EXPECT_EQ(270620409, cdclabel.label());
165 EXPECT_EQ(paramid, vxdlabel.getParameterId());
166 EXPECT_EQ(paramid, cdclabel.getParameterId());
167 // Test time indep. label constructor
168 vxdlabel = GlobalLabel(100873609);
169 cdclabel = GlobalLabel(270620409);
170 EXPECT_EQ(paramid, vxdlabel.getParameterId());
171 EXPECT_EQ(paramid, cdclabel.getParameterId());
172
173 // Register time intervals
174 registerSomeTimeDepParams();
175
176 // Nothing to test on dump... (enable it and see the time-dep map:-)
177 //vxdlabel.dump(100);
178
179 // Test detector time dependent constructors
180 setTime(10);
181 vxdlabel = GlobalLabel::construct<VXDAlignment>(vxdSensor, paramid);
182 cdclabel = GlobalLabel::construct<CDCAlignment>(cdcWire, paramid);
183 EXPECT_EQ(1, vxdlabel.getTimeId());
184 EXPECT_EQ(1, cdclabel.getTimeId());
185 EXPECT_EQ(paramid, vxdlabel.getParameterId());
186 EXPECT_EQ(paramid, cdclabel.getParameterId());
187
188 // Test time dependent label constructor
189 vxdlabel = GlobalLabel(vxdlabel.label());
190 cdclabel = GlobalLabel(cdclabel.label());
191 EXPECT_EQ(paramid, vxdlabel.getParameterId());
192 EXPECT_EQ(paramid, cdclabel.getParameterId());
193 EXPECT_EQ(1, vxdlabel.getTimeId());
194 EXPECT_EQ(1, cdclabel.getTimeId());
195
196 // Test that time dependence works correctly
197 // on several subruns
198 setTime(0);
199 vxdlabel = GlobalLabel::construct<VXDAlignment>(vxdSensor, paramid);
200 cdclabel = GlobalLabel::construct<CDCAlignment>(cdcWire, paramid);
201 EXPECT_EQ(0, vxdlabel.getTimeId());
202 EXPECT_EQ(0, cdclabel.getTimeId());
203
204
205 setTime(1);
206 vxdlabel = GlobalLabel::construct<VXDAlignment>(vxdSensor, paramid);
207 cdclabel = GlobalLabel::construct<CDCAlignment>(cdcWire, paramid);
208 EXPECT_EQ(1, vxdlabel.getTimeId());
209 EXPECT_EQ(1, cdclabel.getTimeId());
210
211 setTime(51);
212 vxdlabel = GlobalLabel::construct<VXDAlignment>(vxdSensor, paramid);
213 cdclabel = GlobalLabel::construct<CDCAlignment>(cdcWire, paramid);
214 EXPECT_EQ(1, vxdlabel.getTimeId());
215 EXPECT_EQ(51, cdclabel.getTimeId());
216
217 setTime(80);
218 vxdlabel = GlobalLabel::construct<VXDAlignment>(vxdSensor, paramid);
219 cdclabel = GlobalLabel::construct<CDCAlignment>(cdcWire, paramid);
220 EXPECT_EQ(1, vxdlabel.getTimeId());
221 EXPECT_EQ(51, cdclabel.getTimeId());
222
223 setTime(100);
224 vxdlabel = GlobalLabel::construct<VXDAlignment>(vxdSensor, paramid);
225 cdclabel = GlobalLabel::construct<CDCAlignment>(cdcWire, paramid);
226 EXPECT_EQ(1, vxdlabel.getTimeId());
227 EXPECT_EQ(51, cdclabel.getTimeId());
228
229 setTime(101);
230 vxdlabel = GlobalLabel::construct<VXDAlignment>(vxdSensor, paramid);
231 cdclabel = GlobalLabel::construct<CDCAlignment>(cdcWire, paramid);
232 EXPECT_EQ(0, vxdlabel.getTimeId());
233 EXPECT_EQ(0, cdclabel.getTimeId());
234
235 // Reset time dependence
237 setTime(90);
238 vxdlabel = GlobalLabel::construct<VXDAlignment>(vxdSensor, paramid);
239 cdclabel = GlobalLabel::construct<CDCAlignment>(cdcWire, paramid);
240 EXPECT_EQ(0, vxdlabel.getTimeId());
241 EXPECT_EQ(0, cdclabel.getTimeId());
242
243 }
244
245} // namespace
short cdcWire
Testing cdc id.
int paramid
Testing parameter id.
short vxdSensor
Testing vxd id.
void registerSomeTimeDepParams()
Register some parameters as time dependent.
virtual void TearDown()
cleanup
virtual void SetUp()
init
void setTime(unsigned int timeid)
Set current time slice for time dependent params.
Class to convert to/from global labels for Millepede II to/from detector & parameter identificators.
Definition GlobalLabel.h:41
int label()
Returns encoded Pede label.
static void clearTimeDependentParamaters()
Forget all previously registered time dependent parameters.
gidTYPE setParameterId(gidTYPE paramId)
Useful setter to quickly change only the parameter id and return back the encoded label (for use in R...
gidTYPE getParameterId() const
Get id of alignment/calibration parameter.
bool getTimeFlag() const
Is label time-dependent?
gidTYPE getElementId() const
Returns the element id (like VxdID for silicon sensors) to identify sets of parameters in DB objects.
static const gidTYPE maxTID
max time slices for a parameter 1..999
Definition GlobalLabel.h:50
static GlobalLabel construct(gidTYPE element, gidTYPE param)
Construct label for given DB object (template argument) and its element and parameter.
Definition GlobalLabel.h:81
void registerTimeDependent(gidTYPE start, gidTYPE end=maxTID)
Register this Detector element and parameter as time dependent with instance starting at "start" time...
static unsigned int & getCurrentTimeIntervalRef()
Returns reference to current time id.
gidTYPE getTimeId() const
Get time id.
Class to uniquely identify a any structure of the PXD and SVD.
Definition VxdID.h:33
baseType getID() const
Get the unique id.
Definition VxdID.h:94
Class to identify a wire inside the CDC.
Definition WireID.h:34
unsigned short getEWire() const
Getter for encoded wire number.
Definition WireID.h:154
TEST_F(GlobalLabelTest, LargeNumberOfTimeDependentParameters)
Test large number of time-dep params for registration and retrieval.
int getID(const std::vector< double > &breaks, double t)
get id of the time point t
Definition calibTools.h:60
Abstract base class for different kinds of events.
STL namespace.