added preliminary multihop solver

+ cmake 3.13 required from now on
+ added adjacency matrix
+ in a scan cover, edges can be scanned multiple times

Author: ettoh

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.10.0)
+cmake_minimum_required(VERSION 3.13.0)
 project(dmsc-visualizer VERSION 0.1.0)
 
 set(CMAKE_CXX_STANDARD 17)
@@ -8,18 +8,18 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 find_package(glm REQUIRED)
 
 # GLFW library
-# TODO not found -> local path
 find_package(glfw3 REQUIRED)
 
 add_library(dmsc STATIC)
 set_target_properties(dmsc PROPERTIES PROJECT_SOURCE_DIR ${PROJECT_SOURCE_DIR})
 
 # Debug flags
 if(MSVC)
-  target_compile_options(dmsc PRIVATE /W4 
-    /wd4458 # declaration of 'identifier' hides class member
-    /wd4100 # 'identifier' : unreferenced formal parameter
+    target_compile_options(dmsc PRIVATE /W4
+        /wd4458 # declaration of 'identifier' hides class member
+        /wd4100 # 'identifier' : unreferenced formal parameter
     )
+    target_link_options(dmsc PUBLIC /NODEFAULTLIB:MSVCRT)
 else()
   target_compile_options(dmsc PRIVATE -Wall -Wextra -pedantic)
 endif()
@@ -36,19 +36,27 @@ endmacro()
 
 # Examples
 OPTION(BUILD_SAMPLES
-  "If the examples are built as well." ON )
+    "If the examples are built as well." ON)
 if(BUILD_SAMPLES)
     add_subdirectory(./examples)
 endif()
 
-# imgui source files
-set(imgui_files
+# external source files
+set(external_files
     external/imgui/imgui.cpp
     external/imgui/imgui_draw.cpp
     external/imgui/imgui_widgets.cpp
     external/imgui/imgui_tables.cpp
     external/imgui/backends/imgui_impl_glfw.cpp
     external/imgui/backends/imgui_impl_opengl3.cpp
+    external/glad/src/glad.c
+)
+
+# solver source files
+set(solver_files
+    src/solver.cpp
+    src/solver/greedy_next.cpp
+    src/solver/greedy_next_khop.cpp
 )
 
 # source files
@@ -57,11 +65,9 @@ target_sources(dmsc
         src/visuals.cpp
         src/instance.cpp
         src/opengl_widgets.cpp
-        src/opengl_primitives.cpp
-        src/solver.cpp
-        src/solver/greedy_next.cpp
-        external/glad/src/glad.c
-        ${imgui_files}
+        src/opengl_primitives.cpp        
+        ${solver_files}
+        ${external_files}
 )
 
 target_include_directories(dmsc

examples/solver.cpp

@@ -1,34 +1,35 @@
 #include <dmsc/instance.hpp>
 #include <dmsc/solver/greedy_next.hpp>
+#include <dmsc/solver/greedy_next_khop.hpp>
 #include <dmsc/visuals.hpp>
 
 using dmsc::solver::GreedyNext;
+using dmsc::solver::GreedyNextKHop;
 
 int main() {
     dmsc::Instance instance;
 
     // 1. create satellites
     dmsc::StateVector sv; // represents a satellite
+    sv.initial_true_anomaly = dmsc::rad(90.f);
     sv.height_perigee = 200.f;
     instance.satellites.push_back(sv); // satellite 0
-    sv.initial_true_anomaly = dmsc::rad(15.f);
-    sv.inclination = dmsc::rad(45.f);
+    sv.inclination = dmsc::rad(50.f);
     instance.satellites.push_back(sv); // satellite 1
-    sv.initial_true_anomaly = dmsc::rad(350.f);
-    sv.inclination = dmsc::rad(23.f);
+    sv.inclination = dmsc::rad(25.f);
     instance.satellites.push_back(sv); // satellite 2
 
     // 2. schedule communications between satellites
-    instance.edges.push_back(dmsc::Edge(0, 1)); // communication between sat 0 and sat 1
-    instance.edges.push_back(dmsc::Edge(0, 2)); // communication between sat 0 and sat 2
-    instance.edges.push_back(dmsc::Edge(1, 2)); // communication between sat 1 and sat 2
+    instance.edges.push_back(dmsc::Edge(0, 1));       // communication between sat 0 and sat 1
+    instance.edges.push_back(dmsc::Edge(0, 2, true)); // communication between sat 0 and sat 2
+    instance.edges.push_back(dmsc::Edge(1, 2, true)); // communication between sat 1 and sat 2
 
     // 3. solve the instance
-    GreedyNext solver = GreedyNext(dmsc::PhysicalInstance(instance));
+    GreedyNextKHop solver = GreedyNextKHop(dmsc::PhysicalInstance(instance), 1);
     dmsc::Solution solution = solver.solve();
 
     // 4. visualize solution
-    visualizeSolution(instance, solution);
+    dmsc::visualizeSolution(instance, solution);
 
     return 0;
 }

include/dmsc/edge.hpp

@@ -17,21 +17,21 @@ struct EdgeOrientation {
 class InterSatelliteLink {
   public:
     // only defined for circular Orbits!
-    InterSatelliteLink(const uint32_t& sat_from, const uint32_t& sat_to, const std::vector<Satellite>& satellites,
+    InterSatelliteLink(const uint32_t& v1_idx, const uint32_t& v2_idx, const std::vector<Satellite>& satellites,
                        const CentralMass cm, const bool optional = false)
-        : sat_from(sat_from)
-        , sat_to(sat_to)
+        : v1_idx(v1_idx)
+        , v2_idx(v2_idx)
         , cm(cm)
         , optional(optional) {
 
-        if (sat_from >= satellites.size() || sat_to >= satellites.size()) {
+        if (v1_idx >= satellites.size() || v2_idx >= satellites.size()) {
             printf("There is no such satellite in given vector!\n");
             assert(false);
             exit(EXIT_FAILURE);
         }
 
-        v1 = &satellites[sat_from];
-        v2 = &satellites[sat_to];
+        v1 = &satellites[v1_idx];
+        v2 = &satellites[v2_idx];
         period = v1->getPeriod();
         if (v1->getSemiMajorAxis() != v2->getSemiMajorAxis()) {
             period = v1->getPeriod() * v2->getPeriod(); // [sec]
@@ -88,7 +88,7 @@ class InterSatelliteLink {
 
         if (sat2.isValid()) {
             angle_sat2 = std::acos(glm::dot(sat2.data, target.sat2.direction)); // [rad]
-            time_sat2 = sat1.t_begin;
+            time_sat2 = sat2.t_begin;
         } else {
             time_sat2 = 0.f; // event is invalid, so assume that sat1 was not part of a communication yet
         }
@@ -128,15 +128,15 @@ class InterSatelliteLink {
     float getMaxAngle() const { return max_angle; }
     const Satellite& getV1() const { return *v1; }
     const Satellite& getV2() const { return *v2; }
-    const uint32_t getFromIdx() const { return sat_from; }
-    const uint32_t getToIdx() const { return sat_to; }
+    const uint32_t getV1Idx() const { return v1_idx; }
+    const uint32_t getV2Idx() const { return v2_idx; }
     float getRadiusCentralMass() const { return cm.radius_central_mass; }
 
   private:
     const Satellite* v1;
     const Satellite* v2;
-    uint32_t sat_from;
-    uint32_t sat_to;
+    uint32_t v1_idx;
+    uint32_t v2_idx;
     float period;    // [sec] time until satellite constellations repeat
     float max_angle; // [rad] max angle for satellites to see each other
     bool optional;   // If true, no communication is scheduled for this edge

include/dmsc/instance.hpp

@@ -9,6 +9,33 @@
 
 namespace dmsc {
 
+/**
+ * @brief TODO
+ *
+ */
+class AdjacencyMatrix {
+  public:
+    struct Item {
+        uint32_t weight = ~0u;
+        uint32_t edge_idx = ~0u; // index of isl-object in physical instance
+        Item() = default;
+        Item(const uint32_t weight, const uint32_t edge_idx)
+            : weight(weight)
+            , edge_idx(edge_idx) {}
+    };
+
+    AdjacencyMatrix() = delete;
+    AdjacencyMatrix(const size_t size, const Item& default_value = Item());
+
+    std::vector<std::vector<Item>> matrix;
+
+    void clear();
+
+    // GETTER
+    std::vector<Item> column(const size_t column) const;
+    std::vector<Item> row(const size_t row) const;
+};
+
 // ------------------------------------------------------------------------------------------------
 
 /**
@@ -73,12 +100,18 @@ class PhysicalInstance {
     float getRadiusCentralMass() const { return cm.radius_central_mass; }
     const std::vector<Satellite>& getSatellites() const { return satellites; }
     const std::vector<InterSatelliteLink>& getEdges() const { return edges; }
+    const AdjacencyMatrix& getAdjacencyMatrix() const { return adjacency_matrix; }
+    const size_t edgeSize() const { return edges.size(); }
+    const size_t satelliteSize() const { return satellites.size(); }
 
   private:
-    CentralMass cm;
-    enum FileReadingMode { READ_INIT, READ_ORBIT, READ_EDGE }; // order must match blocks in file-format
     std::vector<Satellite> satellites;
     std::vector<InterSatelliteLink> edges;
+    CentralMass cm;
+    AdjacencyMatrix adjacency_matrix = AdjacencyMatrix(0);
+    enum FileReadingMode { READ_INIT, READ_ORBIT, READ_EDGE }; // order must match blocks in file-format
+
+    void buildAdjacencyMatrix();
 };
 
 // ------------------------------------------------------------------------------------------------

include/dmsc/solver.hpp

@@ -9,7 +9,7 @@
 
 namespace dmsc {
 
-using ScanCover = std::map<uint32_t, float>; // when an edge is scanned - time in [sec]
+using ScanCover = std::multimap<uint32_t, float>; // when an edge is scanned - time in [sec]
 
 struct Solution {
     float computation_time = 0.f; // [sec]
@@ -24,7 +24,7 @@ using EdgeOrder = std::vector<int>;
 class Solver {
   public:
     Solver(const PhysicalInstance& instance)
-        : instance(PhysicalInstance(instance)) {
+        : instance(instance) {
         createCache();
     };
 
@@ -48,15 +48,6 @@ class Solver {
      */
     float nextVisibility(const InterSatelliteLink& edge, const float t0);
 
-    /**
-     * @brief
-     * @param scan_cover A sorted scan cover.
-     * @return
-     */
-    EdgeOrder toEdgeOrder(const ScanCover& scan_cover);
-
-    ScanCover evaluateEdgeOrder(const EdgeOrder& edge_order);
-
     const PhysicalInstance instance;
     const float step_size = 1.0f; // [sec]
     std::map<const Satellite*, TimelineEvent<glm::vec3>>

include/dmsc/solver/greedy_next_khop.hpp

@@ -0,0 +1,37 @@
+#ifndef DMSC_GreedyNextKHop_H
+#define DMSC_GreedyNextKHop_H
+
+#include "../instance.hpp"
+#include "../solver.hpp"
+
+namespace dmsc {
+namespace solver {
+
+class GreedyNextKHop : public Solver {
+  public:
+    /**
+     * @brief Construct a new GreedyNextKHop solver object.
+     * @param k number of "extra" satellites - e.g. k=1 allows 3 edges (origin, hop, target)
+     */
+    GreedyNextKHop(const PhysicalInstance& instance, const unsigned int k)
+        : Solver(instance)
+        , k(k) {}
+
+    Solution solve();
+
+  private:
+    struct Communication; // stores all paths for a scheduled communication and the currently chosen path + progress
+    using Path = std::vector<uint32_t>;
+    unsigned int k; // number of hops allowed
+
+    /**
+     * @brief Breadth-first search
+     * @return first: if true, at least one path was found; second: adjacency matrix
+     */
+    std::pair<bool, AdjacencyMatrix> findPaths(const uint32_t from, const uint32_t to) const;
+};
+
+} // namespace solver
+} // namespace dmsc
+
+#endif