def band_velocity(p1, p2):
if (p_space_grid == 'cartesian'):
p_x = p1
p_y = p2
elif (p_space_grid == 'polar2D'):
p_x = p1 * af.cos(p2)
p_y = p1 * af.sin(p2)
else :
raise NotImplementedError('Unsupported coordinate system in p_space')
p = af.sqrt(p_x**2. + p_y**2.)
p_hat = [p_x / (p + 1e-20), p_y / (p + 1e-20)]
v_f = fermi_velocity
upper_band_velocity = [ v_f * p_hat[0], v_f * p_hat[1]]
af.eval(upper_band_velocity[0], upper_band_velocity[1])
return(upper_band_velocity)
def jacobian_dx_dq(q1, q2):
# TODO: evaluate this numerically using get_cartesian_coords
a = 0.1
k = np.pi
dx_dq1 = 1.
dx_dq2 = -a * k * af.sin(k * q2)
dy_dq1 = -a * k * af.cos(k * q1)
dy_dq2 = 1.
# a = 2; r = 1.1
# dx_dq1 = 1. + a*af.sqrt(r**2. - q2**2.)
#
# dx_dq2 = -a*q1*q2/af.sqrt(r**2. - q2**2.)
#
# dy_dq1 = 0.
#
# dy_dq2 = 1.
return ([[dx_dq1, dx_dq2], [dy_dq1, dy_dq2]])
def get_p_x_and_p_y(p1, p2):
if (p_space_grid == 'cartesian'):
p_x = p1
p_y = p2
elif (p_space_grid == 'polar2D'):
# In polar2D coordinates, p1 = radius and p2 = theta
r = p1; theta = p2
if (zero_temperature):
# Get p_x and p_y at the Fermi surface
r = fermi_momentum_magnitude(theta)
p_x = r * af.cos(theta)
p_y = r * af.sin(theta)
else :
raise NotImplementedError('Unsupported coordinate system in p_space')
return([p_x, p_y])
def f_right(f, t, q1, q2, p1, p2, p3, params):
k = params.boltzmann_constant
E_upper = params.E_band
T = params.initial_temperature
mu = params.initial_mu
t = params.current_time
omega = 2. * np.pi * params.AC_freq
if (params.source_type == 'AC'):
vel_drift_x_out = params.vel_drift_x_out * np.sin(omega*t)
elif (params.source_type == 'DC'):
vel_drift_x_out = params.vel_drift_x_out
else:
raise NotImplementedError('Unsupported source_type')
if (params.p_space_grid == 'cartesian'):
p_x = p1
p_y = p2
elif (params.p_space_grid == 'polar2D'):
p_x = p1 * af.cos(p2)
p_y = p1 * af.sin(p2)
else:
raise NotImplementedError('Unsupported coordinate system in p_space')
fermi_dirac_out = (1./(af.exp( (E_upper - vel_drift_x_out*p_x - mu)/(k*T) ) + 1.)
)
x, y = coords.get_cartesian_coords(q1, q2)
y_contact_start = params.contact_start
y_contact_end = params.contact_end
cond = ((y >= y_contact_start) & \
(y <= y_contact_end) \
)
f_right = cond*fermi_dirac_out + (1 - cond)*f
af.eval(f_right)
return(f_right)
def f_left(f, t, q1, q2, p1, p2, p3, params):
k = params.boltzmann_constant
E_upper = params.E_band
T = params.initial_temperature
mu = params.initial_mu
t = params.current_time
omega = 2. * np.pi * params.AC_freq
q2_contact_start = params.contact_start
q2_contact_end = params.contact_end
contact_width = q2_contact_end - q2_contact_start
vel_drift_x_in = params.vel_drift_x_in / contact_width
if (params.p_space_grid == 'cartesian'):
p_x = p1
p_y = p2
elif (params.p_space_grid == 'polar2D'):
p_x = p1 * af.cos(p2)
p_y = p1 * af.sin(p2)
else:
raise NotImplementedError('Unsupported coordinate system in p_space')
fermi_dirac_in = (1. / (af.exp(
(E_upper - vel_drift_x_in * p_x - mu) / (k * T)) + 1.))
if params.zero_temperature:
fermi_dirac_in = fermi_dirac_in - 0.5
# Contacts on either side of the device
cond = ((params.y >= q2_contact_start) & \
(params.y <= q2_contact_end) \
)
f_left = cond * fermi_dirac_in + (1 - cond) * f
af.eval(f_left)
return (f_left)
def test_compute_moments():
obj = test()
rho_num = compute_moments(obj, 'density')
rho_ana = 1 + 0.01 * af.sin(2 * np.pi * obj.q1 + 4 * np.pi * obj.q2)
error_rho = af.mean(af.abs(rho_num - rho_ana))
E_num = compute_moments(obj, 'energy')
E_ana = 3 * (1 + 0.01 * af.sin(2 * np.pi * obj.q1 + 4 * np.pi * obj.q2)) \
* (1 + 0.01 * af.cos(2 * np.pi * obj.q1 + 4 * np.pi * obj.q2)) \
+ 3 * (1 + 0.01 * af.sin(2 * np.pi * obj.q1 + 4 * np.pi * obj.q2)) \
* (0.01 * af.exp(-10 * obj.q1**2 - 10 * obj.q2**2))**2
error_E = af.mean(af.abs(E_num - E_ana))
mom_p1b_num = compute_moments(obj, 'mom_p1_bulk')
mom_p1b_ana = (1 + 0.01 * af.sin(2 * np.pi * obj.q1 + 4 * np.pi * obj.q2)) \
* (0.01 * af.exp(-10 * obj.q1**2 - 10 * obj.q2**2))
error_p1b = af.mean(af.abs(mom_p1b_num - mom_p1b_ana))
mom_p2b_num = compute_moments(obj, 'mom_p2_bulk')
mom_p2b_ana = (1 + 0.01 * af.sin(2 * np.pi * obj.q1 + 4 * np.pi * obj.q2)) \
* (0.01 * af.exp(-10 * obj.q1**2 - 10 * obj.q2**2))
error_p2b = af.mean(af.abs(mom_p2b_num - mom_p2b_ana))
mom_p3b_num = compute_moments(obj, 'mom_p3_bulk')
mom_p3b_ana = (1 + 0.01 * af.sin(2 * np.pi * obj.q1 + 4 * np.pi * obj.q2)) \
* (0.01 * af.exp(-10 * obj.q1**2 - 10 * obj.q2**2))
error_p3b = af.mean(af.abs(mom_p3b_num - mom_p3b_ana))
assert (error_rho < 1e-13)
assert (error_E < 1e-13)
assert (error_p1b < 1e-13)
assert (error_p2b < 1e-13)
assert (error_p3b < 1e-13)
def initialize_f(q1, q2, p1, p2, p3, params):
m = params.mass
k = params.boltzmann_constant
rho_b = params.rho_background
T_b = params.temperature_background
p1_bulk = params.p1_bulk_background
p2_bulk = params.p2_bulk_background
p3_bulk = params.p3_bulk_background
pert_real = params.pert_real
pert_imag = params.pert_imag
k_q1 = params.k_q1
k_q2 = params.k_q2
# Calculating the perturbed density:
rho = rho_b + ( pert_real * af.cos(k_q1 * q1 + k_q2 * q2)
- pert_imag * af.sin(k_q1 * q1 + k_q2 * q2)
)
if(params.p_dim == 3):
f = rho * (m / (2 * np.pi * k * T_b))**(3 / 2) \
* af.exp(-m * (p1 - p1_bulk)**2 / (2 * k * T_b)) \
* af.exp(-m * (p2 - p2_bulk)**2 / (2 * k * T_b)) \
* af.exp(-m * (p3 - p3_bulk)**2 / (2 * k * T_b))
elif(params.p_dim == 2):
f = rho * (m / (2 * np.pi * k * T_b)) \
* af.exp(-m * (p1 - p1_bulk)**2 / (2 * k * T_b)) \
* af.exp(-m * (p2 - p2_bulk)**2 / (2 * k * T_b)) \
else:
f = rho * (m / (2 * np.pi * k * T_b))**(1 / 2) \
* af.exp(-m * (p1 - p1_bulk)**2 / (2 * k * T_b)) \
af.eval(f)
return (f)
def f_top(f, t, q1, q2, p1, p2, p3, params):
k = params.boltzmann_constant
E_upper = params.E_band
T = params.initial_temperature
mu = params.initial_mu
t = params.current_time
omega = 2. * np.pi * params.AC_freq
q1_contact_start = params.contact_start
q1_contact_end = params.contact_end
contact_width = q1_contact_end - q1_contact_start
vel_drift_x_out = params.vel_drift_x_out / contact_width
if (params.p_space_grid == 'cartesian'):
p_x = p1
p_y = p2
elif (params.p_space_grid == 'polar2D'):
p_x = p1 * af.cos(p2)
p_y = p1 * af.sin(p2)
else:
raise NotImplementedError('Unsupported coordinate system in p_space')
fermi_dirac_out = (1. / (af.exp(
(E_upper - vel_drift_x_out * p_y - mu) / (k * T)) + 1.))
if params.zero_temperature:
fermi_dirac_out = fermi_dirac_out - 0.5
cond = ((params.x >= q1_contact_start) & \
(params.x <= q1_contact_end) \
)
f_top = cond * fermi_dirac_out + (1 - cond) * f
af.eval(f_top)
return (f_top)
def initialize_f(q1, q2, p1, p2, p3, params):
PETSc.Sys.Print("Initializing f")
k = params.boltzmann_constant
params.mu = 0. * q1 + params.initial_mu
params.T = 0. * q1 + params.initial_temperature
params.vel_drift_x = 0. * q1
params.vel_drift_y = 0. * q1
params.phi = 0. * q1
params.mu_ee = params.mu.copy()
params.T_ee = params.T.copy()
params.vel_drift_x = 0. * q1 + 0e-3
params.vel_drift_y = 0. * q1 + 0e-3
params.j_x = 0. * q1
params.j_y = 0. * q1
params.E_band = params.band_energy(p1, p2)
params.vel_band = params.band_velocity(p1, p2)
E_upper = params.E_band + params.charge[0] * params.phi
if (params.p_space_grid == 'cartesian'):
p_x = p1
p_y = p2
elif (params.p_space_grid == 'polar2D'):
p_x = p1 * af.cos(p2)
p_y = p1 * af.sin(p2)
else:
raise NotImplementedError('Unsupported coordinate system in p_space')
f = (1. / (af.exp(
(E_upper - params.vel_drift_x * p_x - params.vel_drift_y * p_y -
params.mu) / (k * params.T)) + 1.))
af.eval(f)
return (f)
def initialize_f(q1, q2, p1, p2, p3, params):
m = params.mass
k = params.boltzmann_constant
n_b = params.density_background
T_b = params.temperature_background
p1_bulk = params.p1_bulk_background
pert_real = params.pert_real
pert_imag = params.pert_imag
k_q1 = params.k_q1
# Calculating the perturbed density:
n = n_b + (pert_real * af.cos(k_q1 * q1) - pert_imag * af.sin(k_q1 * q1))
f = n * (m / (2 * np.pi * k * T_b))**(1 / 2) \
* af.exp(-m * (p1 - p1_bulk)**2 / (2 * k * T_b)) \
af.eval(f)
return (f)
def f_top(f, t, q1, q2, p1, p2, p3, params):
k = params.boltzmann_constant
E_upper = params.E_band
T = params.initial_temperature
mu = params.initial_mu
t = params.current_time
omega = 2. * np.pi * params.AC_freq
q1_contact_start = params.contact_start
q1_contact_end = params.contact_end
contact_width = q1_contact_end - q1_contact_start
q1_contact_start_2 = 0.
q1_contact_end_2 = 1.73 / 2
contact_width_2 = q1_contact_end_2 - q1_contact_start_2
vel_drift_y_in = -params.vel_drift_x_in / contact_width #Right
vel_drift_y_in_2 = 10. * params.vel_drift_x_in / contact_width_2 #Left
if (params.p_space_grid == 'cartesian'):
p_x = p1
p_y = p2
elif (params.p_space_grid == 'polar2D'):
p_x = p1 * af.cos(p2)
p_y = p1 * af.sin(p2)
else:
raise NotImplementedError('Unsupported coordinate system in p_space')
fermi_dirac_in = (1. / (af.exp(
(E_upper - vel_drift_y_in * p_y - mu) / (k * T)) + 1.))
fermi_dirac_in_2 = (1. / (af.exp(
(E_upper - vel_drift_y_in_2 * p_y - mu) / (k * T)) + 1.))
if (params.contact_geometry == "straight"):
# Contacts on either side of the device
cond = ((q1 >= q1_contact_start) & \
(q1 <= q1_contact_end) \
)
cond_2 = ((q1 >= q1_contact_start_2) & \
(q1 <= q1_contact_end_2) \
)
f_left = cond * fermi_dirac_in + cond_2 * fermi_dirac_in_2 + (
1 - cond_2) * (1 - cond) * f
elif (params.contact_geometry == "turn_around"):
# Contacts on the same side of the device
vel_drift_x_out = -params.vel_drift_x_in * np.sin(omega * t)
fermi_dirac_out = (1. / (af.exp(
(E_upper - vel_drift_x_out * p_x - mu) / (k * T)) + 1.))
# TODO: set these parameters in params.py
cond_in = ((q2 >= 3.5) & (q2 <= 4.5))
cond_out = ((q2 >= 5.5) & (q2 <= 6.5))
f_left = cond_in*fermi_dirac_in + cond_out*fermi_dirac_out \
+ (1 - cond_in)*(1 - cond_out)*f
af.eval(f_left)
return (f_left)
def cos(x):
if isinstance(x, afnumpy.ndarray):
s = arrayfire.cos(x.d_array)
return afnumpy.ndarray(x.shape, dtype=pu.typemap(s.dtype()), af_array=s)
else:
return numpy.cos(x)
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################
import arrayfire as af
af.info()
ITERATIONS = 200
POINTS = int(10.0 * ITERATIONS)
Z = 1 + af.range(POINTS) / ITERATIONS
win = af.Window(800, 800, "3D Plot example using ArrayFire")
t = 0.1
while not win.close():
X = af.cos(Z * t + t) / Z
Y = af.sin(Z * t + t) / Z
X = af.maxof(af.minof(X, 1), -1)
Y = af.maxof(af.minof(Y, 1), -1)
Pts = af.join(1, X, Y, Z)
win.plot3(Pts)
t = t + 0.01
af.display(af.minof(a, b)) af.display(af.rem(a, b)) a = af.randu(3, 3) - 0.5 b = af.randu(3, 3) - 0.5 af.display(af.abs(a)) af.display(af.arg(a)) af.display(af.sign(a)) af.display(af.round(a)) af.display(af.trunc(a)) af.display(af.floor(a)) af.display(af.ceil(a)) af.display(af.hypot(a, b)) af.display(af.sin(a)) af.display(af.cos(a)) af.display(af.tan(a)) af.display(af.asin(a)) af.display(af.acos(a)) af.display(af.atan(a)) af.display(af.atan2(a, b)) c = af.cplx(a) d = af.cplx(a, b) af.display(c) af.display(d) af.display(af.real(d)) af.display(af.imag(d)) af.display(af.conjg(d)) af.display(af.sinh(a))
def __init__(self):
# Creating a physical_system object with
# attributes required for the test
self.physical_system = type('obj', (object, ), {
'moment_exponents': moment_exponents,
'moment_coeffs': moment_coeffs
})
self.single_mode_evolution = False
self.p1_start = -10
self.p2_start = -10
self.p3_start = -10
self.N_p1 = 32
self.N_p2 = 32
self.N_p3 = 32
self.dp1 = (-2 * self.p1_start) / self.N_p1
self.dp2 = (-2 * self.p2_start) / self.N_p2
self.dp3 = (-2 * self.p3_start) / self.N_p3
self.N_q1 = 16
self.N_q2 = 16
self.N_ghost = 3
self.p1 = self.p1_start + (0.5 + np.arange(self.N_p1)) * self.dp1
self.p2 = self.p2_start + (0.5 + np.arange(self.N_p2)) * self.dp2
self.p3 = self.p3_start + (0.5 + np.arange(self.N_p3)) * self.dp3
self.p2, self.p1, self.p3 = np.meshgrid(self.p2, self.p1, self.p3)
self.p1 = af.reorder(af.flat(af.to_array(self.p1)), 2, 3, 0, 1)
self.p2 = af.reorder(af.flat(af.to_array(self.p2)), 2, 3, 0, 1)
self.p3 = af.reorder(af.flat(af.to_array(self.p3)), 2, 3, 0, 1)
self.q1 = (-self.N_ghost + 0.5 +
np.arange(self.N_q1 + 2 * self.N_ghost)) / self.N_q1
self.q2 = (-self.N_ghost + 0.5 +
np.arange(self.N_q2 + 2 * self.N_ghost)) / self.N_q2
self.q2, self.q1 = np.meshgrid(self.q2, self.q1)
self.q1 = af.to_array(self.q1)
self.q2 = af.to_array(self.q2)
rho = (1 + 0.01 * af.sin(2 * np.pi * self.q1 + 4 * np.pi * self.q2))
T = (1 + 0.01 * af.cos(2 * np.pi * self.q1 + 4 * np.pi * self.q2))
p1_b = 0.01 * af.exp(-10 * self.q1**2 - 10 * self.q2**2)
p2_b = 0.01 * af.exp(-10 * self.q1**2 - 10 * self.q2**2)
p3_b = 0.01 * af.exp(-10 * self.q1**2 - 10 * self.q2**2)
self.f = maxwell_boltzmann(rho, T, p1_b, p2_b, p3_b, self.p1, self.p2,
self.p3)
self.Y = 2 * af.fft2(self.f) / (self.N_q1 * self.N_q2)
def test_fdtd_modeTE():
error_E1 = np.zeros(3)
error_E2 = np.zeros(3)
error_B3 = np.zeros(3)
N = 2**np.arange(5, 8)
for i in range(N.size):
obj = test(N[i])
dt = obj.dq1 / 2
time = np.arange(dt, 1 + dt, dt)
N_g = obj.N_ghost
E1_fdtd = 8 * np.pi * af.cos(4 * np.pi * obj.q2_center_bot)
E2_fdtd = 4 * np.pi * af.cos(2 * np.pi * obj.q1_left_center)
B3_fdtd = 2 * np.pi * af.cos(2 * np.pi * (obj.q1_left_center - dt)) \
- 4 * np.pi * af.cos(4 * np.pi * (obj.q2_center_bot - dt))
obj.yee_grid_EM_fields[0, N_g:-N_g, N_g:-N_g] = E1_fdtd[:, N_g:-N_g,
N_g:-N_g]
obj.yee_grid_EM_fields[1, N_g:-N_g, N_g:-N_g] = E2_fdtd[:, N_g:-N_g,
N_g:-N_g]
obj.yee_grid_EM_fields[5, N_g:-N_g, N_g:-N_g] = B3_fdtd[:, N_g:-N_g,
N_g:-N_g]
B3_initial = obj.yee_grid_EM_fields[5].copy()
E1_initial = obj.yee_grid_EM_fields[0].copy()
E2_initial = obj.yee_grid_EM_fields[1].copy()
obj.J1, obj.J2, obj.J3 = 0, 0, 0
for time_index, t0 in enumerate(time):
obj.J1 = 48 * np.pi**2 * af.sin(4 * np.pi *
(obj.q2_center_bot - 2 * t0))
obj.J2 = 12 * np.pi**2 * af.sin(2 * np.pi *
(obj.q1_left_center - 2 * t0))
fdtd(obj, dt)
error_E1[i] = af.sum(
af.abs(obj.yee_grid_EM_fields[0, N_g:-N_g, N_g:-N_g] -
E1_initial[:, N_g:-N_g, N_g:-N_g])) / (
E1_initial.elements())
error_E2[i] = af.sum(
af.abs(obj.yee_grid_EM_fields[1, N_g:-N_g, N_g:-N_g] -
E2_initial[:, N_g:-N_g, N_g:-N_g])) / (
E2_initial.elements())
error_B3[i] = af.sum(
af.abs(obj.yee_grid_EM_fields[5, N_g:-N_g, N_g:-N_g] -
B3_initial[:, N_g:-N_g, N_g:-N_g])) / (
B3_initial.elements())
poly_E1 = np.polyfit(np.log10(N), np.log10(error_E1), 1)
poly_E2 = np.polyfit(np.log10(N), np.log10(error_E2), 1)
poly_B3 = np.polyfit(np.log10(N), np.log10(error_B3), 1)
assert (abs(poly_E1[0] + 2) < 0.25)
assert (abs(poly_E2[0] + 2) < 0.25)
assert (abs(poly_B3[0] + 2) < 0.25)
def unwrap_dct(arr):
return arr + af.round(
(laplacian(af.cos(arr) * laplacian(af.sin(arr)) -
af.sin(arr) * laplacian(af.cos(arr)),
inverse=True) - arr) / 2 / np.pi) * 2 * np.pi
def f_left(f, t, q1, q2, p1, p2, p3, params):
k = params.boltzmann_constant
E_upper = params.E_band
T = params.initial_temperature
mu = params.initial_mu
N_g = domain.N_ghost
# Need to set mu in the ghost zones:
# TODO: remove hardcoding for 2 ghost zones
mu_0 = params.mu[:, :, N_g , :] # value in the first physical zone
mu_1 = params.mu[:, :, N_g+1, :] # value in the second physical zone
x_0 = params.x[:, :, N_g, :]
x_1 = params.x[:, :, N_g+1, :]
a = (mu_0 - mu_1)/(x_0 - x_1)
b = mu_0 - x_0*a
x_minus_2 = params.x[:, :, 0, :]
x_minus_1 = params.x[:, :, 1, :]
mu_minus_2 = a*x_minus_2 + b
mu_minus_1 = a*x_minus_1 + b
# params.mu[:, :, 0, :] = mu_minus_2
# params.mu[:, :, 1, :] = mu_minus_1
t = params.current_time
omega = 2. * np.pi * params.AC_freq
vel_drift_x_in = params.vel_drift_x_in
if (params.p_space_grid == 'cartesian'):
p_x = p1
p_y = p2
elif (params.p_space_grid == 'polar2D'):
p_x = p1 * af.cos(p2)
p_y = p1 * af.sin(p2)
else:
raise NotImplementedError('Unsupported coordinate system in p_space')
fermi_dirac_in = (1./(af.exp( (E_upper - vel_drift_x_in*p_x - mu)/(k*T) ) + 1.)
)
if (params.contact_geometry=="straight"):
# Contacts on either side of the device
q2_contact_start = params.contact_start
q2_contact_end = params.contact_end
cond = ((params.y >= q2_contact_start) & \
(params.y <= q2_contact_end) \
)
f_left = cond*fermi_dirac_in + (1 - cond)*f
elif (params.contact_geometry=="turn_around"):
# Contacts on the same side of the device
vel_drift_x_out = -params.vel_drift_x_in * np.sin(omega*t)
fermi_dirac_out = (1./(af.exp( (E_upper - vel_drift_x_out*p_x - mu)/(k*T) ) + 1.)
)
# TODO: set these parameters in params.py
cond_in = ((q2 >= 3.5) & (q2 <= 4.5))
cond_out = ((q2 >= 5.5) & (q2 <= 6.5))
f_left = cond_in*fermi_dirac_in + cond_out*fermi_dirac_out \
+ (1 - cond_in)*(1 - cond_out)*f
af.eval(f_left)
return(f_left)
def f_left(f, t, q1, q2, p1, p2, p3, params):
k = params.boltzmann_constant
E_upper = params.E_band
T = params.initial_temperature
mu = params.initial_mu
N_g = domain.N_ghost
t = params.current_time
omega = 2. * np.pi * params.AC_freq
vel_drift_x_in = params.vel_drift_x_in
vel_drift_x_out = params.vel_drift_y * 0.0
N_g = domain.N_ghost
for index in range(N_g):
vel_drift_x_out[:, :, index, :] = params.vel_drift_x[:, :, N_g, :]
if (params.p_space_grid == 'cartesian'):
p_x = p1
p_y = p2
elif (params.p_space_grid == 'polar2D'):
p_x = p1 * af.cos(p2)
p_y = p1 * af.sin(p2)
else:
raise NotImplementedError('Unsupported coordinate system in p_space')
fermi_dirac_in = (1. / (af.exp(
(E_upper - vel_drift_x_in * p_x - mu) / (k * T)) + 1.))
fermi_dirac_out = (1. / (af.exp(
(E_upper - vel_drift_x_out * p_x - mu) / (k * T)) + 1.))
if params.zero_temperature:
fermi_dirac_in = fermi_dirac_in - 0.5
if params.zero_temperature:
fermi_dirac_out = fermi_dirac_out - 0.5
if (params.contact_geometry == "straight"):
# Contacts on either side of the device
q2_contact_start = params.contact_start
q2_contact_end = params.contact_end
cond = ((params.y >= q2_contact_start) & \
(params.y <= q2_contact_end) \
)
cond_base = (params.y >= q2_contact_end)
f_left = cond * fermi_dirac_in + cond_base * fermi_dirac_out + (
1 - cond_base) * (1 - cond) * f
elif (params.contact_geometry == "turn_around"):
# Contacts on the same side of the device
vel_drift_x_out = -params.vel_drift_x_in * np.sin(omega * t)
fermi_dirac_out = (1. / (af.exp(
(E_upper - vel_drift_x_out * p_x - mu) / (k * T)) + 1.))
# TODO: set these parameters in params.py
cond_in = ((q2 >= 3.5) & (q2 <= 4.5))
cond_out = ((q2 >= 5.5) & (q2 <= 6.5))
f_left = cond_in*fermi_dirac_in + cond_out*fermi_dirac_out \
+ (1 - cond_in)*(1 - cond_out)*f
af.eval(f_left)
return (f_left)
#!/usr/bin/python
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################
import arrayfire as af
af.info()
POINTS = 30
N = 2 * POINTS
x = (af.iota(d0=N, d1=1, tile_dims=(1, N)) - POINTS) / POINTS
y = (af.iota(d0=1, d1=N, tile_dims=(N, 1)) - POINTS) / POINTS
win = af.Window(800, 800, "3D Surface example using ArrayFire")
t = 0
while not win.close():
t = t + 0.07
z = 10 * x * -af.abs(y) * af.cos(x * x * (y + t)) + af.sin(y *
(x + t)) - 1.5
win.surface(x, y, z)
def simple_arith(verbose = False):
display_func = _util.display_func(verbose)
print_func = _util.print_func(verbose)
a = af.randu(3,3,dtype=af.Dtype.u32)
b = af.constant(4, 3, 3, dtype=af.Dtype.u32)
display_func(a)
display_func(b)
c = a + b
d = a
d += b
display_func(c)
display_func(d)
display_func(a + 2)
display_func(3 + a)
c = a - b
d = a
d -= b
display_func(c)
display_func(d)
display_func(a - 2)
display_func(3 - a)
c = a * b
d = a
d *= b
display_func(c * 2)
display_func(3 * d)
display_func(a * 2)
display_func(3 * a)
c = a / b
d = a
d /= b
display_func(c / 2.0)
display_func(3.0 / d)
display_func(a / 2)
display_func(3 / a)
c = a % b
d = a
d %= b
display_func(c % 2.0)
display_func(3.0 % d)
display_func(a % 2)
display_func(3 % a)
c = a ** b
d = a
d **= b
display_func(c ** 2.0)
display_func(3.0 ** d)
display_func(a ** 2)
display_func(3 ** a)
display_func(a < b)
display_func(a < 0.5)
display_func(0.5 < a)
display_func(a <= b)
display_func(a <= 0.5)
display_func(0.5 <= a)
display_func(a > b)
display_func(a > 0.5)
display_func(0.5 > a)
display_func(a >= b)
display_func(a >= 0.5)
display_func(0.5 >= a)
display_func(a != b)
display_func(a != 0.5)
display_func(0.5 != a)
display_func(a == b)
display_func(a == 0.5)
display_func(0.5 == a)
display_func(a & b)
display_func(a & 2)
c = a
c &= 2
display_func(c)
display_func(a | b)
display_func(a | 2)
c = a
c |= 2
display_func(c)
display_func(a >> b)
display_func(a >> 2)
c = a
c >>= 2
display_func(c)
display_func(a << b)
display_func(a << 2)
c = a
c <<= 2
display_func(c)
display_func(-a)
display_func(+a)
display_func(~a)
display_func(a)
display_func(af.cast(a, af.Dtype.c32))
display_func(af.maxof(a,b))
display_func(af.minof(a,b))
display_func(af.rem(a,b))
a = af.randu(3,3) - 0.5
b = af.randu(3,3) - 0.5
display_func(af.abs(a))
display_func(af.arg(a))
display_func(af.sign(a))
display_func(af.round(a))
display_func(af.trunc(a))
display_func(af.floor(a))
display_func(af.ceil(a))
display_func(af.hypot(a, b))
display_func(af.sin(a))
display_func(af.cos(a))
display_func(af.tan(a))
display_func(af.asin(a))
display_func(af.acos(a))
display_func(af.atan(a))
display_func(af.atan2(a, b))
c = af.cplx(a)
d = af.cplx(a,b)
display_func(c)
display_func(d)
display_func(af.real(d))
display_func(af.imag(d))
display_func(af.conjg(d))
display_func(af.sinh(a))
display_func(af.cosh(a))
display_func(af.tanh(a))
display_func(af.asinh(a))
display_func(af.acosh(a))
display_func(af.atanh(a))
a = af.abs(a)
b = af.abs(b)
display_func(af.root(a, b))
display_func(af.pow(a, b))
display_func(af.pow2(a))
display_func(af.exp(a))
display_func(af.expm1(a))
display_func(af.erf(a))
display_func(af.erfc(a))
display_func(af.log(a))
display_func(af.log1p(a))
display_func(af.log10(a))
display_func(af.log2(a))
display_func(af.sqrt(a))
display_func(af.cbrt(a))
a = af.round(5 * af.randu(3,3) - 1)
b = af.round(5 * af.randu(3,3) - 1)
display_func(af.factorial(a))
display_func(af.tgamma(a))
display_func(af.lgamma(a))
display_func(af.iszero(a))
display_func(af.isinf(a/b))
display_func(af.isnan(a/a))
a = af.randu(5, 1)
b = af.randu(1, 5)
c = af.broadcast(lambda x,y: x+y, a, b)
display_func(a)
display_func(b)
display_func(c)
@af.broadcast
def test_add(aa, bb):
return aa + bb
display_func(test_add(a, b))
import domain
import boundary_conditions
import params
import initialize
import bolt.src.nonrelativistic_boltzmann.advection_terms as advection_terms
import bolt.src.nonrelativistic_boltzmann.collision_operator as collision_operator
import bolt.src.nonrelativistic_boltzmann.moments as moments
# Defining the physical system to be solved:
system = physical_system(domain, boundary_conditions, params, initialize,
advection_terms, collision_operator.BGK, moments)
# Declaring the solver object which will evolve the defined physical system:
ls = linear_solver(system)
n = ls.compute_moments('density')
v1_b = ls.compute_moments('mom_v1_bulk') / n
E = ls.compute_moments('energy')
T = (2 * E - n * v1_b**2) / n
assert (af.mean(af.abs(n[0, 0] -
(1 + 0.01 * af.cos(2 * np.pi * ls.q1_center)))) < 1e-13)
assert (af.mean(af.abs(n[0, 1] -
(1 + 0.02 * af.cos(4 * np.pi * ls.q1_center)))) < 1e-13)
assert (af.mean(af.abs(T[0, 0] -
(1 + 0.02 * af.sin(2 * np.pi * ls.q1_center)))) < 1e-13)
assert (af.mean(
af.abs(T[0, 1] - (100 + 0.01 * af.sin(4 * np.pi * ls.q1_center)))) < 1e-13)
def f_top(f, t, q1, q2, p1, p2, p3, params):
k = params.boltzmann_constant
E_upper = params.E_band
T = params.initial_temperature
mu = params.initial_mu
N_g = domain.N_ghost
# Need to set mu in the ghost zones:
# TODO: remove hardcoding for 2 ghost zones
mu_0 = params.mu[:, :, :, -N_g-1] # value in the last physical zone
mu_1 = params.mu[:, :, :, -N_g-2] # value in the second last physical zone
x_0 = params.x[:, :, :, -N_g-1]
x_1 = params.x[:, :, :, -N_g-2]
a = (mu_0 - mu_1)/(x_0 - x_1)
b = mu_0 - x_0*a
x_plus_1 = params.x[:, :, :, -2]
x_plus_2 = params.x[:, :, :, -1]
mu_plus_1 = a*x_plus_1 + b
mu_plus_2 = a*x_plus_2 + b
# params.mu[:, :, :, -2] = mu_plus_1
# params.mu[:, :, :, -1] = mu_plus_2
t = params.current_time
omega = 2. * np.pi * params.AC_freq
vel_drift_x_out = params.vel_drift_y*0.0
N_g = domain.N_ghost
for index in range(N_g):
vel_drift_x_out[:, :, :, -index-1] = params.vel_drift_y[:, :, :, -N_g-1]
if (params.p_space_grid == 'cartesian'):
p_x = p1
p_y = p2
elif (params.p_space_grid == 'polar2D'):
p_x = p1 * af.cos(p2)
p_y = p1 * af.sin(p2)
else:
raise NotImplementedError('Unsupported coordinate system in p_space')
fermi_dirac_out = (1./(af.exp( (E_upper - vel_drift_x_out*p_y - mu)/(k*T) ) + 1.)
)
#fermi_dirac_out = (1./(af.exp( (E_upper - params.vel_drift_x_in*p_y - params.mu)/(k*T) ) + 1.)
# )
if (params.contact_geometry=="straight"):
# Contacts on either side of the device
q2_contact_start = 0.625#params.contact_start
q2_contact_end = 1.125#params.contact_end
cond = ((params.x >= q2_contact_start) & \
(params.x <= q2_contact_end) \
)
f_right = cond*fermi_dirac_out + (1 - cond)*f
elif (params.contact_geometry=="turn_around"):
# Contacts on the same side of the device
f_right = f
af.eval(f_right)
return(f_right)
import boundary_conditions
import params
import initialize
import bolt.src.nonrelativistic_boltzmann.advection_terms as advection_terms
import bolt.src.nonrelativistic_boltzmann.collision_operator as collision_operator
import bolt.src.nonrelativistic_boltzmann.moments as moments
# Defining the physical system to be solved:
system = physical_system(domain, boundary_conditions, params, initialize,
advection_terms, collision_operator.BGK, moments)
# Declaring the solver object which will evolve the defined physical system:
nls = nonlinear_solver(system)
n = nls.compute_moments('density')
v1_b = nls.compute_moments('mom_v1_bulk') / n
E = nls.compute_moments('energy')
T = (2 * E - n * v1_b**2) / n
assert (af.mean(
af.abs(n[0, 0] - (1 + 0.01 * af.cos(2 * np.pi * nls.q1_center)))) < 1e-13)
assert (af.mean(
af.abs(n[0, 1] - (1 + 0.02 * af.cos(4 * np.pi * nls.q1_center)))) < 1e-13)
assert (af.mean(
af.abs(T[0, 0] - (1 + 0.02 * af.sin(2 * np.pi * nls.q1_center)))) < 1e-13)
assert (af.mean(
af.abs(T[0, 1] -
(100 + 0.01 * af.sin(4 * np.pi * nls.q1_center)))) < 1e-13)
af.display(af.minof(a,b)) af.display(af.rem(a,b)) a = af.randu(3,3) - 0.5 b = af.randu(3,3) - 0.5 af.display(af.abs(a)) af.display(af.arg(a)) af.display(af.sign(a)) af.display(af.round(a)) af.display(af.trunc(a)) af.display(af.floor(a)) af.display(af.ceil(a)) af.display(af.hypot(a, b)) af.display(af.sin(a)) af.display(af.cos(a)) af.display(af.tan(a)) af.display(af.asin(a)) af.display(af.acos(a)) af.display(af.atan(a)) af.display(af.atan2(a, b)) c = af.cplx(a) d = af.cplx(a,b) af.display(c) af.display(d) af.display(af.real(d)) af.display(af.imag(d)) af.display(af.conjg(d)) af.display(af.sinh(a))
# Time parameters:
dt_fvm = params.N_cfl * min(nls.dq1, nls.dq2) \
/ max(domain.p1_end + domain.p2_end + domain.p3_end) # joining elements of the list
dt_fdtd = params.N_cfl * min(nls.dq1, nls.dq2) \
/ params.c # lightspeed
dt = dt_fvm # min(dt_fvm, dt_fdtd)
print('Minimum Value of f:', af.min(nls.f))
print('Error in density:', af.mean(af.abs(nls.compute_moments('density') - 1)))
v2_bulk = nls.compute_moments('mom_v2_bulk') / nls.compute_moments('density')
v3_bulk = nls.compute_moments('mom_v3_bulk') / nls.compute_moments('density')
v2_bulk_ana = params.amplitude * -1.7450858652952794e-15 * af.cos(params.k_q1 * nls.q1_center) \
- params.amplitude * 0.5123323181646575 * af.sin(params.k_q1 * nls.q1_center)
v3_bulk_ana = params.amplitude * 0.5123323181646597 * af.cos(params.k_q1 * nls.q1_center) \
- params.amplitude * 0 * af.sin(params.k_q1 * nls.q1_center)
print('Error in v2_bulk:',
af.mean(af.abs((v2_bulk - v2_bulk_ana) / v2_bulk_ana)))
print('Error in v3_bulk:',
af.mean(af.abs((v3_bulk - v3_bulk_ana) / v3_bulk_ana)))
if (params.t_restart == 0):
time_elapsed = 0
nls.dump_distribution_function('dump_f/t=0.000')
nls.dump_moments('dump_moments/t=0.000')
nls.dump_EM_fields('dump_fields/t=0.000')
def simple_arith(verbose=False):
display_func = _util.display_func(verbose)
print_func = _util.print_func(verbose)
a = af.randu(3, 3)
b = af.constant(4, 3, 3)
display_func(a)
display_func(b)
c = a + b
d = a
d += b
display_func(c)
display_func(d)
display_func(a + 2)
display_func(3 + a)
c = a - b
d = a
d -= b
display_func(c)
display_func(d)
display_func(a - 2)
display_func(3 - a)
c = a * b
d = a
d *= b
display_func(c * 2)
display_func(3 * d)
display_func(a * 2)
display_func(3 * a)
c = a / b
d = a
d /= b
display_func(c / 2.0)
display_func(3.0 / d)
display_func(a / 2)
display_func(3 / a)
c = a % b
d = a
d %= b
display_func(c % 2.0)
display_func(3.0 % d)
display_func(a % 2)
display_func(3 % a)
c = a**b
d = a
d **= b
display_func(c**2.0)
display_func(3.0**d)
display_func(a**2)
display_func(3**a)
display_func(a < b)
display_func(a < 0.5)
display_func(0.5 < a)
display_func(a <= b)
display_func(a <= 0.5)
display_func(0.5 <= a)
display_func(a > b)
display_func(a > 0.5)
display_func(0.5 > a)
display_func(a >= b)
display_func(a >= 0.5)
display_func(0.5 >= a)
display_func(a != b)
display_func(a != 0.5)
display_func(0.5 != a)
display_func(a == b)
display_func(a == 0.5)
display_func(0.5 == a)
a = af.randu(3, 3, dtype=af.Dtype.u32)
b = af.constant(4, 3, 3, dtype=af.Dtype.u32)
display_func(a & b)
display_func(a & 2)
c = a
c &= 2
display_func(c)
display_func(a | b)
display_func(a | 2)
c = a
c |= 2
display_func(c)
display_func(a >> b)
display_func(a >> 2)
c = a
c >>= 2
display_func(c)
display_func(a << b)
display_func(a << 2)
c = a
c <<= 2
display_func(c)
display_func(-a)
display_func(+a)
display_func(~a)
display_func(a)
display_func(af.cast(a, af.Dtype.c32))
display_func(af.maxof(a, b))
display_func(af.minof(a, b))
display_func(af.rem(a, b))
a = af.randu(3, 3) - 0.5
b = af.randu(3, 3) - 0.5
display_func(af.abs(a))
display_func(af.arg(a))
display_func(af.sign(a))
display_func(af.round(a))
display_func(af.trunc(a))
display_func(af.floor(a))
display_func(af.ceil(a))
display_func(af.hypot(a, b))
display_func(af.sin(a))
display_func(af.cos(a))
display_func(af.tan(a))
display_func(af.asin(a))
display_func(af.acos(a))
display_func(af.atan(a))
display_func(af.atan2(a, b))
c = af.cplx(a)
d = af.cplx(a, b)
display_func(c)
display_func(d)
display_func(af.real(d))
display_func(af.imag(d))
display_func(af.conjg(d))
display_func(af.sinh(a))
display_func(af.cosh(a))
display_func(af.tanh(a))
display_func(af.asinh(a))
display_func(af.acosh(a))
display_func(af.atanh(a))
a = af.abs(a)
b = af.abs(b)
display_func(af.root(a, b))
display_func(af.pow(a, b))
display_func(af.pow2(a))
display_func(af.sigmoid(a))
display_func(af.exp(a))
display_func(af.expm1(a))
display_func(af.erf(a))
display_func(af.erfc(a))
display_func(af.log(a))
display_func(af.log1p(a))
display_func(af.log10(a))
display_func(af.log2(a))
display_func(af.sqrt(a))
display_func(af.cbrt(a))
a = af.round(5 * af.randu(3, 3) - 1)
b = af.round(5 * af.randu(3, 3) - 1)
display_func(af.factorial(a))
display_func(af.tgamma(a))
display_func(af.lgamma(a))
display_func(af.iszero(a))
display_func(af.isinf(a / b))
display_func(af.isnan(a / a))
a = af.randu(5, 1)
b = af.randu(1, 5)
c = af.broadcast(lambda x, y: x + y, a, b)
display_func(a)
display_func(b)
display_func(c)
@af.broadcast
def test_add(aa, bb):
return aa + bb
display_func(test_add(a, b))
def test_fdtd_modeTM():
error_B1 = np.zeros(3)
error_B2 = np.zeros(3)
error_E3 = np.zeros(3)
N = 2**np.arange(5, 8)
for i in range(N.size):
obj = test(N[i])
dt = obj.dq1 / 2
time = np.arange(dt, 1 + dt, dt)
N_g = obj.N_ghost
A3 = af.sin(2 * np.pi * (obj.q1_left_bot - 0.5 * dt) + 4 * np.pi *
(obj.q2_left_bot - 0.5 * dt))
B1_fdtd = (af.shift(A3, 0, 0, -1) - A3) / obj.dq2
B2_fdtd = -(af.shift(A3, 0, -1) - A3) / obj.dq1
E3_fdtd = 6 * np.pi * af.cos(2 * np.pi * obj.q1_left_bot +
4 * np.pi * obj.q2_left_bot)
obj.yee_grid_EM_fields[2] = E3_fdtd
obj.yee_grid_EM_fields[3] = B1_fdtd
obj.yee_grid_EM_fields[4] = B2_fdtd
E3_initial = obj.yee_grid_EM_fields[2].copy()
B1_initial = obj.yee_grid_EM_fields[3].copy()
B2_initial = obj.yee_grid_EM_fields[4].copy()
obj.J1, obj.J2, obj.J3 = 0, 0, 0
for time_index, t0 in enumerate(time):
obj.J3 = -16 * np.pi**2 * af.sin(
2 * np.pi * (obj.q1_left_bot - t0 + 0.5 * dt) + 4 * np.pi *
(obj.q2_left_bot - t0 + 0.5 * dt))
fdtd(obj, dt)
error_B1[i] = af.sum(
af.abs(obj.yee_grid_EM_fields[3, N_g:-N_g, N_g:-N_g] -
B1_initial[0, N_g:-N_g, N_g:-N_g])) / (
B1_initial.elements())
error_B2[i] = af.sum(
af.abs(obj.yee_grid_EM_fields[4, N_g:-N_g, N_g:-N_g] -
B2_initial[0, N_g:-N_g, N_g:-N_g])) / (
B2_initial.elements())
error_E3[i] = af.sum(
af.abs(obj.yee_grid_EM_fields[2, N_g:-N_g, N_g:-N_g] -
E3_initial[0, N_g:-N_g, N_g:-N_g])) / (
E3_initial.elements())
poly_B1 = np.polyfit(np.log10(N), np.log10(error_B1), 1)
poly_B2 = np.polyfit(np.log10(N), np.log10(error_B2), 1)
poly_E3 = np.polyfit(np.log10(N), np.log10(error_E3), 1)
assert (abs(poly_B1[0] + 2) < 0.25)
assert (abs(poly_B2[0] + 2) < 0.25)
assert (abs(poly_E3[0] + 2) < 0.25)
advection_terms, collision_operator.BGK, moments)
# Declaring a linear system object which will evolve the defined physical system:
nls = nonlinear_solver(system)
N_g = nls.N_ghost
# Time parameters:
dt_fvm = params.N_cfl * min(nls.dq1, nls.dq2) \
/ max(domain.p1_end + domain.p2_end + domain.p3_end) # joining elements of the list
dt_fdtd = params.N_cfl * min(nls.dq1, nls.dq2) \
/ params.c # lightspeed
dt = min(dt_fvm, dt_fdtd)
v2_bulk_i = params.amplitude * -8.673617379884035e-17 * af.cos(params.k_q1 * nls.q1_center) \
- params.amplitude * - 0.09260702134169797 * af.sin(params.k_q1 * nls.q1_center)
v2_bulk_e = params.amplitude * 8.413408858487514e-17 * af.cos(params.k_q1 * nls.q1_center) \
- params.amplitude * - 0.5389501869018833* af.sin(params.k_q1 * nls.q1_center)
v3_bulk_i = params.amplitude * 0.09260702134169804 * af.cos(params.k_q1 * nls.q1_center) \
- params.amplitude * 3.144186300207963e-18 * af.sin(params.k_q1 * nls.q1_center)
v3_bulk_e = params.amplitude * 0.5389501869018835 * af.cos(params.k_q1 * nls.q1_center) \
- params.amplitude * -3.885780586188048e-16 * af.sin(params.k_q1 * nls.q1_center)
# Checking that the velocity space is well-resolved:
nls.dt = dt
d_flux_p2_dp2 = df_dt_fvm(nls.f, nls, 'd_flux_p2_dp2')
d_flux_p3_dp3 = df_dt_fvm(nls.f, nls, 'd_flux_p3_dp3')
def initialize_f(q1, q2, p1, p2, p3, params):
PETSc.Sys.Print("Initializing f")
k = params.boltzmann_constant
params.mu = 0.*q1 + params.initial_mu
params.T = 0.*q1 + params.initial_temperature
params.mu_ee = params.mu.copy()
params.T_ee = params.T.copy()
A = params.vel_drift_x_in * 0.0
A_x = A
A_y = -A
k_y = 2*np.pi/domain.q2_end
k_x = 2*np.pi/domain.q1_end
params.vel_drift_x = A_x*k_y*af.sin(k_x*q1)*af.cos(k_y*q2)
params.vel_drift_y = A_y*k_x*af.cos(k_x*q1)*af.sin(k_y*q2)
params.j_x = 0.*q1
params.j_y = 0.*q1
params.p_x, params.p_y = params.get_p_x_and_p_y(p1, p2)
params.E_band = params.band_energy(p1, p2)
params.vel_band = params.band_velocity(p1, p2)
# TODO: Injecting get_cartesian_coords into params to avoid circular dependency
params.get_cartesian_coords = coords.get_cartesian_coords
# Load shift indices for all 4 boundaries into params. Required to perform
# mirroring operations along boundaries at arbitrary angles.
if (params.zero_temperature) :
params.shift_indices_left, params.shift_indices_right, \
params.shift_indices_bottom, params.shift_indices_top = \
compute_shift_indices(q1, q2, p1, p2, p3, params)
params.x, params.y = coords.get_cartesian_coords(q1, q2,
q1_start_local_left=params.q1_start_local_left,
q2_start_local_bottom=params.q2_start_local_bottom)
# TODO : Testing : Dump left, bottom, right, top faces also
d_q1 = (q1[0, 0, 1, 0] - q1[0, 0, 0, 0]).scalar()
d_q2 = (q2[0, 0, 0, 1] - q2[0, 0, 0, 0]).scalar()
q1_left_faces = q1 - 0.5*d_q1
q2_bottom_faces = q2 - 0.5*d_q2
q1_right_faces = q1 + 0.5*d_q1
q2_top_faces = q2 + 0.5*d_q2
params.x_top_center, params.y_top_center = coords.get_cartesian_coords(q1, q2_top_faces,
q1_start_local_left=params.q1_start_local_left,
q2_start_local_bottom=params.q2_start_local_bottom)
params.x_right_center, params.y_right_center = coords.get_cartesian_coords(q1_right_faces, q2,
q1_start_local_left=params.q1_start_local_left,
q2_start_local_bottom=params.q2_start_local_bottom)
params.x_bottom_center, params.y_bottom_center = coords.get_cartesian_coords(q1, q2_bottom_faces,
q1_start_local_left=params.q1_start_local_left,
q2_start_local_bottom=params.q2_start_local_bottom)
params.x_left_center, params.y_left_center = coords.get_cartesian_coords(q1_left_faces, q2,
q1_start_local_left=params.q1_start_local_left,
q2_start_local_bottom=params.q2_start_local_bottom)
params.q1 = q1; params.q2 = q2
[[params.dx_dq1, params.dx_dq2], [params.dy_dq1, params.dy_dq2]] = jacobian_dx_dq(q1, q2,
q1_start_local_left=params.q1_start_local_left,
q2_start_local_bottom=params.q2_start_local_bottom)
[[params.dq1_dx, params.dq1_dy], [params.dq2_dx, params.dq2_dy]] = jacobian_dq_dx(q1, q2,
q1_start_local_left=params.q1_start_local_left,
q2_start_local_bottom=params.q2_start_local_bottom)
params.sqrt_det_g = sqrt_det_g(q1, q2,
q1_start_local_left=params.q1_start_local_left,
q2_start_local_bottom=params.q2_start_local_bottom)
# Calculation of integral measure
# Evaluating velocity space resolution for each species:
dp1 = []; dp2 = []; dp3 = []
N_p1 = domain.N_p1; N_p2 = domain.N_p2; N_p3 = domain.N_p3
p1_start = domain.p1_start; p1_end = domain.p1_end
p2_start = domain.p2_start; p2_end = domain.p2_end
p3_start = domain.p3_start; p3_end = domain.p3_end
N_species = len(params.mass)
for i in range(N_species):
dp1.append((p1_end[i] - p1_start[i]) / N_p1)
dp2.append((p2_end[i] - p2_start[i]) / N_p2)
dp3.append((p3_end[i] - p3_start[i]) / N_p3)
theta = af.atan(params.p_y / params.p_x)
p_f = params.fermi_momentum_magnitude(theta)
if (params.p_space_grid == 'cartesian'):
dp_x = dp1[0]; dp_y = dp2[0]; dp_z = dp3[0]
params.integral_measure = \
(4./(2.*np.pi*params.h_bar)**2) * dp_z * dp_y * dp_x
elif (params.p_space_grid == 'polar2D'):
# In polar2D coordinates, p1 = radius and p2 = theta
# Integral : \int delta(r - r_F) F(r, theta) r dr dtheta
r = p1; theta = p2
dp_r = dp1[0]; dp_theta = dp2[0]
if (params.zero_temperature):
# Assumption : F(r, theta) = delta(r-r_F)*F(theta)
params.integral_measure = \
(4./(2.*np.pi*params.h_bar)**2) * p_f * dp_theta
else:
params.integral_measure = \
(4./(2.*np.pi*params.h_bar)**2) * r * dp_r * dp_theta
else :
raise NotImplementedError('Unsupported coordinate system in p_space')
# # Initialize to zero
# f = 0*q1*p1
f = (1./(af.exp( (params.E_band - params.vel_drift_x*params.p_x
- params.vel_drift_y*params.p_y
- params.mu
)/(k*params.T)
) + 1.
))
if (params.zero_temperature) :
f = f - 0.5
af.eval(f)
return(f)
def initialize_A3_B3(q1, q2, params):
A3 = 0.01 * af.cos(2 * np.pi * q1)
B3 = 0.01 * af.sin(2 * np.pi * q1)
return (A3, B3)
#!/usr/bin/python
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################
import arrayfire as af
af.info()
POINTS = 30
N = 2 * POINTS
x = (af.iota(d0 = N, d1 = 1, tile_dims = (1, N)) - POINTS) / POINTS
y = (af.iota(d0 = 1, d1 = N, tile_dims = (N, 1)) - POINTS) / POINTS
win = af.Window(800, 800, "3D Surface example using ArrayFire")
t = 0
while not win.close():
t = t + 0.07
z = 10*x*-af.abs(y) * af.cos(x*x*(y+t))+af.sin(y*(x+t))-1.5;
win.surface(x, y, z)
# Declaring a linear system object which will evolve the defined physical system:
nls = nonlinear_solver(system)
N_g = nls.N_ghost
print('Minimum Value of f_e:', af.min(nls.f[:, 0]))
print('Minimum Value of f_i:', af.min(nls.f[:, 1]))
print('Error in density_e:',
af.mean(af.abs(nls.compute_moments('density')[:, 0] - 1)))
print('Error in density_i:',
af.mean(af.abs(nls.compute_moments('density')[:, 1] - 1)))
v2_bulk = nls.compute_moments('mom_v2_bulk') / nls.compute_moments('density')
v3_bulk = nls.compute_moments('mom_v3_bulk') / nls.compute_moments('density')
v2_bulk_i = params.amplitude * -4.801714581503802e-15 * af.cos(params.k_q1 * nls.q1_center) \
- params.amplitude * -0.3692429960259134 * af.sin(params.k_q1 * nls.q1_center)
v2_bulk_e = params.amplitude * -4.85722573273506e-15 * af.cos(params.k_q1 * nls.q1_center) \
- params.amplitude * - 0.333061857862197* af.sin(params.k_q1 * nls.q1_center)
v3_bulk_i = params.amplitude * -0.3692429960259359 * af.cos(params.k_q1 * nls.q1_center) \
- params.amplitude * 1.8041124150158794e-16 * af.sin(params.k_q1 * nls.q1_center)
v3_bulk_e = params.amplitude * -0.333061857862222 * af.cos(params.k_q1 * nls.q1_center) \
- params.amplitude * -3.885780586188048e-16 * af.sin(params.k_q1 * nls.q1_center)
print('Error in v2_bulk_e:',
af.mean(af.abs((v2_bulk[:, 0] - v2_bulk_e) / v2_bulk_e)))
print('Error in v2_bulk_i:',
af.mean(af.abs((v2_bulk[:, 1] - v2_bulk_i) / v2_bulk_i)))
def initialize_f(q1, q2, p1, p2, p3, params):
PETSc.Sys.Print("Initializing f")
k = params.boltzmann_constant
params.mu = 0. * q1 + params.initial_mu
params.T = 0. * q1 + params.initial_temperature
params.vel_drift_x = 0. * q1
params.vel_drift_y = 0. * q1
params.phi = 0. * q1
params.mu_ee = params.mu.copy()
params.T_ee = params.T.copy()
params.vel_drift_x = 0. * q1 + 0e-3
params.vel_drift_y = 0. * q1 + 0e-3
params.j_x = 0. * q1
params.j_y = 0. * q1
params.E_band = params.band_energy(p1, p2)
params.vel_band = params.band_velocity(p1, p2)
E_upper = params.E_band + params.charge[0] * params.phi
if (params.p_space_grid == 'cartesian'):
p_x = p1
p_y = p2
elif (params.p_space_grid == 'polar2D'):
p_x = p1 * af.cos(p2)
p_y = p1 * af.sin(p2)
else:
raise NotImplementedError('Unsupported coordinate system in p_space')
# Initialize to zero
f = 0 * q1 * p1
# Parameters to define a gaussian in space (representing a 2D ball)
A = domain.N_p2 # Amplitude (required for normalization)
sigma_x = 0.05 # Standard deviation in x
sigma_y = 0.05 # Standard deviation in y
x_0 = 0. # Center in x
y_0 = 0. # Center in y
# TODO: This will work with polar2D p-space only for the moment
# Particles lying on the ball need to have the same velocity (direction)
#theta_0_index = (5*N_p2/8) - 1 # Direction of initial velocity
theta_0_index = int(5 * domain.N_p2 / 8) # Direction of initial velocity
print("Initial angle : ")
af.display(p2[theta_0_index])
# Load shift indices for all 4 boundaries into params. Required to perform
# mirroring operations along boundaries at arbitrary angles.
params.shift_indices_left, params.shift_indices_right, \
params.shift_indices_bottom, params.shift_indices_top = \
compute_shift_indices(q1, q2, p1, p2, p3, params)
x, y = coords.get_cartesian_coords(q1, q2)
# f[theta_0_index, :, :] = A + A*af.exp(-( (x-x_0)**2/(2*sigma_x**2) + \
# (y-y_0)**2/(2*sigma_y**2)
# )
# )
f = (1. / (af.exp(
(E_upper - params.vel_drift_x * p_x - params.vel_drift_y * p_y -
params.mu) / (k * params.T)) + 1.))
af.eval(f)
return (f)
