[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};
  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 *);

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

  void SetMass(Int_t n, Double_t m, Double_t M) {fMassBins=n;fMinMass=m;fMaxMass=M;}

  void SetpA() {fRunOnpA = kTRUE;  fRunOnpp = kFALSE;}
  void Setpp() {fRunOnpA = kFALSE; fRunOnpp = kTRUE; }
  void SetK0L0(Int_t specie) {fSpecie=specie;}
  void SetOnline(Bool_t val) {fOnline=val;}
  void SetHomemade(Bool_t val) {fHomemade=val;}
  void SetExcludeTPCEdges(Bool_t value) {fExcludeTPCEdges=value;}
  void SetCentralityRange(TString val, Int_t m, Int_t M) {fCentMethod=val; fCentPerMin=m; fCentPerMax=M;}
  void SetReadESD(Bool_t val) {fReadESD=val;}
  void SetReadMC(Bool_t val) {fReadMC=val;}
  void SetPostMatched(Int_t val) {fPostMatched=val;}
  void SetAvoidExec(Bool_t val) {fAvoidExec=val;}
  void SetSkipSelection(Bool_t val) {fSkipSelection=val;}
  void SetSkipFlow(Bool_t val) {fSkipFlow=val;}
  void SetUseFlowPackage(Bool_t val) {fUseFP=val;}
  void SetExtraEventRejection(Bool_t val) {fExtraEventRejection=val;}
  void SetVertexZcut(Double_t val) {fVertexZcut=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 SetRFPMinEta(Double_t val) {fRFPminEta=val;}
  void SetRFPMaxEta(Double_t val) {fRFPmaxEta=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 SetDauMinNClsTPC(Int_t val) {fDaughterMinNClsTPC=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 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 SetMinRadXY(Double_t val) {fDecayMinRadXY=val;}
  void SetMaxDecayLength(Double_t val) {fDecayMaxDecayLength=val;}
  void SetMaxProductIPXY(Double_t val) {fDecayMaxProductIPXY=val;}

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

  void MyNotifyRun();
  Bool_t CalibrateEvent();
  void Publish();
  
  void AddEventSpy();
  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 MakeQVZE(AliVEvent *event,Double_t &qxa,Double_t &qya,Double_t &qwa,Double_t &qxb,Double_t &qyb,Double_t &qwb);
  void MakeQTPC(AliVEvent *event,Double_t &qxa,Double_t &qya,Double_t &qwa,Double_t &qxb,Double_t &qyb,Double_t &qwb);
  void MakeQTPC(AliESDEvent *event,Double_t &qxa,Double_t &qya,Double_t &qwa,Double_t &qxb,Double_t &qyb,Double_t &qwb);
  void MakeQTPC(AliAODEvent *event,Double_t &qxa,Double_t &qya,Double_t &qwa,Double_t &qxb,Double_t &qyb,Double_t &qwb);
  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 MakeDHcorr();
  void AddCandidates();
  void ReadEventPlanesFromAOD(AliAODEvent *tAOD);

  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 AddTracksSpy(TList *val, Bool_t fillRes=kFALSE);
  void FillTrackSpy(TString listName, Bool_t fillRes=kFALSE);

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

  void LoadTrack(AliESDtrack *myTrack, Double_t aodChi2NDF=0);
  Bool_t AcceptDaughter();
  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 SaveVZEROQA();

  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
  Int_t fPostMatched;    // post only (un)matched particles
  Bool_t fAvoidExec;     // avoids Exec
  Bool_t fSkipSelection; // skip decay finder
  Bool_t fSkipFlow;      // skip flow-wise code
  Bool_t fSkipDHcorr;    // skip dhcorr code
  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
  TString  fCentMethod; // CC
  Int_t    fCentPerMin; // CC
  Int_t    fCentPerMax; // CC
  Double_t fThisCent;   // CC

  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
  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;   // adress to qalist

  Double_t fPsi2;   // best estimation of Psi2
  Double_t fMCEP;   // stores MC EP (when available)

  Int_t    fMassBins; // opens
  Double_t fMinMass;  // mass
  Double_t fMaxMass;  // window
  Double_t fMinMassX; // HP window
  Double_t fMaxMassX; // HP window

  Int_t fRFPFilterBit;    // RFP TPC
  Double_t fRFPminPt;     // RFP TPC
  Double_t fRFPmaxPt;     // RFP TPC
  Double_t fRFPminEta;    // RFP TPC
  Double_t fRFPmaxEta;    // 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 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 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    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 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    fDaughterMinXRows;             // DAUGHTER CUTS
  Double_t fDaughterMaxChi2PerNClsTPC;    // DAUGHTER CUTS
  Double_t fDaughterMinXRowsOverNClsFTPC; // DAUGHTER CUTS
  Double_t fDaughterMinImpactParameterXY; // DAUGHTER CUTS
  Double_t fDaughterMaxNSigmaPID;         // DAUGHTER CUTS

  ClassDef(AliAnalysisTaskFlowStrange, 5);
};
#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};
	37	AliAnalysisTaskFlowStrange();
	38	AliAnalysisTaskFlowStrange(const Char_t *name);
	39	virtual ~AliAnalysisTaskFlowStrange();
	40	virtual void UserCreateOutputObjects();
	41	virtual void Exec(Option_t*);
	42	virtual void UserExec(Option_t *);
	43	virtual void Terminate(Option_t *);
	44
	45	void MyUserExec(Option_t *);
	46	void SetDebug(Int_t val=1) {fDebug = val;}
	47	void SetQAlevel(Int_t qa) {fQAlevel = qa;}
	48
	49	void SetMass(Int_t n, Double_t m, Double_t M) {fMassBins=n;fMinMass=m;fMaxMass=M;}
	50
	51	void SetpA() {fRunOnpA = kTRUE; fRunOnpp = kFALSE;}
	52	void Setpp() {fRunOnpA = kFALSE; fRunOnpp = kTRUE; }
	53	void SetK0L0(Int_t specie) {fSpecie=specie;}
	54	void SetOnline(Bool_t val) {fOnline=val;}
	55	void SetHomemade(Bool_t val) {fHomemade=val;}
	56	void SetExcludeTPCEdges(Bool_t value) {fExcludeTPCEdges=value;}
	57	void SetCentralityRange(TString val, Int_t m, Int_t M) {fCentMethod=val; fCentPerMin=m; fCentPerMax=M;}
	58	void SetReadESD(Bool_t val) {fReadESD=val;}
	59	void SetReadMC(Bool_t val) {fReadMC=val;}
512ced40	60	void SetPostMatched(Int_t val) {fPostMatched=val;}
24373b38	61	void SetAvoidExec(Bool_t val) {fAvoidExec=val;}
	62	void SetSkipSelection(Bool_t val) {fSkipSelection=val;}
	63	void SetSkipFlow(Bool_t val) {fSkipFlow=val;}
	64	void SetUseFlowPackage(Bool_t val) {fUseFP=val;}
	65	void SetExtraEventRejection(Bool_t val) {fExtraEventRejection=val;}
512ced40	66	void SetVertexZcut(Double_t val) {fVertexZcut=val;}
24373b38	67
	68	void SetWhichPsi(Int_t val) {fWhichPsi=val;}
	69	void SetStoreVZEResponse(Bool_t val) {fVZEsave=val;}
	70	void LoadVZEResponse(TList *val, Bool_t val2=kFALSE, Bool_t val3=kTRUE) {fVZEload=val;fVZEmb=val2;fVZEByDisk=val3;}
	71
	72	void SetRFPFilterBit(Int_t val) {fRFPFilterBit=val;}
	73	void SetRFPMinPt(Double_t val) {fRFPminPt=val;}
	74	void SetRFPMaxPt(Double_t val) {fRFPmaxPt=val;}
	75	void SetRFPMinEta(Double_t val) {fRFPminEta=val;}
	76	void SetRFPMaxEta(Double_t val) {fRFPmaxEta=val;}
	77	void SetRFPTPCSignal(Double_t val) {fRFPTPCsignal=val;}
	78	void SetRFPMaxIPxy(Double_t val) {fRFPmaxIPxy=val;}
	79	void SetRFPMaxIPz(Double_t val) {fRFPmaxIPz=val;}
	80	void SetRFPMinTPCCls(Int_t val) {fRFPTPCncls=val;}
	81	void SetRFPVZERingRange(Int_t val1, Int_t val2, Int_t val3, Int_t val4)
	82	{fVZECa=val1;fVZECb=val2;fVZEAa=val3;fVZEAb=val4;}
	83	void SetDauMinNClsTPC(Int_t val) {fDaughterMinNClsTPC=val;}
	84	void SetDauMinXRows(Int_t val) {fDaughterMinXRows=val;}
	85	void SetDauMaxChi2PerNClsTPC(Double_t val) {fDaughterMaxChi2PerNClsTPC=val;}
	86	void SetDauMinXRowsOverNClsFTPC(Double_t val) {fDaughterMinXRowsOverNClsFTPC=val;}
512ced40	87	void SetDauITSLayer(Int_t layer, Int_t config) {fDaughterITSConfig[layer]=config;}
24373b38	88	void SetDauMinEta(Double_t val) {fDaughterMinEta=val;}
	89	void SetDauMaxEta(Double_t val) {fDaughterMaxEta=val;}
	90	void SetDauMinPt(Double_t val) {fDaughterMinPt=val;}
	91	void SetDauMinImpactParameterXY(Double_t val) {fDaughterMinImpactParameterXY=val;}
	92	void SetDauMaxNSigmaPID(Double_t val) {fDaughterMaxNSigmaPID=val;}
	93	void SetDauUnTagProcedure(Bool_t val) {fDaughterUnTag=val;}
	94
	95	void SetMaxRapidity(Double_t val) {fDecayMaxRapidity=val;}
	96	void SetMinEta(Double_t val) {fDecayMinEta=val;}
	97	void SetMaxEta(Double_t val) {fDecayMaxEta=val;}
	98	void SetMinPt(Double_t val) {fDecayMinPt=val;}
	99	void SetMaxDCAdaughters(Double_t val) {fDecayMaxDCAdaughters=val;}
	100	void SetMinCosinePointingAngleXY(Double_t val) {fDecayMinCosinePointingAngleXY=val;}
	101	void SetMinQt(Double_t val, Bool_t val2=kTRUE) {fDecayMinQt=val; fDecayAPCutPie=val2;}
	102	void SetMinRadXY(Double_t val) {fDecayMinRadXY=val;}
	103	void SetMaxDecayLength(Double_t val) {fDecayMaxDecayLength=val;}
	104	void SetMaxProductIPXY(Double_t val) {fDecayMaxProductIPXY=val;}
	105
	106	private:
	107	AliAnalysisTaskFlowStrange(const AliAnalysisTaskFlowStrange& analysisTask);
	108	AliAnalysisTaskFlowStrange& operator=(const AliAnalysisTaskFlowStrange& analysisTask);
	109	void AddQAEvents();
	110	void AddQACandidates();
	111
	112	void MyNotifyRun();
	113	Bool_t CalibrateEvent();
	114	void Publish();
	115
	116	void AddEventSpy();
	117	Bool_t AcceptAAEvent(AliESDEvent *tESD);
	118	Bool_t AcceptAAEvent(AliAODEvent *tAOD);
	119	Bool_t AcceptPPEvent(AliAODEvent *tAOD);
	120	Bool_t AcceptPAEvent(AliAODEvent *tAOD);
	121	Int_t GetReferenceMultiplicity();
	122
	123	void ReadStack(TClonesArray* mcArray);
	124	void ReadFromESD(AliESDEvent *tESD);
	125	void ReadFromAODv0(AliAODEvent *tAOD);
	126
	127	void ChargeParticles(AliAODEvent *tAOD);
	128
	129	void ComputePsi2(AliVEvent *event);
	130	void AddMakeQSpy();
	131	void MakeQVZE(AliVEvent *event,Double_t &qxa,Double_t &qya,Double_t &qwa,Double_t &qxb,Double_t &qyb,Double_t &qwb);
	132	void MakeQTPC(AliVEvent *event,Double_t &qxa,Double_t &qya,Double_t &qwa,Double_t &qxb,Double_t &qyb,Double_t &qwb);
	133	void MakeQTPC(AliESDEvent *event,Double_t &qxa,Double_t &qya,Double_t &qwa,Double_t &qxb,Double_t &qyb,Double_t &qwb);
	134	void MakeQTPC(AliAODEvent *event,Double_t &qxa,Double_t &qya,Double_t &qwa,Double_t &qxb,Double_t &qyb,Double_t &qwb);
	135	void AddTPCRFPSpy(TList *val);
	136	Bool_t PassesRFPTPCCuts(AliESDtrack *myTrack, Double_t aodChi2NDF=0, Float_t aodipxy=0, Float_t aodipz=0);
	137	void MakeQVectors();
	138	void ResetContainers();
	139
	140	void MakeDHcorr();
	141	void AddCandidates();
	142	void ReadEventPlanesFromAOD(AliAODEvent *tAOD);
	143
	144	Double_t GetMCDPHI(Double_t phi);
	145
	146	Double_t CosThetaPointXY(AliESDv0 me, const AliVVertex vtx);
	147	Double_t CosThetaPointXY(AliAODv0 me, const AliVVertex vtx);
	148	Double_t DecayLengthXY(AliESDv0 me, const AliVVertex vtx);
	149	Double_t DecayLengthXY(AliAODv0 me, const AliVVertex vtx);
	150	Double_t DecayLength(AliESDv0 me, const AliVVertex vtx);
	151	Double_t DecayLength(AliAODv0 me, const AliVVertex vtx);
152
153	void AddMCParticleSpy(TList *val);
154	void FillMCParticleSpy(TString listName, AliAODMCParticle *par);
155	void FillMCParticleSpy(TString listName, TParticle *par);
156
512ced40 RAB	157	void AddCandidatesSpy(TList *val, Bool_t fillRes=kFALSE);
512ced40 RAB	158	void FillCandidateSpy(TString listName, Bool_t fillRes=kFALSE);
24373b38	159
512ced40 RAB	160	void AddTracksSpy(TList *val, Bool_t fillRes=kFALSE);
512ced40 RAB	161	void FillTrackSpy(TString listName, Bool_t fillRes=kFALSE);
24373b38	162
	163	void MakeFilterBits();
	164	Bool_t PassesFilterBit(AliESDtrack *me);
	165
	166	void LoadTrack(AliESDtrack *myTrack, Double_t aodChi2NDF=0);
	167	Bool_t AcceptDaughter();
	168	Bool_t AcceptCandidate();
	169	Bool_t PassesPIDCuts(AliESDtrack *myTrack, AliPID::EParticleType pid=AliPID::kProton);
	170
	171	Bool_t IsAtTPCEdge(Double_t phi,Double_t pt,Int_t charge,Double_t b);
	172
	173	void MakeTrack();
	174	void PushBackFlowTrack(AliFlowEvent *event, Double_t pt, Double_t phi, Double_t eta, Double_t we, Int_t id);
	175
	176	Double_t GetWDist(const AliVVertex* v0, const AliVVertex* v1);
	177	Bool_t plpMV(const AliVEvent *event);
	178
	179	void LoadVZEROResponse();
	180	void AddVZEROResponse();
	181	void SaveVZEROResponse();
	182	void AddVZEQA();
	183	void SaveVZEROQA();
	184
	185	Int_t RefMultTPC();
	186	Int_t RefMultGlobal();
	187
	188	AliPIDResponse *fPIDResponse; //! PID response object
	189	AliESDtrackCuts *fFB1; // filterbit cut equivalent
	190	AliESDtrackCuts *fFB1024; // filterbit cut equivalent
	191	AliFlowEvent *fTPCevent; // flow event (needed here due to ev selection)
	192	AliFlowEvent *fVZEevent; // flow event (needed here due to ev selection)
	193	TObjArray *fCandidates; // array of selected candidates
	194	TList *fList; // stores the final list of output histograms
	195
	196	Int_t fRunNumber; // current run number
	197
	198	Int_t fDebug; // debug level
	199	Int_t fQAlevel; // QA plots
	200
	201	Bool_t fReadESD; // move back to ESD
	202	Bool_t fReadMC; // read MC files
512ced40	203	Int_t fPostMatched; // post only (un)matched particles
24373b38	204	Bool_t fAvoidExec; // avoids Exec
	205	Bool_t fSkipSelection; // skip decay finder
	206	Bool_t fSkipFlow; // skip flow-wise code
	207	Bool_t fSkipDHcorr; // skip dhcorr code
	208	Bool_t fUseFP; // flow package?
	209	Bool_t fRunOnpA; // make task compatible with pA event selection
	210	Bool_t fRunOnpp; // make task compatible with pp event selection
	211	Bool_t fExtraEventRejection; // to reject pile up
	212	TString fCentMethod; // CC
	213	Int_t fCentPerMin; // CC
	214	Int_t fCentPerMax; // CC
	215	Double_t fThisCent; // CC
	216
512ced40 RAB	217	Double_t fVertexZcut; // cut on main vertex Z
512ced40 RAB	218
24373b38	219	Bool_t fExcludeTPCEdges; // exclude TPC edges from single track selection
	220
	221	Int_t fSpecie; // K0=>0 L0=>1
	222	Bool_t fOnline; // change into online v0 finder
	223	Bool_t fHomemade; // homemade v0 finder
	224
	225	Int_t fWhichPsi; // detector for Psi2
	226
	227	Bool_t fVZEsave; // make vze response
	228	TList *fVZEload; // adress to calibration file
	229	TH2D *fVZEResponse; // vze response vs centrality class
	230	Bool_t fVZEmb; // integrate response (linearity)
	231	Bool_t fVZEByDisk; // normalized by disk
	232	Int_t fVZECa; // start of V0C (ring number 0-3)
	233	Int_t fVZECb; // end of V0C (ring number 0-3)
	234	Int_t fVZEAa; // start of V0A (ring number 0-3)
	235	Int_t fVZEAb; // end of V0A (ring number 0-3)
	236	TList *fVZEQA; // adress to qalist
	237
	238	Double_t fPsi2; // best estimation of Psi2
	239	Double_t fMCEP; // stores MC EP (when available)
	240
	241	Int_t fMassBins; // opens
	242	Double_t fMinMass; // mass
	243	Double_t fMaxMass; // window
512ced40 RAB	244	Double_t fMinMassX; // HP window
512ced40 RAB	245	Double_t fMaxMassX; // HP window
24373b38	246
	247	Int_t fRFPFilterBit; // RFP TPC
	248	Double_t fRFPminPt; // RFP TPC
	249	Double_t fRFPmaxPt; // RFP TPC
	250	Double_t fRFPminEta; // RFP TPC
	251	Double_t fRFPmaxEta; // RFP TPC
	252	Double_t fRFPTPCsignal; // RFP TPC
	253	Double_t fRFPmaxIPxy; // RFP TPC
	254	Double_t fRFPmaxIPz; // RFP TPC
	255	Int_t fRFPTPCncls; // RFP TPC
	256
	257	Double_t fDecayMass; // DECAY
	258	Double_t fDecayPhi; // DECAY
	259	Double_t fDecayEta; // DECAY
	260	Double_t fDecayPt; // DECAY
	261	Double_t fDecayDCAdaughters; // DECAY
	262	Double_t fDecayCosinePointingAngleXY; // DECAY
	263	Double_t fDecayRadXY; // DECAY
	264	Double_t fDecayDecayLength; // DECAY
	265	Double_t fDecayQt; // DECAY
	266	Double_t fDecayAlpha; // DECAY
	267	Double_t fDecayRapidity; // DECAY
	268	Double_t fDecayProductIPXY; // DECAY
512ced40 RAB	269	Double_t fDecayIPneg; // DECAY
	270	Double_t fDecayIPpos; // DECAY
	271	Double_t fDecayXneg; // DECAY
	272	Double_t fDecayXpos; // DECAY
24373b38	273	Int_t fDecayIDneg; // DECAY
	274	Int_t fDecayIDpos; // DECAY
	275	Int_t fDecayID; // DECAY
	276
512ced40 RAB	277	Double_t fDecayMatchOrigin; // MC DECAY
	278	Double_t fDecayMatchPhi; // MC DECAY
	279	Double_t fDecayMatchEta; // MC DECAY
	280	Double_t fDecayMatchPt; // MC DECAY
	281	Double_t fDecayMatchRadXY; // MC DECAY
	282
24373b38	283	Double_t fDecayMinEta; // DECAY CUTS
	284	Double_t fDecayMaxEta; // DECAY CUTS
	285	Double_t fDecayMinPt; // DECAY CUTS
	286	Double_t fDecayMaxDCAdaughters; // DECAY CUTS
	287	Double_t fDecayMinCosinePointingAngleXY; // DECAY CUTS
	288	Double_t fDecayMinQt; // DECAY CUTS
	289	Bool_t fDecayAPCutPie; // DECAY CUTS
	290	Double_t fDecayMinRadXY; // DECAY CUTS
	291	Double_t fDecayMaxDecayLength; // DECAY CUTS
	292	Double_t fDecayMaxProductIPXY; // DECAY CUTS
	293	Double_t fDecayMaxRapidity; // DECAY CUTS
	294
	295	Double_t fDaughterPhi; // DAUGHTER
	296	Double_t fDaughterEta; // DAUGHTER
	297	Double_t fDaughterPt; // DAUGHTER
	298	Int_t fDaughterNClsTPC; // DAUGHTER
512ced40	299	Int_t fDaughterITSConfig[6]; // DAUGHTER
24373b38	300	Int_t fDaughterCharge; // DAUGHTER
	301	Int_t fDaughterNFClsTPC; // DAUGHTER
	302	Int_t fDaughterNSClsTPC; // DAUGHTER
	303	Double_t fDaughterChi2PerNClsTPC; // DAUGHTER
	304	Double_t fDaughterXRows; // DAUGHTER
	305	Float_t fDaughterImpactParameterXY; // DAUGHTER
	306	Float_t fDaughterImpactParameterZ; // DAUGHTER
	307	UInt_t fDaughterStatus; // DAUGHTER
512ced40	308	UChar_t fDaughterITScm; // DAUGHTER
24373b38	309	Double_t fDaughterNSigmaPID; // DAUGHTER
	310	Int_t fDaughterKinkIndex; // DAUGHTER
	311
512ced40 RAB	312	Double_t fDaughterMatchPhi; // MC DAUGHTER
	313	Double_t fDaughterMatchEta; // MC DAUGHTER
	314	Double_t fDaughterMatchPt; // MC DAUGHTER
	315	Float_t fDaughterMatchImpactParameterXY; // MC DAUGHTER
	316	Float_t fDaughterMatchImpactParameterZ; // MC DAUGHTER
	317
24373b38	318	Bool_t fDaughterUnTag; // UNTAG PROCEDURE
	319
	320	Double_t fDaughterMinEta; // DAUGHTER CUTS
	321	Double_t fDaughterMaxEta; // DAUGHTER CUTS
	322	Double_t fDaughterMinPt; // DAUGHTER CUTS
	323	Int_t fDaughterMinNClsTPC; // DAUGHTER CUTS
	324	Int_t fDaughterMinXRows; // DAUGHTER CUTS
	325	Double_t fDaughterMaxChi2PerNClsTPC; // DAUGHTER CUTS
	326	Double_t fDaughterMinXRowsOverNClsFTPC; // DAUGHTER CUTS
	327	Double_t fDaughterMinImpactParameterXY; // DAUGHTER CUTS
	328	Double_t fDaughterMaxNSigmaPID; // DAUGHTER CUTS
	329
	330	ClassDef(AliAnalysisTaskFlowStrange, 5);
	331	};
	332	#endif