runtime.hpp

Go to the documentation of this file.

 
#ifndef POPULATION_DYNAMICS_AGE_TO_LENGTH_CONVERSION_RUNTIME_HPP
#define POPULATION_DYNAMICS_AGE_TO_LENGTH_CONVERSION_RUNTIME_HPP
 
#include <cstddef>
#include <memory>
#include <sstream>
#include <stdexcept>
 
#include "base.hpp"
#include "fixed.hpp"
#include "derived.hpp"
#include "population_dynamics/population/population.hpp"
 
namespace fims_popdy {
 
template <typename Type>
std::shared_ptr<AgeToLengthConversionBase<Type>>
BuildAgeToLengthConversionFleet(
    const std::shared_ptr<Population<Type>>& population,
    const std::shared_ptr<Fleet<Type>>& fleet) {
  if (population == nullptr || fleet == nullptr) {
    return nullptr;
  }
 
  if (!fleet->requires_age_length_mapping || fleet->n_lengths == 0) {
    return nullptr;
  }
 
  if (std::shared_ptr<GrowthDerivedObservationBase<Type>> growth_observation =
          std::dynamic_pointer_cast<GrowthDerivedObservationBase<Type>>(
              population->growth)) {
    std::shared_ptr<AgeToLengthConversionBase<Type>>
        age_to_length_conversion_derived =
            std::make_shared<AgeToLengthConversionDerived<Type>>(
                fleet, growth_observation,
                population->size_distribution_provider);
 
    if (age_to_length_conversion_derived->IsActive() &&
        age_to_length_conversion_derived->PrepareForCurrentState()) {
      FIMS_INFO_LOG(
          "Growth-derived age-to-length conversion successfully set to fleet " +
          fims::to_string(fleet->id) + " for population " +
          fims::to_string(population->id));
      return age_to_length_conversion_derived;
    }
    return nullptr;
  }
 
  std::shared_ptr<AgeToLengthConversionBase<Type>>
      age_to_length_conversion_fixed =
          std::make_shared<AgeToLengthConversionFixed<Type>>(fleet);
 
  if (age_to_length_conversion_fixed->IsActive() &&
      age_to_length_conversion_fixed->PrepareForCurrentState()) {
    FIMS_INFO_LOG("Fixed age-to-length matrix successfully set to fleet " +
                  fims::to_string(fleet->id));
    return age_to_length_conversion_fixed;
  }
 
  return nullptr;
}
 
template <typename Type>
void EnsureAgeToLengthConversionFleet(
    const std::shared_ptr<Population<Type>>& population,
    const std::shared_ptr<Fleet<Type>>& fleet) {
  if (fleet == nullptr) {
    throw std::runtime_error(
        "Fleet pointer was null while resolving age-to-length conversion.");
  }
 
  if (population == nullptr) {
    throw std::runtime_error(
        "Population pointer was null while resolving age-to-length "
        "conversion.");
  }
 
  if (!fleet->requires_age_length_mapping || fleet->n_lengths == 0) {
    return;
  }
 
  std::shared_ptr<GrowthDerivedObservationBase<Type>> growth_observation =
      std::dynamic_pointer_cast<GrowthDerivedObservationBase<Type>>(
          population->growth);
 
  if (fleet->age_to_length_conversion_model != nullptr) {
    if (growth_observation != nullptr) {
      std::shared_ptr<AgeToLengthConversionDerived<Type>>
          age_to_length_conversion_derived =
              std::dynamic_pointer_cast<AgeToLengthConversionDerived<Type>>(
                  fleet->age_to_length_conversion_model);
 
      if (age_to_length_conversion_derived != nullptr &&
          age_to_length_conversion_derived->IsActive() &&
          age_to_length_conversion_derived->PrepareForCurrentState()) {
        return;
      }
    } else if (fleet->age_to_length_conversion_model->IsActive() &&
               fleet->age_to_length_conversion_model
                   ->PrepareForCurrentState()) {
      return;
    }
  }
 
  fleet->age_to_length_conversion_model =
      BuildAgeToLengthConversionFleet<Type>(population, fleet);
 
  if (fleet->age_to_length_conversion_model != nullptr) {
    return;
  }
 
  std::stringstream ss;
  ss << "Fleet " << fleet->GetId()
     << " has length composition bins but no usable age-to-length conversion "
        "path.";
 
  if (growth_observation != nullptr) {
    ss << " This population uses a growth-derived-capable growth object, so "
       << "the growth-derived age-to-length conversion path with population "
          "size-provider support "
       << "was required and could not be built or prepared.";
  } else {
    ss << " Provide a valid fixed age-to-length conversion matrix for this "
       << "fleet or use a supported growth-derived-capable growth object.";
  }
 
  FIMS_ERROR_LOG(ss.str());
  throw std::runtime_error(ss.str());
}
 
template <typename Type>
void EnsurePopulationFleetAgeToLengthConversion(
    const std::shared_ptr<Population<Type>>& population) {
  if (population == nullptr) {
    throw std::runtime_error(
        "Population pointer was null while resolving age-to-length "
        "conversions.");
  }
 
  for (size_t i = 0; i < population->fleets.size(); ++i) {
    EnsureAgeToLengthConversionFleet<Type>(population, population->fleets[i]);
  }
}
 
}  // namespace fims_popdy
 
#endif