[u/mrichter/AliRoot.git] / PWGCF / FEMTOSCOPY / Chaoticity / AliFourPion.h

#ifndef AliFourPion_cxx
#define AliFourPion_cxx
//
// Class AliFourPion
//
// AliFourPion
// author:
//        Dhevan Gangadharan (dhevan.raja.gangadharan@cern.ch)
//


class TH1F;
class TH3F;
class TH1D;
class TH2D;
class TH3D;

class TProfile;
class TProfile2D;
class TProfile3D;
class TRandom3;

class AliESDEvent;
class AliAODEvent;
class AliESDtrackCuts;
class AliESDpid;

#include "AliAnalysisTask.h"
#include "AliAnalysisTaskSE.h"
#include "AliESDpid.h"
#include "AliAODPid.h"
#include "AliFourPionEventCollection.h"
#include "AliCentrality.h"

class AliFourPion : public AliAnalysisTaskSE {
 public:

  AliFourPion();
  AliFourPion(const Char_t *name);
  virtual ~AliFourPion();
  AliFourPion(const AliFourPion &obj); 
  AliFourPion &operator=(const AliFourPion &obj);
  

  virtual void   UserCreateOutputObjects();
  virtual void   UserExec(Option_t *option);
  virtual void   Terminate(Option_t *);

  enum {
    kPairLimit = 10000,//10000
    kNormPairLimit = 45000,
    kMultLimitPbPb = 1800,//1800
    kMultLimitpp = 300,
    kMultBinspp = 10,
    kMCarrayLimit = 150000,// 110000
    kQbinsWeights = 40,
    kNDampValues = 16,
    kRmin = 5,// EW min radii 5 fm
    kDENtypes = 104,// was 44
  };

  static const Int_t fKbinsT   = 4;// Set fKstep as well !!!!
  static const Int_t fKbinsY   = 1;// Set fKstep as well !!!!
  static const Int_t fEDbins   = 2;
  static const Int_t fCentBins = 10;// 0-50%
  static const Int_t fMbinsMixing = 10;// 5% widths
  static const Int_t fRVALUES  = 7;// 7 EW radii (5-11) , was 8 Gaussian radii (3-10fm)


  Int_t GetNumKtBins() const {return AliFourPion::fKbinsT;}
  Int_t GetNumRValues() const {return AliFourPion::fRVALUES;}
  Int_t GetNumCentBins() const {return AliFourPion::fCentBins;}
  Int_t GetNumEDBins() const {return AliFourPion::fEDbins;}
  void SetWeightArrays(Bool_t legoCase=kTRUE, TH3F *histos[AliFourPion::fKbinsT][AliFourPion::fCentBins]=0x0);
  void SetMomResCorrections(Bool_t legoCase=kTRUE, TH2D *temp2DSC=0x0, TH2D *temp2DMC=0x0);
  void SetFSICorrelations(Bool_t legoCase=kTRUE, TH1D *tempss[12]=0x0, TH1D *tempos[12]=0x0);
  void SetMuonCorrections(Bool_t legoCase=kTRUE, TH2D *tempMuon=0x0);
  void Setc3FitEAs(Bool_t legoCase=kTRUE, TH3D *histoPbPb=0x0, TH3D *histopPb=0x0, TH3D *histopp=0x0);
  //
  void SetMCdecision(Bool_t mc) {fMCcase = mc;}
  void SetTabulatePairs(Bool_t tabulate) {fTabulatePairs = tabulate;}
  void SetInterpolationType(Bool_t linearInterp) {fLinearInterpolation = linearInterp;}
  void SetCollisionType(Short_t ct) {fCollisionType = ct;}
  void SetGenerateSignal(Bool_t gen) {fGenerateSignal = gen;}
  void SetGeneratorOnly(Bool_t genOnly) {fGeneratorOnly = genOnly;}
  void SetCentBinRange(Int_t low, Int_t high) {fCentBinLowLimit = low; fCentBinHighLimit = high;}
  void SetLEGOCase(Bool_t lego) {fLEGO = lego;}
  void SetFilterBit(UInt_t filterbit) {fFilterBit = filterbit;}
  void SetMaxChi2NDF(Float_t MaxChi2NDF) {fMaxChi2NDF = MaxChi2NDF;}
  void SetMinTPCncls(Int_t MinTPCncls) {fMinTPCncls = MinTPCncls;}
  void SetPairSeparationCutEta(Float_t pairsep) {fMinSepPairEta = pairsep;}
  void SetPairSeparationCutPhi(Float_t pairsep) {fMinSepPairPhi = pairsep;}
  void SetNsigmaTPC(Float_t nsig) {fSigmaCutTPC = nsig;}
  void SetNsigmaTOF(Float_t nsig) {fSigmaCutTOF = nsig;}
  void SetRMax(Int_t rbin) {fRMax = rbin;}
  void SetfcSq(Float_t fcSq) {ffcSq = fcSq;}
  void SetMixedChargeCut(Bool_t mcCut) {fMixedChargeCut = mcCut;}
  void SetMinPt(Float_t minPt) {fMinPt = minPt;}
  void SetMaxPt(Float_t maxPt) {fMaxPt = maxPt;}
  void SetKT3transition(Float_t KT3trans) {fKT3transition = KT3trans;}
  void SetKT4transition(Float_t KT4trans) {fKT4transition = KT4trans;}
  void SetTriggerType(Int_t tt) {fTriggerType = tt;}
  void SetNormLow(Float_t nl) {fNormQcutLow = nl;}
  void SetNormHigh(Float_t nh) {fNormQcutHigh = nh;}
  //
  

 private:

  void ParInit();
  Bool_t AcceptPair(AliFourPionTrackStruct, AliFourPionTrackStruct);
  Bool_t AcceptPairPM(AliFourPionTrackStruct, AliFourPionTrackStruct);
  Float_t Gamov(Int_t, Int_t, Float_t);
  void Shuffle(Int_t*, Int_t, Int_t);
  Float_t GetQinv(Float_t[], Float_t[]);
  void GetQosl(Float_t[], Float_t[], Float_t&, Float_t&, Float_t&);
  void GetWeight(Float_t[], Float_t[], Float_t&, Float_t&);
  Float_t FSICorrelation(Int_t, Int_t, Float_t);
  Float_t MCWeight(Int_t[2], Float_t, Float_t, Float_t, Float_t);
  Float_t MCWeightOSL(Int_t, Int_t, Int_t, Int_t, Float_t, Float_t, Float_t, Float_t);
  Float_t MCWeight3(Int_t, Float_t, Float_t, Int_t[3], Float_t[3], Float_t[3]);
  Float_t MCWeightFSI3(Int_t, Float_t, Float_t, Int_t[3], Float_t[3]);
  Float_t MCWeight4(Int_t, Float_t, Float_t, Int_t[4], Float_t[6], Float_t[6]);
  Float_t MCWeightFSI4(Int_t, Float_t, Float_t, Int_t[4], Float_t[6]);
  //
  void SetFillBins2(Int_t, Int_t, Int_t&, Int_t&);
  void SetFillBins3(Int_t, Int_t, Int_t, Short_t, Int_t&, Int_t&, Int_t&, Bool_t&, Bool_t&, Bool_t&);
  void SetFillBins4(Int_t, Int_t, Int_t, Int_t, Int_t&, Int_t&, Int_t&, Int_t&, Int_t, Bool_t[13]);
  void SetFSIindex(Float_t);
  //
  Float_t cubicInterpolate(Float_t[4], Float_t);
  Float_t nCubicInterpolate(Int_t, Float_t*, Float_t[]);
  
  
  const char* fname;// name of class
  AliAODEvent            *fAOD; //!    // AOD object
  TList                  *fOutputList; //! Compact Output list
  AliPIDResponse         *fPIDResponse; //! PID response object; equivalent to AliAODpidUtil
  
  
  AliFourPionEventCollection ***fEC; //!
  AliFourPionEventStruct *fEvt; //!
  AliFourPionTrackStruct *fTempStruct; //!
  TRandom3* fRandomNumber; //!

  
  //////////////////////////////
  // histogram structures

  
  struct St6 {
    TH1D *fNorm3; //!
    TH1D *fTerms3; //!
    TH3D *fTerms33D; //!
    TProfile *fKfactor; //!
    TProfile3D *fKfactor3D; //!
    TProfile *fKfactorWeighted; //!
    TProfile *fMeanQinv; //!
    TH2D *fIdeal; //!
    TH2D *fSmeared; //!
    //
    TH3D *fMuonSmeared; //!
    TH3D *fMuonIdeal; //!
    TH3D *fMuonPionK3; //!
    TH3D *fPionPionK3; //!
    //
    TH2D *fTwoPartNorm; //!
    TH2D *fTwoPartNegNorm; //!
    TH2D *fTwoPartNormErr; //!
  };
  struct St7 {
    TH3D *fTerms2OSL; //!
    TH3D *fTerms2OSLQW; //!
  };
  struct St5 {
    TH2D *fTerms2; //!
    TH2D *fTerms2QW; //!
    TH3D *fTerms2ThreeD; //!
    TProfile2D *fAvgP; //!
    TH2D *fIdeal; //!
    TH2D *fSmeared; //!
    TH2D *fUnitMultBin; //!
    //
    TH2D *fMuonSmeared; //!
    TH2D *fMuonIdeal; //!
    TH2D *fMuonPionK2; //!
    TH2D *fPionPionK2; //!
    TH1D *fMCqinv; //!
    TH1D *fMCqinvQW; //!
    TH2D *fPIDpurityDen; //!
    TH3D *fPIDpurityNum; //!
    struct St7 OSL_ktbin[2];
  };
  struct StFourPT {
    TH1D *fNorm4; //!
    TH1D *fTerms4; //!
    TProfile *fKfactor; //!
    TProfile *fKfactorWeighted; //!
    TH2D *fIdeal; //!
    TH2D *fSmeared; //!
    //
    TH3D *fMuonSmeared; //!
    TH3D *fMuonIdeal; //!
    TH3D *fMuonPionK4; //!
    TH3D *fPionPionK4; //!
    //
    TH2D *fTwoPartNorm; //!
    TH2D *fTwoPartNegNorm; //!
    TH2D *fTwoPartNormErr; //!
    TH3D *fFullBuildFromFits; //!
    TH3D *fPartialBuildFromFits; //!
  };
  struct St_EDB {
    struct St5 TwoPT[2];
    struct St6 ThreePT[5];
    struct StFourPT FourPT[13];
  };
  struct St_M {
    struct St_EDB EDB[fEDbins];
  };
  struct St4 {
    struct St_M MB[fCentBins];
  };
  struct St3 {
    struct St4 Charge4[2];
    struct St_M MB[fCentBins];
  };
  struct St2 {
    struct St3 Charge3[2];
    struct St_M MB[fCentBins];
  };
  struct St1 {
    struct St2 Charge2[2];
  };
  struct St1 Charge1[2];//!


  /////////////////////
  // 4D r3 denominator
  struct St_Ky {
    struct St_M MB[fCentBins];
  };
  struct St_Kt {
    struct St_Ky KY[fKbinsY];
  };
  struct St_Kt KT[fKbinsT];//!
  
 
  Bool_t fLEGO;
  Bool_t fMCcase;
  Bool_t fAODcase;
  Short_t fCollisionType;
  Bool_t fGenerateSignal;
  Bool_t fGeneratorOnly;
  Bool_t fTabulatePairs;
  Bool_t fLinearInterpolation;
  Bool_t fMixedChargeCut;
  Int_t fRMax;
  Float_t fRstartMC;
  Float_t ffcSq;
  Float_t ffcSqMRC;
  UInt_t fFilterBit;
  Float_t fMaxChi2NDF;
  Int_t fMinTPCncls;
  Double_t fBfield;
  Int_t fMbin;
  Int_t fFSIindex;
  Int_t fEDbin;
  Int_t fMbins;
  Int_t fMultLimit;      
  Int_t fCentBinLowLimit;
  Int_t fCentBinHighLimit;
  Int_t fTriggerType;
  Int_t fEventCounter;
  Int_t fEventsToMix;
  Int_t fZvertexBins;
  Int_t fMultLimits[kMultBinspp+1];
  Float_t fMinPt;
  Float_t fMaxPt;
  Float_t fQcut;
  Float_t fQLowerCut;
  Float_t fNormQcutLow;
  Float_t fNormQcutHigh;
  Float_t fKupperBound;
  Float_t fQupperBoundQ2;
  Float_t fQupperBoundQ3;
  Float_t fQupperBoundQ4;
  Float_t fQbinsQ2;
  Float_t fQbinsQ3;
  Float_t fQbinsQ4;
  Float_t fQupperBoundWeights;
  Float_t fQbinsQinv3D;
  Float_t fQupperBoundQinv3D;
  Float_t fKstepT[fKbinsT];
  Float_t fKstepY[fKbinsY];
  Float_t fKmeanT[fKbinsT];
  Float_t fKmeanY[fKbinsY];
  Float_t fKmiddleT[fKbinsT];
  Float_t fKmiddleY[fKbinsY];
  Float_t fQstep;
  Float_t fQstepWeights;
  Float_t fQmean[kQbinsWeights];
  Float_t fDampStart;
  Float_t fDampStep;
  
  Float_t fTPCTOFboundry;
  Float_t fTOFboundry;
  Float_t fSigmaCutTPC;
  Float_t fSigmaCutTOF;
  
  Float_t fMinSepPairEta;
  Float_t fMinSepPairPhi;
  Float_t fShareQuality;
  Float_t fShareFraction;
  
  Float_t fTrueMassP, fTrueMassPi, fTrueMassK, fTrueMassKs, fTrueMassLam;
 
  Int_t fKtIndexL,fKtIndexH;
  //
  Int_t fQoIndexL,fQoIndexH;
  Int_t fQsIndexL,fQsIndexH;
  Int_t fQlIndexL,fQlIndexH;

  Bool_t fDummyB;

  Float_t fKT3transition;
  Float_t fKT4transition;
  
  Float_t farrP1[4][4][4];
  Float_t farrP2[4][4][4];
  
 
  //
  Char_t fDefaultsCharSwitch[kMultLimitPbPb];//!
  TArrayC *fLowQPairSwitch_E0E0[kMultLimitPbPb];//!
  TArrayC *fLowQPairSwitch_E0E1[kMultLimitPbPb];//!
  TArrayC *fLowQPairSwitch_E0E2[kMultLimitPbPb];//!
  TArrayC *fLowQPairSwitch_E0E3[kMultLimitPbPb];//!
  TArrayC *fLowQPairSwitch_E1E1[kMultLimitPbPb];//!
  TArrayC *fLowQPairSwitch_E1E2[kMultLimitPbPb];//!
  TArrayC *fLowQPairSwitch_E1E3[kMultLimitPbPb];//!
  TArrayC *fLowQPairSwitch_E2E3[kMultLimitPbPb];//!
  //
  TArrayC *fNormQPairSwitch_E0E0[kMultLimitPbPb];//!
  TArrayC *fNormQPairSwitch_E0E1[kMultLimitPbPb];//!
  TArrayC *fNormQPairSwitch_E0E2[kMultLimitPbPb];//!
  TArrayC *fNormQPairSwitch_E0E3[kMultLimitPbPb];//!
  TArrayC *fNormQPairSwitch_E1E1[kMultLimitPbPb];//!
  TArrayC *fNormQPairSwitch_E1E2[kMultLimitPbPb];//!
  TArrayC *fNormQPairSwitch_E1E3[kMultLimitPbPb];//!
  TArrayC *fNormQPairSwitch_E2E3[kMultLimitPbPb];//!

  
 public:
  TH2D *fMomResC2SC;
  TH2D *fMomResC2MC;
  TH2D *fWeightmuonCorrection;
  TH3D *fPbPbc3FitEA;
  TH3D *fpPbc3FitEA;
  TH3D *fppc3FitEA;
  TH1D *fFSIss[12];
  TH1D *fFSIos[12];
  TH3F *fNormWeight[fKbinsT][fCentBins];
  TF1 *ExchangeAmpPointSource[2][50];

  ClassDef(AliFourPion, 1); 
};

#endif
Commit	Line	Data
be9ef9f9	1	#ifndef AliFourPion_cxx
	2	#define AliFourPion_cxx
	3	//
	4	// Class AliFourPion
	5	//
	6	// AliFourPion
	7	// author:
	8	// Dhevan Gangadharan (dhevan.raja.gangadharan@cern.ch)
	9	//
	10
	11
	12
	13	class TH1F;
	14	class TH3F;
	15	class TH1D;
	16	class TH2D;
	17	class TH3D;
	18
	19	class TProfile;
	20	class TProfile2D;
78c3bd48	21	class TProfile3D;
be9ef9f9	22	class TRandom3;
	23
	24	class AliESDEvent;
	25	class AliAODEvent;
	26	class AliESDtrackCuts;
	27	class AliESDpid;
	28
	29	#include "AliAnalysisTask.h"
	30	#include "AliAnalysisTaskSE.h"
	31	#include "AliESDpid.h"
	32	#include "AliAODPid.h"
	33	#include "AliFourPionEventCollection.h"
	34	#include "AliCentrality.h"
	35
	36	class AliFourPion : public AliAnalysisTaskSE {
	37	public:
	38
	39	AliFourPion();
	40	AliFourPion(const Char_t *name);
	41	virtual ~AliFourPion();
	42	AliFourPion(const AliFourPion &obj);
	43	AliFourPion &operator=(const AliFourPion &obj);
	44
	45
	46	virtual void UserCreateOutputObjects();
	47	virtual void UserExec(Option_t *option);
	48	virtual void Terminate(Option_t *);
	49
	50	enum {
	51	kPairLimit = 10000,//10000
	52	kNormPairLimit = 45000,
	53	kMultLimitPbPb = 1800,//1800
	54	kMultLimitpp = 300,
0207c034	55	kMultBinspp = 10,
be9ef9f9	56	kMCarrayLimit = 150000,// 110000
	57	kQbinsWeights = 40,
	58	kNDampValues = 16,
	59	kRmin = 5,// EW min radii 5 fm
9c0557fb	60	kDENtypes = 104,// was 44
be9ef9f9	61	};
	62
	63	static const Int_t fKbinsT = 4;// Set fKstep as well !!!!
	64	static const Int_t fKbinsY = 1;// Set fKstep as well !!!!
	65	static const Int_t fEDbins = 2;
	66	static const Int_t fCentBins = 10;// 0-50%
0207c034	67	static const Int_t fMbinsMixing = 10;// 5% widths
be9ef9f9	68	static const Int_t fRVALUES = 7;// 7 EW radii (5-11) , was 8 Gaussian radii (3-10fm)
	69
	70
	71	Int_t GetNumKtBins() const {return AliFourPion::fKbinsT;}
	72	Int_t GetNumRValues() const {return AliFourPion::fRVALUES;}
	73	Int_t GetNumCentBins() const {return AliFourPion::fCentBins;}
	74	Int_t GetNumEDBins() const {return AliFourPion::fEDbins;}
	75	void SetWeightArrays(Bool_t legoCase=kTRUE, TH3F *histos[AliFourPion::fKbinsT][AliFourPion::fCentBins]=0x0);
80507acf	76	void SetMomResCorrections(Bool_t legoCase=kTRUE, TH2D temp2DSC=0x0, TH2D temp2DMC=0x0);
be9ef9f9	77	void SetFSICorrelations(Bool_t legoCase=kTRUE, TH1D tempss[12]=0x0, TH1D tempos[12]=0x0);
5591748e	78	void SetMuonCorrections(Bool_t legoCase=kTRUE, TH2D *tempMuon=0x0);
55e482b6	79	void Setc3FitEAs(Bool_t legoCase=kTRUE, TH3D histoPbPb=0x0, TH3D histopPb=0x0, TH3D *histopp=0x0);
be9ef9f9	80	//
	81	void SetMCdecision(Bool_t mc) {fMCcase = mc;}
	82	void SetTabulatePairs(Bool_t tabulate) {fTabulatePairs = tabulate;}
95567836	83	void SetInterpolationType(Bool_t linearInterp) {fLinearInterpolation = linearInterp;}
803ae3ce	84	void SetCollisionType(Short_t ct) {fCollisionType = ct;}
be9ef9f9	85	void SetGenerateSignal(Bool_t gen) {fGenerateSignal = gen;}
	86	void SetGeneratorOnly(Bool_t genOnly) {fGeneratorOnly = genOnly;}
	87	void SetCentBinRange(Int_t low, Int_t high) {fCentBinLowLimit = low; fCentBinHighLimit = high;}
	88	void SetLEGOCase(Bool_t lego) {fLEGO = lego;}
	89	void SetFilterBit(UInt_t filterbit) {fFilterBit = filterbit;}
	90	void SetMaxChi2NDF(Float_t MaxChi2NDF) {fMaxChi2NDF = MaxChi2NDF;}
	91	void SetMinTPCncls(Int_t MinTPCncls) {fMinTPCncls = MinTPCncls;}
	92	void SetPairSeparationCutEta(Float_t pairsep) {fMinSepPairEta = pairsep;}
	93	void SetPairSeparationCutPhi(Float_t pairsep) {fMinSepPairPhi = pairsep;}
	94	void SetNsigmaTPC(Float_t nsig) {fSigmaCutTPC = nsig;}
	95	void SetNsigmaTOF(Float_t nsig) {fSigmaCutTOF = nsig;}
	96	void SetRMax(Int_t rbin) {fRMax = rbin;}
	97	void SetfcSq(Float_t fcSq) {ffcSq = fcSq;}
42802bba	98	void SetMixedChargeCut(Bool_t mcCut) {fMixedChargeCut = mcCut;}
	99	void SetMinPt(Float_t minPt) {fMinPt = minPt;}
	100	void SetMaxPt(Float_t maxPt) {fMaxPt = maxPt;}
	101	void SetKT3transition(Float_t KT3trans) {fKT3transition = KT3trans;}
	102	void SetKT4transition(Float_t KT4trans) {fKT4transition = KT4trans;}
0207c034	103	void SetTriggerType(Int_t tt) {fTriggerType = tt;}
d3df474e	104	void SetNormLow(Float_t nl) {fNormQcutLow = nl;}
d3df474e	105	void SetNormHigh(Float_t nh) {fNormQcutHigh = nh;}
be9ef9f9	106	//
d3df474e	107
be9ef9f9	108
	109	private:
	110
	111	void ParInit();
	112	Bool_t AcceptPair(AliFourPionTrackStruct, AliFourPionTrackStruct);
fac2d84b	113	Bool_t AcceptPairPM(AliFourPionTrackStruct, AliFourPionTrackStruct);
fcb16ac9	114	Float_t Gamov(Int_t, Int_t, Float_t);
be9ef9f9	115	void Shuffle(Int_t*, Int_t, Int_t);
	116	Float_t GetQinv(Float_t[], Float_t[]);
	117	void GetQosl(Float_t[], Float_t[], Float_t&, Float_t&, Float_t&);
	118	void GetWeight(Float_t[], Float_t[], Float_t&, Float_t&);
	119	Float_t FSICorrelation(Int_t, Int_t, Float_t);
	120	Float_t MCWeight(Int_t[2], Float_t, Float_t, Float_t, Float_t);
	121	Float_t MCWeightOSL(Int_t, Int_t, Int_t, Int_t, Float_t, Float_t, Float_t, Float_t);
	122	Float_t MCWeight3(Int_t, Float_t, Float_t, Int_t[3], Float_t[3], Float_t[3]);
	123	Float_t MCWeightFSI3(Int_t, Float_t, Float_t, Int_t[3], Float_t[3]);
	124	Float_t MCWeight4(Int_t, Float_t, Float_t, Int_t[4], Float_t[6], Float_t[6]);
	125	Float_t MCWeightFSI4(Int_t, Float_t, Float_t, Int_t[4], Float_t[6]);
	126	//
	127	void SetFillBins2(Int_t, Int_t, Int_t&, Int_t&);
	128	void SetFillBins3(Int_t, Int_t, Int_t, Short_t, Int_t&, Int_t&, Int_t&, Bool_t&, Bool_t&, Bool_t&);
6bb6954b	129	void SetFillBins4(Int_t, Int_t, Int_t, Int_t, Int_t&, Int_t&, Int_t&, Int_t&, Int_t, Bool_t[13]);
be9ef9f9	130	void SetFSIindex(Float_t);
be9ef9f9	131	//
95567836	132	Float_t cubicInterpolate(Float_t[4], Float_t);
95567836	133	Float_t nCubicInterpolate(Int_t, Float_t*, Float_t[]);
2b6fd022	134
be9ef9f9	135
	136	const char* fname;// name of class
	137	AliAODEvent *fAOD; //! // AOD object
	138	TList *fOutputList; //! Compact Output list
	139	AliPIDResponse *fPIDResponse; //! PID response object; equivalent to AliAODpidUtil
	140
	141
	142	AliFourPionEventCollection ***fEC; //!
	143	AliFourPionEventStruct *fEvt; //!
	144	AliFourPionTrackStruct *fTempStruct; //!
	145	TRandom3* fRandomNumber; //!
	146
	147
	148
	149	//////////////////////////////
	150	// histogram structures
	151
	152
	153	struct St6 {
	154	TH1D *fNorm3; //!
	155	TH1D *fTerms3; //!
78c3bd48	156	TH3D *fTerms33D; //!
be9ef9f9	157	TProfile *fKfactor; //!
78c3bd48	158	TProfile3D *fKfactor3D; //!
80507acf	159	TProfile *fKfactorWeighted; //!
be9ef9f9	160	TProfile *fMeanQinv; //!
	161	TH2D *fIdeal; //!
	162	TH2D *fSmeared; //!
	163	//
5591748e	164	TH3D *fMuonSmeared; //!
	165	TH3D *fMuonIdeal; //!
	166	TH3D *fMuonPionK3; //!
	167	TH3D *fPionPionK3; //!
	168	//
be9ef9f9	169	TH2D *fTwoPartNorm; //!
6432c081	170	TH2D *fTwoPartNegNorm; //!
43046300	171	TH2D *fTwoPartNormErr; //!
be9ef9f9	172	};
	173	struct St7 {
	174	TH3D *fTerms2OSL; //!
	175	TH3D *fTerms2OSLQW; //!
	176	};
	177	struct St5 {
	178	TH2D *fTerms2; //!
	179	TH2D *fTerms2QW; //!
	180	TH3D *fTerms2ThreeD; //!
	181	TProfile2D *fAvgP; //!
	182	TH2D *fIdeal; //!
	183	TH2D *fSmeared; //!
	184	TH2D *fUnitMultBin; //!
	185	//
	186	TH2D *fMuonSmeared; //!
	187	TH2D *fMuonIdeal; //!
	188	TH2D *fMuonPionK2; //!
	189	TH2D *fPionPionK2; //!
	190	TH1D *fMCqinv; //!
	191	TH1D *fMCqinvQW; //!
	192	TH2D *fPIDpurityDen; //!
	193	TH3D *fPIDpurityNum; //!
	194	struct St7 OSL_ktbin[2];
	195	};
	196	struct StFourPT {
	197	TH1D *fNorm4; //!
	198	TH1D *fTerms4; //!
	199	TProfile *fKfactor; //!
80507acf	200	TProfile *fKfactorWeighted; //!
be9ef9f9	201	TH2D *fIdeal; //!
	202	TH2D *fSmeared; //!
	203	//
5591748e	204	TH3D *fMuonSmeared; //!
	205	TH3D *fMuonIdeal; //!
	206	TH3D *fMuonPionK4; //!
	207	TH3D *fPionPionK4; //!
	208	//
be9ef9f9	209	TH2D *fTwoPartNorm; //!
6432c081	210	TH2D *fTwoPartNegNorm; //!
43046300	211	TH2D *fTwoPartNormErr; //!
ebd00f1b	212	TH3D *fFullBuildFromFits; //!
ebd00f1b	213	TH3D *fPartialBuildFromFits; //!
be9ef9f9	214	};
	215	struct St_EDB {
	216	struct St5 TwoPT[2];
	217	struct St6 ThreePT[5];
6bb6954b	218	struct StFourPT FourPT[13];
be9ef9f9	219	};
	220	struct St_M {
	221	struct St_EDB EDB[fEDbins];
	222	};
	223	struct St4 {
	224	struct St_M MB[fCentBins];
	225	};
	226	struct St3 {
	227	struct St4 Charge4[2];
	228	struct St_M MB[fCentBins];
	229	};
	230	struct St2 {
	231	struct St3 Charge3[2];
	232	struct St_M MB[fCentBins];
	233	};
	234	struct St1 {
	235	struct St2 Charge2[2];
	236	};
	237	struct St1 Charge1[2];//!
	238
	239
	240	/////////////////////
	241	// 4D r3 denominator
	242	struct St_Ky {
	243	struct St_M MB[fCentBins];
	244	};
	245	struct St_Kt {
	246	struct St_Ky KY[fKbinsY];
	247	};
	248	struct St_Kt KT[fKbinsT];//!
	249
	250
	251	Bool_t fLEGO;
	252	Bool_t fMCcase;
	253	Bool_t fAODcase;
ebd00f1b	254	Short_t fCollisionType;
be9ef9f9	255	Bool_t fGenerateSignal;
be9ef9f9	256	Bool_t fGeneratorOnly;
be9ef9f9	257	Bool_t fTabulatePairs;
95567836	258	Bool_t fLinearInterpolation;
42802bba	259	Bool_t fMixedChargeCut;
be9ef9f9	260	Int_t fRMax;
78c3bd48	261	Float_t fRstartMC;
be9ef9f9	262	Float_t ffcSq;
80507acf	263	Float_t ffcSqMRC;
be9ef9f9	264	UInt_t fFilterBit;
	265	Float_t fMaxChi2NDF;
	266	Int_t fMinTPCncls;
	267	Double_t fBfield;
	268	Int_t fMbin;
	269	Int_t fFSIindex;
	270	Int_t fEDbin;
	271	Int_t fMbins;
	272	Int_t fMultLimit;
	273	Int_t fCentBinLowLimit;
	274	Int_t fCentBinHighLimit;
0207c034	275	Int_t fTriggerType;
be9ef9f9	276	Int_t fEventCounter;
	277	Int_t fEventsToMix;
	278	Int_t fZvertexBins;
	279	Int_t fMultLimits[kMultBinspp+1];
42802bba	280	Float_t fMinPt;
42802bba	281	Float_t fMaxPt;
be9ef9f9	282	Float_t fQcut;
	283	Float_t fQLowerCut;
	284	Float_t fNormQcutLow;
	285	Float_t fNormQcutHigh;
	286	Float_t fKupperBound;
	287	Float_t fQupperBoundQ2;
	288	Float_t fQupperBoundQ3;
	289	Float_t fQupperBoundQ4;
	290	Float_t fQbinsQ2;
	291	Float_t fQbinsQ3;
	292	Float_t fQbinsQ4;
	293	Float_t fQupperBoundWeights;
78c3bd48	294	Float_t fQbinsQinv3D;
78c3bd48	295	Float_t fQupperBoundQinv3D;
be9ef9f9	296	Float_t fKstepT[fKbinsT];
	297	Float_t fKstepY[fKbinsY];
	298	Float_t fKmeanT[fKbinsT];
	299	Float_t fKmeanY[fKbinsY];
	300	Float_t fKmiddleT[fKbinsT];
	301	Float_t fKmiddleY[fKbinsY];
	302	Float_t fQstep;
	303	Float_t fQstepWeights;
	304	Float_t fQmean[kQbinsWeights];
	305	Float_t fDampStart;
	306	Float_t fDampStep;
	307
	308	Float_t fTPCTOFboundry;
	309	Float_t fTOFboundry;
	310	Float_t fSigmaCutTPC;
	311	Float_t fSigmaCutTOF;
	312
	313	Float_t fMinSepPairEta;
	314	Float_t fMinSepPairPhi;
	315	Float_t fShareQuality;
	316	Float_t fShareFraction;
	317
	318	Float_t fTrueMassP, fTrueMassPi, fTrueMassK, fTrueMassKs, fTrueMassLam;
	319
	320	Int_t fKtIndexL,fKtIndexH;
	321	//
	322	Int_t fQoIndexL,fQoIndexH;
	323	Int_t fQsIndexL,fQsIndexH;
	324	Int_t fQlIndexL,fQlIndexH;
	325
	326	Bool_t fDummyB;
	327
	328	Float_t fKT3transition;
	329	Float_t fKT4transition;
	330
95567836	331	Float_t farrP1[4][4][4];
95567836	332	Float_t farrP2[4][4][4];
b71263d0	333
2b6fd022	334
b71263d0	335	//
	336	Char_t fDefaultsCharSwitch[kMultLimitPbPb];//!
	337	TArrayC *fLowQPairSwitch_E0E0[kMultLimitPbPb];//!
	338	TArrayC *fLowQPairSwitch_E0E1[kMultLimitPbPb];//!
	339	TArrayC *fLowQPairSwitch_E0E2[kMultLimitPbPb];//!
	340	TArrayC *fLowQPairSwitch_E0E3[kMultLimitPbPb];//!
6bb6954b	341	TArrayC *fLowQPairSwitch_E1E1[kMultLimitPbPb];//!
b71263d0	342	TArrayC *fLowQPairSwitch_E1E2[kMultLimitPbPb];//!
	343	TArrayC *fLowQPairSwitch_E1E3[kMultLimitPbPb];//!
	344	TArrayC *fLowQPairSwitch_E2E3[kMultLimitPbPb];//!
	345	//
	346	TArrayC *fNormQPairSwitch_E0E0[kMultLimitPbPb];//!
	347	TArrayC *fNormQPairSwitch_E0E1[kMultLimitPbPb];//!
	348	TArrayC *fNormQPairSwitch_E0E2[kMultLimitPbPb];//!
	349	TArrayC *fNormQPairSwitch_E0E3[kMultLimitPbPb];//!
6bb6954b	350	TArrayC *fNormQPairSwitch_E1E1[kMultLimitPbPb];//!
b71263d0	351	TArrayC *fNormQPairSwitch_E1E2[kMultLimitPbPb];//!
	352	TArrayC *fNormQPairSwitch_E1E3[kMultLimitPbPb];//!
	353	TArrayC *fNormQPairSwitch_E2E3[kMultLimitPbPb];//!
	354
ebd00f1b	355
be9ef9f9	356
be9ef9f9	357	public:
80507acf	358	TH2D *fMomResC2SC;
80507acf	359	TH2D *fMomResC2MC;
5591748e	360	TH2D *fWeightmuonCorrection;
55e482b6	361	TH3D *fPbPbc3FitEA;
	362	TH3D *fpPbc3FitEA;
	363	TH3D *fppc3FitEA;
be9ef9f9	364	TH1D *fFSIss[12];
	365	TH1D *fFSIos[12];
	366	TH3F *fNormWeight[fKbinsT][fCentBins];
ebd00f1b	367	TF1 *ExchangeAmpPointSource[2][50];
be9ef9f9	368
	369	ClassDef(AliFourPion, 1);
	370	};
	371
	372	#endif