FitParameter.hpp

Go to the documentation of this file.

// Copyright (c) 2013, 2017 The ComPWA Team.
// This file is part of the ComPWA framework, check
// https://github.com/ComPWA/ComPWA/license.txt for details.


#ifndef _FITPARAMETER_HPP_
#define _FITPARAMETER_HPP_

#include <cmath>
#include <complex>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>

#include <boost/property_tree/ptree_fwd.hpp>
#include <boost/serialization/utility.hpp>

#include "Core/Exceptions.hpp"
#include "Core/FitParameter.hpp"
#include "Core/FunctionTree/Parameter.hpp"
#include "Core/Logging.hpp"

namespace ComPWA {

namespace FunctionTree {

enum ErrorType { SYM = 1, ASYM = 2, LHSCAN = 3, NOTDEF = 0 };

class FitParameter : public Parameter {

public:
  FitParameter(std::string inName = "");

  FitParameter(const boost::property_tree::ptree &pt);

  FitParameter(std::string inName, const double value);

  FitParameter(std::string inName, const double value, const double error);

  FitParameter(std::string inName, const double value, const double min,
               const double max);

  FitParameter(std::string inName, const double value, const double min,
               const double max, const double error);

  FitParameter(ComPWA::FitParameter<double> par);

  virtual bool isParameter() const { return true; }

  operator double() const { return Value; };

  virtual bool hasBounds() const { return HasBounds; }

  virtual bool isFixed() const { return IsFixed; }

  virtual void fixParameter(const bool fixed) { IsFixed = fixed; }

  virtual void updateParameter(std::shared_ptr<FitParameter> newPar);

  //====== PARAMETER VALUE ========
  virtual double value() const { return Value; }

  virtual void setValue(const double inVal);

  virtual std::pair<double, double> bounds() const;

  virtual void setBounds(const double min, const double max);

  virtual void setBounds(const std::pair<double, double> r);

  //====== PARAMETER ERROR ========
  virtual bool hasError() const;

  virtual ErrorType errorType() const { return ErrType; }

  virtual std::pair<double, double> error() const;

  virtual double avgError() const { return 0.5 * (Error.first + Error.second); }

  virtual void setError(double errLow, double errHigh);

  virtual void setError(std::pair<double, double> err);

  virtual void setError(double err);

  bool operator==(const FitParameter otherPar) const;

  void load(const boost::property_tree::ptree &pt);

  boost::property_tree::ptree save() const;

  virtual std::string to_str() const;

  virtual std::string val_to_str() const;

protected:
  virtual std::string className() const { return "Double"; }

  bool HasBounds;

  bool IsFixed;

  double Value;

  std::pair<double, double> Bounds;

  ErrorType ErrType;

  std::pair<double, double> Error;

  virtual void SetErrorType(ErrorType t) { ErrType = t; }

  bool check_bounds(const std::pair<double, double> bounds) const;

private:
  friend class boost::serialization::access;
  template <class archive>
  void serialize(archive &ar, const unsigned int version) {
    using namespace boost::serialization;
    //    ar &boost::serialization::make_nvp(
    //        "Parameter", boost::serialization::base_object<Parameter>(*this));
    ar &make_nvp("Name", Name);
    ar &make_nvp("Bounds", Bounds);
    ar &make_nvp("Fix", IsFixed);
    ar &make_nvp("Value", Value);
    ar &make_nvp("Bounds", Bounds);
    try {
      ar &make_nvp("ErrorType", ErrType);
      ar &make_nvp("Error", Error);
    } catch (...) {
      Error = std::pair<double, double>(0, 0);
      ErrType = ErrorType::SYM;
    }
  }
};
BOOST_SERIALIZATION_SHARED_PTR(ComPWA::FunctionTree::FitParameter)

} // namespace FunctionTree
} // namespace ComPWA

#endif