Rename the equations keyword argument to model (as in Brian 1)

brian2/groups/neurongroup.py

@@ -137,7 +137,7 @@ class NeuronGroup(BrianObject, Group, SpikeSource):
     ----------
     N : int
         Number of neurons in the group.
-    equations : (str, `Equations`)
+    model : (str, `Equations`)
         The differential equations defining the group
     method : (str, function), optional
         The numerical integration method. Either a string with the name of a
@@ -177,7 +177,7 @@ class NeuronGroup(BrianObject, Group, SpikeSource):
     attribute is set to 0 initially, but this can be modified using the
     attributes `state_updater`, `thresholder` and `resetter`.    
     '''
-    def __init__(self, N, equations, method=None,
+    def __init__(self, N, model, method=None,
                  threshold=None,
                  reset=None,
                  refractory=False,
@@ -196,22 +196,22 @@ def __init__(self, N, equations, method=None,
             raise ValueError("NeuronGroup size should be at least 1, was " + str(N))
 
         ##### Prepare and validate equations
-        if isinstance(equations, basestring):
-            equations = Equations(equations)
-        if not isinstance(equations, Equations):
-            raise TypeError(('equations has to be a string or an Equations '
-                             'object, is "%s" instead.') % type(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))
 
         # Check flags
-        equations.check_flags({DIFFERENTIAL_EQUATION: ('unless-refractory'),
-                               PARAMETER: ('constant')})
+        model.check_flags({DIFFERENTIAL_EQUATION: ('unless-refractory'),
+                           PARAMETER: ('constant')})
 
         # add refractoriness
-        equations = add_refractoriness(equations)
-        self.equations = equations
-        uses_refractoriness = len(equations) and any(['unless-refractory' in eq.flags
-                                                      for eq in equations.itervalues()
-                                                      if eq.type == DIFFERENTIAL_EQUATION])
+        model = add_refractoriness(model)
+        self.equations = model
+        uses_refractoriness = len(model) and any(['unless-refractory' in eq.flags
+                                                  for eq in model.itervalues()
+                                                  if eq.type == DIFFERENTIAL_EQUATION])
 
         logger.debug("Creating NeuronGroup of size {self.N}, "
                      "equations {self.equations}.".format(self=self))

brian2/synapses/synapses.py

@@ -533,7 +533,7 @@ class Synapses(BrianObject, Group):
     target : `Group`, optional
         The target of the spikes, typically a `NeuronGroup`. If none is given,
         the same as `source`
-    equations : {`str`, `Equations`}, optional
+    model : {`str`, `Equations`}, optional
         The model equations for the synapses.
     pre : {str, dict}, optional
         The code that will be executed after every pre-synaptic spike. Can be
@@ -582,7 +582,7 @@ class Synapses(BrianObject, Group):
         The name for this object. If none is given, a unique name of the form
         ``synapses``, ``synapses_1``, etc. will be automatically chosen.
     '''
-    def __init__(self, source, target=None, equations=None, pre=None, post=None,
+    def __init__(self, source, target=None, model=None, pre=None, post=None,
                  connect=False, delay=None, namespace=None, dtype=None,
                  language=None, clock=None, method=None, name='synapses*'):
 
@@ -600,25 +600,25 @@ def __init__(self, source, target=None, equations=None, pre=None, post=None,
             self.target = weakref.proxy(target)
 
         ##### Prepare and validate equations
-        if equations is None:
-            equations = ''
+        if model is None:
+            model = ''
 
-        if isinstance(equations, basestring):
-            equations = Equations(equations)
-        if not isinstance(equations, Equations):
-            raise TypeError(('equations has to be a string or an Equations '
-                             'object, is "%s" instead.') % type(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))
 
         # Check flags
-        equations.check_flags({DIFFERENTIAL_EQUATION: ['event-driven', 'lumped'],
-                               STATIC_EQUATION: ['lumped'],
-                               PARAMETER: ['constant', 'lumped']})
+        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 equations.itervalues():
+        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 '

brian2/tests/test_neurongroup.py

@@ -23,7 +23,7 @@ def test_creation():
     A basic test that creating a NeuronGroup works.
     '''
     for language in languages:
-        G = NeuronGroup(42, equations='dv/dt = -v/(10*ms) : 1', reset='v=0',
+        G = NeuronGroup(42, model='dv/dt = -v/(10*ms) : 1', reset='v=0',
                         threshold='v>1', language=language)
         assert len(G) == 42
 

examples/I-F_curve_Hodgkin_Huxley.py

@@ -38,7 +38,7 @@
 I : amp
 ''')
 # Threshold and refractoriness are only used for spike counting
-group = NeuronGroup(N, equations=eqs, threshold='is_active * (v > -40*mV)',
+group = NeuronGroup(N, model=eqs, threshold='is_active * (v > -40*mV)',
                     language=language)
 group.refractory = 1*ms
 group.v = El

examples/I-F_curve_LIF.py

@@ -14,7 +14,7 @@
 dv/dt=(v0-v)/tau : volt (unless-refractory)
 v0 : volt
 '''
-group = NeuronGroup(N, equations=eqs, threshold='v>10 * mV',
+group = NeuronGroup(N, model=eqs, threshold='v>10 * mV',
                     reset='v = 0 * mV', refractory=5*ms)
 group.v = 0 * mV
 group.v0 = linspace(0 * mV, 20 * mV, N)

examples/non_reliability.py

@@ -16,7 +16,7 @@
 eqs_neurons = '''
 dx/dt=(1.1-x)/tau+sigma*(2./tau)**.5*xi:1
 '''
-neurons = NeuronGroup(N, equations=eqs_neurons, threshold='x>1', reset='x=0')
+neurons = NeuronGroup(N, model=eqs_neurons, threshold='x>1', reset='x=0')
 neurons.refractory = 5*ms
 spikes = SpikeMonitor(neurons)
 

examples/phase_locking.py

@@ -14,7 +14,7 @@
 dv/dt=(-v+a*sin(2*pi*freq*t)+b)/tau : 1
 a : 1
 '''
-neurons = NeuronGroup(N, equations=eqs, threshold='v>1', reset='v=0')
+neurons = NeuronGroup(N, model=eqs, threshold='v>1', reset='v=0')
 neurons.v = rand(N)
 neurons.a = linspace(.05, 0.75, N)
 S = SpikeMonitor(neurons)