[u/mrichter/AliRoot.git] / PWGPP / VZERO / AliAnaVZEROPbPb.h

#ifndef AliAnaVZEROPbPb_cxx
#define AliAnaVZEROPbPb_cxx

class TH1F;
class TH2F;
class AliESDEvent;

#include "AliAnalysisTaskSE.h"

class AliAnaVZEROPbPb : public AliAnalysisTaskSE {

public:
  AliAnaVZEROPbPb();
  AliAnaVZEROPbPb(const char *name);
  virtual ~AliAnaVZEROPbPb() {}
  
  virtual void   UserCreateOutputObjects();
  virtual void   UserExec(Option_t *option);
  virtual void   Terminate(Option_t *);

  virtual void Init();

  void SetClassesNames(const Char_t * names);
  void SetOnlineChargeRange(Int_t nbins, Float_t maxA, Float_t macC);
  void SetTotalMultiplicityRange(Int_t nbins, Float_t max);
  void SetMultiplicityRange(Int_t nbins, Float_t maxA, Float_t maxC);
  void SetSumEquaMultRange(Int_t nbins, Float_t maxA, Float_t maxC);
  void SetEquaMultRange(Int_t nbins, Float_t max);
  void SetZVertexCut(Float_t cut){fZvtxCut = cut;};

  void CreateQAHistos();
  void CreateHistosPerL2Trigger();

  void FillQAHistos();
  void FillPerL2TriggerHistos();
  
  TH1F* CreateHisto1D(const char* name, const char* title, Int_t nBins, Double_t xMin, Double_t xMax,
		      const char* xLabel = NULL, const char* yLabel = NULL);
  TH2F* CreateHisto2D(const char* name, const char* title, Int_t nBinsX, Double_t xMin, Double_t xMax,
		      Int_t nBinsY, Double_t yMin, Double_t yMax,
		      const char* xLabel = NULL, const char* yLabel = NULL);
  
 private:
  AliESDEvent *fESD;    //! ESD object
  AliESDVZERO* fEsdV0;
  TList       *fOutputList; //! Output list
  Int_t fNClasses;   
  TObjArray *fClassesNames;

  TH2F *fNFlags; //!

  TH1F *fhAdcNoTime[2];     // ADC spectra (no time measurement)
  TH1F *fhAdcWithTime[2];   // ADC spectra (with time measurement)

  TH2F *fhAdcPMTNoTime;   // ADC spectra per PMT (no time measurement)
  TH2F *fhAdcPMTWithTime; // ADC spectra per PMT (with time measurement)
 
  TH1F *fhTime[2];          // Time spectra per side

  TH1F *fhWidth[2];         // Signal width per side

  TH2F *fhTimePMT;        // Time spectra per PMT
  TH2F *fhWidthPMT;       // Signal width per PMT

  TH2F *fhAdcWidth[2];      // ADC vs Signal width per side

  TH2F *fhTimeCorr;       // Corrected mean time V0C vs V0A

  TH2F *fhAdcTime[2];       // ADC vs Time per side

  TH2F *fhPmtMult;             // Number of fired PMTs in V0C vs V0A
  TH1F *fhV0ampl;          // ADC spectra for both rings

  TH2F *fhEvents;         // Event statistics histogram

  TH2F *fhVtxXYBB;        // XY vertex for beam-beam events
  TH1F *fhVtxZBB;         // Z vertex for beam-beam events
  TH2F *fhVtxXYBGA;       // XY vertex for beam-gas (A side) events
  TH1F *fhVtxZBGA;        // Z vertex for beam-gas (A side) events
  TH2F *fhVtxXYBGC;       // XY vertex for beam-gas (C side) events
  TH1F *fhVtxZBGC;        // Z vertex for beam-gas (C side) events

  TH1F *fhL2Triggers;    //! Triggers counting histo
  TH2F **fhOnlineCharge; //! Online Charge (send to EMCAL) histo
  TH2F **fhRecoMult;     //! Reconstructed Multiplicity V0A % V0C
  TH2F **fhRecoMultPMT;     //! Reconstructed Multiplicity per PMT
  TH2F **fhV0vsSPDCentrality; //! Centrality V0 % SPD
  TH1F **fhTriggerBits;  //! 16 trigger bits
  TH1F **fhTotRecoMult;  //! Total Reconstructed Multiplicity V0A + V0C
  TH1F **fhCentrality;   //! Centrality V0 
  TH2F **fhEqualizedMult; //! Equalized Multiplicity per channel
  TH2F **fhEqualizedMultSum; //! Equalized Multiplicity V0A % V0C

  Int_t   fNBinTotMult; // number of bin of histo fhTotRecoMult
  Float_t fTotMultMax;  // max of histo fhTotRecoMult

  Int_t   fNBinMult;    // number of bin of histo fhRecoMult
  Float_t fV0AMultMax;  // max VZERO-A of histo fhRecoMult
  Float_t fV0CMultMax;  // max VZERO-C of histo fhRecoMult
 
  Int_t   fNBinOnlineCharge;   // number of bin of histo fhOnlineCharge
  Float_t fV0AOnlineChargeMax; // max VZERO-A of histo fhOnlineCharge
  Float_t fV0COnlineChargeMax; // max VZERO-C of histo fhOnlineCharge

  Int_t   fNBinEquaMult;     // number of bin of histo fhEqualizedMult
  Float_t fEquaMultMax;      // max of histo fhEqualizedMult

  Int_t   fNBinSumsEqMult;     // number of bin of histo fhEqualizedMultSum
  Float_t fV0AEqMultMax;       // max VZERO-A of histo fhEqualizedMultSum
  Float_t fV0CEqMultMax;       // max VZERO-C of histo fhEqualizedMultSum

  Float_t fZvtxCut;   // Z vertex cut

  AliAnaVZEROPbPb(const AliAnaVZEROPbPb&); // not implemented
  AliAnaVZEROPbPb& operator=(const AliAnaVZEROPbPb&); // not implemented
  
  ClassDef(AliAnaVZEROPbPb, 3); 
};

#endif
Commit	Line	Data
a148e064	1	#ifndef AliAnaVZEROPbPb_cxx
	2	#define AliAnaVZEROPbPb_cxx
	3
	4	class TH1F;
	5	class TH2F;
	6	class AliESDEvent;
	7
	8	#include "AliAnalysisTaskSE.h"
	9
	10	class AliAnaVZEROPbPb : public AliAnalysisTaskSE {
	11
	12	public:
	13	AliAnaVZEROPbPb();
	14	AliAnaVZEROPbPb(const char *name);
	15	virtual ~AliAnaVZEROPbPb() {}
	16
	17	virtual void UserCreateOutputObjects();
	18	virtual void UserExec(Option_t *option);
	19	virtual void Terminate(Option_t *);
	20
	21	virtual void Init();
	22
a148e064	23	void SetClassesNames(const Char_t * names);
aea8bf4d	24	void SetOnlineChargeRange(Int_t nbins, Float_t maxA, Float_t macC);
	25	void SetTotalMultiplicityRange(Int_t nbins, Float_t max);
	26	void SetMultiplicityRange(Int_t nbins, Float_t maxA, Float_t maxC);
	27	void SetSumEquaMultRange(Int_t nbins, Float_t maxA, Float_t maxC);
	28	void SetEquaMultRange(Int_t nbins, Float_t max);
a6d6c8ca	29	void SetZVertexCut(Float_t cut){fZvtxCut = cut;};
a148e064	30
	31	void CreateQAHistos();
	32	void CreateHistosPerL2Trigger();
	33
	34	void FillQAHistos();
	35	void FillPerL2TriggerHistos();
	36
	37	TH1F* CreateHisto1D(const char* name, const char* title, Int_t nBins, Double_t xMin, Double_t xMax,
	38	const char* xLabel = NULL, const char* yLabel = NULL);
	39	TH2F* CreateHisto2D(const char* name, const char* title, Int_t nBinsX, Double_t xMin, Double_t xMax,
	40	Int_t nBinsY, Double_t yMin, Double_t yMax,
	41	const char* xLabel = NULL, const char* yLabel = NULL);
7b0ae030	42
a148e064	43	private:
	44	AliESDEvent *fESD; //! ESD object
	45	AliESDVZERO* fEsdV0;
	46	TList *fOutputList; //! Output list
aea8bf4d	47	Int_t fNClasses;
a148e064	48	TObjArray *fClassesNames;
	49
	50	TH2F *fNFlags; //!
	51
	52	TH1F *fhAdcNoTime[2]; // ADC spectra (no time measurement)
	53	TH1F *fhAdcWithTime[2]; // ADC spectra (with time measurement)
	54
	55	TH2F *fhAdcPMTNoTime; // ADC spectra per PMT (no time measurement)
	56	TH2F *fhAdcPMTWithTime; // ADC spectra per PMT (with time measurement)
	57
	58	TH1F *fhTime[2]; // Time spectra per side
	59
	60	TH1F *fhWidth[2]; // Signal width per side
	61
	62	TH2F *fhTimePMT; // Time spectra per PMT
	63	TH2F *fhWidthPMT; // Signal width per PMT
	64
	65	TH2F *fhAdcWidth[2]; // ADC vs Signal width per side
	66
	67	TH2F *fhTimeCorr; // Corrected mean time V0C vs V0A
	68
	69	TH2F *fhAdcTime[2]; // ADC vs Time per side
	70
	71	TH2F *fhPmtMult; // Number of fired PMTs in V0C vs V0A
	72	TH1F *fhV0ampl; // ADC spectra for both rings
	73
	74	TH2F *fhEvents; // Event statistics histogram
	75
	76	TH2F *fhVtxXYBB; // XY vertex for beam-beam events
	77	TH1F *fhVtxZBB; // Z vertex for beam-beam events
	78	TH2F *fhVtxXYBGA; // XY vertex for beam-gas (A side) events
	79	TH1F *fhVtxZBGA; // Z vertex for beam-gas (A side) events
	80	TH2F *fhVtxXYBGC; // XY vertex for beam-gas (C side) events
	81	TH1F *fhVtxZBGC; // Z vertex for beam-gas (C side) events
	82
aea8bf4d	83	TH1F *fhL2Triggers; //! Triggers counting histo
	84	TH2F **fhOnlineCharge; //! Online Charge (send to EMCAL) histo
	85	TH2F **fhRecoMult; //! Reconstructed Multiplicity V0A % V0C
1c8bbd7f	86	TH2F **fhRecoMultPMT; //! Reconstructed Multiplicity per PMT
aea8bf4d	87	TH2F **fhV0vsSPDCentrality; //! Centrality V0 % SPD
	88	TH1F **fhTriggerBits; //! 16 trigger bits
	89	TH1F **fhTotRecoMult; //! Total Reconstructed Multiplicity V0A + V0C
	90	TH1F **fhCentrality; //! Centrality V0
	91	TH2F **fhEqualizedMult; //! Equalized Multiplicity per channel
	92	TH2F **fhEqualizedMultSum; //! Equalized Multiplicity V0A % V0C
	93
c5c72a22	94	Int_t fNBinTotMult; // number of bin of histo fhTotRecoMult
c5c72a22	95	Float_t fTotMultMax; // max of histo fhTotRecoMult
aea8bf4d	96
c5c72a22	97	Int_t fNBinMult; // number of bin of histo fhRecoMult
	98	Float_t fV0AMultMax; // max VZERO-A of histo fhRecoMult
	99	Float_t fV0CMultMax; // max VZERO-C of histo fhRecoMult
aea8bf4d	100
c5c72a22	101	Int_t fNBinOnlineCharge; // number of bin of histo fhOnlineCharge
	102	Float_t fV0AOnlineChargeMax; // max VZERO-A of histo fhOnlineCharge
	103	Float_t fV0COnlineChargeMax; // max VZERO-C of histo fhOnlineCharge
aea8bf4d	104
c5c72a22	105	Int_t fNBinEquaMult; // number of bin of histo fhEqualizedMult
c5c72a22	106	Float_t fEquaMultMax; // max of histo fhEqualizedMult
aea8bf4d	107
c5c72a22	108	Int_t fNBinSumsEqMult; // number of bin of histo fhEqualizedMultSum
	109	Float_t fV0AEqMultMax; // max VZERO-A of histo fhEqualizedMultSum
	110	Float_t fV0CEqMultMax; // max VZERO-C of histo fhEqualizedMultSum
a148e064	111
a6d6c8ca	112	Float_t fZvtxCut; // Z vertex cut
a6d6c8ca	113
a148e064	114	AliAnaVZEROPbPb(const AliAnaVZEROPbPb&); // not implemented
	115	AliAnaVZEROPbPb& operator=(const AliAnaVZEROPbPb&); // not implemented
	116
a6d6c8ca	117	ClassDef(AliAnaVZEROPbPb, 3);
a148e064	118	};
	119
	120	#endif