Library models are defined using the `MembraneEquation` class. This is a subclass of
`Equations` which is defined by a capacitance C and a sum of currents. The following instruction:

```
eqs=MembraneEquation(200*pF)
```

defines the equation C*dvm/dt=0*amp, with the membrane capacitance C=200 pF. The name of the membrane potential variable can be changed as follows:

```
eqs=MembraneEquation(200*pF,vm='V')
```

The main interest of this class is that one can use it to build models by adding currents to a membrane
equation. The `Current` class is a subclass of `Equations` which defines a current to be added
to a membrane equation. For example:

```
eqs=MembraneEquation(200*pF)+Current('I=(V0-vm)/R : amp',current_name='I')
```

defines the same equation as:

```
eqs=Equations('''
dvm/dt=I/(200*pF) : volt
I=(V0-vm)/R : amp
''')
```

The keyword `current_name` is optional if there is no ambiguity, i.e., if there is only one variable
or only one variable with amp units. As for standard equations, `Current` objects can be initialised with
a multiline string (several equations). By default, the convention for the current direction is the one for injected
current. For the ionic current convention, use the `IonicCurrent` class:

```
eqs=MembraneEquation(200*pF)+IonicCurrent('I=(vm-V0)/R : amp')
```

Compartmental neuron models can be created by merging several `MembraneEquation` objects,
with the `compartments` module. If `soma` and `dendrite` are two compartments defined as
`MembraneEquation` objects, then a neuron with those 2 compartments can be created as follows:

```
neuron_eqs=Compartments({'soma':soma,'dendrite':dendrite})
neuron_eqs.connect('soma','dendrite',Ra)
neuron=NeuronGroup(1,model=neuron_eqs)
```

The `Compartments` object is initialised with a dictionary of `MembraneEquation` objects.
The returned object `neuron_eqs` is also a `MembraneEquation` object, where the name of
each compartment has been appended to variable names (with a leading underscore).
For example, `neuron.vm_soma` refers to variable `vm` of the somatic compartment.
The `connect` method adds a coupling current between the two named compartments, with the given
resistance `Ra`.

A few standard Integrate-and-Fire models are implemented in the `IF` library module:

```
from brian.library.IF import *
```

All these functions return `Equations` objects (more precisely, `MembraneEquation` objects).

Leaky integrate-and-fire model (

`dvm/dt=(El-vm)/tau : volt`):eqs=leaky_IF(tau=10*ms,El=-70*mV)

Perfect integrator (

`dvm/dt=Im/tau : volt`):eqs=perfect_IF(tau=10*ms)

Quadratic integrate-and-fire model (

`C*dvm/dt=a*(vm-EL)*(vm-VT) : volt`):eqs=quadratic_IF(C=200*pF,a=10*nS/mV,EL=-70*mV,VT=-50*mV)

Exponential integrate-and-fire model (

`C*dvm/dt=gL*(EL-vm)+gL*DeltaT*exp((vm-VT)/DeltaT) :volt`):eqs=exp_IF(C=200*pF,gL=10*nS,EL=-70*mV,VT=-55*mV,DeltaT=3*mV)

In general, it is possible to define a neuron group with different parameter values for each neuron, by passing strings at initialisation. For example, the following code defines leaky integrate-and-fire models with heterogeneous resting potential values:

```
eqs=leaky_IF(tau=10*ms,El='V0')+Equations('V0:volt')
group=NeuronGroup(100,model=eqs,reset=0*mV,threshold=15*mV)
```

Integrate-and-fire models with two variables can display a very rich set of electrophysiological behaviours.
In Brian, two such models have been implemented: Izhikevich model and Brette-Gerstner adaptive exponential
integrate-and-fire model (also included in the `IF` module).
The equations are obtained in the same way as for one-dimensional models:

```
eqs=Izhikevich(a=0.02/ms,b=0.2/ms)
eqs=Brette_Gerstner(C=281*pF,gL=30*nS,EL=-70.6*mV,VT=-50.4*mV,DeltaT=2*mV,tauw=144*ms,a=4*nS)
eqs=aEIF(C=281*pF,gL=30*nS,EL=-70.6*mV,VT=-50.4*mV,DeltaT=2*mV,tauw=144*ms,a=4*nS) # equivalent
```

and two state variables are defined: `vm` (membrane potential) and `w` (adaptation variable).
The equivalent equations for Izhikevich model are:

```
dvm/dt=(0.04/ms/mV)*vm**2+(5/ms)*vm+140*mV/ms-w : volt
dw/dt=a*(b*vm-w) : volt/second
```

and for Brette-Gerstner model:

```
C*dvm/dt=gL*(EL-vm)+gL*DeltaT*exp((vm-VT)/DeltaT)-w :volt
dw/dt=(a*(vm-EL)-w)/tauw : amp
```

To simulate these models, one needs to specify a threshold value, and a good choice is
`VT+4*DeltaT`. The reset is particular in these models since it is bidimensional:
vm->Vr and w->w+b. A specific reset class has been implemented for this purpose:
`AdaptiveReset`, initialised with Vr and b. Thus, a typical construction of a group of
such models is:

```
eqs=Brette_Gerstner(C=281*pF,gL=30*nS,EL=-70.6*mV,VT=-50.4*mV,DeltaT=2*mV,tauw=144*ms,a=4*nS)
group=NeuronGroup(100,model=eqs,threshold=-43*mV,reset=AdaptiveReset(Vr=-70.6*mvolt,b=0.0805*nA))
```

A few simple synaptic models are implemented in the module `synapses`:

```
from brian.library.synapses import *
```

All the following functions need to be passed the name of the variable upon which the received spikes will act, and the name of the variable representing the current or conductance. The simplest one is the exponential synapse:

```
eqs=exp_synapse(input='x',tau=10*ms,unit=amp,output='x_current')
```

It is equivalent to:

```
eqs=Equations('''
dx/dt=-x/tau : amp
x_out=x
''')
```

Here, `x` is the variable which receives the spikes and `x_current` is the variable to be inserted in
the membrane equation (since it is a one-dimensional synaptic model, the variables are the same).
If the output variable name is not defined, then it will be automatically generated by adding the
suffix `_out` to the input name.

Two other types of synapses are implemented. The alpha synapse (`x(t)=alpha*(t/tau)*exp(1-t/tau)`, where
`alpha` is a normalising factor) is defined with the same syntax by:

```
eqs=alpha_synapse(input='x',tau=10*ms,unit=amp)
```

and the bi-exponential synapse is defined by (`x(t)=(tau2/(tau2-tau1))*(exp(-t/tau1)-exp(-t/tau2))`,
up to a normalising factor):

```
eqs=biexp_synapse(input='x',tau1=10*ms,tau2=5*ms,unit=amp)
```

For all types of synapses, the normalising factor is such that the maximum of x(t) is 1. These functions can be used as in the following example:

```
eqs=MembraneEquation(C=200*pF)+Current('I=gl*(El-vm)+ge*(Ee-vm):amp')
eqs+=alpha_synapse(input='ge_in',tau=10*ms,unit=siemens,output='ge')
```

where alpha conductances have been inserted in the membrane equation.

One can directly insert synaptic currents with the functions `exp_current`, `alpha_current`
and `biexp_current`:

```
eqs=MembraneEquation(C=200*pF)+Current('I=gl*(El-vm):amp')+\
alpha_current(input='ge',tau=10*ms)
```

(the units is amp by default), or synaptic conductances with the functions `exp_conductance`, `alpha_conductance`
and `biexp_conductance`:

```
eqs=MembraneEquation(C=200*pF)+Current('I=gl*(El-vm):amp')+\
alpha_conductance(input='ge',E=0*mV,tau=10*ms)
```

where `E` is the reversal potential.

A few standard ionic currents have implemented in the module `ionic_currents`:

```
from brian.library.ionic_currents import *
```

When the current name is not specified,
a unique name is generated automatically. Models can be constructed by adding currents to a
`MembraneEquation`.

Leak current (

`gl*(El-vm)`):current=leak_current(gl=10*nS,El=-70*mV,current_name='I')

Hodgkin-Huxley K+ current:

current=K_current_HH(gmax,EK,current_name='IK'):

Hodgkin-Huxley Na+ current:

current=Na_current_HH(gmax,ENa,current_name='INa'):