Version 1.0-rc1

Changelog NEAT v1.0.0

1. compilechannels is extended to neatmodels command

Instead of compiling channels for simulations with compilechannels, the functionality to export models to simulators has been vastly extended through the neatmodels command. This implements functionality to install collections of channels, defined neat.IonChannel's as a NEAT model (i.e. through neatmodels install <cmd options>), to list installed models (neatmodels list <cmd options>) and to uninstall models (neatmodels uninstall <cmd options>). After installing NEAT, type neatmodels -h in the terminal to see an overview of the options

2. NEST compatibility

neat.CompartmentTree's can now be simulated in NEST. Collection of channels can be installed in the same way as for NEURON, through the neatmodels install terminal command, except that the option -s nest is then invoked with the command. The ionchannels are than converted into NESTML code that is converted into an efficient compartmental modeling C++ code in NEST.

There are three steps towards implementing such a NEST model:

1. Compile the NEST compartmental model

   neatmodels install my_nest_model_name -s nest -p my_channels.py

2. In the python session, load the NEST model in NEAT

   neat.load_nest_model("my_nest_model_name")

3. In the same python session, create a neat.NestCompartmentTree from an existing neat.CompartmentTree and call init_model()

   nest_sim_tree = neat.NestCompartmentTree(existing_compartment_tree)
   nest_model = nest_sim_tree.init_model("my_nest_model_name")

3. Copy construction

Creating new trees from already existing trees can now be done directly by the constructor.
I.e., in NEAT 0.9.2, we would create a new tree from an existing one as follows

new_tree = old_tree.__copy__(new_tree=NewTreeClass())

In NEAT 1.0.0, we can do

new_tree = NewTreeClass(old_tree)

4. Removal of neat.createReducedNeuronModel()

The original procedure in NEAT 0.9.2 to instantiate a reduced NEURON model for simulations involved calling a standalone function neat.createReducedNeuronModel(), i.e.:

neuron_sim_tree = neat.createReducedNeuronModel(compartment_tree)

To harmonize creation of reduced compartmental NEURON simulation trees with all other tree classes, the compartment tree is now simply provided to the constructor of NeuronCompartmentTree.

neuron_sim_tree = neat.NeuronCompartmentTree(compartment_tree)

5. Conversion of function names to snake_case

All function names have been converted from smallCamelCase to snake_case.

6. Treetype is now a context manager

To speed up computations, neat.MorphTree's and derived tree classes allow the definition of a more coarse-grained tree, the computational tree. To toggle between which tree is active, the treetype attribute needed to be set to either 'computational' or 'original'. This error-prone procedure has been replaced by a context manager, one can do:

with tree.as_computational_tree:
    # do something on computational tree

NEAT also provides the computational_tree_decorator and computational_tree_decorator to provide the certainty that functions always operate on a specific tree.

7. Compute linear response kernels in the time domain through neat.GreensTreeTime

A new tree class, neat.GreensTreeTime, supports automatic conversion of the frequency domain kernels into the time domain, so there is no more need to rely on neat.FourrierTools. The conversion algorithm is chosing optimally for the specific kernel, using vector fitting [Gustavsen and Semlyen, 2003, 10.1109/61.660941] when an input resistance kernel is computed, and and explicit quadrature method with a squared-cosine window when it is a transfer resistance kernel.

8. Improved cacheing

Cacheing is improved and more robust through the use of hashing, taking into account a representation string that features all attributes of the tree and all its nodes, so that different trees will always have different hashes. Specific cachetrees have been create to allow the cacheing of expensive computations:

• neat.EquilibriumTree: cached equilibrium voltage calculation through NEURON simulation
• neat.CachedGreensTree: cached evaluation of response kernels in frequency domain
• neat.CachedGreensTreeTime: cached evaluation of response kernels in time domain
• neat.CachedSOVTree: cached evaluation of separation of variables expansion

8. Non-API-affecting changes

1. The neat.CompartmentFitter is now a tree class, inheriting from neat.EquilibriumTree. This does not affect syntax.

Allow wheel building

In this release of NEAT, we have fixed wheel building for smoother installation with pip. We have also implemented better vectorization of ion channels and expansion points for linearization procedures, speeding up the simplification pipeline.

New features

• vectorized impedance matrix calculation for different expansion points #130

Bug fixes

• bug fixes to allow for wheel building #137 #138 #139
• fix pickling bugs #129
• bug fix where channel storage was not emptied when passifying a neuron #126

Maintenance

• github actions workflow #125
• Fix ambiguous naming scheme for 'up' and 'down' directions #131

v0.9.1

This is the second release of NEAT. It contains extensive improvements to the documentation, a new ion-channel description and improved API functionality to fit reduced compartmental models.

New features

• Sphinx documentation #28 #39 #46 #47 #54 #104 #105 #106 #107 #108 #109 #110 #123
• parallel evaluation of ion channel fits #36
• add tutorials to documentation #44 #103
• add examples to documentation #100
• compilechannels command for ion channel compilation to NEURON #49 #61 #90
• new ion channel description #71 #79 #82
• API functionality to check impedance kernels #119

Bugfixes

• C-code syntax improvements to avoid error on certain compiler #96
• Fix multi-cylinder soma loading #98

Maintenance

• improved test coverage #33 #34 #35 #59
• improved tracking of dependencies #43 #121