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_eim_approximation_17(expression_type, basis_generation):
"""
This test is similar to test 15. However, in contrast to test 15, the solution is not split at all.
* EIM: unsplit solution is used in the definition of the parametrized expression, similarly to test 11.
* DEIM: unsplit solution is used in the definition of the parametrized tensor. This results in a single
coefficient of type Function, which however is stored internally by UFL as an Indexed of Function and
a mute index. This test requires the FEniCS backend to properly differentiate between Indexed objects
with a fixed index (such as a component of the solution as in test 13) and Indexed objects with a mute
index, which should be treated has if the entire solution was required.
"""
@StoreMapFromProblemNameToProblem
@StoreMapFromProblemToTrainingStatus
@StoreMapFromSolutionToProblem
class MockProblem(ParametrizedProblem):
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 name(self):
return "MockProblem_17_" + expression_type + "_" + basis_generation
def init(self):
pass
def solve(self):
assert not hasattr(self, "_is_solving")
self._is_solving = True
f00 = project(self.f00, self.V00)
f01 = project(self.f01, self.V00)
assign(self._solution.sub(0).sub(0), f00)
assign(self._solution.sub(0).sub(1), f01)
delattr(self, "_is_solving")
return self._solution
@StoreMapFromProblemToReductionMethod
@UpdateMapFromProblemToTrainingStatus
class MockReductionMethod(ReductionMethod):
def __init__(self, truth_problem, **kwargs):
# Call parent
ReductionMethod.__init__(
self,
os.path.join("test_eim_approximation_17_tempdir",
expression_type, basis_generation,
"mock_problem"))
# Minimal subset of a DifferentialProblemReductionMethod
self.truth_problem = truth_problem
self.reduced_problem = None
# I/O
self.folder["basis"] = os.path.join(
self.truth_problem.folder_prefix, "basis")
# Gram Schmidt
self.GS = GramSchmidt(self.truth_problem.inner_product)
def initialize_training_set(self,
ntrain,
enable_import=True,
sampling=None,
**kwargs):
return ReductionMethod.initialize_training_set(
self, self.truth_problem.mu_range, ntrain, enable_import,
sampling, **kwargs)
def initialize_testing_set(self,
ntest,
enable_import=False,
sampling=None,
**kwargs):
return ReductionMethod.initialize_testing_set(
self, self.truth_problem.mu_range, ntest, enable_import,
sampling, **kwargs)
def offline(self):
self.reduced_problem = MockReducedProblem(self.truth_problem)
if self.folder["basis"].create(
): # basis folder was not available yet
for (index, mu) in enumerate(self.training_set):
self.truth_problem.set_mu(mu)
print("solving mock problem at mu =",
self.truth_problem.mu)
f = self.truth_problem.solve()
self.update_basis_matrix((index, f))
self.reduced_problem.basis_functions.save(
self.folder["basis"], "basis")
else:
self.reduced_problem.basis_functions.load(
self.folder["basis"], "basis")
self._finalize_offline()
return self.reduced_problem
def update_basis_matrix(self, index_and_snapshot):
(index, snapshot) = index_and_snapshot
component = "u" if index % 2 == 0 else "s"
self.reduced_problem.basis_functions.enrich(snapshot, component)
self.GS.apply(self.reduced_problem.basis_functions[component], 0)
def error_analysis(self, N=None, **kwargs):
pass
def speedup_analysis(self, N=None, **kwargs):
pass
@StoreMapFromProblemToReducedProblem
class MockReducedProblem(ParametrizedProblem):
@sync_setters("truth_problem", "set_mu", "mu")
@sync_setters("truth_problem", "set_mu_range", "mu_range")
def __init__(self, truth_problem, **kwargs):
# Call parent
ParametrizedProblem.__init__(
self,
os.path.join("test_eim_approximation_17_tempdir",
expression_type, basis_generation,
"mock_problem"))
# Minimal subset of a ParametrizedReducedDifferentialProblem
self.truth_problem = truth_problem
self.basis_functions = BasisFunctionsMatrix(self.truth_problem.V)
self.basis_functions.init(self.truth_problem.components)
self._solution = None
def solve(self):
print("solving mock reduced problem at mu =", self.mu)
assert not hasattr(self, "_is_solving")
self._is_solving = True
f = self.truth_problem.solve()
f_N = transpose(
self.basis_functions) * self.truth_problem.inner_product * f
# Return the reduced solution
self._solution = OnlineFunction(f_N)
delattr(self, "_is_solving")
return self._solution
class ParametrizedFunctionApproximation(EIMApproximation):
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")
# 1. Create the mesh for this test
mesh = RectangleMesh(Point(0.1, 0.1), Point(0.9, 0.9), 20, 20)
# 2. Create Finite Element space (Lagrange P1)
element_0 = VectorElement("Lagrange", mesh.ufl_cell(), 2)
element_1 = FiniteElement("Lagrange", mesh.ufl_cell(), 1)
element = MixedElement(element_0, element_1)
V = FunctionSpace(mesh, element, components=[["u", "s"], "p"])
# 3. Create a parametrized problem
problem = MockProblem(V)
mu_range = [(-1., -0.01), (-1., -0.01)]
problem.set_mu_range(mu_range)
# 4. Create a reduction method and run the offline phase to generate the corresponding
# reduced problem
reduction_method = MockReductionMethod(problem)
reduction_method.initialize_training_set(16,
sampling=EquispacedDistribution())
reduction_method.offline()
# 5. Allocate an object of the ParametrizedFunctionApproximation class
parametrized_function_approximation = ParametrizedFunctionApproximation(
problem, expression_type, basis_generation)
parametrized_function_approximation.set_mu_range(mu_range)
# 6. Prepare reduction with EIM
parametrized_function_reduction_method = EIMApproximationReductionMethod(
parametrized_function_approximation)
parametrized_function_reduction_method.set_Nmax(16)
parametrized_function_reduction_method.set_tolerance(0.)
# 7. Perform EIM offline phase
parametrized_function_reduction_method.initialize_training_set(
64, sampling=EquispacedDistribution())
reduced_parametrized_function_approximation = parametrized_function_reduction_method.offline(
)
# 8. Perform EIM online solve
online_mu = (-1., -1.)
reduced_parametrized_function_approximation.set_mu(online_mu)
reduced_parametrized_function_approximation.solve()
# 9. Perform EIM error analysis
parametrized_function_reduction_method.initialize_testing_set(100)
parametrized_function_reduction_method.error_analysis()
def test_eim_approximation_20(expression_type, basis_generation):
"""
This test is the version of test 19 where high fidelity solution is used in place of reduced order one.
"""
@StoreMapFromProblemNameToProblem
@StoreMapFromProblemToTrainingStatus
@StoreMapFromSolutionToProblem
class MockProblem(ParametrizedProblem):
def __init__(self, V, **kwargs):
# Call parent
ParametrizedProblem.__init__(
self,
os.path.join("test_eim_approximation_20_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 name(self):
return "MockProblem_20_" + expression_type + "_" + basis_generation
def init(self):
pass
def solve(self):
print("solving mock problem at mu =", self.mu)
assert not hasattr(self, "_is_solving")
self._is_solving = True
f00 = project(self.f00, self.V00)
f01 = project(self.f01, self.V00)
assign(self._solution.sub(0).sub(0), f00)
assign(self._solution.sub(0).sub(1), f01)
delattr(self, "_is_solving")
return self._solution
@StoreMapFromProblemToReductionMethod
class MockReductionMethod(ReductionMethod):
def __init__(self, truth_problem, **kwargs):
# Call parent
ReductionMethod.__init__(
self,
os.path.join("test_eim_approximation_20_tempdir",
expression_type, basis_generation,
"mock_problem"))
# Minimal subset of a DifferentialProblemReductionMethod
self.truth_problem = truth_problem
self.reduced_problem = None
def initialize_training_set(self,
ntrain,
enable_import=True,
sampling=None,
**kwargs):
return ReductionMethod.initialize_training_set(
self, self.truth_problem.mu_range, ntrain, enable_import,
sampling, **kwargs)
def initialize_testing_set(self,
ntest,
enable_import=False,
sampling=None,
**kwargs):
return ReductionMethod.initialize_testing_set(
self, self.truth_problem.mu_range, ntest, enable_import,
sampling, **kwargs)
def offline(self):
pass
def update_basis_matrix(self, snapshot):
pass
def error_analysis(self, N=None, **kwargs):
pass
def speedup_analysis(self, N=None, **kwargs):
pass
class ParametrizedFunctionApproximation(EIMApproximation):
def __init__(self, truth_problem, expression_type, basis_generation):
self.V = truth_problem.V0
(f0, _) = split(truth_problem._solution)
#
folder_prefix = os.path.join("test_eim_approximation_20_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(grad(f0)), folder_prefix,
basis_generation)
elif expression_type == "Vector":
v = TestFunction(self.V)
form = inner(grad(f0), grad(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(grad(f0), grad(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")
# 1. Create the mesh for this test
mesh = RectangleMesh(Point(0.1, 0.1), Point(0.9, 0.9), 20, 20)
# 2. Create Finite Element space (Lagrange P1)
element_0 = VectorElement("Lagrange", mesh.ufl_cell(), 2)
element_1 = FiniteElement("Lagrange", mesh.ufl_cell(), 1)
element = MixedElement(element_0, element_1)
V = FunctionSpace(mesh, element, components=[["u", "s"], "p"])
# 3. Create a parametrized problem
problem = MockProblem(V)
mu_range = [(-1., -0.01), (-1., -0.01)]
problem.set_mu_range(mu_range)
# 4. Create a reduction method, but postpone generation of the reduced problem
MockReductionMethod(problem)
# 5. Allocate an object of the ParametrizedFunctionApproximation class
parametrized_function_approximation = ParametrizedFunctionApproximation(
problem, expression_type, basis_generation)
parametrized_function_approximation.set_mu_range(mu_range)
# 6. Prepare reduction with EIM
parametrized_function_reduction_method = EIMApproximationReductionMethod(
parametrized_function_approximation)
parametrized_function_reduction_method.set_Nmax(16)
parametrized_function_reduction_method.set_tolerance(0.)
# 7. Perform EIM offline phase
parametrized_function_reduction_method.initialize_training_set(
64, sampling=EquispacedDistribution())
reduced_parametrized_function_approximation = parametrized_function_reduction_method.offline(
)
# 8. Perform EIM online solve
online_mu = (-1., -1.)
reduced_parametrized_function_approximation.set_mu(online_mu)
reduced_parametrized_function_approximation.solve()
# 9. Perform EIM error analysis
parametrized_function_reduction_method.initialize_testing_set(100)
parametrized_function_reduction_method.error_analysis()
outdir_base = './../../results/MovingMesh/'
mesh = RectangleMesh(Point(xmin, ymin), Point(xmax, ymax), nx, ny)
n = FacetNormal(mesh)
outfile = File(mesh.mpi_comm(), outdir_base+"psi_h.pvd")
V = VectorFunctionSpace(mesh, 'DG', 2)
Vcg = VectorFunctionSpace(mesh, 'CG', 1)
boundaries = MeshFunction("size_t", mesh, mesh.topology().dim()-1)
boundaries.set_all(0)
ds = Measure('ds', domain=mesh, subdomain_data=boundaries)
# Create function spaces
Q_E_Rho = FiniteElement("DG", mesh.ufl_cell(), k)
T_1 = FunctionSpace(mesh, 'DG', 0)
Qbar_E = FiniteElement("DGT", mesh.ufl_cell(), k)
Q_Rho = FunctionSpace(mesh, Q_E_Rho)
Qbar = FunctionSpace(mesh, Qbar_E)
phih, phih0 = Function(Q_Rho), Function(Q_Rho)
phibar = Function(Qbar)
# Advective velocity
# Swirling deformation advection (see LeVeque)
ux = 'pow(sin(pi*x[0]), 2) * sin(2*pi*x[1])'
vy = '-pow(sin(pi*x[1]), 2) * sin(2*pi*x[0])'
gt_plus = '0.5 * cos(pi*t)'
gt_min = '-0.5 * cos(pi*t)'
# Helper vectors
ex = as_vector([1.0, 0.0])
ey = as_vector([0.0, 1.0])
mesh = RectangleMesh(MPI.comm_world, Point(xmin, ymin), Point(xmax, ymax), nx,
ny)
n = FacetNormal(mesh)
# xdmf output
xdmf_u = XDMFFile(mesh.mpi_comm(), outdir_base + "u.xdmf")
xdmf_p = XDMFFile(mesh.mpi_comm(), outdir_base + "p.xdmf")
xdmf_rho = XDMFFile(mesh.mpi_comm(), outdir_base + "rho.xdmf")
# Function Spaces density tracking/pressure
T_1 = FunctionSpace(mesh, 'DG', 0)
Q_E_Rho = FiniteElement("DG", mesh.ufl_cell(), k)
# Vector valued function spaces for specific momentum tracking
W_E_2 = VectorElement("DG", mesh.ufl_cell(), k)
T_E_2 = VectorElement("DG", mesh.ufl_cell(), 0)
Wbar_E_2 = VectorElement("DGT", mesh.ufl_cell(), kbar)
Wbar_E_2_H12 = VectorElement("CG", mesh.ufl_cell(), kbar)["facet"]
# Function spaces for Stokes
Q_E = FiniteElement("DG", mesh.ufl_cell(), 0)
Qbar_E = FiniteElement("DGT", mesh.ufl_cell(), k)
# For Stokes
mixedL = FunctionSpace(mesh, MixedElement([W_E_2, Q_E]))
mixedG = FunctionSpace(mesh, MixedElement([Wbar_E_2_H12, Qbar_E]))
boundaries = MeshFunction('size_t', mesh, mesh.topology().dim() - 1)
boundaries.set_all(mark["Internal"])
wall=Noslip()
wall.mark(boundaries, mark["wall"])
left = Left()
left.mark(boundaries, mark["inlet"])
right = Right()
right.mark(boundaries, mark["outlet"])
ds = Measure('ds',domain=mesh,subdomain_data=boundaries)
n = FacetNormal(mesh)
# Define variational problem
k = 2
if(k>=2): # Taylor-Hood Function Space 3rd or higher order accurancy
V = VectorElement("CG", mesh.ufl_cell(), k)
Q = FiniteElement("CG", mesh.ufl_cell(), k-1)
W = FunctionSpace(mesh, V*Q)
else:
#Optional MINI element, 2nd order accurancy for velocity
# - MINI
P1 = FiniteElement("Lagrange", mesh.ufl_cell(), 1)
B = FiniteElement("Bubble", mesh.ufl_cell(), 3)
V = VectorElement(P1 + B)
Q = P1
W = FunctionSpace(mesh, V * Q)
# Define variational problem for stokes
(u, p) = TrialFunctions(W)
(v, q) = TestFunctions(W)
def test_eim_approximation_08(expression_type, basis_generation):
"""
The aim of this script is to test that DEIM correctly handles collapsed subspaces. This is a prototype of
the restricted operators required by the right-hand side of a supremizer solve.
* EIM: not applicable.
* DEIM: define a test function on a collapsed subspace (while, in case of rank 2 forms, the trial is defined
on the full space), and integrate.
"""
class MockProblem(ParametrizedProblem):
def __init__(self, V, **kwargs):
ParametrizedProblem.__init__(self, "")
self.V = V
def name(self):
return "MockProblem_08_" + expression_type + "_" + basis_generation
class ParametrizedFunctionApproximation(EIMApproximation):
def __init__(self, V, expression_type, basis_generation):
self.V = V
# Parametrized function to be interpolated
mock_problem = MockProblem(V)
f1 = ParametrizedExpression(mock_problem, "1/sqrt(pow(x[0]-mu[0], 2) + pow(x[1]-mu[1], 2) + 0.01)", mu=(-1., -1.), element=V.sub(1).ufl_element())
#
folder_prefix = os.path.join("test_eim_approximation_08_tempdir", expression_type, basis_generation)
assert expression_type in ("Vector", "Matrix")
if expression_type == "Vector":
q = TestFunction(V.sub(1).collapse())
form = f1*q*dx
# Call Parent constructor
EIMApproximation.__init__(self, mock_problem, ParametrizedTensorFactory(form), folder_prefix, basis_generation)
elif expression_type == "Matrix":
up = TrialFunction(V)
q = TestFunction(V.sub(1).collapse())
(u, p) = split(up)
form = f1*q*div(u)*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")
# 1. Create the mesh for this test
mesh = RectangleMesh(Point(0.1, 0.1), Point(0.9, 0.9), 20, 20)
# 2. Create Finite Element space (Lagrange P1)
element_0 = VectorElement("Lagrange", mesh.ufl_cell(), 2)
element_1 = FiniteElement("Lagrange", mesh.ufl_cell(), 1)
element = MixedElement(element_0, element_1)
V = FunctionSpace(mesh, element)
# 3. Allocate an object of the ParametrizedFunctionApproximation class
parametrized_function_approximation = ParametrizedFunctionApproximation(V, expression_type, basis_generation)
mu_range = [(-1., -0.01), (-1., -0.01)]
parametrized_function_approximation.set_mu_range(mu_range)
# 4. Prepare reduction with EIM
parametrized_function_reduction_method = EIMApproximationReductionMethod(parametrized_function_approximation)
parametrized_function_reduction_method.set_Nmax(20)
parametrized_function_reduction_method.set_tolerance(0.)
# 5. Perform the offline phase
parametrized_function_reduction_method.initialize_training_set(100, sampling=EquispacedDistribution())
reduced_parametrized_function_approximation = parametrized_function_reduction_method.offline()
# 6. Perform an online solve
online_mu = (-1., -1.)
reduced_parametrized_function_approximation.set_mu(online_mu)
reduced_parametrized_function_approximation.solve()
# 7. Perform an error analysis
parametrized_function_reduction_method.initialize_testing_set(100)
parametrized_function_reduction_method.error_analysis()
def test_eim_approximation_05(expression_type, basis_generation):
"""
This test is combination of tests 01-03.
The aim of this script is to test that integration correctly handles several parametrized expressions.
* EIM: not applicable.
* DEIM: several parametrized expressions are combined when defining forms.
"""
class MockProblem(ParametrizedProblem):
def __init__(self, V, **kwargs):
ParametrizedProblem.__init__(self, "")
self.V = V
def name(self):
return "MockProblem_05_" + expression_type + "_" + basis_generation
class ParametrizedFunctionApproximation(EIMApproximation):
def __init__(self, V, expression_type, basis_generation):
self.V = V
# Parametrized function to be interpolated
mock_problem = MockProblem(V)
f1 = ParametrizedExpression(
mock_problem, "1/sqrt(pow(x[0]-mu[0], 2) + pow(x[1]-mu[1], 2) + 0.01)", mu=(-1., -1.),
element=V.sub(1).ufl_element())
f2 = ParametrizedExpression(
mock_problem, "exp( - 2*pow(x[0]-mu[0], 2) - 2*pow(x[1]-mu[1], 2) )", mu=(-1., -1.),
element=V.sub(1).ufl_element())
f3 = ParametrizedExpression(
mock_problem, "(1-x[0])*cos(3*pi*(pi+mu[1])*(1+x[1]))*exp(-(pi+mu[0])*(1+x[0]))", mu=(-1., -1.),
element=V.sub(1).ufl_element())
#
folder_prefix = os.path.join("test_eim_approximation_05_tempdir", expression_type, basis_generation)
assert expression_type in ("Vector", "Matrix")
if expression_type == "Vector":
vq = TestFunction(V)
(v, q) = split(vq)
form = f1 * v[0] * dx + f2 * v[1] * dx + f3 * q * dx
# Call Parent constructor
EIMApproximation.__init__(
self, mock_problem, ParametrizedTensorFactory(form), folder_prefix, basis_generation)
elif expression_type == "Matrix":
up = TrialFunction(V)
vq = TestFunction(V)
(u, p) = split(up)
(v, q) = split(vq)
form = f1 * inner(grad(u), grad(v)) * dx + f2 * p * div(v) * dx + f3 * q * div(u) * 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")
# 1. Create the mesh for this test
mesh = RectangleMesh(Point(0.1, 0.1), Point(0.9, 0.9), 20, 20)
# 2. Create Finite Element space (Lagrange P1)
element_0 = VectorElement("Lagrange", mesh.ufl_cell(), 2)
element_1 = FiniteElement("Lagrange", mesh.ufl_cell(), 1)
element = MixedElement(element_0, element_1)
V = FunctionSpace(mesh, element)
# 3. Allocate an object of the ParametrizedFunctionApproximation class
parametrized_function_approximation = ParametrizedFunctionApproximation(V, expression_type, basis_generation)
mu_range = [(-1., -0.01), (-1., -0.01)]
parametrized_function_approximation.set_mu_range(mu_range)
# 4. Prepare reduction with EIM
parametrized_function_reduction_method = EIMApproximationReductionMethod(parametrized_function_approximation)
parametrized_function_reduction_method.set_Nmax(20)
parametrized_function_reduction_method.set_tolerance(0.)
# 5. Perform the offline phase
parametrized_function_reduction_method.initialize_training_set(100, sampling=EquispacedDistribution())
reduced_parametrized_function_approximation = parametrized_function_reduction_method.offline()
# 6. Perform an online solve
online_mu = (-1., -1.)
reduced_parametrized_function_approximation.set_mu(online_mu)
reduced_parametrized_function_approximation.solve()
# 7. Perform an error analysis
parametrized_function_reduction_method.initialize_testing_set(100)
parametrized_function_reduction_method.error_analysis()
# Mesh generation and refinement
nx = 80
ny = 80
mesh = RectangleMesh(Point(- 0.5 * Lx - Lpml, 0.0), Point(0.5 * Lx + Lpml, - Ly - Lpml), nx, ny, "crossed")
# Markers for Dirichlet bc
ff = MeshFunction("size_t", mesh, mesh.geometry().dim() - 1)
Dirichlet().mark(ff, 1)
# Markers for disk source
mf = MeshFunction("size_t", mesh, mesh.geometry().dim())
circle().mark(mf, 1)
# Create function spaces
VE = VectorElement("CG", mesh.ufl_cell(), 1, dim=2)
TE = TensorElement("DG", mesh.ufl_cell(), 0, shape=(2, 2), symmetry=True)
W = FunctionSpace(mesh, MixedElement([VE, TE]))
F = FunctionSpace(mesh, "CG", 2)
V = W.sub(0).collapse()
M = W.sub(1).collapse()
# Time stepping Parameters
omega_p = 8*DOLFIN_PI
dt = 0.0025
t = 0.0
t_end = 1
gamma = 0.50
beta = 0.25
Expression, Function, DOLFIN_EPS, DirichletBC, LogLevel, UserExpression, split, dx, set_log_level
from gryphon import backwardEuler
class InitialConditions(UserExpression):
def eval(self, values, x):
values[0] = 0.0
values[1] = 0.0
def value_shape(self):
return (2, )
# Define mesh, function space and test functions
mesh = RectangleMesh(Point(0.0, 0.0), Point(1.0, 1.0), 49, 49)
P1 = FiniteElement("Lagrange", mesh.ufl_cell(), 1)
ME = FunctionSpace(mesh, P1 * P1)
q1, q2 = TestFunctions(ME)
U1, U2 = TrialFunctions(ME)
# Define and interpolate initial condition
W = Function(ME)
W.interpolate(InitialConditions())
u, v = split(W)
domainSource = Expression(
"0.1*t*exp(-((x[0]-0.7)*(x[0]-0.7) + (x[1]-0.5)*(x[1]-0.5))/0.01)",
t=0,
degree=1)
# Define the right hand side for each of the PDEs
def test_moving_mesh():
t = 0.
dt = 0.025
num_steps = 20
xmin, ymin = 0., 0.
xmax, ymax = 2., 2.
xc, yc = 1., 1.
nx, ny = 20, 20
pres = 150
k = 1
mesh = RectangleMesh(Point(xmin, ymin), Point(xmax, ymax), nx, ny)
n = FacetNormal(mesh)
# Class for mesh motion
dU = PeriodicVelocity(xmin, xmax, dt, t, degree=1)
Qcg = VectorFunctionSpace(mesh, 'CG', 1)
boundaries = MeshFunction("size_t", mesh, mesh.topology().dim()-1)
boundaries.set_all(0)
leftbound = Left(xmin)
leftbound.mark(boundaries, 99)
ds = Measure('ds', domain=mesh, subdomain_data=boundaries)
# Create function spaces
Q_E_Rho = FiniteElement("DG", mesh.ufl_cell(), k)
T_1 = FunctionSpace(mesh, 'DG', 0)
Qbar_E = FiniteElement("DGT", mesh.ufl_cell(), k)
Q_Rho = FunctionSpace(mesh, Q_E_Rho)
Qbar = FunctionSpace(mesh, Qbar_E)
phih, phih0 = Function(Q_Rho), Function(Q_Rho)
phibar = Function(Qbar)
# Advective velocity
uh = Function(Qcg)
uh.assign(Constant((0., 0.)))
# Mesh velocity
umesh = Function(Qcg)
# 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, GaussianPulse(center=(xc, yc), sigma=float(0.25),
U=[0, 0], time=0., height=1., degree=3))
x = comm.bcast(x, root=0)
s = comm.bcast(s, root=0)
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, ds=ds)
forms_pde = FormsPDE.forms_theta_linear(phih0, uadvect, dt, Constant(1.0), zeta=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)
# Initialize the initial condition at mesh by an l2 projection
lstsq_rho = l2projection(p, Q_Rho, 1)
lstsq_rho.project(phih0.cpp_object())
for step in range(num_steps):
# Compute old area at old configuration
old_area = assemble(phih0*dx)
# Pre-assemble rhs
pde_projection.assemble_state_rhs()
# Move mesh
dU.compute_ubc()
umesh.assign(project(dU, Qcg))
ALE.move(mesh, project(dU * dt, Qcg))
dU.update()
# Relocate particles as a result of mesh motion
# NOTE: if particles were advected themselve,
# we had to run update_facets_info() here as well
p.relocate()
# Assemble left-hand side on new config, but not the right-hand side
pde_projection.assemble(True, False)
pde_projection.solve_problem(phibar.cpp_object(), phih.cpp_object(),
'mumps', 'none')
# Needed to compute conservation, note that there
# is an outgoing flux at left boundary
new_area = assemble(phih*dx)
gamma = conditional(ge(dot(uadvect, n), 0), 0, 1)
bflux = assemble((1-gamma) * dot(uadvect, n) * phih * ds)
# Update solution
assign(phih0, phih)
# Put assertion on (global) mass balance, local mass balance is
# too time consuming but should pass also
assert new_area - old_area + bflux * dt < 1e-12
# Assert that max value of phih stays close to 2 and
# min value close to 0. This typically will fail if
# we do not do a correct relocate of particles
assert np.amin(phih.vector().get_local()) > -0.015
assert np.amax(phih.vector().get_local()) < 1.04
