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 // QA class of Heavy Flavor quark and fragmeted/decayed particles
  17 // -Check kinematics of Heavy Quarks/hadrons, and decayed leptons
  18 //    pT, rapidity
  19 //    decay lepton kinematics w/wo acceptance
  20 //    heavy hadron decay length, electron pT fraction carried from decay
  21 // -Check yield of Heavy Quarks/hadrons
  22 //    Number of produced heavy quark
  23 //    Number of produced hadron of given pdg code
  24 //
  25
  26 #ifndef ALIHFEMCQA_H
  27 #define ALIHFEMCQA_H
  28
  29 #ifndef ROOT_TObject
  30 //#include <TObject.h>
  31 #endif
  32
  33 class TH1F;
  34 class TH2F;
  35 class TParticle;
  36 class TString;
  37 class AliStack;
  38 class AliGenEventHeader;
  39 class AliAODMCParticle;
  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                 enum SourceType {kDirectCharm=1, kDirectBeauty=2, kBeautyCharm=3, kGamma=4, kPi0=5, kElse=6};
  48                 enum ProcessType
  49                         {
  50                         kPairCreationFromq,  kPairCreationFromg,  kFlavourExitation,  kGluonSplitting, kInitialPartonShower, kLightQuarkShower
  51                         };
  52
  53                 AliHFEmcQA();
  54                 AliHFEmcQA(const AliHFEmcQA &p); // copy constructor
  55                 AliHFEmcQA &operator=(const AliHFEmcQA &); // assignment operator
  56
  57                 virtual ~AliHFEmcQA();
  58
  59                 void PostAnalyze() const;
  60                 void CreateHistograms(const Int_t kquark, Int_t icut, TString hnopt=""); // create histograms for mc qa analysis
  61                 void SetStack(AliStack* const stack){fStack=stack;} // set stack pointer
  62                 void SetGenEventHeader(AliGenEventHeader* const mcHeader){fMCHeader=mcHeader;} // set stack pointer
  63                 void SetMCArray(TClonesArray* const mcarry){fMCArray=mcarry;} // set mcarray pointer
  64                 void Init();
  65
  66                 void GetQuarkKine(TParticle *part, Int_t iTrack, const Int_t kquark); // get heavy quark kinematics distribution
  67                 void GetHadronKine(TParticle *part, const Int_t kquark); // get heavy hadron kinematics distribution
  68                 void GetDecayedKine(TParticle *part, const Int_t kquark, const Int_t kdecayed, Int_t icut); // get decay electron kinematics distribution
  69                 void GetDecayedKine(AliAODMCParticle *mcpart, const Int_t kquark, Int_t kdecayed, Int_t icut); // get decay electron kinematics for AOD
  70                 void EndOfEventAna(const Int_t kquark); // run analysis which should be done at the end of the event loop
  71                 Int_t GetSource(TParticle * const mcpart); // return electron source id
  72                 Int_t GetSource(AliAODMCParticle * const mcpart); // return electron source id for AOD
  73
  74         protected:
  75                 void IdentifyMother(Int_t motherlabel, Int_t &motherpdg, Int_t &grandmotherlabel); //
  76                 void HardScattering(const Int_t kquark, Int_t &motherID, Int_t &mothertype, Int_t &motherlabel); // check if the quark is produced from hard scattering
  77                 void ReportStrangeness(Int_t &motherID, Int_t &mothertype, Int_t &motherlabel); // report if the quark production process is unknown
  78                 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
  79                 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
  80                 Float_t GetRapidity(TParticle *part) const; // return rapidity
  81                 Float_t GetRapidity(AliAODMCParticle *part) const; // return rapidity
  82
  83                 AliStack* fStack; // stack pointer
  84                 AliGenEventHeader* fMCHeader; // mcheader pointer
  85                 TClonesArray *fMCArray; // mc array pointer
  86
  87                 static const Int_t fgkGluon; // gluon pdg code
  88                 static const Int_t fgkMaxGener; // ancester level wanted to be checked
  89                 static const Int_t fgkMaxIter; // number of iteration to find out matching particle
  90                 static const Int_t fgkqType; // number of particle type to be checked
  91
  92                 struct AliHists{
  93                         TH1F *fPdgCode; // histogram to store particle pdg code
  94                         TH1F *fPt; // histogram to store pt
  95                         TH1F *fY; // histogram to store rapidity
  96                         TH1F *fEta; // histogram to store eta
  97
  98                         AliHists()
  99                           : fPdgCode()
 100                           , fPt()
 101                           , fY()
 102                           , fEta()
 103                         {
 104                           // default constructor
 105                         };
 106                         AliHists(const AliHists & p)
 107                           : fPdgCode(p.fPdgCode)
 108                           , fPt(p.fPt)
 109                           , fY(p.fY)
 110                           , fEta(p.fEta)
 111                         {
 112                           // copy constructor
 113                         };
 114                         AliHists &operator=(const AliHists &)
 115                         {
 116                           // assignment operator, not yet implemented
 117                           return *this;
 118                         }
 119                 };
 120                 struct AliHistsComm {
 121                         TH1F *fNq; // histogram to store number of quark
 122                         TH1F *fProcessID; // histogram to store process id
 123                         TH2F *fePtRatio; // fraction of electron pT from D or B hadron
 124                         TH2F *fDePtRatio; // fraction of D electron pT from B hadron
 125                         TH2F *feDistance; // distance between electron production point to mother particle
 126                         TH2F *fDeDistance; // distance between D electron production point to mother particle
 127
 128                         AliHistsComm()
 129                           : fNq()
 130                           , fProcessID()
 131                           , fePtRatio()
 132                           , fDePtRatio()
 133                           , feDistance()
 134                           , fDeDistance()
 135                         {
 136                           // default constructor
 137                         };
 138                         AliHistsComm(const AliHistsComm & p)
 139                           : fNq(p.fNq)
 140                           , fProcessID(p.fProcessID)
 141                           , fePtRatio(p.fePtRatio)
 142                           , fDePtRatio(p.fDePtRatio)
 143                           , feDistance(p.feDistance)
 144                           , fDeDistance(p.fDeDistance)
 145                         {
 146                           // copy constructor
 147                         };
 148                         AliHistsComm &operator=(const AliHistsComm &)
 149                         {
 150                           // assignment operator, not yet implemented
 151                           return *this;
 152                         }
 153                 };
 154
 155                 AliHists fHist[2][7][5]; // struct of histograms to store kinematics of given particles
 156                 AliHistsComm fHistComm[2][5]; // struct of additional histograms of given particles
 157
 158                 TParticle *fHeavyQuark[50]; // store pointer of heavy flavour quark
 159                 Int_t fIsHeavy[2]; // count of heavy flavour
 160                 Int_t fNparents; // number of heavy hadrons to be considered
 161                 Int_t fParentSelect[2][7]; // heavy hadron species
 162
 163
 164         ClassDef(AliHFEmcQA,1);
 165 };
 166
 167 #endif