dendrotweaks 0.4.4__py3-none-any.whl → 0.4.6__py3-none-any.whl

dendrotweaks/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.4.4"
+__version__ = "0.4.6"
 
 from dendrotweaks.model import Model
 from dendrotweaks.simulators import NeuronSimulator

dendrotweaks/analysis/__init__.py

@@ -8,4 +8,5 @@ from dendrotweaks.analysis.ephys_analysis import plot_passive_properties
 from dendrotweaks.analysis.ephys_analysis import calculate_voltage_attenuation
 from dendrotweaks.analysis.ephys_analysis import plot_voltage_attenuation
 from dendrotweaks.analysis.ephys_analysis import calculate_dendritic_nonlinearity
-from dendrotweaks.analysis.ephys_analysis import plot_dendritic_nonlinearity
+from dendrotweaks.analysis.ephys_analysis import plot_dendritic_nonlinearity
+from dendrotweaks.analysis.ephys_analysis import calculate_sag_ratio

dendrotweaks/analysis/ephys_analysis.py

@@ -38,6 +38,11 @@ def get_somatic_data(model):
 def calculate_input_resistance(model):
     """
     Calculate the input resistance of the neuron model.
+        
+    This function determines the input resistance by calculating the ratio 
+    between the voltage change and the injected current. The voltage change 
+    is measured as the difference between the membrane potential at the onset 
+    and offset of the current injection.
 
     Parameters
     ----------
@@ -52,13 +57,11 @@ def calculate_input_resistance(model):
     
     v, t, dt, iclamp = get_somatic_data(model)
 
-    v_min = np.min(v)
-    
     amp = iclamp.amp
-    start_ts = iclamp.delay / dt
-    end_ts = int((iclamp.delay + iclamp.dur) / dt)
+    start_ts = int(iclamp.delay / dt)
+    stop_ts = int((iclamp.delay + iclamp.dur) / dt)
     v_onset = v[int(start_ts)]
-    v_offset = v[int(end_ts)]
+    v_offset = v[int(stop_ts)]
     
     R_in = (v_onset - v_offset) / amp
     print(f"Input resistance: {R_in:.2f} MOhm")
@@ -71,44 +74,61 @@ def calculate_input_resistance(model):
     }
 
 
-def _exp_decay(t, A, tau):
-    return A * np.exp(-t / tau)
-
+def _double_exp_decay(t, A1, tau1, A2, tau2):
+    return A1 * np.exp(-t / tau1) + A2 * np.exp(-t / tau2)
 
 def calculate_time_constant(model):
     """
-    Calculate the membrane time constant of the neuron model.
+    Estimate the passive membrane time constant (τm) by fitting
+    a double exponential to the somatic voltage decay and selecting
+    the slowest τ component.
 
     Parameters
     ----------
     model : Model
-        The neuron model.
+        The neuron model (assumes Ih is disabled).
 
     Returns
     -------
     dict
-        A dictionary containing the time constant and the exponential fit.
+        A dictionary with τm (slowest), both τs, and fit details.
     """
     v, t, dt, iclamp = get_somatic_data(model)
 
     start_ts = int(iclamp.delay / dt)
     stop_ts = int((iclamp.delay + iclamp.dur) / dt)
     min_ts = np.argmin(v[start_ts:stop_ts]) + start_ts
-    v_min = np.min(v[start_ts: min_ts])
+    v_min = v[min_ts]
     v_decay = v[start_ts: min_ts] - v_min
     t_decay = t[start_ts: min_ts] - t[start_ts]
-    popt, _ = curve_fit(_exp_decay, t_decay, v_decay, p0=[1, 100])
-    tau = popt[1]
-    A = popt[0]
-    print(f"Membrane time constant: {tau:.2f} ms")
+
+    # Fit double exponential
+    try:
+        popt, _ = curve_fit(
+            _double_exp_decay, t_decay, v_decay, 
+            p0=[1, 10, 0.5, 100], 
+            bounds=(0, [np.inf, 1000, np.inf, 1000])
+        )
+        A1, tau1, A2, tau2 = popt
+        tau_slowest = max(tau1, tau2)
+    except RuntimeError:
+        print("Fit failed. Could not estimate time constant.")
+        return None
+
+    print(f"Time constant {tau_slowest:.2f} ms. Estimated from double exp fit (slowest component)")
+
     return {
-        'time_constant': tau,
-        'A': A,
+        'time_constant': tau_slowest,
         'start_time': start_ts * dt,
+        'tau1': tau1,
+        'tau2': tau2,
+        'A1': A1,
+        'A2': A2,
         'decay_time': t_decay,
         'decay_voltage': v_decay
     }
 
+
 def calculate_passive_properties(model):
     """
     Calculate the passive properties of the neuron model.
@@ -140,7 +160,6 @@ def plot_passive_properties(data, ax=None):
     v_offset = data['offset_voltage']
     t_decay = data['decay_time']
     v_decay = data['decay_voltage']
-    A = data['A']
     start_t = data['start_time']
 
     ax.set_title(f"R_in: {R_in:.2f} MOhm, Tau: {tau:.2f} ms")
@@ -148,8 +167,10 @@ def plot_passive_properties(data, ax=None):
     ax.axhline(v_offset, color='gray', linestyle='--', label='V offset')
     
     # Shift the exp_decay output along the y-axis
-    shifted_exp_decay = _exp_decay(t_decay, A, tau) + v_offset
-    ax.plot(t_decay + start_t, shifted_exp_decay, color='red', label='Exp. fit', linestyle='--')
+    fit_curve = _double_exp_decay(t_decay, data['A1'], data['tau1'], data['A2'], data['tau2']) + v_offset
+    label = f'Double exp fit (tau1 = {data["tau1"]:.1f} ms, tau2 = {data["tau2"]:.1f} ms)'
+
+    ax.plot(t_decay + start_t, fit_curve, color='red', label='Exp. fit', linestyle='--')
     ax.legend()
 
 
@@ -236,7 +257,7 @@ def plot_somatic_spikes(data, ax=None, show_metrics=False):
             ax.plot([t - 10*w/2, t + 10*w/2], [v - a/2, v - a/2], color='lawngreen', linestyle='--')
 
 
-def calculate_fI_curve(model, duration=1000, min_amp=0, max_amp=1, n=5, **kwargs):
+def calculate_fI_curve(model, duration=1000, prerun_time=0, min_amp=0, max_amp=1, n=5, **kwargs):
     """
     Calculate the frequency-current (f-I) curve of the neuron model.
 
@@ -268,7 +289,7 @@ def calculate_fI_curve(model, duration=1000, min_amp=0, max_amp=1, n=5, **kwargs
     vs = {}
     for amp in amps:
         iclamp.amp = amp
-        model.simulator.run(duration)
+        model.run(duration=duration, prerun_time=prerun_time)
         spike_data = detect_somatic_spikes(model, **kwargs)
         n_spikes = len(spike_data['spike_times'])
         rate = n_spikes / iclamp.dur * 1000
@@ -283,7 +304,22 @@ def calculate_fI_curve(model, duration=1000, min_amp=0, max_amp=1, n=5, **kwargs
     }
 
 
-def plot_fI_curve(data, ax=None, **kwargs):
+def plot_fI_curve(data, ax=None, vshift=200, **kwargs):
+    """
+    Plot the f-I curve and somatic voltage traces.
+
+    Parameters
+    ----------
+    data : dict
+        A dictionary containing the current amplitudes, firing rates, and voltages.
+        Can be obtained from `calculate_fI_curve`.
+    ax : matplotlib.axes.Axes, optional
+        The axes to plot on. If two axes are provided, the first will show the somatic voltage traces and the second will show the f-I curve.
+        If a single axis is provided, it will show the f-I curve only.
+        If None, a new figure will be created.
+    vshift : int, optional
+        The vertical shift for the somatic voltage traces. Default is 200.
+    """
 
     if ax is None:
         _, ax = plt.subplots(1, 2, figsize=(5, 5))
@@ -293,25 +329,20 @@ def plot_fI_curve(data, ax=None, **kwargs):
     vs = data['voltages']
     t = data['time']
 
-    for i, (amp, v) in enumerate(vs.items()):
-        ax[0].plot(t, np.array(v) - i*200, label=f'{amp} nA')
-    # ax[0].set_xlabel('Time (ms)')
-    # ax[0].set_ylabel('Voltage (mV)')
-    ax[0].set_title('Somatic spikes')
-    ax[0].legend()
-    ax[0].spines['top'].set_visible(False)
-    ax[0].spines['right'].set_visible(False)
-    ax[0].spines['bottom'].set_visible(False)
-    ax[0].spines['left'].set_visible(False)
-    ax[0].set_xticks([])
-    ax[0].set_yticks([])
+    if isinstance(ax, (list, np.ndarray)):        
+        for i, (amp, v) in enumerate(vs.items()):
+            ax[0].plot(t, np.array(v) - i*vshift, label=f'{amp} nA')
+        ax[0].set_title('Somatic spikes')
+        ax[0].legend()
+        ax[0].axis('off')
+        ax = ax[1]
     
-    ax[1].plot(amps, rates, color='gray', zorder=0)
+    ax.plot(amps, rates, color='gray', zorder=0)
     for a, r in zip(amps, rates):
-        ax[1].scatter(a, r, s=50, edgecolor='white')
-    ax[1].set_xlabel('Current (nA)')
-    ax[1].set_ylabel('Firing rate (Hz)')
-    ax[1].set_title('f-I curve')
+        ax.plot(a, r, 'o', zorder=1)
+    ax.set_xlabel('Current (nA)')
+    ax.set_ylabel('Firing rate (Hz)')
+    ax.set_title('f-I curve')
 
 
 # =============================================================================
@@ -365,16 +396,18 @@ def calculate_voltage_attenuation(model):
 
 
     # Calculate voltage displacement from the resting potential
-    delta_v_at_stimulated = voltage_at_stimulated[0] - np.min(voltage_at_stimulated)
-    delta_vs = [v[0] - np.min(v) for v in voltages]
+    delta_v_at_stimulated = voltage_at_stimulated[0] - voltage_at_stimulated[-2]# np.min(voltage_at_stimulated)
+    delta_vs = [v[0] - v[-2] for v in voltages] # np.min(v) for v in voltages]
 
     min_voltages = [np.min(v) for v in voltages]
+    end_voltages = [v[-2] for v in voltages]
 
     attenuation = [dv / delta_v_at_stimulated for dv in delta_vs]
 
     return {
         'path_distances': path_distances,
         'min_voltages': min_voltages,
+        'end_voltages': end_voltages,
         'attenuation': attenuation
     }
 
@@ -393,7 +426,7 @@ def plot_voltage_attenuation(data, ax=None):
     ax.set_ylabel('Voltage attenuation')
     ax.set_title('Voltage attenuation')
 
-def calculate_dendritic_nonlinearity(model, duration=1000, max_weight=None, n=None):
+def calculate_dendritic_nonlinearity(model, duration=1000, prerun_time=0, max_weight=None, n=None):
     """Calculate the expected and observed voltage changes for a range of synaptic weights.
 
     Parameters
@@ -437,7 +470,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)
+        model.run(duration=duration, prerun_time=prerun_time)
         v = np.array(model.simulator.recordings['v'][seg])
         v_start = v[start_ts]
         v_max = np.max(v[start_ts:])
@@ -456,7 +489,22 @@ def calculate_dendritic_nonlinearity(model, duration=1000, max_weight=None, n=No
     }
 
 
-def plot_dendritic_nonlinearity(data, ax=None, **kwargs):
+def plot_dendritic_nonlinearity(data, ax=None, vshift=200, **kwargs):
+    """
+    Plot the dendritic nonlinearity based on expected and observed voltage changes.
+
+    Parameters
+    ----------
+    data : dict
+        A dictionary containing the expected and observed voltage changes.
+        Can be obtained from `calculate_dendritic_nonlinearity`.
+    ax : matplotlib.axes.Axes, optional
+        The axes to plot on. If two axes are provided, the first will show the voltage traces and the second will show the dendritic nonlinearity.
+        If a single axis is provided, it will show the dendritic nonlinearity only.
+        If None, a new figure will be created.
+    vshift : int, optional
+        The vertical shift for the voltage traces.
+    """
     
     if ax is None:
         _, ax = plt.subplots(1, 2, figsize=(10, 5))
@@ -466,23 +514,53 @@ def plot_dendritic_nonlinearity(data, ax=None, **kwargs):
     vs = data['voltages']
     t = data['time']
 
-    for i, (weight, v) in enumerate(vs.items()):
-        ax[0].plot(t, np.array(v) - i*200, label=f'{weight} synapses')
-    ax[0].set_title('Voltage traces')
-    ax[0].legend()
-    ax[0].spines['top'].set_visible(False)
-    ax[0].spines['right'].set_visible(False)
-    ax[0].spines['bottom'].set_visible(False)
-    ax[0].spines['left'].set_visible(False)
-    ax[0].set_xticks([])
-    ax[0].set_yticks([])
-
-    ax[1].plot(expected_delta_vs, delta_vs, 'o-')
-    ax[1].plot(expected_delta_vs, expected_delta_vs, color='gray', linestyle='--')
-    ax[1].set_xlabel('Expected voltage change (mV)')
-    ax[1].set_ylabel('Observed voltage change (mV)')
-    ax[1].set_title('Dendritic nonlinearity')
+    if isinstance(ax, (list, np.ndarray)):        
+        for i, (weight, v) in enumerate(vs.items()):
+            ax[0].plot(t, np.array(v) - i*vshift, label=f'{weight} synapses')
+        ax[0].set_title('Voltage traces')
+        ax[0].legend()
+        ax[0].axis('off')
+        ax = ax[1]
+    
+    ax.plot(expected_delta_vs, delta_vs, zorder=1)
+    ax.plot(expected_delta_vs, expected_delta_vs, color='gray', linestyle='--', zorder=0)
+    for ep, ob in zip(expected_delta_vs, delta_vs):
+        ax.plot(ep, ob, 'o', zorder=2)
+    ax.set_xlabel('Expected voltage change (mV)')
+    ax.set_ylabel('Observed voltage change (mV)')
+    ax.set_title('Dendritic nonlinearity')
     
 
+def calculate_sag_ratio(model):
+    """
+    Calculate the sag ratio of the neuron model.
+
+    Parameters
+    ----------
+    model : Model
+        The neuron model.
 
+    Returns
+    -------
+    dict
+        A dictionary containing the sag ratio and intermediate values.
+    """
+    v, t, dt, iclamp = get_somatic_data(model)
+
+    start_ts = int(iclamp.delay / dt)
+    stop_ts = int((iclamp.delay + iclamp.dur) / dt)
+    min_ts = np.argmin(v[start_ts:stop_ts]) + start_ts
+    v_min = np.min(v[start_ts: min_ts])
+
+    a = v[stop_ts] - v_min
+    b = v[start_ts] - v_min
+
+    sag_ratio = a / b if b != 0 else np.nan
+
+    print(f"Sag ratio: {a:.2f}/{b:.2f} = {sag_ratio:.2f}")
+    return {
+        'a': a,
+        'b': b,
+        'sag_ratio': sag_ratio,
+    }
 

dendrotweaks/biophys/default_mod/vecstim.mod

@@ -1,6 +1,7 @@
 :  Vector stream of events
 
 NEURON {
+	THREADSAFE
 	ARTIFICIAL_CELL VecStim
 	RANGE delay
 }
@@ -12,13 +13,8 @@ ASSIGNED {
 	delay
 }
 
-PARAMETER { 
-	:delay = 0.0
-} 
-
 INITIAL {
 	index = 0
-	:delay = 0
 	element()
 	if (index > 0) {
 		net_send(delay + etime - t, 1)
@@ -35,12 +31,6 @@ NET_RECEIVE (w) {
 	}
 }
 
-VERBATIM
-extern double* vector_vec();
-extern int vector_capacity();
-extern void* vector_arg();
-ENDVERBATIM
-
 PROCEDURE element() {
 VERBATIM	
   { void* vv; int i, size; double* px;

dendrotweaks/biophys/default_templates/jaxley.py

@@ -0,0 +1,131 @@
+# This Python channel class was automatically generated from a MOD file
+# using DendroTweaks toolbox, dendrotweaks.dendrites.gr
+
+
+from jaxley.channels import Channel
+from jaxley.solver_gate import exponential_euler
+import jax.numpy as np
+
+class {{ class_name }}(Channel):
+    """
+    {{ title }}
+    """
+
+    def __init__(self, name="{{ class_name }}"):
+        self.current_is_in_mA_per_cm2 = True
+        super().__init__(name=name)
+        self.channel_params = {
+            {% for param, value in channel_params.items() -%}
+            "{{ param }}_{{ class_name }}": {{ value }}
+                {%- if not loop.last -%},
+                {%- endif %}
+            {% endfor -%}
+        }
+        self.channel_states = {
+            {% for state in state_vars -%}
+            "{{ state }}_{{class_name}}": 0.0
+                {%- if not loop.last %},
+                {%- endif %}
+            {% endfor -%}
+        }
+        self._state_powers = {
+            {% for state, power in state_vars.items() -%}
+            "{{ state }}_{{class_name}}": {{ power }}
+                {%- if not loop.last %},
+                {%- endif %}
+            {% endfor -%}
+        }
+        self.ion = "{{ ion }}"
+        self.current_name = "i_{{ ion }}"
+
+        self.independent_var_name = "{{ independent_var_name }}"
+        self.tadj = 1
+
+    def set_tadj(self, temperature):
+        """
+        Set the temperature adjustment factor for the channel kinetics.
+
+        Parameters
+        ----------
+        temperature : float
+            The temperature in degrees Celsius.
+
+        Notes
+        -----
+        The temperature adjustment factor is calculated as:
+        tadj = q10 ** ((temperature - reference_temp) / 10)
+        where q10 is the temperature coefficient and reference_temp is the
+        temperature at which the channel kinetics were measured.
+        """
+        q10 = self.channel_params.get(f"q10_{{ class_name }}")
+        reference_temp = self.channel_params.get(f"temp_{{ class_name }}")
+        if q10 is None or reference_temp is None:
+            self.tadj = 1
+            print(f"Warning: q10 or reference temperature not set for {self.name}. Using default tadj = 1.")
+        else:
+            self.tadj = q10 ** ((temperature - reference_temp) / 10)
+
+    def __getitem__(self, item):
+        return self.channel_params[item]
+
+    def __setitem__(self, item, value):
+        self.channel_params[item] = value
+        
+    {% for function in functions %}
+    {{ function['signature'] }}
+        {%- for param in function['params'] -%}
+        {{ param }} = self.channel_params.get("{{ param }}_{{ class_name }}", 1)
+        {% endfor %}
+        {{ function['body'] }}
+    {% if not loop.last %}
+    {% endif %}{% endfor -%}
+    {% for procedure in procedures %}
+    {{ procedure['signature'] }}
+        {% for param in procedure['params'] -%}
+        {{ param }} = self.channel_params.get("{{ param }}_{{ class_name }}", 1)
+        {% endfor %}
+        {{ procedure['body'] }}
+    {%- if not loop.last %}
+    {% endif %}{% endfor %}
+
+    def update_states(self, states, dt, v, params):
+        {% for state, state_params in state_vars.items() -%}
+        {{state}} = states['{{ state }}_{{class_name}}']
+            {%- if not loop.last %}
+            {%- endif %}
+        {% endfor -%}
+        {{- procedure_calls}}
+        {% for state in state_vars.keys() %}new_{{state}} = exponential_euler({{state}}, dt, {{state}}Inf, {{state}}Tau){% if not loop.last %}
+        {% endif %}{% endfor %}
+        return {
+            {% for state in state_vars -%}
+            "{{ state }}_{{class_name}}": new_{{state}}
+                {%- if not loop.last %},
+                {%- endif %}
+            {% endfor -%}
+        }
+
+    def compute_current(self, states, v, params):
+        {% for state in state_vars.keys() -%}
+        {{state}} = states['{{ state }}_{{class_name}}']
+            {%- if not loop.last %}
+            {%- endif %}
+        {% endfor -%}
+        gbar = params["gbar_{{class_name}}"]
+        # E = params["E_{{ ion }}"]
+        E = {{ E_ion }}
+        {{ procedure_calls}}
+        g = self.tadj * gbar *{% for state, power in state_vars.items()%} {{state}}**{{power['power']}} {% if not loop.last %}*{% endif %}{% endfor %}
+        return g * (v - E)
+
+    def init_state(self, states, v, params, delta_t):
+        {{ procedure_calls}}
+        return {
+            {% for state in state_vars.keys() -%}
+            "{{ state }}_{{class_name}}": {{state}}Inf 
+                {%- if not loop.last %},
+                {%- endif %}
+            {% endfor -%}
+        }
+
+

dendrotweaks/biophys/distributions.py

@@ -131,16 +131,16 @@ def gaussian(distance: float, amplitude: float, mean: float, std: float) -> floa
     return amplitude * exp(-((distance - mean) ** 2) / (2 * std ** 2))
 
 
-def step(distance: float, max_value: float,  min_value: float, start: float, end: float) -> float:
+def step(distance: float, start: float, end: float, min_value: float, max_value: float) -> float:
     """
     Step distribution function.
 
     Args:
         distance (float): The distance parameter.
-        min_value (float): The minimum value parameter.
-        max_value (float): The maximum value parameter.
         start (float): The start parameter.
         end (float): The end parameter.
+        min_value (float): The minimum value parameter.
+        max_value (float): The maximum value parameter.
 
     Returns:
         The result of the step equation: min_value if distance < start, max_value if distance > end, and a linear interpolation between min_value and max_value if start <= distance <= end.

dendrotweaks/biophys/io/converter.py

@@ -94,6 +94,10 @@ class MODFileConverter():
         self.reader.read_file(path_to_mod_file)
         self.reader.preprocess()
         blocks = self.reader.get_blocks(verbose)
+        if blocks.get('KINETIC'):
+            raise NotImplementedError(
+                "Conversion aborted: MOD files containing KINETIC blocks are not supported by DendroTweaks."
+            )
         
         if verbose: print(f"\nPARSING")
         self.parser.parse(blocks, verbose)

dendrotweaks/biophys/mechanisms.py

@@ -575,4 +575,14 @@ class CaDynamics(Mechanism):
             'gamma': 0.05,
             'kt': 0.0,
             'kd': 0.0
-        }
+        }
+
+
+class FallbackChannel(IonChannel):
+    """
+    Fallback channel class in case of import failure.
+    """
+    def __init__(self, name):
+        super().__init__(name=name)
+        self.params = {'gbar': 0.0}
+        self.range_params = {'gbar': 0.0}