def test_eim_approximation_00(expression_type, basis_generation):
"""
This test deals with the trivial case of interpolating the zero function/vector/matrix,
as it is a corner case. Next files will deal with more interesting cases.
"""
class MockProblem(ParametrizedProblem):
def __init__(self, V, **kwargs):
ParametrizedProblem.__init__(self, "")
self.V = V
def name(self):
return "MockProblem_00_" + 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)
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")
# 1. Create the mesh for this test
mesh = IntervalMesh(10, 0., 1.)
# 2. Create Finite Element space (Lagrange P1)
V = FunctionSpace(mesh, "Lagrange", 1)
# 3. Allocate an object of the ParametrizedFunctionApproximation class
parametrized_function_approximation = ParametrizedFunctionApproximation(
V, expression_type, basis_generation)
mu_range = [
(0., 1.),
]
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(1)
# 5. Perform the offline phase
parametrized_function_reduction_method.initialize_training_set(
5, sampling=EquispacedDistribution())
reduced_parametrized_function_approximation = parametrized_function_reduction_method.offline(
)
assert reduced_parametrized_function_approximation.N == 1
# 6. Perform an online solve
online_mu = (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(5)
parametrized_function_reduction_method.error_analysis()
def test_eim_approximation_11(expression_type, basis_generation):
"""
The aim of this script is to test EIM/DEIM for nonlinear problems. A parametrized problem is defined
and reduced by means of a reduction method. Then:
* EIM: the expression to be interpolated is the solution of the nonlinear reduced problem.
* DEIM: the form to be interpolated contains the solution of the nonlinear reduced problem.
"""
@StoreMapFromProblemNameToProblem
@StoreMapFromProblemToTrainingStatus
@StoreMapFromSolutionToProblem
class MockProblem(ParametrizedProblem):
def __init__(self, V, **kwargs):
# Call parent
ParametrizedProblem.__init__(
self,
os.path.join("test_eim_approximation_11_tempdir",
expression_type, basis_generation,
"mock_problem"))
# Minimal subset of a ParametrizedDifferentialProblem
self.V = V
self._solution = Function(V)
self.components = ["u"]
# Parametrized function to be interpolated
x = SpatialCoordinate(V.mesh())
mu = SymbolicParameters(self, V, (1., ))
self.f = (1 - x[0]) * cos(3 * pi * mu[0] *
(1 + x[0])) * exp(-mu[0] * (1 + x[0]))
# Inner product
f = TrialFunction(self.V)
g = TestFunction(self.V)
self.inner_product = assemble(f * g * dx)
def name(self):
return "MockProblem_11_" + expression_type + "_" + basis_generation
def init(self):
pass
def solve(self):
assert not hasattr(self, "_is_solving")
self._is_solving = True
project(self.f, self.V, function=self._solution)
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_11_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 mu in 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(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, snapshot):
self.reduced_problem.basis_functions.enrich(snapshot)
self.GS.apply(self.reduced_problem.basis_functions, 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_11_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,
function):
self.V = truth_problem.V
#
folder_prefix = os.path.join("test_eim_approximation_11_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 = 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 = truth_problem._solution * u * v * 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 = IntervalMesh(100, -1., 1.)
# 2. Create Finite Element space (Lagrange P1)
V = FunctionSpace(mesh, "Lagrange", 1)
# 3. Create a parametrized problem
problem = MockProblem(V)
mu_range = [
(1., pi),
]
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(12,
sampling=EquispacedDistribution())
reduction_method.offline()
# 5. Allocate an object of the ParametrizedFunctionApproximation class
parametrized_function_approximation = ParametrizedFunctionApproximation(
problem, expression_type, basis_generation, lambda u: exp(u))
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(12)
parametrized_function_reduction_method.set_tolerance(0.)
# 7. Perform EIM offline phase
parametrized_function_reduction_method.initialize_training_set(
51, sampling=EquispacedDistribution())
reduced_parametrized_function_approximation = parametrized_function_reduction_method.offline(
)
# 8. Perform EIM online solve
online_mu = (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_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_14(expression_type, basis_generation):
"""
The aim of this script is to test EIM/DEIM for nonlinear problems, extending test 13.
The difference with respect to test 13 is that a parametrized problem is defined but it is not
reduced any further. See the description of EIM and DEIM for test 13, taking care of the fact
that the high fidelity solution is used in place of the 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_14_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., ))
self.f00 = (1 - x[0]) * cos(3 * pi * mu[0] *
(1 + x[0])) * exp(-mu[0] * (1 + x[0]))
self.f01 = (1 - x[0]) * sin(3 * pi * mu[0] *
(1 + x[0])) * exp(-mu[0] * (1 + x[0]))
# 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_14_" + 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_14_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.V1
(f0, _) = split(truth_problem._solution)
#
folder_prefix = os.path.join("test_eim_approximation_14_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(f0),
folder_prefix, basis_generation)
elif expression_type == "Vector":
v = TestFunction(self.V)
form = f0[0] * v * dx + f0[1] * v.dx(0) * 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 = f0[0] * u * v * dx + f0[1] * u.dx(0) * v * 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 = IntervalMesh(100, -1., 1.)
# 2. Create Finite Element space (Lagrange P1)
element_0 = VectorElement("Lagrange", mesh.ufl_cell(), 2, dim=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., pi),
]
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(12)
parametrized_function_reduction_method.set_tolerance(0.)
# 7. Perform EIM offline phase
parametrized_function_reduction_method.initialize_training_set(
51, sampling=EquispacedDistribution())
reduced_parametrized_function_approximation = parametrized_function_reduction_method.offline(
)
# 8. Perform EIM online solve
online_mu = (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()
def test_eim_approximation_03(expression_type, basis_generation):
"""
This is a third basic test for EIM/DEIM, based on the Gaussian function of tutorial 05.
* EIM: test interpolation of a scalar function
* DEIM: test interpolation of form with scalar integrand on a scalar space
"""
class MockProblem(ParametrizedProblem):
def __init__(self, V, **kwargs):
ParametrizedProblem.__init__(self, "")
self.V = V
def name(self):
return "MockProblem_03_" + 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)
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())
#
folder_prefix = os.path.join("test_eim_approximation_03_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")
# 1. Create the mesh for this test
mesh = Mesh("../../../tutorials/05_gaussian/data/gaussian.xml")
# 2. Create Finite Element space (Lagrange P1)
V = FunctionSpace(mesh, "Lagrange", 1)
# 3. Allocate an object of the ParametrizedFunctionApproximation class
parametrized_function_approximation = ParametrizedFunctionApproximation(
V, expression_type, basis_generation)
mu_range = [(-1.0, 1.0), (-1.0, 1.0)]
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_12(expression_type, basis_generation):
"""
The aim of this script is to test EIM/DEIM for nonlinear problems, extending test 11.
The difference with respect to test 11 is that a parametrized problem is defined but it is not
reduced any further.
Thus, the high fidelity solution will be used inside the parametrized expression/tensor, while
in test 11 the reduced order solution was being used.
* EIM: the expression to be interpolated is the solution of the nonlinear high fidelity problem.
* DEIM: the form to be interpolated contains the solution of the nonlinear high fidelity problem.
"""
@StoreMapFromProblemNameToProblem
@StoreMapFromProblemToTrainingStatus
@StoreMapFromSolutionToProblem
class MockProblem(ParametrizedProblem):
def __init__(self, V, **kwargs):
# Call parent
ParametrizedProblem.__init__(self, os.path.join("test_eim_approximation_12_tempdir", expression_type, basis_generation, "mock_problem"))
# Minimal subset of a ParametrizedDifferentialProblem
self.V = V
self._solution = Function(V)
self.components = ["u"]
# Parametrized function to be interpolated
x = SpatialCoordinate(V.mesh())
mu = SymbolicParameters(self, V, (1., ))
self.f = (1-x[0])*cos(3*pi*mu[0]*(1+x[0]))*exp(-mu[0]*(1+x[0]))
# Inner product
f = TrialFunction(self.V)
g = TestFunction(self.V)
self.inner_product = assemble(f*g*dx)
def name(self):
return "MockProblem_12_" + 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
project(self.f, self.V, function=self._solution)
delattr(self, "_is_solving")
return self._solution
class ParametrizedFunctionApproximation(EIMApproximation):
def __init__(self, truth_problem, expression_type, basis_generation, function):
self.V = truth_problem.V
#
folder_prefix = os.path.join("test_eim_approximation_12_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 = 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 = truth_problem._solution*u*v*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 = IntervalMesh(100, -1., 1.)
# 2. Create Finite Element space (Lagrange P1)
V = FunctionSpace(mesh, "Lagrange", 1)
# 3. Create a parametrized problem
problem = MockProblem(V)
mu_range = [(1., pi), ]
problem.set_mu_range(mu_range)
# 4. Postpone generation of the reduced problem
# 5. Allocate an object of the ParametrizedFunctionApproximation class
parametrized_function_approximation = ParametrizedFunctionApproximation(problem, expression_type, basis_generation, lambda u: exp(u))
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(12)
parametrized_function_reduction_method.set_tolerance(0.)
# 7. Perform EIM offline phase
parametrized_function_reduction_method.initialize_training_set(51, sampling=EquispacedDistribution())
reduced_parametrized_function_approximation = parametrized_function_reduction_method.offline()
# 8. Perform EIM online solve
online_mu = (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_07(expression_type, basis_generation):
"""
The aim of this test is to check the interpolation of tensor valued functions.
* EIM: test interpolation of a scalar function
* DEIM: test interpolation of form with integrand given by the inner product of a vector valued function
and some derivative of a test/trial functions of a vector function space
"""
class MockProblem(ParametrizedProblem):
def __init__(self, V, **kwargs):
ParametrizedProblem.__init__(self, "")
self.V = V
def name(self):
return "MockProblem_07_" + 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)
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")
# 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)
V = VectorFunctionSpace(mesh, "Lagrange", 1)
# 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(50)
parametrized_function_reduction_method.set_tolerance(0.)
# 5. Perform the offline phase
parametrized_function_reduction_method.initialize_training_set(225, 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(225)
parametrized_function_reduction_method.error_analysis()
def test_eim_approximation_13(expression_type, basis_generation):
"""
The aim of this script is to test EIM/DEIM for nonlinear problems on mixed function spaces.
This test is an extension of test 11. The main difference with respect to test 11 is that a only a component
of the reduced order solution is required to define the parametrized expression/tensor.
* EIM: the expression to be interpolated is a component of the solution of the nonlinear reduced problem.
This results in a parametrized expression of type ListTensor.
* DEIM: the form to be interpolated contains a component of the solution of the nonlinear reduced problem,
split between x and y. This results in two coefficients in the integrand (denoted by f0[0] and f1[0] below)
which are of type Indexed.
"""
@StoreMapFromProblemNameToProblem
@StoreMapFromProblemToTrainingStatus
@StoreMapFromSolutionToProblem
class MockProblem(ParametrizedProblem):
def __init__(self, V, **kwargs):
# Call parent
ParametrizedProblem.__init__(
self,
os.path.join("test_eim_approximation_13_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., ))
self.f00 = (1 - x[0]) * cos(3 * pi * mu[0] *
(1 + x[0])) * exp(-mu[0] * (1 + x[0]))
self.f01 = (1 - x[0]) * sin(3 * pi * mu[0] *
(1 + x[0])) * exp(-mu[0] * (1 + x[0]))
# 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_13_" + 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
@UpdateMapFromProblemToTrainingStatus
class MockReductionMethod(ReductionMethod):
def __init__(self, truth_problem, **kwargs):
# Call parent
ReductionMethod.__init__(
self,
os.path.join("test_eim_approximation_13_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()
component = "u" if index % 2 == 0 else "s"
self.reduced_problem.basis_functions.enrich(f, component)
self.GS.apply(
self.reduced_problem.basis_functions[component], 0)
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 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_13_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.V1
(f0, _) = split(truth_problem._solution)
#
folder_prefix = os.path.join("test_eim_approximation_13_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(f0),
folder_prefix, basis_generation)
elif expression_type == "Vector":
v = TestFunction(self.V)
form = f0[0] * v * dx + f0[1] * v.dx(0) * 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 = f0[0] * u * v * dx + f0[1] * u.dx(0) * v * 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 = IntervalMesh(100, -1., 1.)
# 2. Create Finite Element space (Lagrange P1)
element_0 = VectorElement("Lagrange", mesh.ufl_cell(), 2, dim=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., pi),
]
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(12,
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(12)
parametrized_function_reduction_method.set_tolerance(0.)
# 7. Perform EIM offline phase
parametrized_function_reduction_method.initialize_training_set(
51, sampling=EquispacedDistribution())
reduced_parametrized_function_approximation = parametrized_function_reduction_method.offline(
)
# 8. Perform EIM online solve
online_mu = (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_09(expression_type, basis_generation):
"""
This test is an extension of test 01.
The aim of this script is to test the detection of parametrized expression defined using SymbolicParameters
for mu and SpatialCoordinates for x.
* EIM: test the case when the expression to be interpolated is an Operator (rather than an Expression).
* DEIM: test interpolation of form with integrand function of type Operator (rather than Expression).
"""
class MockProblem(ParametrizedProblem):
def __init__(self, V, **kwargs):
ParametrizedProblem.__init__(self, "")
self.V = V
def name(self):
return "MockProblem_09_" + expression_type + "_" + basis_generation
class ParametrizedFunctionApproximation(EIMApproximation):
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")
# 1. Create the mesh for this test
mesh = IntervalMesh(100, -1., 1.)
# 2. Create Finite Element space (Lagrange P1)
V = FunctionSpace(mesh, "Lagrange", 1)
# 3. Create a parametrized problem
mock_problem = MockProblem(V)
mu_range = [
(1., pi),
]
mock_problem.set_mu_range(mu_range)
# 4. Allocate an object of the ParametrizedFunctionApproximation class
parametrized_function_approximation = ParametrizedFunctionApproximation(
mock_problem, expression_type, basis_generation)
# 5. Prepare reduction with EIM
parametrized_function_reduction_method = EIMApproximationReductionMethod(
parametrized_function_approximation)
parametrized_function_reduction_method.set_Nmax(30)
parametrized_function_reduction_method.set_tolerance(0.)
# 6. Perform the offline phase
parametrized_function_reduction_method.initialize_training_set(
51, sampling=EquispacedDistribution())
reduced_parametrized_function_approximation = parametrized_function_reduction_method.offline(
)
# 7. Perform an online solve
online_mu = (1., )
reduced_parametrized_function_approximation.set_mu(online_mu)
reduced_parametrized_function_approximation.solve()
# 8. Perform an error analysis
parametrized_function_reduction_method.initialize_testing_set(100)
parametrized_function_reduction_method.error_analysis()
def test_eim_approximation_04(expression_type, basis_generation):
"""
This test is an extension of test 03.
The aim of this script is to test that integration of a subdomain is correctly handled by DEIM.
* EIM: not applicable, as there is no difference with respect to test 03.
* DEIM: the integral in form definitions is now restricted to a subdomain.
"""
class MockProblem(ParametrizedProblem):
def __init__(self, V, **kwargs):
ParametrizedProblem.__init__(self, "")
self.V = V
def name(self):
return "MockProblem_04_" + expression_type + "_" + basis_generation
class ParametrizedFunctionApproximation(EIMApproximation):
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")
# 1. Create the mesh for this test
mesh = Mesh("../../../tutorials/01_thermal_block/data/thermal_block.xml")
subdomains = MeshFunction(
"size_t", mesh,
"../../../tutorials/01_thermal_block/data/thermal_block_physical_region.xml"
)
# 2. Create Finite Element space (Lagrange P1)
V = FunctionSpace(mesh, "Lagrange", 1)
# 3. Allocate an object of the ParametrizedFunctionApproximation class
parametrized_function_approximation = ParametrizedFunctionApproximation(
V, subdomains, expression_type, basis_generation)
mu_range = [(-1.0, 1.0), (-1.0, 1.0)]
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_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_10(expression_type, basis_generation):
"""
This test is an extension of test 01.
The aim of this script is to test the detection of time dependent parametrized expression.
* EIM: test the case when the expression to be interpolated is time dependent.
* DEIM: test interpolation of form with a time dependent integrand function.
"""
class MockTimeDependentProblem(ParametrizedProblem):
def __init__(self, V, **kwargs):
ParametrizedProblem.__init__(self, "")
self.V = V
# Minimal subset of a time dependent ParametrizedDifferentialProblem
self.t0 = 0.
self.t = 0.
self.dt = 0.
self.T = 0.
def name(self):
return "MockTimeDependentProblem_10_" + expression_type + "_" + basis_generation
def set_initial_time(self, t0):
self.t0 = t0
def set_time(self, t):
self.t = t
def set_time_step_size(self, dt):
self.dt = dt
def set_final_time(self, T):
self.T = T
class ParametrizedFunctionApproximation(TimeDependentEIMApproximation):
def __init__(self, V, expression_type, basis_generation):
self.V = V
# Parametrized function to be interpolated
mock_time_dependent_problem = MockTimeDependentProblem(V)
f = ParametrizedExpression(
mock_time_dependent_problem,
"(1-x[0])*cos(3*pi*(1+t)*(1+x[0]))*exp(-(1+t)*(1+x[0]))",
mu=(),
t=0.,
element=V.ufl_element())
#
folder_prefix = os.path.join("test_eim_approximation_10_tempdir",
expression_type, basis_generation)
assert expression_type in ("Function", "Vector", "Matrix")
if expression_type == "Function":
# Call Parent constructor
TimeDependentEIMApproximation.__init__(
self, mock_time_dependent_problem,
ParametrizedExpressionFactory(f), folder_prefix,
basis_generation)
elif expression_type == "Vector":
v = TestFunction(V)
form = f * v * dx
# Call Parent constructor
TimeDependentEIMApproximation.__init__(
self, mock_time_dependent_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
TimeDependentEIMApproximation.__init__(
self, mock_time_dependent_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 = IntervalMesh(100, -1., 1.)
# 2. Create Finite Element space (Lagrange P1)
V = FunctionSpace(mesh, "Lagrange", 1)
# 3. Allocate an object of the ParametrizedFunctionApproximation class
parametrized_function_approximation = ParametrizedFunctionApproximation(
V, expression_type, basis_generation)
mu_range = []
parametrized_function_approximation.set_mu_range(mu_range)
parametrized_function_approximation.set_time_step_size(1.e-10)
parametrized_function_approximation.set_final_time(pi - 1)
# 4. Prepare reduction with EIM
parametrized_function_reduction_method = TimeDependentEIMApproximationReductionMethod(
parametrized_function_approximation)
parametrized_function_reduction_method.set_Nmax(30)
parametrized_function_reduction_method.set_tolerance(0.)
# 5. Perform the offline phase
parametrized_function_reduction_method.initialize_training_set(
51, time_sampling=EquispacedDistribution())
reduced_parametrized_function_approximation = parametrized_function_reduction_method.offline(
)
# 6. Perform an online solve
online_mu = ()
online_t = 0.
reduced_parametrized_function_approximation.set_mu(online_mu)
reduced_parametrized_function_approximation.set_time(online_t)
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_01(expression_type, basis_generation):
"""
This is the first basic test for EIM/DEIM, based on the test case of section 3.3.1 of
S. Chaturantabut and D. C. Sorensen
Nonlinear Model Reduction via Discrete Empirical Interpolation
SIAM Journal on Scientific Computing 2010 32:5, 2737-2764
* EIM: test interpolation of a scalar function
* DEIM: test interpolation of form with scalar integrand on a scalar space
"""
class MockProblem(ParametrizedProblem):
def __init__(self, V, **kwargs):
ParametrizedProblem.__init__(self, "")
self.V = V
def name(self):
return "MockProblem_01_" + 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)
f = ParametrizedExpression(mock_problem, "(1-x[0])*cos(3*pi*mu[0]*(1+x[0]))*exp(-mu[0]*(1+x[0]))", mu=(1., ), element=V.ufl_element())
#
folder_prefix = os.path.join("test_eim_approximation_01_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")
# 1. Create the mesh for this test
mesh = IntervalMesh(100, -1., 1.)
# 2. Create Finite Element space (Lagrange P1)
V = FunctionSpace(mesh, "Lagrange", 1)
# 3. Allocate an object of the ParametrizedFunctionApproximation class
parametrized_function_approximation = ParametrizedFunctionApproximation(V, expression_type, basis_generation)
mu_range = [(1., pi), ]
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(30)
parametrized_function_reduction_method.set_tolerance(0.)
# 5. Perform the offline phase
parametrized_function_reduction_method.initialize_training_set(51, sampling=EquispacedDistribution())
reduced_parametrized_function_approximation = parametrized_function_reduction_method.offline()
# 6. Perform an online solve
online_mu = (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_23(expression_type, basis_generation):
"""
This test is an extension of test 23, which splits the parameter independent part of the expression into
an auxiliary (non-parametrized) function. In contrast to tests 11-22, the auxiliary function is not the
solution of a problem: a corresponding auxiliary problem is created automatically.
"""
class MockProblem(ParametrizedProblem):
def __init__(self, V, **kwargs):
ParametrizedProblem.__init__(self, "")
self.V = V
def name(self):
return "MockProblem_23_" + 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)
f = project(Expression("(1-x[0])", element=V.ufl_element()), V)
g = ParametrizedExpression(mock_problem, "cos(3*pi*mu[0]*(1+x[0]))*exp(-mu[0]*(1+x[0]))", mu=(1., ),
element=V.ufl_element())
#
folder_prefix = os.path.join("test_eim_approximation_23_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 * g), folder_prefix, basis_generation)
elif expression_type == "Vector":
v = TestFunction(V)
form = f * g * 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 * g * 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")
# 1. Create the mesh for this test
mesh = IntervalMesh(100, -1., 1.)
# 2. Create Finite Element space (Lagrange P1)
V = FunctionSpace(mesh, "Lagrange", 1)
# 3. Allocate an object of the ParametrizedFunctionApproximation class
parametrized_function_approximation = ParametrizedFunctionApproximation(V, expression_type, basis_generation)
mu_range = [(1., pi), ]
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(30)
parametrized_function_reduction_method.set_tolerance(0.)
# 5. Perform the offline phase
parametrized_function_reduction_method.initialize_training_set(51, sampling=EquispacedDistribution())
reduced_parametrized_function_approximation = parametrized_function_reduction_method.offline()
# 6. Perform an online solve
online_mu = (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()
