### Setup development environment

Source: https://github.com/bluebrain/neurodamus/blob/main/CONTRIBUTING.md

Initialize a virtual environment and install project dependencies.

```sh
virtualenv venv
. venv/bin/activate

# Install neurodamus in development mode
pip install -e .

# Install test requirements
pip install -r tests/requirements.txt
```

--------------------------------

### Install Neurodamus

Source: https://github.com/bluebrain/neurodamus/blob/main/README.rst

Standard installation procedure using git and pip.

```sh
git clone https://github.com/BlueBrain/neurodamus.git
cd neurodamus
pip install .
```

--------------------------------

### Install Neurodamus-py for Development

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/development.md

Commands to clone the repository, create a virtual environment, and install the package in editable mode.

```bash
# ensure a recent python is loaded. Consider loading together with dependencies from BB5
# module load unstable git py-h5py py-libsonata # will also bring Python and mpi

# Get your copy of neurodamus:
git clone git@bbpgitlab.epfl.ch:hpc/sim/neurodamus-py.git

# Create a virtualenv and install in dev-mode (no copies):
python -m venv venv
. venv/bin/activate
pip install -e neurodamus-py

# Test it
neurodamus
    Usage:
        neurodamus <BlueConfig> [options]
        neurodamus --help
```

--------------------------------

### Neuron Tutorial Synapses with Neurodamus

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/examples.md

This example demonstrates setting up synaptic connections in a Neuron model using Neurodamus. It covers basic section properties, applying mechanisms, creating stimuli, and connecting NetStim to ExpSyn.

```python
def test_tut2():
    c = Cell(0, MORPHO)
    print("The morphology {} basal, {} apical, {} axonal sections.".format(
        len(c.dendrites), len(c.apical_dendrites), len(c.axons)))

    for sec in c.all:
        sec.nseg = 1 + 2 * int(sec.L / 40)
        sec.cm = 1
        sec.Ra = 100

    hh = mechanisms.HH(gkbar=.0, gnabar=.0, el=-70)
    hh.apply(c.all)
    hh.gkbar = 0.01
    hh.gnabar = 0.2
    hh.apply(c.soma)
    hh.gnabar = 0.25
    hh.apply(c.axons)

    clamp = CurrentSource.Constant(0.5, 200, 10).attach_to(c.soma)
    Neuron.run_sim(300, c.soma, v_init=-70).plot()

    # Part 2
    clamp.detach()

    stim = synapses.NetStim(5, 5, 20, 0)

    for sect in c.dendrites:
        sr = synapses.ExpSyn(sect(0.5))
        stim.connect_to(sr, weight=0.001)

    Neuron.run_sim(80, c.soma, v_init=-70).plot()
```

--------------------------------

### Run Neurodamus simulation using Node class

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/examples.md

Demonstrates the manual initialization sequence for a Neurodamus simulation. Requires a valid recipe file and appropriate logging setup.

```python
def test_node_run(trace=False):
    """Node is more of a low-level class, where all initialization steps are manual
    """
    setup_logging(DEFAULT_LOG_LEVEL)
    if trace:
        # Some additional logging is available at special level 5
        print("TRACE mode is ON")
        logging.root.setLevel(TRACE_LOG_LEVEL)

    node = Node(RECIPE_FILE)
    node.load_targets()
    node.compute_load_balance()
    node.create_cells()
    node.execute_neuron_configures()

    logging.info("Create connections")
    node.create_synapses()

    logging.info("Enable Stimulus")
    node.enable_stimulus()

    logging.info("Enable Modifications")
    node.enable_modifications()

    if trace:
        logging.info("Dumping config")
        Nd.stdinit()
        node.dump_circuit_config("")

    logging.info("Enable Reports")
    node.enable_reports()

    logging.info("Run")
    node.run_all()

    logging.info("Simulation finished.")
    node.cleanup()
```

--------------------------------

### Define legacy BlueConfig simulation parameters

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/sonata-simulation.md

Example of a legacy BlueConfig simulation configuration block for comparison with SONATA.

```console
Run Default
{
  Duration 100
  Dt 0.025
  BaseSeed 264118

  Simulator NEURON
  # BlueConfig had circuit defs inline
  TargetFile mooc-circuit/user.target
  CircuitTarget hippocampus_neurons:central

  OutputRoot output

  RNGMode Random123  # deprecated
  RunMode RR         # deprecated. use CLI
}
```

--------------------------------

### Developing a Custom Neurodamus

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/index.md

Guide on how to develop custom Neurodamus functionalities, including installation and testing.

```APIDOC
## Developing a Custom Neurodamus

### Description
This guide covers the process of developing custom Neurodamus features, from package requirements to installation and testing.

### Endpoint
/development.md

#### Sections
- Neurodamus-py package
- Requirements
- Install Neurodamus for development
- Editing HOC Files
- Running Tests
- Prepared Config Files
- The quick path way
- Installing With Spack
```

--------------------------------

### Get or Create Connection

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/top.md

Retrieves a connection by pre- and post-synaptic GIDs, creating it if it does not exist.

```python
get_or_create_connection(sgid, tgid, **kwargs)
```

--------------------------------

### Run Neurodamus Docker Container

Source: https://github.com/bluebrain/neurodamus/blob/main/docker/README.md

Starts an interactive Neurodamus container, mounting a local directory for mods and circuit data.

```bash
docker run --rm -it -v <full path of your folder_mods_circuit>:/mnt/mydata bluebrain/neurodamus
```

--------------------------------

### Launch Neurodamus-py with MPI

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/examples.md

Use 'srun' or 'mpiexec' to launch neurodamus-py for parallel execution. This example shows launching with 'srun' and 'special'.

```sh
srun <srun params> special -mpi -python $NEURODAMUS_PYTHON/init.py <neurodamus params>
```

--------------------------------

### Define Sonata simulation parameters

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/sonata-simulation.md

Example of a JSON configuration block for a SONATA simulation, including run parameters, network definition, and output settings.

```json
"run": {
"tstop": 100.0,
  "dt": 0.025,
  "random_seed": 264118,
},

"target_simulator": "NEURON",
"network": "circuit_config.json",
"node_sets_file": "node_sets.json",
"node_set": "most_central_100_SP_PC",

"output": {
  "output_dir": "output_sonata",
  "spikes_file": "out.h5",
  "spikes_sort_order": "by_time"
},
```

--------------------------------

### Running Neurodamus with MPI

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/overview.md

Launch neurodamus using 'srun' or 'mpiexec' for parallel execution. This example shows how to set environment variables for the Python path and HOC library, then execute the simulation.

```sh
export NEURODAMUS_PYTHON=$(python -c "import neurodamus; from pathlib import Path; print(Path(neurodamus.__file__).parent / 'data')")
export HOC_LIBRARY_PATH=<hoc_files_folder>
srun <srun params> <your_built_special> -mpi -python $NEURODAMUS_PYTHON/init.py <neurodamus params>
```

--------------------------------

### Build Single Compartment Neuron Model with Neurodamus

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/examples.md

This example demonstrates building a basic single compartment neuron model, adding membrane mechanisms, creating stimuli, and running simulations using Neurodamus's high-level API for Neuron. It includes options for quick execution or detailed simulation with active channels.

```python
#!/usr/bin/env python
"""
Neuron tutorial I using the new HighLevel API. Original tutorial at
https://github.com/BlueBrain/SimulationTutorials/blob/master/CNS2017/NEURON/NEURON_intro.ipynb
"""
from neurodamus.core import Cell
from neurodamus.core import CurrentSource
from neurodamus.core import Neuron
from neurodamus.core import mechanisms


# Change v_init globally
# Alternatively v_init can be configured per simulation in run_sim(**kw)
Neuron.Simulation.v_init = -70


def test_tut1(quick=True):
    c = Cell.Builder.add_soma(60).create()
    hh = Cell.Mechanisms.HH(gkbar=0.0, gnabar=0.0, el=-70)
    hh.apply(c.soma)

    # clamp = StimuliSource.pulse(0.1, 50, delay=10).attach_to(c.soma)  # eqv. to Constant()
    CurrentSource.Constant(0.1, 50, 10).attach_to(c.soma)
    Neuron.run_sim(100, c.soma).plot()
    if quick:
        return

    # Execution with Active channels
    hh.gkbar = 0.01
    hh.gnabar = 0.2
    hh.apply(c.soma)
    sim = Neuron.run_sim(100, c.soma)
    # sim.run_continue(100)
    sim.plot()

    # Extending the model with dendrites
    c = (c.builder
         .add_dendrite("dend", 400, 9, diam=2, Ra=100)
         .add_dendrite("dend2", 400, 9, diam=2, Ra=100)
         .create())

    mechanisms.HH(el=-70, gl=5e-4, gkbar=.0, gnabar=.0).apply(c.dendrites)
    Neuron.run_sim(50, c.dendrites[0]).plot()

    Cell.show_topology()
    Neuron.h.psection(sec=c.dendrites[0])


if __name__ == "__main__":
    test_tut1(False)
    from six.moves import input
    input("Press enter to quit")
```

--------------------------------

### Configure Development Environment with Modules and Virtualenv

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/development.md

Sets up the environment by loading modules, creating a virtual environment for testing, and configuring the PYTHONPATH.

```bash
module load unstable py-neurodamus neurodamus-neocortex

# Set up a virtualenv for other packages, e.g. pytest
# Remember that any installed package in this venv takes precedence over the loaded module
python -m venv venv
. venv/bin/activate
pip install pytest pytest-forked

# Make dev neurodamus-py take precedence over everything
export PYTHONPATH=$PWD/neurodamus-py:$PYTHONPATH

# You should be good to go
cd neurodamus-py
pytest -s -k scientific/test_projections
```

--------------------------------

### Get METype Cell Threshold

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/top.md

Retrieves the threshold value for an METype or PointCell.

```python
METype.getThreshold()
```

```python
PointCell.getThreshold()
```

--------------------------------

### GET /connection

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/top.md

Retrieves a connection object based on pre and post gids.

```APIDOC
## GET /connection

### Description
Retrieves a connection from the pre and post gids.

### Parameters
#### Query Parameters
- **sgid** (int) - Required - The pre-gid of the cell
- **tgid** (int) - Required - The post-gid of the cell

### Response
#### Success Response (200)
- **connection** (object) - A connection object if it exists, otherwise null
```

--------------------------------

### Prepare Model: Full Simulation with --keep-build

Source: https://github.com/bluebrain/neurodamus/wiki/Using-CoreNeuron-in-Practice

Run a normal simulation while retaining intermediate files for later direct CoreNEURON execution. This option instantiates the model, runs the simulation, and preserves the 'coreneuron_input' directory and configuration files.

```bash
srun special -mpi -python $NEURODAMUS_PYTHON/init.py --configFile=simulation_config.json --keep-build
```

--------------------------------

### Get All Spikes Map

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/top.md

Returns the GroupedMultiMap containing all the spike data managed by the SpikeManager.

```python
SpikeManager.get_map()
```

--------------------------------

### Get Static METype Version

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/top.md

Retrieves the static version information for the METype class.

```python
METype.getVersion()
```

--------------------------------

### Execute Simulation with Model Building Steps

Source: https://github.com/bluebrain/neurodamus/wiki/Using-CoreNeuron-in-Practice

Use the --modelbuilding-steps command line option to split the model building phase for large networks. This option is only compatible with CoreNEURON.

```bash
srun dplace special -mpi -python $NEURODAMUS_PYTHON/init.py --configFile=simulation_config.json --modelbuilding-steps=2
```

--------------------------------

### Memory Load Balance Tutorial

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/index.md

A tutorial on memory load balancing within Neurodamus, covering simulation and rebalancing.

```APIDOC
## Memory Load Balance Tutorial

### Description
This tutorial explains memory load balancing in Neurodamus, including introduction, dry run, model instantiation, rebalance, and simulation.

### Endpoint
/memory_load_balance.md

#### Sections
- Introduction
- Dry Run
- Model Instantiation
- Rebalance
- Simulation
```

--------------------------------

### Get METype Cell Hyperpolarization Amplitude

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/top.md

Retrieves the hyperpolarization amplitude (HypAmp) for an METype or PointCell.

```python
METype.getHypAmp()
```

```python
PointCell.getHypAmp()
```

--------------------------------

### neurodamus.utils.logging.setup_logging

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/utils.md

Configures the logging system for the Neurodamus project, supporting stdout and file output with MPI rank identification.

```APIDOC
## setup_logging(loglevel, logfile=None, rank=None)

### Description
Setup neurodamus logging. Features tabs and colors output to stdout and pydamus.log.

### Parameters
#### Query Parameters
- **loglevel** (int) - Required - Minimum loglevel for emitting messages
- **logfile** (str) - Optional - The destination for log messages besides stdout
- **rank** (int) - Optional - A tag so warnings/errors are correctly identified in case of MPI
```

--------------------------------

### GET /connections

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/top.md

Retrieves connections based on pre and post synaptic GIDs and population IDs.

```APIDOC
## GET /connections

### Description
Retrieves all connections that match post and pre gids eventually in a subset of the populations.

### Method
GET

### Endpoint
/connections

### Parameters
#### Query Parameters
- **post_gids** (list) - Required - The target gids of the connections to search (None = All)
- **pre_gids** (list) - Optional - The pre-gids to search. Default: all
- **population_ids** (int/tuple) - Optional - A int/tuple of populations ids. Default: all
```

--------------------------------

### Prepare Model: Instantiation Only with --simulate-model=OFF

Source: https://github.com/bluebrain/neurodamus/wiki/Using-CoreNeuron-in-Practice

Instantiate the model without running CoreNEURON, generating necessary input files. This option is useful for preparing the environment for direct CoreNEURON execution without performing the simulation itself.

```bash
srun special -mpi -python $NEURODAMUS_PYTHON/init.py --configFile=simulation_config.json --simulate-model=OFF
```

--------------------------------

### SonataReader Get Counts

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/io.md

Counts synapses for the given target neuron IDs. Returns a dictionary.

```python
get_counts(tgids)
```

--------------------------------

### Run Simulations with Neurodamus-py

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/development.md

Steps to load the required Neuron model, set the PYTHONPATH, and execute a simulation.

```bash
# now, yeah, load a compiled model for Neuron
module load neurodamus-neocortex
# Make our neurodamus-py take precedence (see note below)
export PYTHONPATH=$PWD/neurodamus-py:$PYTHONPATH

# find the usecase3 simulation in tests
cd neurodamus-py/tests/simulations/usecase3

# Run it!
neurodamus simulation_sonata.json

# You should get
# ::INIT:: Special available. Replacing binary...
# numprocs=1
# NEURON -- VERSION 9.0.dev-1349-g67a672a2c+ HEAD (67a672a2c+) 2023-05-04
# ...

# In order to run on 4 MPI ranks:
srun -n4 [--account=proj16] neurodamus simulation_sonata.json
```

--------------------------------

### Synaptic Release Log Output

Source: https://github.com/bluebrain/neurodamus/wiki/Make-a-connection-output-additional-information-following-an-Action-Potential-(AP)

Example of the log message generated when a synapse successfully releases.

```text
[Syn 1633] Release! t = 99.9902, vals: 1.05995 0.939071 1.12872 0.939071
```

--------------------------------

### Initialize Spack Environment

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/development.md

Commands to load Spack and create a new environment for Neurodamus.

```default
module load unstable spack
# and follow the instructions provided to get an editable version.
```

```default
spack env create neurodamus
spack env activate -p neurodamus

spack add neurodamus-neocortex
```

--------------------------------

### Synaptic Failure Log Output

Source: https://github.com/bluebrain/neurodamus/wiki/Make-a-connection-output-additional-information-following-an-Action-Potential-(AP)

Example of the log message generated when a synapse fails to release.

```text
[Syn 2868] Failure! t = 99.9752: urand = 0.528058
```

--------------------------------

### SynapseReader Get Synapse Parameters

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/io.md

Obtains the synapse parameters record for a given GID from the synapse reader.

```python
get_synapse_parameters(gid)
```

--------------------------------

### Initialize and Update Progress Bar

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/utils.md

Demonstrates basic usage of the ProgressBar class with default settings.

```pycon
>>> from progressbar import ProgressBar
>>> p = ProgressBar()
>>> print p
[>............] 0%
>>> p + 1
>>> print p
[=>...........] 10%
>>> p + 9
>>> print p
[============>] 0%
```

--------------------------------

### Clone BlueConfigs Repository

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/development.md

Retrieve the repository containing input files for simulations.

```default
git clone git@bbpgitlab.epfl.ch:hpc/sim/blueconfigs.git
```

--------------------------------

### SonataReader Get Property

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/io.md

Retrieves a pre-loaded property for a given GID and field name from SONATA data.

```python
get_property(gid, field_name)
```

--------------------------------

### View Neurodamus Help and Options

Source: https://github.com/bluebrain/neurodamus/wiki/Using-CoreNeuron-in-Practice

Display available command line options for Neurodamus, including save and restore functionality.

```bash
>neurodamus --help
neurodamus

    Usage:
        neurodamus <ConfigFile> [options]
        neurodamus --help

    Options:
        ...
        --save=<PATH>           Path to create a save point to enable resume.
        --save-time=<TIME>      The simulation time [ms] to save the state. (Default: At the end)
        --restore=<PATH>        Restore and resume simulation from a save point on disk
        ...
```

--------------------------------

### CellManagerBase Class

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/top.md

Base class for cell managers, providing core functionalities for cell management and simulation setup.

```APIDOC
## Class neurodamus.cell_distributor.CellManagerBase

### Description
Base class for cell managers, providing core functionalities for cell management and simulation setup.

### Properties
- **cells** - Instantiated cells.
- **circuit_name** - Name of the circuit.
- **circuit_target** - Target of the circuit.
- **connection_managers** - List of connection managers.
- **gid2cell** - Mapping from GID to cell object.
- **is_default** - Boolean indicating if it's the default manager.
- **is_virtual** - Boolean indicating if it's a virtual manager.
- **local_nodes** - Nodes local to the current processor.
- **pc** - Pointer to the simulation environment.
- **population_name** - Name of the cell population.
- **target_manager** - The target manager object.
- **total_cells** - Total number of cells managed.

### Methods
#### enable_report(report_conf, target_name, use_coreneuron)

Placeholder for Engines implementing their own reporting.

* **Parameters:**
  * **report_conf** – The dict containing the report configuration
  * **target_name** – The target of the report
  * **use_coreneuron** – Whether the simulator is CoreNeuron

#### finalize(**opts)

Instantiates cells and initializes the network in the simulator. Note: it should be called after all cell distributors have done load_nodes() so gids offsets are final.

#### getGidListForProcessor()

Gets the list of GIDs for the current processor.

#### get_cell(gid)

Retrieves a cell object given its GID.

#### get_cellref(gid)

Retrieve a cell object given its gid. Note that this function handles multisplit cases incl converting to an spgid automatically.

Returns: Cell object

#### get_final_gids()

Gets the final list of GIDs.

#### load_artificial_cell(gid, artificial_cell)

Loads an artificial cell.

#### load_nodes(load_balancer=None, , _loader=None, loader_opts=None)

Top-level loader of nodes.

#### post_stdinit()

Post stdinit actions.

#### pre_stdinit()

Post stdinit actions.

#### record_spikes(gids=None, append_spike_vecs=None)

Setup recording of spike events (crossing of threshold) for cells on this node.

#### register_connection_manager(conn_manager: [ConnectionManagerBase](#neurodamus.connection_manager.ConnectionManagerBase))

Registers a connection manager.
```

--------------------------------

### Enable Synapse Verbose Logging

Source: https://github.com/bluebrain/neurodamus/wiki/Make-a-connection-output-additional-information-following-an-Action-Potential-(AP)

Configure the simulation to output detailed synaptic event information via the connection_overrides section.

```json
"connection_overrides": [
  {
    "name": "init",
    "source": "hex_O1",
    "target": "hex_O1",
    "synapse_configure" : "%s.verboseLevel = 1"
  }, 
  ...
]
```

--------------------------------

### Create a new git branch

Source: https://github.com/bluebrain/neurodamus/blob/main/CONTRIBUTING.md

Use this command to start a new feature or fix branch from the master branch.

```shell
git checkout -b my-fix-branch master
```

--------------------------------

### Configure Custom Progress Bar

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/utils.md

Shows how to initialize a ProgressBar with custom options for width, fill character, and formatting.

```pycon
>>> from progressbar import ProgressBar
>>> custom_options = {
...     'end': 100,
...     'width': 20,
...     'fill': '#',
...     'format': '%(progress)s%% [%(fill)s%(blank)s]'
... }
>>> p = ProgressBar(**custom_options)
>>> print p
0% [....................]
>>> p + 5
>>> print p
5% [#...................]
>>> p + 9
>>> print p
100% [####################]
```

--------------------------------

### Run Basic Simulation with Neurodamus CLI

Source: https://context7.com/bluebrain/neurodamus/llms.txt

Execute a basic simulation using the Neurodamus command-line interface with a SONATA configuration file. Requires MPI for parallel execution.

```bash
# Basic simulation run with MPI
srun -n 64 neurodamus simulation_config.json
```

```bash
# Run with verbose logging
neurodamus simulation_config.json --verbose
```

```bash
# Dry run to estimate memory usage without running simulation
neurodamus simulation_config.json --dry-run
```

```bash
# Build model only (for CoreNEURON), don't simulate
neurodamus simulation_config.json --build-model=ON --simulate-model=OFF
```

```bash
# Run with load balancing enabled
neurodamus simulation_config.json --lb-mode=WholeCell
```

```bash
# Run with memory-based load balancing (requires prior dry-run)
neurodamus simulation_config.json --lb-mode=Memory
```

```bash
# Save simulation state at specific time
neurodamus simulation_config.json --save=/path/to/save --save-time=100
```

```bash
# Restore and continue simulation
neurodamus simulation_config.json --restore=/path/to/save
```

```bash
# Run in CoreNEURON direct mode (without writing model to disk)
neurodamus simulation_config.json --coreneuron-direct-mode
```

```bash
# Debug specific cell
neurodamus simulation_config.json --dump-cell-state=12345
```

--------------------------------

### Load Balance Info from CX Files

Source: https://github.com/bluebrain/neurodamus/blob/main/_benchmarks/opti_configure_0.2.2/line_stats.txt

Constructs the path to cx_* files and initializes the BalanceInfo object using the provided path, MPI rank, and CPU count. Handles custom CWD paths.

```python
cx_path = "cx_%d" % MPI.cpu_count
if run_conf.exists("CWD"):
    # Should we allow for another path to facilitate reusing cx* files?
    cx_path = path.join(run_conf.get("CWD").s, cx_path)

# self.binfo reads the files that have the predistributed cells (and pieces)
self._binfo = Nd.BalanceInfo(cx_path, MPI.rank, MPI.cpu_count)
```

--------------------------------

### Run Production Simulations

Source: https://github.com/bluebrain/neurodamus/blob/main/README.rst

Execute simulations using the special binary for optimized performance.

```sh
export NEURODAMUS_PYTHON=$(python -c "import neurodamus; from pathlib import Path; print(Path(neurod)mus.__file__).parent / 'data')")
export HOC_LIBRARY_PATH=<hoc_files_folder>
srun <srun params> <your_built_special> -mpi -python $NEURODAMUS_PYTHON/init.py <neurodamus params>
```

--------------------------------

### Reset Progress Bar

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/utils.md

Resets the current progress of a Progress object back to its starting point. This is useful for reusing a progress tracker.

```python
progress_instance.reset()
```

--------------------------------

### Set Initial Time Bin

Source: https://github.com/bluebrain/neurodamus/blob/main/_benchmarks/opti_configure_0.2.2/line_stats.txt

Sets the initial time bin for simulation events. This is part of setting up time-dependent processes.

```python
tbins_vec.x[0] = 0.0
```

--------------------------------

### Get Synapse Parameters

Source: https://github.com/bluebrain/neurodamus/blob/main/_benchmarks/opti_configure_0.2.2/line_stats.0.txt

Retrieves synapse parameters for a given cell GID. It first checks a cache and if not found, loads the data from the H5 file.

```APIDOC
## GET /api/cells/{gid}/synapse_parameters

### Description
Retrieves all synapse parameters for a specified post-synaptic cell GID. The function first checks a cache for the parameters. If not found, it loads the data from the H5 file, processes it, and returns a list of SynapseParameters objects.

### Method
GET

### Endpoint
/api/cells/{gid}/synapse_parameters

### Parameters
#### Path Parameters
- **gid** (int) - Required - The global ID (GID) of the cell whose synapse parameters are required.

### Response
#### Success Response (200)
- **list** (array) - A list containing SynapseParameters objects for each synapse connected to the cell.

#### Response Example
[
  {
    "sgid": 12345,
    "delay": 0.001,
    "isec": 0,
    "ipt": 0,
    "offset": 0.0,
    "weight": 0.1,
    "U": 0.5,
    "D": 0.1,
    "F": 0.0,
    "DTC": 0.0,
    "isynType": 1,
    "nrrp": 0.0
  }
]

#### Error Response (404)
- **message** (string) - Indicates that no synapses were found for the specified GID.
```

--------------------------------

### Instantiate Neurodamus Model

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/memory_load_balance.md

Create the model without running the simulation to prepare for rebalancing. Use --lb-mode=Memory and --simulate-model=OFF.

```bash
$ neurodamus ... --lb-mode=Memory --simulate-model=OFF
```

```bash
$ neurodamus ... --lb-mode=Memory --configFile=simulation_config.json --simulate-model=OFF --output-path=/path/to/output
```

--------------------------------

### SonataReader Get Connection Counts

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/io.md

Counts synapses per connection for all given target neuron IDs. Returns a dictionary with a numpy structured array as values.

```python
get_conn_counts(tgids)
```

--------------------------------

### Apply Memory Load Balancing for Multi-Cycle Simulations

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/examples.md

Use --lb-mode=Memory and --modelbuilding-steps together to apply memory load balancing for multi-cycle simulations.

```bash
neurodamus --configFile=simulation_config.json --lb-mode=Memory --modelbuilding-steps=10
```

--------------------------------

### Configure Cell Library Loading

Source: https://github.com/bluebrain/neurodamus/blob/main/_benchmarks/opti_configure_0.2.2/line_stats.txt

Determines whether to load metype info from 'start.ncs' or 'circuit.mvd3' based on the 'CellLibraryFile' configuration. Raises an error for invalid filenames.

```python
if run_conf.exists("CellLibraryFile"):
    celldb_filename = run_conf.get("CellLibraryFile").s
    if celldb_filename == "circuit.mvd3":
        logging.info("Reading gid:METype info from circuit.mvd3")
        self._useMVD3 = True

    elif celldb_filename != "start.ncs":
        logging.error("Invalid CellLibraryFile %s. Terminating", celldb_filename)
        raise ConfigurationError("Invalid CellLibFile".format(celldb_filename))
# Default
if not self._useMVD3:
    logging.info("Reading gid:METype info from start.ncs")
```

--------------------------------

### Run Simulation with Neurodamus High-Level API

Source: https://context7.com/bluebrain/neurodamus/llms.txt

Utilize the `Neurodamus` class for a high-level interface to manage simulation setup, execution, and cleanup. Custom options can be passed during instantiation.

```python
from neurodamus import Neurodamus

# Create and run a complete simulation
nd = Neurodamus('simulation_config.json')
nd.run()
```

```python
# Create simulation with custom options
nd = Neurodamus(
    'simulation_config.json',
    auto_init=True,           # Automatically initialize simulation
    logging_level=2,          # Verbose logging
    disable_reports=False,    # Enable reports
    output_path='/custom/output',  # Override output directory
    lb_mode='WholeCell'       # Enable load balancing
)
nd.run(cleanup=True)  # Run and cleanup intermediate files
```

```python
# Interactive simulation with manual control
nd = Neurodamus('simulation_config.json', auto_init=False)
# ... make modifications to circuit before initialization ...
nd.init()  # Explicitly initialize
nd.run()
```

--------------------------------

### ConnectionSet Initialization

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/top.md

Initializes a dataset of connections, potentially with different seeds for several populations.

```python
ConnectionSet(src_id, dst_id, conn_factory=<class 'neurodamus.connection.Connection'>)
```

--------------------------------

### Run SONATA Simulation with special

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/sonata-faq.md

Execute a SONATA simulation using the 'special' command with MPI enabled, pointing to the SONATA configuration file via the --configFile option.

```bash
$  srun special -mpi -python $NEURODAMUS_PYTHON/init.py --configFile=simulation_config.json
```

--------------------------------

### _apply_configuration

Source: https://github.com/bluebrain/neurodamus/blob/main/_benchmarks/opti_configure_0.2.2/line_stats.0.txt

Executes a configuration against a synapse or a tuple of synapses.

```APIDOC
## INTERNAL METHOD _apply_configuration

### Description
Applies a specific configuration to a given synapse or a tuple of synapses.

### Parameters
- **configuration** (object) - The configuration to be applied
- **synapse** (object/tuple) - The synapse to be applied the configuration. If synapse is a tuple the configuration is applied to each element.
```

--------------------------------

### Run CoreNeuron Simulation

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/memory_load_balance.md

Execute the simulation using the rebalanced data files.

```bash
$ special-core -d /path/to/coreneuron_input -f /path/to/rebalanced_file.dat
```

--------------------------------

### POST /connections/configure

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/top.md

Configures circuit connections based on a provided configuration block.

```APIDOC
## POST /connections/configure

### Description
Configure-only circuit connections according to a config Connection block.

### Parameters
#### Request Body
- **conn_conf** (dict) - Required - The configuration block
```

--------------------------------

### Create and Configure Synapse and NetCon

Source: https://github.com/bluebrain/neurodamus/blob/main/_benchmarks/opti_configure_0.2.2/line_stats.0.txt

Instantiates a synapse object and appends a corresponding NetCon to the parallel network manager.

```python
syn_params = self._synapse_params[syn_i]
syn_obj = self._create_synapse(cell, syn_params, x, self._synapse_ids[syn_i], base_seed)
cell_syn_list = cell.CellRef.synlist
self._synapses.append(syn_obj)

nc_index = pnm.nc_append(self.sgid, tgid, cell_syn_list.count()-1,
                                       syn_params.delay, syn_params.weight)
nc = pnm.nclist.object(nc_index)  # Netcon object
nc.delay = syn_params.delay
nc.weight[0] = syn_params.weight * self.weight_factor
nc.threshold = -30
```

--------------------------------

### Simulation Initialization

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/neurodamus.md

Initializes the simulation by finalizing the model and preparing for execution. Optionally generates CoreNeuron configuration.

```APIDOC
## POST /sim/init

### Description
Finalize the model and prepare to run simulation. After finalizing the model, will eventually write coreneuron config and initialize the neuron simulation if applicable.

### Method
POST

### Endpoint
/sim/init

### Parameters
#### Query Parameters
- **corenrn_gen** (boolean) - Optional - Whether to generate coreneuron config. Default: None (if required)
- **spike_compress** (boolean) - Optional - Override \_finalize_model options. E.g. spike compression.

### Request Example
```json
{
  "corenrn_gen": true,
  "spike_compress": false
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates successful initialization.

#### Response Example
```json
{
  "status": "Simulation initialized successfully."
}
```
```

--------------------------------

### Dry Run with Multi-Cycle Simulations

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/examples.md

For multi-cycle simulations, specify the number of steps using --modelbuilding-steps along with --dry-run.

```bash
neurodamus --configFile=simulation_config.json --dry-run --modelbuilding-steps=10
```

--------------------------------

### Run CoreNEURON Simulation with Neurodamus

Source: https://context7.com/bluebrain/neurodamus/llms.txt

Execute CoreNEURON simulations using Neurodamus with various options for optimization and debugging. Use --coreneuron-direct-mode for memory transfer without disk I/O, --keep-build to retain intermediate files, --enable-shm=ON for faster data loading, and --model-stats to view model statistics.

```bash
# Standard CoreNEURON simulation (writes model to disk)
neurodamus simulation_config.json --lb-mode=WholeCell
```

```bash
# CoreNEURON direct mode (memory transfer, no disk I/O)
neurodamus simulation_config.json --coreneuron-direct-mode
```

```bash
# Keep CoreNEURON intermediate files for debugging
neurodamus simulation_config.json --keep-build
```

```bash
# Enable SHM file transfer for faster CoreNEURON data loading
neurodamus simulation_config.json --enable-shm=ON
```

```bash
# Show CoreNEURON model statistics
neurodamus simulation_config.json --model-stats
```

--------------------------------

### Configure InhPoissonStim and NetCon

Source: https://github.com/bluebrain/neurodamus/blob/main/_benchmarks/opti_configure_0.2.2/line_stats.txt

Initializes the Poisson stimulation object and connects it to a synapse using a NetCon, setting delay and weight parameters.

```python
ips = ND.InhPoissonStim(x)
netcon_m = ND.NetCon(ips, syn_obj)
netcon_m.delay = 0.1
netcon_m.weight[0] = syn_params.weight * self.weight_factor
self._minis_netcons.append(netcon_m)
```

--------------------------------

### Run Single Process Simulation

Source: https://github.com/bluebrain/neurodamus/blob/main/docker/README.md

Executes the Neurodamus simulation using a single process with Python initialization.

```bash
./x86_64/special -mpi -python $NEURODAMUS_PYTHON/init.py --configFile=<your_folder>/simulation_config.json
```

--------------------------------

### Connection Finalization and Synapse Initialization

Source: https://github.com/bluebrain/neurodamus/blob/main/_benchmarks/opti_configure_0.2.2/line_stats.0.txt

Initializes synapse and netcon lists and prepares vectors for rate and time binning during the connection finalization process.

```python
def finalize(self, pnm, cell, base_seed=None, tgid_override=None):
    """ When all parameters are set, create synapses and netcons

    Args:
        pnm: parallelNetManager object which manages cells (& netcons) for NEURON
        cell: cell provided directly rather than via pnm to avoid loadbalance issues
        base_seed: base seed value (leave default None in case no adjustment is needed)
        tgid_override: optional argument which overrides the tgid in the event of loadbalancing

    """
    tgid = tgid_override if tgid_override is not None else self.tgid
    weight_adjusts = []
    wa_netcon_pre = []
    wa_netcon_post = []
    rng_info = ND.RNGSettings()
    tbins_vec = ND.Vector(1)
    tbins_vec.x[0] = 0.0
    rate_vec = ND.Vector(1)

    # Initialize member lists
    self._synapses = []
    self._netcons = []
    self._minis_netcons = []
    self._minis_RNGs = []

    # Note that synapseLocation.SPLIT = 1
    # All locations, on and off node should be in this list, but only synapses/netcons on-node
    # should get instantiated
    for syn_i, sc in enumerate(self._tpoint_man.sclst):
        if not sc.exists():
            continue
        # Put the section in the stack, so generic hoc instructions apply to the right section
        sc.sec.push()

        x = self._tpoint_man.x[syn_i]
```

--------------------------------

### Configure LFP in BlueConfig

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/online-lfp.md

Add the LFPWeightsPath to the Run Default section and define an lfp report block.

```default
Run Default
{
    ...
    LFPWeightsPath /path/to/electrodes_file.h5
    ...
}
```

```default
Report lfp_report
{
    Target AllCompartments
    Type lfp
    ReportOn v
    Unit mV
    Format SONATA
    Dt .1
    StartTime 0
    EndTime 110000
}
```

--------------------------------

### POST /connections/create

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/top.md

Creates connections according to loaded parameters in the active ConnectionSet.

```APIDOC
## POST /connections/create

### Description
Creates connections according to loaded parameters in ‘Connection’ blocks of the config.

### Parameters
#### Request Body
- **src_target** (str) - Optional - Target name to restrict creating connections coming from it
- **dst_target** (str) - Optional - Target name to restrict creating connections going into it
```

--------------------------------

### Generate Load Balance Context Manager

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/architecture.md

Use this context manager to create new load balance data. Instantiate nodes and synapses within the body, and ensure preparatory and post-actions like creating mcomplex and evaluating cell complexity are executed.

```python
with lbal.generate_load_balance(t1, cell_manager):
  cell_manager.finalize()
  conn_manager.create_connections()
```

--------------------------------

### Run integration tests

Source: https://github.com/bluebrain/neurodamus/blob/main/CONTRIBUTING.md

Execute integration tests using tox.

```sh
tox -e integration
```

--------------------------------

### Global Configuration

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/core.md

Global configuration settings and methods.

```APIDOC
## neurodamus.core.configuration.GlobalConfig

### Description
Global configuration settings.

### Fields
- **debug_conn** (list) - Debug connections.
- **verbosity** (int) - Verbosity level.

### Class Methods
- **set_mpi()**: Sets MPI configuration.
```

--------------------------------

### Instantiate Replay Stim

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/top.md

Inserts a replay stim into a given synapse. Requires connection, section, synapse object, and synapse parameters.

```python
create_on(conn, sec, syn_obj, syn_params)
```

--------------------------------

### Neurodamus-py Command Line Usage

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/examples.md

Basic command to run neurodamus with a simulation configuration file and options.

```bash
$ neurodamus
  Usage:
      neurodamus <simulation_config.json> [options]
      neurodamus --help
```

--------------------------------

### GlobalConfig Class

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/core.md

Global configuration settings for the simulation.

```python
class neurodamus.core.configuration.GlobalConfig:
    debug_conn *= []
    verbosity *= 1
```

--------------------------------

### Develop with Spack

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/development.md

Clones the repository and uses spack develop to link the local source code.

```default
git clone git@bbpgitlab.epfl.ch:hpc/sim/neurodamus-py.git
spack develop -p ${PWD}/neurodamus-py --no-clone py-neurodamus@develop
spack add py-neurodamus@develop

spack install --jobs NPROC
```

--------------------------------

### Apply Configuration to Synapse

Source: https://github.com/bluebrain/neurodamus/blob/main/_benchmarks/opti_configure_0.2.2/line_stats.0.txt

Executes a configuration against a synapse or a tuple of synapses.

```python
@staticmethod
def _apply_configuration(configuration, synapse):
    # In the future configurations should be Python functions?
    """ Executes a configuration against a (tuple of) synapse(s)

    Args:
        configuration: The configuration to be applied
        synapse: The synapse to be applied the configuration. If synapse is a tuple the
            configuration is applied to each element.
```

--------------------------------

### Initialize Load Balancing Structures

Source: https://github.com/bluebrain/neurodamus/blob/main/_benchmarks/opti_configure_0.2.2/line_stats.txt

Initializes structures for load balancing if the 'RunMode' is set to 'LoadBalance' or 'WholeCell'. This includes creating gid vectors.

```python
if run_conf.exists("RunMode") \
        and run_conf.get("RunMode").s in ("LoadBalance", "WholeCell"):
    logging.info("  > Distributing cells according to load-balance")
    self._lb_flag = True
    self._spgidvec = compat.Vector("I")
    gidvec = compat.Vector("I")
```

--------------------------------

### Load Sonata Circuit Configuration

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/io.md

Loads circuit configuration from Sonata files, supporting dynamic properties and various loading modes. Requires circuit configuration, GIDs, and optionally population details.

```python
load_sonata(circuit_conf, all_gids, stride=1, stride_offset=0, node_population, load_dynamic_props=(), has_extra_data=False, dry_run_stats=None, load_mode=None)
```

--------------------------------

### ConfigT Class

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/utils.md

Base class for configurations, allowing initialization from kwargs and dictionaries with validation.

```APIDOC
## Class neurodamus.utils.pyutils.ConfigT

### Description
Base class for configurations. This class serves as a base for set of configurations. By inheriting and setting several class-level attributes, instances will be able to initialize from kwargs and dictionaries with the same keys, effectively working as validators of fields with default values. Furthermore, for validation of values, the attributes may be Enums.

```default
class RunConfig(ConfigT):
   # NOTE: Enum fields: the FIRST value is the default
   mode = Enum("Mode", "BUILD_SIMULATE BUILD_ONLY")
   model_path = None
```

### Methods
#### classmethod set_defaults(**opts)

#### apply(obj, subset=None, excludes=(), **overrides)
Applies the configuration to one or multiple objects (if tuple)

#### as_dict(subset=None, excludes=())

#### get(*args)

#### property all
```

--------------------------------

### Open Spike File for Replay

Source: https://github.com/bluebrain/neurodamus/blob/main/docs/api/subpackages/top.md

Opens a spike file, interpreting it as binary or ASCII based on the extension. Applies a delay to spike times.

```python
SpikeManager.open_spike_file(filename, delay, population=None)
```

--------------------------------

### Build Neurodamus Docker Image

Source: https://github.com/bluebrain/neurodamus/blob/main/docker/README.md

Builds the Neurodamus Docker image from the local Dockerfile. Optionally specify versions for libsonata, libsonatareport, and neuron.

```bash
cd docker/ 
docker build -t neurodamus .

```

```bash
docker build -t neurodamus --build-arg LIBSONATA_TAG=v0.1.21 --build-arg LIBSONATAREPORT_TAG=1.2.1 --build-arg NEURON_TAG=9.0a .
```