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