Installing Anaconda¶

Download the Anaconda distribution for your Operating System. For Windows users that want to use Python 3.x, we strongly recommend installing the 32 Bit version even on 64 Bit systems, since setting the compilation environment (see Requirements for C++ code generation below) is less complicated in that case. Note that the choice between Python 2.7 and Python 3.x is not very important at this stage, Anaconda allows you to create a Python 3 environment from Python 2 Anaconda and vice versa.

After the installation, make sure that your environment is configured to use the Anaconda distribution. You should have access to the conda command in a terminal and running python (e.g. from your IDE) should show a header like this, indicating that you are using Anaconda’s Python interpreter:

Python 2.7.10 |Anaconda 2.3.0 (64-bit)| (default, May 28 2015, 17:02:03)
[GCC 4.4.7 20120313 (Red Hat 4.4.7-1)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
Anaconda is brought to you by Continuum Analytics.
Please check out: http://continuum.io/thanks and https://binstar.org

Here’s some documentation on how to set up some popular IDEs for Anaconda: https://docs.continuum.io/anaconda/ide_integration

Installing Brian 2¶

You can either install Brian 2 in the Anaconda root environment, or create a new environment for Brian 2 (http://conda.pydata.org/docs/using/envs.html). The latter has the advantage that you can update (or not update) the dependencies of Brian 2 independently from the rest of your system.

Since Brian 2 is not part of the main Anaconda distribution, you have to install it from the brian-team channel. To do so, use:

conda install -c brian-team brian2

You can also permanently add the channel to your list of channels:

conda config --add channels brian-team

This has only to be done once. After that, you can install and update the brian2 packages as any other Anaconda package:

conda install brian2

Installing other useful packages¶

There are various packages that are useful but not necessary for working with Brian. These include: matplotlib (for plotting), nose (for running the test suite), ipython and jupyter-notebook (for an interactive console). To install them from anaconda, simply do:

conda install matplotlib nose ipython jupyter-notebook

You should also have a look at the brian2tools package, which contains several useful functions to visualize Brian 2 simulations and recordings. You can install it with pip or anaconda, in the same way as Brian 2 itself, e.g. with:

conda install -c brian-team brian2tools

Linux and OS X¶

On Linux and Mac OS X, you will most likely already have a working C++ compiler installed (try calling g++ --version in a terminal). If not, use your distribution’s package manager to install a g++ package.

Windows¶

On Windows, the necessary steps to get Runtime code generation (i.e. Cython/weave) to work depend on the Python version you are using:

Python 2.7

• Download and install the Microsoft Visual C++ Compiler for Python 2.7

This should be all you need.

Python 3.4

• Download and install the Microsoft .NET Framework 4
• Download and install the Microsoft Windows SDK for Windows 7 and .NET Framework 4

For 64 Bit Windows with Python 3.4, you have to additionally set up your environment correctly every time you run your Brian script (this is why we recommend against using this combination on Windows). To do this, run the following commands (assuming the default installation path) at the CMD prompt, or put them in a batch file:

setlocal EnableDelayedExpansion
CALL "C:\Program Files\Microsoft SDKs\Windows\v7.1\Bin\SetEnv.cmd" /x64 /release
set DISTUTILS_USE_SDK=1

Python 3.5

• Download and install Visual Studio Community 2015. Do not chose the default install but instead customize it, the only necessary option is “Programming Languages / Visual C++ / Common Tools for Visual C++ 2015”

For Standalone code generation, you can either use the compiler installed above or any other version of Visual Studio – in this case, the Python version does not matter.

Try running the test suite (see Testing Brian below) after the installation to make sure everything is working as expected.

Major new features¶

• Much more flexible model definitions. The behaviour of all model elements can now be defined by arbitrary equations specified in standard mathematical notation.
• Code generation as standard. Behind the scenes, Brian automatically generates and compiles C++ code to simulate your model, making it much faster.
• “Standalone mode”. In this mode, Brian generates a complete C++ project tree that implements your model. This can be then be compiled and run entirely independently of Brian. This leads to both highly efficient code, as well as making it much easier to run simulations on non-standard computational hardware, for example on robotics platforms.
• Multicompartmental modelling.
• Python 2 and 3 support.

New features¶

• Installation should now be much easier, especially if using the Anaconda Python distribution. See Installation.
• Many improvements to Synapses which replaces the old Connection object in Brian 1. This includes: synapses that are triggered by non-spike events; synapses that target other synapses; huge speed improvements thanks to using code generation; new “generator syntax” when creating synapses is much more flexible and efficient. See Synapses.
• New model definitions allow for much more flexible refractoriness. See Refractoriness.
• SpikeMonitor and StateMonitor are now much more flexible, and cover a lot of what used to be covered by things like MultiStateMonitor, etc. See Recording during a simulation.
• Multiple event types. In addition to the default spike event, you can create arbitrary events, and have these trigger code blocks (like reset) or synaptic events. See Custom events.
• New units system allows arrays to have units. This eliminates the need for a lot of the special casing that was required in Brian 1. See Physical units.
• Indexing variable by condition, e.g. you might write G.v['x>0'] to return all values of variable v in NeuronGroup G where the group’s variable x>0. See State variables.
• Correct numerical integration of stochastic differential equations. See Numerical integration.
• “Magic” run() system has been greatly simplified and is now much more transparent. In addition, if there is any ambiguity about what the user wants to run, an erorr will be raised rather than making a guess. This makes it much safer. In addition, there is now a store()/restore() mechanism that simplifies restarting simulations and managing separate training/testing runs. See Running a simulation.
• Changing an external variable between runs now works as expected, i.e. something like tau=1*ms; run(100*ms); tau=5*ms; run(100*ms). In Brian 1 this would have used tau=1*ms for both runs. More generally, in Brian 2 there is now better control over namespaces. See Namespaces.
• New “shared” variables with a single value shared between all neurons. See Shared variables.
• New Group.run_regularly() method for a codegen-compatible way of doing things that used to be done with network_operation() (which can still be used). See Regular operations.
• New system for handling externally defined functions. They have to specify which units they accept in their arguments, and what they return. In addition, you can easily specify the implementation of user-defined functions in different languages for code generation. See Functions.
• State variables can now be defined as integer or boolean values. See Equations.
• State variables can now be exported directly to Pandas data frame. See Storing state variables.
• New generalised “flags” system for giving additional information when defining models. See Flags.
• TimedArray now allows for 2D arrays with arbitrary indexing. See Timed arrays.
• Better support for using Brian in IPython/Jupyter. See, for example, start_scope().
• New preferences system. See Preferences.
• Random number generation can now be made reliably reproducible. See Random numbers.
• New profiling option to see which parts of your simulation are taking the longest to run. See Profiling.
• New logging system allows for more precise control. See Logging.
• New ways of importing Brian for advanced Python users. See Importing Brian.
• Improved control over the order in which objects are updated during a run. See Scheduling and custom progress reporting.
• Users can now easily define their own numerical integration methods. See State update.
• Support for parallel processing using the OpenMP version of standalone mode. Note that all Brian tests pass with this, but it is still considered to be experimental. See Multi-threading with OpenMP.

Backwards incompatible changes¶

See Detailed Brian 1 to Brian 2 conversion notes.

Behind the scenes changes¶

• All user models are now passed through the code generation system. This allows us to be much more flexible about introducing new target languages for generated code to make use of non-standard computational hardware. See Code generation.
• New standalone/device mode allows generation of a complete project tree that can be compiled and built independently of Brian and Python. This allows for even more flexible use of Brian on non-standard hardware. See Devices.
• All objects now have a unique name, used in code generation. This can also be used to access the object through the Network object.

Contributions¶

Full list of all Brian 2 contributors, ordered by the time of their first contribution:

• Dan Goodman (@thesamovar)
• Marcel Stimberg (@mstimberg)
• Romain Brette (@romainbrette)
• Cyrille Rossant (@rossant)
• Victor Benichoux (@victorbenichoux)
• Pierre Yger (@yger)
• Werner Beroux (@wernight)
• Konrad Wartke (@Kwartke)
• Daniel Bliss (@dabliss)
• Jan-Hendrik Schleimer (@ttxtea)
• Moritz Augustin (@moritzaugustin)
• Romain Cazé (@rcaze)
• Dominik Krzemiński (@dokato)
• Martino Sorbaro (@martinosorb)
• Benjamin Evans (@bdevans)

New features¶

• A new flag constant over dt can be applied to subexpressions to have them only evaluated once per timestep (see Models and neuron groups). This flag is mandatory for stateful subexpressions, e.g. expressions using rand() or randn(). (#720, #721)

Improvements and bug fixes¶

• Fix EventMonitor.values() and SpikeMonitor.spike_trains() to always return sorted spike/event times (#725).
• Respect the active attribute in C++ standalone mode (#718).
• More consistent check of compatible time and dt values (#730).
• Attempting to set a synaptic variable or to start a simulation with synapses without any preceding connect call now raises an error (#737).
• Improve the performance of coordinate calculation for Morphology objects, which previously made plotting very slow for complex morphologies (#741).
• Fix a bug in SpatialNeuron where it did not detect non-linear dependencies on v, introduced via point currents (#743).

Infrastructure and documentation improvements¶

• An interactive demo, tutorials, and examples can now be run in an interactive jupyter notebook on the mybinder platform, without any need for a local Brian installation (#736). Thanks to Ben Evans for the idea and help with the implementation.
• A new extensive guide for converting Brian 1 simulations to Brian 2 user coming from Brian 1: Changes for Brian 1 users
• A re-organized User’s guide, with clearer indications which information is important for new Brian users.

Contributions¶

Code and documentation contributions (ordered by the number of commits):

• Marcel Stimberg (@mstimberg)
• Dan Goodman (@thesamovar)
• Benjamin Evans (@bdevans)

Testing, suggestions and bug reports (ordered alphabetically, apologies to anyone we forgot...):

• Chaofei Hong
• Daniel Bliss
• Jacopo Bono
• Ruben Tikidji-Hamburyan

New features¶

• Brian now comes with its own seed() function, allowing to seed the random number generator and thereby to make simulations reproducible. This function works for all code generation targets and in runtime and standalone mode. See Random numbers for details.
• Brian can now export/import state variables of a group or a full network to/from a pandas DataFrame and comes with a mechanism to extend this to other formats. Thanks to Dominik Krzemiński for this contribution (see #306).

Improvements and bug fixes¶

• Use a Mersenne-Twister pseudorandom number generator in C++ standalone mode, replacing the previously used low-quality random number generator from the C standard library (see #222, #671 and #706).
• Fix a memory leak in code running with the weave code generation target, and a smaller memory leak related to units stored repetitively in the UnitRegistry.
• Fix a difference of one timestep in the number of simulated timesteps between runtime and standalone that could arise for very specific values of dt and t (see #695).
• Fix standalone compilation failures with the most recent gcc version which defaults to C++14 mode (see #701)
• Fix incorrect summation in synapses when using the (summed) flag and writing to pre-synaptic variables (see #704)
• Make synaptic pathways work when connecting groups that define nested subexpressions, instead of failing with a cryptic error message (see #707).

Contributions¶

Code and documentation contributions (ordered by the number of commits):

• Marcel Stimberg (@mstimberg)
• Dominik Krzemiński (@dokato)
• Dan Goodman (@thesamovar)
• Martino Sorbaro (@martinosorb)

Testing, suggestions and bug reports (ordered alphabetically, apologies to anyone we forgot...):

• Craig Henriquez
• Daniel Bliss
• David Higgins
• Gordon Erlebacher
• Max Gillett
• Moritz Augustin
• Sami Abdul-Wahid

Improvements and bug fixes¶

• Fix a regression from 2.0b4: stochastic differential equations without any non-stochastic part (e.g. dx/dt = xi/sqrt(ms)`) were not integrated correctly (see #686).
• Repeatedly calling restore() (or Network.restore()) no longer raises an error (see #681).
• Fix an issue that made PoissonInput refuse to run after a change of dt (see #684).
• If the rates argument of PoissonGroup is a string, it will now be evaluated at every time step instead of once at construction time. This makes time-dependent rate expressions work as expected (see #660).

Contributions¶

Code and documentation contributions (ordered by the number of commits):

• Marcel Stimberg (@mstimberg)

Testing, suggestions and bug reports (ordered alphabetically, apologies to anyone we forgot...):

• Cian O’Donnell
• Daniel Bliss
• Ibrahim Ozturk
• Olivia Gozel

Major new features¶

• New “generator syntax” to efficiently generate synapses (e.g. one-to-one connections), see Creating synapses for more details.
• For synaptic connections with multiple synapses between a pair of neurons, the number of the synapse can now be stored in a variable, allowing its use in expressions and statements (see Creating synapses).
• Synapses can now target other Synapses objects, useful for some models of synaptic modulation.
• The Morphology object has been completely re-worked and several issues have been fixed. The new Section object allows to model a section as a series of truncated cones (see Creating a neuron morphology).
• Scripts with a single run() call, no longer need an explicit device.build() call to run with the C++ standalone device. A set_device() in the beginning is enough and will trigger the build call after the run (see Standalone code generation).
• All state variables within a Network can now be accessed by Network.get_states() and Network.set_states() and the store()/restore() mechanism can now store the full state of a simulation to disk.
• Stochastic differential equations with multiplicative noise can now be integrated using the Euler-Heun method (heun). Thanks to Jan-Hendrik Schleimer for this contribution.
• Error messages have been significantly improved: errors for unit mismatches are now much clearer and error messages triggered during the intialization phase point back to the line of code where the relevant object (e.g. a NeuronGroup) was created.
• PopulationRateMonitor now provides a smooth_rate method for a filtered version of the stored rates.

Improvements and bug fixes¶

• In addition to the new synapse creation syntax, sparse probabilistic connections are now created much faster.
• The time for the initialization phase at the beginning of a run() has been significantly reduced.
• Multicompartmental simulations with a large number of compartments are now simulated more efficiently and are making better use of several processor cores when OpenMP is activated in C++ standalone mode. Thanks to Moritz Augustin for this contribution.
• Simulations will use compiler settings that optimize performance by default.
• Objects that have user-specified names are better supported for complex simulation scenarios (names no longer have to be unique at all times, but only across a network or across a standalone device).
• Various fixes for compatibility with recent versions of numpy and sympy

Important backwards-incompatible changes¶

• The argument names in Synapses.connect() have changed and the first argument can no longer be an array of indices. To connect based on indices, use Synapses.connect(i=source_indices, j=target_indices). See Creating synapses and the documentation of Synapses.connect() for more details.
• The actions triggered by pre-synaptic and post-synaptic spikes are now described by the on_pre and on_post keyword arguments (instead of pre and post).
• The Morphology object no longer allows to change attributes such as length and diameter after its creation. Complex morphologies should instead be created using the Section class, allowing for the specification of all details.
• Morphology objects that are defined with coordinates need to provide the start point (relative to the end point of the parent compartment) as the first coordinate. See Creating a neuron morphology for more details.
• For simulations using the C++ standalone mode, no longer call Device.build (if using a single run() call), or use set_device() with build_on_run=False (see Standalone code generation).

Infrastructure improvements¶

• Our test suite is now also run on Mac OS-X (on the Travis CI platform).

Contributions¶

Code and documentation contributions (ordered by the number of commits):

• Marcel Stimberg (@mstimberg)
• Dan Goodman (@thesamovar)
• Moritz Augustin (@moritzaugustin)
• Jan-Hendrik Schleimer (@ttxtea)
• Romain Cazé (@rcaze)
• Konrad Wartke (@Kwartke)
• Romain Brette (@romainbrette)

Testing, suggestions and bug reports (ordered alphabetically, apologies to anyone we forgot...):

• Chaofei Hong
• Kees de Leeuw
• Luke Y Prince
• Myung Seok Shim
• Owen Mackwood
• Github users: @epaxon, @flinz, @mariomulansky, @martinosorb, @neuralyzer, @oleskiw, @prcastro, @sudoankit

Major new features¶

• In addition to the standard threshold/reset, groups can now define “custom events”. These can be recorded with the new EventMonitor (a generalization of SpikeMonitor) and Synapses can connect to these events instead of the standard spike event. See Custom events for more details.
• SpikeMonitor and EventMonitor can now also record state variable values at the time of spikes (or custom events), thereby offering the functionality of StateSpikeMonitor from Brian 1. See Recording variables at spike time for more details.
• The code generation modes that interact with C++ code (weave, Cython, and C++ standalone) can now be more easily configured to work with external libraries (compiler and linker options, header files, etc.). See the documentation of the cpp_prefs module for more details.

Improvemements and bug fixes¶

• Cython simulations no longer interfere with each other when run in parallel (thanks to Daniel Bliss for reporting and fixing this).
• The C++ standalone now works with scalar delays and the spike queue implementation deals more efficiently with them in general.
• Dynamic arrays are now resized more efficiently, leading to faster monitors in runtime mode.
• The spikes generated by a SpikeGeneratorGroup can now be changed between runs using the set_spikes method.
• Multi-step state updaters now work correctly for non-autonomous differential equations
• PoissonInput now correctly works with multiple clocks (thanks to Daniel Bliss for reporting and fixing this)
• The get_states method now works for StateMonitor. This method provides a convenient way to access all the data stored in the monitor, e.g. in order to store it on disk.
• C++ compilation is now easier to get to work under Windows, see Installation for details.

Important backwards-incompatible changes¶

• The custom_operation method has been renamed to run_regularly and can now be called without the need for storing its return value.
• StateMonitor will now by default record at the beginning of a time step instead of at the end. See Recording variables continuously for details.
• Scalar quantities now behave as python scalars with respect to in-place modifications (augmented assignments). This means that x = 3*mV; y = x; y += 1*mV will no longer increase the value of the variable x as well.

Infrastructure improvements¶

• We now provide conda packages for Brian 2, making it very easy to install when using the Anaconda distribution (see Installation).

Contributions¶

Code and documentation contributions (ordered by the number of commits):

• Marcel Stimberg (@mstimberg)
• Dan Goodman (@thesamovar)
• Daniel Bliss (@dabliss)
• Romain Brette (@romainbrette)

Testing, suggestions and bug reports (ordered alphabetically, apologies to everyone we forgot...):

• Daniel Bliss
• Damien Drix
• Rainer Engelken
• Beatriz Herrera Figueredo
• Owen Mackwood
• Augustine Tan
• Ot de Wiljes

Major new features¶

• A new PoissonInput class for efficient simulation of Poisson-distributed input events.

Improvements¶

• The order of execution for pre and post statements happending in the same time step was not well defined (it fell back to the default alphabetical ordering, executing post before pre). It now explicitly specifies the order attribute so that pre gets executed before post (as in Brian 1). See the Synapses documentation for details.
• The default schedule that is used can now be set via a preference (core.network.default_schedule). New automatically generated scheduling slots relative to the explicitly defined ones can be used, e.g. before_resets or after_synapses. See Scheduling for details.
• The scipy package is no longer a dependency (note that weave for compiled C code under Python 2 is now available in a separate package). Note that multicompartmental models will still benefit from the scipy package if they are simulated in pure Python (i.e. with the numpy code generation target) – otherwise Brian 2 will fall back to a numpy-only solution which is significantly slower.

Important bug fixes¶

• Fix SpikeGeneratorGroup which did not emit all the spikes under certain conditions for some code generation targets (#429)
• Fix an incorrect update of pre-synaptic variables in synaptic statements for the numpy code generation target (#435).
• Fix the possibility of an incorrect memory access when recording a subgroup with SpikeMonitor (#454).
• Fix the storing of results on disk for C++ standalone on Windows – variables that had the same name when ignoring case (e.g. i and I) where overwriting each other (#455).

Infrastructure improvements¶

• Brian 2 now has a chat room on gitter: https://gitter.im/brian-team/brian2
• The sphinx documentation can now be built from the release archive file
• After a big cleanup, all files in the repository have now simple LF line endings (see https://help.github.com/articles/dealing-with-line-endings/ on how to configure your own machine properly if you want to contribute to Brian).

Contributions¶

Code and documentation contributions (ordered by the number of commits):

• Marcel Stimberg (@mstimberg)
• Dan Goodman (@thesamovar)
• Konrad Wartke (@kwartke)

Testing, suggestions and bug reports (ordered alphabetically, apologies to everyone we forgot...):

• Daniel Bliss
• Owen Mackwood
• Ankur Sinha
• Richard Tomsett

Major new features¶

• Multi-compartmental simulations can now be run using the Standalone code generation mode (this is not yet well-tested, though).
• The implementation of TimedArray now supports two-dimensional arrays, i.e. different input per neuron (or synapse, etc.), see Timed arrays for details.
• Previously, not setting a code generation target (using the codegen.target preference) would mean that the numpy target was used. Now, the default target is auto, which means that a compiled language (weave or cython) will be used if possible. See Computational methods and efficiency for details.
• The implementation of SpikeGeneratorGroup has been improved and it now supports a period argument to repeatedly generate a spike pattern.

Improvements¶

• The selection of a numerical algorithm (if none has been specified by the user) has been simplified. See Numerical integration for details.
• Expressions that are shared among neurons/synapses are now updated only once instead of for every neuron/synapse which can lead to performance improvements.
• On Windows, The Microsoft Visual C compiler is now supported in the cpp_standalone mode, see the respective notes in the Installation and Computational methods and efficiency documents.
• Simulation runs (using the standard “runtime” device) now collect profiling information. See Profiling for details.

Infrastructure and documentation improvements¶

• Tutorials for beginners in the form of ipython notebooks (currently only covering the basics of neurons and synapses) are now available.
• The Examples in the documentation now include the images they generated. Several examples have been adapted from Brian 1.
• The code is now automatically tested on Windows machines, using the appveyor service. This complements the Linux testing on travis.
• Using a version of a dependency (e.g. sympy) that we don’t support will now raise an error when you import brian2 – see Dependency checks for more details.
• Test coverage for the cpp_standalone mode has been significantly increased.

Important bug fixes¶

• The preparation time for complicated equations has been significantly reduced.
• The string representation of small physical quantities has been corrected (#361)
• Linking variables from a group of size 1 now works correctly (#383)

Contributions¶

Code and documentation contributions (ordered by the number of commits):

• Marcel Stimberg (@mstimberg)
• Dan Goodman (@thesamovar)
• Romain Brette (@romainbrette)
• Pierre Yger (@yger)

Testing, suggestions and bug reports (ordered alphabetically, apologies to everyone we forgot...):

• Conor Cox
• Gordon Erlebacher
• Konstantin Mergenthaler

Major new features¶

• New classes Morphology and SpatialNeuron for the simulation of Multicompartment models
• A temporary “bridge” for brian.hears that allows to use its Brian 1 version from Brian 2 (Brian Hears)
• Cython is now a new code generation target, therefore the performance benefits of compiled code are now also available to users running simulations under Python 3.x (where scipy.weave is not available)
• Networks can now store their current state and return to it at a later time, e.g. for simulating multiple trials starting from a fixed network state (Continuing/repeating simulations)
• C++ standalone mode: multiple processors are now supported via OpenMP (Multi-threading with OpenMP), although this code has not yet been well tested so may be inaccurate.
• C++ standalone mode: after a run, state variables and monitored values can be loaded from disk transparently. Most scripts therefore only need two additional lines to use standalone mode instead of Brian’s default runtime mode (Standalone code generation).

Syntax changes¶

• The syntax and semantics of everything around simulation time steps, clocks, and multiple runs have been cleaned up, making reinit obsolete and also making it unnecessary for most users to explicitly generate Clock objects – instead, a dt keyword can be specified for objects such as NeuronGroup (Running a simulation)
• The scalar flag for parameters/subexpressions has been renamed to shared
• The “unit” for boolean variables has been renamed from bool to boolean
• C++ standalone: several keywords of CPPStandaloneDevice.build have been renamed
• The preferences are now accessible via prefs instead of brian_prefs
• The runner method has been renamed to custom_operation

Improvements¶

• Variables can now be linked across NeuronGroups (Linked variables)
• More flexible progress reporting system, progress reporting also works in the C++ standalone mode (Progress reporting)
• State variables can be declared as integer (Equation strings)

Bug fixes¶

57 github issues have been closed since the alpha release, of which 26 had been labeled as bugs. We recommend all users of Brian 2 to upgrade.

Contributions¶

Code and documentation contributions (ordered by the number of commits):

• Marcel Stimberg (@mstimberg)
• Dan Goodman (@thesamovar)
• Romain Brette (@romainbrette)
• Pierre Yger (@yger)
• Werner Beroux (@wernight)

Testing, suggestions and bug reports (ordered alphabetically, apologies to everyone we forgot…):

• Guillaume Bellec
• Victor Benichoux
• Laureline Logiaco
• Konstantin Mergenthaler
• Maurizio De Pitta
• Jan-Hendrick Schleimer
• Douglas Sterling
• Katharina Wilmes

List of detailed instructions¶

group = NeuronGroup(N, 'dv/dt = -v / tau : volt',
                    threshold=-50*mV,
                    reset=-70*mV)

group = NeuronGroup(N, 'dv/dt = -v / tau : volt',
                    threshold='v > -50*mV',
                    reset='v = -70*mV')

group = NeuronGroup(N, 'dv/dt = -v / tau : volt',
                    threshold=Threshold(-50*mV, state='v'),
                    reset=Reset(-70*mV, state='w'))

group = NeuronGroup(N, 'dv/dt = -v / tau : volt',
                    threshold='v > -50*mV',
                    reset='v = -70*mV')

group = NeuronGroup(N, '''dv/dt = -v / tau : volt
                          dvt/dt = -vt / tau : volt
                          vr : volt''',
                    threshold=VariableThreshold(state='v',
                                                threshold_state='vt'),
                    reset=VariableThreshold(state='v',
                                            resetvaluestate='vr'))

group = NeuronGroup(N, '''dv/dt = -v / tau : volt
                          dvt/dt = -vt / tau : volt
                          vr : volt''',
                    threshold='v > vt',
                    reset='v = vr')

group = NeuronGroup(N, 'rate : Hz',
                    threshold=PoissonThreshold(state='rate'))

group = NeuronGroup(N, 'rate : Hz',
                    threshold='rand()<rate*dt')

def myreset(P,spikes):
    P.v_[spikes] = -70*mV+rand(len(spikes))*5*mV

group = NeuronGroup(N, 'dv/dt = -v / tau : volt',
                    threshold=-50*mV,
                    reset=myreset)

group = NeuronGroup(N, 'dv/dt = -v / tau : volt',
                    threshold='v > -50*mV',
                    reset='-70*mV + rand()*5*mV')

def mythreshold(v):
    return (v > -50*mV) & (rand(N) > 0.5)

group = NeuronGroup(N, 'dv/dt = -v / tau : volt',
                    threshold=SimpleFunThreshold(mythreshold,
                                                 state='v'),
                    reset=-70*mV)

group = NeuronGroup(N, 'dv/dt = -v / tau : volt',
                    threshold='v > -50*mV and rand() > 0.5',
                    reset='v = -70*mV')

def single_threshold(v):
    # Only let a single neuron spike
    crossed_threshold = np.nonzero(v > -50*mV)[0]
    should_spike = np.zeros(len(P), dtype=np.bool)
    if len(crossed_threshold):
        choose = np.random.randint(len(crossed_threshold))
        should_spike[crossed_threshold[choose]] = True
    return should_spike

def global_reset(P, spikes):
    # Reset everything
    if len(spikes):
        P.v_[:] = -70*mV

neurons = NeuronGroup(N, 'dv/dt = -v / tau : volt',
                      threshold=SimpleFunThreshold(single_threshold,
                                                   state='v'),
                      reset=global_reset)

@check_units(v=volt, result=bool)
def single_threshold(v):
    pass # ... (identical to Brian 1)

@check_units(spikes=1, result=1)
def global_reset(spikes):
    # Reset everything
    if len(spikes):
         neurons.v_[:] = -0.070

neurons = NeuronGroup(N, 'dv/dt = -v / tau : volt',
                      threshold='single_threshold(v)',
                      reset='dummy = global_reset(i)')
# Set the code generation target for threshold/reset only:
neuron.thresholder['spike'].codeobj_class = NumpyCodeObject
neuron.resetter['spike'].codeobj_class = NumpyCodeObject

group = NeuronGroup(N, 'dv/dt = (I - v)/tau : volt',
                    threshold=-50*mV,
                    reset=-70*mV,
                    refractory=3*ms)

group = NeuronGroup(N, 'dv/dt = (I - v)/tau : volt (unless refractory)',
                    threshold='v > -50*mV',
                    reset='v = -70*mV',
                    refractory=3*ms)

group = NeuronGroup(N,'''
                    dv/dt = (I_L - I_Na - I_K + I)/Cm : volt
                    ...''',
                    threshold=EmpiricalThreshold(threshold=20*mV,
                                                 refractory=1*ms,
                                                 state='v'))

group = NeuronGroup(N,'''
                    dv/dt = (I_L - I_Na - I_K + I)/Cm : volt
                    ...''',
                    threshold='v > -20*mV',
                    refractory=1*ms)

group = NeuronGroup(4000, ...)
group_exc = group.subgroup(3200)
group_inh = group.subgroup(800)

group = NeuronGroup(4000, ...)
group_exc = group[:3200]
group_inh = group[3200:]

group1 = NeuronGroup(N,
                     'dv/dt = -v / tau : volt')
group2 = NeuronGroup(N,
                     '''dv/dt = (-v + w) / tau : volt
                        w : volt''')
group2.w = linked_var(group1, 'v')

group1 = NeuronGroup(N,
                     'dv/dt = -v / tau : volt')
group2 = NeuronGroup(N,
                     '''dv/dt = (-v + w) / tau : volt
                        w : volt (linked)''')
group2.w = linked_var(group1, 'v')

conn = Connection(source, target, 'ge')

conn = Synapses(source, target, 'w : siemens',
                on_pre='ge += w')

conn1 = Connection(source, target, 'ge')
conn1[3, 5] = 3*nS

conn1 = Synapses(source, target, 'w: siemens',
                 on_pre='ge += w')
conn1.connect(i=3, j=5)
conn1.w[3, 5] = 3*nS  # (or conn1.w = 3*nS)

conn2 = Connection(source, target, 'ge')
conn2.connect_full(source, target, 5*nS)

conn2 = ... # see above
conn2.connect()
conn2.w = 5*nS

conn3 = Connection(source, target, 'ge')
conn3.connect_random(source, target,
                     sparseness=0.02,
                     weight=2*ns)

conn3 = ... # see above
conn3.connect(p=0.02)
conn3.w = 2*nS

conn4 = Connection(source, target, 'ge')
conn4.connect_one_to_one(source, target,
                         weight=4*nS)

conn4 = ... # see above
conn4.connect(j='i')
conn4.w = 4*nS

conn5 = IdentityConnection(source, target,
                           weight=3*nS)

conn5 = Synapses(source, target,
                 'w : siemens (shared)')
conn5.w = 3*nS

# len(source) == 20, len(target) == 30
conn6 = Connection(source, target, 'ge')
W = rand(20, 30)*nS
conn6.connect(source, target, weight=W)

# len(source) == 20, len(target) == 30
conn6 = Synapses(source, target, 'w: siemens',
                 on_pre='ge += w')
W = rand(20, 30)*nS
conn6.connect()
conn6.w = W.flatten()

conn7 = Connection(source, target, 'ge')
conn7.connect_full(source[:5], target[5:10], 5*nS)

conn7 = Synapses(source, target, 'w: siemens',
                 on_pre='ge += w')
conn7.connect('i < 5 and j >=5 and j <10')
# Alternative (more efficient):
# conn7.connect(j='k in range(5, 10) if i < 5')
conn7.w[source[:5], target[5:10]] = 5*nS

conn8 = Connection(source, target, 'ge')
conn8.connect_full(source, target,
                   weight=lambda i,j:(1+cos(i-j))*2*nS)

conn8 = Synapses(source, target, 'w: siemens',
                 on_pre='ge += w')
conn8.connect()
conn8.w = '(1 + cos(i - j))*2*nS'

conn9 = Connection(source, target, 'ge')
conn9.connect_random(source, target,
                     sparseness=0.02,
                     weight=lambda:rand()*nS)

conn9 = ... # see above
conn9.connect(p=0.02)
conn9.w = 'rand()*nS'

conn10 = Connection(source, target, 'ge')
conn10.connect_random(source, target,
                      sparseness=lambda i,j:exp(-abs(i-j)*.1),
                      weight=2*ns)

conn10 = ... # see above
conn10.connect(p='exp(-abs(i - j)*.1)')
conn10.w = 2*nS

conn11 = Connection(source, target, 'ge', delay=True,
                    max_delay=5*ms)
conn11.connect_full(source, target, weight=3*nS,
                    delay=(0*ms, 5*ms))

conn11 = Synapses(source, target, 'w : siemens',
                  on_pre='ge += w')
conn11.connect()
conn11.w = 3*nS
conn11.delay = 'rand()*5*ms'

conn12 = Connection(source, target, 'ge',
                    modulation='u')

conn12 = Synapses(source, target, 'w : siemens',
                  on_pre='ge += w * u_pre')

stdp_syn = Synapses(inputs, neurons, model='''
                    w:1
                    dApre/dt = -Apre/taupre : 1 (event-driven)
                    dApost/dt = -Apost/taupost : 1 (event-driven)''',
                    pre='''ge + =w
                           Apre += delta_Apre
                           w = clip(w + Apost, 0, gmax)''',
                    post='''Apost += delta_Apost
                            w = clip(w + Apre, 0, gmax)''')

stdp_syn = Synapses(inputs, neurons, model='''
                    w:1
                    dApre/dt = -Apre/taupre : 1 (event-driven)
                    dApost/dt = -Apost/taupost : 1 (event-driven)''',
                    on_pre='''ge + =w
                           Apre += delta_Apre
                           w = clip(w + Apost, 0, gmax)''',
                    on_post='''Apost += delta_Apost
                            w = clip(w + Apre, 0, gmax)''')

# a non-linear synapse (e.g. NMDA)
neurons = NeuronGroup(1, model='''
                      dv/dt = (gtot - v)/(10*ms) : 1
                      gtot : 1''')
syn = Synapses(inputs, neurons,
               model='''
               dg/dt = -a*g+b*x*(1-g) : 1
               dx/dt = -c*x : 1
               w : 1 # synaptic weight''',
               pre='x += w')
neurons.gtot=S.g

# a non-linear synapse (e.g. NMDA)
neurons = NeuronGroup(1, model='''
                      dv/dt = (gtot - v)/(10*ms) : 1
                      gtot : 1''')
syn = Synapses(inputs, neurons,
               model='''
               dg/dt = -a*g+b*x*(1-g) : 1
               dx/dt = -c*x : 1
               w : 1 # synaptic weight
               gtot_post = g : 1 (summed)''',
               on_pre='x += w')

syn = Synapses(...)
# single synapse
syn[3, 5] = True

syn = Synapses(...)
# single synapse
syn.connect(i=3, j=5)

# all-to-all connections
syn[:, :] = True

# all-to-all connections
syn.connect()

# all to neuron number 1
syn[:, 1] = True

# all to neuron number 1
syn.connect(j='1')

# multiple synapses
syn[4, 7] = 3

# multiple synapses
syn.connect(i=4, j=7, n=3)

# connection probability 2%
syn[:, :] = 0.02

# connection probability 2%
syn.connect(p=0.02)

S = Synapses(...,
             pre=('ge + =w',
                  '''w = clip(w + Apost, 0, inf)
                     Apre += delta_Apre'''),
             post='''Apost += delta_Apost
                     w = clip(w + Apre, 0, inf)''')

S[:, :] = True
S.delay[1][:, :] = 3*ms # delayed trace

S = Synapses(...,
             pre={'pre_transmission':
                  'ge += w',
                  'pre_plasticity':
                  '''w = clip(w + Apost, 0, inf)
                     Apre += delta_Apre'''},
             post='''Apost += delta_Apost
                     w = clip(w + Apre, 0, inf)''')

S.connect()
S.pre_plasticity.delay[:, :] = 3*ms # delayed trace

syn = Synapses(...)
# record all synapse targetting neuron 3
indices = syn.synapse_index((slice(None), 3))
mon = StateMonitor(S, 'w', record=indices)

syn = Synapses(...)
# record all synapse targetting neuron 3
mon = StateMonitor(S, 'w', record=S[:, 3])

rates = lambda t:(1+cos(2*pi*t*1*Hz))*10*Hz
group = PoissonGroup(100, rates=rates)

rates = '(1 + cos(2*pi*t*1*Hz)*10*Hz)'
group = PoissonGroup(100, rates=rates)

group = NeuronGroup(10,
                    'dv/dt = -v/(10*ms) : 1')
input = PoissonInput(group, N=1000, rate=1*Hz,
                     weight=0.1, state='v',
                     freeze=True)

group = NeuronGroup(10, '''dv/dt = -v / (10*ms) : 1
                           shared_input : 1 (shared)''')
poisson_input = BinomialFunction(n=1000, p=1*Hz*group.dt)
group.run_regularly('''shared_input = poisson_input()*0.1
                       v += shared_input''')

gen1 = SpikeGeneratorGroup(2, [(0, 0*ms), (1, 1*ms)])
gen2 = SpikeGeneratorGroup(2, [(array([0, 1]), 0*ms),
                               (array([0, 1]), 1*ms)]
gen3 = SpikeGeneratorGroup(2, (array([0, 1]),
                               array([0, 1])*ms))
gen4 = SpikeGeneratorGroup(2, array([[0, 0.0],
                                    [1, 0.001]])

gen1 = SpikeGeneratorGroup(2, [0, 1], [0, 1]*ms)
gen2 = SpikeGeneratorGroup(2, [0, 1, 0, 1],
                           [0, 0, 1, 1]*ms)
gen3 = SpikeGeneratorGroup(2, [0, 1], [0, 1]*ms)

gen4 = SpikeGeneratorGroup(2, [0, 1], [0, 1]*ms)

# same input for all neurons
eqs = '''
      dv/dt = (I - v)/tau : volt
      I : volt
      '''
group = NeuronGroup(1, model=eqs,
                    reset=0*mV, threshold=15*mV)
group.I = TimedArray(linspace(0*mV, 20*mV, 100),
                     dt=10*ms)

# same input for all neurons
I = TimedArray(linspace(0*mV, 20*mV, 100),
               dt=10*ms)
eqs = '''
      dv/dt = (I(t) - v)/tau : volt
      '''
group = NeuronGroup(1, model=eqs,
                    reset='v = 0*mV',
                    threshold='v > 15*mV')

# neuron-specific input
eqs = '''
      dv/dt = (I - v)/tau : volt
      I : volt
      '''
group = NeuronGroup(5, model=eqs,
                    reset=0*mV, threshold=15*mV)
values = (linspace(0*mV, 20*mV, 100)[:, None] *
          linspace(0, 1, 5))
group.I = TimedArray(values, dt=10*ms)

# neuron-specific input
values = (linspace(0*mV, 20*mV, 100)[:, None] *
          linspace(0, 1, 5))
I = TimedArray(values, dt=10*ms)
eqs = '''
      dv/dt = (I(t, i) - v)/tau : volt
      '''
group = NeuronGroup(5, model=eqs,
                    reset='v = 0*mV',
                    threshold='v > 15*mV')

mon = SpikeMonitor(group)
#... do the run
list_of_pairs = mon.spikes
index_list, time_list = zip(*list_of_pairs)
index_array = array(index_list)
time_array = array(time_list)
# time_array is unitless in Brian 1

mon = SpikeMonitor(group)
#... do the run
list_of_pairs = zip(*mon.it)
index_list = list(mon.i)
time_list = list(mon.t)
index_array, time_array = mon.i, mon.t
# time_array has units in Brian 2

# dictionary of spike times for each neuron:
spike_dict = mon.spiketimes
# all spikes for neuron 3:
spikes_3 = spike_dict[3] #  (no units)
spikes_3 = mon[3] #  alternative (no units)

# dictionary of spike times for each neuron:
spike_dict = mon.spike_trains()
# all spikes for neuron 3:
spikes_3 = spike_dict[3]  # with units

counter = SpikeCounter(group)
pop_counter = PopulationSpikeCounter(group)
#... do the run
# Number of spikes for neuron 3:
count_3 = counter[3]
# Total number of spikes:
total_spikes = pop_counter.nspikes

counter = SpikeMonitor(group, record=False)

#... do the run
# Number of spikes for neuron 3
count_3 = counter.count[3]
# Total number of spikes:
total_spikes = counter.num_spikes

mon = StateMonitor(group, 'v',
                   record=True)
# ... do the run
# plot the trace of neuron 3:
plot(mon.times/ms, mon[3]/mV)
# plot the traces of all neurons:
plot(mon.times/ms, mon.values.T/mV)

mon = StateMonitor(group, 'v',
                   record=True)
# ... do the run
# plot the trace of neuron 3:
plot(mon.t/ms, mon[3].v/mV)
# plot the traces of all neurons:
plot(mon.t/ms, mon.v.T/mV)

mon = MultiStateMonitor(group, ['v', 'w'],
                        record=True)
# ... do the run
# plot the traces of v and w for neuron 3:
plot(mon['v'].times/ms, mon['v'][3]/mV)
plot(mon['w'].times/ms, mon['w'][3]/mV)

mon = StateMonitor(group, ['v', 'w'],
                   record=True)
# ... do the run
# plot the traces of v and w for neuron 3:
plot(mon.t/ms, mon[3].v/mV)
plot(mon.t/ms, mon[3].w/mV)

# We assume that "group" has a varying threshold
mon = StateSpikeMonitor(group, 'v')
# ... do the run
# plot the mean v at spike time for each neuron
mean_values = [mean(mon.values('v', idx))
                for idx in range(len(group))]

plot(mean_values/mV, 'o')

# We assume that "group" has a varying threshold
mon = SpikeMonitor(group, variables='v')
# ... do the run
# plot the mean v at spike time for each neuron
values = mon.values('v')
mean_values = [mean(values[idx])
               for idx in range(len(group))]
plot(mean_values/mV, 'o')

group = ...
mon = ...
net = Network(group, mon)
net.run(1*ms)

reinit()
group = ...
mon = ...
net = Network(group, mon)
net.run(1*ms)

group = ...
mon = ...
net = Network(group, mon)
net.run(1*ms)

# new network starts at 0s
group = ...
mon = ...
net = Network(group, mon)
net.run(1*ms)

for r in range(100):
    reinit_default_clock()
    clear()
    group1 = NeuronGroup(...)
    group2 = NeuronGroup(...)
    syn = Synapses(group1, group2, ...)
    mon = SpikeMonitor(group2)
    run(1*second)

for r in range(100):


    group1 = NeuronGroup(...)
    group2 = NeuronGroup(...)
    syn = Synapses(group1, group2, ...)
    mon = SpikeMonitor(group2)
    run(1*second)

@magic_return
def f():
    return PoissonGroup(100, rates=100*Hz)

pg = f() # needs magic_return
mon = SpikeMonitor(pg)
run(100*ms)

def f():
    return PoissonGroup(100, rates=100*Hz)

pg = f() # is "visible" and will be included
mon = SpikeMonitor(pg)
run(100*ms)

groups = {'exc': NeuronGroup(...),
          'inh': NeuronGroup(...)}
...

run(5*ms)

groups = {'exc': NeuronGroup(...),
          'inh': NeuronGroup(...)}
...
net = Network(groups)
net.run(5*ms)

tau = 10*ms
# to be sure that changes between runs are taken into
# account, define "I" as a neuronal parameter
group = NeuronGroup(10, '''dv/dt = (-v + I) / tau : 1
                           I : 1''')
group.v = linspace(0, 1, 10)
group.I = 0.0
mon = StateMonitor(group, 'v', record=True)
run(5*ms)
group.I = 0.5
run(5*ms)
group.I = 0.0
run(5*ms)

tau = 10*ms

# The value for I will be updated at each run
group = NeuronGroup(10, 'dv/dt = (-v + I) / tau : 1')

group.v = linspace(0, 1, 10)
I = 0.0
mon = StateMonitor(group, 'v', record=True)
run(5*ms)
I = 0.5
run(5*ms)
I = 0.0
run(5*ms)

V0 = 10*mV
C = 200*pF
Ra = 150*kohm
R = 50*Mohm
soma_eqs = (MembraneEquation(C) +
            IonicCurrent('I=(vm-V0)/R : amp'))
dend_eqs = MembraneEquation(C)
neuron_eqs = Compartments({'soma': soma_eqs,
                           'dend': dend_eqs})

neuron = NeuronGroup(N, neuron_eqs)

V0 = 10*mV
C = 200*pF
Ra = 150*kohm
R = 50*Mohm
neuron_eqs = '''
dvm_soma/dt = (I_soma + I_soma_dend)/C : volt
I_soma = (V0 - vm_soma)/R : amp
I_soma_dend = (vm_dend - vm_soma)/Ra : amp
dvm_dend/dt = -I_soma_dend/C : volt'''

neuron = NeuronGroup(N, neuron_eqs)

eqs = (perfect_IF(tau=10*ms) +
       Current('I : volt'))
group = NeuronGroup(N, eqs,
                    threshold='v > -50*mV',
                    reset='v = -70*mV')

tau = 10*ms
eqs = '''dvm/dt = I/tau : volt
         I : volt'''
group = NeuronGroup(N, eqs,
                    threshold='v > -50*mV',
                    reset='v = -70*mV')

eqs = (leaky_IF(tau=10*ms, El=-70*mV) +
       Current('I : volt'))
group = ... # see above

tau = 10*ms; El = -70*mV
eqs = '''dvm/dt = ((El - vm) + I)/tau : volt
         I : volt'''
group = ... # see above

eqs = (exp_IF(C=1*nF, gL=30*nS, EL=-70*mV,
              VT=-50*mV, DeltaT=2*mV) +
       Current('I : amp'))
group = ... # see above

C = 1*nF; gL = 30*nS; EL = -70*mV; VT = -50*mV; DeltaT = 2*mV
eqs = '''dvm/dt = (gL*(EL-vm)+gL*DeltaT*exp((vm-VT)/DeltaT) + I)/C : volt
         I : amp'''
group = ... # see above

eqs = (quadratic_IF(C=1*nF, a=5*nS/mV,
       EL=-70*mV, VT=-50*mV) +
       Current('I : amp'))
group = ... # see above

C = 1*nF; a=5*nS/mV; EL=-70*mV; VT = -50*mV
eqs = '''dvm/dt = (a_q*(vm-EL)*(vm-VT) + I)/C : volt
         I : amp'''
group = ... # see above

eqs = (Izhikevich(a=0.02/ms, b=0.2/ms) +
       Current('I : volt/second'))
group = ... # see above

a = 0.02/ms; b = 0.2/ms
eqs = '''dvm/dt = (0.04/ms/mV)*vm**2+(5/ms)*vm+140*mV/ms-w + I : volt
         dw/dt = a_I*(b_I*vm-w) : volt/second
         I : volt/second'''
group = ... # see above

# AdEx, aEIF, and Brette_Gerstner all refer to the same model
eqs = (aEIF(C=1*nF, gL=30*nS, EL=-70*mV,
            VT=-50*mV, DeltaT=2*mV, tauw=150*ms, a=4*nS) +
       Current('I:amp'))
group = NeuronGroup(N, eqs,
                    threshold='v > -20*mV',
                    reset=AdaptiveReset(Vr=-70*mV, b=0.08*nA))