rcpp_growth.hpp

Go to the documentation of this file.

 
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_GROWTH_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_GROWTH_HPP
 
#include "../../../population_dynamics/growth/growth.hpp"
#include "rcpp_interface_base.hpp"
 
class GrowthInterfaceBase : public FIMSRcppInterfaceBase {
public:
  static uint32_t id_g;
  uint32_t id;
  static std::map<uint32_t, std::shared_ptr<GrowthInterfaceBase>> live_objects;
 
  GrowthInterfaceBase() {
    this->id = GrowthInterfaceBase::id_g++;
    /* Create instance of map: key is id and value is pointer to
    GrowthInterfaceBase */
    // GrowthInterfaceBase::live_objects[this->id] =
    // std::make_shared<GrowthInterfaceBase>(*this);
  }
 
  GrowthInterfaceBase(const GrowthInterfaceBase &other) : id(other.id) {}
 
  virtual ~GrowthInterfaceBase() {}
 
  virtual uint32_t get_id() = 0;
 
  virtual double evaluate(double age) = 0;
};
// static id of the GrowthInterfaceBase object
uint32_t GrowthInterfaceBase::id_g = 1;
// local id of the GrowthInterfaceBase object map relating the ID of the
// GrowthInterfaceBase to the GrowthInterfaceBase objects
std::map<uint32_t, std::shared_ptr<GrowthInterfaceBase>>
    GrowthInterfaceBase::live_objects;
 
class EWAAGrowthInterface : public GrowthInterfaceBase {
public:
  RealVector weights;
  RealVector ages;
  SharedInt n_years;
  std::shared_ptr<std::map<int, std::map<double, double>>> ewaa;
  bool initialized = false;
 
  EWAAGrowthInterface() : GrowthInterfaceBase() {
    this->ewaa = std::make_shared<std::map<int, std::map<double, double>>>();
    GrowthInterfaceBase::live_objects[this->id] =
        std::make_shared<EWAAGrowthInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        std::make_shared<EWAAGrowthInterface>(*this));
  }
 
  EWAAGrowthInterface(const EWAAGrowthInterface &other)
      : GrowthInterfaceBase(other), weights(other.weights), ages(other.ages),
        n_years(other.n_years), ewaa(other.ewaa),
        initialized(other.initialized) {}
 
  virtual ~EWAAGrowthInterface() {}
 
  virtual uint32_t get_id() { return this->id; }
 
  inline std::map<int, std::map<double, double>> make_map(RealVector ages, RealVector weights,
                                           SharedInt n_years) {
    std::map<int, std::map<double, double>> mymap;
    const size_t n_years_plus_one = static_cast<size_t>(n_years.get() + 1);
    
    // Reject invalid year counts because map keys are expected to include
    // at least one model year.
    if (n_years.get() < 1) {
      Rcpp::stop("EWAA Error:: n_years must be at least 1");
    }
 
    // Reject empty vectors because we need at least one age-weight pair.
    if (weights.size() == 0 || ages.size() == 0) {
      Rcpp::stop("EWAA Error:: ages and weights must have at least one value");
    }
 
    // Accept either:
    // 1) one weight vector by age (shared across years), or
    // 2) a full year-by-age matrix flattened as (n_years + 1) * n_ages.
    if ((weights.size() != ages.size() * n_years_plus_one) &&
       (weights.size() != ages.size())) {
      Rcpp::stop("weights size does not match ages size or ages size times "
                 "(n_years + 1), where the plus one is for the beginning "
                 "of the year after the terminal year spawning-biomass "
                 "calculations.");
    } else if (weights.size() == ages.size()) {
      // One age-specific vector was provided, so replicate the same
      // weight-at-age values for every year key (0 through n_years).
      for (size_t y = 0; y < n_years_plus_one; y++) {
        for (size_t i = 0; i < ages.size(); i++) {
          mymap[y][ages[i]] = weights[i];
        }
      }
    } else if (weights.size() == ages.size() * n_years_plus_one) {
      // A flattened year-by-age matrix was provided, so map each block of
      // n_ages values to the corresponding year key (0 through n_years).
      for (size_t y = 0; y < n_years_plus_one; y++) {
        for (size_t i = 0; i < ages.size(); i++) {
          mymap[y][ages[i]] = weights[y * ages.size() + i];
        }
      }
    }
    return mymap;
  }
 
    virtual double evaluate(double age) {
      fims_popdy::EWAAGrowth<double> EWAAGrowth;
 
      // Build the EWAA map once from R inputs the first time evaluate() is
      // called.
      if (initialized == false) {
        EWAAGrowth.ewaa = make_map(this->ages, this->weights, this->n_years);
        initialized = true;
      } else {
        // Prevent re-initializing this object with a second evaluate() call.
        Rcpp::stop(
            "this empirical weight at age object is already initialized");
      }
      return EWAAGrowth.evaluate(0, age);
    }
 
    virtual std::string to_json() {
      std::stringstream ss;
      ss << "{\n";
      ss << " \"module_name\": \"Growth\",\n";
      ss << " \"module_type\": \"EWAA\",\n";
      ss << " \"module_id\":" << this->id << ",\n";
      ss << " \"parameters\": [\n{\n";
      ss << " \"name\": \"weight_at_age\",\n";
      ss << " \"id\": null,\n";
      ss << " \"type\": \"vector\",\n";
      ss << " \"dimensionality\": {\n";
      ss << "  \"header\": [\"n_years+1\",\"n_ages\"],\n";
      ss << "  \"dimensions\": [" << this->n_years.get() + 1 << "," << this->ages.size() << "]\n},\n";
 
      ss << " \"values\": [\n";
      for (size_t i = 0; i < weights.size() - 1; i++) {
        ss << "{\n";
        ss << "\"id\": null,\n";
        ss << "\"value\": " << weights[i] << ",\n";
        ss << "\"estimated_value\": " << weights[i] << ",\n";
        ss << "\"estimation_type\": \"constant\"\n";
        ss << "},\n";
      }
      ss << "{\n";
      ss << "\"id\": null,\n";
      ss << "\"value\": " << weights[weights.size() - 1] << ",\n";
      ss << "\"estimated_value\": " << weights[weights.size() - 1] << ",\n";
      ss << "\"estimation_type\": \"constant\"\n";
      ss << "}\n]\n";
      ss << "}\n]\n}\n";
      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::EWAAGrowth<Type>> ewaa_growth =
          std::make_shared<fims_popdy::EWAAGrowth<Type>>();
 
      // set relative info
      ewaa_growth->id = this->id;
      ewaa_growth->ewaa =
          make_map(this->ages, this->weights, this->n_years); // this->ewaa;
      // add to Information
      info->growth_models[ewaa_growth->id] = ewaa_growth;
 
      return true;
    }
 
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
 
      return true;
    }
 
#endif
  };
 
#endif