bluerecording 0.4.0__tar.gz

bluerecording-0.4.0/.gitignore

@@ -0,0 +1,58 @@
+x86_64/
+**/core*
+figures/
+positions_all_new/
+positions_all_new_big/
+**/*coeffs*.h5
+*.SUCCESS
+networks/
+!examples/compare-to-reference-solutions_old/data/configuration/networks/
+!examples/single_cell_l5_tpc/configuration/networks/
+network/
+examples/allen/data/simulation/configuration/components
+bkg_inputs/
+atlas/
+reporting/
+!examples/compare-to-reference-solutions_old/data/reporting/
+reporting_small/
+reporting_big/
+output_sonata/
+**/*.png
+**/*.pyc
+**/*.log
+**/*.out
+mod/
+.ipynb_checkpoints/
+**/*.dat
+**/*.swp
+**/*.swn
+**/*.swo
+**/*.err
+build/
+bluerecording.egg-info
+.exception_node
+*.nrrd
+neurodamus/
+positions/
+*.pkl
+!*_ref.pkl
+venv/
+*_venv/
+env.sh
+pkls/
+pkls_big/
+htmlcov/
+**/EEG.h5
+**/ECoG.h5
+**/LFP.h5
+*removeme*
+*DS_Store
+*Infinite_VeryFar_HighRes.h5
+*Infinite_Close_HighRes_SmallSphere.h5
+libsonatareport/
+neurodamus-models/
+nrn/
+.code
+.kiro
+*output/
+.vscode/

bluerecording-0.4.0/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: bluerecording
+Version: 0.4.0
+Summary: A tool for calculating extracellular recording lead fields
+Requires-Python: <3.14,>=3.10
+Requires-Dist: h5py
+Requires-Dist: libsonata
+Requires-Dist: morphio
+Requires-Dist: mpi4py
+Requires-Dist: neurodamus>=4.2.1
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: voxcell
+Provides-Extra: all
+Requires-Dist: bluepysnap; extra == 'all'
+Requires-Dist: ipympl; extra == 'all'
+Requires-Dist: jupyterlab; extra == 'all'
+Requires-Dist: neuron; extra == 'all'
+Requires-Dist: pytest; extra == 'all'
+Requires-Dist: pytest-forked; extra == 'all'
+Requires-Dist: pytest-mpi; extra == 'all'
+Provides-Extra: neuron
+Requires-Dist: neuron; extra == 'neuron'
+Provides-Extra: notebooks
+Requires-Dist: bluepysnap; extra == 'notebooks'
+Requires-Dist: ipympl; extra == 'notebooks'
+Requires-Dist: jupyterlab; extra == 'notebooks'
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-forked; extra == 'test'
+Requires-Dist: pytest-mpi; extra == 'test'

bluerecording-0.4.0/bluerecording/__init__.py

@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+from importlib.metadata import version
+
+__version__ = version("bluerecording")
+
+
+def _check_dependencies():
+    """Verify runtime dependencies that need special attention.
+
+    - h5py is declared in pyproject.toml but must be the MPI-enabled build.
+      The default pip wheel lacks MPI support.
+    - neuron is an optional extra ([neuron]). Required at runtime but kept
+      optional because it may be built from source.
+    """
+    import h5py
+
+    if not h5py.get_config().mpi:
+        raise ImportError(
+            "h5py is installed but was built without MPI support.\n"
+            "bluerecording requires parallel HDF5 I/O.\n"
+            "Fix with:\n"
+            "  pip uninstall h5py\n"
+            "  HDF5_MPI=ON pip install --no-cache-dir --no-binary=h5py h5py "
+            "--no-build-isolation\n"
+            "Or use './dev_setup.sh' followed by 'source env.sh' "
+            "which handles this automatically."
+        )
+
+    try:
+        import neuron  # noqa: F401
+    except ImportError:
+        raise ImportError(
+            "bluerecording requires NEURON.\n"
+            "Install with: pip install bluerecording[neuron]\n"
+            "Or use './dev_setup.sh' followed by 'source env.sh' "
+            "to build from source."
+        )
+
+
+_check_dependencies()

bluerecording-0.4.0/bluerecording/circuit.py

@@ -0,0 +1,68 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Shared circuit initialization via neurodamus.
+
+Provides the entry point for loading a circuit model and extracting
+the discretization info (node IDs, compartment structure, morphology access)
+needed by both get_positions and write_weights.
+"""
+import libsonata
+import numpy as np
+
+from .utils import get_circuit_path
+
+
+def init_circuit(path_to_simconfig: str):
+    """Initialize neurodamus and extract circuit discretization info.
+
+    Args:
+        path_to_simconfig: Path to the SONATA simulation configuration file.
+
+    Returns:
+        node_manager: The neurodamus node manager for the single population.
+        ids: GIDs assigned to this MPI rank.
+        cols: (N, 2) int64 array of (gid, section) pairs describing every
+            compartment on this rank.
+        population: libsonata NodePopulation, needed for morphology file
+            resolution.
+        population_name: Name of the SONATA node population.
+        morphologies_dir: Fully resolved path to the morphologies directory,
+            as provided by libsonata.
+    """
+    # Lazy import: neurodamus pulls in NEURON, which is not available
+    # in lightweight installs (e.g. CI with --quick).
+    import neurodamus
+
+    nd = neurodamus.Neurodamus(
+        path_to_simconfig,
+        disable_reports=True,
+        direct_mode=True,
+        build_model=True,
+        enable_coord_mapping=True,
+        keep_build=False,
+        simulator="NEURON",
+    )
+    assert len(nd.circuits.node_managers) == 1, (
+        "Multiple or no node managers are not allowed for the moment"
+    )
+    node_manager = next(iter(nd.circuits.node_managers.values()))
+
+    ids = node_manager.get_final_gids()
+    points = node_manager.target_manager.get_target(None).get_point_list(
+        node_manager,
+        libsonata.SimulationConfig.Report.Sections.all,
+        libsonata.SimulationConfig.Report.Compartments.all,
+    )
+    cols = np.array(
+        [(p.gid, s) for p in points for s in sorted(p.sclst_ids)],
+        dtype=np.int64,
+    ).reshape(-1, 2)
+
+    population_name = node_manager.population_name
+
+    circuit_conf = libsonata.CircuitConfig.from_file(
+        get_circuit_path(path_to_simconfig)
+    )
+    population = circuit_conf.node_population(population_name)
+    morphologies_dir = circuit_conf.node_population_properties(population_name).morphologies_dir
+
+    return node_manager, ids, cols, population, population_name, morphologies_dir

bluerecording-0.4.0/bluerecording/cli.py

@@ -0,0 +1,131 @@
+import argparse
+from pathlib import Path
+from . import positions
+from .circuit import init_circuit
+from .weights import DEFAULT_SIGMA, write_h5_file
+from .weights import initialize_h5_file
+from . import __version__
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="bluerecording",
+        description="Bluerecording CLI"
+    )
+
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}"
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # write_positions command
+    gp_parser = subparsers.add_parser(
+        "write_positions",
+        help="Compute and save segment positions to disk"
+    )
+    gp_parser.add_argument(
+        "path_to_simconfig",
+        type=str,
+        help="Path to the simulation configuration file"
+    )
+    gp_parser.add_argument(
+        "path_to_positions_folder",
+        type=str,
+        help="Path to the folder where positions will be stored"
+    )
+    gp_parser.add_argument(
+        "--no-replace-axons",
+        action="store_false",
+        dest="replace_axons",
+        help="Do not replace existing axons (default: replace)"
+    )
+
+    # write_weights command
+    ww_parser = subparsers.add_parser(
+        "write_weights",
+        help="Compute electrode weights for all cells in the circuit"
+    )
+    ww_parser.add_argument(
+        "path_to_simconfig",
+        type=str,
+        help="Path to the simulation configuration file"
+    )
+    ww_parser.add_argument(
+        "electrode_csv",
+        type=str,
+        help="Path to the electrode CSV file"
+    )
+    ww_parser.add_argument(
+        "output_path",
+        type=str,
+        help="Path to the output H5 weights file, or a directory (weights.h5 will be created inside)"
+    )
+    ww_parser.add_argument(
+        "--no-replace-axons",
+        action="store_false",
+        dest="replace_axons",
+        help="Do not replace existing axons (default: replace)"
+    )
+    ww_parser.add_argument(
+        "--sigma",
+        type=float,
+        nargs="+",
+        default=None,
+        help=f"Extracellular conductivity in S/m (default: {DEFAULT_SIGMA})"
+    )
+    ww_parser.add_argument(
+        "--path-to-fields",
+        type=str,
+        nargs="+",
+        default=None,
+        help="Path(s) to H5 potential field files for reciprocity electrodes"
+    )
+    ww_parser.add_argument(
+        "--with-neurite-type",
+        action="store_true",
+        default=False,
+        dest="with_neurite_type",
+        help="Append a neurite_types dataset to the weights file",
+    )
+    ww_parser.add_argument(
+        "--write-positions",
+        action="store_true",
+        default=False,
+        dest="write_positions",
+        help="Also save segment positions alongside the weights file",
+    )
+
+    args = parser.parse_args()
+
+    if args.command == "write_positions":
+        node_manager, ids, cols, population, _, morphologies_dir = init_circuit(args.path_to_simconfig)
+        positions_df, _, _ = positions.get_positions(
+            node_manager, ids, cols, population,
+            morphologies_dir=morphologies_dir,
+            replace_axons=args.replace_axons,
+        )
+        positions.save_positions(positions_df, args.path_to_positions_folder)
+
+    elif args.command == "write_weights":
+        node_manager, ids, cols, population, population_name, morphologies_dir = init_circuit(args.path_to_simconfig)
+        positions_df, cols, neurite_types = positions.get_positions(
+            node_manager, ids, cols, population,
+            morphologies_dir=morphologies_dir,
+            replace_axons=args.replace_axons,
+        )
+        output_file = Path(args.output_path)
+        if output_file.is_dir() or not output_file.suffix:
+            output_file.mkdir(parents=True, exist_ok=True)
+            output_file = output_file / "weights.h5"
+        elif output_file.suffix != ".h5":
+            parser.error(f"output_path must be a directory or an .h5 file, got '{output_file}'")
+
+        initialize_h5_file(cols, population_name, str(output_file), args.electrode_csv,
+                         with_neurite_type=args.with_neurite_type)
+        write_h5_file(positions_df, cols, population_name, str(output_file),
+                    sigma=args.sigma, path_to_fields=args.path_to_fields,
+                    neurite_types=neurite_types if args.with_neurite_type else None)
+        if args.write_positions:
+            positions.save_positions(positions_df, output_file.parent)