[u/mrichter/AliRoot.git] / PWGLF / SPECTRA / PiKaPr / TestAOD / AliAnalysisTaskSpectraAllChAOD.h

#ifndef ALIANALYSISTASKSPECTRAALLCHAOD_H
#define ALIANALYSISTASKSPECTRAALLCHAOD_H

/*  See cxx source for full Copyright notice */

//-------------------------------------------------------------------------
//                      AliAnalysisTaskSpectraAllChAOD
//
//
//
//
// Author: Leonardo Milano, CERN
//-------------------------------------------------------------------------

class AliAODEvent;
class AliSpectraAODTrackCuts;
class AliSpectraAODEventCuts;
class AliHelperPID;

#include "AliAnalysisTaskSE.h"

class AliAnalysisTaskSpectraAllChAOD : public AliAnalysisTaskSE
{
 public:
  // constructors
 AliAnalysisTaskSpectraAllChAOD() : AliAnalysisTaskSE(),
    fAOD(0x0),
    fTrackCuts(0x0),
    fEventCuts(0x0),
    fHelperPID(0x0),
    fIsMC(0),
    fDoDoubleCounting(0),
    fFillOnlyEvents(0),
    fCharge(0),
    fVZEROside(0),
    fOutput(0x0),
    fnCentBins(20),
    fnQvecBins(40),
    fnNchBins(200),
    fIsQvecCalibMode(0),
    fQvecUpperLim(100),
    fIsAOD160(1),
    fnDCABins(60),
    fDCAmin(-3),
    fDCAmax(3)
      {}
  AliAnalysisTaskSpectraAllChAOD(const char *name);
  virtual ~AliAnalysisTaskSpectraAllChAOD() {
    Printf("calling detructor of AliAnalysisTaskSpectraAllChAOD - To be implemented");
  }
  
  void SetIsMC(Bool_t isMC = kFALSE)    {fIsMC = isMC; };
  Bool_t GetIsMC()           const           { return fIsMC;};
 
  void SetDoDoubleCounting(Bool_t doDoubleCounting = kFALSE)    {fDoDoubleCounting = doDoubleCounting; };
  Bool_t GetDoDoubleCounting()           const           { return fDoDoubleCounting;};
 
  void SetFillOnlyEvents(Bool_t fillOnlyEvents = kFALSE)    {fFillOnlyEvents = fillOnlyEvents; };
  Bool_t GetFillOnlyEvents()           const           { return fFillOnlyEvents;};
 
  void SetCharge(Int_t charge = 0)    {fCharge = charge; };
  Int_t GetCharge()           const           { return fCharge;};
  
  void SetVZEROside(Int_t side = 0)    {fVZEROside = side; };
  Int_t GetVZEROside()           const           { return fVZEROside;};
  
  virtual void   UserCreateOutputObjects();
  virtual void   UserExec(Option_t *option);
  virtual void   Terminate(Option_t *);
  
  AliSpectraAODTrackCuts      * GetTrackCuts()         {  return fTrackCuts; }
  AliSpectraAODEventCuts      * GetEventCuts()         {  return fEventCuts; }
  AliHelperPID                   * GetHelperPID()          { return fHelperPID; }
  TList                          * GetOutputList()         { return fOutput; }
  
  void SetTrackCuts(AliSpectraAODTrackCuts * tc)       { fTrackCuts = tc; }
  void SetEventCuts(AliSpectraAODEventCuts * vc)       { fEventCuts = vc; }
  void SetHelperPID(AliHelperPID* pid)                     { fHelperPID = pid; }
  void SetnCentBins(Int_t val)                             { fnCentBins = val; }
  void SetnQvecBins(Int_t val)                             { fnQvecBins = val; }
  void SetnNchBins(Int_t val)                             { fnNchBins = val; }
  void SetQvecCalibMode(Bool_t mode)                  { fIsQvecCalibMode = mode; }
  void SetQvecUpperLimit(Double_t val)                { fQvecUpperLim = val; }
  
  void SetIsAOD160(Bool_t aod)                        { fIsAOD160 = aod; }
  void SetnDCABin(Int_t val)                          { fnDCABins = val; } 
  void SetDCAmin(Double_t val)                        { fDCAmin = val; }
  void SetDCAmax(Double_t val)                        { fDCAmax = val; }
  Bool_t GetDCA(const AliAODTrack* trk, Double_t * p);

 private:
  
  AliAODEvent                   * fAOD;                         //! AOD object
  AliSpectraAODTrackCuts      * fTrackCuts;                   // Track Cuts
  AliSpectraAODEventCuts      * fEventCuts;                   // Event Cuts
  AliHelperPID                   * fHelperPID;                    // points to class for PID
  Bool_t                          fIsMC;                         // true if processing MC
  Bool_t                          fDoDoubleCounting;           // true is double counting for Nsigma accepetd
  Bool_t                          fFillOnlyEvents;               // if true fill only NSparseHistEv
  Int_t                            fCharge;                      // charge to be selected
  Int_t                            fVZEROside;                  // 0: VZERO-A 1: VZERO-C
  TList                          * fOutput;                     // output list
  Int_t                            fnCentBins;                  // number of bins for the centrality axis
  Int_t                            fnQvecBins;                 // number of bins for the q vector axis
  Int_t                            fnNchBins;                 // number of bins for the Nch axis
  Bool_t                           fIsQvecCalibMode;          //calib mode for Qvector percentile
  Double_t                         fQvecUpperLim;             //Upper limit for Qvector
  Bool_t                           fIsAOD160;              // enable DCA for AOD160
  Int_t                            fnDCABins;              // number of bins for DCA axis
  Double_t                         fDCAmin;                // min DCA value
  Double_t                         fDCAmax;                // max DCA value
  AliAnalysisTaskSpectraAllChAOD(const AliAnalysisTaskSpectraAllChAOD&);
  AliAnalysisTaskSpectraAllChAOD& operator=(const AliAnalysisTaskSpectraAllChAOD&);
  
  ClassDef(AliAnalysisTaskSpectraAllChAOD, 8);
};

#endif
Commit	Line	Data
c683985a	1	#ifndef ALIANALYSISTASKSPECTRAALLCHAOD_H
	2	#define ALIANALYSISTASKSPECTRAALLCHAOD_H
	3
	4	/* See cxx source for full Copyright notice */
	5
	6	//-------------------------------------------------------------------------
	7	// AliAnalysisTaskSpectraAllChAOD
	8	//
	9	//
	10	//
	11	//
	12	// Author: Leonardo Milano, CERN
	13	//-------------------------------------------------------------------------
	14
	15	class AliAODEvent;
	16	class AliSpectraAODTrackCuts;
	17	class AliSpectraAODEventCuts;
	18	class AliHelperPID;
	19
	20	#include "AliAnalysisTaskSE.h"
	21
	22	class AliAnalysisTaskSpectraAllChAOD : public AliAnalysisTaskSE
	23	{
	24	public:
	25	// constructors
	26	AliAnalysisTaskSpectraAllChAOD() : AliAnalysisTaskSE(),
	27	fAOD(0x0),
	28	fTrackCuts(0x0),
	29	fEventCuts(0x0),
	30	fHelperPID(0x0),
	31	fIsMC(0),
bc07eb4b	32	fDoDoubleCounting(0),
dbbc07ac	33	fFillOnlyEvents(0),
c683985a	34	fCharge(0),
	35	fVZEROside(0),
	36	fOutput(0x0),
	37	fnCentBins(20),
67b8dfd2	38	fnQvecBins(40),
eba59d12	39	fnNchBins(200),
eba59d12	40	fIsQvecCalibMode(0),
93c24428	41	fQvecUpperLim(100),
	42	fIsAOD160(1),
	43	fnDCABins(60),
	44	fDCAmin(-3),
	45	fDCAmax(3)
c683985a	46	{}
	47	AliAnalysisTaskSpectraAllChAOD(const char *name);
	48	virtual ~AliAnalysisTaskSpectraAllChAOD() {
	49	Printf("calling detructor of AliAnalysisTaskSpectraAllChAOD - To be implemented");
	50	}
	51
	52	void SetIsMC(Bool_t isMC = kFALSE) {fIsMC = isMC; };
	53	Bool_t GetIsMC() const { return fIsMC;};
	54
bc07eb4b	55	void SetDoDoubleCounting(Bool_t doDoubleCounting = kFALSE) {fDoDoubleCounting = doDoubleCounting; };
	56	Bool_t GetDoDoubleCounting() const { return fDoDoubleCounting;};
	57
dbbc07ac	58	void SetFillOnlyEvents(Bool_t fillOnlyEvents = kFALSE) {fFillOnlyEvents = fillOnlyEvents; };
	59	Bool_t GetFillOnlyEvents() const { return fFillOnlyEvents;};
	60
c683985a	61	void SetCharge(Int_t charge = 0) {fCharge = charge; };
	62	Int_t GetCharge() const { return fCharge;};
	63
	64	void SetVZEROside(Int_t side = 0) {fVZEROside = side; };
	65	Int_t GetVZEROside() const { return fVZEROside;};
	66
	67	virtual void UserCreateOutputObjects();
	68	virtual void UserExec(Option_t *option);
	69	virtual void Terminate(Option_t *);
	70
	71	AliSpectraAODTrackCuts * GetTrackCuts() { return fTrackCuts; }
	72	AliSpectraAODEventCuts * GetEventCuts() { return fEventCuts; }
	73	AliHelperPID * GetHelperPID() { return fHelperPID; }
	74	TList * GetOutputList() { return fOutput; }
	75
	76	void SetTrackCuts(AliSpectraAODTrackCuts * tc) { fTrackCuts = tc; }
	77	void SetEventCuts(AliSpectraAODEventCuts * vc) { fEventCuts = vc; }
	78	void SetHelperPID(AliHelperPID* pid) { fHelperPID = pid; }
	79	void SetnCentBins(Int_t val) { fnCentBins = val; }
	80	void SetnQvecBins(Int_t val) { fnQvecBins = val; }
67b8dfd2	81	void SetnNchBins(Int_t val) { fnNchBins = val; }
eba59d12	82	void SetQvecCalibMode(Bool_t mode) { fIsQvecCalibMode = mode; }
eba59d12	83	void SetQvecUpperLimit(Double_t val) { fQvecUpperLim = val; }
c683985a	84
93c24428	85	void SetIsAOD160(Bool_t aod) { fIsAOD160 = aod; }
	86	void SetnDCABin(Int_t val) { fnDCABins = val; }
	87	void SetDCAmin(Double_t val) { fDCAmin = val; }
	88	void SetDCAmax(Double_t val) { fDCAmax = val; }
665f3db3	89	Bool_t GetDCA(const AliAODTrack* trk, Double_t * p);
665f3db3	90
c683985a	91	private:
c683985a	92
bc07eb4b	93	AliAODEvent * fAOD; //! AOD object
	94	AliSpectraAODTrackCuts * fTrackCuts; // Track Cuts
	95	AliSpectraAODEventCuts * fEventCuts; // Event Cuts
	96	AliHelperPID * fHelperPID; // points to class for PID
	97	Bool_t fIsMC; // true if processing MC
	98	Bool_t fDoDoubleCounting; // true is double counting for Nsigma accepetd
dbbc07ac	99	Bool_t fFillOnlyEvents; // if true fill only NSparseHistEv
bc07eb4b	100	Int_t fCharge; // charge to be selected
	101	Int_t fVZEROside; // 0: VZERO-A 1: VZERO-C
	102	TList * fOutput; // output list
	103	Int_t fnCentBins; // number of bins for the centrality axis
	104	Int_t fnQvecBins; // number of bins for the q vector axis
67b8dfd2	105	Int_t fnNchBins; // number of bins for the Nch axis
eba59d12	106	Bool_t fIsQvecCalibMode; //calib mode for Qvector percentile
eba59d12	107	Double_t fQvecUpperLim; //Upper limit for Qvector
93c24428	108	Bool_t fIsAOD160; // enable DCA for AOD160
	109	Int_t fnDCABins; // number of bins for DCA axis
	110	Double_t fDCAmin; // min DCA value
	111	Double_t fDCAmax; // max DCA value
c683985a	112	AliAnalysisTaskSpectraAllChAOD(const AliAnalysisTaskSpectraAllChAOD&);
	113	AliAnalysisTaskSpectraAllChAOD& operator=(const AliAnalysisTaskSpectraAllChAOD&);
	114
93c24428	115	ClassDef(AliAnalysisTaskSpectraAllChAOD, 8);
c683985a	116	};
	117
	118	#endif