Correct calculation of size of calculated_stats_ vector

src/HealthGPS/analysis_module.cpp

@@ -22,13 +22,13 @@ AnalysisModule::AnalysisModule(AnalysisDefinition &&definition, WeightModel &&cl
  residual_disability_weight_{create_age_gender_table<double>(age_range)},
  comorbidities_{comorbidities} {}
 
-// Overload constructor with additional parameter for calculated_factors_
+// Overload constructor with additional parameter for calculated_stats_
 AnalysisModule::AnalysisModule(AnalysisDefinition &&definition, WeightModel &&classifier,
  const core::IntegerInterval age_range, unsigned int comorbidities,
- std::vector<double> calculated_factors)
+ std::vector<double> calculated_stats)
  : definition_{std::move(definition)}, weight_classifier_{std::move(classifier)},
  residual_disability_weight_{create_age_gender_table<double>(age_range)},
- comorbidities_{comorbidities}, calculated_factors_{std::move(calculated_factors)} {}
+ comorbidities_{comorbidities}, calculated_stats_{std::move(calculated_stats)} {}
 SimulationModuleType AnalysisModule::type() const noexcept {
  return SimulationModuleType::Analysis;
 }
@@ -59,17 +59,21 @@ void AnalysisModule::initialise_vector(RuntimeContext &context) {
  factor_bin_widths_.push_back((max_factor - min_factor) / factor_bins_.back());
  }
 
- // The number of factors to calculate is the number of factors minus the length of the `factors`
- // vector.
- size_t num_factors_to_calc = context.mapping().entries().size() - factors_to_calculate_.size();
+ // The number of factors to calculate stats for is the number of factors minus the length of the
+ // `factors` vector.
+ size_t num_stats_to_calc = context.mapping().entries().size() - factors_to_calculate_.size();
+
+ // And for each factor, we calculate the stats described in `channels_`, so we
+ // multiply the size of `channels_` by the number of factors to calculate stats for.
+ num_stats_to_calc *= channels_.size();
 
  // The product of the number of bins for each factor can be used to calculate the size of the
- // `calculated_factors_` in the next step
+ // `calculated_stats_` in the next step
  size_t total_num_bins =
  std::accumulate(factor_bins_.cbegin(), factor_bins_.cend(), size_t{1}, std::multiplies<>());
 
  // Set the vector size and initialise all values to 0.0
- calculated_factors_.resize(total_num_bins * num_factors_to_calc);
+ calculated_stats_.resize(total_num_bins * num_stats_to_calc);
 }
 
 const std::string &AnalysisModule::name() const noexcept { return name_; }
@@ -115,7 +119,7 @@ void AnalysisModule::initialise_population(RuntimeContext &context) {
 void AnalysisModule::update_population(RuntimeContext &context) {
 
  // Reset the calculated factors vector to 0.0
- std::ranges::fill(calculated_factors_, 0.0);
+ std::ranges::fill(calculated_stats_, 0.0);
 
  publish_result_message(context);
 }
@@ -328,7 +332,7 @@ void AnalysisModule::calculate_population_statistics(RuntimeContext &context) {
  bin_indices.push_back(bin_index);
  }
 
- // Calculate the index in the calculated_factors_ vector
+ // Calculate the index in the calculated_stats_ vector
  size_t index = 0;
  for (size_t i = 0; i < bin_indices.size() - 1; i++) {
  size_t accumulated_bins =
@@ -342,7 +346,7 @@ void AnalysisModule::calculate_population_statistics(RuntimeContext &context) {
  for (const auto &factor : context.mapping().entries()) {
  if (std::find(factors_to_calculate_.cbegin(), factors_to_calculate_.cend(),
  factor.key()) == factors_to_calculate_.cend()) {
- calculated_factors_[index++] += person.get_risk_factor_value(factor.key());
+ calculated_stats_[index++] += person.get_risk_factor_value(factor.key());
  }
  }
  }

src/HealthGPS/analysis_module.h

@@ -49,7 +49,7 @@ class AnalysisModule final : public UpdatableModule {
  unsigned int comorbidities_;
  std::string name_{"Analysis"};
  std::vector<core::Identifier> factors_to_calculate_ = {"Gender"_id, "Age"_id};
- std::vector<double> calculated_factors_;
+ std::vector<double> calculated_stats_;
  std::vector<size_t> factor_bins_;
  std::vector<double> factor_bin_widths_;
  std::vector<double> factor_min_values_;