[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 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 = 11,
    kMCarrayLimit = 150000,// 110000
    kQbinsWeights = 40,
    kNDampValues = 16,
    kRmin = 5,// EW min radii 5 fm
    kDENtypes = 5,
  };

  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 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 *temp2D=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 SetMCdecision(Bool_t mc) {fMCcase = mc;}
  void SetTabulatePairs(Bool_t tabulate) {fTabulatePairs = tabulate;}
  void SetPbPbCase(Bool_t pbpb) {fPbPbcase = pbpb;}
  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;}
  //


 private:

  void ParInit();
  Bool_t AcceptPair(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);
  //
  
  
  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; //!
    TProfile *fKfactor; //!
    TProfile *fMeanQinv; //!
    TH2D *fIdeal; //!
    TH2D *fSmeared; //!
    //
    TH3D *fMuonSmeared; //!
    TH3D *fMuonIdeal; //!
    TH3D *fMuonPionK3; //!
    TH3D *fPionPionK3; //!
    //
    TH2D *fTwoPartNorm; //!
    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; //!
    TH2D *fIdeal; //!
    TH2D *fSmeared; //!
    //
    TH3D *fMuonSmeared; //!
    TH3D *fMuonIdeal; //!
    TH3D *fMuonPionK4; //!
    TH3D *fPionPionK4; //!
    //
    TH2D *fTwoPartNorm; //!
    TH2D *fTwoPartNormErr; //!
  };
  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;
  Bool_t fPbPbcase;
  Bool_t fGenerateSignal;
  Bool_t fGeneratorOnly;
  Bool_t fPdensityPairCut;
  Bool_t fTabulatePairs;
  Int_t fRMax;
  Float_t ffcSq;
  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 fEventCounter;
  Int_t fEventsToMix;
  Int_t fZvertexBins;
  Int_t fMultLimits[kMultBinspp+1];
  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 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;
  
  
  /* bool LowQPairSwitch_E0E0[kMultLimitPbPb][kMultLimitPbPb];//!
  bool LowQPairSwitch_E0E1[kMultLimitPbPb][kMultLimitPbPb];//!
  bool LowQPairSwitch_E0E2[kMultLimitPbPb][kMultLimitPbPb];//!
  bool LowQPairSwitch_E0E3[kMultLimitPbPb][kMultLimitPbPb];//!
  bool LowQPairSwitch_E1E2[kMultLimitPbPb][kMultLimitPbPb];//!
  bool LowQPairSwitch_E1E3[kMultLimitPbPb][kMultLimitPbPb];//!
  bool LowQPairSwitch_E2E3[kMultLimitPbPb][kMultLimitPbPb];//!
  //
  bool NormQPairSwitch_E0E0[kMultLimitPbPb][kMultLimitPbPb];//!
  bool NormQPairSwitch_E0E1[kMultLimitPbPb][kMultLimitPbPb];//!
  bool NormQPairSwitch_E0E2[kMultLimitPbPb][kMultLimitPbPb];//!
  bool NormQPairSwitch_E0E3[kMultLimitPbPb][kMultLimitPbPb];//!
  bool NormQPairSwitch_E1E2[kMultLimitPbPb][kMultLimitPbPb];//!
  bool NormQPairSwitch_E1E3[kMultLimitPbPb][kMultLimitPbPb];//!
  bool NormQPairSwitch_E2E3[kMultLimitPbPb][kMultLimitPbPb];//!
  */
  //
  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 *fMomResC2;
  TH2D *fWeightmuonCorrection;
  TH1D *fFSIss[12];
  TH1D *fFSIos[12];
  TH3F *fNormWeight[fKbinsT][fCentBins];
 

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