dendrotweaks 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

dendrotweaks/__init__.py

@@ -1,8 +1,8 @@
-__version__ = "0.3.1"
+__version__ = "0.4.0"
 
 from dendrotweaks.model import Model
 from dendrotweaks.simulators import NEURONSimulator
-from dendrotweaks.membrane.distributions import Distribution
+from dendrotweaks.biophys.distributions import Distribution
 from dendrotweaks.path_manager import PathManager
 from dendrotweaks.stimuli import Synapse, Population, IClamp
 

dendrotweaks/analysis/ephys_analysis.py

@@ -27,7 +27,7 @@ def get_somatic_data(model):
     seg = model.seg_tree.root
     iclamp = model.iclamps[seg]
 
-    v = np.array(model.simulator.vs[seg])
+    v = np.array(model.simulator.recordings['v'][seg])
     t = np.array(model.simulator.t)
     dt = model.simulator.dt
 
@@ -165,7 +165,7 @@ def detect_somatic_spikes(model, **kwargs):
     """
     seg = model.seg_tree.root
             
-    v = np.array(model.simulator.vs[seg])
+    v = np.array(model.simulator.recordings['v'][seg])
     t = np.array(model.simulator.t)
     dt = model.simulator.dt
 
@@ -271,7 +271,7 @@ def calculate_fI_curve(model, duration=1000, min_amp=0, max_amp=1, n=5, **kwargs
         n_spikes = len(spike_data['spike_times'])
         rate = n_spikes / iclamp.dur * 1000
         rates.append(rate)
-        vs[amp] = model.simulator.vs[seg]
+        vs[amp] = model.simulator.recordings['v'][seg]
 
     return {
         'current_amplitudes': amps,
@@ -336,11 +336,14 @@ def calculate_voltage_attenuation(model):
     if len(stimulated_segs) != 1:
         print("Only one stimulation site is supported")
         return None
-    recorded_segs = list(model.recordings.keys())
+    recorded_segs = list(model.recordings['v'].keys())
     if len(recorded_segs) < 2:
         print("At least two recording sites are required")
         return None
 
+    print(f"Stimulating segment: {stimulated_segs[0]}")
+    print(f"Recording segments: {recorded_segs}")
+
     stimulated_seg = stimulated_segs[0]
 
     iclamp = model.iclamps[stimulated_seg]
@@ -355,8 +358,9 @@ def calculate_voltage_attenuation(model):
     start_ts = int(iclamp.delay / model.simulator.dt)
     stop_ts = int((iclamp.delay + iclamp.dur) / model.simulator.dt)
 
-    voltage_at_stimulated = np.array(model.simulator.vs[stimulated_seg])[start_ts:stop_ts]
-    voltages = [np.array(model.simulator.vs[seg])[start_ts:stop_ts] for seg in recorded_segs]
+    voltage_at_stimulated = np.array(model.simulator.recordings['v'][stimulated_seg])[start_ts:stop_ts]
+    voltages = [np.array(model.simulator.recordings['v'][seg])[start_ts:stop_ts] for seg in recorded_segs]
+
 
     # Calculate voltage displacement from the resting potential
     delta_v_at_stimulated = voltage_at_stimulated[0] - np.min(voltage_at_stimulated)
@@ -405,7 +409,7 @@ def calculate_dendritic_nonlinearity(model, duration=1000, max_weight=None, n=No
         A dictionary containing the expected and observed voltage changes.
     """
 
-    recorded_segs = list(model.recordings.keys())
+    recorded_segs = list(model.recordings['v'].keys())
     seg = recorded_segs[0]
 
     populations = [pop for pops in model.populations.values() for pop in pops.values()]
@@ -432,7 +436,7 @@ def calculate_dendritic_nonlinearity(model, duration=1000, max_weight=None, n=No
     for w in weights:
         population.update_input_params(weight=w)
         model.simulator.run(duration)
-        v = np.array(model.simulator.vs[seg])
+        v = np.array(model.simulator.recordings['v'][seg])
         v_start = v[start_ts]
         v_max = np.max(v[start_ts:])
         delta_v = v_max - v_start

dendrotweaks/biophys/__init__.py

@@ -0,0 +1,7 @@
+from dendrotweaks.biophys.mechanisms import Mechanism, IonChannel, StandardIonChannel
+from dendrotweaks.biophys.mechanisms import CaDynamics, LeakChannel
+from dendrotweaks.biophys.mechanisms import LeakChannel
+from dendrotweaks.biophys.groups import SegmentGroup
+from dendrotweaks.biophys.distributions import Distribution
+
+import dendrotweaks.biophys.io as io

dendrotweaks/{membrane → biophys}/default_templates/NEURON_template.py

@@ -114,7 +114,7 @@ class Cell():
         {% for domain, mechanisms in domains_to_mechs.items() %}
         for sec in self.{{ domains_to_NEURON[domain] }}:
             {% for mechanism in mechanisms %}
-                sec.insert('{{ mechanism }}')
+            sec.insert('{{ mechanism }}')
             {%- endfor %}
         {% endfor %}
 
@@ -235,10 +235,12 @@ class Cell():
 
     def add_recordings(self):
         recordings = []
-        {% for seg, rec in recordings.items() %}
+        {% for var, recs in recordings.items() %}
+        {% for seg, rec in recs.items() %}
         rec = h.Vector()
-        rec.record(self.{{seg._section.domain}}[{{seg._section.domain_idx}}]({{seg.x}})._ref_v)
+        rec.record(self.{{seg._section.domain}}[{{seg._section.domain_idx}}]({{seg.x}})._ref_{{ var }})
         recordings.append(rec)
+        {%- endfor -%}
         {% endfor %}
         return recordings
 

dendrotweaks/{membrane → biophys}/default_templates/default.py

@@ -3,7 +3,7 @@
 
 import sys
 
-from dendrotweaks.membrane.mechanisms import IonChannel
+from dendrotweaks.biophys.mechanisms import IonChannel
 import numpy as np
 
 class {{ class_name }}(IonChannel):
@@ -43,6 +43,7 @@ class {{ class_name }}(IonChannel):
         }
         self.ion = "{{ ion }}"
         self.current_name = "i_{{ ion }}"
+        self.current_available = {{ current_available }}
         self.independent_var_name = "{{ independent_var_name }}"
         self.temperature = 37
 

dendrotweaks/{membrane → biophys}/default_templates/standard_channel.mod

@@ -23,7 +23,7 @@ UNITS {
 }
 
 PARAMETER {
-    {% for key, value, unit in range_params %}{{ "%-7s"|format(key) }} = {{ value }} ({{ unit }}){% if not loop.last %}
+    {% for key, value, unit in params %}{{ "%-7s"|format(key) }} = {{ value }} ({{ unit }}){% if not loop.last %}
     {% endif %}{% endfor %}
 }
 
@@ -57,7 +57,11 @@ DERIVATIVE states {
 }
 
 INITIAL {
+    {%- if has_tadj%}
     tadj = q10^((celsius - temp)/10(degC))
+    {%- else %}
+    tadj = 1
+    {%- endif %}
     rates(v)
     {% for state in state_vars %}{{ state }} = {{ state }}_inf
     {% endfor %}

dendrotweaks/{membrane → biophys}/groups.py

@@ -3,8 +3,8 @@ from typing import List, Callable, Dict
 from dendrotweaks.morphology.trees import Node
 from dendrotweaks.morphology.sec_trees import Section
 from dendrotweaks.morphology.seg_trees import Segment
-from dendrotweaks.membrane.mechanisms import Mechanism
-from dendrotweaks.membrane.distributions import Distribution
+from dendrotweaks.biophys.mechanisms import Mechanism
+from dendrotweaks.biophys.distributions import Distribution
 from dendrotweaks.utils import timeit
 from dataclasses import dataclass, field, asdict
 from typing import List, Tuple, Dict, Optional

dendrotweaks/biophys/io/__init__.py

@@ -0,0 +1,11 @@
+from dendrotweaks.biophys.io.loader import MODFileLoader
+from dendrotweaks.biophys.io.converter import MODFileConverter
+
+from dendrotweaks.biophys.io.reader import MODFileReader
+from dendrotweaks.biophys.io.parser import MODFileParser
+from dendrotweaks.biophys.io.code_generators import PythonCodeGenerator
+from dendrotweaks.biophys.io.code_generators import NMODLCodeGenerator
+
+from dendrotweaks.biophys.io.factories import create_channel
+from dendrotweaks.biophys.io.factories import create_standard_channel
+from dendrotweaks.biophys.io.factories import standardize_channel

dendrotweaks/{membrane → biophys}/io/ast.py

@@ -90,6 +90,12 @@ class AbstracSyntaxTree():
         return {k:v for k, v in self.params.items()
                 if k in self['NEURON']['range']}
 
+    @property
+    def current_available(self):
+        """
+        Returns True if the current is available in the mechanism.
+        """
+        return 'i' in self['NEURON']['range']
 
     # ASSIGNED block
     @property

dendrotweaks/{membrane → biophys}/io/code_generators.py

@@ -72,6 +72,7 @@ class PythonCodeGenerator(CodeGenerator):
             'independent_var_name': ast.independent_var_name,
             'channel_params': ast.params,
             'range_params': ast.range_params,
+            'current_available': ast.current_available,
             'state_vars': ast.state_vars,
             'functions': self._generate_functions(ast),
             'procedures': self._generate_procedures(ast),
@@ -296,10 +297,15 @@ class NMODLCodeGenerator(CodeGenerator):
         variables = {
             'suffix': channel.name,
             'ion': channel.ion,
-            'range_params': [
+            'params': [
                 (param, channel.params[param], get_unit(param))
                 for param in channel.params
             ],
+            'range_params': [
+                (param, channel.range_params[param], get_unit(param))
+                for param in channel.range_params
+            ],
+            'has_tadj': ('q10' in channel.params and 'temp' in channel.params),
             'state_vars': {
                 var: params['power'] for var, params in channel._state_powers.items()
             },

dendrotweaks/{membrane → biophys}/io/converter.py

@@ -1,6 +1,6 @@
-from dendrotweaks.membrane.io.reader import MODFileReader
-from dendrotweaks.membrane.io.parser import MODFileParser
-from dendrotweaks.membrane.io.code_generators import PythonCodeGenerator
+from dendrotweaks.biophys.io.reader import MODFileReader
+from dendrotweaks.biophys.io.parser import MODFileParser
+from dendrotweaks.biophys.io.code_generators import PythonCodeGenerator
 
 class MODFileConverter():
     """

dendrotweaks/{membrane → biophys}/io/factories.py

@@ -3,9 +3,9 @@ import sys
 from typing import List, Tuple
 
 
-from dendrotweaks.membrane.io.converter import MODFileConverter
-from dendrotweaks.membrane.io.code_generators import NMODLCodeGenerator
-from dendrotweaks.membrane.mechanisms import Mechanism, IonChannel, StandardIonChannel
+from dendrotweaks.biophys.io.converter import MODFileConverter
+from dendrotweaks.biophys.io.code_generators import NMODLCodeGenerator
+from dendrotweaks.biophys.mechanisms import Mechanism, IonChannel, StandardIonChannel
 
 
 def create_channel(path_to_mod_file: str,
@@ -86,10 +86,12 @@ def standardize_channel(channel: IonChannel,
                                           state_powers=channel._state_powers, 
                                           ion=channel.ion)
 
-    standard_channel.params.update({'q10': channel.params.get('q10'),
-                                    'temp': channel.params.get('temp')})
+    if 'q10' in channel.params:
+        standard_channel.params['q10'] = channel.params['q10']
+    if 'temp' in channel.params:
+        standard_channel.params['temp'] = channel.params['temp']
 
-    fit_temperature = channel.params.get('temp') or 23
+    fit_temperature = channel.params.get('temp')
 
     standard_channel.set_tadj(fit_temperature)
     # Fit the standard channel to the data

dendrotweaks/biophys/io/loader.py

@@ -0,0 +1,190 @@
+import os
+import sys
+import shutil
+import subprocess
+import neuron
+from neuron import h
+
+
+class MODFileLoader():
+
+    def __init__(self):
+        self._loaded_mechanisms = set()
+        self.verbose = False
+
+    def _log(self, message):
+        """Print a message if verbose mode is enabled."""
+        if self.verbose:
+            print(message)
+              
+    # LOADING METHODS
+
+    def _get_mechanism_dir(self, path_to_mod_file: str) -> str:
+        """
+        Get the subdirectory for the given mod file.
+
+        Parameters
+        ----------
+        path_to_mod_file : str
+            Path to the .mod file.
+
+        Returns
+        -------
+        str
+            Path to the subdirectory for the mechanism.
+        """
+        mechanism_name = os.path.basename(path_to_mod_file).replace('.mod', '')
+        parent_dir = os.path.dirname(path_to_mod_file)
+        if sys.platform.startswith('win'):
+            return os.path.join(parent_dir, mechanism_name, mechanism_name)
+        else:
+            return os.path.join(parent_dir, mechanism_name)
+
+    def _clean_mechanism_dir(self, mechanism_dir: str) -> None:
+        
+        if sys.platform.startswith('win'):
+            parent_dir = os.path.dirname(mechanism_dir)
+            shutil.rmtree(parent_dir)
+        else:
+            shutil.rmtree(mechanism_dir)
+
+
+    def load_mechanism(self, path_to_mod_file: str, 
+                       recompile: bool = False) -> None:
+        """
+        Load a mechanism from the specified mod file.
+        Uses the NEURON neuron.load_mechanisms method to make
+        the mechanism available in the hoc interpreter.
+        Creates a temporary directory for the mechanism files
+        to be able to dynamically load mechanisms.
+
+        Parameters
+        ----------
+        path_to_mod_file : str
+            Path to the .mod file.
+        recompile : bool
+            Force recompilation even if already compiled.
+        """
+        mechanism_name = os.path.basename(path_to_mod_file).replace('.mod', '')
+        mechanism_dir = self._get_mechanism_dir(path_to_mod_file)      
+
+        if self.verbose: print(f"{'=' * 60}\nLoading mechanism {mechanism_name} to NEURON...")
+
+        # Check if the mechanism is already loaded
+        if mechanism_name in self._loaded_mechanisms:
+            self._log(f'Mechanism "{mechanism_name}" already loaded')
+            return
+
+        if recompile and os.path.exists(mechanism_dir):
+            self._clean_mechanism_dir(mechanism_dir)
+
+        self._separate_and_compile(mechanism_name, mechanism_dir, path_to_mod_file)
+
+        # Load the mechanism
+        self._load_mechanism(mechanism_name, mechanism_dir)
+
+
+    # HELPER METHODS
+
+    def _separate_and_compile(self, mechanism_name, mechanism_dir, path_to_mod_file):
+        """
+        Separate the mechanism files into their own directory and compile them.
+        Separation is done to enable dynamic loading of mechanisms.
+        Compilation is done using the appropriate command based on the platform.
+        
+        Parameters
+        ----------
+        mechanism_name : str
+            Name of the mechanism.
+        mechanism_dir : str
+            Directory to store the mechanism files.
+        path_to_mod_file : str
+            Path to the .mod file.
+        """
+
+        if sys.platform.startswith('win'):
+            dll_file = os.path.join(os.path.dirname(mechanism_dir), 'nrnmech.dll')
+            if not os.path.exists(dll_file):
+                self._log(f'Compiling mechanism "{mechanism_name}"...')
+                os.makedirs(mechanism_dir, exist_ok=True)
+                shutil.copy(path_to_mod_file, mechanism_dir)
+                self._compile_files(mechanism_dir, ["mknrndll"], shell=True)
+        else:
+            x86_64_dir = os.path.join(mechanism_dir, 'x86_64')
+            if not os.path.exists(x86_64_dir):
+                self._log(f'Compiling mechanism "{mechanism_name}"...')
+                os.makedirs(mechanism_dir, exist_ok=True)
+                shutil.copy(path_to_mod_file, mechanism_dir)
+                self._compile_files(mechanism_dir, ["nrnivmodl"])
+
+
+    def _load_mechanism(self, mechanism_name: str, mechanism_dir: str) -> None:
+        """
+        Load the mechanism into NEURON using neuron.load_mechanisms.
+        This method checks if the mechanism is already loaded
+        and only loads it if not.
+        Parameters
+        ----------
+        mechanism_name : str
+            Name of the mechanism.
+        mechanism_dir : str
+            Directory containing the compiled mechanism files.
+        """
+
+        if hasattr(h, mechanism_name):
+            self._log(f'Mechanism "{mechanism_name}" already exists in hoc')
+        else:
+            try:
+                neuron.load_mechanisms(mechanism_dir)
+            except Exception as e:
+                print(f"Failed to load mechanism {mechanism_name}: {e}")
+                return
+        self._loaded_mechanisms.add(mechanism_name)
+        self._log(f'Loaded mechanism "{mechanism_name}"')
+        
+
+    
+    def _compile_files(self, path, command, shell=False):
+        """
+        Compile the MOD files in the specified directory.
+
+        Parameters
+        ----------
+        path : str or Path
+            Directory containing MOD files to compile.
+        command : list
+            Compilation command to execute. Either "mknrndll" or "nrnivmodl".
+        shell : bool
+            Whether to use shell=True for subprocess.run
+            (Windows compatibility).
+
+        Returns
+        -------
+        bool
+            True if compilation succeeded, False otherwise.
+        """
+        path_str = str(path)
+
+        try:
+            result = subprocess.run(
+                command,
+                cwd=path_str,
+                check=True,
+                capture_output=True,
+                text=True,
+                shell=shell
+            )
+
+            self._log("Compilation successful.")
+            if self.verbose and result.stdout:
+                print(result.stdout)
+            return
+
+        except subprocess.CalledProcessError as e:
+            print(f"Compilation failed with return code {e.returncode}")
+            if self.verbose:
+                if e.stdout:
+                    print("Compiler output:\n", e.stdout)
+                if e.stderr:
+                    print("Compiler errors:\n", e.stderr)
+            return

dendrotweaks/{membrane → biophys}/io/parser.py

@@ -2,14 +2,14 @@ import re
 import pprint
 from typing import List, Dict, Union, Any
 
-from dendrotweaks.membrane.io.grammar import title, comment_block
-from dendrotweaks.membrane.io.grammar import neuron_block
-from dendrotweaks.membrane.io.grammar import units_block, parameter_block, assigned_block
-from dendrotweaks.membrane.io.grammar import state_block
-from dendrotweaks.membrane.io.grammar import breakpoint_block, derivative_block, initial_block
-from dendrotweaks.membrane.io.grammar import function_block, procedure_block
-
-from dendrotweaks.membrane.io.ast import AbstracSyntaxTree
+from dendrotweaks.biophys.io.grammar import title, comment_block
+from dendrotweaks.biophys.io.grammar import neuron_block
+from dendrotweaks.biophys.io.grammar import units_block, parameter_block, assigned_block
+from dendrotweaks.biophys.io.grammar import state_block
+from dendrotweaks.biophys.io.grammar import breakpoint_block, derivative_block, initial_block
+from dendrotweaks.biophys.io.grammar import function_block, procedure_block
+
+from dendrotweaks.biophys.io.ast import AbstracSyntaxTree
 
 
 class MODFileParser():

dendrotweaks/{membrane → biophys}/mechanisms.py

@@ -32,6 +32,7 @@ class Mechanism():
         self.name = name
         self.params = {}
         self.range_params = {}
+        self.current_available = False
 
     @property
     def params_with_suffix(self):
@@ -119,9 +120,12 @@ class IonChannel(Mechanism):
         where q10 is the temperature coefficient and reference_temp is the
         temperature at which the channel kinetics were measured.
         """
-        q10 = self.params.get("q10", 2.3)
-        reference_temp = self.params.get("temp", temperature)
-        self.tadj = q10 ** ((temperature - reference_temp) / 10)
+        q10 = self.params.get("q10")
+        reference_temp = self.params.get("temp")
+        if q10 is None or reference_temp is None:
+            self.tadj = 1
+        else:
+            self.tadj = q10 ** ((temperature - reference_temp) / 10)
 
     def get_data(self, x=None, temperature: float = 37, verbose=True) -> Dict[str, Dict[str, float]]:
         """
@@ -367,14 +371,14 @@ class StandardIonChannel(IonChannel):
         #             for param in self.STANDARD_PARAMS]
 
         self.params = {
+            'gbar': 0.0,
+            **{
             f'{param}_{state}': None
             for state in state_powers
             for param in self.STANDARD_PARAMS
+            }
         }
-        self.params.update({
-            'gbar': 0.0,
-        })
-        self.range_params = self.params.copy()
+        self.range_params = {k:v for k, v in self.params.items()}
 
         self.temperature = 37
 
@@ -474,9 +478,9 @@ class StandardIonChannel(IonChannel):
                 fit_result.params = {key: round(value, round_params) for key, value in fit_result.params.items()}
 
             for param in ['k', 'delta', 'tau0', 'vhalf', 'sigma']:
-                self.params[f'{param}_{state}'] = fit_result.params[param]
-
-        self.range_params = self.params.copy()
+                value = fit_result.params[param]
+                self.params[f'{param}_{state}'] = value
+                self.range_params[f'{param}_{state}'] = value
     
     
     def to_dict(self):