Belle II Software  release-05-01-25
trackletFilters.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2014 - 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/spacePointCreation/SpacePoint.h>
14 #include <tracking/spacePointCreation/SpacePointTrackCand.h>
15 #include <tracking/trackFindingVXD/filterMap/trackletVariables/ZiggZaggXY.h>
16 #include <tracking/trackFindingVXD/filterMap/trackletVariables/ZiggZaggXYWithSigma.h>
17 #include <tracking/trackFindingVXD/filterMap/trackletVariables/ZiggZaggRZ.h>
18 
19 #include <tracking/trackFindingVXD/filterMap/filterFramework/Shortcuts.h>
20 
21 #include <vxd/geometry/SensorInfoBase.h>
22 
23 using namespace std;
24 using namespace Belle2;
25 
26 namespace VXDTFtrackletFilterTest {
27 
29  class TrackletFilterTest : public ::testing::Test {
30  protected:
31  };
32 
33 
34 
36  VXD::SensorInfoBase createSensorInfo(VxdID aVxdID, double globalX = 0., double globalY = 0., double globalZ = -0.)
37  {
38  // (SensorType type, VxdID id, double width, double length, double thickness, int uCells, int vCells, double width2=-1, double splitLength=-1, int vCells2=0)
39  VXD::SensorInfoBase sensorInfoBase(VXD::SensorInfoBase::PXD, aVxdID, 2.3, 4.2, 0.3, 2, 4, -1);
40 
41  TGeoRotation r1;
42  r1.SetAngles(45, 20, 30); // rotation defined by Euler angles
43  TGeoTranslation t1(globalX, globalY, globalZ);
44  TGeoCombiTrans c1(t1, r1);
45  TGeoHMatrix transform = c1;
46  sensorInfoBase.setTransformation(transform);
47  // also need the reco-transform
48  sensorInfoBase.setTransformation(transform, true);
49 
50  return sensorInfoBase;
51  }
52 
53 
54 
56  SpacePoint provideSpacePointDummy(double X, double Y, double Z)
57  {
58  VxdID aVxdID = VxdID(1, 1, 1);
59  VXD::SensorInfoBase sensorInfoBase = createSensorInfo(aVxdID, X, Y, Z);
60 
61  PXDCluster aCluster = PXDCluster(aVxdID, 0., 0., 0.1, 0.1, 0, 0, 1, 1, 1, 1, 1, 1);
62 
63  return SpacePoint(&aCluster, &sensorInfoBase);
64  }
65 
66 
67 
69  int lastResult = 0;
70 
71 
72 
74  class ResultsObserver : public VoidObserver {
75  public:
77  template<class Var, typename ... otherTypes>
78  static void notify(const Var& filterType,
79  typename Var::variableType fResult,
80  otherTypes ...)
81  {
82  B2INFO("ResultsObserver: Filter " << filterType.name() << " got result of " << fResult);
83  lastResult = fResult;
84  }
85 
86  };
87 
88 
90  TEST_F(TrackletFilterTest, SpacePointCreation)
91  {
92  SpacePoint testSP = provideSpacePointDummy(1.2, 2.3, 4.2);
93  EXPECT_FLOAT_EQ(1.2, testSP.getPosition().X()) ;
94  EXPECT_FLOAT_EQ(2.3, testSP.getPosition().Y()) ;
95  EXPECT_FLOAT_EQ(4.2, testSP.getPosition().Z()) ;
96  }
97 
98 
100  TEST_F(TrackletFilterTest, SelectionVariableName)
101  {
102  auto ziggZaggXYChecker = ZiggZaggXY<SpacePoint, SpacePointTrackCand>();
103  EXPECT_EQ("ZiggZaggXY" , ziggZaggXYChecker.name());
104 
105  auto ziggZaggXYWithSigmaChecker = ZiggZaggXYWithSigma<SpacePoint, SpacePointTrackCand>();
106  EXPECT_EQ("ZiggZaggXYWithSigma" , ziggZaggXYWithSigmaChecker.name());
107 
108  auto ziggZaggRZChecker = ZiggZaggRZ<SpacePoint, SpacePointTrackCand>();
109  EXPECT_EQ("ZiggZaggRZ" , ziggZaggRZChecker.name());
110  }
111 
112 
114  TEST_F(TrackletFilterTest, TestZiggZagg)
115  {
116  // Info: the actual position is not important, the naming just indicates the way one should add hits to the containers!
117  SpacePoint outerSP = provideSpacePointDummy(1.1, 1., 1.); // R: 1.48660687
118  SpacePoint outerCenterSP = provideSpacePointDummy(2., 2., 2.); // R: 2.82842712
119  SpacePoint innerCenterSP = provideSpacePointDummy(3., 2.1, 3.); // R: 3.66196668
120  SpacePoint innerSP = provideSpacePointDummy(4., 3., 3.); // R: 5
121  SpacePoint innermostSP = provideSpacePointDummy(5., 3, 6.); // R: 5.83095189
122 
124  const std::vector<const Belle2::SpacePoint*> aSpacePointVec = { &outerSP, &outerCenterSP, &innerCenterSP, &innerSP };
125 
127  ziggZaggXYChecker4VecSPs(
128  ClosedRange<int, int>(1, 1));
129  EXPECT_FALSE(ziggZaggXYChecker4VecSPs.accept(aSpacePointVec));
130  EXPECT_EQ(2, lastResult);
131 
133  // should be ziggZagg:
134  SpacePointTrackCand aSpacePointTC = SpacePointTrackCand(aSpacePointVec, 11, -1, 23);
135 
136  Filter< ZiggZaggXY<SpacePoint, SpacePointTrackCand>, ClosedRange<int, int>, ResultsObserver > ziggZaggXYChecker4SPTC(
137  ClosedRange<int, int>(1, 1));
138  EXPECT_FALSE(ziggZaggXYChecker4SPTC.accept(aSpacePointTC));
139  EXPECT_EQ(2, lastResult);
141  ziggZaggXYWithSigmaChecker4SPTC(
142  ClosedRange<int, int>(0, 1));
143  EXPECT_FALSE(ziggZaggXYWithSigmaChecker4SPTC.accept(aSpacePointTC));
144  EXPECT_EQ(2, lastResult);
145  Filter< ZiggZaggRZ<SpacePoint, SpacePointTrackCand>, ClosedRange<int, int>, ResultsObserver > ziggZaggRZChecker4SPTC(
146  ClosedRange<int, int>(1, 1));
147  EXPECT_FALSE(ziggZaggRZChecker4SPTC.accept(aSpacePointTC));
148  EXPECT_EQ(2, lastResult);
149 
150 
151  // should be ziggZagg:
152  const std::vector<const Belle2::SpacePoint*> aSpacePointVec2 = { &outerSP, &outerCenterSP, &innerCenterSP, &innerSP, &innerSP };
153  SpacePointTrackCand aSpacePointTC2 = SpacePointTrackCand(aSpacePointVec2, 11, -1, 23);
154 
155  EXPECT_FALSE(ziggZaggXYChecker4SPTC.accept(aSpacePointTC2));
156  EXPECT_EQ(3, lastResult); // last two hits are identical, will be detected in Filter.
157  EXPECT_FALSE(ziggZaggXYWithSigmaChecker4SPTC.accept(aSpacePointTC2));
158  EXPECT_EQ(2, lastResult);
159  EXPECT_FALSE(ziggZaggRZChecker4SPTC.accept(aSpacePointTC2));
160  EXPECT_EQ(3, lastResult);
161 
162 
163  // should _not_ be ziggZagg:
164  const std::vector<const Belle2::SpacePoint*> aSpacePointVec3 = { &outerSP, &outerCenterSP, &innerSP, &innermostSP };
165  SpacePointTrackCand aSpacePointTC3 = SpacePointTrackCand(aSpacePointVec3, 11, -1, 23);
166 
167  EXPECT_TRUE(ziggZaggXYChecker4SPTC.accept(aSpacePointTC3));
168  EXPECT_EQ(1, lastResult);
169  EXPECT_TRUE(ziggZaggXYWithSigmaChecker4SPTC.accept(aSpacePointTC3));
170  EXPECT_EQ(1, lastResult);
171  EXPECT_FALSE(ziggZaggRZChecker4SPTC.accept(aSpacePointTC3));
172  EXPECT_EQ(2, lastResult);
173 
174 
175  // /** Difference between ZiggZaggs (no RZ-test here) **/
176  SpacePoint testSP1 = provideSpacePointDummy(1.001, 1., 0.); // sets to positionSigma of ~0.1 in x,y,z!
177  SpacePoint testSP2 = provideSpacePointDummy(2., 2.0002, 0.); // sets to positionSigma of ~0.1 in x,y,z!
178  SpacePoint testSP3 = provideSpacePointDummy(3.0005, 3., 0.); // sets to positionSigma of ~0.1 in x,y,z!
179  SpacePoint testSP4 = provideSpacePointDummy(4., 4.0003, 0.); // sets to positionSigma of ~0.1 in x,y,z!
180  SpacePoint testSP5 = provideSpacePointDummy(5.001, 5., 0.); // sets to positionSigma of ~0.1 in x,y,z!
181  const std::vector<const Belle2::SpacePoint*> aSpacePointVec4 = { &testSP1, &testSP2, &testSP3, &testSP4, &testSP5 };
182  SpacePointTrackCand aSpacePointTC4 = SpacePointTrackCand(aSpacePointVec4, 11, -1, 23);
183 
184  EXPECT_FALSE(ziggZaggXYChecker4SPTC.accept(aSpacePointTC4));
185  EXPECT_EQ(2, lastResult);
186  EXPECT_TRUE(ziggZaggXYWithSigmaChecker4SPTC.accept(aSpacePointTC4)); // does not ziggZagg due to positionSigma != 0
187  EXPECT_EQ(0, lastResult);
188 
189  }
190 
191 }
192 
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:43
VXDTFtrackletFilterTest::ResultsObserver
takes result, prints it and stores it to lastResult
Definition: trackletFilters.cc:74
Belle2::VXD::SensorInfoBase
Base class to provide Sensor Information for PXD and SVD.
Definition: SensorInfoBase.h:40
VXDTFtrackletFilterTest::TrackletFilterTest
Test class for these new and shiny two-hit-filters.
Definition: trackletFilters.cc:29
Belle2::ClosedRange
Represents a closed set of arithmetic types.
Definition: ClosedRange.h:42
Belle2::B2Vector3::Z
DataType Z() const
access variable Z (= .at(2) without boundary check)
Definition: B2Vector3.h:434
Belle2::SpacePoint
SpacePoint typically is build from 1 PXDCluster or 1-2 SVDClusters.
Definition: SpacePoint.h:52
Belle2::SpacePoint::getPosition
const B2Vector3< double > & getPosition() const
return the position vector in global coordinates
Definition: SpacePoint.h:148
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::TEST_F
TEST_F(GlobalLabelTest, LargeNumberOfTimeDependentParameters)
Test large number of time-dep params for registration and retrieval.
Definition: globalLabel.cc:65
Belle2::PXDCluster
The PXD Cluster class This class stores all information about reconstructed PXD clusters The position...
Definition: PXDCluster.h:41
Belle2::B2Vector3::X
DataType X() const
access variable X (= .at(0) without boundary check)
Definition: B2Vector3.h:430
Belle2::Filter
This class is used to select pairs, triplets...
Definition: Filter.h:44
Belle2::B2Vector3::Y
DataType Y() const
access variable Y (= .at(1) without boundary check)
Definition: B2Vector3.h:432
Belle2::VoidObserver
The most CPU efficient Observer for the VXDTF filter tools (even if useless).
Definition: VoidObserver.h:40
Belle2::SpacePointTrackCand
Storage for (VXD) SpacePoint-based track candidates.
Definition: SpacePointTrackCand.h:51
VXDTFtrackletFilterTest::ResultsObserver::notify
static void notify(const Var &filterType, typename Var::variableType fResult, otherTypes ...)
notify function is called by the filter, this one takes result, prints it and stores it to lastResult...
Definition: trackletFilters.cc:78