**The latest standard distribution of NEURON is version 7.3**, which is now availiable from http://www.neuron.yale.edu/neuron/download

In addition to lots of internal bug fixes and performance enhancements over prior versions, NEURON 7.3 has

*many*new features that users will find helpful. These are grouped below into the following categories:

- Model specification

hoc

NEURON+Python

Network models and parallel simulations

NEURON Installers

Items of particular interest to developers

**the _new_ Programmer's Reference**

- home page http://www.neuron.yale.edu/neuron/stati ... index.html

alphabetical index http://www.neuron.yale.edu/neuron/stati ... index.html

**Model specification**

- Reaction diffusion in one dimension can now be specified using Python classes and methods described in the new Programmer's Reference under Programmatic Model Specification / Basic Reaction-Diffusion. Also, a tutorial on how to use this new feature has been added to http://www.neuron.yale.edu/neuron/docs. This is a very active area in NEURON development, and we are working to extend it to two- and three-dimensional reaction-diffusion. Previously it was necessary to use NMODL for reaction-diffusion. We expect that interpreter-based specification of reaction-diffusion will eventually replace this application of NMODL.

**hoc**

- PtrVector is a new hoc class that implements fast scatter/gather from a Vector to other hoc variables. Example:
Code: Select all

`objref a,b a = new Vector(5) a.indgen() // a now contains 0 1 2 3 4 b = new Vector(5) b.fill(0) // b now contains 0 0 0 0 0 objref pv pv = new PtrVector(5) for i=0,4 pv.pset(i, &b.x[i]) pv.scatter(a) // b now contains 0 1 2 3 4 b.mul(10) pv.gather(a) // a now contains 0 10 20 30 40`

**NEURON+Python**

- The NEURON+Python help system has been much expanded so that the same information used to generate the Programmer's Reference is immediately available from within a live NEURON session. Example: start NEURON with Python as its interpreterthen at the >>> prompt execute the following statements
Code: Select all

`nrniv -python`

This brings up help for the Vector class's size method.Code: Select all

`from neuron import h v = h.Vector() help(v.size)`

- Python can compare and hash hoc objects, Sections, and Segments. This makes it easy to determine if two different names refer to the same thing. Example:
Code: Select all

`>>> a = h.Section() >>> b = h.Section() >>> c = a >>> a == b False >>> a == c True`

- Vector.as_numpy() returns a numpy array that shares the Vector's data. This saves time and space by allowing the Vector's data to be used as a numpy array without first having to be duplicated in a numpy array.
- ModelView works with Python cells.
- The Graph, Shape, and PlotShape .menu_action("name", pycall) and Shape.menu_tool(pycall) all work from Python.
- PlotShape(sectionlist) now works in Python; previously it worked only in HOC
- In Python, NetCon.record(action) works where action is a Python callable or tuple of (callable, (args))

**Network models and parallel simulations**

- NEURON now offers the Random123 pseudorandom sequence generator, which uses 4 integers to define the random sequence. This is an excellent random number generator for parallel problems, even better than MCellRan4.
- NMODL's FOR_NETCONS now works for ARTIFICIAL_CELLs. Its principal utility is for implementing spike-timing-dependent synaptic plasticity. For an example, see viewtopic.php?f=16&t=470&p=1614#p1614
- ParallelContext.spike_record(-1, spiketimevec, gidvec) records the output for all spike sources in a model that have a gid.
- ParallelContext.timeout(seconds) sets the timeout that specifies when to abort a simulation that is getting bogged down.
- Inter-host communication can now use the ParallelContext.py_alltoall() to send distinct arbitrary Python objects to all the other ranks.

- NrnFILEWrap is used to avoid huge numbers of replicated reads of hoc files when there are more than 100K processes.
- A special multisend method with two-phase spike exchange and efficient setup is used for the BlueGene/P

**NEURON Installers**

- Configuration of compilation and installation of NEURON has been updated for current hardware and OSes i.e. MSWin 7, 8, OS X lion, latest Ubuntu etc.
- A single OS X version of NEURON works for lion and mountain lion, regardless of whether OpenMPI and/or Python has been installed.
- A 64bit version of NEURON is available for MSWin.
- The NEURON module in <prefix>/lib/python is automatically installed with setup.py.

**Items of particular interest to developers**

- The nonvint_block_supervisor is an API to NEURON's internal algorithms that allows new equations, currents, and conductances to be introduced by Python and solved by fixed step and adaptive integration. It has been particularly useful in connecting Python equations to NEURON for specification of reaction-diffusion.
- CVode.extra_scatter_gather(direction, PythonObject) registers python callable objects that are called after cvode scatters its version of the states (direction = 0) and before cvode gathers states (direction = 1, which typically occurs during finitialize and cvode.re_init(). This is useful when ionic concentration variables such as cai need to shadow other reaction-diffusion state variables that are "owned" by Python.
- LinearMechanism has been extended to allow a Python callable as an optional first argument that can change the b and g terms in equations of the form c*dy/dt + g*y = b. This makes it possible for b to become essentially a nonlinear function of t and y, i.e. allows LinearMechanism to be used with nonlinear equations.
- A NrnDAE API is now available for use that generalizes the method used by LinearMechanism for adding new sets of equations that augment the current balance equation Jacobian.
- neuron.nrn_dll() gives Python access to the C-language internals of NEURON. This makes all internal NEURON functions, variables, etc., available through a ctypes object.
- The interface to MUSIC has been updated and allows MUSIC to be dynamically loaded into a Python interpreter.