def convert_name_reference(self, variable):
"""
Converts a single variable to nest processable format.
:param variable: a single variable.
:type variable: ASTVariable
:return: a nest processable format.
:rtype: str
"""
from pynestml.codegeneration.nest_printer import NestPrinter
assert (variable is not None and isinstance(variable, ASTVariable)), \
'(PyNestML.CodeGeneration.NestReferenceConverter) No or wrong type of uses-gsl provided (%s)!' % type(
variable)
variable_name = NestNamesConverter.convert_to_cpp_name(
variable.get_complete_name())
if variable_name == PredefinedVariables.E_CONSTANT:
return 'numerics::e'
else:
symbol = variable.get_scope().resolve_to_symbol(
variable_name, SymbolKind.VARIABLE)
if symbol is None:
# test if variable name can be resolved to a type
if PredefinedUnits.is_unit(variable.get_complete_name()):
return str(
UnitConverter.get_factor(
PredefinedUnits.get_unit(
variable.get_complete_name()).get_unit()))
code, message = Messages.get_could_not_resolve(variable_name)
Logger.log_message(
log_level=LoggingLevel.ERROR,
code=code,
message=message,
error_position=variable.get_source_position())
return ''
else:
if symbol.is_local():
return variable_name + (
'[i]' if symbol.has_vector_parameter() else '')
elif symbol.is_buffer():
return NestPrinter.print_origin(symbol) + NestNamesConverter.buffer_value(symbol) \
+ ('[i]' if symbol.has_vector_parameter() else '')
else:
if symbol.is_function:
return 'get_' + variable_name + '()' + (
'[i]' if symbol.has_vector_parameter() else '')
else:
if symbol.is_init_values():
temp = NestPrinter.print_origin(symbol)
if self.uses_gsl:
temp += GSLNamesConverter.name(symbol)
else:
temp += NestNamesConverter.name(symbol)
temp += ('[i]'
if symbol.has_vector_parameter() else '')
return temp
else:
return NestPrinter.print_origin(symbol) + \
NestNamesConverter.name(symbol) + \
('[i]' if symbol.has_vector_parameter() else '')
def convert_name_reference(self, ast_variable):
"""
Converts a single name reference to a gsl processable format.
:param ast_variable: a single variable
:type ast_variable: ASTVariable
:return: a gsl processable format of the variable
:rtype: str
"""
variable_name = NestNamesConverter.convert_to_cpp_name(
ast_variable.get_name())
symbol = ast_variable.get_scope().resolve_to_symbol(
ast_variable.get_complete_name(), SymbolKind.VARIABLE)
if PredefinedUnits.is_unit(ast_variable.get_complete_name()):
return str(
UnitConverter.get_factor(
PredefinedUnits.get_unit(
ast_variable.get_complete_name()).get_unit()))
if symbol.is_init_values():
return GSLNamesConverter.name(symbol)
elif symbol.is_buffer():
return 'node.B_.' + NestNamesConverter.buffer_value(symbol)
elif variable_name == PredefinedVariables.E_CONSTANT:
return 'numerics::e'
elif symbol.is_local() or symbol.is_function:
return variable_name
elif symbol.has_vector_parameter():
return 'node.get_' + variable_name + '()[i]'
else:
return 'node.get_' + variable_name + '()'
def convert_name_reference(self,
ast_variable: ASTVariable,
prefix: str = ''):
"""
Converts a single name reference to a gsl processable format.
:param ast_variable: a single variable
:type ast_variable: ASTVariable
:return: a gsl processable format of the variable
:rtype: str
"""
variable_name = NestNamesConverter.convert_to_cpp_name(
ast_variable.get_name())
if variable_name == PredefinedVariables.E_CONSTANT:
return 'numerics::e'
symbol = ast_variable.get_scope().resolve_to_symbol(
ast_variable.get_complete_name(), SymbolKind.VARIABLE)
if symbol is None:
# test if variable name can be resolved to a type
if PredefinedUnits.is_unit(ast_variable.get_complete_name()):
return str(
UnitConverter.get_factor(
PredefinedUnits.get_unit(
ast_variable.get_complete_name()).get_unit()))
code, message = Messages.get_could_not_resolve(variable_name)
Logger.log_message(
log_level=LoggingLevel.ERROR,
code=code,
message=message,
error_position=ast_variable.get_source_position())
return ''
if symbol.is_init_values():
return GSLNamesConverter.name(symbol)
if symbol.is_buffer():
if isinstance(symbol.get_type_symbol(), UnitTypeSymbol):
units_conversion_factor = UnitConverter.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 += prefix + 'B_.' + NestNamesConverter.buffer_value(symbol)
if symbol.has_vector_parameter():
s += '[i]'
if not units_conversion_factor == 1:
s += ")"
return s
if symbol.is_local() or symbol.is_function:
return variable_name
if symbol.has_vector_parameter():
return prefix + 'get_' + variable_name + '()[i]'
return prefix + 'get_' + variable_name + '()'
def convert_name_reference(self, ast_variable):
"""
Converts a single name reference to a gsl processable format.
:param ast_variable: a single variable
:type ast_variable: ASTVariable
:return: a gsl processable format of the variable
:rtype: str
"""
variable_name = NestNamesConverter.convert_to_cpp_name(ast_variable.get_name())
symbol = ast_variable.get_scope().resolve_to_symbol(ast_variable.get_complete_name(), SymbolKind.VARIABLE)
if PredefinedUnits.is_unit(ast_variable.get_complete_name()):
return str(
UnitConverter.get_factor(PredefinedUnits.get_unit(ast_variable.get_complete_name()).get_unit()))
if symbol.is_init_values():
return GSLNamesConverter.name(symbol)
elif symbol.is_buffer():
return 'node.B_.' + NestNamesConverter.buffer_value(symbol)
elif variable_name == PredefinedVariables.E_CONSTANT:
return 'numerics::e'
elif symbol.is_local() or symbol.is_function:
return variable_name
elif symbol.has_vector_parameter():
return 'node.get_' + variable_name + '()[i]'
else:
return 'node.get_' + variable_name + '()'
def name(cls, symbol):
"""
Transforms the haded over symbol to a GSL processable format.
:param symbol: a single variable symbol
:type symbol: VariableSymbol
:return: the corresponding string format
:rtype: str
"""
if symbol.is_init_values() and not symbol.is_function:
return 'ode_state[State_::' + NestNamesConverter.convert_to_cpp_name(symbol.get_symbol_name()) + ']'
else:
return NestNamesConverter.name(symbol)
def name(cls, symbol):
"""
Transforms the given symbol to a format that can be processed by GSL.
:param symbol: a single variable symbol
:type symbol: VariableSymbol
:return: the corresponding string format
:rtype: str
"""
if symbol.is_state() and not symbol.is_inline_expression:
return 'ode_state[State_::' + NestNamesConverter.convert_to_cpp_name(
symbol.get_symbol_name()) + ']'
else:
return NestNamesConverter.name(symbol)
def print_buffer_declaration_value(cls, ast_buffer):
"""
Returns a string representation for the declaration of a buffer's value.
:param ast_buffer: a single buffer variable symbol
:type ast_buffer: VariableSymbol
:return: the corresponding string representation
:rtype: str
"""
assert isinstance(ast_buffer, VariableSymbol), \
'(PyNestML.CodeGeneration.Printer) No or wrong type of ast_buffer symbol provided (%s)!' % type(ast_buffer)
if ast_buffer.has_vector_parameter():
return 'std::vector<double> ' + NestNamesConverter.buffer_value(ast_buffer)
else:
return 'double ' + NestNamesConverter.buffer_value(ast_buffer)
def convert_name_reference(self, variable):
"""
Converts a single variable to nest processable format.
:param variable: a single variable.
:type variable: ASTVariable
:return: a nest processable format.
:rtype: str
"""
from pynestml.codegeneration.nest_printer import NestPrinter
assert (variable is not None and isinstance(variable, ASTVariable)), \
'(PyNestML.CodeGeneration.NestReferenceConverter) No or wrong type of uses-gsl provided (%s)!' % type(
variable)
variable_name = NestNamesConverter.convert_to_cpp_name(variable.get_complete_name())
if PredefinedUnits.is_unit(variable.get_complete_name()):
return str(
UnitConverter.get_factor(PredefinedUnits.get_unit(variable.get_complete_name()).get_unit()))
if variable_name == PredefinedVariables.E_CONSTANT:
return 'numerics::e'
else:
symbol = variable.get_scope().resolve_to_symbol(variable_name, SymbolKind.VARIABLE)
if symbol is None:
# this should actually not happen, but an error message is better than an exception
code, message = Messages.get_could_not_resolve(variable_name)
Logger.log_message(log_level=LoggingLevel.ERROR, code=code, message=message,
error_position=variable.get_source_position())
return ''
else:
if symbol.is_local():
return variable_name + ('[i]' if symbol.has_vector_parameter() else '')
elif symbol.is_buffer():
return NestPrinter.print_origin(symbol) + NestNamesConverter.buffer_value(symbol) \
+ ('[i]' if symbol.has_vector_parameter() else '')
else:
if symbol.is_function:
return 'get_' + variable_name + '()' + ('[i]' if symbol.has_vector_parameter() else '')
else:
if symbol.is_init_values():
temp = NestPrinter.print_origin(symbol)
if self.uses_gsl:
temp += GSLNamesConverter.name(symbol)
else:
temp += NestNamesConverter.name(symbol)
temp += ('[i]' if symbol.has_vector_parameter() else '')
return temp
else:
return NestPrinter.print_origin(symbol) + \
NestNamesConverter.name(symbol) + \
('[i]' if symbol.has_vector_parameter() else '')
def print_buffer_declaration_value(cls, ast_buffer):
"""
Returns a string representation for the declaration of a buffer's value.
:param ast_buffer: a single buffer variable symbol
:type ast_buffer: VariableSymbol
:return: the corresponding string representation
:rtype: str
"""
assert isinstance(ast_buffer, VariableSymbol), \
'(PyNestML.CodeGeneration.Printer) No or wrong type of ast_buffer symbol provided (%s)!' % type(ast_buffer)
if ast_buffer.has_vector_parameter():
return 'std::vector<double> ' + NestNamesConverter.buffer_value(
ast_buffer)
else:
return 'double ' + NestNamesConverter.buffer_value(ast_buffer)
def setup_generation_helpers(neuron):
"""
Returns a standard namespace with often required functionality.
:param neuron: a single neuron instance
:type neuron: ASTNeuron
:return: a map from name to functionality.
:rtype: dict
"""
gsl_converter = GSLReferenceConverter()
gsl_printer = LegacyExpressionPrinter(gsl_converter)
# helper classes and objects
converter = NESTReferenceConverter(False)
legacy_pretty_printer = LegacyExpressionPrinter(converter)
namespace = dict()
namespace['neuronName'] = neuron.get_name()
namespace['neuron'] = neuron
namespace['moduleName'] = FrontendConfiguration.get_module_name()
namespace['printer'] = NestPrinter(legacy_pretty_printer)
namespace['assignments'] = NestAssignmentsHelper()
namespace['names'] = NestNamesConverter()
namespace['declarations'] = NestDeclarationsHelper()
namespace['utils'] = ASTUtils()
namespace['idemPrinter'] = LegacyExpressionPrinter()
namespace['outputEvent'] = namespace['printer'].print_output_event(neuron.get_body())
namespace['is_spike_input'] = ASTUtils.is_spike_input(neuron.get_body())
namespace['is_current_input'] = ASTUtils.is_current_input(neuron.get_body())
namespace['odeTransformer'] = OdeTransformer()
namespace['printerGSL'] = gsl_printer
namespace['now'] = datetime.datetime.utcnow()
define_solver_type(neuron, namespace)
return namespace
def setup_model_generation_helpers(self, neuron: ASTNeuron):
"""
Returns a namespace for Jinja2 neuron model documentation template.
:param neuron: a single neuron instance
:type neuron: ASTNeuron
:return: a map from name to functionality.
:rtype: dict
"""
converter = LatexReferenceConverter()
latex_expression_printer = LatexExpressionPrinter(converter)
namespace = dict()
namespace['now'] = datetime.datetime.utcnow()
namespace['neuron'] = neuron
namespace['neuronName'] = str(neuron.get_name())
namespace['printer'] = NestPrinter(latex_expression_printer)
namespace['assignments'] = NestAssignmentsHelper()
namespace['names'] = NestNamesConverter()
namespace['declarations'] = NestDeclarationsHelper()
namespace['utils'] = ASTUtils()
namespace['odeTransformer'] = OdeTransformer()
import textwrap
pre_comments_bak = neuron.pre_comments
neuron.pre_comments = []
namespace['neuron_source_code'] = textwrap.indent(
neuron.__str__(), " ")
neuron.pre_comments = pre_comments_bak
return namespace
def setup_index_generation_helpers(self, neurons: List[ASTNeuron]):
"""
Returns a namespace for Jinja2 neuron model index page template.
:param neurons: a list of neuron instances
:type neurons: List[ASTNeuron]
:return: a map from name to functionality.
:rtype: dict
"""
converter = LatexReferenceConverter()
latex_expression_printer = LatexExpressionPrinter(converter)
namespace = dict()
namespace['now'] = datetime.datetime.utcnow()
namespace['neurons'] = neurons
namespace['neuronNames'] = [
str(neuron.get_name()) for neuron in neurons
]
namespace['printer'] = NestPrinter(latex_expression_printer)
namespace['assignments'] = NestAssignmentsHelper()
namespace['names'] = NestNamesConverter()
namespace['declarations'] = NestDeclarationsHelper()
namespace['utils'] = ASTUtils()
namespace['odeTransformer'] = OdeTransformer()
return namespace
def array_index(cls, symbol):
"""
Transforms the haded over symbol to a GSL processable format.
:param symbol: a single variable symbol
:type symbol: VariableSymbol
:return: the corresponding string format
:rtype: str
"""
return 'State_::' + NestNamesConverter.convert_to_cpp_name(symbol.get_symbol_name())
def buffer_value(cls, variable_symbol):
"""
Converts for a handed over symbol the corresponding name of the buffer to a gsl processable format.
:param variable_symbol: a single variable symbol.
:type variable_symbol: VariableSymbol
:return: the corresponding representation as a string
:rtype: str
"""
return NestNamesConverter.buffer_value(variable_symbol)
def convert_to_cpp_name(cls, variable_name):
"""
Converts a handed over name to the corresponding gsl / c++ naming guideline.
In concrete terms:
Converts names of the form g_in'' to a compilable C++ identifier: __DDX_g_in
:param variable_name: a single name.
:type variable_name: str
:return: the corresponding transformed name.
:rtype: str
"""
return NestNamesConverter.convert_to_cpp_name(variable_name)
def __get_unit_name(self, variable):
assert (variable is not None and isinstance(variable, ASTVariable)), \
'(PyNestML.CodeGeneration.NestReferenceConverter) No or wrong type of uses-gsl provided (%s)!' % type(
variable)
assert variable.get_scope() is not None, "Undeclared variable: " + variable.get_complete_name()
variable_name = NestNamesConverter.convert_to_cpp_name(variable.get_complete_name())
symbol = variable.get_scope().resolve_to_symbol(variable_name, SymbolKind.VARIABLE)
if isinstance(symbol.get_type_symbol(), UnitTypeSymbol):
return symbol.get_type_symbol().unit.unit.to_string()
return ''
def setup_generation_helpers(self, neuron):
"""
Returns a standard namespace with often required functionality.
:param neuron: a single neuron instance
:type neuron: ASTNeuron
:return: a map from name to functionality.
:rtype: dict
"""
gsl_converter = GSLReferenceConverter()
gsl_printer = LegacyExpressionPrinter(gsl_converter)
# helper classes and objects
converter = NESTReferenceConverter(False)
legacy_pretty_printer = LegacyExpressionPrinter(converter)
namespace = dict()
namespace['neuronName'] = neuron.get_name()
namespace['neuron'] = neuron
namespace['moduleName'] = FrontendConfiguration.get_module_name()
namespace['printer'] = NestPrinter(legacy_pretty_printer)
namespace['assignments'] = NestAssignmentsHelper()
namespace['names'] = NestNamesConverter()
namespace['declarations'] = NestDeclarationsHelper()
namespace['utils'] = ASTUtils()
namespace['idemPrinter'] = LegacyExpressionPrinter()
namespace['outputEvent'] = namespace['printer'].print_output_event(neuron.get_body())
namespace['is_spike_input'] = ASTUtils.is_spike_input(neuron.get_body())
namespace['is_current_input'] = ASTUtils.is_current_input(neuron.get_body())
namespace['odeTransformer'] = OdeTransformer()
namespace['printerGSL'] = gsl_printer
namespace['now'] = datetime.datetime.utcnow()
namespace['tracing'] = FrontendConfiguration.is_dev
namespace['PredefinedUnits'] = pynestml.symbols.predefined_units.PredefinedUnits
namespace['UnitTypeSymbol'] = pynestml.symbols.unit_type_symbol.UnitTypeSymbol
rng_visitor = ASTRandomNumberGeneratorVisitor()
neuron.accept(rng_visitor)
namespace['norm_rng'] = rng_visitor._norm_rng_is_used
self.define_solver_type(neuron, namespace)
return namespace
def setup_generation_helpers(self, neuron: ASTNeuron) -> Dict:
"""
Returns a standard namespace with often required functionality.
:param neuron: a single neuron instance
:type neuron: ASTNeuron
:return: a map from name to functionality.
:rtype: dict
"""
gsl_converter = GSLReferenceConverter()
gsl_printer = UnitlessExpressionPrinter(gsl_converter)
# helper classes and objects
converter = NESTReferenceConverter(False)
unitless_pretty_printer = UnitlessExpressionPrinter(converter)
namespace = dict()
namespace['neuronName'] = neuron.get_name()
namespace['neuron'] = neuron
namespace['moduleName'] = FrontendConfiguration.get_module_name()
namespace['printer'] = NestPrinter(unitless_pretty_printer)
namespace['assignments'] = NestAssignmentsHelper()
namespace['names'] = NestNamesConverter()
namespace['declarations'] = NestDeclarationsHelper()
namespace['utils'] = ASTUtils()
namespace['idemPrinter'] = UnitlessExpressionPrinter()
namespace['outputEvent'] = namespace['printer'].print_output_event(
neuron.get_body())
namespace['is_spike_input'] = ASTUtils.is_spike_input(
neuron.get_body())
namespace['is_current_input'] = ASTUtils.is_current_input(
neuron.get_body())
namespace['odeTransformer'] = OdeTransformer()
namespace['printerGSL'] = gsl_printer
namespace['now'] = datetime.datetime.utcnow()
namespace['tracing'] = FrontendConfiguration.is_dev
namespace[
'PredefinedUnits'] = pynestml.symbols.predefined_units.PredefinedUnits
namespace[
'UnitTypeSymbol'] = pynestml.symbols.unit_type_symbol.UnitTypeSymbol
namespace['initial_values'] = {}
namespace['uses_analytic_solver'] = neuron.get_name() in self.analytic_solver.keys() \
and self.analytic_solver[neuron.get_name()] is not None
if namespace['uses_analytic_solver']:
namespace['analytic_state_variables'] = self.analytic_solver[
neuron.get_name()]["state_variables"]
namespace['analytic_variable_symbols'] = {
sym:
neuron.get_equations_block().get_scope().resolve_to_symbol(
sym, SymbolKind.VARIABLE)
for sym in namespace['analytic_state_variables']
}
namespace['update_expressions'] = {}
for sym, expr in self.analytic_solver[
neuron.get_name()]["initial_values"].items():
namespace['initial_values'][sym] = expr
for sym in namespace['analytic_state_variables']:
expr_str = self.analytic_solver[
neuron.get_name()]["update_expressions"][sym]
expr_ast = ModelParser.parse_expression(expr_str)
# pretend that update expressions are in "equations" block, which should always be present, as differential equations must have been defined to get here
expr_ast.update_scope(
neuron.get_equations_blocks().get_scope())
expr_ast.accept(ASTSymbolTableVisitor())
namespace['update_expressions'][sym] = expr_ast
namespace['propagators'] = self.analytic_solver[
neuron.get_name()]["propagators"]
namespace['uses_numeric_solver'] = neuron.get_name() in self.analytic_solver.keys() \
and self.numeric_solver[neuron.get_name()] is not None
if namespace['uses_numeric_solver']:
namespace['numeric_state_variables'] = self.numeric_solver[
neuron.get_name()]["state_variables"]
namespace['numeric_variable_symbols'] = {
sym:
neuron.get_equations_block().get_scope().resolve_to_symbol(
sym, SymbolKind.VARIABLE)
for sym in namespace['numeric_state_variables']
}
assert not any([
sym is None
for sym in namespace['numeric_variable_symbols'].values()
])
namespace['numeric_update_expressions'] = {}
for sym, expr in self.numeric_solver[
neuron.get_name()]["initial_values"].items():
namespace['initial_values'][sym] = expr
for sym in namespace['numeric_state_variables']:
expr_str = self.numeric_solver[
neuron.get_name()]["update_expressions"][sym]
expr_ast = ModelParser.parse_expression(expr_str)
# pretend that update expressions are in "equations" block, which should always be present, as differential equations must have been defined to get here
expr_ast.update_scope(
neuron.get_equations_blocks().get_scope())
expr_ast.accept(ASTSymbolTableVisitor())
namespace['numeric_update_expressions'][sym] = expr_ast
namespace['useGSL'] = namespace['uses_numeric_solver']
namespace['names'] = GSLNamesConverter()
converter = NESTReferenceConverter(True)
unitless_pretty_printer = UnitlessExpressionPrinter(converter)
namespace['printer'] = NestPrinter(unitless_pretty_printer)
namespace["spike_updates"] = neuron.spike_updates
rng_visitor = ASTRandomNumberGeneratorVisitor()
neuron.accept(rng_visitor)
namespace['norm_rng'] = rng_visitor._norm_rng_is_used
return namespace
def convert_name_reference(self, variable: ASTVariable, prefix='') -> str:
"""
Converts a single variable to nest processable format.
:param variable: a single variable.
:type variable: ASTVariable
:return: a nest processable format.
"""
from pynestml.codegeneration.nest_printer import NestPrinter
if isinstance(variable, ASTExternalVariable):
_name = str(variable)
if variable.get_alternate_name():
# the disadvantage of this approach is that the time the value is to be obtained is not explicitly specified, so we will actually get the value at the end of the min_delay timestep
return "((POST_NEURON_TYPE*)(__target))->get_" + variable.get_alternate_name(
) + "()"
return "((POST_NEURON_TYPE*)(__target))->get_" + _name + "(_tr_t)"
if variable.get_name() == PredefinedVariables.E_CONSTANT:
return 'numerics::e'
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(variable.get_complete_name()):
return str(
UnitConverter.get_factor(
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,
error_position=variable.get_source_position())
return ''
if symbol.is_local():
return variable.get_name() + (
'[' + variable.get_vector_parameter() +
']' if symbol.has_vector_parameter() else '')
if symbol.is_buffer():
if isinstance(symbol.get_type_symbol(), UnitTypeSymbol):
units_conversion_factor = UnitConverter.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 += NestPrinter.print_origin(
symbol,
prefix=prefix) + NestNamesConverter.buffer_value(symbol)
if symbol.has_vector_parameter():
s += '[' + variable.get_vector_parameter() + ']'
if not units_conversion_factor == 1:
s += ")"
return s
if symbol.is_inline_expression:
return 'get_' + variable.get_name() + '()' + (
'[i]' if symbol.has_vector_parameter() else '')
if symbol.is_kernel():
assert False, "NEST reference converter cannot print kernel; kernel should have been converted during code generation"
if symbol.is_state():
temp = ""
temp += NestNamesConverter.getter(symbol) + "()"
temp += ('[' + variable.get_vector_parameter() +
']' if symbol.has_vector_parameter() else '')
return temp
variable_name = NestNamesConverter.convert_to_cpp_name(
variable.get_complete_name())
if symbol.is_local():
return variable_name + ('[i]'
if symbol.has_vector_parameter() else '')
if symbol.is_inline_expression:
return 'get_' + variable_name + '()' + (
'[i]' if symbol.has_vector_parameter() else '')
return NestPrinter.print_origin(symbol, prefix=prefix) + \
NestNamesConverter.name(symbol) + \
('[' + variable.get_vector_parameter() + ']' if symbol.has_vector_parameter() else '')
def convert_name_reference(self, variable, prefix='', with_origins = True):
"""
Converts a single variable to nest processable format.
:param variable: a single variable.
:type variable: ASTVariable
:return: a nest processable format.
:rtype: str
"""
from pynestml.codegeneration.nest_printer import NestPrinter
assert (variable is not None and isinstance(variable, ASTVariable)), \
'(PyNestML.CodeGeneration.NestReferenceConverter) No or wrong type of uses-gsl provided (%s)!' % type(
variable)
variable_name = NestNamesConverter.convert_to_cpp_name(variable.get_complete_name())
if variable_name == PredefinedVariables.E_CONSTANT:
return 'numerics::e'
assert variable.get_scope() is not None, "Undeclared variable: " + variable.get_complete_name()
symbol = variable.get_scope().resolve_to_symbol(variable_name, SymbolKind.VARIABLE)
if symbol is None:
# test if variable name can be resolved to a type
if PredefinedUnits.is_unit(variable.get_complete_name()):
return str(UnitConverter.get_factor(PredefinedUnits.get_unit(variable.get_complete_name()).get_unit()))
code, message = Messages.get_could_not_resolve(variable_name)
Logger.log_message(log_level=LoggingLevel.ERROR, code=code, message=message,
error_position=variable.get_source_position())
return ''
if symbol.is_local():
return variable_name + ('[i]' if symbol.has_vector_parameter() else '')
if symbol.is_buffer():
if isinstance(symbol.get_type_symbol(), UnitTypeSymbol):
units_conversion_factor = UnitConverter.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 += NestPrinter.print_origin(symbol, prefix=prefix) if with_origins else ''
s += NestNamesConverter.buffer_value(symbol)
if symbol.has_vector_parameter():
s += '[i]'
if not units_conversion_factor == 1:
s += ")"
return s
if symbol.is_inline_expression:
return 'get_' + variable_name + '()' + ('[i]' if symbol.has_vector_parameter() else '')
if symbol.is_kernel():
assert False, "NEST reference converter cannot print kernel; kernel should have been converted during code generation"
if symbol.is_state():
temp = NestPrinter.print_origin(symbol, prefix=prefix) if with_origins else ''
if self.uses_gsl:
temp += GSLNamesConverter.name(symbol)
else:
temp += NestNamesConverter.name(symbol)
temp += ('[i]' if symbol.has_vector_parameter() else '')
return temp
return (NestPrinter.print_origin(symbol, prefix=prefix) if with_origins else '') + \
NestNamesConverter.name(symbol) + \
('[i]' if symbol.has_vector_parameter() else '')
