[u/mrichter/AliRoot.git] / PWG3 / hfe / AliHFEmcQA.h

#ifndef ALIHFEMCQA_H
#define ALIHFEMCQA_H

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */ 

//
// QA class of Heavy Flavor quark and fragmeted/decayed particles
// -Check kinematics of Heavy Quarks/hadrons, and decayed leptons
//    pT, rapidity
//    decay lepton kinematics w/wo acceptance
//    heavy hadron decay length, electron pT fraction carried from decay 
// -Check yield of Heavy Quarks/hadrons
//    Number of produced heavy quark
//    Number of produced hadron of given pdg code
//

#ifndef ROOT_TObject
//#include <TObject.h>
#endif

class TH1F;
class TH2F;
class TList;
class TParticle;
class TString;
class AliMCEvent;
class AliGenEventHeader;
class AliAODMCParticle;

//________________________________________________________________
class AliHFEmcQA: public TObject {

  public: 
    enum heavyType {kCharm=4, kBeauty=5, kOthers=6, kElectronPDG=11};
    enum qType {kQuark, kantiQuark, kHadron, keHadron, kDeHadron, kElectron, kElectron2nd};
    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};
    enum ProcessType {
      kPairCreationFromq,  kPairCreationFromg,  kFlavourExitation,  kGluonSplitting, kInitialPartonShower, kLightQuarkShower
    };

    AliHFEmcQA();
    AliHFEmcQA(const AliHFEmcQA &p); // copy constructor
    AliHFEmcQA &operator=(const AliHFEmcQA &); // assignment operator

    virtual ~AliHFEmcQA();

    TList *GetList() const { return fQAhistos; };
    void PostAnalyze() const;
    void CreatDefaultHistograms(TList * const qaList); // create default histograms  
    void CreateHistograms(const Int_t kquark, Int_t icut, TString hnopt=""); // create histograms for mc qa analysis
    void SetMCEvent(AliMCEvent* const mcEvent){fMCEvent = mcEvent;} 
    void SetGenEventHeader(AliGenEventHeader* const mcHeader){fMCHeader=mcHeader;} // set stack pointer
    void SetMCArray(TClonesArray* const mcarry){fMCArray=mcarry;} // set mcarray pointer
    void Init();

    void GetQuarkKine(TParticle *part, Int_t iTrack, const Int_t kquark); // get heavy quark kinematics distribution
    void GetHadronKine(TParticle *part, const Int_t kquark); // get heavy hadron kinematics distribution
    void GetDecayedKine(TParticle *part, const Int_t kquark, const Int_t kdecayed, Int_t icut); // get decay electron kinematics distribution
		void GetDecayedKine(AliAODMCParticle *mcpart, const Int_t kquark, Int_t kdecayed, Int_t icut); // get decay electron kinematics for AOD 
    void EndOfEventAna(const Int_t kquark); // run analysis which should be done at the end of the event loop
		Int_t GetSource(TParticle * const mcpart); // return source id 
		Int_t GetElecSource(TParticle * const mcpart); // return electron source id 
		Int_t GetSource(AliAODMCParticle * const mcpart); // return electron source id for AOD

  protected:
    void IdentifyMother(Int_t motherlabel, Int_t &motherpdg, Int_t &grandmotherlabel); // 
    void HardScattering(const Int_t kquark, Int_t &motherID, Int_t &mothertype, Int_t &motherlabel); // check if the quark is produced from hard scattering
    void ReportStrangeness(Int_t &motherID, Int_t &mothertype, Int_t &motherlabel); // report if the quark production process is unknown
    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 
    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

    AliMCEvent* fMCEvent; // mcevent pointer
    AliGenEventHeader* fMCHeader; // mcheader pointer
    TClonesArray *fMCArray; // mc array pointer

    static const Int_t fgkGluon; // gluon pdg code
    static const Int_t fgkMaxGener; // ancester level wanted to be checked 
    static const Int_t fgkMaxIter; // number of iteration to find out matching particle 
    static const Int_t fgkqType; // number of particle type to be checked

    struct AliHists{
      TH1F *fPdgCode; // histogram to store particle pdg code
      TH1F *fPt; // histogram to store pt
      TH1F *fY; // histogram to store rapidity
      TH1F *fEta; // histogram to store eta

			AliHists()
			  : fPdgCode()
			  , fPt()
			  , fY()
			  , fEta()
      {
			  // default constructor
			};
			AliHists(const AliHists & p)
			  : fPdgCode(p.fPdgCode)
			  , fPt(p.fPt)
			  , fY(p.fY)
			  , fEta(p.fEta)
      {
			  // copy constructor
			};
			AliHists &operator=(const AliHists &)
			{
			  // assignment operator, not yet implemented 
			  return *this;
			}
      void FillList(TList *l) const;
    };
    struct AliHistsComm {
      TH1F *fNq; // histogram to store number of quark
      TH1F *fProcessID; // histogram to store process id 
      TH2F *fePtRatio; // fraction of electron pT from D or B hadron
      TH2F *fPtCorr; // pt correlation between e and direct D or B 
      TH2F *fDePtRatio; // fraction of D electron pT from B hadron 
      TH2F *feDistance; // distance between electron production point to mother particle 
      TH2F *fDeDistance; // distance between D electron production point to mother particle

			AliHistsComm()
			  : fNq()
			  , fProcessID()
			  , fePtRatio()
			  , fPtCorr()
			  , fDePtRatio()
			  , feDistance()
			  , fDeDistance()
      {  
			  // default constructor
			};
			AliHistsComm(const AliHistsComm & p)
			  : fNq(p.fNq)
			  , fProcessID(p.fProcessID)
			  , fePtRatio(p.fePtRatio)
			  , fPtCorr(p.fPtCorr)
			  , fDePtRatio(p.fDePtRatio)
			  , feDistance(p.feDistance)
			  , fDeDistance(p.fDeDistance)
      {
			  // copy constructor
			};
			AliHistsComm &operator=(const AliHistsComm &)
			{
			  // assignment operator, not yet implemented 
			  return *this;
			}
      void FillList(TList *l) const;
    };

    AliHists fHist[3][7][6]; // struct of histograms to store kinematics of given particles
    AliHistsComm fHistComm[2][6]; // struct of additional histograms of given particles
    TH2F *fhD[9]; // D meson pt,Y spectra
    TH1F *fhDLogbin[9]; // D meson pt w diff binning

    TList *fQAhistos;           // Container for QA histos
    TParticle *fHeavyQuark[50]; //! store pointer of heavy flavour quark 
    Int_t fIsHeavy[2]; // count of heavy flavour
    Int_t fNparents; // number of heavy hadrons to be considered
    Int_t fParentSelect[2][7]; // heavy hadron species


  ClassDef(AliHFEmcQA,1);
};

#endif
Commit	Line	Data
27de2dfb	1	#ifndef ALIHFEMCQA_H
	2	#define ALIHFEMCQA_H
	3
259c3296	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	**************************************************************************/
27de2dfb	18
	19	/* $Id$ */
	20
50685501	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	//
259c3296	31
259c3296	32	#ifndef ROOT_TObject
75d81601	33	//#include <TObject.h>
259c3296	34	#endif
	35
	36	class TH1F;
	37	class TH2F;
70da6c5a	38	class TList;
259c3296	39	class TParticle;
259c3296	40	class TString;
faee3b18	41	class AliMCEvent;
9bcfd1ab	42	class AliGenEventHeader;
0792aa82	43	class AliAODMCParticle;
259c3296	44
	45	//________________________________________________________________
	46	class AliHFEmcQA: public TObject {
	47
70da6c5a	48	public:
faee3b18	49	enum heavyType {kCharm=4, kBeauty=5, kOthers=6, kElectronPDG=11};
70da6c5a	50	enum qType {kQuark, kantiQuark, kHadron, keHadron, kDeHadron, kElectron, kElectron2nd};
e3fc062d	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};
70da6c5a	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
70da6c5a	62	TList *GetList() const { return fQAhistos; };
70da6c5a	63	void PostAnalyze() const;
e3fc062d	64	void CreatDefaultHistograms(TList * const qaList); // create default histograms
70da6c5a	65	void CreateHistograms(const Int_t kquark, Int_t icut, TString hnopt=""); // create histograms for mc qa analysis
faee3b18	66	void SetMCEvent(AliMCEvent* const mcEvent){fMCEvent = mcEvent;}
70da6c5a	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
0792aa82	74	void GetDecayedKine(AliAODMCParticle *mcpart, const Int_t kquark, Int_t kdecayed, Int_t icut); // get decay electron kinematics for AOD
70da6c5a	75	void EndOfEventAna(const Int_t kquark); // run analysis which should be done at the end of the event loop
e3fc062d	76	Int_t GetSource(TParticle * const mcpart); // return source id
e3fc062d	77	Int_t GetElecSource(TParticle * const mcpart); // return electron source id
9bcfd1ab	78	Int_t GetSource(AliAODMCParticle * const mcpart); // return electron source id for AOD
dbe3abbe	79
70da6c5a	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
faee3b18	87	AliMCEvent* fMCEvent; // mcevent pointer
70da6c5a	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
75d81601	101
	102	AliHists()
	103	: fPdgCode()
	104	, fPt()
	105	, fY()
	106	, fEta()
70da6c5a	107	{
75d81601	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)
70da6c5a	115	{
75d81601	116	// copy constructor
	117	};
	118	AliHists &operator=(const AliHists &)
	119	{
	120	// assignment operator, not yet implemented
	121	return *this;
	122	}
70da6c5a	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
ccc37cdc	129	TH2F *fPtCorr; // pt correlation between e and direct D or B
70da6c5a	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
75d81601	133
	134	AliHistsComm()
	135	: fNq()
	136	, fProcessID()
	137	, fePtRatio()
ccc37cdc	138	, fPtCorr()
75d81601	139	, fDePtRatio()
	140	, feDistance()
	141	, fDeDistance()
70da6c5a	142	{
75d81601	143	// default constructor
	144	};
	145	AliHistsComm(const AliHistsComm & p)
	146	: fNq(p.fNq)
	147	, fProcessID(p.fProcessID)
	148	, fePtRatio(p.fePtRatio)
ccc37cdc	149	, fPtCorr(p.fPtCorr)
75d81601	150	, fDePtRatio(p.fDePtRatio)
	151	, feDistance(p.feDistance)
	152	, fDeDistance(p.fDeDistance)
70da6c5a	153	{
75d81601	154	// copy constructor
	155	};
	156	AliHistsComm &operator=(const AliHistsComm &)
	157	{
	158	// assignment operator, not yet implemented
	159	return *this;
	160	}
70da6c5a	161	void FillList(TList *l) const;
70da6c5a	162	};
259c3296	163
faee3b18	164	AliHists fHist[3][7][6]; // struct of histograms to store kinematics of given particles
faee3b18	165	AliHistsComm fHistComm[2][6]; // struct of additional histograms of given particles
ccc37cdc	166	TH2F *fhD[9]; // D meson pt,Y spectra
ccc37cdc	167	TH1F *fhDLogbin[9]; // D meson pt w diff binning
259c3296	168
70da6c5a	169	TList *fQAhistos; // Container for QA histos
bf892a6a	170	TParticle *fHeavyQuark[50]; //! store pointer of heavy flavour quark
70da6c5a	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
259c3296	174
259c3296	175
70da6c5a	176	ClassDef(AliHFEmcQA,1);
259c3296	177	};
	178
	179	#endif