[u/mrichter/AliRoot.git] / PWG1 / AliAnalysisTaskQASym.h

#ifndef AliAnalysisTaskQASym_cxx
#define AliAnalysisTaskQASym_cxx
 

class TH1F;
class TH2F;
class TList;
class TNtuple;

class AliESDEvent;
class AliESDtrack;
class AliESDtrackCuts;


#include "AliAnalysisTaskSE.h"
#include "TFile.h"
#include "TNtuple.h"

class AliAnalysisTaskQASym : public AliAnalysisTaskSE {
 public:
  AliAnalysisTaskQASym(const char *name = "AliAnalysisTaskQASym");
  virtual ~AliAnalysisTaskQASym() {}
  
  virtual void   UserCreateOutputObjects();
  virtual void   UserExec(Option_t *option);
  virtual void   Terminate(Option_t *);

  
  virtual void   SetCuts(AliESDtrackCuts* cuts)
     {fCuts = cuts;}

  virtual void   SetFieldOn(Bool_t b = kTRUE){fFieldOn = b;} 
  
 private:

 
  Bool_t      fFieldOn;

  TList       *fHists;          // List of histos

  //old
  TH1F        *fHistRECpt;      // pt 
  TH1F        *fEta;            // eta
  TH2F        *fEtaPhi;         // eta-phi
  TH1F        *fEtaPt;          // eta over pt 
  TH1F        *fQPt;            // charge over pt 
  TH1F        *fDca;            // distance of closest approach
  TH1F        *fqPtRec[7];      // charge over pt divided for ITS layer cases
  TH1F        *fqRec;           // reconstrcuted charge
  TH1F        *fsigmaPt;        // sigma_pT
  TH2F        *fDcaSigmaPos[7]; // distance of closest approach against sigma_pT
  TH2F        *fDcaSigmaNeg[7]; // distance of closest approach against sigma_pT


  //positive und negative particles
  TH1F        *fRecPtPos;      // pt of pos partice
  TH1F        *fRecPtNeg;      // pt of neg particle
  TH1F        *fRecPhiPos;     // phi of pos. particle
  TH1F        *fRecPhiNeg;     // phi of neg. particle
  TH1F        *fRecEtaPos;     // eta of neg. particle
  TH1F        *fRecEtaNeg;     // eta of neg. particle
  TH1F        *fRecEtaPtPos;   // eta over pt of neg. particle
  TH1F        *fRecEtaPtNeg;   // eta over pt of neg. particle
  TH1F        *fRecDcaPos;     // distance of closest approach of neg. particle
  TH1F        *fRecDcaNeg;     // distance of closest of neg. particle
  TH1F        *fRecDcaNegInv;  // invers dca of neg. particle
  TH1F        *fRecDPos;       // impact parameter of neg. particle
  TH1F        *fRecDNeg;       // impact parameter of neg. particle


  // two sides of TPC -> Eta/Theta
  TH1F        *fRecQPtPosEta; 
  TH1F        *fRecQPtNegEta;
  TH1F        *fRecPtPosEta;  
  TH1F        *fRecPtNegEta; 
  TH1F        *fRecPhiPosEta;
  TH1F        *fRecPhiNegEta;
  TH1F        *fRecDcaPosEta;
  TH1F        *fRecDcaNegEta;
  TH1F        *fRecDPosEta;
  TH1F        *fRecDNegEta;


  // sectors of TPC (with pt>xGeV?), TODO: extent to TPC standalone tracks
  TH1F        *fRecPtTpcSector[18];
  TH1F        *fRecEtaTpcSector[18];
  TH1F        *fRecQPtTpcSector[18];
  TH1F        *fRecEtaPtTpcSector[18];
  TH1F        *fSignedDcaTpcSector[18];


  // 7 different case of hit in ITS ladders
  TH1F        *fSignDcaPos[7];
  TH1F        *fSignDcaNeg[7];
  TH1F        *fSignDcaNegInv[7];
  TH1F        *fPtSigmaPos[7];
  TH1F        *fPtSigmaNeg[7];
  TH1F        *fRecPtPosLadder[7];
  TH1F        *fRecPtNegLadder[7];
  TH1F        *fRecPhiPosLadder[7];
  TH1F        *fRecPhiNegLadder[7];
  TH1F        *fRecEtaPosLadder[7];
  TH1F        *fRecEtaNegLadder[7];


  // 2D: all measures as function of z of vertex
  TH2F        *fRecPtPosVz;
  TH2F        *fRecPtNegVz;
  TH2F        *fRecEtaPosVz;
  TH2F        *fRecEtaNegVz;
  TH2F        *fRecPhiPosVz;
  TH2F        *fRecPhiNegVz;
  TH2F        *fSignedDcaPosVz;
  TH2F        *fSignedDcaNegVz;
  TH2F        *fRecQPtPosEtaVz;
  TH2F        *fRecQPtNegEtaVz;
  TH2F        *fRecEtaPtPosVz;
  TH2F        *fRecEtaPtNegVz;


  //high
  TH1F * fDeltaPhiAll;
  TH2F * fDeltaPhiLeading;
  TH1F * fDiffDcaD;

  //sim
  TH1F * fPhiRec;
  TH1F * fThetaRec;
  TH1F * fNumber;
  TH1F * fVx;
  TH1F * fVy;
  TH1F * fVz;
  TNtuple * test;


  Double_t  sdca_tr;
  Float_t xy, z;

  AliESDtrackCuts* fCuts;                      // List of cuts
  AliAnalysisTaskQASym(const AliAnalysisTaskQASym&); // not implemented
  AliAnalysisTaskQASym& operator=(const AliAnalysisTaskQASym&); // not implemented
  
  ClassDef(AliAnalysisTaskQASym, 1); // Basic QA exploiting symmetries
};

#endif
Commit	Line	Data
9f9631f3	1	#ifndef AliAnalysisTaskQASym_cxx
	2	#define AliAnalysisTaskQASym_cxx
	3
	4
	5	class TH1F;
	6	class TH2F;
	7	class TList;
	8	class TNtuple;
	9
	10	class AliESDEvent;
	11	class AliESDtrack;
	12	class AliESDtrackCuts;
	13
	14
	15	#include "AliAnalysisTaskSE.h"
	16	#include "TFile.h"
	17	#include "TNtuple.h"
	18
	19	class AliAnalysisTaskQASym : public AliAnalysisTaskSE {
	20	public:
	21	AliAnalysisTaskQASym(const char *name = "AliAnalysisTaskQASym");
	22	virtual ~AliAnalysisTaskQASym() {}
	23
	24	virtual void UserCreateOutputObjects();
	25	virtual void UserExec(Option_t *option);
	26	virtual void Terminate(Option_t *);
	27
	28
	29
	30	virtual void SetCuts(AliESDtrackCuts* cuts)
	31	{fCuts = cuts;}
	32
	33	virtual void SetFieldOn(Bool_t b = kTRUE){fFieldOn = b;}
	34
	35	private:
	36
	37
	38	Bool_t fFieldOn;
	39
	40	TList *fHists; // List of histos
	41
	42	//old
	43	TH1F *fHistRECpt; // pt
	44	TH1F *fEta; // eta
e4ab7356	45	TH2F *fEtaPhi; // eta-phi
9f9631f3	46	TH1F *fEtaPt; // eta over pt
	47	TH1F *fQPt; // charge over pt
	48	TH1F *fDca; // distance of closest approach
	49	TH1F *fqPtRec[7]; // charge over pt divided for ITS layer cases
	50	TH1F *fqRec; // reconstrcuted charge
	51	TH1F *fsigmaPt; // sigma_pT
	52	TH2F *fDcaSigmaPos[7]; // distance of closest approach against sigma_pT
	53	TH2F *fDcaSigmaNeg[7]; // distance of closest approach against sigma_pT
	54
	55
	56	//positive und negative particles
	57	TH1F *fRecPtPos; // pt of pos partice
	58	TH1F *fRecPtNeg; // pt of neg particle
	59	TH1F *fRecPhiPos; // phi of pos. particle
	60	TH1F *fRecPhiNeg; // phi of neg. particle
	61	TH1F *fRecEtaPos; // eta of neg. particle
	62	TH1F *fRecEtaNeg; // eta of neg. particle
	63	TH1F *fRecEtaPtPos; // eta over pt of neg. particle
	64	TH1F *fRecEtaPtNeg; // eta over pt of neg. particle
	65	TH1F *fRecDcaPos; // distance of closest approach of neg. particle
	66	TH1F *fRecDcaNeg; // distance of closest of neg. particle
	67	TH1F *fRecDcaNegInv; // invers dca of neg. particle
	68	TH1F *fRecDPos; // impact parameter of neg. particle
	69	TH1F *fRecDNeg; // impact parameter of neg. particle
	70
	71
	72
	73
	74	// two sides of TPC -> Eta/Theta
	75	TH1F *fRecQPtPosEta;
	76	TH1F *fRecQPtNegEta;
	77	TH1F *fRecPtPosEta;
	78	TH1F *fRecPtNegEta;
	79	TH1F *fRecPhiPosEta;
	80	TH1F *fRecPhiNegEta;
	81	TH1F *fRecDcaPosEta;
	82	TH1F *fRecDcaNegEta;
	83	TH1F *fRecDPosEta;
	84	TH1F *fRecDNegEta;
	85
	86
	87
	88	// sectors of TPC (with pt>xGeV?), TODO: extent to TPC standalone tracks
	89	TH1F *fRecPtTpcSector[18];
	90	TH1F *fRecEtaTpcSector[18];
	91	TH1F *fRecQPtTpcSector[18];
	92	TH1F *fRecEtaPtTpcSector[18];
	93	TH1F *fSignedDcaTpcSector[18];
	94
	95
	96	// 7 different case of hit in ITS ladders
	97	TH1F *fSignDcaPos[7];
	98	TH1F *fSignDcaNeg[7];
	99	TH1F *fSignDcaNegInv[7];
	100	TH1F *fPtSigmaPos[7];
	101	TH1F *fPtSigmaNeg[7];
	102	TH1F *fRecPtPosLadder[7];
	103	TH1F *fRecPtNegLadder[7];
	104	TH1F *fRecPhiPosLadder[7];
	105	TH1F *fRecPhiNegLadder[7];
	106	TH1F *fRecEtaPosLadder[7];
	107	TH1F *fRecEtaNegLadder[7];
	108
	109
110	// 2D: all measures as function of z of vertex
111	TH2F *fRecPtPosVz;
112	TH2F *fRecPtNegVz;
113	TH2F *fRecEtaPosVz;
114	TH2F *fRecEtaNegVz;
115	TH2F *fRecPhiPosVz;
116	TH2F *fRecPhiNegVz;
117	TH2F *fSignedDcaPosVz;
118	TH2F *fSignedDcaNegVz;
119	TH2F *fRecQPtPosEtaVz;
120	TH2F *fRecQPtNegEtaVz;
121	TH2F *fRecEtaPtPosVz;
122	TH2F *fRecEtaPtNegVz;
123
124
125	//high
126	TH1F * fDeltaPhiAll;
127	TH2F * fDeltaPhiLeading;
128	TH1F * fDiffDcaD;
129
130	//sim
131	TH1F * fPhiRec;
132	TH1F * fThetaRec;
133	TH1F * fNumber;
134	TH1F * fVx;
135	TH1F * fVy;
136	TH1F * fVz;
137	TNtuple * test;
138
139
140
141	Double_t sdca_tr;
142	Float_t xy, z;
143
144	AliESDtrackCuts* fCuts; // List of cuts
145	AliAnalysisTaskQASym(const AliAnalysisTaskQASym&); // not implemented
146	AliAnalysisTaskQASym& operator=(const AliAnalysisTaskQASym&); // not implemented
147
148	ClassDef(AliAnalysisTaskQASym, 1); // Basic QA exploiting symmetries
149	};
150
151	#endif