AliBasedNdetaTask.h

Go to the documentation of this file.

//
// Task to analyse the AOD for for dN/deta in the base regions 
//
#ifndef ALIBASEDNDETATASK_H
#define ALIBASEDNDETATASK_H

#include "AliBaseAODTask.h"
#include <AliAnalysisUtils.h>
class TAxis;
class TList;
class TH2D;
class TH2F;
class TH1D;
class TH1I;
class TF1;
class TProfile;
class AliAODEvent;
class AliAODForwardMult;
class TObjArray;

class AliBasedNdetaTask : public AliBaseAODTask
{
public:
  enum {
    kNone = 0,
    kEventLevel = 0x1,
    kDummy = 0x2, 
    kBackground = 0x4,
    kTriggerEfficiency = 0x8,
    kZeroBin = 0x10,
    kFull = kEventLevel | kBackground | kTriggerEfficiency,
  };
  enum EPileupMask { 
    kPileupNormal = 0, 
    kPileupSPD    = 0x1, 
    kPileupTrk    = 0x2, 
    kPileupBC     = 0x4, 
    kPileupFull   = 0x8,
    kPileupIgnore = 0x10,
    kPileupUtil = 0x20,
    kPileupBins = 0x40,
  };

  enum ECentralityEstimator { 
    kCentNone,
    kCentDefault,   // What ever stored in AOD 
    kCentV0M,       // VZERO multiplcity 
    kCentV0A,       // VZERO-A 
    kCentV0A123,    // VZERO-A 
    kCentV0C,       // VZERO-C
    kCentFMD,       // FMD
    kCentTrk,       // Tracks
    kCentTkl,       // Tracklets
    kCentCL0,       // Clusters in SPD-0
    kCentCL1,       // Clusters in SPD-1
    kCentCND,       // Candle - tracks+tracklets
    kCentZNA,       // ZDC neutrons A-side
    kCentZNC,       // ZDC neutrons C-side
    kCentZPA,       // ZDC protons A-side
    kCentZPC,       // ZDC protons C-side
    kCentNPA,       // ?
    kCentV0MvsFMD,  // V0M vs FMD
    kCentTklvsV0M,  // Tracks vs V0M
    kCentZEMvsZDC,  // ZDC veto vs neutrons
    kMult,          // Reference multiplicity in @f$|\eta|<0.8@f$ 
    kMultV0A,       // HMTF V0A
    kMultV0M,       // HMTF V0M
    kMultV0C,       // HMTF V0C 
    kCentTrue = 0x100, 
    kCentEq   = 0x200
  };
  AliBasedNdetaTask();
  AliBasedNdetaTask(const char* name);
  virtual ~AliBasedNdetaTask();
  
  virtual void SetDebugLevel(Int_t level);
  void SetCorrEmpty(Bool_t use) { fCorrEmpty = use; }
  void SetUseROOTProjectX(Bool_t use) { fUseROOTProj = use; }
  void SetUseUtilPileup(Bool_t use) { fUseUtilPileup = use; }
  void SetTriggerEff(Double_t e) { fTriggerEff = e; } 
  void SetTriggerEff0(Double_t e) { fTriggerEff0 = e; } 
  void SetSatelliteVertices(Bool_t satVtx) { fSatelliteVertices = satVtx; }
  Bool_t SetCentralityMethod(const TString& method);
  AliAnalysisUtils& GetAnalysisUtils() { return fAnaUtil; }
  static const Char_t* NormalizationSchemeString(UShort_t scheme);
  static UShort_t ParseNormalizationScheme(const Char_t* what);
  void SetNormalizationScheme(UShort_t scheme);
  void SetNormalizationScheme(const char* what);
  void SetMCFinalCorrFilename(const char* filename) { 
    fFinalMCCorrFile.Clear();
    fFinalMCCorrFile.Append(filename); 
  }
  void Print(Option_t* option="R") const;
  virtual Bool_t Book();
  virtual Bool_t PreEvent() {
    fCacheCent = -10; fCacheQual = 0xFFFF; return true; } 
  virtual Bool_t Event(AliAODEvent& aod);
  virtual Bool_t Finalize();
  /* @} */

  static TH1D* ProjectX(const TH2D* h, 
      const char* name,
      Int_t firstbin, 
      Int_t lastbin, 
      bool  useROOT=false,
      bool  corr=true,
      bool  error=true);
  static void ScaleToCoverage(TH2D* copy, const TH1D* norm);
  static void ScaleToCoverage(TH1D* copy, const TH1D* norm);
  static void SetHistogramAttributes(TH1D* h, Int_t colour, Int_t marker, 
             const char* title, 
             const char* ytitle=0);
  enum { 
    kSolid        = 0x000, 
    kHollow       = 0x001, 
    kCircle       = 0x002,
    kSquare       = 0x004, 
    kUpTriangle   = 0x006, 
    kDownTriangle = 0x008, 
    kDiamond      = 0x00a,
    kCross        = 0x00c,
    kStar         = 0x00e
  };
  static Int_t GetMarkerStyle(UShort_t bits);
  static UShort_t GetMarkerBits(Int_t style);
  static Int_t FlipHollowStyle(Int_t style);
  void SetGlobalEmpiricalcorrection(TH2D* h){fEmpiricalCorrection=h;}
  void SetIpzReweight(TF1* f) { fIpzReweight = f; }
protected:
  AliBasedNdetaTask(const AliBasedNdetaTask&){;}
  AliBasedNdetaTask& operator=(const AliBasedNdetaTask&);
  // Forward declaration 
  class CentralityBin;
  virtual Bool_t CheckEvent(const AliAODForwardMult& forward);
  virtual void InitializeCentBins();
  virtual TH2D* GetHistogram(const AliAODEvent& aod, Bool_t mc=false) = 0;
  virtual Int_t GetColor() const { return kBlack; }
  virtual Int_t GetMarker() const { return GetMarkerStyle(kCircle); }
  virtual void CheckEventData(Double_t vtx, 
            TH2*     data, 
            TH2*     mcData);
  void AddCentralityBin(UShort_t at, Float_t low, Float_t high);
  virtual CentralityBin* MakeCentralityBin(const char* name, Float_t low, 
             Float_t high) const;
  
  // function which applies empirical correction to the AOD object 
  Bool_t ApplyEmpiricalCorrection(const AliAODForwardMult* aod,TH2D* data);
  static TH1* Asymmetry(TH1* h);
  static Int_t GetCentMethodID(const TString& meth);
  static const char* GetCentMethod(UShort_t id);
  Double_t GetCentrality(AliAODEvent&       event,
       AliAODForwardMult* forward,
       Int_t&             qual);
  Double_t GetCentrality(AliAODEvent&       event,
       AliAODForwardMult* forward);
  //==================================================================
  struct Sum : public TNamed
  {
    TH2D* fSum;     // Sum of non-zero events
    TH2D* fSum0;    // Sum of zero events 
    TH1I* fEvents;  // Distribution of events 
    Int_t fDebug;   // Debug level
    Sum() : fSum(0), fSum0(0), fEvents(0), fDebug(0) {}
    Sum(const char* name, const char* postfix) 
      : TNamed(name,postfix), 
  fSum(0), 
  fSum0(0), 
  fEvents(0), 
  fDebug(0) 
    {}
    Sum(const Sum& o) 
      : TNamed(o), 
  fSum(o.fSum), 
  fSum0(o.fSum0), 
  fEvents(o.fEvents), 
  fDebug(o.fDebug) 
    {}
    Sum& operator=(const Sum& o) 
    {
      if (&o == this) return *this;
      SetName(o.GetName()); fSum = o.fSum; fSum0 = o.fSum0; fEvents=o.fEvents;
      return *this;
    }
    ~Sum() {}
    void Init(TList* list, const TH2D* data, Int_t col);
    void Add(const TH2D* data, Bool_t isZero, Double_t weight);
    static TString GetHistName(const char* name, Int_t what=0, 
             const char* post=0);
    TString GetHistName(Int_t what=0) const;
    TH2D* CalcSum(TList* o, Double_t& ntotal,
      Double_t zeroEff, Double_t otherEff=1, Int_t marker=20,
      Bool_t rootXproj=false, Bool_t corrEmpty=true) const;

    virtual void Print(Option_t* option="") const;
    // ClassDef(Sum,2); // Summed histograms
  };
    
  //==================================================================
  class CentralityBin : public TNamed
  {
  public:
    CentralityBin();
    CentralityBin(const char* name, Float_t low, Float_t high);
    CentralityBin(const CentralityBin& other);
    virtual ~CentralityBin();
    CentralityBin& operator=(const CentralityBin& other);
    Bool_t IsAllBin() const { return fLow == 0 && fHigh == 0; }
    Bool_t IsInclusiveBin() const { return fLow == 0 && fHigh == 101; }
    const char* GetListName() const;
    virtual void CreateOutputObjects(TList* dir, Int_t mask);
    virtual Bool_t ProcessEvent(const AliAODForwardMult* forward, 
        UInt_t                   triggerMask,
        Bool_t                   isZero,
        Double_t                 vzMin, 
        Double_t                 vzMax, 
        const TH2D*              data, 
        const TH2D*              mc,
        UInt_t                   filter,
        Double_t                 weight);
    virtual Double_t Normalization(const TH1I& t, 
           UShort_t    scheme,
           Double_t    trgEff,
           Double_t&   ntotal,
           TString*    text) const;
    virtual void MakeResult(const TH2D* sum,  
          const char* postfix, 
          bool        rootProj, 
          bool        corrEmpty,
          Double_t    scaler,
          Int_t       marker,
          Int_t       color, 
          TList*      mclist,
          TList*      truthlist);
    virtual bool End(TList*      sums, 
         TList*      results,
         UShort_t    scheme,
         Double_t    trigEff,
         Double_t    trigEff0,
         Bool_t      rootProj,
         Bool_t      corrEmpty, 
         Int_t       triggerMask,
         Int_t       marker,
         Int_t       color,
         TList*      mclist,
         TList*      truthlist);
    const Sum* GetSum(Bool_t mc=false) const { return mc ? fSumMC : fSum; }
    Sum* GetSum(Bool_t mc=false) { return mc ? fSumMC : fSum; }
    const TH1I* GetTriggers() const { return fTriggers; } 
    TH1I* GetTriggers() { return fTriggers; }
    const TH1I* GetStatus() const { return fStatus; } 
    TH1I* GetStatus() { return fStatus; }
    Int_t GetColor(Int_t fallback=kRed+2) const;
    void SetColor(Color_t colour) { fColor = colour; }
    TList* GetResults() const { return fOutput; }
    const char* GetResultName(const char* postfix="") const;
    TH1* GetResult(const char* postfix="",
       Bool_t      verbose=true) const;
    void SetDebugLevel(Int_t lvl);
    void SetSatelliteVertices(Bool_t satVtx) { fSatelliteVertices = satVtx; }
    virtual void Print(Option_t* option="") const;
  protected:
    virtual Bool_t ReadSum(TList* list, bool mc=false);
    virtual void CreateSums(const TH2D* data, const TH2D* mc);
    virtual Bool_t CheckEvent(const AliAODForwardMult* forward, 
            Int_t                    triggerMask,
            Double_t                 vzMin, 
            Double_t                 vzMax,
            Int_t                    filter);
    TList*   fSums;      // Output list 
    TList*   fOutput;    // Output list 
    Sum*     fSum;       // Sum histogram
    Sum*     fSumMC;     // MC sum histogram
    TH1I*    fTriggers;  // Trigger histogram 
    TH1I*    fStatus;    // Trigger histogram 
    Float_t  fLow;       // Lower limit (inclusive)
    Float_t  fHigh;      // Upper limit (exclusive)
    Bool_t   fDoFinalMCCorrection; //Do final MC correction
    Bool_t   fSatelliteVertices; // Satellite vertex flag
    Int_t    fDebug;     // Debug level
    Color_t  fColor;     // Colour used 

    // ClassDef(CentralityBin,5); // A centrality bin 
  };
  Bool_t          fCorrEmpty;    // Correct for empty bins 
  Bool_t          fUseROOTProj;  // Whether to use ROOT's ProjectionX
  Double_t        fTriggerEff;   // Trigger efficiency for selected trigger(s)
  Double_t        fTriggerEff0;  // Bin-0 Trigger efficiency for sel trigger(s)
  TObjArray*      fListOfCentralities; // Centrality bins 
  UShort_t        fNormalizationScheme; // Normalization scheme
  TString         fFinalMCCorrFile; //Filename for final MC corr
  Bool_t          fSatelliteVertices; // satellite vertex flag
  TH2D*           fEmpiricalCorrection; // Empirical correction 
  TProfile*     fMeanVsC;         //mean signal per event vs cent
  TH1D*           fSeenCent;      // The seen centrality 
  TH1D*           fTakenCent;     // The taken centrality 
  TString         fCentMethod;    // Centrality estimator 
  AliAnalysisUtils fAnaUtil;      // Analysis utility 
  Bool_t          fUseUtilPileup; // Check for SPD outliers
  TF1*            fIpzReweight;   // Re-weighing function
  Double_t        fCacheCent;     // Stored centrality
  Int_t           fCacheQual;     // Stored centrality quality flag 
  ClassDef(AliBasedNdetaTask,19); // Determine charged particle density
};

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