rcpp_fleet.hpp

Go to the documentation of this file.

#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_FLEET_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_FLEET_HPP
 
#include "rcpp_interface_base.hpp"
#include "../../../population_dynamics/fleet/fleet.hpp"

class FleetInterfaceBase : public FIMSRcppInterfaceBase {
 public:
  static uint32_t id_g;
  uint32_t id;
  static std::map<uint32_t, std::shared_ptr<FleetInterfaceBase>> live_objects;

  FleetInterfaceBase() {
    this->id = FleetInterfaceBase::id_g++;
    /* Create instance of map: key is id and value is pointer to
    FleetInterfaceBase */
    // FleetInterfaceBase::live_objects[this->id] = this;
  }

  FleetInterfaceBase(const FleetInterfaceBase &other) : id(other.id) {}

  virtual ~FleetInterfaceBase() {}

  virtual uint32_t get_id() = 0;
};

class FleetInterface : public FleetInterfaceBase {
  SharedInt interface_observed_agecomp_data_id_m = -999;
  SharedInt interface_observed_lengthcomp_data_id_m = -999;
  SharedBoolean interface_requires_age_length_mapping = false;
  SharedInt interface_observed_index_data_id_m = -999;
  SharedInt interface_observed_catch_data_id_m = -999;
  SharedInt interface_selectivity_id_m = -999;
 
 public:
  SharedString name = fims::to_string("NA");
  SharedInt n_ages = 0;
  SharedInt n_lengths = 0;
  RealVector lengths;
  SharedInt n_years = 0;
  SharedString observed_catch_units = fims::to_string("weight");
  SharedString observed_index_units = fims::to_string("weight");
  VariableVector log_q;
  VariableVector log_Fmort;

  VariableVector age_to_length_conversion;
  RealVector weight_at_age;

  RealVector ageing_error;
 
  // Fleet based derived quantities
  VariableVector catch_numbers_at_age;
  VariableVector catch_weight_at_age;
  VariableVector catch_numbers_at_length;
  VariableVector catch_weight;
  VariableVector catch_numbers;
  VariableVector catch_expected;
  VariableVector log_catch_expected;
  VariableVector agecomp_proportion;
  VariableVector lengthcomp_proportion;
  VariableVector index_numbers_at_age;
  VariableVector index_weight_at_age;
  VariableVector index_numbers_at_length;
  VariableVector index_weight;
  VariableVector index_numbers;
  VariableVector index_expected;
  VariableVector log_index_expected;
  VariableVector agecomp_expected;
  VariableVector lengthcomp_expected;

  FleetInterface() : FleetInterfaceBase() {
    // RealVector starts with 1 value, but an empty weight_at_age is how a
    // fleet says it uses the population weight at age
    this->weight_at_age.resize(0);
    // Likewise, an empty ageing_error means no ageing error
    this->ageing_error.resize(0);
    std::shared_ptr<FleetInterface> fleet =
        std::make_shared<FleetInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(fleet);
    /* Create instance of map: key is id and value is pointer to
     FleetInterfaceBase */
    FleetInterfaceBase::live_objects[this->id] = fleet;
  }

  FleetInterface(const FleetInterface &other)
      : FleetInterfaceBase(other),
        interface_observed_agecomp_data_id_m(
            other.interface_observed_agecomp_data_id_m),
        interface_observed_lengthcomp_data_id_m(
            other.interface_observed_lengthcomp_data_id_m),
        interface_requires_age_length_mapping(
            other.interface_requires_age_length_mapping),
        interface_observed_index_data_id_m(
            other.interface_observed_index_data_id_m),
        interface_observed_catch_data_id_m(
            other.interface_observed_catch_data_id_m),
        interface_selectivity_id_m(other.interface_selectivity_id_m),
        name(other.name),
        n_ages(other.n_ages),
        n_lengths(other.n_lengths),
        lengths(other.lengths),
        n_years(other.n_years),
        observed_catch_units(other.observed_catch_units),
        observed_index_units(other.observed_index_units),
        log_q(other.log_q),
        log_Fmort(other.log_Fmort),
        age_to_length_conversion(other.age_to_length_conversion),
        weight_at_age(other.weight_at_age),
        ageing_error(other.ageing_error),
        catch_numbers_at_age(other.catch_numbers_at_age),
        catch_weight_at_age(other.catch_weight_at_age),
        catch_numbers_at_length(other.catch_numbers_at_length),
        catch_weight(other.catch_weight),
        catch_numbers(other.catch_numbers),
        catch_expected(other.catch_expected),
        log_catch_expected(other.log_catch_expected),
        agecomp_proportion(other.agecomp_proportion),
        lengthcomp_proportion(other.lengthcomp_proportion),
        index_numbers_at_age(other.index_numbers_at_age),
        index_weight_at_age(other.index_weight_at_age),
        index_numbers_at_length(other.index_numbers_at_length),
        index_weight(other.index_weight),
        index_numbers(other.index_numbers),
        index_expected(other.index_expected),
        log_index_expected(other.log_index_expected),
        agecomp_expected(other.agecomp_expected),
        lengthcomp_expected(other.lengthcomp_expected) {}

  virtual ~FleetInterface() {}

  virtual uint32_t get_id() { return this->id; }

  void SetName(const std::string &name) { this->name.set(name); }

  std::string GetName() const { return this->name.get(); }

  void SetObservedAgeCompDataID(int observed_agecomp_data_id) {
    interface_observed_agecomp_data_id_m.set(observed_agecomp_data_id);
  }

  void SetObservedLengthCompDataID(int observed_lengthcomp_data_id) {
    interface_observed_lengthcomp_data_id_m.set(observed_lengthcomp_data_id);
  }

  void SetRequiresAgeLengthMapping(bool requires_age_length_mapping) {
    interface_requires_age_length_mapping.set(requires_age_length_mapping);
  }

  void SetObservedIndexDataID(int observed_index_data_id) {
    interface_observed_index_data_id_m.set(observed_index_data_id);
  }

  void SetObservedCatchDataID(int observed_catch_data_id) {
    interface_observed_catch_data_id_m.set(observed_catch_data_id);
  }

  void SetSelectivityID(int selectivity_id) {
    interface_selectivity_id_m.set(selectivity_id);
  }

  uint32_t GetSelectivityID() { return interface_selectivity_id_m.get(); }

  int GetObservedAgeCompDataID() {
    return interface_observed_agecomp_data_id_m.get();
  }

  int GetObservedLengthCompDataID() {
    return interface_observed_lengthcomp_data_id_m.get();
  }

  bool GetRequiresAgeLengthMapping() {
    return interface_requires_age_length_mapping.get();
  }

  int GetObservedIndexDataID() {
    return interface_observed_index_data_id_m.get();
  }

  int GetObservedCatchDataID() {
    return interface_observed_catch_data_id_m.get();
  }

  virtual void finalize() {
    if (this->finalized) {
      // log warning that finalize has been called more than once.
      FIMS_WARNING_LOG("Fleet " + 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>::fleet_iterator it;
 
    it = info->fleets.find(this->id);
 
    if (it == info->fleets.end()) {
      FIMS_WARNING_LOG("Fleet " + fims::to_string(this->id) +
                       " not found in Information.");
      return;
    } else {
      std::shared_ptr<fims_popdy::Fleet<double>> fleet =
          std::dynamic_pointer_cast<fims_popdy::Fleet<double>>(it->second);
 
      for (size_t i = 0; i < this->log_Fmort.size(); i++) {
        if (this->log_Fmort[i].estimation_type_m.get() == "constant") {
          this->log_Fmort[i].final_value_m = this->log_Fmort[i].initial_value_m;
        } else {
          this->log_Fmort[i].final_value_m = fleet->log_Fmort[i];
        }
      }
 
      for (size_t i = 0; i < this->log_q.size(); i++) {
        if (this->log_q[i].estimation_type_m.get() == "constant") {
          this->log_q[i].final_value_m = this->log_q[i].initial_value_m;
        } else {
          this->log_q[i].final_value_m = fleet->log_q[i];
        }
      }
 
      for (size_t i = 0; i < fleet->age_to_length_conversion.size(); i++) {
        if (this->age_to_length_conversion[i].estimation_type_m.get() ==
            "constant") {
          this->age_to_length_conversion[i].final_value_m =
              this->age_to_length_conversion[i].initial_value_m;
        } else {
          this->age_to_length_conversion[i].final_value_m =
              fleet->age_to_length_conversion[i];
        }
      }
    }
  }
 
#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::Fleet<Type>> fleet =
        std::make_shared<fims_popdy::Fleet<Type>>();
 
    std::stringstream ss;
 
    // set relative info
    fleet->id = this->id;
    fleet->n_ages = this->n_ages.get();
    fleet->n_lengths = this->n_lengths.get();
    fleet->n_years = this->n_years.get();
    fleet->observed_catch_units = this->observed_catch_units;
    fleet->observed_index_units = this->observed_index_units;
 
    fleet->fleet_observed_agecomp_data_id_m =
        interface_observed_agecomp_data_id_m.get();
 
    fleet->fleet_observed_lengthcomp_data_id_m =
        interface_observed_lengthcomp_data_id_m.get();
    fleet->requires_age_length_mapping =
        interface_requires_age_length_mapping.get();
 
    fleet->fleet_observed_index_data_id_m =
        interface_observed_index_data_id_m.get();
    fleet->fleet_observed_catch_data_id_m =
        interface_observed_catch_data_id_m.get();
 
    fleet->fleet_selectivity_id_m = interface_selectivity_id_m.get();
 
    // The index reads 1 log_q for all years or 1 log_q per year
    if (this->log_q.size() != 1 &&
        this->log_q.size() != static_cast<size_t>(this->n_years.get())) {
      FIMS_ERROR_LOG("The size of `log_q` is not 1 or `n_years`: " +
                     fims::to_string(this->log_q.size()) + " values and " +
                     fims::to_string(this->n_years.get()) + " years");
      throw std::invalid_argument(
          "Fleet log_q size mismatch. Fleet log_q has " +
          fims::to_string(this->log_q.size()) +
          " values, but it needs 1 value or 1 value per year (" +
          fims::to_string(this->n_years.get()) + ").");
    }
    fleet->log_q.resize(this->log_q.size());
    for (size_t i = 0; i < this->log_q.size(); i++) {
      fleet->log_q[i] = this->log_q[i].initial_value_m;
 
      if (this->log_q[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Fleet." << this->id << ".log_q." << this->log_q[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(fleet->log_q[i]);
      }
      if (this->log_q[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Fleet." << this->id << ".log_q." << this->log_q[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(fleet->log_q[i]);
      }
    }
    // add to variable_map
    info->variable_map[this->log_q.id_m] = &(fleet)->log_q;
 
    if (this->log_Fmort.size() != static_cast<size_t>(this->n_years.get())) {
      FIMS_ERROR_LOG("The size of `log_Fmort` does not match `n_years`: " +
                     fims::to_string(this->log_Fmort.size()) +
                     " != " + fims::to_string(this->n_years.get()));
      throw std::invalid_argument(
          "Fleet log_Fmort size mismatch."
          "Fleet log_Fmort is of size " +
          fims::to_string(this->log_Fmort.size()) +
          " and the number of years is " +
          fims::to_string(this->n_years.get()));
    }
    fleet->log_Fmort.resize(static_cast<size_t>(this->log_Fmort.size()));
    for (size_t i = 0; i < log_Fmort.size(); i++) {
      fleet->log_Fmort[i] = this->log_Fmort[i].initial_value_m;
 
      if (this->log_Fmort[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Fleet." << this->id << ".log_Fmort." << this->log_Fmort[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(fleet->log_Fmort[i]);
      }
      if (this->log_Fmort[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Fleet." << this->id << ".log_Fmort." << this->log_Fmort[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(fleet->log_Fmort[i]);
      }
    }
    // add to variable_map
    info->variable_map[this->log_Fmort.id_m] = &(fleet)->log_Fmort;
 
    const size_t expected_weight_at_age_size =
        static_cast<size_t>(this->n_years.get() * this->n_ages.get());
    if (this->weight_at_age.size() != 0 &&
        this->weight_at_age.size() != expected_weight_at_age_size) {
      FIMS_ERROR_LOG(
          "The size of `weight_at_age` does not match n_years x "
          "n_ages: " +
          fims::to_string(this->weight_at_age.size()) +
          " != " + fims::to_string(expected_weight_at_age_size));
      throw std::invalid_argument(
          "Fleet weight_at_age size mismatch. Expected 0 or " +
          fims::to_string(expected_weight_at_age_size) + " values, found " +
          fims::to_string(this->weight_at_age.size()) + ".");
    }
    fleet->weight_at_age.resize(this->weight_at_age.size());
    for (size_t i = 0; i < fleet->weight_at_age.size(); i++) {
      fleet->weight_at_age[i] = this->weight_at_age[i];
    }
 
    if (this->n_lengths.get() > 0) {
      if (this->lengths.size() != static_cast<size_t>(this->n_lengths.get())) {
        FIMS_ERROR_LOG("The size of `lengths` does not match `n_lengths`: " +
                       fims::to_string(this->lengths.size()) +
                       " != " + fims::to_string(this->n_lengths.get()));
        throw std::invalid_argument(
            "Fleet lengths size mismatch. Fleet lengths is of size " +
            fims::to_string(this->lengths.size()) +
            " and the number of lengths is " +
            fims::to_string(this->n_lengths.get()));
      }
 
      fleet->lengths.resize(this->lengths.size());
      for (size_t i = 0; i < fleet->lengths.size(); i++) {
        fleet->lengths[i] = this->lengths[i];
      }
 
      fleet->age_to_length_conversion.resize(
          this->age_to_length_conversion.size());
 
      // One age x length table for all years, or one table per year.
      const size_t expected_age_to_length_conversion_size =
          static_cast<size_t>(this->n_ages.get() * this->n_lengths.get());
      const size_t expected_age_to_length_conversion_size_by_year =
          static_cast<size_t>(this->n_years.get()) *
          expected_age_to_length_conversion_size;
      const size_t supplied_age_to_length_conversion_size =
          this->age_to_length_conversion.size();
 
      if (supplied_age_to_length_conversion_size != 0 &&
          supplied_age_to_length_conversion_size !=
              expected_age_to_length_conversion_size &&
          supplied_age_to_length_conversion_size !=
              expected_age_to_length_conversion_size_by_year) {
        FIMS_ERROR_LOG(
            "age_to_length_conversion size mismatch, " +
            fims::to_string(supplied_age_to_length_conversion_size) + " != " +
            fims::to_string(expected_age_to_length_conversion_size) + " or " +
            fims::to_string(expected_age_to_length_conversion_size_by_year));
        throw std::invalid_argument(
            "Fleet age_to_length_conversion size mismatch. Expected " +
            fims::to_string(expected_age_to_length_conversion_size) + " or " +
            fims::to_string(expected_age_to_length_conversion_size_by_year) +
            " values but received " +
            fims::to_string(supplied_age_to_length_conversion_size) + ".");
      }
 
      for (size_t i = 0; i < fleet->age_to_length_conversion.size(); i++) {
        fleet->age_to_length_conversion[i] =
            this->age_to_length_conversion[i].initial_value_m;
 
        if (this->age_to_length_conversion[i].estimation_type_m.get() ==
            "fixed_effects") {
          ss.str("");
          ss << "Fleet." << this->id << ".age_to_length_conversion."
             << this->age_to_length_conversion[i].id_m;
          info->RegisterParameterName(ss.str());
          info->RegisterParameter(fleet->age_to_length_conversion[i]);
        }
        if (this->age_to_length_conversion[i].estimation_type_m.get() ==
            "random_effects") {
          FIMS_ERROR_LOG(
              "age_to_length_conversion cannot be set to random effects");
        }
      }
 
      info->variable_map[this->age_to_length_conversion.id_m] =
          &(fleet)->age_to_length_conversion;
    }
 
    if (this->ageing_error.size() != 0) {
      const size_t matrix_size =
          static_cast<size_t>(this->n_ages.get() * this->n_ages.get());
      const size_t supplied_size = this->ageing_error.size();
      if (supplied_size != matrix_size &&
          supplied_size !=
              matrix_size * static_cast<size_t>(this->n_years.get())) {
        FIMS_ERROR_LOG("ageing_error size mismatch, " +
                       fims::to_string(supplied_size) +
                       " is not n_ages^2 or n_years * n_ages^2.");
        throw std::invalid_argument(
            "Fleet ageing_error size mismatch. Expected " +
            fims::to_string(matrix_size) + " or " +
            fims::to_string(matrix_size * this->n_years.get()) +
            " values but received " + fims::to_string(supplied_size) + ".");
      }
    }
    fleet->ageing_error.resize(this->ageing_error.size());
    for (size_t i = 0; i < fleet->ageing_error.size(); i++) {
      fleet->ageing_error[i] = this->ageing_error[i];
    }
 
    // add to Information
    info->fleets[fleet->id] = fleet;
 
    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