def simulate(self, cell):
# pylint: disable=invalid-name,no-member
data = self.data
run_param = self.run_param
elec_x = np.empty([
len(run_param['theta']),
run_param['n_phi'],
run_param['n'],
])
elec_y = np.empty(elec_x.shape)
elec_z = np.empty(elec_x.shape)
for i, theta in enumerate(run_param['theta']):
theta = theta * np.pi / 180
for j in xrange(run_param['n_phi']):
phi = float(j) / run_param['n_phi'] * np.pi * 2
y1 = run_param['R'] * np.cos(theta)
x1 = run_param['R'] * np.sin(theta) * np.sin(phi)
z1 = run_param['R'] * np.sin(theta) * np.cos(phi)
y0 = run_param['R_0'] * np.cos(theta)
x0 = run_param['R_0'] * np.sin(theta) * np.sin(phi)
z0 = run_param['R_0'] * np.sin(theta) * np.cos(phi)
elec_x[i, j] = np.linspace(x0, x1, run_param['n'])
elec_y[i, j] = np.linspace(y0, y1, run_param['n'])
elec_z[i, j] = np.linspace(z0, z1, run_param['n'])
x = elec_x.flatten()
y = elec_y.flatten()
z = elec_z.flatten()
cell.simulate(rec_imem=True)
# Record the LFP of the electrodes.
electrode = LFPy.RecExtElectrode(cell,
x=x,
y=y,
z=z,
sigma=run_param['sigma'])
electrode.method = run_param['ext_method']
electrode.calc_lfp()
data['LFP'] = electrode.LFP
data['elec_x'] = x
data['elec_y'] = y
data['elec_z'] = z
data['t_vec'] = cell.tvec
data['soma_v'] = cell.somav
data['dt'] = cell.timeres_NEURON
data['poly_morph'] \
= de.get_polygons_no_axon(cell,['x','y'])
data['poly_morph_axon'] \
= de.get_polygons_axon(cell,['x','y'])
data['poly_morph_xz'] \
= de.get_polygons_no_axon(cell,['x','z'])
data['poly_morph_axon_xz'] \
= de.get_polygons_axon(cell,['x','z'])
def simulate(self, cell):
self.data['poly_morph_x_y'] \
= de.get_polygons_no_axon(cell,('x','y'))
self.data['poly_morph_x_y_axon'] \
= de.get_polygons_axon(cell,('x','y'))
self.data['poly_morph_x_z'] \
= de.get_polygons_no_axon(cell,('x','z'))
self.data['poly_morph_x_z_axon'] \
= de.get_polygons_axon(cell,('x','z'))
self.data['poly_morph_y_z'] \
= de.get_polygons_no_axon(cell,('y','z'))
self.data['poly_morph_y_z_axon'] \
= de.get_polygons_axon(cell,('y','z'))
def simulate(self, cell):
data = self.data
run_param = self.run_param
# Calculate random numbers in a sphere.
np.random.seed(run_param['seed'])
l = np.random.uniform(0, 1, run_param['N'])
u = np.random.uniform(-1, 1, run_param['N'])
phi = np.random.uniform(0, 2 * np.pi, run_param['N'])
x = run_param['R'] * np.power(l, 1 /
3.0) * np.sqrt(1 - u * u) * np.cos(phi),
y = run_param['R'] * np.power(l, 1 /
3.0) * np.sqrt(1 - u * u) * np.sin(phi),
z = run_param['R'] * np.power(l, 1 / 3.0) * u
cell.simulate(rec_imem=True)
# Record the LFP of the electrodes.
electrode = LFPy.RecExtElectrode(cell,
x=x,
y=y,
z=z,
sigma=run_param['sigma'])
electrode.method = run_param['ext_method']
electrode.calc_lfp()
data['LFP'] = electrode.LFP
data['elec_x'] = x
data['elec_y'] = y
data['elec_z'] = z
data['t_vec'] = cell.tvec
data['soma_v'] = cell.somav
data['dt'] = cell.timeres_NEURON
data['poly_morph'] \
= de.get_polygons_no_axon(cell,['x','y'])
data['poly_morph_axon'] \
= de.get_polygons_axon(cell,['x','y'])
data['poly_morph_xz'] \
= de.get_polygons_no_axon(cell,['x','z'])
data['poly_morph_axon_xz'] \
= de.get_polygons_axon(cell,['x','z'])
def simulate(self, cell):
# pylint: disable=invalid-name,no-member
data = self.data
run_param = self.run_param
cell.simulate(rec_imem=True)
np.random.seed(run_param['seed'])
angle = np.random.uniform(0, 2*np.pi, size=run_param['N'])
z = np.random.uniform(-1, 1, size=run_param['N'])
x = np.sqrt(1-z*z)*np.cos(angle) * run_param['r']
y = np.sqrt(1-z*z)*np.sin(angle) * run_param['r']
z = z * run_param['r']
# Record the LFP of the electrodes.
electrode = LFPy.RecExtElectrode(cell,
x=x,
y=y,
z=z,
sigma=run_param['sigma'])
electrode.method = run_param['ext_method']
electrode.calc_lfp()
data['LFP'] = electrode.LFP*1000
data['elec_x'] = x
data['elec_y'] = y
data['elec_z'] = z
data['t_vec'] = cell.tvec
data['soma_v'] = cell.somav
data['dt'] = cell.timeres_NEURON
data['poly_morph'] \
= de.get_polygons_no_axon(cell,['x','y'])
data['poly_morph_axon'] \
= de.get_polygons_axon(cell,['x','y'])
data['poly_morph_xz'] \
= de.get_polygons_no_axon(cell,['x','z'])
data['poly_morph_axon_xz'] \
= de.get_polygons_axon(cell,['x','z'])
def simulate(self, cell):
run_param = self.run_param
cell = cell
# Calculate the electrode linspaces for the two planes.
elec_dx = run_param['elec_dx']
pos_min = run_param['x_lim'][0]
pos_max = run_param['x_lim'][1]
n_elec_x = abs(pos_max - pos_min)/elec_dx + 1
lin_x = np.linspace(pos_min, pos_max, n_elec_x, endpoint=True)
elec_dy = run_param['elec_dy']
pos_min = run_param['y_lim'][0]
pos_max = run_param['y_lim'][1]
n_elec_y = abs(pos_max - pos_min)/elec_dy + 1
lin_y = np.linspace(pos_min, pos_max, n_elec_y, endpoint=True)
# Simulate and store the currents.
cell.simulate(rec_imem=True)
electrode_dict = \
LFPy_util.electrodes.grid_electrodes(lin_x, lin_y, [0])
electrode_dict['sigma'] = 0.3
electrode = LFPy.RecExtElectrode(cell, **electrode_dict)
electrode.method = run_param['ext_method']
electrode.calc_lfp()
self.data['electrode_dict'] = electrode_dict
self.data['elec_x'] = electrode_dict['x']
self.data['elec_y'] = electrode_dict['y']
self.data['n_elec_x'] = n_elec_x
self.data['n_elec_y'] = n_elec_y
self.data['LFP'] = electrode.LFP
self.data['lin_x'] = lin_x
self.data['lin_y'] = lin_y
self.data['dt'] = cell.timeres_NEURON
self.data['t_vec'] = cell.tvec
self.data['soma_v'] = cell.somav
self.data['poly_morph'] = de.get_polygons_no_axon(cell, ['x', 'y'])
self.data['poly_morph_axon'] = de.get_polygons_axon(cell, ['x', 'y'])
