Updating ITS macros (Ruben)
[u/mrichter/AliRoot.git] / PWGPP / ITS / AliAnalysisTaskITSAlignQA.h
1 #ifndef ALIANALYSISTASKITSALIGNQA
2 #define ALIANALYSISTASKITSALIGNQA
3
4 /* Copyright(c) 1998-2012, ALICE Experiment at CERN, All rights reserved. *
5  * See cxx source for full Copyright notice                               */
6
7 //*************************************************************************
8 // Class AliAnalysiTaskITSAlignQA
9 // AliAnalysisTaskSE to extract from ESD + ESDfriends 
10 // the track-to-point residuals and dE/dx vs, time for SDD modules
11 //
12 // Author: F. Prino, prino@to.infn.it
13 //*************************************************************************
14
15 class TList;
16 class TH1F;
17 class TH2F;
18 class TProfile;
19 class TTree;
20 class TString;
21 class AliESDEvent;
22 class AliESDfriend;
23 class AliITSTPArrayFit;
24 class AliTrackPointArray;
25 class AliITSSumTP;
26
27 #include "AliAnalysisTaskSE.h"
28
29 class AliAnalysisTaskITSAlignQA : public AliAnalysisTaskSE {
30
31  public:
32   enum {kEvAll=0,kEvCnt,kEvVtx,kEvPlp,kNTracks,kNEvStatBins,  kEvAcc=kEvPlp};
33   AliAnalysisTaskITSAlignQA();
34   virtual ~AliAnalysisTaskITSAlignQA();
35
36   virtual void   UserExec(Option_t *option);
37   virtual void   UserCreateOutputObjects();
38   virtual void   Terminate(Option_t *option);
39
40   void SetDoFillTPTree(Bool_t opt){
41     fDoFillTPTree=opt;
42   }
43   void SetDoSPDResiduals(Bool_t opt){
44     fDoSPDResiduals=opt;
45   }
46   void SetDoSDDResiduals(Bool_t opt){
47     fDoSDDResiduals=opt;
48   }
49   void SetDoSSDResiduals(Bool_t opt){
50     fDoSSDResiduals=opt;
51   }
52   void SetDoSDDdEdxCalib(Bool_t opt){
53     fDoSDDdEdxCalib=opt;
54   }
55   void SetDoSDDVDriftCalib(Bool_t opt){
56     fDoSDDVDriftCalib=opt;
57   }
58   void SetDoSDDDriftTime(Bool_t opt){
59     fDoSDDDriftTime=opt;
60   }
61   void SetDoAllResiduals(){
62     fDoSPDResiduals=kTRUE;
63     fDoSDDResiduals=kTRUE;
64     fDoSSDResiduals=kTRUE;
65   }
66   void SetDoAll(){
67     SetDoAllResiduals();
68     fDoSDDdEdxCalib=kTRUE;    
69   }
70   void SetUseITSstandaloneTracks(Bool_t use){
71     fUseITSsaTracks=use;
72   }
73   void SetLoadGeometryFromOCDB(Bool_t opt){
74     fLoadGeometry=opt;
75   }
76
77   void SetMinITSPoints(Int_t minp=3){
78     fMinITSpts=minp;
79   }
80   void SetMinTPCPoints(Int_t minp=70){
81     fMinTPCpts=minp;
82   }
83   void SetMinPt(Float_t minpt=1.0){
84     fMinPt=minpt;
85   }
86   void SetUseTPCMomentum(Bool_t v=kTRUE)    { fUseTPCMomentum = v;}
87   //
88   void SetMinVtxContributors(Int_t n=5)     { fMinVtxContributors = n; }
89   void SetUseVertex(Bool_t v=kTRUE)         { fUseVertex = v; }
90   void SetUseVertexForZOnly(Bool_t v=kTRUE) { fUseVertexForZOnly = v; } // Use the vertex for SDD Z residuals only
91   void SetRemovePileupWithSPD(Bool_t opt=kTRUE) { fRemovePileupWithSPD = opt; }
92   void SetMinMaxMult(Double_t mn=0,Double_t mx=1e9) {fMinMult=mn; fMaxMult=mx;} 
93   void SetCutDCA(double xy, double z) {fCutDCAXY = xy; fCutDCAZ = z;}
94
95   void SetOCDBInfo(UInt_t runNb, const char *location) {
96     fRunNb=runNb; 
97     fOCDBLocation=location;
98   }
99
100   Bool_t   GetUseTPCMomentum()                    const {return fUseTPCMomentum;}
101   Bool_t   AcceptTrack(const AliESDtrack * track, const AliESDVertex* vtx=0);
102   Bool_t   AcceptVertex(const AliESDVertex * vtx, const AliESDVertex * vtxSPD);
103   Bool_t   AcceptCentrality(const AliESDEvent *esd) const;
104   void     CreateSPDHistos();
105   void     CreateSDDHistos();
106   void     CreateSSDHistos();
107
108   void     FitAndFillSPD(Int_t iLayer, const AliTrackPointArray *array, Int_t npts, AliESDtrack * track);
109   void     FitAndFillSDDrphi(const AliTrackPointArray *array, Int_t npts, AliESDtrack * track);
110   void     FitAndFillSDDz(Int_t iLayer, const AliTrackPointArray *array, Int_t npts, AliESDtrack * track);
111   void     FitAndFillSSD(Int_t iLayer, const AliTrackPointArray *array, Int_t npts, AliESDtrack * track);
112   void     SetPtBinLimits(Int_t nBins, Double_t* xbins){
113     fNPtBins=nBins;
114     if(nBins>kMaxPtBins) fNPtBins=kMaxPtBins;
115     for(Int_t iBin=0; iBin<=fNPtBins; iBin++) fPtBinLimits[iBin]=xbins[iBin];
116   }
117   void     LoadGeometryFromOCDB();
118   AliTrackPointArray* PrepareTrack(const AliTrackPointArray* inp, const AliESDVertex* vtx=0);
119   void                PrepareVertexConstraint(const AliESDVertex* vtx, AliTrackPoint &point);
120   //
121   void    CreateUserInfo();
122  private:
123   AliAnalysisTaskITSAlignQA(const AliAnalysisTaskITSAlignQA &source);
124   AliAnalysisTaskITSAlignQA& operator=(const AliAnalysisTaskITSAlignQA &source);
125   
126   enum {kNSPDmods = 240};
127   enum {kNSDDmods = 260};
128   enum {kNSSDmods = 1698};
129   enum {kMaxPtBins = 12};
130   enum {kVtxSensVID=14371};    // dummy VID for "vertex" point
131
132   TList* fOutput;              //! Histos with residuals
133   TH1F*  fHistNEvents;         //! histo with N of events  
134   TH1F*  fHistPtAccept;        //! histo of pt distribution of accepted tracks 
135
136   TH2F*  fHistSPDResidX[kNSPDmods];       //! histos of SPD residuals along Xloc vs. Pt
137   TH2F*  fHistSPDResidZ[kNSPDmods];       //! histos of SPD residuals along Zloc vs. Pt
138   TH2F*  fHistSDDResidX[kNSDDmods];       //! histos of SDD residuals along Xloc vs. Pt
139   TH2F*  fHistSDDResidZ[kNSDDmods];       //! histos of SDD residuals along Zloc vs. Pt
140   TH2F*  fHistSSDResidX[kNSSDmods];       //! histos of SSD residuals along Xloc vs. Pt
141   TH2F*  fHistSSDResidZ[kNSSDmods];       //! histos of SSD residuals along Zloc vs. Pt
142
143   TH2F*  fHistSDDResidXvsX[kNSDDmods];    //! histos of SDD residuals along Xloc vs. Xloc
144   TH2F*  fHistSDDResidXvsZ[kNSDDmods];    //! histos of SDD residuals along Xloc vs. Zloc
145   TH2F*  fHistSDDResidZvsX[kNSDDmods];    //! histos of SDD residuals along Zloc vs. Xloc
146   TH2F*  fHistSDDResidZvsZ[kNSDDmods];    //! histos of SDD residuals along Zloc vs. Zloc
147   TH2F*  fHistSDDdEdxvsDrTime[kNSDDmods]; //! histos of SDD dE/dx vs. drift time
148   TH1F*  fHistSDDDrTimeAll[kNSDDmods];    //! histos of SDD drift time (all clusters)
149   TH1F*  fHistSDDDrTimeExtra[kNSDDmods];  //! histos of SDD drift time (extra clusters)
150   TH1F*  fHistSDDDrTimeAttac[kNSDDmods];  //! histos of SDD drift time (attached clusters)
151   //
152   // RS
153   TProfile* fHProfSDDResidXvsXD[kNSDDmods][2]; // ! profile histos of SDD residuals along Xloc vs. Drift distance, each side separately
154   TProfile* fHProfSDDDrTimevsXD[kNSDDmods][2]; // ! profile histos of SDD drift time vs. Drift distance, each side separately
155   TProfile* fHProfSDDResidXvsZ[kNSDDmods][2];  // ! profile histos of SDD residuals along Xloc vs. Z (anode), each side separately
156   TProfile* fHProfSDDDrTimevsZ[kNSDDmods][2];  // ! profile histos of SDD drift time vs. Z (anode), each side separately
157   //
158   Bool_t   fDoSPDResiduals;   // Flag to enable histos of SPD residuals
159   Bool_t   fDoSDDResiduals;   // Flag to enable histos of SDD residuals
160   Bool_t   fDoSSDResiduals;   // Flag to enable histos of SSD residuals
161   Bool_t   fDoSDDdEdxCalib;   // Flag to enable histos for SDD dE/dx calibration
162   Bool_t   fDoSDDVDriftCalib; // Flag to enable histos for SDD VDrift calibration
163   Bool_t   fDoSDDDriftTime;   // Flag to enable histos for SDD Drift times
164   Bool_t   fDoFillTPTree;     // Flag to enable tree with trackpoints
165   Bool_t   fUseITSsaTracks;   // Flag for using standalone ITS tracks
166   Bool_t   fLoadGeometry;     // Flag to control the loading of geometry from OCDB
167   Bool_t   fUseVertex;        // Use the vertex as an extra point
168   Bool_t   fUseVertexForZOnly; // Use the vertex for SDD Z residuals only
169   Bool_t   fUseTPCMomentum;   // for the curv. constraint use TPC momentum rather than global
170   Int_t    fMinVtxContributors; // min N contributors to accept vertex if fUseVertex is on
171   Bool_t   fRemovePileupWithSPD; // Use/not use pileup rejection with SPD
172   Int_t    fMinITSpts;        // Minimum number of ITS points per track
173   Int_t    fMinTPCpts;        // Minimum number of TPC points per track
174   Float_t  fMinPt;            // Minimum pt to accept tracks
175   Int_t    fNPtBins;          // number of pt bins
176   Double_t fMinMult;          // min centrality cut
177   Double_t fMaxMult;          // max centrality cut
178   Double_t fPtBinLimits[kMaxPtBins+1];  // limits of Pt bins
179   Double_t fCutDCAXY;        // apply rough XY DCA cut in case of vtx constraint, in terms of standard deviations
180   Double_t fCutDCAZ;         // apply rough Z  DCA cut in case of vtx constraint  in terms of standard deviations
181   AliITSTPArrayFit* fFitter;  // Track Point fitter
182   AliITSSumTP* fITSSumTP;     // TracPoints summary objects
183   Int_t fRunNb;               // Run number
184   TString fOCDBLocation;      // OCDB location
185   ClassDef(AliAnalysisTaskITSAlignQA,6);
186 };
187
188
189 #endif
190
191