DividedHisto.h

/*
 * HalDividedHisto1D.h
 *
 *  Created on: 30-04-2022
 *      Author: Daniel Wielanek
 *      E-mail: daniel.wielanek@gmail.com
 *      Warsaw University of Technology, Faculty of Physics
 */
#ifndef HALDIVIDEDHISTO1D_H_
#define HALDIVIDEDHISTO1D_H_
 
#include "Object.h"
 
#include <TH2.h>
#include <TH3.h>
#include <TString.h>
 
 
namespace Hal {
  class HistoStyle;
  class HistogramAxisConf;
  class DividedHisto1D : public Object {
    friend class HistoStyle;
 
  private:
    Bool_t fNumIsCloned;
    Bool_t fDenIsCloned;
 
  protected:
    TH1* fNum;
    TH1* fDen;
    Bool_t fBinomial;
    const Int_t fDim;
    Double_t* fNormMin;  //[fDim]
    Double_t* fNormMax;  //[fDim]
    Double_t fScale;
    TString fAxisName;
    TString fComment;
    TList* fLabels;
    DividedHisto1D(TString name, const Int_t dim);
    virtual void Folding1D(Double_t val, Option_t* axis);
    virtual void Normalize(TH1* h) const;
    virtual TString CommonExtract(Int_t counter, TString dir) const;
    virtual void SetHistoName(TH1* h) const;
    virtual TString GetPic() const;
    virtual void ApplyStyle(const HistoStyle& h);
 
  public:
    DividedHisto1D();
    DividedHisto1D(TString name) : DividedHisto1D(name, 1) {};
    DividedHisto1D(TString name, Int_t nbins, Double_t min, Double_t max, Char_t type = 'D');
    DividedHisto1D(TString name, const HistogramAxisConf& conf, Char_t type = 'D');
    DividedHisto1D(const DividedHisto1D& other);
    DividedHisto1D& operator=(const DividedHisto1D& other);
    void SetScale(Double_t scale);
    void SetAxisName(TString name);
    TH1* GetNum() const;
    TH1* GetDen() const;
    TH1* GetHist(Bool_t normalized = kTRUE) const;
    void SetOwnerNum(Bool_t own) { fNumIsCloned = own; };
    void SetOwnerDen(Bool_t own) { fDenIsCloned = own; };
    void SetOwner(Bool_t own) { fNumIsCloned = fDenIsCloned = own; };
    void SetNorm(Double_t min, Double_t max, Int_t axis = 0);
    void AddLabel(TString label);
    void SetBinomial(Bool_t binomial);
    void SetComment(TString comment);
    void FillNum(Double_t x, Double_t weight) { fNum->Fill(x, weight); };
    void FillDen(Double_t x, Double_t weight) { fDen->Fill(x, weight); };
    virtual void AddNum(TH1* num, Option_t* opt = "");
    virtual void AddDen(TH1* den, Option_t* opt = "");
    virtual void AddNumDen(TH1* num, TH1* den, Option_t* opt = "");
    virtual void AddScaled(const DividedHisto1D& other, Double_t scale = 1);
    void Fold1D(Double_t val, Option_t* opt = "x");
    virtual void Rebin(Int_t ngroup, Option_t* opt);
    virtual void Add(const Object* h);
    virtual void Browse(TBrowser* b);
    virtual void FillNumObj(TObject* /*obj*/) {};
    virtual void FillDenObj(TObject* /*obj*/) {};
    virtual void Print(Option_t* opt) const;
    virtual void SetDirectory(TDirectory* dir = nullptr);
    Int_t GetNDim() const { return fDim; };
    Int_t GetLabelsNo() const;
    Bool_t IsBinomial() const { return fBinomial; };
    Bool_t IsDenOwner() const { return fDenIsCloned; };
    Bool_t IsNumOwner() const { return fNumIsCloned; };
    Bool_t IsOwner() const { return (fNumIsCloned && fDenIsCloned); };
    Double_t GetNormMin(Int_t no = 0) const;
    Double_t GetNormMax(Int_t no = 0) const;
    Double_t GetScale() const;
    Double_t CalculateNorm(Double_t min, Double_t max) const;
    virtual Long64_t Merge(TCollection* collection);
    TString GetAxisName() const { return fAxisName; };
    TList* GetLabelList() const { return fLabels; };
    TString GetLabel(Int_t i) const;
    TString GetExtractType() const;
    TString GetComment() const { return fComment; };
    virtual void Draw(Option_t* opt = "all");
    virtual TString HTMLExtract(Int_t counter = 0, TString dir = " ") const;
    virtual TObject* GetSpecial(TString opt) const { return nullptr; }
    virtual ~DividedHisto1D();
    ClassDef(DividedHisto1D, 4)
  };
  class DividedHisto2D : public DividedHisto1D {
  protected:
    virtual void Normalize(TH1* h) const;
    virtual void SetHistoName(TH1* h) const;
    virtual void Folding2D(Double_t valX, Double_t valY, Option_t* opt);
    virtual void Folding1D(Double_t val, Option_t* axis);
    DividedHisto2D(TString name, const Int_t dim) : DividedHisto1D(name, dim) {};
    TH1D* Projection2DTo1D(Double_t min, Double_t max, Option_t* opt) const;
 
  public:
    DividedHisto2D();
    DividedHisto2D(TString name) : DividedHisto1D(name, 2) {};
    DividedHisto2D(TString name,
                   Int_t binsX,
                   Double_t minX,
                   Double_t maxX,
                   Int_t binsY,
                   Double_t minY,
                   Double_t maxY,
                   Char_t type = 'D');
    DividedHisto2D(TString name, const HistogramAxisConf& axX, const HistogramAxisConf& axY, Char_t type = 'D');
    DividedHisto2D(const DividedHisto2D& other);
    void Fold2D(Double_t valX, Double_t valY, Option_t* opt = "xy");
    void FillNum(Double_t x, Double_t y, Double_t weight) { ((TH2*) fNum)->Fill(x, y, weight); };
    void FillDen(Double_t x, Double_t y, Double_t weight) { ((TH2*) fDen)->Fill(x, y, weight); };
    virtual TString HTMLExtract(Int_t counter = 0, TString dir = " ") const;
    virtual void Rebin(Int_t ngroup, Option_t* opt);
    TH1D* GetProjection1D(Double_t min, Double_t max, Option_t* opt) const { return Projection2DTo1D(min, max, opt); }
    Double_t CalculateNorm(Double_t minX, Double_t maxX, Double_t minY, Double_t maxY) const;
    virtual void Browse(TBrowser* b);
    DividedHisto2D& operator=(const DividedHisto2D& other);
    ~DividedHisto2D();
    ClassDef(DividedHisto2D, 2)
  };
  class DividedHisto3D : public DividedHisto2D {
  protected:
    void Normalize(TH1* h) const;
    virtual void SetHistoName(TH1* h) const;
    virtual void Folding1D(Double_t val, Option_t* axis);
    virtual void Folding2D(Double_t valX, Double_t valY, Option_t* opt);
    virtual TH1D* Projection3DTo1D(Double_t min1, Double_t max1, Double_t min2, Double_t max2, Option_t* opt) const;
 
  public:
    DividedHisto3D();
    DividedHisto3D(TString name) : DividedHisto2D(name, 3) {};
    DividedHisto3D(TString name,
                   const HistogramAxisConf& axX,
                   const HistogramAxisConf& axY,
                   const HistogramAxisConf& axZ,
                   Char_t type = 'D');
    DividedHisto3D(TString name,
                   Int_t binsX,
                   Double_t minX,
                   Double_t maxX,
                   Int_t binsY,
                   Double_t minY,
                   Double_t maxY,
                   Int_t binsZ,
                   Double_t minZ,
                   Double_t maxZ,
                   Char_t type = 'D');
    DividedHisto3D(const DividedHisto3D& other);
    void FillNum(Double_t x, Double_t y, Double_t z, Double_t weight) { ((TH3*) fNum)->Fill(x, y, z, weight); };
    void FillDen(Double_t x, Double_t y, Double_t z, Double_t weight) { ((TH3*) fDen)->Fill(x, y, z, weight); };
    TH1D* GetProjection1D(Double_t min1, Double_t max1, Double_t min2, Double_t max2, Option_t* opt) const {
      return Projection3DTo1D(min1, max1, min2, max2, opt);
    }
    virtual void Rebin(Int_t ngroup, Option_t* opt);
    virtual void Fold3D(Double_t valX, Double_t valY, Double_t valZ, Option_t* opt);
    virtual TH2D* GetProjection2D(Double_t min, Double_t max, Option_t* opt) const;
    Double_t CalculateNorm(Double_t minX, Double_t maxX, Double_t minY, Double_t maxY, Double_t minZ, Double_t maxZ) const;
    DividedHisto3D& operator=(const DividedHisto3D& other);
    virtual TString HTMLExtract(Int_t counter = 0, TString dir = " ") const;
    ~DividedHisto3D();
    ClassDef(DividedHisto3D, 3)
  };
}  // namespace Hal
#endif /* HALDIVIDEDHISTO1D_H_ */