# step 1: need multiple input currents
I0 = np.linspace(1,10,10)
n_spikes = []
# step 2: choose a value T for time of stim
T0 = 200
# step 3: establish a voltage threshold for "spikes"
V = np.array()
Vth = 0
# step 4: for loop for each input current value in HH model
for k in range(0, len(I0)
[V,m,n,h,t]=HH(I0[k], T0)
spike = V[V > Vth]
peaks = find_peaks(spike)[0]
rate = len(peaks)
fRateVector = fRateVector + [rate]
# step 5: attempt to plot everything and hope for the best
plt.figure()
plt.plot(fRateVector,I0)
plt.xlabel('Current')
plt.ylabel('Frequency')
@author: lenovo
Generating firing rates at different I0
"""
from HH_functions import HH
import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import find_peaks
T0 = 1000
len_I0 = 20
frate = np.zeros(len_I0)
for I0 in range(0, len_I0, 1):
I00 = I0
[V, m, h, n, t] = HH(I00, T0)
##peakind = signal.find_peaks_cwt(np.shape(V),np.arange(1,2000))
#peakind = find_peaks(np.reshape(V,-1),height=0)
peakind = find_peaks(np.reshape(V, -1), height=-20)
##frate[I0]=1000/(peakind[0][1]- peakind[0][0])
#frate[I0]=np.shape(peak)
frate[I0] = len(peakind[0])
plt.figure()
III = range(len_I0)
plt.plot(III, frate)
plt.xlabel('Input Current/mA')
plt.ylabel('Firing Rate/Hz')
plt.title('F-I Curve for HH Model')
###################################
#numi0=0
#for I0 in range(40):
import matplotlib.pyplot as plt
from scipy.signal import find_peaks
from scipy.signal import savgol_filter
from HH_functions import HH
# for function instruction or parameters
import inspect
inspect.getsourcelines(HH)
T0 = 500
Input = np.linspace(0, 60, 100)
spikes = np.zeros((len(Input)))
#loop over inputs within input_array
for i in range(len(Input)):
[V, m, h, n, t] = HH(Input[i], T0)
V = np.concatenate(V) #restructure V so each elements not arrays
peaks = find_peaks(V,
prominence=(15,
None)) #find peak via prominence critereion
spikes[i] = len(peaks[0]) * 2 #estimate peak frequency within 1 sec [Hz]
plt.figure()
plt.plot(Input, spikes, lw=3)
plt.xlabel('Input [mA/cm^2]')
plt.ylabel('Firing rate [Hz]')
# Smoothed function via Savitsky-Golay filter
plt.plot(Input, savgol_filter(spikes, 45, 4))
plt.show
- `t` = the time axis of the simulation (useful for plotting). ## Part 2: At low input current (`I0`), examine the HH dynamics. To understand how the HH model works, we'll start by focusing on the case when `I0` is small. Let's fix the input current to zero, I0 = 0 and let's simulate the model for 100 ms, T0 = 100 We've now defined both inputs to the `HH` function, and can execute it, as follows, [V,m,h,n,t]=HH(I0,T0) Notice that the function returns five outputs, which we assign to the variables `V`, `m`, `h`, `n`, and `t`. <div class="question"> **Q:** What are the dynamics of the voltage (variable `V`) resulting from this simulation?<br> HINT: Plot `V` vs `t`. </div> <div class="question"> **Q:** What are the dynamics of the gating variables (`m`, `h`, `n`) resulting from this simulation?<br>
"""
import numpy as np
from HH_functions import HH
import matplotlib.pyplot as plt
# Test for a range of currents
currents = np.arange(0, 200, 10)
firing_rates = np.zeros([len(currents), 1])
T0 = 15 # Input Current
# Test over all currents
for i in range(0, len(currents)):
# Simulate the Hodgkin Huxley Model
[Vs, ms, hs, ns, ts] = HH(currents[i], T0)
# Test for a rise before the peak
a = (Vs[0:len(Vs) - 2] < Vs[1:len(Vs) - 1])
# Test for a fall after the peak
b = (Vs[1:len(Vs) - 1] > Vs[2:])
# Find spikes (spots with a rise before and a fall after)
spikes = np.logical_and(a, b)
# Count number of spikes
firing_rates[i] = sum(spikes)
# Plot
plt.plot(currents, firing_rates)
@author: bever
"""
#NOTE: this will not work for the default HH function!
#edited the HH file to return dv and take in dt
import numpy as np
import matplotlib.pyplot as plt
from HH_functions import HH
T0 = 500 #number of time points
n = 200 # length of I vector
I = np.linspace(0, 100, n) #input
dt = 0.01
T = T0 / dt # [ms]
FI_rate = np.zeros(n)
for j in np.arange(n):
I0 = I[j]
V, m, h, n, t, dv = HH(I0, T0, dt)
num_peaks = 0
for i in np.arange(T - 1):
if dv[int(i)] > 0 and dv[int(i + 1)] < 0:
num_peaks = num_peaks + 1
FI_rate[j] = num_peaks
plt.plot(I, FI_rate)
plt.xlabel("Imput current(I)")
plt.ylabel("Number of Spikes")
plt.show()
#General import statements
import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import find_peaks
from HH_functions import HH
#Brute force method of demonstrating F-I Curve for H-H Model
fRateVector = [] #Create vector to store firing rates
iRange = np.linspace(0, 25, 25) #Set how many inputs to test
T0 = 400 #Set temporal length of simulation
#!! Note !! >100 is computationally expensive
for i in range(0, len(iRange)):
I0 = iRange[i] #Set input current
[V, m, h, n, t] = HH(I0, T0) #Run HH simulation
V = np.reshape(V, -1)
highV = V[V > 0] #Collect Voltage only above 0 mV
numPeaks = find_peaks(highV)[0] #Find peaks on cropped voltage data
fRate = len(numPeaks) #Get number of spikes
fRateVector = fRateVector + [fRate]
#Plotting...
plt.figure()
plt.plot(iRange, fRateVector)
plt.ylabel('Firing Rate (# of spikes)')
plt.xlabel('Current (Amps)')
plt.title('F-I Curve for HH Model')
@author: kylie
"""
#F-I curve for Hodgkin-Huxley Model
import numpy as np
import math
import matplotlib.pyplot as plt
from HH_functions import HH
from scipy.signal import argrelextrema
T0 = 100 #set time for simulation
I = np.linspace(0, 50, 50) #set range of input currents
Vth = -20 #set voltage threshold for "spike"
NumSpike = [] #create vector to store spikes
for i in range(0, len(I)): #for each value of input current...
[V, m, h, n, t] = HH(I[i], T0) #simulate HH
Vspike = V[
V > Vth] #extract voltages where voltage exceeds threshold as 'Vspike'
spike_max = Vspike[argrelextrema(
Vspike, np.greater)] #extract the max voltages for Vspike
fire_num = len(
spike_max) #calculating number of spikes during Vspike intervals
NumSpike = NumSpike + [
fire_num
] #returning number of spikes to spike vector NumSpike
FR = [x / (T0 / 1000) for x in NumSpike] #firing rate
plt.figure()
plt.plot(I, FR)
plt.ylabel('Firing Rate (Hz)')
plt.xlabel('Input Current (Amps)')