LCOV - code coverage report
Current view: top level - TPC/TPCcalib - AliTPCcalibTimeGain.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1 25 4.0 %
Date: 2016-06-14 17:26:59 Functions: 1 29 3.4 %

          Line data    Source code
       1             : #ifndef ALITPCCALIBTIMEGAIN_H
       2             : #define ALITPCCALIBTIMEGAIN_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 "AliTPCcalibBase.h"
       8             : #include "TH2F.h"
       9             : #include "TF1.h"
      10             : #include "THnSparse.h"
      11             : #include "TArrayD.h"
      12             : #include "TObjArray.h"
      13             : #include "AliSplineFit.h"
      14             : 
      15             : class TH1F;
      16             : class TH3F;
      17             : class TH2F;
      18             : class TList;
      19             : class TGraphErrors;
      20             : class AliESDEvent;
      21             : class AliESDtrack;
      22             : class AliTPCcalibLaser;
      23             : class AliTPCseed;
      24             : 
      25             : #include "TTreeStream.h"
      26             : 
      27             : 
      28             : class AliTPCcalibTimeGain:public AliTPCcalibBase {
      29             : public:
      30             :   AliTPCcalibTimeGain(); 
      31             :   AliTPCcalibTimeGain(const Text_t *name, const Text_t *title, UInt_t StartTime, UInt_t EndTime, Int_t deltaIntegrationTimeGain);
      32             :   virtual ~AliTPCcalibTimeGain();
      33             :   //
      34             :   virtual void           Process(AliESDEvent *event);
      35             :   virtual Long64_t       Merge(TCollection *li);
      36             :   virtual void           AnalyzeRun(Int_t minEntries);
      37             :   //
      38             :   void                   ProcessCosmicEvent(AliESDEvent *event);
      39             :   void                   ProcessBeamEvent(AliESDEvent *event);
      40             :   //
      41             :   void                   CalculateBetheAlephParams(TH2F *hist, Double_t * ini);
      42             :   static void            BinLogX(THnSparse *h, Int_t axisDim);
      43             :   static void            BinLogX(TH1 *h);
      44             :   //
      45           0 :   THnSparse *            GetHistGainTime() const {return (THnSparse*) fHistGainTime;};
      46           0 :   TH2F      *            GetHistDeDxTotal() const {return (TH2F*) fHistDeDxTotal;};
      47             :   //
      48             :   TGraphErrors *         GetGraphGainVsTime(Int_t runNumber = 0, Int_t minEntries = 2000);
      49             :   static AliSplineFit *  MakeSplineFit(TGraphErrors * graph);
      50             :   TGraphErrors *         GetGraphAttachment(Int_t minEntries, Int_t nmaxBin, Float_t fracLow=0.1, Float_t fracUp=0.9);
      51             :   //
      52           0 :   void SetMIP(Float_t MIP){fMIP = MIP;};
      53           0 :   void SetUseMax(Bool_t UseMax){fUseMax = UseMax;};
      54           0 :   void SetLowerTrunc(Float_t LowerTrunc){fLowerTrunc = LowerTrunc;};
      55           0 :   void SetUpperTrunc(Float_t UpperTrunc){fUpperTrunc = UpperTrunc;};
      56           0 :   void SetUseShapeNorm(Bool_t UseShapeNorm){fUseShapeNorm = UseShapeNorm;};
      57           0 :   void SetUsePosNorm(Bool_t UsePosNorm){fUsePosNorm = UsePosNorm;};
      58           0 :   void SetUsePadNorm(Int_t UsePadNorm){fUsePadNorm = UsePadNorm;};
      59           0 :   void SetIsCosmic(Bool_t IsCosmic){fIsCosmic = IsCosmic;};
      60           0 :   void SetLowMemoryConsumption(Bool_t LowMemoryConsumption){fLowMemoryConsumption = LowMemoryConsumption;};
      61           0 :   void SetUseCookAnalytical(Bool_t UseCookAnalytical){fUseCookAnalytical = UseCookAnalytical;};
      62             :   //
      63           0 :   void SetCutMinCrossRows(Int_t crossRows){fCutCrossRows = crossRows;};
      64           0 :   void SetCutMaxEta(Float_t maxEta){fCutEtaWindow = maxEta;};
      65           0 :   void SetCutRequireITSrefit(Bool_t requireItsRefit = kFALSE){fCutRequireITSrefit = requireItsRefit;};
      66           0 :   void SetCutMaxDcaXY(Float_t maxXY){fCutMaxDcaXY = maxXY;}; 
      67           0 :   void SetCutMaxDcaZ(Float_t maxZ){fCutMaxDcaZ = maxZ;}; 
      68             :   //
      69           0 :   void SetMinMomentumMIP(Float_t minMom = 0.4){fMinMomentumMIP = minMom;};
      70           0 :   void SetMaxMomentumMIP(Float_t maxMom = 0.6){fMaxMomentumMIP = maxMom;};
      71           0 :   void SetAlephParameters(Float_t * parameters){for(Int_t j=0;j<5;j++) fAlephParameters[j] = parameters[j];};
      72             : 
      73           0 :   static void SetMergeEntriesCut(Double_t entriesCut){fgMergeEntriesCut = entriesCut;}
      74             : 
      75           0 :   Double_t GetEntries() const {return fHistGainTime->GetEntries();}
      76             : 
      77             : private:
      78             :   static Double_t fgMergeEntriesCut;  //maximal number of entries for merging  -can be modified via setter
      79             : 
      80             :   Float_t GetTPCdEdx(AliTPCseed * seed);   // wrapper for CookdEdxNorm or analytical
      81             :   //
      82             :   THnSparse    * fHistGainTime;            // dEdx vs. time, type, Driftlength, momentum P
      83             :   TGraphErrors * fGainVsTime;              // multiplication factor vs. time
      84             :   TH2F         * fHistDeDxTotal;           // dEdx vs. momentum for quality assurance
      85             :   //
      86             :   Float_t fIntegrationTimeDeDx;         // required statistics for each dEdx time bin
      87             :   //
      88             :   Float_t fMIP;                         // rough MIP position in order to have scaleable histograms
      89             :   //
      90             :   // track cuts
      91             :   //
      92             :   Int_t   fCutCrossRows;                // minimum number of crossed rows 
      93             :   Float_t fCutEtaWindow;                // maximum eta of tracks
      94             :   Bool_t  fCutRequireITSrefit;          // if ITSrefit should be required (dangerous in cpass0)
      95             :   Float_t fCutMaxDcaXY;                 // max dca_xy (only TPConly resolution is guaranteed!)
      96             :   Float_t fCutMaxDcaZ;                  // max dca_z  (dangerous if vDrift is not calibrated)
      97             :   //
      98             :   // definition of MIP window
      99             :   //
     100             :   Float_t fMinMomentumMIP;              // minimum momentum of MIP region, e.g. 400 MeV
     101             :   Float_t fMaxMomentumMIP;              // maximum momentum of MIP region, e.g. 600 MeV
     102             :   Float_t fAlephParameters[5];          // parameters for equalization in MIP window, parameter set should be =1 at MIP
     103             :   //
     104             :   //
     105             :   Bool_t  fUseMax;                      // true: use max charge for dE/dx calculation, false: use total charge for dE/dx calculation
     106             :   Float_t fLowerTrunc;                  // lower truncation of dE/dx ; at most 5%
     107             :   Float_t fUpperTrunc;                  // upper truncation of dE/dx ; ca. 70%
     108             :   Bool_t  fUseShapeNorm;                // use empirical correction of dependencies
     109             :   Bool_t  fUsePosNorm;                  // charge correction (analytical?)
     110             :   Int_t   fUsePadNorm;                  // normalization of pad geometries
     111             :   Bool_t  fUseCookAnalytical;           // true if CookdEdxAnalytical should be used
     112             :   //
     113             :   Bool_t  fIsCosmic;                    // kTRUE if the analyzed runs contain cosmic events
     114             :   Bool_t  fLowMemoryConsumption;        // set this option kTRUE if the momenta information should not be stored in order to save memory
     115             :   //
     116             :   AliTPCcalibTimeGain(const AliTPCcalibTimeGain&); 
     117             :   AliTPCcalibTimeGain& operator=(const AliTPCcalibTimeGain&); 
     118           0 :   void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
     119           0 :   void     Process(AliTPCseed *track){return AliTPCcalibBase::Process(track);}
     120             : 
     121           6 :   ClassDef(AliTPCcalibTimeGain, 2);
     122             : };
     123             : 
     124             : #endif
     125             : 
     126             : 

Generated by: LCOV version 1.11