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)