AliForwardFlowTaskQC.h

Go to the documentation of this file.

//
// Calculate the flow in the forward regions using the Q cumulants method
//
#ifndef ALIFORWARDFLOWTASKQC_H
#define ALIFORWARDFLOWTASKQC_H

#include "AliAnalysisTaskSE.h"
#include "TString.h"
#include <TH2D.h>
class AliAODForwardMult;
class TH1I;
class TH1D;
class TH2I;
class TH2F;
class TH2D;
class TH3D;
class TAxis;
class AliAnalysisFilter;
class AliESDEvent;
class AliForwardFlowTaskQC : public AliAnalysisTaskSE
{
public:
  AliForwardFlowTaskQC();
  AliForwardFlowTaskQC(const char* name);
  virtual ~AliForwardFlowTaskQC() {}
  virtual void UserCreateOutputObjects();
  virtual void Init() {} 
  virtual void UserExec(Option_t *option);
  virtual void Terminate(Option_t *option);
  /* @} */
  TList* GetOutputList() { return fOutputList; }
  void SetMaxFlowMoment(Short_t n) { fMaxMoment = n; } 
  void SetVertexAxis(TAxis* axis) { fVtxAxis = axis; }
  void SetCentralityAxis(TAxis* axis) { fCentAxis = axis; }
  void SetCentralityAxis(const char* bins);
  void SetDetectorCuts(Double_t fmdCut, Double_t spdCut) { fFMDCut = fmdCut; fSPDCut = spdCut; }
  void SetFlowFlags(UShort_t flags);
  static const Char_t* GetQCType(UShort_t flags, Bool_t prependUS = kTRUE);
  void SetEtaGapValue(Double_t eg) { fEtaGap = eg; }
  void SetTrackCuts(AliAnalysisFilter* trCuts) { fTrackCuts = trCuts; }
  enum EFlowFlags {
    kStdQC   = 0x0001, // Standard QC{2} and QC{4} calculations
    kEtaGap  = 0x0002, // QC{2} w/ an eta-gap
    k3Cor    = 0x0004, // 3 correlator method for QC{2} w/ an eta-gap
    kSymEta  = 0x0008, // Symmetrize ref flow in std. QC{2} and QC{4} around eta = 0
    kSatVtx  = 0x0010, // Do satellite vertex input (currently not implemented)
    kNUAcorr = 0x0020, // Apply full NUA correction
    kFMD     = 0x0040, // Use FMD for forward flow
    kVZERO   = 0x0080, // Use VZERO for forward flow
    kSPD     = 0x0100, // SPD object flag
    kMC      = 0x0200, // MC object flag
    kTracks  = 0x1000, // Use tracks for reference flow
    kTPC     = 0x3000, // Use TPC tracks
    kHybrid  = 0x5000  // Use hybrid tracks
  };
  struct CumuHistos : public TObject
  {
  public:
    /*
     * Constructor
     */
    CumuHistos() : fMaxMoment(), fRefHists(), fDiffHists(), fNUA() {}
    CumuHistos(Int_t n, UInt_t nua) : fMaxMoment(n), fRefHists(), fDiffHists(), fNUA(nua) {}
    CumuHistos(const CumuHistos& o)
      : TObject(o),
        fMaxMoment(o.fMaxMoment), // Max moment to compute
        fRefHists(o.fRefHists),   // List with ref hists
        fDiffHists(o.fDiffHists), // List with diff hists
        fNUA(o.fNUA)
    {}
    CumuHistos& operator=(const CumuHistos& o) 
    { 
      if (&o == this) return *this;
      TObject::operator=(o);
      fMaxMoment = o.fMaxMoment;
      fRefHists  = o.fRefHists;
      fDiffHists = o.fDiffHists;
      fNUA       = o.fNUA;
      return *this;
    }
    ~CumuHistos(){}
    TH1* Get(Char_t t, Int_t n, UInt_t nua = 0) const;
    void ConnectList(TString name, TList* l);
     void Add(TH1* h) const;
    Bool_t IsConnected() { return (fRefHists && fDiffHists); }
    enum {
      kNoNUA = 0, // No NUA applied
      kNUAOld,    // NUA correction from same moment applied
      kNUA        // Full cross-moment NUA correction applied
    };
  protected:
    Int_t GetPos(Int_t n, UInt_t nua) const;

    Int_t  fMaxMoment;  // Max flow moment contained
    TList* fRefHists;   // List of reference hists
    TList* fDiffHists;  // List of diff hists
    UInt_t fNUA;        // NUA tracker

    // ClassDef(CumuHistos, 1);
  }; // End of struct

protected:
  enum {
    kFillRef  = 0x1, // Fill only ref flow
    kFillDiff = 0x2, // Fill only diff flow
    kFillBoth = 0x3, // Fill both
    kReset    = 0x4, // Reset hists (used with one of the above)
  };
  enum {
    kNoEvent = 1, // No event found
    kNoForward,   // No forward object found
    kNoCentral,   // No central object found
    kNoTrigger,   // No (wrong) trigger
    kNoCent,      // No centrality
    kInvCent,     // Centrality outside range
    kNoVtx,       // No vertex
    kInvVtx,      // Vertex outside range
    kOK           // Event OK!
  };
  // ----------------- Being nested class ---------------------
  class VertexBin : public TNamed
  {
  public:
    /*
     * Constructor
     */
    VertexBin();
    VertexBin(Int_t vLow, Int_t vHigh, 
              UShort_t moment, TString type,
              UShort_t flags, 
              Double_t cut = -1, Double_t etaGap = -1.);
    VertexBin(const VertexBin& o){;}
    VertexBin& operator=(const VertexBin& v);
    ~VertexBin(){}
    void AddOutput(TList* list, TAxis* centAxis);
    Bool_t FillHists(TH2D& dNdetadphi, Double_t cent, UShort_t mode);
    Bool_t FillTracks(TObjArray* trList, AliESDEvent* esd,
          AliAnalysisFilter* trFilter, UShort_t mode);
    void CumulantsAccumulate(Double_t cent);
    void CumulantsAccumulate3Cor(Double_t cent);
    void GetLimits(Int_t bin, Int_t& aLow, Int_t& aHigh, Int_t& bLow, Int_t& bHigh) const;
    void CumulantsTerminate(TList* inlist, TList* outlist);
    /*
     * Enumeration for cumulant histograms
     */
    enum { kW2Two = 1, // <w2*two>
     kW2, // <w2>
     kW4Four, // <w4*four>
     kW4, // <w4>
     kCosphi1phi2, // <cos(phi1+phi2)> 
     kSinphi1phi2, // <sin(phi1+phi2)>
     kCosphi1phi2phi3m, // <cos(phi1-phi2-phi3)>
     kSinphi1phi2phi3m, // <sin(phi1-phi2-phi3)>
     k3pWeight, // M(M-1)(M-1) or (mp*M-2mq)(M-1)
     kCosphi1phi2phi3p, // <cos(phi1+phi2-phi3)>
     kSinphi1phi2phi3p // <sin(phi1+phi2-phi3)>
    };
  protected:
    void CalculateReferenceFlow(CumuHistos& cumu2h, CumuHistos& cumu4h, TH2I* quality, TH1D* chist, TH2D* dNdetaRef) const;
    void CalculateDifferentialFlow(CumuHistos& cumu2h, CumuHistos& cumu4h, TH2I* quality, TH2D* dNdetaDiff) const;
    void Calculate3CorFlow(CumuHistos& cumu2h, TH2I* quality, TH1D* chist, TH2D* dNdetaRef, TH2D* dNdetaDiff) const;
    void SolveCoupledFlowEquations(CumuHistos& cumu, Char_t type) const;
    Double_t CalculateNUAMatrixElement(Int_t n, Int_t m, Char_t type, Int_t binA, Int_t cBin) const;
    void AddVertexBins(CumuHistos& cumu, TList* list, UInt_t nNUA) const;
    Int_t GetBinNumberCos(Int_t n = 0) const;
    Int_t GetBinNumberSin(Int_t n = 0) const;
    void SetupNUALabels(TAxis* a) const;
    TH2I* MakeQualityHist(const Char_t* name) const;
    TH2D* MakeOutputHist(Int_t qc, Int_t n, const Char_t* ctype, UInt_t nua) const;

    UShort_t   fMaxMoment;     // Max flow moment 
    Int_t      fVzMin;         // z-vertex min must be in whole [cm]
    Int_t      fVzMax;         // z-vertex max must be in whole [cm]
    TString    fType;          // Data type
    UShort_t   fFlags;         // Flow flags, e.g., eta-gap or sat. vtx
    Double_t   fSigmaCut;      // Detector specific cut for outlier events
    Double_t   fEtaGap;        // Eta gap value
    Double_t   fEtaLims[6];    // Limits for binning in 3Cor method
    TH2D*      fCumuRef;       // Histogram for reference flow
    TH2D*      fCumuDiff;      // Histogram for differential flow
    CumuHistos fCumuHists;     // Array of histograms for cumulants calculations
    TH3D*      fCumuNUARef;    // histogram for NUA terms
    TH3D*      fCumuNUADiff;   // histogram for NUA terms
    TH2F*      fdNdedpRefAcc;  // Diagnostics histogram for acc. maps
    TH2F*      fdNdedpDiffAcc; // Diagnostics histogram for acc. maps
    TH2F*      fOutliers;      // Sigma <M> histogram 
    UShort_t   fDebug;         // Debug flag

    // ClassDef(VertexBin, 4); // object for eta dependent cumulants ananlysis
  };
  // ---------- End of nested class -------------
  AliForwardFlowTaskQC(const AliForwardFlowTaskQC& o);
  AliForwardFlowTaskQC& operator=(const AliForwardFlowTaskQC&);
  virtual void InitVertexBins();
  virtual void InitHists();
  virtual Bool_t Analyze();
  virtual void Finalize();
  void FillVtxBinList(const TList& list, TH2D& h1, Int_t vtx, UShort_t flags = 0x0) const;
  void FillVtxBinListEtaGap(const TList& list, TH2D& href, TH2D& hdiff, Int_t vtx, UShort_t flags = 0x0) const;
  void FillVtxBinList3Cor(const TList& list, TH2D& hcent, TH2D& hfwd, Int_t vtx, UShort_t flags = 0x0);
  TH2D& CombineHists(TH2D& hcent, TH2D& hfwd);
  Bool_t FillTracks(VertexBin* bin, UShort_t mode) const;
  void EndVtxBinList(const TList& list) const;
  void MakeCentralityHists(TList* list) const;
  virtual Bool_t CheckEvent(const AliAODForwardMult* aodfm);
  virtual Bool_t CheckTrigger(const AliAODForwardMult* aodfm) const;
  virtual Bool_t GetCentrality(const AliAODForwardMult* aodfm);
  virtual Bool_t GetVertex(const AliAODForwardMult* aodfm);
  AliVVZERO* GetVZERO() const;
  void FillVZEROHist(AliVVZERO* vzero);
  void PrintFlowSetup() const;

  TAxis*             fVtxAxis;       //  Axis to control vertex binning
  TAxis*             fCentAxis;      //  Axis to control centrality/multiplicity binning
  Double_t           fFMDCut;        //  FMD sigma cut for outlier events
  Double_t           fSPDCut;        //  SPD sigma cut for outlier events
  UShort_t           fFlowFlags;     //  Flow flags, e.g., eta-gap, sat. vtx.
  Double_t           fEtaGap;        //  Eta gap value
  TList              fBinsForward;   //  List with forward VertexBin objects 
  TList              fBinsCentral;   //  List with central VertexBin objects
  TList*             fSumList;       //  Sum list
  TList*             fOutputList;    //  Output list
  AliAODEvent*       fAOD;           //  AOD event
  AliAnalysisFilter* fTrackCuts;     //  ESD track cuts
  Int_t              fMaxMoment;     //  Calculate v_{n} flag
  Float_t            fVtx;           //  Z vertex bin
  Double_t           fCent;          //  Centrality
  TH2D               fHistdNdedpV0;  //  VZERO d^2N/detadphi histogram
  TH2D               fHistdNdedp3Cor;//  3 correlator d^2N/detadphi histogram
  TH2D*              fHistFMDSPDCorr;//  Diagnostics hist for multiplicity correlations between FMD and SPD
  TH1D*              fHistCent;      //  Diagnostics hist for centrality
  TH1D*              fHistVertexSel; //  Diagnostics hist for selected vertices
  TH1I*              fHistEventSel;  //  Diagnostics hist for event selection

  ClassDef(AliForwardFlowTaskQC, 5); // Analysis task for flow analysis
};

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