def test_matmul_3D():
'''
'''
M = 3
N = 2
P = 4
Q = 2
a = af.range(M * N * Q, dtype=af.Dtype.u32)
b = af.range(N * P * Q, dtype=af.Dtype.u32)
a = af.moddims(a, d0=M, d1=N, d2=Q)
b = af.moddims(b, d0=N, d1=P, d2=Q)
a_init = a
b_init = b
ref_a_0 = np.matmul(np.array(a_init[:, :, 0]), np.array(b_init[:, :, 0]))
ref_a_1 = np.matmul(np.array(a_init[:, :, 1]), np.array(b_init[:, :, 1]))
test_matmul = np.array(utils.matmul_3D(a, b))
diff_mat_0 = np.abs(test_matmul[:, :, 0] - ref_a_0)
diff_mat_1 = np.abs(test_matmul[:, :, 1] - ref_a_1)
assert np.all(diff_mat_0 == 0) and np.all(diff_mat_1 == 0)
def A_matrix():
'''
Calculates A matrix whose elements :math:`A_{p i}` are given by
:math:`A_{pi} = \\int^1_{-1} L_p(\\xi)L_i(\\xi) \\frac{dx}{d\\xi}`
The integrals are computed using the integrate() function.
Since elements are taken to be of equal size, :math:`\\frac {dx}{d\\xi}`
is same everywhere
Returns
-------
A_matrix : arrayfire.Array [N_LGL N_LGL 1 1]
The value of integral of product of lagrange basis functions
obtained by LGL points, using the integrate() function
'''
# Coefficients of Lagrange basis polynomials.
lagrange_coeffs = params.lagrange_coeffs
lagrange_coeffs = af.reorder(lagrange_coeffs, 1, 2, 0)
# Coefficients of product of Lagrange basis polynomials.
lag_prod_coeffs = af.convolve1(lagrange_coeffs,\
af.reorder(lagrange_coeffs, 0, 2, 1),\
conv_mode=af.CONV_MODE.EXPAND)
lag_prod_coeffs = af.reorder(lag_prod_coeffs, 1, 2, 0)
lag_prod_coeffs = af.moddims(lag_prod_coeffs, params.N_LGL**2,
2 * params.N_LGL - 1)
dx_dxi = params.dx_dxi
A_matrix = dx_dxi * af.moddims(lagrange.integrate(lag_prod_coeffs),\
params.N_LGL, params.N_LGL)
return A_matrix
def test_poly1d_prod():
'''
Checks the product of the polynomials of different degrees using the
poly1d_product function and compares it to the analytically calculated
product coefficients.
'''
N = 3
N_a = 3
poly_a = af.range(N * N_a, dtype=af.Dtype.u32)
poly_a = af.moddims(poly_a, d0=N, d1=N_a)
N_b = 2
poly_b = af.range(N * N_b, dtype=af.Dtype.u32)
poly_b = af.moddims(poly_b, d0=N, d1=N_b)
ref_poly = af.np_to_af_array(
np.array([[0., 0., 9., 18.], [1., 8., 23., 28.], [4., 20., 41., 40.]]))
test_poly1d_prod = utils.poly1d_product(poly_a, poly_b)
test_poly1d_prod_commutative = utils.poly1d_product(poly_b, poly_a)
diff = af.abs(test_poly1d_prod - ref_poly)
diff_commutative = af.abs(test_poly1d_prod_commutative - ref_poly)
assert af.all_true(diff == 0.) and af.all_true(diff_commutative == 0.)
def read_and_preprocess_notmnist_data():
print('Reading and preprocessing notMNIST data...')
with open('notMNIST.pickle', 'rb') as f:
data = pickle.load(f)
train_images = af.from_ndarray(data['train_dataset'])
train_targets = af.from_ndarray(ints_to_onehots(data['train_labels'], 10))
test_images = af.from_ndarray(data['test_dataset'])
test_targets = af.from_ndarray(ints_to_onehots(data['test_labels'], 10))
num_train = train_images.dims()[0]
num_test = test_images.dims()[0]
feature_length = int(train_images.elements() / num_train)
train_feats = af.moddims(train_images, num_train, feature_length)
test_feats = af.moddims(test_images, num_test, feature_length)
X_train = train_feats.to_ndarray()
y_train = train_targets.to_ndarray()
X_test = test_feats.to_ndarray()
y_test = test_targets.to_ndarray()
y_train = onehots_to_ints(y_train).astype('uint32')
y_test = onehots_to_ints(y_test).astype('uint32')
print('Reading and preprocessing notMNIST data DONE')
return (X_train, y_train, X_test, y_test)
def read_and_preprocess_mnist_data():
print('Reading and preprocessing MNIST data...')
train_images = af.read_array('train_images.af', key='train_images')
train_targets = af.read_array('train_targets.af', key='train_targets')
test_images = af.read_array('test_images.af', key='test_images')
test_targets = af.read_array('test_targets.af', key='test_targets')
num_train = train_images.dims()[2]
num_classes = train_targets.dims()[0]
num_test = test_images.dims()[2]
feature_length = int(train_images.elements() / num_train)
train_feats = af.transpose(
af.moddims(train_images, feature_length, num_train))
test_feats = af.transpose(af.moddims(test_images, feature_length,
num_test))
train_targets = af.transpose(train_targets)
test_targets = af.transpose(test_targets)
X_train = train_feats.to_ndarray()
y_train = train_targets.to_ndarray()
X_test = test_feats.to_ndarray()
y_test = test_targets.to_ndarray()
y_train = onehots_to_ints(y_train)
y_test = onehots_to_ints(y_test)
y_train = y_train.astype('uint32')
y_test = y_test.astype('uint32')
print('Reading and preprocessing MNIST data DONE')
return (X_train, y_train, X_test, y_test)
def communicate_fields(self, on_fdtd_grid=False):
"""
Used in communicating the values at the boundary zones for each of
the local vectors among all procs.This routine is called to take care
of communication(and periodic B.C's) procedures for the EM field
arrays. The function is used for communicating the EM field values
on the cell centered grid which is used by default. Additionally,it can
also be used to communicate the values on the Yee-grid which is used by the FDTD solver.
"""
if (self.performance_test_flag == True):
tic = af.time()
# Obtaining start coordinates for the local zone
# Additionally, we also obtain the size of the local zone
((i_q1_start, i_q2_start), (N_q1_local,
N_q2_local)) = self._da_fields.getCorners()
N_g = self.N_g
# Assigning the values of the af.Array
# fields quantities to the PETSc.Vec:
if (on_fdtd_grid is True):
flattened_global_EM_fields_array = \
af.flat(self.yee_grid_EM_fields[:, :, N_g:-N_g, N_g:-N_g])
flattened_global_EM_fields_array.to_ndarray(self._glob_fields_array)
else:
flattened_global_EM_fields_array = \
af.flat(self.cell_centered_EM_fields[:, :, N_g:-N_g, N_g:-N_g])
flattened_global_EM_fields_array.to_ndarray(self._glob_fields_array)
# Takes care of boundary conditions and interzonal communications:
self._da_fields.globalToLocal(self._glob_fields, self._local_fields)
# Converting back to af.Array
if (on_fdtd_grid is True):
self.yee_grid_EM_fields = af.moddims(
af.to_array(self._local_fields_array), 6, 1, N_q1_local + 2 * N_g,
N_q2_local + 2 * N_g)
af.eval(self.yee_grid_EM_fields)
else:
self.cell_centered_EM_fields = af.moddims(
af.to_array(self._local_fields_array), 6, 1, N_q1_local + 2 * N_g,
N_q2_local + 2 * N_g)
af.eval(self.cell_centered_EM_fields)
if (self.performance_test_flag == True):
af.sync()
toc = af.time()
self.time_communicate_fields += toc - tic
return
def Get_Linear_Equation_Gpu(x,
weight,
bin_data_num,
bin_data_y,
r,
dtype='f4'):
n, p = x.shape
d = p - 1
if dtype is 'f4':
dtype = af.Dtype.f32
elif dtype is 'f8':
dtype = af.Dtype.f64
xw = af.constant(0, n, p, dtype=dtype)
for ii in af.ParallelRange(p):
xw[:, ii] = x[:, ii] * weight
s = af.constant(0, p, p, np.prod(bin_data_num.shape), dtype=dtype)
t = af.constant(0, p, np.prod(bin_data_num.shape), dtype=dtype)
ker_d = np.ones(4, dtype='int')
ker_d[:d] = 2 * r + 1
if d is 4:
for i in range(p):
for j in range(i, p):
if i is 0:
kernel = af.moddims(xw[:, j], ker_d[0], ker_d[1], ker_d[2],
ker_d[3])
t[j] = af.flat(
af.reorder(Convolve4(bin_data_y, kernel), 3, 2, 1, 0))
else:
kernel = af.moddims(xw[:, i] * x[:, j], ker_d[0], ker_d[1],
ker_d[2], ker_d[3])
s[i, j] = af.flat(
af.reorder(Convolve4(bin_data_num, kernel), 3, 2, 1, 0))
s[j, i] = s[i, j]
elif d < 4:
for i in range(p):
for j in range(i, p):
if i is 0:
kernel = af.moddims(xw[:, j], ker_d[0], ker_d[1], ker_d[2],
ker_d[3])
if kernel.elements() is 1:
t[j] = af.flat((bin_data_y * kernel.to_list()[0]).T)
else:
t[j] = af.flat(af.fft_convolve(bin_data_y, kernel).T)
else:
kernel = af.moddims(xw[:, i] * x[:, j], ker_d[0], ker_d[1],
ker_d[2], ker_d[3])
if kernel.elements() is 1:
s[i, j] = af.flat((bin_data_num * kernel.to_list()[0]).T)
else:
s[i, j] = af.flat(af.fft_convolve(bin_data_num, kernel).T)
s[j, i] = s[i, j]
for i in range(1, p):
s[i, i] += 1e-12
return ([
np.array(s).reshape(p**2, -1).T.reshape(-1, p, p),
np.array(af.flat(t))
])
def volume_integral(u, advec_var):
'''
Vectorize, p, q, moddims.
'''
dLp_xi_ij_Lq_eta_ij = advec_var.dLp_Lq
dLq_eta_ij_Lp_xi_ij = advec_var.dLq_Lp
dxi_dx = 10.
deta_dy = 10.
jacobian = 100.
c_x = params.c_x
c_y = params.c_y
if (params.volume_integrand_scheme_2d == 'Lobatto'
and params.N_LGL == params.N_quad):
w_i = af.flat(
af.transpose(
af.tile(advec_var.lobatto_weights_quadrature, 1,
params.N_LGL)))
w_j = af.tile(advec_var.lobatto_weights_quadrature, params.N_LGL)
wi_wj_dLp_xi = af.broadcast(utils.multiply, w_i * w_j,
advec_var.dLp_Lq)
volume_integrand_ij_1_sp = c_x * dxi_dx * af.broadcast(utils.multiply,\
wi_wj_dLp_xi, u) / jacobian
wi_wj_dLq_eta = af.broadcast(utils.multiply, w_i * w_j,
advec_var.dLq_Lp)
volume_integrand_ij_2_sp = c_y * deta_dy * af.broadcast(utils.multiply,\
wi_wj_dLq_eta, u) / jacobian
volume_integral = af.reorder(
af.sum(volume_integrand_ij_1_sp + volume_integrand_ij_2_sp, 0), 2,
1, 0)
else:
volume_integrand_ij_1 = c_x * dxi_dx * af.broadcast(utils.multiply,\
dLp_xi_ij_Lq_eta_ij,\
u) / jacobian
volume_integrand_ij_2 = c_y * deta_dy * af.broadcast(utils.multiply,\
dLq_eta_ij_Lp_xi_ij,\
u) / jacobian
volume_integrand_ij = af.moddims(volume_integrand_ij_1 + volume_integrand_ij_2, params.N_LGL ** 2,\
(params.N_LGL ** 2) * 100)
lagrange_interpolation = af.moddims(
wave_equation_2d.lag_interpolation_2d(volume_integrand_ij,
advec_var.Li_Lj_coeffs),
params.N_LGL, params.N_LGL, params.N_LGL**2 * 100)
volume_integrand_total = utils.integrate_2d_multivar_poly(lagrange_interpolation[:, :, :],\
params.N_quad,'gauss', advec_var)
volume_integral = af.transpose(
af.moddims(volume_integrand_total, 100, params.N_LGL**2))
return volume_integral
def calculate_dfdp_background(self):
"""
Calculates the derivative of the background distribution
with respect to the variables p1, p2, p3. This is used to
solve for the contribution from the fields
"""
f_b = af.moddims(self.f_background, self.N_p1, self.N_p2, self.N_p3, self.N_species)
# 8th order central diff -- just in case
# f_minus_4 = af.shift(f_b, 4); f_plus_4 = af.shift(f_b, -4)
# f_minus_3 = af.shift(f_b, 3); f_plus_3 = af.shift(f_b, -3)
# f_minus_2 = af.shift(f_b, 2); f_plus_2 = af.shift(f_b, -2)
# f_minus_1 = af.shift(f_b, 1); f_plus_1 = af.shift(f_b, -1)
#
# dfdp1_background = \
# ( 1/280)*f_minus_4 + (-4/105)*f_minus_3 + ( 1/5)*f_minus_2 + (-4/5)*f_minus_1 \
# + (-1/280)*f_plus_4 + ( 4/105)*f_plus_3 + (-1/5)*f_plus_2 + ( 4/5)*f_plus_1
#
# dfdp1_background = dfdp1_background/self.dp1
# Using a 4th order central difference stencil:
dfdp1_background = (-af.shift(f_b, -2) + 8 * af.shift(f_b, -1)
+af.shift(f_b, 2) - 8 * af.shift(f_b, 1)
) / (12 * self.dp1)
dfdp2_background = (-af.shift(f_b, 0, -2) + 8 * af.shift(f_b, 0, -1)
+af.shift(f_b, 0, 2) - 8 * af.shift(f_b, 0, 1)
) / (12 * self.dp2)
dfdp3_background = (-af.shift(f_b, 0, 0, -2) + 8 * af.shift(f_b, 0, 0, -1)
+af.shift(f_b, 0, 0, 2) - 8 * af.shift(f_b, 0, 0, 1)
) / (12 * self.dp3)
# Reshaping such that the variations in velocity are along axis 0:
self.dfdp1_background = af.moddims(dfdp1_background,
self.N_p1 * self.N_p2 * self.N_p3,
self.N_species
)
self.dfdp2_background = af.moddims(dfdp2_background,
self.N_p1 * self.N_p2 * self.N_p3,
self.N_species
)
self.dfdp3_background = af.moddims(dfdp3_background,
self.N_p1 * self.N_p2 * self.N_p3,
self.N_species
)
af.eval(self.dfdp1_background,
self.dfdp2_background,
self.dfdp3_background
)
return
def pool(image, w, s):
#TODO: Remove assumption of image.dims()[3] == 1
d0, d1, d2 = image.dims()
#TODO: remove reorder and moddims call
image = af.moddims(af.reorder(image, 2, 0, 1), 1, d2, d0, d1)
d0, d1, d2, d3 = image.dims()
h_o = (d2 - w)/s + 1
w_o = (d3 - w)/s + 1
tiles = af.unwrap(af.reorder(image, 2, 3, 1, 0), w, w, s, s)
return af.reorder(af.reorder(af.moddims(af.max(tiles, 0), d0, h_o, w_o,
d1), 0, 3, 1, 2), 2, 3, 1, 0)
def conv(weights, biases, image, wx, wy, sx = 1, sy = 1, px = 0, py = 0, groups = 1):
image = __pad(image, px, py)
batch = util.num_input(image)
n_filters = util.num_filters(weights)
n_channel = util.num_channels(weights)
w_i = image.dims()[0]
h_i = image.dims()[1]
w_o = (w_i - wx) / sx + 1
h_o = (h_i - wy) / sy + 1
tiles = af.unwrap(image, wx, wy, sx, sy)
weights = af.moddims(weights, wx*wy, n_channel, n_filters)
out = af.constant(0, batch, n_filters, w_o, h_o)
if groups > 1:
out = af.constant(0, w_o, h_o, n_filters, batch)
split_in = util.num_channels(image) / groups
s_i = split_in
split_out = n_filters / groups
s_o = split_out
for i in xrange(groups):
weights_slice = af.moddims(weights[:,:,i*s_o:(i+1)*s_o],
wx, wy, n_channel, split_out)
biases_slice = biases[i*s_o:(i+1)*s_o]
image_slice = image[:,:,i*s_i:(i+1)*s_i]
out[:,:,i*s_o:(i+1)*s_o] = conv(weights_slice,
biases_slice,
image_slice,
wx, wy, sx, sy, 0, 0, 1)
# out[:,i*s_o:(i+1)*s_o] = conv(weights_slice,
# biases_slice,
# image_slice,
# wx, wy, sx, sy, 0, 0, 1)
return out
#TODO: Speedup this section
for f in xrange(n_filters):
for d in xrange(n_channel):
tile_d = af.reorder(tiles[:,:,d],1,0)
weight_d = weights[:,d,f]
out[0,f] += af.moddims(af.matmul(tile_d, weight_d), 1,1, w_o, h_o)
out[0,f] += biases[f].to_list()[0]
return af.reorder(out, 2, 3, 1, 0)
def lax_friedrichs_flux(u, gv):
'''
'''
u = af.reorder(af.moddims(u, params.N_LGL**2, 10, 10), 2, 1, 0)
diff_u_boundary = af.np_to_af_array(np.zeros([10, 10, params.N_LGL**2]))
u_xi_minus1_boundary_right = u[:, :, :params.N_LGL]
u_xi_minus1_boundary_left = af.shift(u[:, :, -params.N_LGL:], d0=0, d1=1)
u[:, :, :params.N_LGL] = (u_xi_minus1_boundary_right +
u_xi_minus1_boundary_left) / 2
diff_u_boundary[:, :, :params.N_LGL] = (u_xi_minus1_boundary_right -
u_xi_minus1_boundary_left)
u_xi_1_boundary_left = u[:, :, -params.N_LGL:]
u_xi_1_boundary_right = af.shift(u[:, :, :params.N_LGL], d0=0, d1=-1)
u[:, :, :params.N_LGL] = (u_xi_minus1_boundary_left +
u_xi_minus1_boundary_right) / 2
diff_u_boundary[:, :, -params.N_LGL:] = (u_xi_minus1_boundary_right -
u_xi_minus1_boundary_left)
u_eta_minus1_boundary_down = af.shift(u[:, :, params.N_LGL -
1:params.N_LGL**2:params.N_LGL],
d0=-1)
u_eta_minus1_boundary_up = u[:, :, 0:-params.N_LGL + 1:params.N_LGL]
u[:, :, 0:-params.N_LGL + 1:params.N_LGL] = (u_eta_minus1_boundary_down\
+ u_eta_minus1_boundary_up) / 2
diff_u_boundary[:, :, 0:-params.N_LGL + 1:params.N_LGL] = (u_eta_minus1_boundary_up\
-u_eta_minus1_boundary_down)
u_eta_1_boundary_down = u[:, :,
params.N_LGL - 1:params.N_LGL**2:params.N_LGL]
u_eta_1_boundary_up = af.shift(u[:, :, 0:-params.N_LGL + 1:params.N_LGL],
d0=1)
u[:, :, params.N_LGL - 1:params.N_LGL ** 2:params.N_LGL] = (u_eta_1_boundary_up\
+u_eta_1_boundary_down) / 2
diff_u_boundary[:, :, params.N_LGL - 1:params.N_LGL ** 2:params.N_LGL] = (u_eta_1_boundary_up\
-u_eta_1_boundary_down)
u = af.moddims(af.reorder(u, 2, 1, 0), params.N_LGL**2, 100)
diff_u_boundary = af.moddims(af.reorder(diff_u_boundary, 2, 1, 0),
params.N_LGL**2, 100)
F_xi_e_ij = F_xi(u, gv) - params.c_x * diff_u_boundary
F_eta_e_ij = F_eta(u, gv) - params.c_y * diff_u_boundary
return F_xi_e_ij, F_eta_e_ij
def f_left(q1, q2, p1, p2, p3, params):
f = q1**0 * np.sqrt(1 / (4 * np.pi)) * af.exp(-p1**2 / 4)
f[:] = 0
f = af.moddims(f, 49*49, 4, 4)
f_activated = f.copy()
f_activated[:, 3, 2] = 1
f = af.moddims(f, 49, 49, 4*4)
f_activated = af.moddims(f_activated, 49, 49, 4*4)
f[:, 19:28] = f_activated[:, 19:28]
return(f)
def add_boundary_conditions(u, v):
u_bc = af.np_to_af_array(np.zeros([params.n, params.n]))
v_bc = af.np_to_af_array(np.zeros([params.n, params.n]))
u = af.moddims(u, params.n - 2, params.n - 2)
v = af.moddims(v, params.n - 2, params.n - 2)
u_bc[1:-1, 1:-1] = u
v_bc[1:-1, 1:-1] = v
u_bc[:, 0] += params.u_i_0
return u_bc, v_bc
def f_left(q1, q2, p1, p2, p3, params):
f = q1**0 * np.sqrt(1 / (4 * np.pi)) * af.exp(-p1**2 / 4)
f[:] = 0
f = af.moddims(f, 1038 * 178, 4, 4)
f_activated = f.copy()
f_activated[:, 3, 2] = 1
f_activated[:, 3, 1] = 1
f = af.moddims(f, 1038, 178, 4 * 4)
f_activated = af.moddims(f_activated, 1038, 178, 4 * 4)
f[:, 71:105] = f_activated[:, 71:105]
return (f)
def initialize_f(q1, q2, p1, p2, p3, params):
rho = af.exp(-200 * (q1 - 0.5)**2 - 200 * (q2 - 0.5)**2)
f = p1 * rho
f[:] = 0
f = af.moddims(f, N_p1, N_p2, N_p3, q1.shape[2] * q1.shape[3])
rho = af.moddims(rho, 1, 1, 1, q1.shape[2] * q1.shape[3])
f[2, 2, 0] = rho
f = af.moddims(f, N_p1 * N_p2 * N_p3, 1, q1.shape[2], q1.shape[3])
af.eval(f)
return (f)
def grad_q(q, u, v):
'''
done - Matching qx qnd qy
'''
q = af.moddims(q, params.n, params.n)
q_x = af.np_to_af_array(np.zeros([params.n, params.n]))
q_y = af.np_to_af_array(np.zeros([params.n, params.n]))
q_x[1:-1, 1:-1] = (q[:-2, 1:-1] - q[2:, 1:-1]) * (params.n - 1) / 2.0
q_y[1:-1, 1:-1] = (q[1:-1, :-2] - q[1:-1, 2:]) * (params.n - 1) / 2.0
# Horizontal boundary conditions, qx = 0
q_y[0, 1:-1] = (q[0, :-2] - q[0, 2:]) * (params.n - 1) / 2.0
q_y[-1, 1:-1] = (q[-1, :-2] - q[-1, 2:]) * (params.n - 1) / 2.0
# Vertical boundary conditions, qy = 0
q_x[1:-1, 0] = (q[:-2, 0] - q[2:, 0]) * (params.n - 1) / 2.0
q_x[1:-1, -1] = (q[:-2, -1] - q[2:, -1]) * (params.n - 1) / 2.0
#UNEXPLAINED SWITCHING in the second part of numerator in octave
q_x = af.flat(q_x)
q_y = af.flat(q_y)
return q_x, q_y
def load_distribution_function(self, file_name):
"""
This function is used to load the distribution function from the
dump file that was created by dump_distribution_function.
Parameters
----------
file_name : The distribution_function array will be loaded from this
provided file name.
Examples
--------
>> solver.load_distribution_function('distribution_function')
The above statemant will load the distribution function data stored in the file
distribution_function.h5 into self.f
"""
viewer = PETSc.Viewer().createHDF5(file_name + '.h5',
PETSc.Viewer.Mode.READ,
comm=self._comm
)
self._glob_f.load(viewer)
N_g = self.N_ghost
self.f[:, N_g:-N_g, N_g:-N_g] = af.moddims(af.to_array(self._glob_f_array),
self.N_p1 * self.N_p2 * self.N_p3,
self.N_q1, self.N_q2
)
return
def _convert_to_p_expanded(self, array):
"""
Since we are limited to use 4D arrays due to
the bound from ArrayFire, we define 2 forms
which can be used such that the computations may
carried out along all dimensions necessary:
q_expanded form:(N_p1 * N_p2 * N_p3, N_s, N_q1, N_q2)
p_expanded form:(N_p1, N_p2, N_p3, N_s * N_q1 * N_q2)
This function converts the input array from
q_expanded to p_expanded form.
"""
# Obtaining start coordinates for the local zone
# Additionally, we also obtain the size of the local zone
((i_q1_start, i_q2_start), (N_q1_local,
N_q2_local)) = self._da_f.getCorners()
array = af.moddims(
array, self.N_p1 + 2 * self.N_ghost_p,
self.N_p2 + 2 * self.N_ghost_p, self.N_p3 + 2 * self.N_ghost_p,
self.N_species * (N_q1_local + 2 * self.N_ghost_q) *
(N_q2_local + 2 * self.N_ghost_q))
af.eval(array)
return (array)
def calculate_dfdp_background(self):
"""
Calculates the derivative of the background distribution
with respect to the variables p1, p2, p3. This is used to
solve for the contribution from the fields
"""
f_b = af.moddims(self.f_background, self.N_p1, self.N_p2, self.N_p3)
# Using a 4th order central difference stencil:
dfdp1_background = (-af.shift(f_b, -2) + 8 * af.shift(f_b, -1) + af.shift(
f_b, 2) - 8 * af.shift(f_b, 1)) / (12 * self.dp1)
dfdp2_background = (-af.shift(f_b, 0, -2) + 8 * af.shift(f_b, 0, -1) +
af.shift(f_b, 0, 2) -
8 * af.shift(f_b, 0, 1)) / (12 * self.dp2)
dfdp3_background = (-af.shift(f_b, 0, 0, -2) +
8 * af.shift(f_b, 0, 0, -1) + af.shift(f_b, 0, 0, 2) -
8 * af.shift(f_b, 0, 0, 1)) / (12 * self.dp3)
# Reordering such that the variations in velocity are along axis 2
self.dfdp1_background = af.reorder(af.flat(dfdp1_background), 2, 3, 0, 1)
self.dfdp2_background = af.reorder(af.flat(dfdp2_background), 2, 3, 0, 1)
self.dfdp3_background = af.reorder(af.flat(dfdp3_background), 2, 3, 0, 1)
af.eval(self.dfdp1_background, self.dfdp2_background,
self.dfdp3_background)
return
def fc(weights, biases, image):
#TODO: fix shape of fc weights
#TODO: fix handling 1d vs 3d image
#TODO: remove assumption of only 1 input
s = image.dims()[0]
if len(image.dims()) is 3:
in0, in1, in2 = image.dims()
image = af.reorder(image, 1, 0, 2)
s = in0*in1*in2
image = af.moddims(image, 1, s)
d0, d1, d2, d3 = weights.dims()
weights = af.moddims(weights, d2, d3)
out = af.moddims(af.matmul(image, weights), d3) + biases
return out
def volume_integral(u, gv):
'''
Vectorize, p, q, moddims.
'''
dLp_xi_ij_Lq_eta_ij = gv.dLp_Lq
dLq_eta_ij_Lp_xi_ij = gv.dLq_Lp
if (params.volume_integrand_scheme_2d == 'Lobatto'
and params.N_LGL == params.N_quad):
w_i = af.flat(
af.transpose(
af.tile(gv.lobatto_weights_quadrature, 1, params.N_LGL)))
w_j = af.tile(gv.lobatto_weights_quadrature, params.N_LGL)
wi_wj_dLp_xi = af.broadcast(utils.multiply, w_i * w_j, gv.dLp_Lq)
volume_integrand_ij_1_sp = af.broadcast(utils.multiply,\
wi_wj_dLp_xi, F_xi(u, gv) * gv.sqrt_g)
wi_wj_dLq_eta = af.broadcast(utils.multiply, w_i * w_j, gv.dLq_Lp)
volume_integrand_ij_2_sp = af.broadcast(utils.multiply,\
wi_wj_dLq_eta, F_eta(u, gv) * gv.sqrt_g)
volume_integral = af.reorder(
af.sum(volume_integrand_ij_1_sp + volume_integrand_ij_2_sp, 0), 2,
1, 0)
else: # NEEDS TO BE CHANGED
volume_integrand_ij_1 = af.broadcast(utils.multiply,\
dLp_xi_ij_Lq_eta_ij,\
F_xi(u, gv))
volume_integrand_ij_2 = af.broadcast(utils.multiply,\
dLq_eta_ij_Lp_xi_ij,\
F_eta(u, gv))
volume_integrand_ij = af.moddims((volume_integrand_ij_1 + volume_integrand_ij_2)\
* np.mean(gv.sqrt_det_g), params.N_LGL ** 2,\
(params.N_LGL ** 2) * 100)
lagrange_interpolation = af.moddims(
lag_interpolation_2d(volume_integrand_ij, gv.Li_Lj_coeffs),
params.N_LGL, params.N_LGL, params.N_LGL**2 * 100)
volume_integrand_total = utils.integrate_2d_multivar_poly(lagrange_interpolation[:, :, :],\
params.N_quad,'gauss', gv)
volume_integral = af.transpose(
af.moddims(volume_integrand_total, 100, params.N_LGL**2))
return volume_integral
def simple_data(verbose=False):
display_func = _util.display_func(verbose)
display_func(af.constant(100, 3, 3, dtype=af.Dtype.f32))
display_func(af.constant(25, 3, 3, dtype=af.Dtype.c32))
display_func(af.constant(2**50, 3, 3, dtype=af.Dtype.s64))
display_func(af.constant(2+3j, 3, 3))
display_func(af.constant(3+5j, 3, 3, dtype=af.Dtype.c32))
display_func(af.range(3, 3))
display_func(af.iota(3, 3, tile_dims=(2, 2)))
display_func(af.identity(3, 3, 1, 2, af.Dtype.b8))
display_func(af.identity(3, 3, dtype=af.Dtype.c32))
a = af.randu(3, 4)
b = af.diag(a, extract=True)
c = af.diag(a, 1, extract=True)
display_func(a)
display_func(b)
display_func(c)
display_func(af.diag(b, extract=False))
display_func(af.diag(c, 1, extract=False))
display_func(af.join(0, a, a))
display_func(af.join(1, a, a, a))
display_func(af.tile(a, 2, 2))
display_func(af.reorder(a, 1, 0))
display_func(af.shift(a, -1, 1))
display_func(af.moddims(a, 6, 2))
display_func(af.flat(a))
display_func(af.flip(a, 0))
display_func(af.flip(a, 1))
display_func(af.lower(a, False))
display_func(af.lower(a, True))
display_func(af.upper(a, False))
display_func(af.upper(a, True))
a = af.randu(5, 5)
display_func(af.transpose(a))
af.transpose_inplace(a)
display_func(a)
display_func(af.select(a > 0.3, a, -0.3))
af.replace(a, a > 0.3, -0.3)
display_func(a)
display_func(af.pad(a, (1, 1, 0, 0), (2, 2, 0, 0)))
def simple_data(verbose=False):
display_func = _util.display_func(verbose)
print_func = _util.print_func(verbose)
display_func(af.constant(100, 3,3, dtype=af.Dtype.f32))
display_func(af.constant(25, 3,3, dtype=af.Dtype.c32))
display_func(af.constant(2**50, 3,3, dtype=af.Dtype.s64))
display_func(af.constant(2+3j, 3,3))
display_func(af.constant(3+5j, 3,3, dtype=af.Dtype.c32))
display_func(af.range(3, 3))
display_func(af.iota(3, 3, tile_dims=(2,2)))
display_func(af.identity(3, 3, 1, 2, af.Dtype.b8))
display_func(af.identity(3, 3, dtype=af.Dtype.c32))
a = af.randu(3, 4)
b = af.diag(a, extract=True)
c = af.diag(a, 1, extract=True)
display_func(a)
display_func(b)
display_func(c)
display_func(af.diag(b, extract = False))
display_func(af.diag(c, 1, extract = False))
display_func(af.join(0, a, a))
display_func(af.join(1, a, a, a))
display_func(af.tile(a, 2, 2))
display_func(af.reorder(a, 1, 0))
display_func(af.shift(a, -1, 1))
display_func(af.moddims(a, 6, 2))
display_func(af.flat(a))
display_func(af.flip(a, 0))
display_func(af.flip(a, 1))
display_func(af.lower(a, False))
display_func(af.lower(a, True))
display_func(af.upper(a, False))
display_func(af.upper(a, True))
a = af.randu(5,5)
display_func(af.transpose(a))
af.transpose_inplace(a)
display_func(a)
display_func(af.select(a > 0.3, a, -0.3))
af.replace(a, a > 0.3, -0.3)
display_func(a)
def _soft_l_value_demapper_af(rx_symbs, M, snr, bits_map):
num_bits = int(np.log2(M))
N = rx_symbs.shape[0]
k = bits_map.shape[1]
sig = af.np_to_af_array(rx_symbs)
bit_mtx = af.moddims(af.np_to_af_array(bits_map), 1, num_bits, k, 2)
tmp = af.sum(af.broadcast(lambda x,y: af.exp(-snr*af.abs(x-y)**2), bit_mtx, sig), dim=2)
lvl = af.log(tmp[:,:,:,1]) - af.log(tmp[:,:,:,0])
return np.array(lvl)
def __pad(image, px, py):
if px == 0 and py == 0:
return image
d = image.dims()
pad_x = d[0]+2*px
pad_y = d[1]+2*py
return af.moddims(af.unwrap(image, pad_x, pad_y, pad_x, pad_y, px, py),
pad_x, pad_y, d[2])
def projection_step(u, v, A_projection):
N_squared = params.n**2
u_boundary_condition, v_boundary_condition = add_boundary_conditions(u, v)
q = projection_step_poisson(u_boundary_condition, v_boundary_condition,
A_projection)
gradient_q = grad_q(q, u, v)
u_boundary_condition = af.flat(u_boundary_condition)
v_boundary_condition = af.flat(v_boundary_condition)
u4 = u_boundary_condition - gradient_q[0]
v4 = v_boundary_condition - gradient_q[1]
u4 = af.flat(af.moddims(u4, params.n, params.n)[1:-1, 1:-1])
v4 = af.flat(af.moddims(v4, params.n, params.n)[1:-1, 1:-1])
return u4, v4
def predict_proba1(self, X):
near_locs, near_dists = af.vision.nearest_neighbour(X, self._data, self._dim, \
self._num_nearest, self._match_type)
weights = self._get_neighbor_weights(near_dists)
top_labels = af.moddims(self._labels[near_locs], \
get_dims(near_locs)[0], get_dims(near_locs)[1])
accum_weights = af.scan_by_key(
top_labels, weights) # reduce by key would be more ideal
probs, _ = af.imax(accum_weights, dim=0)
return probs.T
def contour_2d(u, index):
'''
'''
color_levels = np.linspace(-1.1, 1.1, 100)
u_plot = af.flip(af.moddims(u, params.N_LGL, params.N_LGL, 10, 10), 0)
x_plot = af.flip(af.moddims(x_e_ij, params.N_LGL, params.N_LGL, 10, 10), 0)
y_plot = af.flip(af.moddims(y_e_ij, params.N_LGL, params.N_LGL, 10, 10), 0)
x_contour = af.np_to_af_array(
np.zeros([params.N_LGL * 10, params.N_LGL * 10]))
y_contour = af.np_to_af_array(
np.zeros([params.N_LGL * 10, params.N_LGL * 10]))
u_contour = af.np_to_af_array(
np.zeros([params.N_LGL * 10, params.N_LGL * 10]))
fig = pl.figure()
#
for i in range(100):
p = int(i / 10)
q = i - p * 10
x_contour[p * params.N_LGL:params.N_LGL * (p + 1),\
q * params.N_LGL:params.N_LGL * (q + 1)] = x_plot[:, :, q, p]
y_contour[p * params.N_LGL:params.N_LGL * (p + 1),\
q * params.N_LGL:params.N_LGL * (q + 1)] = y_plot[:, :, q, p]
u_contour[p * params.N_LGL:params.N_LGL * (p + 1),\
q * params.N_LGL:params.N_LGL * (q + 1)] = u_plot[:, :, q, p]
x_contour = np.array(x_contour)
y_contour = np.array(y_contour)
u_contour = np.array(u_contour)
pl.contourf(x_contour,
y_contour,
u_contour,
200,
levels=color_levels,
cmap='jet')
pl.gca().set_aspect('equal')
pl.colorbar()
pl.title('Time = %.2f' % (index * 10 * delta_t_2d))
fig.savefig('results/2D_Wave_images/%04d' % (index) + '.png')
pl.close('all')
return
def lrn(image, size, alpha, beta):
#TODO: Remove assumption of image.dims()[3] == 1
d0, d1, d2 = image.dims()
#TODO: remove reorder and moddims call
image = af.moddims(af.reorder(image, 2, 0, 1), 1, d2, d0, d1)
d0, d1, d2, d3 = image.dims()
pad = (size - 1) / 2
padded_size = d1+2*pad
out = af.constant(0,d1, d2, d3)
image = af.moddims(image, d1, d2, d3)
padded = af.moddims(af.unwrap(image, padded_size, d2, padded_size, d2, pad,0), padded_size, d2, d2)
padded = padded*padded
for i in xrange(size):
out += padded[i:i+d1]
out = 1 + (float(alpha)/size) * out
out = af.pow(out,beta)
#TODO: remove reorder call
return af.reorder(af.moddims(image/out, d0,d1,d2,d3), 2, 3, 1, 0)
def initialize_f(q1, q2, p1, p2, p3, params):
x = q1 * af.cos(q2)
y = q1 * af.sin(q2)
# Calculating the perturbed density:
rho = af.exp(-(x**2 + (y - 1.5)**2)/0.25**2)
f = p1 * rho
f[:] = 0
f = af.moddims(f, 32, 32, 70*70)
rho = af.moddims(rho, 1, 1, 70*70)
f[20, 20] = rho
f = af.moddims(f, 32*32, 70, 70)
af.eval(f)
return (f)
a = af.randu(3, 4) b = af.diag(a, extract=True) c = af.diag(a, 1, extract=True) af.display(a) af.display(b) af.display(c) af.display(af.diag(b, extract = False)) af.display(af.diag(c, 1, extract = False)) af.display(af.tile(a, 2, 2)) af.display(af.reorder(a, 1, 0)) af.display(af.shift(a, -1, 1)) af.display(af.moddims(a, 6, 2)) af.display(af.flat(a)) af.display(af.flip(a, 0)) af.display(af.flip(a, 1)) af.display(af.lower(a, False)) af.display(af.lower(a, True)) af.display(af.upper(a, False)) af.display(af.upper(a, True))
a = af.randu(3, 4) b = af.diag(a, extract=True) c = af.diag(a, 1, extract=True) af.print_array(a) af.print_array(b) af.print_array(c) af.print_array(af.diag(b, extract = False)) af.print_array(af.diag(c, 1, extract = False)) af.print_array(af.tile(a, 2, 2)) af.print_array(af.reorder(a, 1, 0)) af.print_array(af.shift(a, -1, 1)) af.print_array(af.moddims(a, 6, 2)) af.print_array(af.flat(a)) af.print_array(af.flip(a, 0)) af.print_array(af.flip(a, 1)) af.print_array(af.lower(a, False)) af.print_array(af.lower(a, True)) af.print_array(af.upper(a, False)) af.print_array(af.upper(a, True))