def test_l2projection_bounded_3D(polynomial_order, lb, ub): xmin, ymin, zmin = 0., 0., 0. xmax, ymax, zmax = 1., 1., 1. nx = 10 interpolate_expression = Ball(0.15, [0.5, 0.5, 0.5], degree=3, lb=lb, ub=ub) property_idx = 1 mesh = BoxMesh(Point(xmin, ymin, zmin), Point(xmax, ymax, zmax), nx, nx, nx) V = FunctionSpace(mesh, "DG", polynomial_order) x = RegularBox(Point(0., 0., 0.), Point(1., 1., 1.)).generate([100, 100, 100]) s = assign_particle_values(x, interpolate_expression) # Just make a complicated particle, possibly with scalars and vectors mixed p = particles(x, [s], mesh) vh = Function(V) lstsq_rho = l2projection(p, V, property_idx) lstsq_rho.project(vh.cpp_object(), lb, ub) # Assert if it stays within bounds assert np.any(vh.vector().get_local() < ub + 1e-12) assert np.any(vh.vector().get_local() > lb - 1e-12)
def test_l2projection_bounded(polynomial_order, lb, ub): # Test l2 projection if it stays within bounds given by lb and ub interpolate_expression = SlottedDisk(radius=0.15, center=[0.5, 0.5], width=0.05, depth=0., degree=3, lb=lb, ub=ub) xmin, xmax = 0., 1. ymin, ymax = 0., 1. property_idx = 5 mesh = RectangleMesh(Point(xmin, ymin), Point(xmax, ymax), 40, 40) V = FunctionSpace(mesh, "DG", polynomial_order) x = RandomRectangle(Point(xmin, ymin), Point(xmax, ymax)).generate([500, 500]) s = assign_particle_values(x, interpolate_expression) # Just make a complicated particle, possibly with scalars and vectors mixed p = particles(x, [x, s, x, x, s], mesh) vh = Function(V) lstsq_rho = l2projection(p, V, property_idx) lstsq_rho.project(vh, lb, ub) # Assert if it stays within bounds assert np.all(vh.vector().get_local() < ub + 1e-12) assert np.all(vh.vector().get_local() > lb - 1e-12)
def test_l2projection(polynomial_order, in_expression): # Test l2 projection for scalar and vector valued expression interpolate_expression = Expression(in_expression, degree=3) xmin, xmax = 0., 1. ymin, ymax = 0., 1. property_idx = 5 mesh = RectangleMesh(Point(xmin, ymin), Point(xmax, ymax), 40, 40) if len(interpolate_expression.ufl_shape) == 0: V = FunctionSpace(mesh, "DG", polynomial_order) elif len(interpolate_expression.ufl_shape) == 1: V = VectorFunctionSpace(mesh, "DG", polynomial_order) v_exact = Function(V) v_exact.interpolate(interpolate_expression) x = RandomRectangle(Point(xmin, ymin), Point(xmax, ymax)).generate([500, 500]) s = assign_particle_values(x, interpolate_expression) # Just make a complicated particle, possibly with scalars and vectors mixed p = particles(x, [x, s, x, x, s], mesh) vh = Function(V) lstsq_rho = l2projection(p, V, property_idx) lstsq_rho.project(vh) error_sq = abs(assemble(dot(v_exact - vh, v_exact - vh) * dx)) assert error_sq < 1e-15
def test_pde_constrained(polynomial_order, in_expression): interpolate_expression = Expression(in_expression, degree=3) xmin, xmax = 0., 1. ymin, ymax = 0., 1. property_idx = 1 dt = 1. k = polynomial_order # Make mesh mesh = RectangleMesh(Point(xmin, ymin), Point(xmax, ymax), 40, 40) # Make function spaces and functions W_e = FiniteElement("DG", mesh.ufl_cell(), k) T_e = FiniteElement("DG", mesh.ufl_cell(), 0) Wbar_e = FiniteElement("DGT", mesh.ufl_cell(), k) W = FunctionSpace(mesh, W_e) T = FunctionSpace(mesh, T_e) Wbar = FunctionSpace(mesh, Wbar_e) psi_h, psi0_h = Function(W), Function(W) lambda_h = Function(T) psibar_h = Function(Wbar) uadvect = Constant((0, 0)) # Define particles x = RandomRectangle(Point(xmin, ymin), Point(xmax, ymax)).generate([500, 500]) s = assign_particle_values(x, interpolate_expression) psi0_h.assign(interpolate_expression) # Just make a complicated particle, possibly with scalars and vectors mixed p = particles(x, [s], mesh) p.interpolate(psi0_h, 1) # Initialize forms FuncSpace_adv = { 'FuncSpace_local': W, 'FuncSpace_lambda': T, 'FuncSpace_bar': Wbar } forms_pde = FormsPDEMap(mesh, FuncSpace_adv).forms_theta_linear( psi0_h, uadvect, dt, Constant(1.0)) pde_projection = PDEStaticCondensation(mesh, p, forms_pde['N_a'], forms_pde['G_a'], forms_pde['L_a'], forms_pde['H_a'], forms_pde['B_a'], forms_pde['Q_a'], forms_pde['R_a'], forms_pde['S_a'], [], property_idx) # Assemble and solve pde_projection.assemble(True, True) pde_projection.solve_problem(psibar_h, psi_h, lambda_h, 'none', 'default') error_psih = abs(assemble((psi_h - psi0_h) * (psi_h - psi0_h) * dx)) error_lamb = abs(assemble(lambda_h * lambda_h * dx)) assert error_psih < 1e-15 assert error_lamb < 1e-15
def test_mesh_generator_2d(): """Basic functionality test.""" mesh = RectangleMesh(Point(0.0, 0.0), Point(1.0, 1.0), 5, 5) for x in mesh.coordinates(): x[0] += 0.5 * x[1] w = RandomCell(mesh) pts = w.generate(3) assert len(pts) == mesh.num_cells() * 3 interpolate_expression = Expression("x[0] + x[1]", degree=1) s = assign_particle_values(pts, interpolate_expression, on_root=False) p = particles(pts, [s], mesh) assert np.linalg.norm(np.sum(pts, axis=1) - s) <= 1e-15 assert np.linalg.norm(pts - p.positions()) <= 1e-15
def test_l2_projection_3D(polynomial_order, in_expression): xmin, ymin, zmin = 0.0, 0.0, 0.0 xmax, ymax, zmax = 1.0, 1.0, 1.0 nx = 25 property_idx = 1 mesh = BoxMesh(Point(xmin, ymin, zmin), Point(xmax, ymax, zmax), nx, nx, nx) interpolate_expression = Expression(in_expression, degree=3) if len(interpolate_expression.ufl_shape) == 0: V = FunctionSpace(mesh, "DG", polynomial_order) elif len(interpolate_expression.ufl_shape) == 1: V = VectorFunctionSpace(mesh, "DG", polynomial_order) v_exact = Function(V) v_exact.assign(interpolate_expression) x = RandomBox(Point(0.0, 0.0, 0.0), Point(1.0, 1.0, 1.0)).generate([4, 4, 4]) s = assign_particle_values(x, interpolate_expression) # Just make a complicated particle, possibly with scalars and vectors mixed p = particles(x, [s], mesh) # Do AddDelete sweep AD = AddDelete(p, 13, 15, [v_exact]) AD.do_sweep() vh = Function(V) lstsq_vh = l2projection(p, V, property_idx) lstsq_vh.project(vh.cpp_object()) error_sq = abs(assemble(dot(v_exact - vh, v_exact - vh) * dx)) if comm.Get_rank() == 0: assert error_sq < 1e-13
def test_mesh_generator_3d(): """Basic functionality test.""" mesh = BoxMesh(Point(0.0, 0.0, 0.0), Point(1.0, 1.0, 1.0), 5, 5, 5) for x in mesh.coordinates(): x[0] += 0.5 * x[1] + 0.2 * x[2] w = RandomCell(mesh) pts = w.generate(3) assert len(pts) == mesh.num_cells() * 3 interpolate_expression = Expression("x[0] + x[1] + x[2]", degree=1) s = assign_particle_values(pts, interpolate_expression, on_root=False) assert np.linalg.norm(np.sum(pts, axis=1) - s) <= 1e-15 p = particles(pts, [s], mesh) assert pts.shape == p.positions().shape for i in range(10000): s, t, u, v = w._random_bary(4) assert s >= 0 and s <= 1 assert t >= 0 and t <= 1 assert u >= 0 and u <= 1 assert v >= 0 and v <= 1
print('Initializing function spaces') strain_mesh, temp_mesh, epsII_mesh = Function(Vdg), Function(Vdg), Function( Vdg) # Initial conditions for strain and temp strain_fun = Expression("0.0", degree=1) temp_fun = temp_init(Ts, Tb, surf_fun, bed_fun, degree=1) # Create functions defined on mesh with initial values strain_mesh.assign(strain_init) temp_mesh.assign(interpolate(temp_fun, Vdg)) epsII_mesh.assign(strain_init) # Particle values at nodes pstrain = assign_particle_values(xp, strain_fun) pepsII = assign_particle_values(xp, strain_fun) ptemp = assign_particle_values(xp, temp_fun) print('Done initializing function spaces') # Now we initialize the particle class print('Creating particles') p = particles(xp, [pstrain, ptemp, pepsII], mesh.mesh) print('Done particles') # Make sure we have enough particles per cell #AD = AddDelete(p, p_min, p_max, [strain_mesh, temp_mesh,epsII_mesh]) # Sweep over mesh to delete/insert particles #AD.do_sweep() (xp, pstrain, ptemp, pepsII) = (p.return_property(mesh, 0), p.return_property(mesh, 1),
u_expr = Expression((ux+'*'+gt_min, vy+'*'+gt_min), degree=2, t=0.) u_expre_neg = Expression((ux+'*'+gt_plus, vy+'*'+gt_plus), degree=2, t=0.) # Mesh velocity umesh = Function(Vcg) # Advective velocity uh = Function(V) uh.assign(u_expr) # Total velocity uadvect = uh - umesh # Now throw in the particles x = RandomRectangle(Point(xmin, ymin), Point(xmax, ymax)).generate([pres, pres]) s = assign_particle_values(x, CosineHill(radius=0.25, center=[0.25, 0.5], amplitude=1.0, degree=1)) p = particles(x, [s], mesh) # Define projections problem FuncSpace_adv = {'FuncSpace_local': Q_Rho, 'FuncSpace_lambda': T_1, 'FuncSpace_bar': Qbar} FormsPDE = FormsPDEMap(mesh, FuncSpace_adv, beta_map=Constant(1e-8)) forms_pde = FormsPDE.forms_theta_linear(phih0, uadvect, dt, Constant(1.0), zeta=Constant(0.), h=Constant(0.)) pde_projection = PDEStaticCondensation(mesh, p, forms_pde['N_a'], forms_pde['G_a'], forms_pde['L_a'], forms_pde['H_a'], forms_pde['B_a'], forms_pde['Q_a'], forms_pde['R_a'], forms_pde['S_a'], [], 1) ap = advect_rk3(p, V, uh, 'open')
ubar0_a = Function(Wbar_2_H12) Udiv = Function(W_2) Uh = Function(mixedL) Uhbar = Function(mixedG) U0 = Function(mixedL) Uhbar0 = Function(mixedG) # Set initial density field initial_density = BinaryBlock(geometry, float(rho1), float(rho2), degree=1) zero_expression = Expression(("0.", "0."), degree=1) # Initialize particles x = RandomRectangle(Point(xmin, ymin), Point(xmax, ymax)).generate( [pres, int(pres * (ymax - ymin) / (xmax - xmin))]) up = assign_particle_values(x, zero_expression) rhop = assign_particle_values(x, initial_density) # Increment requires dup to be stored, init zero dup = up p = particles(x, [rhop, up, dup], mesh) # Init rho0 field lstsq_rho = l2projection(p, Q_Rho, 1) lstsq_rho.project(rho0, float(rho2), float(rho1)) # Initialize l2 projection for specific momentum lstsq_u = l2projection(p, W_2, 2) # Initialize advection class
depth=0., degree=3, lb=lb, ub=ub) # Function space and velocity field W = FunctionSpace(mesh, 'DG', k) psi_h = Function(W) V = VectorFunctionSpace(mesh, 'DG', 3) uh = Function(V) uh.assign(Expression(('-Uh*x[1]', 'Uh*x[0]'), Uh=Uh, degree=3)) # Generate particles x = RandomCircle(Point(x0, y0), r).generate([pres, pres]) s = assign_particle_values(x, psi0_expr) p = particles(x, [s], mesh) # Initialize advection class, use RK3 scheme ap = advect_rk3(p, V, uh, 'closed') # Init projection lstsq_psi = l2projection(p, W, 1) # Do projection to get initial field lstsq_psi.project(psi_h.cpp_object(), lb, ub) AD = AddDelete(p, 10, 20, [psi_h], [1], [lb, ub]) step = 0 t = 0. area_0 = assemble(psi_h * dx) timer = Timer()
ubar0_a = Function(Wbar_2_H12) ubar_a = Function(Wbar_2) Udiv = Function(W_2) U0, Uh = Function(mixedL), Function(mixedL) Uhbar = Function(mixedG) u0_a.assign(u_exact) ubar0_a.assign(u_exact) Udiv.assign(u_exact) # Initialize particles x = RandomRectangle(Point(xmin, ymin), Point(xmax, ymax)).generate([pres, pres]) s = assign_particle_values(x, u_exact) lims = np.array([ [xmin, xmin, ymin, ymax], [xmax, xmax, ymin, ymax], [xmin, xmax, ymin, ymin], [xmin, xmax, ymax, ymax], ]) # Particle specific momentum is stored at slot 1 # the second slot will be to store old velocities at particle level property_idx = 1 p = particles(x, [s, s], mesh) ap = advect_rk3(p, W_2, Udiv, "periodic", lims.flatten()) # Particle management