mdst

Topics
	mdst data objects
	mdst modules

Classes
class	BeamSpot
	This class contains the beam spot position and size modeled as a gaussian distribution in space. More...
class	CollisionAxisCMS
	This class contains the measured values of the orientation of the collision axis in the CM system obtained by pure Lorentz boost angleXZ = atan(pHERcms.X / pHERcms.Z) angleYZ = atan(pHERcms.Y / pHERcms.Z) where pHERcms is HER momentum in CM system obtained by boost. More...
class	CollisionBoostVector
	This class contains the measured average boost vector vec(beta) = (beta_x, beta_y, beta_z) = vec(p_e+e-)/E_e+e- of the center-of-mass system in the lab frame and its uncertainty. More...
class	CollisionInvariantMass
	This class contains the measured average center-of-mass energy, which is equal to the invariant mass of the colliding beams, and its uncertainty. More...
class	DBRepresentationOfSoftwareTriggerCut
	Class to handle storing SoftwareTriggerCuts in the database. More...
class	SoftwareTriggerCutBase
	Base class for the SoftwareTriggerCut and its DBRepresentation. More...
class	SoftwareTriggerMenu
	Class to handle storing the trigger menu in the database. More...
class	TRGGDLDBBadrun
	The payload class for GDL badrun. More...
class	TRGGDLDBFTDLBits
	The payload class for FTDL output bit. More...
class	TRGGDLDBInputBits
	The payload class for GDL input bit. More...
class	TRGGDLDBPrescales
	The payload class for GDL psnm. More...
class	TTDOffsets
	This class contains information to correct the information obtained from the TTD (simple offsets) More...
class	BeamSpotTest
class	ECLClusterTest
	Test class for the Track object. More...
class	EventLevelTrackingInfoTest
	Unit tests for the event level tracking information. More...
class	HitPatternCDCTest
	Unit tests for the CDC hit Patterns. More...
class	HitPatternVXDTest
class	KlIdTest
	Test class for the KlId object. More...
class	TrackTest
	Test class for the Track object. More...
class	TrackFitResultTest
	Set up a few arrays and objects in the datastore. More...
class	V0Test
	Set up a few arrays and objects in the datastore. More...

Functions
	TEST_F (BeamSpotTest, Basic)
	Constructor, copy constructor, comparison, setters and getters.
	TEST_F (ECLClusterTest, Constructors)
	Test default constructor.
	TEST_F (ECLClusterTest, SettersAndGetters)
	Test setter and getter.
	TEST_F (EventLevelTrackingInfoTest, settersNGettersCDC)
	Test simple Setters, Getters, and Hassers for the CDC related part.
	TEST_F (EventLevelTrackingInfoTest, settersNGettersVXD)
	Test simple Setters and Getters for the VXD related part.
	TEST_F (EventLevelTrackingInfoTest, settersNGettersFlagBlock)
	Test simple Setters and Getters for the VXD related part.
	TEST_F (HitPatternCDCTest, settersNGetters)
	Test simple Setters, Getters, and Hassers.
	TEST_F (HitPatternCDCTest, SetNGetTotalNumberOfHits)
	This tests if the total number of hits is set and read correctly.
	TEST_F (HitPatternCDCTest, getLongestContRunInSL)
	Test if the longest run in a superlayer is returned correctly.
	TEST_F (HitPatternCDCTest, getFirstLastLayer)
	Test if getFirst/LastLayer returns the proper value.
	TEST_F (HitPatternVXDTest, NumberingScheme)
	Test the numbering scheme in the static variables.
	TEST_F (HitPatternVXDTest, General)
	Constructor and some general getters.
	TEST_F (HitPatternVXDTest, SVDSetterAndGetter)
	Test simple Setters and Getters for SVD.
	TEST_F (HitPatternVXDTest, PXDSetterAndGetter)
	Test simple Setters and Getters for the PXD.
	TEST_F (HitPatternVXDTest, NGetters)
	Test total number of hit getters.
	TEST_F (HitPatternVXDTest, getNLayers)
	Test the getNLayer functions.
	TEST_F (HitPatternVXDTest, getFirstLastLayer)
	Test the getters for First/Last Layer.
	TEST_F (KlIdTest, SettersAndGetters)
	Test setter and getter.
TrackFitResult const *	addDummyTrack (StoreArray< TrackFitResult > &trackFitResults, Const::ChargedStable particeType, float pValue=1.)
	Utility function to create dummy TrackFitResults.
	TEST_F (TrackTest, settersNGetters)
	Test simple Setters and Getters.
	TEST_F (TrackTest, getTrackFitResultWithClosestMass)
	Test getTrackFitResultWithClosestMass.
	TEST_F (TrackTest, getTrackFitResultWithBestPValue)
	Test getTrackFitResultWithBestPValue.
	TEST_F (TrackFitResultTest, Getters)
	Test simple Setters and Getters.
	TEST_F (TrackFitResultTest, ErrorPropagation)
	Test if the error propagation of the covariance matrix works properly.
	TEST_F (TrackFitResultTest, Charge)
	Test get charge.
	TEST_F (V0Test, IndexGetters)
	Test Index Getter.
	TEST_F (V0Test, PointerGetters)
	Test Pointer Getter.

Detailed Description

Function Documentation

addDummyTrack()

TrackFitResult const * addDummyTrack	(	StoreArray< TrackFitResult > &	trackFitResults,
		Const::ChargedStable	particeType,
		float	pValue = 1. )

Utility function to create dummy TrackFitResults.

Definition at line 35 of file track.cc.

  {
    const ROOT::Math::XYZVector dummyVector3;
    const TMatrixDSym dummyMatrix(6);
    const int charge = 1;
    const float bField = 1.5;
 
    const auto newFitRes = trackFitResults.appendNew(dummyVector3, dummyVector3, dummyMatrix, charge, particeType, pValue,
                                                     bField, 0, 0, 0);
    return newFitRes;
  }

TEST_F() [1/26]

TEST_F	(	BeamSpotTest	,
		Basic	)

Constructor, copy constructor, comparison, setters and getters.

Definition at line 25 of file BeamSpotUT.cc.

  {
    BeamSpot bs;
    EXPECT_EQ(bs.getIPPosition().X(), 0.);
    EXPECT_EQ(bs.getIPPosition().Y(), 0.);
    EXPECT_EQ(bs.getIPPosition().Z(), 0.);
 
    std::function<float (int, int)> sizeElement = [ & sizeElement](int i, int j) {
      return j >= i ? (i + 1) + 10 * (j + 1) : sizeElement(j, i) ;
    };
 
    std::function<float (int, int)> errorElement = [& errorElement](int i, int j) {
      return j >= i ? 100 + (i + 1) + 10 * (j + 1) : errorElement(j, i);
    };
 
    TMatrixDSym size(3), positionError(3);
    for (int i = 0; i < 3; i++)
      for (int j = i; j < 3; j++) {
        size(i, j) = size(j, i) = sizeElement(i, j);
        positionError(i, j) = positionError(j, i) = errorElement(i, j);
      }
 
    ROOT::Math::XYZVector position;
    position.SetXYZ(1., 2., 3.);
 
    bs.setSizeCovMatrix(size);
    bs.setIP(position, positionError);
 
    ROOT::Math::XYZVector testPosition = bs.getIPPosition();
    EXPECT_EQ(testPosition.X(), 1.);
    EXPECT_EQ(testPosition.Y(), 2.);
    EXPECT_EQ(testPosition.Z(), 3.);
 
    TMatrixDSym testError = bs.getIPPositionCovMatrix();
    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 3; j++)
        EXPECT_EQ(testError(i, j), errorElement(i, j));
 
    TMatrixDSym testSize = bs.getSizeCovMatrix();
    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 3; j++)
        EXPECT_EQ(testSize(i, j), sizeElement(i, j));
 
 
    TMatrixDSym testCovVertex = bs.getCovVertex();
    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 3; j++)
        EXPECT_EQ(testCovVertex(i, j), (sizeElement(i, j) + errorElement(i, j)));
 
    EXPECT_EQ(bs.getGlobalUniqueID(), 1);
    BeamSpot bs2(bs);
    EXPECT_EQ(bs == bs2, true);
 
    BeamSpot bs3;
    bs3 = bs;
    EXPECT_EQ(bs == bs3, true);
 
    BeamSpot bs4;
    bs4 = bs3;
    size(2, 2) = 0.;
 
    bs3.setSizeCovMatrix(size);
    size(2, 2) = std::numeric_limits<double>::min();
    bs4.setSizeCovMatrix(size);
 
    EXPECT_EQ(bs4 == bs3, false);
  }

TEST_F() [2/26]

TEST_F	(	ECLClusterTest	,
		Constructors	)

Test default constructor.

Definition at line 29 of file eclCluster.cc.

  {
    ECLCluster myECLCluster;
 
    EXPECT_EQ(exp(-5.), myECLCluster.getEnergy(ECLCluster::EHypothesisBit::c_nPhotons));
    EXPECT_EQ(exp(-5.), myECLCluster.getEnergyRaw());
    EXPECT_EQ(exp(-5.), myECLCluster.getEnergyHighestCrystal());
    EXPECT_EQ(0, myECLCluster.getTheta());
    EXPECT_EQ(0, myECLCluster.getPhi());
    EXPECT_EQ(0, myECLCluster.getR());
    EXPECT_EQ(0, myECLCluster.getTime());
    EXPECT_EQ(0, myECLCluster.getDeltaTime99());
    EXPECT_EQ(0, myECLCluster.getStatus());
    EXPECT_EQ(0, myECLCluster.getNumberOfCrystals());
    EXPECT_EQ(0, myECLCluster.getLAT());
    EXPECT_EQ(0, myECLCluster.getAbsZernike40());
    EXPECT_EQ(0, myECLCluster.getAbsZernike51());
    EXPECT_EQ(0, myECLCluster.getZernikeMVA());
    EXPECT_EQ(0, myECLCluster.getE1oE9());
    EXPECT_EQ(0, myECLCluster.getE9oE21());
 
    EXPECT_EQ(0, myECLCluster.getUncertaintyEnergy());
    EXPECT_EQ(0, myECLCluster.getUncertaintyTheta());
    EXPECT_EQ(0, myECLCluster.getUncertaintyPhi());
 
    EXPECT_FALSE(myECLCluster.isTrack());
    EXPECT_TRUE(myECLCluster.isNeutral());
 
    double x = myECLCluster.getClusterPosition().X();
    double y = myECLCluster.getClusterPosition().Y();
    double z = myECLCluster.getClusterPosition().Z();
    EXPECT_EQ(0, x);
    EXPECT_EQ(0, y);
    EXPECT_EQ(0, z);
 
    const auto error3x3 = myECLCluster.getCovarianceMatrix3x3();
    EXPECT_EQ(0, error3x3(0, 0));
    EXPECT_EQ(0, error3x3(0, 1));
    EXPECT_EQ(0, error3x3(0, 2));
    EXPECT_EQ(0, error3x3(1, 0));
    EXPECT_EQ(0, error3x3(1, 1));
    EXPECT_EQ(0, error3x3(1, 2));
    EXPECT_EQ(0, error3x3(2, 0));
    EXPECT_EQ(0, error3x3(2, 1));
    EXPECT_EQ(0, error3x3(2, 2));
 
  } // default constructor

TEST_F() [3/26]

TEST_F	(	ECLClusterTest	,
		SettersAndGetters	)

Test setter and getter.

Definition at line 78 of file eclCluster.cc.

  {
    ECLCluster myECLCluster;
    // Pick some arbitrary numbers to test with
    const bool isTrack = true;
    const double energy = 1.165;
    const float theta = 1.2;
    const float phi = 1.2;
    const double r = 1.2;
    const double energyDepSum = 12.3;
    const double time = 17.2;
    const double deltaTime99 = 1.1;
    const double E9oE21 = 0.1;
    const double highestEnergy = 32.1;
    const double lat = 0.5;
    const double   nOfCrystals = 4;
    const ECLCluster::EStatusBit status = ECLCluster::EStatusBit::c_PulseShapeDiscrimination;
    // Energy->[0], Phi->[2], Theta->[5]
    double error[6] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6};
 
    myECLCluster.setEnergy(energy);
    myECLCluster.setE9oE21(E9oE21);
    myECLCluster.setEnergyRaw(energyDepSum);
    myECLCluster.setTheta(theta);
    myECLCluster.setPhi(phi);
    myECLCluster.setR(r);
    myECLCluster.setTime(time);
    myECLCluster.setDeltaTime99(deltaTime99);
    myECLCluster.setEnergyHighestCrystal(highestEnergy);
    myECLCluster.setStatus(status);
    myECLCluster.setNumberOfCrystals(nOfCrystals);
    myECLCluster.setLAT(lat);
    myECLCluster.setCovarianceMatrix(error);
    myECLCluster.setIsTrack(isTrack);
    myECLCluster.setHypothesis(ECLCluster::EHypothesisBit::c_nPhotons);
 
    EXPECT_FLOAT_EQ(energy, myECLCluster.getEnergy(ECLCluster::EHypothesisBit::c_nPhotons));
    EXPECT_FLOAT_EQ(E9oE21, myECLCluster.getE9oE21());
    EXPECT_FLOAT_EQ(energyDepSum, myECLCluster.getEnergyRaw());
    EXPECT_FLOAT_EQ(theta, myECLCluster.getTheta());
    EXPECT_FLOAT_EQ(phi, myECLCluster.getPhi());
    EXPECT_FLOAT_EQ(r, myECLCluster.getR());
    EXPECT_FLOAT_EQ(time, myECLCluster.getTime());
    EXPECT_FLOAT_EQ(deltaTime99, myECLCluster.getDeltaTime99());
    EXPECT_FLOAT_EQ(highestEnergy, myECLCluster.getEnergyHighestCrystal());
    EXPECT_TRUE(myECLCluster.hasStatus(status));
    EXPECT_FLOAT_EQ(nOfCrystals, myECLCluster.getNumberOfCrystals());
    EXPECT_FLOAT_EQ(lat, myECLCluster.getLAT());
 
    EXPECT_FLOAT_EQ(error[0], myECLCluster.getUncertaintyEnergy()*myECLCluster.getUncertaintyEnergy());
    EXPECT_FLOAT_EQ(error[5], myECLCluster.getUncertaintyTheta()*myECLCluster.getUncertaintyTheta());
    EXPECT_FLOAT_EQ(error[2], myECLCluster.getUncertaintyPhi()*myECLCluster.getUncertaintyPhi());
 
    EXPECT_TRUE(myECLCluster.isTrack());
    EXPECT_FALSE(myECLCluster.isNeutral());
 
    const auto error3x3 = myECLCluster.getCovarianceMatrix3x3();
    EXPECT_FLOAT_EQ(error[0], error3x3(0, 0));
    EXPECT_FLOAT_EQ(error[1], error3x3(0, 1));
    EXPECT_FLOAT_EQ(error[3], error3x3(0, 2));
    EXPECT_FLOAT_EQ(error[1], error3x3(1, 0));
    EXPECT_FLOAT_EQ(error[2], error3x3(1, 1));
    EXPECT_FLOAT_EQ(error[4], error3x3(1, 2));
    EXPECT_FLOAT_EQ(error[3], error3x3(2, 0));
    EXPECT_FLOAT_EQ(error[4], error3x3(2, 1));
    EXPECT_FLOAT_EQ(error[5], error3x3(2, 2));
 
  } // default constructor

TEST_F() [4/26]

TEST_F	(	EventLevelTrackingInfoTest	,
		settersNGettersCDC	)

Test simple Setters, Getters, and Hassers for the CDC related part.

Definition at line 23 of file eventLevelTrackingInfo.cc.

  {
    // Test proper initialization for an empty afterimage.
    EventLevelTrackingInfo eventLevelTrackingInfo;
    EXPECT_EQ(eventLevelTrackingInfo.getNCDCHitsNotAssigned(), 0);
    EXPECT_EQ(eventLevelTrackingInfo.getNCDCHitsNotAssignedPostCleaning(), 0);
 
    //Let's set the total number CDC hits in the afterimage
    eventLevelTrackingInfo.setNCDCHitsNotAssigned(324);
    eventLevelTrackingInfo.setNCDCHitsNotAssignedPostCleaning(257);
 
    EXPECT_EQ(eventLevelTrackingInfo.getNCDCHitsNotAssigned(), 324);
    EXPECT_EQ(eventLevelTrackingInfo.getNCDCHitsNotAssignedPostCleaning(), 257);
 
    //Let's set and get information for the various layers:
    eventLevelTrackingInfo.setCDCLayer(9); // SL1
    EXPECT_TRUE(eventLevelTrackingInfo.hasCDCLayer(9));
    EXPECT_FALSE(eventLevelTrackingInfo.hasCDCLayer(10));
    eventLevelTrackingInfo.setCDCLayer(23);
    EXPECT_TRUE(eventLevelTrackingInfo.hasCDCLayer(23));
    EXPECT_FALSE(eventLevelTrackingInfo.hasCDCLayer(55));
 
    EXPECT_B2FATAL(eventLevelTrackingInfo.setCDCLayer(56));
    EXPECT_B2FATAL(eventLevelTrackingInfo.hasCDCLayer(56));
 
    //Let's have a look at the SuperLayers ...
    EXPECT_TRUE(eventLevelTrackingInfo.hasCDCSLayer(1));
    EXPECT_FALSE(eventLevelTrackingInfo.hasCDCSLayer(5));
 
    //Let's set and get the information on unused segments:
    eventLevelTrackingInfo.setNCDCSegments(21);
    EXPECT_EQ(eventLevelTrackingInfo.getNCDCSegments(), 21);
    eventLevelTrackingInfo.setNCDCSegments(300);
    EXPECT_EQ(eventLevelTrackingInfo.getNCDCSegments(), 255);
  }

TEST_F() [5/26]

TEST_F	(	EventLevelTrackingInfoTest	,
		settersNGettersFlagBlock	)

Test simple Setters and Getters for the VXD related part.

Definition at line 82 of file eventLevelTrackingInfo.cc.

  {
    EventLevelTrackingInfo eventLevelTrackingInfo;
    EXPECT_EQ(eventLevelTrackingInfo.hasUnspecifiedTrackFindingFailure(), false);
    EXPECT_EQ(eventLevelTrackingInfo.hasAnErrorFlag(), false);
    EXPECT_EQ(eventLevelTrackingInfo.hasVXDTF2AbortionFlag(), false);
    eventLevelTrackingInfo.setUnspecifiedTrackFindingFailure();
    EXPECT_EQ(eventLevelTrackingInfo.hasUnspecifiedTrackFindingFailure(), true);
    EXPECT_EQ(eventLevelTrackingInfo.hasAnErrorFlag(), true);
    EXPECT_EQ(eventLevelTrackingInfo.hasVXDTF2AbortionFlag(), false);
 
    EventLevelTrackingInfo eventLevelTrackingInfo2;
    EXPECT_EQ(eventLevelTrackingInfo2.hasVXDTF2AbortionFlag(), false);
    EXPECT_EQ(eventLevelTrackingInfo2.hasAnErrorFlag(), false);
    EXPECT_EQ(eventLevelTrackingInfo2.hasUnspecifiedTrackFindingFailure(), false);
    eventLevelTrackingInfo2.setVXDTF2AbortionFlag();
    EXPECT_EQ(eventLevelTrackingInfo2.hasVXDTF2AbortionFlag(), true);
    EXPECT_EQ(eventLevelTrackingInfo2.hasAnErrorFlag(), true);
    EXPECT_EQ(eventLevelTrackingInfo2.hasUnspecifiedTrackFindingFailure(), false);
  }

TEST_F() [6/26]

TEST_F	(	EventLevelTrackingInfoTest	,
		settersNGettersVXD	)

Test simple Setters and Getters for the VXD related part.

Definition at line 60 of file eventLevelTrackingInfo.cc.

  {
    EventLevelTrackingInfo eventLevelTrackingInfo;
    EXPECT_EQ(eventLevelTrackingInfo.getNVXDClustersInLayer(3), 0);
    eventLevelTrackingInfo.setNVXDClustersInLayer(3, true, 81);
    EXPECT_EQ(eventLevelTrackingInfo.getNVXDClustersInLayer(3), 81);
    eventLevelTrackingInfo.setNVXDClustersInLayer(2, true, 3456);
    EXPECT_EQ(eventLevelTrackingInfo.getNVXDClustersInLayer(2), 3456);
    EXPECT_EQ(eventLevelTrackingInfo.getNVXDClustersInLayer(3, true), 81);
    EXPECT_EQ(eventLevelTrackingInfo.getNVXDClustersInLayer(3, false), 0);
    EXPECT_B2FATAL(eventLevelTrackingInfo.getNVXDClustersInLayer(56));
 
    eventLevelTrackingInfo.setNVXDClustersInLayer(6, true, 300);
    EXPECT_EQ(eventLevelTrackingInfo.getNVXDClustersInLayer(6, true), 255);
 
    eventLevelTrackingInfo.setSVDFirstSampleTime(-128);
    EXPECT_EQ(eventLevelTrackingInfo.getSVDFirstSampleTime(), -128);
    eventLevelTrackingInfo.setSVDFirstSampleTime(127);
    EXPECT_EQ(eventLevelTrackingInfo.getSVDFirstSampleTime(), 127);
  }

TEST_F() [7/26]

TEST_F	(	HitPatternCDCTest	,
		getFirstLastLayer	)

Test if getFirst/LastLayer returns the proper value.

Definition at line 97 of file hitPatternCDC.cc.

  {
    HitPatternCDC myHitPatternCDC(0);
    myHitPatternCDC.setNHits(123); //arbitrary number to check if this layer is masked out correctly
 
    unsigned short firstLayer = 5;
    unsigned short lastLayer = 46;
    myHitPatternCDC.setLayer(firstLayer);
    myHitPatternCDC.setLayer(lastLayer);
    EXPECT_EQ(firstLayer, myHitPatternCDC.getFirstLayer());
    EXPECT_EQ(lastLayer, myHitPatternCDC.getLastLayer());
 
    myHitPatternCDC.resetPattern();
    EXPECT_EQ(-1, myHitPatternCDC.getFirstLayer());
    EXPECT_EQ(-1, myHitPatternCDC.getLastLayer());
  }

TEST_F() [8/26]

TEST_F	(	HitPatternCDCTest	,
		getLongestContRunInSL	)

Test if the longest run in a superlayer is returned correctly.

Definition at line 80 of file hitPatternCDC.cc.

  {
    unsigned long long int initValue = static_cast<unsigned long long int>(0xEEEEEEEEEEEEEEL); // 11101110...11101110
    HitPatternCDC myHitPatternCDC(initValue);
    EXPECT_EQ(3, myHitPatternCDC.getLongestContRunInSL(0));
    EXPECT_EQ(3, myHitPatternCDC.getLongestContRunInSL(1));
    EXPECT_EQ(3, myHitPatternCDC.getLongestContRunInSL(2));
    EXPECT_EQ(3, myHitPatternCDC.getLongestContRunInSL(3));
    EXPECT_EQ(3, myHitPatternCDC.getLongestContRunInSL(4));
    EXPECT_EQ(3, myHitPatternCDC.getLongestContRunInSL(5));
    EXPECT_EQ(3, myHitPatternCDC.getLongestContRunInSL(6));
    EXPECT_EQ(3, myHitPatternCDC.getLongestContRunInSL(7));
    EXPECT_EQ(3, myHitPatternCDC.getLongestContRunInSL(8));
 
  }

TEST_F() [9/26]

TEST_F	(	HitPatternCDCTest	,
		SetNGetTotalNumberOfHits	)

This tests if the total number of hits is set and read correctly.

Definition at line 63 of file hitPatternCDC.cc.

  {
    unsigned long long int initValue = static_cast<unsigned long long int>(0xAAAAAAAAAAAAAAAAL); //101010...101010
    HitPatternCDC myHitPatternCDC(initValue);
    EXPECT_EQ(170, myHitPatternCDC.getNHits());
    unsigned short int nHits1 = 255;
    myHitPatternCDC.setNHits(nHits1);
    EXPECT_EQ(nHits1, myHitPatternCDC.getNHits());
    unsigned short int nHits2 = 0;
    myHitPatternCDC.setNHits(nHits2);
    EXPECT_EQ(nHits2, myHitPatternCDC.getNHits());
    unsigned short int nHits3 = 93;
    myHitPatternCDC.setNHits(nHits3);
    EXPECT_EQ(nHits3, myHitPatternCDC.getNHits());
  }

TEST_F() [10/26]

TEST_F	(	HitPatternCDCTest	,
		settersNGetters	)

Test simple Setters, Getters, and Hassers.

Definition at line 22 of file hitPatternCDC.cc.

  {
    // Test proper initialization.
    unsigned long initValue = 66560; // python >>> 2 ** 16 + 2 ** 10
    HitPatternCDC hitPatternCDC(initValue);
    EXPECT_EQ(initValue, hitPatternCDC.getInteger());
 
    HitPatternCDC hitPatternCDC2;
    EXPECT_EQ(0,  hitPatternCDC2.getNHits());
 
    // Test setting and getting individual bits
    short layer = 5;
    hitPatternCDC2.setLayer(layer);
    EXPECT_EQ(true, hitPatternCDC2.hasLayer(5));
 
    // Test of SuperLayer getters; setters don't make sense.
    // Reminder: Start counting from 0 here.
    // Even -> Axial Layer; Odd -> Stereo Layer
    HitPatternCDC hitPatternCDC3;
    hitPatternCDC3.setLayer(9);   // SL 1
    hitPatternCDC3.setLayer(15);  // SL 2
    hitPatternCDC3.setLayer(21);  // SL 3
 
    EXPECT_FALSE(hitPatternCDC3.hasSLayer(0));
    EXPECT_TRUE(hitPatternCDC3.hasSLayer(1));
 
    // Test Axial and Stereo requests.
    EXPECT_TRUE(hitPatternCDC3.hasAxialLayer());
    EXPECT_TRUE(hitPatternCDC3.hasStereoLayer());
    EXPECT_FALSE(hitPatternCDC2.hasStereoLayer());
 
    hitPatternCDC3.resetLayer(15);
    EXPECT_FALSE(hitPatternCDC3.hasAxialLayer());
 
    // Test resetting of super layers.
    hitPatternCDC3.resetSLayer(1);
    hitPatternCDC3.resetSLayer(3);
    EXPECT_EQ(0, hitPatternCDC3.getNHits());
  } // settersNGetters

TEST_F() [11/26]

TEST_F	(	HitPatternVXDTest	,
		General	)

Constructor and some general getters.

Definition at line 34 of file hitPatternVXD.cc.

  {
    unsigned int initValue = 16776960;
    std::bitset<32> initValueAsBitset(static_cast<std::string>("00000000111111111111111100000000"));
 
    HitPatternVXD myHitPattern(initValue);
    EXPECT_EQ(initValueAsBitset, myHitPattern.getBitset());
    EXPECT_EQ(initValue, myHitPattern.getInteger());
 
  }

TEST_F() [12/26]

TEST_F	(	HitPatternVXDTest	,
		getFirstLastLayer	)

Test the getters for First/Last Layer.

Definition at line 142 of file hitPatternVXD.cc.

  {
    HitPatternVXD myHitPattern(0);
    // random choices
    const unsigned short firstLayerPXD = 1;
    const unsigned short lastLayerPXD = 2;
    const unsigned short firstLayerSVD = 4;
    const unsigned short lastLayerSVD = 6;
 
    // set SVD
    myHitPattern.setSVDLayer(3, 0, 0);
    myHitPattern.setSVDLayer(4, 3, 0);
    myHitPattern.setSVDLayer(5, 0, 1);
    myHitPattern.setSVDLayer(6, 1, 1);
    // set PXD normal
    myHitPattern.setPXDLayer(1, 1, HitPatternVXD::PXDMode::normal);
    myHitPattern.setPXDLayer(2, 2, HitPatternVXD::PXDMode::normal);
    // set PXD gated
    myHitPattern.setPXDLayer(1, 1, HitPatternVXD::PXDMode::gated);
    myHitPattern.setPXDLayer(2, 2, HitPatternVXD::PXDMode::gated);
 
    EXPECT_EQ(firstLayerSVD, myHitPattern.getFirstSVDLayer());
    EXPECT_EQ(lastLayerSVD, myHitPattern.getLastSVDLayer());
    EXPECT_EQ(firstLayerPXD, myHitPattern.getFirstPXDLayer(HitPatternVXD::PXDMode::normal));
    EXPECT_EQ(lastLayerPXD, myHitPattern.getLastPXDLayer(HitPatternVXD::PXDMode::normal));
    EXPECT_EQ(firstLayerPXD, myHitPattern.getFirstPXDLayer(HitPatternVXD::PXDMode::gated));
    EXPECT_EQ(lastLayerPXD, myHitPattern.getLastPXDLayer(HitPatternVXD::PXDMode::gated));
  }

TEST_F() [13/26]

TEST_F	(	HitPatternVXDTest	,
		getNLayers	)

Test the getNLayer functions.

Definition at line 114 of file hitPatternVXD.cc.

  {
    HitPatternVXD myHitPattern(0);
    const unsigned short nSVD = 3;
    const unsigned short nPXDnormal = 2;
    const unsigned short nPXDgated = 1;
 
    // set SVD
    myHitPattern.setSVDLayer(3, 1, 3);
    myHitPattern.setSVDLayer(4, 0, 0);
    myHitPattern.setSVDLayer(5, 1, 1);
    myHitPattern.setSVDLayer(6, 0, 1);
    // set PXD normal
    myHitPattern.setPXDLayer(1, 1, HitPatternVXD::PXDMode::normal);
    myHitPattern.setPXDLayer(2, 2, HitPatternVXD::PXDMode::normal);
    // set PXD gated
    myHitPattern.setPXDLayer(1, 0, HitPatternVXD::PXDMode::gated);
    myHitPattern.setPXDLayer(2, 2, HitPatternVXD::PXDMode::gated);
 
    EXPECT_EQ(nSVD, myHitPattern.getNSVDLayers());
    EXPECT_EQ(nPXDnormal, myHitPattern.getNPXDLayers(HitPatternVXD::PXDMode::normal));
    EXPECT_EQ(nPXDgated, myHitPattern.getNPXDLayers(HitPatternVXD::PXDMode::gated));
    EXPECT_EQ(nSVD + nPXDnormal, myHitPattern.getNVXDLayers(HitPatternVXD::PXDMode::normal));
    EXPECT_EQ(nSVD + nPXDgated, myHitPattern.getNVXDLayers(HitPatternVXD::PXDMode::gated));
 
  }

TEST_F() [14/26]

TEST_F	(	HitPatternVXDTest	,
		NGetters	)

Test total number of hit getters.

Definition at line 101 of file hitPatternVXD.cc.

  {
    HitPatternVXD myHitPattern(16777215);
    const unsigned short svdHits = 24;
    const unsigned short pxdHits = 12;
    const unsigned short ndf = 2 * pxdHits + svdHits;
    EXPECT_EQ(svdHits, myHitPattern.getNSVDHits());
    EXPECT_EQ(pxdHits, myHitPattern.getNPXDHits());
    EXPECT_EQ(ndf, myHitPattern.getNdf());
 
  }

TEST_F() [15/26]

TEST_F	(	HitPatternVXDTest	,
		NumberingScheme	)

Test the numbering scheme in the static variables.

Definition at line 25 of file hitPatternVXD.cc.

  {
    const std::list<unsigned short> pxdNumbering = {1, 2};
    const std::list<unsigned short> svdNumbering = {3, 4, 5, 6};
    EXPECT_EQ(pxdNumbering, HitPatternVXD::s_PXDLayerNumbers);
    EXPECT_EQ(svdNumbering, HitPatternVXD::s_SVDLayerNumbers);
  }

TEST_F() [16/26]

TEST_F	(	HitPatternVXDTest	,
		PXDSetterAndGetter	)

Test simple Setters and Getters for the PXD.

Definition at line 68 of file hitPatternVXD.cc.

  {
    HitPatternVXD myHitPattern(0);
 
    for (const auto layerId : HitPatternVXD::s_PXDLayerNumbers) {
      for (unsigned int nHits = 0; nHits <= 3; ++nHits) {
        myHitPattern.setPXDLayer(layerId, nHits, HitPatternVXD::PXDMode::normal);
        EXPECT_EQ(nHits, myHitPattern.getPXDLayer(layerId, HitPatternVXD::PXDMode::normal));
        myHitPattern.resetPXDLayer(layerId, HitPatternVXD::PXDMode::normal);
        EXPECT_EQ(0, myHitPattern.getPXDLayer(layerId, HitPatternVXD::PXDMode::normal));
 
        myHitPattern.setPXDLayer(layerId, nHits, HitPatternVXD::PXDMode::gated);
        EXPECT_EQ(nHits, myHitPattern.getPXDLayer(layerId, HitPatternVXD::PXDMode::gated));
        myHitPattern.resetPXDLayer(layerId, HitPatternVXD::PXDMode::gated);
        EXPECT_EQ(0, myHitPattern.getPXDLayer(layerId, HitPatternVXD::PXDMode::gated));
      }
    }
 
    for (const auto layerId : HitPatternVXD::s_PXDLayerNumbers) {
      unsigned int nHits = 4;
      myHitPattern.setPXDLayer(layerId, nHits, HitPatternVXD::PXDMode::normal);
      EXPECT_EQ(3, myHitPattern.getPXDLayer(layerId, HitPatternVXD::PXDMode::normal));
      myHitPattern.resetPXDLayer(layerId, HitPatternVXD::PXDMode::normal);
      EXPECT_EQ(0, myHitPattern.getPXDLayer(layerId, HitPatternVXD::PXDMode::normal));
 
      myHitPattern.setPXDLayer(layerId, nHits, HitPatternVXD::PXDMode::gated);
      EXPECT_EQ(3, myHitPattern.getPXDLayer(layerId, HitPatternVXD::PXDMode::gated));
      myHitPattern.resetPXDLayer(layerId, HitPatternVXD::PXDMode::gated);
      EXPECT_EQ(0, myHitPattern.getPXDLayer(layerId, HitPatternVXD::PXDMode::gated));
    }
  }

TEST_F() [17/26]

TEST_F	(	HitPatternVXDTest	,
		SVDSetterAndGetter	)

Test simple Setters and Getters for SVD.

Definition at line 46 of file hitPatternVXD.cc.

  {
    HitPatternVXD myHitPattern(0);
 
    for (const auto layerId : HitPatternVXD::s_SVDLayerNumbers) {
      unsigned short uHits = 2;
      unsigned short vHits = 1;
      myHitPattern.setSVDLayer(layerId, uHits, vHits);
      EXPECT_EQ(uHits, myHitPattern.getSVDLayer(layerId).first);
      EXPECT_EQ(vHits, myHitPattern.getSVDLayer(layerId).second);
      myHitPattern.resetSVDLayer(layerId);
      EXPECT_EQ(0, myHitPattern.getSVDLayer(layerId).first);
      EXPECT_EQ(0, myHitPattern.getSVDLayer(layerId).second);
      uHits = 4;
      vHits = 4;
      myHitPattern.setSVDLayer(layerId, uHits, vHits);
      EXPECT_EQ(3, myHitPattern.getSVDLayer(layerId).first);
      EXPECT_EQ(3, myHitPattern.getSVDLayer(layerId).second);
    }
  }

TEST_F() [18/26]

TEST_F	(	KlIdTest	,
		SettersAndGetters	)

Test setter and getter.

Definition at line 30 of file KlIdTest.cc.

  {
 
    DataStore::Instance().setInitializeActive(true);
    StoreArray<ECLCluster> eclClusters;
    eclClusters.registerInDataStore();
    StoreArray<KLMCluster> klmClusters;
    klmClusters.registerInDataStore();
    StoreArray<KlId> klids;
    klids.registerInDataStore();
    klmClusters.registerRelationTo(klids);
    eclClusters.registerRelationTo(klids);
 
 
    const KlId* klid = klids.appendNew();
    const KLMCluster* klmCluster = klmClusters.appendNew();
    const ECLCluster* eclCluster = eclClusters.appendNew();
 
    EXPECT_FALSE(klid->isECL());
    EXPECT_FALSE(klid->isKLM());
    EXPECT_TRUE(std::isnan(klid->getKlId()));
 
    klmCluster->addRelationTo(klid, 0.5);
    eclCluster->addRelationTo(klid, 0.5);
 
    EXPECT_TRUE(klid->isECL());
    EXPECT_TRUE(klid->isKLM());
    EXPECT_EQ(0.5, klid->getKlId());
 
  }

TEST_F() [19/26]

TEST_F	(	TrackFitResultTest	,
		Charge	)

Test get charge.

Definition at line 151 of file trackFitResult.cc.

  {
    auto bField = 1.5;
    auto pValue = 0.45;
    ROOT::Math::XYZVector position(0., 0., 0.);
    ROOT::Math::XYZVector momentum(1., 1., 1.);
    TMatrixDSym cov6(6);
    auto pType = Belle2::Const::electron;
 
    auto charge = -1.0;
    Belle2::TrackFitResult myResultMinus(position, momentum, cov6, charge, pType, pValue, bField, 0, 0, 0);
    EXPECT_EQ(myResultMinus.getChargeSign(), charge);
 
    charge = 0;
    Belle2::TrackFitResult myResultNull(position, momentum, cov6, charge, pType, pValue, bField, 0, 0, 0);
    EXPECT_EQ(myResultNull.getChargeSign(), charge);
 
    charge = +1.0;
    Belle2::TrackFitResult myResultPlus(position, momentum, cov6, charge, pType, pValue, bField, 0, 0, 0);
    EXPECT_EQ(myResultPlus.getChargeSign(), charge);
  }

TEST_F() [20/26]

TEST_F	(	TrackFitResultTest	,
		ErrorPropagation	)

Test if the error propagation of the covariance matrix works properly.

Definition at line 82 of file trackFitResult.cc.

  {
    TRandom3 generator;
    unsigned int nCases = 1;
    double absError = 1e-6;
 
    for (unsigned int iCase = 0; iCase < nCases; ++iCase) {
 
      auto bField = 1.5;
      auto pType = Belle2::Const::electron;
      auto pValue = 0.45;
      std::vector<float> tau;
      for (int i = 0; i < 5; ++i) {
        // does not matter what is appended here, we only test the cov matrix
        tau.push_back(1);
      }
      std::vector<float> cov(15);
      for (auto& element : cov) {
        element = generator.Gaus(1e-4);
      }
      Belle2::TrackFitResult myResult(tau, cov, pType, pValue, 0, 0, 0);
      TMatrixDSym covariance(myResult.getCovariance6());
 
      for (int i = 0; i < 5; ++i)
        for (int j = i; j < 5; ++j)
          EXPECT_EQ(covariance(i, j), covariance(j, i));
 
      TMatrixDSym cov6(6);
      for (unsigned int row = 0; row < 6; ++row) {
        for (unsigned int col = 0; col < 6; ++col) {
          cov6(row, col) = covariance(row, col);
        }
      }
      Belle2::TrackFitResult myResult2(myResult.getPosition(), myResult.getMomentum(), cov6,
                                       myResult.getChargeSign(), pType, pValue, bField, 0, 0, 0);
 
      TMatrixDSym myResultCov5 = myResult.getCovariance5();
      TMatrixDSym myResult2Cov5 = myResult2.getCovariance5();
 
      EXPECT_NEAR(myResultCov5(0, 0), myResult2Cov5(0, 0), absError);
      EXPECT_NEAR(myResultCov5(0, 1), myResult2Cov5(0, 1), absError);
      EXPECT_NEAR(myResultCov5(0, 2), myResult2Cov5(0, 2), absError);
      EXPECT_NEAR(myResultCov5(0, 3), myResult2Cov5(0, 3), absError);
      EXPECT_NEAR(myResultCov5(0, 4), myResult2Cov5(0, 4), absError);
      EXPECT_NEAR(myResultCov5(1, 0), myResult2Cov5(1, 0), absError);
      EXPECT_NEAR(myResultCov5(1, 1), myResult2Cov5(1, 1), absError);
      EXPECT_NEAR(myResultCov5(1, 2), myResult2Cov5(1, 2), absError);
      EXPECT_NEAR(myResultCov5(1, 3), myResult2Cov5(1, 3), absError);
      EXPECT_NEAR(myResultCov5(1, 4), myResult2Cov5(1, 4), absError);
      EXPECT_NEAR(myResultCov5(2, 0), myResult2Cov5(2, 0), absError);
      EXPECT_NEAR(myResultCov5(2, 1), myResult2Cov5(2, 1), absError);
      EXPECT_NEAR(myResultCov5(2, 2), myResult2Cov5(2, 2), absError);
      EXPECT_NEAR(myResultCov5(2, 3), myResult2Cov5(2, 3), absError);
      EXPECT_NEAR(myResultCov5(2, 4), myResult2Cov5(2, 4), absError);
      EXPECT_NEAR(myResultCov5(3, 0), myResult2Cov5(3, 0), absError);
      EXPECT_NEAR(myResultCov5(3, 1), myResult2Cov5(3, 1), absError);
      EXPECT_NEAR(myResultCov5(3, 2), myResult2Cov5(3, 2), absError);
      EXPECT_NEAR(myResultCov5(3, 3), myResult2Cov5(3, 3), absError);
      EXPECT_NEAR(myResultCov5(3, 4), myResult2Cov5(3, 4), absError);
      EXPECT_NEAR(myResultCov5(4, 0), myResult2Cov5(4, 0), absError);
      EXPECT_NEAR(myResultCov5(4, 1), myResult2Cov5(4, 1), absError);
      EXPECT_NEAR(myResultCov5(4, 2), myResult2Cov5(4, 2), absError);
      EXPECT_NEAR(myResultCov5(4, 3), myResult2Cov5(4, 3), absError);
      EXPECT_NEAR(myResultCov5(4, 4), myResult2Cov5(4, 4), absError);
 
    }
  } // Testcases error propagation

TEST_F() [21/26]

TEST_F	(	TrackFitResultTest	,
		Getters	)

Test simple Setters and Getters.

Definition at line 36 of file trackFitResult.cc.

  {
    TRandom3 generator;
    unsigned int nCases = 1;
    double absError = 1e-6;
    double bField = 1.5;
 
    for (unsigned int i = 0; i < nCases; ++i) {
 
      short int charge = generator.Uniform(-1, 1) > 0 ? 1 : -1;
      Const::ParticleType pType = Const::electron;
      float pValue = 0.45;
 
      // Generate a random put orthogonal pair of vectors in the r-phi plane
      TVector2 d(generator.Uniform(-1, 1), generator.Uniform(-1, 1));
      TVector2 pt(generator.Uniform(-1, 1), generator.Uniform(-1, 1));
      d.Set(d.X(), -(d.X()*pt.Px()) / pt.Py());
      // Add a random z component
      ROOT::Math::XYZVector position(d.X(), d.Y(), generator.Uniform(-1, 1));
      ROOT::Math::XYZVector momentum(pt.Px(), pt.Py(), generator.Uniform(-1, 1));
 
      TMatrixDSym cov6(6);
 
      // Set up class for testing
      TrackFitResult myResult(position, momentum, cov6, charge, pType, pValue, bField, 0, 0, 0);
 
      // Test all vector elements
      EXPECT_NEAR(position.X(), myResult.getPosition().X(), absError);
      EXPECT_NEAR(position.Y(), myResult.getPosition().Y(), absError);
      EXPECT_NEAR(position.Z(), myResult.getPosition().Z(), absError);
      EXPECT_NEAR(momentum.X(), myResult.getMomentum().X(), absError);
      EXPECT_NEAR(momentum.Y(), myResult.getMomentum().Y(), absError);
      EXPECT_NEAR(momentum.Z(), myResult.getMomentum().Z(), absError);
 
      // Test getter for transverse momentum
      EXPECT_NEAR(momentum.Rho(), myResult.getTransverseMomentum(), absError);
 
      // Test other variables
      EXPECT_EQ(charge, myResult.getChargeSign());
      EXPECT_EQ(pValue, myResult.getPValue());
      EXPECT_EQ(pType, myResult.getParticleType());
 
    }
  } // Testcases for getters

TEST_F() [22/26]

TEST_F	(	TrackTest	,
		getTrackFitResultWithBestPValue	)

Test getTrackFitResultWithBestPValue.

Definition at line 160 of file track.cc.

  {
    // Create some TrackFitResults in the the DataStore.
    // PDGCode of the TrackFitResult will be used in the test to identify the TFR.
    DataStore::Instance().setInitializeActive(true);
    StoreArray<TrackFitResult> myResults;
    myResults.registerInDataStore();
 
    // add four fit results with different p values
    const auto myMuon = addDummyTrack(myResults, Const::muon, Const::floatNaN);
    const auto myPion = addDummyTrack(myResults, Const::pion, 0.75);
    const auto myKaon = addDummyTrack(myResults, Const::kaon, 0.4);
    const auto myProton = addDummyTrack(myResults, Const::proton, Const::floatNaN);
 
    Track mytrack;
    mytrack.setTrackFitResultIndex(Const::muon, myMuon->getArrayIndex());
    mytrack.setTrackFitResultIndex(Const::pion, myPion->getArrayIndex());
    mytrack.setTrackFitResultIndex(Const::kaon, myKaon->getArrayIndex());
    mytrack.setTrackFitResultIndex(Const::proton, myProton->getArrayIndex());
 
    // check that fit hypothesis with best p value (here pion) is returned
    const auto bestFit = mytrack.getTrackFitResultWithBestPValue();
    EXPECT_EQ(Const::pion.getPDGCode(), bestFit->getParticleType().getPDGCode());
    EXPECT_EQ(mytrack.getTrackFitResult(Const::pion)->getArrayIndex(), bestFit->getArrayIndex());
    EXPECT_EQ(bestFit->getPValue(), 0.75);
  }

TEST_F() [23/26]

TEST_F	(	TrackTest	,
		getTrackFitResultWithClosestMass	)

Test getTrackFitResultWithClosestMass.

Definition at line 119 of file track.cc.

  {
    //Create some TrackFitResults in the the DataStore.
    //PDGCode of the TrackFitResult will be used in the test to identify the TFR.
    DataStore::Instance().setInitializeActive(true);
    StoreArray<TrackFitResult> myResults;
    myResults.registerInDataStore();
 
    // add two fit results
    const auto myKaon = addDummyTrack(myResults, Const::kaon);
    const auto myElectron = addDummyTrack(myResults, Const::electron);
 
    Track mytrack1;
    mytrack1.setTrackFitResultIndex(Const::electron, myElectron->getArrayIndex());
    mytrack1.setTrackFitResultIndex(Const::kaon, myKaon->getArrayIndex());
 
    EXPECT_EQ(mytrack1.getNumberOfFittedHypotheses(), 2);
 
    // check for correct hypothesis if we request a fitted particle
    const auto fitCloseToKaonMass = mytrack1.getTrackFitResultWithClosestMass(Const::kaon);
    EXPECT_EQ(Const::kaon.getPDGCode(), fitCloseToKaonMass->getParticleType().getPDGCode());
    EXPECT_EQ(mytrack1.getTrackFitResult(Const::kaon)->getArrayIndex(), fitCloseToKaonMass->getArrayIndex());
 
    // check to get Pion fit
    const auto wantPionButHaveElectronFit = mytrack1.getTrackFitResultWithClosestMass(Const::pion);
    EXPECT_EQ(Const::electron.getPDGCode(), wantPionButHaveElectronFit->getParticleType().getPDGCode());
    EXPECT_EQ(mytrack1.getTrackFitResult(Const::electron)->getArrayIndex(), wantPionButHaveElectronFit->getArrayIndex());
 
    // check to get Electron fit
    const auto wantMuonButHaveElectronFit = mytrack1.getTrackFitResultWithClosestMass(Const::muon);
    EXPECT_EQ(Const::electron.getPDGCode(), wantMuonButHaveElectronFit->getParticleType().getPDGCode());
    EXPECT_EQ(mytrack1.getTrackFitResult(Const::electron)->getArrayIndex(), wantMuonButHaveElectronFit->getArrayIndex());
 
    // check to get Proton fit
    const auto wantProtonButHaveKaonFit = mytrack1.getTrackFitResultWithClosestMass(Const::proton);
    EXPECT_EQ(Const::kaon.getPDGCode(), wantProtonButHaveKaonFit->getParticleType().getPDGCode());
    EXPECT_EQ(mytrack1.getTrackFitResult(Const::kaon)->getArrayIndex(), wantProtonButHaveKaonFit->getArrayIndex());
  }

TEST_F() [24/26]

TEST_F	(	TrackTest	,
		settersNGetters	)

Test simple Setters and Getters.

Definition at line 50 of file track.cc.

  {
    //Create some TrackFitResults in the the DataStore.
    //PDGCode of the TrackFitResult will be used in the test to identify the TFR.
    DataStore::Instance().setInitializeActive(true);
    StoreArray<TrackFitResult> myResults;
    myResults.registerInDataStore();
 
    const auto myPion = addDummyTrack(myResults, Const::pion);
    const auto myKaon = addDummyTrack(myResults, Const::kaon);
    const auto myElectron = addDummyTrack(myResults, Const::electron);
    const auto myMuon = addDummyTrack(myResults, Const::muon);
 
    EXPECT_EQ(myPion->getArrayIndex(), 0);
    EXPECT_EQ(myKaon->getArrayIndex(), 1);
    EXPECT_EQ(myElectron->getArrayIndex(), 2);
    EXPECT_EQ(myMuon->getArrayIndex(), 3);
 
    Track mytrack1;
    mytrack1.setTrackFitResultIndex(Const::pion, myPion->getArrayIndex());
    mytrack1.setTrackFitResultIndex(Const::muon, myMuon->getArrayIndex());
    mytrack1.setTrackFitResultIndex(Const::kaon, myKaon->getArrayIndex());
 
    EXPECT_EQ(mytrack1.getNumberOfFittedHypotheses(), 3);
    // If the index of the corresponding particle is set, the correct particle should be returned.
    EXPECT_EQ(mytrack1.getTrackFitResult(Const::pion)->getParticleType(), Const::pion);
    EXPECT_EQ(mytrack1.getTrackFitResult(Const::kaon)->getParticleType(), Const::kaon);
    EXPECT_EQ(mytrack1.getTrackFitResult(Const::muon)->getParticleType(), Const::muon);
    // If the index of the corresponding particle is *not* set, a nullptr should be returned.
    EXPECT_EQ(mytrack1.getTrackFitResult(Const::electron), nullptr);
 
    // If the index of the corresponding particle is set, the correct particle should be returned.
    EXPECT_EQ(mytrack1.getTrackFitResult(Const::pion)->getArrayIndex(), myPion->getArrayIndex());
    EXPECT_EQ(mytrack1.getTrackFitResult(Const::kaon)->getArrayIndex(), myKaon->getArrayIndex());
    EXPECT_EQ(mytrack1.getTrackFitResult(Const::muon)->getArrayIndex(), myMuon->getArrayIndex());
    // If the index of the corresponding particle is *not* set, a nullptr should be returned.
    EXPECT_EQ(mytrack1.getTrackFitResult(Const::electron), nullptr);
 
    const auto allResults = mytrack1.getTrackFitResults();
    // should return all hypothesis which were added before
    EXPECT_EQ(allResults.size(), 3);
 
    // check that all correct hypothesis are returned and the electron is not
    auto countPion = std::count_if(allResults.begin(), allResults.end(),
                                   [myPion](std::pair<Const::ChargedStable,  const TrackFitResult*> fitPair)
    {return (fitPair.first == Const::pion) && (fitPair.second->getArrayIndex() == myPion->getArrayIndex());});
    auto countMuon = std::count_if(allResults.begin(), allResults.end(),
                                   [myMuon](std::pair<Const::ChargedStable,  const TrackFitResult*> fitPair)
    {return (fitPair.first == Const::muon) && (fitPair.second->getArrayIndex() == myMuon->getArrayIndex());});
    auto countElectron = std::count_if(allResults.begin(), allResults.end(),
                                       [](std::pair<Const::ChargedStable,  const TrackFitResult*> fitPair)
    {return fitPair.first == Const::electron;});
    auto countKaon = std::count_if(allResults.begin(), allResults.end(),
                                   [myKaon](std::pair<Const::ChargedStable,  const TrackFitResult*> fitPair)
    {return (fitPair.first == Const::kaon) && (fitPair.second->getArrayIndex() == myKaon->getArrayIndex());});
 
    EXPECT_EQ(countPion, 1);
    EXPECT_EQ(countMuon, 1);
    EXPECT_EQ(countElectron, 0);
    EXPECT_EQ(countKaon, 1);
 
    Track trackQITest;
    EXPECT_EQ(trackQITest.getQualityIndicator(), 0.);
    Track trackQITest1(0.5);
    EXPECT_EQ(trackQITest1.getQualityIndicator(), 0.5);
  }

TEST_F() [25/26]

TEST_F	(	V0Test	,
		IndexGetters	)

Test Index Getter.

Definition at line 52 of file v0.cc.

  {
    V0 myV0;
    EXPECT_EQ(m_default_index, std::get<0>(myV0.getTrackIndices()));
    EXPECT_EQ(m_default_index, std::get<1>(myV0.getTrackIndices()));
    EXPECT_EQ(m_default_index, std::get<0>(myV0.getTrackFitResultIndices()));
    EXPECT_EQ(m_default_index, std::get<1>(myV0.getTrackFitResultIndices()));
 
  } // Testcases for Index Getter

TEST_F() [26/26]

TEST_F	(	V0Test	,
		PointerGetters	)

Test Pointer Getter.

Definition at line 63 of file v0.cc.

  {
    V0 myV0;
    EXPECT_ANY_THROW(std::get<0>(myV0.getTracks()));
    EXPECT_ANY_THROW(std::get<1>(myV0.getTracks()));
    EXPECT_ANY_THROW(std::get<0>(myV0.getTrackFitResults()));
    EXPECT_ANY_THROW(std::get<1>(myV0.getTrackFitResults()));
  } // Testcases for Pointer Getter