def _calculate_p_center(self): """ Initializes the cannonical variables p1, p2 and p3 using a centered formulation. The size, and resolution are the same as declared under domain of the physical system object. """ p1_center = self.p1_start + (0.5 + np.arange( -self.N_ghost_p, self.N_p1 + self.N_ghost_p)) * self.dp1 p2_center = self.p2_start + (0.5 + np.arange( -self.N_ghost_p, self.N_p2 + self.N_ghost_p)) * self.dp2 p3_center = self.p3_start + (0.5 + np.arange( -self.N_ghost_p, self.N_p3 + self.N_ghost_p)) * self.dp3 p2_center, p1_center, p3_center = np.meshgrid(p2_center, p1_center, p3_center) # Flattening the arrays: p1_center = af.flat(af.to_array(p1_center)) p2_center = af.flat(af.to_array(p2_center)) p3_center = af.flat(af.to_array(p3_center)) if (self.N_species > 1): p1_center = af.tile(p1_center, 1, self.N_species) p2_center = af.tile(p2_center, 1, self.N_species) p3_center = af.tile(p3_center, 1, self.N_species) af.eval(p1_center, p2_center, p3_center) return (p1_center, p2_center, p3_center)
def lobatto_quad_multivar_poly(poly_xi_eta, N_quad, advec_var): ''' ''' shape_poly_2d = shape(poly_xi_eta) xi_LGL = lagrange.LGL_points(N_quad) eta_LGL = lagrange.LGL_points(N_quad) Xi, Eta = af_meshgrid(xi_LGL, eta_LGL) Xi = af.flat(Xi) Eta = af.flat(Eta) w_i = lagrange.lobatto_weights(N_quad) w_j = lagrange.lobatto_weights(N_quad) W_i, W_j = af_meshgrid(w_i, w_j) W_i = af.tile(af.flat(W_i), d0 = 1, d1 = shape_poly_2d[2]) W_j = af.tile(af.flat(W_j), d0 = 1, d1 = shape_poly_2d[2]) P_xi_eta_quad_val = af.transpose(polyval_2d(poly_xi_eta, Xi, Eta)) integral = af.sum(W_i * W_j * P_xi_eta_quad_val, dim = 0) return af.transpose(integral)
def calculate_p_center(p1_start, p2_start, p3_start, N_p1, N_p2, N_p3, dp1, dp2, dp3, ): """ Initializes the cannonical variables p1, p2 and p3 using a centered formulation. """ p1_center = af.constant(0, N_p1 * N_p2 * N_p3, len(p1_start), dtype = af.Dtype.f64) p2_center = af.constant(0, N_p1 * N_p2 * N_p3, len(p2_start), dtype = af.Dtype.f64) p3_center = af.constant(0, N_p1 * N_p2 * N_p3, len(p3_start), dtype = af.Dtype.f64) # Assigning for each species: for i in range(len(p1_start)): p1 = p1_start[i] + (0.5 + np.arange(N_p1)) * dp1[i] p2 = p2_start[i] + (0.5 + np.arange(N_p2)) * dp2[i] p3 = p3_start[i] + (0.5 + np.arange(N_p3)) * dp3[i] p2_center[:, i] = af.flat(af.to_array(np.meshgrid(p2, p1, p3)[0])) p1_center[:, i] = af.flat(af.to_array(np.meshgrid(p2, p1, p3)[1])) p3_center[:, i] = af.flat(af.to_array(np.meshgrid(p2, p1, p3)[2])) af.eval(p1_center, p2_center, p3_center) return (p1_center, p2_center, p3_center)
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 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 test_calculate_p(): obj = test() p1, p2, p3 = calculate_p(obj) p1_expected = obj.p1_start + (0.5 + np.arange(obj.N_p1)) * obj.dp1 p2_expected = obj.p2_start + (0.5 + np.arange(obj.N_p2)) * obj.dp2 p3_expected = obj.p3_start + (0.5 + np.arange(obj.N_p3)) * obj.dp3 p2_expected, p1_expected, p3_expected = np.meshgrid(p2_expected, p1_expected, p3_expected ) p1_expected = af.reorder(af.flat(af.to_array(p1_expected)), 2, 3, 0, 1 ) p2_expected = af.reorder(af.flat(af.to_array(p2_expected)), 2, 3, 0, 1 ) p3_expected = af.reorder(af.flat(af.to_array(p3_expected)), 2, 3, 0, 1 ) assert(af.sum(af.abs(p1_expected - p1)) == 0) assert(af.sum(af.abs(p2_expected - p2)) == 0) assert(af.sum(af.abs(p3_expected - p3)) == 0)
def dump_coordinate_info(self, arrays, name, file_name): self._da_coord_arrays = PETSc.DMDA().create( [self.N_q1, self.N_q2], dof=len(arrays), proc_sizes=(self._nproc_in_q1, self._nproc_in_q2), ownership_ranges=self._ownership_ranges, comm=self._comm) self._glob_coord = self._da_coord_arrays.createGlobalVec() self._glob_coord_array = self._glob_coord.getArray() N_g = self.N_ghost for i in range(len(arrays)): if (i == 0): array_to_dump = arrays[0][:, :, N_g:-N_g, N_g:-N_g] else: array_to_dump = af.join(0, array_to_dump, arrays[i][:, :, N_g:-N_g, N_g:-N_g]) af.flat(array_to_dump).to_ndarray(self._glob_coord_array) PETSc.Object.setName(self._glob_coord, name) viewer = PETSc.Viewer().createBinary(file_name + '.bin', 'w', comm=self._comm) viewer(self._glob_coord)
def _calculate_p_center(self): """ Initializes the cannonical variables p1, p2 and p3 using a centered formulation. The size, and resolution are the same as declared under domain of the physical system object. """ p1_center = \ self.p1_start + (0.5 + np.arange(0, self.N_p1, 1)) * self.dp1 p2_center = \ self.p2_start + (0.5 + np.arange(0, self.N_p2, 1)) * self.dp2 p3_center = \ self.p3_start + (0.5 + np.arange(0, self.N_p3, 1)) * self.dp3 p2_center, p1_center, p3_center = np.meshgrid(p2_center, p1_center, p3_center ) # Flattening the obtained arrays: p1_center = af.flat(af.to_array(p1_center)) p2_center = af.flat(af.to_array(p2_center)) p3_center = af.flat(af.to_array(p3_center)) # Reordering such that variation in velocity is along axis 2: # This is done to be consistent with the positionsExpanded form: p1_center = af.reorder(p1_center, 2, 3, 0, 1) p2_center = af.reorder(p2_center, 2, 3, 0, 1) p3_center = af.reorder(p3_center, 2, 3, 0, 1) af.eval(p1_center, p2_center, p3_center) return(p1_center, p2_center, p3_center)
def _calculate_p_back(self): p1_center = self.p1_start + (0.5 + np.arange( -self.N_ghost_p, self.N_p1 + self.N_ghost_p)) * self.dp1 p2_center = self.p2_start + (0.5 + np.arange( -self.N_ghost_p, self.N_p2 + self.N_ghost_p)) * self.dp2 p3_back = self.p3_start + np.arange( -self.N_ghost_p, self.N_p3 + self.N_ghost_p) * self.dp3 p2_back, p1_back, p3_back = np.meshgrid(p2_center, p1_center, p3_center) # Flattening the arrays: p1_back = af.flat(af.to_array(p1_back)) p2_back = af.flat(af.to_array(p2_back)) p3_back = af.flat(af.to_array(p3_back)) if (self.N_species > 1): p1_back = af.tile(p1_back, 1, self.N_species) p2_back = af.tile(p2_back, 1, self.N_species) p3_back = af.tile(p3_back, 1, self.N_species) af.eval(p1_back, p2_back, p3_back) return (p1_back, p2_back, p3_back)
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 dump_moments(self, file_name): """ This function is used to dump variables to a file for later usage. Parameters ---------- file_name : str The variables will be dumped to this provided file name. Returns ------- This function returns None. However it creates a file 'file_name.h5', containing all the moments that were defined under moments_defs in physical_system. Examples -------- >> solver.dump_variables('boltzmann_moments_dump') The above set of statements will create a HDF5 file which contains the all the moments which have been defined in the physical_system object. The data is always stored with the key 'moments' inside the HDF5 file. Suppose 'density' and 'energy' are two these moments, and are declared the first and second in the moment_exponents object: These variables can then be accessed from the file using >> import h5py >> h5f = h5py.File('boltzmann_moments_dump.h5', 'r') >> rho = h5f['moments'][:][:, :, 0] >> E = h5f['moments'][:][:, :, 1] >> h5f.close() """ N_g = self.N_ghost i = 0 for key in self.physical_system.moment_exponents: if (i == 0): array_to_dump = self.compute_moments(key)[:, N_g:-N_g, N_g:-N_g] else: array_to_dump = af.join( 0, array_to_dump, self.compute_moments(key)[:, N_g:-N_g, N_g:-N_g]) i += 1 af.flat(array_to_dump).to_ndarray(self._glob_moments_array) PETSc.Object.setName(self._glob_moments, 'moments') viewer = PETSc.Viewer().createHDF5(file_name + '.h5', 'w', comm=self._comm) viewer(self._glob_moments)
def communicate_f(self): """ 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 distribution function array. """ 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_f.getCorners() N_g_q = self.N_ghost_q N_g_p = self.N_ghost_p # Assigning the local array only when Dirichlet # boundary conditions are applied. This is needed since # only inflowing characteristics are to be changed by # the apply boundary conditions function. if (self.boundary_conditions.in_q1_left == 'dirichlet' or self.boundary_conditions.in_q1_right == 'dirichlet' or self.boundary_conditions.in_q2_bottom == 'dirichlet' or self.boundary_conditions.in_q2_top == 'dirichlet'): af.flat(self.f).to_ndarray(self._local_f_array) # Global value is non-inclusive of the ghost-zones: af.flat(self.f[:, :, N_g_q:-N_g_q, N_g_q:-N_g_q]).to_ndarray(self._glob_f_array) # The following function takes care of interzonal communications # Additionally, it also automatically applies periodic BCs when necessary self._da_f.globalToLocal(self._glob_f, self._local_f) # Converting back from PETSc.Vec to af.Array: f_flattened = af.to_array(self._local_f_array) self.f = af.moddims(f_flattened, (self.N_p1 + 2 * N_g_p) * (self.N_p2 + 2 * N_g_p) * (self.N_p3 + 2 * N_g_p), self.N_species, N_q1_local + 2 * N_g_q, N_q2_local + 2 * N_g_q) af.eval(self.f) if (self.performance_test_flag == True): af.sync() toc = af.time() self.time_communicate_f += toc - tic return
def __init__(self): self.physical_system = type('obj', (object, ), { 'moment_exponents': moment_exponents, 'moment_coeffs': moment_coeffs }) 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.flat(af.to_array(self.p1)) self.p2 = af.flat(af.to_array(self.p2)) self.p3 = af.flat(af.to_array(self.p3)) 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.reorder(af.to_array(self.q1), 2, 0, 1) self.q2 = af.reorder(af.to_array(self.q2), 2, 0, 1) 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)
def log_loss(y_true, y_prob): """Compute Logistic loss for classification. Parameters ---------- y_true : array-like or label indicator matrix Ground truth (correct) labels. y_prob : array-like of float, shape = (n_samples, n_classes) Predicted probabilities, as returned by a classifier's predict_proba method. Returns ------- loss : float The degree to which the samples are correctly predicted. """ # eps = np.finfo(y_prob.dtype).eps # y_prob = np.clip(y_prob, eps, 1 - eps) # if y_prob.shape[1] == 1: # y_prob = np.append(1 - y_prob, y_prob, axis=1) # # if y_true.shape[1] == 1: # y_true = np.append(1 - y_true, y_true, axis=1) # # return - xlogy(y_true, y_prob).sum() / y_prob.shape[0] eps = numpy.finfo(typemap(y_prob.dtype())).eps y_prob[y_prob < eps] = eps y_prob[y_prob > (1.0 - eps)] = 1.0 - eps if y_prob.numdims() == 1: y_prob = af.join(1, (1.0 - y_prob).as_type(y_prob.dtype()), y_prob) if y_true.numdims() == 1: y_true = af.join(1, (1.0 - y_true).as_type(y_true.dtype()), y_true) return - af.sum(af.flat(xlogy(y_true, y_prob))) / y_prob.shape[0]
def test_interpolation(): ''' ''' threshold = 8e-9 params.N_LGL = 8 gv = gvar.advection_variables(params.N_LGL, params.N_quad,\ params.x_nodes, params.N_Elements,\ params.c, params.total_time, params.wave,\ params.c_x, params.c_y, params.courant,\ params.mesh_file, params.total_time_2d) N_LGL = 8 xi_LGL = lagrange.LGL_points(N_LGL) xi_i = af.flat(af.transpose(af.tile(xi_LGL, 1, N_LGL))) eta_j = af.tile(xi_LGL, N_LGL) f_ij = np.e**(xi_i + eta_j) interpolated_f = wave_equation_2d.lag_interpolation_2d( f_ij, gv.Li_Lj_coeffs) xi = utils.linspace(-1, 1, 8) eta = utils.linspace(-1, 1, 8) assert (af.mean( af.transpose(utils.polyval_2d(interpolated_f, xi, eta)) - np.e**(xi + eta)) < threshold)
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 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 dump_distribution_function(self, file_name): """ This function is used to dump distribution function to a file for later usage.This dumps the complete 5D distribution function which can be used for post-processing Parameters ---------- file_name : The distribution_function array will be dumped to this provided file name. Returns ------- This function returns None. However it creates a file 'file_name.h5', containing the data of the distribution function Examples -------- >> solver.dump_distribution_function('distribution_function') The above statement will create a HDF5 file which contains the distribution function. The data is always stored with the key 'distribution_function' This can later be accessed using >> import h5py >> h5f = h5py.File('distribution_function', 'r') >> f = h5f['distribution_function'][:] >> h5f.close() """ N_g = self.N_ghost af.flat(self.f[:, N_g:-N_g, N_g:-N_g]).to_ndarray(self._glob_f_array) PETSc.Object.setName(self._glob_f, 'distribution_function') viewer = PETSc.Viewer().createHDF5(file_name + '.h5', 'w', comm=self._comm) viewer(self._glob_f) return
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 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 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 squared_loss(y_true, y_pred): """Compute the squared loss for regression. Parameters ---------- y_true : array-like or label indicator matrix Ground truth (correct) values. y_pred : array-like or label indicator matrix Predicted values, as returned by a regression estimator. Returns ------- loss : float The degree to which the samples are correctly predicted. """ return af.mean(af.flat((y_true - y_pred) ** 2)) / 2
def predict(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 _, max_weight_locs = af.imax(accum_weights, dim=0) pred_idxs = af.range(get_dims(accum_weights)[1]) * get_dims( accum_weights)[0] + max_weight_locs.T top_labels_flat = af.flat(top_labels) pred_classes = top_labels_flat[pred_idxs] return pred_classes
def __init__(self, N): self.p_dim = 3 self.p1_start = -10 self.p2_start = -10 self.p3_start = -10 self.p1_end = 10 self.p2_end = 10 self.p3_end = 10 self.N_p1 = N self.N_p2 = N self.N_p3 = N self.dp1 = (self.p1_end - self.p1_start) / self.N_p1 self.dp2 = (self.p2_end - self.p2_start) / self.N_p2 self.dp3 = (self.p3_end - self.p3_start) / self.N_p3 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, self.p2, self.p3 = af.to_array(self.p1),\ af.to_array(self.p2),\ af.to_array(self.p3) self.p1 = af.reorder(af.flat(self.p1), 2, 3, 0, 1) self.p2 = af.reorder(af.flat(self.p2), 2, 3, 0, 1) self.p3 = af.reorder(af.flat(self.p3), 2, 3, 0, 1) self.f_background = af.exp(-self.p1**2) \ * af.exp(-self.p2**2) \ * af.exp(-self.p3**2)
def af_to_petsc_glob_array(domain_metadata, af_array, glob_array): # domaint_metadata obj should contain the following i_q1_start = domain_metadata.i_q1_start # start index of bulk domain i_q1_end = domain_metadata.i_q1_end # end index, before ghost zones i_q2_start = domain_metadata.i_q2_start i_q2_end = domain_metadata.i_q2_end tmp_array = af.flat(af_array[:, :, i_q1_start:i_q1_end, i_q2_start:i_q2_end]) tmp_array.to_ndarray(glob_array) return
def _predict(self, query, train_feats, train_labels, k, dist_type, weight_by_dist): near_locs, near_dists = af.vision.nearest_neighbour(query, train_feats, 1, \ k, dist_type) weights = self._get_neighbor_weights(near_dists, weight_by_dist, k) top_labels = af.moddims(train_labels[near_locs], \ near_locs.dims()[0], near_locs.dims()[1]) accum_weights = af.scan_by_key( top_labels, weights) # reduce by key would be more ideal _, max_weight_locs = af.imax(accum_weights, dim=0) pred_idxs = af.range(accum_weights.dims() [1]) * accum_weights.dims()[0] + max_weight_locs.T top_labels_flat = af.flat(top_labels) pred_classes = top_labels_flat[pred_idxs] return pred_classes
def calculate_p_corner(p1_start, p2_start, p3_start, N_p1, N_p2, N_p3, dp1, dp2, dp3, ): """ Initializes the cannonical variables p1, p2 and p3 at the corners of the momentum space grid zone """ p1_corner = af.constant(0, N_p1 * N_p2 * N_p3, len(p1_start), dtype = af.Dtype.f64) p2_corner = af.constant(0, N_p1 * N_p2 * N_p3, len(p2_start), dtype = af.Dtype.f64) p3_corner = af.constant(0, N_p1 * N_p2 * N_p3, len(p3_start), dtype = af.Dtype.f64) # Assigning for each species: for i in range(len(p1_start)): p1 = p1_start[i] + (np.arange(N_p1)) * dp1[i] p2 = p2_start[i] + (np.arange(N_p2)) * dp2[i] p3 = p3_start[i] + (np.arange(N_p3)) * dp3[i] p2_corner[:, i] = af.flat(af.to_array(np.meshgrid(p2, p1, p3)[0])) p1_corner[:, i] = af.flat(af.to_array(np.meshgrid(p2, p1, p3)[1])) p3_corner[:, i] = af.flat(af.to_array(np.meshgrid(p2, p1, p3)[2])) return (p1_corner, p2_corner, p3_corner)
def gauss_quad_multivar_poly(poly_xi_eta, N_quad, advec_var): ''' ''' shape_poly_2d = poly_xi_eta.shape xi_gauss = advec_var.gauss_points Xi = af.flat(af.transpose(af.tile(xi_gauss, 1, params.N_quad))) Eta = af.tile(xi_gauss, params.N_quad) w_i = advec_var.gauss_weights test_W_i = af.flat(af.transpose(af.tile(w_i, 1, params.N_quad))) test_W_j = af.tile(w_i, params.N_quad) W_i = af.tile(test_W_i, d0 = 1, d1 = shape_poly_2d[2]) W_j = af.tile(test_W_j, d0 = 1, d1 = shape_poly_2d[2]) P_xi_eta_quad_val = af.transpose(multivariable_poly_value(poly_xi_eta, Xi, Eta)) #P_xi_eta_quad_val = af.transpose(polyval_2d(poly_xi_eta, Xi, Eta)) integral = af.sum(W_i * W_j * P_xi_eta_quad_val, dim = 0) return af.transpose(integral)
def multivariable_poly_value(poly_2d, x, y): ''' ''' polynomial_coeffs = af.transpose(af.moddims(poly_2d, poly_2d.shape[0] ** 2, poly_2d.shape[2])) power_index = af.flip(af.np_to_af_array(np.arange(poly_2d.shape[0]))) x_power_indices = af.flat(af.transpose(af.tile(power_index, 1, poly_2d.shape[0]))) y_power_indices = af.tile(power_index, poly_2d.shape[0]) x_power = af.broadcast(power, af.transpose(x), x_power_indices) y_power = af.broadcast(power, af.transpose(y), y_power_indices) polynomial_value = af.matmul(polynomial_coeffs, x_power * y_power) return polynomial_value
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 test_1V(): obj = test() obj.single_mode_evolution = False f_generalized = MB_dist(obj.q1_center, obj.q2_center, obj.p1, obj.p2, obj.p3, 1) C_f_hat_generalized = 2 * af.fft2( collision_operator.BGK( f_generalized, obj.q1_center, obj.q2_center, obj.p1, obj.p2, obj.p3, obj.compute_moments, obj.physical_system.params)) / (obj.N_q2 * obj.N_q1) # Background C_f_hat_generalized[0, 0, :] = 0 # Finding the indices of the mode excited: i_q1_max = np.unravel_index( af.imax(af.abs(C_f_hat_generalized))[1], (obj.N_q1, obj.N_q2, obj.N_p1 * obj.N_p2 * obj.N_p3), order='F')[0] i_q2_max = np.unravel_index( af.imax(af.abs(C_f_hat_generalized))[1], (obj.N_q1, obj.N_q2, obj.N_p1 * obj.N_p2 * obj.N_p3), order='F')[1] obj.p1 = np.array(af.reorder(obj.p1, 1, 2, 3, 0)) obj.p2 = np.array(af.reorder(obj.p2, 1, 2, 3, 0)) obj.p3 = np.array(af.reorder(obj.p3, 1, 2, 3, 0)) delta_f_hat = 0.01 * (1 / (2 * np.pi))**(1 / 2) \ * np.exp(-0.5 * obj.p1**2) obj.single_mode_evolution = True C_f_hat_single_mode = collision_operator.linearized_BGK( delta_f_hat, obj.p1, obj.p2, obj.p3, obj.compute_moments, obj.physical_system.params) assert (af.mean( af.abs( af.flat(C_f_hat_generalized[i_q1_max, i_q2_max]) - af.to_array(C_f_hat_single_mode.flatten()))) < 1e-14)
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))
def flat(self): ret = ndarray(self.size, dtype=self.dtype, af_array=arrayfire.flat(self.d_array)) ret._base = self return ret