fix

Author: mgeplf

include/bbp/sonata/config.h

@@ -11,7 +11,6 @@
 
 #pragma once
 
-#include <memory>  // std::unique_ptr
 #include <set>
 #include <string>
 #include <unordered_map>
@@ -266,27 +265,34 @@ class SONATA_API SimulationConfig
     struct Run {
         enum class IntegrationMethod { invalid = -1, euler, nicholson, nicholson_ion };
 
+        static constexpr int DEFAULT_spikeThreshold = -30;
+        static constexpr IntegrationMethod DEFAULT_IntegrationMethod = IntegrationMethod::euler;
+        static constexpr int DEFAULT_stimulusSeed = 0;
+        static constexpr int DEFAULT_ionchannelSeed = 0;
+        static constexpr int DEFAULT_minisSeed = 0;
+        static constexpr int DEFAULT_synapseSeed = 0;
+
         /// Biological simulation end time in milliseconds
         double tstop{};
         /// Integration step duration in milliseconds
         double dt{};
         /// Random seed
         int randomSeed{};
         /// The spike detection threshold. Default is -30mV
-        int spikeThreshold;
+        int spikeThreshold = DEFAULT_spikeThreshold;
         /// Selects the NEURON/CoreNEURON integration method. This parameter sets the NEURON
         /// global variable h.secondorder. Default 0 ('euler')
-        IntegrationMethod integrationMethod;
+        IntegrationMethod integrationMethod = DEFAULT_IntegrationMethod;
         /// A non-negative integer used for seeding noise stimuli and any other future stochastic
         /// stimuli, default is 0.
-        int stimulusSeed;
+        int stimulusSeed = DEFAULT_stimulusSeed;
         /// A non-negative integer used for seeding stochastic ion channels, default is 0.
-        int ionchannelSeed;
+        int ionchannelSeed = DEFAULT_ionchannelSeed;
         /// A non-negative integer used for seeding the Poisson processes that drives the minis,
         /// default is 0.
-        int minisSeed;
+        int minisSeed = DEFAULT_minisSeed;
         /// A non-negative integer used for seeding stochastic synapses, default is 0.
-        int synapseSeed;
+        int synapseSeed = DEFAULT_synapseSeed;
         /// Filename that contains the weights for the LFP calculation.
         std::string electrodesFile;
     };
@@ -296,14 +302,19 @@ class SONATA_API SimulationConfig
     struct Output {
         enum class SpikesSortOrder { invalid = -1, none, by_id, by_time };
 
+        static constexpr char DEFAULT_outputDir[] = "output";
+        static constexpr char DEFAULT_logFile[] = "";
+        static constexpr char DEFAULT_spikesFile[] = "out.h5";
+        static constexpr SpikesSortOrder DEFAULT_sortOrder = SpikesSortOrder::by_time;
+
         /// Spike report file output directory. Default is "output"
-        std::string outputDir;
+        std::string outputDir = DEFAULT_outputDir;
         /// Filename where console output is written. Default is STDOUT.
-        std::string logFile;
+        std::string logFile = DEFAULT_logFile;
         /// Spike report file name. Default is "out.h5"
-        std::string spikesFile;
+        std::string spikesFile = DEFAULT_spikesFile;
         /// The sorting order of the spike report. Default is "by_time"
-        SpikesSortOrder sortOrder;
+        SpikesSortOrder sortOrder = DEFAULT_sortOrder;
     };
 
     struct ModificationBase {
@@ -333,19 +344,23 @@ class SONATA_API SimulationConfig
      */
     struct Conditions {
         enum class SpikeLocation { invalid = -1, soma, AIS };
+        static constexpr double DEFAULT_celsius = 34.0;
+        static constexpr double DEFAULT_vInit = -80.0;
+        static constexpr SpikeLocation DEFAULT_spikeLocation = SpikeLocation::soma;
+        static constexpr bool DEFAULT_randomizeGabaRiseTime = false;
 
         /// Temperature of experiment. Default is 34.0
-        double celsius;
+        double celsius = DEFAULT_celsius;
         /// Initial membrane voltage in mV. Default is -80
-        double vInit;
+        double vInit = DEFAULT_vInit;
         /// The spike detection location. Can be either ‘soma’ or 'AIS'. Default is 'soma'
-        SpikeLocation spikeLocation;
+        SpikeLocation spikeLocation = DEFAULT_spikeLocation;
         /// Extracellular calcium concentration, being applied to the synapse uHill parameter in
         /// order to scale the U parameter of synapses. Default is None.
         nonstd::optional<double> extracellularCalcium{nonstd::nullopt};
         /// Enable legacy behavior to randomize the GABA_A rise time in the helper functions.
         /// Default is false
-        bool randomizeGabaRiseTime;
+        bool randomizeGabaRiseTime = DEFAULT_randomizeGabaRiseTime;
         /// Properties to assign values to variables in synapse MOD files.
         /// The format is a dictionary with keys being the SUFFIX names and values being
         /// dictionaries of variables' names and values.

python/tests/test_config.py

@@ -628,16 +628,14 @@ def test_empty_connection_overrides(self):
     def test_empty_conditions(self):
         contents = """
         {
-          "manifest": {
-            "$CIRCUIT_DIR": "./circuit"
-          },
+          "manifest": { "$CIRCUIT_DIR": "./circuit" },
           "network": "$CIRCUIT_DIR/circuit_config.json",
           "run": { "random_seed": 12345, "dt": 0.05, "tstop": 1000 },
           "connection_overrides": []
         }
         """
         conf = SimulationConfig(contents, "./")
-        self.assertEqual(conf.conditions.celsius, 35.0)
+        self.assertEqual(conf.conditions.celsius, 34.0)
         self.assertEqual(conf.conditions.v_init, -80)
 
     def test_run(self):

src/config.cpp

@@ -132,6 +132,25 @@ NLOHMANN_JSON_SERIALIZE_ENUM(
      {SimulationConfig::ModificationBase::ModificationType::ConfigureAllSections,
       "ConfigureAllSections"}})
 
+// { in C++14; one has to declare static constexpr members; this can go away in c++17
+#define D(name) decltype(SimulationConfig::name) constexpr SimulationConfig::name;
+D(Output::DEFAULT_outputDir)
+D(Conditions::DEFAULT_randomizeGabaRiseTime)
+D(Output::DEFAULT_logFile)
+D(Run::DEFAULT_stimulusSeed)
+D(Conditions::DEFAULT_spikeLocation)
+D(Run::DEFAULT_ionchannelSeed)
+D(Output::DEFAULT_sortOrder)
+D(Run::DEFAULT_IntegrationMethod)
+D(Conditions::DEFAULT_vInit)
+D(Run::DEFAULT_minisSeed)
+D(Output::DEFAULT_spikesFile)
+D(Conditions::DEFAULT_celsius)
+D(Run::DEFAULT_synapseSeed)
+D(Run::DEFAULT_spikeThreshold)
+#undef D
+// }
+
 namespace {
 // to be replaced by std::filesystem once C++17 is used
 namespace fs = ghc::filesystem;
@@ -976,15 +995,15 @@ class SimulationConfig::Parser
         parseMandatory(*runIt, "tstop", "run", result.tstop);
         parseMandatory(*runIt, "dt", "run", result.dt);
         parseMandatory(*runIt, "random_seed", "run", result.randomSeed);
-        parseOptional(*runIt, "spike_threshold", result.spikeThreshold, {-30});
+        parseOptional(*runIt, "spike_threshold", result.spikeThreshold, {Run::DEFAULT_spikeThreshold});
         parseOptional(*runIt,
                       "integration_method",
                       result.integrationMethod,
-                      {Run::IntegrationMethod::euler});
-        parseOptional(*runIt, "stimulus_seed", result.stimulusSeed, {0});
-        parseOptional(*runIt, "ionchannel_seed", result.ionchannelSeed, {0});
-        parseOptional(*runIt, "minis_seed", result.minisSeed, {0});
-        parseOptional(*runIt, "synapse_seed", result.synapseSeed, {0});
+                      {Run::DEFAULT_IntegrationMethod});
+        parseOptional(*runIt, "stimulus_seed", result.stimulusSeed, {Run::DEFAULT_stimulusSeed});
+        parseOptional(*runIt, "ionchannel_seed", result.ionchannelSeed, {Run::DEFAULT_ionchannelSeed});
+        parseOptional(*runIt, "minis_seed", result.minisSeed, {Run::DEFAULT_minisSeed});
+        parseOptional(*runIt, "synapse_seed", result.synapseSeed, {Run::DEFAULT_synapseSeed});
         parseOptional(*runIt, "electrodes_file", result.electrodesFile, {""});
 
         if (!result.electrodesFile.empty()) {
@@ -1001,37 +1020,37 @@ class SimulationConfig::Parser
         if (outputIt == _json.end()) {
             return result;
         }
-        parseOptional(*outputIt, "output_dir", result.outputDir, {"output"});
-        parseOptional(*outputIt, "log_file", result.logFile, {""});
-        parseOptional(*outputIt, "spikes_file", result.spikesFile, {"out.h5"});
+        parseOptional(*outputIt, "output_dir", result.outputDir, {Output::DEFAULT_outputDir});
+        parseOptional(*outputIt, "log_file", result.logFile, {Output::DEFAULT_logFile});
+        parseOptional(*outputIt, "spikes_file", result.spikesFile, {Output::DEFAULT_spikesFile});
         parseOptional(*outputIt,
                       "spikes_sort_order",
                       result.sortOrder,
-                      {Output::SpikesSortOrder::by_time});
+                      {Output::DEFAULT_sortOrder});
 
         result.outputDir = toAbsolute(_basePath, result.outputDir);
 
         return result;
     }
 
     SimulationConfig::Conditions parseConditions() const {
-        SimulationConfig::Conditions result{};
+        SimulationConfig::Conditions result;
 
         const auto conditionsIt = _json.find("conditions");
         if (conditionsIt == _json.end()) {
             return result;
         }
-        parseOptional(*conditionsIt, "celsius", result.celsius, {34.0});
-        parseOptional(*conditionsIt, "v_init", result.vInit, {-80});
+        parseOptional(*conditionsIt, "celsius", result.celsius, {Conditions::DEFAULT_celsius});
+        parseOptional(*conditionsIt, "v_init", result.vInit, {Conditions::DEFAULT_vInit});
         parseOptional(*conditionsIt,
                       "spike_location",
                       result.spikeLocation,
-                      {Conditions::SpikeLocation::soma});
+                      {Conditions::DEFAULT_spikeLocation});
         parseOptional(*conditionsIt, "extracellular_calcium", result.extracellularCalcium);
         parseOptional(*conditionsIt,
                       "randomize_gaba_rise_time",
                       result.randomizeGabaRiseTime,
-                      {false});
+                      {Conditions::DEFAULT_randomizeGabaRiseTime});
         parseConditionsMechanisms(*conditionsIt, result.mechanisms);
         parseConditionsModifications(*conditionsIt, result.modifications);
         return result;
@@ -1093,7 +1112,7 @@ class SimulationConfig::Parser
     }
 
     SimulationConfig::SimulatorType parseTargetSimulator() const {
-        SimulationConfig::SimulatorType val;
+        SimulationConfig::SimulatorType val = SimulationConfig::SimulatorType::NEURON;
         parseOptional(_json, "target_simulator", val, {SimulationConfig::SimulatorType::NEURON});
         return val;
     }
@@ -1135,7 +1154,7 @@ class SimulationConfig::Parser
             const auto& valueIt = it.value();
             const auto debugStr = fmt::format("input {}", it.key());
 
-            InputBase::Module module;
+            InputBase::Module module = InputBase::Module::invalid;
             parseMandatory(valueIt, "module", debugStr, module);
 
             const auto input = parseInputModule(valueIt, module, _basePath, debugStr);