Since it contains fixes of coding rule violations, all classes are involved. Further...
[u/mrichter/AliRoot.git] / PWG3 / hfe / AliHFEmcQA.h
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15 /**************************************************************************
16  *                                                                        *
17  * QA class of Heavy Flavor quark and fragmeted/decayed particles         *
18  * -Check kinematics of Heavy Quarks/hadrons, and decayed leptons         *
19  *    pT, rapidity                                                        *
20  *    decay lepton kinematics w/wo acceptance                             *
21  *    heavy hadron decay length, electron pT fraction carried from decay  *
22  * -Check yield of Heavy Quarks/hadrons                                   *
23  *    Number of produced heavy quark                                      *
24  *    Number of produced hadron of given pdg code                         *
25  *                                                                        *
26  **************************************************************************/
27
28 #ifndef ALIHFEMCQA_H
29 #define ALIHFEMCQA_H
30
31 #ifndef ROOT_TObject
32 //#include <TObject.h>
33 #endif
34
35 class TH1F;
36 class TH2F;
37 class TParticle;
38 class TString;
39 class AliStack;
40
41 //________________________________________________________________
42 class AliHFEmcQA: public TObject {
43
44         public: 
45                 enum heavyType {kCharm=4, kBeauty=5, kElectronPDG=11};
46                 enum qType {kQuark, kantiQuark, kHadron, keHadron, kDeHadron, kElectron, kElectron2nd};
47                 AliHFEmcQA();
48                 AliHFEmcQA(const AliHFEmcQA &p); // copy constructor
49                 AliHFEmcQA &operator=(const AliHFEmcQA &); // assignment operator
50
51                 virtual ~AliHFEmcQA();
52
53                 void PostAnalyze();
54                 void CreateHistograms(const Int_t kquark, Int_t icut, TString hnopt=""); // create histograms for mc qa analysis
55                 void SetStack(AliStack* const stack){fStack=stack;} // set stack pointer
56                 void Init();
57
58                 void GetQuarkKine(Int_t iTrack, const Int_t kquark); // get heavy quark kinematics distribution
59                 void GetHadronKine(Int_t iTrack, const Int_t kquark); // get heavy hadron kinematics distribution
60                 void GetDecayedKine(Int_t iTrack, const Int_t kquark, const Int_t kdecayed, Int_t icut, Bool_t isbarrel=kFALSE); // get decay electron kinematics distribution
61                 void EndOfEventAna(const Int_t kquark); // run analysis which should be done at the end of the event loop
62
63         protected:
64                 void IdentifyMother(Int_t motherlabel, Int_t &motherpdg, Int_t &grandmotherlabel); // 
65                 void HardScattering(const Int_t kquark, Int_t &motherID, Int_t &mothertype, Int_t &motherlabel); // check if the quark is produced from hard scattering
66                 void ReportStrangeness(Int_t &motherID, Int_t &mothertype, Int_t &motherlabel); // report if the quark production process is unknown
67                 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 
68                 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
69                 Float_t GetRapidity(TParticle *part); // return rapidity
70
71                 AliStack* fStack; // stack pointer           
72
73                 static const Int_t fgkGluon; // gluon pdg code
74                 static const Int_t fgkMaxGener; // ancester level wanted to be checked 
75                 static const Int_t fgkMaxIter; // number of iteration to find out matching particle 
76                 static const Int_t fgkqType; // number of particle type to be checked
77
78
79                 enum ProcessType
80                         {
81                         kPairCreationFromq,  kPairCreationFromg,  kFlavourExitation,  kGluonSplitting, kInitialPartonShower, kLightQuarkShower
82                         };
83
84                 struct AliHists{
85                         TH1F *fPdgCode; // histogram to store particle pdg code
86                         TH1F *fPt; // histogram to store pt
87                         TH1F *fY; // histogram to store rapidity
88                         TH1F *fEta; // histogram to store eta
89
90                         AliHists()
91                           : fPdgCode()
92                           , fPt()
93                           , fY()
94                           , fEta()
95                         {
96                           // default constructor
97                         };
98                         AliHists(const AliHists & p)
99                           : fPdgCode(p.fPdgCode)
100                           , fPt(p.fPt)
101                           , fY(p.fY)
102                           , fEta(p.fEta)
103                         {
104                           // copy constructor
105                         };
106                         AliHists &operator=(const AliHists &)
107                         {
108                           // assignment operator, not yet implemented 
109                           return *this;
110                         }
111                 };
112                 struct AliHistsComm {
113                         TH1F *fNq; // histogram to store number of quark
114                         TH1F *fProcessID; // histogram to store process id 
115                         TH2F *fePtRatio; // fraction of electron pT from D or B hadron
116                         TH2F *fDePtRatio; // fraction of D electron pT from B hadron 
117                         TH2F *feDistance; // distance between electron production point to mother particle 
118                         TH2F *fDeDistance; // distance between D electron production point to mother particle
119
120                         AliHistsComm()
121                           : fNq()
122                           , fProcessID()
123                           , fePtRatio()
124                           , fDePtRatio()
125                           , feDistance()
126                           , fDeDistance()
127                         {
128                           // default constructor
129                         };
130                         AliHistsComm(const AliHistsComm & p)
131                           : fNq(p.fNq)
132                           , fProcessID(p.fProcessID)
133                           , fePtRatio(p.fePtRatio)
134                           , fDePtRatio(p.fDePtRatio)
135                           , feDistance(p.feDistance)
136                           , fDeDistance(p.fDeDistance)
137                         {
138                           // copy constructor
139                         };
140                         AliHistsComm &operator=(const AliHistsComm &)
141                         {
142                           // assignment operator, not yet implemented 
143                           return *this;
144                         }
145                 };
146
147                 AliHists fHist[2][7][5]; // struct of histograms to store kinematics of given particles
148                 AliHistsComm fHistComm[2][5]; // struct of additional histograms of given particles
149
150                 TParticle *fHeavyQuark[50]; // store pointer of heavy flavour quark 
151                 Int_t fIsHeavy[2]; // count of heavy flavour
152                 Int_t fNparents; // number of heavy hadrons to be considered
153                 Int_t fParentSelect[2][7]; // heavy hadron species
154
155
156         ClassDef(AliHFEmcQA,0);
157 };
158
159 #endif