There are two NEURON one-day tutorials in the near future:
June 28: GUI/theory/scripting overview -- free and online; register at https://framaforms.org/incfocns-software-wg-cns2022-satellite-tutorials-registration-1654593600
July 16: using NEURON and NetPyNE through the cloud; in person event at CNS 2022 in Melbourne, Australia https://cnsorg.org/cns-2022
Remember, if you're looking for a more extensive introduction to NEURON, you can always watch last year's two month long summer webinar series: https://nrn.readthedocs.io/en/latest/videos/neuron-course-2021.html
What: An interactive online course about the NEURON Simulation Environment
When: Starts Thursday, June 3, 2021, and meets on Tuesdays and Thursdays thereafter until Tuesday August 3.
Faculty: Ted Carnevale and Robert McDougal
Application deadline: Monday, May 31, 2021
Registration fee: None.
This course maps the first half of the NEURON Summer Course into a series of interactive online workshops about building and working with models of single neurons. It is designed for those who are planning to use NEURON in neuroscience research or teaching, or already have active projects that involve NEURON, and is suitable for users at all levels of expertise.
Beginners with little or no modeling experience will learn the philosophical basis, scientific rationale, and technical aspects of modeling.
Intermediate users will learn the best approaches to common tasks, and how to use special features of NEURON in their own work.
Experienced users will benefit from an update on new features and a review of important topics that may have escaped their attention when they first started using NEURON.
Although this course focuses on modeling individual cells, the topics it covers are the foundation for modeling networks with NEURON.
This course is not an introduction to cellular neurophysiology or Python programming. It presumes you already have a basic understanding of the anatomical and biophysical properties of neurons, and are familiar with Python. If Python is new to you, be sure to work through the Python introduction before the course starts. You might also find the Scripting NEURON basics tutorial to be helpful. If you don't know anything about biological neurons, read chapters 1, 3, 4, and 5 of Cellular and Molecular Neurophysiology (ed. C. Hammond, Academic Press, 2008) or something equivalent before the course starts.
Space is limited, and applications will be considered in the order received. The application deadline is Monday, May 31, 2021. No applications will be accepted after that date.
How to apply
Applicants will be notified of acceptance shortly after Monday, May 31.
Preliminary Course Schedule
The workshops will start at 1 pm New York time and run for 1 to 2 hours, depending on the topic at hand. Each Thursday workshop will start with a brief question and answer session, followed by introduction of new material, and ending with an assignment that participants are expected to do on their own. In each Tuesday workshop, participants will have the opportunity to present their results, discuss problems that they encountered, and show how they solved them.
Thursday 6/3 and Tuesday 6/8 (Carnevale)
Introduction to mechanistic modeling in neuroscience.
Concepts: Hypotheses and models; the importance of conceptual control; neurites, cables, sections.
Activity: Building and using a simple model cell with the CellBuilder.
Homework: Build and use a model axon. Use it to measure conduction velocity and study anode break excitation.
Thursday 6/10 and Tuesday 6/15 (Carnevale)
Branched model neurons.
Concepts: Range, range variables, spatial discretization, nodes, nseg.
Activity: Build a model pyramidal cell. Current clamp the soma and find spike threshold.
Homework: Change the current clamp to an excitatory synapse and examine how synaptic location affects response at the soma. Build a model interneuron and determine how synaptic location affects synaptic efficacy.
Thursday 6/17 and Tuesday 6/22 (Carnevale)
Adding new ion channels to NEURON with NMODL and the Channel Builder.
Homework: Given a set of channel mod files, do current and voltage clamp experiments on a virtual oocyte.
Thursday 6/24 and Tuesday 6/29 (McDougal)
Python + NEURON.
Concepts: Programmatic specification of topology, channel distribution, and virtual experiments. Best practices.
Thursday 7/1 and Tuesday 7/6 (McDougal)
Building and using a model cell with Python.
Concepts: Incremental revision and testing.
Activity: Producing model cells that work with the GUI and are suitable for use in network models running on parallel hardware.
Thursday 7/8 and Tuesday 7/13 (McDougal)
Working with morphometric data.
Concepts: Data file formats. Detecting common problems with morphometric data.
Activity: Importing and evaluating morphologies. Strategies for managing anatomically detailed models.
Thursday 7/15 and Tuesday 7/20 (McDougal)
Reproducibility in computational modeling.
Concepts: Model sharing, discovering what's in a model (model introspection and analysis).
Activity: Using ModelDB and ModelView.
Thursday 7/22 and Tuesday 7/27 (Carnevale)
Numerical methods in NEURON.
Concepts: Fixed time step and adaptive integration, parameter discontinuities.
Activity: Compare fixed time step and adaptive integration simulation results. Force a parameter change at a particular time.
Thursday 7/29 and Tuesday 8/3 (McDougal and Carnevale)
The hoc programming language.
Concepts and activity: Understanding hoc code; making minor changes when necessary.
Homework: Load HOC model from ModelDB. Work with it from Python.
- Dynamic selection of legacy vs modern units using HOC/Python API (default : modern)
- Faster reaction-diffusion support
- Initial GPU support using integration of CoreNEURON
- Binary installer for new Apple M1 platform
- Binary wheel distribution for Python 3.9 and Python 2.7
- Release of NMODL version 0.3 (available as python wheel)
- Versioned documentation available via nrn.readthedocs.io
- CMake as a primary build system for NEURON and Interviews
h.Sectionnow interprets positional arguments as
cell. Previously positional arguments were interpreted in the other order. (Calling it with keyword arguments is unchanged.)
- For 3d reaction-diffusion simulations, the voxelization and segment mapping algorithms have been adjusted, especially around the soma. Voxel indices and sometimes counts will change from previous versions.
- Five functions in the
- Autotools build is deprecated and will be removed in the next release. Use CMake instead.
- Python 2 and Python 3.5 support is deprecated and will be removed in the next release. Use
Python >= 3.6
For the complete list of bug fixes, see the list on the GitHub here.
Improvements / Other Changes
- Allow for two point (single section) SWC somas
- GitHub Actions and Azure as primary CI systems. Travis CI removed.
- GitHub Releases provides full source tarballs, binary installers and python wheels.
- Improved testing and CI infrastructure including GPUs
- nrn-build-ci repository test nightly builds for Ubuntu 18.04, Ubuntu 20.04, Fedora 32, Fedora 33, CentOS7, CentOS8, Debian Buster (10) and macOS 10.15 platforms.
- Improved integration of CoreNEURON
- Support for recent numpy version
- Various build improvements on Linux, MacOS and HPC platforms
- Documentation from various repositories is consolidated under
- New releases via Spack and Easybuild package managers
- Fix deadlock when compiling NEURON with AVX-512
- Add backward-cpp for better backtraces
- NEURON_MODULE_OPTIONS environment variable to pass in nrniv options before
Existing models should work without any changes. In order to upgrade NEURON version you can:
- Use python wheels provided for Linux or Mac OS platform
- Use binary installer provided for windows
- Install from source, preferably using CMake build system
- For new version, it's always a good idea to start over from scratch with nrnivmodl (deleting existing directory like
Installation section under nrn.readthedocs.io/. In the very rare case that numerical differences exist, check selection of legacy vs modern units.
See the list of contributors on respective GitHub projects:
- NEURON : https://github.com/neuronsimulator/nrn/graphs/contributors
- CoreNEURON : https://github.com/BlueBrain/CoreNeuron/graphs/contributors
- NMODL : https://github.com/BlueBrain/nmodl/graphs/contributors
Feedback / Help
- Software related issues should be reported on the GitHub : https://github.com/neuronsimulator/nrn/issues/new/choose
- For developing models and any scientific questions, see NEURON Forum : https://www.neuron.yale.edu/phpBB/
- If you want to participate / contribute to the development of NEURON, you can join monthly developers meeting : https://github.com/neuronsimulator/nrn/wiki
NEURON 7.8.2 adds support for Python 3.9 and is otherwise a bug-fix release. Bug-fixes in this release include:
- User-created pointers are now checked to be non-null before dereferencing.
- Rare RangeVarPlot point-duplication prevented.
- Test script enhancements.
- Bugfix on determining which reversal potentials need to be recalculated when using an explicit h.ion_style
- Windows cmake gui event loop fix when running via nrniv -python instead of directly from python.
- Support for running on systems with placeholder python files that prompt installation of Python.
- Reaction-diffusion support is more robust to model changes after creation (Sections no longer kept alive, detects changes to nseg in variable step even if cvode.re_init is not called).
- Bugfix to reaction-diffusion extracellular multicompartment reaction fluxes with MPI.
- Test script enhancements.
- modlunit support for NMODL "REPRESENTS" keyword.
- Fix for rare library name extension issues (libpython2 vs libpython2.7)
What’s new in NEURON 7.8
Easier installation on macOS and Linux; just use: “pip3 install neuron”
More reaction-diffusion integration: PlotShape.plot support, h.distance, node in sec
Increased support for Python graphics packages
PlotShape.plot and RangeVarPlot.plot both gained support for plotly; RangeVarPlot.plot also gained support for plotnine
New, optional mechanism syntax and introspection; mechanism descriptions now displayed in ModelView
h.hh.insert(h.allsec()) and soma.insert(h.hh)
h.hh.code, h.hh.file, help(h.hh)
If the nmodl module is installed: h.hh.ontology_ids, h.hh.ast, h.hh.ions
Cleaner mod-file pointer setting syntax
Gui redirect support for routing legacy graphics to an interviews alternative
Support for cmake compilation in addition to autotools
Compilation flag for using 2019 SI unit values (off by default)
Miscellaneous bug fixes and optimizations
Possibly breaking change (but very rare in practice):
SectionList iteration does not change the currently accessed section; use section methods or sec= instead
We'll have our next monthly NEURON developer's meeting this Friday, June 19th at 10:00 EDT (16:00 CEST). Contact one of the developer's for a zoom link if you wish to join.
The agenda is posted on the wiki: https://github.com/neuronsimulator/nrn/wiki/June-2020
The July meeting will be on Friday, July 17th at 10:00 EDT (16:00 CEST).
November 13-15 2019 the new NEURON core development team met for the first time, hosted by Robert McDougal at the Center for Biomedical Data Science, Yale University in New Haven CT. Besides the project owner and lead developer, Michael Hines, various members from Robert McDougal’s team, the Blue Brain Project’s HPC Team of Felix Schürmann (from EPFL) as well as from SUNY Downstate’s Neurosimulation lab of Bill Lytton attended the meeting. In total, 15 people came together to discuss, learn and code.
The aim of our meeting was explicitly to not only discuss high-level topics and the future roadmap for NEURON, but to also allow the various contributors to meet in person, work on pending issues, and advance code development.
We started off the meeting with discussions of community engagement, and methods to facilitate developer community interactions. One of the outcomes is that we now have an official contributors guide! One major goal of these recent efforts will be to make future contributions into the NEURON code base, as well as tutorials and documentation, more accessible to the community. This will be done by documenting how we develop in this project, by simplifying the development process through better build and testing tools, and by ensuring that the code remains correct as contributions come in through a rigorous continuous integration framework.
In recent months, we began an important effort to introduce a new CMake-based build system that should eventually replace the autotools-based build system, offering more flexibility and simplicity, and rendering NEURON easier to install and maintain. With the introduction of the new build system comes also the integration of components of the NEURON ecosystem, which were previously built separately. InterViews, CoreNEURON and NMODL can now optionally be cloned as submodules into the git repository of NEURON and built as dependencies of NEURON through simple configuration flags. During our codejam sessions we put this new build system to the test, making sure that all participants could build their latest copy of NEURON and further develop it. Specifically we further developed the setuptools-based Python builder in NEURON that will enable us to build pip-installable source and binary distributions, namely sdist and wheels. These pre-built packages will soon be available in the official NEURON pypi repository, allowing NEURON to be installed within seconds on most desktop systems today. Even more exciting is the prospect that these packages will be available within cloud-based Jupyter solutions, making the NEURON environment one click away for the user. To further integrate the ecosystem tools we added support for coreNEURON to NetPyNE and tested several network models.
Testing is a vital aspect of the software development life cycle, ensuring the correctness and quality of a software project in its current state, and preventing regression as code is added. Thus, we have taken several steps to improve the testing of the NEURON package. First, we setup the catch2 testing framework allowing us to test the lower level C/C++ functions in NEURON, providing the possibility to write both unit and functional tests. Second, we included the pytest framework to test Python functionality of NEURON and RXD, and began integrating the stand-alone RXD tests into pytest. Third, we added a few simple HOC script integration tests (e.g. ringtest) testing NEURON and the HOC interpreter. Finally, to make sure your code changes in NEURON do not introduce regressions, and to help you run newly introduced unit tests for your code, we have included the testing framework into the CMake buildsystem, allowing it to be run with a simple make test.
We want to make the NEURON codebase more accessible to the user, inviting the user community to contribute fixes and improvements. To do this we made a significant effort to improve NEURON’s programmer’s documentation. In addition to the Python and HOC programmer's references and Python tutorials which were added as submodules to the repository, the doxygen documentation framework was added for documenting the C/C++ parts of the code. Furthermore, the doxygen documentation is made automatically available via the travis CI plan in neuronsimulator.github.io/nrn. Of course we will need to now work on adding much more documentation text into the code itself, but we expect that this will be done gradually as we visit the various parts in the code in our future efforts.
After three days of intense coding, testing, building, fixing and discussing, we felt we have not only managed to make a big step forward in NEURON development but also for the NEURON developers themselves through our shared experiences!
We are all looking forward to the next NEURON developers codejam, being planned for April/May 2020.
What: Using NEURON to Model Cells and Networks
When: Friday, Oct. 18 from 9 AM to 5 PM
Where: Downtown Chicago location to be announced
Satellite event to the 2019 Society for Neuroscience Meeting
This course provides a practical introduction to building and using models of neurons and networks with NEURON. Covered topics include basic concepts, workflow for building and using models, speeding up simulations with parallel hardware from multicore personal computers to massively parallel supercomputers, using Python with NEURON, and modeling reaction-diffusion with the RxD class.
The registration deadline for this course is Friday Oct. 4, but you should sign up now because space is limited. See https://neuron.yale.edu/neuron/static/courses/chi2019/chi2019.html for more information and a link to the registration form.
NEURON 7.7.2 is now available for download. It is the recommended version for all new projects.
New features since NEURON 7.6 include:
- Reaction-diffusion enhancements
- Reimplemented reaction-diffusion simulation support, providing ~10x faster simulations with JIT compiled reactions
- faster 3D voxelization
- rxd.Parameters can now be used as fixed concentrations
- support for specifying electrophysiology models (see, e.g. the Hodgkin-Huxley model implemented using the rxd framework)
- extracellular simulation support enabled by default
- SBML export.
- See the tutorials for examples.
- Python-graphics aware .plot methods for RangeVarPlot and PlotShape.
- Mechanism introspection using new .code() and .file() methods in MechanismType.
- Updated help documentation; all examples should work for both Python 2 and 3.
- Ontology tagging with REPRESENTS keyword for NMODL and represents keyword for rxd.Species.
- Can now initialize MPI with h.nrnmpi_init(); i.e. no need for special flags or mpi4py.
- neuron.units submodule to simplify model specification.
- All platforms can now use nrnivmodl to compile NMODL files; previously Windows could not.
- Python-API enhancements
- constructor now accepts a Python iterable of sections
- methods accept a section argument; no need for sec=
- can directly set values; e.g. vec = 42
- vector.record now returns the vector, allowing one line recording specification; e.g. v = h.Vector().record(soma(0.5)._ref_v)
- More compact syntax for h.distance and h.RangeVarPlot
- Simpler NMODL pointer setting; instead of using h.setpointer, can use, e.g. seg._ref_POINTER_suffix = ptr
- new Section methods: wholetree, subtree that return Python lists of sections
- new Segment method: volume
- More meaningful return data types for CVode methods
The 2019 NEURON Summer Course will be held at the University of Minnesota, Minneapolis from Monday, June 10, through Saturday, June 15.
The course will present a thorough introduction to computational modeling of neurons and networks with NEURON, and is suitable for individuals at all levels of expertise. This year continues the 6 day curriculum we introduced in 2017 in order to provide expanded coverage of parallel simulation, and to give participants more time for active learning exercises.
The registration deadline is Friday, May 31, 2019. No applications will be accepted after that date, and there will be no on-site registration. Space is limited, and applications will be considered in the order received.
For more information and the on-line registration form, see http://www.neuron.yale.edu/neuron/static/courses/summer2019/summer2019.html