rcpp_recruitment.hpp

Go to the documentation of this file.

 
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_RECRUITMENT_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_RECRUITMENT_HPP
 
#include "../../../population_dynamics/recruitment/recruitment.hpp"
#include "rcpp_interface_base.hpp"
 
class RecruitmentInterfaceBase : public FIMSRcppInterfaceBase {
 public:
  static uint32_t id_g;
  uint32_t id;
  SharedInt process_id = -999;
  static std::map<uint32_t, std::shared_ptr<RecruitmentInterfaceBase>>
      live_objects;
 
  RecruitmentInterfaceBase() {
    this->id = RecruitmentInterfaceBase::id_g++;
    /* Create instance of map: key is id and value is pointer to
    RecruitmentInterfaceBase */
    // RecruitmentInterfaceBase::live_objects[this->id] = this;
  }
 
  RecruitmentInterfaceBase(const RecruitmentInterfaceBase &other)
      : id(other.id), process_id(other.process_id) {}
 
  virtual ~RecruitmentInterfaceBase() {}
 
  virtual uint32_t get_id() = 0;
 
  virtual double evaluate_mean(double spawners, double ssbzero) = 0;
 
  virtual double evaluate_process(size_t pos) = 0;
};
// static id of the RecruitmentInterfaceBase object
uint32_t RecruitmentInterfaceBase::id_g = 1;
// local id of the RecruitmentInterfaceBase object map relating the ID of the
// RecruitmentInterfaceBase to the RecruitmentInterfaceBase objects
std::map<uint32_t, std::shared_ptr<RecruitmentInterfaceBase>>
    RecruitmentInterfaceBase::live_objects;
 
class BevertonHoltRecruitmentInterface : public RecruitmentInterfaceBase {
 public:
  SharedInt n_years;
  ParameterVector logit_steep;
  ParameterVector log_rzero;
  ParameterVector log_devs;
  ParameterVector log_r;
  ParameterVector log_expected_recruitment;
  fims_double estimated_logit_steep;
  fims_double estimated_log_rzero;
  RealVector estimated_log_devs;
 
  BevertonHoltRecruitmentInterface() : RecruitmentInterfaceBase() {
    RecruitmentInterfaceBase::live_objects[this->id] =
        std::make_shared<BevertonHoltRecruitmentInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        RecruitmentInterfaceBase::live_objects[this->id]);
  }
 
  BevertonHoltRecruitmentInterface(
      const BevertonHoltRecruitmentInterface &other)
      : RecruitmentInterfaceBase(other),
        n_years(other.n_years),
        logit_steep(other.logit_steep),
        log_rzero(other.log_rzero),
        log_devs(other.log_devs),
        log_r(other.log_r),
        log_expected_recruitment(other.log_expected_recruitment),
        estimated_logit_steep(other.estimated_logit_steep),
        estimated_log_rzero(other.estimated_log_rzero),
        estimated_log_devs(other.estimated_log_devs) {}
 
  virtual ~BevertonHoltRecruitmentInterface() {}
 
  virtual uint32_t get_id() { return this->id; }
 
  void SetRecruitmentProcessID(uint32_t process_id) {
    this->process_id.set(process_id);
  }
 
  virtual double evaluate_mean(double spawners, double ssbzero) {
    fims_popdy::SRBevertonHolt<double> BevHolt;
    BevHolt.logit_steep.resize(1);
    BevHolt.logit_steep[0] = this->logit_steep[0].initial_value_m;
    if (this->logit_steep[0].initial_value_m == 1.0) {
      warning(
          "Steepness is subject to a logit transformation. "
          "Fixing it at 1.0 is not currently possible.");
    }
    BevHolt.log_rzero.resize(1);
    BevHolt.log_rzero[0] = this->log_rzero[0].initial_value_m;
 
    return BevHolt.evaluate_mean(spawners, ssbzero);
  }
 
  virtual double evaluate_process(size_t pos) { return 0; }
 
  virtual void finalize() {
    if (this->finalized) {
      // log warning that finalize has been called more than once.
      FIMS_WARNING_LOG("Beverton-Holt Recruitment  " +
                       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>::recruitment_models_iterator it;
 
    it = info->recruitment_models.find(this->id);
 
    if (it == info->recruitment_models.end()) {
      FIMS_WARNING_LOG("Beverton-Holt Recruitment " +
                       fims::to_string(this->id) +
                       " not found in Information.");
      return;
    } else {
      std::shared_ptr<fims_popdy::SRBevertonHolt<double>> recr =
          std::dynamic_pointer_cast<fims_popdy::SRBevertonHolt<double>>(
              it->second);
 
      for (size_t i = 0; i < this->logit_steep.size(); i++) {
        if (this->logit_steep[i].estimation_type_m.get() == "constant") {
          this->logit_steep[i].final_value_m =
              this->logit_steep[i].initial_value_m;
        } else {
          this->logit_steep[i].final_value_m = recr->logit_steep[i];
        }
      }
 
      for (size_t i = 0; i < log_rzero.size(); i++) {
        if (log_rzero[i].estimation_type_m.get() == "constant") {
          this->log_rzero[i].final_value_m = this->log_rzero[i].initial_value_m;
        } else {
          this->log_rzero[i].final_value_m = recr->log_rzero[i];
        }
      }
 
      for (size_t i = 0; i < this->log_devs.size(); i++) {
        if (this->log_devs[i].estimation_type_m.get() == "constant") {
          this->log_devs[i].final_value_m = this->log_devs[i].initial_value_m;
        } else {
          this->log_devs[i].final_value_m = recr->log_recruit_devs[i];
        }
      }
 
      for (size_t i = 0; i < this->log_r.size(); i++) {
        if (this->log_r[i].estimation_type_m.get() == "constant") {
          this->log_r[i].final_value_m = this->log_r[i].initial_value_m;
        } else {
          this->log_r[i].final_value_m = recr->log_r[i];
        }
      }
    }
  }
  virtual void set_uncertainty(
      std::map<std::string, std::vector<double>> &se_values) {
    fims::Vector<double> logit_steep_uncertainty(this->logit_steep.size(),
                                                 -99999999);
    this->get_se_values("logit_steep", se_values, logit_steep_uncertainty);
    fims::Vector<double> log_rzero_uncertainty(this->log_rzero.size(),
                                               -999999999);
    this->get_se_values("log_rzero", se_values, log_rzero_uncertainty);
    fims::Vector<double> log_devs_uncertainty(this->log_devs.size(),
                                              -999999999);
    this->get_se_values("log_devs", se_values, log_devs_uncertainty);
    for (size_t i = 0; i < this->logit_steep.size(); i++) {
      this->logit_steep[i].uncertainty_m = logit_steep_uncertainty[i];
    }
    for (size_t i = 0; i < this->log_rzero.size(); i++) {
      this->log_rzero[i].uncertainty_m = log_rzero_uncertainty[i];
    }
    for (size_t i = 0; i < this->log_devs.size(); i++) {
      this->log_devs[i].uncertainty_m = log_devs_uncertainty[i];
    }
  }
 
  virtual std::string to_json() {
    std::stringstream ss;
 
    ss << "{\n";
    ss << " \"module_name\": \"Recruitment\",\n";
    ss << " \"module_type\": \"Beverton-Holt\",\n";
    ss << " \"module_id\": " << this->id << ",\n";
 
    ss << " \"parameters\": [\n{\n";
    ss << "  \"name\": \"logit_steep\",\n";
    ss << "  \"id\":" << this->logit_steep.id_m << ",\n";
    ss << "  \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [" << this->logit_steep.size() << "]\n},\n";
    ss << "  \"values\":" << this->logit_steep << "},\n";
 
    ss << "{\n";
    ss << "   \"name\": \"log_rzero\",\n";
    ss << "   \"id\":" << this->log_rzero.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [" << this->log_rzero.size() << "]\n},\n";
    ss << "   \"values\":" << this->log_rzero << "},\n";
 
    ss << "{\n";
    ss << "   \"name\": \"log_devs\",\n";
    ss << "   \"id\":" << this->log_devs.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [\"n_years-1\"],\n";
    ss << "  \"dimensions\": [" << this->log_devs.size() << "]\n},\n";
    ss << "   \"values\":" << this->log_devs << "}]\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::SRBevertonHolt<Type>> recruitment =
        std::make_shared<fims_popdy::SRBevertonHolt<Type>>();
 
    std::stringstream ss;
 
    // set relative info
    recruitment->id = this->id;
    recruitment->process_id = this->process_id.get();
    // set logit_steep
    recruitment->logit_steep.resize(this->logit_steep.size());
    for (size_t i = 0; i < this->logit_steep.size(); i++) {
      recruitment->logit_steep[i] = this->logit_steep[i].initial_value_m;
 
      if (this->logit_steep[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Recruitment." << this->id << ".logit_steep."
           << this->logit_steep[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(recruitment->logit_steep[i]);
      }
      if (this->logit_steep[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Recruitment." << this->id << ".logit_steep."
           << this->logit_steep[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(recruitment->logit_steep[i]);
      }
    }
    info->variable_map[this->logit_steep.id_m] = &(recruitment)->logit_steep;
 
    // set log_rzero
    recruitment->log_rzero.resize(this->log_rzero.size());
    for (size_t i = 0; i < this->log_rzero.size(); i++) {
      recruitment->log_rzero[i] = this->log_rzero[i].initial_value_m;
 
      if (this->log_rzero[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Recruitment." << this->id << ".log_rzero."
           << this->log_rzero[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(recruitment->log_rzero[i]);
      }
      if (this->log_rzero[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Recruitment." << this->id << ".log_rzero."
           << this->log_rzero[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(recruitment->log_rzero[i]);
      }
    }
    info->variable_map[this->log_rzero.id_m] = &(recruitment)->log_rzero;
    // set log_recruit_devs
    recruitment->log_recruit_devs.resize(this->log_devs.size());
    for (size_t i = 0; i < this->log_devs.size(); i++) {
      recruitment->log_recruit_devs[i] = this->log_devs[i].initial_value_m;
 
      if (this->log_devs[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Recruitment." << this->id << ".log_devs."
           << this->log_devs[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(recruitment->log_recruit_devs[i]);
      }
      if (this->log_devs[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Recruitment." << this->id << ".log_devs."
           << this->log_devs[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(recruitment->log_recruit_devs[i]);
      }
    }
 
    info->variable_map[this->log_devs.id_m] = &(recruitment)->log_recruit_devs;
 
    // set log_r
    recruitment->log_r.resize(this->log_r.size());
    for (size_t i = 0; i < log_r.size(); i++) {
      recruitment->log_r[i] = this->log_r[i].initial_value_m;
 
      if (this->log_r[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Recruitment." << this->id << ".log_r." << this->log_r[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(recruitment->log_r[i]);
      }
      if (this->log_r[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Recruitment." << this->id << ".log_r." << this->log_r[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(recruitment->log_r[i]);
      }
    }
 
    info->variable_map[this->log_r.id_m] = &(recruitment)->log_r;
    // set log_expected_recruitment
    recruitment->log_expected_recruitment.resize(this->n_years.get() + 1);
    for (size_t i = 0; i < static_cast<size_t>(this->n_years.get() + 1); i++) {
      recruitment->log_expected_recruitment[i] = 0;
    }
    info->variable_map[this->log_expected_recruitment.id_m] =
        &(recruitment)->log_expected_recruitment;
 
    // add to Information
    info->recruitment_models[recruitment->id] = recruitment;
 
    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 LogDevsRecruitmentInterface : public RecruitmentInterfaceBase {
 public:
  LogDevsRecruitmentInterface() : RecruitmentInterfaceBase() {
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        std::make_shared<LogDevsRecruitmentInterface>(*this));
  }
 
  virtual ~LogDevsRecruitmentInterface() {}
 
  virtual uint32_t get_id() { return this->id; }
 
  virtual double evaluate_mean(double spawners, double ssbzero) { return 0; }
 
  virtual double evaluate_process(size_t pos) {
    fims_popdy::LogDevs<double> LogDevs;
 
    return LogDevs.evaluate_process(pos);
  }
 
#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::LogDevs<Type>> recruitment_process =
        std::make_shared<fims_popdy::LogDevs<Type>>();
 
    recruitment_process->id = this->id;
 
    // add to Information
    info->recruitment_process_models[recruitment_process->id] =
        recruitment_process;
 
    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 LogRRecruitmentInterface : public RecruitmentInterfaceBase {
 public:
  LogRRecruitmentInterface() : RecruitmentInterfaceBase() {
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        std::make_shared<LogRRecruitmentInterface>(*this));
  }
 
  virtual ~LogRRecruitmentInterface() {}
 
  virtual uint32_t get_id() { return this->id; }
 
  virtual double evaluate_mean(double spawners, double ssbzero) { return 0; }
 
  virtual double evaluate_process(size_t pos) {
    fims_popdy::LogR<double> LogR;
 
    return LogR.evaluate_process(pos);
  }
 
#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::LogR<Type>> recruitment_process =
        std::make_shared<fims_popdy::LogR<Type>>();
 
    recruitment_process->id = this->id;
 
    // add to Information
    info->recruitment_process_models[recruitment_process->id] =
        recruitment_process;
 
    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