LDFFinderKG/LDF.h

Go to the documentation of this file.

#ifndef _LDFFinderKG_LDF_h_
#define _LDFFinderKG_LDF_h_

#include "VLDF.h"
#include "NKGLDF.h"
#include "NKGASLDF.h"
#include "NKGFermiLDF.h"
#include "NKGBetaOnlyLDF.h"
#include "PowerLawLDF.h"
#include "ExpSqrtPolyLDF.h"
#include "NKGAGLDF.h"

#include <string>
#include <vector>
#include <utl/AugerException.h>
#include <boost/shared_ptr.hpp>


namespace LDFFinderKG {

  class LDF {

  public:
    LDF() : fType("Undefined") { }

    LDF(const std::string& type,
        const double rRef,
        const std::vector<double>& pars,
        const std::vector<double>& uncPars) :
      fType(type)
    {
      if (type == "NKG")
        fPtr.reset(new NKGLDF(rRef));
      else if (type == "NKGAS")
        fPtr.reset(new NKGASLDF(rRef));
      else if (type == "NKGFermi")
        fPtr.reset(new NKGFermiLDF(rRef));
      else if (type == "NKGBetaOnly")
        fPtr.reset(new NKGBetaOnlyLDF(rRef));
      else if (type == "PowerLaw")
        fPtr.reset(new PowerLawLDF(rRef));
      else if (type == "ExpSqrtPoly")
        fPtr.reset(new ExpSqrtPolyLDF(rRef));
      else if (type == "NKGAG")
        fPtr.reset(new NKGAGLDF(rRef));
      else
        throw utl::NonExistentComponentException("undefined LDF type");

      if (pars.size() != fPtr->fShapeModelVector.size()) {
        const std::string err =
          "number of required parameters does not match XML data vector (shape model)";
        throw utl::NonExistentComponentException(err);
      }
      fPtr->fShapeModelVector = pars;

      if (uncPars.size() != fPtr->fBetaUncertaintyModelVector.size()) {
        const std::string err =
          "number of required parameters does not match XML data vector (shape uncertainty model)";
        throw utl::NonExistentComponentException(err);
      }
      fPtr->fBetaUncertaintyModelVector = uncPars;
    }

    // forward these to VLDF...

    double operator()(const double r, const std::vector<double>& shape) const
    { return fPtr->Value(r, shape); }

    double SecondDerivative(const double r, const std::vector<double>& shape) const
    { return fPtr->SecondDerivative(r, shape); }

    std::vector<double> ShapeModel(const double cosTheta, const double showerSize) const
    { return fPtr->ShapeModel(cosTheta, showerSize); }

    double BetaUncertainty(const double showerSize) const
    { return fPtr->BetaUncertainty(showerSize); }

    // some getters, setters

    const std::string& GetType() const
    { return fType; }

    unsigned int GetNShapeParameters() const
    { return fPtr->GetNShapeParameters(); }

    double GetReferenceDistance() const
    { return fPtr->fReferenceDistance; }

  protected:
    std::string fType;
    boost::shared_ptr<VLDF> fPtr;

  };

}


#endif