CbmKresConversionPhotons.h

Go to the documentation of this file.

#ifndef CBM_KRES_CONVERSION_PHOTONS
#define CBM_KRES_CONVERSION_PHOTONS
 
#include "CbmKFVertex.h"
#include "CbmMCTrack.h"
#include "CbmRichRing.h"
#include "CbmRichRingFitterEllipseTau.h"
#include "CbmStsTrack.h"
#include "CbmVertex.h"
#include "KFParticle.h"
#include "TH2D.h"
#include <TClonesArray.h>
 
#include "CbmKresSelectAnnPhotons.h"
#include "CbmKresTrainAnnDirectPhotons.h"
 
#include "CbmLmvmKinematicParams.h"
 
class CbmRichRingFitterEllipseTau;
 
using namespace std;
 
class CbmKresConversionPhotons {
 
public:
  //***** brief Standard constructor.
  CbmKresConversionPhotons();
  //***** brief Standard destructor.
  virtual ~CbmKresConversionPhotons();
 
 
  void Init();
  void InitHistograms();
  void Finish();
 
  void Exec(int fEventNumDP,
            double OpeningAngleCut,
            double GammaInvMassCut,
            int RealPID);
 
  void SaveOutsideTracks(CbmMCTrack* mcTrack1,
                         CbmStsTrack* stsTrack,
                         double charge,
                         int stsInd,
                         int richInd,
                         int stsMcTrackId,
                         CbmRichRing* RING);
 
  void SaveTargetTracks(CbmMCTrack* mcTrack1,
                        CbmStsTrack* stsTrack,
                        TVector3 refmom,
                        double charge,
                        int stsInd,
                        int richInd,
                        int stsMcTrackId,
                        CbmRichRing* RING);
 
  int FindInRich(int richInd, int stsMcTrackId);
 
  int CheckIfElectron(CbmRichRing* ring, double momentum);
 
  std::vector<TVector3> SaveAllHits(CbmStsTrack* track);
 
  void FindGammasTarget(int EventNumMan,
                        double AngleCut,
                        double InvMassCut,
                        int RealPID,
                        vector<CbmMCTrack*> MCtracks_minus,
                        vector<CbmMCTrack*> MCtracks_plus,
                        vector<CbmStsTrack*> StsTrack_minus,
                        vector<CbmStsTrack*> StsTrack_plus,
                        vector<TVector3> Momenta_minus,
                        vector<TVector3> Momenta_plus,
                        std::vector<int> Rings_minus,
                        std::vector<int> Rings_plus,
                        std::vector<int> stsIndex_minus,
                        std::vector<int> stsIndex_plus,
                        vector<CbmRichRing*> richRing_minus,
                        vector<CbmRichRing*> richRing_plus);
 
  void FindGammasOutside(int EventNumMan,
                         double AngleCut,
                         double InvMassCut,
                         int RealPID,
                         vector<CbmMCTrack*> MCtracks_minus_Outside,
                         vector<CbmMCTrack*> MCtracks_plus_Outside,
                         vector<CbmStsTrack*> StsTrack_minus_Outside,
                         vector<CbmStsTrack*> StsTrack_plus_Outside,
                         std::vector<int> Rings_minus_Outside,
                         std::vector<int> Rings_plus_Outside,
                         std::vector<int> stsIndex_minus_Outside,
                         std::vector<int> stsIndex_plus_Outside,
                         vector<CbmRichRing*> richRing_minus_Outside,
                         vector<CbmRichRing*> richRing_plus_Outside);
 
  void FindGammasBoth();
 
  double CalculatePlaneAngle_last_fromHits(std::vector<TVector3> track_1,
                                           std::vector<TVector3> track_2);
 
  double CalculatePlaneAngle_last(CbmStsTrack* Sts_1, CbmStsTrack* Sts_2);
 
  double CalculatePlaneAngle_first(CbmStsTrack* Sts_1, CbmStsTrack* Sts_2);
 
  void DP_likesign_Mixing_Target(double AngleCut, double InvMassCut);
 
  void DP_likesign_Mixing_Outside(double AngleCut, double InvMassCut);
 
  void DP_Mixing_Target(double AngleCut, double InvMassCut);
 
  void DP_Mixing_Outside(double AngleCut, double InvMassCut);
 
 
private:
  CbmKresTrainAnnDirectPhotons* fTrainPhotons;
  Int_t AnnTrainPhotons;
  CbmKresSelectAnnPhotons* fAnnPhotonsSelection;
  Int_t UseAnnPhotons;
 
 
  TClonesArray* fMcTracks;
  TClonesArray* fGlobalTracks;
  TClonesArray* fStsTracks;
  TClonesArray* fStsTrackMatches;
  TClonesArray* fRichProjections;
  TClonesArray* fRichRings;
  TClonesArray* fRichRingMatches;
  TClonesArray* fRichHits;
  TClonesArray* fArrayMvdHit;
  TClonesArray* fArrayStsHit;
 
  CbmVertex* fPrimVertex;
  CbmKFVertex fKFVertex;
 
  CbmRichRingFitterEllipseTau* fTauFit;
 
  // charged tracks from outside
  vector<CbmStsTrack*> VStsTrack_minus_Outside;
  vector<CbmMCTrack*> VMCtracks_minus_Outside;
  std::vector<int> VRings_minus_Outside;
  std::vector<int> VStsIndex_minus_Outside;
  vector<CbmRichRing*> VRichRing_minus_Outside;
 
  vector<CbmStsTrack*> VStsTrack_plus_Outside;
  vector<CbmMCTrack*> VMCtracks_plus_Outside;
  std::vector<int> VRings_plus_Outside;
  std::vector<int> VStsIndex_plus_Outside;
  vector<CbmRichRing*> VRichRing_plus_Outside;
 
 
  // charged tracks from the target
  vector<CbmMCTrack*> VMCtracks_minus_Target;
  vector<CbmStsTrack*> VStsTrack_minus_Target;
  vector<TVector3> VMomenta_minus_Target;
  std::vector<int> VRings_minus_Target;
  std::vector<int> VStsIndex_minus_Target;
  vector<CbmRichRing*> VRichRing_minus_Target;
 
  vector<CbmMCTrack*> VMCtracks_plus_Target;
  vector<CbmStsTrack*> VStsTrack_plus_Target;
  vector<TVector3> VMomenta_plus_Target;
  std::vector<int> VRings_plus_Target;
  std::vector<int> VStsIndex_plus_Target;
  vector<CbmRichRing*> VRichRing_plus_Target;
 
 
  vector<TVector3> frefmomenta;
  std::vector<int> frefId;
  std::vector<CbmMCTrack*> fMCtracks;
 
  // DP_LK_EMT Target
  std::vector<TVector3> DP_LK_EMT_momenta_minus_Target;
  std::vector<int> DP_LK_EMT_NofRings_minus_Target;
  std::vector<CbmStsTrack*> DP_LK_EMT_STS_minus_Target;
  std::vector<int> DP_LK_EMT_STS_minus_index_Target;
 
  std::vector<TVector3> DP_LK_EMT_momenta_plus_Target;
  std::vector<int> DP_LK_EMT_NofRings_plus_Target;
  std::vector<CbmStsTrack*> DP_LK_EMT_STS_plus_Target;
  std::vector<int> DP_LK_EMT_STS_plus_index_Target;
 
  // DP_LK_EMT Outside
  std::vector<int> DP_LK_EMT_NofRings_minus_Outside;
  std::vector<CbmStsTrack*> DP_LK_EMT_STS_minus_Outside;
  std::vector<int> DP_LK_EMT_STS_minus_index_Outside;
 
  std::vector<int> DP_LK_EMT_NofRings_plus_Outside;
  std::vector<CbmStsTrack*> DP_LK_EMT_STS_plus_Outside;
  std::vector<int> DP_LK_EMT_STS_plus_index_Outside;
 
 
  // DP_EMT Target
  std::vector<int> DP_EMT_Event_minus_Target;
  std::vector<TVector3> DP_EMT_momenta_minus_Target;
  std::vector<int> DP_EMT_NofRings_minus_Target;
  std::vector<std::vector<TVector3>> DP_EMT_Hits_minus_Target;
 
  std::vector<int> DP_EMT_Event_plus_Target;
  std::vector<TVector3> DP_EMT_momenta_plus_Target;
  std::vector<int> DP_EMT_NofRings_plus_Target;
  std::vector<std::vector<TVector3>> DP_EMT_Hits_plus_Target;
 
  // DP_EMT Outside
  std::vector<int> DP_EMT_Event_minus_Outside;
  std::vector<CbmStsTrack*> DP_EMT_STS_minus_Outside;
  std::vector<KFParticle> DP_EMT_KFTrack_minus_Outside;
  std::vector<int> DP_EMT_NofRings_minus_Outside;
  std::vector<std::vector<TVector3>> DP_EMT_Hits_minus_Outside;
 
  std::vector<int> DP_EMT_Event_plus_Outside;
  std::vector<CbmStsTrack*> DP_EMT_STS_plus_Outside;
  std::vector<KFParticle> DP_EMT_KFTrack_plus_Outside;
  std::vector<int> DP_EMT_NofRings_plus_Outside;
  std::vector<std::vector<TVector3>> DP_EMT_Hits_plus_Outside;
 
 
  // combined gammas from the target
  std::vector<std::vector<TVector3>> Gammas_all_Target;
  std::vector<std::vector<TVector3>> Gammas_zero_Target;
  std::vector<std::vector<TVector3>> Gammas_one_Target;
  std::vector<std::vector<TVector3>> Gammas_two_Target;
  std::vector<std::vector<TVector3>> Gammas_onetwo_Target;
 
  std::vector<std::vector<int>> Gammas_stsIndex_all_Target;
  std::vector<std::vector<int>> Gammas_stsIndex_zero_Target;
  std::vector<std::vector<int>> Gammas_stsIndex_one_Target;
  std::vector<std::vector<int>> Gammas_stsIndex_two_Target;
  std::vector<std::vector<int>> Gammas_stsIndex_onetwo_Target;
 
  std::vector<std::vector<CbmMCTrack*>> Gammas_MC_all_Target;
  std::vector<std::vector<CbmMCTrack*>> Gammas_MC_zero_Target;
  std::vector<std::vector<CbmMCTrack*>> Gammas_MC_one_Target;
  std::vector<std::vector<CbmMCTrack*>> Gammas_MC_two_Target;
  std::vector<std::vector<CbmMCTrack*>> Gammas_MC_onetwo_Target;
 
 
  // combined gammas from outside
  std::vector<std::vector<TVector3>> Gammas_all_Outside;
  std::vector<std::vector<TVector3>> Gammas_zero_Outside;
  std::vector<std::vector<TVector3>> Gammas_one_Outside;
  std::vector<std::vector<TVector3>> Gammas_two_Outside;
  std::vector<std::vector<TVector3>> Gammas_onetwo_Outside;
 
  std::vector<std::vector<int>> Gammas_stsIndex_all_Outside;
  std::vector<std::vector<int>> Gammas_stsIndex_zero_Outside;
  std::vector<std::vector<int>> Gammas_stsIndex_one_Outside;
  std::vector<std::vector<int>> Gammas_stsIndex_two_Outside;
  std::vector<std::vector<int>> Gammas_stsIndex_onetwo_Outside;
 
  std::vector<std::vector<CbmMCTrack*>> Gammas_MC_all_Outside;
  std::vector<std::vector<CbmMCTrack*>> Gammas_MC_zero_Outside;
  std::vector<std::vector<CbmMCTrack*>> Gammas_MC_one_Outside;
  std::vector<std::vector<CbmMCTrack*>> Gammas_MC_two_Outside;
  std::vector<std::vector<CbmMCTrack*>> Gammas_MC_onetwo_Outside;
 
 
  // combined gammas from the target and outside together
  std::vector<std::vector<TVector3>> Gammas_all_Both;
  std::vector<std::vector<TVector3>> Gammas_zero_Both;
  std::vector<std::vector<TVector3>> Gammas_one_Both;
  std::vector<std::vector<TVector3>> Gammas_two_Both;
  std::vector<std::vector<TVector3>> Gammas_onetwo_Both;
 
  std::vector<std::vector<int>> Gammas_stsIndex_all_Both;
  std::vector<std::vector<int>> Gammas_stsIndex_zero_Both;
  std::vector<std::vector<int>> Gammas_stsIndex_one_Both;
  std::vector<std::vector<int>> Gammas_stsIndex_two_Both;
  std::vector<std::vector<int>> Gammas_stsIndex_onetwo_Both;
 
  std::vector<std::vector<CbmMCTrack*>> Gammas_MC_all_Both;
  std::vector<std::vector<CbmMCTrack*>> Gammas_MC_zero_Both;
  std::vector<std::vector<CbmMCTrack*>> Gammas_MC_one_Both;
  std::vector<std::vector<CbmMCTrack*>> Gammas_MC_two_Both;
  std::vector<std::vector<CbmMCTrack*>> Gammas_MC_onetwo_Both;
 
 
  // histograms
  // Target
  vector<TH1*> fHistoList_dp_Target;
  TH1D* Mother_PDG_Target;
  TH1D* GrandMother_PDG_Target;
 
  // Outside
  vector<TH1*> fHistoList_dp_Outside;
  TH1D* Mother_PDG_Outside;
  TH1D* GrandMother_PDG_Outside;
 
  // Both
  vector<TH1*> fHistoList_dp_Both;
  TH2D* Pdg_vs_Distance_for_dp;
  TH2D* P_vs_Distance_for_dp;
  TH1D* DP_AnnTruePairs;
  TH1D* DP_AnnFalsePairs;
  TH1D* DP_AnnTruePairs_AfterCuts;
  TH1D* DP_AnnFalsePairs_AfterCuts;
 
 
  vector<TH1*> fHistoList_dp_cuts_Both;
  TH2D* DP_candidates_InvMass_vs_OA_Both;
  TH2D* DP_InvMass_vs_OA_Both;
  TH1D* DP_candidates_InvMass_Both;
  TH1D* DP_InvMass_Both;
  TH1D* DP_candidates_OA_Both;
  TH1D* DP_OA_Both;
  TH1D* DP_candidates_PlaneAngles_last_Both;
  TH1D* DP_PlaneAngles_last_Both;
  TH1D* DP_candidates_PlaneAngles_first_Both;
  TH1D* DP_PlaneAngles_first_Both;
 
  vector<TH1*> fHistoList_dp_cuts_Target;
  TH2D* DP_candidates_InvMass_vs_OA_Target;
  TH2D* DP_InvMass_vs_OA_Target;
  TH1D* DP_candidates_InvMass_Target;
  TH1D* DP_InvMass_Target;
  TH1D* DP_candidates_OA_Target;
  TH1D* DP_OA_Target;
  TH1D* DP_candidates_PlaneAngles_last_Target;
  TH1D* DP_PlaneAngles_last_Target;
  TH1D* DP_candidates_PlaneAngles_first_Target;
  TH1D* DP_PlaneAngles_first_Target;
 
  vector<TH1*> fHistoList_dp_cuts_Outside;
  TH2D* DP_candidates_InvMass_vs_OA_Outside;
  TH2D* DP_InvMass_vs_OA_Outside;
  TH1D* DP_candidates_InvMass_Outside;
  TH1D* DP_InvMass_Outside;
  TH1D* DP_candidates_OA_Outside;
  TH1D* DP_OA_Outside;
  TH1D* DP_candidates_PlaneAngles_last_Outside;
  TH1D* DP_PlaneAngles_last_Outside;
  TH1D* DP_candidates_PlaneAngles_first_Outside;
  TH1D* DP_PlaneAngles_first_Outside;
 
 
  // Target => all
  vector<TH1*> fHistoList_dp_all_Target;
  TH1D* DP_InvMassReco_all_Target;
  TH1D* DP_OpeningAngleReco_all_Target;
  TH1D* DP_Pdg_all_Target;
  TH1D* DP_P_reco_all_Target;
  TH1D* DP_Pt_reco_all_Target;
  TH1D* Ph_fromTarget_Pt_reco_all_Target;
  TH1D* Ph_fromPions_Pt_reco_all_Target;
  TH1D* Ph_fromEtas_Pt_reco_all_Target;
  TH1D* Ph_fromDalitz_Pt_reco_all_Target;
 
  // Target => zero
  vector<TH1*> fHistoList_dp_zero_Target;
  TH1D* DP_InvMassReco_zero_Target;
  TH1D* DP_OpeningAngleReco_zero_Target;
  TH1D* DP_Pdg_zero_Target;
  TH1D* DP_P_reco_zero_Target;
  TH1D* DP_Pt_reco_zero_Target;
  TH1D* Ph_fromTarget_Pt_reco_zero_Target;
  TH1D* Ph_fromPions_Pt_reco_zero_Target;
  TH1D* Ph_fromEtas_Pt_reco_zero_Target;
  TH1D* Ph_fromDalitz_Pt_reco_zero_Target;
 
  // Target => one
  vector<TH1*> fHistoList_dp_one_Target;
  TH1D* DP_InvMassReco_one_Target;
  TH1D* DP_OpeningAngleReco_one_Target;
  TH1D* DP_Pdg_one_Target;
  TH1D* DP_P_reco_one_Target;
  TH1D* DP_Pt_reco_one_Target;
  TH1D* Ph_fromTarget_Pt_reco_one_Target;
  TH1D* Ph_fromPions_Pt_reco_one_Target;
  TH1D* Ph_fromEtas_Pt_reco_one_Target;
  TH1D* Ph_fromDalitz_Pt_reco_one_Target;
 
  // Target => two
  vector<TH1*> fHistoList_dp_two_Target;
  TH1D* DP_InvMassReco_two_Target;
  TH1D* DP_OpeningAngleReco_two_Target;
  TH1D* DP_Pdg_two_Target;
  TH1D* DP_P_reco_two_Target;
  TH1D* DP_Pt_reco_two_Target;
  TH1D* Ph_fromTarget_Pt_reco_two_Target;
  TH1D* Ph_fromPions_Pt_reco_two_Target;
  TH1D* Ph_fromEtas_Pt_reco_two_Target;
  TH1D* Ph_fromDalitz_Pt_reco_two_Target;
  TH1D* Ph_fromXi_Pt_reco_two_Target;
  TH1D* Ph_fromOther_Pt_reco_two_Target;
  TH1D* Ph_twoFromTarget_Pt_reco_two_Target;
  TH1D* Ph_fromCombinatorial_Pt_reco_two_Target;
  TH1D* Ph_fromConversion_Pt_reco_two_Target;
 
  TH1D* twoFromTarget_PDG_two_Target;
  TH1D* fromCombinatorial_PDG_two_Target;
  TH1D* CombinatorialGrMotherPdg_two_Target;
  TH1D* CombinatorialMotherPdg_two_Target;
  TH1D* Electrons_two_Target;
  TH1D* Pions_two_Target;
  TH1D* PionElectron_two_Target;
  TH1D* elsePionOrElectron_two_Target;
  TH1D* DalitzAndConversion_Pt_two_Target;
  TH1D* DoubleConversion_Pt_two_Target;
  TH1D* fromFireball_P_two_Target;
  TH1D* twoFromTarget_P_two_Target;
  TH1D* fromCombinatorial_electron_P_two_Target;
  TH1D* fromCombinatorial_NOTelectron_P_two_Target;
 
 
  // Target => onetwo
  vector<TH1*> fHistoList_dp_onetwo_Target;
  TH1D* DP_InvMassReco_onetwo_Target;
  TH1D* DP_OpeningAngleReco_onetwo_Target;
  TH1D* DP_Pdg_onetwo_Target;
  TH1D* DP_P_reco_onetwo_Target;
  TH1D* DP_Pt_reco_onetwo_Target;
  TH1D* Ph_fromTarget_Pt_reco_onetwo_Target;
  TH1D* Ph_fromPions_Pt_reco_onetwo_Target;
  TH1D* Ph_fromEtas_Pt_reco_onetwo_Target;
  TH1D* Ph_fromDalitz_Pt_reco_onetwo_Target;
  TH1D* Ph_fromXi_Pt_reco_onetwo_Target;
  TH1D* Ph_fromOther_Pt_reco_onetwo_Target;
  TH1D* Ph_twoFromTarget_Pt_reco_onetwo_Target;
  TH1D* Ph_fromCombinatorial_Pt_reco_onetwo_Target;
  TH1D* Ph_fromConversion_Pt_reco_onetwo_Target;
 
  TH1D* twoFromTarget_PDG_onetwo_Target;
  TH1D* fromCombinatorial_PDG_onetwo_Target;
  TH1D* CombinatorialGrMotherPdg_onetwo_Target;
  TH1D* CombinatorialMotherPdg_onetwo_Target;
  TH1D* Electrons_onetwo_Target;
  TH1D* Pions_onetwo_Target;
  TH1D* PionElectron_onetwo_Target;
  TH1D* elsePionOrElectron_onetwo_Target;
  TH1D* DalitzAndConversion_Pt_onetwo_Target;
  TH1D* DoubleConversion_Pt_onetwo_Target;
  TH1D* fromFireball_P_onetwo_Target;
  TH1D* twoFromTarget_P_onetwo_Target;
  TH1D* fromCombinatorial_electron_P_onetwo_Target;
  TH1D* fromCombinatorial_NOTelectron_P_onetwo_Target;
 
 
  // Outside => all
  vector<TH1*> fHistoList_dp_all_Outside;
  TH1D* DP_InvMassReco_all_Outside;
  TH1D* DP_OpeningAngleReco_all_Outside;
  TH1D* DP_Pdg_all_Outside;
  TH1D* DP_P_reco_all_Outside;
  TH1D* DP_Pt_reco_all_Outside;
  TH1D* Ph_fromTarget_Pt_reco_all_Outside;
  TH1D* Ph_fromPions_Pt_reco_all_Outside;
  TH1D* Ph_fromEtas_Pt_reco_all_Outside;
  TH1D* Ph_fromDalitz_Pt_reco_all_Outside;
 
  // Outside => zero
  vector<TH1*> fHistoList_dp_zero_Outside;
  TH1D* DP_InvMassReco_zero_Outside;
  TH1D* DP_OpeningAngleReco_zero_Outside;
  TH1D* DP_Pdg_zero_Outside;
  TH1D* DP_P_reco_zero_Outside;
  TH1D* DP_Pt_reco_zero_Outside;
  TH1D* Ph_fromTarget_Pt_reco_zero_Outside;
  TH1D* Ph_fromPions_Pt_reco_zero_Outside;
  TH1D* Ph_fromEtas_Pt_reco_zero_Outside;
  TH1D* Ph_fromDalitz_Pt_reco_zero_Outside;
 
  // Outside => one
  vector<TH1*> fHistoList_dp_one_Outside;
  TH1D* DP_InvMassReco_one_Outside;
  TH1D* DP_OpeningAngleReco_one_Outside;
  TH1D* DP_Pdg_one_Outside;
  TH1D* DP_P_reco_one_Outside;
  TH1D* DP_Pt_reco_one_Outside;
  TH1D* Ph_fromTarget_Pt_reco_one_Outside;
  TH1D* Ph_fromPions_Pt_reco_one_Outside;
  TH1D* Ph_fromEtas_Pt_reco_one_Outside;
  TH1D* Ph_fromDalitz_Pt_reco_one_Outside;
 
  // Outside => two
  vector<TH1*> fHistoList_dp_two_Outside;
  TH1D* DP_InvMassReco_two_Outside;
  TH1D* DP_OpeningAngleReco_two_Outside;
  TH1D* DP_Pdg_two_Outside;
  TH1D* DP_P_reco_two_Outside;
  TH1D* DP_Pt_reco_two_Outside;
  TH1D* Ph_fromTarget_Pt_reco_two_Outside;
  TH1D* Ph_fromPions_Pt_reco_two_Outside;
  TH1D* Ph_fromEtas_Pt_reco_two_Outside;
  TH1D* Ph_fromDalitz_Pt_reco_two_Outside;
  TH1D* Ph_fromXi_Pt_reco_two_Outside;
  TH1D* Ph_fromOther_Pt_reco_two_Outside;
  TH1D* Ph_twoFromTarget_Pt_reco_two_Outside;
  TH1D* Ph_fromCombinatorial_Pt_reco_two_Outside;
  TH1D* Ph_fromConversion_Pt_reco_two_Outside;
  TH1D* twoFromTarget_PDG_two_Outside;
  TH1D* fromCombinatorial_PDG_two_Outside;
  TH1D* CombinatorialGrMotherPdg_two_Outside;
  TH1D* CombinatorialMotherPdg_two_Outside;
  TH1D* Electrons_two_Outside;
  TH1D* Pions_two_Outside;
  TH1D* PionElectron_two_Outside;
  TH1D* elsePionOrElectron_two_Outside;
  TH1D* DalitzAndConversion_Pt_two_Outside;
  TH1D* DoubleConversion_Pt_two_Outside;
  TH1D* fromFireball_P_two_Outside;
  TH1D* twoFromTarget_P_two_Outside;
  TH1D* fromCombinatorial_electron_P_two_Outside;
  TH1D* fromCombinatorial_NOTelectron_P_two_Outside;
 
  // Outside => onetwo
  vector<TH1*> fHistoList_dp_onetwo_Outside;
  TH1D* DP_InvMassReco_onetwo_Outside;
  TH1D* DP_OpeningAngleReco_onetwo_Outside;
  TH1D* DP_Pdg_onetwo_Outside;
  TH1D* DP_P_reco_onetwo_Outside;
  TH1D* DP_Pt_reco_onetwo_Outside;
  TH1D* Ph_fromTarget_Pt_reco_onetwo_Outside;
  TH1D* Ph_fromPions_Pt_reco_onetwo_Outside;
  TH1D* Ph_fromEtas_Pt_reco_onetwo_Outside;
  TH1D* Ph_fromDalitz_Pt_reco_onetwo_Outside;
  TH1D* Ph_fromXi_Pt_reco_onetwo_Outside;
  TH1D* Ph_fromOther_Pt_reco_onetwo_Outside;
  TH1D* Ph_twoFromTarget_Pt_reco_onetwo_Outside;
  TH1D* Ph_fromCombinatorial_Pt_reco_onetwo_Outside;
  TH1D* Ph_fromConversion_Pt_reco_onetwo_Outside;
  TH1D* twoFromTarget_PDG_onetwo_Outside;
  TH1D* fromCombinatorial_PDG_onetwo_Outside;
  TH1D* CombinatorialGrMotherPdg_onetwo_Outside;
  TH1D* CombinatorialMotherPdg_onetwo_Outside;
  TH1D* Electrons_onetwo_Outside;
  TH1D* Pions_onetwo_Outside;
  TH1D* PionElectron_onetwo_Outside;
  TH1D* elsePionOrElectron_onetwo_Outside;
  TH1D* DalitzAndConversion_Pt_onetwo_Outside;
  TH1D* DoubleConversion_Pt_onetwo_Outside;
  TH1D* fromFireball_P_onetwo_Outside;
  TH1D* twoFromTarget_P_onetwo_Outside;
  TH1D* fromCombinatorial_electron_P_onetwo_Outside;
  TH1D* fromCombinatorial_NOTelectron_P_onetwo_Outside;
 
 
  // Both => all
  vector<TH1*> fHistoList_dp_all_Both;
  TH1D* DP_InvMassReco_all_Both;
  TH1D* DP_OpeningAngleReco_all_Both;
  TH1D* DP_Pdg_all_Both;
  TH1D* DP_P_reco_all_Both;
  TH1D* DP_Pt_reco_all_Both;
  TH1D* Ph_fromTarget_Pt_reco_all_Both;
  TH1D* Ph_fromPions_Pt_reco_all_Both;
  TH1D* Ph_fromEtas_Pt_reco_all_Both;
  TH1D* Ph_fromDalitz_Pt_reco_all_Both;
  TH2D* Ph_pt_vs_rap_est_all_Both;
 
  // Both => zero
  vector<TH1*> fHistoList_dp_zero_Both;
  TH1D* DP_InvMassReco_zero_Both;
  TH1D* DP_OpeningAngleReco_zero_Both;
  TH1D* DP_Pdg_zero_Both;
  TH1D* DP_P_reco_zero_Both;
  TH1D* DP_Pt_reco_zero_Both;
  TH1D* Ph_fromTarget_Pt_reco_zero_Both;
  TH1D* Ph_fromPions_Pt_reco_zero_Both;
  TH1D* Ph_fromEtas_Pt_reco_zero_Both;
  TH1D* Ph_fromDalitz_Pt_reco_zero_Both;
  TH2D* Ph_pt_vs_rap_est_zero_Both;
 
  // Both => one
  vector<TH1*> fHistoList_dp_one_Both;
  TH1D* DP_InvMassReco_one_Both;
  TH1D* DP_OpeningAngleReco_one_Both;
  TH1D* DP_Pdg_one_Both;
  TH1D* DP_P_reco_one_Both;
  TH1D* DP_Pt_reco_one_Both;
  TH1D* Ph_fromTarget_Pt_reco_one_Both;
  TH1D* Ph_fromPions_Pt_reco_one_Both;
  TH1D* Ph_fromEtas_Pt_reco_one_Both;
  TH1D* Ph_fromDalitz_Pt_reco_one_Both;
  TH2D* Ph_pt_vs_rap_est_one_Both;
 
  // Both => two
  vector<TH1*> fHistoList_dp_two_Both;
  TH1D* DP_InvMassReco_two_Both;
  TH1D* DP_OpeningAngleReco_two_Both;
  TH1D* DP_Pdg_two_Both;
  TH1D* DP_P_reco_two_Both;
  TH1D* DP_Pt_reco_two_Both;
  TH1D* Ph_fromTarget_Pt_reco_two_Both;
  TH1D* Ph_fromPions_Pt_reco_two_Both;
  TH1D* Ph_fromEtas_Pt_reco_two_Both;
  TH1D* Ph_fromDalitz_Pt_reco_two_Both;
  TH1D* Ph_twoFromTarget_Pt_reco_two_Both;
  TH1D* Ph_fromCombinatorial_Pt_reco_two_Both;
  TH1D* Ph_fromConversion_Pt_reco_two_Both;
  TH2D* Ph_pt_vs_rap_est_two_Both;
 
  // Both => onetwo
  vector<TH1*> fHistoList_dp_onetwo_Both;
  TH1D* DP_InvMassReco_onetwo_Both;
  TH1D* DP_OpeningAngleReco_onetwo_Both;
  TH1D* DP_Pdg_onetwo_Both;
  TH1D* DP_P_reco_onetwo_Both;
  TH1D* DP_Pt_reco_onetwo_Both;
  TH1D* Ph_fromTarget_Pt_reco_onetwo_Both;
  TH1D* Ph_fromPions_Pt_reco_onetwo_Both;
  TH1D* Ph_fromEtas_Pt_reco_onetwo_Both;
  TH1D* Ph_fromDalitz_Pt_reco_onetwo_Both;
  TH1D* Ph_twoFromTarget_Pt_reco_onetwo_Both;
  TH1D* Ph_fromCombinatorial_Pt_reco_onetwo_Both;
  TH1D* Ph_fromConversion_Pt_reco_onetwo_Both;
  TH2D* Ph_pt_vs_rap_est_onetwo_Both;
 
 
  // EMT DP target
  TH1D* DP_EMT_Pt_all_Target;
  TH1D* DP_EMT_Pt_zero_Target;
  TH1D* DP_EMT_Pt_one_Target;
  TH1D* DP_EMT_Pt_two_Target;
  TH1D* DP_EMT_Pt_onetwo_Target;
 
  // EMT DP Outside
  TH1D* DP_EMT_Pt_all_Outside;
  TH1D* DP_EMT_Pt_zero_Outside;
  TH1D* DP_EMT_Pt_one_Outside;
  TH1D* DP_EMT_Pt_two_Outside;
  TH1D* DP_EMT_Pt_onetwo_Outside;
 
  // EMT DP Both
  TH1D* DP_EMT_Pt_all_Both;
  TH1D* DP_EMT_Pt_zero_Both;
  TH1D* DP_EMT_Pt_one_Both;
  TH1D* DP_EMT_Pt_two_Both;
  TH1D* DP_EMT_Pt_onetwo_Both;
 
  TH1D* DP_LK_EMT_neg_Pt_all_Target;
  TH1D* DP_LK_EMT_neg_Pt_zero_Target;
  TH1D* DP_LK_EMT_neg_Pt_one_Target;
  TH1D* DP_LK_EMT_neg_Pt_two_Target;
  TH1D* DP_LK_EMT_neg_Pt_onetwo_Target;
 
  TH1D* DP_LK_EMT_pos_Pt_all_Target;
  TH1D* DP_LK_EMT_pos_Pt_zero_Target;
  TH1D* DP_LK_EMT_pos_Pt_one_Target;
  TH1D* DP_LK_EMT_pos_Pt_two_Target;
  TH1D* DP_LK_EMT_pos_Pt_onetwo_Target;
 
  TH1D* DP_LK_EMT_Pt_all_Target;
  TH1D* DP_LK_EMT_Pt_zero_Target;
  TH1D* DP_LK_EMT_Pt_one_Target;
  TH1D* DP_LK_EMT_Pt_two_Target;
  TH1D* DP_LK_EMT_Pt_onetwo_Target;
 
  TH1D* DP_LK_EMT_neg_Pt_all_Outside;
  TH1D* DP_LK_EMT_neg_Pt_zero_Outside;
  TH1D* DP_LK_EMT_neg_Pt_one_Outside;
  TH1D* DP_LK_EMT_neg_Pt_two_Outside;
  TH1D* DP_LK_EMT_neg_Pt_onetwo_Outside;
 
  TH1D* DP_LK_EMT_pos_Pt_all_Outside;
  TH1D* DP_LK_EMT_pos_Pt_zero_Outside;
  TH1D* DP_LK_EMT_pos_Pt_one_Outside;
  TH1D* DP_LK_EMT_pos_Pt_two_Outside;
  TH1D* DP_LK_EMT_pos_Pt_onetwo_Outside;
 
  TH1D* DP_LK_EMT_Pt_all_Outside;
  TH1D* DP_LK_EMT_Pt_zero_Outside;
  TH1D* DP_LK_EMT_Pt_one_Outside;
  TH1D* DP_LK_EMT_Pt_two_Outside;
  TH1D* DP_LK_EMT_Pt_onetwo_Outside;
 
 
  //***** brief Copy constructor.
  CbmKresConversionPhotons(const CbmKresConversionPhotons&);
 
  //***** brief Assignment operator.
  CbmKresConversionPhotons operator=(const CbmKresConversionPhotons&);
 
 
  ClassDef(CbmKresConversionPhotons, 1)
};
 
#endif