AliFMDDensityCalculator.h

Go to the documentation of this file.

// This class calculates the inclusive charged particle density
// in each for the 5 FMD rings. 
//
#ifndef ALIFMDDENSITYCALCULATOR_H
#define ALIFMDDENSITYCALCULATOR_H

#include <TNamed.h>
#include <TList.h>
#include <TArrayI.h>
#include <TVector3.h>
#include "AliForwardUtil.h"
#include "AliFMDMultCuts.h"
#include "AliPoissonCalculator.h"
class AliESDFMD;
class TH2D;
class TH1D;
class TProfile;
class AliFMDCorrELossFit;

class AliFMDDensityCalculator : public TNamed
{
public:
  enum { 
    kPhiNoCorrect,
    kPhiCorrectNch,
    kPhiCorrectELoss
  };
  static const char* fgkFolderName;
  AliFMDDensityCalculator();
  AliFMDDensityCalculator(const char* name);
  AliFMDDensityCalculator(const AliFMDDensityCalculator& o);
  virtual ~AliFMDDensityCalculator();
  AliFMDDensityCalculator& operator=(const AliFMDDensityCalculator& o);
  virtual void SetupForData(const TAxis& etaAxis);
  virtual Bool_t Calculate(const AliESDFMD&        fmd, 
         AliForwardUtil::Histos& hists, 
         Bool_t          lowFlux, 
         Double_t        cent=-1, 
         const TVector3&         ip=TVector3(1024,1024,0));
  virtual void Terminate(const TList* dir, TList* output, Int_t nEvents);
  virtual void CreateOutputObjects(TList* dir);
  void SetDebug(Int_t dbg=1) { fDebug = dbg; }  
  void SetDoTiming(Bool_t enable=true) { fDoTiming = enable; }
  void SetMaxParticles(UShort_t m) { fMaxParticles = m; }  
  void SetUsePoisson(Bool_t u) { fUsePoisson = u; }
  void SetRecalculatePhi(Bool_t use) { fRecalculatePhi = use; }
  void SetUsePhiAcceptance(UShort_t u=kPhiCorrectNch) { fUsePhiAcceptance = u; }
  void SetLumping(Int_t eta, Int_t phi) { 
    fEtaLumping = (eta < 1 ? 1 : eta); 
    fPhiLumping = (phi < 1 ? 1 : phi); 
  }
  void SetMinQuality(UShort_t cut=10) { fMinQuality = cut; }
  void SetMaxOutliers(Double_t ratio=0.10) { fMaxOutliers = ratio; }
  void SetOutlierCut(Double_t cut=0.50) { fOutlierCut = cut; }
  Double_t GetMultCut(UShort_t d, Char_t r, Double_t eta, 
          Bool_t errors=true) const;
  Double_t GetMultCut(UShort_t d, Char_t r, Int_t ieta, 
          Bool_t errors=true) const;
  UShort_t GetMinQuality() const { return fMinQuality; }
  void Print(Option_t* option="") const;
  AliFMDMultCuts& GetCuts() { return fCuts; }
  void SetCuts(const AliFMDMultCuts& c) { fCuts = c; }
protected:
  Int_t FindMaxWeight(const AliFMDCorrELossFit* cor,
          UShort_t d, Char_t r, Int_t iEta) const;

  Int_t FindMaxWeight(const AliFMDCorrELossFit* cor,
          UShort_t d, Char_t r, Double_t iEta) const;

  void CacheMaxWeights(const TAxis& axis);
  Int_t GetMaxWeight(UShort_t d, Char_t r, Int_t iEta) const;
  Int_t GetMaxWeight(UShort_t d, Char_t r, Float_t eta) const;

  virtual Float_t NParticles(Float_t  mult, 
           UShort_t d, 
           Char_t   r, 
           Float_t  eta, 
           Bool_t   lowFlux) const;
  virtual Float_t Correction(UShort_t d, Char_t r, UShort_t t, 
           Float_t eta, Bool_t lowFlux) const;
  virtual Float_t AcceptanceCorrection(Char_t r, UShort_t t) const;
  virtual TH1D*   GenerateAcceptanceCorrection(Char_t r) const;
  virtual Bool_t CheckOutlier(Double_t eloss, 
            Double_t poisson,
            Double_t cut=0.5) const;
  struct RingHistos : public AliForwardUtil::RingHistos
  { 
    RingHistos();
    RingHistos(UShort_t d, Char_t r);
    RingHistos(const RingHistos& o);
    RingHistos& operator=(const RingHistos& o);
    ~RingHistos();
    void SetupForData(const TAxis& eAxis);
    void CreateOutputObjects(TList* dir);
    void Terminate(TList* dir, Int_t nEvents);
    TList*    fList;
    // TH2D*     fEvsN;           // Correlation of Eloss vs uncorrected Nch
    // TH2D*     fEvsM;           // Correlation of Eloss vs corrected Nch
    // TProfile* fEtaVsN;         // Average uncorrected Nch vs eta
    // TProfile* fEtaVsM;         // Average corrected Nch vs eta
    TProfile* fCorr;           // Average correction vs eta
    TH2D*     fDensity;        // Distribution inclusive Nch
    TH2D*     fELossVsPoisson; // Correlation of energy loss vs Poisson N_ch
    TH1D*     fDiffELossPoisson;// Relative difference to Poisson
    TH2D*     fELossVsPoissonOut; // Correlation of energy loss vs Poisson N_ch
    TH1D*     fDiffELossPoissonOut;// Relative difference to Poisson
    TH1D*     fOutliers;       // Fraction of outliers per event 
    AliPoissonCalculator fPoisson; // Calculate density using Poisson method
    TH1D*     fELoss;          // Energy loss as seen by this 
    TH1D*     fELossUsed;      // Energy loss in strips with signal 
    Double_t  fMultCut;        // If set, use this
    TH1D*     fTotal;          // Total number of strips per eta
    TH1D*     fGood;           // Number of good strips per eta
    TH2D*     fPhiAcc;         // Phi acceptance vs IpZ
    TH1D*     fPhiBefore;      // Phi before re-calce 
    TH1D*     fPhiAfter;       // Phi after re-calc
    TH1D*     fEtaBefore;      // Phi before re-calce 
    TH1D*     fEtaAfter;       // Phi after re-calc
    // ClassDef(RingHistos,10);
  };
  RingHistos* GetRingHistos(UShort_t d, Char_t r) const;
  TList    fRingHistos;    //  List of histogram containers
  TH1D*    fSumOfWeights;  //  Histogram
  TH1D*    fWeightedSum;   //  Histogram
  TH1D*    fCorrections;   //  Histogram
  UShort_t fMaxParticles;  //  Maximum particle weight to use 
  Bool_t   fUsePoisson;    //  If true, then use poisson statistics 
  UShort_t fUsePhiAcceptance; // Whether to correct for corners 
  TH1D*    fAccI;          //  Acceptance correction for inner rings
  TH1D*    fAccO;          //  Acceptance correction for outer rings
  TArrayI  fFMD1iMax;      //  Array of max weights 
  TArrayI  fFMD2iMax;      //  Array of max weights 
  TArrayI  fFMD2oMax;      //  Array of max weights 
  TArrayI  fFMD3iMax;      //  Array of max weights 
  TArrayI  fFMD3oMax;      //  Array of max weights 
  TH2D*    fMaxWeights;    //  Histogram of max weights
  TH2D*    fLowCuts;       //  Histogram of low cuts
  Int_t    fEtaLumping;    //  How to lump eta bins for Poisson 
  Int_t    fPhiLumping;    //  How to lump phi bins for Poisson 
  Int_t    fDebug;         //  Debug level 
  AliFMDMultCuts fCuts;    // Cuts
  Bool_t   fRecalculatePhi;  // Whether to correct for (X,Y) offset
  UShort_t fMinQuality;      // Least quality for fits
  AliForwardUtil::Histos fCache;
  Bool_t                 fDoTiming;
  TProfile*              fHTiming;
  Double_t               fMaxOutliers; // Maximum ratio of outlier bins 
  Double_t               fOutlierCut;  // Maximum relative diviation 

  ClassDef(AliFMDDensityCalculator,14); // Calculate Nch density 
};

#endif
// Local Variables:
//   mode: C++
// End: