[u/mrichter/AliRoot.git] / PWG / FLOW / Tasks / AliAnalysisTaskQCumulants.h

/* 
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. 
 * See cxx source for full Copyright notice 
 * $Id$ 
 */

/**************************************
 * analysis task for Q-cumulants      * 
 *                                    * 
 * authors: Naomi van der Kolk        *
 *           (kolk@nikhef.nl)         *  
 *          Raimond Snellings         *
 *           (snelling@nikhef.nl)     * 
 *          Ante Bilandzic            *
 *           (anteb@nikhef.nl)        * 
 * ***********************************/

#ifndef ALIANALYSISTASKQCUMULANTS_H
#define ALIANALYSISTASKQCUMULANTS_H

#include "AliAnalysisTaskSE.h"
#include "AliFlowCommonConstants.h"

class TString;
class TList;
class AliFlowEventSimple;
class AliFlowAnalysisWithQCumulants;

//================================================================================================================

class AliAnalysisTaskQCumulants : public AliAnalysisTaskSE{
 public:
  AliAnalysisTaskQCumulants();
  AliAnalysisTaskQCumulants(const char *name, Bool_t useParticleWeights=kFALSE);
  virtual ~AliAnalysisTaskQCumulants(){}; 
  
  virtual void UserCreateOutputObjects();
  virtual void UserExec(Option_t *option);
  virtual void Terminate(Option_t *);
  
  // Common:
  void SetBookOnlyBasicCCH(Bool_t const bobcch) {this->fBookOnlyBasicCCH = bobcch;};
  Bool_t GetBookOnlyBasicCCH() const {return this->fBookOnlyBasicCCH;};  
  void SetFillMultipleControlHistograms(Bool_t const fmch) {this->fFillMultipleControlHistograms = fmch;};
  Bool_t GetFillMultipleControlHistograms() const {return this->fFillMultipleControlHistograms;}; 
  void SetHarmonic(Int_t const harmonic) {this->fHarmonic = harmonic;};
  Int_t GetHarmonic() const {return this->fHarmonic;};
  void SetApplyCorrectionForNUA(Bool_t const applyCorrectionForNUA) {this->fApplyCorrectionForNUA = applyCorrectionForNUA;};
  Bool_t GetApplyCorrectionForNUA() const {return this->fApplyCorrectionForNUA;};
  void SetApplyCorrectionForNUAVsM(Bool_t const applyCorrectionForNUAVsM) {this->fApplyCorrectionForNUAVsM = applyCorrectionForNUAVsM;};
  Bool_t GetApplyCorrectionForNUAVsM() const {return this->fApplyCorrectionForNUAVsM;};      
  void SetPropagateErrorAlsoFromNIT(Bool_t const peafNIT) {this->fPropagateErrorAlsoFromNIT = peafNIT;};
  Bool_t GetPropagateErrorAlsoFromNIT() const {return this->fPropagateErrorAlsoFromNIT;};  
  void SetCalculateDiffFlow(Bool_t const calculateDiffFlow) {this->fCalculateDiffFlow = calculateDiffFlow;};
  Bool_t GetCalculateDiffFlow() const {return this->fCalculateDiffFlow;};
  void SetCalculate2DDiffFlow(Bool_t const calculate2DDiffFlow) {this->fCalculate2DDiffFlow = calculate2DDiffFlow;};
  Bool_t GetCalculate2DDiffFlow() const {return this->fCalculate2DDiffFlow;};
  void SetCalculateDiffFlowVsEta(Bool_t const cdfve) {this->fCalculateDiffFlowVsEta = cdfve;};
  Bool_t GetCalculateDiffFlowVsEta() const {return this->fCalculateDiffFlowVsEta;};  
  void SetStoreDistributions(Bool_t const storeDistributions) {this->fStoreDistributions = storeDistributions;};
  Bool_t GetStoreDistributions() const {return this->fStoreDistributions;};
  void SetCalculateCumulantsVsM(Bool_t const ccvm) {this->fCalculateCumulantsVsM = ccvm;};
  Bool_t GetCalculateCumulantsVsM() const {return this->fCalculateCumulantsVsM;};
  void SetCalculateAllCorrelationsVsM(Bool_t const cacvm) {this->fCalculateAllCorrelationsVsM = cacvm;};
  Bool_t GetCalculateAllCorrelationsVsM() const {return this->fCalculateAllCorrelationsVsM;}; 
  void SetCalculateMixedHarmonics(Bool_t const cmh) {this->fCalculateMixedHarmonics = cmh;};
  Bool_t GetCalculateMixedHarmonics() const {return this->fCalculateMixedHarmonics;};   
  void SetCalculateMixedHarmonicsVsM(Bool_t const cmhvm) {this->fCalculateMixedHarmonicsVsM = cmhvm;};
  Bool_t GetCalculateMixedHarmonicsVsM() const {return this->fCalculateMixedHarmonicsVsM;}; 
  void SetStoreControlHistograms(Bool_t const sch) {this->fStoreControlHistograms = sch;};
  Bool_t GetStoreControlHistograms() const {return this->fStoreControlHistograms;};
  void SetMinimumBiasReferenceFlow(Bool_t const mmrf) {this->fMinimumBiasReferenceFlow = mmrf;};
  Bool_t GetMinimumBiasReferenceFlow() const {return this->fMinimumBiasReferenceFlow;};     
  void SetForgetAboutCovariances(Bool_t const fac) {this->fForgetAboutCovariances = fac;};
  Bool_t GetForgetAboutCovariances() const {return this->fForgetAboutCovariances;};   
  void SetStorePhiDistributionForOneEvent(Bool_t const spdfoe) {this->fStorePhiDistributionForOneEvent = spdfoe;};
  Bool_t GetStorePhiDistributionForOneEvent() const {return this->fStorePhiDistributionForOneEvent;};
  void SetPhiDistributionForOneEventSettings(Double_t const pdfoes, Int_t const i) {this->fPhiDistributionForOneEventSettings[i] = pdfoes;};
  Double_t GetPhiDistributionForOneEventSettings(Int_t const i) const {return this->fPhiDistributionForOneEventSettings[i];};  
  void SetExactNoRPs(Int_t const enr) {this->fExactNoRPs = enr;};
  Int_t GetExactNoRPs() const {return this->fExactNoRPs;}; 
  void SetUse2DHistograms(Bool_t const u2dh){this->fUse2DHistograms = u2dh;if(u2dh){this->fStoreControlHistograms = kTRUE;}};
  Bool_t GetUse2DHistograms() const {return this->fUse2DHistograms;};
  void SetFillProfilesVsMUsingWeights(Bool_t const fpvmuw){this->fFillProfilesVsMUsingWeights = fpvmuw;};
  Bool_t GetFillProfilesVsMUsingWeights() const {return this->fFillProfilesVsMUsingWeights;};
  void SetUseQvectorTerms(Bool_t const uqvt){this->fUseQvectorTerms = uqvt;if(uqvt){this->fStoreControlHistograms = kTRUE;}};
  Bool_t GetUseQvectorTerms() const {return this->fUseQvectorTerms;};
 
  // Multiparticle correlations vs multiplicity:
  void SetnBinsMult(Int_t const nbm) {this->fnBinsMult = nbm;};
  Int_t GetnBinsMult() const {return this->fnBinsMult;};  
  void SetMinMult(Double_t const minm) {this->fMinMult = minm;};
  Double_t GetMinMult() const {return this->fMinMult;};
  void SetMaxMult(Double_t const maxm) {this->fMaxMult = maxm;};
  Double_t GetMaxMult() const {return this->fMaxMult;};
  // Particle weights:
  void SetUsePhiWeights(Bool_t const uPhiW) {this->fUsePhiWeights = uPhiW;};
  Bool_t GetUsePhiWeights() const {return this->fUsePhiWeights;};
  void SetUsePtWeights(Bool_t const uPtW) {this->fUsePtWeights = uPtW;};
  Bool_t GetUsePtWeights() const {return this->fUsePtWeights;};
  void SetUseEtaWeights(Bool_t const uEtaW) {this->fUseEtaWeights = uEtaW;};
  Bool_t GetUseEtaWeights() const {return this->fUseEtaWeights;};
  void SetUseTrackWeights(Bool_t const uTrackW) {this->fUseTrackWeights = uTrackW;};
  Bool_t GetUseTrackWeights() const {return this->fUseTrackWeights;};
  // Event weights:
  void SetMultiplicityWeight(const char *multiplicityWeight) {*this->fMultiplicityWeight = multiplicityWeight;};
  void SetMultiplicityIs(AliFlowCommonConstants::ERefMultSource mi) {this->fMultiplicityIs = mi;};
  // # of bins for correlation axis in fDistributions[4], fCorrelation2468VsMult[4] and fCorrelationProduct2468VsMult[1]
  void SetnBinsForCorrelations(Int_t const nb) {this->fnBinsForCorrelations = nb;};
  Int_t GetnBinsForCorrelations() const {return this->fnBinsForCorrelations;};
  // Boundaries for distributions of correlations:
  void SetMinValueOfCorrelation(Int_t const ci, Double_t const minValue) {this->fMinValueOfCorrelation[ci] = minValue;};
  Double_t GetMinValueOfCorrelation(Int_t ci) const {return this->fMinValueOfCorrelation[ci];};
  void SetMaxValueOfCorrelation(Int_t const ci, Double_t const maxValue) {this->fMaxValueOfCorrelation[ci] = maxValue;};
  Double_t GetMaxValueOfCorrelation(Int_t ci) const {return this->fMaxValueOfCorrelation[ci];};
  // min and max values of correlation products:
  void SetMinValueOfCorrelationProduct(Int_t const cpi, Double_t const minValue) {this->fMinValueOfCorrelationProduct[cpi] = minValue;};
  Double_t GetMinValueOfCorrelationProduct(Int_t cpi) const {return this->fMinValueOfCorrelationProduct[cpi];};
  void SetMaxValueOfCorrelationProduct(Int_t const cpi, Double_t const maxValue) {this->fMaxValueOfCorrelationProduct[cpi] = maxValue;};
  Double_t GetMaxValueOfCorrelationProduct(Int_t cpi) const {return this->fMaxValueOfCorrelationProduct[cpi];};
  // min and max values of QvectorTerms:
  void SetMinValueOfQvectorTerms(Int_t const qvti, Double_t const minValue) {this->fMinValueOfQvectorTerms[qvti] = minValue;};
  Double_t GetMinValueOfQvectorTerms(Int_t qvti) const {return this->fMinValueOfQvectorTerms[qvti];};
  void SetMaxValueOfQvectorTerms(Int_t const qvti, Double_t const maxValue) {this->fMaxValueOfQvectorTerms[qvti] = maxValue;};
  Double_t GetMaxValueOfQvectorTerms(Int_t qvti) const {return this->fMaxValueOfQvectorTerms[qvti];};
  // bootstrap:
  void SetUseBootstrap(Bool_t const ub) {this->fUseBootstrap = ub;};
  Bool_t GetUseBootstrap() const {return this->fUseBootstrap;};
  void SetUseBootstrapVsM(Bool_t const ubVsM) {this->fUseBootstrapVsM = ubVsM;};
  Bool_t GetUseBootstrapVsM() const {return this->fUseBootstrapVsM;};
  void SetnSubsamples(Int_t const ns) {this->fnSubsamples = ns;};
  Int_t GetnSubsamples() const {return this->fnSubsamples;};

 private:
  AliAnalysisTaskQCumulants(const AliAnalysisTaskQCumulants& aatqc);
  AliAnalysisTaskQCumulants& operator=(const AliAnalysisTaskQCumulants& aatqc);
  
  AliFlowEventSimple *fEvent;         // the input event
  AliFlowAnalysisWithQCumulants *fQC; // Q-cumulant object
  TList *fListHistos;                 // collection of output 
  // Common:
  Bool_t fBookOnlyBasicCCH;              // book only basis common control histrograms (by default book them all) 
  Bool_t fFillMultipleControlHistograms; // fill separately control histos for events with >= 2, 4, 6 and 8 particles
  Int_t fHarmonic;                       // harmonic  
  Bool_t fApplyCorrectionForNUA;         // apply correction for non-uniform acceptance 
  Bool_t fApplyCorrectionForNUAVsM;      // apply correction for non-uniform acceptance versus M    
  Bool_t fPropagateErrorAlsoFromNIT;     // propagate error by taking into account also non-isotrpic terms  
  Bool_t fCalculateDiffFlow;             // calculate differential flow in pt or eta
  Bool_t fCalculate2DDiffFlow;           // calculate differential flow in (pt,eta) (Remark: this is very expensive in terms of CPU time)
  Bool_t fCalculateDiffFlowVsEta;        // if you set kFALSE only differential flow vs pt is calculated  
  Bool_t fStoreDistributions;            // store or not distributions of correlations
  Bool_t fCalculateCumulantsVsM;         // calculate cumulants versus multiplicity  
  Bool_t fCalculateAllCorrelationsVsM;   // calculate all correlations versus multiplicity   
  Bool_t fCalculateMixedHarmonics;       // calculate all mixed harmonics correlations     
  Bool_t fCalculateMixedHarmonicsVsM;    // calculate all mixed harmonics correlations versus multiplicity 
  Bool_t fStoreControlHistograms;        // store or not control histograms
  Bool_t fMinimumBiasReferenceFlow;      // store as reference flow in AliFlowCommonHistResults the minimum bias result (kFALSE by default)     
  Bool_t fForgetAboutCovariances;        // when propagating error forget about the covariances  
  Bool_t fStorePhiDistributionForOneEvent; // store phi distribution for one event to illustrate flow
  Double_t fPhiDistributionForOneEventSettings[4]; // [v_min,v_max,refMult_min,refMult_max]
  Int_t fExactNoRPs;                     // when shuffled, select only this number of RPs for the analysis 
  Bool_t fUse2DHistograms;               // use TH2D instead of TProfile to improve numerical stability in reference flow calculation   
  Bool_t fFillProfilesVsMUsingWeights;   // if the width of multiplicity bin is 1, weights are not needed   
  Bool_t fUseQvectorTerms; // use TH2D with separate Q-vector terms instead of TProfile to improve numerical stability in reference flow calculation    
  // Multiparticle correlations vs multiplicity:
  Int_t fnBinsMult;                   // number of multiplicity bins for flow analysis versus multiplicity  
  Double_t fMinMult;                  // minimal multiplicity for flow analysis versus multiplicity  
  Double_t fMaxMult;                  // maximal multiplicity for flow analysis versus multiplicity    
  // Particle weights:
  Bool_t fUseParticleWeights;         // use any particle weights
  Bool_t fUsePhiWeights;              // use phi weights
  Bool_t fUsePtWeights;               // use pt weights
  Bool_t fUseEtaWeights;              // use eta weights  
  Bool_t fUseTrackWeights;            // use track weights (e.g. VZERO sector weights)  
  TList *fWeightsList;                // list with weights
  // Event weights:
  TString *fMultiplicityWeight;       // event-by-event weights for multiparticle correlations ("combinations","unit" or "multiplicity")  
  AliFlowCommonConstants::ERefMultSource fMultiplicityIs;           // by default "#RPs", other supported options are "RefMultFromESD" = ref. mult. from ESD, and "#POIs"
  Int_t fnBinsForCorrelations; // # of bins for correlation axis in fDistributions[4], fCorrelation2468VsMult[4] and fCorrelationProduct2468VsMult[1]
  // Boundaries for distributions of correlations:
  Double_t fMinValueOfCorrelation[4]; // min values of <2>, <4>, <6> and <8>
  Double_t fMaxValueOfCorrelation[4]; // max values of <2>, <4>, <6> and <8>
  Double_t fMinValueOfCorrelationProduct[1]; // min values of <2><4>, <2><6>, <2><8>, <4><6> etc. TBI add the other ones when needed first time
  Double_t fMaxValueOfCorrelationProduct[1]; // max values of <2><4>, <2><6>, <2><8>, <4><6> etc. TBI add the other ones when needed first time
  Double_t fMinValueOfQvectorTerms[4]; // min value of Q-vector terms
  Double_t fMaxValueOfQvectorTerms[4]; // max value of Q-vector terms
  // Bootstrap:
  Bool_t fUseBootstrap; // use bootstrap to estimate statistical spread
  Bool_t fUseBootstrapVsM; // use bootstrap to estimate statistical spread for results vs M
  Int_t fnSubsamples; // number of subsamples (SS), by default 10
  
  ClassDef(AliAnalysisTaskQCumulants, 2); 
};

//================================================================================================================

#endif
Commit	Line	Data
bc92c0cb	1	/*
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved.
	3	* See cxx source for full Copyright notice
	4	* $Id$
	5	*/
	6
	7	/**************************************
	8	* analysis task for Q-cumulants *
	9	* *
	10	* authors: Naomi van der Kolk *
	11	* (kolk@nikhef.nl) *
	12	* Raimond Snellings *
	13	* (snelling@nikhef.nl) *
	14	* Ante Bilandzic *
	15	* (anteb@nikhef.nl) *
	16	* ***********************************/
	17
52021ae2	18	#ifndef ALIANALYSISTASKQCUMULANTS_H
52021ae2	19	#define ALIANALYSISTASKQCUMULANTS_H
bc92c0cb	20
2ed70edf	21	#include "AliAnalysisTaskSE.h"
df23c5ae	22	#include "AliFlowCommonConstants.h"
bc92c0cb	23
2701c4bc	24	class TString;
2ed70edf	25	class TList;
2ed70edf	26	class AliFlowEventSimple;
bc92c0cb	27	class AliFlowAnalysisWithQCumulants;
bc92c0cb	28
	29	//================================================================================================================
	30
2ed70edf	31	class AliAnalysisTaskQCumulants : public AliAnalysisTaskSE{
bc92c0cb	32	public:
bc92c0cb	33	AliAnalysisTaskQCumulants();
2ed70edf	34	AliAnalysisTaskQCumulants(const char *name, Bool_t useParticleWeights=kFALSE);
bc92c0cb	35	virtual ~AliAnalysisTaskQCumulants(){};
bc92c0cb	36
b3dacf6b	37	virtual void UserCreateOutputObjects();
	38	virtual void UserExec(Option_t *option);
	39	virtual void Terminate(Option_t *);
bc92c0cb	40
b3dacf6b	41	// Common:
62d19320	42	void SetBookOnlyBasicCCH(Bool_t const bobcch) {this->fBookOnlyBasicCCH = bobcch;};
62d19320	43	Bool_t GetBookOnlyBasicCCH() const {return this->fBookOnlyBasicCCH;};
dd442cd2	44	void SetFillMultipleControlHistograms(Bool_t const fmch) {this->fFillMultipleControlHistograms = fmch;};
dd442cd2	45	Bool_t GetFillMultipleControlHistograms() const {return this->fFillMultipleControlHistograms;};
2ed70edf	46	void SetHarmonic(Int_t const harmonic) {this->fHarmonic = harmonic;};
	47	Int_t GetHarmonic() const {return this->fHarmonic;};
	48	void SetApplyCorrectionForNUA(Bool_t const applyCorrectionForNUA) {this->fApplyCorrectionForNUA = applyCorrectionForNUA;};
	49	Bool_t GetApplyCorrectionForNUA() const {return this->fApplyCorrectionForNUA;};
050c0a54	50	void SetApplyCorrectionForNUAVsM(Bool_t const applyCorrectionForNUAVsM) {this->fApplyCorrectionForNUAVsM = applyCorrectionForNUAVsM;};
050c0a54	51	Bool_t GetApplyCorrectionForNUAVsM() const {return this->fApplyCorrectionForNUAVsM;};
b77b6434	52	void SetPropagateErrorAlsoFromNIT(Bool_t const peafNIT) {this->fPropagateErrorAlsoFromNIT = peafNIT;};
b77b6434	53	Bool_t GetPropagateErrorAlsoFromNIT() const {return this->fPropagateErrorAlsoFromNIT;};
1268c371	54	void SetCalculateDiffFlow(Bool_t const calculateDiffFlow) {this->fCalculateDiffFlow = calculateDiffFlow;};
	55	Bool_t GetCalculateDiffFlow() const {return this->fCalculateDiffFlow;};
	56	void SetCalculate2DDiffFlow(Bool_t const calculate2DDiffFlow) {this->fCalculate2DDiffFlow = calculate2DDiffFlow;};
	57	Bool_t GetCalculate2DDiffFlow() const {return this->fCalculate2DDiffFlow;};
62e36168	58	void SetCalculateDiffFlowVsEta(Bool_t const cdfve) {this->fCalculateDiffFlowVsEta = cdfve;};
62e36168	59	Bool_t GetCalculateDiffFlowVsEta() const {return this->fCalculateDiffFlowVsEta;};
2ed70edf	60	void SetStoreDistributions(Bool_t const storeDistributions) {this->fStoreDistributions = storeDistributions;};
2ed70edf	61	Bool_t GetStoreDistributions() const {return this->fStoreDistributions;};
b3dacf6b	62	void SetCalculateCumulantsVsM(Bool_t const ccvm) {this->fCalculateCumulantsVsM = ccvm;};
0dd3b008	63	Bool_t GetCalculateCumulantsVsM() const {return this->fCalculateCumulantsVsM;};
3435cacb	64	void SetCalculateAllCorrelationsVsM(Bool_t const cacvm) {this->fCalculateAllCorrelationsVsM = cacvm;};
3842bdcd	65	Bool_t GetCalculateAllCorrelationsVsM() const {return this->fCalculateAllCorrelationsVsM;};
8f0fcf13	66	void SetCalculateMixedHarmonics(Bool_t const cmh) {this->fCalculateMixedHarmonics = cmh;};
	67	Bool_t GetCalculateMixedHarmonics() const {return this->fCalculateMixedHarmonics;};
	68	void SetCalculateMixedHarmonicsVsM(Bool_t const cmhvm) {this->fCalculateMixedHarmonicsVsM = cmhvm;};
df23c5ae	69	Bool_t GetCalculateMixedHarmonicsVsM() const {return this->fCalculateMixedHarmonicsVsM;};
	70	void SetStoreControlHistograms(Bool_t const sch) {this->fStoreControlHistograms = sch;};
	71	Bool_t GetStoreControlHistograms() const {return this->fStoreControlHistograms;};
0dd3b008	72	void SetMinimumBiasReferenceFlow(Bool_t const mmrf) {this->fMinimumBiasReferenceFlow = mmrf;};
8e1cefdd	73	Bool_t GetMinimumBiasReferenceFlow() const {return this->fMinimumBiasReferenceFlow;};
8e1cefdd	74	void SetForgetAboutCovariances(Bool_t const fac) {this->fForgetAboutCovariances = fac;};
e5834fcb	75	Bool_t GetForgetAboutCovariances() const {return this->fForgetAboutCovariances;};
	76	void SetStorePhiDistributionForOneEvent(Bool_t const spdfoe) {this->fStorePhiDistributionForOneEvent = spdfoe;};
	77	Bool_t GetStorePhiDistributionForOneEvent() const {return this->fStorePhiDistributionForOneEvent;};
	78	void SetPhiDistributionForOneEventSettings(Double_t const pdfoes, Int_t const i) {this->fPhiDistributionForOneEventSettings[i] = pdfoes;};
	79	Double_t GetPhiDistributionForOneEventSettings(Int_t const i) const {return this->fPhiDistributionForOneEventSettings[i];};
d9e6d8bb	80	void SetExactNoRPs(Int_t const enr) {this->fExactNoRPs = enr;};
d9e6d8bb	81	Int_t GetExactNoRPs() const {return this->fExactNoRPs;};
1db7eced	82	void SetUse2DHistograms(Bool_t const u2dh){this->fUse2DHistograms = u2dh;if(u2dh){this->fStoreControlHistograms = kTRUE;}};
	83	Bool_t GetUse2DHistograms() const {return this->fUse2DHistograms;};
	84	void SetFillProfilesVsMUsingWeights(Bool_t const fpvmuw){this->fFillProfilesVsMUsingWeights = fpvmuw;};
	85	Bool_t GetFillProfilesVsMUsingWeights() const {return this->fFillProfilesVsMUsingWeights;};
	86	void SetUseQvectorTerms(Bool_t const uqvt){this->fUseQvectorTerms = uqvt;if(uqvt){this->fStoreControlHistograms = kTRUE;}};
	87	Bool_t GetUseQvectorTerms() const {return this->fUseQvectorTerms;};
e5834fcb	88
b3dacf6b	89	// Multiparticle correlations vs multiplicity:
067e9bc8	90	void SetnBinsMult(Int_t const nbm) {this->fnBinsMult = nbm;};
	91	Int_t GetnBinsMult() const {return this->fnBinsMult;};
	92	void SetMinMult(Double_t const minm) {this->fMinMult = minm;};
	93	Double_t GetMinMult() const {return this->fMinMult;};
	94	void SetMaxMult(Double_t const maxm) {this->fMaxMult = maxm;};
	95	Double_t GetMaxMult() const {return this->fMaxMult;};
b3dacf6b	96	// Particle weights:
e04e4ec5	97	void SetUsePhiWeights(Bool_t const uPhiW) {this->fUsePhiWeights = uPhiW;};
	98	Bool_t GetUsePhiWeights() const {return this->fUsePhiWeights;};
	99	void SetUsePtWeights(Bool_t const uPtW) {this->fUsePtWeights = uPtW;};
	100	Bool_t GetUsePtWeights() const {return this->fUsePtWeights;};
	101	void SetUseEtaWeights(Bool_t const uEtaW) {this->fUseEtaWeights = uEtaW;};
	102	Bool_t GetUseEtaWeights() const {return this->fUseEtaWeights;};
403e3389	103	void SetUseTrackWeights(Bool_t const uTrackW) {this->fUseTrackWeights = uTrackW;};
403e3389	104	Bool_t GetUseTrackWeights() const {return this->fUseTrackWeights;};
b3dacf6b	105	// Event weights:
2ed70edf	106	void SetMultiplicityWeight(const char multiplicityWeight) {this->fMultiplicityWeight = multiplicityWeight;};
df23c5ae	107	void SetMultiplicityIs(AliFlowCommonConstants::ERefMultSource mi) {this->fMultiplicityIs = mi;};
1db7eced	108	// # of bins for correlation axis in fDistributions[4], fCorrelation2468VsMult[4] and fCorrelationProduct2468VsMult[1]
	109	void SetnBinsForCorrelations(Int_t const nb) {this->fnBinsForCorrelations = nb;};
	110	Int_t GetnBinsForCorrelations() const {return this->fnBinsForCorrelations;};
d9e6d8bb	111	// Boundaries for distributions of correlations:
	112	void SetMinValueOfCorrelation(Int_t const ci, Double_t const minValue) {this->fMinValueOfCorrelation[ci] = minValue;};
	113	Double_t GetMinValueOfCorrelation(Int_t ci) const {return this->fMinValueOfCorrelation[ci];};
	114	void SetMaxValueOfCorrelation(Int_t const ci, Double_t const maxValue) {this->fMaxValueOfCorrelation[ci] = maxValue;};
	115	Double_t GetMaxValueOfCorrelation(Int_t ci) const {return this->fMaxValueOfCorrelation[ci];};
1db7eced	116	// min and max values of correlation products:
	117	void SetMinValueOfCorrelationProduct(Int_t const cpi, Double_t const minValue) {this->fMinValueOfCorrelationProduct[cpi] = minValue;};
	118	Double_t GetMinValueOfCorrelationProduct(Int_t cpi) const {return this->fMinValueOfCorrelationProduct[cpi];};
	119	void SetMaxValueOfCorrelationProduct(Int_t const cpi, Double_t const maxValue) {this->fMaxValueOfCorrelationProduct[cpi] = maxValue;};
	120	Double_t GetMaxValueOfCorrelationProduct(Int_t cpi) const {return this->fMaxValueOfCorrelationProduct[cpi];};
a6547379	121	// min and max values of QvectorTerms:
	122	void SetMinValueOfQvectorTerms(Int_t const qvti, Double_t const minValue) {this->fMinValueOfQvectorTerms[qvti] = minValue;};
	123	Double_t GetMinValueOfQvectorTerms(Int_t qvti) const {return this->fMinValueOfQvectorTerms[qvti];};
	124	void SetMaxValueOfQvectorTerms(Int_t const qvti, Double_t const maxValue) {this->fMaxValueOfQvectorTerms[qvti] = maxValue;};
	125	Double_t GetMaxValueOfQvectorTerms(Int_t qvti) const {return this->fMaxValueOfQvectorTerms[qvti];};
	126	// bootstrap:
	127	void SetUseBootstrap(Bool_t const ub) {this->fUseBootstrap = ub;};
	128	Bool_t GetUseBootstrap() const {return this->fUseBootstrap;};
	129	void SetUseBootstrapVsM(Bool_t const ubVsM) {this->fUseBootstrapVsM = ubVsM;};
	130	Bool_t GetUseBootstrapVsM() const {return this->fUseBootstrapVsM;};
	131	void SetnSubsamples(Int_t const ns) {this->fnSubsamples = ns;};
	132	Int_t GetnSubsamples() const {return this->fnSubsamples;};
d9e6d8bb	133
bc92c0cb	134	private:
	135	AliAnalysisTaskQCumulants(const AliAnalysisTaskQCumulants& aatqc);
	136	AliAnalysisTaskQCumulants& operator=(const AliAnalysisTaskQCumulants& aatqc);
e04e4ec5	137
2ed70edf	138	AliFlowEventSimple *fEvent; // the input event
	139	AliFlowAnalysisWithQCumulants *fQC; // Q-cumulant object
	140	TList *fListHistos; // collection of output
b3dacf6b	141	// Common:
62d19320	142	Bool_t fBookOnlyBasicCCH; // book only basis common control histrograms (by default book them all)
dd442cd2	143	Bool_t fFillMultipleControlHistograms; // fill separately control histos for events with >= 2, 4, 6 and 8 particles
	144	Int_t fHarmonic; // harmonic
	145	Bool_t fApplyCorrectionForNUA; // apply correction for non-uniform acceptance
	146	Bool_t fApplyCorrectionForNUAVsM; // apply correction for non-uniform acceptance versus M
	147	Bool_t fPropagateErrorAlsoFromNIT; // propagate error by taking into account also non-isotrpic terms
1268c371	148	Bool_t fCalculateDiffFlow; // calculate differential flow in pt or eta
1268c371	149	Bool_t fCalculate2DDiffFlow; // calculate differential flow in (pt,eta) (Remark: this is very expensive in terms of CPU time)
62e36168	150	Bool_t fCalculateDiffFlowVsEta; // if you set kFALSE only differential flow vs pt is calculated
dd442cd2	151	Bool_t fStoreDistributions; // store or not distributions of correlations
dd442cd2	152	Bool_t fCalculateCumulantsVsM; // calculate cumulants versus multiplicity
3842bdcd	153	Bool_t fCalculateAllCorrelationsVsM; // calculate all correlations versus multiplicity
8f0fcf13	154	Bool_t fCalculateMixedHarmonics; // calculate all mixed harmonics correlations
df23c5ae	155	Bool_t fCalculateMixedHarmonicsVsM; // calculate all mixed harmonics correlations versus multiplicity
df23c5ae	156	Bool_t fStoreControlHistograms; // store or not control histograms
dd442cd2	157	Bool_t fMinimumBiasReferenceFlow; // store as reference flow in AliFlowCommonHistResults the minimum bias result (kFALSE by default)
dd442cd2	158	Bool_t fForgetAboutCovariances; // when propagating error forget about the covariances
e5834fcb	159	Bool_t fStorePhiDistributionForOneEvent; // store phi distribution for one event to illustrate flow
d9e6d8bb	160	Double_t fPhiDistributionForOneEventSettings[4]; // [v_min,v_max,refMult_min,refMult_max]
1db7eced	161	Int_t fExactNoRPs; // when shuffled, select only this number of RPs for the analysis
	162	Bool_t fUse2DHistograms; // use TH2D instead of TProfile to improve numerical stability in reference flow calculation
	163	Bool_t fFillProfilesVsMUsingWeights; // if the width of multiplicity bin is 1, weights are not needed
	164	Bool_t fUseQvectorTerms; // use TH2D with separate Q-vector terms instead of TProfile to improve numerical stability in reference flow calculation
b3dacf6b	165	// Multiparticle correlations vs multiplicity:
067e9bc8	166	Int_t fnBinsMult; // number of multiplicity bins for flow analysis versus multiplicity
	167	Double_t fMinMult; // minimal multiplicity for flow analysis versus multiplicity
	168	Double_t fMaxMult; // maximal multiplicity for flow analysis versus multiplicity
b3dacf6b	169	// Particle weights:
2ed70edf	170	Bool_t fUseParticleWeights; // use any particle weights
	171	Bool_t fUsePhiWeights; // use phi weights
	172	Bool_t fUsePtWeights; // use pt weights
	173	Bool_t fUseEtaWeights; // use eta weights
403e3389	174	Bool_t fUseTrackWeights; // use track weights (e.g. VZERO sector weights)
2ed70edf	175	TList *fWeightsList; // list with weights
b3dacf6b	176	// Event weights:
2ed70edf	177	TString *fMultiplicityWeight; // event-by-event weights for multiparticle correlations ("combinations","unit" or "multiplicity")
df23c5ae	178	AliFlowCommonConstants::ERefMultSource fMultiplicityIs; // by default "#RPs", other supported options are "RefMultFromESD" = ref. mult. from ESD, and "#POIs"
1db7eced	179	Int_t fnBinsForCorrelations; // # of bins for correlation axis in fDistributions[4], fCorrelation2468VsMult[4] and fCorrelationProduct2468VsMult[1]
d9e6d8bb	180	// Boundaries for distributions of correlations:
	181	Double_t fMinValueOfCorrelation[4]; // min values of <2>, <4>, <6> and <8>
	182	Double_t fMaxValueOfCorrelation[4]; // max values of <2>, <4>, <6> and <8>
1db7eced	183	Double_t fMinValueOfCorrelationProduct[1]; // min values of <2><4>, <2><6>, <2><8>, <4><6> etc. TBI add the other ones when needed first time
1db7eced	184	Double_t fMaxValueOfCorrelationProduct[1]; // max values of <2><4>, <2><6>, <2><8>, <4><6> etc. TBI add the other ones when needed first time
a6547379	185	Double_t fMinValueOfQvectorTerms[4]; // min value of Q-vector terms
	186	Double_t fMaxValueOfQvectorTerms[4]; // max value of Q-vector terms
	187	// Bootstrap:
	188	Bool_t fUseBootstrap; // use bootstrap to estimate statistical spread
	189	Bool_t fUseBootstrapVsM; // use bootstrap to estimate statistical spread for results vs M
	190	Int_t fnSubsamples; // number of subsamples (SS), by default 10
2ed70edf	191
a6547379	192	ClassDef(AliAnalysisTaskQCumulants, 2);
bc92c0cb	193	};
	194
	195	//================================================================================================================
	196
	197	#endif
	198
	199
	200
	201
	202
	203
	204
	205
	206
	207
	208