Belle II Software  release-06-01-15
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 
13 namespace 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 //************** METHODES of the Collector
61 // virtual void initSectors (std::map<std::pair<unsigned int, unsigned int>, std::vector<int>> sectors);
62 // // Beginn 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, TVector3 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 (); // Für alle folgenden 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 dosn'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, TVector3 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  TVector3(),
219  TVector3());
220  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({4}), 2, TVector3(),
221  TVector3());
222  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({7}), 4, TVector3(),
223  TVector3());
224  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({9}), 5, TVector3(),
225  TVector3());
226  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({10}), 5, TVector3(),
227  TVector3());
228 
229  // ID 5 - 9
230  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({11, 12, 13}), 6,
231  TVector3(),
232  TVector3());
233  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({14, 15}), 7,
234  TVector3(),
235  TVector3());
236  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({17}), 8, TVector3(),
237  TVector3());
238  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({17}), 9, TVector3(),
239  TVector3());
240  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({18}), 1, TVector3(),
241  TVector3());
242 
243  // ID 10 - 14
244  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), -1, TVector3(),
245  TVector3());
246  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), -1, TVector3(),
247  TVector3());
248  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), -1, TVector3(),
249  TVector3());
250  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), -1, TVector3(),
251  TVector3());
252  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), -1, TVector3(),
253  TVector3());
254 
255  // ID 15 - 19
256  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 19, TVector3(),
257  TVector3());
258  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 20, TVector3(),
259  TVector3());
260  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 21, TVector3(),
261  TVector3());
262  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 22, TVector3(),
263  TVector3());
264  m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 23, TVector3(),
265  TVector3());
266  }
267 
268 
269  void CollectorTFInfoTest::import_hit_loop()
270  {
271  uint anz_hits = 10;
272 
273  // std::vector<int> clusters = {7, 8, 9};
274  for (uint index = 0; index < pass_sector_ids.size(); index++) {
275  for (uint i = 0; i < anz_hits; i++) {
276  // virtual int importHit (int pass_index, std::string died_at, std::vector<int> accepted,
277  // std::vector<int> rejected, std::vector<int> assigned_Cluster_IDs,
278  // int sec_id, TVector3 hit_position); // Hit import_clusters
279 
280  /*int akt_id =*/ m_collector.importHit(index, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 1, TVector3(),
281  TVector3());
282  }
283  }
284  }
285 
286 
287  void CollectorTFInfoTest::import_cell_standard()
288  {
289  // ID 0 - 9
290  // Allowed Overlap => Cellid 2, 3 (same hit)
291  // Not allowed overlap => Cellid 7, 8 (other hit)
292 
293  // Cellid 1 => overlapped Sector
294  m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({1, 2}));
295  m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({4, 5}));
296  m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({11, 9}));
297  m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({9, 10}));
298  m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>());
299  m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>());
300  m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>());
301  m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({15, 16}));
302  m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({16, 17}));
303  m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>());
304 
305  // 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
306  }
307 
308 
309  void CollectorTFInfoTest::import_cell_loop()
310  {
311  uint anz_cell = 10;
312  std::vector<int> hits = {1, 2, 3};
313 
314  for (uint index = 0; index < pass_sector_ids.size(); index++) {
315  for (uint i = 0; i < anz_cell; i++) {
316  // virtual int importCell (int pass_index, std::string died_at, std::vector<int> accepted,
317  // std::vector<int> rejected, std::vector<int> assigned_Hit_IDs); // Cell Import
318  /*int akt_id =*/ m_collector.importCell(index, "", -1, std::vector<int>(), std::vector<int>(), hits);
319  }
320  }
321  }
322 
323  void CollectorTFInfoTest::import_tfc_standard()
324  {
325  std::vector<std::pair<int, unsigned int>> cells0 = {std::make_pair(0, 0)};
326  std::vector<std::pair<int, unsigned int>> cells1 = {std::make_pair(1, 1)};
327  std::vector<std::pair<int, unsigned int>> cells23 = {std::make_pair(2, 2), std::make_pair(3, 3)};
328  std::vector<std::pair<int, unsigned int>> cells79 = {std::make_pair(7, 7), std::make_pair(9, 9)};
329  std::vector<std::pair<int, unsigned int>> cells8 = {std::make_pair(8, 8)};
330 
331  // ID 1 = Sector overlapped
332  // ID 2 = allowed overlapping (Cells)
333  // ID 3, 4 = not allowed overlapping (Cells)
334  m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), cells0);
335  m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), cells1);
336  m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), cells23);
337  m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), cells79);
338  m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), cells8);
339 
340  m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(),
341  std::vector<std::pair<int, unsigned int>>({}));
342  m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(),
343  std::vector<std::pair<int, unsigned int>>({}));
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  }
351 
352 
353  void CollectorTFInfoTest::import_tfc_loop()
354  {
355  uint anz_tfc = 10;
356  std::vector<std::pair<int, unsigned int>> cells = {std::make_pair(1, 1), std::make_pair(2, 2), std::make_pair(3, 3)};
357 
358  for (uint index = 0; index < pass_sector_ids.size(); index++) {
359  for (uint i = 0; i < anz_tfc; i++) {
360  // int passIndex, std::string diedAt, int diedId, std::vector<int> accepted, std::vector<int> rejected,
361  // const std::vector<std::pair<int, unsigned int>> assignedCellIDs
362  // TC Import
363  /*int akt_id =*/ m_collector.importTC(index, "", -1, std::vector<int>(), std::vector<int>(), cells);
364  }
365  }
366  }
367 
368 
369  // Output of all interesting Information of Cells
370  void CollectorTFInfoTest::getAllCells()
371  {
372  for (uint i = 0; i < m_collector.m_cellTF.size(); i++) {
373  B2INFO("* Cell ID: " << i << "; active: " << m_collector.m_cellTF[i].getActive() << ", died_at: " <<
374  m_collector.m_cellTF[i].getDiedAt() << "; m_assigned_hits_ids - size: " << m_collector.m_cellTF[i].getAssignedHits().size() <<
375  "; Neighbours - size: " << m_collector.m_cellTF[i].getNeighbours().size() << "; State: " << m_collector.m_cellTF[i].getState() <<
376  "; use counter: " << m_collector.m_cellTF[i].getUseCounter());
377  }
378  }
379 
380 
381  // Output of all interesting Information of Hits
382  void CollectorTFInfoTest::getAllHits()
383  {
384  for (uint i = 0; i < m_collector.m_hitTF.size(); i++) {
385  B2INFO("* Hit ID: " << i << "; active: " << m_collector.m_hitTF[i].getActive() << ", died_at: " <<
386  m_collector.m_hitTF[i].getDiedAt() << "; m_assigned_cluster - size: " << m_collector.m_hitTF[i].getAssignedCluster().size() <<
387  "; UseTC IDs - size: " << m_collector.m_hitTF[i].getUseCounterTCIDs().size() <<
388  "; use counter: " << m_collector.m_hitTF[i].getUseCounter() << "; SectorID: " << m_collector.m_hitTF[i].getSectorID());
389  }
390  }
391 
392  // Output of all interesting Information of Clusters
393  void CollectorTFInfoTest::getAllClusters()
394  {
395  for (uint i = 0; i < m_collector.m_clustersTF.size(); i++) {
396  B2INFO("* Cluster ID: " << i << "; active: " << m_collector.m_clustersTF[i].getActive() << ", died_at: " <<
397  m_collector.m_clustersTF[i].getDiedAt() << "; Real Cluster ID: " <<
398  m_collector.m_clustersTF[i].getRealClusterID() << "; Detector Type: "
399  << m_collector.m_clustersTF[i].getDetectorType() << "; use counter: " << m_collector.m_clustersTF[i].getUseCounter());
400  }
401  }
402 
403 
404  // Output of all interesting Information of TC
405  void CollectorTFInfoTest::getAllTC()
406  {
407  for (uint i = 0; i < m_collector.m_tfCandTF.size(); i++) {
408  B2INFO("* TC ID: " << i << "; active: " << m_collector.m_tfCandTF[i].getActive() << ", died_at: " <<
409  m_collector.m_tfCandTF[i].getDiedAt() << "; Own ID: " <<
410  m_collector.m_tfCandTF[i].getOwnID() << "; AssignedCells - size: " <<
411  m_collector.m_tfCandTF[i].getAssignedCell().size());
412  }
413  }
414 
415 
416  // Output of all interesting Information of Sectors
417  void CollectorTFInfoTest::getAllSectors()
418  {
419  for (auto& akt_sector : m_collector.m_sectorTF) {
420  B2INFO("* Sector ID: " << akt_sector.second.getSectorID() << "; active: " << akt_sector.second.getActive() << ", died_at: " <<
421  akt_sector.second.getDiedAt() << "; is only friend: " <<
422  akt_sector.second.getIsOnlyFriend() << "; Friends - size: "
423  << akt_sector.second.getFriends().size() << "; use counter: " << akt_sector.second.getUseCounter());
424  }
425  }
426 
427 
428  /*
429  //TEST SILENT KILL
430  TEST_F(CollectorTFInfoTest, testSilentKill){
431 
432  import_sectors_standard();
433 
434  import_clusters_standard();
435 
436  import_hit_standard ();
437 
438  // 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
439 
440  import_cell_standard();
441 
442  // for (int i = 0; i < m_collector.m_cellTF.size(); i++) {
443  // B2INFO ("cell => hits size: " << m_collector.m_cellTF[i].getAssignedHits().size() );
444  //
445  // }
446 
447 
448  // 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
449 
450 
451  import_tfc_standard();
452 
453  // for (int i = 0; i < m_collector.m_tfCandTF.size(); i++) {
454  // B2INFO ("TfCand: " << i << "; active: " << m_collector.m_tfCandTF[i].getActive() << ", ass_cells - size: " << m_collector.m_tfCandTF[i].getAssignedCell().size() );
455  // }
456  //
457 
458  // for (int i = 0; i < m_collector.m_cellTF.size(); i++) {
459  // B2INFO ("Before Silent Kill Cell ID: " << i << "; active: " << m_collector.m_cellTF[i].getActive() );
460  // }
461  //
462  // for (int i = 0; i < m_collector.m_hitTF.size(); i++) {
463  // B2INFO ("Before Silent Kill Hit ID: " << i << "; active: " << m_collector.m_hitTF[i].getActive());
464  // }
465 
466  // for (int i = 0; i < m_collector.m_clustersTF.size(); i++) {
467  // B2INFO ("Before Silent Kill Cluster ID: " << i << "; active: " << m_collector.m_clustersTF[i].getActive() );
468  // }
469 
470  m_collector.silentKill();
471 
472  int cells_live = 0;
473 
474  for (uint i = 0; i < m_collector.m_cellTF.size(); i++) {
475  cells_live += m_collector.m_cellTF[i].getActive();
476  // B2INFO ("After Silent Kill Cell ID: " << i << "; active: " << m_collector.m_cellTF[i].getActive() );
477  }
478 
479  int hit_live = 0;
480  for (uint i = 0; i < m_collector.m_hitTF.size(); i++) {
481  hit_live += m_collector.m_hitTF[i].getActive();
482  // B2INFO ("After Silent Kill Hit ID: " << i << "; active: " << m_collector.m_hitTF[i].getActive() << ", diet_at: " << m_collector.m_hitTF[i].getDiedAt() );
483  }
484 
485  B2INFO ("hit_live " << hit_live);
486  B2INFO ("cells_live: " << cells_live);
487 
488  // Active Hits after Silent Kill
489  ASSERT_EQ(10, hit_live );
490 
491  // Active Cells after Silent Kill
492  ASSERT_EQ(7, cells_live );
493 
494  // for (int i = 0; i < m_collector.m_clustersTF.size(); i++) {
495  // B2INFO ("After Silent Kill Cluster ID: " << i << "; active: " << m_collector.m_clustersTF[i].getActive() );
496  // }
497 
498 
499  }
500 
501  */
502 
503 // //TESTs the overlapping logic
504 // TEST_F(CollectorTFInfoTest, testOverlapped){
505 //
506 // import_sectors_standard();
507 //
508 // import_clusters_standard();
509 //
510 // import_hit_standard ();
511 //
512 // import_cell_standard();
513 //
514 // import_tfc_standard();
515 //
516 // // Hit ID
517 // // ID 0 - 4
518 // // Sector Overlap => Hitid 3,4
519 // // Cluster Overlap => Hitid 7,8
520 //
521 // bool false_item = false;
522 // bool true_item = true;
523 //
524 // ASSERT_EQ(false_item, m_collector.isHitOverlapped(1) );
525 // ASSERT_EQ(false_item, m_collector.isHitOverlapped(2) );
526 // ASSERT_EQ(true_item, m_collector.isHitOverlapped(3) );
527 // ASSERT_EQ(true_item, m_collector.isHitOverlapped(4) );
528 // ASSERT_EQ(true_item, m_collector.isHitOverlapped(7) );
529 // ASSERT_EQ(true_item, m_collector.isHitOverlapped(8) );
530 //
531 // for (uint i = 0; i < m_collector.m_hitTF.size(); i++) {
532 // B2INFO ("Hit ID: " << i << "; overlapped: " << m_collector.isHitOverlapped(i));
533 // }
534 //
535 // // Cell IDs
536 // // Allowed Overlap => Cellid 2, 3 (same hit)
537 // // Not allowed overlap => Cellid 7, 8 (other hit)
538 //
539 // ASSERT_EQ(false_item, m_collector.isCellOverlapped(2) );
540 // ASSERT_EQ(false_item, m_collector.isCellOverlapped(3) );
541 // ASSERT_EQ(true_item, m_collector.isCellOverlapped(7) );
542 // ASSERT_EQ(true_item, m_collector.isCellOverlapped(8) );
543 //
544 //
545 // for (uint i = 0; i < m_collector.m_cellTF.size(); i++) {
546 // B2INFO ("Cell ID: " << i << "; overlapped: " << m_collector.isCellOverlapped(i));
547 // }
548 //
549 // // TfCand
550 // // ID 1 = Sector overlapped
551 // // ID 2 = allowed overlapping (Cells)
552 // // ID 3, 4 = not allowed overlapping (Cells)
553 //
554 // ASSERT_EQ(true_item, m_collector.isTCOverlapped(1) );
555 // ASSERT_EQ(false_item, m_collector.isTCOverlapped(2) );
556 // ASSERT_EQ(true_item, m_collector.isTCOverlapped(3) );
557 // ASSERT_EQ(true_item, m_collector.isTCOverlapped(4) );
558 //
559 // for (uint i = 0; i < m_collector.m_tfCandTF.size(); i++) {
560 // B2INFO ("TC ID: " << i << "; overlapped: " << m_collector.isTCOverlapped(i));
561 // }
562 //
563 // // getAllSectors ();
564 // // getAllClusters ();
565 // // getAllHits ();
566 // // getAllCells();
567 // // getAllTC ();
568 //
569 //
570 //
571 // }
572 //
573 
575  TEST_F(CollectorTFInfoTest, testAllInformationLoop)
576  {
577  bool false_item = false;
578  bool true_item = true;
579 
580  import_sectors_loop();
581 
582  import_clusters_loop();
583 
584  m_collector.updateSectors(4, 1, "geloescht", 0, std::vector<int>(), std::vector<int>(), 0);
585 
586  m_collector.updateClusters(3, "geloescht", 0, std::vector<int>(), std::vector<int>(), 0);
587 
588  ASSERT_EQ("geloescht", m_collector.m_clustersTF[3].getDiedAt());
589  ASSERT_EQ(false_item, m_collector.m_clustersTF[3].getActive());
590 
591  import_hit_loop();
592 
593  m_collector.updateHit(1, "geloescht", 0, std::vector<int>(), std::vector<int>(), -1, -1, std::vector<int>());
594 
595  ASSERT_EQ("geloescht", m_collector.m_hitTF[1].getDiedAt());
596  ASSERT_EQ(false_item, m_collector.m_hitTF[1].getActive());
597  ASSERT_EQ(true_item, m_collector.m_hitTF[2].getActive());
598 
599  import_cell_loop();
600  m_collector.updateCell(3, "geloescht", 2, std::vector<int>(), std::vector<int>(), -1, -1, 0, std::vector<int>());
601 
602  ASSERT_EQ("geloescht", m_collector.m_cellTF[3].getDiedAt());
603  ASSERT_EQ(false_item, m_collector.m_cellTF[3].getActive());
604  ASSERT_EQ(true_item, m_collector.m_cellTF[1].getActive());
605 
606  import_tfc_loop();
607 
608  m_collector.updateTC(2, "geloescht", 4, std::vector<int>(), std::vector<int>());
609 
610  ASSERT_EQ("geloescht", m_collector.m_tfCandTF[2].getDiedAt());
611  ASSERT_EQ(false_item, m_collector.m_tfCandTF[2].getActive());
612  ASSERT_EQ(true_item, m_collector.m_tfCandTF[1].getActive());
613  }
615 }
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::TEST_F
TEST_F(GlobalLabelTest, LargeNumberOfTimeDependentParameters)
Test large number of time-dep params for registration and retrieval.
Definition: globalLabel.cc:72
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:417
Belle2::CollectorTFInfoTest::import_tfc_standard
void import_tfc_standard()
dummy comment: import_tfc_standard
Definition: collectortfinfo.h:323
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:309
Belle2::CollectorTFInfoTest::getAllTC
void getAllTC()
Output of all interesting Information of TC.
Definition: collectortfinfo.h:405
Belle2::CollectorTFInfoTest::import_hit_loop
void import_hit_loop()
dummy comment: import_hit_loop
Definition: collectortfinfo.h:269
Belle2::CollectorTFInfoTest::import_tfc_loop
void import_tfc_loop()
dummy comment: import_tfc_loop
Definition: collectortfinfo.h:353
Belle2::CollectorTFInfoTest::import_cell_standard
void import_cell_standard()
dummy comment: import_cell_standard
Definition: collectortfinfo.h:287
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:393
Belle2::CollectorTFInfoTest::getAllHits
void getAllHits()
Output of all interesting Information of Hits.
Definition: collectortfinfo.h:382
Belle2::CollectorTFInfoTest::getAllCells
void getAllCells()
Output of all interesting Information of Cells.
Definition: collectortfinfo.h:370
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17