BCVariable.h

#ifndef __BCVARIABLE__H
#define __BCVARIABLE__H

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

// ---------------------------------------------------------
#include <string>
#include <cmath>

class TH1;
class TH2;
class TH3;
class TRandom;

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

class BCVariable
{

public:

    BCVariable();

    BCVariable(const std::string& name, double lowerlimit, double upperlimit, const std::string& latexname = "", const std::string& unitstring = "");

    virtual ~BCVariable() {};

    virtual const std::string& GetPrefix() const
    { return fPrefix; }

    virtual const std::string& GetName() const
    { return fName; }

    virtual const std::string& GetSafeName() const
    { return fSafeName; }

    virtual const std::string& GetLatexName() const
    { return (fLatexName.empty()) ? fName : fLatexName; }

    virtual const std::string& GetUnitString() const
    { return fUnitString; }

    virtual std::string GetLatexNameWithUnits() const
    { if (GetUnitString().empty()) return GetLatexName(); return GetLatexName() + " " + GetUnitString(); }

    virtual double GetLowerLimit() const
    { return fLowerLimit; }

    virtual double GetUpperLimit() const
    { return fUpperLimit; }

    virtual double GetRangeWidth() const
    { return fUpperLimit - fLowerLimit; }

    virtual double GetRangeCenter() const
    { return (fUpperLimit + fLowerLimit) / 2.; }

    virtual unsigned GetPrecision() const
    { return fPrecision;}

    virtual bool FillH1() const
    { return fFillH1; }

    virtual bool FillH2() const
    { return fFillH2; }

    virtual unsigned GetNbins() const
    { return fNbins; }

    virtual void SetName(const std::string& name);

    virtual void SetLatexName(const std::string& latex_name)
    { fLatexName = latex_name; }

    virtual void SetUnitString(const std::string& unit_string)
    { fUnitString = unit_string; }

    virtual void SetLowerLimit(double limit)
    { SetLimits(limit, fUpperLimit); }

    virtual void SetUpperLimit(double limit)
    { SetLimits(fLowerLimit, limit); }

    virtual void SetLimits(double lowerlimit = 0, double upperlimit = 1);

    virtual void SetPrecision(unsigned precision)
    { fPrecision = precision; }

    virtual void FillHistograms(bool flag)
    { FillHistograms(flag, flag); }

    virtual void FillHistograms(bool fill_1d, bool fill_2d)
    { FillH1(fill_1d); FillH2(fill_2d); }

    virtual void FillH1(bool flag)
    { fFillH1 = flag; }

    virtual void FillH2(bool flag)
    { fFillH2 = flag; }


    virtual void SetNbins(unsigned nbins)
    { fNbins = nbins; }
    virtual bool IsNamed(const std::string& name) const
    { return fName.compare(name) == 0; }

    virtual bool IsSafeNamed(const std::string& safename) const
    { return fSafeName.compare(safename) == 0; }

    virtual double PositionInRange(double x) const
    { return (x - fLowerLimit) / (fUpperLimit - fLowerLimit); }

    virtual double ValueFromPositionInRange(double p) const
    { return fLowerLimit + p * (fUpperLimit - fLowerLimit); }

    virtual void CalculatePrecision(bool force = false);

    virtual bool IsAtLimit(double value) const;

    virtual bool IsWithinLimits(double value) const
    { return (value >= fLowerLimit and value <= fUpperLimit); }

    virtual void PrintSummary() const;

    virtual std::string OneLineSummary(bool print_prefix = true, int name_length = -1) const;

    virtual std::string H1Title() const;

    virtual std::string H2Title(const BCVariable& ordinate) const;

    virtual std::string H3Title(const BCVariable& ordinate_y, const BCVariable& ordinate_z) const;

    virtual TH1* CreateH1(const std::string& name) const;

    virtual TH2* CreateH2(const std::string& name, const BCVariable& ordinate) const;

    virtual TH3* CreateH3(const std::string& name, const BCVariable& ordinate_y, const BCVariable& ordinate_z) const;

    virtual double GetUniformRandomValue(TRandom* const R) const;

protected:
    std::string fPrefix;

    std::string fName;

    std::string fSafeName;

    double fLowerLimit;

    double fUpperLimit;

    unsigned fPrecision;

    std::string fLatexName;

    std::string fUnitString;

    bool fFillH1;

    bool fFillH2;

    unsigned fNbins;

};
#endif