VXDTFObserversTest Namespace Reference

TODO next steps: More...

Classes
class	CountAcceptedRejectedMCParticleObserver
	this observer identifies the McParticles responsible for creating underlying clusters for given spacePoints and counts how often a particle type was accepted and how often it was rejected More...
class	CountAcceptRejectObserver
	this observer does simply count the number of times, the attached SelectionVariable was accepted or rejected More...
class	CountBadCaseObserver
	this observer does simply count the number of times, the attached Filter resulted in isinf or isnan More...
class	CountContainer
	a container for counting accepted and rejected stuff, just delivers some interfaces to make the code more readable More...
class	counter
	a tiny counter class for counting stuff More...
class	counterMC
	a tiny counter class for counting stuff retrieved from MC-bla More...
class	CountUsedObserver
	this observer does simply count the number of times, the attached SelectionVariable was used More...
class	InfoObserver
	this observer does simply print the name of the SelectionVariable and the result of its value-function as a Warning More...
class	ObserversTest
	Test class for testing and developing new Observers. More...
class	ProvideBasicInfoObserver
	this observer combines all the easy-to-get info retrievable by observers and prints it to screen More...
class	VectorOfObservers
	WARNING TODO: More...

Functions
VXD::SensorInfoBase	provideSensorInfo (VxdID aVxdID, double globalX=0., double globalY=0., double globalZ=-0.)
	this is a small helper function to create a sensorInfo to be used
PXDCluster	providePXDCluster (double u, double v, VxdID aVxdID, double uError=0.1, double vError=0.1)
	returns a pxdCluster with given sensorID and local coordinates
SVDCluster	provideSVDCluster (VxdID aVxdID, bool isU, double position, double error=0.1)
	returns a svdCluster with given sensorID, uType and local position
SpacePoint	provideSpacePointDummy (unsigned short i, double X, double Y, double Z)
	when given index number for vxdID and global coordinates, a SpacePoint lying there will be returned
	TEST_F (ObserversTest, TestRelationSetup)
	initialize static member of variant Try2
	TEST_F (ObserversTest, TestMCDataAccess)
	tests possibility of accessing MCData
	TEST_F (ObserversTest, TestObserverFlexibility)
	presents the functionality of the SpacePoint-creating function written above
	TEST_F (ObserversTest, ignoreMe)
	ignore what is written in this test, is simply used as a temporary storage for currently not used code-snippets

Detailed Description

TODO next steps:

• write an observer reading relevant info (like whether two clusters of a spacePoint are related to the same mcParticle)
• implement easy container to be filled by observers
• write an observer which fills this container
• write all the other observers planned

Function Documentation

providePXDCluster()

PXDCluster providePXDCluster	(	double	u,
		double	v,
		VxdID	aVxdID,
		double	uError = 0.1,
		double	vError = 0.1
	)

returns a pxdCluster with given sensorID and local coordinates

Definition at line 69 of file observers.cc.

  {
    return PXDCluster(aVxdID, u, v, uError, vError, 0, 0, 1, 1, 1, 1, 1, 1);
  }

provideSensorInfo()

VXD::SensorInfoBase provideSensorInfo	(	VxdID	aVxdID,
		double	globalX = 0.,
		double	globalY = 0.,
		double	globalZ = -0.
	)

this is a small helper function to create a sensorInfo to be used

Definition at line 49 of file observers.cc.

  {
    // (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;
  }

provideSpacePointDummy()

SpacePoint provideSpacePointDummy	(	unsigned short	i,
		double	X,
		double	Y,
		double	Z
	)

when given index number for vxdID and global coordinates, a SpacePoint lying there will be returned

Definition at line 83 of file observers.cc.

  {
    VxdID aVxdID = VxdID(i, i, i);
    VXD::SensorInfoBase sensorInfoBase = provideSensorInfo(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);
  }

provideSVDCluster()

SVDCluster provideSVDCluster	(	VxdID	aVxdID,
		bool	isU,
		double	position,
		double	error = 0.1
	)

returns a svdCluster with given sensorID, uType and local position

Definition at line 76 of file observers.cc.

  {
    return SVDCluster(aVxdID, isU, position, error, 0.1, 0.1, 1, 1, 1, 1);
  }

TEST_F() [1/4]

TEST_F	(	ObserversTest	,
		ignoreMe
	)

ignore what is written in this test, is simply used as a temporary storage for currently not used code-snippets

a tiny CollectedObservers class for CollectedObservers stuff

Definition at line 956 of file observers.cc.

  {
    //garbage:
    //  VectorOfObservers<Distance3DSquared>::addObserver(CountUsedObserver::notify);
    //  auto storeFunc = std::bind((void(*)(const SpacePoint&, const SpacePoint&, const Belle2::Distance3DSquared&, float))&CountUsedObserver::notify, std::placeholders::_1, std::placeholders::_2, Distance3DSquared(), std::placeholders::_3);
    //  auto storeFunc1 = std::bind(void(*)(const typename Distance3DSquared::argumentType&, const typename Distance3DSquared::argumentType&, const Distance3DSquared&, typename Distance3DSquared::variableType) /*&CountUsedObserver::notify*/), std::placeholders::_1, std::placeholders::_2, Distance3DSquared(), std::placeholders::_3);
 
//  ObserverVector<Distance3DSquared>::sm_collectedObservers.push_back(storeFunc);
    //  ObserverVector<Distance3DSquared>::sm_collectedObservers.push_back(std::bind((void(*)(const SpacePoint&, const SpacePoint&, const Belle2::Distance3DSquared&, float))&CountUsedObserver::notify, std::placeholders::_1, std::placeholders::_2, Distance3DSquared(), std::placeholders::_3));
    // std::vector< typename ObserverVector<FilterType>::observerFunction >();
    //     ObserverVector<VectorOfObservers>::sm_collectedObservers = std::vector< typename VectorOfObservers<Distance3DSquared>::observerFunction >();
//  ErrorObserver anErrorBla();
    //  WarningObserver aWarningBla();
    //  ObserverVector<Distance3DSquared>::addObserver(aWarningBla/*, filterBla*/);
    //  ObserverVector<Distance3DSquared>::addObserver(aBla/*, filterBla*/);
    // // // // // //   Distance3DSquared filterBla();
 
//   template<class FilterType> class CollectedObservers {
//   public:
//  typedef std::function< void (const typename FilterType::argumentType&, const typename FilterType::argumentType&, const FilterType&, typename FilterType::variableType)> observerFunction;
//
//  /** collects observers to be executed during notify */
//  static std::vector< observerFunction > collectedObservers;
//  CollectedObservers() {};
//  ~CollectedObservers() {};
//   };
 
//  static void addObserver( CountUsedObserver& newObserver) {
//    //  static void addObserver(observerFunction newObserver) {
//    ObserverVector<FilterType>::sm_collectedObservers.push_back(std::bind(&newObserver::notify, std::placeholders::_1, std::placeholders::_2, FilterType(), std::placeholders::_3));
//  }
  }

TEST_F() [2/4]

TEST_F	(	ObserversTest	,
		TestMCDataAccess
	)

tests possibility of accessing MCData

TODO further tests!

Definition at line 811 of file observers.cc.

  {
    Filter< Distance3DSquared<SpacePoint>, Range<double, double>, VoidObserver > unobservedFilter(Range<double, double>(2.5,
        3.5));
    Filter< Distance3DSquared<SpacePoint>, Range<double, double>, CountAcceptedRejectedMCParticleObserver > observedFilter(
      unobservedFilter);
    auto mcCounter = counterMC< Distance3DSquared<SpacePoint> >();
 
    for (int i = 1 ; i < spacePointData.getEntries(); i++) {
      SpacePoint& spA = *spacePointData[i];
      SpacePoint& spB = *spacePointData[i - 1];
      B2DEBUG(10, "spData-Sps got arraIndices: " << spacePointData[i]->getArrayIndex() << "/" << spacePointData[i - 1]->getArrayIndex() <<
              " and VxdIDs " << spacePointData[i]->getVxdID() << "/" << spacePointData[i - 1]->getVxdID());
      observedFilter.accept(spA, spB);
    }
 
    EXPECT_EQ(3, mcCounter.pdGacceptedRejected.size());
    EXPECT_EQ(3, mcCounter.mcIDacceptedRejected.size());
 
    mcCounter.pdGacceptedRejected.PrintResults("pdgCode");
 
    // the filter was too loose, everything is accepted
    EXPECT_EQ(1, mcCounter.pdGacceptedRejected.ReturnResult(CountContainer::Particles{11}).accept);
    EXPECT_EQ(3, mcCounter.pdGacceptedRejected.ReturnResult(CountContainer::Particles{11, 13}).accept);
    EXPECT_EQ(1, mcCounter.pdGacceptedRejected.ReturnResult(CountContainer::Particles{13}).accept);
    // and nothing was rejected...
    EXPECT_EQ(0, mcCounter.pdGacceptedRejected.ReturnResult(CountContainer::Particles{11}).reject);
    EXPECT_EQ(0, mcCounter.pdGacceptedRejected.ReturnResult(CountContainer::Particles{11, 13}).reject);
    EXPECT_EQ(0, mcCounter.pdGacceptedRejected.ReturnResult(CountContainer::Particles{13}).reject);
 
 
    mcCounter.mcIDacceptedRejected.PrintResults("pID");
 
    EXPECT_EQ(1, mcCounter.mcIDacceptedRejected.ReturnResult(CountContainer::Particles{1}).accept);
    EXPECT_EQ(3, mcCounter.mcIDacceptedRejected.ReturnResult(CountContainer::Particles{1, 2}).accept);
    EXPECT_EQ(1, mcCounter.mcIDacceptedRejected.ReturnResult(CountContainer::Particles{2}).accept);
 
    EXPECT_EQ(0, mcCounter.mcIDacceptedRejected.ReturnResult(CountContainer::Particles{1}).reject);
    EXPECT_EQ(0, mcCounter.mcIDacceptedRejected.ReturnResult(CountContainer::Particles{1, 2}).reject);
    EXPECT_EQ(0, mcCounter.mcIDacceptedRejected.ReturnResult(CountContainer::Particles{2}).reject);
 
 
    // now we set the filter using values which are too strict
    Filter< Distance3DSquared<SpacePoint>, Range<double, double>, VoidObserver > unobservedFilterStrict(Range<double, double>
        (3.1, 3.5));
    Filter< Distance3DSquared<SpacePoint>, Range<double, double>, CountAcceptedRejectedMCParticleObserver >
    observedFilterStrict(
      unobservedFilterStrict);
 
    for (int i = 1 ; i < spacePointData.getEntries(); i++) {
      SpacePoint& spA = *spacePointData[i];
      SpacePoint& spB = *spacePointData[i - 1];
      observedFilterStrict.accept(spA, spB);
    }
 
    EXPECT_EQ(3, mcCounter.pdGacceptedRejected.size());
    EXPECT_EQ(3, mcCounter.mcIDacceptedRejected.size());
 
    // first filter does write into the same container, therefore values didn't change for accepted
    EXPECT_EQ(1, mcCounter.pdGacceptedRejected.ReturnResult(CountContainer::Particles{11}).accept);
    EXPECT_EQ(3, mcCounter.pdGacceptedRejected.ReturnResult(CountContainer::Particles{11, 13}).accept);
    EXPECT_EQ(1, mcCounter.pdGacceptedRejected.ReturnResult(CountContainer::Particles{13}).accept);
 
    // second filter does reject everything:
    EXPECT_EQ(1, mcCounter.pdGacceptedRejected.ReturnResult(CountContainer::Particles{11}).reject);
    EXPECT_EQ(3, mcCounter.pdGacceptedRejected.ReturnResult(CountContainer::Particles{11, 13}).reject);
    EXPECT_EQ(1, mcCounter.pdGacceptedRejected.ReturnResult(CountContainer::Particles{13}).reject);
 
    EXPECT_EQ(1, mcCounter.mcIDacceptedRejected.ReturnResult(CountContainer::Particles{1}).accept);
    EXPECT_EQ(3, mcCounter.mcIDacceptedRejected.ReturnResult(CountContainer::Particles{1, 2}).accept);
    EXPECT_EQ(1, mcCounter.mcIDacceptedRejected.ReturnResult(CountContainer::Particles{2}).accept);
 
    EXPECT_EQ(1, mcCounter.mcIDacceptedRejected.ReturnResult(CountContainer::Particles{1}).reject);
    EXPECT_EQ(3, mcCounter.mcIDacceptedRejected.ReturnResult(CountContainer::Particles{1, 2}).reject);
    EXPECT_EQ(1, mcCounter.mcIDacceptedRejected.ReturnResult(CountContainer::Particles{2}).reject);
 
  }

TEST_F() [3/4]

TEST_F	(	ObserversTest	,
		TestObserverFlexibility
	)

presents the functionality of the SpacePoint-creating function written above

variant A (doesn't work, because of static function(?)):

variant B:

doesn't work, different type, additionally static_cast doesn't work too (reinterpret_casat too dangerous, didn't try):

long-term goal, something comparable to this:

Definition at line 895 of file observers.cc.

  {
    // Very verbose declaration, see below for convenient shortcuts
    Filter< Distance3DSquared<SpacePoint>, Range<double, double>, VoidObserver > unobservedFilter(Range<double, double>(0.,
        1.));
 
    //     Filter< Distance3DSquared<SpacePoint>, Range<double, double>, VectorOfObservers<Distance3DSquared> > filter(unobservedFilter);
    Filter< Distance3DSquared<SpacePoint>, Range<double, double>, InfoObserver > observedFilter(unobservedFilter);
    SpacePoint x1 = provideSpacePointDummy(1, 0.0f, 0.0f, 0.0f);
    SpacePoint x2 = provideSpacePointDummy(1, 0.5f, 0.0f, 0.0f);
    SpacePoint x3 = provideSpacePointDummy(1, 2.0f, 0.0f, 0.0f);
    auto myCounter = counter<Distance3DSquared<SpacePoint>>();
    myCounter.resetCounter();
 
//  auto storeFuncVariantA = std::bind( ((VectorOfObservers<Distance3DSquared>::observerFunction) &CountingObserver::notify), std::placeholders::_1, std::placeholders::_2, Distance3DSquared(), std::placeholders::_3);
    //  VectorOfObservers<Distance3DSquared>::sm_collectedObservers.push_back(storeFuncVariantA);
 
    auto storeFuncVariantB = std::bind(((VectorOfObservers<Distance3DSquared<SpacePoint>>::CStyleFunctionPointer)
                                        &CountUsedObserver::notify), std::placeholders::_1, std::placeholders::_2, Distance3DSquared<SpacePoint>(),
                                       std::placeholders::_3);
 
    char* realname(nullptr);
    int status(0);
    realname = abi::__cxa_demangle(typeid(storeFuncVariantB).name(), 0, 0, &status);
    std::string name(realname);
    free(realname);
    B2INFO("storeFuncVariantB is of type: " << name);
 
//  VectorOfObservers<Distance3DSquared>::sm_collectedObserversTry2.push_back(storeFuncVariantB);
 
 
//  VectorOfObservers<Distance3DSquared>::sm_collectedObserversCSTYLE.push_back(storeFuncVariantB);
 
    // VectorOfObservers<Distance3DSquared>::addObserver(CountUsedObserver);
    // VectorOfObservers<Distance3DSquared>::addObserver(WarningObserver);
 
    observedFilter.accept(x2, x1);
    observedFilter.accept(x3, x1);
    EXPECT_EQ(0, myCounter.used);
 
    Filter< Distance3DSquared<SpacePoint>, Range<double, double>, ProvideBasicInfoObserver > anotherObservedFilter(
      unobservedFilter);
 
    anotherObservedFilter.accept(x2, x1);
    anotherObservedFilter.accept(x3, x1);
    EXPECT_EQ(2, myCounter.used);
    EXPECT_EQ(1, myCounter.accepted);
    EXPECT_EQ(1, myCounter.rejected);
    EXPECT_EQ(0, myCounter.wasInf);
    EXPECT_EQ(0, myCounter.wasNan);
  }

TEST_F() [4/4]

TEST_F	(	ObserversTest	,
		TestRelationSetup
	)

initialize static member of variant Try2

tests whether the setup of relations is doing what it is supposed to do

Definition at line 761 of file observers.cc.

  {
    EXPECT_EQ(6, spacePointData.getEntries());
 
    for (SpacePoint& aSP : spacePointData) {
      unsigned nullptrTrap = 0;
      RelationVector<PXDCluster> pxDClusters = aSP.getRelationsTo<PXDCluster>();
      for (PXDCluster& aCluster : pxDClusters) {
        MCParticle* aParticle = aCluster.getRelatedTo<MCParticle>();
        if (aParticle == nullptr) { nullptrTrap = 1; }
        EXPECT_EQ(0, nullptrTrap);
 
        if (aParticle) {
          EXPECT_EQ(aSP.getArrayIndex(), aCluster.getArrayIndex());
          EXPECT_EQ(aSP.getArrayIndex(), aParticle->getArrayIndex());
          EXPECT_EQ(int(aParticle->getMomentum().X()), aParticle->getArrayIndex() + 1);
          EXPECT_EQ(int(aParticle->getMomentum().Y()), aParticle->getArrayIndex() + 1);
          EXPECT_EQ(int(aParticle->getMomentum().Z()), aParticle->getArrayIndex() + 1);
        }
 
        nullptrTrap = 0;
      }
 
      RelationVector<SVDCluster> svDClusters = aSP.getRelationsTo<SVDCluster>();
      for (SVDCluster& aCluster : svDClusters) {
        MCParticle* aParticle = aCluster.getRelatedTo<MCParticle>();
        if (aParticle == nullptr) { nullptrTrap = 2; }
        EXPECT_EQ(0, nullptrTrap);
 
        if (aParticle) {
          EXPECT_EQ(aSP.getArrayIndex(), 2 + aCluster.getArrayIndex() / 2);
          EXPECT_EQ(aSP.getArrayIndex() / 4, aParticle->getArrayIndex());
          EXPECT_EQ(int(aParticle->getMomentum().X()), aParticle->getArrayIndex() + 1);
          EXPECT_EQ(int(aParticle->getMomentum().Y()), aParticle->getArrayIndex() + 1);
          EXPECT_EQ(int(aParticle->getMomentum().Z()), aParticle->getArrayIndex() + 1);
        }
 
        nullptrTrap = 0;
      }
 
      // at least one cluster type has to be connected to given spacePoint!
      EXPECT_NE(0, pxDClusters.size() + svDClusters.size());
    }
  }