fixed.hpp

Go to the documentation of this file.

 
#ifndef POPULATION_DYNAMICS_AGE_TO_LENGTH_CONVERSION_FIXED_HPP
#define POPULATION_DYNAMICS_AGE_TO_LENGTH_CONVERSION_FIXED_HPP
 
// Needed for size_t.
#include <cstddef>
 
// Needed for shared_ptr and weak_ptr.
#include <memory>
 
// Base age-to-length conversion interface.
#include "base.hpp"
 
// Fleet definition, since this age-to-length conversion reads the fleet's fixed
// age-to-length conversion matrix.
#include "population_dynamics/fleet/fleet.hpp"
 
namespace fims_popdy {
 
template <typename Type>
struct AgeToLengthConversionFixed : public AgeToLengthConversionBase<Type> {
  // Non-owning link back to the fleet. weak_ptr avoids creating an
  // ownership cycle if Fleet later owns an AgeToLengthConversionBase pointer.
  std::weak_ptr<Fleet<Type>> fleet; 
  AgeToLengthConversionFixed(const std::shared_ptr<Fleet<Type>>& fleet)
      : AgeToLengthConversionBase<Type>(), fleet(fleet) {}
 
  virtual ~AgeToLengthConversionFixed() {}
 
  virtual bool IsActive() const override {
    // Convert the weak_ptr into a temporary shared_ptr so we can safely
    // access the fleet if it still exists.
    std::shared_ptr<Fleet<Type>> fleet_ptr = fleet.lock();
 
    // If the fleet no longer exists, this age-to-length conversion cannot be
    // used.
    if (fleet_ptr == nullptr) {
      return false;
    }
 
    // The fixed age-to-length conversion is active only if:
    // - the fleet has at least one age
    // - the fleet has at least one length bin
    // - the stored fixed matrix has the expected age x length size
    return fleet_ptr->n_ages > 0 && fleet_ptr->n_lengths > 0 &&
           fleet_ptr->age_to_length_conversion.size() ==
               (fleet_ptr->n_ages * fleet_ptr->n_lengths);
  }
 
  virtual bool PrepareForCurrentState() override { return this->IsActive(); }
 
  virtual bool BuildAgeToLengthConversionRow(
      size_t year, size_t age, fims::Vector<Type>& out_row) const override {
    // The current fixed matrix path does not vary by year, but year stays
    // in the interface so all age-to-length conversion types share the same
    // method signature.
    (void)year;
 
    // Safely access the linked fleet.
    std::shared_ptr<Fleet<Type>> fleet_ptr = fleet.lock();
 
    // Stop if:
    // - the fleet no longer exists
    // - dimensions are invalid
    // - the requested age is out of range
    // - the fixed matrix does not have the expected size
    if (fleet_ptr == nullptr || fleet_ptr->n_ages == 0 ||
        fleet_ptr->n_lengths == 0 || age >= fleet_ptr->n_ages ||
        fleet_ptr->age_to_length_conversion.size() !=
            (fleet_ptr->n_ages * fleet_ptr->n_lengths)) {
      return false;
    }
 
    // Resize the output row so it has one entry per fleet length bin.
    out_row.resize(fleet_ptr->n_lengths);
 
    // Compute the starting position for this age in the flattened
    // age x length matrix.
    const size_t row_offset = age * fleet_ptr->n_lengths;
 
    // Copy the fixed age-to-length probabilities for this age into out_row.
    for (size_t l = 0; l < fleet_ptr->n_lengths; ++l) {
      out_row[l] = fleet_ptr->age_to_length_conversion[row_offset + l];
    }
 
    // Report success.
    return true;
  }
};
 
}  // namespace fims_popdy
 
#endif /* POPULATION_DYNAMICS_AGE_TO_LENGTH_CONVERSION_FIXED_HPP */