CbmAnaConversionTest.h

Go to the documentation of this file.

 
#ifndef CBM_ANA_CONVERSION_TEST
#define CBM_ANA_CONVERSION_TEST
 
// included from ROOT
#include <TClonesArray.h>
#include <TH1.h>
#include <TH2.h>
#include <TH3.h>
#include <TStopwatch.h>
 
// included from CbmRoot
#include "CbmGlobalTrack.h"
#include "CbmKFVertex.h"
#include "CbmLitGlobalElectronId.h"
#include "CbmLmvmKinematicParams.h"
#include "CbmMCTrack.h"
#include "CbmVertex.h"
 
#include <vector>
 
class CbmAnaConversionTest {
 
public:
  CbmAnaConversionTest();
  virtual ~CbmAnaConversionTest();
 
  void Init();
  void InitHistos();
  void Finish();
 
  void Exec();
 
  void GetNofRichElectrons();
  Double_t CalcInvMass(Int_t e1, Int_t e2, Int_t e3, Int_t e4);
 
  void DoSTSonlyAnalysis();
  void CombineElectrons_FromSTSandRICH();
  void CombinePhotons();
  void CombineElectrons_FromRICH();
  CbmLmvmKinematicParams CalculateKinematicParamsReco(const TVector3 electron1,
                                                      const TVector3 electron2);
  Double_t Invmass_4particlesRECO(const TVector3 part1,
                                  const TVector3 part2,
                                  const TVector3 part3,
                                  const TVector3 part4);
 
  void CombineElectrons_STSonly();
  void CombinePhotons_STSonly();
 
  Bool_t HasRichInd(Int_t gtIndex, Int_t arrayIndex);
 
  void MixedEventTest_3p1();
  void MixedEventTest_STSonly();
  Double_t ElectronANNvalue(Int_t globalTrackIndex, Double_t momentum);
 
 
private:
  TClonesArray* fRichPoints;
  TClonesArray* fRichRings;
  TClonesArray* fRichRingMatches;
  TClonesArray* fMcTracks;
  TClonesArray* fStsTracks;
  TClonesArray* fStsTrackMatches;
  TClonesArray* fGlobalTracks;
  CbmVertex* fPrimVertex;
  CbmKFVertex fKFVertex;
 
  std::vector<TH1*>
    fHistoList_test;  // list of all histograms related to rich rings
 
  std::vector<int> fElectrons_gtid;
  std::vector<int> fElectrons_mcid;
  std::vector<int> fElectrons_richInd;
  std::vector<int> fElectrons_pi0mcid;
  std::vector<int> fElectrons_same;
 
  TH1I* fElectrons_nofPerPi0;
  TH1I* fElectrons_nofPerPi0_withRichInd;
 
  TH1D* fhElectronsTest_invmass;
 
 
  // histograms for STS only analysis
  TH1I* fhTest_ParticlesPerEvent;
  TH1I* fhTest_RICHelectronsPerEvent;
  TH1I* fhTest_PhotonsPerEvent_RICHonly;
  TH1I* fhTest_PhotonsPerEvent_STSandRICH;
  TH1I* fhTest_ReconstructedPi0PerEvent;
  TH1D* fhTest_invmass;
  TH1D* fhTest_invmass_pCut;
  TH1D* fhTest_invmass_GGcut;
 
  // arrays for CombinePhotons_STSonly()
  TH1D* fhTest_invmass_RICHindex0;
  TH1D* fhTest_invmass_RICHindex1;
  TH1D* fhTest_invmass_RICHindex2;
  TH1D* fhTest_invmass_RICHindex3;
  TH1D* fhTest_invmass_RICHindex4;
 
  TH2D* fhTest_invmass_MCcutAll;
  TH1D* fhTest_peakCheck1;
  TH1D* fhTest_peakCheck2;
  TH1D* fhTest_peakCheck3;
  TH2D* fhTest_invmass_ANNcuts;
 
  TH2D* fhTest_phaseSpace_pi0;
  TH2D* fhTest_phaseSpace_eta;
 
  // array with all refitted momenta
  std::vector<TVector3> fVector_AllMomenta;
 
 
  // arrays for STS only analysis (i.e. signal only in STS is required, not necessarily in RICH)
  std::vector<CbmGlobalTrack*> fVector_gt;
  std::vector<TVector3> fVector_momenta;
  std::vector<double> fVector_chi;
  std::vector<int> fVector_gtIndex;
  std::vector<int> fVector_richIndex;
  std::vector<int> fVector_mcIndex;
  std::vector<bool> fVector_withRichSignal;
  std::vector<std::vector<int>> fVector_reconstructedPhotons_FromSTSandRICH;
 
  // arrays for electrons, that have been identified in RICH as electrons
  std::vector<CbmGlobalTrack*> fVector_electronRICH_gt;
  std::vector<int> fVector_electronRICH_gtIndex;
  std::vector<int> fVector_electronRICH_mcIndex;
  std::vector<TVector3> fVector_electronRICH_momenta;
  std::vector<std::vector<int>> fVector_electronRICH_reconstructedPhotons;
 
  // additional arrays, for CombineElectrons_STSonly() and CombinePhotons_STSonly()
  std::vector<std::vector<int>> fVector_reconstructedPhotons_STSonly;
 
 
  // EVENT MIXING
  Int_t globalEventNo;
  //    for STS only mixed events creation
  //    TH1D * fhTest_eventMixing_RICHindex0;
  //    TH1D * fhTest_eventMixing_RICHindex1;
  //    TH1D * fhTest_eventMixing_RICHindex2;
  //    TH1D * fhTest_eventMixing_RICHindex3;
  //    TH1D * fhTest_eventMixing_RICHindex4;
  std::vector<std::vector<TVector3>> fMixedTest_STSonly_photons;
  std::vector<int> fMixedTest_STSonly_eventno;
  std::vector<std::vector<bool>> fMixedTest_STSonly_hasRichInd;
  TH1D* fhTest_eventMixing_STSonly_2p2;
  TH1D* fhTest_eventMixing_STSonly_3p1;
  TH1D* fhTest_eventMixing_STSonly_4p0;
 
  //    for other event mixing (3 + 1)
  std::vector<std::vector<TVector3>> fMixedTest_3p1_photons;
  std::vector<int> fMixedTest_3p1_eventno;
  std::vector<int> fMixedTest_3p1_combined;
  std::vector<std::vector<Double_t>> fMixedTest_3p1_ann;
  TH1D* fhTest_eventMixing_3p1;
  TH1D* fhTest_eventMixing_3p1_pCut;
  TH1D* fhTest_eventMixing_3p1_GGcut;
  TH2D* fhTest_eventMixing_3p1_ANNcuts;
 
 
  CbmAnaConversionTest(const CbmAnaConversionTest&);
  CbmAnaConversionTest operator=(const CbmAnaConversionTest&);
 
  ClassDef(CbmAnaConversionTest, 1)
};
 
#endif