fix asserts for debug builds

Author: reneSchm

cpp/memilio/utils/index.h

@@ -22,6 +22,7 @@
 
 #include "memilio/io/io.h"
 #include "memilio/utils/compiler_diagnostics.h"
+#include "memilio/utils/metaprogramming.h"
 #include "memilio/utils/type_safe.h"
 
 #include <cstddef>
@@ -116,9 +117,10 @@ class MEMILIO_ENABLE_EBO Index<CategoryTag> : public TypeSafe<size_t, Index<Cate
 public:
     using TypeSafe<size_t, Index<CategoryTag>>::TypeSafe;
 
-    static size_t constexpr size = 1;
+    static constexpr size_t size         = 1;
+    static constexpr bool has_duplicates = false;
 
-    static Index constexpr Zero()
+    static constexpr Index Zero()
     {
         return Index((size_t)0);
     }
@@ -173,7 +175,8 @@ template <typename... CategoryTag>
 class Index
 {
 public:
-    static size_t constexpr size = sizeof...(CategoryTag);
+    static constexpr size_t size         = sizeof...(CategoryTag);
+    static constexpr bool has_duplicates = has_duplicates_v<CategoryTag...>;
 
     static Index constexpr Zero()
     {
@@ -211,6 +214,25 @@ class Index
         return !(this == other);
     }
 
+    bool operator<(Index const& other) const
+    {
+        // use apply to unfold both tuples, then use a fold expression to evaluate a pairwise less
+        return std::apply(
+            [&other](auto&&... indices_) {
+                return std::apply(
+                    [&](auto&&... other_indices_) {
+                        return ((indices_ < other_indices_) && ...);
+                    },
+                    other.indices);
+            },
+            indices);
+    }
+
+    bool operator<=(Index const& other) const
+    {
+        return (*this == other) || (*this < other);
+    }
+
     /**
      * serialize this. 
      * @see mio::serialize
@@ -372,9 +394,16 @@ inline Index<CategoryTags...> extend_index_impl(const Index<Subset...>& i, const
  * @return A (sub)index with the given categories and values from index.
  */
 template <class SubIndex, class SuperIndex>
-SubIndex reduce_index(const SuperIndex& index)
+decltype(auto) reduce_index(const SuperIndex& index)
 {
-    return details::reduce_index_impl(index, mio::Tag<SubIndex>{});
+    if constexpr (SubIndex::size == 1 && std::is_base_of_v<Index<SubIndex>, SubIndex>) {
+        // this case handles reducing from e.g. Index<AgeGroup, ...> directly to AgeGroup
+        // the default case would instead reduce to Index<AgeGroup>, which may cause conversion errors
+        return details::reduce_index_impl(index, mio::Tag<Index<SubIndex>>{});
+    }
+    else {
+        return details::reduce_index_impl(index, mio::Tag<SubIndex>{});
+    }
 }
 
 template <class Enum, class SuperIndex>

cpp/models/smm/model.h

@@ -51,6 +51,7 @@ class Model : public mio::CompartmentalModel<FP, Comp, mio::Populations<FP, Popu
 {
     using Base = mio::CompartmentalModel<FP, Comp, mio::Populations<FP, PopulationIndex<StatusT, RegionT>>,
                                          ParametersBase<FP, StatusT, RegionT>>;
+    static_assert(!Base::Populations::Index::has_duplicates, "Do not use the same Index tag multiple times!");
 
 public:
     using Status = StatusT;

cpp/models/smm/simulation.h

@@ -41,7 +41,6 @@ class Simulation
 {
 public:
     using Model = smm::Model<FP, Comp, Status, Region>;
-    using Index = typename Model::Populations::Index;
 
     /**
      * @brief Set up the simulation for a Stochastic Metapopulation Model.
@@ -60,12 +59,14 @@ class Simulation
     {
         assert(dt > 0);
         assert(m_waiting_times.size() > 0);
-        assert(std::all_of(adoption_rates().begin(), adoption_rates().end(), [](auto&& r) {
-            return static_cast<size_t>(r.region) < regions;
-        }));
-        assert(std::all_of(transition_rates().begin(), transition_rates().end(), [](auto&& r) {
-            return static_cast<size_t>(r.from) < regions && static_cast<size_t>(r.to) < regions;
-        }));
+        assert(std::all_of(adoption_rates().begin(), adoption_rates().end(),
+                           [regions = reduce_index<Region>(model.populations.size())](auto&& r) {
+                               return r.region < regions;
+                           }));
+        assert(std::all_of(transition_rates().begin(), transition_rates().end(),
+                           [regions = reduce_index<Region>(model.populations.size())](auto&& r) {
+                               return r.from < regions && r.to < regions;
+                           }));
         // initialize (internal) next event times by random values
         for (size_t i = 0; i < m_tp_next_event.size(); i++) {
             m_tp_next_event[i] += mio::ExponentialDistribution<FP>::get_instance()(m_model->get_rng(), 1.0);