trackletFilters.cc

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#include <gtest/gtest.h>
 
#include <tracking/spacePointCreation/SpacePoint.h>
#include <tracking/spacePointCreation/SpacePointTrackCand.h>
#include <tracking/trackFindingVXD/filterMap/trackletVariables/ZiggZaggXY.h>
#include <tracking/trackFindingVXD/filterMap/trackletVariables/ZiggZaggXYWithSigma.h>
#include <tracking/trackFindingVXD/filterMap/trackletVariables/ZiggZaggRZ.h>
 
#include <tracking/trackFindingVXD/filterMap/filterFramework/Shortcuts.h>
 
#include <vxd/geometry/SensorInfoBase.h>
 
using namespace std;
using namespace Belle2;
 
namespace VXDTFtrackletFilterTest {
 
  class TrackletFilterTest : public ::testing::Test {
  protected:
  };
 
 
 
  VXD::SensorInfoBase createSensorInfo(VxdID aVxdID, double globalX = 0., double globalY = 0., double globalZ = -0.)
  {
    // (SensorType type, VxdID id, double width, double length, double thickness, int uCells, int vCells, double width2=-1, double splitLength=-1, int vCells2=0)
    VXD::SensorInfoBase sensorInfoBase(VXD::SensorInfoBase::PXD, aVxdID, 2.3, 4.2, 0.3, 2, 4, -1);
 
    TGeoRotation r1;
    r1.SetAngles(45, 20, 30);      // rotation defined by Euler angles
    TGeoTranslation t1(globalX, globalY, globalZ);
    TGeoCombiTrans c1(t1, r1);
    TGeoHMatrix transform = c1;
    sensorInfoBase.setTransformation(transform);
    // also need the reco-transform
    sensorInfoBase.setTransformation(transform, true);
 
    return sensorInfoBase;
  }
 
 
 
  SpacePoint provideSpacePointDummy(double X, double Y, double Z)
  {
    VxdID aVxdID = VxdID(1, 1, 1);
    VXD::SensorInfoBase sensorInfoBase = createSensorInfo(aVxdID, X, Y, Z);
 
    PXDCluster aCluster = PXDCluster(aVxdID, 0., 0., 0.1, 0.1, 0, 0, 1, 1, 1, 1, 1, 1);
 
    return SpacePoint(&aCluster, &sensorInfoBase);
  }
 
 
 
  int lastResult = 0;
 
 
 
  class ResultsObserver : public VoidObserver {
  public:
    template<class Var, typename ... otherTypes>
    static void notify(const Var& filterType,
                       typename Var::variableType fResult,
                       otherTypes ...)
    {
      B2INFO("ResultsObserver: Filter " << filterType.name() << " got result of " << fResult);
      lastResult = fResult;
    }
 
  };
 
 
  TEST_F(TrackletFilterTest, SpacePointCreation)
  {
    SpacePoint testSP = provideSpacePointDummy(1.2, 2.3, 4.2);
    EXPECT_FLOAT_EQ(1.2, testSP.getPosition().X()) ;
    EXPECT_FLOAT_EQ(2.3, testSP.getPosition().Y()) ;
    EXPECT_FLOAT_EQ(4.2, testSP.getPosition().Z()) ;
  }
 
 
  TEST_F(TrackletFilterTest, SelectionVariableName)
  {
    auto ziggZaggXYChecker = ZiggZaggXY<SpacePoint, SpacePointTrackCand>();
    EXPECT_EQ("ZiggZaggXY", ziggZaggXYChecker.name());
 
    auto ziggZaggXYWithSigmaChecker = ZiggZaggXYWithSigma<SpacePoint, SpacePointTrackCand>();
    EXPECT_EQ("ZiggZaggXYWithSigma", ziggZaggXYWithSigmaChecker.name());
 
    auto ziggZaggRZChecker = ZiggZaggRZ<SpacePoint, SpacePointTrackCand>();
    EXPECT_EQ("ZiggZaggRZ", ziggZaggRZChecker.name());
  }
 
 
  TEST_F(TrackletFilterTest, TestZiggZagg)
  {
    // Info: the actual position is not important, the naming just indicates the way one should add hits to the containers!
    SpacePoint outerSP = provideSpacePointDummy(1.1, 1., 1.); // R: 1.48660687
    SpacePoint outerCenterSP = provideSpacePointDummy(2., 2., 2.); // R: 2.82842712
    SpacePoint innerCenterSP = provideSpacePointDummy(3., 2.1, 3.); // R: 3.66196668
    SpacePoint innerSP = provideSpacePointDummy(4., 3., 3.); // R: 5
    SpacePoint innermostSP = provideSpacePointDummy(5., 3, 6.); // R: 5.83095189
 
    const std::vector<const Belle2::SpacePoint*> aSpacePointVec = { &outerSP, &outerCenterSP, &innerCenterSP, &innerSP };
 
    Filter< ZiggZaggXY<SpacePoint, std::vector<const Belle2::SpacePoint*>>, ClosedRange<int, int>, ResultsObserver >
        ziggZaggXYChecker4VecSPs(
          ClosedRange<int, int>(1, 1));
    EXPECT_FALSE(ziggZaggXYChecker4VecSPs.accept(aSpacePointVec));
    EXPECT_EQ(2, lastResult);
 
    // should be ziggZagg:
    SpacePointTrackCand aSpacePointTC = SpacePointTrackCand(aSpacePointVec, 11, -1, 23);
 
    Filter< ZiggZaggXY<SpacePoint, SpacePointTrackCand>, ClosedRange<int, int>, ResultsObserver > ziggZaggXYChecker4SPTC(
      ClosedRange<int, int>(1, 1));
    EXPECT_FALSE(ziggZaggXYChecker4SPTC.accept(aSpacePointTC));
    EXPECT_EQ(2, lastResult);
    Filter< ZiggZaggXYWithSigma<SpacePoint, SpacePointTrackCand>, ClosedRange<int, int>, ResultsObserver >
    ziggZaggXYWithSigmaChecker4SPTC(
      ClosedRange<int, int>(0, 1));
    EXPECT_FALSE(ziggZaggXYWithSigmaChecker4SPTC.accept(aSpacePointTC));
    EXPECT_EQ(2, lastResult);
    Filter< ZiggZaggRZ<SpacePoint, SpacePointTrackCand>, ClosedRange<int, int>, ResultsObserver > ziggZaggRZChecker4SPTC(
      ClosedRange<int, int>(1, 1));
    EXPECT_FALSE(ziggZaggRZChecker4SPTC.accept(aSpacePointTC));
    EXPECT_EQ(2, lastResult);
 
 
    // should be ziggZagg:
    const std::vector<const Belle2::SpacePoint*> aSpacePointVec2 = { &outerSP, &outerCenterSP, &innerCenterSP, &innerSP, &innerSP };
    SpacePointTrackCand aSpacePointTC2 = SpacePointTrackCand(aSpacePointVec2, 11, -1, 23);
 
    EXPECT_FALSE(ziggZaggXYChecker4SPTC.accept(aSpacePointTC2));
    EXPECT_EQ(3, lastResult); // last two hits are identical, will be detected in Filter.
    EXPECT_FALSE(ziggZaggXYWithSigmaChecker4SPTC.accept(aSpacePointTC2));
    EXPECT_EQ(2, lastResult);
    EXPECT_FALSE(ziggZaggRZChecker4SPTC.accept(aSpacePointTC2));
    EXPECT_EQ(3, lastResult);
 
 
    // should _not_ be ziggZagg:
    const std::vector<const Belle2::SpacePoint*> aSpacePointVec3 = { &outerSP, &outerCenterSP, &innerSP, &innermostSP };
    SpacePointTrackCand aSpacePointTC3 = SpacePointTrackCand(aSpacePointVec3, 11, -1, 23);
 
    EXPECT_TRUE(ziggZaggXYChecker4SPTC.accept(aSpacePointTC3));
    EXPECT_EQ(1, lastResult);
    EXPECT_TRUE(ziggZaggXYWithSigmaChecker4SPTC.accept(aSpacePointTC3));
    EXPECT_EQ(1, lastResult);
    EXPECT_FALSE(ziggZaggRZChecker4SPTC.accept(aSpacePointTC3));
    EXPECT_EQ(2, lastResult);
 
 
    //  /** Difference between ZiggZaggs (no RZ-test here) **/
    SpacePoint testSP1 = provideSpacePointDummy(1.001, 1., 0.); // sets to positionSigma of ~0.1 in x,y,z!
    SpacePoint testSP2 = provideSpacePointDummy(2., 2.0002, 0.); // sets to positionSigma of ~0.1 in x,y,z!
    SpacePoint testSP3 = provideSpacePointDummy(3.0005, 3., 0.); // sets to positionSigma of ~0.1 in x,y,z!
    SpacePoint testSP4 = provideSpacePointDummy(4., 4.0003, 0.); // sets to positionSigma of ~0.1 in x,y,z!
    SpacePoint testSP5 = provideSpacePointDummy(5.001, 5., 0.); // sets to positionSigma of ~0.1 in x,y,z!
    const std::vector<const Belle2::SpacePoint*> aSpacePointVec4 = { &testSP1, &testSP2, &testSP3, &testSP4, &testSP5 };
    SpacePointTrackCand aSpacePointTC4 = SpacePointTrackCand(aSpacePointVec4, 11, -1, 23);
 
    EXPECT_FALSE(ziggZaggXYChecker4SPTC.accept(aSpacePointTC4));
    EXPECT_EQ(2, lastResult);
    EXPECT_TRUE(ziggZaggXYWithSigmaChecker4SPTC.accept(aSpacePointTC4)); // does not ziggZagg due to positionSigma != 0
    EXPECT_EQ(0, lastResult);
 
  }
 
}