Save individual scores in history

Author: ottoblep

include/simulation/RoutingSolver.hpp

@@ -13,7 +13,7 @@
 namespace cda_rail::sim {
 
 struct ScoreHistory
-    : public std::vector<std::tuple<std::chrono::milliseconds, double>> {
+    : public std::vector<std::tuple<std::chrono::milliseconds, ScoreSet>> {
   void export_csv(const std::filesystem::path& p) const;
 };
 

include/simulation/SolverResult.hpp

@@ -6,13 +6,21 @@
 
 namespace cda_rail::sim {
 
+struct ScoreSet {
+  std::unordered_map<std::string, double> stop_scores;
+  std::unordered_map<std::string, double> destination_scores;
+  double                                  collision_score = 0;
+
+  double get_score() const;
+  double get_collision_score() const;
+  double get_stop_score() const;
+  double get_destination_score() const;
+};
+
 class SolverResult {
   RoutingSolutionSet solutions;
   TrainTrajectorySet trajectories;
-
-  std::unordered_map<std::string, double> stop_scores;
-  std::unordered_map<std::string, double> destination_scores;
-  double                                  collision_score;
+  ScoreSet           scores;
 
 public:
   SolverResult(const SimulationInstance& instance);
@@ -24,7 +32,7 @@ class SolverResult {
 
   const RoutingSolutionSet& get_solutions() const;
   const TrainTrajectorySet& get_trajectories() const;
-  double                    get_score() const;
+  const ScoreSet&           get_score_set() const;
 };
 
 }; // namespace cda_rail::sim

src/simulation/RoutingSolver.cpp

@@ -3,10 +3,14 @@
 void cda_rail::sim::ScoreHistory::export_csv(
     const std::filesystem::path& p) const {
   std::ofstream csvfile(p);
-  csvfile << "time,score" << std::endl;
+  csvfile << "time,overall_score,collision_score,destination_score,stop_score"
+          << std::endl;
 
   for (auto it = begin(); it != end(); it++) {
-    csvfile << std::get<0>(*it).count() << "," << std::get<1>(*it) << std::endl;
+    const ScoreSet& set = std::get<1>(*it);
+    csvfile << std::get<0>(*it).count() << "," << set.get_score() << ","
+            << set.get_collision_score() << "," << set.get_destination_score()
+            << "," << set.get_stop_score() << "," << std::endl;
   }
 
   csvfile.close();
@@ -15,12 +19,15 @@ void cda_rail::sim::ScoreHistory::export_csv(
 void cda_rail::sim::ScoreHistoryCollection::export_csv(
     const std::filesystem::path& p) const {
   std::ofstream csvfile(p);
-  csvfile << "time,score" << std::endl;
+  csvfile << "time,overall_score,collision_score,destination_score,stop_score"
+          << std::endl;
 
   for (auto hist_it = begin(); hist_it != end(); hist_it++) {
     for (auto it = (*hist_it).begin(); it != (*hist_it).end(); it++) {
-      csvfile << std::get<0>(*it).count() << "," << std::get<1>(*it)
-              << std::endl;
+      const ScoreSet& set = std::get<1>(*it);
+      csvfile << std::get<0>(*it).count() << "," << set.get_score() << ","
+              << set.get_collision_score() << "," << set.get_destination_score()
+              << "," << set.get_stop_score() << "," << std::endl;
     }
   }
 
@@ -46,8 +53,9 @@ cda_rail::sim::RoutingSolver::random_local_search(
       std::chrono::steady_clock::now();
 
   for (;;) {
-    auto   res = local_search(RoutingSolutionSet{instance, rng_engine}, params);
-    double round_score = std::get<0>(res).get_score();
+    auto res = local_search(RoutingSolutionSet{instance, rng_engine}, params);
+    ScoreSet round_score_set = std::get<0>(res).get_score_set();
+    double   round_score     = round_score_set.get_score();
 
     std::chrono::steady_clock::time_point round_time =
         std::chrono::steady_clock::now();
@@ -58,7 +66,7 @@ cda_rail::sim::RoutingSolver::random_local_search(
       best_result.emplace(std::get<0>(res));
       hist.push_back({std::chrono::duration_cast<std::chrono::milliseconds>(
                           round_time - initial_time),
-                      best_score});
+                      round_score_set});
     }
 
     if (std::chrono::duration_cast<std::chrono::seconds>(
@@ -89,7 +97,8 @@ cda_rail::sim::RoutingSolver::grasp_search(std::chrono::seconds max_search_time,
 
     auto res =
         local_search(RoutingSolutionSet{instance, rng_engine}, loc_params);
-    double round_score = std::get<0>(res).get_score();
+    ScoreSet round_score_set = std::get<0>(res).get_score_set();
+    double   round_score     = round_score_set.get_score();
 
     std::chrono::steady_clock::time_point round_time =
         std::chrono::steady_clock::now();
@@ -100,7 +109,7 @@ cda_rail::sim::RoutingSolver::grasp_search(std::chrono::seconds max_search_time,
       best_result.emplace(std::get<0>(res));
       hist.push_back({std::chrono::duration_cast<std::chrono::milliseconds>(
                           round_time - initial_time),
-                      best_score});
+                      round_score_set});
     }
 
     if (std::chrono::duration_cast<std::chrono::seconds>(
@@ -131,7 +140,8 @@ cda_rail::sim::RoutingSolver::random_search(
   for (;;) {
     SolverResult round_result{instance,
                               RoutingSolutionSet{instance, rng_engine}};
-    double       round_score = round_result.get_score();
+    ScoreSet     round_score_set = round_result.get_score_set();
+    double       round_score     = round_score_set.get_score();
 
     std::chrono::steady_clock::time_point round_time =
         std::chrono::steady_clock::now();
@@ -147,7 +157,7 @@ cda_rail::sim::RoutingSolver::random_search(
       best_result.emplace(round_result);
       hist.push_back({std::chrono::duration_cast<std::chrono::milliseconds>(
                           round_time - initial_time),
-                      best_score});
+                      round_score_set});
     }
 
     if (max_stall_time.has_value()) {
@@ -184,7 +194,12 @@ cda_rail::sim::RoutingSolver::greedy_search(
   for (;;) {
     std::optional<cda_rail::sim::SolverResult> round_result_opt =
         greedy_solution(params);
-    double round_score = round_result_opt.value().get_score();
+
+    if (!round_result_opt.has_value())
+      continue;
+
+    ScoreSet round_score_set = round_result_opt.value().get_score_set();
+    double   round_score     = round_score_set.get_score();
 
     std::chrono::steady_clock::time_point round_time =
         std::chrono::steady_clock::now();
@@ -201,7 +216,7 @@ cda_rail::sim::RoutingSolver::greedy_search(
       auto total_time_spent =
           std::chrono::duration_cast<std::chrono::milliseconds>(round_time -
                                                                 initial_time);
-      hist.push_back({total_time_spent, best_score});
+      hist.push_back({total_time_spent, round_score_set});
     }
 
     if (max_stall_time.has_value()) {
@@ -233,22 +248,24 @@ cda_rail::sim::RoutingSolver::local_search(
   ScoreHistory hist;
   double       sampling_range_fraction = params.start_sampling_range_fraction;
   SolverResult last_result{instance, starting_solution};
-  double       last_score = last_result.get_score();
+  ScoreSet     last_score_set = last_result.get_score_set();
+  double       last_score     = last_score_set.get_score();
   hist.push_back({std::chrono::duration_cast<std::chrono::milliseconds>(
                       std::chrono::steady_clock::now() - initial_time),
-                  last_score});
+                  last_score_set});
 
   while (sampling_range_fraction > params.abort_sampling_range_fraction) {
     RoutingSolutionSet new_sol = last_result.get_solutions();
     new_sol.perturb(instance, sampling_range_fraction, rng_engine);
     SolverResult new_result{instance, new_sol};
+    ScoreSet     new_score_set = new_result.get_score_set();
 
-    if (double new_score = new_result.get_score(); new_score < last_score) {
+    if (double new_score = new_score_set.get_score(); new_score < last_score) {
       last_result = new_result;
       last_score  = new_score;
       hist.push_back({std::chrono::duration_cast<std::chrono::milliseconds>(
                           std::chrono::steady_clock::now() - initial_time),
-                      last_score});
+                      new_score_set});
     } else {
       sampling_range_fraction =
           sampling_range_fraction * params.contraction_coeff;
@@ -268,22 +285,24 @@ cda_rail::sim::RoutingSolver::local_search(
   ScoreHistory hist;
   double       sampling_range_fraction = params.start_sampling_range_fraction;
   SolverResult last_result{instance, starting_solution};
-  double       last_score = last_result.get_score();
+  ScoreSet     last_score_set = last_result.get_score_set();
+  double       last_score     = last_score_set.get_score();
   hist.push_back({std::chrono::duration_cast<std::chrono::milliseconds>(
                       std::chrono::steady_clock::now() - initial_time),
-                  last_score});
+                  last_score_set});
 
   while (sampling_range_fraction > params.abort_sampling_range_fraction) {
     RoutingSolutionSet new_sol = last_result.get_solutions();
     new_sol.perturb(instance, sampling_range_fraction, rng01);
     SolverResult new_result{instance, new_sol};
+    ScoreSet     new_score_set = new_result.get_score_set();
 
-    if (double new_score = new_result.get_score(); new_score < last_score) {
+    if (double new_score = new_score_set.get_score(); new_score < last_score) {
       last_result = new_result;
       last_score  = new_score;
       hist.push_back({std::chrono::duration_cast<std::chrono::milliseconds>(
                           std::chrono::steady_clock::now() - initial_time),
-                      last_score});
+                      new_score_set});
     } else {
       sampling_range_fraction =
           sampling_range_fraction * params.contraction_coeff;
@@ -320,7 +339,8 @@ cda_rail::sim::RoutingSolver::greedy_solution(GreedyParams params) {
       RoutingSolution round_sol{instance, train, rng_engine};
       TrainTrajectory round_traj{instance, train, round_sol};
       result.insert_or_assign(round_sol, round_traj);
-      double round_score = result.get_score();
+      ScoreSet round_score_set = result.get_score_set();
+      double   round_score     = round_score_set.get_score();
 
       std::chrono::steady_clock::time_point round_time =
           std::chrono::steady_clock::now();
@@ -411,7 +431,7 @@ void cda_rail::sim::RoutingSolver::init_genes(
 bool cda_rail::sim::RoutingSolver::eval_solution(const RoutingSolutionSet& p,
                                                  MiddleCost&               c) {
   SolverResult round_result{instance, p};
-  c.score = round_result.get_score();
+  c.score = round_result.get_score_set().get_score();
   return true;
 }
 
@@ -474,5 +494,8 @@ void cda_rail::sim::RoutingSolver::SO_report_generation(
   std::chrono::milliseconds past_time =
       std::chrono::duration_cast<std::chrono::milliseconds>(round_time -
                                                             starting_time);
-  hist.push_back({past_time, last_generation.best_total_cost});
+  auto best_individual =
+      last_generation.chromosomes[last_generation.best_chromosome_index];
+  SolverResult best_result{instance, best_individual.genes};
+  hist.push_back({past_time, best_result.get_score_set()});
 }

src/simulation/SolverResult.cpp

@@ -3,7 +3,7 @@
 
 cda_rail::sim::SolverResult::SolverResult(const SimulationInstance& instance)
     : solutions(RoutingSolutionSet{}),
-      trajectories(TrainTrajectorySet(instance)), collision_score(0) {}
+      trajectories(TrainTrajectorySet(instance)) {}
 
 cda_rail::sim::SolverResult::SolverResult(const SimulationInstance& instance,
                                           const RoutingSolutionSet& solutions)
@@ -14,28 +14,29 @@ cda_rail::sim::SolverResult::SolverResult(const SimulationInstance& instance,
         "Solutions and Trajectories are not the same size");
 
   for (auto const& [train_name, traj] : trajectories.get_map()) {
-    stop_scores.insert_or_assign(train_name, stop_penalty(traj));
+    scores.stop_scores.insert_or_assign(train_name, stop_penalty(traj));
   }
 
   for (auto const& [train_name, traj] : trajectories.get_map()) {
-    destination_scores.insert_or_assign(train_name, destination_penalty(traj));
+    scores.destination_scores.insert_or_assign(train_name,
+                                               destination_penalty(traj));
   }
 
-  collision_score = collision_penalty(trajectories);
+  scores.collision_score = collision_penalty(trajectories);
 }
 
 void cda_rail::sim::SolverResult::insert_or_assign(
     const RoutingSolution& solution, const TrainTrajectory& trajectory) {
   solutions.solutions.insert_or_assign(trajectory.get_train().name, solution);
   trajectories.insert_or_assign(trajectory.get_train().name, trajectory);
 
-  stop_scores.insert_or_assign(trajectory.get_train().name,
-                               stop_penalty(trajectory));
-  destination_scores.insert_or_assign(trajectory.get_train().name,
-                                      destination_penalty(trajectory));
+  scores.stop_scores.insert_or_assign(trajectory.get_train().name,
+                                      stop_penalty(trajectory));
+  scores.destination_scores.insert_or_assign(trajectory.get_train().name,
+                                             destination_penalty(trajectory));
 
   // TODO: don't need to recompute all pairs for new train
-  collision_score = collision_penalty(trajectories);
+  scores.collision_score = collision_penalty(trajectories);
 }
 
 const cda_rail::sim::RoutingSolutionSet&
@@ -48,18 +49,39 @@ cda_rail::sim::SolverResult::get_trajectories() const {
   return trajectories;
 }
 
-double cda_rail::sim::SolverResult::get_score() const {
+double cda_rail::sim::ScoreSet::get_score() const {
   double score_sum = 0;
 
+  score_sum += get_collision_score();
+  score_sum += get_destination_score();
+  score_sum += get_stop_score();
+
+  return score_sum;
+}
+
+double cda_rail::sim::ScoreSet::get_collision_score() const {
+  return collision_score;
+}
+
+double cda_rail::sim::ScoreSet::get_stop_score() const {
+  double score_sum = 0;
   for (auto const& [train_name, score] : stop_scores) {
     score_sum = score_sum + score;
   }
 
+  return score_sum;
+}
+
+double cda_rail::sim::ScoreSet::get_destination_score() const {
+  double score_sum = 0;
   for (auto const& [train_name, score] : destination_scores) {
     score_sum = score_sum + score;
   }
 
-  score_sum = score_sum + collision_score;
-
   return score_sum;
 }
+
+const cda_rail::sim::ScoreSet&
+cda_rail::sim::SolverResult::get_score_set() const {
+  return scores;
+}

test/test_simulation.cpp

@@ -259,11 +259,11 @@ TEST(Simulation, SolverResult) {
     for (auto train_idx = train_idxs.begin(); train_idx != train_idxs.end();
          train_idx++) {
       const auto           train          = train_list.get_train(*train_idx);
-      double               previous_score = result.get_score();
+      double               previous_score = result.get_score_set().get_score();
       sim::RoutingSolution round_sol{instance, train, rng_engine};
       sim::TrainTrajectory round_traj{instance, train, round_sol};
       result.insert_or_assign(round_sol, round_traj);
-      ASSERT_GE(result.get_score(), previous_score);
+      ASSERT_GE(result.get_score_set().get_score(), previous_score);
     }
   }
 }