GHShapeParameters.cc

Go to the documentation of this file.

#include "GHShapeParameters.h"
#include <evt/GaisserHillas4Parameter.h>
#include <utl/Branch.h>
#include <utl/UnitGrammar.h>
#include <sstream>
using namespace std;

using namespace evt;
using namespace evt::gh;
using namespace utl;

namespace FdEnergyDepositFinderKG {

  inline
  EShapeParameter
  nameToGHEnum(const string name, const EFunctionType ghType)
  {
    EShapeParameter par = eX0;
    if (name == "eX0")
      par = eX0;
    else if (name == "eLambda")
      par = eLambda;
    else if (name == "eFWHM")
      par = eFWHM;
    else if (name == "eAsym")
      par = eAsym;
    else if (name == "eUspL")
      par = eUSP_L;
    else if (name == "eUspR")
      par = eUSP_R;
    else {
      ostringstream errMsg;
      errMsg << "string to enum conversion not implemented for parameter "
             << name;
      throw XMLParseException(errMsg.str());
    }

    // consistency check
    GaisserHillas4Parameter tmp(ghType);
    if (!tmp.IsInternal(par)) {
      ostringstream errMsg;
      errMsg << "incompatible shape parameter "
             << gh::GetShapeParameterName(par)
             << ", from XML name " << name
             << ", GH type is "
             << GetFunctionTypeName(ghType);
      throw XMLParseException(errMsg.str());
    }

    return par;
  }

  GHShapeParameters::GHShapeParameters(const Branch& config)
  {
    const string ghType = config.GetChild("gaisserHillasType").Get<string>();
    if (ghType == "eClassic")
      fGHType = eClassic;
    else if (ghType == "eWidth")
      fGHType = eWidth;
    else if (ghType == "eUSP")
      fGHType = eUSP;
    else {
      throw XMLParseException("Unknown GH type " + ghType);
    }
    const Branch ghParB = config.GetChild("gaisserHillasShapeParameters",
                                          "type=" + ghType);
    if (ghParB) {
      AugerUnitParser up;
      for (int index = 0; index < 2; ++index) {
        const EOneTwo i = EOneTwo(index);
        ostringstream attribute;
        attribute << "id=" << index + 1;
        const Branch par = ghParB.GetChild("par", attribute.str());
        fConstraint[i] = par.GetChild("mean").Get<Function>();
        fConstraintVariance[i] = par.GetChild("sigma").Get<Function>();
        fUnit[i] = par.GetChild("unit").Get<Function>();
        fParType[i] = nameToGHEnum(par.GetChild("name").Get<string>(), fGHType);
        const vector<double> range = par.GetChild("range").Get<vector<double> >();
        fRangeMin[i] = range[0]; // range.size() == 2 guaranteed by xsd
        fRangeMax[i] = range[1];
        fStep[i] =  par.GetChild("step").Get<double>();
      }
    }
    else {
      ostringstream errMsg;
      errMsg << "no configuration found for GH type "
             << GetFunctionTypeName(fGHType);
      throw XMLParseException(errMsg.str());
    }
  }

  GHShapeParameters::GHShapeParameters()  :
    fGHType(eClassic)
  {
    for (unsigned int i = 0; i < eTwo + 1; ++i) {
      //fConstraint[i] = 0;
      //fConstraintVariance[i] = 0;
      fRangeMin[i] = 0;
      fRangeMax[i] = 0;
      fStep[i] =  0;
    }
  }
}