def test_export_xdmf(): mesh = fenics.UnitSquareMesh(3, 3) V = fenics.FunctionSpace(mesh, 'P', 1) folder = "Solution" exports = { "xdmf": { "functions": ['solute', 'retention'], "labels": ['a', 'b'], "folder": folder } } files = [fenics.XDMFFile(folder + "/" + "a.xdmf"), fenics.XDMFFile(folder + "/" + "b.xdmf")] assert FESTIM.export_xdmf( [fenics.Function(V), fenics.Function(V)], exports, files, 20) is None exports["xdmf"]["functions"] = ['solute', 'blabla'] with pytest.raises(KeyError, match=r'blabla'): FESTIM.export_xdmf( [fenics.Function(V), fenics.Function(V)], exports, files, 20) exports["xdmf"]["functions"] = ['solute', '13'] with pytest.raises(KeyError, match=r'13'): FESTIM.export_xdmf( [fenics.Function(V), fenics.Function(V)], exports, files, 20)
def construct_mesh_and_observation_coordinates(mesh_type, mesh_resolution, obs_resolution): if mesh_type == "square": mesh = fenics.UnitSquareMesh(mesh_resolution, mesh_resolution) observation_coordinates = np.stack( np.meshgrid( np.linspace(0, 1, 2 * obs_resolution + 1)[1:-1:2], np.linspace(0, 1, 2 * obs_resolution + 1)[1:-1:2], ), -1, ).reshape((-1, 2)) elif mesh_type == "circle": mesh = fenics.UnitDiscMesh.create(fenics.MPI.comm_world, mesh_resolution, 1, 2) observation_coordinates = [] for i, radius in enumerate(np.linspace(0, 1, obs_resolution, False)): angles = np.linspace(0, 2 * np.pi, max(1, i * obs_resolution), False) observation_coordinates.append( np.stack([np.sin(angles) * radius, np.cos(angles) * radius], -1)) observation_coordinates = np.concatenate(observation_coordinates, 0) else: raise ValueError(f"Unknown mesh type {mesh_type}") return mesh, observation_coordinates
def create_simple_mesh(self): #domain = mesher.Circle(fe.Point(0,0), 1) #mesh = mesher.generate_mesh(domain, 64) ''' domain_vertices = [\ fe.Point(0.0, 0.0),\ fe.Point(10.0, 0.0),\ fe.Point(10.0, 2.0),\ fe.Point(8.0, 2.0),\ fe.Point(7.5, 1.0),\ fe.Point(2.5, 1.0),\ fe.Point(2.0, 4.0),\ fe.Point(0.0, 4.0),\ fe.Point(0.0, 0.0)] geo = mesher.Polygon(domain_vertices) self.mesh = mesher.generate_mesh(geo, 64); ''' print('Creating simple mesh') nx = ny = 8 if self.dimension == 1: self.mesh = fe.UnitIntervalMesh(nx) #self.mesh = fe.IntervalMesh(nx,-4, 4) if self.dimension == 2: self.mesh = fe.UnitSquareMesh(nx, ny) '''
def __init__(self, K): # Variables x, y = sym.symbols('x[0], x[1]', real=True, positive=True) f = sym.Function('f')(x, y) grid = np.linspace(0, 1, K + 2)[1:-1] x_obs, y_obs = np.meshgrid(grid, grid) self.x_obs, self.y_obs = x_obs.reshape(K * K), y_obs.reshape(K * K) # --- THIS PART USED TO NOT BE PARALELLIZABLE --- # # Create mesh and define function space n_mesh = 80 self.mesh = fen.UnitSquareMesh(n_mesh, n_mesh) self.f_space = fen.FunctionSpace(self.mesh, 'P', 2) # Define boundary condition # u_boundary = fen.Expression('x[0] + x[1]', degree=2) u_boundary = fen.Expression('0', degree=2) self.bound_cond = fen.DirichletBC(self.f_space, u_boundary, lambda x, on_boundary: on_boundary) # Define variational problem self.trial_f = fen.TrialFunction(self.f_space) self.test_f = fen.TestFunction(self.f_space) rhs = fen.Constant(50) self.lin_func = rhs * self.test_f * fen.dx
def create_simple_mesh(self): print('Creating simple mesh') nx = ny = self.mesh_density if self.dimension == 1: self.mesh = fe.IntervalMesh(nx, self.x_left, self.x_right) if self.dimension == 2: self.mesh = fe.UnitSquareMesh(nx, ny)
def calTrueSol(para): nx, ny = para['mesh_N'][0], para['mesh_N'][1] mesh = fe.UnitSquareMesh(nx, ny) Vu = fe.FunctionSpace(mesh, 'P', para['P']) Vc = fe.FunctionSpace(mesh, 'P', para['P']) al = fe.Constant(para['alpha']) f = fe.Expression(para['f'], degree=5) q1 = fe.interpolate(fe.Expression(para['q1'], degree=5), Vc) q2 = fe.interpolate(fe.Expression(para['q2'], degree=5), Vc) q3 = fe.interpolate(fe.Expression(para['q3'], degree=5), Vc) theta = fe.interpolate(fe.Expression(para['q4'], degree=5), Vc) class BoundaryX0(fe.SubDomain): def inside(self, x, on_boundary): return on_boundary and fe.near(x[0], 0.0) class BoundaryX1(fe.SubDomain): def inside(self, x, on_boundary): return on_boundary and fe.near(x[0], 1.0) class BoundaryY0(fe.SubDomain): def inside(self, x, on_boundary): return on_boundary and fe.near(x[1], 0.0) class BoundaryY1(fe.SubDomain): def inside(self, x, on_boundary): return on_boundary and fe.near(x[1], 1.0) boundaries = fe.MeshFunction('size_t', mesh, mesh.topology().dim() - 1) boundaries.set_all(0) bc0, bc1, bc2, bc3 = BoundaryX0(), BoundaryX1(), BoundaryY0(), BoundaryY1() bc0.mark(boundaries, 1) bc1.mark(boundaries, 2) bc2.mark(boundaries, 3) bc3.mark(boundaries, 4) domains = fe.MeshFunction("size_t", mesh, mesh.topology().dim()) domains.set_all(0) bcD = fe.DirichletBC(Vu, theta, boundaries, 4) dx = fe.Measure('dx', domain=mesh, subdomain_data=domains) ds = fe.Measure('ds', domain=mesh, subdomain_data=boundaries) u_trial, u_test = fe.TrialFunction(Vu), fe.TestFunction(Vu) u = fe.Function(Vu) left = fe.inner(al * fe.nabla_grad(u_trial), fe.nabla_grad(u_test)) * dx right = f * u_test * dx + (q1 * u_test * ds(1) + q2 * u_test * ds(2) + q3 * u_test * ds(3)) left_m, right_m = fe.assemble_system(left, right, bcD) fe.solve(left_m, u.vector(), right_m) return u
def __init__(self, para): # para = [nx, ny, FunctionSpace, degree, ...] self.nx, self.ny = para['mesh_N'][0], para['mesh_N'][1] self.mesh = fe.UnitSquareMesh(self.nx, self.ny) self.Vu = fe.FunctionSpace(self.mesh, 'P', para['P']) self.Vc = fe.FunctionSpace(self.mesh, 'P', para['P']) self.sol = [] self.al = fe.Constant(1.0) self.f = fe.Constant(0.0) self.q = fe.Constant(0.0) self.theta = [] self.mE = 0
def __init__(self, para): self.nx, self.ny = para['mesh_N'][0], para['mesh_N'][1] self.mesh = fe.UnitSquareMesh(self.nx, self.ny) self.Vu = fe.FunctionSpace(self.mesh, 'P', para['P']) self.Vc = fe.FunctionSpace(self.mesh, 'P', para['P']) self.al = fe.Expression(para['alpha'], degree=5) self.q1 = fe.interpolate(fe.Expression(para['q1'], degree=5), self.Vc) self.q2 = fe.interpolate(fe.Expression(para['q2'], degree=5), self.Vc) self.q3 = fe.interpolate(fe.Expression(para['q3'], degree=5), self.Vc) self.f = fe.Expression(para['f'], degree=5) self.theta = fe.Constant(0.0) self.u = fe.Function(self.Vu)
def mesh_gen_default(self, intervals, typ='P', order=1): """ creates a square with sides of 1, divided by intervals by default the type of the volume associated with the mesh is considered to be Lagrangian, with order 1. """ self._mesh = FEN.UnitSquareMesh(intervals, intervals) self.input['mesh'] = self._mesh self._V = FEN.FunctionSpace(self._mesh, typ, order) self.input['V'] = self._V self._u = FEN.TrialFunction(self._V) self._v = FEN.TestFunction(self._V)
def test_input_data_read_and_interp(temp_model, monkeypatch): """Test the reading & interpolation of input data into InputData object""" work_dir = temp_model["work_dir"] toml_file = temp_model["toml_filename"] # Switch to the working directory monkeypatch.chdir(work_dir) params = test_parse_config(temp_model) dd = params.io.input_dir data_file = params.io.data_file # Load the mesh & input data inmesh = fice.mesh.get_mesh(params) indata = inout.InputData(params) # Create a function space for interpolation test_space = fe.FunctionSpace(inmesh, 'Lagrange', 1) # Check successfully reads bed & data_mask bed_interp = indata.interpolate("bed", test_space).vector()[:] # Check the actual value of an interpolated field: # TODO - this is a little ad hoc, can it be incorporated into test definition? if "ismip" in toml_file: # test_x = np.hsplit(test_space.tabulate_dof_coordinates(), 2)[0][:,0] test_y = np.hsplit(test_space.tabulate_dof_coordinates(), 2)[1][:, 0] test_bed = 1e4 - test_y * np.tan(0.1 * np.pi / 180.0) - 1e3 elif "ice_stream" in toml_file: test_x = np.hsplit(test_space.tabulate_dof_coordinates(), 2)[0][:, 0] test_bed = -500.0 - (test_x / 500.0) else: raise Exception("Unrecognised test setup") assert np.linalg.norm(test_bed - bed_interp) < 1e-10 # Check unfound data raises error... with pytest.raises(KeyError): indata.interpolate("a_madeup_name", test_space) # ...unless a default is supplied outfun = indata.interpolate("a_madeup_name", test_space, default=1.0) assert np.all(outfun.vector()[:] == 1.0) # Check that an out-of-bounds mesh returns an error bad_mesh = fe.UnitSquareMesh(2, 2) fe.MeshTransformation.translate(bad_mesh, fe.Point(-1e10, -1e10)) bad_space = fe.FunctionSpace(bad_mesh, 'Lagrange', 1) with pytest.raises(ValueError): indata.interpolate("bed", bad_space)
def __init__(self, N, K): # Variables x, y = sym.symbols('x[0], x[1]', real=True, positive=True) f = sym.Function('f')(x, y) # Precision (inverse covariance) operator, when α = 1 tau, alpha = 3, 2 precision = (-sym.diff(f, x, x) - sym.diff(f, y, y) + tau**2 * f) indices = [(m, n) for m in range(0, N) for n in range(0, N)] # indices = indices[:-1] self.indices = sorted(indices, key=max) eig_f = [ sym.cos(i[0] * sym.pi * x) * sym.cos(i[1] * sym.pi * y) for i in self.indices ] # Eigenvalues of the covariance operator self.eig_v = [ 1 / (precision.subs(f, e).doit() / e).simplify()**alpha for e in eig_f ] grid = np.linspace(0, 1, K + 2)[1:-1] x_obs, y_obs = np.meshgrid(grid, grid) self.x_obs, self.y_obs = x_obs.reshape(K * K), y_obs.reshape(K * K) # Basis_functions self.functions = [ f * np.sqrt(float(v)) for f, v in zip(eig_f, self.eig_v) ] # --- THIS PART USED TO NOT BE PARALELLIZABLE --- # # Create mesh and define function space n_mesh = 80 mesh = fen.UnitSquareMesh(n_mesh, n_mesh) self.f_space = fen.FunctionSpace(mesh, 'P', 2) # Define boundary condition # u_boundary = fen.Expression('x[0] + x[1]', degree=2) u_boundary = fen.Expression('0', degree=2) self.bound_cond = fen.DirichletBC(self.f_space, u_boundary, lambda x, on_boundary: on_boundary) # Define variational problem self.trial_f = fen.TrialFunction(self.f_space) self.test_f = fen.TestFunction(self.f_space) rhs = fen.Constant(50) # rhs = fen.Expression('sin(x[0])*sin(x[1])', degree=2) self.lin_func = rhs * self.test_f * fen.dx
def solve_poisson_with_fem(lightweight=False): # Create mesh and define function space mesh = fs.UnitSquareMesh(8, 8) V = fs.FunctionSpace(mesh, 'P', 1) # Define boundary condition u_code = 'x[0] + 2*x[1] + 1' u_D = fs.Expression(u_code, degree=2) def boundary(x, on_boundary): return on_boundary bc = fs.DirichletBC(V, u_D, boundary) # Define variational problem u = fs.Function(V) # Note: not TrialFunction! v = fs.TestFunction(V) # f = fs.Expression(f_code, degree=2) f_code = '-10*x[0] - 20*x[1] - 10' f = fs.Expression(f_code, degree=2) F = q(u) * fs.dot(fs.grad(u), fs.grad(v)) * fs.dx - f * v * fs.dx # Compute solution fs.solve(F == 0, u, bc) # Plot solution fs.plot(u) # Compute maximum error at vertices. This computation illustrates # an alternative to using compute_vertex_values as in poisson.py. u_e = fs.interpolate(u_D, V) # Restore numpy object image1d = np.empty((81, ), dtype=np.float) for v in fs.vertices(mesh): image1d[v.index()] = u(*mesh.coordinates()[v.index()]) if not lightweight: error_max = np.abs(u_e.vector().get_local() - u.vector().get_local()).max() print('error_max = ', error_max) fs.plot(u) plt.show() save_contour(image1d, 1.0, 1.0, 'poisson') return image1d
def test_ghia1982_steady_lid_driven_cavity(): lid = "near(x[1], 1.)" fixed_walls = "near(x[0], 0.) | near(x[0], 1.) | near(x[1], 0.)" bottom_left_corner = "near(x[0], 0.) && near(x[1], 0.)" m = 20 w, mesh = phaseflow.run( mesh=fenics.UnitSquareMesh(fenics.dolfin.mpi_comm_world(), m, m, 'crossed'), end_time=1.e12, time_step_size=1.e12, nlp_relative_tolerance=1.e-4, liquid_viscosity=0.01, gravity=(0., 0.), stefan_number=1.e16, output_dir='output/test_ghia1982_steady_lid_driven_cavity', initial_values_expression=(lid, "0.", "0.", "1."), boundary_conditions=[{ 'subspace': 0, 'value_expression': ("1.", "0."), 'degree': 3, 'location_expression': lid, 'method': 'topological' }, { 'subspace': 0, 'value_expression': ("0.", "0."), 'degree': 3, 'location_expression': fixed_walls, 'method': 'topological' }, { 'subspace': 1, 'value_expression': "0.", 'degree': 2, 'location_expression': bottom_left_corner, 'method': 'pointwise' }, { 'subspace': 2, 'value_expression': "1.", 'degree': 2, 'location_expression': bottom_left_corner, 'method': 'pointwise' }]) verify_against_ghia1982(w, mesh)
def __init__(self, h, eps, dim): """ Initializing poisson solver :param h: mesh size (of unit interval discretisation) :param eps: small parameter :param dim: dimension (in {1,2,3}) """ self.h = h self.n = int(1 / h) self.eps = eps self.dim = dim self.mesh = fe.UnitIntervalMesh(self.n) a_eps = '1./(2+cos(2*pi*x[0]/eps))' self.e_is = [fe.Constant(1.)] if self.dim == 2: self.mesh = fe.UnitSquareMesh(self.n, self.n) a_eps = '1./(2+cos(2*pi*(x[0]+2*x[1])/eps))' self.e_is = [fe.Constant((1., 0.)), fe.Constant((0., 1.))] elif self.dim == 3: self.mesh = fe.UnitCubeMesh(self.n, self.n, self.n) a_eps = '1./(2+cos(2*pi*(x[0]+3*x[1]+6*x[2])/eps))' self.e_is = [ fe.Constant((1., 0., 0.)), fe.Constant((0., 1., 0.)), fe.Constant((0., 0., 1.)) ] else: self.dim = 1 print("Solving rapid varying Poisson problem in R^%d" % self.dim) self.diff_coef = fe.Expression(a_eps, eps=self.eps, degree=2, domain=self.mesh) self.a_y = fe.Expression(a_eps.replace("/eps", ""), degree=2, domain=self.mesh) self.function_space = fe.FunctionSpace(self.mesh, 'P', 2) self.solution = fe.Function(self.function_space) self.cell_solutions = [ fe.Function(self.function_space) for _ in range(self.dim) ] self.eff_diff = np.zeros((self.dim, self.dim)) # Define boundary condition self.bc_function = fe.Constant(0.0) self.f = fe.Constant(1)
def _setup(self, **kwargs): if not self._custom_params_set_flag: raise RuntimeError for key in kwargs: if key not in self.params: raise KeyError if kwargs: raise RuntimeError def gp(key): value = kwargs.get(key, None) if value is None: value = self.params[key] if value is None: raise ValueError return value dtype, device = fetch_dtype_device(gp('dtype'), gp('device')) nx_fom = gp('nx_rom') * (2**gp('num_refines')) ny_fom = gp('ny_rom') * (2**gp('num_refines')) mesh_rom = df.UnitSquareMesh(df.MPI.comm_self, gp('nx_rom'), gp('ny_rom')) mesh_fom = refine(mesh_rom, gp('num_refines')) ########## Physics ######### physics = dict() physics['fom'] = LinearEllipticPhysics('fom', gp('ptype'), mesh_fom) physics['rom'] = LinearEllipticPhysics('rom', gp('ptype'), mesh_rom) dh = PhysicsResolutionInterpolator(physics, dtype=torch.double) physics['W'] = dh._W.detach().cpu().numpy().T.copy() return physics, gp, ny_fom, nx_fom, dtype, device
"""CS tutorial demo program: Poisson equation with Dirichlet conditions. Test problem is chosen to give an exact solution at all nodes of the mesh. -Laplace(u) = f in the unit square u = u_D on the boundary u_D = 1 + x^2 + 2y^2 f = -6 """ from __future__ import print_function import fenics as fex import matplotlib.pyplot as plt # Create mesh and define function space mesh = fex.UnitSquareMesh(8, 8) V = fex.FunctionSpace(mesh, 'P', 1) # Define boundary condition u_D = fex.Expression('1 + x[0]*x[0] + 2*x[1]*x[1]', degree=2) def boundary(x, on_boundary): return on_boundary bc = fex.DirichletBC(V, u_D, boundary) # Define variational problem u = fex.TrialFunction(V) v = fex.TestFunction(V) f = fex.Constant(-6.0) a = fex.dot(fex.grad(u), fex.grad(v)) * fex.dx
def melt_toy_pcm(output_dir="output/test_melt_toy_pcm/", restart=False, restart_filepath='', start_time=0.): # Make the mesh. initial_mesh_size = 1 mesh = fenics.UnitSquareMesh(initial_mesh_size, initial_mesh_size, 'crossed') initial_hot_wall_refinement_cycles = 6 class HotWall(fenics.SubDomain): def inside(self, x, on_boundary): return on_boundary and fenics.near(x[0], 0.) hot_wall = HotWall() for i in range(initial_hot_wall_refinement_cycles): edge_markers = fenics.EdgeFunction("bool", mesh) hot_wall.mark(edge_markers, True) fenics.adapt(mesh, edge_markers) mesh = mesh.child() # Run phaseflow. T_hot = 1. T_cold = -0.1 w, mesh = phaseflow.run( stefan_number=1., rayleigh_number=1.e6, prandtl_number=0.71, solid_viscosity=1.e4, liquid_viscosity=1., mesh=mesh, time_step_size=1.e-3, start_time=start_time, end_time=0.02, stop_when_steady=True, temperature_of_fusion=T_f, regularization_smoothing_factor=0.025, adaptive=True, adaptive_metric='phase_only', adaptive_solver_tolerance=1.e-4, nlp_relative_tolerance=1.e-8, initial_values_expression=("0.", "0.", "0.", "(" + str(T_hot) + " - " + str(T_cold) + ")*(x[0] < 0.001) + " + str(T_cold)), boundary_conditions=[{ 'subspace': 0, 'value_expression': ("0.", "0."), 'degree': 3, 'location_expression': "near(x[0], 0.) | near(x[0], 1.) | near(x[1], 0.) | near(x[1], 1.)", 'method': "topological" }, { 'subspace': 2, 'value_expression': str(T_hot), 'degree': 2, 'location_expression': "near(x[0], 0.)", 'method': "topological" }, { 'subspace': 2, 'value_expression': str(T_cold), 'degree': 2, 'location_expression': "near(x[0], 1.)", 'method': "topological" }], output_dir=output_dir, restart=restart, restart_filepath=restart_filepath) return w
def solve_heat_with_fem(lightweight=False): T = 2.0 # final time num_steps = 100 # number of time steps dt = T / num_steps # time step size alpha = 3 # parameter alpha beta = 1.2 # parameter beta # Create mesh and define function space nx = ny = 8 mesh = fs.UnitSquareMesh(nx, ny) V = fs.FunctionSpace(mesh, 'P', 1) # Define boundary condition u_D = fs.Expression('1 + x[0]*x[0] + alpha*x[1]*x[1] + beta*t', degree=2, alpha=alpha, beta=beta, t=0) bc = fs.DirichletBC(V, u_D, boundary) # Define initial value u_n = fs.interpolate(u_D, V) # u_n = project(u_D, V) # Define variational problem u = fs.TrialFunction(V) v = fs.TestFunction(V) f = fs.Constant(beta - 2 - 2 * alpha) F = u * v * fs.dx + dt * fs.dot( fs.grad(u), fs.grad(v)) * fs.dx - (u_n + dt * f) * v * fs.dx a, L = fs.lhs(F), fs.rhs(F) # Time-stepping u = fs.Function(V) t = 0 images1d = [] for n in range(num_steps): # Update current time t += dt u_D.t = t # Compute solution fs.solve(a == L, u, bc) # Restore numpy object image1d = np.empty((81, ), dtype=np.float) for v in fs.vertices(mesh): image1d[v.index()] = u(*mesh.coordinates()[v.index()]) images1d.append(image1d) if not lightweight: # Compute error at vertices u_e = fs.interpolate(u_D, V) error = np.abs(u_e.vector().get_local() - u.vector().get_local()).max() print('t = %.2f: error = %.3g' % (t, error)) # Update previous solution u_n.assign(u) # Plotting if not lightweight: fs.plot(u) plt.show() save_dynamic_contours(images1d, 1.0, 1.0, 'heat2d') return images1d
def natural_convection_water( restart=False, restart_filepath='', output_dir='output/test_natural_convection_water/', start_time=0., end_time=10., time_step_size=0.001): m = 40 Ra = 2.518084e6 Pr = 6.99 T_h = 10. # [deg C] T_c = 0. # [deg C] theta_hot = 1. theta_cold = 0. T_f = T_fusion = 0. # [deg C] T_ref = T_fusion theta_f = theta_fusion = T_fusion - T_ref T_m = 4.0293 # [deg C] rho_m = 999.972 # [kg/m^3] w = 9.2793e-6 # [(deg C)^(-q)] q = 1.894816 def rho(theta): return rho_m * (1. - w * abs((T_h - T_c) * theta + T_ref - T_m)**q) def ddtheta_rho(theta): return -q*rho_m*w*abs(T_m - T_ref + theta*(T_c - T_h))**(q - 1.)* \ fenics.sign(T_m - T_ref + theta*(T_c - T_h))*(T_c - T_h) beta = 6.91e-5 # [K^-1] def m_B(T, Ra, Pr, Re): return Ra / (Pr * Re * Re) / (beta * (T_h - T_c)) * (rho(theta_f) - rho(T)) / rho(theta_f) def ddT_m_B(T, Ra, Pr, Re): return -Ra / (Pr * Re * Re) / (beta * (T_h - T_c)) * (ddtheta_rho(T)) / rho(theta_f) w, mesh = phaseflow.run( rayleigh_number=Ra, prandtl_number=Pr, stefan_number=1.e16, temperature_of_fusion=-1., regularization_smoothing_factor=0.1, nlp_relative_tolerance=1.e-8, adaptive=False, m_B=m_B, ddT_m_B=ddT_m_B, mesh=fenics.UnitSquareMesh(m, m, 'crossed'), stop_when_steady=True, steady_relative_tolerance=1.e-5, initial_values_expression=("0.", "0.", "0.", str(theta_hot) + "*near(x[0], 0.) + " + str(theta_cold) + "*near(x[0], 1.)"), boundary_conditions=[{ 'subspace': 0, 'value_expression': ("0.", "0."), 'degree': 3, 'location_expression': "near(x[0], 0.) | near(x[0], 1.) | near(x[1], 0.) | near(x[1], 1.)", 'method': "topological" }, { 'subspace': 2, 'value_expression': str(theta_hot), 'degree': 2, 'location_expression': "near(x[0], 0.)", 'method': "topological" }, { 'subspace': 2, 'value_expression': str(theta_cold), 'degree': 2, 'location_expression': "near(x[0], 1.)", 'method': "topological" }], time_step_size=time_step_size, start_time=start_time, end_time=end_time, output_dir="output/test_natural_convection_water") return w, mesh
inds_of_points_in_mesh = [] for k in range(N): pk = fenics.Point(points_pp[k, :]) if me.bbt.compute_collisions(pk): inds_of_points_in_mesh.append(k) ff = np.zeros(N) for k in inds_of_points_in_mesh: pk = fenics.Point(points_pp[k, :]) ff[k] = me.f(pk) return ff if run_test: mesh = fenics.UnitSquareMesh(10, 10) V = fenics.FunctionSpace(mesh, 'CG', 2) V_evaluator = FenicsFunctionExtendByZeroEvaluator(V) u = fenics.Function(V) u.vector()[:] = np.random.randn(V.dim()) p = np.array([0.5, 0.5]) up_true = u(fenics.Point(p)) up = V_evaluator(u.vector()[:], p) err_V_evaluator_single = np.abs(up - up_true) / np.abs(up_true) print('err_V_evaluator_single=', err_V_evaluator_single) N = 1000 pp = 3 * np.random.rand(N, 2) - 1.0 # random points in [-1, 2]^2
import fenics as fn import fenics_adjoint as fa import ufl from jaxfenics_adjoint import build_jax_fem_eval from jaxfenics_adjoint import from_numpy import matplotlib.pyplot as plt config.update("jax_enable_x64", True) fn.set_log_level(fn.LogLevel.ERROR) # Create mesh, refined in the center n = 64 mesh = fn.UnitSquareMesh(n, n) cf = fn.MeshFunction("bool", mesh, mesh.geometry().dim()) subdomain = fn.CompiledSubDomain( "std::abs(x[0]-0.5) < 0.25 && std::abs(x[1]-0.5) < 0.25" ) subdomain.mark(cf, True) mesh = fa.Mesh(fn.refine(mesh, cf)) # Define discrete function spaces and functions V = fn.FunctionSpace(mesh, "CG", 1) W = fn.FunctionSpace(mesh, "DG", 0) solve_templates = (fa.Function(W),) assemble_templates = (fa.Function(V), fa.Function(W))
import fenics import matplotlib N = 4 mesh = fenics.UnitSquareMesh(N, N) P2 = fenics.VectorElement('P', mesh.ufl_cell(), 2) P1 = fenics.FiniteElement('P', mesh.ufl_cell(), 1) P2P1 = fenics.MixedElement([P2, P1]) W = fenics.FunctionSpace(mesh, P2P1) psi_u, psi_p = fenics.TestFunctions(W) w = fenics.Function(W) u, p = fenics.split(w) dynamic_viscosity = 0.01 mu = fenics.Constant(dynamic_viscosity) inner, dot, grad, div, sym = fenics.inner, fenics.dot, fenics.grad, fenics.div, fenics.sym momentum = dot(psi_u, dot(grad(u), u)) - div(psi_u) * p + 2. * mu * inner( sym(grad(psi_u)), sym(grad(u))) mass = -psi_p * div(u)
import fenics as fn # set parameters fn.parameters["form_compiler"]["representation"] = "uflacs" fn.parameters["form_compiler"]["cpp_optimize"] = True # mesh setup nps = 64 # number of points mesh = fn.UnitSquareMesh(nps, nps) fileu = fn.File(mesh.mpi_comm(), "Output/1_3_Schnackenberg/u.pvd") filev = fn.File(mesh.mpi_comm(), "Output/1_3_Schnackenberg/v.pvd") # function spaces P1 = fn.FiniteElement("Lagrange", mesh.ufl_cell(), 1) Mh = fn.FunctionSpace(mesh, "Lagrange", 1) Nh = fn.FunctionSpace(mesh, fn.MixedElement([P1, P1])) Sol = fn.Function(Nh) # trial and test functions u, v = fn.TrialFunctions(Nh) uT, vT = fn.TestFunctions(Nh) # model constants a = fn.Constant(0.1305) b = fn.Constant(0.7695) c1 = fn.Constant(0.05) c2 = fn.Constant(1.0) d = fn.Constant(170.0) # initial value uinit = fn.Expression('a + b + 0.001 * exp(-100.0 * (pow(x[0] - 1.0/3, 2)' + ' + pow(x[1] - 0.5, 2)))',
def square(self, nx, ny): return FEN.UnitSquareMesh(nx, ny)
def xest_first_tutorial(self): T = 2.0 # final time num_steps = 10 # number of time steps dt = T / num_steps # time step size alpha = 3 # parameter alpha beta = 1.2 # parameter beta # Create mesh and define function space nx = ny = 8 mesh = fenics.UnitSquareMesh(nx, ny) V = fenics.FunctionSpace(mesh, 'P', 1) # Define boundary condition u_D = fenics.Expression('1 + x[0]*x[0] + alpha*x[1]*x[1] + beta*t', degree=2, alpha=alpha, beta=beta, t=0) def boundary(x, on_boundary): return on_boundary bc = fenics.DirichletBC(V, u_D, boundary) # Define initial value u_n = fenics.interpolate(u_D, V) #u_n = project(u_D, V) # Define variational problem u = fenics.TrialFunction(V) v = fenics.TestFunction(V) f = fenics.Constant(beta - 2 - 2 * alpha) F = u * v * fenics.dx + dt * fenics.dot(fenics.grad(u), fenics.grad( v)) * fenics.dx - (u_n + dt * f) * v * fenics.dx a, L = fenics.lhs(F), fenics.rhs(F) # Time-stepping u = fenics.Function(V) t = 0 vtkfile = fenics.File( os.path.join(os.path.dirname(__file__), 'output', 'heat_constructed_solution', 'solution.pvd')) not_initialised = True for n in range(num_steps): # Update current time t += dt u_D.t = t # Compute solution fenics.solve(a == L, u, bc) # Plot the solution vtkfile << (u, t) fenics.plot(u) if not_initialised: animation_camera = celluloid.Camera(plt.gcf()) not_initialised = False animation_camera.snap() # Compute error at vertices u_e = fenics.interpolate(u_D, V) error = np.abs(u_e.vector().get_local() - u.vector().get_local()).max() print('t = %.2f: error = %.3g' % (t, error)) # Update previous solution u_n.assign(u) # Hold plot animation = animation_camera.animate() animation.save( os.path.join(os.path.dirname(__file__), 'output', 'heat_equation.mp4'))
# You should have received a copy of the GNU General Public License # along with CASHOCS. If not, see <https://www.gnu.org/licenses/>. """Tests for the geometry module. """ import os import fenics import numpy as np import cashocs from cashocs.geometry import MeshQuality c_mesh, _, _, _, _, _ = cashocs.regular_mesh(5) u_mesh = fenics.UnitSquareMesh(5, 5) def test_mesh_import(): os.system('cashocs-convert ./mesh/mesh.msh ./mesh/mesh.xdmf') mesh, subdomains, boundaries, dx, ds, dS = cashocs.import_mesh( './mesh/mesh.xdmf') gmsh_coords = np.array([[0, 0], [1, 0], [1, 1], [0, 1], [0.499999999998694, 0], [1, 0.499999999998694], [0.5000000000020591, 1], [0, 0.5000000000020591], [0.2500000000010297, 0.7500000000010296], [0.3749999970924328, 0.3750000029075671], [0.7187499979760099, 0.2812500030636815], [0.6542968741702071, 0.6542968818888233]])
from pytest_check import check import fdm import jax from jax.config import config import jax.numpy as np import fenics import ufl from jaxfenics import build_jax_solve_eval_fwd config.update("jax_enable_x64", True) fenics.parameters["std_out_all_processes"] = False fenics.set_log_level(fenics.LogLevel.ERROR) mesh = fenics.UnitSquareMesh(3, 2) V = fenics.FunctionSpace(mesh, "P", 1) def solve_fenics(kappa0, kappa1): f = fenics.Expression( "10*exp(-(pow(x[0] - 0.5, 2) + pow(x[1] - 0.5, 2)) / 0.02)", degree=2) u = fenics.Function(V) bcs = [fenics.DirichletBC(V, fenics.Constant(0.0), "on_boundary")] inner, grad, dx = ufl.inner, ufl.grad, ufl.dx JJ = 0.5 * inner(kappa0 * grad(u), grad(u)) * dx - kappa1 * f * u * dx v = fenics.TestFunction(V) F = fenics.derivative(JJ, u, v)
div(u) = 0 """ import fenics as fs import numpy as np import matplotlib.pyplot as plt # scaled variables T = 10.0 # final time num_steps = 500 # number of time steps dt = T / num_steps # time step size mu = 1 # kinematic viscosity rho = 1 # density # Create mesh and define function spaces SEPARATELY for pressure and velocity spaces. mesh = fs.UnitSquareMesh(16, 16) V = fs.VectorFunctionSpace(mesh, 'P', 2) # velocity space, a vector space Q = fs.FunctionSpace(mesh, 'P', 1) # pressure space, a scalar space # Define trial and test functions u = fs.TrialFunction(V) # in velocity space v = fs.TestFunction(V) p = fs.TrialFunction(Q) # in pressure space q = fs.TestFunction(Q) # Define functions for solutions at previous and current time steps u_n = fs.Function(V) # u^(n) u_ = fs.Function(V) # u^(n+1) p_n = fs.Function(Q) # p^(n) p_ = fs.Function(Q) # p^(n+1)
FEniCS tutorial demo program: Poisson equation with Dirichlet conditions. Test problem is chosen to give an exact solution at all nodes of the mesh. -Laplace(u) = f in the unit square u = u_D on the boundary u_D = 1 + x^2 + 2y^2 f = -6 """ import fenics as fs import numpy as np import matplotlib.pyplot as plt # create mesh and define function space mesh = fs.UnitSquareMesh(8, 8) V = fs.FunctionSpace(mesh, 'P', 1) # define boundary condition u_D = fs.Expression('1 + x[0]*x[0] + 2*x[1]*x[1]', degree=2) def boundary(x, on_boundary): return on_boundary bc = fs.DirichletBC(V, u_D, boundary) # define variational problem u = fs.TrialFunction(V) v = fs.TestFunction(V)
def coarse_mesh(self): return fenics.UnitSquareMesh(4, 4)