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