BCHistogramBase.h

#ifndef __BCHistogramBase__H
#define __BCHistogramBase__H

/*
 * Copyright (C) 2007-2018, the BAT core developer team
 * All rights reserved.
 *
 * For the licensing terms see doc/COPYING.
 * For documentation see http://mpp.mpg.de/bat
 */

// ---------------------------------------------------------

#include <vector>
#include <string>
#include <utility>

#include <TLegend.h>

class TH1;
class TLegendEntry;
class TObject;

// ---------------------------------------------------------

class BCHistogramBase
{
public:

    enum BCHColorScheme {
        kBlackWhite     = 0,
        kGreenYellowRed = 1,
        kBlueOrange     = 2,
        kRedGreen       = 3
    };

    BCHistogramBase(const TH1* const hist = 0, int dimension = 0);

    BCHistogramBase(const BCHistogramBase& other);

    virtual ~BCHistogramBase();

    BCHistogramBase& operator=(BCHistogramBase other);

    friend void swap(BCHistogramBase& first, BCHistogramBase& second);

    BCHistogramBase& operator=(const TH1* const hist)
    { SetHistogram(hist); return *this; }

    BCHistogramBase& operator=(const TH1& hist)
    { SetHistogram(&hist); return *this; }

    TH1* GetHistogram()
    { return fHistogram; };

    unsigned GetDimension() const
    { return fDimension; }

    TLegend& GetLegend()
    { return fLegend; }

    unsigned GetNLegendColumns() const
    { return fNLegendColumns; }

    std::vector<double>&  GetBestFitParameters()
    { return fGlobalMode; }

    const std::vector<double>&  GetBestFitParameters() const
    { return fGlobalMode; }

    double GetBestFitParameters(unsigned i) const
    { return fGlobalMode.at(i); }

    std::vector<double>& GetLocalMode()
    { return fLocalMode; }

    const std::vector<double>& GetLocalMode() const
    { return fLocalMode; }

    double GetLocalMode(unsigned i)
    { return fLocalMode.at(i); }

    int GetBandColor(int index) const
    { return fBandColors.at(index); };

    bool GetBandOvercoverage() const
    { return fBandOvercoverage; }

    int GetLineColor() const
    { return fLineColor; }

    int GetLineStyle() const
    { return fLineStyle; }

    int GetLineWidth() const
    { return fLineWidth; }

    int GetMarkerColor() const
    { return fMarkerColor; }

    double GetMarkerScale() const
    { return fMarkerScale; }

    short GetBandFillStyle() const
    { return fBandFillStyle; }

    unsigned GetNBands() const
    { return fNBands; }

    unsigned GetNSmooth() const
    { return fNSmooth; }

    bool GetDrawGlobalMode() const
    { return fDrawGlobalMode; }

    bool GetDrawGlobalModeArrows() const
    { return fDrawGlobalMode and fDrawGlobalModeArrows; }

    int GetBestFitParametersMarkerStyle() const
    { return fGlobalModeMarkerStyle; }

    bool GetDrawLocalMode() const
    { return fDrawLocalMode; }

    bool GetDrawLocalModeArrows() const
    { return fDrawLocalMode and fDrawLocalModeArrows; }

    int GetLocalModeMarkerStyle() const
    { return fLocalModeMarkerStyle; }

    bool GetDrawMean() const
    { return fDrawMean; }

    int GetMeanMarkerStyle() const
    { return fMeanMarkerStyle; }

    bool GetDrawStandardDeviation() const
    { return fDrawMean and fDrawStandardDeviation; }

    bool GetLogx() const
    { return fLogx; }

    bool GetLogy() const
    { return fLogy; }

    bool GetLogz() const
    { return fLogz; }

    bool GetGridx() const
    { return fGridx; }

    bool GetGridy() const
    { return fGridy; }

    std::vector<double>& GetIntervals()
    { return fIntervals; }

    const std::vector<double>& GetIntervals() const
    { return fIntervals; }

    std::string& GetROOToptions()
    { return fROOToptions; }

    const std::string& GetROOToptions() const
    { return fROOToptions; }

    virtual void CopyOptions(const BCHistogramBase& other);

    void SetGlobalMode(std::vector<double> gm)
    { fGlobalMode = gm; }

    void UnsetGlobalMode()
    { fGlobalMode.clear(); }

    void SetGlobalMode(unsigned i, double lm)
    { if (i < fGlobalMode.size()) fGlobalMode[i] = lm; }

    void SetLocalMode(std::vector<double> lm)
    { fLocalMode = lm; }

    void UnsetLocalMode()
    { fLocalMode.clear(); }

    void SetLocalMode(unsigned i, double lm)
    { if (i < fLocalMode.size()) fLocalMode[i] = lm; }

    virtual void SetColorScheme(BCHColorScheme scheme);

    void AddBandColor(int c)
    { fBandColors.push_back(c); }

    void SetBandColor(unsigned i, int c)
    { if (i < fBandColors.size()) fBandColors[i] = c; }

    void SetBandOvercoverage(bool flag = true)
    { fBandOvercoverage = flag; }

    void SetLineColor(int c)
    { fLineColor = c; }

    void SetLineStyle(int s)
    { fLineStyle = s; }

    void SetLineWidth(int w)
    { fLineWidth = w; }

    void SetMarkerColor(int c)
    { fMarkerColor = c; }

    void SetMarkerScale(double s)
    { fMarkerScale = s; }

    void SetBandFillStyle(short f)
    { fBandFillStyle = f; }

    virtual void SetHistogram(const TH1* const hist);

    void SetLogx(bool flag = true)
    { fLogx = flag; }

    void SetLogy(bool flag = true)
    { fLogy = flag; }

    void SetLogz(bool flag = true)
    { fLogz = flag; }

    void SetGridx(bool flag = true)
    { fGridx = flag; }

    void SetGridy(bool flag = true)
    { fGridy = flag; }

    void SetNBands(unsigned n)
    { fNBands = n; fIntervals = DefaultIntervals(); }

    void SetNSmooth(unsigned n)
    { fNSmooth = n; }

    void SetDrawGlobalMode(bool flag = true, bool arrows = true)
    { fDrawGlobalMode = flag; fDrawGlobalModeArrows = arrows;}

    void SetGlobalModeMarkerStyle(int s)
    { fGlobalModeMarkerStyle = s; }

    void SetDrawLocalMode(bool flag = true, bool arrows = true)
    { fDrawLocalMode = flag; fDrawLocalModeArrows = arrows;}

    void SetLocalModeMarkerStyle(int s)
    { fLocalModeMarkerStyle = s; }

    void SetDrawMean(bool flag = true, bool stddev = true)
    { fDrawMean = flag; fDrawStandardDeviation = stddev;}

    void SetMeanMarkerStyle(int s)
    { fMeanMarkerStyle = s; }

    void SetDrawLegend(bool flag = true)
    { fDrawLegend = flag; }

    void SetNLegendColumns(unsigned n)
    { fNLegendColumns = n; }

    void SetStats(bool flag = true)
    { fDrawStats = flag; }

    void SetIntervals(std::vector<double> intervals)
    { fIntervals = intervals; }

    void SetInterval(double interval)
    { fIntervals.clear(); fIntervals.push_back(interval); }

    void AddInterval(double interval)
    { fIntervals.push_back(interval); }

    void SetROOToptions(const std::string& options)
    { fROOToptions = options; }

    virtual bool Valid() const;

    void ClearBandColors()
    { fBandColors.clear(); }

    void ClearIntervals()
    { fIntervals.clear(); }

    void Smooth(int n = -1);

    virtual void Draw();

    virtual void DrawBands(const std::string& /*options*/)
    { }

    virtual void DrawMarkers();

    virtual void DrawGlobalMode();

    virtual void DrawLocalMode();

    virtual void DrawMean();

    virtual double ResizeLegend();

    virtual void DrawLegend();

    void GetNonzeroBinDensityMassVector(std::vector<std::pair<double, double> >& bin_dens_mass, int sort = -1);

    std::vector<std::pair<double, double> > GetSmallestIntervalBounds(std::vector<double> masses, bool overcoverage = true);

    virtual std::vector<double> GetSmallestIntervalSize(std::vector<double> masses, bool overcoverage = true);

    virtual double GetSmallestIntervalSize(double mass, bool overcoverage = true);

    virtual void CheckIntervals(std::vector<double>& intervals, int sort);

    virtual std::vector<double> DefaultIntervals(int nbands = -1);

    TLegendEntry* AddLegendEntry(TObject* obj, const std::string& label, const std::string& options);

    TLegendEntry* AddBandLegendEntry(TObject* obj, const std::string& label, const std::string& options);

protected:

    TH1* fHistogram;

    TLegend fLegend;

    unsigned fNLegendColumns;

    std::vector<double> fGlobalMode;

    std::vector<double> fLocalMode;

    std::vector<int> fBandColors;

    bool fBandOvercoverage;

    short fBandFillStyle;

    int fLineColor;

    int fLineStyle;

    int fLineWidth;

    int fMarkerColor;

    double fMarkerScale;

    bool fLogx;

    bool fLogy;

    bool fLogz;

    bool fGridx;

    bool fGridy;

    unsigned fNBands;

    unsigned fNSmooth;

    bool fDrawGlobalMode;

    bool fDrawGlobalModeArrows;

    int fGlobalModeMarkerStyle;

    bool fDrawLocalMode;

    bool fDrawLocalModeArrows;

    int fLocalModeMarkerStyle;

    bool fDrawMean;

    int fMeanMarkerStyle;

    bool fDrawStandardDeviation;

    bool fDrawLegend;

    bool fDrawStats;

    int fDimension;

    std::vector<double> fIntervals;

    std::string fROOToptions;

    mutable std::vector<TObject*> fROOTObjects;

    std::vector<TLegendEntry*> fExtraLegendEntries;

};

// ---------------------------------------------------------

#endif