individual.hpp

Go to the documentation of this file.

 
#pragma once
#ifndef PBT_INDIVIDUAL_HPP_
#define PBT_INDIVIDUAL_HPP_
 
#include "random_fwd.hpp"
 
#include <cstdint>
#include <iosfwd>
#include <memory>
#include <vector>
#include <unordered_map>
 
 
namespace pbf {
 
 
class IndividualJson {
    friend class Individual;
  public:
    IndividualJson();
    void read(std::istream&);
    std::ostream& write(std::ostream&) const;
  private:
    using RowMatrix = std::vector<std::vector<double>>;
 
    std::vector<double> natural_mortality = {};
    std::vector<double> fishing_mortality = {};
    std::vector<double> fishing_coef = {};
    std::vector<double> weight_for_age = {};
    std::vector<RowMatrix> migration_matrices = {};
};
 
class Individual {
  public:
    Individual() = delete;
    explicit Individual(bool is_male) noexcept: is_male_(is_male) {}
    Individual(const std::shared_ptr<Individual>& father,
               const std::shared_ptr<Individual>& mother,
               int_fast32_t year, bool is_male) noexcept
    : father_(father), mother_(mother),
      birth_year_(year), is_male_(is_male) {}
    Individual(const Individual&) = delete;
    ~Individual() = default;
 
    double death_rate(const int_fast32_t year, const int_fast32_t season) const {
        const auto q_age = 4 * age(year) + season;
        return DEATH_RATE(q_age, year);
    }
 
    uint_fast32_t migrate(uint_fast32_t loc, int_fast32_t year, URBG&);
 
    void trace_back(std::ostream& ost, std::unordered_map<const Individual*, uint_fast32_t>* ids,
                    uint_fast32_t loc, int_fast32_t year) const;
    std::ostream& write(std::ostream&) const;
    std::ostream& write(std::ostream&, const std::unordered_map<const Individual*, uint_fast32_t>&) const;
    static std::ostream& write_trace_back_header(std::ostream&);
    static std::ostream& write_names(std::ostream&);
    friend std::ostream& operator<<(std::ostream&, const Individual&);
 
    constexpr static inline int_fast32_t MAX_AGE = 80;
    static inline IndividualJson JSON;
    static void set_dependent_static(const uint_fast32_t years);
    static bool is_ready(const uint_fast32_t years) {
        return (
          FISHING_COEF_.size() >= years
          && JSON.natural_mortality.size() >= 4u * MAX_AGE
          && JSON.fishing_mortality.size() >= 4u * MAX_AGE
          && WEIGHT_FOR_AGE_.size() >= MAX_AGE
          && MIGRATION_DESTINATION_.size() >= MAX_AGE
        );
    }
    static double DEATH_RATE(const int_fast32_t q_age, const int_fast32_t year) {
        const auto m = JSON.natural_mortality[q_age];
        const auto f = JSON.fishing_mortality[q_age] * FISHING_COEF_[year];
        return 1.0 - std::exp(-m - f);
    }
 
 
    int_fast32_t age(const int_fast32_t year) const noexcept {
        return year - birth_year_;
    }
    double weight(int_fast32_t year) const noexcept {
        return WEIGHT_FOR_AGE_[age(year)];
    }
    bool is_male() const noexcept {return is_male_;}
 
  private:
    using PairDestDist=std::pair<int_fast32_t, std::discrete_distribution<uint_fast32_t>>;
    static void set_static_migration();
    static void set_static_mortality();
    static void set_static_weight();
    static inline std::vector<double> FISHING_COEF_;
    static inline std::vector<double> WEIGHT_FOR_AGE_;
    static inline std::vector<std::vector<PairDestDist>> MIGRATION_DESTINATION_;
 
    const std::shared_ptr<Individual> father_ = nullptr;
    const std::shared_ptr<Individual> mother_ = nullptr;
    int_fast32_t birth_year_ = -4;
    const bool is_male_;
};
 
} // namespace pbf
 
#endif /* PBT_INDIVIDUAL_HPP_ */