def _derivatives(self, coupling_variables):
[x, y] = self._unwrap_state_vector()
d_x = (-self.params["alpha"] * x**3 + self.params["beta"] * x**2 +
self.params["gamma"] * x - y + coupling_variables["network_x"] +
system_input(self.noise_input_idx[0]) + self.params["x_ext"])
d_y = ((x - self.params["delta"] - self.params["epsilon"] * y) /
self.params["tau"] + coupling_variables["network_y"] +
system_input(self.noise_input_idx[1]) + self.params["y_ext"])
return [d_x, d_y]
def _derivatives(self, coupling_variables):
[x, y] = self._unwrap_state_vector()
d_x = ((self.params["a"] - x**2 - y**2) * x - self.params["w"] * y +
coupling_variables["network_x"] +
system_input(self.noise_input_idx[0]) + self.params["x_ext"])
d_y = ((self.params["a"] - x**2 - y**2) * y + self.params["w"] * x +
coupling_variables["network_y"] +
system_input(self.noise_input_idx[1]) + self.params["y_ext"])
return [d_x, d_y]
def _derivatives(self, coupling_variables):
(
I_mu,
I_syn_mu_exc,
I_syn_mu_inh,
I_syn_sigma_exc,
I_syn_sigma_inh,
firing_rate,
) = self._unwrap_state_vector()
exc_inp, inh_inp, exc_inp_sq, inh_inp_sq = self._compute_couplings(
coupling_variables)
I_sigma = se.sqrt(
2 * self.params["Jie_max"]**2 * I_syn_sigma_exc *
self.params["tau_se"] * self.params["taum"] /
((1.0 + exc_inp) * self.params["taum"] + self.params["tau_se"]) +
2 * self.params["Jii_max"]**2 * I_syn_sigma_inh *
self.params["tau_si"] * self.params["taum"] /
((1.0 + inh_inp) * self.params["taum"] + self.params["tau_si"]) +
self.params["sigmai_ext"]**2)
# get values from linear-nonlinear lookup table
firing_rate_now = self.callback_functions["firing_rate_lookup"](
I_mu, I_sigma)
tau = self.callback_functions["tau_lookup"](I_mu, I_sigma)
d_I_mu = (self.params["Jie_max"] * I_syn_mu_exc +
self.params["Jii_max"] * I_syn_mu_inh +
system_input(self.noise_input_idx[0]) +
self.params["ext_inh_current"] - I_mu) / tau
d_I_syn_mu_exc = ((1.0 - I_syn_mu_exc) * exc_inp -
I_syn_mu_exc) / self.params["tau_se"]
d_I_syn_mu_inh = ((1.0 - I_syn_mu_inh) * inh_inp -
I_syn_mu_inh) / self.params["tau_si"]
d_I_syn_sigma_exc = (
(1.0 - I_syn_mu_exc)**2 * exc_inp_sq +
(exc_inp_sq - 2.0 * self.params["tau_se"] *
(exc_inp + 1.0)) * I_syn_sigma_exc) / (self.params["tau_se"]**2)
d_I_syn_sigma_inh = (
(1.0 - I_syn_mu_inh)**2 * inh_inp_sq +
(inh_inp_sq - 2.0 * self.params["tau_si"] *
(inh_inp + 1.0)) * I_syn_sigma_inh) / (self.params["tau_si"]**2)
# firing rate as dummy dynamical variable with infinitely fast
# fixed-point dynamics
d_firing_rate = -self.params["lambda"] * (firing_rate -
firing_rate_now)
return [
d_I_mu,
d_I_syn_mu_exc,
d_I_syn_mu_inh,
d_I_syn_sigma_exc,
d_I_syn_sigma_inh,
d_firing_rate,
]
def _derivatives(self, coupling_variables):
[x] = self._unwrap_state_vector()
d_x = (-x + (1.0 - x) * self._sigmoid(
coupling_variables["node_inh_exc"] -
coupling_variables["node_inh_inh"] +
coupling_variables["network_inh_exc"] + self.params["ext_input"]) +
system_input(self.noise_input_idx[0])) / self.params["tau"]
return [d_x]
def _derivatives(self, coupling_variables):
(
I_mu,
I_syn_mu_exc,
I_syn_mu_inh,
I_syn_sigma_exc,
I_syn_sigma_inh,
firing_rate,
) = self._unwrap_state_vector()
exc_inp, inh_inp, exc_inp_sq, inh_inp_sq = self._compute_couplings(
coupling_variables)
I_sigma = self._get_current_sigma(
I_syn_sigma_exc,
I_syn_sigma_inh,
exc_inp,
inh_inp,
self.params["Jie_max"],
self.params["Jii_max"],
self.params["sigmai_ext"],
)
# get values from linear-nonlinear lookup table
firing_rate_now = self.callback_functions["firing_rate_lookup"](
I_mu, I_sigma)
tau = self.callback_functions["tau_lookup"](I_mu, I_sigma)
d_I_mu = (self.params["Jie_max"] * I_syn_mu_exc +
self.params["Jii_max"] * I_syn_mu_inh +
system_input(self.noise_input_idx[0]) +
self.params["ext_inh_current"] - I_mu) / tau
d_I_syn_mu_exc = self._get_synaptic_current_mu(I_syn_mu_exc, exc_inp,
self.params["tau_se"])
d_I_syn_mu_inh = self._get_synaptic_current_mu(I_syn_mu_inh, inh_inp,
self.params["tau_si"])
d_I_syn_sigma_exc = self._get_synaptic_current_sigma(
I_syn_mu_exc, I_syn_sigma_exc, exc_inp, exc_inp_sq,
self.params["tau_se"])
d_I_syn_sigma_inh = self._get_synaptic_current_sigma(
I_syn_mu_inh, I_syn_sigma_inh, inh_inp, inh_inp_sq,
self.params["tau_si"])
# firing rate as dummy dynamical variable with infinitely fast fixed-point dynamics
d_firing_rate = -self.params["lambda"] * (firing_rate -
firing_rate_now)
return [
d_I_mu,
d_I_syn_mu_exc,
d_I_syn_mu_inh,
d_I_syn_sigma_exc,
d_I_syn_sigma_inh,
d_firing_rate,
]
def _derivatives(self, coupling_variables):
(
voltage,
h_T,
syn_ext,
syn_inh,
dsyn_ext,
dsyn_inh,
firing_rate,
) = self._unwrap_state_vector()
# voltage dynamics
d_voltage = -(
self._get_leak_current(voltage)
+ self._get_excitatory_current(voltage, syn_ext)
+ self._get_inhibitory_current(voltage, syn_inh)
+ self.params["ext_current"]
) / self.params["tau"] - (1.0 / self.params["C_m"]) * (
self._get_potassium_leak_current(voltage) + self._get_T_type_current(voltage, h_T)
)
# channel dynamics: T-type
d_h_T = (self._h_inf_T(voltage) - h_T) / self._tau_h_T(voltage)
# synaptic dynamics
d_syn_ext = dsyn_ext
d_syn_inh = dsyn_inh
d_dsyn_ext = (
self.params["gamma_e"] ** 2
* (
coupling_variables["node_inh_exc"]
+ coupling_variables["network_inh_exc"]
+ system_input(self.noise_input_idx[0])
- syn_ext
)
- 2 * self.params["gamma_e"] * dsyn_ext
)
d_dsyn_inh = (
self.params["gamma_r"] ** 2 * (coupling_variables["node_inh_inh"] - syn_inh)
- 2 * self.params["gamma_r"] * dsyn_inh
)
# firing rate as dummy dynamical variable with infinitely fast
# fixed-point dynamics
firing_rate_now = self._get_firing_rate(voltage)
d_firing_rate = -self.params["lambda"] * (firing_rate - firing_rate_now)
return [
d_voltage,
d_h_T,
d_syn_ext,
d_syn_inh,
d_dsyn_ext,
d_dsyn_inh,
d_firing_rate,
]
def _derivatives(self, coupling_variables):
[s, firing_rate] = self._unwrap_state_vector()
current = (self.params["w"] * self.params["J"] * s +
self.params["J"] * coupling_variables["network_S"] +
self.params["exc_current"])
firing_rate_now = self._get_firing_rate(current)
d_s = ((-s / self.params["tau"]) +
(1.0 - s) * self.params["gamma"] * firing_rate_now +
system_input(self.noise_input_idx[0]))
# firing rate as dummy dynamical variable with infinitely fast
# fixed-point dynamics
d_firing_rate = -self.params["lambda"] * (firing_rate -
firing_rate_now)
return [d_s, d_firing_rate]
def _derivatives(self, coupling_variables):
(
voltage,
ca_conc,
h_T,
m_h1,
m_h2,
syn_ext,
syn_inh,
dsyn_ext,
dsyn_inh,
firing_rate,
) = self._unwrap_state_vector()
# voltage dynamics
d_voltage = -(self._get_leak_current(voltage) +
self._get_excitatory_current(voltage, syn_ext) +
self._get_inhibitory_current(voltage, syn_inh) +
self.params["ext_current"]) / self.params["tau"] - (
1.0 / self.params["C_m"]) * (
self._get_potassium_leak_current(voltage) +
self._get_T_type_current(voltage, h_T) +
self._get_anomalous_rectifier_current(
voltage, m_h1, m_h2))
# calcium concetration dynamics
d_ca_conc = (
self.params["alpha_Ca"] * self._get_T_type_current(voltage, h_T) -
(ca_conc - self.params["Ca_0"]) / self.params["tau_Ca"])
# channel dynamics: T-type and rectifier current
d_h_T = (self._h_inf_T(voltage) - h_T) / self._tau_h_T(voltage)
d_m_h1 = ((self._m_inf_h(voltage) *
(1.0 - m_h2) - m_h1) / self._tau_m_h(voltage) -
self.params["k3"] * self._P_h(ca_conc) * m_h1 +
self.params["k4"] * m_h2)
d_m_h2 = self.params["k3"] * self._P_h(
ca_conc) * m_h1 - self.params["k4"] * m_h2
# synaptic dynamics
d_syn_ext = dsyn_ext
d_syn_inh = dsyn_inh
d_dsyn_ext = (self.params["gamma_e"]**2 *
(coupling_variables["node_exc_exc"] +
coupling_variables["network_exc_exc"] +
system_input(self.noise_input_idx[0]) - syn_ext) -
2 * self.params["gamma_e"] * dsyn_ext)
d_dsyn_inh = (self.params["gamma_r"]**2 *
(coupling_variables["node_exc_inh"] - syn_inh) -
2 * self.params["gamma_r"] * dsyn_inh)
# firing rate as dummy dynamical variable with infinitely fast
# fixed-point dynamics
firing_rate_now = self._get_firing_rate(voltage)
d_firing_rate = -self.params["lambda"] * (firing_rate -
firing_rate_now)
return [
d_voltage,
d_ca_conc,
d_h_T,
d_m_h1,
d_m_h2,
d_syn_ext,
d_syn_inh,
d_dsyn_ext,
d_dsyn_inh,
d_firing_rate,
]
