Possibility to keep only D mesons that have a c or b quark as a grandmother (Francesc...
[u/mrichter/AliRoot.git] / PWG3 / hfe / AliHFEmcQA.h
1 #ifndef ALIHFEMCQA_H
2 #define ALIHFEMCQA_H
3
4 /**************************************************************************
5  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
6  *                                                                        *
7  * Author: The ALICE Off-line Project.                                    *
8  * Contributors are mentioned in the code where appropriate.              *
9  *                                                                        *
10  * Permission to use, copy, modify and distribute this software and its   *
11  * documentation strictly for non-commercial purposes is hereby granted   *
12  * without fee, provided that the above copyright notice appears in all   *
13  * copies and that both the copyright notice and this permission notice   *
14  * appear in the supporting documentation. The authors make no claims     *
15  * about the suitability of this software for any purpose. It is          *
16  * provided "as is" without express or implied warranty.                  *
17  **************************************************************************/
18
19 /* $Id$ */ 
20
21 //
22 // QA class of Heavy Flavor quark and fragmeted/decayed particles
23 // -Check kinematics of Heavy Quarks/hadrons, and decayed leptons
24 //    pT, rapidity
25 //    decay lepton kinematics w/wo acceptance
26 //    heavy hadron decay length, electron pT fraction carried from decay 
27 // -Check yield of Heavy Quarks/hadrons
28 //    Number of produced heavy quark
29 //    Number of produced hadron of given pdg code
30 //
31
32 #ifndef ROOT_TObject
33 //#include <TObject.h>
34 #endif
35
36 class TH1F;
37 class TH2F;
38 class TList;
39 class TParticle;
40 class TString;
41 class AliMCEvent;
42 class AliGenEventHeader;
43 class AliAODMCParticle;
44
45 //________________________________________________________________
46 class AliHFEmcQA: public TObject {
47
48   public: 
49     enum heavyType {kCharm=4, kBeauty=5, kOthers=6, kElectronPDG=11};
50     enum qType {kQuark, kantiQuark, kHadron, keHadron, kDeHadron, kElectron, kElectron2nd};
51     enum SourceType {kDirectCharm=1, kDirectBeauty=2, kBeautyCharm=3, kGamma=4, kPi0=5, kElse=6, kMisID=7, kEta=8, kOmega=9, kPhi=10, kEtaPrime=11, kRho0=12};
52     enum ProcessType {
53       kPairCreationFromq,  kPairCreationFromg,  kFlavourExitation,  kGluonSplitting, kInitialPartonShower, kLightQuarkShower
54     };
55
56     AliHFEmcQA();
57     AliHFEmcQA(const AliHFEmcQA &p); // copy constructor
58     AliHFEmcQA &operator=(const AliHFEmcQA &); // assignment operator
59
60     virtual ~AliHFEmcQA();
61
62     TList *GetList() const { return fQAhistos; };
63     void PostAnalyze() const;
64     void CreatDefaultHistograms(TList * const qaList); // create default histograms  
65     void CreateHistograms(const Int_t kquark, Int_t icut, TString hnopt=""); // create histograms for mc qa analysis
66     void SetMCEvent(AliMCEvent* const mcEvent){fMCEvent = mcEvent;} 
67     void SetGenEventHeader(AliGenEventHeader* const mcHeader){fMCHeader=mcHeader;} // set stack pointer
68     void SetMCArray(TClonesArray* const mcarry){fMCArray=mcarry;} // set mcarray pointer
69     void Init();
70
71     void GetQuarkKine(TParticle *part, Int_t iTrack, const Int_t kquark); // get heavy quark kinematics distribution
72     void GetHadronKine(TParticle *part, const Int_t kquark); // get heavy hadron kinematics distribution
73     void GetDecayedKine(TParticle *part, const Int_t kquark, const Int_t kdecayed, Int_t icut); // get decay electron kinematics distribution
74                 void GetDecayedKine(AliAODMCParticle *mcpart, const Int_t kquark, Int_t kdecayed, Int_t icut); // get decay electron kinematics for AOD 
75     void EndOfEventAna(const Int_t kquark); // run analysis which should be done at the end of the event loop
76                 Int_t GetSource(TParticle * const mcpart); // return source id 
77                 Int_t GetElecSource(TParticle * const mcpart); // return electron source id 
78                 Int_t GetSource(AliAODMCParticle * const mcpart); // return electron source id for AOD
79
80   protected:
81     void IdentifyMother(Int_t motherlabel, Int_t &motherpdg, Int_t &grandmotherlabel); // 
82     void HardScattering(const Int_t kquark, Int_t &motherID, Int_t &mothertype, Int_t &motherlabel); // check if the quark is produced from hard scattering
83     void ReportStrangeness(Int_t &motherID, Int_t &mothertype, Int_t &motherlabel); // report if the quark production process is unknown
84     Bool_t IsFromInitialShower(Int_t inputmotherlabel, Int_t &motherID, Int_t &mothertype, Int_t &motherlabel); // check if the quark is produced from initial parton shower 
85     Bool_t IsFromFinalParton(Int_t inputmotherlabel, Int_t &motherID, Int_t &mothertype, Int_t &motherlabel); // check if the quark is produced from final parton shower
86
87     AliMCEvent* fMCEvent; // mcevent pointer
88     AliGenEventHeader* fMCHeader; // mcheader pointer
89     TClonesArray *fMCArray; // mc array pointer
90
91     static const Int_t fgkGluon; // gluon pdg code
92     static const Int_t fgkMaxGener; // ancester level wanted to be checked 
93     static const Int_t fgkMaxIter; // number of iteration to find out matching particle 
94     static const Int_t fgkqType; // number of particle type to be checked
95
96     struct AliHists{
97       TH1F *fPdgCode; // histogram to store particle pdg code
98       TH1F *fPt; // histogram to store pt
99       TH1F *fY; // histogram to store rapidity
100       TH1F *fEta; // histogram to store eta
101
102                         AliHists()
103                           : fPdgCode()
104                           , fPt()
105                           , fY()
106                           , fEta()
107       {
108                           // default constructor
109                         };
110                         AliHists(const AliHists & p)
111                           : fPdgCode(p.fPdgCode)
112                           , fPt(p.fPt)
113                           , fY(p.fY)
114                           , fEta(p.fEta)
115       {
116                           // copy constructor
117                         };
118                         AliHists &operator=(const AliHists &)
119                         {
120                           // assignment operator, not yet implemented 
121                           return *this;
122                         }
123       void FillList(TList *l) const;
124     };
125     struct AliHistsComm {
126       TH1F *fNq; // histogram to store number of quark
127       TH1F *fProcessID; // histogram to store process id 
128       TH2F *fePtRatio; // fraction of electron pT from D or B hadron
129       TH2F *fPtCorr; // pt correlation between e and direct D or B 
130       TH2F *fDePtRatio; // fraction of D electron pT from B hadron 
131       TH2F *feDistance; // distance between electron production point to mother particle 
132       TH2F *fDeDistance; // distance between D electron production point to mother particle
133
134                         AliHistsComm()
135                           : fNq()
136                           , fProcessID()
137                           , fePtRatio()
138                           , fPtCorr()
139                           , fDePtRatio()
140                           , feDistance()
141                           , fDeDistance()
142       {  
143                           // default constructor
144                         };
145                         AliHistsComm(const AliHistsComm & p)
146                           : fNq(p.fNq)
147                           , fProcessID(p.fProcessID)
148                           , fePtRatio(p.fePtRatio)
149                           , fPtCorr(p.fPtCorr)
150                           , fDePtRatio(p.fDePtRatio)
151                           , feDistance(p.feDistance)
152                           , fDeDistance(p.fDeDistance)
153       {
154                           // copy constructor
155                         };
156                         AliHistsComm &operator=(const AliHistsComm &)
157                         {
158                           // assignment operator, not yet implemented 
159                           return *this;
160                         }
161       void FillList(TList *l) const;
162     };
163
164     AliHists fHist[3][7][6]; // struct of histograms to store kinematics of given particles
165     AliHistsComm fHistComm[2][6]; // struct of additional histograms of given particles
166     TH2F *fhD[9]; // D meson pt,Y spectra
167     TH1F *fhDLogbin[9]; // D meson pt w diff binning
168
169     TList *fQAhistos;           // Container for QA histos
170     TParticle *fHeavyQuark[50]; //! store pointer of heavy flavour quark 
171     Int_t fIsHeavy[2]; // count of heavy flavour
172     Int_t fNparents; // number of heavy hadrons to be considered
173     Int_t fParentSelect[2][7]; // heavy hadron species
174
175
176   ClassDef(AliHFEmcQA,1);
177 };
178
179 #endif