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

/////////////////////////////////////////////////////
// AliAnalysisTaskFlowStrange:
// Analysis task to select K0/Lambda candidates for flow analysis.
// Authors: Cristian Ivan (civan@cern.ch)
//          Carlos Perez (cperez@cern.ch)
//          Pawel Debski (pdebski@cern.ch)
//////////////////////////////////////////////////////

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

#ifndef AliAnalysisTaskFlowStrange_H
#define AliAnalysisTaskFlowStrange_H

#include "AliAnalysisTaskSE.h"

class TList;
class TH2D;
class TObjArray;
class TClonesArray;
class AliAODMCParticle;
class AliESDtrackCuts;
class AliFlowEventCuts;
class AliPIDResponse;
class AliESDEvent;
class AliAODEvent;
class AliAODv0;
class AliESDv0;
class AliVVertex;
class AliFlowBayesianPID;
class AliAODVertex;

class AliAnalysisTaskFlowStrange : public AliAnalysisTaskSE {
 public:
  enum Especie {kKZE=0,kLDA=1,kLDABAR=2,kLDAALL=3,kCHARGED=90,kPION=91,kKAON=92,kPROTON=93};
  enum Econfig {kSpecie=1,kHarmonic,kReadMC,kSkipSelection};
  AliAnalysisTaskFlowStrange();
  AliAnalysisTaskFlowStrange(const Char_t *name);
  virtual ~AliAnalysisTaskFlowStrange();
  virtual void UserCreateOutputObjects();
  virtual void Exec(Option_t*);
  virtual void UserExec(Option_t *);
  virtual void Terminate(Option_t *);
  virtual void MyUserExec(Option_t *);
  virtual void MyUserCreateOutputObjects();
  virtual void MyPrintConfig();
  virtual void PrintConfig();

  void SetHarmonic(Int_t val) {fHarmonic= val;}

  void SetOutputList(TList *lst) {fList=lst;}
  TList* GetOutputList() {return fList;}
  TList* RunTerminateAgain(TList *lst);

  void SetDebug(Int_t val=1) {fDebug = val;}
  void SetQAlevel(Int_t qa) {fQAlevel = qa;}

  void SetpA() {fRunOnpA = kTRUE;  fRunOnpp = kFALSE;}
  void Setpp() {fRunOnpA = kFALSE; fRunOnpp = kTRUE; }
  void SetReadESD(Bool_t val) {fReadESD=val;}
  void SetReadMC(Bool_t val) {fReadMC=val;}

  void SetAvoidExec(Bool_t val) {fAvoidExec=val;}
  void SetVertexZcut(Double_t val) {fVertexZcut=val;}
  void SetSkipCentralitySelection(Bool_t val) {fSkipCentralitySelection=val;}
  void SetCentralityRange(TString val, Int_t m, Int_t M) {fCentMethod=val; fCentPerMin=m; fCentPerMax=M;}
  void SetExtraEventRejection(Bool_t val) {fExtraEventRejection=val;}
  void SetSkipTerminate(Bool_t val) {fSkipTerminate=val;}

  void SetAddPiToMCReactionPlane(Bool_t val) {fAddPiToMCReactionPlane=val;}
  void SetUseFlowPackage(Bool_t val) {fUseFP=val;}
  void SetWhichPsi(Int_t val) {fWhichPsi=val;}
  void SetStoreVZEResponse(Bool_t val) {fVZEsave=val;}
  void LoadVZEResponse(TList *val, Bool_t val2=kFALSE, Bool_t val3=kTRUE) {fVZEload=val;fVZEmb=val2;fVZEByDisk=val3;}
  void SetRFPFilterBit(Int_t val) {fRFPFilterBit=val;}
  void SetRFPMinPt(Double_t val) {fRFPminPt=val;}
  void SetRFPMaxPt(Double_t val) {fRFPmaxPt=val;}
  void SetRFPAMinEta(Double_t val) {fRFPAminEta=val;}
  void SetRFPAMaxEta(Double_t val) {fRFPAmaxEta=val;}
  void SetRFPCMinEta(Double_t val) {fRFPCminEta=val;}
  void SetRFPCMaxEta(Double_t val) {fRFPCmaxEta=val;}
  void SetRFPTPCSignal(Double_t val) {fRFPTPCsignal=val;}
  void SetRFPMaxIPxy(Double_t val) {fRFPmaxIPxy=val;}
  void SetRFPMaxIPz(Double_t val) {fRFPmaxIPz=val;}
  void SetRFPMinTPCCls(Int_t val) {fRFPTPCncls=val;}
  void SetRFPVZERingRange(Int_t val1, Int_t val2, Int_t val3, Int_t val4)
    {fVZECa=val1;fVZECb=val2;fVZEAa=val3;fVZEAb=val4;}

  void SetSkipSelection(Bool_t val) {fSkipSelection=val;}
  void SetSkipVn(Bool_t val) {fSkipVn=val;}
  void SetPostMatched(Int_t val) {fPostMatched=val;}
  void SetK0L0(Int_t specie) {fSpecie=specie;}
  void SetMass(Int_t n, Double_t m, Double_t M) {fMassBins=n;fMinMass=m;fMaxMass=M;}
  void SetPtEdges(Int_t n, Double_t *p);
  void SetOnline(Bool_t val) {fOnline=val;}
  void SetHomemade(Bool_t val) {fHomemade=val;}
  void SetExcludeTPCEdges(Bool_t value) {fExcludeTPCEdges=value;}
  void SetMaxRapidity(Double_t val) {fDecayMaxRapidity=val;}
  void SetMinEta(Double_t val) {fDecayMinEta=val;}
  void SetMaxEta(Double_t val) {fDecayMaxEta=val;}
  void SetMinPt(Double_t val) {fDecayMinPt=val;}
  void SetMaxDCAdaughters(Double_t val) {fDecayMaxDCAdaughters=val;}
  void SetMinCosinePointingAngleXY(Double_t val) {fDecayMinCosinePointingAngleXY=val;}
  void SetMinQt(Double_t val, Bool_t val2=kTRUE) {fDecayMinQt=val; fDecayAPCutPie=val2;}
  void SetStopPIDAtPt(Double_t val) {fDecayStopPIDAtPt=val;}
  void SetMinRadXY(Double_t val) {fDecayMinRadXY=val;}
  void SetMaxDecayLength(Double_t val) {fDecayMaxDecayLength=val;}
  void SetMaxProductIPXY(Double_t val) {fDecayMaxProductIPXY=val;}

  void SetDauMinNClsTPC(Int_t val) {fDaughterMinNClsTPC=val;}
  void SetDauMinNClsITS(Int_t val) {fDaughterMinNClsITS=val;}
  void SetDauMinXRows(Int_t val) {fDaughterMinXRows=val;}
  void SetDauMaxChi2PerNClsTPC(Double_t val) {fDaughterMaxChi2PerNClsTPC=val;}
  void SetDauMinXRowsOverNClsFTPC(Double_t val) {fDaughterMinXRowsOverNClsFTPC=val;}
  void SetDauITSLayer(Int_t layer, Int_t config) {fDaughterITSConfig[layer]=config;}
  void SetDauMinEta(Double_t val) {fDaughterMinEta=val;}
  void SetDauMaxEta(Double_t val) {fDaughterMaxEta=val;}
  void SetDauMinPt(Double_t val) {fDaughterMinPt=val;}
  void SetDauMinImpactParameterXY(Double_t val) {fDaughterMinImpactParameterXY=val;}
  void SetDauMaxNSigmaPID(Double_t val) {fDaughterMaxNSigmaPID=val;}
  void SetDauUnTagProcedure(Bool_t val) {fDaughterUnTag=val;}
  void SetDauSPDRequireAny(Bool_t val) {fDaughterSPDRequireAny=val;}
  void SetDauITSrefit(Bool_t val) {fDaughterITSrefit=val;}

  void OpenToyModel();
  void MakeToyEvent(Int_t seed=0, Int_t m_decay = 30, Double_t v_decay = 0.05,
		    Double_t mass_decay_mu = 0.497648, Double_t mass_decay_sg = 0.01,
		    Int_t m_bgr = 30, Double_t v_bgr = 0.08,
		    Int_t mtpc_a = 300, Double_t v_tpca = 0.10, Int_t mtpc_c = 300, Double_t v_tpcc = 0.10,
		    Int_t mvze_a = 300, Double_t v_vzea = 0.10, Int_t mvze_c = 300, Double_t v_vzec = 0.10 );
  void CloseToyModel();
  TList* RebinDecayVn(Int_t nbins, Int_t *bins);

 private:
  AliAnalysisTaskFlowStrange(const AliAnalysisTaskFlowStrange& analysisTask);
  AliAnalysisTaskFlowStrange& operator=(const AliAnalysisTaskFlowStrange& analysisTask);
  void AddQAEvents();
  void AddQACandidates();

  void MyNotifyRun();
  Bool_t CalibrateEvent();
  void Publish();
  
  void AddEventSpy(TString name);
  void FillEventSpy(TString name);

  Bool_t MinimumRequirementsAA(AliAODEvent *tAOD);
  Bool_t AcceptAAEvent(AliESDEvent *tESD);
  Bool_t AcceptAAEvent(AliAODEvent *tAOD);
  Bool_t AcceptPPEvent(AliAODEvent *tAOD);
  Bool_t AcceptPAEvent(AliAODEvent *tAOD);
  Int_t GetReferenceMultiplicity();

  void ReadStack(TClonesArray* mcArray);
  void ReadFromESD(AliESDEvent *tESD);
  void ReadFromAODv0(AliAODEvent *tAOD);

  void ChargeParticles(AliAODEvent *tAOD);

  void ComputePsi2(AliVEvent *event);
  void AddMakeQSpy();
  void FillMakeQSpy();
  void ComputeChi2VZERO();
  void MakeQVZE(AliVEvent *event);
  void MakeQTPC(AliVEvent *event);
  void MakeQTPC(AliESDEvent *event);
  void MakeQTPC(AliAODEvent *event);
  void AddTPCRFPSpy(TList *val);
  Bool_t PassesRFPTPCCuts(AliESDtrack *myTrack, Double_t aodChi2NDF=0, Float_t aodipxy=0, Float_t aodipz=0);
  void MakeQVectors();
  void ResetContainers();

  void AddCandidates();
  TList* RebinDecayVn(TList *tList,Int_t nbins, Int_t *bins);

  Double_t GetMCDPHI(Double_t phi);

  Double_t CosThetaPointXY(AliESDv0 *me, const AliVVertex *vtx);
  Double_t CosThetaPointXY(AliAODv0 *me, const AliVVertex *vtx);
  Double_t DecayLengthXY(AliESDv0 *me, const AliVVertex *vtx);
  Double_t DecayLengthXY(AliAODv0 *me, const AliVVertex *vtx);
  Double_t DecayLength(AliESDv0 *me, const AliVVertex *vtx);
  Double_t DecayLength(AliAODv0 *me, const AliVVertex *vtx);

  void AddMCParticleSpy(TList *val);
  void FillMCParticleSpy(TString listName, AliAODMCParticle *par);
  void FillMCParticleSpy(TString listName, TParticle *par);

  void AddCandidatesSpy(TList *val, Bool_t fillRes=kFALSE);
  void FillCandidateSpy(TString listName, Bool_t fillRes=kFALSE);

  void AddTrackSpy(TList *val, Bool_t fillRes=kFALSE);
  void FillTrackSpy(TString listName, Bool_t fillRes=kFALSE);

  void AddDecayVn(TList *val);
  void FillDecayVn(TString listName,Double_t ms,Double_t pt,Double_t phi,Double_t eta,Int_t fid1,Int_t fid2);
  void QCStoreDecayVn(TString name);
  void ComputeDecayVn(TString listName);

  void AddTrackVn(TList *val);
  void FillTrackVn(TString listName,Double_t pt,Double_t phi,Double_t eta,Int_t fid);
  void QCStoreTrackVn(TString name);
  void ComputeTrackVn(TString listName);
  Bool_t InQTPC(Int_t id);

  void MakeFilterBits();
  Bool_t PassesFilterBit(AliESDtrack *me);

  void LoadTrack(AliESDtrack *myTrack, Double_t aodChi2NDF=0);
  Bool_t AcceptDaughter(Bool_t strongITS=kTRUE);
  Bool_t AcceptCandidate();
  Bool_t PassesPIDCuts(AliESDtrack *myTrack, AliPID::EParticleType pid=AliPID::kProton);

  Bool_t IsAtTPCEdge(Double_t phi,Double_t pt,Int_t charge,Double_t b);

  void MakeTrack();
  void PushBackFlowTrack(AliFlowEvent *event, Double_t pt, Double_t phi, Double_t eta, Double_t we, Int_t id);

  Double_t GetWDist(const AliVVertex* v0, const AliVVertex* v1);
  Bool_t plpMV(const AliVEvent *event);

  void LoadVZEROResponse();
  void AddVZEROResponse();
  void SaveVZEROResponse();
  void AddVZEQA();
  void FillVZEQA();
  void FillVZEQA(AliAODEvent *tAOD);

  Int_t RefMult(AliAODEvent *tAOD, Int_t fb);
  Int_t RefMultTPC();
  Int_t RefMultGlobal();

  AliPIDResponse *fPIDResponse; //! PID response object
  AliESDtrackCuts *fFB1;        // filterbit cut equivalent
  AliESDtrackCuts *fFB1024;     // filterbit cut equivalent
  AliFlowEvent   *fTPCevent;    // flow event (needed here due to ev selection)
  AliFlowEvent   *fVZEevent;    // flow event (needed here due to ev selection)
  TObjArray      *fCandidates;  // array of selected candidates
  TList          *fList;        // stores the final list of output histograms

  Int_t fRunNumber; // current run number

  Int_t fDebug;   // debug level
  Int_t fQAlevel; // QA plots

  Bool_t fReadESD;       // move back to ESD
  Bool_t fReadMC;        // read MC files
  Bool_t fAddPiToMCReactionPlane; // add pi randomly (MCTUNED)
  Int_t fPostMatched;    // post only (un)matched particles
  Bool_t fAvoidExec;     // avoids Exec
  Bool_t fSkipSelection; // skip decay finder
  Bool_t fSkipVn;        // skip flow computation
  Bool_t fUseFP;         // flow package?
  Bool_t fRunOnpA;       // make task compatible with pA event selection
  Bool_t fRunOnpp;       // make task compatible with pp event selection
  Bool_t fExtraEventRejection; // to reject pile up
  Bool_t fSkipCentralitySelection; // to skip centrality
  TString  fCentMethod; // CC
  Int_t    fCentPerMin; // CC
  Int_t    fCentPerMax; // CC
  Double_t fThisCent;   // CC
  Double_t fV0M; // V0M CC
  Double_t fTRK; // TRK CC
  Double_t fPriVtxZ; // vtxZ
  Double_t fSPDVtxZ; // vtxZ
  Int_t fSPDtracklets; // spd tracklets
  Float_t fVZETotM; // vzero total multiplicity
  Int_t fRefMultTPC; // tpc only multiplicity
  Int_t fRefMultHyb; // hybrid multiplicity

  Double_t fVertexZcut; // cut on main vertex Z

  Bool_t fExcludeTPCEdges; // exclude TPC edges from single track selection

  Int_t  fSpecie;   // K0=>0 L0=>1
  Bool_t fOnline;   // change into online v0 finder
  Bool_t fHomemade; // homemade v0 finder

  Int_t fWhichPsi;  // detector for Psi2

  Bool_t  fVZEsave; // make vze response
  TList  *fVZEload; // adress to calibration file
  TH2D   *fVZEResponse; // vze response vs centrality class
  Double_t fVZEextW[64]; // vze weights
  Bool_t  fVZEmb;   // integrate response (linearity)
  Bool_t  fVZEByDisk; // normalized by disk
  Int_t   fVZECa;   // start of V0C (ring number 0-3)
  Int_t   fVZECb;   // end of V0C (ring number 0-3)
  Int_t   fVZEAa;   // start of V0A (ring number 0-3)
  Int_t   fVZEAb;   // end of V0A (ring number 0-3)
  TList  *fVZEQA;   // address to qalist

  Int_t fHarmonic;  // flow angle order
  Double_t fPsi2;   // best estimation of Psi2
  Double_t fMCEP;   // stores MC EP (when available)
  // VZE QVector
  Double_t fQVZEACos;
  Double_t fQVZEASin;
  Double_t fQVZECCos;
  Double_t fQVZECSin;
  Double_t fQVZEA;
  Double_t fQVZEC;
  Bool_t fVZEWarning;
  // TPC QVector
  Double_t fQTPCACos;
  Double_t fQTPCASin;
  Double_t fQTPCCCos;
  Double_t fQTPCCSin;
  Double_t fQTPC2hCos;
  Double_t fQTPC2hSin;
  Double_t fQTPCA;
  Double_t fQTPCC;
  Int_t fQTPCA_nTracks;
  Int_t fQTPCC_nTracks;
  Int_t fQTPCA_fID[2000];
  Int_t fQTPCC_fID[2000];
  Bool_t fSkipTerminate;

  Int_t    fMassBins; // opens
  Double_t fMinMass;  // mass
  Double_t fMaxMass;  // window
  Int_t fPtBins;        // to shrink
  Double_t fPtBinEdge[100]; // output

  Int_t fRFPFilterBit;    // RFP TPC
  Double_t fRFPminPt;     // RFP TPC
  Double_t fRFPmaxPt;     // RFP TPC
  Double_t fRFPAminEta;   // RFP TPC
  Double_t fRFPAmaxEta;   // RFP TPC
  Double_t fRFPCminEta;   // RFP TPC
  Double_t fRFPCmaxEta;   // RFP TPC
  Double_t fRFPTPCsignal; // RFP TPC
  Double_t fRFPmaxIPxy;   // RFP TPC
  Double_t fRFPmaxIPz;    // RFP TPC
  Int_t fRFPTPCncls;      // RFP TPC

  Double_t fDecayMass;                  // DECAY
  Double_t fDecayPhi;                   // DECAY
  Double_t fDecayEta;                   // DECAY
  Double_t fDecayPt;                    // DECAY
  Double_t fDecayDCAdaughters;          // DECAY
  Double_t fDecayCosinePointingAngleXY; // DECAY
  Double_t fDecayRadXY;                 // DECAY
  Double_t fDecayDecayLength;           // DECAY
  Double_t fDecayDecayLengthLab;        // DECAY
  Double_t fDecayQt;                    // DECAY
  Double_t fDecayAlpha;                 // DECAY
  Double_t fDecayRapidity;              // DECAY
  Double_t fDecayProductIPXY;           // DECAY
  Double_t fDecayIPneg;                 // DECAY
  Double_t fDecayIPpos;                 // DECAY
  Double_t fDecayXneg;                  // DECAY
  Double_t fDecayXpos;                  // DECAY
  Int_t    fDecayIDneg;                 // DECAY
  Int_t    fDecayIDpos;                 // DECAY
  Int_t    fDecayID;                    // DECAY

  Double_t fDecayMatchOrigin;  // MC DECAY
  Double_t fDecayMatchPhi;     // MC DECAY
  Double_t fDecayMatchEta;     // MC DECAY
  Double_t fDecayMatchPt;      // MC DECAY
  Double_t fDecayMatchRadXY;   // MC DECAY

  Double_t fDecayMinEta;                   // DECAY CUTS
  Double_t fDecayMaxEta;                   // DECAY CUTS
  Double_t fDecayMinPt;                    // DECAY CUTS
  Double_t fDecayMaxDCAdaughters;          // DECAY CUTS
  Double_t fDecayMinCosinePointingAngleXY; // DECAY CUTS
  Double_t fDecayMinQt;                    // DECAY CUTS
  Bool_t   fDecayAPCutPie;                 // DECAY CUTS
  Double_t fDecayStopPIDAtPt;              // DECAY CUTS
  Double_t fDecayMinRadXY;                 // DECAY CUTS
  Double_t fDecayMaxDecayLength;           // DECAY CUTS
  Double_t fDecayMaxProductIPXY;           // DECAY CUTS
  Double_t fDecayMaxRapidity;              // DECAY CUTS

  Double_t fDaughterPhi;               // DAUGHTER
  Double_t fDaughterEta;               // DAUGHTER
  Double_t fDaughterPt;                // DAUGHTER
  Int_t    fDaughterNClsTPC;           // DAUGHTER
  Int_t    fDaughterNClsITS;           // DAUGHTER
  Int_t    fDaughterITSConfig[6];      // DAUGHTER
  Int_t    fDaughterCharge;            // DAUGHTER
  Int_t    fDaughterNFClsTPC;          // DAUGHTER
  Int_t    fDaughterNSClsTPC;          // DAUGHTER
  Double_t fDaughterChi2PerNClsTPC;    // DAUGHTER
  Double_t fDaughterXRows;             // DAUGHTER
  Float_t  fDaughterImpactParameterXY; // DAUGHTER
  Float_t  fDaughterImpactParameterZ;  // DAUGHTER
  UInt_t   fDaughterStatus;            // DAUGHTER
  UChar_t  fDaughterITScm;             // DAUGHTER
  Double_t fDaughterNSigmaPID;         // DAUGHTER
  Int_t    fDaughterKinkIndex;         // DAUGHTER
  Double_t fDaughterAtSecPhi;          // DAUGHTER
  Double_t fDaughterAtSecEta;          // DAUGHTER
  Double_t fDaughterAtSecPt;           // DAUGHTER

  Double_t fDaughterMatchPhi;               // MC DAUGHTER
  Double_t fDaughterMatchEta;               // MC DAUGHTER
  Double_t fDaughterMatchPt;                // MC DAUGHTER
  Float_t  fDaughterMatchImpactParameterXY; // MC DAUGHTER
  Float_t  fDaughterMatchImpactParameterZ;  // MC DAUGHTER

  Bool_t   fDaughterUnTag;             // UNTAG PROCEDURE

  Double_t fDaughterMinEta;               // DAUGHTER CUTS
  Double_t fDaughterMaxEta;               // DAUGHTER CUTS
  Double_t fDaughterMinPt;                // DAUGHTER CUTS
  Int_t    fDaughterMinNClsTPC;           // DAUGHTER CUTS
  Int_t    fDaughterMinNClsITS;           // DAUGHTER CUTS
  Int_t    fDaughterMinXRows;             // DAUGHTER CUTS
  Double_t fDaughterMaxChi2PerNClsTPC;    // DAUGHTER CUTS
  Double_t fDaughterMinXRowsOverNClsFTPC; // DAUGHTER CUTS
  Double_t fDaughterMinImpactParameterXY; // DAUGHTER CUTS
  Double_t fDaughterMaxNSigmaPID;         // DAUGHTER CUTS
  Bool_t   fDaughterSPDRequireAny;        // DAUGHTER CUTS
  Bool_t   fDaughterITSrefit;             // DAUGHTER CUTS

  ClassDef(AliAnalysisTaskFlowStrange, 6);
};
#endif
Commit	Line	Data
24373b38	1	/////////////////////////////////////////////////////
	2	// AliAnalysisTaskFlowStrange:
	3	// Analysis task to select K0/Lambda candidates for flow analysis.
	4	// Authors: Cristian Ivan (civan@cern.ch)
	5	// Carlos Perez (cperez@cern.ch)
	6	// Pawel Debski (pdebski@cern.ch)
	7	//////////////////////////////////////////////////////
	8
	9	/* Copyright(c) 1998-1999, ALICExperiment at CERN, All rights reserved. *
	10	* See cxx source for full Copyright notice */
	11	/* $Id: $ */
	12
	13	#ifndef AliAnalysisTaskFlowStrange_H
	14	#define AliAnalysisTaskFlowStrange_H
	15
	16	#include "AliAnalysisTaskSE.h"
	17
	18	class TList;
	19	class TH2D;
	20	class TObjArray;
	21	class TClonesArray;
	22	class AliAODMCParticle;
	23	class AliESDtrackCuts;
	24	class AliFlowEventCuts;
	25	class AliPIDResponse;
	26	class AliESDEvent;
	27	class AliAODEvent;
	28	class AliAODv0;
	29	class AliESDv0;
	30	class AliVVertex;
	31	class AliFlowBayesianPID;
	32	class AliAODVertex;
	33
	34	class AliAnalysisTaskFlowStrange : public AliAnalysisTaskSE {
	35	public:
	36	enum Especie {kKZE=0,kLDA=1,kLDABAR=2,kLDAALL=3,kCHARGED=90,kPION=91,kKAON=92,kPROTON=93};
6c0d2d67	37	enum Econfig {kSpecie=1,kHarmonic,kReadMC,kSkipSelection};
24373b38	38	AliAnalysisTaskFlowStrange();
	39	AliAnalysisTaskFlowStrange(const Char_t *name);
	40	virtual ~AliAnalysisTaskFlowStrange();
	41	virtual void UserCreateOutputObjects();
	42	virtual void Exec(Option_t*);
	43	virtual void UserExec(Option_t *);
	44	virtual void Terminate(Option_t *);
52476a4c	45	virtual void MyUserExec(Option_t *);
	46	virtual void MyUserCreateOutputObjects();
	47	virtual void MyPrintConfig();
	48	virtual void PrintConfig();
24373b38	49
52476a4c	50	void SetHarmonic(Int_t val) {fHarmonic= val;}
	51
	52	void SetOutputList(TList *lst) {fList=lst;}
	53	TList* GetOutputList() {return fList;}
6c0d2d67	54	TList* RunTerminateAgain(TList *lst);
6c0d2d67	55
24373b38	56	void SetDebug(Int_t val=1) {fDebug = val;}
	57	void SetQAlevel(Int_t qa) {fQAlevel = qa;}
	58
24373b38	59	void SetpA() {fRunOnpA = kTRUE; fRunOnpp = kFALSE;}
24373b38	60	void Setpp() {fRunOnpA = kFALSE; fRunOnpp = kTRUE; }
24373b38	61	void SetReadESD(Bool_t val) {fReadESD=val;}
24373b38	62	void SetReadMC(Bool_t val) {fReadMC=val;}
6c0d2d67	63
24373b38	64	void SetAvoidExec(Bool_t val) {fAvoidExec=val;}
512ced40	65	void SetVertexZcut(Double_t val) {fVertexZcut=val;}
6c0d2d67	66	void SetSkipCentralitySelection(Bool_t val) {fSkipCentralitySelection=val;}
	67	void SetCentralityRange(TString val, Int_t m, Int_t M) {fCentMethod=val; fCentPerMin=m; fCentPerMax=M;}
	68	void SetExtraEventRejection(Bool_t val) {fExtraEventRejection=val;}
	69	void SetSkipTerminate(Bool_t val) {fSkipTerminate=val;}
24373b38	70
6c0d2d67	71	void SetAddPiToMCReactionPlane(Bool_t val) {fAddPiToMCReactionPlane=val;}
6c0d2d67	72	void SetUseFlowPackage(Bool_t val) {fUseFP=val;}
24373b38	73	void SetWhichPsi(Int_t val) {fWhichPsi=val;}
	74	void SetStoreVZEResponse(Bool_t val) {fVZEsave=val;}
	75	void LoadVZEResponse(TList *val, Bool_t val2=kFALSE, Bool_t val3=kTRUE) {fVZEload=val;fVZEmb=val2;fVZEByDisk=val3;}
24373b38	76	void SetRFPFilterBit(Int_t val) {fRFPFilterBit=val;}
	77	void SetRFPMinPt(Double_t val) {fRFPminPt=val;}
	78	void SetRFPMaxPt(Double_t val) {fRFPmaxPt=val;}
6c0d2d67	79	void SetRFPAMinEta(Double_t val) {fRFPAminEta=val;}
	80	void SetRFPAMaxEta(Double_t val) {fRFPAmaxEta=val;}
	81	void SetRFPCMinEta(Double_t val) {fRFPCminEta=val;}
	82	void SetRFPCMaxEta(Double_t val) {fRFPCmaxEta=val;}
24373b38	83	void SetRFPTPCSignal(Double_t val) {fRFPTPCsignal=val;}
	84	void SetRFPMaxIPxy(Double_t val) {fRFPmaxIPxy=val;}
	85	void SetRFPMaxIPz(Double_t val) {fRFPmaxIPz=val;}
	86	void SetRFPMinTPCCls(Int_t val) {fRFPTPCncls=val;}
	87	void SetRFPVZERingRange(Int_t val1, Int_t val2, Int_t val3, Int_t val4)
	88	{fVZECa=val1;fVZECb=val2;fVZEAa=val3;fVZEAb=val4;}
24373b38	89
6c0d2d67	90	void SetSkipSelection(Bool_t val) {fSkipSelection=val;}
52476a4c	91	void SetSkipVn(Bool_t val) {fSkipVn=val;}
6c0d2d67	92	void SetPostMatched(Int_t val) {fPostMatched=val;}
	93	void SetK0L0(Int_t specie) {fSpecie=specie;}
	94	void SetMass(Int_t n, Double_t m, Double_t M) {fMassBins=n;fMinMass=m;fMaxMass=M;}
52476a4c	95	void SetPtEdges(Int_t n, Double_t *p);
6c0d2d67	96	void SetOnline(Bool_t val) {fOnline=val;}
	97	void SetHomemade(Bool_t val) {fHomemade=val;}
	98	void SetExcludeTPCEdges(Bool_t value) {fExcludeTPCEdges=value;}
24373b38	99	void SetMaxRapidity(Double_t val) {fDecayMaxRapidity=val;}
	100	void SetMinEta(Double_t val) {fDecayMinEta=val;}
	101	void SetMaxEta(Double_t val) {fDecayMaxEta=val;}
	102	void SetMinPt(Double_t val) {fDecayMinPt=val;}
	103	void SetMaxDCAdaughters(Double_t val) {fDecayMaxDCAdaughters=val;}
	104	void SetMinCosinePointingAngleXY(Double_t val) {fDecayMinCosinePointingAngleXY=val;}
	105	void SetMinQt(Double_t val, Bool_t val2=kTRUE) {fDecayMinQt=val; fDecayAPCutPie=val2;}
52476a4c	106	void SetStopPIDAtPt(Double_t val) {fDecayStopPIDAtPt=val;}
24373b38	107	void SetMinRadXY(Double_t val) {fDecayMinRadXY=val;}
	108	void SetMaxDecayLength(Double_t val) {fDecayMaxDecayLength=val;}
	109	void SetMaxProductIPXY(Double_t val) {fDecayMaxProductIPXY=val;}
	110
6c0d2d67	111	void SetDauMinNClsTPC(Int_t val) {fDaughterMinNClsTPC=val;}
52476a4c	112	void SetDauMinNClsITS(Int_t val) {fDaughterMinNClsITS=val;}
6c0d2d67	113	void SetDauMinXRows(Int_t val) {fDaughterMinXRows=val;}
	114	void SetDauMaxChi2PerNClsTPC(Double_t val) {fDaughterMaxChi2PerNClsTPC=val;}
	115	void SetDauMinXRowsOverNClsFTPC(Double_t val) {fDaughterMinXRowsOverNClsFTPC=val;}
	116	void SetDauITSLayer(Int_t layer, Int_t config) {fDaughterITSConfig[layer]=config;}
	117	void SetDauMinEta(Double_t val) {fDaughterMinEta=val;}
	118	void SetDauMaxEta(Double_t val) {fDaughterMaxEta=val;}
	119	void SetDauMinPt(Double_t val) {fDaughterMinPt=val;}
	120	void SetDauMinImpactParameterXY(Double_t val) {fDaughterMinImpactParameterXY=val;}
	121	void SetDauMaxNSigmaPID(Double_t val) {fDaughterMaxNSigmaPID=val;}
	122	void SetDauUnTagProcedure(Bool_t val) {fDaughterUnTag=val;}
52476a4c	123	void SetDauSPDRequireAny(Bool_t val) {fDaughterSPDRequireAny=val;}
	124	void SetDauITSrefit(Bool_t val) {fDaughterITSrefit=val;}
	125
	126	void OpenToyModel();
	127	void MakeToyEvent(Int_t seed=0, Int_t m_decay = 30, Double_t v_decay = 0.05,
	128	Double_t mass_decay_mu = 0.497648, Double_t mass_decay_sg = 0.01,
	129	Int_t m_bgr = 30, Double_t v_bgr = 0.08,
	130	Int_t mtpc_a = 300, Double_t v_tpca = 0.10, Int_t mtpc_c = 300, Double_t v_tpcc = 0.10,
	131	Int_t mvze_a = 300, Double_t v_vzea = 0.10, Int_t mvze_c = 300, Double_t v_vzec = 0.10 );
	132	void CloseToyModel();
	133	TList* RebinDecayVn(Int_t nbins, Int_t *bins);
6c0d2d67	134
24373b38	135	private:
	136	AliAnalysisTaskFlowStrange(const AliAnalysisTaskFlowStrange& analysisTask);
	137	AliAnalysisTaskFlowStrange& operator=(const AliAnalysisTaskFlowStrange& analysisTask);
	138	void AddQAEvents();
	139	void AddQACandidates();
	140
	141	void MyNotifyRun();
	142	Bool_t CalibrateEvent();
	143	void Publish();
	144
c41a93af	145	void AddEventSpy(TString name);
6c0d2d67	146	void FillEventSpy(TString name);
	147
	148	Bool_t MinimumRequirementsAA(AliAODEvent *tAOD);
24373b38	149	Bool_t AcceptAAEvent(AliESDEvent *tESD);
	150	Bool_t AcceptAAEvent(AliAODEvent *tAOD);
	151	Bool_t AcceptPPEvent(AliAODEvent *tAOD);
	152	Bool_t AcceptPAEvent(AliAODEvent *tAOD);
	153	Int_t GetReferenceMultiplicity();
	154
	155	void ReadStack(TClonesArray* mcArray);
	156	void ReadFromESD(AliESDEvent *tESD);
	157	void ReadFromAODv0(AliAODEvent *tAOD);
	158
	159	void ChargeParticles(AliAODEvent *tAOD);
	160
	161	void ComputePsi2(AliVEvent *event);
	162	void AddMakeQSpy();
52476a4c	163	void FillMakeQSpy();
52476a4c	164	void ComputeChi2VZERO();
6c0d2d67	165	void MakeQVZE(AliVEvent *event);
	166	void MakeQTPC(AliVEvent *event);
	167	void MakeQTPC(AliESDEvent *event);
	168	void MakeQTPC(AliAODEvent *event);
24373b38	169	void AddTPCRFPSpy(TList *val);
	170	Bool_t PassesRFPTPCCuts(AliESDtrack *myTrack, Double_t aodChi2NDF=0, Float_t aodipxy=0, Float_t aodipz=0);
	171	void MakeQVectors();
	172	void ResetContainers();
	173
24373b38	174	void AddCandidates();
52476a4c	175	TList* RebinDecayVn(TList tList,Int_t nbins, Int_t bins);
24373b38	176
	177	Double_t GetMCDPHI(Double_t phi);
	178
	179	Double_t CosThetaPointXY(AliESDv0 me, const AliVVertex vtx);
	180	Double_t CosThetaPointXY(AliAODv0 me, const AliVVertex vtx);
	181	Double_t DecayLengthXY(AliESDv0 me, const AliVVertex vtx);
	182	Double_t DecayLengthXY(AliAODv0 me, const AliVVertex vtx);
	183	Double_t DecayLength(AliESDv0 me, const AliVVertex vtx);
	184	Double_t DecayLength(AliAODv0 me, const AliVVertex vtx);
	185
	186	void AddMCParticleSpy(TList *val);
	187	void FillMCParticleSpy(TString listName, AliAODMCParticle *par);
	188	void FillMCParticleSpy(TString listName, TParticle *par);
	189
512ced40 RAB	190	void AddCandidatesSpy(TList *val, Bool_t fillRes=kFALSE);
512ced40 RAB	191	void FillCandidateSpy(TString listName, Bool_t fillRes=kFALSE);
24373b38	192
6c0d2d67	193	void AddTrackSpy(TList *val, Bool_t fillRes=kFALSE);
512ced40	194	void FillTrackSpy(TString listName, Bool_t fillRes=kFALSE);
24373b38	195
6c0d2d67	196	void AddDecayVn(TList *val);
	197	void FillDecayVn(TString listName,Double_t ms,Double_t pt,Double_t phi,Double_t eta,Int_t fid1,Int_t fid2);
	198	void QCStoreDecayVn(TString name);
	199	void ComputeDecayVn(TString listName);
	200
	201	void AddTrackVn(TList *val);
	202	void FillTrackVn(TString listName,Double_t pt,Double_t phi,Double_t eta,Int_t fid);
	203	void QCStoreTrackVn(TString name);
	204	void ComputeTrackVn(TString listName);
	205	Bool_t InQTPC(Int_t id);
	206
24373b38	207	void MakeFilterBits();
	208	Bool_t PassesFilterBit(AliESDtrack *me);
	209
	210	void LoadTrack(AliESDtrack *myTrack, Double_t aodChi2NDF=0);
52476a4c	211	Bool_t AcceptDaughter(Bool_t strongITS=kTRUE);
24373b38	212	Bool_t AcceptCandidate();
	213	Bool_t PassesPIDCuts(AliESDtrack *myTrack, AliPID::EParticleType pid=AliPID::kProton);
	214
	215	Bool_t IsAtTPCEdge(Double_t phi,Double_t pt,Int_t charge,Double_t b);
	216
	217	void MakeTrack();
	218	void PushBackFlowTrack(AliFlowEvent *event, Double_t pt, Double_t phi, Double_t eta, Double_t we, Int_t id);
	219
	220	Double_t GetWDist(const AliVVertex* v0, const AliVVertex* v1);
	221	Bool_t plpMV(const AliVEvent *event);
	222
	223	void LoadVZEROResponse();
	224	void AddVZEROResponse();
	225	void SaveVZEROResponse();
	226	void AddVZEQA();
52476a4c	227	void FillVZEQA();
52476a4c	228	void FillVZEQA(AliAODEvent *tAOD);
24373b38	229
6c0d2d67	230	Int_t RefMult(AliAODEvent *tAOD, Int_t fb);
24373b38	231	Int_t RefMultTPC();
	232	Int_t RefMultGlobal();
	233
	234	AliPIDResponse *fPIDResponse; //! PID response object
	235	AliESDtrackCuts *fFB1; // filterbit cut equivalent
	236	AliESDtrackCuts *fFB1024; // filterbit cut equivalent
	237	AliFlowEvent *fTPCevent; // flow event (needed here due to ev selection)
	238	AliFlowEvent *fVZEevent; // flow event (needed here due to ev selection)
	239	TObjArray *fCandidates; // array of selected candidates
	240	TList *fList; // stores the final list of output histograms
	241
	242	Int_t fRunNumber; // current run number
	243
	244	Int_t fDebug; // debug level
	245	Int_t fQAlevel; // QA plots
	246
	247	Bool_t fReadESD; // move back to ESD
	248	Bool_t fReadMC; // read MC files
6c0d2d67	249	Bool_t fAddPiToMCReactionPlane; // add pi randomly (MCTUNED)
512ced40	250	Int_t fPostMatched; // post only (un)matched particles
24373b38	251	Bool_t fAvoidExec; // avoids Exec
24373b38	252	Bool_t fSkipSelection; // skip decay finder
52476a4c	253	Bool_t fSkipVn; // skip flow computation
24373b38	254	Bool_t fUseFP; // flow package?
	255	Bool_t fRunOnpA; // make task compatible with pA event selection
	256	Bool_t fRunOnpp; // make task compatible with pp event selection
	257	Bool_t fExtraEventRejection; // to reject pile up
6c0d2d67	258	Bool_t fSkipCentralitySelection; // to skip centrality
24373b38	259	TString fCentMethod; // CC
	260	Int_t fCentPerMin; // CC
	261	Int_t fCentPerMax; // CC
	262	Double_t fThisCent; // CC
6c0d2d67	263	Double_t fV0M; // V0M CC
	264	Double_t fTRK; // TRK CC
	265	Double_t fPriVtxZ; // vtxZ
	266	Double_t fSPDVtxZ; // vtxZ
	267	Int_t fSPDtracklets; // spd tracklets
	268	Float_t fVZETotM; // vzero total multiplicity
	269	Int_t fRefMultTPC; // tpc only multiplicity
	270	Int_t fRefMultHyb; // hybrid multiplicity
24373b38	271
512ced40 RAB	272	Double_t fVertexZcut; // cut on main vertex Z
512ced40 RAB	273
24373b38	274	Bool_t fExcludeTPCEdges; // exclude TPC edges from single track selection
	275
	276	Int_t fSpecie; // K0=>0 L0=>1
	277	Bool_t fOnline; // change into online v0 finder
	278	Bool_t fHomemade; // homemade v0 finder
	279
	280	Int_t fWhichPsi; // detector for Psi2
	281
	282	Bool_t fVZEsave; // make vze response
	283	TList *fVZEload; // adress to calibration file
	284	TH2D *fVZEResponse; // vze response vs centrality class
52476a4c	285	Double_t fVZEextW[64]; // vze weights
24373b38	286	Bool_t fVZEmb; // integrate response (linearity)
	287	Bool_t fVZEByDisk; // normalized by disk
	288	Int_t fVZECa; // start of V0C (ring number 0-3)
	289	Int_t fVZECb; // end of V0C (ring number 0-3)
	290	Int_t fVZEAa; // start of V0A (ring number 0-3)
	291	Int_t fVZEAb; // end of V0A (ring number 0-3)
6c0d2d67	292	TList *fVZEQA; // address to qalist
24373b38	293
6c0d2d67	294	Int_t fHarmonic; // flow angle order
24373b38	295	Double_t fPsi2; // best estimation of Psi2
24373b38	296	Double_t fMCEP; // stores MC EP (when available)
6c0d2d67	297	// VZE QVector
	298	Double_t fQVZEACos;
	299	Double_t fQVZEASin;
	300	Double_t fQVZECCos;
	301	Double_t fQVZECSin;
	302	Double_t fQVZEA;
	303	Double_t fQVZEC;
52476a4c	304	Bool_t fVZEWarning;
6c0d2d67	305	// TPC QVector
	306	Double_t fQTPCACos;
	307	Double_t fQTPCASin;
	308	Double_t fQTPCCCos;
	309	Double_t fQTPCCSin;
	310	Double_t fQTPC2hCos;
	311	Double_t fQTPC2hSin;
	312	Double_t fQTPCA;
	313	Double_t fQTPCC;
	314	Int_t fQTPCA_nTracks;
	315	Int_t fQTPCC_nTracks;
	316	Int_t fQTPCA_fID[2000];
	317	Int_t fQTPCC_fID[2000];
	318	Bool_t fSkipTerminate;
24373b38	319
	320	Int_t fMassBins; // opens
	321	Double_t fMinMass; // mass
	322	Double_t fMaxMass; // window
52476a4c	323	Int_t fPtBins; // to shrink
52476a4c	324	Double_t fPtBinEdge[100]; // output
24373b38	325
	326	Int_t fRFPFilterBit; // RFP TPC
	327	Double_t fRFPminPt; // RFP TPC
	328	Double_t fRFPmaxPt; // RFP TPC
6c0d2d67	329	Double_t fRFPAminEta; // RFP TPC
	330	Double_t fRFPAmaxEta; // RFP TPC
	331	Double_t fRFPCminEta; // RFP TPC
	332	Double_t fRFPCmaxEta; // RFP TPC
24373b38	333	Double_t fRFPTPCsignal; // RFP TPC
	334	Double_t fRFPmaxIPxy; // RFP TPC
	335	Double_t fRFPmaxIPz; // RFP TPC
	336	Int_t fRFPTPCncls; // RFP TPC
	337
	338	Double_t fDecayMass; // DECAY
	339	Double_t fDecayPhi; // DECAY
	340	Double_t fDecayEta; // DECAY
	341	Double_t fDecayPt; // DECAY
	342	Double_t fDecayDCAdaughters; // DECAY
	343	Double_t fDecayCosinePointingAngleXY; // DECAY
	344	Double_t fDecayRadXY; // DECAY
	345	Double_t fDecayDecayLength; // DECAY
52476a4c	346	Double_t fDecayDecayLengthLab; // DECAY
24373b38	347	Double_t fDecayQt; // DECAY
	348	Double_t fDecayAlpha; // DECAY
	349	Double_t fDecayRapidity; // DECAY
	350	Double_t fDecayProductIPXY; // DECAY
512ced40 RAB	351	Double_t fDecayIPneg; // DECAY
	352	Double_t fDecayIPpos; // DECAY
	353	Double_t fDecayXneg; // DECAY
	354	Double_t fDecayXpos; // DECAY
24373b38	355	Int_t fDecayIDneg; // DECAY
	356	Int_t fDecayIDpos; // DECAY
	357	Int_t fDecayID; // DECAY
	358
512ced40 RAB	359	Double_t fDecayMatchOrigin; // MC DECAY
	360	Double_t fDecayMatchPhi; // MC DECAY
	361	Double_t fDecayMatchEta; // MC DECAY
	362	Double_t fDecayMatchPt; // MC DECAY
	363	Double_t fDecayMatchRadXY; // MC DECAY
	364
24373b38	365	Double_t fDecayMinEta; // DECAY CUTS
	366	Double_t fDecayMaxEta; // DECAY CUTS
	367	Double_t fDecayMinPt; // DECAY CUTS
	368	Double_t fDecayMaxDCAdaughters; // DECAY CUTS
	369	Double_t fDecayMinCosinePointingAngleXY; // DECAY CUTS
	370	Double_t fDecayMinQt; // DECAY CUTS
	371	Bool_t fDecayAPCutPie; // DECAY CUTS
52476a4c	372	Double_t fDecayStopPIDAtPt; // DECAY CUTS
24373b38	373	Double_t fDecayMinRadXY; // DECAY CUTS
	374	Double_t fDecayMaxDecayLength; // DECAY CUTS
	375	Double_t fDecayMaxProductIPXY; // DECAY CUTS
	376	Double_t fDecayMaxRapidity; // DECAY CUTS
	377
	378	Double_t fDaughterPhi; // DAUGHTER
	379	Double_t fDaughterEta; // DAUGHTER
	380	Double_t fDaughterPt; // DAUGHTER
	381	Int_t fDaughterNClsTPC; // DAUGHTER
52476a4c	382	Int_t fDaughterNClsITS; // DAUGHTER
512ced40	383	Int_t fDaughterITSConfig[6]; // DAUGHTER
24373b38	384	Int_t fDaughterCharge; // DAUGHTER
	385	Int_t fDaughterNFClsTPC; // DAUGHTER
	386	Int_t fDaughterNSClsTPC; // DAUGHTER
	387	Double_t fDaughterChi2PerNClsTPC; // DAUGHTER
	388	Double_t fDaughterXRows; // DAUGHTER
	389	Float_t fDaughterImpactParameterXY; // DAUGHTER
	390	Float_t fDaughterImpactParameterZ; // DAUGHTER
	391	UInt_t fDaughterStatus; // DAUGHTER
512ced40	392	UChar_t fDaughterITScm; // DAUGHTER
24373b38	393	Double_t fDaughterNSigmaPID; // DAUGHTER
24373b38	394	Int_t fDaughterKinkIndex; // DAUGHTER
6c0d2d67	395	Double_t fDaughterAtSecPhi; // DAUGHTER
	396	Double_t fDaughterAtSecEta; // DAUGHTER
	397	Double_t fDaughterAtSecPt; // DAUGHTER
24373b38	398
512ced40 RAB	399	Double_t fDaughterMatchPhi; // MC DAUGHTER
	400	Double_t fDaughterMatchEta; // MC DAUGHTER
	401	Double_t fDaughterMatchPt; // MC DAUGHTER
	402	Float_t fDaughterMatchImpactParameterXY; // MC DAUGHTER
	403	Float_t fDaughterMatchImpactParameterZ; // MC DAUGHTER
	404
24373b38	405	Bool_t fDaughterUnTag; // UNTAG PROCEDURE
	406
	407	Double_t fDaughterMinEta; // DAUGHTER CUTS
	408	Double_t fDaughterMaxEta; // DAUGHTER CUTS
	409	Double_t fDaughterMinPt; // DAUGHTER CUTS
	410	Int_t fDaughterMinNClsTPC; // DAUGHTER CUTS
52476a4c	411	Int_t fDaughterMinNClsITS; // DAUGHTER CUTS
24373b38	412	Int_t fDaughterMinXRows; // DAUGHTER CUTS
	413	Double_t fDaughterMaxChi2PerNClsTPC; // DAUGHTER CUTS
	414	Double_t fDaughterMinXRowsOverNClsFTPC; // DAUGHTER CUTS
	415	Double_t fDaughterMinImpactParameterXY; // DAUGHTER CUTS
	416	Double_t fDaughterMaxNSigmaPID; // DAUGHTER CUTS
52476a4c	417	Bool_t fDaughterSPDRequireAny; // DAUGHTER CUTS
52476a4c	418	Bool_t fDaughterITSrefit; // DAUGHTER CUTS
24373b38	419
6c0d2d67	420	ClassDef(AliAnalysisTaskFlowStrange, 6);
24373b38	421	};
24373b38	422	#endif