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

doc/running/index.rst

@@ -4,8 +4,18 @@ Running NESTML
 Running NESTML causes several processing steps to occur:
 
 1. The model is parsed from file and checked (syntax, consistent physical units, and so on).
-2. Code is generated from the model by one of the "code generators" selected when NESTML was invoked.
-3. If necessary, the code is compiled and built by the "builder" that belongs to the selected code generator.
+2. A series of transformation steps are optionally carried out on the model. Which set of transformers is used is automatically determined based on the target platform selected when NESTML was invoked. (See the section "Available transformers" below.)
+3. Code is generated from the model by one of the "code generators" selected when NESTML was invoked. If necessary, the code is compiled and built by the "builder" that belongs to the selected code generator. (See the section "Supported target platforms" below.)
+
+
+Available transformers
+----------------------
+
+- **Non-dimensionalisation transformer**
+
+  :class:`pynestml.transformers.non_dimensionalisation_transformer.NonDimensionalisationTransformer`
+
+  Eliminates physical units from models, converting numerical values to real numbers.
 
 
 Supported target platforms

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_output_port_defined_if_emit_call.py

@@ -104,6 +104,7 @@ def visit_function_call(self, node: ASTFunctionCall):
                     # types are not equal, but castable
                     code, message = Messages.get_implicit_cast_rhs_to_lhs(output_block_attr_type_sym.print_symbol(),
                                                                           emit_spike_arg_type_sym.print_symbol())
+                    # XXX: this should be removed
                     Logger.log_message(error_position=output_blocks[0].get_source_position(),
                                        code=code, message=message, log_level=LoggingLevel.WARNING)
                     continue

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

pynestml/codegeneration/printers/c_simple_expression_printer.py

@@ -71,7 +71,4 @@ def _print(self, node: ASTNode) -> str:
         return self.print_simple_expression(node)
 
     def print(self, node: ASTNode) -> str:
-        if node.get_implicit_conversion_factor() and not node.get_implicit_conversion_factor() == 1:
-            return "(" + str(node.get_implicit_conversion_factor()) + " * (" + self._print(node) + "))"
-
         return self._print(node)

pynestml/codegeneration/printers/cpp_expression_printer.py

@@ -39,9 +39,6 @@ class CppExpressionPrinter(ExpressionPrinter):
 
     def print(self, node: ASTNode) -> str:
         if isinstance(node, ASTExpression):
-            if node.get_implicit_conversion_factor() and not node.get_implicit_conversion_factor() == 1:
-                return "(" + str(node.get_implicit_conversion_factor()) + " * (" + self.print_expression(node) + "))"
-
             return self.print_expression(node)
 
         return self._simple_expression_printer.print(node)

pynestml/codegeneration/printers/gsl_variable_printer.py

@@ -18,7 +18,7 @@
 #
 # 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_unit_converter import NESTUnitConverter
+
 from pynestml.codegeneration.printers.cpp_variable_printer import CppVariablePrinter
 from pynestml.meta_model.ast_variable import ASTVariable
 from pynestml.symbols.predefined_units import PredefinedUnits
@@ -45,7 +45,7 @@ def print_variable(self, node: ASTVariable) -> str:
         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()))
+                return str(PredefinedUnits.get_unit(node.get_complete_name()).get_unit())
 
             code, message = Messages.get_could_not_resolve(node.get_name())
             Logger.log_message(log_level=LoggingLevel.ERROR, code=code, message=message,

pynestml/codegeneration/printers/latex_expression_printer.py

@@ -35,10 +35,6 @@ class LatexExpressionPrinter(ExpressionPrinter):
     """
 
     def print(self, node: ASTExpressionNode) -> str:
-        if node.get_implicit_conversion_factor() is not None \
-           and str(node.get_implicit_conversion_factor()) not in ["1.", "1.0", "1"]:
-            return str(node.get_implicit_conversion_factor()) + " * (" + self.print_expression(node) + ")"
-
         return self.print_expression(node)
 
     def print_expression(self, node: ASTExpressionNode) -> str:

pynestml/codegeneration/printers/nest_variable_printer.py

@@ -26,7 +26,6 @@
 from pynestml.codegeneration.nest_code_generator_utils import NESTCodeGeneratorUtils
 from pynestml.codegeneration.printers.cpp_variable_printer import CppVariablePrinter
 from pynestml.codegeneration.printers.expression_printer import ExpressionPrinter
-from pynestml.codegeneration.nest_unit_converter import NESTUnitConverter
 from pynestml.meta_model.ast_external_variable import ASTExternalVariable
 from pynestml.meta_model.ast_variable import ASTVariable
 from pynestml.symbols.predefined_units import PredefinedUnits
@@ -99,7 +98,7 @@ def print_variable(self, variable: ASTVariable) -> str:
         if symbol is None:
             # test if variable name can be resolved to a type
             if PredefinedUnits.is_unit(variable.get_complete_name()):
-                return str(NESTUnitConverter.get_factor(PredefinedUnits.get_unit(variable.get_complete_name()).get_unit()))
+                return str(PredefinedUnits.get_unit(variable.get_complete_name()).get_unit())
 
             code, message = Messages.get_could_not_resolve(variable.get_name())
             Logger.log_message(log_level=LoggingLevel.ERROR, code=code, message=message,
@@ -111,18 +110,11 @@ def print_variable(self, variable: ASTVariable) -> str:
             vector_param = "[" + self._expression_printer.print(variable.get_vector_parameter()) + "]"
 
         if symbol.is_buffer():
-            if isinstance(symbol.get_type_symbol(), UnitTypeSymbol):
-                units_conversion_factor = NESTUnitConverter.get_factor(symbol.get_type_symbol().unit.unit)
-            else:
-                units_conversion_factor = 1
             s = ""
-            if not units_conversion_factor == 1:
-                s += "(" + str(units_conversion_factor) + " * "
             if self.cpp_variable_suffix == "":
                 s += "B_."
             s += self._print_buffer_value(variable)
-            if not units_conversion_factor == 1:
-                s += ")"
+
             return s
 
         if symbol.is_inline_expression:

pynestml/codegeneration/printers/nestml_expression_printer.py

@@ -36,9 +36,6 @@ class NESTMLExpressionPrinter(ExpressionPrinter):
 
     def print(self, node: ASTNode) -> str:
         if isinstance(node, ASTExpression):
-            if node.get_implicit_conversion_factor() and not node.get_implicit_conversion_factor() == 1:
-                return "(" + str(node.get_implicit_conversion_factor()) + " * (" + self.print_expression(node) + "))"
-
             return self.print_expression(node)
 
         if isinstance(node, ASTArithmeticOperator):

pynestml/codegeneration/printers/nestml_simple_expression_printer.py

@@ -41,9 +41,6 @@ def _print(self, node: ASTNode) -> str:
         return self.print_simple_expression(node)
 
     def print(self, node: ASTNode) -> str:
-        if node.get_implicit_conversion_factor() and not node.get_implicit_conversion_factor() == 1:
-            return "(" + str(node.get_implicit_conversion_factor()) + " * (" + self._print(node) + "))"
-
         return self._print(node)
 
     def print_simple_expression(self, node: ASTSimpleExpression) -> str:

pynestml/codegeneration/printers/python_expression_printer.py

@@ -36,9 +36,6 @@ class PythonExpressionPrinter(ExpressionPrinter):
 
     def print(self, node: ASTNode) -> str:
         if isinstance(node, ASTExpression):
-            if node.get_implicit_conversion_factor() and not node.get_implicit_conversion_factor() == 1:
-                return "(" + str(node.get_implicit_conversion_factor()) + " * (" + self.print_expression(node) + "))"
-
             return self.print_expression(node)
 
         return self._simple_expression_printer.print(node)

pynestml/codegeneration/printers/python_simple_expression_printer.py

@@ -75,7 +75,4 @@ def _print(self, node: ASTNode) -> str:
         return self.print_simple_expression(node)
 
     def print(self, node: ASTNode) -> str:
-        if node.get_implicit_conversion_factor() and not node.get_implicit_conversion_factor() == 1:
-            return "(" + str(node.get_implicit_conversion_factor()) + " * (" + self._print(node) + "))"
-
         return self._print(node)

pynestml/codegeneration/printers/python_variable_printer.py

@@ -21,7 +21,6 @@
 
 from __future__ import annotations
 
-from pynestml.codegeneration.nest_unit_converter import NESTUnitConverter
 from pynestml.codegeneration.printers.expression_printer import ExpressionPrinter
 from pynestml.codegeneration.printers.variable_printer import VariablePrinter
 from pynestml.codegeneration.python_code_generator_utils import PythonCodeGeneratorUtils
@@ -93,7 +92,7 @@ def print_variable(self, variable: ASTVariable) -> str:
         if symbol is None:
             # test if variable name can be resolved to a type
             if PredefinedUnits.is_unit(variable.get_complete_name()):
-                return str(NESTUnitConverter.get_factor(PredefinedUnits.get_unit(variable.get_complete_name()).get_unit()))
+                return str(PredefinedUnits.get_unit(variable.get_complete_name()).get_unit())
 
             code, message = Messages.get_could_not_resolve(variable.get_name())
             Logger.log_message(log_level=LoggingLevel.ERROR, code=code, message=message,
@@ -105,17 +104,9 @@ def print_variable(self, variable: ASTVariable) -> str:
             vector_param = "[" + self._expression_printer.print(variable.get_vector_parameter()) + "]"
 
         if symbol.is_buffer():
-            if isinstance(symbol.get_type_symbol(), UnitTypeSymbol):
-                units_conversion_factor = NESTUnitConverter.get_factor(symbol.get_type_symbol().unit.unit)
-            else:
-                units_conversion_factor = 1
             s = ""
-            if not units_conversion_factor == 1:
-                s += "(" + str(units_conversion_factor) + " * "
             s += self._print(variable, symbol, with_origin=self.with_origin) + vector_param
             s += vector_param
-            if not units_conversion_factor == 1:
-                s += ")"
             return s
 
         if symbol.is_inline_expression: