BCH1D.h

#ifndef __BCH1D__H
#define __BCH1D__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 "BCHistogramBase.h"

#include <vector>

class TH1;

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

class BCH1D : public BCHistogramBase
{

public:

    enum BCH1DBandType {
        kNoBands          = -1,
        kCentralInterval  =  0,
        kSmallestInterval =  1,
        kUpperLimit       =  2,
        kLowerLimit       =  3,
        kUserSpecified    =  4
    };

    BCH1D(const TH1* const hist = 0);

    BCH1D(const BCH1D& other);

    virtual ~BCH1D() {};

    using BCHistogramBase::GetLocalMode;
    double GetLocalMode()
    { return GetLocalMode(0); }

    using BCHistogramBase::GetBestFitParameters;
    double GetBestFitParameters()
    { return GetBestFitParameters(0); }

    double GetMedian()
    { return this->GetQuantile(0.5); };

    double GetQuantile(double probability);

    double GetLimit(double probability)
    { return this->GetQuantile(probability); };

    BCH1DBandType GetBandType()
    { return fBandType; }

    unsigned GetNQuantiles()
    { return fNQuantiles; }

    int GetQuantileLineColor()
    { return fQuantileLineColor; }

    bool GetDrawMedian()
    { return fDrawMedian; }

    bool GetDrawCentral68()
    { return fDrawCentral68; }

    using BCHistogramBase::CopyOptions;

    void CopyOptions(const BCH1D& other);

    void SetColorScheme(BCHColorScheme scheme);

    using BCHistogramBase::SetGlobalMode;

    void SetGlobalMode(double mode)
    { SetGlobalMode(std::vector<double>(1, mode)); }

    using BCHistogramBase::SetLocalMode;

    void SetLocalMode(double mode)
    { SetLocalMode(std::vector<double>(1, mode)); }

    void SetBandType(BCH1DBandType bt)
    { fBandType = bt; }

    void SetDrawQuantiles(unsigned n)
    { fNQuantiles = n; }

    void SetQuantileLineColor(int c)
    { fQuantileLineColor = c; }

    void SetDrawMedian(bool flag = true, bool central68 = true)
    { fDrawMedian = flag; fDrawCentral68 = central68;}

    using BCHistogramBase::CheckIntervals;

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

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

    virtual void DrawBands(const std::string& options = "same");

    virtual void DrawMarkers();

    virtual void DrawQuantiles(unsigned n);

    virtual void DrawMedian();

    void PrintSummary(const std::string& prefix = "", unsigned prec = 6, std::vector<double> intervals = std::vector<double>(0));

    struct BCH1DInterval {
        double xmin;
        double xmax;
        double mode;
        double relative_height;
        double relative_mass;
        BCH1DInterval();

        void PrintSummary(const std::string& prefix = "", unsigned prec = 6) const;
    };

    struct BCH1DSmallestInterval {
        std::vector<BCH1D::BCH1DInterval> intervals;
        double total_mass;
        double mode;
        double max_val;

        BCH1DSmallestInterval();

        void PrintSummary(const std::string& prefix = "", unsigned prec = 6) const;
    };

    std::vector<BCH1D::BCH1DSmallestInterval> GetSmallestIntervals(std::vector<double> masses);

    BCH1D::BCH1DSmallestInterval GetSmallestIntervals(double mass)
    { return GetSmallestIntervals(std::vector<double>(1, mass)).at(0); }

    TH1* GetSubHistogram(double min, double max, const std::string& name = "", bool preserve_range = false);

protected:

    BCH1DBandType fBandType;

    unsigned fNQuantiles;

    int fQuantileLineColor;

    bool fDrawMedian;

    bool fDrawCentral68;
};

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

#endif