dendrotweaks 0.4.3__py3-none-any.whl → 0.4.5__py3-none-any.whl

dendrotweaks/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.4.3"
+__version__ = "0.4.5"
 
 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()
 
 
@@ -365,16 +386,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
     }
 
@@ -484,5 +507,36 @@ def plot_dendritic_nonlinearity(data, ax=None, **kwargs):
     ax[1].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_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/model.py

@@ -1104,9 +1104,8 @@ class Model():
                     value = seg.parent.get_param_value(param_name)
                     seg.set_param_value(param_name, value)
             else:
-                dists = np.array([seg.path_distance() for seg in filtered_segments])
-                values = distribution(dists)
-                for seg, value in zip(filtered_segments, values):
+                for seg in filtered_segments:
+                    value = distribution(seg.path_distance())
                     seg.set_param_value(param_name, value)
 
 
@@ -1422,12 +1421,15 @@ class Model():
             domains_to_mechs = {domain_name: mech_names for domain_name, mech_names
                 in self.domains_to_mechs.items() if domain_name in [domain.name for domain in domains_in_subtree]}
             common_mechs = set.intersection(*domains_to_mechs.values())
-            if not common_mechs:
+            if not all(mech_names == common_mechs
+                    for mech_names in domains_to_mechs.values()):
                 raise ValueError(
                     'The domains in the subtree have different mechanisms. '
                     'Please ensure that all domains in the subtree have the same mechanisms. '
                     'You may need to insert the missing mechanisms and set their conductances to 0 where they are not needed.'
                 )
+        elif len(domains_in_subtree) == 1:
+            common_mechs = self.domains_to_mechs[domain_name].copy()
         
         inserted_mechs = {mech_name: mech for mech_name, mech
             in self.mechanisms.items()
@@ -1497,9 +1499,15 @@ class Model():
 
         root_segs = [seg for seg in root.segments]
         params_to_coeffs = {}
-        for param_name in self.params:
-            coeffs = self.fit_distribution(param_name, segments=root_segs, plot=False)
-            params_to_coeffs[param_name] = coeffs
+        # for param_name in self.params:
+        common_mechs.add('Independent')
+        for mech in common_mechs:
+            for param_name in self.mechs_to_params[mech]:
+                coeffs = self.fit_distribution(param_name, segments=root_segs, plot=False)
+                if coeffs is None:
+                    warnings.warn(f'Cannot fit distribution for parameter {param_name}. No values found.')
+                    continue
+                params_to_coeffs[param_name] = coeffs
 
         
         # Create new domain
@@ -1536,9 +1544,12 @@ class Model():
         }
 
 
-    def fit_distribution(self, param_name, segments, max_degree=6, tolerance=1e-7, plot=False):
+    def fit_distribution(self, param_name, segments, max_degree=20, tolerance=1e-7, plot=False):
         from numpy import polyfit, polyval
         values = [seg.get_param_value(param_name) for seg in segments]
+        # if all values are NaN, return None
+        if all(np.isnan(values)):
+            return None
         distances = [seg.path_distance() for seg in segments]
         sorted_pairs = sorted(zip(distances, values))
         distances, values = zip(*sorted_pairs)
@@ -1565,7 +1576,7 @@ class Model():
         elif len(coeffs) == 2:
             self.params[param_name][group_name] = Distribution('linear', slope=coeffs[0], intercept=coeffs[1])
         else:
-            self.params[param_name][group_name] = Distribution('polynomial', coeffs=coeffs)
+            self.params[param_name][group_name] = Distribution('polynomial', coeffs=coeffs.tolist())
             
 
     # ========================================================================
@@ -1906,13 +1917,13 @@ class Model():
 
         df_iclamps = df_stimuli[df_stimuli['type'] == 'iclamp'].reset_index(drop=True, inplace=False)
 
-        for i, row in df_iclamps.iterrows():
+        for row in df_iclamps.itertuples(index=False):
             self.add_iclamp(
-            self.sec_tree.sections[row['sec_idx']], 
-            row['loc'],
-            data['stimuli']['iclamps'][i]['amp'],
-            data['stimuli']['iclamps'][i]['delay'],
-            data['stimuli']['iclamps'][i]['dur']
+            self.sec_tree.sections[row.sec_idx], 
+            row.loc,
+            data['stimuli']['iclamps'][row.idx]['amp'],
+            data['stimuli']['iclamps'][row.idx]['delay'],
+            data['stimuli']['iclamps'][row.idx]['dur']
             )
 
         # Populations -------------------------------------------------------
@@ -1945,15 +1956,10 @@ class Model():
         # Recordings ---------------------------------------------------------
 
         df_recs = df_stimuli[df_stimuli['type'] == 'rec'].reset_index(drop=True, inplace=False)
-        for i, row in df_recs.iterrows():
-            # TODO: This conditional statement is to account for a recent change
-            # in the JSON structure. It should be removed in the future.
-            if data['stimuli'].get('recordings'):
-                var = data['stimuli']['recordings'][i]['var']
-            else:
-                var = 'v'
+        for row in df_recs.itertuples(index=False):
+            var = data['stimuli']['recordings'][row.idx]['var']
             self.add_recording(
-                self.sec_tree.sections[row['sec_idx']], row['loc'], var
+            self.sec_tree.sections[row.sec_idx], row.loc, var
             )
 
 

dendrotweaks/morphology/io/factories.py

@@ -36,8 +36,8 @@ def create_point_tree(source: Union[str, DataFrame]) -> PointTree:
         raise ValueError("Source must be a file path (str) or a DataFrame.")
 
     nodes = [
-        Point(row['Index'], row['Type'], row['X'], row['Y'], row['Z'], row['R'], row['Parent'])
-        for _, row in df.iterrows()
+        Point(row.Index, row.Type, row.X, row.Y, row.Z, row.R, row.Parent)
+        for row in df.itertuples(index=False)
     ]
     point_tree =  PointTree(nodes)
     point_tree.remove_overlaps()

dendrotweaks/morphology/io/reader.py

@@ -35,7 +35,16 @@ class SWCReader():
             header=None, 
             comment='#', 
             names=['Index', 'Type', 'X', 'Y', 'Z', 'R', 'Parent'],
-            index_col=False
+            index_col=False,
+            dtype={
+            'Index': int,
+            'Type': int,
+            'X': float,
+            'Y': float,
+            'Z': float,
+            'R': float,
+            'Parent': int
+            }
         )
 
         if (df['R'] == 0).all():

dendrotweaks/morphology/point_trees.py

@@ -59,7 +59,7 @@ class Point(Node):
                  x: float, y: float, z: float, r: float, 
                  parent_idx: str) -> None:
         super().__init__(idx, parent_idx)
-        self.type_idx = type_idx
+        self.type_idx = int(type_idx)
         self.x = x
         self.y = y
         self.z = z

dendrotweaks/utils.py

@@ -182,31 +182,54 @@ def read_file(path_to_file):
     return content
 
 
-def download_example_data(path_to_destination):
+def download_example_data(path_to_destination, include_templates=True, include_modfiles=True):
     """
-    Download the examples subfolder from the DendroTweaks GitHub repository.
+    Download and extract specific folders from the DendroTweaks GitHub repository:
+    - examples/                <- from examples subfolder (always included)
+    - examples/Templates/      <- from src/dendrotweaks/biophys/default_templates (optional)
+    - examples/Default/        <- from src/dendrotweaks/biophys/default_mod (optional)
 
     Parameters
     ----------
     path_to_destination : str
-        The path to the destination folder where the examples will be downloaded.
+        The path to the destination folder where the data will be downloaded and extracted.
+
+    include_templates : bool, optional
+        If True, also extract default_templates/ into examples/Templates/.
+
+    include_modfiles : bool, optional
+        If True, also extract default_mod/ into examples/Default/.
     """
     if not os.path.exists(path_to_destination):
         os.makedirs(path_to_destination)
 
     repo_url = "https://github.com/Poirazi-Lab/DendroTweaks/archive/refs/heads/main.zip"
-    zip_path = os.path.join(path_to_destination, "examples.zip")
+    zip_path = os.path.join(path_to_destination, "dendrotweaks_repo.zip")
 
-    print(f"Downloading examples from {repo_url}...")
+    print(f"Downloading data from {repo_url}...")
     urllib.request.urlretrieve(repo_url, zip_path)
 
-    print(f"Extracting examples to {path_to_destination}")
+    print(f"Extracting relevant folders to {path_to_destination}...")
     with zipfile.ZipFile(zip_path, 'r') as zip_ref:
         for member in zip_ref.namelist():
+            target_path = None
+
+            # === Always extract examples/ folder ===
             if member.startswith("DendroTweaks-main/examples/"):
-                # Extract the file with the correct path
-                member_path = os.path.relpath(member, "DendroTweaks-main/examples")
-                target_path = os.path.join(path_to_destination, member_path)
+                rel_path = os.path.relpath(member, "DendroTweaks-main/examples")
+                target_path = os.path.join(path_to_destination, rel_path)
+
+            # === Optionally extract Templates/ folder ===
+            elif include_templates and member.startswith("DendroTweaks-main/src/dendrotweaks/biophys/default_templates/"):
+                rel_path = os.path.relpath(member, "DendroTweaks-main/src/dendrotweaks/biophys/default_templates")
+                target_path = os.path.join(path_to_destination, "Templates", rel_path)
+
+            # === Optionally extract Default/ folder ===
+            elif include_modfiles and member.startswith("DendroTweaks-main/src/dendrotweaks/biophys/default_mod/"):
+                rel_path = os.path.relpath(member, "DendroTweaks-main/src/dendrotweaks/biophys/default_mod")
+                target_path = os.path.join(path_to_destination, "Default", rel_path)
+
+            if target_path:
                 if member.endswith('/'):
                     os.makedirs(target_path, exist_ok=True)
                 else:
@@ -214,8 +237,8 @@ def download_example_data(path_to_destination):
                     with zip_ref.open(member) as source, open(target_path, 'wb') as target:
                         target.write(source.read())
 
-    os.remove(zip_path)  # Clean up the zip file
-    print(f"Examples downloaded successfully to {path_to_destination}/.")
+    os.remove(zip_path)
+    print(f"Data downloaded and extracted successfully to {path_to_destination}/.")
 
 
 

{dendrotweaks-0.4.3.dist-info → dendrotweaks-0.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dendrotweaks
-Version: 0.4.3
+Version: 0.4.5
 Summary: A toolbox for exploring dendritic dynamics
 Home-page: https://dendrotweaks.dendrites.gr
 Author: Roman Makarov

{dendrotweaks-0.4.3.dist-info → dendrotweaks-0.4.5.dist-info}/RECORD

@@ -1,11 +1,11 @@
-dendrotweaks/__init__.py,sha256=qo6haBW1LRSOhXRjByeruiXSnrnjxrUxqRbDymWSLaQ,384
-dendrotweaks/model.py,sha256=Dm_KJ8KbvHLCFKB3LwBHhgSrdiQteamqgda1J0p898w,71053
+dendrotweaks/__init__.py,sha256=wAjTFbihG1E0dDURosjTFhIilebuX2iXvefW8BYoDYQ,384
+dendrotweaks/model.py,sha256=6yvsIu-DImsBNosJmqJt6n59vaFMtRsDog4wAWppwlY,71362
 dendrotweaks/model_io.py,sha256=xwXKMcUle-Y0HoWFYVZu3G8v4pdQXmeaDfl2Xi65eHw,2137
 dendrotweaks/path_manager.py,sha256=dai5o6UA0nk-ubwKWRu4LFdDBO77zW_SsMf6k0MLBiI,8703
 dendrotweaks/simulators.py,sha256=OscZ4H6z9YiNloDtMAgpPx9n2e-9WJyLEWtcSD1YZR8,7411
-dendrotweaks/utils.py,sha256=jaUJNb39Bsevg3WJByP56bO7CLj1wzlh-uGZl-lxi1I,7131
-dendrotweaks/analysis/__init__.py,sha256=SEYpoQ5iXiQXyHB20-IAdDHYI-7CR5GYFXIwr-O05Ug,858
-dendrotweaks/analysis/ephys_analysis.py,sha256=PqT3aBCuxQbvdm9jnXjlTJ3R5n7_Vwp4fLrHGgtfoWw,14362
+dendrotweaks/utils.py,sha256=KrGV8972sCqn-OKiOpr2KOcEekcHnP10Tl499z5M60k,8477
+dendrotweaks/analysis/__init__.py,sha256=tDi4BHtW1fX5iiZVk1OM3gmLo69VFmUN8AEK_F8tDq4,927
+dendrotweaks/analysis/ephys_analysis.py,sha256=EuT7bHoSAjNg4736iKxj2Y1UfI2TfeWeoxtvUe78zfw,16188
 dendrotweaks/analysis/morphometric_analysis.py,sha256=5zohjGssyx-wezI-yY3Q-kYM_wzAQLLFBJ9Xk950_JY,3571
 dendrotweaks/biophys/__init__.py,sha256=k0o2xwyoaJUb1lfO9OHtqxheNP6R-Ya5o0g-bJOdCZg,360
 dendrotweaks/biophys/distributions.py,sha256=XGczxBYJ0-vkIfXbfzvlIqlH9OpBuT9J95Kzyd2zL5A,10325
@@ -20,6 +20,7 @@ dendrotweaks/biophys/default_mod/NMDA.mod,sha256=tT4Q5UPoeztXcQ45uZc2PUO3-8OkDLC
 dendrotweaks/biophys/default_mod/vecstim.mod,sha256=iSpJgR96O2Z3pLNUFIsZ7YJ529ncKUBaZqDJvA0_oV0,965
 dendrotweaks/biophys/default_templates/NEURON_template.py,sha256=MWSv2fLKGJxdt2zfSO0b74peuBC8U9j_S6AwM5URXts,14945
 dendrotweaks/biophys/default_templates/default.py,sha256=7HEbR2GJEOhgiox1QtZUEuHi5ihNAHDLsXQiQk980tI,2201
+dendrotweaks/biophys/default_templates/jaxley.py,sha256=RFmWyLOwa0GCjkuaT-gBbjVrniu99DD3PPAs3J9os3E,4599
 dendrotweaks/biophys/default_templates/standard_channel.mod,sha256=sw80c-JyqfXNA7c7v7pZGLY-0MgFUvd3bPvJcAGXNSk,2923
 dendrotweaks/biophys/default_templates/template_jaxley.py,sha256=t-GsCSUyQ7rDoaLmyuWd9bIxB8W3bCqJdnikD59EVvI,3676
 dendrotweaks/biophys/default_templates/template_jaxley_new.py,sha256=I62KhnOYNV1bT-nPsDTxjIISYmDcso2X8rnsos28nYs,3631
@@ -34,13 +35,13 @@ dendrotweaks/biophys/io/parser.py,sha256=boT27lFrn5LYrJnkZFs0SwrZZrkSkwO8efqGPJ4
 dendrotweaks/biophys/io/reader.py,sha256=JWm5WM9illvSfDkhWEmWBcj8Y7PSi8zeZX9j1ARUHVU,6576
 dendrotweaks/morphology/__init__.py,sha256=JwXmSmdn9e_jqslITEdiU9kWvzxcxT9Aw_kUkXLbm5o,353
 dendrotweaks/morphology/domains.py,sha256=l57KVR5eo1LlH_fCd1AOMiG_SsYLBPBTGQ5R78BHfdM,2545
-dendrotweaks/morphology/point_trees.py,sha256=5dUPaQXYPdJbWoD3pFI2DV2XnuFRhB5d0wTBlfmmIeI,21600
+dendrotweaks/morphology/point_trees.py,sha256=aZl5p6FGn6mph9xNo-3L_HC7mIvLhvi3BLJuhuihssk,21605
 dendrotweaks/morphology/sec_trees.py,sha256=eKLC-yNhsn_rPdTE7w7p6STa1onYkBTGcpBKBpEWZUI,36957
 dendrotweaks/morphology/seg_trees.py,sha256=-XeSJuD7ZixBJYQDzvmSEiNvOWbVmX_DanyAPkkR-NA,4042
 dendrotweaks/morphology/trees.py,sha256=NrNvPMR-U0clt63eqwVJqU0H8NJgY53QGA_BkdcwkQI,16033
 dendrotweaks/morphology/io/__init__.py,sha256=gAZqZdf5VKPb6ksK8Lwt7MbTAq8TDP8uq3Vs_ebNFEY,324
-dendrotweaks/morphology/io/factories.py,sha256=DCE37QCloiYVro5HGihJbxPz91BB3y5NNf-oRaQ-M2g,6383
-dendrotweaks/morphology/io/reader.py,sha256=hW3c541WtG1rNag_YreEhvrLzm8-OTtw0fQREeHDthM,1913
+dendrotweaks/morphology/io/factories.py,sha256=YkTCXWuJ6bwUW0kjcV2TSzu43EvkE8N5yC3q-B02kxc,6372
+dendrotweaks/morphology/io/reader.py,sha256=R368nkHfAKHdSnqg7jjc_us7gVSOlMJpzAjhUUU7Wfw,2121
 dendrotweaks/morphology/io/validation.py,sha256=lVkYw9y9yG5QpRh_N0YQ3FbZwuSUsQfSqJTMumMcDdc,7872
 dendrotweaks/morphology/reduce/__init__.py,sha256=p6Mg3KDHxTt8S4DtI0m7L7MqV6dS2pdIYAwB7B-toVw,921
 dendrotweaks/morphology/reduce/reduce.py,sha256=5czZDrG3xsvHn3c_tbYhUOlXgST989-RS-ntbhlvvA0,6361
@@ -49,8 +50,8 @@ dendrotweaks/stimuli/__init__.py,sha256=bFfSEZhCVpwOVEBgLe65iiY3SdpjKPhyLemC1z5O
 dendrotweaks/stimuli/iclamps.py,sha256=NjkhhwZKJR1f_g3N9BVxMVoO9ubBk5WkQ6h9Bnf9xgA,1681
 dendrotweaks/stimuli/populations.py,sha256=vq2NUOaxaltUwlcT7wuCe8z1JWc8rk6HfPmfEd1kK68,8335
 dendrotweaks/stimuli/synapses.py,sha256=g4MgWTske2TZ2i9FIIOE8-KXNx_3dWa3zEhB2rcqYig,5470
-dendrotweaks-0.4.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-dendrotweaks-0.4.3.dist-info/METADATA,sha256=KV5Ev0CC98m0JrqsvOG5szTc8Yqi_RjcKuOK4C7yHZo,2740
-dendrotweaks-0.4.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dendrotweaks-0.4.3.dist-info/top_level.txt,sha256=OzT_2BSI5j5zxC447K6Y-0W-GHbued7iX-_hFGAKMxY,13
-dendrotweaks-0.4.3.dist-info/RECORD,,
+dendrotweaks-0.4.5.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+dendrotweaks-0.4.5.dist-info/METADATA,sha256=B834Ro9ggHwzr3Ma4FE-twhlZ_v--ZHd-uvUk8HI1SQ,2740
+dendrotweaks-0.4.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dendrotweaks-0.4.5.dist-info/top_level.txt,sha256=OzT_2BSI5j5zxC447K6Y-0W-GHbued7iX-_hFGAKMxY,13
+dendrotweaks-0.4.5.dist-info/RECORD,,