def update_derived_parameters(self, corrected_d_p=True):
"""
Calculate coefficients for the neural field model based on a Reduced set
of Hindmarsh-Rose oscillators. Specifically, this method implements
equations for calculating coefficients found in the supplemental
material of [SJ_2008]_.
Include equations here...
"""
newaxis = numpy.newaxis
trapz = scipy_integrate_trapz
stepu = 1.0 / (self.nu + 2 - 1)
stepv = 1.0 / (self.nv + 2 - 1)
norm = scipy_stats_norm(loc=self.mu, scale=self.sigma)
Iu = norm.ppf(numpy.arange(stepu, 1.0, stepu))
Iv = norm.ppf(numpy.arange(stepv, 1.0, stepv))
# Define the modes
V = numpy.zeros((self.number_of_modes, self.nv))
U = numpy.zeros((self.number_of_modes, self.nu))
nv_per_mode = self.nv // self.number_of_modes
nu_per_mode = self.nu // self.number_of_modes
for i in range(self.number_of_modes):
V[i,
i * nv_per_mode:(i + 1) * nv_per_mode] = numpy.ones(nv_per_mode)
U[i,
i * nu_per_mode:(i + 1) * nu_per_mode] = numpy.ones(nu_per_mode)
# Normalise the modes
V = V / numpy.tile(numpy.sqrt(trapz(V * V, Iv, axis=1)),
(self.nv, 1)).T
U = U / numpy.tile(numpy.sqrt(trapz(U * U, Iu, axis=1)),
(self.nu, 1)).T
# Get Normal PDF's evaluated with sampling Zv and Zu
g1 = norm.pdf(Iv)
g2 = norm.pdf(Iu)
G1 = numpy.tile(g1, (self.number_of_modes, 1))
G2 = numpy.tile(g2, (self.number_of_modes, 1))
cV = numpy.conj(V)
cU = numpy.conj(U)
#import pdb; pdb.set_trace()
intcVdI = trapz(cV, Iv, axis=1)[:, newaxis]
intG1VdI = trapz(G1 * V, Iv, axis=1)[newaxis, :]
intcUdI = trapz(cU, Iu, axis=1)[:, newaxis]
#Calculate coefficients
self.A_ik = numpy.dot(intcVdI, intG1VdI).T
self.B_ik = numpy.dot(intcVdI, trapz(G2 * U, Iu, axis=1)[newaxis, :])
self.C_ik = numpy.dot(intcUdI, intG1VdI).T
self.a_i = self.a * trapz(cV * V**3, Iv, axis=1)[newaxis, :]
self.e_i = self.a * trapz(cU * U**3, Iu, axis=1)[newaxis, :]
self.b_i = self.b * trapz(cV * V**2, Iv, axis=1)[newaxis, :]
self.f_i = self.b * trapz(cU * U**2, Iu, axis=1)[newaxis, :]
self.c_i = (self.c * intcVdI).T
self.h_i = (self.c * intcUdI).T
self.IE_i = trapz(Iv * cV, Iv, axis=1)[newaxis, :]
self.II_i = trapz(Iu * cU, Iu, axis=1)[newaxis, :]
if corrected_d_p:
# correction identified by Shrey Dutta & Arpan Bannerjee, confirmed by RS
self.d_i = self.d * trapz(cV * V**2, Iv, axis=1)[newaxis, :]
self.p_i = self.d * trapz(cU * U**2, Iu, axis=1)[newaxis, :]
else:
# typo in the original paper by RS & VJ, kept for comparison purposes.
self.d_i = (self.d * intcVdI).T
self.p_i = (self.d * intcUdI).T
self.m_i = (self.r * self.s * self.xo * intcVdI).T
self.n_i = (self.r * self.s * self.xo * intcUdI).T
def update_derived_parameters(self):
"""
Calculate coefficients for the Reduced FitzHugh-Nagumo oscillator based
neural field model. Specifically, this method implements equations for
calculating coefficients found in the supplemental material of
[SJ_2008]_.
Include equations here...
"""
newaxis = numpy.newaxis
trapz = scipy_integrate_trapz
stepu = 1.0 / (self.nu + 2 - 1)
stepv = 1.0 / (self.nv + 2 - 1)
norm = scipy_stats_norm(loc=self.mu, scale=self.sigma)
Zu = norm.ppf(numpy.arange(stepu, 1.0, stepu))
Zv = norm.ppf(numpy.arange(stepv, 1.0, stepv))
# Define the modes
V = numpy.zeros((self.number_of_modes, self.nv))
U = numpy.zeros((self.number_of_modes, self.nu))
nv_per_mode = self.nv // self.number_of_modes
nu_per_mode = self.nu // self.number_of_modes
for i in range(self.number_of_modes):
V[i,
i * nv_per_mode:(i + 1) * nv_per_mode] = numpy.ones(nv_per_mode)
U[i,
i * nu_per_mode:(i + 1) * nu_per_mode] = numpy.ones(nu_per_mode)
# Normalise the modes
V = V / numpy.tile(numpy.sqrt(trapz(V * V, Zv, axis=1)),
(self.nv, 1)).T
U = U / numpy.tile(numpy.sqrt(trapz(U * U, Zu, axis=1)),
(self.nv, 1)).T
# Get Normal PDF's evaluated with sampling Zv and Zu
g1 = norm.pdf(Zv)
g2 = norm.pdf(Zu)
G1 = numpy.tile(g1, (self.number_of_modes, 1))
G2 = numpy.tile(g2, (self.number_of_modes, 1))
cV = numpy.conj(V)
cU = numpy.conj(U)
intcVdZ = trapz(cV, Zv, axis=1)[:, newaxis]
intG1VdZ = trapz(G1 * V, Zv, axis=1)[newaxis, :]
intcUdZ = trapz(cU, Zu, axis=1)[:, newaxis]
# import pdb; pdb.set_trace()
# Calculate coefficients
self.Aik = numpy.dot(intcVdZ, intG1VdZ).T
self.Bik = numpy.dot(intcVdZ, trapz(G2 * U, Zu, axis=1)[newaxis, :])
self.Cik = numpy.dot(intcUdZ, intG1VdZ).T
self.e_i = trapz(cV * V**3, Zv, axis=1)[newaxis, :]
self.f_i = trapz(cU * U**3, Zu, axis=1)[newaxis, :]
self.IE_i = trapz(Zv * cV, Zv, axis=1)[newaxis, :]
self.II_i = trapz(Zu * cU, Zu, axis=1)[newaxis, :]
self.m_i = (self.a * intcVdZ).T
self.n_i = (self.a * intcUdZ).T