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 "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() {}
 
  virtual ~Information() {}
 
  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;
 
    for (recruitment_models_iterator it = recruitment_models.begin();
         it != recruitment_models.end(); ++it) {
      std::shared_ptr<fims_popdy::RecruitmentBase<Type>> recruitment =
          (*it).second;
      if (recruitment->process) {
        recruitment->process.reset();
      }
      if (recruitment->recruitment) {
        recruitment->recruitment.reset();
      }
    }
    for (recruitment_process_iterator it = recruitment_process_models.begin();
         it != recruitment_process_models.end(); ++it) {
      std::shared_ptr<fims_popdy::RecruitmentBase<Type>> recruitment =
          (*it).second;
      if (recruitment->process) {
        recruitment->process.reset();
      }
      if (recruitment->recruitment) {
        recruitment->recruitment.reset();
      }
    }
    this->recruitment_models.clear();
    this->recruitment_process_models.clear();
 
    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->priors)[0]) {
        d->priors.clear();
      }
      if (d->data_observed_values) {
        d->data_observed_values.reset();
      }
      if (d->data_expected_values) {
        d->data_expected_values->clear();
      }
      if (d->re) {
        d->re->clear();
      }
      if (d->re_expected_values) {
        d->re_expected_values->clear();
      }
    }
    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 SetFleetLandingsData(bool& valid_model,
                            std::shared_ptr<fims_popdy::Fleet<Type>> f) {
    if (f->fleet_observed_landings_data_id_m != static_cast<Type>(-999)) {
      uint32_t observed_landings_id =
          static_cast<uint32_t>(f->fleet_observed_landings_data_id_m);
      data_iterator it = this->data_objects.find(observed_landings_id);
      if (it != this->data_objects.end()) {
        f->observed_landings_data = (*it).second;
        FIMS_INFO_LOG("Landings data for fleet " + fims::to_string(f->id) +
                      " successfully set to " +
                      fims::to_string(f->observed_landings_data->at(1)));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG("Expected landings data not defined for fleet " +
                       fims::to_string(f->id) + ", index " +
                       fims::to_string(observed_landings_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 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.");
      }
    }
  }
 
  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)
        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));
 
      SetFleetLandingsData(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);
 
      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 */