rcpp_selectivity.hpp

Go to the documentation of this file.

 
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_SELECTIVITY_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_SELECTIVITY_HPP
 
#include "../../../population_dynamics/selectivity/selectivity.hpp"
#include "rcpp_interface_base.hpp"
 
class SelectivityInterfaceBase : public FIMSRcppInterfaceBase {
 public:
  static uint32_t id_g;
  uint32_t id;
  static std::map<uint32_t, std::shared_ptr<SelectivityInterfaceBase>>
      live_objects;
 
  SelectivityInterfaceBase() {
    this->id = SelectivityInterfaceBase::id_g++;
    /* Create instance of map: key is id and value is pointer to
    SelectivityInterfaceBase */
    // SelectivityInterfaceBase::live_objects[this->id] = this;
  }
 
  SelectivityInterfaceBase(const SelectivityInterfaceBase &other)
      : id(other.id) {}
 
  virtual ~SelectivityInterfaceBase() {}
 
  virtual uint32_t get_id() = 0;
 
  virtual double evaluate(double x) = 0;
};
// static id of the SelectivityInterfaceBase object
uint32_t SelectivityInterfaceBase::id_g = 1;
// local id of the SelectivityInterfaceBase object map relating the ID of the
// SelectivityInterfaceBase to the SelectivityInterfaceBase objects
std::map<uint32_t, std::shared_ptr<SelectivityInterfaceBase>>
    SelectivityInterfaceBase::live_objects;
 
class LogisticSelectivityInterface : public SelectivityInterfaceBase {
 public:
  ParameterVector inflection_point;
  ParameterVector slope;
 
  LogisticSelectivityInterface() : SelectivityInterfaceBase() {
    SelectivityInterfaceBase::live_objects[this->id] =
        std::make_shared<LogisticSelectivityInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        SelectivityInterfaceBase::live_objects[this->id]);
  }
 
  LogisticSelectivityInterface(const LogisticSelectivityInterface &other)
      : SelectivityInterfaceBase(other),
        inflection_point(other.inflection_point),
        slope(other.slope) {}
 
  virtual ~LogisticSelectivityInterface() {}
 
  virtual uint32_t get_id() { return this->id; }
 
  virtual double evaluate(double x) {
    fims_popdy::LogisticSelectivity<double> LogisticSel;
    LogisticSel.inflection_point.resize(1);
    LogisticSel.inflection_point[0] = this->inflection_point[0].initial_value_m;
    LogisticSel.slope.resize(1);
    LogisticSel.slope[0] = this->slope[0].initial_value_m;
    return LogisticSel.evaluate(x);
  }
 
  virtual void finalize() {
    if (this->finalized) {
      // log warning that finalize has been called more than once.
      FIMS_WARNING_LOG("Logistic Selectivity  " + 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>::selectivity_models_iterator it;
 
    // search for maturity in Information
    it = info->selectivity_models.find(this->id);
    // if not found, just return
    if (it == info->selectivity_models.end()) {
      FIMS_WARNING_LOG("Logistic Selectivity " + fims::to_string(this->id) +
                       " not found in Information.");
      return;
    } else {
      std::shared_ptr<fims_popdy::LogisticSelectivity<double>> sel =
          std::dynamic_pointer_cast<fims_popdy::LogisticSelectivity<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 = sel->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 = sel->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);
    this->get_se_values("inflection_point", se_values,
                        inflection_point_uncertainty);
    fims::Vector<double> slope_uncertainty(this->slope.size(), -999);
    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\":\"Selectivity\",\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::LogisticSelectivity<Type>> selectivity =
        std::make_shared<fims_popdy::LogisticSelectivity<Type>>();
    std::stringstream ss;
    // set relative info
    selectivity->id = this->id;
    selectivity->inflection_point.resize(this->inflection_point.size());
    for (size_t i = 0; i < this->inflection_point.size(); i++) {
      selectivity->inflection_point[i] =
          this->inflection_point[i].initial_value_m;
      if (this->inflection_point[i].estimation_type_m.get() ==
          "fixed_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".inflection_point."
           << this->inflection_point[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(selectivity->inflection_point[i]);
      }
      if (this->inflection_point[i].estimation_type_m.get() ==
          "random_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".inflection_point."
           << this->inflection_point[i].id_m;
        info->RegisterRandomEffect(selectivity->inflection_point[i]);
        info->RegisterRandomEffectName(ss.str());
      }
    }
    info->variable_map[this->inflection_point.id_m] =
        &(selectivity)->inflection_point;
 
    selectivity->slope.resize(this->slope.size());
    for (size_t i = 0; i < this->slope.size(); i++) {
      selectivity->slope[i] = this->slope[i].initial_value_m;
      if (this->slope[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".slope." << this->slope[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(selectivity->slope[i]);
      }
      if (this->slope[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".slope." << this->slope[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(selectivity->slope[i]);
      }
    }
    info->variable_map[this->slope.id_m] = &(selectivity)->slope;
 
    // add to Information
    info->selectivity_models[selectivity->id] = selectivity;
 
    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
};
 
class DoubleLogisticSelectivityInterface : public SelectivityInterfaceBase {
 public:
  ParameterVector inflection_point_asc; 
  ParameterVector
      slope_asc; 
  ParameterVector inflection_point_desc; 
  ParameterVector
      slope_desc; 
  DoubleLogisticSelectivityInterface() : SelectivityInterfaceBase() {
    SelectivityInterfaceBase::live_objects[this->id] =
        std::make_shared<DoubleLogisticSelectivityInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        SelectivityInterfaceBase::live_objects[this->id]);
  }
 
  DoubleLogisticSelectivityInterface(
      const DoubleLogisticSelectivityInterface &other)
      : SelectivityInterfaceBase(other),
        inflection_point_asc(other.inflection_point_asc),
        slope_asc(other.slope_asc),
        inflection_point_desc(other.inflection_point_desc),
        slope_desc(other.slope_desc) {}
 
  virtual ~DoubleLogisticSelectivityInterface() {}
 
  virtual uint32_t get_id() { return this->id; }
 
  virtual double evaluate(double x) {
    fims_popdy::DoubleLogisticSelectivity<double> DoubleLogisticSel;
    DoubleLogisticSel.inflection_point_asc.resize(1);
    DoubleLogisticSel.inflection_point_asc[0] =
        this->inflection_point_asc[0].initial_value_m;
    DoubleLogisticSel.slope_asc.resize(1);
    DoubleLogisticSel.slope_asc[0] = this->slope_asc[0].initial_value_m;
    DoubleLogisticSel.inflection_point_desc.resize(1);
    DoubleLogisticSel.inflection_point_desc[0] =
        this->inflection_point_desc[0].initial_value_m;
    DoubleLogisticSel.slope_desc.resize(1);
    DoubleLogisticSel.slope_desc[0] = this->slope_desc[0].initial_value_m;
    return DoubleLogisticSel.evaluate(x);
  }
  virtual void finalize() {
    if (this->finalized) {
      // log warning that finalize has been called more than once.
      FIMS_WARNING_LOG("Double Logistic Selectivity  " +
                       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>::selectivity_models_iterator it;
 
    // search for maturity in Information
    it = info->selectivity_models.find(this->id);
    // if not found, just return
    if (it == info->selectivity_models.end()) {
      FIMS_WARNING_LOG("Double Logistic Selectivity " +
                       fims::to_string(this->id) +
                       " not found in Information.");
      return;
    } else {
      std::shared_ptr<fims_popdy::DoubleLogisticSelectivity<double>> sel =
          std::dynamic_pointer_cast<
              fims_popdy::DoubleLogisticSelectivity<double>>(it->second);
 
      for (size_t i = 0; i < inflection_point_asc.size(); i++) {
        if (this->inflection_point_asc[i].estimation_type_m.get() ==
            "constant") {
          this->inflection_point_asc[i].final_value_m =
              this->inflection_point_asc[i].initial_value_m;
        } else {
          this->inflection_point_asc[i].final_value_m =
              sel->inflection_point_asc[i];
        }
      }
 
      for (size_t i = 0; i < slope_asc.size(); i++) {
        if (this->slope_asc[i].estimation_type_m.get() == "constant") {
          this->slope_asc[i].final_value_m = this->slope_asc[i].initial_value_m;
        } else {
          this->slope_asc[i].final_value_m = sel->slope_asc[i];
        }
      }
 
      for (size_t i = 0; i < inflection_point_desc.size(); i++) {
        if (this->inflection_point_desc[i].estimation_type_m.get() ==
            "constant") {
          this->inflection_point_desc[i].final_value_m =
              this->inflection_point_desc[i].initial_value_m;
        } else {
          this->inflection_point_desc[i].final_value_m =
              sel->inflection_point_desc[i];
        }
      }
 
      for (size_t i = 0; i < slope_desc.size(); i++) {
        if (this->slope_desc[i].estimation_type_m.get() == "constant") {
          this->slope_desc[i].final_value_m =
              this->slope_desc[i].initial_value_m;
        } else {
          this->slope_desc[i].final_value_m = sel->slope_desc[i];
        }
      }
    }
  }
 
  virtual void set_uncertainty(
      std::map<std::string, std::vector<double>> &se_values) {
    fims::Vector<double> inflection_point_asc_uncertainty(
        this->inflection_point_asc.size(), -999);
    this->get_se_values("inflection_point_asc", se_values,
                        inflection_point_asc_uncertainty);
    fims::Vector<double> slope_asc_uncertainty(this->slope_asc.size(), -999);
    this->get_se_values("slope_asc", se_values, slope_asc_uncertainty);
    fims::Vector<double> inflection_point_desc_uncertainty(
        this->inflection_point_desc.size(), -999);
    this->get_se_values("inflection_point_desc", se_values,
                        inflection_point_desc_uncertainty);
    fims::Vector<double> slope_desc_uncertainty(this->slope_desc.size(), -999);
    this->get_se_values("slope_desc", se_values, slope_desc_uncertainty);
    for (size_t i = 0; i < this->inflection_point_asc.size(); i++) {
      this->inflection_point_asc[i].uncertainty_m =
          inflection_point_asc_uncertainty[i];
    }
    for (size_t i = 0; i < this->slope_asc.size(); i++) {
      this->slope_asc[i].uncertainty_m = slope_asc_uncertainty[i];
    }
    for (size_t i = 0; i < this->inflection_point_desc.size(); i++) {
      this->inflection_point_desc[i].uncertainty_m =
          inflection_point_desc_uncertainty[i];
    }
    for (size_t i = 0; i < this->slope_desc.size(); i++) {
      this->slope_desc[i].uncertainty_m = slope_desc_uncertainty[i];
    }
  }
 
  virtual std::string to_json() {
    std::stringstream ss;
 
    ss << "{\n";
    ss << " \"module_name\": \"Selectivity\",\n";
    ss << " \"module_type\": \"DoubleLogistic\",\n";
    ss << " \"module_id\": " << this->id << ",\n";
 
    ss << " \"parameters\":[\n{\n";
    ss << "   \"name\": \"inflection_point_asc\",\n";
    ss << "   \"id\":" << this->inflection_point_asc.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [1]\n},\n";
    ss << "   \"values\":" << this->inflection_point_asc << "},\n";
 
    ss << "{\n";
    ss << "   \"name\": \"slope_asc\",\n";
    ss << "   \"id\":" << this->slope_asc.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [1]\n},\n";
    ss << "   \"values\":" << this->slope_asc << "},\n";
 
    ss << " {\n";
    ss << "   \"name\": \"inflection_point_desc\",\n";
    ss << "   \"id\":" << this->inflection_point_desc.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [1]\n},\n";
    ss << "   \"values\":" << this->inflection_point_desc << "},\n";
 
    ss << "{\n";
    ss << "   \"name\": \"slope_desc\",\n";
    ss << "   \"id\":" << this->slope_desc.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [1]\n},\n";
    ss << "   \"values\":" << this->slope_desc << "}]\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::DoubleLogisticSelectivity<Type>> selectivity =
        std::make_shared<fims_popdy::DoubleLogisticSelectivity<Type>>();
 
    std::stringstream ss;
    // set relative info
    selectivity->id = this->id;
    selectivity->inflection_point_asc.resize(this->inflection_point_asc.size());
    for (size_t i = 0; i < this->inflection_point_asc.size(); i++) {
      selectivity->inflection_point_asc[i] =
          this->inflection_point_asc[i].initial_value_m;
      if (this->inflection_point_asc[i].estimation_type_m.get() ==
          "fixed_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".inflection_point_asc."
           << this->inflection_point_asc[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(selectivity->inflection_point_asc[i]);
      }
      if (this->inflection_point_asc[i].estimation_type_m.get() ==
          "random_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".inflection_point_asc."
           << this->inflection_point_asc[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(selectivity->inflection_point_asc[i]);
      }
    }
    info->variable_map[this->inflection_point_asc.id_m] =
        &(selectivity)->inflection_point_asc;
 
    selectivity->slope_asc.resize(this->slope_asc.size());
    for (size_t i = 0; i < this->slope_asc.size(); i++) {
      selectivity->slope_asc[i] = this->slope_asc[i].initial_value_m;
 
      if (this->slope_asc[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".slope_asc."
           << this->slope_asc[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(selectivity->slope_asc[i]);
      }
      if (this->slope_asc[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".slope_asc."
           << this->slope_asc[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(selectivity->slope_asc[i]);
      }
    }
    info->variable_map[this->slope_asc.id_m] = &(selectivity)->slope_asc;
 
    selectivity->inflection_point_desc.resize(
        this->inflection_point_desc.size());
    for (size_t i = 0; i < this->inflection_point_desc.size(); i++) {
      selectivity->inflection_point_desc[i] =
          this->inflection_point_desc[i].initial_value_m;
 
      if (this->inflection_point_desc[i].estimation_type_m.get() ==
          "fixed_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".inflection_point_desc."
           << this->inflection_point_desc[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(selectivity->inflection_point_desc[i]);
      }
      if (this->inflection_point_desc[i].estimation_type_m.get() ==
          "random_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".inflection_point_desc."
           << this->inflection_point_desc[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(selectivity->inflection_point_desc[i]);
      }
    }
    info->variable_map[this->inflection_point_desc.id_m] =
        &(selectivity)->inflection_point_desc;
 
    selectivity->slope_desc.resize(this->slope_desc.size());
    for (size_t i = 0; i < this->slope_desc.size(); i++) {
      selectivity->slope_desc[i] = this->slope_desc[i].initial_value_m;
 
      if (this->slope_desc[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".slope_desc."
           << this->slope_desc[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(selectivity->slope_desc[i]);
      }
      if (this->slope_desc[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".slope_desc."
           << this->slope_desc[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(selectivity->slope_desc[i]);
      }
    }
 
    info->variable_map[this->slope_desc.id_m] = &(selectivity)->slope_desc;
 
    // add to Information
    info->selectivity_models[selectivity->id] = selectivity;
 
    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