def test_E_hall():
'''
Tests E-field update, hall term (B x curl(B)) only by selection of inputs
'''
# =============================================================================
# grids = [32, 64, 128, 256, 512, 1024, 2048]
# err_curl = np.zeros(len(grids))
# err_interp = np.zeros(len(grids))
# err_hall = np.zeros(len(grids))
# =============================================================================
#for NX, ii in zip(grids, range(len(grids))):
NX = 32 #const.NX
xmin = 0.0 #const.xmin
xmax = 2*np.pi #const.xmax
dx = xmax / NX
k = 1.0
marker_size = 70
E_nodes = (np.arange(NX + 3) - 0.5) * dx # Physical location of nodes
B_nodes = (np.arange(NX + 3) - 1.0) * dx
## INPUTS ##
Bx = np.sin(1.0*k*B_nodes)
By = np.sin(2.0*k*B_nodes)
Bz = np.sin(3.0*k*B_nodes)
Bxe = np.sin(1.0*k*E_nodes)
Bye = np.sin(2.0*k*E_nodes)
Bze = np.sin(3.0*k*E_nodes)
dBy = 2.0 * k * np.cos(2.0*k*E_nodes)
dBz = 3.0 * k * np.cos(3.0*k*E_nodes)
B_input = np.zeros((NX + 3, 3))
B_input[:, 0] = Bx
B_input[:, 1] = By
B_input[:, 2] = Bz
Be_input = np.zeros((NX + 3, 3))
Be_input[:, 0] = Bxe
Be_input[:, 1] = Bye
Be_input[:, 2] = Bze
B_center = aux.interpolate_to_center_cspline3D(B_input, DX=dx)
## TEST CURL B (AGAIN JUST TO BE SURE)
curl_B_FD = fields.get_curl_B(B_input, DX=dx)
curl_B_anal = np.zeros((NX + 3, 3))
curl_B_anal[:, 1] = -dBz
curl_B_anal[:, 2] = dBy
## ELECTRIC FIELD CALCULATION ##
E_FD = fields.calculate_E( B_input, np.zeros((NX + 3, 3)), np.ones(NX + 3), DX=dx)
E_FD2 = fields.calculate_E_w_exel(B_input, np.zeros((NX + 3, 3)), np.ones(NX + 3), DX=dx)
E_anal = np.zeros((NX + 3, 3))
E_anal[:, 0] = - (Bye * dBy + Bze * dBz)
E_anal[:, 1] = Bxe * dBy
E_anal[:, 2] = Bxe * dBz
E_anal /= const.mu0
# =============================================================================
# ## Calculate errors ##
# err_curl[ii] = np.abs(curl_B_FD[1: -2, :] - curl_B_anal[1: -2, :]).max()
# err_interp[ii] = np.abs(B_center[1: -2, :] - Be_input[1: -2, :] ).max()
# err_hall[ii] = np.abs(E_FD[1: -2, :] - E_anal[1: -2, :] ).max()
#
# for ii in range(len(grids) - 1):
# order_curl = np.log(err_curl[ii] / err_curl[ii + 1] ) / np.log(2)
# order_interp = np.log(err_interp[ii] / err_interp[ii + 1]) / np.log(2)
# order_hall = np.log(err_hall[ii] / err_hall[ii + 1] ) / np.log(2)
#
# print ''
# print 'Grid reduction: {} -> {}'.format(grids[ii], grids[ii + 1])
# print 'Curl order: {}, \nC-spline Interpolation order: {}'.format(order_curl, order_interp)
# print 'E-field Hall order: {}'.format(order_hall)
# =============================================================================
plot = True
if plot == True:
# =============================================================================
# # Plot curl test
# plt.figure()
# plt.scatter(E_nodes, curl_B_anal[:, 1], s=marker_size, c='k')
# plt.scatter(E_nodes, curl_B_anal[:, 2], s=marker_size, c='k')
# plt.scatter(E_nodes, curl_B_FD[:, 1], s=marker_size, marker='x')
# plt.scatter(E_nodes, curl_B_FD[:, 2], s=marker_size, marker='x')
#
# # Plot center-interpolated B test
# plt.figure()
# plt.scatter(B_nodes, B_input[:, 0], s=marker_size, c='b')
# plt.scatter(B_nodes, B_input[:, 1], s=marker_size, c='b')
# plt.scatter(B_nodes, B_input[:, 2], s=marker_size, c='b')
# plt.scatter(E_nodes, B_center[:, 0], s=marker_size, c='r')
# plt.scatter(E_nodes, B_center[:, 1], s=marker_size, c='r')
# plt.scatter(E_nodes, B_center[:, 2], s=marker_size, c='r')
# =============================================================================
# Plot E-field test solutions
plt.scatter(E_nodes, E_anal[:, 0], s=marker_size, marker='o', c='k')
plt.scatter(E_nodes, E_anal[:, 1], s=marker_size, marker='o', c='k')
plt.scatter(E_nodes, E_anal[:, 2], s=marker_size, marker='o', c='k')
plt.scatter(E_nodes, E_FD[:, 0], s=marker_size, c='b', marker='+')
plt.scatter(E_nodes, E_FD[:, 1], s=marker_size, c='b', marker='+')
plt.scatter(E_nodes, E_FD[:, 2], s=marker_size, c='b', marker='+')
plt.scatter(E_nodes, E_FD2[:, 0], s=marker_size, c='r', marker='x')
plt.scatter(E_nodes, E_FD2[:, 1], s=marker_size, c='r', marker='x')
plt.scatter(E_nodes, E_FD2[:, 2], s=marker_size, c='r', marker='x')
for kk in range(NX + 3):
plt.axvline(E_nodes[kk], linestyle='--', c='r', alpha=0.2)
plt.axvline(B_nodes[kk], linestyle='--', c='b', alpha=0.2)
plt.axvline(xmin, linestyle='-', c='k', alpha=0.2)
plt.axvline(xmax, linestyle='-', c='k', alpha=0.2)
plt.xlim(xmin - 1.5*dx, xmax + 2*dx)
return
def test_curl_B():
#errors = np.zeros(4)
#grids = [16, 32, 64, 128]
#for NX, ii in zip(grids, range(len(grids))):
NX = 50 #const.NX
xmin = 0.0 #const.xmin
xmax = 2*np.pi#const.xmax
dx = xmax / NX #const.dx
x = np.arange(xmin, xmax, dx/100.) # Simulation domain space 0,NX (normalized to grid)
k = 1.0
# Physical location of nodes
E_nodes = (np.arange(NX + 3) - 0.5) * dx
B_nodes = (np.arange(NX + 3) - 1.0) * dx
Bx = np.cos(1.0*k*B_nodes)
By = np.cos(1.5*k*B_nodes)
Bz = np.cos(2.0*k*B_nodes)
dBy = -1.5 * k * np.sin(1.5*k*E_nodes)
dBz = -2.0 * k * np.sin(2.0*k*E_nodes)
B_input = np.zeros((NX + 3, 3))
B_input[:, 0] = Bx
B_input[:, 1] = By
B_input[:, 2] = Bz
curl_B_FD = fields.get_curl_B(B_input, DX=dx)
curl_B_anal = np.zeros((NX + 3, 3))
curl_B_anal[:, 1] = -dBz
curl_B_anal[:, 2] = dBy
# =============================================================================
# By_error = 100.*(curl_B[:, 1] - By_anal) / By_anal
# Bz_error = 100.*(curl_B[:, 2] - Bz_anal) / Bz_anal
#
# errors[ii] = abs(By_error).max()
#
# power = np.log(errors[2] / errors[3]) / np.log(2)
# print power
# =============================================================================
## DO THE PLOTTING ##
plt.figure(figsize=(15, 15))
marker_size = None
#plt.plot(x, -deriv, linestyle=':', c='b', label='By Analytic Solution')
plt.scatter(E_nodes, curl_B_anal[:, 1], marker='o', c='k', s=marker_size, label='By Node Solution')
plt.scatter(E_nodes, curl_B_FD[:, 1], marker='x', c='b', s=marker_size, label='By Finite Difference')
#plt.plot(x, deriv, linestyle=':', c='r', label='Bz Analytic Solution')
plt.scatter(E_nodes, curl_B_anal[:, 2], marker='o', c='k', s=marker_size, label='Bz Node Solution')
plt.scatter(E_nodes, curl_B_FD[:, 2], marker='x', c='r', s=marker_size, label='Bz Finite Difference')
plt.title(r'Test of $\nabla \times B$')
for kk in range(NX + 3):
plt.axvline(E_nodes[kk], linestyle='--', c='r', alpha=0.2)
plt.axvline(B_nodes[kk], linestyle='--', c='b', alpha=0.2)
plt.axvline(xmin, linestyle='-', c='k', alpha=0.2)
plt.axvline(xmax, linestyle='-', c='k', alpha=0.2)
plt.xlim(xmin - 1.5*dx, xmax + 2*dx)
plt.legend()
return
