Add numeric solver to synapses

doc/running/running_nest.rst

@@ -25,7 +25,7 @@ Event-based updating of synapses
 
 The synapse is allowed to contain an ``update`` block. Statements in the ``update`` block are executed whenever the internal state of the synapse is updated from one timepoint to the next; these updates are typically triggered by incoming spikes. The NESTML ``timestep()`` function will return the time that has elapsed since the last event was handled.
 
-Synapses in NEST are not allowed to have any nonlinear time-based internal dynamics (ODEs). This is due to the fact that synapses are, unlike nodes, not updated on a regular time grid. Linear ODEs are allowed, because they admit an analytical solution, which can be updated in a single step from the previous event time to the current event time. However, nonlinear dynamics are not allowed because they would require a numeric solver evaluating the dynamics on a regular time grid.
+Synapses can have ODEs with linear and non-linear dynamics. In the case of linear dynamics, the ODEs are solved with the propagators provided by the ODE-toolbox; for non-linear dynamics, the ODEs are solved using a fourth order Runge-Kutta solver with adaptive timestep.
 
 If ODE-toolbox is not successful in finding the propagator solver to a system of ODEs that is, however, solvable, the propagators may be entered "by hand" in the ``update`` block of the model. This block may contain any series of statements to update the state of the system from the current timestep to the next, for example, multiplications of state variables by the propagators.
 

pynestml/codegeneration/nest_code_generator.py

@@ -223,14 +223,23 @@ def setup_printers(self):
         self._gsl_variable_printer = GSLVariablePrinter(None)
         if self.option_exists("nest_version") and (self.get_option("nest_version").startswith("2") or self.get_option("nest_version").startswith("v2")):
             self._gsl_function_call_printer = NEST2GSLFunctionCallPrinter(None)
+            self._gsl_function_call_printer_no_origin = NEST2GSLFunctionCallPrinter(None)
         else:
             self._gsl_function_call_printer = NESTGSLFunctionCallPrinter(None)
+            self._gsl_function_call_printer_no_origin = NEST2GSLFunctionCallPrinter(None)
 
         self._gsl_printer = CppExpressionPrinter(simple_expression_printer=CppSimpleExpressionPrinter(variable_printer=self._gsl_variable_printer,
                                                                                                       constant_printer=self._constant_printer,
                                                                                                       function_call_printer=self._gsl_function_call_printer))
         self._gsl_function_call_printer._expression_printer = self._gsl_printer
 
+        self._gsl_variable_printer_no_origin = GSLVariablePrinter(None, with_origin=False)
+        self._gsl_printer_no_origin = CppExpressionPrinter(simple_expression_printer=CppSimpleExpressionPrinter(variable_printer=self._gsl_variable_printer_no_origin,
+                                                                                                                constant_printer=self._constant_printer,
+                                                                                                                function_call_printer=self._gsl_function_call_printer))
+        self._gsl_variable_printer_no_origin._expression_printer = self._gsl_printer_no_origin
+        self._gsl_function_call_printer_no_origin._expression_printer = self._gsl_printer_no_origin
+
         # ODE-toolbox printers
         self._ode_toolbox_variable_printer = ODEToolboxVariablePrinter(None)
         self._ode_toolbox_function_call_printer = ODEToolboxFunctionCallPrinter(None)
@@ -521,6 +530,7 @@ def _get_model_namespace(self, astnode: ASTModel) -> Dict:
         namespace["printer"] = self._nest_printer
         namespace["printer_no_origin"] = self._printer_no_origin
         namespace["gsl_printer"] = self._gsl_printer
+        namespace["gsl_printer_no_origin"] = self._gsl_printer_no_origin
         namespace["nestml_printer"] = NESTMLPrinter()
         namespace["type_symbol_printer"] = self._type_symbol_printer
 
@@ -666,6 +676,9 @@ def _get_synapse_model_namespace(self, synapse: ASTModel) -> Dict:
                 expr_ast.accept(ASTSymbolTableVisitor())
                 namespace["numeric_update_expressions"][sym] = expr_ast
 
+            ASTUtils.assign_numeric_non_numeric_state_variables(synapse, namespace["numeric_state_variables"],
+                                                                namespace["numeric_update_expressions"] if "numeric_update_expressions" in namespace.keys() else None, namespace["update_expressions"] if "update_expressions" in namespace.keys() else None)
+
         namespace["spike_updates"] = synapse.spike_updates
 
         # special case for NEST delay variable (state or parameter)

pynestml/codegeneration/nest_code_generator_utils.py

@@ -58,9 +58,6 @@ def print_symbol_origin(cls, variable_symbol: VariableSymbol, variable: ASTVaria
         if variable_symbol.block_type == BlockType.INTERNALS:
             return "V_.%s"
 
-        if variable_symbol.block_type == BlockType.INPUT:
-            return "B_.%s"
-
         return ""
 
     @classmethod

pynestml/codegeneration/printers/gsl_variable_printer.py

@@ -18,12 +18,13 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with NEST.  If not, see <http://www.gnu.org/licenses/>.
+from pynestml.codegeneration.nest_code_generator_utils import NESTCodeGeneratorUtils
 from pynestml.codegeneration.nest_unit_converter import NESTUnitConverter
 from pynestml.codegeneration.printers.cpp_variable_printer import CppVariablePrinter
+from pynestml.codegeneration.printers.expression_printer import ExpressionPrinter
 from pynestml.meta_model.ast_variable import ASTVariable
 from pynestml.symbols.predefined_units import PredefinedUnits
 from pynestml.symbols.symbol import SymbolKind
-from pynestml.utils.ast_utils import ASTUtils
 from pynestml.utils.logger import Logger, LoggingLevel
 from pynestml.utils.messages import Messages
 
@@ -33,46 +34,42 @@ class GSLVariablePrinter(CppVariablePrinter):
     Variable printer for C++ syntax and using the GSL (GNU Scientific Library) API from inside the ``extern "C"`` stepping function.
     """
 
-    def print_variable(self, node: ASTVariable) -> str:
+    def __init__(self, expression_printer: ExpressionPrinter, with_origin: bool = True, ):
+        super().__init__(expression_printer)
+        self.with_origin = with_origin
+
+    def print_variable(self, variable: ASTVariable) -> str:
         """
         Converts a single name reference to a gsl processable format.
-        :param node: a single variable
+        :param variable: a single variable
         :return: a gsl processable format of the variable
         """
-        assert isinstance(node, ASTVariable)
-        symbol = node.get_scope().resolve_to_symbol(node.get_complete_name(), SymbolKind.VARIABLE)
+        assert isinstance(variable, ASTVariable)
+        symbol = variable.get_scope().resolve_to_symbol(variable.get_complete_name(), SymbolKind.VARIABLE)
 
         if symbol is None:
             # test if variable name can be resolved to a type
-            if PredefinedUnits.is_unit(node.get_complete_name()):
-                return str(NESTUnitConverter.get_factor(PredefinedUnits.get_unit(node.get_complete_name()).get_unit()))
+            if PredefinedUnits.is_unit(variable.get_complete_name()):
+                return str(
+                    NESTUnitConverter.get_factor(PredefinedUnits.get_unit(variable.get_complete_name()).get_unit()))
 
-            code, message = Messages.get_could_not_resolve(node.get_name())
+            code, message = Messages.get_could_not_resolve(variable.get_name())
             Logger.log_message(log_level=LoggingLevel.ERROR, code=code, message=message,
-                               error_position=node.get_source_position())
+                               error_position=variable.get_source_position())
             return ""
 
-        if node.is_delay_variable():
-            return self._print_delay_variable(node)
+        if variable.is_delay_variable():
+            return self._print_delay_variable(variable)
 
         if symbol.is_state() and not symbol.is_inline_expression:
-            if "_is_numeric" in dir(node) and node._is_numeric:
+            if "_is_numeric" in dir(variable) and variable._is_numeric:
                 # ode_state[] here is---and must be---the state vector supplied by the integrator, not the state vector in the node, node.S_.ode_state[].
-                return "ode_state[State_::" + CppVariablePrinter._print_cpp_name(node.get_complete_name()) + "]"
-
-            # non-ODE state symbol
-            return "node.S_." + CppVariablePrinter._print_cpp_name(node.get_complete_name())
-
-        if symbol.is_parameters():
-            return "node.P_." + super().print_variable(node)
-
-        if symbol.is_internals():
-            return "node.V_." + super().print_variable(node)
+                return "ode_state[State_::" + CppVariablePrinter._print_cpp_name(variable.get_complete_name()) + "]"
 
         if symbol.is_input():
-            return "node.B_." + self._print_buffer_value(node)
+            return "node.B_." + self._print_buffer_value(variable)
 
-        raise Exception("Unknown node type")
+        return self._print(variable, symbol, with_origin=self.with_origin)
 
     def _print_delay_variable(self, variable: ASTVariable) -> str:
         """
@@ -105,3 +102,9 @@ def _print_buffer_value(self, variable: ASTVariable) -> str:
 
         assert variable_symbol.is_continuous_input_port()
         return "continuous_inputs_grid_sum_[" + variable.get_name().upper() + "]"
+
+    def _print(self, variable, symbol, with_origin: bool = True):
+        variable_name = CppVariablePrinter._print_cpp_name(variable.get_complete_name())
+        if with_origin:
+            return "node." + NESTCodeGeneratorUtils.print_symbol_origin(symbol, variable) % variable_name
+        return "node." + variable_name