ConfigParameter.cc

Go to the documentation of this file.

#include <utl/ConfigParameter.h>

#include <utl/VRandomSampler.h>
#include <utl/RandomSamplerFromPDF.h>
#include <utl/RandomSamplerFromCDF.h>
#include <utl/Branch.h>
#include <utl/ConsecutiveEnumFactory.h>
#include <utl/RandomEngine.h>
#include <utl/ErrorLogger.h>
#include <utl/TabulatedFunction.h>
//
#include <string>
#include <list>
#include <vector>
#include <algorithm>
#include <iterator>


namespace {

  class FixedSampler: public utl::VRandomSampler {
  public:
    FixedSampler(const utl::ConfigParameter::Type& v);
  protected:
    virtual double MapRandom(double rand) const;
  private:
    utl::ConfigParameter::Type fValue;
  };


  FixedSampler::FixedSampler(const utl::ConfigParameter::Type& v) :
    fValue(v)
  { }


  double
  FixedSampler::MapRandom(double /*rand*/)
    const
  {
    // Here we have a "cast" from the utl::ConfigParameter::Type
    // to double, which are the same by now.
    return fValue;
  }


  class ListSampler : public utl::VRandomSampler {
  public:
    typedef std::list<utl::ConfigParameter::Type> List;
    template<class C>
    ListSampler(const C& values);
    ListSampler(std::unique_ptr<List>& source);
  protected:
    virtual double MapRandom(const double rand) const;
  private:
    void Init();
    std::unique_ptr<List> fValues;
    mutable List::const_iterator fIt;
    List::const_iterator fEnd;
  };


  template<class C>
  ListSampler::ListSampler(const C& values) :
    fValues(new List(values.begin(), values.end()))
  {
    Init();
  }


  ListSampler::ListSampler(std::unique_ptr<List>& source) :
    fValues(std::move(source))
  {
    Init();
  }


  void
  ListSampler::Init()
  {
    // Init iterators:
    fIt = fValues->begin();
    fEnd = fValues->end();  // once and for all.
  }


  double
  ListSampler::MapRandom(double /*rand*/)
    const
  {
    if (fIt == fEnd)
      fIt = fValues->begin();  // circularly.
    // see FixedSampler regarding the cast.
    return *(fIt++);  // note post-increment.
  }

}


namespace utl {

  const char* const ConfigParameter::kFunctionTypeTags[] = { "Fixed", "PDF", "CDF", "ValueList" };

  const char* const ConfigParameter::kParametrizationTags[] =
    { "Formula", "FormulaWithVariable", "Map", "TabulatedFunction", "Vector", "VectorPair" };

  const char* const ConfigParameter::kInterpolationTags[] = { "Linear", "Discrete", "Step" };


  ConfigParameter::ConfigParameter(utl::RandomEngine& eng, const utl::Branch& configData) :
    fEngine(eng),
    fLastValue(0)
  {
    std::string tagFunc;
    configData.GetChild("functionType").GetData(tagFunc);
    FunctionType type = utl::ConsecutiveEnumFactory<FunctionType, eValueList, kFunctionTypeTags>::Create(tagFunc);
    switch (type) {
    case eFixed:
      {
        const double v = configData.GetChild("value").Get<double>();
        fSampler.reset(new FixedSampler(v));
      }
      break;
    case eValueList:
      {
        // Heap allocated and then tranfer ownership.
        std::unique_ptr<ListSampler::List> vs(new ListSampler::List());
        configData.GetChild("valueList").GetData(*vs);
        fSampler.reset(new ListSampler(vs));
      }
      break;
    case ePDF:
    case eCDF:
      {
        const std::string tagPar = configData.GetChild("parametrization").Get<std::string>();
        Parametrization par = utl::ConsecutiveEnumFactory<Parametrization, eVectorPair, kParametrizationTags>::Create(tagPar);
        // All kind of posible parameters.
        std::string function;
        double min;
        double max;
        int bins;
        std::string iVarName;
        std::map<double, double> dfMap;
        utl::TabulatedFunction dfTab;
        std::vector<double> dfVect;
        std::vector<double> xVect;
        std::vector<double> yVect;
        std::string interpol;  // watch out, the police!
        // Alias for the factory: used inside the ePDF case.
        typedef utl::RandomSamplerFromPDF::InterpolationType InterpolType;
        typedef utl::ConsecutiveEnumFactory<InterpolType, utl::RandomSamplerFromPDF::eStep, kInterpolationTags> InterpolFactory;
        // Cheap: do it despite may not be needed (so to have a little cleaner code)...
        utl::Branch interpolChild = configData.GetChild("interpolationType");
        if (interpolChild)  // ... but do a check in this case.
          interpolChild.GetData(interpol);
        switch (par) {
        case eFormulaWithVariable:
          configData.GetChild("independentVariableName").GetData(iVarName);
          // fall through
        case eFormula:
          configData.GetChild("function").GetData(function);
          configData.GetChild("min").GetData(min);
          configData.GetChild("max").GetData(max);
          configData.GetChild("bins").GetData(bins);
          if (par == eFormula) {
            if (type == ePDF)
              fSampler.reset(new utl::RandomSamplerFromPDF(function, min, max, bins));
            else
              fSampler.reset(new utl::RandomSamplerFromCDF(function, min, max, bins));
          } else {
            if (type == ePDF)
              fSampler.reset(new utl::RandomSamplerFromPDF(function, iVarName, min, max, bins));
            else
              fSampler.reset(new utl::RandomSamplerFromCDF(function, iVarName, min, max, bins));
          }
          break;
        case eMap:
          /*configData.GetChild("map").GetData(dfMap);
          if (type == ePDF)
            fSampler.reset(new utl::RandomSamplerFromPDF(dfMap, InterpolFactory::Create(interpol)));
          else
            fSampler.reset(new utl::RandomSamplerFromCDF(dfMap));*/
          ERROR("Branch doesn't provide a GetData(std::map<>) method.");
          break;
        case eTabulatedFunction:
          configData.GetChild("tabulatedFunction").GetData(dfTab);
          if (type == ePDF)
            fSampler.reset(new utl::RandomSamplerFromPDF(dfTab, InterpolFactory::Create(interpol)));
          else
            fSampler.reset(new utl::RandomSamplerFromCDF(dfTab));
          break;
        case eVector:
          configData.GetChild("vector").GetData(dfVect);
          if (type == ePDF)
           fSampler.reset(new utl::RandomSamplerFromPDF(dfTab, InterpolFactory::Create(interpol)));
          else
           fSampler.reset(new utl::RandomSamplerFromCDF(dfTab));
          break;
        case eVectorPair:
          configData.GetChild("vectorX").GetData(xVect);
          configData.GetChild("vectorY").GetData(yVect);
          if (type == ePDF)
           fSampler.reset(new utl::RandomSamplerFromPDF(xVect, yVect, InterpolFactory::Create(interpol)));
          else
           fSampler.reset(new utl::RandomSamplerFromCDF(xVect, yVect));
          break;
        }
      }
      break;
    }
    configData.GetChild("delta").GetData(fDelta);
    if (fDelta) {
      // Load an initial value for the sequence obtained
      // with the delta strategy. If not present, zero remains.
      utl::Branch b = configData.GetChild("initialOffset");
      if (b)
        b.GetData(fLastValue);
    }
  }


  ConfigParameter::~ConfigParameter()
  {
    // Nothing to do, but here the type pointed to by the
    // auto_ptr has been defined.
  }


  double
  ConfigParameter::operator()()
    const
  {
    const double v = fSampler->shoot(fEngine.GetEngine());
    // If delta we take the shot value to be an increment wrt the previous.
    return fDelta ? (fLastValue += v) : (fLastValue = v);
  }

}