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)