information.hpp

Go to the documentation of this file.

 
#ifndef FIMS_COMMON_INFORMATION_HPP
#define FIMS_COMMON_INFORMATION_HPP
 
#include <algorithm>
#include <map>
#include <memory>
#include <vector>
 
#include "distributions/distributions.hpp"
#include "models/functors/fishery_model_base.hpp"
#include "population_dynamics/fleet/fleet.hpp"
#include "population_dynamics/growth/growth.hpp"
#include "population_dynamics/population/population.hpp"
#include "population_dynamics/recruitment/recruitment.hpp"
#include "population_dynamics/selectivity/selectivity.hpp"
#include "population_dynamics/age_to_length_conversion/functors/runtime.hpp"
#include "population_dynamics/size/functors/size_grid_builder.hpp"
#include "population_dynamics/size/growth_derived_size_provider.hpp"
#include "def.hpp"
#include "fims_vector.hpp"
#include "model_object.hpp"
 
namespace fims_info {

template <typename Type>
class Information {
 public:
  size_t n_years = 0; 
  size_t n_ages = 0;  
 
  static std::shared_ptr<Information<Type>>
      fims_information;          
  std::vector<Type*> parameters; 
  std::vector<Type*>
      random_effects_parameters; 
  std::vector<Type*>
      fixed_effects_parameters; 
  std::vector<std::string> parameter_names; 
  std::vector<std::string>
      random_effects_names; 
 
  // data objects
  std::map<uint32_t, std::shared_ptr<fims_data_object::DataObject<Type>>>
      data_objects; 
  typedef typename std::map<
      uint32_t, std::shared_ptr<fims_data_object::DataObject<Type>>>::iterator
      data_iterator; 
 
  // life history modules
  std::map<uint32_t, std::shared_ptr<fims_popdy::RecruitmentBase<Type>>>
      recruitment_models; 
  typedef typename std::map<
      uint32_t, std::shared_ptr<fims_popdy::RecruitmentBase<Type>>>::iterator
      recruitment_models_iterator;
 
  std::map<uint32_t, std::shared_ptr<fims_popdy::RecruitmentBase<Type>>>
      recruitment_process_models; 
  typedef typename std::map<
      uint32_t, std::shared_ptr<fims_popdy::RecruitmentBase<Type>>>::iterator
      recruitment_process_iterator;
 
  std::map<uint32_t, std::shared_ptr<fims_popdy::SelectivityBase<Type>>>
      selectivity_models; 
  typedef typename std::map<
      uint32_t, std::shared_ptr<fims_popdy::SelectivityBase<Type>>>::iterator
      selectivity_models_iterator;
 
  std::map<uint32_t, std::shared_ptr<fims_popdy::GrowthBase<Type>>>
      growth_models; 
  typedef
      typename std::map<uint32_t,
                        std::shared_ptr<fims_popdy::GrowthBase<Type>>>::iterator
          growth_models_iterator;
 
  std::map<uint32_t, std::shared_ptr<fims_popdy::MaturityBase<Type>>>
      maturity_models; 
  typedef typename std::map<
      uint32_t, std::shared_ptr<fims_popdy::MaturityBase<Type>>>::iterator
      maturity_models_iterator;
 
  // fleet modules
  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;
 
  // populations
  std::map<uint32_t, std::shared_ptr<fims_popdy::Population<Type>>>
      populations; 
  typedef
      typename std::map<uint32_t,
                        std::shared_ptr<fims_popdy::Population<Type>>>::iterator
          population_iterator;
 
  // distributions
  std::map<uint32_t,
           std::shared_ptr<fims_distributions::DensityComponentBase<Type>>>
      density_components; 
  typedef typename std::map<
      uint32_t,
      std::shared_ptr<fims_distributions::DensityComponentBase<Type>>>::iterator
      density_components_iterator;
 
  std::unordered_map<uint32_t,
                     std::shared_ptr<fims_popdy::FisheryModelBase<Type>>>
      models_map; 
  typedef typename std::unordered_map<
      uint32_t, std::shared_ptr<fims_popdy::FisheryModelBase<Type>>>::iterator
      model_map_iterator; 
 
  std::unordered_map<uint32_t, fims::Vector<Type>*>
      variable_map; 
  typedef typename std::unordered_map<uint32_t, fims::Vector<Type>*>::iterator
      variable_map_iterator; 
 
  Information() {}
 
  // Explicit Clear() is not guaranteed before package unload or process exit.
  // Break recruitment/process ownership cycles while both maps are still alive.
  virtual ~Information() { ResetRecruitmentLinks(); }
 
 private:
  void ResetRecruitmentLinks() noexcept {
    auto detach = [](auto& models) {
      for (auto& entry : models) {
        const auto& recruitment = entry.second;
        if (recruitment) {
          recruitment->process.reset();
          recruitment->recruitment.reset();
        }
      }
    };
    detach(this->recruitment_models);
    detach(this->recruitment_process_models);
  }
 
 public:
  void Clear() {
    this->data_objects.clear();
    this->populations.clear();
    this->fixed_effects_parameters.clear();
    this->fleets.clear();
    this->growth_models.clear();
    this->maturity_models.clear();
    this->parameter_names.clear();
    this->parameters.clear();
    this->random_effects_names.clear();
    this->random_effects_parameters.clear();
    this->selectivity_models.clear();
    this->models_map.clear();
    this->n_years = 0;
    this->n_ages = 0;
 
    ResetRecruitmentLinks();
    this->recruitment_models.clear();
    this->recruitment_process_models.clear();
 
    // Density components borrow these vectors from the population, fleet, and
    // recruitment modules released above, so only drop the links. Reading
    // through them here would touch freed memory.
    for (density_components_iterator it = density_components.begin();
         it != density_components.end(); ++it) {
      std::shared_ptr<fims_distributions::DensityComponentBase<Type>> d =
          (*it).second;
      d->priors.clear();
      d->data_observed_values.reset();
      d->data_expected_values = nullptr;
      d->re = nullptr;
      d->re_expected_values = nullptr;
    }
    this->density_components.clear();
  }

  std::string State() {
    std::stringstream ss;
    ss << "Information object State:\n";
    ss << "data_objects: " << this->data_objects.clear();
    ss << "populations: " << this->populations.size() << std::endl;
    ss << "fixed_effects_parameters: " << this->fixed_effects_parameters.size()
       << std::endl;
    ss << "fleets: " << this->fleets.size() << std::endl;
    ss << "growth_models: " << this->growth_models.size() << std::endl;
    ss << "maturity_models: " << this->maturity_models.size() << std::endl;
    ss << "parameter_names: " << this->parameter_names.size() << std::endl;
    ss << "parameters: " << this->parameters.size() << std::endl;
    ss << "random_effects_names: " << this->random_effects_names.size()
       << std::endl;
    ss << "random_effects_parameters: "
       << this->random_effects_parameters.size() << std::endl;
    ss << "recruitment_models: " << this->recruitment_models.size()
       << std::endl;
    ss << "recruitment_process_models: "
       << this->recruitment_process_models.size() << std::endl;
    ss << "selectivity_models: " << this->selectivity_models.size()
       << std::endl;
    ss << "models_map: " << this->models_map.size() << std::endl;
    ss << "n_years: " << this->n_years << std::endl;
    ss << "n_ages: " << this->n_ages << std::endl;
    ss << "density_components: " << this->density_components.size()
       << std::endl;
    return ss.str();
  }

  static std::shared_ptr<Information<Type>> GetInstance() {
    if (Information<Type>::fims_information == nullptr) {
      Information<Type>::fims_information =
          std::make_shared<fims_info::Information<Type>>();
    }
    return Information<Type>::fims_information;
  }

  void RegisterParameter(Type& p) {
    this->fixed_effects_parameters.push_back(&p);
  }

  void RegisterRandomEffect(Type& re) {
    this->random_effects_parameters.push_back(&re);
  }

  void RegisterParameterName(std::string p_name) {
    this->parameter_names.push_back(p_name);
  }

  void RegisterRandomEffectName(std::string re_name) {
    this->random_effects_names.push_back(re_name);
  }

  void SetupPriors() {
    for (density_components_iterator it = density_components.begin();
         it != density_components.end(); ++it) {
      std::shared_ptr<fims_distributions::DensityComponentBase<Type>> d =
          (*it).second;
      if (d->input_type == "prior") {
        FIMS_INFO_LOG("Setup prior for distribution " + fims::to_string(d->id));
        variable_map_iterator vmit;
        FIMS_INFO_LOG("Link prior from distribution " + fims::to_string(d->id) +
                      " to parameter " + fims::to_string(d->key[0]));
        d->priors.resize(d->key.size());
        for (size_t i = 0; i < d->key.size(); i++) {
          FIMS_INFO_LOG("Link prior from distribution " +
                        fims::to_string(d->id) + " to parameter " +
                        fims::to_string(d->key[0]));
          vmit = this->variable_map.find(d->key[i]);
          d->priors[i] = (*vmit).second;
        }
        FIMS_INFO_LOG("Prior size for distribution " + fims::to_string(d->id) +
                      "is: " + fims::to_string(d->observed_values.size()));
      }
    }
  }

  void SetupRandomEffects() {
    for (density_components_iterator it = this->density_components.begin();
         it != this->density_components.end(); ++it) {
      std::shared_ptr<fims_distributions::DensityComponentBase<Type>> d =
          (*it).second;
      if (d->input_type == "random_effects") {
        FIMS_INFO_LOG("Setup random effects for distribution " +
                      fims::to_string(d->id));
        variable_map_iterator vmit;
        FIMS_INFO_LOG("Link random effects from distribution " +
                      fims::to_string(d->id) + " to derived value " +
                      fims::to_string(d->key[0]));
        vmit = this->variable_map.find(d->key[0]);
        d->re = (*vmit).second;
        if (d->key.size() == 2) {
          vmit = this->variable_map.find(d->key[1]);
          d->re_expected_values = (*vmit).second;
        } else {
          d->re_expected_values = &d->expected_values;
        }
        FIMS_INFO_LOG("Random effect size for distribution " +
                      fims::to_string(d->id) +
                      " is: " + fims::to_string(d->observed_values.size()));
      }
    }
  }

  void SetupData() {
    for (density_components_iterator it = this->density_components.begin();
         it != this->density_components.end(); ++it) {
      std::shared_ptr<fims_distributions::DensityComponentBase<Type>> d =
          (*it).second;
      if (d->input_type == "data") {
        FIMS_INFO_LOG("Setup expected value for data distribution " +
                      fims::to_string(d->id));
        variable_map_iterator vmit;
        FIMS_INFO_LOG("Link expected value from distribution " +
                      fims::to_string(d->id) + " to derived value " +
                      fims::to_string(d->key[0]));
        vmit = this->variable_map.find(d->key[0]);
        d->data_expected_values = (*vmit).second;
        FIMS_INFO_LOG(
            "Expected value size for distribution " + fims::to_string(d->id) +
            " is: " + fims::to_string((*d->data_expected_values).size()));
      }
    }
  }

  void SetFleetCatchData(bool& valid_model,
                         std::shared_ptr<fims_popdy::Fleet<Type>> f) {
    if (f->fleet_observed_catch_data_id_m != static_cast<Type>(-999)) {
      uint32_t observed_catch_id =
          static_cast<uint32_t>(f->fleet_observed_catch_data_id_m);
      data_iterator it = this->data_objects.find(observed_catch_id);
      if (it != this->data_objects.end()) {
        f->observed_catch_data = (*it).second;
        FIMS_INFO_LOG("Catch data for fleet " + fims::to_string(f->id) +
                      " successfully set to " +
                      fims::to_string(f->observed_catch_data->at(1)));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG("Expected catch data not defined for fleet " +
                       fims::to_string(f->id) + ", index " +
                       fims::to_string(observed_catch_id));
      }
    }
  }

  void SetFleetIndexData(bool& valid_model,
                         std::shared_ptr<fims_popdy::Fleet<Type>> f) {
    if (f->fleet_observed_index_data_id_m != static_cast<Type>(-999)) {
      uint32_t observed_index_id =
          static_cast<uint32_t>(f->fleet_observed_index_data_id_m);
      data_iterator it = this->data_objects.find(observed_index_id);
      if (it != this->data_objects.end()) {
        f->observed_index_data = (*it).second;
        FIMS_INFO_LOG("Index data for fleet " + fims::to_string(f->id) +
                      " successfully set to " +
                      fims::to_string(f->observed_index_data->at(1)));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG("Expected index data not defined for fleet " +
                       fims::to_string(f->id) + ", index " +
                       fims::to_string(observed_index_id));
      }
    }
  }

  void SetAgeCompositionData(bool& valid_model,
                             std::shared_ptr<fims_popdy::Fleet<Type>> f) {
    if (f->fleet_observed_agecomp_data_id_m != static_cast<Type>(-999)) {
      uint32_t observed_agecomp_id =
          static_cast<uint32_t>(f->fleet_observed_agecomp_data_id_m);
      data_iterator it = this->data_objects.find(observed_agecomp_id);
      if (it != this->data_objects.end()) {
        f->observed_agecomp_data = (*it).second;
        FIMS_INFO_LOG("Observed input age-composition data for fleet " +
                      fims::to_string(f->id) + " successfully set to " +
                      fims::to_string(f->observed_agecomp_data->at(1)));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG(
            "Expected age-composition observations not defined for fleet " +
            fims::to_string(f->id));
      }
    }
  }

  void SetLengthCompositionData(bool& valid_model,
                                std::shared_ptr<fims_popdy::Fleet<Type>> f) {
    if (f->fleet_observed_lengthcomp_data_id_m != static_cast<Type>(-999)) {
      uint32_t observed_lengthcomp_id =
          static_cast<uint32_t>(f->fleet_observed_lengthcomp_data_id_m);
      data_iterator it = this->data_objects.find(observed_lengthcomp_id);
      if (it != this->data_objects.end()) {
        f->observed_lengthcomp_data = (*it).second;
        FIMS_INFO_LOG("Observed input length-composition data for fleet " +
                      fims::to_string(f->id) + " successfully set to " +
                      fims::to_string(f->observed_lengthcomp_data->at(1)));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG(
            "Expected length-composition observations not defined for fleet " +
            fims::to_string(f->id));
      }
    }
  }

  void SetFleetSelectivityModel(bool& valid_model,
                                std::shared_ptr<fims_popdy::Fleet<Type>> f) {
    if (f->fleet_selectivity_id_m != static_cast<Type>(-999)) {
      uint32_t sel_id = static_cast<uint32_t>(
          f->fleet_selectivity_id_m);  // cast as unsigned integer
      selectivity_models_iterator it = this->selectivity_models.find(
          sel_id);  // if find, set it, otherwise invalid
 
      if (it != this->selectivity_models.end()) {
        f->selectivity = (*it).second;  // elements in container held in pair
        FIMS_INFO_LOG("Selectivity model " +
                      fims::to_string(f->fleet_selectivity_id_m) +
                      " successfully set to fleet " + fims::to_string(f->id));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG("Expected selectivity pattern not defined for fleet " +
                       fims::to_string(f->id) + ", selectivity pattern " +
                       fims::to_string(sel_id));
      }
    } else {
      FIMS_WARNING_LOG("Warning: No selectivity pattern defined for fleet " +
                       fims::to_string(f->id) +
                       ". FIMS requires selectivity be defined for all fleets "
                       "when running a catch at age model.");
    }
  }

  void SetFleetAgeToLengthConversionModel(
      bool& valid_model, std::shared_ptr<fims_popdy::Population<Type>> p,
      std::shared_ptr<fims_popdy::Fleet<Type>> f) {
    if (p == nullptr || f == nullptr) {
      valid_model = false;
      FIMS_ERROR_LOG(
          "Unable to set fleet age-to-length conversion because the population "
          "or fleet "
          "pointer was null.");
      return;
    }
 
    f->age_to_length_conversion_model =
        fims_popdy::BuildAgeToLengthConversionFleet<Type>(p, f);
 
    if (f->age_to_length_conversion_model != nullptr &&
        f->age_to_length_conversion_model->IsActive()) {
      return;
    }
 
    if (!f->requires_age_length_mapping) {
      return;
    }
 
    if (f->n_lengths == 0) {
      valid_model = false;
      FIMS_ERROR_LOG("Fleet " + fims::to_string(f->id) +
                     " requires age-to-length conversion but has no fleet "
                     "length observation bins. Provide length_bin rows or "
                     "length_comp rows with length values.");
      return;
    }
 
    valid_model = false;
    FIMS_ERROR_LOG("Fleet " + fims::to_string(f->id) +
                   " has fleet length observation bins but no usable "
                   "age-to-length conversion path. Provide fixed "
                   "age-to-length conversion of size " +
                   fims::to_string(f->n_ages * f->n_lengths) + " (or " +
                   fims::to_string(f->n_years * f->n_ages * f->n_lengths) +
                   " for 1 table per year) or use a supported growth-derived "
                   "age-to-length conversion path.");
  }

  void SetRecruitment(bool& valid_model,
                      std::shared_ptr<fims_popdy::Population<Type>> p) {
    if (p->recruitment_id != static_cast<Type>(-999)) {
      uint32_t recruitment_uint = static_cast<uint32_t>(p->recruitment_id);
 
      recruitment_models_iterator it =
          this->recruitment_models.find(recruitment_uint);
 
      if (it != this->recruitment_models.end()) {
        p->recruitment = (*it).second;  // recruitment defined in population.hpp
        FIMS_INFO_LOG("Recruitment model " + fims::to_string(recruitment_uint) +
                      " successfully set to population " +
                      fims::to_string(p->id));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG(
            "Expected recruitment function not defined for "
            "population " +
            fims::to_string(p->id) + ", recruitment function " +
            fims::to_string(recruitment_uint));
      }
    } else {
      FIMS_WARNING_LOG(
          "No recruitment function defined for population " +
          fims::to_string(p->id) +
          ". FIMS requires recruitment functions be defined for all "
          "populations when running a catch at age model.");
    }
  }

  void SetRecruitmentProcess(bool& valid_model,
                             std::shared_ptr<fims_popdy::Population<Type>> p) {
    std::shared_ptr<fims_popdy::RecruitmentBase<Type>> r = p->recruitment;
    // if recruitment is defined
    if (r) {
      if (r->process_id != static_cast<Type>(-999)) {
        uint32_t process_uint = static_cast<uint32_t>(r->process_id);
        recruitment_process_iterator it =
            this->recruitment_process_models.find(process_uint);
 
        if (it != this->recruitment_process_models.end()) {
          r->process = (*it).second;  // recruitment process
          FIMS_INFO_LOG(
              "Recruitment Process model " + fims::to_string(process_uint) +
              " successfully set to population " + fims::to_string(p->id));
          (*it).second->recruitment = r;
        } else {
          valid_model = false;
          FIMS_ERROR_LOG(
              "Expected recruitment process function not defined for "
              "population " +
              fims::to_string(p->id) + ", recruitment process function " +
              fims::to_string(process_uint));
        }
      } else {
        FIMS_WARNING_LOG(
            "No recruitment process function defined for population " +
            fims::to_string(p->id) +
            ". FIMS requires recruitment process functions be defined for all "
            "recruitments when running a catch at age model.");
      }
    }
  }

  fims::Vector<fims::Vector<double>> PrepareFleetObservationBinEdges(
      const std::shared_ptr<fims_popdy::Population<Type>>& p) {
    fims::Vector<fims::Vector<double>> fleet_edges;
 
    for (std::size_t fleet_index = 0; fleet_index < p->fleets.size();
         ++fleet_index) {
      const std::shared_ptr<fims_popdy::Fleet<Type>>& fleet =
          p->fleets[fleet_index];
 
      if (fleet == nullptr) {
        continue;
      }
 
      if (!fleet->requires_age_length_mapping || fleet->n_lengths == 0) {
        fleet->length_bin_edges = fims::Vector<double>();
        continue;
      }
 
      if (fleet->lengths.size() != fleet->n_lengths) {
        throw std::runtime_error(
            "Fleet length_bin lower edges are not consistent with n_lengths");
      }
 
      fleet->length_bin_edges =
          fims_popdy::SizeGridBuilder::BuildObservationEdgesFromLowerEdges(
              fleet->lengths);
 
      fleet_edges.emplace_back(fleet->length_bin_edges);
    }
 
    return fleet_edges;
  }

  void EnforcePopulationGridNotCoarserThanFleetBins(
      const fims_popdy::SizeGrid& size_grid,
      const fims::Vector<fims::Vector<double>>& fleet_edges) {
    if (!size_grid.IsConsistent() || size_grid.n_bins == 0 ||
        fleet_edges.size() == 0) {
      return;
    }
 
    for (std::size_t population_bin_index = 0;
         population_bin_index < size_grid.n_bins; ++population_bin_index) {
      const double population_left = size_grid.edges[population_bin_index];
      const double population_right = size_grid.edges[population_bin_index + 1];
      const double population_bin_width = population_right - population_left;
      const double population_tolerance =
          1e-12 * (population_bin_width > 1.0 ? population_bin_width : 1.0);
 
      for (std::size_t fleet_index = 0; fleet_index < fleet_edges.size();
           ++fleet_index) {
        const fims::Vector<double>& edges = fleet_edges[fleet_index];
 
        for (std::size_t fleet_bin_index = 1; fleet_bin_index < edges.size();
             ++fleet_bin_index) {
          const double fleet_left = edges[fleet_bin_index - 1];
          const double fleet_right = edges[fleet_bin_index];
          const double overlap_left = std::max(population_left, fleet_left);
          const double overlap_right = std::min(population_right, fleet_right);
 
          if (!(overlap_right > overlap_left)) {
            continue;
          }
 
          const double fleet_bin_width = fleet_right - fleet_left;
          if (population_bin_width > fleet_bin_width + population_tolerance) {
            throw std::runtime_error(
                "Population biological size grid contains at least one bin "
                "that is coarser than an overlapping active fleet observation "
                "bin. Provide a finer biological size-grid override or correct "
                "the fleet bin setup.");
          }
        }
      }
    }
  }

  void EnsurePopulationSizeGrid(
      bool& valid_model, std::shared_ptr<fims_popdy::Population<Type>> p) {
    fims::Vector<fims::Vector<double>> fleet_edges;
 
    try {
      fleet_edges = PrepareFleetObservationBinEdges(p);
    } catch (const std::exception& e) {
      valid_model = false;
      FIMS_ERROR_LOG(
          "Failed to prepare fleet observation-bin geometry for population " +
          fims::to_string(p->id) + ": " + e.what());
      return;
    }
 
    if (p->size_grid.IsConsistent() && p->size_grid.n_bins > 0) {
      try {
        EnforcePopulationGridNotCoarserThanFleetBins(p->size_grid, fleet_edges);
      } catch (const std::exception& e) {
        valid_model = false;
        FIMS_ERROR_LOG(
            "Population " + fims::to_string(p->id) +
            " has a biological size grid that is incompatible with active "
            "fleet observation bins: " +
            e.what());
      }
      return;
    }
 
    const bool size_grid_missing = p->size_grid.n_bins == 0 &&
                                   p->size_grid.edges.size() == 0 &&
                                   p->size_grid.centers.size() == 0;
 
    if (size_grid_missing) {
      try {
        if (fleet_edges.size() == 0) {
          throw std::runtime_error(
              "No resolvable fleet observation-bin geometry was available "
              "to build the default biological size grid");
        }
 
        p->size_grid = fims_popdy::SizeGridBuilder::BuildDefaultFromFleetEdges(
            fleet_edges);
        EnforcePopulationGridNotCoarserThanFleetBins(p->size_grid, fleet_edges);
 
        const std::size_t regular_bin_count =
            p->size_grid.n_bins > 0 ? p->size_grid.n_bins - 1 : 0;
 
        if (regular_bin_count > 200) {
          FIMS_WARNING_LOG(
              "Built-in default biological size grid created more than 200 "
              "regular bins for population " +
              fims::to_string(p->id) +
              ". This may slow model evaluation. Consider providing a "
              "biological size-grid override if needed.");
        }
 
      } catch (const std::exception& e) {
        valid_model = false;
        FIMS_ERROR_LOG(
            "Failed to initialize default population size grid for "
            "population " +
            fims::to_string(p->id) + ": " + e.what());
      }
      return;
    }
 
    valid_model = false;
    FIMS_ERROR_LOG(
        "Population " + fims::to_string(p->id) +
        " has an invalid biological size grid. Provide a consistent override "
        "or leave the grid empty so FIMS can build the default.");
  }

  void ConfigureGrowthDerivedSizeProvider(
      std::shared_ptr<fims_popdy::Population<Type>> p,
      std::shared_ptr<fims_popdy::GrowthDerivedObservationBase<Type>>
          growth_observation) {
    std::shared_ptr<fims_popdy::GrowthDerivedSizeProvider<Type>> size_provider =
        std::make_shared<fims_popdy::GrowthDerivedSizeProvider<Type>>();
 
    size_provider->SetGrowth(growth_observation);
    size_provider->SetPopulationDimensions(p->n_years, p->n_ages);
    size_provider->SetPopulationSizeGrid(&(p->size_grid));
 
    p->size_distribution_provider = size_provider;
  }

  void SetGrowth(bool& valid_model,
                 std::shared_ptr<fims_popdy::Population<Type>> p) {
    if (p->growth_id != static_cast<Type>(-999)) {
      uint32_t growth_uint = static_cast<uint32_t>(p->growth_id);
      growth_models_iterator it = this->growth_models.find(
          growth_uint);  // growth_models is specified in information.hpp
      // and used in rcpp
      // at the head of information.hpp; are the
      // dimensions of ages defined in rcpp or where?
      if (it != this->growth_models.end()) {
        p->growth =
            (*it).second;  // growth defined in population.hpp (the object
        // is called p, growth is within p)
        if (std::shared_ptr<fims_popdy::GrowthDerivedObservationBase<Type>>
                growth_observation = std::dynamic_pointer_cast<
                    fims_popdy::GrowthDerivedObservationBase<Type>>(
                    p->growth)) {
          growth_observation->Initialize(p->n_years, p->n_ages, 1);
 
          if (p->ages.size() > 0) {
            double min_age = p->ages[0];
            for (size_t i = 1; i < p->ages.size(); ++i) {
              if (p->ages[i] < min_age) {
                min_age = p->ages[i];
              }
            }
            growth_observation->SetAgeOffset(static_cast<double>(min_age));
          }
 
          const bool population_has_size_grid_input =
              p->size_grid.n_bins > 0 || p->size_grid.edges.size() > 0 ||
              p->size_grid.centers.size() > 0;
 
          bool any_length_based_fleet = false;
          for (std::size_t i = 0; i < p->fleets.size(); ++i) {
            if (p->fleets[i] != nullptr &&
                p->fleets[i]->requires_age_length_mapping &&
                p->fleets[i]->n_lengths > 0) {
              any_length_based_fleet = true;
              break;
            }
          }
 
          if (population_has_size_grid_input || any_length_based_fleet) {
            EnsurePopulationSizeGrid(valid_model, p);
            if (!valid_model) {
              return;
            }
            ConfigureGrowthDerivedSizeProvider(p, growth_observation);
          }
        }
        FIMS_INFO_LOG("Growth model " + fims::to_string(growth_uint) +
                      " successfully set to population " +
                      fims::to_string(p->id));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG("Expected growth function not defined for population " +
                       fims::to_string(p->id) + ", growth function " +
                       fims::to_string(growth_uint));
      }
    } else {
      FIMS_WARNING_LOG("Growth function undefined for population " +
                       fims::to_string(p->id) +
                       ". FIMS requires growth functions be defined for all "
                       "populations when running a catch at age model.");
    }
  }

  void SetMaturity(bool& valid_model,
                   std::shared_ptr<fims_popdy::Population<Type>> p) {
    if (p->maturity_id != static_cast<Type>(-999)) {
      uint32_t maturity_uint = static_cast<uint32_t>(p->maturity_id);
      maturity_models_iterator it = this->maturity_models.find(
          maturity_uint);  // >maturity_models is specified in
      // information.hpp and used in rcpp
      if (it != this->maturity_models.end()) {
        p->maturity = (*it).second;  // >maturity defined in population.hpp
        FIMS_INFO_LOG("Maturity model " + fims::to_string(maturity_uint) +
                      " successfully set to population " +
                      fims::to_string(p->id));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG(
            "Expected maturity function not defined for population " +
            fims::to_string(p->id) + ", maturity function " +
            fims::to_string(maturity_uint));
      }
    } else {
      FIMS_WARNING_LOG("Maturity function undefined for population " +
                       fims::to_string(p->id) +
                       ". FIMS requires maturity functions be defined for all "
                       "populations when running a catch at age model.");
    }
  }

  void CreateFleetObjects(bool& valid_model) {
    for (fleet_iterator it = this->fleets.begin(); it != this->fleets.end();
         ++it) {
      std::shared_ptr<fims_popdy::Fleet<Type>> f = (*it).second;
      FIMS_INFO_LOG("Initializing fleet " + fims::to_string(f->id));
 
      SetFleetCatchData(valid_model, f);
 
      SetFleetIndexData(valid_model, f);
 
      SetAgeCompositionData(valid_model, f);
 
      SetLengthCompositionData(valid_model, f);
 
      SetFleetSelectivityModel(valid_model, f);
    }
  }

  void SetDataObjects(bool& valid_model) {
    for (density_components_iterator it = this->density_components.begin();
         it != this->density_components.end(); ++it) {
      std::shared_ptr<fims_distributions::DensityComponentBase<Type>> d =
          (*it).second;
 
      // set data objects if distribution is a data type
      if (d->input_type == "data") {
        if (d->observed_data_id_m != static_cast<Type>(-999)) {
          uint32_t observed_data_id =
              static_cast<uint32_t>(d->observed_data_id_m);
          data_iterator it = this->data_objects.find(observed_data_id);
 
          if (it != this->data_objects.end()) {
            d->data_observed_values = (*it).second;
            FIMS_INFO_LOG("Observed data " + fims::to_string(observed_data_id) +
                          " successfully set to density component " +
                          fims::to_string(d->id));
          } else {
            valid_model = false;
            FIMS_ERROR_LOG(
                "Expected data observations not defined for density "
                "component " +
                fims::to_string(d->id) + ", observed data " +
                fims::to_string(observed_data_id));
          }
        } else {
          valid_model = false;
          FIMS_ERROR_LOG("No data input for density component" +
                         fims::to_string(d->id));
        }
      }
    }
  }

  void CreatePopulationObjects(bool& valid_model) {
    for (population_iterator it = this->populations.begin();
         it != this->populations.end(); ++it) {
      std::shared_ptr<fims_popdy::Population<Type>> p = (*it).second;
 
      FIMS_INFO_LOG("Initializing population " + fims::to_string(p->id));
      // check if population has fleets
      typename std::set<uint32_t>::iterator fleet_ids_it;
 
      for (fleet_ids_it = p->fleet_ids.begin();
           fleet_ids_it != p->fleet_ids.end(); ++fleet_ids_it) {
        // error check and set population elements
        // check me - add another fleet iterator to push information from
        //  for (fleet_iterator it = this->fleets.begin(); it !=
        //  this->fleets.end();
        //        ++it) {
 
        fleet_iterator it = this->fleets.find(*fleet_ids_it);
 
        if (it != this->fleets.end()) {
          // Initialize fleet object
          std::shared_ptr<fims_popdy::Fleet<Type>> f = (*it).second;
          // population to the individual fleets This is to pass catch at age
          // from population to fleets?
          // any shared member in p (population is pushed into fleets)
          p->fleets.push_back(f);
        } else {
          valid_model = false;
          FIMS_ERROR_LOG("Fleet \"" + fims::to_string(*fleet_ids_it) +
                         "\" undefined, not found for Population \"" +
                         fims::to_string(p->id) + "\". ");
        }
      }
 
      // set information dimensions
      this->n_years = std::max(this->n_years, p->n_years);
      this->n_ages = std::max(this->n_ages, p->n_ages);
 
      SetRecruitment(valid_model, p);
 
      SetRecruitmentProcess(valid_model, p);
 
      SetGrowth(valid_model, p);
      for (size_t i = 0; i < p->fleets.size(); ++i) {
        SetFleetAgeToLengthConversionModel(valid_model, p, p->fleets[i]);
      }
 
      SetMaturity(valid_model, p);
    }
  }

  void CreateModelingObjects(bool& valid_model) {
    for (model_map_iterator it = this->models_map.begin();
         it != this->models_map.end(); ++it) {
      std::shared_ptr<fims_popdy::FisheryModelBase<Type>>& model = (*it).second;
      std::set<uint32_t>::iterator jt;
 
      for (jt = model->population_ids.begin();
           jt != model->population_ids.end(); ++jt) {
        population_iterator pt = this->populations.find((*jt));
 
        if (pt != this->populations.end()) {
          std::shared_ptr<fims_popdy::Population<Type>> p = (*pt).second;
          model->populations.push_back(p);
          for (size_t i = 0; i < p->fleets.size(); i++) {
            uint32_t local_fleet_id = p->fleets[i]->GetId();
            model->fleets[local_fleet_id] = p->fleets[i];
            FIMS_INFO_LOG(std::string("Linked fleet id ") +
                          fims::to_string(local_fleet_id) +
                          std::string(" into model id ") +
                          fims::to_string(model->GetId()));
          }
        } else {
          valid_model = false;
          FIMS_ERROR_LOG("No population object defined for model " +
                         fims::to_string(model->GetId()));
        }
      }
      model->Initialize();
    }
  }

  bool CreateModel() {
    FIMS_INFO_LOG("Creating model and checking for required components...");
    bool valid_model = true;
 
    CreateFleetObjects(valid_model);
 
    SetDataObjects(valid_model);
 
    CreatePopulationObjects(valid_model);
 
    CreateModelingObjects(valid_model);
 
    // setup priors, random effect, and data density components
    SetupPriors();
    SetupRandomEffects();
    SetupData();
 
    if (valid_model) {
      FIMS_INFO_LOG("Model successfully created.");
    } else {
      FIMS_ERROR_LOG("Model creation failed.");
    }
 
    return valid_model;
  }

  size_t GetNages() const { return n_ages; }

  void SetNages(size_t n_ages) { this->n_ages = n_ages; }

  size_t GetNyears() const { return n_years; }

  void SetNyears(size_t n_years) { this->n_years = n_years; }

  std::vector<Type*>& GetParameters() { return parameters; }

  std::vector<Type*>& GetFixedEffectsParameters() {
    return fixed_effects_parameters;
  }

  std::vector<Type*>& GetRandomEffectsParameters() {
    return random_effects_parameters;
  }

  bool CheckModel() {
    bool valid_model = true;
    for (model_map_iterator it = this->models_map.begin();
         it != this->models_map.end(); ++it) {
      std::shared_ptr<fims_popdy::FisheryModelBase<Type>>& model = (*it).second;
      std::set<uint32_t>::iterator jt;
 
      for (jt = model->population_ids.begin();
           jt != model->population_ids.end(); ++jt) {
        population_iterator pt = this->populations.find((*jt));
 
        if (pt != this->populations.end()) {
          std::shared_ptr<fims_popdy::Population<Type>> p = (*pt).second;
 
          if (model->model_type_m == "caa") {
            typename std::set<uint32_t>::iterator fleet_ids_it;
            for (fleet_ids_it = p->fleet_ids.begin();
                 fleet_ids_it != p->fleet_ids.end(); ++fleet_ids_it) {
              fleet_iterator it = this->fleets.find(*fleet_ids_it);
 
              if (it != this->fleets.end()) {
                // Initialize fleet object
                std::shared_ptr<fims_popdy::Fleet<Type>> f = (*it).second;
 
                if (f->fleet_selectivity_id_m == static_cast<Type>(-999)) {
                  valid_model = false;
                  FIMS_ERROR_LOG(
                      "No selectivity pattern defined for fleet " +
                      fims::to_string(f->id) +
                      ". FIMS requires selectivity be defined for all fleets "
                      "when running a catch at age model.");
                }
              }
            }
 
            if (p->recruitment_id == static_cast<Type>(-999)) {
              valid_model = false;
              FIMS_ERROR_LOG(
                  "No recruitment function defined for population " +
                  fims::to_string(p->id) +
                  ". FIMS requires recruitment functions be defined for all "
                  "populations when running a catch at age model.");
            }
 
            std::shared_ptr<fims_popdy::RecruitmentBase<Type>> r =
                p->recruitment;
            r = p->recruitment;
            if (r->process_id == static_cast<Type>(-999)) {
              valid_model = false;
              FIMS_ERROR_LOG(
                  "No recruitment process function defined for population " +
                  fims::to_string(p->id) +
                  ". FIMS requires recruitment process functions be defined "
                  "for all "
                  "recruitments when running a catch at age model.");
            }
 
            if (p->growth_id == static_cast<Type>(-999)) {
              valid_model = false;
              FIMS_ERROR_LOG(
                  "No growth function defined for population " +
                  fims::to_string(p->id) +
                  ". FIMS requires growth functions be defined for all "
                  "populations when running a catch at age model.");
            }
 
            if (p->maturity_id == static_cast<Type>(-999)) {
              valid_model = false;
 
              FIMS_WARNING_LOG(
                  "No maturity function defined for population " +
                  fims::to_string(p->id) +
                  ". FIMS requires maturity functions be defined for all "
                  "populations when running a catch at age model.");
            }
          }
        }
      }
    }
    return valid_model;
  }
};
 
template <typename Type>
std::shared_ptr<Information<Type>> Information<Type>::fims_information =
    nullptr; 
 
}  // namespace fims_info
 
#endif /* FIMS_COMMON_INFORMATION_HPP */