BmnRoot 26.10.0-18-g4e3414f9
Software framework of the BM@N experiment
Loading...
Searching...
No Matches
CbmStsAddress_test.C
Go to the documentation of this file.
1/** @file CbmStsAddress_test.C
2 ** @brief Unit test of CbmStsAddress
3 ** This macro tests the functionality of the CbmStsAddress class.
4 ** i.e. the encoding and decoding of the STS address bit field.
5 **
6 ** @author V. Friese <v.friese@gsi.de>
7 */
8
9#include <iostream>
10
11using namespace std;
12
13Int_t CbmStsAddress_test(Int_t nTests = 10000)
14{
15
16 // ===== Init ========================================================
17 // ----- Timer
18 TStopwatch timer;
19 timer.Start();
20
21 cout << "==========================" << endl;
22 cout << "Unit test of CbmStsAddress" << endl;
23 cout << "==========================" << endl;
24
25 // ---- Get and check number of STS levels
26 Int_t nLevels = CbmStsAddress::GetNofLevels();
27 if (nLevels > 10) {
28 cout << "Number of STS levels ( " << nLevels << " ) is larger than 10." << endl;
29 cout << "Please adjust size of static arrays in this macro." << endl;
30 return 1;
31 }
32
33 // ----- Some variables
34 Bool_t testStatus = kTRUE;
35 Int_t bitField[10];
36 TStopwatch watch1;
37 TStopwatch watch2;
38 Int_t pass = 0;
39 Int_t fail = 0;
40 Int_t elementId[10], newElementId[10];
41 UInt_t address, newAddress;
42
43 // ----- Get address bit field
44 for (Int_t level = 0; level < nLevels; level++)
45 bitField[level] = CbmStsAddress::GetNofBits(level);
46 cout << endl;
47 CbmStsAddress::Print();
48 // =======================================================================
49
50 // =======================================================================
51 // Test 1: elementId -> address, compare GetAddress methods
52 // =======================================================================
53 cout << endl << endl;
54 cout << "Test 1: elementId -> address, number of tests " << nTests << endl;
55 watch1.Reset();
56 watch2.Reset();
57 pass = 0;
58 fail = 0;
59 watch1.Start();
60 for (Int_t iTest = 0; iTest < nTests; iTest++) {
61
62 // ----- Generate random element Ids
63 for (Int_t level = 1; level < nLevels; level++) {
64 Int_t range = (1 << bitField[level]) - 1;
65 elementId[level] = gRandom->Integer(range + 1);
66 }
67
68 watch2.Start(kFALSE);
69 // ----- Get address
70 address = CbmStsAddress::GetAddress(elementId[1], elementId[2], elementId[3], elementId[4], elementId[5],
71 elementId[6], elementId[7]);
72
73 // ----- Get address with id array
74 newAddress = CbmStsAddress::GetAddress(elementId);
75 watch2.Stop();
76
77 // ---- Compare both addresses
78 cout << "\rTest " << setw(6) << iTest + 1 << ", address 1 " << setw(10) << address << ", address 2 " << setw(10)
79 << newAddress << std::flush;
80 if (newAddress == address)
81 pass++;
82 else
83 fail++;
84
85 } // test loop
86
87 watch1.Stop();
88 cout << endl;
89 cout << "Tests passed: " << pass << ", failed " << fail << endl;
90 cout << "Total time per test: CPU " << 1.e6 * watch1.CpuTime() / Double_t(nTests) << " mus, Real "
91 << 1.e6 * watch1.RealTime() / Double_t(nTests) << " mus" << endl;
92 cout << "Core time per test: CPU " << 1.e6 * watch2.CpuTime() / Double_t(nTests) << " mus, Real "
93 << 1.e6 * watch2.RealTime() / Double_t(nTests) << " mus" << endl;
94 if (fail)
95 testStatus = kFALSE;
96 // =======================================================================
97
98 // =======================================================================
99 // Test 2: elementId -> address -> elementId
100 // =======================================================================
101 cout << endl << endl;
102 cout << "Test 2: elementId -> address -> elementId, number of tests " << nTests << endl;
103 watch1.Reset();
104 watch2.Reset();
105 pass = 0;
106 fail = 0;
107 watch1.Start();
108 for (Int_t iTest = 0; iTest < nTests; iTest++) {
109
110 // ----- Generate random element Ids
111 for (Int_t level = 1; level < nLevels; level++) {
112 Int_t range = (1 << bitField[level]) - 1;
113 elementId[level] = gRandom->Integer(range + 1);
114 }
115
116 // ----- Get address
117 watch2.Start(kFALSE);
118 address = CbmStsAddress::GetAddress(elementId[1], elementId[2], elementId[3], elementId[4], elementId[5],
119 elementId[6], elementId[7]);
120
121 // ----- Get element Ids from address
122 for (Int_t level = 0; level < nLevels; level++)
123 newElementId[level] = CbmStsAddress::GetElementId(address, level);
124 watch2.Stop();
125
126 // ----- Compare element Ids
127 Bool_t good = kTRUE;
128 for (Int_t level = 1; level < nLevels; level++)
129 if (newElementId[level] != elementId[level]) {
130 cout << "Failure: level " << level << ", generated Id " << elementId[level] << ", converted Id "
131 << newElementId[level] << endl;
132 good = kFALSE;
133 }
134 if (good)
135 pass++;
136 else
137 fail++;
138 cout << "\rTest " << setw(6) << iTest + 1 << ", old Ids: ";
139 for (Int_t level = 1; level < nLevels; level++)
140 cout << elementId[level] << " ";
141 cout << ", new Ids: ";
142 for (Int_t level = 1; level < nLevels; level++)
143 cout << newElementId[level] << " ";
144 cout << " " << flush;
145
146 } // test loop
147 cout << endl;
148 watch1.Stop();
149
150 cout << "Tests passed: " << pass << ", failed " << fail << endl;
151 cout << "Total time per test: CPU " << 1.e6 * watch1.CpuTime() / Double_t(nTests) << " mus, Real "
152 << 1.e6 * watch1.RealTime() / Double_t(nTests) << " mus" << endl;
153 cout << "Core time per test: CPU " << 1.e6 * watch2.CpuTime() / Double_t(nTests) << " mus, Real "
154 << 1.e6 * watch2.RealTime() / Double_t(nTests) << " mus" << endl;
155 if (fail)
156 testStatus = kFALSE;
157 // =======================================================================
158
159 // =======================================================================
160 // Test 3: address-> elementId -> address
161 // =======================================================================
162 cout << endl << endl;
163 cout << "Test 3: address-> elementId -> address, number of tests " << nTests << endl;
164 watch1.Reset();
165 watch2.Reset();
166 pass = 0;
167 fail = 0;
168 watch1.Start();
169 for (Int_t iTest = 0; iTest < nTests; iTest++) {
170
171 // ---- Generate a random STS address
172 Int_t nBits = 32 - bitField[0];
173 address = (gRandom->Integer(1 << nBits) << bitField[0]) | 2;
174
175 // ---- Get element Ids from address
176 watch2.Start(kFALSE);
177 for (Int_t level = 0; level < nLevels; level++)
178 elementId[level] = CbmStsAddress::GetElementId(address, level);
179
180 // ---- Generate new address from element Ids
181 newAddress = CbmStsAddress::GetAddress(elementId[1], elementId[2], elementId[3], elementId[4], elementId[5],
182 elementId[6], elementId[7]);
183 watch2.Stop();
184
185 // ---- Compare old and new addresses
186 cout << "\rTest " << setw(6) << iTest + 1 << ", old address " << setw(10) << address << ", new address "
187 << setw(10) << newAddress << std::flush;
188 if (newAddress == address)
189 pass++;
190 else
191 fail++;
192
193 } // test loop
194
195 watch1.Stop();
196 cout << endl;
197 cout << "Tests passed: " << pass << ", failed " << fail << endl;
198 cout << "Total time per test: CPU " << 1.e6 * watch1.CpuTime() / Double_t(nTests) << " mus, Real "
199 << 1.e6 * watch1.RealTime() / Double_t(nTests) << " mus" << endl;
200 cout << "Core time per test: CPU " << 1.e6 * watch2.CpuTime() / Double_t(nTests) << " mus, Real "
201 << 1.e6 * watch2.RealTime() / Double_t(nTests) << " mus" << endl;
202 if (fail)
203 testStatus = kFALSE;
204 // =======================================================================
205
206 // =======================================================================
207 // Test 4: elementId -> address -> SetElementId
208 // =======================================================================
209 cout << endl << endl;
210 cout << "Test 4: elementId -> address -> SetElementId, number of tests " << nTests << endl;
211 watch1.Reset();
212 watch2.Reset();
213 pass = 0;
214 fail = 0;
215 watch1.Start();
216 for (Int_t iTest = 0; iTest < nTests; iTest++) {
217
218 // ----- Generate random element Ids
219 for (Int_t level = 1; level < nLevels; level++) {
220 Int_t range = (1 << bitField[level]) - 1;
221 elementId[level] = gRandom->Integer(range + 1);
222 }
223
224 // ----- Generate random new Id
225 Int_t changeLevel = gRandom->Integer(nLevels - 1) + 1;
226 Int_t range = (1 << bitField[changeLevel]) - 1;
227 Int_t newId = gRandom->Integer(range + 1);
228
229 // ----- Get address
230 watch2.Start(kFALSE);
231 address = CbmStsAddress::GetAddress(elementId[1], elementId[2], elementId[3], elementId[4], elementId[5],
232 elementId[6], elementId[7]);
233
234 // ----- Change id of given level
235 newAddress = CbmStsAddress::SetElementId(address, changeLevel, newId);
236
237 // ----- Get element Ids from address
238 for (Int_t level = 0; level < nLevels; level++)
239 newElementId[level] = CbmStsAddress::GetElementId(newAddress, level);
240 watch2.Stop();
241
242 // ----- Compare element Ids
243 Bool_t good = kTRUE;
244 for (Int_t level = 1; level < nLevels; level++) {
245 Int_t testId = 0;
246 if (level == changeLevel)
247 testId = newId;
248 else
249 testId = elementId[level];
250 if (newElementId[level] != testId) {
251 cout << "Failure: level " << level << ", generated Id " << testId << ", converted Id "
252 << newElementId[level] << endl;
253 good = kFALSE;
254 }
255 }
256 if (good)
257 pass++;
258 else
259 fail++;
260 cout << "\rTest " << setw(6) << iTest + 1 << ", old Ids: ";
261 for (Int_t level = 1; level < nLevels; level++)
262 cout << elementId[level] << " ";
263 cout << ", change level " << changeLevel << " to id " << newId;
264 cout << ", new Ids: ";
265 for (Int_t level = 1; level < nLevels; level++)
266 cout << newElementId[level] << " ";
267 cout << " " << flush;
268
269 } // test loop
270 cout << endl;
271 watch1.Stop();
272
273 cout << "Tests passed: " << pass << ", failed " << fail << endl;
274 cout << "Total time per test: CPU " << 1.e6 * watch1.CpuTime() / Double_t(nTests) << " mus, Real "
275 << 1.e6 * watch1.RealTime() / Double_t(nTests) << " mus" << endl;
276 cout << "Core time per test: CPU " << 1.e6 * watch2.CpuTime() / Double_t(nTests) << " mus, Real "
277 << 1.e6 * watch2.RealTime() / Double_t(nTests) << " mus" << endl;
278 if (fail)
279 testStatus = kFALSE;
280 // =======================================================================
281
282 // =======================================================================
283 // Test 5: Overflow in GetAddress
284 // =======================================================================
285 cout << endl << endl;
286 cout << "Test 5: overflow in GetAddress" << endl;
287
288 // ----- Generate random element Ids
289 for (Int_t level = 1; level < nLevels; level++) {
290 Int_t range = (1 << bitField[level]) - 1;
291 elementId[level] = gRandom->Integer(range + 1);
292 }
293
294 // ----- Illegal value for a random level
295 Int_t checkLevel = gRandom->Integer(nLevels - 1) + 1;
296 Int_t range = (1 << bitField[checkLevel]) - 1;
297 elementId[checkLevel] = range + 1;
298
299 // ----- Get address (should give an error)
300 address = CbmStsAddress::GetAddress(elementId[1], elementId[2], elementId[3], elementId[4], elementId[5],
301 elementId[6], elementId[7]);
302
303 // ----- Get address with array (should give an error)
304 newAddress = CbmStsAddress::GetAddress(elementId);
305
306 // ----- Check result
307 cout << "Addresses are " << address << " " << newAddress;
308 if (address + newAddress) {
309 testStatus = kFALSE;
310 cout << " : FAILED" << endl;
311 } else
312 cout << " : OK" << endl;
313 // =======================================================================
314
315 // =======================================================================
316 // Test 6: Overflow in SetElementId
317 // =======================================================================
318 cout << endl << endl;
319 cout << "Test 6: overflow in SetElementId" << endl;
320
321 // ---- Generate a random STS address
322 Int_t nBits = 32 - bitField[0];
323 address = (gRandom->Integer(1 << nBits) << bitField[0]) | 2;
324
325 // ----- Illegal value for a random level
326 Int_t checkLevel = gRandom->Integer(nLevels - 1) + 1;
327 Int_t range = (1 << bitField[checkLevel]) - 1;
328 Int_t newId = range + 1;
329
330 // ----- Set illegal element id for chosen level (should return error)
331 newAddress = CbmStsAddress::SetElementId(address, checkLevel, newId);
332
333 // ----- Check result
334 cout << "New address is " << newAddress;
335 if (newAddress) {
336 testStatus = kFALSE;
337 cout << " : FAILED" << endl;
338 } else
339 cout << " : OK" << endl;
340 // =======================================================================
341
342 // ===== Test result ===============================================
343 timer.Stop();
344 cout << endl << endl;
345 cout << "Time consumed: CPU " << timer.CpuTime() << " s, real " << timer.RealTime() << " s" << endl;
346 cout << "Test status: ";
347 if (testStatus) {
348 cout << " PASSED" << endl << endl;
349 return 0;
350 }
351 cout << " FAILED" << endl << endl;
352 return 1;
353 // =======================================================================
354};
CbmStsAddress_test
Int_t CbmStsAddress_test(Int_t nTests=10000)
Definition CbmStsAddress_test.C:13
Bool_t
bool Bool_t
Int_t
int Int_t
UInt_t
unsigned int UInt_t
kFALSE
constexpr Bool_t kFALSE
Double_t
double Double_t
kTRUE
constexpr Bool_t kTRUE
gRandom
R__EXTERN TRandom * gRandom
CbmStsAddress::GetAddress
static UInt_t GetAddress(Int_t station=0, Int_t ladder=0, Int_t halfladder=0, Int_t module=0, Int_t sensor=0, Int_t side=0, Int_t channel=0)
Construct address.
Definition CbmStsAddress.cxx:39
CbmStsAddress::Print
static void Print()
Print information on the bit field.
Definition CbmStsAddress.cxx:104
CbmStsAddress::GetElementId
static Int_t GetElementId(UInt_t address, Int_t level)
Get the index of an element.
Definition CbmStsAddress.h:99
CbmStsAddress::GetNofBits
static Int_t GetNofBits(Int_t level)
Get the number of bits for a given hierarchy level.
Definition CbmStsAddress.h:87
CbmStsAddress::SetElementId
static UInt_t SetElementId(UInt_t address, Int_t level, Int_t newId)
Set the index of an element leaving the other element levels untouched.
Definition CbmStsAddress.h:116
CbmStsAddress::GetNofLevels
static Int_t GetNofLevels()
Get the number of hierarchy levels For use in macros which do not include this header file.
Definition CbmStsAddress.h:81
TStopwatch::RealTime
Double_t RealTime()
TStopwatch::Start
void Start(Bool_t reset=kTRUE)
TStopwatch::CpuTime
Double_t CpuTime()
TStopwatch::Stop
void Stop()
TStopwatch::Reset
void Reset()
std
Definition json.hpp:4446