Add a Transformer to support multiple backends with different preferred prefixes a.k.a Non-dimensionalisation-transformer

.gitignore

@@ -7,14 +7,20 @@ target/
 build/
 buildNest/
 venv/
-spinnaker-install/
+tests/spinnaker_tests/bak/spinnaker-install/
 spinnaker-target/
 report/
 reports/
 nestml-*/
 *.egg-info
 stash/
-
+tests/spinnaker2_tests/spinnaker2-install
+tests/spinnaker2_tests/spinnaker2-target
+tests/spinnaker_tests/report
+tests/spinnaker_tests/spinnaker-install
+tests/spinnaker_tests/spinnaker-target
+tests/nest_tests/target_*/
+tests/spinnaker2_tests/nestml_*/
 
 __*
 
@@ -35,3 +41,27 @@ venv
 *.gdf
 *~
 *.iml
+tests/nest_tests/non_dimensionalisation_transformer/resources/non_dimensionalisation_transformer_test_neuron.nestml.bak
+tests/nest_tests/non_dimensionalisation_transformer/tests/reference_test_non_dim_transformer_function_call_in_equation_block.png
+tests/nest_tests/non_dimensionalisation_transformer/tests/transformed_model_test_exp_in_equation_block.txt
+tests/nest_tests/non_dimensionalisation_transformer/tests/transformed_model.txt
+pynestml/codegeneration/resources_spinnaker2/bak/@[email protected]
+pynestml/codegeneration/resources_spinnaker2/bak/@[email protected]
+pynestml/codegeneration/resources_spinnaker2/bak/decay.h.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/global_params.h.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/maths-util.h.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/neuron_model_@NEURON_NAME@_impl.c.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/neuron_model_@NEURON_NAME@_impl.h.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/neuron_model.h.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/neuron-typedefs.h.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/neuron.c.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/neuron.h.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/param_defs.h.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/population_table.h.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/regions.h.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/simulation.h.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/synapse_row.h.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/synapse_types_exponential_impl.h.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/synapse_types.h.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/synapses.c.jinja2
+pynestml/codegeneration/resources_spinnaker2/bak/synapses.h.jinja2

models/neurons/iaf_psc_exp_neuron_NO_ISTIM.nestml

@@ -0,0 +1,130 @@
+# iaf_psc_exp_NO_ISTIM - Leaky integrate-and-fire neuron model
+# ###################################################
+# 
+# Description
+# +++++++++++
+# 
+# iaf_psc_exp is an implementation of a leaky integrate-and-fire model
+# with exponentially decaying synaptic currents according to [1]_.
+# Thus, postsynaptic currents have an infinitely short rise time.
+# The input current I_stim is removed for code generation testing purposes.
+# 
+# The threshold crossing is followed by an absolute refractory period
+# during which the membrane potential is clamped to the resting potential
+# and spiking is prohibited.
+# 
+# The general framework for the consistent formulation of systems with
+# neuron like dynamics interacting by point events is described in
+# [1]_.  A flow chart can be found in [2]_.
+# 
+# Critical tests for the formulation of the neuron model are the
+# comparisons of simulation results for different computation step
+# sizes.
+# 
+# .. note::
+#
+#    If tau_m is very close to tau_syn_exc or tau_syn_inh, numerical problems
+#    may arise due to singularities in the propagator matrics. If this is
+#    the case, replace equal-valued parameters by a single parameter.
+# 
+# For details, please see ``IAF_neurons_singularity.ipynb`` in
+# the NEST source code (``docs/model_details``).
+# 
+# 
+# References
+# ++++++++++
+# 
+# .. [1] Rotter S,  Diesmann M (1999). Exact simulation of
+#        time-invariant linear systems with applications to neuronal
+#        modeling. Biologial Cybernetics 81:381-402.
+#        DOI: https://doi.org/10.1007/s004220050570
+# .. [2] Diesmann M, Gewaltig M-O, Rotter S, & Aertsen A (2001). State
+#        space analysis of synchronous spiking in cortical neural
+#        networks. Neurocomputing 38-40:565-571.
+#        DOI: https://doi.org/10.1016/S0925-2312(01)00409-X
+# .. [3] Morrison A, Straube S, Plesser H E, Diesmann M (2006). Exact
+#        subthreshold integration with continuous spike times in discrete time
+#        neural network simulations. Neural Computation, in press
+#        DOI: https://doi.org/10.1162/neco.2007.19.1.47
+# 
+# 
+# See also
+# ++++++++
+# 
+# iaf_psc_delta, iaf_psc_alpha, iaf_cond_exp
+#
+#
+# Copyright statement
+# +++++++++++++++++++
+#
+# This file is part of NEST.
+# 
+# Copyright (C) 2004 The NEST Initiative
+#
+# NEST is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#
+# NEST is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with NEST.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+model iaf_psc_exp_neuron_NO_ISTIM:
+
+    state:
+        V_m mV = E_L    # Membrane potential
+        refr_t ms = 0 ms    # Refractory period timer
+        I_syn_exc pA = 0 pA
+        I_syn_inh pA = 0 pA
+
+    equations:
+        I_syn_exc' = -I_syn_exc / tau_syn_exc
+        I_syn_inh' = -I_syn_inh / tau_syn_inh
+        V_m' = -(V_m - E_L) / tau_m + (I_syn_exc - I_syn_inh + I_e) / C_m
+        refr_t' = -1e3 * ms/s    # refractoriness is implemented as an ODE, representing a timer counting back down to zero. XXX: TODO: This should simply read ``refr_t' = -1 / s`` (see https://github.com/nest/nestml/issues/984)
+
+    parameters:
+        C_m pF = 250 pF           # Capacitance of the membrane
+        tau_m ms = 10 ms          # Membrane time constant
+        tau_syn_inh ms = 2 ms     # Time constant of inhibitory synaptic current
+        tau_syn_exc ms = 2 ms     # Time constant of excitatory synaptic current
+        refr_T ms = 2 ms          # Duration of refractory period
+        E_L mV = -70 mV           # Resting potential
+        V_reset mV = -70 mV       # Reset value of the membrane potential
+        V_th mV = -55 mV          # Spike threshold potential
+
+        # constant external input current
+        I_e pA = 0 pA
+
+    input:
+        exc_spikes <- excitatory spike
+        inh_spikes <- inhibitory spike
+
+    output:
+        spike
+
+    update:
+        if refr_t > 0 ms:
+            # neuron is absolute refractory, do not evolve V_m
+            integrate_odes(I_syn_exc, I_syn_inh, refr_t)
+        else:
+            # neuron not refractory
+            integrate_odes(I_syn_exc, I_syn_inh, V_m)
+
+    onReceive(exc_spikes):
+        I_syn_exc += exc_spikes * pA * s
+
+    onReceive(inh_spikes):
+        I_syn_inh += inh_spikes * pA * s
+
+    onCondition(refr_t <= 0 ms and V_m >= V_th):
+        # threshold crossing
+        refr_t = refr_T    # start of the refractory period
+        V_m = V_reset
+        emit_spike()

pynestml/cocos/co_co_function_calls_consistent.py

@@ -28,7 +28,6 @@
 from pynestml.utils.ast_utils import ASTUtils
 from pynestml.utils.logger import Logger, LoggingLevel
 from pynestml.utils.messages import Messages
-from pynestml.utils.type_caster import TypeCaster
 from pynestml.visitors.ast_visitor import ASTVisitor
 
 
@@ -109,5 +108,5 @@ def visit_function_call(self, node):
                 # variadic type symbol accepts anything
                 return
 
-            if not actual_type.equals(expected_type) and not isinstance(expected_type, TemplateTypeSymbol):
-                TypeCaster.try_to_recover_or_error(expected_type, actual_type, actual_arg)
+            # if not actual_type.equals(expected_type) and not isinstance(expected_type, TemplateTypeSymbol):
+            #     TypeCaster.try_to_recover_or_error(expected_type, actual_type, actual_arg)

pynestml/cocos/co_co_illegal_expression.py

@@ -28,7 +28,6 @@
 from pynestml.utils.logger import LoggingLevel, Logger
 from pynestml.utils.logging_helper import LoggingHelper
 from pynestml.utils.messages import Messages
-from pynestml.utils.type_caster import TypeCaster
 from pynestml.visitors.ast_visitor import ASTVisitor
 
 
@@ -68,9 +67,8 @@ def visit_declaration(self, node):
             if isinstance(rhs_type, ErrorTypeSymbol):
                 LoggingHelper.drop_missing_type_error(node)
                 return
-            if self.__types_do_not_match(lhs_type, rhs_type):
-                TypeCaster.try_to_recover_or_error(lhs_type, rhs_type, node.get_expression())
-        return
+            # if self.__types_do_not_match(lhs_type, rhs_type):
+            #     TypeCaster.try_to_recover_or_error(lhs_type, rhs_type, node.get_expression())
 
     def visit_inline_expression(self, node):
         """
@@ -82,8 +80,8 @@ def visit_inline_expression(self, node):
         if isinstance(rhs_type, ErrorTypeSymbol):
             LoggingHelper.drop_missing_type_error(node)
             return
-        if self.__types_do_not_match(lhs_type, rhs_type):
-            TypeCaster.try_to_recover_or_error(lhs_type, rhs_type, node.get_expression())
+        # if self.__types_do_not_match(lhs_type, rhs_type):
+        #     TypeCaster.try_to_recover_or_error(lhs_type, rhs_type, node.get_expression())
 
     def visit_assignment(self, node):
         """
@@ -120,23 +118,23 @@ def handle_compound_assignment(self, node):
         lhs_type_symbol = lhs_variable_symbol.get_type_symbol()
 
         if node.is_compound_product:
-            if self.__types_do_not_match(lhs_type_symbol, lhs_type_symbol * rhs_type_symbol):
-                TypeCaster.try_to_recover_or_error(lhs_type_symbol, lhs_type_symbol * rhs_type_symbol,
-                                                   node.get_expression())
-                return
+            # if self.__types_do_not_match(lhs_type_symbol, lhs_type_symbol * rhs_type_symbol):
+            #     TypeCaster.try_to_recover_or_error(lhs_type_symbol, lhs_type_symbol * rhs_type_symbol,
+            #                                        node.get_expression())
+            #     return
             return
 
         if node.is_compound_quotient:
-            if self.__types_do_not_match(lhs_type_symbol, lhs_type_symbol / rhs_type_symbol):
-                TypeCaster.try_to_recover_or_error(lhs_type_symbol, lhs_type_symbol / rhs_type_symbol,
-                                                   node.get_expression())
-                return
+            # if self.__types_do_not_match(lhs_type_symbol, lhs_type_symbol / rhs_type_symbol):
+            #     TypeCaster.try_to_recover_or_error(lhs_type_symbol, lhs_type_symbol / rhs_type_symbol,
+            #                                        node.get_expression())
+            #     return
             return
 
         assert node.is_compound_sum or node.is_compound_minus
-        if self.__types_do_not_match(lhs_type_symbol, rhs_type_symbol):
-            TypeCaster.try_to_recover_or_error(lhs_type_symbol, rhs_type_symbol,
-                                               node.get_expression())
+        # if self.__types_do_not_match(lhs_type_symbol, rhs_type_symbol):
+        #     TypeCaster.try_to_recover_or_error(lhs_type_symbol, rhs_type_symbol,
+        #                                        node.get_expression())
 
     @staticmethod
     def __types_do_not_match(lhs_type_symbol, rhs_type_symbol):
@@ -154,11 +152,10 @@ def handle_simple_assignment(self, node):
             LoggingHelper.drop_missing_type_error(node)
             return
 
-        if lhs_variable_symbol is not None and self.__types_do_not_match(lhs_variable_symbol.get_type_symbol(),
-                                                                         rhs_type_symbol):
-            TypeCaster.try_to_recover_or_error(lhs_variable_symbol.get_type_symbol(), rhs_type_symbol,
-                                               node.get_expression())
-        return
+        # if lhs_variable_symbol is not None and self.__types_do_not_match(lhs_variable_symbol.get_type_symbol(),
+        #                                                                  rhs_type_symbol):
+        #     TypeCaster.try_to_recover_or_error(lhs_variable_symbol.get_type_symbol(), rhs_type_symbol,
+        #                                        node.get_expression())
 
     def visit_if_clause(self, node):
         """

pynestml/cocos/co_co_user_defined_function_correctly_defined.py

@@ -28,7 +28,6 @@
 from pynestml.symbols.symbol import SymbolKind
 from pynestml.utils.logger import LoggingLevel, Logger
 from pynestml.utils.messages import Messages
-from pynestml.utils.type_caster import TypeCaster
 
 
 class CoCoUserDefinedFunctionCorrectlyDefined(CoCo):
@@ -128,9 +127,9 @@ def __check_return_recursively(cls, type_symbol=None, stmts=None, ret_defined=Fa
                         code, message = Messages.get_type_could_not_be_derived(cls.processed_function.get_name())
                         Logger.log_message(error_position=stmt.get_source_position(),
                                            code=code, message=message, log_level=LoggingLevel.ERROR)
-                    elif not type_of_return.equals(type_symbol):
-                        TypeCaster.try_to_recover_or_error(type_symbol, type_of_return,
-                                                           stmt.get_return_stmt().get_expression())
+                    # elif not type_of_return.equals(type_symbol):
+                    #     TypeCaster.try_to_recover_or_error(type_symbol, type_of_return,
+                    #                                        stmt.get_return_stmt().get_expression())
             elif isinstance(stmt, ASTCompoundStmt):
                 # otherwise it is a compound stmt, thus check recursively
                 if stmt.is_if_stmt():

pynestml/codegeneration/nest_code_generator.py

@@ -18,7 +18,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with NEST.  If not, see <http://www.gnu.org/licenses/>.
-
 from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple
 
 import datetime
@@ -312,11 +311,14 @@ def analyse_transform_neurons(self, neurons: List[ASTModel]) -> None:
         for neuron in neurons:
             code, message = Messages.get_analysing_transforming_model(neuron.get_name())
             Logger.log_message(None, code, message, None, LoggingLevel.INFO)
-            spike_updates, post_spike_updates, equations_with_delay_vars, equations_with_vector_vars = self.analyse_neuron(neuron)
+            spike_updates, post_spike_updates, equations_with_delay_vars, equations_with_vector_vars = self.analyse_neuron(neuron)  # , parameter_value_dict, updated_state_dict = self.analyse_neuron(neuron)
             neuron.spike_updates = spike_updates
             neuron.post_spike_updates = post_spike_updates
             neuron.equations_with_delay_vars = equations_with_delay_vars
             neuron.equations_with_vector_vars = equations_with_vector_vars
+            # neuron.analytic_solver = analytic_solver
+            # neuron.parameter_value_dict = parameter_value_dict
+            # neuron.updated_state_dict = updated_state_dict
 
     def analyse_transform_synapses(self, synapses: List[ASTModel]) -> None:
         """
@@ -362,6 +364,15 @@ def analyse_neuron(self, neuron: ASTModel) -> Tuple[Dict[str, ASTAssignment], Di
         neuron.accept(equations_with_delay_vars_visitor)
         equations_with_delay_vars = equations_with_delay_vars_visitor.equations
 
+        # Collect all parameters and their attached values
+        # parameter_block = neuron.get_parameters_blocks()[0]
+        # parameter_value_dict = ASTUtils.generate_parameter_value_dict(neuron, parameter_block)
+        # state_block = neuron.get_state_blocks()[0]
+        # updated_state_dict = ASTUtils.generate_updated_state_dict(neuron, state_block, parameter_value_dict)
+
+
+
+
         # Collect all the equations with vector variables
         eqns_with_vector_vars_visitor = ASTEquationsWithVectorVariablesVisitor()
         neuron.accept(eqns_with_vector_vars_visitor)
@@ -413,7 +424,7 @@ def analyse_neuron(self, neuron: ASTModel) -> Tuple[Dict[str, ASTAssignment], Di
 
         spike_updates, post_spike_updates = self.get_spike_update_expressions(neuron, kernel_buffers, [analytic_solver, numeric_solver], delta_factors)
 
-        return spike_updates, post_spike_updates, equations_with_delay_vars, equations_with_vector_vars
+        return spike_updates, post_spike_updates, equations_with_delay_vars, equations_with_vector_vars# , analytic_solver  , parameter_value_dict, updated_state_dict
 
     def analyse_synapse(self, synapse: ASTModel) -> Dict[str, ASTAssignment]:
         """
@@ -915,6 +926,12 @@ def ode_toolbox_analysis(self, neuron: ASTModel, kernel_buffers: Mapping[ASTKern
         odetoolbox_indict["options"]["output_timestep_symbol"] = "__h"
         odetoolbox_indict["options"]["simplify_expression"] = self.get_option("simplify_expression")
         disable_analytic_solver = self.get_option("solver") != "analytic"
+        # solver_result = odetoolbox.analysis(odetoolbox_indict,
+        #                                     disable_stiffness_check=True,
+        #                                     disable_analytic_solver=disable_analytic_solver,
+        #                                     preserve_expressions=self.get_option("preserve_expressions"),
+        #                                     simplify_expression=self.get_option("simplify_expression"),
+        #                                     log_level=FrontendConfiguration.logging_level)
         solver_result = odetoolbox.analysis(odetoolbox_indict,
                                             disable_stiffness_check=True,
                                             disable_analytic_solver=disable_analytic_solver,