TPC/AliTPCcalibTracksGain.h

   1 #ifndef AliTPCCALIBTRACKSGAIN_H
   2 #define AliTPCCALIBTRACKSGAIN_H
   3
   4 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  * See cxx source for full Copyright notice                               */
   6
   7 #include <TChain.h>
   8 #include <TNamed.h>
   9
  10
  11 #include <TObjArray.h>
  12 #include <TH2D.h>
  13 #include <TVectorD.h>
  14 #include <TMatrixD.h>
  15
  16 #include <iostream>
  17 #include <TH1F.h>
  18
  19 #include <AliTPCcalibBase.h>
  20
  21 using namespace std;
  22
  23 class TTreeSRedirector;
  24 class TObjString;
  25 class TLinearFitter;
  26 class TProfile;
  27 class TProfile2D;
  28 class TH1F;
  29
  30 class AliTPCClusterParam;
  31 class AliTPCParamSR;
  32 class AliTPCCalROC;
  33 class AliTPCCalPad;
  34 class AliTPCseed;
  35 class AliTPCclusterMI;
  36 class AliTrackPointArray;
  37 class TTreeStream;
  38 class AliTPCcalibTracksCuts;
  39 class AliTPCFitPad;
  40 class TGraph;
  41 class AliTPCCClusterParam;
  42
  43 class AliTPCcalibTracksGain : public AliTPCcalibBase {
  44 public:
  45    enum {
  46       kShortPads = 0,
  47       kMediumPads = 1,
  48       kLongPads = 2
  49    };
  50    enum {
  51       kSimpleFitter = 0,
  52       kSqrtFitter = 1,
  53       kLogFitter = 2
  54    };
  55
  56   AliTPCcalibTracksGain();
  57   AliTPCcalibTracksGain(const AliTPCcalibTracksGain& obj);
  58   AliTPCcalibTracksGain(const char* name, const char* title, AliTPCcalibTracksCuts* cuts);
  59   virtual ~AliTPCcalibTracksGain();
  60   AliTPCcalibTracksGain& operator=(const AliTPCcalibTracksGain& rhs);
  61   virtual Long64_t        Merge(TCollection *list);
  62   virtual void            Process(AliTPCseed* seed);
  63   virtual void            Terminate();
  64   virtual void            Analyze();
  65   void                    SetGainMap(AliTPCCalPad *GainMap){fGainMap = GainMap;};
  66   //
  67   // Tracks and cluster manipulation
  68   //
  69   Float_t         GetMaxNorm(AliTPCclusterMI * cl);
  70   Float_t         GetQNorm(AliTPCclusterMI * cl);
  71   Float_t         GetGain(AliTPCclusterMI* cl);
  72   void            AddTrack(AliTPCseed* seed);
  73   void            DumpTrack(AliTPCseed* track);
  74   Bool_t          GetDedx(AliTPCseed* track, Int_t padType,  Int_t*rows,
  75                           Int_t &sector, Int_t& npoints,
  76                           TVectorD &dedxM, TVectorD &dedxQ,
  77                           TVectorD &parY, TVectorD &parZ, TVectorD & meanPos);
  78   void            AddCluster(AliTPCclusterMI* cluster, Float_t momenta, Float_t mdedx, Int_t padType, Float_t xcenter, TVectorD &dedxQ, TVectorD & dedxM, Float_t fraction, Float_t fraction2, Float_t dedge, TVectorD& parY, TVectorD& parZ, TVectorD& meanPos);
  79   void            AddTracklet(UInt_t sector, UInt_t padType,TVectorD &dedxQ, TVectorD &dedxM,TVectorD& parY, TVectorD& parZ, TVectorD& meanPos);
  80
  81   void            AddCluster(AliTPCclusterMI* cluster);
  82   void            Add(AliTPCcalibTracksGain* cal);
  83
  84   //
  85   // Debug stream analyze part
  86   //
  87   static TVectorD * MakeQPosNorm(TTree * chain, Int_t ipad, Bool_t isMax, Int_t maxPoints=1000000, Int_t verbose=0);
  88
  89   static void MakeQPosNormAll(TTree * chain, AliTPCClusterParam * param, Int_t maxPoints=1000000, Int_t verbose=0);
  90
  91   //
  92   // Histogram part
  93   //
  94   TH1F  * GetQM(Int_t sector=-1){return (TH1F*)(sector<0 ?  fArrayQM->At(72): fArrayQM->At(sector));}
  95   TH1F  * GetQT(Int_t sector=-1){return (TH1F*)(sector<0 ?  fArrayQT->At(72): fArrayQT->At(sector));}
  96   TProfile* GetProfileQM(Int_t sector){return (TProfile*)(sector<0 ? fProfileArrayQM->At(36): fProfileArrayQM->At(sector));}
  97   TProfile* GetProfileQT(Int_t sector){return (TProfile*)(sector<0 ? fProfileArrayQT->At(36): fProfileArrayQT->At(sector));}
  98   TProfile2D* GetProfileQM2D(Int_t sector){return (TProfile2D*)(sector<0 ? fProfileArrayQM2D->At(36): fProfileArrayQM2D->At(sector));}
  99   TProfile2D* GetProfileQT2D(Int_t sector){return (TProfile2D*)(sector<0 ? fProfileArrayQT2D->At(36): fProfileArrayQT2D->At(sector));}
 100   //
 101   // Get Derived results - gain maps
 102   //
 103   AliTPCCalPad*   CreateFitCalPad(UInt_t fitType, Bool_t undoTransformation = kFALSE, Bool_t normalizeToPadSize = kFALSE);
 104   AliTPCCalROC*   CreateFitCalROC(UInt_t sector, UInt_t fitType, Bool_t undoTransformation = kFALSE, Bool_t normalizeToPadSize = kFALSE);
 105   AliTPCCalROC*   CreateFitCalROC(UInt_t sector, UInt_t padType, TVectorD &fitParam, UInt_t fitType, Bool_t undoTransformation = kFALSE, Bool_t normalizeToPadSize = kFALSE);
 106   AliTPCCalROC*   CreateCombinedCalROC(const AliTPCCalROC* roc1, const AliTPCCalROC* roc2);
 107   //
 108   void            Evaluate(Bool_t robust = kFALSE, Double_t frac = -1.);
 109   Bool_t            GetParameters(UInt_t segment, UInt_t padType, UInt_t fitType, TVectorD &fitParam);
 110   void            GetErrors(UInt_t segment, UInt_t padType, UInt_t fitType, TVectorD &fitError);
 111   Double_t        GetRedChi2(UInt_t segment, UInt_t padType, UInt_t fitType);
 112   void            GetCovarianceMatrix(UInt_t segment, UInt_t padType, UInt_t fitType, TMatrixD& covMatrix);
 113   //
 114   //
 115   void            UpdateClusterParam(AliTPCClusterParam *param);
 116   TGraph *        CreateAmpGraph(Int_t ipad, Bool_t qmax);
 117
 118
 119   TLinearFitter*  GetFitter(UInt_t segment, UInt_t padType, UInt_t fitType);
 120   void     Process(AliESDEvent *event) {AliTPCcalibBase::Process(event);};
 121   void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
 122
 123 public:
 124   //
 125   // Helper function
 126   //
 127   static Double_t GetPadLength(Double_t lx);
 128   static Int_t    GetPadType(Double_t lx);
 129   static Bool_t   GetRowPad(Double_t lx, Double_t ly, Int_t& row, Int_t& pad); // just for debugging
 130   //
 131   //
 132   AliTPCcalibTracksCuts* fCuts;            // cuts that are used for sieving the tracks used for calibration
 133   AliTPCCalPad *fGainMap;                //  gain map to be applied
 134   //
 135   //
 136   // Simple Profiles and histograms - per chambers + 1 total
 137   //
 138   TObjArray*        fArrayQM;                // Qmax normalized
 139   TObjArray*        fArrayQT;                // Qtot normalized
 140   TObjArray*        fProfileArrayQM;         // Qmax normalized  versus local X
 141   TObjArray*        fProfileArrayQT;         // Qtot normalized  versus local X
 142   TObjArray*        fProfileArrayQM2D;       // Qmax normalized  versus local X and phi
 143   TObjArray*        fProfileArrayQT2D;       // Qtot normalized  versus local X and phi
 144   //
 145   // Fitters
 146   //
 147   AliTPCFitPad*     fSimpleFitter;         // simple fitter for short pads
 148   AliTPCFitPad*     fSqrtFitter;           // sqrt fitter for medium pads
 149   AliTPCFitPad*     fLogFitter;            // log fitter for long pads
 150   //
 151   TLinearFitter*    fFitter0M;          // fitting of the atenuation, angular correction, and mean chamber gain
 152   TLinearFitter*    fFitter1M;          // fitting of the atenuation, angular correction, and mean chamber gain
 153   TLinearFitter*    fFitter2M;          // fitting of the atenuation, angular correction, and mean chamber gain
 154   TLinearFitter*    fFitter0T;          // fitting of the atenuation, angular correction, and mean chamber gain
 155   TLinearFitter*    fFitter1T;          // fitting of the atenuation, angular correction, and mean chamber gain
 156   TLinearFitter*    fFitter2T;          // fitting of the atenuation, angular correction, and mean chamber gain
 157   //
 158   // angular adn diffusion effect fitter
 159   //
 160   TLinearFitter*    fDFitter0M;          // fitting of the atenuation, angular correction
 161   TLinearFitter*    fDFitter1M;          // fitting of the atenuation, angular correction
 162   TLinearFitter*    fDFitter2M;          // fitting of the atenuation, angular correction
 163   TLinearFitter*    fDFitter0T;          // fitting of the atenuation, angular correction
 164   TLinearFitter*    fDFitter1T;          // fitting of the atenuation, angular correction
 165   TLinearFitter*    fDFitter2T;          // fitting of the atenuation, angular correction
 166   //
 167   AliTPCFitPad*     fSingleSectorFitter;   // just for debugging
 168   //
 169   // Conters
 170   //
 171   UInt_t          fTotalTracks;         // just for debugging
 172   UInt_t          fAcceptedTracks;      // just for debugging
 173   AliTPCCalPad*   fDebugCalPadRaw;      // just for debugging
 174   AliTPCCalPad*   fDebugCalPadCorr;     // just for debugging
 175   UInt_t          fNShortClusters[36];   // number of clusters registered on short pads
 176   UInt_t          fNMediumClusters[36];  // number of clusters registered on medium pads
 177   UInt_t          fNLongClusters[36];    // number of clusters registered on long pads
 178   //
 179   //
 180   //
 181   // Setup
 182   //
 183    static       AliTPCParamSR* fgTPCparam;              //! helper object for geometry related operations
 184    static const Double_t       fgkM;                    // value used in the transformation of the charge values for the logarithmic fitter
 185    static const char*          fgkDebugStreamFileName;  // filename of the debug stream file
 186    static const Bool_t         fgkUseTotalCharge;       // whether to use the cluster's total or maximum charge
 187
 188    ClassDef(AliTPCcalibTracksGain, 1);
 189 };
 190
 191 #endif