BCVariableSet.h

#ifndef __BCVARIABLESET__H
#define __BCVARIABLESET__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 <vector>
#include <string>

#include "BCLog.h"
#include "BCAux.h"

#include <TString.h>

class TRandom;

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

template<class T>
class BCVariableSet
{
public:

    BCVariableSet() :
        fMaxNameLength(0)
    {
    }

    /*
     * Destructor */
    virtual ~BCVariableSet()
    {
    }

    virtual bool Add(const T& var)
    {
        // check if variable with same name or same safe name exists
        for (unsigned int i = 0; i < fVars.size() ; ++i)
            if (var.IsNamed(fVars[i].GetName())) {
                BCLog::OutError("BCVariableSet::Add : Variable with name" + var.GetName() + "exists already.");
                return false;
            } else if ( var.IsSafeNamed(fVars[i].GetSafeName()) ) {
                BCLog::OutError("BCVariableSet::Add : Variable with safe name " + var.GetSafeName() + " exists already.");
                return false;
            }

        // add var to container
        fVars.push_back(var);
        fMaxNameLength = std::max(fMaxNameLength, (unsigned)var.GetName().length());

        return true;
    }

    virtual bool Add(const std::string& name, double min, double max, const std::string& latexname = "", const std::string& unitstring = "")
    {
        // check if variable with same name or same safe name exists
        for (unsigned int i = 0; i < fVars.size() ; ++i)
            if (fVars[i].IsNamed(name)) {
                BCLog::OutError("BCVariableSet::Add : Variable with name " + name + " exists already.");
                return false;
            } else if ( fVars[i].IsSafeNamed(BCAux::SafeName(name)) ) {
                BCLog::OutError("BCVariableSet::Add : Variable with safe name " + fVars[i].GetSafeName() + "%s exists already.");
                return false;
            }

        // add var to container
        fVars.push_back(T(name, min, max, latexname, unitstring));
        fMaxNameLength = std::max(fMaxNameLength, (unsigned)name.length());

        return true;
    }

    virtual T& operator[](unsigned index)
    {   return fVars[index]; }

    virtual const T& operator[](unsigned index) const
    {   return fVars[index]; }

    virtual T& At(unsigned index)
    { return fVars.at(index); }

    virtual const T& At(unsigned index) const
    { return fVars.at(index); }

    virtual T& Get(const std::string& name)
    {   return At(Index(name)); }

    virtual const T& Get(const std::string& name) const
    {   return At(Index(name)); }

    virtual T& Back()
    { return fVars.back(); }

    virtual const T& Back() const
    { return fVars.back(); }

    virtual unsigned Index(const std::string& name) const
    {
        for (unsigned int i = 0; i < fVars.size() ; ++i)
            if ( fVars[i].IsNamed(name) )
                return i;
        BCLog::OutWarning("BCVariableSet::Index : no variable named '" + name + "'");
        return fVars.size();
    }

    virtual unsigned Size() const
    { return fVars.size(); }

    virtual bool Empty() const
    { return fVars.empty(); }

    virtual void SetNBins(unsigned nbins)
    {
        for (unsigned i = 0 ; i < fVars.size() ; ++i )
            fVars[i].SetNbins(nbins);
    }

    virtual void SetPrecision(unsigned n)
    {
        for (unsigned i = 0 ; i < fVars.size() ; ++i )
            fVars[i].SetPrecision(n);
    }

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

    virtual void FillHistograms(bool flag_1d, bool flag_2d)
    { FillH1(flag_1d); FillH2(flag_2d); }

    virtual void FillH1(bool flag)
    {
        for (unsigned i = 0 ; i < fVars.size() ; ++i )
            fVars[i].FillH1(flag);
    }

    virtual void FillH2(bool flag)
    {
        for (unsigned i = 0 ; i < fVars.size() ; ++i )
            fVars[i].FillH2(flag);
    }

    virtual unsigned MaxNameLength() const
    { return fMaxNameLength; }

    virtual double Volume() const
    {
        double volume = 1;
        for (unsigned i = 0; i < fVars.size(); ++i)
            volume *= fVars[i].GetRangeWidth();
        if (volume < 0)
            return 0;
        return volume;
    }

    virtual bool IsWithinLimits(const std::vector<double>& x) const
    {
        if (x.size() != fVars.size())
            return false;
        for (unsigned i = 0; i < fVars.size(); ++i)
            if (!fVars[i].IsWithinLimits(x[i]))
                return false;
        return true;
    }

    virtual std::vector<double> PositionInRange(const std::vector<double>& x) const
    {
        std::vector<double> p;
        for (unsigned i = 0; i < fVars.size(); ++i)
            p.push_back(fVars[i].PositionInRange(x[i]));
        return p;
    }

    virtual void ValueFromPositionInRange(std::vector<double>& p) const
    {
        if ( p.size() != fVars.size() )
            return;
        for (unsigned i = 0; i < fVars.size(); ++i)
            p[i] = fVars[i].ValueFromPositionInRange(p[i]);
    }

    virtual std::vector<double> GetRangeCenters() const
    {
        std::vector<double> p;
        for (unsigned i = 0; i < fVars.size(); ++i)
            p.push_back(fVars[i].GetRangeCenter());
        return p;
    }

    virtual std::vector<double> GetUniformRandomValues(TRandom* const R) const
    {
        std::vector<double> p;
        for (unsigned i = 0; i < fVars.size(); ++i)
            p.push_back(fVars[i].GetUniformRandomValue(R));
        return p;
    }

    virtual void PrintSummary() const
    {
        unsigned n = (int)log10(fVars.size()) + 1;
        for (unsigned i = 0; i < fVars.size(); ++i)
            BCLog::OutSummary(Form(" %*u) ", n, i) + fVars[i].OneLineSummary(false, fMaxNameLength));
    }

protected:
    std::vector<T> fVars;

    unsigned fMaxNameLength;

};
#endif