def getting_started(): """ An example to quickly get started with the Hodgkin-Huxley module. """ current = input_factory.get_step_current(10, 45, b2.ms, 7.2 * b2.uA) state_monitor = simulate_HH_neuron(current, 70 * b2.ms) plot_data(state_monitor, title="HH Neuron, step current")
def getting_started(): """ An example to quickly get started with the LIF module. Returns: """ # specify step current step_current = input_factory.get_step_current(t_start=10, t_end=190, unit_time=b2.ms, amplitude=20 * b2.namp) # run the LIF model (state_monitor, spike_monitor) = simulate_LIF_neuron(input_current=step_current, simulation_time=200 * b2.ms) # plot the membrane voltage plot_tools.plot_voltage_and_current_traces(state_monitor, step_current, title="Leaky Integrate-and-Fire Neuron", firing_threshold=FIRING_THRESHOLD) print("nr of spikes: {}".format(len(spike_monitor.t))) plt.show() # second example: sinusoidal current. note the higher resolution 0.1 * b2.ms sinusoidal_current = input_factory.get_sinusoidal_current( 500, 1500, unit_time=0.1 * b2.ms, amplitude=2.5 * b2.namp, frequency=150 * b2.Hz, direct_current=2. * b2.namp) (state_monitor, spike_monitor) = simulate_LIF_neuron( input_current=sinusoidal_current, simulation_time=200 * b2.ms) plot_tools.plot_voltage_and_current_traces( state_monitor, sinusoidal_current, title="Sinusoidal input current", firing_threshold=FIRING_THRESHOLD) print("nr of spikes: {}".format(spike_monitor.count[0])) plt.show()
def test_simulate_HH_neuron(): """Test Hodgkin-Huxley model: simulate_HH_neuron()""" current = input_factory.get_step_current(0, 1, b2.ms, 100. * b2.uA) state_monitor = HH.simulate_HH_neuron(current, simulation_time=1. * b2.ms) max_voltage = max(state_monitor.vm[0] / b2.mV) # print("max_voltage:{}".format(max_voltage)) assert max_voltage > 50., "simulation error: max voltage is not > 50"
def _min_curr_expl(): from neurodynex.tools import plot_tools, input_factory durations = [1, 2, 5, 10, 20, 50, 100, 200] min_amp = [8.6, 4.45, 2., 1.15, .70, .48, 0.43, .4] i = 1 t = durations[i] I_amp = min_amp[i] * b2.namp input_current = input_factory.get_step_current(t_start=10, t_end=10 + t - 1, unit_time=b2.ms, amplitude=I_amp) state_monitor, spike_monitor = simulate_exponential_IF_neuron( I_stim=input_current, simulation_time=(t + 20) * b2.ms) plot_tools.plot_voltage_and_current_traces( state_monitor, input_current, title="step current", firing_threshold=FIRING_THRESHOLD_v_spike, legend_location=2) plt.show() print("nr of spikes: {}".format(spike_monitor.count[0]))
def getting_started(): """ An example to quickly get started with the LIF module. Returns: """ # specify step current step_current = input_factory.get_step_current( t_start=100, t_end=200, unit_time=b2.ms, amplitude=1.2 * b2.namp) # run the LIF model (state_monitor, spike_monitor) = simulate_LIF_neuron(input_current=step_current, simulation_time=300 * b2.ms) # plot the membrane voltage plot_tools.plot_voltage_and_current_traces(state_monitor, step_current, title="Step current", firing_threshold=FIRING_THRESHOLD) print("nr of spikes: {}".format(len(spike_monitor.t))) plt.show() # second example: sinusoidal current. note the higher resolution 0.1 * b2.ms sinusoidal_current = input_factory.get_sinusoidal_current( 500, 1500, unit_time=0.1 * b2.ms, amplitude=2.5 * b2.namp, frequency=150 * b2.Hz, direct_current=2. * b2.namp) # run the LIF model (state_monitor, spike_monitor) = simulate_LIF_neuron( input_current=sinusoidal_current, simulation_time=200 * b2.ms) # plot the membrane voltage plot_tools.plot_voltage_and_current_traces( state_monitor, sinusoidal_current, title="Sinusoidal input current", firing_threshold=FIRING_THRESHOLD) print("nr of spikes: {}".format(spike_monitor.count[0])) plt.show()
def test_simulate_exponential_IF_neuron(): """Test if simulates simulate_AdEx_neuron generates two spikes""" current = input_factory.get_step_current(0, 0, 1. * b2.ms, 0.5 * b2.nA) state_monitor, spike_monitor = AdEx.simulate_AdEx_neuron(I_stim=current, simulation_time=1.5 * b2.ms) nr_spikes = spike_monitor.count[0] # print("nr_spikes:{}".format(nr_spikes)) assert nr_spikes == 2, \ "simulation error: Pulse current did not trigger exactly two spikes. " \ "Check if the AdEx default values did change."
def test_simulate_LIF_neuron(): """Test LIF model: simulate_LIF_neuron(short pulse, 1ms, default values)""" c = input_factory.get_step_current(0, 9, 0.1 * b2.ms, .02 * b2.uA) m, spike_monitor = LIF.simulate_LIF_neuron(c, simulation_time=1.1 * b2.ms) nr_spikes = spike_monitor.count[0] # print("nr_spikes:{}".format(nr_spikes)) assert nr_spikes > 0, \ "simulation error: Pulse current did not trigger a spike. " \ "Check if the LIF default values did change."
def test_simulate_exponential_IF_neuron(): """Test exponential-integrate-and-fire model""" c = input_factory.get_step_current(0, 2, 1 * b2.ms, amplitude=8.5 * b2.namp) m, spike_monitor = exp_IF.simulate_exponential_IF_neuron(I_stim=c, simulation_time=1.5 * b2.ms) nr_spikes = spike_monitor.count[0] # print("nr_spikes:{}".format(nr_spikes)) assert nr_spikes == 1, \ "simulation error: Pulse current did not trigger exactly one spike. " \ "Check if the exp-IF default values did change."
def getting_started(): """ A simple example """ import neurodynex.tools.plot_tools as plot_tools input_current = input_factory.get_step_current(t_start=20, t_end=120, unit_time=b2.ms, amplitude=0.8 * b2.namp) state_monitor, spike_monitor = simulate_exponential_IF_neuron( I_stim=input_current, simulation_time=180 * b2.ms) plot_tools.plot_voltage_and_current_traces( state_monitor, input_current, title="step current", firing_threshold=FIRING_THRESHOLD_v_spike) print("nr of spikes: {}".format(spike_monitor.count[0])) plt.show()
def getting_started(): """ Simple example to get started """ from neurodynex.tools import plot_tools current = input_factory.get_step_current(10, 200, 1. * b2.ms, 65.0 * b2.pA) state_monitor, spike_monitor = simulate_AdEx_neuron(I_stim=current, simulation_time=300 * b2.ms) plot_tools.plot_voltage_and_current_traces(state_monitor, current) plot_adex_state(state_monitor) print("nr of spikes: {}".format(spike_monitor.count[0]))
def getting_started(): """ Simple example to get started """ from neurodynex.tools import plot_tools current = input_factory.get_step_current(10, 200, 1. * b2.ms, 500 * b2.pA) ic = input_factory.get_zero_current() state_monitor, spike_monitor = simulate_AdEx_neuron(I_stim=current, simulation_time=300 * b2.ms) # plot_tools.plot_network_activity(rate_monitor, spike_monitor, state_monitor) # plt.show() plot_tools.plot_voltage_and_current_traces(state_monitor, current, title="AdEx neuron simulations") plt.show() plot_adex_state(state_monitor) print("nr of spikes: {}".format(spike_monitor.count[0]))
def getting_started(): """A simple code example to get started. """ current = input_factory.get_step_current(500, 510, unit_time=b2.us, amplitude=3. * b2.namp) voltage_monitor, cable_model = simulate_passive_cable( length=0.5 * b2.mm, current_injection_location=[0.1 * b2.mm], input_current=current, nr_compartments=100, simulation_time=2 * b2.ms) # provide a minimal plot plt.figure() plt.imshow(voltage_monitor.v / b2.volt) plt.colorbar(label="voltage") plt.xlabel("time index") plt.ylabel("location index") plt.title("vm at (t,x), raw data voltage_monitor.v") plt.show()
def test_neurons_run(): """Test if neuron functions are runnable.""" import brian2 as b2 from neurodynex.tools import input_factory from neurodynex.neuron_type import neurons # create an input current input_current = input_factory.get_step_current(1, 2, 1. * b2.ms, 0.1 * b2.pA) # get an instance of class NeuronX a_neuron_of_type_X = neurons.NeuronX( ) # we do not know if it's type I or II state_monitor = a_neuron_of_type_X.run(input_current, 2 * b2.ms) assert isinstance(state_monitor, b2.StateMonitor ), "a_neuron_of_type_X.run did not return a StateMonitor" a_neuron_of_type_Y = neurons.NeuronY( ) # we do not know if it's type I or II state_monitor = a_neuron_of_type_Y.run(input_current, 2 * b2.ms) assert isinstance(state_monitor, b2.StateMonitor ), "a_neuron_of_type_Y.run did not return a StateMonitor"
def getting_started(): """ simple demo to get started Returns: """ from neurodynex.tools import input_factory # create an input current input_current = input_factory.get_step_current(50, 150, 1. * b2.ms, 0.5 * b2.pA) # get an instance of class NeuronX a_neuron_of_type_X = NeuronX() # simulate it and get the state variables state_monitor = a_neuron_of_type_X.run(input_current, 200 * b2.ms) # plot state vs. time plot_data(state_monitor, title="Neuron of Type X") # get an instance of class NeuronY a_neuron_of_type_Y = NeuronY() state_monitor = a_neuron_of_type_Y.run(input_current, 200 * b2.ms) plot_data(state_monitor, title="Neuron of Type Y")
plt.figure("Fig1") plot_tools.plot_voltage_and_current_traces( state_monitor1, input_current, title="step current", firing_threshold=exp_IF.FIRING_THRESHOLD_v_spike) plt.show() """ i = 4 # change i and find the value that goes into min_amp durations = [1, 2, 5, 10, 20, 50, 100] min_amp = [0., 4.42, 0., 1.10, .70, .48, 0.] t = durations[i] I_amp = min_amp[i] * b2.namp title_txt = "I_amp={}, t={}".format(I_amp, t * b2.ms) input_current = input_factory.get_step_current(t_start=10, t_end=10 + t - 1, unit_time=b2.ms, amplitude=I_amp) state_monitor, spike_monitor = exp_IF.simulate_exponential_IF_neuron( I_stim=input_current, simulation_time=(t + 20) * b2.ms) plt.figure(1) plot_tools.plot_voltage_and_current_traces( state_monitor, input_current, title=title_txt, firing_threshold=exp_IF.FIRING_THRESHOLD_v_spike, legend_location=2) print("nr of spikes: {}".format(spike_monitor.count[0])) plt.figure(2)
resistance = self.resistance if (threshold == None): threshold = self.threshold eqs = "dv/dt = (-(v-v_rest) +delta_t*exp((v-rheo_threshold)/delta_t)+ resistance * current(t,i))/(time_scale) : volt" neuron = b2.NeuronGroup(1, model=eqs, reset="v=v_reset", threshold="v>threshold", method="euler") neuron.v = v_rest voltage_monitor = b2.StateMonitor(neuron, ["v"], record=True) spike_monitor = b2.SpikeMonitor(neuron) net = b2.Network(neuron, voltage_monitor, spike_monitor) net.run(time) return voltage_monitor, spike_monitor lif_neuron = expLIF() print('7 repetitive spikes : current = 0.8 nA') input_current = input_factory.get_step_current(t_start=20, t_end=120, unit_time=b2.ms, amplitude=0.8 * b2.namp) state_monitor, spike_monitor = lif_neuron.simulate(current=input_current, time=200 * b2.ms) plot_tools.plot_voltage_and_current_traces( state_monitor, input_current, title="step current", firing_threshold=lif_neuron.threshold) print("nr of spikes: {}".format(spike_monitor.count[0]))
import matplotlib.pyplot as plt from neurodynex.adex_model import AdEx from neurodynex.tools import plot_tools, input_factory """ MEMBRANE_TIME_SCALE_tau_m = 5 * b2.ms MEMBRANE_RESISTANCE_R = 500*b2.Mohm V_REST = -70.0 * b2.mV V_RESET = -51.0 * b2.mV RHEOBASE_THRESHOLD_v_rh = -50.0 * b2.mV SHARPNESS_delta_T = 2.0 * b2.mV ADAPTATION_VOLTAGE_COUPLING_a = 0.5 * b2.nS ADAPTATION_TIME_CONSTANT_tau_w = 100.0 * b2.ms SPIKE_TRIGGERED_ADAPTATION_INCREMENT_b = 7.0 * b2.pA """ current = input_factory.get_step_current(10, 250, 1. * b2.ms, 65.0 * b2.pA) # Variare l'adaptation voltage coupling influisce sul numero di spikes # Il bursting si ottiene cambiando il valore del reset del potenziale, ovviamente # in tal modo ti posizioni in un altro punto dello spazio delle fasi # "a" cambia anche la posizione dei punti di equilibrio a seconda della positività o negatività state_monitor, spike_monitor = AdEx.simulate_AdEx_neuron(I_stim=current, simulation_time=400 * b2.ms, a=-0.5 * b2.nS, v_reset=-46 * b2.mV) plt.figure(1) plot_tools.plot_voltage_and_current_traces(state_monitor, current) print("nr of spikes: {}".format(spike_monitor.count[0])) plt.figure(2)
idx_t_end = int(round(slow_ramp_t_end*b2.ms / b2.defaultclock.dt)) voltage_slow = state_monitor1.vm[0,idx_t_end] print("voltage_slow = {} V".format(voltage_slow)) # Qui sotto invece un aumento repentino della corrente b2.defaultclock.dt = 0.02*b2.ms fast_ramp_t_end = 100 fast_ramp_current = input_factory.get_ramp_current(50, fast_ramp_t_end, 0.1*b2.ms, 0.*b2.uA, 4.5*b2.uA) state_monitor2 = HH.simulate_HH_neuron(fast_ramp_current, 40 * b2.ms) idx_t_end = int(round(fast_ramp_t_end*0.1*b2.ms / b2.defaultclock.dt)) voltage_fast = state_monitor2.vm[0,idx_t_end] print("voltage_fast = {} V".format(voltage_fast)) Una cosa importante che cambia è lo step temporale con il quale aumenta la corrente. Questo dipende dal parametro dopo slow/fast_ramp_t_end. Questo fa in modo che la fast current vada da cinque a dieci msecondi. Uno si chiede "ma perché non mettere come prima b2.ms e rapportarsi a questa unità di misura?", misteri della fede. HH.plot_data(state_monitor1, title="Slow") HH.plot_data(state_monitor2, title="Fast") """ # Hyperpolarizing current in grado di creare uno spike I = -5 corrente = input_factory.get_step_current(10, 90, b2.ms, I*b2.uA) state_monitor = HH.simulate_HH_neuron(corrente, 100 * b2.ms) HH.plot_data(state_monitor, title="Hyperpolarizing current") plt.show()
from neurodynex.tools import input_factory import matplotlib.pyplot as plt import numpy as np # integration time step in milliseconds b2.defaultclock.dt = 0.01 * b2.ms # DEFAULT morphological and electrical parameters CABLE_LENGTH = 500. * b2.um # length of dendrite CABLE_DIAMETER = 2. * b2.um # diameter of dendrite R_LONGITUDINAL = 0.5 * b2.kohm * b2.mm # Intracellular medium resistance R_TRANSVERSAL = 1.25 * b2.Mohm * b2.mm**2 # cell membrane resistance (->leak current) E_LEAK = -70. * b2.mV # reversal potential of the leak current (-> resting potential) CAPACITANCE = 0.8 * b2.uF / b2.cm**2 # membrane capacitance DEFAULT_INPUT_CURRENT = input_factory.get_step_current(2000, 3000, unit_time=b2.us, amplitude=0.2 * b2.namp) DEFAULT_INPUT_LOCATION = [CABLE_LENGTH / 3] # provide an array of locations # print("Membrane Timescale = {}".format(R_TRANSVERSAL*CAPACITANCE)) def simulate_passive_cable(current_injection_location=DEFAULT_INPUT_LOCATION, input_current=DEFAULT_INPUT_CURRENT, length=CABLE_LENGTH, diameter=CABLE_DIAMETER, r_longitudinal=R_LONGITUDINAL, r_transversal=R_TRANSVERSAL, e_leak=E_LEAK, initial_voltage=E_LEAK, capacitance=CAPACITANCE, nr_compartments=200,
la corrente di soglia per ottenere un firing tonico in entrambi è di 0.38 pAmp, quindi è con questa corrente che ho la biforcazione saddle-note onto/off limit cycle. """ T = 1200 * b2.ms f1 = [] f2 = [] I = [] I_ist = 0.01 neuronX = neurons.NeuronX() neuronY = neurons.NeuronY() while I_ist < 0.90: input_current = input_factory.get_step_current(100, 1100, b2.ms, I_ist * b2.pA) state_monitor1 = neuronX.run(input_current, T) state_monitor2 = neuronY.run(input_current, T) spike_stats1 = spike_tools.get_spike_stats(state_monitor1, 0 * b2.mV) spike_stats2 = spike_tools.get_spike_stats(state_monitor2, 0 * b2.mV) f1.append(spike_stats1[0] / T) f2.append(spike_stats2[0] / T) I_ist += 0.01 I.append(I_ist) """ print(f1) print(f2) print(I) """ plt.figure(1)