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)
import fenics as fe # We load a few fenics objects into the global namespace from fenics import div, grad, curl, inner, dot, inv, tr import numpy as np #import matplotlib.pyplot as plt # some fenics settings fe.parameters['form_compiler']['cpp_optimize'] = True fe.parameters['form_compiler']['optimize'] = True #fe.parameters["form_compiler"]["quadrature_degree"] = 5 # Create mesh and define function space n = 20 mesh = fe.UnitCubeMesh(n, n, n) # Init function spaces element_3 = fe.VectorElement("P", mesh.ufl_cell(), 1) element = fe.FiniteElement("P", mesh.ufl_cell(), 2) # Mixed function space TH = element_3 * element V = fe.FunctionSpace(mesh, TH) # Define Boundaries left = fe.CompiledSubDomain("near(x[0], side) && on_boundary", side=0.0) right = fe.CompiledSubDomain("near(x[0], side) && on_boundary", side=1.0) # Define Dirichlet boundary (x = 0 or x = 1) u_left = fe.Expression(("0.0", "0.0", "0.0"), element=element_3) u_right = fe.Expression(("0.0", "0.0", "0.0"), element=element_3)
def load_mesh(self, fn: str = None): if fn is not None: self.mesh = fe.Mesh(fn) else: self.mesh = fe.UnitCubeMesh(10, 12, 14)
def convert_scipy_csr_matrix_to_fenics_csr_matrix(A_scipy): A_petsc = PETSc.Mat().createAIJ(size=A_scipy.shape, csr=(A_scipy.indptr, A_scipy.indices, A_scipy.array)) A_fenics = fenics.PETScMatrix(A_petsc) return A_fenics if perform_tests: import numpy as np from time import time # Make Laplacian matrix in fenics n = 10 mesh = fenics.UnitCubeMesh(n, n, n) V = fenics.FunctionSpace(mesh, 'CG', 1) u = fenics.TrialFunction(V) v = fenics.TestFunction(V) a = fenics.inner(fenics.grad(u), fenics.grad(v)) * fenics.dx + u * v * fenics.dx f = fenics.Function(V) f.vector()[:] = np.random.randn(V.dim()) b = f * v * fenics.dx b_fenics = fenics.assemble(b) b_numpy = b_fenics[:] A_fenics = fenics.assemble(a)