def test_construction_errors():
'''
Test that the Equations constructor raises errors correctly
'''
# parse error
assert_raises(EquationError, lambda: Equations('dv/dt = -v / tau volt'))
# Only a single string or a list of SingleEquation objects is allowed
assert_raises(TypeError, lambda: Equations(None))
assert_raises(TypeError, lambda: Equations(42))
assert_raises(TypeError, lambda: Equations(['dv/dt = -v / tau : volt']))
# duplicate variable names
assert_raises(EquationError, lambda: Equations('''dv/dt = -v / tau : volt
v = 2 * t/second * volt : volt'''))
eqs = [SingleEquation(DIFFERENTIAL_EQUATION, 'v', volt,
expr=Expression('-v / tau')),
SingleEquation(SUBEXPRESSION, 'v', volt,
expr=Expression('2 * t/second * volt'))
]
assert_raises(EquationError, lambda: Equations(eqs))
# illegal variable names
assert_raises(ValueError, lambda: Equations('ddt/dt = -dt / tau : volt'))
assert_raises(ValueError, lambda: Equations('dt/dt = -t / tau : volt'))
assert_raises(ValueError, lambda: Equations('dxi/dt = -xi / tau : volt'))
assert_raises(ValueError, lambda: Equations('for : volt'))
assert_raises((EquationError, ValueError),
lambda: Equations('d1a/dt = -1a / tau : volt'))
assert_raises(ValueError, lambda: Equations('d_x/dt = -_x / tau : volt'))
# xi in a subexpression
assert_raises(EquationError,
lambda: Equations('''dv/dt = -(v + I) / (5 * ms) : volt
I = second**-1*xi**-2*volt : volt'''))
# more than one xi
assert_raises(EquationError,
lambda: Equations('''dv/dt = -v / tau + xi/tau**.5 : volt
dx/dt = -x / tau + 2*xi/tau : volt
tau : second'''))
# using not-allowed flags
eqs = Equations('dv/dt = -v / (5 * ms) : volt (flag)')
eqs.check_flags({DIFFERENTIAL_EQUATION: ['flag']}) # allow this flag
assert_raises(ValueError, lambda: eqs.check_flags({DIFFERENTIAL_EQUATION: []}))
assert_raises(ValueError, lambda: eqs.check_flags({}))
assert_raises(ValueError, lambda: eqs.check_flags({SUBEXPRESSION: ['flag']}))
assert_raises(ValueError, lambda: eqs.check_flags({DIFFERENTIAL_EQUATION: ['otherflag']}))
# Circular subexpression
assert_raises(ValueError, lambda: Equations('''dv/dt = -(v + w) / (10 * ms) : 1
w = 2 * x : 1
x = 3 * w : 1'''))
# Boolean/integer differential equations
assert_raises(TypeError, lambda: Equations('dv/dt = -v / (10*ms) : boolean'))
assert_raises(TypeError, lambda: Equations('dv/dt = -v / (10*ms) : integer'))
def test_construction_errors():
"""
Test that the Equations constructor raises errors correctly
"""
# parse error
with pytest.raises(EquationError):
Equations('dv/dt = -v / tau volt')
with pytest.raises(EquationError):
Equations('dv/dt = -v / tau : volt second')
# incorrect unit definition
with pytest.raises(EquationError):
Equations('dv/dt = -v / tau : mvolt')
with pytest.raises(EquationError):
Equations('dv/dt = -v / tau : voltage')
with pytest.raises(EquationError):
Equations('dv/dt = -v / tau : 1.0*volt')
# Only a single string or a list of SingleEquation objects is allowed
with pytest.raises(TypeError):
Equations(None)
with pytest.raises(TypeError):
Equations(42)
with pytest.raises(TypeError):
Equations(['dv/dt = -v / tau : volt'])
# duplicate variable names
with pytest.raises(EquationError):
Equations("""dv/dt = -v / tau : volt
v = 2 * t/second * volt : volt""")
eqs = [
SingleEquation(DIFFERENTIAL_EQUATION,
'v',
volt.dim,
expr=Expression('-v / tau')),
SingleEquation(SUBEXPRESSION,
'v',
volt.dim,
expr=Expression('2 * t/second * volt'))
]
with pytest.raises(EquationError):
Equations(eqs)
# illegal variable names
with pytest.raises(SyntaxError):
Equations('ddt/dt = -dt / tau : volt')
with pytest.raises(SyntaxError):
Equations('dt/dt = -t / tau : volt')
with pytest.raises(SyntaxError):
Equations('dxi/dt = -xi / tau : volt')
with pytest.raises(SyntaxError):
Equations('for : volt')
with pytest.raises((EquationError, SyntaxError)):
Equations('d1a/dt = -1a / tau : volt')
with pytest.raises(SyntaxError):
Equations('d_x/dt = -_x / tau : volt')
# xi in a subexpression
with pytest.raises(EquationError):
Equations("""dv/dt = -(v + I) / (5 * ms) : volt
I = second**-1*xi**-2*volt : volt""")
# more than one xi
with pytest.raises(EquationError):
Equations("""dv/dt = -v / tau + xi/tau**.5 : volt
dx/dt = -x / tau + 2*xi/tau : volt
tau : second""")
# using not-allowed flags
eqs = Equations('dv/dt = -v / (5 * ms) : volt (flag)')
eqs.check_flags({DIFFERENTIAL_EQUATION: ['flag']}) # allow this flag
with pytest.raises(ValueError):
eqs.check_flags({DIFFERENTIAL_EQUATION: []})
with pytest.raises(ValueError):
eqs.check_flags({})
with pytest.raises(ValueError):
eqs.check_flags({SUBEXPRESSION: ['flag']})
with pytest.raises(ValueError):
eqs.check_flags({DIFFERENTIAL_EQUATION: ['otherflag']})
eqs = Equations('dv/dt = -v / (5 * ms) : volt (flag1, flag2)')
eqs.check_flags({DIFFERENTIAL_EQUATION: ['flag1',
'flag2']}) # allow both flags
# Don't allow the two flags in combination
with pytest.raises(ValueError):
eqs.check_flags({DIFFERENTIAL_EQUATION: ['flag1', 'flag2']},
incompatible_flags=[('flag1', 'flag2')])
eqs = Equations("""dv/dt = -v / (5 * ms) : volt (flag1)
dw/dt = -w / (5 * ms) : volt (flag2)""")
# They should be allowed when used independently
eqs.check_flags({DIFFERENTIAL_EQUATION: ['flag1', 'flag2']},
incompatible_flags=[('flag1', 'flag2')])
# Circular subexpression
with pytest.raises(ValueError):
Equations("""dv/dt = -(v + w) / (10 * ms) : 1
w = 2 * x : 1
x = 3 * w : 1""")
# Boolean/integer differential equations
with pytest.raises(TypeError):
Equations('dv/dt = -v / (10*ms) : boolean')
with pytest.raises(TypeError):
Equations('dv/dt = -v / (10*ms) : integer')
def __init__(self,
source,
target=None,
model=None,
pre=None,
post=None,
connect=False,
delay=None,
namespace=None,
dtype=None,
codeobj_class=None,
clock=None,
method=None,
name='synapses*'):
self._N = 0
Group.__init__(self, when=clock, name=name)
self.codeobj_class = codeobj_class
self.source = weakref.proxy(source)
if target is None:
self.target = self.source
else:
self.target = weakref.proxy(target)
##### Prepare and validate equations
if model is None:
model = ''
if isinstance(model, basestring):
model = Equations(model)
if not isinstance(model, Equations):
raise TypeError(('model has to be a string or an Equations '
'object, is "%s" instead.') % type(model))
# Check flags
model.check_flags({
DIFFERENTIAL_EQUATION: ['event-driven'],
SUBEXPRESSION: ['summed', 'scalar'],
PARAMETER: ['constant', 'scalar']
})
# Add the lastupdate variable, needed for event-driven updates
if 'lastupdate' in model._equations:
raise SyntaxError('lastupdate is a reserved name.')
model._equations['lastupdate'] = SingleEquation(
PARAMETER, 'lastupdate', second)
self._create_variables(model)
# Separate the equations into event-driven equations,
# continuously updated equations and summed variable updates
event_driven = []
continuous = []
summed_updates = []
for single_equation in model.itervalues():
if 'event-driven' in single_equation.flags:
event_driven.append(single_equation)
elif 'summed' in single_equation.flags:
summed_updates.append(single_equation)
else:
continuous.append(single_equation)
if len(event_driven):
self.event_driven = Equations(event_driven)
else:
self.event_driven = None
self.equations = Equations(continuous)
if namespace is None:
namespace = {}
#: The group-specific namespace
self.namespace = namespace
#: Set of `Variable` objects that should be resized when the
#: number of synapses changes
self._registered_variables = set()
for varname, var in self.variables.iteritems():
if isinstance(var, DynamicArrayVariable):
# Register the array with the `SynapticItemMapping` object so
# it gets automatically resized
self.register_variable(var)
if delay is None:
delay = {}
if isinstance(delay, Quantity):
delay = {'pre': delay}
elif not isinstance(delay, collections.Mapping):
raise TypeError('Delay argument has to be a quantity or a '
'dictionary, is type %s instead.' % type(delay))
#: List of names of all updaters, e.g. ['pre', 'post']
self._synaptic_updaters = []
#: List of all `SynapticPathway` objects
self._pathways = []
for prepost, argument in zip(('pre', 'post'), (pre, post)):
if not argument:
continue
if isinstance(argument, basestring):
pathway_delay = delay.get(prepost, None)
self._add_updater(argument, prepost, delay=pathway_delay)
elif isinstance(argument, collections.Mapping):
for key, value in argument.iteritems():
if not isinstance(key, basestring):
err_msg = ('Keys for the "{}" argument'
'have to be strings, got '
'{} instead.').format(prepost, type(key))
raise TypeError(err_msg)
pathway_delay = delay.get(key, None)
self._add_updater(value,
prepost,
objname=key,
delay=pathway_delay)
# Check whether any delays were specified for pathways that don't exist
for pathway in delay:
if not pathway in self._synaptic_updaters:
raise ValueError(('Cannot set the delay for pathway '
'"%s": unknown pathway.') % pathway)
# If we have a pathway called "pre" (the most common use case), provide
# direct access to its delay via a delay attribute (instead of having
# to use pre.delay)
if 'pre' in self._synaptic_updaters:
self.variables.add_reference('delay', self.pre.variables['delay'])
#: Performs numerical integration step
self.state_updater = None
# We only need a state update if we have differential equations
if len(self.equations.diff_eq_names):
self.state_updater = StateUpdater(self, method)
self.contained_objects.append(self.state_updater)
#: "Summed variable" mechanism -- sum over all synapses of a
#: pre-/postsynaptic target
self.summed_updaters = {}
# We want to raise an error if the same variable is updated twice
# using this mechanism. This could happen if the Synapses object
# connected a NeuronGroup to itself since then all variables are
# accessible as var_pre and var_post.
summed_targets = set()
for single_equation in summed_updates:
varname = single_equation.varname
if not (varname.endswith('_pre') or varname.endswith('_post')):
raise ValueError(('The summed variable "%s" does not end '
'in "_pre" or "_post".') % varname)
if not varname in self.variables:
raise ValueError(('The summed variable "%s" does not refer'
'do any known variable in the '
'target group.') % varname)
if varname.endswith('_pre'):
summed_target = self.source
orig_varname = varname[:-4]
else:
summed_target = self.target
orig_varname = varname[:-5]
target_eq = getattr(summed_target, 'equations',
{}).get(orig_varname, None)
if target_eq is None or target_eq.type != PARAMETER:
raise ValueError(('The summed variable "%s" needs a '
'corresponding parameter "%s" in the '
'target group.') % (varname, orig_varname))
fail_for_dimension_mismatch(
self.variables['_summed_' + varname].unit,
self.variables[varname].unit, ('Summed variables need to have '
'the same units in Synapses '
'and the target group'))
if self.variables[varname] in summed_targets:
raise ValueError(('The target variable "%s" is already '
'updated by another summed '
'variable') % orig_varname)
summed_targets.add(self.variables[varname])
updater = SummedVariableUpdater(single_equation.expr, varname,
self, summed_target)
self.summed_updaters[varname] = updater
self.contained_objects.append(updater)
# Do an initial connect, if requested
if not isinstance(connect, (bool, basestring)):
raise TypeError(
('"connect" keyword has to be a boolean value or a '
'string, is type %s instead.' % type(connect)))
self._initial_connect = connect
if not connect is False:
self.connect(connect, level=1)
# Activate name attribute access
self._enable_group_attributes()
def __init__(self,
morphology=None,
model=None,
threshold=None,
refractory=False,
reset=None,
events=None,
threshold_location=None,
dt=None,
clock=None,
order=0,
Cm=0.9 * uF / cm**2,
Ri=150 * ohm * cm,
name='spatialneuron*',
dtype=None,
namespace=None,
method=('linear', 'exponential_euler', 'rk2', 'heun')):
# #### Prepare and validate equations
if isinstance(model, basestring):
model = Equations(model)
if not isinstance(model, Equations):
raise TypeError(('model has to be a string or an Equations '
'object, is "%s" instead.') % type(model))
# Insert the threshold mechanism at the specified location
if threshold_location is not None:
if hasattr(threshold_location,
'_indices'): # assuming this is a method
threshold_location = threshold_location._indices()
# for now, only a single compartment allowed
if len(threshold_location) == 1:
threshold_location = threshold_location[0]
else:
raise AttributeError(('Threshold can only be applied on a '
'single location'))
threshold = '(' + threshold + ') and (i == ' + str(
threshold_location) + ')'
# Check flags (we have point currents)
model.check_flags({
DIFFERENTIAL_EQUATION: ('point current', ),
PARAMETER: ('constant', 'shared', 'linked', 'point current'),
SUBEXPRESSION: ('shared', 'point current', 'constant over dt')
})
#: The original equations as specified by the user (i.e. before
#: inserting point-currents into the membrane equation, before adding
#: all the internally used variables and constants, etc.).
self.user_equations = model
# Separate subexpressions depending whether they are considered to be
# constant over a time step or not (this would also be done by the
# NeuronGroup initializer later, but this would give incorrect results
# for the linearity check)
model, constant_over_dt = extract_constant_subexpressions(model)
# Extract membrane equation
if 'Im' in model:
if len(model['Im'].flags):
raise TypeError(
'Cannot specify any flags for the transmembrane '
'current Im.')
membrane_expr = model['Im'].expr # the membrane equation
else:
raise TypeError('The transmembrane current Im must be defined')
model_equations = []
# Insert point currents in the membrane equation
for eq in model.itervalues():
if eq.varname == 'Im':
continue # ignore -- handled separately
if 'point current' in eq.flags:
fail_for_dimension_mismatch(
eq.dim, amp,
"Point current " + eq.varname + " should be in amp")
membrane_expr = Expression(
str(membrane_expr.code) + '+' + eq.varname + '/area')
eq = SingleEquation(
eq.type,
eq.varname,
eq.dim,
expr=eq.expr,
flags=list(set(eq.flags) - set(['point current'])))
model_equations.append(eq)
model_equations.append(
SingleEquation(SUBEXPRESSION,
'Im',
dimensions=(amp / meter**2).dim,
expr=membrane_expr))
model_equations.append(SingleEquation(PARAMETER, 'v', volt.dim))
model = Equations(model_equations)
###### Process model equations (Im) to extract total conductance and the remaining current
# Expand expressions in the membrane equation
for var, expr in model.get_substituted_expressions(
include_subexpressions=True):
if var == 'Im':
Im_expr = expr
break
else:
raise AssertionError('Model equations did not contain Im!')
# Differentiate Im with respect to v
Im_sympy_exp = str_to_sympy(Im_expr.code)
v_sympy = sp.Symbol('v', real=True)
diffed = sp.diff(Im_sympy_exp, v_sympy)
unevaled_derivatives = diffed.atoms(sp.Derivative)
if len(unevaled_derivatives):
raise TypeError(
'Cannot take the derivative of "{Im}" with respect '
'to v.'.format(Im=Im_expr.code))
gtot_str = sympy_to_str(sp.simplify(-diffed))
I0_str = sympy_to_str(sp.simplify(Im_sympy_exp - diffed * v_sympy))
if gtot_str == '0':
gtot_str += '*siemens/meter**2'
if I0_str == '0':
I0_str += '*amp/meter**2'
gtot_str = "gtot__private=" + gtot_str + ": siemens/meter**2"
I0_str = "I0__private=" + I0_str + ": amp/meter**2"
model += Equations(gtot_str + "\n" + I0_str)
# Insert morphology (store a copy)
self.morphology = copy.deepcopy(morphology)
# Flatten the morphology
self.flat_morphology = FlatMorphology(morphology)
# Equations for morphology
# TODO: check whether Cm and Ri are already in the equations
# no: should be shared instead of constant
# yes: should be constant (check)
eqs_constants = Equations("""
length : meter (constant)
distance : meter (constant)
area : meter**2 (constant)
volume : meter**3
Ic : amp/meter**2
diameter : meter (constant)
Cm : farad/meter**2 (constant)
Ri : ohm*meter (constant, shared)
r_length_1 : meter (constant)
r_length_2 : meter (constant)
time_constant = Cm/gtot__private : second
space_constant = (2/pi)**(1.0/3.0) * (area/(1/r_length_1 + 1/r_length_2))**(1.0/6.0) /
(2*(Ri*gtot__private)**(1.0/2.0)) : meter
""")
if self.flat_morphology.has_coordinates:
eqs_constants += Equations('''
x : meter (constant)
y : meter (constant)
z : meter (constant)
''')
NeuronGroup.__init__(self,
morphology.total_compartments,
model=model + eqs_constants,
threshold=threshold,
refractory=refractory,
reset=reset,
events=events,
method=method,
dt=dt,
clock=clock,
order=order,
namespace=namespace,
dtype=dtype,
name=name)
# Parameters and intermediate variables for solving the cable equations
# Note that some of these variables could have meaningful physical
# units (e.g. _v_star is in volt, _I0_all is in amp/meter**2 etc.) but
# since these variables should never be used in user code, we don't
# assign them any units
self.variables.add_arrays(
[
'_ab_star0',
'_ab_star1',
'_ab_star2',
'_a_minus0',
'_a_minus1',
'_a_minus2',
'_a_plus0',
'_a_plus1',
'_a_plus2',
'_b_plus',
'_b_minus',
'_v_star',
'_u_plus',
'_u_minus',
'_v_previous',
# The following three are for solving the
# three tridiag systems in parallel
'_c1',
'_c2',
'_c3',
# The following two are only necessary for
# C code where we cannot deal with scalars
# and arrays interchangeably:
'_I0_all',
'_gtot_all'
],
size=self.N,
read_only=True)
self.Cm = Cm
self.Ri = Ri
# These explict assignments will load the morphology values from disk
# in standalone mode
self.distance_ = self.flat_morphology.distance
self.length_ = self.flat_morphology.length
self.area_ = self.flat_morphology.area
self.diameter_ = self.flat_morphology.diameter
self.r_length_1_ = self.flat_morphology.r_length_1
self.r_length_2_ = self.flat_morphology.r_length_2
if self.flat_morphology.has_coordinates:
self.x_ = self.flat_morphology.x
self.y_ = self.flat_morphology.y
self.z_ = self.flat_morphology.z
# Performs numerical integration step
self.add_attribute('diffusion_state_updater')
self.diffusion_state_updater = SpatialStateUpdater(self,
method,
clock=self.clock,
order=order)
# Update v after the gating variables to obtain consistent Ic and Im
self.diffusion_state_updater.order = 1
# Creation of contained_objects that do the work
self.contained_objects.extend([self.diffusion_state_updater])
if len(constant_over_dt):
self.subexpression_updater = SubexpressionUpdater(
self, constant_over_dt)
self.contained_objects.append(self.subexpression_updater)
def __init__(self,
source,
target=None,
model=None,
pre=None,
post=None,
connect=False,
delay=None,
namespace=None,
dtype=None,
codeobj_class=None,
clock=None,
method=None,
name='synapses*'):
BrianObject.__init__(self, when=clock, name=name)
self.codeobj_class = codeobj_class
self.source = weakref.proxy(source)
if target is None:
self.target = self.source
else:
self.target = weakref.proxy(target)
##### Prepare and validate equations
if model is None:
model = ''
if isinstance(model, basestring):
model = Equations(model)
if not isinstance(model, Equations):
raise TypeError(('model has to be a string or an Equations '
'object, is "%s" instead.') % type(model))
# Check flags
model.check_flags({
DIFFERENTIAL_EQUATION: ['event-driven', 'lumped'],
STATIC_EQUATION: ['lumped'],
PARAMETER: ['constant', 'lumped']
})
# Separate the equations into event-driven and continuously updated
# equations
event_driven = []
continuous = []
for single_equation in model.itervalues():
if 'event-driven' in single_equation.flags:
if 'lumped' in single_equation.flags:
raise ValueError(
('Event-driven variable %s cannot be '
'a lumped variable.') % single_equation.varname)
event_driven.append(single_equation)
else:
continuous.append(single_equation)
# Add the lastupdate variable, used by event-driven equations
continuous.append(SingleEquation(PARAMETER, 'lastupdate', second))
if len(event_driven):
self.event_driven = Equations(event_driven)
else:
self.event_driven = None
self.equations = Equations(continuous)
##### Setup the memory
self.arrays = self._allocate_memory(dtype=dtype)
# Setup the namespace
self._given_namespace = namespace
self.namespace = create_namespace(namespace)
self._queues = {}
self._delays = {}
self.item_mapping = SynapticItemMapping(self)
self.indices = {
'_idx': self.item_mapping,
'_presynaptic_idx': self.item_mapping.synaptic_pre,
'_postsynaptic_idx': self.item_mapping.synaptic_post
}
# Allow S.i instead of S.indices.i, etc.
self.i = self.item_mapping.i
self.j = self.item_mapping.j
self.k = self.item_mapping.k
# Setup variables
self.variables = self._create_variables()
#: List of names of all updaters, e.g. ['pre', 'post']
self._updaters = []
for prepost, argument in zip(('pre', 'post'), (pre, post)):
if not argument:
continue
if isinstance(argument, basestring):
self._add_updater(argument, prepost)
elif isinstance(argument, collections.Mapping):
for key, value in argument.iteritems():
if not isinstance(key, basestring):
err_msg = ('Keys for the "{}" argument'
'have to be strings, got '
'{} instead.').format(prepost, type(key))
raise TypeError(err_msg)
self._add_updater(value, prepost, objname=key)
# If we have a pathway called "pre" (the most common use case), provide
# direct access to its delay via a delay attribute (instead of having
# to use pre.delay)
if 'pre' in self._updaters:
self.variables['delay'] = self.pre.variables['delay']
if delay is not None:
if isinstance(delay, Quantity):
if not 'pre' in self._updaters:
raise ValueError(
('Cannot set delay, no "pre" pathway exists.'
'Use a dictionary if you want to set the '
'delay for a pathway with a different name.'))
delay = {'pre': delay}
if not isinstance(delay, collections.Mapping):
raise TypeError('Delay argument has to be a quantity or a '
'dictionary, is type %s instead.' %
type(delay))
for pathway, pathway_delay in delay.iteritems():
if not pathway in self._updaters:
raise ValueError(('Cannot set the delay for pathway '
'"%s": unknown pathway.') % pathway)
if not isinstance(pathway_delay, Quantity):
raise TypeError(('Cannot set the delay for pathway "%s": '
'expected a quantity, got %s instead.') %
(pathway, type(pathway_delay)))
if pathway_delay.size != 1:
raise TypeError(('Cannot set the delay for pathway "%s": '
'expected a scalar quantity, got a '
'quantity with shape %s instead.') %
str(pathway_delay.shape))
fail_for_dimension_mismatch(pathway_delay, second,
('Delay has to be '
'specified in units '
'of seconds'))
updater = getattr(self, pathway)
self.item_mapping.unregister_variable(updater._delays)
del updater._delays
# For simplicity, store the delay as a one-element array
# so that for example updater._delays[:] works.
updater._delays = np.array([float(pathway_delay)])
variable = ArrayVariable('delay',
second,
updater._delays,
group_name=self.name,
scalar=True)
updater.variables['delay'] = variable
if pathway == 'pre':
self.variables['delay'] = variable
#: Performs numerical integration step
self.state_updater = StateUpdater(self, method)
self.contained_objects.append(self.state_updater)
#: "Lumped variable" mechanism -- sum over all synapses of a
#: postsynaptic target
self.lumped_updaters = {}
for single_equation in self.equations.itervalues():
if 'lumped' in single_equation.flags:
varname = single_equation.varname
# For a lumped variable, we need an equivalent parameter in the
# target group
if not varname in self.target.variables:
raise ValueError(
('The lumped variable %s needs a variable '
'of the same name in the target '
'group ') % single_equation.varname)
fail_for_dimension_mismatch(self.variables[varname].unit,
self.target.variables[varname],
('Lumped variables need to have '
'the same units in Synapses '
'and the target group'))
# TODO: Add some more stringent check about the type of
# variable in the target group
updater = LumpedUpdater(varname, self, self.target)
self.lumped_updaters[varname] = updater
self.contained_objects.append(updater)
# Do an initial connect, if requested
if not isinstance(connect, (bool, basestring)):
raise TypeError(
('"connect" keyword has to be a boolean value or a '
'string, is type %s instead.' % type(connect)))
self._initial_connect = connect
if not connect is False:
self.connect(connect, level=1)
# Activate name attribute access
Group.__init__(self)