fishery_model_base.hpp

Go to the documentation of this file.

 
#ifndef FIMS_MODELS_FISHERY_MODEL_BASE_HPP
#define FIMS_MODELS_FISHERY_MODEL_BASE_HPP
 
#include "../../common/model_object.hpp"
#include "../../common/fims_math.hpp"
#include "../../common/fims_vector.hpp"
#include "../../population_dynamics/population/population.hpp"
namespace fims_popdy {
 
struct DimensionInfo {
  std::string name;                    
  int ndims;                           
  fims::Vector<int> dims;              
  fims::Vector<std::string> dim_names; 
  fims::Vector<double> se_values_m;    
  DimensionInfo() : ndims(0) {}
 
  DimensionInfo(const std::string &name, const fims::Vector<int> &dims,
                const fims::Vector<std::string> &dim_names)
      : name(name), ndims(dims.size()), dims(dims), dim_names(dim_names) {}
 
  DimensionInfo(const DimensionInfo &other)
      : name(other.name),
        ndims(other.dims.size()),
        dims(other.dims),
        dim_names(other.dim_names) {}
 
  DimensionInfo &operator=(const DimensionInfo &other) {
    if (this != &other) {
      name = other.name;
      ndims = other.ndims;
      dims = other.dims;
      dim_names = other.dim_names;
      se_values_m = other.se_values_m;
    }
    return *this;
  }
};
 
struct UncertaintyReportInfo {
  std::string name;
  uint32_t id_m;
  size_t start_m;
  size_t length_m;
 
  UncertaintyReportInfo() : id_m(0), start_m(0), length_m(0) {}
 
  UncertaintyReportInfo(const std::string &name, uint32_t id, size_t start,
                        size_t length)
      : name(name), id_m(id), start_m(start), length_m(length) {}
 
  UncertaintyReportInfo(const UncertaintyReportInfo &other)
      : name(other.name),
        id_m(other.id_m),
        start_m(other.start_m),
        length_m(other.length_m) {}
};
 
template <typename Type>
class FisheryModelBase : public fims_model_object::FIMSObject<Type> {
  static uint32_t id_g; 
  uint32_t id; 
 public:
#ifdef TMB_MODEL
  bool do_reporting =
      true; 
#endif
  std::string model_type_m;
  std::set<uint32_t> population_ids;
  std::vector<std::shared_ptr<fims_popdy::Population<Type>>> populations;
  std::map<uint32_t, std::shared_ptr<fims_popdy::Fleet<Type>>> fleets;
  typedef typename std::map<uint32_t,
                            std::shared_ptr<fims_popdy::Fleet<Type>>>::iterator
      fleet_iterator;
 
  typedef typename std::map<uint32_t, std::map<std::string, fims::Vector<Type>>>
      DerivedQuantitiesMap;
 
  typedef typename DerivedQuantitiesMap::iterator DerivedQuantitiesMapIterator;
 
  std::shared_ptr<DerivedQuantitiesMap> fleet_derived_quantities;
 
  std::shared_ptr<DerivedQuantitiesMap> population_derived_quantities;
 
  typedef typename std::map<uint32_t, std::map<std::string, DimensionInfo>>
      DimensionInfoMap;
 
  std::shared_ptr<DimensionInfoMap> fleet_dimension_info;
 
  std::shared_ptr<DimensionInfoMap> population_dimension_info;
 
  typedef
      typename std::map<uint32_t, std::map<std::string, UncertaintyReportInfo>>
          UncertaintyReportInfoMap;
 
  std::shared_ptr<UncertaintyReportInfoMap> fleet_uncertainty_report_info;
 
  std::shared_ptr<UncertaintyReportInfoMap> population_uncertainty_report_info;
 
#ifdef TMB_MODEL
  ::objective_function<Type> *of;
#endif
  FisheryModelBase() : id(FisheryModelBase::id_g++) {
    fleet_derived_quantities = std::make_shared<DerivedQuantitiesMap>();
    population_derived_quantities = std::make_shared<DerivedQuantitiesMap>();
    fleet_dimension_info = std::make_shared<DimensionInfoMap>();
    population_dimension_info = std::make_shared<DimensionInfoMap>();
  }
 
  FisheryModelBase(const FisheryModelBase &other)
      : id(other.id),
        population_ids(other.population_ids),
        populations(other.populations),
        fleet_derived_quantities(other.fleet_derived_quantities),
        population_derived_quantities(other.population_derived_quantities),
        fleet_dimension_info(other.fleet_dimension_info),
        population_dimension_info(other.population_dimension_info) {}
 
  virtual ~FisheryModelBase() {}
 
  std::map<uint32_t, std::map<std::string, DimensionInfo>> &
  GetFleetDimensionInfo() {
    return *fleet_dimension_info;
  }
 
  std::map<uint32_t, std::map<std::string, DimensionInfo>> &
  GetPopulationDimensionInfo() {
    return *population_dimension_info;
  }
 
  DerivedQuantitiesMap &GetFleetDerivedQuantities() {
    return *fleet_derived_quantities;
  }
 
  DerivedQuantitiesMap &GetPopulationDerivedQuantities() {
    return *population_derived_quantities;
  }
 
  std::map<std::string, fims::Vector<Type>> &GetFleetDerivedQuantities(
      uint32_t fleet_id) {
    if (!fleet_derived_quantities) {
      throw std::runtime_error(
          "GetFleetDerivedQuantities: fleet_derived_quantities is null");
    }
    auto &outer = *fleet_derived_quantities;
    auto it = outer.find(fleet_id);
    if (it == outer.end()) {
      std::stringstream ss;
 
      ss << "GetFleetDerivedQuantities: fleet_id " << fleet_id
         << " not found in fleet_derived_quantities";
      throw std::out_of_range(ss.str());
    }
    return it->second;
  }
 
  void InitializeFleetDerivedQuantities(uint32_t fleet_id) {
    // Ensure the shared_ptr exists
    if (!fleet_derived_quantities) {
      fleet_derived_quantities = std::make_shared<
          std::map<uint32_t, std::map<std::string, fims::Vector<Type>>>>();
    }
 
    auto &outer = *fleet_derived_quantities;
 
    // Insert only if not already present
    if (outer.find(fleet_id) == outer.end()) {
      outer.emplace(fleet_id, std::map<std::string, fims::Vector<Type>>{});
    }
  }
 
  void InitializePopulationDerivedQuantities(uint32_t population_id) {
    // Ensure the shared_ptr exists
    if (!population_derived_quantities) {
      population_derived_quantities = std::make_shared<
          std::map<uint32_t, std::map<std::string, fims::Vector<Type>>>>();
    }
 
    auto &outer = *population_derived_quantities;
 
    // Insert only if not already present
    if (outer.find(population_id) == outer.end()) {
      outer.emplace(population_id, std::map<std::string, fims::Vector<Type>>{});
    }
  }
 
  std::map<std::string, fims::Vector<Type>> &GetPopulationDerivedQuantities(
      uint32_t population_id) {
    if (!population_derived_quantities) {
      throw std::runtime_error(
          "GetPopulationDerivedQuantities: population_derived_quantities is "
          "null");
    }
    auto &outer = *population_derived_quantities;
    auto it = outer.find(population_id);
    if (it == outer.end()) {
      std::ostringstream ss;
      ss << "GetPopulationDerivedQuantities: population_id " << population_id
         << " not found in population_derived_quantities";
      throw std::out_of_range(ss.str());
    }
    return it->second;
  }
 
  std::map<std::string, DimensionInfo> &GetFleetDimensionInfo(
      uint32_t fleet_id) {
    return (*fleet_dimension_info)[fleet_id];
  }
 
  std::map<std::string, DimensionInfo> &GetPopulationDimensionInfo(
      uint32_t population_id) {
    return (*population_dimension_info)[population_id];
  }
 
  UncertaintyReportInfoMap &GetFleetUncertaintyReportInfo() {
    return *fleet_uncertainty_report_info;
  }
 
  UncertaintyReportInfoMap &GetPopulationUncertaintyReportInfo() {
    return *population_uncertainty_report_info;
  }
 
  std::map<std::string, UncertaintyReportInfo> &GetFleetUncertaintyReportInfo(
      uint32_t fleet_id) {
    return (*fleet_uncertainty_report_info)[fleet_id];
  }
 
  std::map<std::string, UncertaintyReportInfo> &
  GetPopulationUncertaintyReportInfo(uint32_t population_id) {
    return (*population_uncertainty_report_info)[population_id];
  }
 
  virtual void Initialize() {}
 
  virtual void Prepare() {}
 
  virtual void ResetVector(fims::Vector<Type> &v, Type value = 0.0) {
    std::fill(v.begin(), v.end(), value);
  }
 
  virtual void Evaluate() {}
 
  virtual void Report() {}
 
  uint32_t GetId() { return this->id; }
};
 
template <typename Type>
uint32_t FisheryModelBase<Type>::id_g = 0;
 
}  // namespace fims_popdy
#endif