Stricter checks on network construction / simulation parameters.

arbor/connection.hpp

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <cstdint>
-
 #include <arbor/common_types.hpp>
 #include <arbor/spike.hpp>
 #include <arbor/spike_event.hpp>

arbor/include/arbor/recipe.hpp

@@ -54,8 +54,8 @@ struct cell_connection_base {
 
     cell_connection_base(L src, cell_local_label_type dst, float w, const U::quantity& d):
         source(std::move(src)), target(std::move(dst)), weight(w), delay(d.value_as(U::ms)) {
-        if (std::isnan(weight)) throw std::out_of_range("Connection weight must be finite.");
-        if (std::isnan(delay) || delay < 0)  throw std::out_of_range("Connection delay must be non-negative and infinite in units of [ms].");
+        if (std::isnan(weight)) throw std::domain_error("Connection weight must be finite.");
+        if (std::isnan(delay) || delay <= 0)  throw std::domain_error("Connection delay must be positive, finite, and given in units of [ms].");
     }
 };
 
@@ -69,7 +69,7 @@ struct gap_junction_connection {
 
     gap_junction_connection(cell_global_label_type peer, cell_local_label_type local, double g):
         peer(std::move(peer)), local(std::move(local)), weight(g) {
-        if (std::isnan(weight)) throw std::out_of_range("Gap junction weight must be finite.");
+        if (std::isnan(weight)) throw std::domain_error("Gap junction weight must be finite.");
     }
 };
 

arbor/simulation.cpp

@@ -19,6 +19,7 @@
 #include "threading/threading.hpp"
 #include "util/maputil.hpp"
 #include "util/span.hpp"
+#include "util/strprintf.hpp"
 #include "profile/profiler_macro.hpp"
 
 namespace arb {
@@ -355,7 +356,7 @@ void simulation_state::reset() {
 time_type simulation_state::run(time_type tfinal, time_type dt) {
     // Progress simulation to time tfinal, through a series of integration epochs
     // of length at most t_interval_. t_interval_ is chosen to be no more than
-    // than half the network minimum delay.
+    // than half the network minimum delay and minimally the timestep `dt`.
     //
     // There are three simulation tasks that can be run partially in parallel:
     //
@@ -394,10 +395,12 @@ time_type simulation_state::run(time_type tfinal, time_type dt) {
     // Requires state at end of run(), with epoch_.id==k:
     //     * U(k) and D(k) have completed.
 
-    if (!std::isfinite(tfinal) || tfinal < 0) throw std::domain_error("simulation: tfinal must be finite, positive, and in [ms]");
-    if (!std::isfinite(dt) || tfinal < 0) throw std::domain_error("simulation: dt must be finite, positive, and in [ms]");
-
-    if (tfinal<=epoch_.t1) return epoch_.t1;
+    // Compare up to picoseconds
+    time_type eps = 1e-9;
+    if (!std::isfinite(dt) || dt < eps) throw std::domain_error("simulation: dt must be finite, positive, and in [ms]");
+    if (dt - t_interval_ > eps) throw std::domain_error(util::pprintf("simulation: dt={}ms is larger than epoch length by {}, chose at most half the minimal connection delay {}ms.", dt, dt - t_interval_, t_interval_));
+    if (!std::isfinite(tfinal) || tfinal < eps) throw std::domain_error("simulation: tfinal must be finite, positive, and in [ms]");
+    if (tfinal - epoch_.t1 < dt) throw std::domain_error(util::pprintf("simulation: tfinal={}ms doesn't make progress of least one dt; current time of simulation is {}ms and dt {}ms", tfinal, epoch_.t1, dt));
 
     // Compute following epoch, with max time tfinal.
     auto next_epoch = [tfinal](epoch e, time_type interval) -> epoch {

test/unit/test_lif_cell_group.cpp

@@ -708,7 +708,7 @@ TEST(lif_cell_group, probe_with_connections) {
         [&spikes](const std::vector<spike>& spk) { for (const auto& s: spk) spikes.push_back(s.time); }
     );
 
-    sim.run(10*U::ms, 0.005*U::ms);
+    sim.run(10*U::ms, 0.0025*U::ms);
     std::vector<Um_type> exp = {{ 0, -18 },
                                 { 0.025, -17.9750624 },
                                 { 0.05, -17.9502492 },

test/unit/test_serdes.cpp

@@ -233,7 +233,7 @@ TEST(serdes, single_cell) {
 }
 
 TEST(serdes, network) {
-    auto dt = 0.5*arb::units::ms;
+    auto dt = 0.05*arb::units::ms;
     auto T  = 5*arb::units::ms;
 
     // Result
@@ -302,7 +302,7 @@ TEST(serdes, host_device_arrays) {
 }
 
 TEST(serdes, single_cell_gpu) {
-    auto dt = 0.5*arb::units::ms;
+    auto dt = 0.05*arb::units::ms;
     auto T  = 5*arb::units::ms;
 
     // Result