rcpp_maturity.hpp

Go to the documentation of this file.

 
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_MATURITY_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_MATURITY_HPP
 
#include "../../../population_dynamics/maturity/maturity.hpp"
#include "rcpp_interface_base.hpp"
 
class MaturityInterfaceBase : public FIMSRcppInterfaceBase {
 public:
  static uint32_t id_g;
  uint32_t id;
  static std::map<uint32_t, std::shared_ptr<MaturityInterfaceBase>>
      live_objects;
 
  MaturityInterfaceBase() {
    this->id = MaturityInterfaceBase::id_g++;
    /* Create instance of map: key is id and value is pointer to
    MaturityInterfaceBase */
    // MaturityInterfaceBase::live_objects[this->id] = this;
  }
 
  MaturityInterfaceBase(const MaturityInterfaceBase& other) : id(other.id) {}
 
  virtual ~MaturityInterfaceBase() {}
 
  virtual uint32_t get_id() = 0;
 
  virtual double evaluate(double x) = 0;
};
// static id of the MaturityInterfaceBase object
uint32_t MaturityInterfaceBase::id_g = 1;
// local id of the MaturityInterfaceBase object map relating the ID of the
// MaturityInterfaceBase to the MaturityInterfaceBase objects
std::map<uint32_t, std::shared_ptr<MaturityInterfaceBase>>
    MaturityInterfaceBase::live_objects;
 
class LogisticMaturityInterface : public MaturityInterfaceBase {
 public:
  ParameterVector inflection_point;
  ParameterVector slope;
 
  LogisticMaturityInterface() : MaturityInterfaceBase() {
    MaturityInterfaceBase::live_objects[this->id] =
        std::make_shared<LogisticMaturityInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        MaturityInterfaceBase::live_objects[this->id]);
  }
 
  LogisticMaturityInterface(const LogisticMaturityInterface& other)
      : MaturityInterfaceBase(other),
        inflection_point(other.inflection_point),
        slope(other.slope) {}
 
  virtual ~LogisticMaturityInterface() {}
 
  virtual uint32_t get_id() { return this->id; }
 
  virtual double evaluate(double x) {
    fims_popdy::LogisticMaturity<double> LogisticMat;
    LogisticMat.inflection_point.resize(1);
    LogisticMat.inflection_point[0] = this->inflection_point[0].initial_value_m;
    LogisticMat.slope.resize(1);
    LogisticMat.slope[0] = this->slope[0].initial_value_m;
    return LogisticMat.evaluate(x);
  }
 
  virtual void finalize() {
    if (this->finalized) {
      // log warning that finalize has been called more than once.
      FIMS_WARNING_LOG("Logistic Maturity  " + fims::to_string(this->id) +
                       " has been finalized already.");
    }
 
    this->finalized = true;  // indicate this has been called already
 
    std::shared_ptr<fims_info::Information<double>> info =
        fims_info::Information<double>::GetInstance();
 
    fims_info::Information<double>::maturity_models_iterator it;
 
    // search for maturity in Information
    it = info->maturity_models.find(this->id);
    // if not found, just return
    if (it == info->maturity_models.end()) {
      FIMS_WARNING_LOG("Logistic Maturity " + fims::to_string(this->id) +
                       " not found in Information.");
      return;
    } else {
      std::shared_ptr<fims_popdy::LogisticMaturity<double>> mat =
          std::dynamic_pointer_cast<fims_popdy::LogisticMaturity<double>>(
              it->second);
 
      for (size_t i = 0; i < inflection_point.size(); i++) {
        if (this->inflection_point[i].estimation_type_m.get() == "constant") {
          this->inflection_point[i].final_value_m =
              this->inflection_point[i].initial_value_m;
        } else {
          this->inflection_point[i].final_value_m = mat->inflection_point[i];
        }
      }
 
      for (size_t i = 0; i < slope.size(); i++) {
        if (this->slope[i].estimation_type_m.get() == "constant") {
          this->slope[i].final_value_m = this->slope[i].initial_value_m;
        } else {
          this->slope[i].final_value_m = mat->slope[i];
        }
      }
    }
  }
 
  virtual void set_uncertainty(
      std::map<std::string, std::vector<double>>& se_values) {
    fims::Vector<double> inflection_point_uncertainty(
        this->inflection_point.size(), -999);
    fims::Vector<double> slope_uncertainty(this->slope.size(), -999);
    this->get_se_values("inflection_point", se_values,
                        inflection_point_uncertainty);
    this->get_se_values("slope", se_values, slope_uncertainty);
 
    for (size_t i = 0; i < this->inflection_point.size(); i++) {
      this->inflection_point[i].uncertainty_m = inflection_point_uncertainty[i];
    }
    for (size_t i = 0; i < this->slope.size(); i++) {
      this->slope[i].uncertainty_m = slope_uncertainty[i];
    }
  }
 
  virtual std::string to_json() {
    std::stringstream ss;
    ss << "{\n";
    ss << " \"module_name\": \"Maturity\",\n";
    ss << " \"module_type\": \"Logistic\",\n";
    ss << " \"module_id\": " << this->id << ",\n";
 
    ss << " \"parameters\": [\n{\n";
    ss << "   \"name\": \"inflection_point\",\n";
    ss << "   \"id\":" << this->inflection_point.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [1]\n},\n";
    ss << "   \"values\":" << this->inflection_point << "},\n ";
 
    ss << "{\n";
    ss << "   \"name\": \"slope\",\n";
    ss << "   \"id\":" << this->slope.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [1]\n},\n";
    ss << "   \"values\":" << this->slope << "}]\n";
 
    ss << "}";
 
    return ss.str();
  }
 
#ifdef TMB_MODEL
 
  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();
 
    std::shared_ptr<fims_popdy::LogisticMaturity<Type>> maturity =
        std::make_shared<fims_popdy::LogisticMaturity<Type>>();
 
    // set relative info
    maturity->id = this->id;
    std::stringstream ss;
    maturity->inflection_point.resize(this->inflection_point.size());
    for (size_t i = 0; i < this->inflection_point.size(); i++) {
      maturity->inflection_point[i] = this->inflection_point[i].initial_value_m;
      if (this->inflection_point[i].estimation_type_m.get() ==
          "fixed_effects") {
        ss.str("");
        ss << "Maturity." << this->id << ".inflection_point."
           << this->inflection_point[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(maturity->inflection_point[i]);
      }
      if (this->inflection_point[i].estimation_type_m.get() ==
          "random_effects") {
        ss.str("");
        ss << "Maturity." << this->id << ".inflection_point."
           << this->inflection_point[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(maturity->inflection_point[i]);
      }
    }
 
    maturity->slope.resize(this->slope.size());
    for (size_t i = 0; i < this->slope.size(); i++) {
      maturity->slope[i] = this->slope[i].initial_value_m;
      if (this->slope[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Maturity." << this->id << ".slope." << this->slope[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(maturity->slope[i]);
      }
      if (this->slope[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Maturity." << this->id << ".slope." << this->slope[i].id_m;
        info->RegisterRandomEffect(maturity->slope[i]);
        info->RegisterRandomEffectName(ss.str());
      }
    }
 
    // add to Information
    info->maturity_models[maturity->id] = maturity;
 
    return true;
  }
 
  virtual bool add_to_fims_tmb() {
#ifdef TMBAD_FRAMEWORK
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
#else
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMB_FIMS_FIRST_ORDER>();
    this->add_to_fims_tmb_internal<TMB_FIMS_SECOND_ORDER>();
    this->add_to_fims_tmb_internal<TMB_FIMS_THIRD_ORDER>();
#endif
 
    return true;
  }
 
#endif
};
 
#endif