dendrotweaks 0.3.1__py3-none-any.whl

dendrotweaks/path_manager.py

@@ -0,0 +1,261 @@
+import os
+from typing import List, Dict
+import shutil
+
+class PathManager:
+    """
+    A manager class for handling file and directory paths related to models data.
+
+    Parameters
+    ----------
+    path_to_model : str
+        The path to the model directory.
+
+    Attributes
+    ----------
+    path_to_model : str
+        The path to the model directory.
+    paths : Dict[str, str]
+        A dictionary of paths for different file types.
+    """
+    def __init__(self, path_to_model: str):
+        if not os.path.isdir(path_to_model):
+            raise FileNotFoundError(f"Directory {path_to_model} does not exist.")
+        self.path_to_model = path_to_model
+        self.paths = {
+            'default_mod': os.path.join(self.path_to_data, 'Default'),
+            'templates': os.path.join(self.path_to_data, 'Templates'),
+            'morphology': os.path.join(self.path_to_model, 'morphology'),
+            'membrane': os.path.join(self.path_to_model, 'membrane'),
+            'mod': os.path.join(self.path_to_model, 'membrane', 'mod'),
+            'python': os.path.join(self.path_to_model, 'membrane', 'python'),
+            'stimuli': os.path.join(self.path_to_model, 'stimuli'),
+        }
+        self._ensure_paths_exist()
+
+
+    def _ensure_paths_exist(self):
+        """
+        Ensure all necessary paths exist.
+        """
+        os.makedirs(self.path_to_model, exist_ok=True)
+        for path in self.paths.values():
+            os.makedirs(path, exist_ok=True)
+        # if empty, copy default mod files
+        if not os.listdir(self.paths['default_mod']):
+            self.copy_default_mod_files()
+        if not os.listdir(self.paths['templates']):
+            self.copy_template_files()
+        
+    @property
+    def path_to_data(self):
+        """
+        The path to the data directory.
+        """
+        return os.path.dirname(self.path_to_model)
+
+    def __repr__(self):
+        return f"PathManager({self.path_to_model})"
+
+    def copy_default_mod_files(self):
+        """
+        Copy default mod files to the data directory.
+        """
+        # __file__ + 'membrane' + 'default_mod'
+        DEFAULT_MOD_DIR = os.path.join(os.path.dirname(__file__), 'membrane', 'default_mod')
+        for file_name in os.listdir(DEFAULT_MOD_DIR):
+            source = os.path.join(DEFAULT_MOD_DIR, file_name)
+            destination = os.path.join(self.paths['default_mod'], file_name)
+            shutil.copyfile(source, destination)
+
+    def copy_template_files(self):
+        """
+        Copy template files to the data directory.
+        """
+        # __file__ + 'membrane' + 'templates'
+        TEMPLATES_DIR = os.path.join(os.path.dirname(__file__), 'membrane', 'default_templates')
+        for file_name in os.listdir(TEMPLATES_DIR):
+            source = os.path.join(TEMPLATES_DIR, file_name)
+            destination = os.path.join(self.paths['templates'], file_name)
+            shutil.copyfile(source, destination)
+
+
+    def get_path(self, file_type: str) -> str:
+        """
+        Get the path for a specific file type.
+        
+        Parameters
+        ----------
+        file_type : str
+            The type of file (e.g., 'mod', 'swc').
+        
+        Returns
+        -------
+        str
+            The full directory path.
+        """
+        path = self.paths.get(file_type, None)
+        if os.path.isdir(path):
+            return path
+        raise FileNotFoundError(f"Directory for {file_type} does not exist.")
+
+    def get_file_path(self, file_type: str, file_name: str, extension: str) -> str:
+        """
+        Construct a file path with an optional extension for a specific type.
+        
+        Parameters
+        ----------
+        file_type : str
+            The type of file (e.g., 'morphology', 'stimuli').
+        file_name : str
+            The name of the file.
+        extension : str
+            The file extension (e.g., 'mod', 'swc').
+
+        Returns
+        -------
+        str
+            The full file path.
+        """
+        dir_path = self.get_path(file_type)
+        file_name = f"{file_name}.{extension}"
+        return os.path.join(dir_path, file_name)
+
+    def list_files(self, file_type: str, extension: str = "") -> List[str]:
+        """
+        List all files of a given type and optional archive.
+        
+        Parameters
+        ----------
+        file_type : str
+            The type of file (e.g. 'morphology', 'stimuli').
+        extension : str
+            The file extension to filter by (e.g., 'mod', 'swc').
+        
+        Returns
+        -------
+        List[str]
+            A list of file names.
+        """
+        directory = self.paths.get(file_type, "")
+        if not extension.startswith('.'): extension = f".{extension}"
+        if not os.path.isdir(directory):
+            return []
+        return [f.replace(extension, '') 
+                for f in os.listdir(directory) if f.endswith(extension)]
+
+
+    def list_morphologies(self, extension: str = '.swc') -> List[str]:
+        """
+        List all SWC files.
+        
+        Returns
+        -------
+        List[str]
+            A list of SWC file names.
+        """
+        return self.list_files('morphology', extension=extension)
+
+
+    def list_stimuli(self, extension: str = '.json') -> List[str]:
+        """
+        List all JSON files.
+        
+        Returns
+        -------
+        List[str]
+            A list of JSON file names.
+        """
+        return self.list_files('stimuli', extension=extension)
+
+
+    def list_membrane(self):
+        """
+        List all membrane files.
+        
+        Returns
+        -------
+        List[str]
+            A list of membrane file
+        """
+        return self.list_files('membrane', extension='.json')
+
+
+    def print_directory_tree(self, subfolder=None) -> None:
+        """
+        Print a directory tree for a given file type.
+        
+        Parameters
+        ----------
+        file_type : str
+            The type of file (e.g., 'mod', 'swc').
+        """
+        base_path = self.paths.get('model') if not subfolder else self.paths.get(subfolder)
+        if not base_path or not os.path.isdir(base_path):
+            print(f"Directory for {file_type} does not exist.")
+            return
+
+        def print_tree(path, prefix=""):
+            items = os.listdir(path)
+            for idx, item in enumerate(sorted(items)):
+                is_last = idx == len(items) - 1
+                connector = "└──" if is_last else "├──"
+                item_path = os.path.join(path, item)
+                print(f"{prefix}{connector} {item}")
+                if os.path.isdir(item_path) and not item.startswith('x86_64'):
+                    extension = "│   " if not is_last else "    "
+                    print_tree(item_path, prefix + extension)
+
+        print_tree(base_path)
+
+    def get_channel_paths(self, mechanism_name: str, 
+                          python_template_name: str = None) -> Dict[str, str]:
+        """
+        Get all necessary paths for creating a channel.
+
+        Parameters
+        ----------
+        mechanism_name : str
+            The name of the mechanism.
+        python_template_name : str, optional
+            The name of the Python template file.
+
+        Returns
+        -------
+        Dict[str, str]
+            A dictionary of paths.
+        """
+        python_template_name = python_template_name or "default"
+        return {
+            'path_to_mod_file': self.get_file_path('mod', mechanism_name, 'mod'),
+            'path_to_python_file': self.get_file_path('python', mechanism_name, 'py'),
+            'path_to_python_template': self.get_file_path('templates', python_template_name, 'py'),
+        }
+
+    def get_standard_channel_paths(self, mechanism_name: str,
+                                   python_template_name: str = None,
+                                   mod_template_name: str = None) -> Dict[str, str]:
+        """
+        Get all necessary paths for creating a standard channel.
+
+        Parameters
+        ----------
+        mechanism_name : str
+            The name of the mechanism.
+        python_template_name : str, optional
+            The name of the Python template file.
+        mod_template_name : str, optional
+            The name of the MOD template file.
+
+        Returns
+        -------
+        Dict[str, str]
+            A dictionary of paths.
+        """
+        python_template_name = python_template_name or "default"
+        mod_template_name = mod_template_name or "standard_channel"
+        return {
+            # **self.get_channel_paths(mechanism_name, python_template_name),
+            'path_to_mod_template': self.get_file_path('templates', mod_template_name, 'mod'),
+            'path_to_standard_mod_file': self.get_file_path('mod', f"std{mechanism_name}", 'mod'),
+        }

dendrotweaks/simulators.py

@@ -0,0 +1,235 @@
+from collections import defaultdict
+import warnings
+
+import matplotlib.pyplot as plt
+import neuron
+from neuron import h
+from neuron.units import ms, mV
+h.load_file('stdrun.hoc')
+# h.load_file('import3d.hoc')
+# h.load_file('nrngui.hoc')
+# h.load_file('import3d')
+
+import contextlib
+
+@contextlib.contextmanager
+def push_section(section):
+    section.push()
+    yield
+    h.pop_section()
+
+def reset_neuron():
+
+    # h('forall delete_section()')
+    # h('forall delete_all()')
+    # h('forall delete()')
+
+    for sec in h.allsec():
+        with push_section(sec):
+            h.delete_section()
+
+reset_neuron()            
+
+class Simulator:
+    """
+    A generic simulator class.
+    """
+    def __init__(self):
+        self.vs = None
+        self.t = None
+        self.dt = None
+        self.recordings = {}
+
+    def plot_voltage(self, ax=None, segments=None, **kwargs):
+        if ax is None:
+            fig, ax = plt.subplots()
+        if segments is None:
+            segments = self.recordings.keys()
+        for seg, v in self.vs.items():
+            if segments and seg not in segments:
+                continue
+            ax.plot(self.t, v, label=f'{seg.domain} {seg.idx}', **kwargs)
+
+        if len(segments) < 10:
+            ax.legend()
+        # ax.set_ylim(-100, 60)
+        ax.set_xlabel('Time (ms)')
+        ax.set_ylabel('Voltage (mV)')
+        
+
+class NEURONSimulator(Simulator):
+    """
+    A class to represent the NEURON simulator.
+
+    Parameters
+    ----------
+    temperature : float
+        The temperature of the simulation in Celsius.
+    v_init : float
+        The initial membrane potential of the neuron in mV.
+    dt : float
+        The time step of the simulation in ms.
+    cvode : bool
+        Whether to use the CVode variable time step integrator.
+
+    Attributes
+    ----------
+    temperature : float
+        The temperature of the simulation in Celsius.
+    v_init : float
+        The initial membrane potential of the neuron in mV.
+    dt : float
+        The time step of the simulation in ms.
+    """
+
+    def __init__(self, temperature=37, v_init=-70, dt=0.025, cvode=False):
+        super().__init__()
+        
+        self.temperature = temperature
+        self.v_init = v_init * mV
+        self._duration = 300
+
+        self.dt = dt
+        self._cvode = cvode
+
+
+    def add_recording(self, sec, loc, var='v'):
+        """
+        Add a recording to the simulator.
+
+        Parameters
+        ----------
+        sec : Section
+            The section to record from.
+        loc : float
+            The location along the normalized section length to record from.
+        var : str
+            The variable to record. Default is 'v' (voltage).
+        """
+        seg = sec(loc)
+        if self.recordings.get(seg):
+            self.remove_recording(sec, loc)
+        self.recordings[seg] = h.Vector().record(getattr(seg._ref, f'_ref_{var}'))
+
+    def remove_recording(self, sec, loc):
+        """
+        Remove a recording from the simulator.
+
+        Parameters
+        ----------
+        sec : Section
+            The section to remove the recording from.
+        loc : float 
+            The location along the normalized section length to remove the recording from.
+        """
+        seg = sec(loc)
+        if self.recordings.get(seg):
+            self.recordings[seg] = None
+            self.recordings.pop(seg)
+
+    def remove_all_recordings(self):
+        """
+        Remove all recordings from the simulator.
+        """
+        for seg in list(self.recordings.keys()):
+            sec, loc = seg._section, seg.x
+            self.remove_recording(sec, loc)
+        if self.recordings:
+            warnings.warn(f'Not all recordings were removed: {self.recordings}')
+        self.recordings = {}
+
+
+    def _init_simulation(self):
+        h.CVode().active(self._cvode)
+        h.celsius = self.temperature
+        h.dt = self.dt
+        h.stdinit()
+        h.init()
+        h.finitialize(self.v_init)
+        if h.cvode.active():
+            h.cvode.re_init()
+        else:
+            h.fcurrent()
+        h.frecord_init()
+
+    def run(self, duration=300):
+        """
+        Run a simulation.
+
+        Parameters
+        ----------
+        duration : float
+            The duration of the simulation in milliseconds.
+        """
+        self._duration = duration
+
+
+        # vs = list(self.recordings.values())
+        Is = []
+
+        # for v in self.recordings.values():
+        #     # v = h.Vector().record(seg._ref_v)
+        #     vs.append(v)
+
+        t = h.Vector().record(h._ref_t)
+
+        # if self.ch is None:
+        #     pass
+        # else:
+        #     for seg in self.recordings.keys():
+        #         if getattr(seg, f'_ref_i_{self.ch.suffix}', None) is None:
+        #             logger.warning(
+        #                 f'No current recorded for {self.ch.suffix} at {seg}. Make i a RANGE variable in mod file.')
+        #             continue
+        #         I = h.Vector().record(getattr(seg, f'_ref_i_{self.ch.suffix}'))
+        #         Is.append(I)
+
+        self._init_simulation()
+
+        h.continuerun(duration * ms)
+
+        self.t = t.to_python()
+        self.vs = {seg: v.to_python() for seg, v in self.recordings.items()}
+    
+
+    def to_dict(self):
+        """
+        Convert the simulator to a dictionary.
+
+        Returns
+        -------
+        dict
+            A dictionary representation of the simulator.
+        """
+        return {
+            'temperature': self.temperature,
+            'v_init': self.v_init,
+            'dt': self.dt,
+            'duration': self._duration
+        }
+
+    def from_dict(self, data):
+        """
+        Create a simulator from a dictionary.
+
+        Parameters
+        ----------
+        data : dict
+            The dictionary representation of the simulator.
+        """
+        self.temperature = data['temperature']
+        self.v_init = data['v_init']
+        self.dt = data['dt']
+        self._duration = data['duration']
+
+
+class JaxleySimulator(Simulator):
+    """
+    A class to represent a Jaxley simulator.
+    """
+
+    def __init__(self):
+        super().__init__()
+        ...
+
+    

dendrotweaks/stimuli/__init__.py

@@ -0,0 +1,3 @@
+from dendrotweaks.stimuli.iclamps import IClamp
+from dendrotweaks.stimuli.synapses import Synapse
+from dendrotweaks.stimuli.populations import Population

dendrotweaks/stimuli/iclamps.py

@@ -0,0 +1,73 @@
+from neuron import h
+h.load_file('stdrun.hoc')
+
+class IClamp():
+    """
+    A current clamp stimulus.
+
+    Parameters
+    ----------
+    sec : Section
+        The section to place the stimulus on.
+    loc : float
+        The location along the section to place the stimulus.
+        Can be a float between 0 and 1.
+    amp : float
+        The amplitude of the stimulus, in nA.
+    delay : int
+        The delay of the stimulus, in ms.
+    dur : int
+        The duration of the stimulus, in ms.
+
+    Attributes
+    ----------
+    sec : Section
+        The section to place the stimulus on.
+    loc : float
+        The location along the section to place the stimulus.
+    """
+
+    def __init__(self, sec, loc, amp=0, delay=100, dur=100):
+        self.sec = sec
+        self.loc = loc
+        self._iclamp = h.IClamp(sec(loc)._ref)
+        self._iclamp.amp = amp
+        self._iclamp.delay = delay
+        self._iclamp.dur = dur
+
+    def __repr__(self):
+        return f"<IClamp(sec[{self.sec.idx}]({self.loc:.2f}))>"
+        
+    @property
+    def amp(self):
+        """
+        The amplitude of the stimulus, in nA.
+        """
+        return self._iclamp.amp
+
+    @amp.setter
+    def amp(self, new_amp):
+        self._iclamp.amp = new_amp
+
+
+    @property
+    def delay(self):
+        """
+        The delay of the stimulus, in ms.
+        """
+        return self._iclamp.delay
+
+    @delay.setter
+    def delay(self, new_delay):
+        self._iclamp.delay = new_delay
+
+    @property
+    def dur(self):
+        """
+        The duration of the stimulus, in ms.
+        """
+        return self._iclamp.dur
+
+    @dur.setter
+    def dur(self, new_dur):
+        self._iclamp.dur = new_dur