Belle II Software development
collectortfinfo.h
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#include <framework/gearbox/Const.h>
9#include <framework/logging/Logger.h>
10#include <tracking/trackFindingVXD/displayInterfaceTF/CollectorTFInfo.h>
11#include <gtest/gtest.h>
12
13namespace Belle2 {
20 class CollectorTFInfoTest : public ::testing::Test {
21
27 public:
28 void import_sectors_loop();
29 void import_sectors_standard();
31 void import_clusters_loop();
32 void import_clusters_standard();
34 void import_hit_loop();
35 void import_hit_standard();
37 void import_cell_loop();
38 void import_cell_standard();
40 void import_tfc_loop();
41 void import_tfc_standard();
43 void getAllCells();
44 void getAllHits();
45 void getAllClusters();
46 void getAllTC();
47 void getAllSectors();
50 protected:
51 CollectorTFInfo m_collector = CollectorTFInfo();
52 // Pass Ids
53 std::vector<int> pass_sector_ids = {0, 1, 2};
54 int pass_sector_id_single = 0;
57 };
58
59
60//************** METHODS of the Collector
61// virtual void initSectors (std::map<std::pair<unsigned int, unsigned int>, std::vector<int>> sectors);
62// // Begin Run, safe sectors here
63//
64// virtual void initPersistent (); // Init Persistence
65// virtual void intEvent (); // Clusters import, Sector fill
66//
67// virtual int importCluster (int pass_index, std::string died_at, std::vector<int> accepted, std::vector<int> rejected, int detector_type);
68//
69// virtual void updateSectors (int sector_ID, int pass_index, std::string died_at, std::vector<int> accepted, std::vector<int> rejected, int deltaUseCounter); //Sector update
70// virtual void updateClusters (int cluster_id, std::string died_at, std::vector<int> accepted, std::vector<int> rejected, int deltaUseCounter); //Cluster Update
71//
72// virtual int importHit (int pass_index, std::string died_at, std::vector<int> accepted, std::vector<int> rejected, std::vector<int> assigned_Cluster_IDs, int sec_id, B2Vector3D hit_position); // Hit import
73// virtual void updateHit (int hit_id, std::string died_at, std::vector<int> accepted, std::vector<int> rejected, int deltaUseCounter_TCID, std::vector<int> deltaUseCounter_cell); // Hit update
74//
75// int getParticleIDfromRelations (int pass_index, int cluster_id);
76//
77// virtual int importCell (int pass_index, std::string died_at, std::vector<int> accepted, std::vector<int> rejected, std::vector<int> assigned_Hit_IDs); // Cell Import
78// virtual void updateCell (int cellID, std::string died_at, std::vector<int> accepted, std::vector<int> rejected, int deltaUseCounter_TCID, int changeCellState, std::vector<int> neighbours); // Cell Update
79//
80// virtual int importTC (int pass_index, std::string died_at, std::vector<int> accepted, std::vector<int> rejected, std::vector<int> assigned_Cell_IDs); // TC Import
81// virtual void updateTC (int tcid, std::string died_at, std::vector<int> accepted, std::vector<int> rejected); // TC Update
82//
83// virtual void silentKill (); // For all future Updates
84// virtual void safeInformation ();
85//
86//
87
88
89
90
91 void CollectorTFInfoTest::import_sectors_standard()
92 {
93
94
95 uint sector_map_size = 40;
96
97 // Create Test Sector
98 std::map<std::pair<unsigned int, unsigned int>, std::vector<int>> sectors_display_all_pass;
99 std::vector<int> sectors_display_friends;
100
101// B2INFO ("PassNr. " << pass_sector_id_single << "Size of Sector Map: " << sector_map_size );
102
103 sectors_display_friends.clear();
104 sectors_display_all_pass.insert(std::make_pair(std::make_pair(pass_sector_id_single, 0), sectors_display_friends));
105
106 sectors_display_friends.clear();
107 sectors_display_friends.push_back(0);
108 sectors_display_all_pass.insert(std::make_pair(std::make_pair(pass_sector_id_single, 1), sectors_display_friends));
109
110 sectors_display_friends.clear();
111 sectors_display_friends.push_back(1);
112 sectors_display_all_pass.insert(std::make_pair(std::make_pair(pass_sector_id_single, 2), sectors_display_friends));
113
114 // Sector 3 - 40
115 sectors_display_friends.clear();
116 for (uint u = 3; u < sector_map_size; u++) {
117 sectors_display_all_pass.insert(std::make_pair(std::make_pair(pass_sector_id_single, u), sectors_display_friends));
118 }
119
120
121
122
123 m_collector.initPersistent();
124 m_collector.intEvent();
125 // m_collector.initSectors (sectors_display_all_pass, std::vector<double>(), std::vector<double>());
126
127 }
128
129
130 void CollectorTFInfoTest::import_clusters_standard()
131 {
132
133 uint anz_clusters_svd = 15;
134 uint anz_clusters_pxd = 15;
135
136
137 for (uint i = 0; i < anz_clusters_svd; i++) {
138 // importCluster (int pass_index, std::string died_at, int accepted, int rejected, int detector_type)
139 /*int akt_id =*/ m_collector.importCluster(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), Const::SVD, i);
140
141// B2INFO ("AKT ID SVD: " << akt_id);
142
143 }
144
145 for (uint i = 0; i < anz_clusters_pxd; i++) {
146 // importCluster (int pass_index, std::string died_at, int accepted, int rejected, int detector_type)
147 /*int akt_id = */m_collector.importCluster(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), Const::PXD, i);
148
149// B2INFO ("AKT ID PXD: " << akt_id);
150 }
151 }
152
153
154 void CollectorTFInfoTest::import_sectors_loop()
155 {
156 // Create Test Sector
157 std::map<unsigned int, std::vector<int>> sector_map;
158 uint size_of_sectors = 10;
159
160 for (uint i = 0; i < size_of_sectors; i++) {
161 sector_map.insert(std::make_pair(i, std::vector<int>()));
162 }
163
164 // 1. Sectors init
165 //KeySectors doesn't function => so pair Int int
166 std::map<std::pair<unsigned int, unsigned int>, std::vector<int>> sectors_display_all_pass;
167 std::vector<int> sectors_display_friends;
168
169 for (uint i = 0; i < pass_sector_ids.size(); i++) {
170
171 B2DEBUG(1, "PassNr. " << i << "Size of Sector Map: " << sector_map.size());
172
173 for (auto& akt_sector : sector_map) {
174 sectors_display_friends.clear();
175
176 // Friends read and store in second vector
177 for (auto& akt_friend : akt_sector.second) {
178 sectors_display_friends.push_back(akt_friend);
179 }
180 sectors_display_all_pass.insert(std::make_pair(std::make_pair(i, akt_sector.first), sectors_display_friends));
181 }
182 }
183 m_collector.initPersistent();
184 m_collector.intEvent();
185 // m_collector.initSectors (sectors_display_all_pass, std::vector<double>(), std::vector<double>());
186 }
187
188
189 void CollectorTFInfoTest::import_clusters_loop()
190 {
191 uint anz_clusters_svd = 10;
192 uint anz_clusters_pxd = 10;
193
194 for (uint index = 0; index < pass_sector_ids.size(); index++) {
195 for (uint i = 0; i < anz_clusters_svd; i++) {
196 // importCluster (int pass_index, std::string died_at, int accepted, int rejected, int detector_type)
197 /*int akt_id =*/
198 m_collector.importCluster(index, "", -1, std::vector<int>(), std::vector<int>(), Const::SVD, i);
199 }
200 for (uint i = 0; i < anz_clusters_pxd; i++) {
201 // importCluster (int pass_index, std::string died_at, int accepted, int rejected, int detector_type)
202 /*int akt_id =*/
203 m_collector.importCluster(index, "", -1, std::vector<int>(), std::vector<int>(), Const::PXD, i);
204 }
205 }
206 }
207
208 void CollectorTFInfoTest::import_hit_standard()
209 {
210 // virtual int importHit (int pass_index, std::string died_at, std::vector<int> accepted,
211 // std::vector<int> rejected, std::vector<int> assigned_Cluster_IDs,
212 // int sec_id, B2Vector3D hit_position); // Hit import_clusters
213
214 // ID 0 - 4
215 // Sector Overlap => Hitid 3,4
216 // Cluster Overlap => Hitid 7,8
217 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({1, 2, 3}), 0,
218 B2Vector3D(),
219 B2Vector3D());
220 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({4}), 2, B2Vector3D(),
221 B2Vector3D());
222 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({7}), 4, B2Vector3D(),
223 B2Vector3D());
224 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({9}), 5, B2Vector3D(),
225 B2Vector3D());
226 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({10}), 5,
227 B2Vector3D(),
228 B2Vector3D());
229
230 // ID 5 - 9
231 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({11, 12, 13}), 6,
232 B2Vector3D(),
233 B2Vector3D());
234 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({14, 15}), 7,
235 B2Vector3D(),
236 B2Vector3D());
237 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({17}), 8,
238 B2Vector3D(),
239 B2Vector3D());
240 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({17}), 9,
241 B2Vector3D(),
242 B2Vector3D());
243 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({18}), 1,
244 B2Vector3D(),
245 B2Vector3D());
246
247 // ID 10 - 14
248 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), -1, B2Vector3D(),
249 B2Vector3D());
250 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), -1, B2Vector3D(),
251 B2Vector3D());
252 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), -1, B2Vector3D(),
253 B2Vector3D());
254 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), -1, B2Vector3D(),
255 B2Vector3D());
256 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), -1, B2Vector3D(),
257 B2Vector3D());
258
259 // ID 15 - 19
260 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 19, B2Vector3D(),
261 B2Vector3D());
262 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 20, B2Vector3D(),
263 B2Vector3D());
264 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 21, B2Vector3D(),
265 B2Vector3D());
266 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 22, B2Vector3D(),
267 B2Vector3D());
268 m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 23, B2Vector3D(),
269 B2Vector3D());
270 }
271
272
273 void CollectorTFInfoTest::import_hit_loop()
274 {
275 uint anz_hits = 10;
276
277 // std::vector<int> clusters = {7, 8, 9};
278 for (uint index = 0; index < pass_sector_ids.size(); index++) {
279 for (uint i = 0; i < anz_hits; i++) {
280 // virtual int importHit (int pass_index, std::string died_at, std::vector<int> accepted,
281 // std::vector<int> rejected, std::vector<int> assigned_Cluster_IDs,
282 // int sec_id, B2Vector3D hit_position); // Hit import_clusters
283
284 /*int akt_id =*/ m_collector.importHit(index, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 1, B2Vector3D(),
285 B2Vector3D());
286 }
287 }
288 }
289
290
291 void CollectorTFInfoTest::import_cell_standard()
292 {
293 // ID 0 - 9
294 // Allowed Overlap => Cellid 2, 3 (same hit)
295 // Not allowed overlap => Cellid 7, 8 (other hit)
296
297 // Cellid 1 => overlapped Sector
298 m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({1, 2}));
299 m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({4, 5}));
300 m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({11, 9}));
301 m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({9, 10}));
302 m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>());
303 m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>());
304 m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>());
305 m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({15, 16}));
306 m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({16, 17}));
307 m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>());
308
309 // virtual int importCell (int pass_index, std::string died_at, std::vector<int> accepted, std::vector<int> rejected, std::vector<int> assigned_Hit_IDs); // Cell Import
310 }
311
312
313 void CollectorTFInfoTest::import_cell_loop()
314 {
315 uint anz_cell = 10;
316 std::vector<int> hits = {1, 2, 3};
317
318 for (uint index = 0; index < pass_sector_ids.size(); index++) {
319 for (uint i = 0; i < anz_cell; i++) {
320 // virtual int importCell (int pass_index, std::string died_at, std::vector<int> accepted,
321 // std::vector<int> rejected, std::vector<int> assigned_Hit_IDs); // Cell Import
322 /*int akt_id =*/ m_collector.importCell(index, "", -1, std::vector<int>(), std::vector<int>(), hits);
323 }
324 }
325 }
326
327 void CollectorTFInfoTest::import_tfc_standard()
328 {
329 std::vector<std::pair<int, unsigned int>> cells0 = {std::make_pair(0, 0)};
330 std::vector<std::pair<int, unsigned int>> cells1 = {std::make_pair(1, 1)};
331 std::vector<std::pair<int, unsigned int>> cells23 = {std::make_pair(2, 2), std::make_pair(3, 3)};
332 std::vector<std::pair<int, unsigned int>> cells79 = {std::make_pair(7, 7), std::make_pair(9, 9)};
333 std::vector<std::pair<int, unsigned int>> cells8 = {std::make_pair(8, 8)};
334
335 // ID 1 = Sector overlapped
336 // ID 2 = allowed overlapping (Cells)
337 // ID 3, 4 = not allowed overlapping (Cells)
338 m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), cells0);
339 m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), cells1);
340 m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), cells23);
341 m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), cells79);
342 m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), cells8);
343
344 m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(),
345 std::vector<std::pair<int, unsigned int>>({}));
346 m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(),
347 std::vector<std::pair<int, unsigned int>>({}));
348 m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(),
349 std::vector<std::pair<int, unsigned int>>({}));
350 m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(),
351 std::vector<std::pair<int, unsigned int>>({}));
352 m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(),
353 std::vector<std::pair<int, unsigned int>>({}));
354 }
355
356
357 void CollectorTFInfoTest::import_tfc_loop()
358 {
359 uint anz_tfc = 10;
360 std::vector<std::pair<int, unsigned int>> cells = {std::make_pair(1, 1), std::make_pair(2, 2), std::make_pair(3, 3)};
361
362 for (uint index = 0; index < pass_sector_ids.size(); index++) {
363 for (uint i = 0; i < anz_tfc; i++) {
364 // int passIndex, std::string diedAt, int diedId, std::vector<int> accepted, std::vector<int> rejected,
365 // const std::vector<std::pair<int, unsigned int>> assignedCellIDs
366 // TC Import
367 /*int akt_id =*/ m_collector.importTC(index, "", -1, std::vector<int>(), std::vector<int>(), cells);
368 }
369 }
370 }
371
372
373 // Output of all interesting Information of Cells
374 void CollectorTFInfoTest::getAllCells()
375 {
376 for (uint i = 0; i < m_collector.m_cellTF.size(); i++) {
377 B2INFO("* Cell ID: " << i << "; active: " << m_collector.m_cellTF[i].getActive() << ", died_at: " <<
378 m_collector.m_cellTF[i].getDiedAt() << "; m_assigned_hits_ids - size: " << m_collector.m_cellTF[i].getAssignedHits().size() <<
379 "; Neighbours - size: " << m_collector.m_cellTF[i].getNeighbours().size() << "; State: " << m_collector.m_cellTF[i].getState() <<
380 "; use counter: " << m_collector.m_cellTF[i].getUseCounter());
381 }
382 }
383
384
385 // Output of all interesting Information of Hits
386 void CollectorTFInfoTest::getAllHits()
387 {
388 for (uint i = 0; i < m_collector.m_hitTF.size(); i++) {
389 B2INFO("* Hit ID: " << i << "; active: " << m_collector.m_hitTF[i].getActive() << ", died_at: " <<
390 m_collector.m_hitTF[i].getDiedAt() << "; m_assigned_cluster - size: " << m_collector.m_hitTF[i].getAssignedCluster().size() <<
391 "; UseTC IDs - size: " << m_collector.m_hitTF[i].getUseCounterTCIDs().size() <<
392 "; use counter: " << m_collector.m_hitTF[i].getUseCounter() << "; SectorID: " << m_collector.m_hitTF[i].getSectorID());
393 }
394 }
395
396 // Output of all interesting Information of Clusters
397 void CollectorTFInfoTest::getAllClusters()
398 {
399 for (uint i = 0; i < m_collector.m_clustersTF.size(); i++) {
400 B2INFO("* Cluster ID: " << i << "; active: " << m_collector.m_clustersTF[i].getActive() << ", died_at: " <<
401 m_collector.m_clustersTF[i].getDiedAt() << "; Real Cluster ID: " <<
402 m_collector.m_clustersTF[i].getRealClusterID() << "; Detector Type: "
403 << m_collector.m_clustersTF[i].getDetectorType() << "; use counter: " << m_collector.m_clustersTF[i].getUseCounter());
404 }
405 }
406
407
408 // Output of all interesting Information of TC
409 void CollectorTFInfoTest::getAllTC()
410 {
411 for (uint i = 0; i < m_collector.m_tfCandTF.size(); i++) {
412 B2INFO("* TC ID: " << i << "; active: " << m_collector.m_tfCandTF[i].getActive() << ", died_at: " <<
413 m_collector.m_tfCandTF[i].getDiedAt() << "; Own ID: " <<
414 m_collector.m_tfCandTF[i].getOwnID() << "; AssignedCells - size: " <<
415 m_collector.m_tfCandTF[i].getAssignedCell().size());
416 }
417 }
418
419
420 // Output of all interesting Information of Sectors
421 void CollectorTFInfoTest::getAllSectors()
422 {
423 for (auto& akt_sector : m_collector.m_sectorTF) {
424 B2INFO("* Sector ID: " << akt_sector.second.getSectorID() << "; active: " << akt_sector.second.getActive() << ", died_at: " <<
425 akt_sector.second.getDiedAt() << "; is only friend: " <<
426 akt_sector.second.getIsOnlyFriend() << "; Friends - size: "
427 << akt_sector.second.getFriends().size() << "; use counter: " << akt_sector.second.getUseCounter());
428 }
429 }
430
431
432 /*
433 //TEST SILENT KILL
434 TEST_F(CollectorTFInfoTest, testSilentKill){
435
436 import_sectors_standard();
437
438 import_clusters_standard();
439
440 import_hit_standard ();
441
442 // virtual void updateHit (int hit_id, std::string died_at, std::vector<int> accepted, std::vector<int> rejected, int deltaUseCounter_TCID, std::vector<int> deltaUseCounter_cell); // Hit updateCell
443
444 import_cell_standard();
445
446 // for (int i = 0; i < m_collector.m_cellTF.size(); i++) {
447 // B2INFO ("cell => hits size: " << m_collector.m_cellTF[i].getAssignedHits().size() );
448 //
449 // }
450
451
452 // virtual void updateCell (int cellID, std::string died_at, std::vector<int> accepted, std::vector<int> rejected, int deltaUseCounter_TCID, int changeCellState, std::vector<int> neighbours); // Cell Updates
453
454
455 import_tfc_standard();
456
457 // for (int i = 0; i < m_collector.m_tfCandTF.size(); i++) {
458 // B2INFO ("TfCand: " << i << "; active: " << m_collector.m_tfCandTF[i].getActive() << ", ass_cells - size: " << m_collector.m_tfCandTF[i].getAssignedCell().size() );
459 // }
460 //
461
462 // for (int i = 0; i < m_collector.m_cellTF.size(); i++) {
463 // B2INFO ("Before Silent Kill Cell ID: " << i << "; active: " << m_collector.m_cellTF[i].getActive() );
464 // }
465 //
466 // for (int i = 0; i < m_collector.m_hitTF.size(); i++) {
467 // B2INFO ("Before Silent Kill Hit ID: " << i << "; active: " << m_collector.m_hitTF[i].getActive());
468 // }
469
470 // for (int i = 0; i < m_collector.m_clustersTF.size(); i++) {
471 // B2INFO ("Before Silent Kill Cluster ID: " << i << "; active: " << m_collector.m_clustersTF[i].getActive() );
472 // }
473
474 m_collector.silentKill();
475
476 int cells_live = 0;
477
478 for (uint i = 0; i < m_collector.m_cellTF.size(); i++) {
479 cells_live += m_collector.m_cellTF[i].getActive();
480 // B2INFO ("After Silent Kill Cell ID: " << i << "; active: " << m_collector.m_cellTF[i].getActive() );
481 }
482
483 int hit_live = 0;
484 for (uint i = 0; i < m_collector.m_hitTF.size(); i++) {
485 hit_live += m_collector.m_hitTF[i].getActive();
486 // B2INFO ("After Silent Kill Hit ID: " << i << "; active: " << m_collector.m_hitTF[i].getActive() << ", diet_at: " << m_collector.m_hitTF[i].getDiedAt() );
487 }
488
489 B2INFO ("hit_live " << hit_live);
490 B2INFO ("cells_live: " << cells_live);
491
492 // Active Hits after Silent Kill
493 ASSERT_EQ(10, hit_live );
494
495 // Active Cells after Silent Kill
496 ASSERT_EQ(7, cells_live );
497
498 // for (int i = 0; i < m_collector.m_clustersTF.size(); i++) {
499 // B2INFO ("After Silent Kill Cluster ID: " << i << "; active: " << m_collector.m_clustersTF[i].getActive() );
500 // }
501
502
503 }
504
505 */
506
507// //TESTs the overlapping logic
508// TEST_F(CollectorTFInfoTest, testOverlapped){
509//
510// import_sectors_standard();
511//
512// import_clusters_standard();
513//
514// import_hit_standard ();
515//
516// import_cell_standard();
517//
518// import_tfc_standard();
519//
520// // Hit ID
521// // ID 0 - 4
522// // Sector Overlap => Hitid 3,4
523// // Cluster Overlap => Hitid 7,8
524//
525// bool false_item = false;
526// bool true_item = true;
527//
528// ASSERT_EQ(false_item, m_collector.isHitOverlapped(1) );
529// ASSERT_EQ(false_item, m_collector.isHitOverlapped(2) );
530// ASSERT_EQ(true_item, m_collector.isHitOverlapped(3) );
531// ASSERT_EQ(true_item, m_collector.isHitOverlapped(4) );
532// ASSERT_EQ(true_item, m_collector.isHitOverlapped(7) );
533// ASSERT_EQ(true_item, m_collector.isHitOverlapped(8) );
534//
535// for (uint i = 0; i < m_collector.m_hitTF.size(); i++) {
536// B2INFO ("Hit ID: " << i << "; overlapped: " << m_collector.isHitOverlapped(i));
537// }
538//
539// // Cell IDs
540// // Allowed Overlap => Cellid 2, 3 (same hit)
541// // Not allowed overlap => Cellid 7, 8 (other hit)
542//
543// ASSERT_EQ(false_item, m_collector.isCellOverlapped(2) );
544// ASSERT_EQ(false_item, m_collector.isCellOverlapped(3) );
545// ASSERT_EQ(true_item, m_collector.isCellOverlapped(7) );
546// ASSERT_EQ(true_item, m_collector.isCellOverlapped(8) );
547//
548//
549// for (uint i = 0; i < m_collector.m_cellTF.size(); i++) {
550// B2INFO ("Cell ID: " << i << "; overlapped: " << m_collector.isCellOverlapped(i));
551// }
552//
553// // TfCand
554// // ID 1 = Sector overlapped
555// // ID 2 = allowed overlapping (Cells)
556// // ID 3, 4 = not allowed overlapping (Cells)
557//
558// ASSERT_EQ(true_item, m_collector.isTCOverlapped(1) );
559// ASSERT_EQ(false_item, m_collector.isTCOverlapped(2) );
560// ASSERT_EQ(true_item, m_collector.isTCOverlapped(3) );
561// ASSERT_EQ(true_item, m_collector.isTCOverlapped(4) );
562//
563// for (uint i = 0; i < m_collector.m_tfCandTF.size(); i++) {
564// B2INFO ("TC ID: " << i << "; overlapped: " << m_collector.isTCOverlapped(i));
565// }
566//
567// // getAllSectors ();
568// // getAllClusters ();
569// // getAllHits ();
570// // getAllCells();
571// // getAllTC ();
572//
573//
574//
575// }
576//
577
579 TEST_F(CollectorTFInfoTest, testAllInformationLoop)
580 {
581 bool false_item = false;
582 bool true_item = true;
583
584 import_sectors_loop();
585
586 import_clusters_loop();
587
588 m_collector.updateSectors(4, 1, "geloescht", 0, std::vector<int>(), std::vector<int>(), 0);
589
590 m_collector.updateClusters(3, "geloescht", 0, std::vector<int>(), std::vector<int>(), 0);
591
592 ASSERT_EQ("geloescht", m_collector.m_clustersTF[3].getDiedAt());
593 ASSERT_EQ(false_item, m_collector.m_clustersTF[3].getActive());
594
595 import_hit_loop();
596
597 m_collector.updateHit(1, "geloescht", 0, std::vector<int>(), std::vector<int>(), -1, -1, std::vector<int>());
598
599 ASSERT_EQ("geloescht", m_collector.m_hitTF[1].getDiedAt());
600 ASSERT_EQ(false_item, m_collector.m_hitTF[1].getActive());
601 ASSERT_EQ(true_item, m_collector.m_hitTF[2].getActive());
602
603 import_cell_loop();
604 m_collector.updateCell(3, "geloescht", 2, std::vector<int>(), std::vector<int>(), -1, -1, 0, std::vector<int>());
605
606 ASSERT_EQ("geloescht", m_collector.m_cellTF[3].getDiedAt());
607 ASSERT_EQ(false_item, m_collector.m_cellTF[3].getActive());
608 ASSERT_EQ(true_item, m_collector.m_cellTF[1].getActive());
609
610 import_tfc_loop();
611
612 m_collector.updateTC(2, "geloescht", 4, std::vector<int>(), std::vector<int>());
613
614 ASSERT_EQ("geloescht", m_collector.m_tfCandTF[2].getDiedAt());
615 ASSERT_EQ(false_item, m_collector.m_tfCandTF[2].getActive());
616 ASSERT_EQ(true_item, m_collector.m_tfCandTF[1].getActive());
617 }
619}
Belle2::CollectorTFInfoTest
Set up a few arrays and objects in the datastore.
Definition: collectortfinfo.h:20
Belle2::CollectorTFInfoTest::pass_sector_ids
std::vector< int > pass_sector_ids
fixed vector of pass indices (values are never used)
Definition: collectortfinfo.h:53
Belle2::CollectorTFInfoTest::m_collector
CollectorTFInfo m_collector
cached ref to CollectorTFInfo()
Definition: collectortfinfo.h:51
Belle2::CollectorTFInfoTest::pass_sector_id_single
int pass_sector_id_single
fixed index for beginning pass
Definition: collectortfinfo.h:54
Belle2::B2Vector3D
B2Vector3< double > B2Vector3D
typedef for common usage with double
Definition: B2Vector3.h:516
Belle2::CollectorTFInfoTest::import_hit_standard
void import_hit_standard()
dummy comment: import_hit_standard
Definition: collectortfinfo.h:208
Belle2::CollectorTFInfoTest::import_clusters_standard
void import_clusters_standard()
dummy comment: import_clusters_standard
Definition: collectortfinfo.h:130
Belle2::CollectorTFInfoTest::import_clusters_loop
void import_clusters_loop()
dummy comment: import_clusters_loop
Definition: collectortfinfo.h:189
Belle2::CollectorTFInfoTest::getAllSectors
void getAllSectors()
Output of all interesting Information of Sectors.
Definition: collectortfinfo.h:421
Belle2::CollectorTFInfoTest::import_tfc_standard
void import_tfc_standard()
dummy comment: import_tfc_standard
Definition: collectortfinfo.h:327
Belle2::CollectorTFInfoTest::import_sectors_standard
void import_sectors_standard()
dummy comment: import_sectors_standard
Definition: collectortfinfo.h:91
Belle2::CollectorTFInfoTest::import_cell_loop
void import_cell_loop()
dummy comment: import_cell_loop
Definition: collectortfinfo.h:313
Belle2::CollectorTFInfoTest::getAllTC
void getAllTC()
Output of all interesting Information of TC.
Definition: collectortfinfo.h:409
Belle2::CollectorTFInfoTest::import_hit_loop
void import_hit_loop()
dummy comment: import_hit_loop
Definition: collectortfinfo.h:273
Belle2::CollectorTFInfoTest::import_tfc_loop
void import_tfc_loop()
dummy comment: import_tfc_loop
Definition: collectortfinfo.h:357
Belle2::CollectorTFInfoTest::import_cell_standard
void import_cell_standard()
dummy comment: import_cell_standard
Definition: collectortfinfo.h:291
Belle2::CollectorTFInfoTest::import_sectors_loop
void import_sectors_loop()
Documentation Comment Jakob Lettenbichler: this was written by a student and will be removed after fi...
Definition: collectortfinfo.h:154
Belle2::CollectorTFInfoTest::getAllClusters
void getAllClusters()
Output of all interesting Information of Clusters.
Definition: collectortfinfo.h:397
Belle2::CollectorTFInfoTest::getAllHits
void getAllHits()
Output of all interesting Information of Hits.
Definition: collectortfinfo.h:386
Belle2::CollectorTFInfoTest::getAllCells
void getAllCells()
Output of all interesting Information of Cells.
Definition: collectortfinfo.h:374
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17