Belle II Software  release-05-01-25
directedNodeNetwork.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2015 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Jakob Lettenbichler (jakob.lettenbichler@oeaw.ac.at) *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <gtest/gtest.h>
12 
13 #include <tracking/trackFindingVXD/segmentNetwork/DirectedNode.h>
14 #include <tracking/trackFindingVXD/segmentNetwork/DirectedNodeNetwork.h>
15 #include <tracking/trackFindingVXD/segmentNetwork/DirectedNodeNetworkContainer.h>
16 
17 #include <vxd/geometry/SensorInfoBase.h>
18 #include <pxd/dataobjects/PXDCluster.h>
19 #include <framework/datastore/StoreArray.h>
20 #include <framework/datastore/StoreObjPtr.h>
21 #include <tracking/spacePointCreation/SpacePoint.h>
22 #include <tracking/spacePointCreation/SpacePointTrackCand.h>
23 
24 
25 #include <array>
26 #include <iostream>
27 #include <deque>
28 
29 using namespace std;
30 using namespace Belle2;
31 
38 namespace DirectedNodeNetworkTests {
39 
40 
42  VXD::SensorInfoBase provideSensorInfo(VxdID aVxdID, double globalX = 0., double globalY = 0., double globalZ = -0.)
43  {
44  // (SensorType type, VxdID id, double width, double length, double thickness, int uCells, int vCells, double width2=-1, double splitLength=-1, int vCells2=0)
45  VXD::SensorInfoBase sensorInfoBase(VXD::SensorInfoBase::PXD, aVxdID, 2.3, 4.2, 0.3, 2, 4, -1);
46 
47  TGeoRotation r1;
48  r1.SetAngles(45, 20, 30); // rotation defined by Euler angles
49  TGeoTranslation t1(globalX, globalY, globalZ);
50  TGeoCombiTrans c1(t1, r1);
51  TGeoHMatrix transform = c1;
52  sensorInfoBase.setTransformation(transform);
53 
54  return sensorInfoBase;
55  }
56 
57 
59  PXDCluster providePXDCluster(double u, double v, VxdID aVxdID, double uError = 0.1, double vError = 0.1)
60  {
61  return PXDCluster(aVxdID, u, v, uError, vError, 0, 0, 1, 1, 1, 1 , 1, 1);
62  }
63 
68  class DirectedNodeNetworkTest : public ::testing::Test {
69  protected:
70 
72  virtual void SetUp()
73  {
74  DataStore::Instance().setInitializeActive(true);
75 
76  m_spacePointData.registerInDataStore();
77  m_pxdClusterData.registerInDataStore();
78  m_spacePointTrackCandData.registerInDataStore();
79 
80  m_spacePointData.registerRelationTo(m_pxdClusterData);
81 
82  m_networkContainerInDataStore.registerInDataStore();
83  StoreObjPtr<DirectedNodeNetworkContainer> networkContainerInDataStore;
84 
85  DataStore::Instance().setInitializeActive(false);
86 
87  unsigned int nHits = 5;
88 
90  for (unsigned int i = 1; i <= nHits; ++i) { //
91 
92  VxdID aVxdID = VxdID(i, i, i);
93 
94  VXD::SensorInfoBase aSensorInfo = provideSensorInfo(aVxdID, (unsigned short)i, (unsigned short)i + 1., (unsigned short)i + 2.);
95 
96  const PXDCluster* pxdCluster = m_pxdClusterData.appendNew(providePXDCluster(float(i) / float(nHits), float(i) / float(nHits),
97  aVxdID));
98 
99  SpacePoint* newSP = m_spacePointData.appendNew(pxdCluster, &aSensorInfo);
100  B2DEBUG(10, " setup: new spacePoint got arrayIndex: " << newSP->getArrayIndex() << " and VxdID " << newSP->getVxdID());
101  newSP->addRelationTo(pxdCluster);
102  }
103 
104  B2DEBUG(10, "DirectedNodeNetworkTest:SetUP: created " << m_pxdClusterData.getEntries() << "/" << m_spacePointData.getEntries() <<
105  " pxdClusters/SpacePoints");
106 
108  vector<SpacePoint*> allSpacePoints;
109  for (SpacePoint& aSP : m_spacePointData) {
110  allSpacePoints.push_back(&aSP);
111  }
112 
113  vector<const SpacePoint*> sps4TC1 = { allSpacePoints.at(0), allSpacePoints.at(1)};
114  SpacePointTrackCand* aSPTC1 = m_spacePointTrackCandData.appendNew((sps4TC1)); // shares hits with no one
115  aSPTC1->setQualityIndicator(0.92);
116 
117  vector<const SpacePoint*> sps4TC2 = { allSpacePoints.at(2), allSpacePoints.at(3)};
118  SpacePointTrackCand* aSPTC2 = m_spacePointTrackCandData.appendNew((sps4TC2)); // shares a hit with tc3, tc4, tc5
119  aSPTC2->setQualityIndicator(0.9);
120 
121  vector<const SpacePoint*> sps4TC3 = { allSpacePoints.at(3), allSpacePoints.at(4)};
122  SpacePointTrackCand* aSPTC3 = m_spacePointTrackCandData.appendNew((sps4TC3)); // shares a hit with tc2, tc5
123  aSPTC3->setQualityIndicator(0.8);
124 
125  vector<const SpacePoint*> sps4TC4 = { allSpacePoints.at(4)};
126  SpacePointTrackCand* aSPTC4 = m_spacePointTrackCandData.appendNew((sps4TC4)); // shares a hit with tc3 too, but not with tc2
127  aSPTC4->setQualityIndicator(0.7);
128 
129  vector<const SpacePoint*> sps4TC5 = { allSpacePoints.at(2), allSpacePoints.at(4)};
130  SpacePointTrackCand* aSPTC5 = m_spacePointTrackCandData.appendNew((sps4TC5)); // shares a hit with tc2 and tc3
131  aSPTC5->setQualityIndicator(0.65);
132  }
133 
135  virtual void TearDown() { DataStore::Instance().reset(); }
136 
137  StoreArray<SpacePoint> m_spacePointData;
138  StoreArray<PXDCluster> m_pxdClusterData;
139  StoreArray<SpacePointTrackCand> m_spacePointTrackCandData;
140  StoreArray<DirectedNodeNetworkContainer>
141  m_networkContainerInDataStore;
142  };
143 
144 
145 
146 
148  TEST_F(DirectedNodeNetworkTest, MockupSanityCheck)
149  {
150  EXPECT_EQ(5, m_pxdClusterData.getEntries());
151  EXPECT_EQ(5, m_spacePointData.getEntries());
152  EXPECT_EQ(m_pxdClusterData.getEntries(), m_spacePointData.getEntries());
153  EXPECT_EQ(5, m_spacePointTrackCandData.getEntries());
154  }
155 
156 
157 
163  TEST_F(DirectedNodeNetworkTest, CreateNetworkIntAndThoroughlyTestIntendedBehavior)
164  {
165  // here some tool-definitions first:
166 
168  auto nodeWasFound = [&](std::vector<DirectedNode<int, VoidMetaInfo>*>& nodes, DirectedNode<int, VoidMetaInfo>* node) -> bool {
169  for (DirectedNode<int, VoidMetaInfo>* otherNode : nodes)
170  {
171  if (node->getEntry() == otherNode->getEntry()) { return true; }
172  }
173  return false;
174  };
175 
177  auto printNodeEntries = [&](std::vector<DirectedNode<int, VoidMetaInfo>*>& nodes) -> std::string {
178  std::string output = "Nodes got the following entries: ";
179  for (DirectedNode<int, VoidMetaInfo>* node : nodes)
180  {
181  output += std::to_string(node->getEntry()) + " ";
182  }
183  return output + "\n";
184  };
185 
186  // just some input for testing:
187  std::array<int, 5> intArray = { { 2, 5, 3, 4, 99} };
188  std::array<int, 5> intArray2 = { { 144, 121, 33, 35, 31415} }; // these entries are independent of the first intArray-entries
189  std::array<int, 5> intArray3 = { { 1440, 1210, 3, 33, 3141529} }; // entry 2 crosses intArray, entry 3 crosses intArray2
190  std::deque<int> onTheFlyCreatedInts; // the user has to take care about the lifetime of the objects to be linked in the network!
191  EXPECT_EQ(5, intArray.size());
192 
193  DirectedNodeNetwork<int, VoidMetaInfo> intNetwork;
194  EXPECT_EQ(0, intNetwork.size());
195  B2INFO("tests case when both nodes are new and when inner one is new, but outer one not");
196  for (unsigned int index = 1 ; index < 5; index++) {
197  B2INFO("intArray-index " << index << " of array has entry: " << intArray.at(index));
198 
199  intNetwork.addNode(intArray.at(index - 1), intArray.at(index - 1));
200  intNetwork.addNode(intArray.at(index), intArray.at(index));
201  // correct order: outerEntry, innerEntry:
202  intNetwork.linkNodes(intArray.at(index - 1), intArray.at(index));
203 
204  // innerEnd has been updated:
205  EXPECT_EQ(intArray.at(index), intNetwork.getInnerEnds().at(0)->getEntry());
206 
207  // entries are now in network:
208  EXPECT_EQ(intArray.at(index - 1), *intNetwork.getNode(intArray.at(index - 1)));
209  EXPECT_EQ(intArray.at(index), *intNetwork.getNode(intArray.at(index)));
210 
211  // get all nodes of outer node, expected: 1 inner and no outerNodes:
212  auto& innerNodes = intNetwork.getNode(intArray.at(index - 1))->getInnerNodes();
213  auto& outerNodes = intNetwork.getNode(intArray.at(index))->getOuterNodes();
214  EXPECT_EQ(1, innerNodes.size());
215  EXPECT_EQ(1, outerNodes.size());
216 
217  // array[index] is now linked as inner node of array[index-1]:
218  EXPECT_EQ(*(innerNodes.at(0)), *(intNetwork.getNode(intArray.at(index))));
219  }
220  EXPECT_EQ(0, intNetwork.getNode(intArray.at(0))->getOuterNodes().size()); // the outermost node has no outerNodes
221  EXPECT_EQ(0, intNetwork.getNode(intArray.at(4))->getInnerNodes().size()); // the innermost node has no innerNodes
222 
223  // some extra sanity checks, are inner- and outerEnds as expected?
224  EXPECT_EQ(intArray.size(), intNetwork.size());
225  std::vector<DirectedNode<int, VoidMetaInfo>*> outerEnds_before = intNetwork.getOuterEnds();
226  std::vector<DirectedNode<int, VoidMetaInfo>*> innerEnds_before = intNetwork.getInnerEnds();
227  EXPECT_EQ(1, outerEnds_before.size());
228  EXPECT_EQ(1, innerEnds_before.size());
229 
230  DirectedNode<int, VoidMetaInfo>* outermostNode = outerEnds_before.at(0);
231  EXPECT_EQ(intArray.at(0), outermostNode->getEntry());
232  EXPECT_EQ(outermostNode->getEntry(), *outermostNode);
233  EXPECT_EQ(intArray.at(1), *(outermostNode->getInnerNodes().at(0)));
234 
235  DirectedNode<int, VoidMetaInfo>* innermostNode = innerEnds_before.at(0);
236  EXPECT_EQ(intArray.at(4), innermostNode->getEntry());
237  EXPECT_EQ(innermostNode->getEntry(), *innermostNode);
238  EXPECT_EQ(intArray.at(3), *(innermostNode->getOuterNodes().at(0)));
239 
240 
241  {
242  B2INFO("building another path, which is independent of the first one:");
243  for (unsigned int index = 1 ; index < 5; index++) {
244  B2INFO("intArray2-index " << index << " of array has entry: " << intArray2.at(index));
245 
246  intNetwork.addNode(intArray2.at(index - 1), intArray2.at(index - 1));
247  intNetwork.addNode(intArray2.at(index), intArray2.at(index));
248  // correct order: outerEntry, innerEntry:
249  intNetwork.linkNodes(intArray2.at(index - 1), intArray2.at(index));
250 
251  // entries are now in network:
252  EXPECT_EQ(intArray2.at(index - 1), *intNetwork.getNode(intArray2.at(index - 1)));
253  EXPECT_EQ(intArray2.at(index), *intNetwork.getNode(intArray2.at(index)));
254 
255  // get all nodes of outer node, expected: 1 inner and no outerNodes:
256  auto& innerNodes = intNetwork.getNode(intArray2.at(index - 1))->getInnerNodes();
257  auto& outerNodes = intNetwork.getNode(intArray2.at(index))->getOuterNodes();
258  EXPECT_EQ(1, innerNodes.size());
259  EXPECT_EQ(1, outerNodes.size());
260 
261  // array[index] is now linked as inner node of array[index-1]:
262  EXPECT_TRUE(nodeWasFound(innerNodes, intNetwork.getNode(intArray2.at(index))));
263  EXPECT_EQ(*(innerNodes.at(0)), *(intNetwork.getNode(intArray2.at(index))));
264  }
265  EXPECT_EQ(0, intNetwork.getNode(intArray2.at(0))->getOuterNodes().size()); // the outermost node has no outerNodes
266  EXPECT_EQ(0, intNetwork.getNode(intArray2.at(4))->getInnerNodes().size()); // the innermost node has no innerNodes
267 
268  // some extra sanity checks, are inner- and outerEnds as expected?
269  EXPECT_EQ(10, intNetwork.size());
270  std::vector<DirectedNode<int, VoidMetaInfo>*> outerEnds = intNetwork.getOuterEnds();
271  std::vector<DirectedNode<int, VoidMetaInfo>*> innerEnds = intNetwork.getInnerEnds();
272  EXPECT_EQ(2, outerEnds.size());
273  EXPECT_EQ(2, innerEnds.size());
274  }
275 
276 
277  B2INFO("building another path into the network which crosses the other paths:"); {
278  B2INFO("tests cases: both new, outer new but inner not, inner new but outer not, both already existing:");
279  for (unsigned int index = 1 ; index < 5; index++) {
280  B2INFO("intArray3-indices " << index - 1 << "/" << index <<
281  " of array have entries: " << intArray3.at(index - 1) << "/" << intArray3.at(index) << "\n"
282  );
283 
284  intNetwork.addNode(intArray3.at(index - 1), intArray3.at(index - 1));
285  intNetwork.addNode(intArray3.at(index), intArray3.at(index));
286  // correct order: outerEntry, innerEntry:
287  intNetwork.linkNodes(intArray3.at(index - 1), intArray3.at(index));
288 
289  // entries are now in network:
290  EXPECT_EQ(intArray3.at(index - 1), *intNetwork.getNode(intArray3.at(index - 1)));
291  EXPECT_EQ(intArray3.at(index), *intNetwork.getNode(intArray3.at(index)));
292 
293  // array[index] is now linked as an inner node of array[index-1]:
294  EXPECT_TRUE(nodeWasFound(intNetwork.getNode(intArray3.at(index - 1))->getInnerNodes(),
295  intNetwork.getNode(intArray3.at(index))));
296 
297 
298  if (index > 1) continue; // the following tests do not work for paths crossing each other, therefore tests would fail
299  // innerEnd has been updated:
300  std::vector<DirectedNode<int, VoidMetaInfo>*> innerEnds = intNetwork.getInnerEnds();
301  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray3.at(index))));
302  B2INFO("innerEnds after indices " << index - 1 << "/" << index << " are: " << printNodeEntries(innerEnds));
303 
304  // get all nodes of outer node, expected: 1 inner and no outerNodes:
305  auto& innerNodes = intNetwork.getNode(intArray3.at(index - 1))->getInnerNodes();
306  auto& outerNodes = intNetwork.getNode(intArray3.at(index))->getOuterNodes();
307  EXPECT_EQ(1, innerNodes.size());
308  EXPECT_EQ(1, outerNodes.size());
309  }
310  EXPECT_EQ(0, intNetwork.getNode(intArray3.at(0))->getOuterNodes().size()); // the outermost node has no outerNodes
311  EXPECT_EQ(0, intNetwork.getNode(intArray3.at(4))->getInnerNodes().size()); // the innermost node has no innerNodes
312 
313  // some extra sanity checks, are inner- and outerEnds as expected?
314  EXPECT_EQ(13, intNetwork.size());
315  //B2INFO(" theWholeNetwork: \n" << printNodeEntries(intNetwork.getNodes()));
316  std::vector<DirectedNode<int, VoidMetaInfo>*> outerEnds = intNetwork.getOuterEnds();
317  std::vector<DirectedNode<int, VoidMetaInfo>*> innerEnds = intNetwork.getInnerEnds();
318  EXPECT_EQ(3, outerEnds.size());
319  EXPECT_EQ(3, innerEnds.size());
320  B2INFO("outerEnds are: \n" << printNodeEntries(outerEnds));
321  B2INFO("innerEnds are: \n" << printNodeEntries(innerEnds));
322  }
323 
324  B2INFO("case: when outer node is new, but inner one not: "); {
325  B2INFO(" case: inner one was outer end before: ");
326  auto* oldOuterMostNode = intNetwork.getOuterEnds().at(0);
327  int oldOuterInt = oldOuterMostNode->getEntry();
328  onTheFlyCreatedInts.push_back(42);
329  int& newInnerInt = onTheFlyCreatedInts.back();
330  EXPECT_TRUE(NULL == intNetwork.getNode(newInnerInt));
331  intNetwork.addNode(newInnerInt, newInnerInt);
332  intNetwork.linkNodes(newInnerInt, oldOuterInt);
333  EXPECT_FALSE(NULL == intNetwork.getNode(newInnerInt));
334  EXPECT_EQ(14, intNetwork.size());
335  EXPECT_EQ(3, intNetwork.getInnerEnds().size());
336  std::vector<DirectedNode<int, VoidMetaInfo>*> newOuterEnds = intNetwork.getOuterEnds();
337  EXPECT_EQ(3, newOuterEnds.size()); // did not change, new outermost node replaced old one
338  EXPECT_EQ(1, oldOuterMostNode->getOuterNodes().size());
339  EXPECT_EQ(newInnerInt, *(oldOuterMostNode->getOuterNodes().at(0)));
340  }
341 
342  {
343  B2INFO(" case: inner one was no outer end before: ");
344  onTheFlyCreatedInts.push_back(23);
345  int& newOuterInt = onTheFlyCreatedInts.back();
346  int& existingInt = intArray.at(1); // neither an outer nor an inner end before.
347  std::vector<DirectedNode<int, VoidMetaInfo>*> oldOuterEnds = intNetwork.getOuterEnds();
348  std::vector<DirectedNode<int, VoidMetaInfo>*> oldInnerEnds = intNetwork.getInnerEnds();
349 
350  EXPECT_EQ(3, oldOuterEnds.size());
351  EXPECT_TRUE(NULL == intNetwork.getNode(newOuterInt));
352  unsigned int sizeB4 = intNetwork.size();
353  intNetwork.addNode(newOuterInt, newOuterInt);
354  intNetwork.linkNodes(newOuterInt, existingInt);
355  EXPECT_FALSE(NULL == intNetwork.getNode(newOuterInt));
356  EXPECT_EQ(sizeB4 + 1, intNetwork.size());
357  EXPECT_EQ(3, intNetwork.getInnerEnds().size());
358  DirectedNode<int, VoidMetaInfo>* existingNode = intNetwork.getNode(existingInt);
359  EXPECT_EQ(1, existingNode->getInnerNodes().size());
360  EXPECT_EQ(2, existingNode->getOuterNodes().size());
361  std::vector<DirectedNode<int, VoidMetaInfo>*> newOuterEnds = intNetwork.getOuterEnds();
362  EXPECT_EQ(4, newOuterEnds.size()); // did change, new outermost node co-existing with old outermost one
363  EXPECT_EQ(2, existingNode->getOuterNodes().size());
364 
365  }
366 
367 
368  {
369  B2INFO("case: when both were there, but not linked yet: ");
370  unsigned int sizeB4 = intNetwork.size();
371  intNetwork.linkNodes(intArray.at(0), intArray.at(2));
372  EXPECT_EQ(sizeB4, intNetwork.size()); // size of network does not change
373  EXPECT_EQ(3, intNetwork.getInnerEnds().size()); // this can not change here
374  EXPECT_EQ(4, intNetwork.getOuterEnds().size());
375  std::vector<DirectedNode<int, VoidMetaInfo>*> innerEnds = intNetwork.getNode(intArray.at(0))->getInnerNodes();
376  EXPECT_EQ(2, innerEnds.size());
377  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray.at(1))));
378  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray.at(2))));
379  EXPECT_TRUE(nodeWasFound(innerEnds, innerEnds.at(1)));
380 
381 
382  B2INFO("case: when outer both were there and already linked: ");
383  EXPECT_FALSE(intNetwork.linkNodes(intArray.at(0), intArray.at(2)));
384  // nothing was added, everything the same as last case:
385  EXPECT_EQ(sizeB4, intNetwork.size());
386  EXPECT_EQ(3, intNetwork.getInnerEnds().size());
387  EXPECT_EQ(4, intNetwork.getOuterEnds().size());
388  std::vector<DirectedNode<int, VoidMetaInfo>*> moreInnerEnds = intNetwork.getNode(intArray.at(0))->getInnerNodes();
389  EXPECT_EQ(innerEnds.size(), moreInnerEnds.size());
390  EXPECT_TRUE(nodeWasFound(innerEnds, moreInnerEnds.at(0)));
391  EXPECT_TRUE(nodeWasFound(innerEnds, moreInnerEnds.at(1)));
392  }
393 
394 
395  B2INFO("testing members for filling, when (at least) one entry was already there:"); {
396  B2INFO("case: addInnerToLastOuterNode: both were there, but not linked yet: ");
397  unsigned int networkSizeB4 = intNetwork.size();
398  unsigned int nInnerEndsB4 = intNetwork.getInnerEnds().size();
399  intNetwork.addInnerToLastOuterNode(intArray.at(3));
400  EXPECT_EQ(networkSizeB4, intNetwork.size());
401  EXPECT_EQ(nInnerEndsB4, intNetwork.getInnerEnds().size());
402  std::vector<DirectedNode<int, VoidMetaInfo>*> innerEnds = intNetwork.getNode(intArray.at(0))->getInnerNodes();
403  EXPECT_EQ(3, innerEnds.size());
404 
405  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray.at(1))));
406  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray.at(2))));
407  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray.at(3))));
408  }
409 
410 
411  {
412  B2INFO("case: addInnerToLastOuterNode: both were there, but already linked (same results as before, but with an error for unintended behavior):");
413  unsigned int networkSizeB4 = intNetwork.size();
414  unsigned int nInnerEndsB4 = intNetwork.getInnerEnds().size();
415  intNetwork.addInnerToLastOuterNode(intArray.at(3));
416  EXPECT_EQ(networkSizeB4, intNetwork.size());
417  EXPECT_EQ(nInnerEndsB4, intNetwork.getInnerEnds().size());
418  std::vector<DirectedNode<int, VoidMetaInfo>*> innerEnds = intNetwork.getNode(intArray.at(0))->getInnerNodes();
419  EXPECT_EQ(3, innerEnds.size());
420 
421  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray.at(1))));
422  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray.at(2))));
423  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray.at(3))));
424  }
425  /*
426  {
427  B2INFO("case: addInnerToLastOuterNode: inner was not there yet (innerEndsUpdate):");
428  onTheFlyCreatedInts.push_back(31);
429  int& lastOuterNodeInt = intNetwork.getLastOuterNode()->getEntry();
430  int& newInnerInt = onTheFlyCreatedInts.back();
431  unsigned int networkSizeB4 = intNetwork.size();
432  unsigned int nInnerEndsB4 = intNetwork.getInnerEnds().size();
433  unsigned int nInnerNodesB4 = intNetwork.getNode(lastOuterNodeInt)->getInnerNodes().size();
434  intNetwork.addInnerToLastOuterNode(newInnerInt);
435  EXPECT_EQ(networkSizeB4 + 1, intNetwork.size());
436  EXPECT_EQ(nInnerEndsB4 + 1, intNetwork.getInnerEnds().size());
437  EXPECT_EQ(nInnerNodesB4 + 1, intNetwork.getNode(lastOuterNodeInt)->getInnerNodes().size());
438 
439  EXPECT_TRUE(nodeWasFound(intNetwork.getNode(lastOuterNodeInt)->getInnerNodes(), intNetwork.getNode(newInnerInt)));
440  auto innerEnds = intNetwork.getInnerEnds();
441  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(newInnerInt)));
442  }
443 
444  {
445  B2INFO("case: addOuterToLastInnerNode: both were there, but not linked yet:");
446  int& lastInnerNodeInt = intNetwork.getLastInnerNode()->getEntry();
447  unsigned int networkSizeB4 = intNetwork.size();
448  unsigned int nOuterEndsB4 = intNetwork.getOuterEnds().size();
449  intNetwork.addOuterToLastInnerNode(intArray2.at(1));
450  EXPECT_EQ(networkSizeB4, intNetwork.size());
451  EXPECT_EQ(nOuterEndsB4, intNetwork.getOuterEnds().size());
452  std::vector<DirectedNode<int, VoidMetaInfo>*> outerNodes = intNetwork.getNode(lastInnerNodeInt)->getOuterNodes();
453  EXPECT_EQ(2, outerNodes.size());
454  }
455 
456  {
457  B2INFO("case: addOuterToLastInnerNode: both were there, but already linked (same results as before, but with an error for unintended behavior):");
458  int& lastInnerNodeInt = intNetwork.getLastInnerNode()->getEntry();
459  unsigned int networkSizeB4 = intNetwork.size();
460  unsigned int nOuterEndsB4 = intNetwork.getOuterEnds().size();
461  intNetwork.addOuterToLastInnerNode(intArray2.at(1));
462  EXPECT_EQ(networkSizeB4, intNetwork.size());
463  EXPECT_EQ(nOuterEndsB4, intNetwork.getOuterEnds().size());
464  std::vector<DirectedNode<int, VoidMetaInfo>*> outerNodes = intNetwork.getNode(lastInnerNodeInt)->getOuterNodes();
465  EXPECT_EQ(2, outerNodes.size());
466  }
467 
468  {
469  B2INFO("case: addOuterToLastInnerNode: outer was not there yet (outerEndsUpdate):");
470  onTheFlyCreatedInts.push_back(66);
471  int& lastInnerNodeInt = intNetwork.getLastInnerNode()->getEntry();
472  int& newOuterInt = onTheFlyCreatedInts.back();
473  unsigned int networkSizeB4 = intNetwork.size();
474  unsigned int nOuterEndsB4 = intNetwork.getOuterEnds().size();
475  unsigned int nOuterNodesB4 = intNetwork.getNode(lastInnerNodeInt)->getOuterNodes().size();
476  intNetwork.addOuterToLastInnerNode(newOuterInt);
477  EXPECT_EQ(networkSizeB4 + 1, intNetwork.size());
478  EXPECT_EQ(nOuterEndsB4 + 1, intNetwork.getOuterEnds().size());
479  EXPECT_EQ(nOuterNodesB4 + 1, intNetwork.getNode(lastInnerNodeInt)->getOuterNodes().size());
480 
481  EXPECT_TRUE(nodeWasFound(intNetwork.getNode(lastInnerNodeInt)->getOuterNodes(), intNetwork.getNode(newOuterInt)));
482  auto outerEnds = intNetwork.getOuterEnds();
483  EXPECT_TRUE(nodeWasFound(outerEnds, intNetwork.getNode(newOuterInt)));
484  }
485  */
486  }
487 
488 
492  /*
493  TEST_F(DirectedNodeNetworkTest, CreateRealisticNetwork)
494  {
495  // testing to write that container now onto the datastore:
496  DirectedNodeNetworkContainer* realisticNetworkPtr = networkContainerInDataStore.appendNew();
497  DirectedNodeNetwork<TrackNode, VoidMetaInfo> hitNetwork = realisticNetworkPtr->accessHitNetwork();
498  vector<TrackNode*> trackNodes = realisticNetworkPtr->accessTrackNodes();
499 
500  const DirectedNodeNetworkContainer::StaticSectorType dummyStaticSector;
501  // const StaticSectorType * staticSectorPtr = &dummyStaticSector; // WARNING TODO warum funzt diese Konvertierung net?!?
502  ActiveSector<DirectedNodeNetworkContainer::StaticSectorType, TrackNode> dummyActiveSector(&dummyStaticSector);
503 
504  EXPECT_EQ(0, hitNetwork.size());
505 
506  unsigned nEntries = spacePointData.getEntries();
507  for (SpacePoint& aSP : spacePointData) {
508  trackNodes.push_back(new TrackNode());
509  TrackNode* node = trackNodes.back();
510  node->spacePoint = &aSP;
511  node->sector = &dummyActiveSector;
512  }
513 
514  // filling: correct usage:
515  // tests case when both nodes are new and when inner one is new, but outer one not:
516  for (unsigned int index = 1 ; index < nEntries; index++) {
517  TrackNode* outerNode = trackNodes[index - 1];
518  TrackNode* innerNode = trackNodes[index];
519  SpacePoint& outerSP = *(outerNode->spacePoint);
520  SpacePoint& innerSP = *(innerNode->spacePoint);
521 
522  B2INFO("CreateRealisticNetwork: index " << index);
523 
524  // correct order: outerEntry, innerEntry:
525  hitNetwork.linkTheseEntries(*outerNode, *innerNode);
526 
527  // innerEnd has been updated:
528  EXPECT_EQ(innerSP, *(hitNetwork.getInnerEnds().at(0)->getEntry().spacePoint));
529 
530  // entries are now in network:
531  EXPECT_EQ(outerSP, *(hitNetwork.getNode(*outerNode)->getEntry().spacePoint));
532  EXPECT_EQ(innerSP, *(hitNetwork.getNode(*innerNode)->getEntry().spacePoint));
533  EXPECT_EQ(*outerNode, *hitNetwork.getNode(*outerNode));
534  EXPECT_EQ(*innerNode, *hitNetwork.getNode(*innerNode));
535 
536  // get all nodes of outer node, expected: 1 inner and no outerNodes:
537  auto& innerNodes = hitNetwork.getNode(*outerNode)->getInnerNodes();
538  auto& outerNodes = hitNetwork.getNode(*innerNode)->getOuterNodes();
539  EXPECT_EQ(1, innerNodes.size());
540  EXPECT_EQ(1, outerNodes.size());
541 
542  // array[index] is now linked as inner node of array[index-1]:
543  EXPECT_EQ(*(innerNodes.at(0)), *(hitNetwork.getNode(*innerNode)));
544  }
545 
546  EXPECT_EQ(0, hitNetwork.getNode(*trackNodes[0])->getOuterNodes().size()); // the outermost node has no outerNodes
547  EXPECT_EQ(0, hitNetwork.getNode(*trackNodes[4])->getInnerNodes().size()); // the innermost node has no innerNodes
548 
549  // some extra sanity checks, are inner- and outerEnds as expected?
550  EXPECT_EQ(nEntries, hitNetwork.size());
551  std::vector<DirectedNode<TrackNode, VoidMetaInfo>*> outerEnds = hitNetwork.getOuterEnds();
552  std::vector<DirectedNode<TrackNode, VoidMetaInfo>*> innerEnds = hitNetwork.getInnerEnds();
553  EXPECT_EQ(1, outerEnds.size());
554  EXPECT_EQ(1, innerEnds.size());
555 
556  DirectedNode<TrackNode, VoidMetaInfo>* outermostNode = outerEnds.at(0);
557  EXPECT_EQ(*spacePointData[0], *(outermostNode->getEntry().spacePoint));
558  EXPECT_EQ(*spacePointData[1], *(outermostNode->getInnerNodes().at(0)->getEntry().spacePoint));
559 
560  DirectedNode<TrackNode, VoidMetaInfo>* innermostNode = innerEnds.at(0);
561  EXPECT_EQ(*spacePointData[4], *(innermostNode->getEntry().spacePoint));
562  EXPECT_EQ(innermostNode->getEntry(), *innermostNode);
563  EXPECT_EQ(*spacePointData[3], *(innermostNode->getOuterNodes().at(0)->getEntry().spacePoint));
564 
565 
566 
567  // preparing some extra data for testing:
568  VxdID aID;
569  VXD::SensorInfoBase aSensorInfo = provideSensorInfo(aID, 2, 4, 5);
570 
571  PXDCluster pxdCluster = providePXDCluster(2.3 , 4.2, aID);
572  SpacePoint newSP = SpacePoint(&pxdCluster, &aSensorInfo);
573  TrackNode newNode = TrackNode();
574  newNode.spacePoint = & newSP;
575  newNode.sector = &dummyActiveSector;
576 
577 
578  // testing case, when outer node is new, but inner one not:
579  TrackNode& oldNode = outermostNode->getEntry();
580  hitNetwork.linkTheseEntries(newNode, oldNode);
581  EXPECT_EQ(6, hitNetwork.size());
582 
583  std::vector<DirectedNode<TrackNode, VoidMetaInfo>*> newOuterEnds = hitNetwork.getOuterEnds();
584  EXPECT_EQ(1, newOuterEnds.size());
585  DirectedNode<TrackNode, VoidMetaInfo>* newOutermostNode = newOuterEnds.at(0);
586  EXPECT_NE(oldNode, newOutermostNode->getEntry());
587  EXPECT_EQ(newNode, newOutermostNode->getEntry());
588  EXPECT_EQ(*spacePointData[0], *(newOutermostNode->getInnerNodes().at(0)->getEntry().spacePoint));
589  EXPECT_EQ(newNode, *(outermostNode->getOuterNodes().at(0)));
590 
591 
592  // testing case, when outer both were there, but not linked yet:
593  hitNetwork.linkTheseEntries(*trackNodes[0], *trackNodes[2]);
594  EXPECT_EQ(6, hitNetwork.size()); // size of network does not change
595  std::vector<DirectedNode<TrackNode, VoidMetaInfo>*> moreInnerEnds = hitNetwork.getNode(*trackNodes[0])->getInnerNodes();
596  EXPECT_EQ(2, moreInnerEnds.size());
597  EXPECT_EQ(*trackNodes[1], *moreInnerEnds.at(0));
598  EXPECT_EQ(*trackNodes[2], *moreInnerEnds.at(1));
599 
600 
601  // testing case, when outer both were there and already linked:
602  hitNetwork.linkTheseEntries(*trackNodes[0], *trackNodes[2]);
603 
604  // nothing was added, everything the same as last case:
605  EXPECT_EQ(6, hitNetwork.size());
606  std::vector<DirectedNode<TrackNode, VoidMetaInfo>*> evenMoreInnerEnds = hitNetwork.getNode(*trackNodes[0])->getInnerNodes();
607  EXPECT_EQ(moreInnerEnds.size(), evenMoreInnerEnds.size());
608  EXPECT_EQ(*moreInnerEnds.at(0), *evenMoreInnerEnds.at(0));
609  EXPECT_EQ(*moreInnerEnds.at(1), *evenMoreInnerEnds.at(1));
610  }*/
611 } // end namespace
612 
613 
614 
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:43
Belle2::DirectedNode::getInnerNodes
std::vector< DirectedNode< EntryType, MetaInfoType > * > & getInnerNodes()
************************* PUBLIC MEMBER FUNCTIONS *************************
Definition: DirectedNode.h:96
Belle2::DirectedNodeNetwork::getOuterEnds
std::vector< Node * > getOuterEnds()
getters:
Definition: DirectedNodeNetwork.h:177
Belle2::RelationsInterface::addRelationTo
void addRelationTo(const RelationsInterface< BASE > *object, float weight=1.0, const std::string &namedRelation="") const
Add a relation from this object to another object (with caching).
Definition: RelationsObject.h:144
Belle2::VXD::SensorInfoBase
Base class to provide Sensor Information for PXD and SVD.
Definition: SensorInfoBase.h:40
Belle2::DirectedNodeNetwork::size
unsigned int size() const
Returns number of nodes to be found in the network.
Definition: DirectedNodeNetwork.h:225
Belle2::DirectedNode::getOuterNodes
std::vector< DirectedNode< EntryType, MetaInfoType > * > & getOuterNodes()
Returns links to all outer nodes attached to this one.
Definition: DirectedNode.h:99
Belle2::DirectedNodeNetwork
Network of directed nodes of the type EntryType.
Definition: DirectedNodeNetwork.h:38
Belle2::SpacePoint
SpacePoint typically is build from 1 PXDCluster or 1-2 SVDClusters.
Definition: SpacePoint.h:52
DirectedNodeNetworkTests
These tests cover the functionality of the classes: DirectedNode, DirectedNodeNetwork.
Definition: directedNodeNetwork.cc:38
Belle2::VXD::SensorInfoBase::setTransformation
void setTransformation(const TGeoHMatrix &transform, bool reco=false)
Set the transformation matrix of the Sensor.
Definition: SensorInfoBase.h:305
Belle2::DirectedNodeNetwork::linkNodes
bool linkNodes(NodeID outerNodeID, NodeID innerNodeID)
takes two entry IDs and weaves them into the network
Definition: DirectedNodeNetwork.h:132
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: ParticleList.h:33
Belle2::DirectedNodeNetwork::getNode
Node * getNode(NodeID toBeFound)
Returns pointer to the node carrying the entry which is equal to given parameter.
Definition: DirectedNodeNetwork.h:194
Belle2::DirectedNodeNetwork::getInnerEnds
std::vector< Node * > getInnerEnds()
returns all nodes which have no inner nodes (but outer ones) and therefore are inner ends of the netw...
Definition: DirectedNodeNetwork.h:185
Belle2::TEST_F
TEST_F(GlobalLabelTest, LargeNumberOfTimeDependentParameters)
Test large number of time-dep params for registration and retrieval.
Definition: globalLabel.cc:65
DirectedNodeNetworkTests::DirectedNodeNetworkTest::m_spacePointTrackCandData
StoreArray< SpacePointTrackCand > m_spacePointTrackCandData
some spacePointTrackCands for testing.
Definition: directedNodeNetwork.cc:139
DirectedNodeNetworkTests::DirectedNodeNetworkTest::SetUp
virtual void SetUp()
SetUp environment - prepare related storearrays of SpacePoints and PXDClusters.
Definition: directedNodeNetwork.cc:72
Belle2::PXDCluster
The PXD Cluster class This class stores all information about reconstructed PXD clusters The position...
Definition: PXDCluster.h:41
Belle2::RelationsInterface::getArrayIndex
int getArrayIndex() const
Returns this object's array index (in StoreArray), or -1 if not found.
Definition: RelationsObject.h:387
DirectedNodeNetworkTests::DirectedNodeNetworkTest::m_spacePointData
StoreArray< SpacePoint > m_spacePointData
some spacePoints for testing.
Definition: directedNodeNetwork.cc:137
DirectedNodeNetworkTests::DirectedNodeNetworkTest::TearDown
virtual void TearDown()
TearDown environment - clear datastore.
Definition: directedNodeNetwork.cc:135
Belle2::StoreArray< SpacePoint >
DirectedNodeNetworkTests::DirectedNodeNetworkTest::m_networkContainerInDataStore
StoreArray< DirectedNodeNetworkContainer > m_networkContainerInDataStore
testing to store a dummy class containing DirectedNodeNetwork as member .
Definition: directedNodeNetwork.cc:141
Belle2::DirectedNode
The Node-Class.
Definition: DirectedNode.h:41
DirectedNodeNetworkTests::DirectedNodeNetworkTest
Test class demonstrating the behavior of TCNetworkContainer.
Definition: directedNodeNetwork.cc:68
Belle2::DirectedNodeNetwork::addNode
bool addNode(NodeID nodeID, EntryType &newEntry)
************************* PUBLIC MEMBER FUNCTIONS *************************
Definition: DirectedNodeNetwork.h:72
Belle2::DirectedNode::getEntry
EntryType & getEntry()
Allows access to stored entry.
Definition: DirectedNode.h:102
Belle2::DirectedNodeNetwork::addInnerToLastOuterNode
bool addInnerToLastOuterNode(NodeID innerNodeID)
to the last outerNode added, another innerNode will be attached
Definition: DirectedNodeNetwork.h:85
Belle2::SpacePointTrackCand
Storage for (VXD) SpacePoint-based track candidates.
Definition: SpacePointTrackCand.h:51
Belle2::SpacePointTrackCand::setQualityIndicator
void setQualityIndicator(const double newIndicator)
sets the new status of the estimated quality of this track candidate.
Definition: SpacePointTrackCand.h:321
Belle2::SpacePoint::getVxdID
VxdID getVxdID() const
Return the VxdID of the sensor on which the the cluster of the SpacePoint lives.
Definition: SpacePoint.h:158
DirectedNodeNetworkTests::DirectedNodeNetworkTest::m_pxdClusterData
StoreArray< PXDCluster > m_pxdClusterData
some pxd clusters for testing.
Definition: directedNodeNetwork.cc:138