def _test_reduced_mesh_elliptic_matrix(V, reduced_mesh):
reduced_V = reduced_mesh.get_reduced_function_spaces()
dofs = reduced_mesh.get_dofs_list()
reduced_dofs = reduced_mesh.get_reduced_dofs_list()
u = TrialFunction(V)
v = TestFunction(V)
trial = 1
test = 0
u_N = TrialFunction(reduced_V[trial])
v_N = TestFunction(reduced_V[test])
A = assemble((u.dx(0) * v + u * v) * dx)
A_N = assemble((u_N.dx(0) * v_N + u_N * v_N) * dx)
A_dofs = evaluate_and_vectorize_sparse_matrix_at_dofs(A, dofs)
A_N_reduced_dofs = evaluate_and_vectorize_sparse_matrix_at_dofs(A_N, reduced_dofs)
test_logger.log(DEBUG, "A at dofs:")
test_logger.log(DEBUG, str(A_dofs))
test_logger.log(DEBUG, "A_N at reduced dofs:")
test_logger.log(DEBUG, str(A_N_reduced_dofs))
test_logger.log(DEBUG, "Error:")
test_logger.log(DEBUG, str(A_dofs - A_N_reduced_dofs))
assert isclose(A_dofs, A_N_reduced_dofs).all()
def __init__(self, U_m, mesh):
"""Function spaces and BCs"""
V = VectorFunctionSpace(mesh, 'P', 2)
Q = FunctionSpace(mesh, 'P', 1)
self.mesh = mesh
self.vu, self.vp = TestFunction(V), TestFunction(Q) # for integration
self.u_, self.p_ = Function(V), Function(Q) # for the solution
self.u_1, self.p_1 = Function(V), Function(Q) # for the prev. solution
self.u_k, self.p_k = Function(V), Function(Q) # for the prev. solution
self.u, self.p = TrialFunction(V), TrialFunction(Q) # unknown!
U0_str = "4.*U_m*x[1]*(.41-x[1])/(.41*.41)"
x = [0,
.41 / 2] # evaluate the Expression at the center of the channel
self.U_mean = np.mean(2 / 3 * eval(U0_str))
U0 = Expression((U0_str, "0"), U_m=U_m, degree=2)
bc0 = DirichletBC(V, Constant((0, 0)), cylinderwall)
bc1 = DirichletBC(V, Constant((0, 0)), topandbottom)
bc2 = DirichletBC(V, U0, inlet)
bc3 = DirichletBC(Q, Constant(0), outlet)
self.bcu = [bc0, bc1, bc2]
self.bcp = [bc3]
# ds is needed to compute drag and lift.
ASD1 = AutoSubDomain(topandbottom)
ASD2 = AutoSubDomain(cylinderwall)
mf = MeshFunction("size_t", mesh, 1)
mf.set_all(0)
ASD1.mark(mf, 1)
ASD2.mark(mf, 2)
self.ds_ = ds(subdomain_data=mf, domain=mesh)
return
def _test_reduced_mesh_collapsed_matrix(V, U, reduced_mesh):
reduced_V = reduced_mesh.get_reduced_function_spaces()
dofs = reduced_mesh.get_dofs_list()
reduced_dofs = reduced_mesh.get_reduced_dofs_list()
u = TrialFunction(U)
(u_0, u_1) = split(u)
v = TestFunction(V)
trial = 1
test = 0
u_N = TrialFunction(reduced_V[trial])
v_N = TestFunction(reduced_V[test])
(u_N_0, u_N_1) = split(u_N)
A = assemble(inner(u_0, v) * dx + u_1 * v[0] * dx)
A_N = assemble(inner(u_N_0, v_N) * dx + u_N_1 * v_N[0] * dx)
A_dofs = evaluate_and_vectorize_sparse_matrix_at_dofs(A, dofs)
A_N_reduced_dofs = evaluate_and_vectorize_sparse_matrix_at_dofs(A_N, reduced_dofs)
test_logger.log(DEBUG, "A at dofs:")
test_logger.log(DEBUG, str(A_dofs))
test_logger.log(DEBUG, "A_N at reduced dofs:")
test_logger.log(DEBUG, str(A_N_reduced_dofs))
test_logger.log(DEBUG, "Error:")
test_logger.log(DEBUG, str(A_dofs - A_N_reduced_dofs))
assert isclose(A_dofs, A_N_reduced_dofs).all()
def test_nest_matrix(pushpop_parameters):
# Create Matrices and insert into nest
A00 = PETScMatrix()
A01 = PETScMatrix()
A10 = PETScMatrix()
mesh = UnitSquareMesh(12, 12)
V = FunctionSpace(mesh, "Lagrange", 2)
Q = FunctionSpace(mesh, "Lagrange", 1)
u, v = TrialFunction(V), TestFunction(V)
p, q = TrialFunction(Q), TestFunction(Q)
assemble(u * v * dx, tensor=A00)
assemble(p * v * dx, tensor=A01)
assemble(u * q * dx, tensor=A10)
AA = PETScNestMatrix([A00, A01, A10, None])
# Create compatible RHS Vectors and insert into nest
u = PETScVector()
p = PETScVector()
x = PETScVector()
A00.init_vector(u, 1)
A01.init_vector(p, 1)
AA.init_vectors(x, [u, p])
def _test_reduced_mesh_mixed_matrix(V, reduced_mesh):
reduced_V = reduced_mesh.get_reduced_function_spaces()
dofs = reduced_mesh.get_dofs_list()
reduced_dofs = reduced_mesh.get_reduced_dofs_list()
u = TrialFunction(V)
v = TestFunction(V)
(u_0, u_1) = split(u)
(v_0, v_1) = split(v)
trial = 1
test = 0
u_N = TrialFunction(reduced_V[trial])
v_N = TestFunction(reduced_V[test])
(u_N_0, u_N_1) = split(u_N)
(v_N_0, v_N_1) = split(v_N)
A = assemble(u_0[0]*v_0[0]*dx + u_0[0]*v_0[1]*dx + u_0[1]*v_0[0]*dx + u_0[1]*v_0[1]*dx + u_1*v_1*dx + u_0[0]*v_1*dx + u_1*v_0[1]*dx)
A_N = assemble(u_N_0[0]*v_N_0[0]*dx + u_N_0[0]*v_N_0[1]*dx + u_N_0[1]*v_N_0[0]*dx + u_N_0[1]*v_N_0[1]*dx + u_N_1*v_N_1*dx + u_N_0[0]*v_N_1*dx + u_N_1*v_N_0[1]*dx)
A_dofs = evaluate_and_vectorize_sparse_matrix_at_dofs(A, dofs)
A_N_reduced_dofs = evaluate_and_vectorize_sparse_matrix_at_dofs(A_N, reduced_dofs)
log(PROGRESS, "A at dofs:\n" + str(A_dofs))
log(PROGRESS, "A_N at reduced dofs:\n" + str(A_N_reduced_dofs))
log(PROGRESS, "Error:\n" + str(A_dofs - A_N_reduced_dofs))
assert isclose(A_dofs, A_N_reduced_dofs).all()
def weighted_gradient_matrix(mesh, i, family='CG', degree=1, constrained_domain=None):
"""Compute weighted gradient matrix
The matrix allows you to compute the gradient of a P1 Function
through a simple matrix vector product
CG family:
p_ is the pressure solution on CG1
dPdX = weighted_gradient_matrix(mesh, 0, 'CG', degree)
V = FunctionSpace(mesh, 'CG', degree)
dpdx = Function(V)
dpdx.vector()[:] = dPdX * p_.vector()
The space for dpdx must be continuous Lagrange of some order
CR family:
p_ is the pressure solution on CR
dPdX = weighted_gradient_matrix(mesh, 0, 'CR', 1)
V = FunctionSpace(mesh, 'CR', 1)
dpdx = Function(V)
dpdx.vector()[:] = dPdX * p_.vector()
"""
DG = FunctionSpace(mesh, 'DG', 0)
if family == 'CG':
# Source and Target spaces are CG_1 and CG_degree
S = FunctionSpace(mesh, 'CG', 1, constrained_domain=constrained_domain)
T = FunctionSpace(mesh, 'CG', degree, constrained_domain=constrained_domain)
elif family == 'CR':
if degree != 1:
print('\033[1;37;34m%s\033[0m' % 'Ignoring degree')
# Source and Target spaces are CR
S = FunctionSpace(mesh, 'CR', 1, constrained_domain=constrained_domain)
T = S
else:
raise ValueError('Only CG and CR families are allowed.')
G = assemble(TrialFunction(DG)*TestFunction(T)*dx)
dg = Function(DG)
if isinstance(i, (tuple, list)):
CC = []
for ii in i:
dP = assemble(TrialFunction(S).dx(ii)*TestFunction(DG)*dx)
A = Matrix(G)
Cp = compiled_gradient_module.compute_weighted_gradient_matrix(A, dP, dg)
CC.append(Cp)
return CC
else:
dP = assemble(TrialFunction(S).dx(i)*TestFunction(DG)*dx)
Cp = compiled_gradient_module.compute_weighted_gradient_matrix(G, dP, dg)
#info(G, True)
#info(dP, True)
return Cp
def assemble_operator_for_restriction_decorator_impl(self, term):
original_term = restricted_term_to_original_term.get(term)
if original_term is None: # term was not a original term
return assemble_operator(self, term)
else:
assert (term.endswith("_restricted") or term.startswith("inner_product_")
or term.startswith("dirichlet_bc_"))
if term.endswith("_restricted") or term.startswith("inner_product_"):
test_int = _to_int(self.V, test)
trial_int = _to_int(self.V, trial)
assert test_int is not None or trial_int is not None
replacements = dict()
if test_int is not None:
original_test = split(TestFunction(self.V))
original_test = original_test[test_int]
restricted_test = TestFunction(self.V.sub(test_int).collapse())
replacements[original_test] = restricted_test
if trial_int is not None:
original_trial = split(TrialFunction(self.V))
original_trial = original_trial[trial_int]
restricted_trial = TrialFunction(self.V.sub(trial_int).collapse())
replacements[original_trial] = restricted_trial
return tuple(replace(op, replacements) for op in assemble_operator(self, original_term))
elif term.startswith("dirichlet_bc_"):
assert test is None
trial_int = _to_int(self.V, trial)
assert trial_int is not None
original_dirichlet_bcs = assemble_operator(self, original_term)
restricted_dirichlet_bcs = list()
for original_dirichlet_bc in original_dirichlet_bcs:
restricted_dirichlet_bc = list()
for original_dirichlet_bc_i in original_dirichlet_bc:
V = original_dirichlet_bc_i.function_space()
parent_V = V
assert hasattr(parent_V, "_root_space_after_sub")
while parent_V._root_space_after_sub is not None:
parent_V = parent_V._root_space_after_sub
assert hasattr(parent_V, "_root_space_after_sub")
V_component = [int(c) for c in V.component()]
assert len(V_component) >= 1
assert V_component[0] == trial_int
restricted_V = parent_V.sub(V_component[0]).collapse()
for c in V_component[1:]:
restricted_V = restricted_V.sub(c)
restricted_value = Constant(zeros(original_dirichlet_bc_i.value().ufl_shape))
args = list()
args.append(restricted_V)
args.append(restricted_value)
args.extend(original_dirichlet_bc_i._domain)
kwargs = original_dirichlet_bc_i._kwargs
restricted_dirichlet_bc.append(DirichletBC(*args, **kwargs))
assert len(restricted_dirichlet_bc) == len(original_dirichlet_bc)
restricted_dirichlet_bcs.append(restricted_dirichlet_bc)
assert len(restricted_dirichlet_bcs) == len(original_dirichlet_bcs)
return tuple(restricted_dirichlet_bcs)
def navier_stokes_IPCS(mesh, dt, parameter):
"""
fenics code: weak form of the problem.
"""
mu, rho, nu = parameter
V = VectorFunctionSpace(mesh, 'P', 2)
Q = FunctionSpace(mesh, 'P', 1)
bc0 = DirichletBC(V, Constant((0, 0)), cylinderwall)
bc1 = DirichletBC(V, Constant((0, 0)), topandbottom)
bc2 = DirichletBC(V, U0, inlet)
bc3 = DirichletBC(Q, Constant(1), outlet)
bcs = [bc0, bc1, bc2, bc3]
# ds is needed to compute drag and lift. Not used here.
ASD1 = AutoSubDomain(topandbottom)
ASD2 = AutoSubDomain(cylinderwall)
mf = MeshFunction("size_t", mesh, 1)
mf.set_all(0)
ASD1.mark(mf, 1)
ASD2.mark(mf, 2)
ds_ = ds(subdomain_data=mf, domain=mesh)
vu, vp = TestFunction(V), TestFunction(Q) # for integration
u_, p_ = Function(V), Function(Q) # for the solution
u_1, p_1 = Function(V), Function(Q) # for the prev. solution
u, p = TrialFunction(V), TrialFunction(Q) # unknown!
bcu = [bcs[0], bcs[1], bcs[2]]
bcp = [bcs[3]]
n = FacetNormal(mesh)
u_mid = (u + u_1) / 2.0
F1 = rho*dot((u - u_1) / dt, vu)*dx \
+ rho*dot(dot(u_1, nabla_grad(u_1)), vu)*dx \
+ inner(sigma(u_mid, p_1, mu), epsilon(vu))*dx \
+ dot(p_1*n, vu)*ds - dot(mu*nabla_grad(u_mid)*n, vu)*ds
a1 = lhs(F1)
L1 = rhs(F1)
# Define variational problem for step 2
a2 = dot(nabla_grad(p), nabla_grad(vp)) * dx
L2 = dot(nabla_grad(p_1), nabla_grad(vp)) * dx - (
rho / dt) * div(u_) * vp * dx # rho missing in FEniCS tutorial
# Define variational problem for step 3
a3 = dot(u, vu) * dx
L3 = dot(u_, vu) * dx - dt * dot(nabla_grad(p_ - p_1), vu) * dx
# Assemble matrices
A1 = assemble(a1)
A2 = assemble(a2)
A3 = assemble(a3)
# Apply boundary conditions to matrices
[bc.apply(A1) for bc in bcu]
[bc.apply(A2) for bc in bcp]
return u_, p_, u_1, p_1, L1, A1, L2, A2, L3, A3, bcu, bcp
def __init__(self, V, Vm, bc, bcadj, \
RHSinput=[], ObsOp=[], UD=[], Regul=[], Data=[], plot=False, \
mycomm=None):
# Define test, trial and all other functions
self.trial = TrialFunction(V)
self.test = TestFunction(V)
self.mtrial = TrialFunction(Vm)
self.mtest = TestFunction(Vm)
self.rhs = Function(V)
self.m = Function(Vm)
self.mcopy = Function(Vm)
self.srchdir = Function(Vm)
self.delta_m = Function(Vm)
self.MG = Function(Vm)
self.MGv = self.MG.vector()
self.Grad = Function(Vm)
self.Gradnorm = 0.0
self.lenm = len(self.m.vector().array())
self.u = Function(V)
self.ud = Function(V)
self.diff = Function(V)
self.p = Function(V)
# Store other info:
self.ObsOp = ObsOp
self.UD = UD
self.reset() # Initialize U, C and E to []
self.Data = Data
self.GN = 1.0 # GN = 0.0 => GN Hessian; = 1.0 => full Hessian
# Define weak forms to assemble A, C and E
self._wkforma()
self._wkformc()
self._wkforme()
# Operators and bc
LinearOperator.__init__(self, self.delta_m.vector(), \
self.delta_m.vector())
self.bc = bc
self.bcadj = bcadj
self._assemble_solverM(Vm)
self.assemble_A()
self.assemble_RHS(RHSinput)
self.Regul = Regul
self.regparam = 1.0
if Regul != []:
self.PD = self.Regul.isPD()
# Counters, tolerances and others
self.nbPDEsolves = 0 # Updated when solve_A called
self.nbfwdsolves = 0 # Counter for plots
self.nbadjsolves = 0 # Counter for plots
# MPI:
self.mycomm = mycomm
def __init__(self,
form,
Space,
bcs=[],
name="x",
matvec=[None, None],
method="default",
solver_type="cg",
preconditioner_type="default"):
Function.__init__(self, Space, name=name)
self.form = form
self.method = method
self.bcs = bcs
self.matvec = matvec
self.trial = trial = TrialFunction(Space)
self.test = test = TestFunction(Space)
Mass = inner(trial, test) * dx()
self.bf = inner(form, test) * dx()
self.rhs = Vector(self.vector())
if method.lower() == "default":
self.A = A_cache[(Mass, tuple(bcs))]
self.sol = Solver_cache[(Mass, tuple(bcs), solver_type,
preconditioner_type)]
elif method.lower() == "lumping":
assert Space.ufl_element().degree() < 2
self.A = A_cache[(Mass, tuple(bcs))]
ones = Function(Space)
ones.vector()[:] = 1.
self.ML = self.A * ones.vector()
self.ML.set_local(1. / self.ML.array())
def __init__(self, Th, N):
self.N = N
mesh = UnitSquareMesh(Th, Th)
self.V = FunctionSpace(mesh, "Lagrange", 1)
u = TrialFunction(self.V)
v = TestFunction(self.V)
self.a = lambda k: k * inner(grad(u), grad(v)) * dx
def mpi1d_weak_solution(V: FunctionSpace, f: Function, ft: Function,
fx: Function) -> (Function, Function):
# Define trial and test functions.
v = TrialFunction(V)
w = TestFunction(V)
# Define weak formulation.
A = (v.dx(1) * w.dx(1) + v * w + (fx * v + f * v.dx(1)) *
(fx * w + f * w.dx(1))) * dx
b = -ft * (fx * w + f * w.dx(1)) * dx
# F = (v.dx(1) * w.dx(1) + v * w
# + (fx * v + f * v.dx(1) + ft) * (fx * w + f * w.dx(1))) * dx
# A = lhs(F)
# b = rhs(F)
# Compute solution.
v = Function(V)
solve(A == b, v)
# Compute k.
k = project(fx * v + f * v.dx(1) + ft, V)
return v, k
def __init__(self,
form,
mesh,
bcs=[],
name="CG1",
method={},
bounded=False):
solver_type = method.get('solver_type', 'cg')
preconditioner_type = method.get('preconditioner_type', 'default')
solver_method = method.get('method', 'default')
self.bounded = bounded
Space = FunctionSpace(mesh, "CG", 1)
OasisFunction.__init__(self,
form,
Space,
bcs=bcs,
name=name,
method=solver_method,
solver_type=solver_type,
preconditioner_type=preconditioner_type)
if solver_method.lower() == "weightedaverage":
from fenicstools import compiled_gradient_module
DG = FunctionSpace(mesh, 'DG', 0)
# Cannot use cache. Matrix will be modified
self.A = assemble(TrialFunction(DG) * self.test * dx())
self.dg = dg = Function(DG)
compiled_gradient_module.compute_DG0_to_CG_weight_matrix(
self.A, dg)
self.bf_dg = inner(form, TestFunction(DG)) * dx()
def __init__(self, V, expression_type, basis_generation):
self.V = V
# Parametrized function to be interpolated
mock_problem = MockProblem(V)
f = ParametrizedExpression(mock_problem,
"0",
mu=(1., ),
element=V.ufl_element())
#
folder_prefix = os.path.join("test_eim_approximation_00_tempdir",
expression_type, basis_generation)
assert expression_type in ("Function", "Vector", "Matrix")
if expression_type == "Function":
# Call Parent constructor
EIMApproximation.__init__(self, mock_problem,
ParametrizedExpressionFactory(f),
folder_prefix, basis_generation)
elif expression_type == "Vector":
v = TestFunction(V)
form = f * v * dx
# Call Parent constructor
EIMApproximation.__init__(self, mock_problem,
ParametrizedTensorFactory(form),
folder_prefix, basis_generation)
elif expression_type == "Matrix":
u = TrialFunction(V)
v = TestFunction(V)
form = f * u * v * dx
# Call Parent constructor
EIMApproximation.__init__(self, mock_problem,
ParametrizedTensorFactory(form),
folder_prefix, basis_generation)
else: # impossible to arrive here anyway thanks to the assert
raise AssertionError("Invalid expression_type")
def les_update(nut_, nut_form, A_mass, At, u_, dt, bc_ksgs, bt, ksgs_sol,
KineticEnergySGS, CG1, ksgs, delta, **NS_namespace):
p, q = TrialFunction(CG1), TestFunction(CG1)
Ck = KineticEnergySGS["Ck"]
Ce = KineticEnergySGS["Ce"]
Sij = sym(grad(u_))
assemble(dt * inner(dot(u_, 0.5 * grad(p)), q) * dx + inner(
(dt * Ce * sqrt(ksgs) / delta) * 0.5 * p, q) * dx +
inner(dt * Ck * sqrt(ksgs) * delta * grad(0.5 * p), grad(q)) * dx,
tensor=At)
assemble(dt * 2 * Ck * delta * sqrt(ksgs) * inner(Sij, grad(u_)) * q * dx,
tensor=bt)
bt.axpy(1.0, A_mass * ksgs.vector())
bt.axpy(-1.0, At * ksgs.vector())
At.axpy(1.0, A_mass, True)
# Solve for ksgs
bc_ksgs.apply(At, bt)
ksgs_sol.solve(At, ksgs.vector(), bt)
ksgs.vector().set_local(ksgs.vector().array().clip(min=1e-7))
ksgs.vector().apply("insert")
# Update nut_
nut_()
def __init__(self, truth_problem, expression_type, basis_generation):
self.V = truth_problem.V
#
folder_prefix = os.path.join("test_eim_approximation_17_tempdir",
expression_type, basis_generation)
assert expression_type in ("Function", "Vector", "Matrix")
if expression_type == "Function":
# Call Parent constructor
EIMApproximation.__init__(
self, truth_problem,
ParametrizedExpressionFactory(truth_problem._solution),
folder_prefix, basis_generation)
elif expression_type == "Vector":
v = TestFunction(self.V)
form = inner(truth_problem._solution, v) * dx
# Call Parent constructor
EIMApproximation.__init__(self, truth_problem,
ParametrizedTensorFactory(form),
folder_prefix, basis_generation)
elif expression_type == "Matrix":
u = TrialFunction(self.V)
v = TestFunction(self.V)
form = inner(truth_problem._solution, u) * v[0] * dx
# Call Parent constructor
EIMApproximation.__init__(self, truth_problem,
ParametrizedTensorFactory(form),
folder_prefix, basis_generation)
else: # impossible to arrive here anyway thanks to the assert
raise AssertionError("Invalid expression_type")
def test_krylov_solver_lu():
mesh = UnitSquareMesh(MPI.comm_world, 12, 12)
V = FunctionSpace(mesh, ("Lagrange", 1))
u, v = TrialFunction(V), TestFunction(V)
a = inner(u, v) * dx
L = inner(1.0, v) * dx
A = assemble_matrix(a)
A.assemble()
b = assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
norm = 13.0
solver = PETScKrylovSolver(mesh.mpi_comm())
solver.set_options_prefix("test_lu_")
PETScOptions.set("test_lu_ksp_type", "preonly")
PETScOptions.set("test_lu_pc_type", "lu")
solver.set_from_options()
x = A.createVecRight()
solver.set_operator(A)
solver.solve(x, b)
# *Tight* tolerance for LU solves
assert round(x.norm(PETSc.NormType.N2) - norm, 12) == 0
def solve(self, dt):
self.u = Function(self.V0)
self.w = TestFunction(self.V0)
self.du = TrialFunction(self.V0)
x = SpatialCoordinate(self.mesh0)
L = inner( self.S(), self.eps(self.w) )*dx(degree=4)\
- inner( self.b, self.w )*dx(degree=4)\
- inner( self.h, self.w )*ds(degree=4)\
+ inner( 1e-6*self.u, self.w )*ds(degree=4)\
- inner( min_value(x[2]+self.ut[2]+self.u[2], 0) * Constant((0,0,-1.0)), self.w )*ds(degree=4)
a = derivative(L, self.u, self.du)
problem = NonlinearVariationalProblem(L, self.u, bcs=[], J=a)
solver = NonlinearVariationalSolver(problem)
solver.solve()
self.ut.vector()[:] = self.ut.vector()[:] + self.u.vector()[:]
ALE.move(self.mesh, Function(self.V, self.u.vector()))
self.v.vector()[:] = self.u.vector()[:] / dt
self.n = FacetNormal(self.mesh)
def __init__(self, simulation, every_timestep):
"""
Calculate the hydrostatic pressure
"""
self.simulation = simulation
self.active = True
self.every_timestep = every_timestep
rho = simulation.data['rho']
g = simulation.data['g']
ph = simulation.data['p_hydrostatic']
# Define the weak form
Vp = ph.function_space()
p = TrialFunction(Vp)
q = TestFunction(Vp)
a = dot(grad(p), grad(q)) * dx
L = rho * dot(g, grad(q)) * dx
self.func = ph
self.tensor_lhs = assemble(a)
self.form_rhs = Form(L)
self.null_space = None
self.solver = linear_solver_from_input(
simulation,
'solver/p_hydrostatic',
default_parameters=DEFAULT_SOLVER_CONFIGURATION,
)
def _change_degree(self, degree, *args, **kwargs):
gc.collect()
with self.global_preprocessing_time:
logger.debug('Creating function space...')
self._V = FunctionSpace(self._mesh, "CG", degree)
logger.debug('Done. Creating integration subdomains...')
self.create_integration_subdomains()
logger.debug('Done. Creating test function...')
self._v = TestFunction(self._V)
logger.debug('Done. Creating potential function...')
self._potential_function = Function(self._V)
logger.debug('Done. Creating trial function...')
self._potential_trial = TrialFunction(self._V)
logger.debug('Done. Creating LHS part of equation...')
self._a = self._lhs()
logger.debug('Done. Assembling linear equation matrix...')
self._terms_with_unknown = assemble(self._a)
logger.debug('Done. Defining boundary condition...')
self._dirichlet_bc = self._boundary_condition(*args, **kwargs)
logger.debug('Done. Applying boundary condition to the matrix...')
self._dirichlet_bc.apply(self._terms_with_unknown)
logger.debug('Done. Creating solver...')
self._solver = KrylovSolver("cg", "ilu")
self._solver.parameters["maximum_iterations"] = self.MAX_ITER
self._solver.parameters["absolute_tolerance"] = 1E-8
logger.debug('Done. Solver created.')
self._degree = degree
def divergence_matrix(mesh):
CR = VectorFunctionSpace(mesh, 'CR', 1)
DG = FunctionSpace(mesh, 'DG', 0)
A = cg1_cr_interpolation_matrix(mesh)
M = assemble(dot(div(TrialFunction(CR)), TestFunction(DG)) * dx())
C = compiled_cr_module.cr_divergence_matrix(M, A, DG, CR)
return C
def __init__(self, mock_problem, expression_type, basis_generation):
self.V = mock_problem.V
# Parametrized function to be interpolated
mu = SymbolicParameters(mock_problem, self.V, (1., ))
x = SpatialCoordinate(self.V.mesh())
f = (1 - x[0]) * cos(3 * pi * mu[0] * (1 + x[0])) * exp(-mu[0] *
(1 + x[0]))
#
folder_prefix = os.path.join("test_eim_approximation_09_tempdir",
expression_type, basis_generation)
assert expression_type in ("Function", "Vector", "Matrix")
if expression_type == "Function":
# Call Parent constructor
EIMApproximation.__init__(self, mock_problem,
ParametrizedExpressionFactory(f),
folder_prefix, basis_generation)
elif expression_type == "Vector":
v = TestFunction(self.V)
form = f * v * dx
# Call Parent constructor
EIMApproximation.__init__(self, mock_problem,
ParametrizedTensorFactory(form),
folder_prefix, basis_generation)
elif expression_type == "Matrix":
u = TrialFunction(self.V)
v = TestFunction(self.V)
form = f * u * v * dx
# Call Parent constructor
EIMApproximation.__init__(self, mock_problem,
ParametrizedTensorFactory(form),
folder_prefix, basis_generation)
else: # impossible to arrive here anyway thanks to the assert
raise AssertionError("Invalid expression_type")
def __init__(self, Th, callback_type):
# Create mesh and define function space
mesh = UnitSquareMesh(Th, Th)
self.V = FunctionSpace(mesh, "Lagrange", 1)
# Define variational problem
du = TrialFunction(self.V)
v = TestFunction(self.V)
self.u = Function(self.V)
self.r = lambda u, g: inner(grad(u), grad(v)) * dx + inner(
u + u**3, v) * dx - g * v * dx
self.j = lambda u, r: derivative(r, u, du)
# Define initial guess
self.initial_guess_expression = Expression(
"0.1 + 0.9*x[0]*x[1]", element=self.V.ufl_element())
# Define callback function depending on callback type
assert callback_type in ("form callbacks", "tensor callbacks")
if callback_type == "form callbacks":
def callback(arg):
return arg
elif callback_type == "tensor callbacks":
def callback(arg):
return assemble(arg)
self.callback_type = callback_type
self.callback = callback
def test_nullspace_check(mesh, degree):
V = VectorFunctionSpace(mesh, ('Lagrange', degree))
u, v = TrialFunction(V), TestFunction(V)
mesh.geometry.coord_mapping = fem.create_coordinate_map(mesh)
E, nu = 2.0e2, 0.3
mu = E / (2.0 * (1.0 + nu))
lmbda = E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu))
def sigma(w, gdim):
return 2.0 * mu * ufl.sym(grad(w)) + lmbda * ufl.tr(
grad(w)) * ufl.Identity(gdim)
a = inner(sigma(u, mesh.geometry.dim), grad(v)) * dx
zero = Function(V)
L = inner(zero, v) * dx
# Assemble matrix and create compatible vector
A, L = assembling.assemble_system(a, L, [])
# Create null space basis and test
null_space = build_elastic_nullspace(V)
assert null_space.in_nullspace(A, tol=1.0e-8)
null_space.orthonormalize()
assert null_space.in_nullspace(A, tol=1.0e-8)
# Create incorrect null space basis and test
null_space = build_broken_elastic_nullspace(V)
assert not null_space.in_nullspace(A, tol=1.0e-8)
null_space.orthonormalize()
assert not null_space.in_nullspace(A, tol=1.0e-8)
def _assemble(self):
# Get input:
self.gamma = self.Parameters['gamma']
if self.Parameters.has_key('beta'): self.beta = self.Parameters['beta']
else: self.beta = 0.0
self.Vm = self.Parameters['Vm']
self.m0 = Function(self.Vm)
if self.Parameters.has_key('m0'):
setfct(self.m0, self.Parameters['m0'])
self.mtrial = TrialFunction(self.Vm)
self.mtest = TestFunction(self.Vm)
self.mysample = Function(self.Vm)
self.draw = Function(self.Vm)
# Assemble:
self.R = assemble(inner(nabla_grad(self.mtrial), \
nabla_grad(self.mtest))*dx)
self.M = assemble(inner(self.mtrial, self.mtest) * dx)
self.Msolver = PETScKrylovSolver('cg', 'jacobi')
self.Msolver.parameters["maximum_iterations"] = 2000
self.Msolver.parameters["relative_tolerance"] = 1e-24
self.Msolver.parameters["absolute_tolerance"] = 1e-24
self.Msolver.parameters["error_on_nonconvergence"] = True
self.Msolver.parameters["nonzero_initial_guess"] = False
self.Msolver.set_operator(self.M)
# preconditioner is Gamma^{-1}:
if self.beta > 1e-10:
self.precond = self.gamma * self.R + self.beta * self.M
else:
self.precond = self.gamma * self.R + (1e-10) * self.M
# Minvprior is M.A^2 (if you use M inner-product):
self.Minvprior = self.gamma * self.R + self.beta * self.M
def __init__(self, V, subdomains, expression_type, basis_generation):
self.V = V
# Parametrized function to be interpolated
mock_problem = MockProblem(V)
f = ParametrizedExpression(
mock_problem,
"exp( - 2*pow(x[0]-mu[0], 2) - 2*pow(x[1]-mu[1], 2) )",
mu=(0., 0.),
element=V.ufl_element())
# Subdomain measure
dx = Measure("dx")(subdomain_data=subdomains)(1)
#
folder_prefix = os.path.join("test_eim_approximation_04_tempdir",
expression_type, basis_generation)
assert expression_type in ("Vector", "Matrix")
if expression_type == "Vector":
v = TestFunction(V)
form = f * v * dx
# Call Parent constructor
EIMApproximation.__init__(self, mock_problem,
ParametrizedTensorFactory(form),
folder_prefix, basis_generation)
elif expression_type == "Matrix":
u = TrialFunction(V)
v = TestFunction(V)
form = f * u * v * dx
# Call Parent constructor
EIMApproximation.__init__(self, mock_problem,
ParametrizedTensorFactory(form),
folder_prefix, basis_generation)
else: # impossible to arrive here anyway thanks to the assert
raise AssertionError("Invalid expression_type")
def __init__(self, V, **kwargs):
# Call parent
ParametrizedProblem.__init__(
self,
os.path.join("test_eim_approximation_17_tempdir",
expression_type, basis_generation,
"mock_problem"))
# Minimal subset of a ParametrizedDifferentialProblem
self.V = V
self._solution = Function(V)
self.components = ["u", "s", "p"]
# Parametrized function to be interpolated
x = SpatialCoordinate(V.mesh())
mu = SymbolicParameters(self, V, (-1., -1.))
self.f00 = 1. / sqrt(
pow(x[0] - mu[0], 2) + pow(x[1] - mu[1], 2) + 0.01)
self.f01 = 1. / sqrt(
pow(x[0] - mu[0], 4) + pow(x[1] - mu[1], 4) + 0.01)
# Inner product
f = TrialFunction(self.V)
g = TestFunction(self.V)
self.inner_product = assemble(inner(f, g) * dx)
# Collapsed vector and space
self.V0 = V.sub(0).collapse()
self.V00 = V.sub(0).sub(0).collapse()
self.V1 = V.sub(1).collapse()
def __init__(self, V, expression_type, basis_generation):
self.V = V
# Parametrized function to be interpolated
mock_problem = MockProblem(V)
f_expression = (
("1/sqrt(pow(x[0]-mu[0], 2) + pow(x[1]-mu[1], 2) + 0.01)",
"exp( - 2*pow(x[0]-mu[0], 2) - 2*pow(x[1]-mu[1], 2) )"),
("10.*(1-x[0])*cos(3*pi*(pi+mu[1])*(1+x[1]))*exp(-(pi+mu[0])*(1+x[0]))",
"sqrt(pow(x[0]-mu[0], 2) + pow(x[1]-mu[1], 2) + 0.01)")
)
tensor_element = TensorElement(V.sub(0).ufl_element())
f = ParametrizedExpression(mock_problem, f_expression, mu=(-1., -1.), element=tensor_element)
#
folder_prefix = os.path.join("test_eim_approximation_07_tempdir", expression_type, basis_generation)
assert expression_type in ("Function", "Vector", "Matrix")
if expression_type == "Function":
# Call Parent constructor
EIMApproximation.__init__(
self, mock_problem, ParametrizedExpressionFactory(f), folder_prefix, basis_generation)
elif expression_type == "Vector":
v = TestFunction(V)
form = inner(f, grad(v)) * dx
# Call Parent constructor
EIMApproximation.__init__(
self, mock_problem, ParametrizedTensorFactory(form), folder_prefix, basis_generation)
elif expression_type == "Matrix":
u = TrialFunction(V)
v = TestFunction(V)
form = inner(grad(u) * f, grad(v)) * dx
# Call Parent constructor
EIMApproximation.__init__(
self, mock_problem, ParametrizedTensorFactory(form), folder_prefix, basis_generation)
else: # impossible to arrive here anyway thanks to the assert
raise AssertionError("Invalid expression_type")
def test_lhs_rhs_simple():
"""Test taking lhs/rhs of DOLFIN specific forms (constants
without cell). """
mesh = RectangleMesh(MPI.comm_world, [numpy.array([0.0, 0.0, 0.0]),
numpy.array([2.0, 1.0, 0.0])],
[3, 5], CellType.triangle)
V = FunctionSpace(mesh, "CG", 1)
f = 2.0
g = 3.0
v = TestFunction(V)
u = TrialFunction(V)
F = inner(g * grad(f * v), grad(u)) * dx + f * v * dx
a, L = system(F)
Fl = lhs(F)
Fr = rhs(F)
assert(Fr)
a0 = inner(grad(v), grad(u)) * dx
n = assemble(a).norm("frobenius") # noqa
nl = assemble(Fl).norm("frobenius") # noqa
n0 = 6.0 * assemble(a0).norm("frobenius") # noqa
assert round(n - n0, 7) == 0
assert round(n - nl, 7) == 0
def test_local_assembler_1D():
mesh = UnitIntervalMesh(MPI.comm_world, 20)
V = FunctionSpace(mesh, 'CG', 1)
u = TrialFunction(V)
v = TestFunction(V)
c = Cell(mesh, 0)
a_scalar = 1.0 * dx(domain=mesh)
a_vector = v * dx
a_matrix = u * v * dx
A_scalar = assemble_local(a_scalar, c)
A_vector = assemble_local(a_vector, c)
A_matrix = assemble_local(a_matrix, c)
assert isinstance(A_scalar, float)
assert numpy.isclose(A_scalar, 0.05)
assert isinstance(A_vector, numpy.ndarray)
assert A_vector.shape == (2,)
assert numpy.isclose(A_vector[0], 0.025)
assert numpy.isclose(A_vector[1], 0.025)
assert isinstance(A_matrix, numpy.ndarray)
assert A_matrix.shape == (2, 2)
assert numpy.isclose(A_matrix[0, 0], 1 / 60)
assert numpy.isclose(A_matrix[0, 1], 1 / 120)
assert numpy.isclose(A_matrix[1, 0], 1 / 120)
assert numpy.isclose(A_matrix[1, 1], 1 / 60)
