{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Created by Namit Dwivedi (Scimemi Lab) on 09/19/2024\n", "# Please contact Namit (namitdwivedi08@gmail.com) or Dr Annalisa Scimemi (scimemia@gmail.com) for questions\n", "# The goal of this code is to determine the synaptic weight that reproduces the mIPSC recorded experimentally\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from neuron import h\n", "import pandas as pd\n", "\n", "# Define the path to the csv output file saving the mIPSC reading\n", "output_path = 'C:/Users/ND653384/Documents/Namit/Voltage_escape/1016/mIPSC.csv' #Change as needed\n", "\n", "\n", "# Load morphology and hoc files\n", "h.load_file('C:/Users/ND653384/Desktop/New folder/246/nrnez_2024_06_24_11_37_59/run_1/CA1PC.nrn') #Change as needed\n", "\n", "# Define file paths\n", "syn_loc_file = 'C:/Users/ND653384/Desktop/New folder/New mIPSC 1017/nrnez_2024_10_17_14_47_08/run_1/Inhibitory/syn_loc.dat' #Change as needed\n", "\n", "\n", "# Read synapse location data\n", "with open(syn_loc_file, 'r') as file:\n", " synapse_data = [line.strip().split() for line in file.readlines()]\n", "\n", "\n", "# " ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Soma mechanisms: ['pas']\n", "Passive channels are present in the soma\n", "Nonsense\n", "['pas']\n", "apical[563]\n", "apical[445]\n", "apical[419]\n", "apical[840]\n", "apical[3280]\n", "apical[30]\n", "apical[502]\n", "apical[601]\n", "apical[1972]\n", "apical[1307]\n", "apical[3269]\n", "apical[425]\n", "apical[1264]\n", "apical[1812]\n", "apical[2085]\n", "apical[418]\n", "apical[3232]\n", "apical[629]\n", "apical[3386]\n", "apical[715]\n", "apical[2720]\n", "apical[3257]\n", "apical[95]\n", "apical[1753]\n", "apical[3424]\n", "apical[585]\n", "apical[779]\n", "apical[2621]\n", "apical[3210]\n", "apical[3207]\n", "apical[137]\n", "apical[2690]\n", "apical[1322]\n", "apical[51]\n", "apical[3363]\n", "apical[125]\n", "apical[685]\n", "apical[1797]\n", "apical[1271]\n", "apical[3443]\n", "apical[607]\n", "apical[1261]\n", "apical[1375]\n", "apical[768]\n", "apical[707]\n", "apical[2653]\n", "apical[597]\n", "apical[3433]\n", "apical[1324]\n", "apical[82]\n", "apical[1363]\n", "apical[115]\n", "apical[2708]\n", "apical[39]\n", "apical[1788]\n", "apical[1800]\n", "apical[1280]\n", "apical[534]\n", "apical[1809]\n", "apical[3254]\n", "apical[3440]\n", "apical[682]\n", "apical[645]\n", "apical[822]\n", "apical[3298]\n", "apical[1736]\n", "apical[1737]\n", "apical[1314]\n", "apical[781]\n", "apical[1313]\n", "apical[690]\n", "apical[489]\n", "apical[1276]\n", "apical[0]\n", "apical[1235]\n", "apical[562]\n", "apical[86]\n", "apical[763]\n", "apical[2604]\n", "apical[122]\n", "apical[2030]\n", "apical[1896]\n", "apical[1778]\n", "apical[1756]\n", "apical[420]\n", "apical[513]\n", "apical[535]\n", "apical[819]\n", "apical[415]\n", "apical[3244]\n", "apical[122]\n", "apical[1728]\n", "apical[3459]\n", "apical[2619]\n", "apical[448]\n", "apical[614]\n", "apical[102]\n", "Apical Section: apical[563] | Distance from soma: 62.38 µm\n", "Apical Section: apical[445] | Distance from soma: 76.12 µm\n", "Apical Section: apical[419] | Distance from soma: 56.38 µm\n", "Apical Section: apical[840] | Distance from soma: 208.06 µm\n", "Apical Section: apical[3280] | Distance from soma: 113.41 µm\n", "Apical Section: apical[30] | Distance from soma: 73.15 µm\n", "Apical Section: apical[502] | Distance from soma: 136.25 µm\n", "Apical Section: apical[601] | Distance from soma: 101.17 µm\n", "Apical Section: apical[1972] | Distance from soma: 97.44 µm\n", "Apical Section: apical[1307] | Distance from soma: 183.70 µm\n", "Apical Section: apical[3269] | Distance from soma: 92.48 µm\n", "Apical Section: apical[425] | Distance from soma: 63.14 µm\n", "Apical Section: apical[1264] | Distance from soma: 130.87 µm\n", "Apical Section: apical[1812] | Distance from soma: 75.18 µm\n", "Apical Section: apical[2085] | Distance from soma: 183.51 µm\n", "Apical Section: apical[418] | Distance from soma: 55.12 µm\n", "Apical Section: apical[3232] | Distance from soma: 114.38 µm\n", "Apical Section: apical[629] | Distance from soma: 134.19 µm\n", "Apical Section: apical[3386] | Distance from soma: 126.00 µm\n", "Apical Section: apical[715] | Distance from soma: 232.29 µm\n", "Apical Section: apical[2720] | Distance from soma: 107.14 µm\n", "Apical Section: apical[3257] | Distance from soma: 78.75 µm\n", "Apical Section: apical[95] | Distance from soma: 151.09 µm\n", "Apical Section: apical[1753] | Distance from soma: 102.80 µm\n", "Apical Section: apical[3424] | Distance from soma: 182.06 µm\n", "Apical Section: apical[585] | Distance from soma: 84.18 µm\n", "Apical Section: apical[779] | Distance from soma: 207.05 µm\n", "Apical Section: apical[2621] | Distance from soma: 127.18 µm\n", "Apical Section: apical[3210] | Distance from soma: 87.53 µm\n", "Apical Section: apical[3207] | Distance from soma: 83.18 µm\n", "Apical Section: apical[137] | Distance from soma: 206.09 µm\n", "Apical Section: apical[2690] | Distance from soma: 166.13 µm\n", "Apical Section: apical[1322] | Distance from soma: 202.25 µm\n", "Apical Section: apical[51] | Distance from soma: 96.93 µm\n", "Apical Section: apical[3363] | Distance from soma: 192.58 µm\n", "Apical Section: apical[125] | Distance from soma: 190.39 µm\n", "Apical Section: apical[685] | Distance from soma: 203.62 µm\n", "Apical Section: apical[1797] | Distance from soma: 61.02 µm\n", "Apical Section: apical[1271] | Distance from soma: 138.92 µm\n", "Apical Section: apical[3443] | Distance from soma: 202.82 µm\n", "Apical Section: apical[607] | Distance from soma: 108.50 µm\n", "Apical Section: apical[1261] | Distance from soma: 128.11 µm\n", "Apical Section: apical[1375] | Distance from soma: 125.94 µm\n", "Apical Section: apical[768] | Distance from soma: 192.91 µm\n", "Apical Section: apical[707] | Distance from soma: 223.99 µm\n", "Apical Section: apical[2653] | Distance from soma: 165.63 µm\n", "Apical Section: apical[597] | Distance from soma: 96.38 µm\n", "Apical Section: apical[3433] | Distance from soma: 190.04 µm\n", "Apical Section: apical[1324] | Distance from soma: 205.45 µm\n", "Apical Section: apical[82] | Distance from soma: 131.99 µm\n", "Apical Section: apical[1363] | Distance from soma: 110.10 µm\n", "Apical Section: apical[115] | Distance from soma: 177.03 µm\n", "Apical Section: apical[2708] | Distance from soma: 133.90 µm\n", "Apical Section: apical[39] | Distance from soma: 83.47 µm\n", "Apical Section: apical[1788] | Distance from soma: 150.90 µm\n", "Apical Section: apical[1800] | Distance from soma: 62.46 µm\n", "Apical Section: apical[1280] | Distance from soma: 149.30 µm\n", "Apical Section: apical[534] | Distance from soma: 162.96 µm\n", "Apical Section: apical[1809] | Distance from soma: 71.90 µm\n", "Apical Section: apical[3254] | Distance from soma: 75.18 µm\n", "Apical Section: apical[3440] | Distance from soma: 198.70 µm\n", "Apical Section: apical[682] | Distance from soma: 201.55 µm\n", "Apical Section: apical[645] | Distance from soma: 155.89 µm\n", "Apical Section: apical[822] | Distance from soma: 188.97 µm\n", "Apical Section: apical[3298] | Distance from soma: 136.26 µm\n", "Apical Section: apical[1736] | Distance from soma: 176.24 µm\n", "Apical Section: apical[1737] | Distance from soma: 177.57 µm\n", "Apical Section: apical[1314] | Distance from soma: 192.00 µm\n", "Apical Section: apical[781] | Distance from soma: 208.43 µm\n", "Apical Section: apical[1313] | Distance from soma: 190.64 µm\n", "Apical Section: apical[690] | Distance from soma: 208.32 µm\n", "Apical Section: apical[489] | Distance from soma: 120.36 µm\n", "Apical Section: apical[1276] | Distance from soma: 145.89 µm\n", "Apical Section: apical[0] | Distance from soma: 33.15 µm\n", "Apical Section: apical[1235] | Distance from soma: 212.63 µm\n", "Apical Section: apical[562] | Distance from soma: 61.17 µm\n", "Apical Section: apical[86] | Distance from soma: 137.52 µm\n", "Apical Section: apical[763] | Distance from soma: 186.71 µm\n", "Apical Section: apical[2604] | Distance from soma: 113.61 µm\n", "Apical Section: apical[122] | Distance from soma: 186.62 µm\n", "Apical Section: apical[2030] | Distance from soma: 193.51 µm\n", "Apical Section: apical[1896] | Distance from soma: 121.27 µm\n", "Apical Section: apical[1778] | Distance from soma: 137.45 µm\n", "Apical Section: apical[1756] | Distance from soma: 106.49 µm\n", "Apical Section: apical[420] | Distance from soma: 57.37 µm\n", "Apical Section: apical[513] | Distance from soma: 147.62 µm\n", "Apical Section: apical[535] | Distance from soma: 163.95 µm\n", "Apical Section: apical[819] | Distance from soma: 186.86 µm\n", "Apical Section: apical[415] | Distance from soma: 51.17 µm\n", "Apical Section: apical[3244] | Distance from soma: 131.74 µm\n", "Apical Section: apical[122] | Distance from soma: 186.62 µm\n", "Apical Section: apical[1728] | Distance from soma: 165.74 µm\n", "Apical Section: apical[3459] | Distance from soma: 220.22 µm\n", "Apical Section: apical[2619] | Distance from soma: 125.45 µm\n", "Apical Section: apical[448] | Distance from soma: 80.01 µm\n", "Apical Section: apical[614] | Distance from soma: 114.53 µm\n", "Apical Section: apical[102] | Distance from soma: 161.06 µm\n", "0.025\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\ND653384\\AppData\\Local\\Temp\\1\\ipykernel_19812\\2661557417.py:20: RuntimeWarning: overflow encountered in exp\n", " sec.g_pas = 1e-5 * np.exp(distance / 100) # Set leak conductance (S/cm2)\n" ] }, { "data": { "text/plain": [ "0.0" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "soma= h.soma[0]\n", "axon= h.axon\n", "# Create lists to store sections and recorders\n", "apical_sections = []\n", "recorders = []\n", "Rec_id= []\n", "\n", "def calculate_distance(section):\n", " h.distance(sec=h.soma[0]) # Set soma as reference for making distance measures\n", " return h.distance(0.5, sec=section)\n", "\n", "# Set axial resistance for all sections (optional)\n", "for sec in h.allsec():\n", " sec.Ra = 150 # ohm-cm\n", "\n", "# Introduce passive channels in each section \n", "for sec in h.allsec():\n", " sec.insert('pas') # Insert passive channel\n", " distance = calculate_distance(sec)\n", " sec.g_pas = 1e-5 * np.exp(distance / 100) # Set leak conductance (S/cm2)\n", " sec.e_pas = 0 \n", "\n", "\n", "\n", "\n", "\n", "\n", "soma_mechs = [mech.name() for seg in soma for mech in seg]\n", "print(f\"Soma mechanisms: {soma_mechs}\")\n", "\n", "if 'pas' not in soma_mechs:\n", " print(\"No passive channels in the soma\")\n", "else:\n", " print(\"Passive channels are present in the soma\")\n", "\n", "if 'hh' not in soma_mechs:\n", " print(\"Nonsense\")\n", "else:\n", " print(\"Culprit\")\n", "\n", "print(soma_mechs)\n", "\n", "\n", "\n", "\n", "# Iterate through synapse data\n", "for section_type, apical_number in synapse_data:\n", " section_type = int(section_type)\n", " apical_number = int(apical_number)\n", "\n", " # Check if section is apical\n", " if section_type == 3:\n", " # Access apical section by its number\n", " apical_section = h.apical[apical_number]\n", "\n", " # Record membrane potential\n", " rec = h.Vector()\n", " rec.record(apical_section(0.5)._ref_v)\n", " recorders.append(rec)\n", " apical_sections.append(apical_section)\n", " Rec_id.append(apical_number)\n", "\n", "\n", " print(apical_section)\n", "\n", "# Access the soma\n", "\n", "soma = h.soma[0]\n", "soma_rec = h.Vector()\n", "soma_rec.record(h.soma[0](0.5)._ref_v)\n", "\n", "# Create SEClamp \n", "seclamp1 = h.SEClamp(0.5, sec=soma)\n", "\n", "# Set SEClamp parameters\n", "seclamp1.dur1 = 1e9\n", "seclamp1.amp1 = 0\n", "seclamp1.rs = 12\n", " \n", "t = h.Vector().record(h._ref_t)\n", "# Iterate through only apical sections and print their distances\n", "for apical_section in apical_sections:\n", " distance = calculate_distance(apical_section)\n", " print(f\"Apical Section: {apical_section.name()} | Distance from soma: {distance:.2f} µm\")\n", "\n", "print(h.dt)\n", "# Run simulation\n", "h.load_file(\"stdrun.hoc\")\n", "h.finitialize(0)\n", "h.continuerun(300)\n", "\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Simulating for Synapse 1 at Section: apical[563]\n", "Simulating for Synapse 2 at Section: apical[445]\n", "Simulating for Synapse 3 at Section: apical[419]\n", "Simulating for Synapse 4 at Section: apical[840]\n", "Simulating for Synapse 5 at Section: apical[3280]\n", "Simulating for Synapse 6 at Section: apical[30]\n", "Simulating for Synapse 7 at Section: apical[502]\n", "Simulating for Synapse 8 at Section: apical[601]\n", "Simulating for Synapse 9 at Section: apical[1972]\n", "Simulating for Synapse 10 at Section: apical[1307]\n", "Simulating for Synapse 11 at Section: apical[3269]\n", "Simulating for Synapse 12 at Section: apical[425]\n", "Simulating for Synapse 13 at Section: apical[1264]\n", "Simulating for Synapse 14 at Section: apical[1812]\n", "Simulating for Synapse 15 at Section: apical[2085]\n", "Simulating for Synapse 16 at Section: apical[418]\n", "Simulating for Synapse 17 at Section: apical[3232]\n", "Simulating for Synapse 18 at Section: apical[629]\n", "Simulating for Synapse 19 at Section: apical[3386]\n", "Simulating for Synapse 20 at Section: apical[715]\n", "Simulating for Synapse 21 at Section: apical[2720]\n", "Simulating for Synapse 22 at Section: apical[3257]\n", "Simulating for Synapse 23 at Section: apical[95]\n", "Simulating for Synapse 24 at Section: apical[1753]\n", "Simulating for Synapse 25 at Section: apical[3424]\n", "Simulating for Synapse 26 at Section: apical[585]\n", "Simulating for Synapse 27 at Section: apical[779]\n", "Simulating for Synapse 28 at Section: apical[2621]\n", "Simulating for Synapse 29 at Section: apical[3210]\n", "Simulating for Synapse 30 at Section: apical[3207]\n", "Simulating for Synapse 31 at Section: apical[137]\n", "Simulating for Synapse 32 at Section: apical[2690]\n", "Simulating for Synapse 33 at Section: apical[1322]\n", "Simulating for Synapse 34 at Section: apical[51]\n", "Simulating for Synapse 35 at Section: apical[3363]\n", "Simulating for Synapse 36 at Section: apical[125]\n", "Simulating for Synapse 37 at Section: apical[685]\n", "Simulating for Synapse 38 at Section: apical[1797]\n", "Simulating for Synapse 39 at Section: apical[1271]\n", "Simulating for Synapse 40 at Section: apical[3443]\n", "Simulating for Synapse 41 at Section: apical[607]\n", "Simulating for Synapse 42 at Section: apical[1261]\n", "Simulating for Synapse 43 at Section: apical[1375]\n", "Simulating for Synapse 44 at Section: apical[768]\n", "Simulating for Synapse 45 at Section: apical[707]\n", "Simulating for Synapse 46 at Section: apical[2653]\n", "Simulating for Synapse 47 at Section: apical[597]\n", "Simulating for Synapse 48 at Section: apical[3433]\n", "Simulating for Synapse 49 at Section: apical[1324]\n", "Simulating for Synapse 50 at Section: apical[82]\n", "Simulating for Synapse 51 at Section: apical[1363]\n", "Simulating for Synapse 52 at Section: apical[115]\n", "Simulating for Synapse 53 at Section: apical[2708]\n", "Simulating for Synapse 54 at Section: apical[39]\n", "Simulating for Synapse 55 at Section: apical[1788]\n", "Simulating for Synapse 56 at Section: apical[1800]\n", "Simulating for Synapse 57 at Section: apical[1280]\n", "Simulating for Synapse 58 at Section: apical[534]\n", "Simulating for Synapse 59 at Section: apical[1809]\n", "Simulating for Synapse 60 at Section: apical[3254]\n", "Simulating for Synapse 61 at Section: apical[3440]\n", "Simulating for Synapse 62 at Section: apical[682]\n", "Simulating for Synapse 63 at Section: apical[645]\n", "Simulating for Synapse 64 at Section: apical[822]\n", "Simulating for Synapse 65 at Section: apical[3298]\n", "Simulating for Synapse 66 at Section: apical[1736]\n", "Simulating for Synapse 67 at Section: apical[1737]\n", "Simulating for Synapse 68 at Section: apical[1314]\n", "Simulating for Synapse 69 at Section: apical[781]\n", "Simulating for Synapse 70 at Section: apical[1313]\n", "Simulating for Synapse 71 at Section: apical[690]\n", "Simulating for Synapse 72 at Section: apical[489]\n", "Simulating for Synapse 73 at Section: apical[1276]\n", "Simulating for Synapse 74 at Section: apical[0]\n", "Simulating for Synapse 75 at Section: apical[1235]\n", "Simulating for Synapse 76 at Section: apical[562]\n", "Simulating for Synapse 77 at Section: apical[86]\n", "Simulating for Synapse 78 at Section: apical[763]\n", "Simulating for Synapse 79 at Section: apical[2604]\n", "Simulating for Synapse 80 at Section: apical[122]\n", "Simulating for Synapse 81 at Section: apical[2030]\n", "Simulating for Synapse 82 at Section: apical[1896]\n", "Simulating for Synapse 83 at Section: apical[1778]\n", "Simulating for Synapse 84 at Section: apical[1756]\n", "Simulating for Synapse 85 at Section: apical[420]\n", "Simulating for Synapse 86 at Section: apical[513]\n", "Simulating for Synapse 87 at Section: apical[535]\n", "Simulating for Synapse 88 at Section: apical[819]\n", "Simulating for Synapse 89 at Section: apical[415]\n", "Simulating for Synapse 90 at Section: apical[3244]\n", "Simulating for Synapse 91 at Section: apical[122]\n", "Simulating for Synapse 92 at Section: apical[1728]\n", "Simulating for Synapse 93 at Section: apical[3459]\n", "Simulating for Synapse 94 at Section: apical[2619]\n", "Simulating for Synapse 95 at Section: apical[448]\n", "Simulating for Synapse 96 at Section: apical[614]\n", "Simulating for Synapse 97 at Section: apical[102]\n", "Average currents saved to C:/Users/ND653384/Documents/Namit/Voltage_escape/1016/average_currents.csv\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "\n", "# Function to run simulation for a single synapse\n", "def run_single_synapse_simulation(apical_section, synapse_data, syn_tau1, syn_tau2, syn_e):\n", " # Create Exp2Syn synapse on the apical section\n", " syn = h.Exp2Syn(0.5, sec=apical_section)\n", " syn.tau1 = syn_tau1\n", " syn.tau2 = syn_tau2\n", " syn.e = syn_e\n", "\n", " # Create a NetStim to activate the synapse\n", " stim = h.NetStim()\n", " stim.number = 1 # Number of spikes\n", " stim.start = 100 # Start time in ms\n", " stim.interval = 0 # Interval between spikes in ms\n", "\n", " # Connect the NetStim to the synapse\n", " nc = h.NetCon(stim, syn)\n", " nc.weight[0] = 0.485e-3 # Synaptic weight in uS\n", "\n", " # Record the synaptic current\n", " syn_current = h.Vector()\n", " syn_current.record(syn._ref_i)\n", "\n", " # Run the simulation\n", " h.finitialize(0)\n", " h.continuerun(300)\n", "\n", " # Convert current from nA to pA\n", " syn_current_pA = [i * 1000 for i in syn_current]\n", "\n", " return syn_current_pA\n", "\n", "# Function to calculate average current for all synapses\n", "def calculate_average_current(apical_sections, synapse_data, syn_tau1, syn_tau2, syn_e):\n", " all_soma_currents = []\n", " all_synaptic_currents = []\n", "\n", " for idx, apical_section in enumerate(apical_sections):\n", " print(f\"Simulating for Synapse {idx + 1} at Section: {apical_section.name()}\")\n", "\n", " # Record somatic current\n", " soma_current = h.Vector()\n", " soma_current.record(seclamp1._ref_i)\n", "\n", " # Simulate single synapse activation and get synaptic current\n", " syn_current_pA = run_single_synapse_simulation(apical_section, synapse_data, syn_tau1, syn_tau2, syn_e)\n", " all_synaptic_currents.append(syn_current_pA)\n", "\n", " # Convert soma current from nA to pA\n", " soma_current_pA = [i * 1000 for i in soma_current]\n", " all_soma_currents.append(soma_current_pA)\n", "\n", " # Convert to numpy arrays to compute averages\n", " all_soma_currents = np.array(all_soma_currents)\n", " all_synaptic_currents = np.array(all_synaptic_currents)\n", "\n", " # Calculate average somatic and synaptic currents across all synapses\n", " avg_soma_current = np.mean(all_soma_currents, axis=0)\n", " avg_synaptic_current = np.mean(all_synaptic_currents, axis=0)\n", "\n", " return avg_soma_current, avg_synaptic_current\n", "\n", "# Define your synapse parameters\n", "syn_tau1 = 1.5 # ms # Rise time constant in ms\n", "syn_tau2 = 20 # ms # Decay time constant in ms\n", "syn_e = -70 # mV # GABA reversal potential\n", "\n", "# Run the simulation and get average currents\n", "avg_soma_current, avg_synaptic_current = calculate_average_current(apical_sections, synapse_data, syn_tau1, syn_tau2, syn_e)\n", "\n", "# Save the average currents to CSV\n", "time_ms = np.array(t)\n", "data = {\n", " 'Time (ms)': time_ms,\n", " 'Average Somatic Current (pA)': avg_soma_current,\n", " 'Average Synaptic Current (pA)': avg_synaptic_current\n", "}\n", "\n", "# Create DataFrame and save\n", "df = pd.DataFrame(data)\n", "df.to_csv(output_path, index=False)\n", "\n", "print(f\"Average currents saved to {output_path}\")\n", "\n", "# Plot the average currents\n", "plt.figure(figsize=(10, 6))\n", "\n", "# Plot average somatic current\n", "plt.plot(time_ms, avg_soma_current, label='Average Somatic IPSC', color='red')\n", "\n", "# Plot average synaptic current\n", "plt.plot(time_ms, avg_synaptic_current, label='Average Synaptic Current', color='blue')\n", "\n", "# Add labels and title\n", "plt.xlabel('Time (ms)')\n", "plt.ylabel('Current (pA)')\n", "plt.title('Average Somatic and Synaptic Currents')\n", "plt.legend()\n", "\n", "# Show the plot\n", "plt.show()\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "20-80% Rise Time: 3.3750 ms\n", "Half-Decay Time (t50): 17.7750 ms\n", "Peak amplitude of mIPSC:12.791841152240531\n" ] } ], "source": [ "# Function to calculate 20-80% rise time and half-decay time (t50) for avg_soma_current\n", "def calculate_rise_time_and_half_decay(time_ms, avg_soma_current):\n", " # Find the peak current and its index\n", " peak_index = np.argmax(avg_soma_current)\n", " peak_value = avg_soma_current[peak_index]\n", "\n", " # Calculate 20% and 80% of the peak value\n", " threshold_20 = 0.2 * peak_value\n", " threshold_80 = 0.8 * peak_value\n", "\n", " # Find the time corresponding to 20% of the peak (before peak)\n", " try:\n", " crossing_20 = np.where(avg_soma_current[:peak_index] >= threshold_20)[0][0]\n", " except IndexError:\n", " crossing_20 = None\n", " print(\"No valid 20% threshold crossing found.\")\n", " \n", " # Find the time corresponding to 80% of the peak (before peak)\n", " try:\n", " crossing_80 = np.where(avg_soma_current[:peak_index] >= threshold_80)[0][0]\n", " except IndexError:\n", " crossing_80 = None\n", " print(\"No valid 80% threshold crossing found.\")\n", " \n", " # Calculate 20-80% rise time if valid thresholds are found\n", " if crossing_20 is not None and crossing_80 is not None:\n", " rise_time_20_80 = time_ms[crossing_80] - time_ms[crossing_20]\n", " else:\n", " rise_time_20_80 = None\n", "\n", " # Calculate 50% decay value\n", " half_value = 0.5 * peak_value\n", "\n", " # Find the index where the current decays to 50% after the peak\n", " try:\n", " crossing_50 = np.where(avg_soma_current[peak_index:] <= half_value)[0][0]\n", " except IndexError:\n", " crossing_50 = None\n", " print(\"No valid half-decay threshold found.\")\n", " \n", " # Calculate half-decay time (t50) if valid threshold is found\n", " if crossing_50 is not None:\n", " half_decay_time = time_ms[peak_index + crossing_50] - time_ms[peak_index]\n", " else:\n", " half_decay_time = None\n", "\n", " return rise_time_20_80, half_decay_time\n", "\n", "# Calculate 20-80% rise time and t50 for avg_soma_current\n", "rise_time_20_80, half_decay_time = calculate_rise_time_and_half_decay(time_ms, avg_soma_current)\n", "\n", "# Display results\n", "print(f\"Peak amplitude of mIPSC:{max(avg_soma_current)}\")\n", "print(f\"20-80% Rise Time: {rise_time_20_80:.4f} ms\" if rise_time_20_80 else \"20-80% Rise Time: Not calculated\")\n", "print(f\"Half-Decay Time (t50): {half_decay_time:.4f} ms\" if half_decay_time else \"Half-Decay Time (t50): Not calculated\")\n", "\n", "# Reference values for mIPSC amplitude and kinetics from experiments\n", "# amp: 12.7496 pA\n", "# rise: 3.58649 ms\n", "# t50: 17.8088 ms" ] } ], "metadata": { "kernelspec": { "display_name": "base", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.14" } }, "nbformat": 4, "nbformat_minor": 2 }