Vss modeling

README.md

@@ -75,7 +75,11 @@ Otherwise, they have to be set manually, see also https://support.gurobi.com/hc/
 
 ### Usage
 
-Currently, the tool provides only basic access via the command line. `rail_vss_generation_timetable_mip_testing` provides access to solving a specified instance at different levels of accuracy and with a predefined timeout.
+Currently, the tool provides only basic access via the command line and supports the generation of minimal VSS layouts. More command line functions will be added shortly. Example networks can be found in `test/example-networks/`.
+
+#### MILP based algorithm
+
+`rail_vss_generation_timetable_mip_testing` provides access to solving a specified instance at different levels of accuracy and with a predefined timeout.
 It produces additional debugging output and saves the raw model and solution to a file.
 The syntax is as follows
 
@@ -101,13 +105,39 @@ Hence, the instance _SimpleStation_ can be solved using default values by the fo
 .\build\apps\rail_vss_generation_timetable_mip_testing SimpleStation .\test\example-networks\SimpleStation 15 1 0 1 1 0 1 -1
 ```
 
-More command line functions will be added shortly.
+#### Iterative approach
+
+An iterative approach has been implemented, which can significantly improve the runtime. It uses the continuous model for placing VSS borders. The syntax is as follows
+
+```commandline
+.\build\apps\rail_vss_generation_timetable_mip_iterative_vss_testing [model_name] [instance_path] [delta_t] [fix_routes] [include_train_dynamics] [include_braking_curves] [use_pwl] [use_schedule_cuts] [iterate_vss] [optimality_strategy] [timeout] [output_path - optional]
+```
+
+The parameters meaning is as follows:
+
+- _delta_t_: Length of discretized time intervals in seconds.
+- _fix_routes_: If true, the routes are fixed to the ones given in the instance. Otherwise, routing is part of the optimization.
+- _include_train_dynamics_: If true, the train dynamics (i.e., limited acceleration and deceleration) are included in the model.
+- _include_braking_curves_: If true, the braking curves (i.e., the braking distance depending on the current speed has to be cleared) are included in the model.
+- _use_pwl_: If true, the braking distances are approximated by piecewise linear functions with a fixed maximal error. Otherwise, they are modeled as quadratic functions and Gurobi's ability to solve these using spatial branching is used. Only relevant if include_braking_curves is true.
+- _use_schedule_cuts_: If true, the formulation is strengthened using cuts implied by the schedule.
+- _iterate_vss_: If true, the solver proceeds iteratively, i.e., it will start by trying to solve a restricted model, which is easier to solve, and only slowly increases its size. In many cases, already on such restricted models the optimal solution can be found.
+- _optimality_strategy_: 0 (Optimal): The proven optimal solution is found; 1 (TradeOff): The restricted model is solved to optimality. The solution is returned even if it is not proven to be globally optimal. Experiments show that it is likely optimal, but the algorithm provides no guarantee; 2 (Feasible): The algorithm focuses only on finding a (probably good) feasible solution. It is likely not the optimal solution, but only close to optimal. No guarantee is provided.
+- _time_limit_: Time limit in seconds. No limit if negative.
+- _output_path_: The path in which the solution is written. The default is the current working directory.
+
+Booleans have to be passed as numbers (0 = false or 1 = true).
+Hence, the instance _SimpleStation_ can be solved using default values by the following command:
+
+```commandline
+.\build\apps\rail_vss_generation_timetable_mip_iterative_vss_testing SimpleStation .\test\example-networks\SimpleStation 15 1 1 1 0 1 1 0 -1
+```
+
+#### Access via C++
 
 Additionally, one can call the public methods to create, save, load, and solve respective instances in C++ directly.
 For this, we refer to the source code's docstrings and example usages in the Google Tests found in the `test` folder.
 
-Example networks can be found in `test/example-networks/`.
-
 ## Contact Information
 
 If you have any questions, feel free to contact us via [email protected] or by creating an issue on GitHub.

apps/CMakeLists.txt

@@ -5,3 +5,5 @@ macro(ADD_SIM_EXECUTABLE appname)
 endmacro()
 
 add_sim_executable(vss_generation_timetable_mip_testing)
+add_sim_executable(vss_generation_timetable_mip_iterative_vss_testing)
+add_sim_executable(vss_generation_timetable_iterative_parameter_testing)

apps/vss_generation_timetable_iterative_parameter_testing.cpp

@@ -0,0 +1,99 @@
+#include "Definitions.hpp"
+#include "VSSModel.hpp"
+#include "solver/mip-based/VSSGenTimetableSolver.hpp"
+
+#include <gsl/span>
+
+int main(int argc, char** argv) {
+  if (argc < 13 || argc > 15) {
+    std::cerr << "Expected 12 or 13 or 14 arguments, got " << argc - 1
+              << std::endl;
+    std::exit(-1);
+  }
+
+  auto args = gsl::span<char*>(argv, argc);
+
+  const std::string                                  model_name    = args[1];
+  const std::string                                  instance_path = args[2];
+  cda_rail::solver::mip_based::VSSGenTimetableSolver solver(instance_path);
+
+  std::cout << "Instance " << model_name << " loaded at " << instance_path
+            << std::endl;
+
+  const int  delta_t                 = std::stoi(args[3]);
+  const bool fix_routes              = std::stoi(args[4]) != 0;
+  const bool include_braking_curves  = std::stoi(args[5]) != 0;
+  const bool iterate_vss             = std::stoi(args[6]) != 0;
+  const int  optimality_strategy_int = std::stoi(args[7]);
+  const auto optimality_strategy =
+      static_cast<cda_rail::OptimalityStrategy>(optimality_strategy_int);
+  const int  update_strategy_int = std::stoi(args[8]);
+  const auto update_strategy =
+      static_cast<cda_rail::solver::mip_based::UpdateStrategy>(
+          update_strategy_int);
+  const double      initial_vss  = std::stod(args[9]);
+  const double      update_value = std::stod(args[10]);
+  const bool        include_cuts = std::stoi(args[11]) != 0;
+  const int         timeout      = std::stoi(args[12]);
+  const std::string output_path  = (argc >= 14 ? args[13] : "");
+  const std::string file_name =
+      (argc >= 15
+           ? args[14]
+           : model_name + "_" + std::to_string(delta_t) + "_" +
+                 std::to_string(static_cast<int>(fix_routes)) + "_" +
+                 std::to_string(static_cast<int>(include_braking_curves)) +
+                 "_" + std::to_string(static_cast<int>(iterate_vss)) + "_" +
+                 std::to_string(optimality_strategy_int) + "_" +
+                 std::to_string(update_strategy_int) + "_" +
+                 std::to_string(initial_vss) + "_" +
+                 std::to_string(update_value) + "_" +
+                 std::to_string(static_cast<int>(include_cuts)) + "_" +
+                 std::to_string(timeout));
+
+  std::cout << "The following parameters were passed to the toolkit:"
+            << std::endl;
+  std::cout << "   delta_t: " << delta_t << std::endl;
+  if (fix_routes) {
+    std::cout << "   routes are fixed" << std::endl;
+  }
+  if (include_braking_curves) {
+    std::cout << "   braking distance is included" << std::endl;
+  }
+  if (iterate_vss) {
+    std::cout << "   VSS is iterated to optimality" << std::endl;
+    std::cout << "      using initial value " << initial_vss << std::endl;
+    std::cout << "      and update value " << update_value << std::endl;
+    if (update_strategy == cda_rail::solver::mip_based::UpdateStrategy::Fixed) {
+      std::cout << "      with fixed update strategy" << std::endl;
+    } else if (update_strategy ==
+               cda_rail::solver::mip_based::UpdateStrategy::Relative) {
+      std::cout << "      with relative update strategy" << std::endl;
+    } else {
+      std::cout << "      with unknown update strategy" << std::endl;
+    }
+    if (include_cuts) {
+      std::cout << "      and cuts are used" << std::endl;
+    }
+  }
+  if (optimality_strategy == cda_rail::OptimalityStrategy::Optimal) {
+    std::cout << "   optimality strategy: optimal" << std::endl;
+  } else if (optimality_strategy == cda_rail::OptimalityStrategy::TradeOff) {
+    std::cout << "   optimality strategy: trade-off" << std::endl;
+  } else if (optimality_strategy == cda_rail::OptimalityStrategy::Feasible) {
+    std::cout << "   optimality strategy: feasible" << std::endl;
+  } else {
+    std::cout << "   optimality strategy: unknown" << std::endl;
+  }
+  std::cout << "   timeout: " << timeout << "s" << std::endl;
+  std::cout << "   output path: " << output_path << std::endl;
+  std::cout << "   file name: " << file_name << std::endl;
+
+  cda_rail::vss::Model vss_model(cda_rail::vss::ModelType::Continuous);
+
+  solver.solve(
+      {delta_t, fix_routes, true, include_braking_curves}, {vss_model},
+      {iterate_vss, optimality_strategy, update_strategy, initial_vss,
+       update_value, include_cuts},
+      {false, cda_rail::ExportOption::ExportSolution, file_name, output_path},
+      timeout, true);
+}

apps/vss_generation_timetable_mip_iterative_vss_testing.cpp

@@ -0,0 +1,86 @@
+#include "Definitions.hpp"
+#include "VSSModel.hpp"
+#include "solver/mip-based/VSSGenTimetableSolver.hpp"
+
+#include <gsl/span>
+
+int main(int argc, char** argv) {
+  if (argc < 12 || argc > 13) {
+    std::cerr << "Expected 11 or 12 arguments, got " << argc - 1 << std::endl;
+    std::exit(-1);
+  }
+
+  auto args = gsl::span<char*>(argv, argc);
+
+  const std::string                                  model_name    = args[1];
+  const std::string                                  instance_path = args[2];
+  cda_rail::solver::mip_based::VSSGenTimetableSolver solver(instance_path);
+
+  std::cout << "Instance " << model_name << " loaded at " << instance_path
+            << std::endl;
+
+  const int  delta_t                 = std::stoi(args[3]);
+  const bool fix_routes              = std::stoi(args[4]) != 0;
+  const bool include_train_dynamics  = std::stoi(args[5]) != 0;
+  const bool include_braking_curves  = std::stoi(args[6]) != 0;
+  const bool use_pwl                 = std::stoi(args[7]) != 0;
+  const bool use_schedule_cuts       = std::stoi(args[8]) != 0;
+  const bool iterate_vss             = std::stoi(args[9]) != 0;
+  const int  optimality_strategy_int = std::stoi(args[10]);
+  const auto optimality_strategy =
+      static_cast<cda_rail::OptimalityStrategy>(optimality_strategy_int);
+  const int         timeout     = std::stoi(args[11]);
+  const std::string output_path = (argc == 13 ? args[12] : "");
+
+  std::cout << "The following parameters were passed to the toolkit:"
+            << std::endl;
+  std::cout << "   delta_t: " << delta_t << std::endl;
+  if (fix_routes) {
+    std::cout << "   routes are fixed" << std::endl;
+  }
+  if (include_train_dynamics) {
+    std::cout << "   acceleration and deceleration are included" << std::endl;
+  }
+  if (include_braking_curves) {
+    std::cout << "   braking distance is included" << std::endl;
+  }
+  if (use_pwl) {
+    std::cout << "   piecewise linear functions are used" << std::endl;
+  }
+  if (use_schedule_cuts) {
+    std::cout << "   schedule cuts are used" << std::endl;
+  }
+  if (iterate_vss) {
+    std::cout << "   VSS is iterated" << std::endl;
+  }
+  if (optimality_strategy == cda_rail::OptimalityStrategy::Optimal) {
+    std::cout << "   optimality strategy: optimal" << std::endl;
+  } else if (optimality_strategy == cda_rail::OptimalityStrategy::TradeOff) {
+    std::cout << "   optimality strategy: trade-off" << std::endl;
+  } else if (optimality_strategy == cda_rail::OptimalityStrategy::Feasible) {
+    std::cout << "   optimality strategy: feasible" << std::endl;
+  } else {
+    std::cout << "   optimality strategy: unknown" << std::endl;
+  }
+  std::cout << "   timeout: " << timeout << "s" << std::endl;
+
+  const std::string file_name =
+      model_name + "_" + std::to_string(delta_t) + "_" +
+      std::to_string(static_cast<int>(fix_routes)) + "_" +
+      std::to_string(static_cast<int>(include_train_dynamics)) + "_" +
+      std::to_string(static_cast<int>(include_braking_curves)) + "_" +
+      std::to_string(static_cast<int>(use_pwl)) + "_" +
+      std::to_string(static_cast<int>(use_schedule_cuts)) + "_" +
+      std::to_string(static_cast<int>(iterate_vss)) + "_" +
+      std::to_string(static_cast<int>(optimality_strategy_int)) + "_" +
+      std::to_string(timeout);
+
+  cda_rail::vss::Model vss_model(cda_rail::vss::ModelType::Continuous);
+
+  solver.solve(
+      {delta_t, fix_routes, include_train_dynamics, include_braking_curves},
+      {vss_model, use_pwl, use_schedule_cuts},
+      {iterate_vss, optimality_strategy},
+      {false, cda_rail::ExportOption::ExportSolution, file_name, output_path},
+      timeout, true);
+}

apps/vss_generation_timetable_mip_testing.cpp

@@ -1,10 +1,12 @@
+#include "Definitions.hpp"
+#include "VSSModel.hpp"
 #include "solver/mip-based/VSSGenTimetableSolver.hpp"
 
 #include <gsl/span>
 
 int main(int argc, char** argv) {
-  if (argc != 11) {
-    std::cout << "Expected 10 arguments, got " << argc - 1 << std::endl;
+  if (argc < 11 || argc > 12) {
+    std::cerr << "Expected 10 or 11 arguments, got " << argc - 1 << std::endl;
     std::exit(-1);
   }
 
@@ -17,14 +19,15 @@ int main(int argc, char** argv) {
   std::cout << "Instance " << model_name << " loaded at " << instance_path
             << std::endl;
 
-  const int  delta_t                  = std::stoi(args[3]);
-  const bool fix_routes               = std::stoi(args[4]) != 0;
-  const bool discretize_vss_positions = std::stoi(args[5]) != 0;
-  const bool include_train_dynamics   = std::stoi(args[6]) != 0;
-  const bool include_braking_curves   = std::stoi(args[7]) != 0;
-  const bool use_pwl                  = std::stoi(args[8]) != 0;
-  const bool use_schedule_cuts        = std::stoi(args[9]) != 0;
-  const int  timeout                  = std::stoi(args[10]);
+  const int         delta_t                  = std::stoi(args[3]);
+  const bool        fix_routes               = std::stoi(args[4]) != 0;
+  const bool        discretize_vss_positions = std::stoi(args[5]) != 0;
+  const bool        include_train_dynamics   = std::stoi(args[6]) != 0;
+  const bool        include_braking_curves   = std::stoi(args[7]) != 0;
+  const bool        use_pwl                  = std::stoi(args[8]) != 0;
+  const bool        use_schedule_cuts        = std::stoi(args[9]) != 0;
+  const int         timeout                  = std::stoi(args[10]);
+  const std::string output_path              = (argc == 12 ? args[11] : "");
 
   std::cout << "The following parameters were passed to the toolkit:"
             << std::endl;
@@ -59,7 +62,17 @@ int main(int argc, char** argv) {
       std::to_string(static_cast<int>(use_schedule_cuts)) + "_" +
       std::to_string(timeout);
 
-  solver.solve(delta_t, fix_routes, discretize_vss_positions,
-               include_train_dynamics, include_braking_curves, use_pwl,
-               use_schedule_cuts, timeout, true, true, file_name);
+  cda_rail::vss::Model vss_model =
+      discretize_vss_positions
+          ? cda_rail::vss::Model(cda_rail::vss::ModelType::Discrete,
+                                 {&cda_rail::vss::functions::uniform})
+          : cda_rail::vss::Model(cda_rail::vss::ModelType::Continuous);
+
+  solver.solve(
+      {delta_t, fix_routes, include_train_dynamics, include_braking_curves},
+      {vss_model, use_pwl, use_schedule_cuts},
+      {false, cda_rail::OptimalityStrategy::Optimal},
+      {false, cda_rail::ExportOption::ExportSolutionWithInstance, file_name,
+       output_path},
+      timeout, true);
 }

include/CustomExceptions.hpp

@@ -1,3 +1,4 @@
+#pragma once
 #include <exception>
 #include <string>
 #include <utility>