Belle II Software development
Modules | Classes | Functions
alignment
Packages

Modules

 alignment data objects
 
 alignment modules
 

Classes

class  MillepedeAlgorithm
 Class implementing Millepede calibration algorithm. More...
 
class  MillepedeTreeConversionAlgorithm
 Creation of a plain TTree with residual and global derivative values from GBL data saved to a ROOT file. More...
 
class  CDCCalibration
 CDC alignment and calibration constants. More...
 
class  VXDAlignment
 VXD alignment (and maybe some calibration) parameters. More...
 
class  GblMultipleScatteringController
 TrackSegmentController for use with GblFitter in Belle2. More...
 
class  GlobalLabel
 Class to convert to/from global labels for Millepede II to/from detector & parameter identificators. More...
 
class  AlignableBKLMRecoHit
 Alignable BKLM hit. More...
 
class  AlignableCDCRecoHit
 This class is used to transfer CDC information to the track fit and Millepede. More...
 
class  AlignableEKLMRecoHit
 Alignable EKLM hit. More...
 
class  AlignablePXDRecoHit
 This class is used to transfer PXD information to the track fit. More...
 
class  AlignableSVDRecoHit
 This class is used to transfer SVD information to the track fit. More...
 
class  AlignableSVDRecoHit2D
 This class is used to transfer SVD information to the track fit. More...
 
class  GlobalLabelTest
 Test fixture. More...
 

Functions

 TEST_F (GlobalLabelTest, LargeNumberOfTimeDependentParameters)
 Test large number of time-dep params for registration and retrieval.
 
 TEST_F (GlobalLabelTest, TimeSettingWorkflow)
 Test that time dependence works.
 
 TEST_F (GlobalLabelTest, GettersSettersOperators)
 Test getters/setters, operators.
 
 TEST_F (GlobalLabelTest, QickTestNormalOperation)
 Test the default way of using this.
 

Detailed Description

Function Documentation

◆ TEST_F() [1/4]

TEST_F ( GlobalLabelTest  ,
GettersSettersOperators   
)

Test getters/setters, operators.

Definition at line 121 of file globalLabel.cc.

122 {
123 GlobalLabel vxdlabel1 = GlobalLabel::construct<VXDAlignment>(vxdSensor, paramid);
124 GlobalLabel vxdlabel2(100873609);
125
126 // getters
127 EXPECT_EQ(80, GlobalLabel::getCurrentTimeIntervalRef());
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)
138 EXPECT_EQ(80, GlobalLabel::getCurrentTimeIntervalRef());
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
150 GlobalLabel other = GlobalLabel::construct<CDCAlignment>(cdcWire, 2);
151 EXPECT_EQ(270620402, other.label());
152 other = vxdlabel1;
153 EXPECT_EQ(100873609, other.label());
154 }
Belle2::GlobalLabel
Class to convert to/from global labels for Millepede II to/from detector & parameter identificators.
Definition: GlobalLabel.h:41
Belle2::GlobalLabel::label
int label()
Returns encoded Pede label.
Definition: GlobalLabel.h:141
Belle2::GlobalLabel::getParameterId
gidTYPE getParameterId() const
Get id of alignment/calibration parameter.
Definition: GlobalLabel.h:164
Belle2::GlobalLabel::getTimeFlag
bool getTimeFlag() const
Is label time-dependent?
Definition: GlobalLabel.h:170
Belle2::GlobalLabel::getElementId
gidTYPE getElementId() const
Returns the element id (like VxdID for silicon sensors) to identify sets of parameters in DB objects.
Definition: GlobalLabel.h:161
Belle2::GlobalLabel::getCurrentTimeIntervalRef
static unsigned int & getCurrentTimeIntervalRef()
Returns reference to current time id.
Definition: GlobalLabel.h:199
Belle2::GlobalLabel::getTimeId
gidTYPE getTimeId() const
Get time id.
Definition: GlobalLabel.h:167

◆ TEST_F() [2/4]

TEST_F ( GlobalLabelTest  ,
LargeNumberOfTimeDependentParameters   
)

Test large number of time-dep params for registration and retrieval.

Definition at line 69 of file globalLabel.cc.

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);
74 GlobalLabel lab = GlobalLabel::construct<VXDAlignment>(id.getID(), 1);
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);
88 GlobalLabel staticLayer = GlobalLabel::construct<VXDAlignment>(VxdID(6, 0, 0).getID(), 2);
89
90 EXPECT_EQ(i, movingLayer.getTimeId());
91 EXPECT_EQ(0, movingLayerStaticParam.getTimeId());
92 EXPECT_EQ(0, staticLayer.getTimeId());
93 }
94 }
95
96 }
Belle2::GlobalLabel::setParameterId
gidTYPE setParameterId(gidTYPE paramId)
Useful setter to quickly change only the parameter id and return back the encoded label (for use in R...
Definition: GlobalLabel.cc:72
Belle2::GlobalLabel::maxTID
static const gidTYPE maxTID
max time slices for a parameter 1..999
Definition: GlobalLabel.h:50
Belle2::GlobalLabel::registerTimeDependent
void registerTimeDependent(gidTYPE start, gidTYPE end=maxTID)
Register this Detector element and parameter as time dependent with instance starting at "start" time...
Definition: GlobalLabel.cc:45
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:33
Belle2::getID
int getID(const std::vector< double > &breaks, double t)
get id of the time point t
Definition: calibTools.h:60

◆ TEST_F() [3/4]

TEST_F ( GlobalLabelTest  ,
QickTestNormalOperation   
)

Test the default way of using this.

Definition at line 157 of file globalLabel.cc.

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
236 GlobalLabel::clearTimeDependentParamaters();
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 }
Belle2::GlobalLabel::clearTimeDependentParamaters
static void clearTimeDependentParamaters()
Forget all previously registered time dependent parameters.
Definition: GlobalLabel.cc:66

◆ TEST_F() [4/4]

TEST_F ( GlobalLabelTest  ,
TimeSettingWorkflow   
)

Test that time dependence works.

Definition at line 99 of file globalLabel.cc.

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 }