def __init__(self, group, when='resets', order=None, event='spike'): self.event = event # Since this now works for general events not only spikes, we have to # pass the information about which variable to use to the template, # it can not longer simply refer to "_spikespace" eventspace_name = '_{}space'.format(event) template_kwds = {'eventspace_variable': group.variables[eventspace_name]} needed_variables= [eventspace_name] order = order if order is not None else group.order CodeRunner.__init__(self, group, 'reset', code='', # will be set in update_abstract_code clock=group.clock, when=when, order=order, name=group.name + '_resetter*', override_conditional_write=['not_refractory'], needed_variables=needed_variables, template_kwds=template_kwds) # Check the abstract code for unit mismatches (only works if the # namespace is already complete) try: self.update_abstract_code(level=1) check_code_units(self.abstract_code, self.group) except KeyError: pass
def __init__(self, group, when='thresholds', event='spike'): self.event = event if group._refractory is False or event != 'spike': template_kwds = {'_uses_refractory': False} needed_variables = [] else: template_kwds = {'_uses_refractory': True} needed_variables=['t', 'not_refractory', 'lastspike'] # Since this now works for general events not only spikes, we have to # pass the information about which variable to use to the template, # it can not longer simply refer to "_spikespace" eventspace_name = '_{}space'.format(event) template_kwds['eventspace_variable'] = group.variables[eventspace_name] needed_variables.append(eventspace_name) CodeRunner.__init__(self, group, 'threshold', code='', # will be set in update_abstract_code clock=group.clock, when=when, order=group.order, name=group.name+'_thresholder*', needed_variables=needed_variables, template_kwds=template_kwds) # Check the abstract code for unit mismatches (only works if the # namespace is already complete) try: self.update_abstract_code(level=1) check_code_units(self.abstract_code, self.group) except KeyError: pass
def __init__(self, group): GroupCodeRunner.__init__(self, group, 'reset', when=(group.clock, 'resets'), name=group.name + '_resetter*') # Check the abstract code for unit mismatches (only works if the # namespace is already complete) self.update_abstract_code() check_code_units(self.abstract_code, self.group, ignore_keyerrors=True)
def get_with_expression(self, variable_name, variable, code, level=0, run_namespace=None): ''' Gets a variable using a string expression. Is called by `VariableView.get_item` for statements such as ``print G.v['g_syn > 0']``. Parameters ---------- variable_name : str The name of the variable in its context (e.g. ``'g_post'`` for a variable with name ``'g'``) variable : `ArrayVariable` The `ArrayVariable` object for the variable to be set code : str An expression that states a condition for elements that should be selected. Can contain references to indices, such as ``i`` or ``j`` and to state variables. For example: ``'i>3 and v>0*mV'``. level : int, optional How much farther to go up in the stack to find the implicit namespace (if used, see `run_namespace`). run_namespace : dict-like, optional An additional namespace that is used for variable lookup (if not defined, the implicit namespace of local variables is used). ''' if variable.scalar: raise IndexError(('Cannot access the variable %s with a ' 'string expression, it is a scalar ' 'variable.') % variable_name) # Add the recorded variable under a known name to the variables # dictionary. Important to deal correctly with # the type of the variable in C++ variables = Variables(None) variables.add_auxiliary_variable('_variable', unit=variable.unit, dtype=variable.dtype, scalar=variable.scalar) variables.add_auxiliary_variable('_cond', unit=Unit(1), dtype=np.bool) abstract_code = '_variable = ' + variable_name + '\n' abstract_code += '_cond = ' + code check_code_units(abstract_code, self, additional_variables=variables, level=level+2, run_namespace=run_namespace) codeobj = create_runner_codeobj(self, abstract_code, 'group_variable_get_conditional', additional_variables=variables, level=level+2, run_namespace=run_namespace, ) return codeobj()
def __init__(self, group): CodeRunner.__init__(self, group, 'reset', when=(group.clock, 'resets'), name=group.name + '_resetter*', override_conditional_write=['not_refractory']) # Check the abstract code for unit mismatches (only works if the # namespace is already complete) try: self.update_abstract_code(level=1) check_code_units(self.abstract_code, self.group) except KeyError: pass
def set_with_expression_conditional(self, varname, variable, cond, code, check_units=True, level=0, run_namespace=None): ''' Sets a variable using a string expression and string condition. Is called by `VariableView.set_item` for statements such as ``S.var['i!=j'] = 'exp(-abs(i-j)/space_constant)*nS'`` Parameters ---------- varname : str The name of the variable to be set. variable : `ArrayVariable` The `ArrayVariable` object for the variable to be set. cond : str The string condition for which the variables should be set. code : str The code that should be executed to set the variable values. check_units : bool, optional Whether to check the units of the expression. level : int, optional How much farther to go up in the stack to find the implicit namespace (if used, see `run_namespace`). run_namespace : dict-like, optional An additional namespace that is used for variable lookup (if not defined, the implicit namespace of local variables is used). ''' if variable.scalar and cond != 'True': raise IndexError(('Cannot conditionally set the scalar variable ' '%s.') % varname) abstract_code_cond = '_cond = '+cond abstract_code = varname + ' = ' + code variables = Variables(None) variables.add_auxiliary_variable('_cond', unit=Unit(1), dtype=np.bool) check_code_units(abstract_code_cond, self, additional_variables=variables, level=level+2, run_namespace=run_namespace) # TODO: Have an additional argument to avoid going through the index # array for situations where iterate_all could be used codeobj = create_runner_codeobj(self, {'condition': abstract_code_cond, 'statement': abstract_code}, 'group_variable_set_conditional', additional_variables=variables, check_units=check_units, level=level+2, run_namespace=run_namespace) codeobj()
def get_with_expression(self, group, variable_name, variable, code, level=0): ''' Gets a variable using a string expression. Is called by `VariableView.get_item` for statements such as ``print G.v['g_syn > 0']``. Parameters ---------- group : `Group` The group providing the context for the indexing. variable_name : str The name of the variable in its context (e.g. ``'g_post'`` for a variable with name ``'g'``) variable : `ArrayVariable` The `ArrayVariable` object for the variable to be set code : str An expression that states a condition for elements that should be selected. Can contain references to indices, such as ``i`` or ``j`` and to state variables. For example: ``'i>3 and v>0*mV'``. level : int, optional How much farther to go up in the stack to find the namespace. ''' # interpret the string expression namespace = get_local_namespace(level+1) additional_namespace = ('implicit-namespace', namespace) # Add the recorded variable under a known name to the variables # dictionary. Important to deal correctly with # the type of the variable in C++ variables = Variables(None) variables.add_auxiliary_variable('_variable', unit=variable.unit, dtype=variable.dtype, scalar=variable.scalar, is_bool=variable.is_bool) variables.add_auxiliary_variable('_cond', unit=Unit(1), dtype=np.bool, is_bool=True) abstract_code = '_variable = ' + variable_name + '\n' abstract_code += '_cond = ' + code check_code_units(abstract_code, group, additional_namespace=additional_namespace, additional_variables=variables) codeobj = create_runner_codeobj(group, abstract_code, 'group_variable_get_conditional', additional_variables=variables, additional_namespace=additional_namespace, ) return codeobj()
def set_with_expression_conditional(self, group, varname, variable, cond, code, check_units=True, level=0): ''' Sets a variable using a string expression and string condition. Is called by `VariableView.set_item` for statements such as ``S.var['i!=j'] = 'exp(-abs(i-j)/space_constant)*nS'`` Parameters ---------- group : `Group` The group providing the context for the indexing. varname : str The name of the variable to be set. variable : `ArrayVariable` The `ArrayVariable` object for the variable to be set. cond : str The string condition for which the variables should be set. code : str The code that should be executed to set the variable values. check_units : bool, optional Whether to check the units of the expression. level : int, optional How much farther to go up in the stack to find the namespace. ''' abstract_code_cond = '_cond = '+cond abstract_code = varname + ' = ' + code namespace = get_local_namespace(level + 1) additional_namespace = ('implicit-namespace', namespace) variables = Variables(None) variables.add_auxiliary_variable('_cond', unit=Unit(1), dtype=np.bool, is_bool=True) check_code_units(abstract_code_cond, group, additional_variables=variables, additional_namespace=additional_namespace) # TODO: Have an additional argument to avoid going through the index # array for situations where iterate_all could be used codeobj = create_runner_codeobj(group, {'condition': abstract_code_cond, 'statement': abstract_code}, 'group_variable_set_conditional', additional_variables=variables, additional_namespace=additional_namespace, check_units=check_units) codeobj()
def __init__(self, group): if group._refractory is False: template_kwds = {'_uses_refractory': False} needed_variables = [] else: template_kwds = {'_uses_refractory': True} needed_variables=['t', 'not_refractory', 'lastspike'] GroupCodeRunner.__init__(self, group, 'threshold', when=(group.clock, 'thresholds'), name=group.name+'_thresholder*', needed_variables=needed_variables, template_kwds=template_kwds) # Check the abstract code for unit mismatches (only works if the # namespace is already complete) self.update_abstract_code() check_code_units(self.abstract_code, self.group, ignore_keyerrors=True)
def before_run(self, namespace): self.update_abstract_code() # If the GroupCodeRunner has variables, add them if hasattr(self, 'variables'): additional_variables = self.variables else: additional_variables = None if self.check_units: check_code_units(self.abstract_code, self.group, additional_variables, namespace) self.codeobj = create_runner_codeobj(group=self.group, code=self.abstract_code, template_name=self.template, name=self.name+'_codeobject*', check_units=self.check_units, additional_variables=additional_variables, additional_namespace=namespace, needed_variables=self.needed_variables, template_kwds=self.template_kwds) self.code_objects[:] = [weakref.proxy(self.codeobj)]
def __getitem__(self, item): if isinstance(item, basestring): variables = Variables(None) variables.add_auxiliary_variable("_indices", unit=Unit(1), dtype=np.int32) variables.add_auxiliary_variable("_cond", unit=Unit(1), dtype=np.bool) abstract_code = "_cond = " + item check_code_units(abstract_code, self.group, additional_variables=variables, level=1) from brian2.devices.device import get_default_codeobject_class codeobj = create_runner_codeobj( self.group, abstract_code, "group_get_indices", additional_variables=variables, level=1, codeobj_class=get_default_codeobject_class("codegen.string_expression_target"), ) return codeobj() else: return self.indices(item)
def __getitem__(self, item): if isinstance(item, basestring): variables = Variables(None) variables.add_auxiliary_variable('_indices', unit=Unit(1), dtype=np.int32) variables.add_auxiliary_variable('_cond', unit=Unit(1), dtype=np.bool) abstract_code = '_cond = ' + item check_code_units(abstract_code, self.group, additional_variables=variables, level=1) codeobj = create_runner_codeobj(self.group, abstract_code, 'group_get_indices', additional_variables=variables, level=1 ) return codeobj() else: return self.group.calc_indices(item)
def __init__(self, group): if group._refractory is False: template_kwds = {'_uses_refractory': False} needed_variables = [] else: template_kwds = {'_uses_refractory': True} needed_variables=['t', 'not_refractory', 'lastspike'] CodeRunner.__init__(self, group, 'threshold', when=(group.clock, 'thresholds'), name=group.name+'_thresholder*', needed_variables=needed_variables, template_kwds=template_kwds) # Check the abstract code for unit mismatches (only works if the # namespace is already complete) try: self.update_abstract_code(level=1) check_code_units(self.abstract_code, self.group) except KeyError: pass
def __getitem__(self, item): if isinstance(item, basestring): variables = Variables(None) variables.add_auxiliary_variable('_indices', unit=Unit(1), dtype=np.int32) variables.add_auxiliary_variable('_cond', unit=Unit(1), dtype=np.bool) abstract_code = '_cond = ' + item check_code_units(abstract_code, self.group, additional_variables=variables, level=1) from brian2.devices.device import get_default_codeobject_class codeobj = create_runner_codeobj(self.group, abstract_code, 'group_get_indices', additional_variables=variables, level=1, codeobj_class=get_default_codeobject_class('codegen.string_expression_target') ) return codeobj() else: return self.indices(item)
def __init__(self, group): if group._refractory is False: template_kwds = {'_uses_refractory': False} needed_variables = [] else: template_kwds = {'_uses_refractory': True} needed_variables=['t', 'not_refractory', 'lastspike'] CodeRunner.__init__(self, group, 'threshold', code='', # will be set in update_abstract_code clock=group.clock, when='thresholds', order=group.order, name=group.name+'_thresholder*', needed_variables=needed_variables, template_kwds=template_kwds) # Check the abstract code for unit mismatches (only works if the # namespace is already complete) try: self.update_abstract_code(level=1) check_code_units(self.abstract_code, self.group) except KeyError: pass
def __getitem__(self, item): if isinstance(item, basestring): namespace = get_local_namespace(1) additional_namespace = ('implicit-namespace', namespace) variables = Variables(None) variables.add_auxiliary_variable('_indices', unit=Unit(1), dtype=np.int32) variables.add_auxiliary_variable('_cond', unit=Unit(1), dtype=np.bool, is_bool=True) abstract_code = '_cond = ' + item check_code_units(abstract_code, self.group, additional_namespace=additional_namespace, additional_variables=variables) codeobj = create_runner_codeobj(self.group, abstract_code, 'group_get_indices', additional_variables=variables, additional_namespace=additional_namespace, ) return codeobj() else: return self.group.calc_indices(item)