AliFMDHistCollector.h

Go to the documentation of this file.

// 
// This class collects the event histograms into single histograms, 
// one for each ring in each vertex bin.  
//
#ifndef ALIFMDHISTCOLLECTOR_H
#define ALIFMDHISTCOLLECTOR_H

#include <TNamed.h>
#include <TList.h>
#include <TArrayI.h>
#include "AliForwardUtil.h"
class AliESDFMD;
class TH2;
class TH2D;
class TH1D;
class TObjArray;

class AliFMDHistCollector : public TNamed
{
public:
  enum MergeMethod {
    kStraightMean,       
    kStraightMeanNoZero, 
    kWeightedMean, 
    kLeastError,
    kSum,
    kPreferInner,
    kPreferOuter

  };
  enum FiducialMethod { 
    kByCut, 
    kDistance 
  };
   enum FMDRingBits { 
     kFMD1I=0x01,
     kFMD1 =kFMD1I,
     kFMD2I=0x02,
     kFMD2O=0x04,
     kFMD2 =kFMD2I|kFMD2O,
     kFMD3I=0x08,
     kFMD3O=0x10,
     kFMD3 =kFMD3I|kFMD3O
  };
  AliFMDHistCollector();
  AliFMDHistCollector(const char* title);
  AliFMDHistCollector(const AliFMDHistCollector& o);

  virtual ~AliFMDHistCollector();
  AliFMDHistCollector& operator=(const AliFMDHistCollector&);
  virtual void SetupForData(const TAxis& vtxAxis,
        const TAxis& etaAxis);
  virtual Bool_t Collect(const AliForwardUtil::Histos& hists, 
       AliForwardUtil::Histos&       sums, 
       UShort_t                      vtxBin, 
       TH2D&                         out,
       Double_t            cent=-1.0,
       Bool_t                        eta2phi=false,
       Bool_t                        add=true);
  virtual void CreateOutputObjects(TList* dir);
  void SetMergeMethod(MergeMethod m) { fMergeMethod = m; }
  MergeMethod GetMergeMethod() const { return fMergeMethod; }
  void SetFiducialMethod(FiducialMethod m) { fFiducialMethod = m; }
  void SetNCutBins(UInt_t n=2) { fNCutBins = n; }
  void SetCorrectionCut(Float_t cut=0.5) { fCorrectionCut = cut; }
  void SetFMDRingsToSkip(UShort_t mask) { fSkipFMDRings = mask; }
  void SetMakeBGHitMaps(Bool_t use) { fBgAndHitMaps = use; }
  void SetMakeCentralitySums(Bool_t use) { fDoByCent = use; }
  void SetDebug(Int_t dbg=1) { fDebug = dbg; }
  void Print(Option_t* option="") const;
protected:
  static void GetDetRing(Int_t idx, UShort_t& d, Char_t& r);
  static Int_t GetIdx(UShort_t d, Char_t r);
  static Bool_t CheckSkip(UShort_t d, Char_t r, UShort_t skips);
  static Bool_t CheckCorrection(FiducialMethod m, Double_t cut, 
        const TH2D* bg, Int_t ie, Int_t ip);

  static void MergeBins(MergeMethod   m, 
      Double_t c,   Double_t e, 
      Double_t oc,  Double_t oe,
      Double_t& rc, Double_t& re);
  
  //==================================================================
  struct VtxBin : public TObject
  {
    VtxBin(Int_t index=0, Double_t minIpZ=999, Double_t maxIpZ=-999,
     Int_t nCut=0);
    VtxBin(const VtxBin& o);
    VtxBin& operator=(const VtxBin& o);
    const Char_t* GetName() const;
    void SetupForData(TH2*           coverage,
          UShort_t       skip,
          FiducialMethod fiducial, 
          Double_t       cut,
          TList*         l, 
          const TAxis&   etaAxis,
          Bool_t         doHitMap,
          Bool_t         storeSecMap);
    Bool_t Collect(const AliForwardUtil::Histos& hists, 
       AliForwardUtil::Histos&       sums, 
       TH2D&                         out,
       TH2D*                         sumRings,
       TH1D*                         skipped,
       Double_t                      cent,
       MergeMethod                   m,
       UShort_t                      skips,
       TList*                        byCent,
       Bool_t                        eta2phi,
       Bool_t                        add);
    Int_t GetOverlap(UShort_t d, Char_t r, Int_t bin) const;
    void GetFirstAndLast(UShort_t d, UShort_t r, 
       Int_t& first, Int_t& last) const {
      GetFirstAndLast(GetIdx(d,r), first, last);
    }
    void GetFirstAndLast(Int_t idx,Int_t& first, Int_t& last) const;
    Int_t GetFirst(Int_t idx) const;
    Int_t GetLast(Int_t idx) const;
    Int_t GetFirst(UShort_t d, Char_t r) const { return GetFirst(GetIdx(d,r));}
    Int_t GetLast(UShort_t d, Char_t r) const { return GetLast(GetIdx(d,r));}

    Int_t                   fIndex;     // Vertex bin index
    Double_t                fLow;       // Low @f$ ip_z @f$ 
    Double_t                fHigh;      // High @f$ ip_z @f$
    AliForwardUtil::Histos* fHitMap;    // Hit map (optional)
    TArrayI                 fFirstBin;  // Per-ring first bin
    TArrayI                 fLastBin;   // Per-ring last bin
    Int_t                   fNCutBins;  // Number of bins to cut 

    // ClassDef(VtxBin,1); // Vertex bin in histogram collector
  };
  VtxBin* GetVtxBin(Int_t ivtx);
  const VtxBin* GetVtxBin(Int_t ivtx) const;

  Int_t       fNCutBins;        // Number of additional bins to cut away
  Float_t     fCorrectionCut;   // Cut-off on secondary corrections 
  Int_t       fDebug;           // Debug level 
  TList*      fList;    // Output list
  TH2D*       fSumRings;        // Sum per ring (on y-axis)
  TH2D*       fCoverage;        // Sum per ring (on y-axis)
  TH1D*       fSkipped;         // Skipped rings
  MergeMethod fMergeMethod;     // Merge methiod for overlapping bins 
  FiducialMethod fFiducialMethod; // Fidicual method
  UShort_t    fSkipFMDRings;    // FMD rings to ignore     
  Bool_t      fBgAndHitMaps;    // Make hit/bg maps or not
  TObjArray*  fVtxList;         
  TList*      fByCent;          // By centrality sums
  Bool_t      fDoByCent;        // Whether to do by centrality sum
  ClassDef(AliFMDHistCollector,6); // Calculate Nch density 
};


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