def _evaluate(expression: (Matrix.Type(), Vector.Type(), Function.Type(),
TensorsList, FunctionsList,
ParametrizedTensorFactory,
ParametrizedExpressionFactory),
at: (ReducedMesh, ReducedVertices, None) = None,
**kwargs):
return evaluate_base(expression, at, **kwargs)
def _abs(expression: (Function.Type(), Operator)):
function = function_from_ufl_operators(expression)
space = function.function_space()
abs_output = abs(function.vector())
value_max = abs_output.max_abs_return_value
global_dof_max = abs_output.max_abs_return_location
assert len(global_dof_max) == 1
global_dof_max = global_dof_max[0]
coordinates_max = get_global_dof_coordinates(global_dof_max, space)
component_max = get_global_dof_component(global_dof_max, space)
# Prettify print
coordinates_max_component_max_dof_max = PrettyTuple(coordinates_max, component_max, global_dof_max)
return AbsOutput(value_max, coordinates_max_component_max_dof_max)
def _export(
solution: (
Function.Type(),
Matrix.Type(),
Vector.Type()
),
directory: (
Folders.Folder,
str
),
filename: str,
suffix: (
int,
None
) = None,
component: (
int,
str,
None
) = None
):
export_base(solution, directory, filename, suffix, component)
def _assign(object_to: Function.Type(), object_from: Function.Type()):
if object_from is not object_to:
dolfin_assign(object_to, object_from)
def _assign(object_to: Function.Type(), object_from: Operator):
dolfin_assign(object_to, function_from_ufl_operators(object_from))
from ufl.core.operator import Operator
from rbnics.backends.basic import transpose as basic_transpose
from rbnics.backends.dolfin.basis_functions_matrix import BasisFunctionsMatrix
from rbnics.backends.dolfin.evaluate import evaluate
from rbnics.backends.dolfin.function import Function
from rbnics.backends.dolfin.functions_list import FunctionsList
from rbnics.backends.dolfin.matrix import Matrix
from rbnics.backends.dolfin.non_affine_expansion_storage import NonAffineExpansionStorage
from rbnics.backends.dolfin.parametrized_tensor_factory import ParametrizedTensorFactory
from rbnics.backends.dolfin.tensors_list import TensorsList
from rbnics.backends.dolfin.vector import Vector
from rbnics.backends.dolfin.wrapping import function_from_ufl_operators, function_to_vector, matrix_mul_vector, vector_mul_vector, vectorized_matrix_inner_vectorized_matrix
from rbnics.backends.online import OnlineMatrix, OnlineVector
from rbnics.utils.decorators import backend_for, ModuleWrapper
def AdditionalIsFunction(arg):
return isinstance(arg, Operator)
def ConvertAdditionalFunctionTypes(arg):
assert isinstance(arg, Operator)
return function_from_ufl_operators(arg)
backend = ModuleWrapper(BasisFunctionsMatrix, evaluate, Function, FunctionsList, Matrix, NonAffineExpansionStorage, ParametrizedTensorFactory, TensorsList, Vector)
wrapping = ModuleWrapper(function_to_vector, matrix_mul_vector, vector_mul_vector, vectorized_matrix_inner_vectorized_matrix)
online_backend = ModuleWrapper(OnlineMatrix=OnlineMatrix, OnlineVector=OnlineVector)
online_wrapping = ModuleWrapper()
transpose_base = basic_transpose(backend, wrapping, online_backend, online_wrapping, AdditionalIsFunction, ConvertAdditionalFunctionTypes)
@backend_for("dolfin", inputs=((BasisFunctionsMatrix, Function.Type(), FunctionsList, Matrix.Type(), Operator, ParametrizedTensorFactory, TensorsList, Vector.Type()), ))
def transpose(arg):
return transpose_base(arg)
# Copyright (C) 2015-2021 by the RBniCS authors
#
# This file is part of RBniCS.
#
# SPDX-License-Identifier: LGPL-3.0-or-later
from ufl.core.operator import Operator
from dolfin import assign as dolfin_assign
from rbnics.backends.dolfin.function import Function
from rbnics.backends.dolfin.matrix import Matrix
from rbnics.backends.dolfin.vector import Vector
from rbnics.backends.dolfin.wrapping import function_from_ufl_operators, to_petsc4py
from rbnics.utils.decorators import backend_for, list_of, overload
@backend_for("dolfin", inputs=((Function.Type(), list_of(Function.Type()), Matrix.Type(), Vector.Type()),
(Function.Type(), list_of(Function.Type()), Matrix.Type(), Operator, Vector.Type())))
def assign(object_to, object_from):
_assign(object_to, object_from)
@overload
def _assign(object_to: Function.Type(), object_from: Function.Type()):
if object_from is not object_to:
dolfin_assign(object_to, object_from)
@overload
def _assign(object_to: Function.Type(), object_from: Operator):
dolfin_assign(object_to, function_from_ufl_operators(object_from))
# You should have received a copy of the GNU Lesser General Public License
# along with RBniCS. If not, see <http://www.gnu.org/licenses/>.
#
from math import fabs
from ufl.core.operator import Operator
from rbnics.backends.dolfin.matrix import Matrix
from rbnics.backends.dolfin.vector import Vector
from rbnics.backends.dolfin.function import Function
from rbnics.backends.dolfin.wrapping import function_from_ufl_operators, get_global_dof_coordinates, get_global_dof_component, to_petsc4py
from rbnics.utils.decorators import backend_for, overload
from rbnics.utils.mpi import parallel_max
# abs function to compute maximum absolute value of an expression, matrix or vector (for EIM). To be used in combination with max
# even though here we actually carry out both the max and the abs!
@backend_for("dolfin", inputs=((Matrix.Type(), Vector.Type(), Function.Type(), Operator), ))
def abs(expression):
return _abs(expression)
@overload
def _abs(matrix: Matrix.Type()):
# Note: PETSc offers a method MatGetRowMaxAbs, but it is not wrapped in petsc4py. We do the same by hand
mat = to_petsc4py(matrix)
row_start, row_end = mat.getOwnershipRange()
i_max, j_max = None, None
value_max = None
for i in range(row_start, row_end):
cols, vals = mat.getRow(i)
for (c, v) in zip(cols, vals):
if value_max is None or fabs(v) > fabs(value_max):
i_max = i
def _generate_space(expression: Function.Type()):
return expression.function_space()
def AdditionalIsFunction(arg):
return isinstance(arg, Operator)
def ConvertAdditionalFunctionTypes(arg):
assert isinstance(arg, Operator)
return function_from_ufl_operators(arg)
backend = ModuleWrapper(BasisFunctionsMatrix, evaluate, Function,
FunctionsList, Matrix, NonAffineExpansionStorage,
ParametrizedTensorFactory, TensorsList, Vector)
wrapping = ModuleWrapper(function_to_vector, matrix_mul_vector,
vector_mul_vector,
vectorized_matrix_inner_vectorized_matrix)
online_backend = ModuleWrapper(OnlineMatrix=OnlineMatrix,
OnlineVector=OnlineVector)
online_wrapping = ModuleWrapper()
transpose_base = basic_transpose(backend, wrapping, online_backend,
online_wrapping, AdditionalIsFunction,
ConvertAdditionalFunctionTypes)
@backend_for("dolfin",
inputs=((BasisFunctionsMatrix, Function.Type(), FunctionsList,
Matrix.Type(), Operator, ParametrizedTensorFactory,
TensorsList, Vector.Type()), ))
def transpose(arg):
return transpose_base(arg)
# Copyright (C) 2015-2021 by the RBniCS authors
#
# This file is part of RBniCS.
#
# SPDX-License-Identifier: LGPL-3.0-or-later
from rbnics.backends.basic import copy as basic_copy
from rbnics.backends.dolfin.function import Function
from rbnics.backends.dolfin.matrix import Matrix
from rbnics.backends.dolfin.vector import Vector
from rbnics.backends.dolfin.wrapping import function_copy, tensor_copy
from rbnics.utils.decorators import backend_for, list_of, ModuleWrapper
backend = ModuleWrapper(Function, Matrix, Vector)
wrapping = ModuleWrapper(function_copy, tensor_copy)
copy_base = basic_copy(backend, wrapping)
@backend_for("dolfin",
inputs=((Function.Type(), list_of(Function.Type()), Matrix.Type(),
Vector.Type()), ))
def copy(arg):
return copy_base(arg)
# SPDX-License-Identifier: LGPL-3.0-or-later
from ufl import Form
from dolfin import assemble, DirichletBC, PETScLUSolver
from rbnics.backends.abstract import LinearSolver as AbstractLinearSolver, LinearProblemWrapper
from rbnics.backends.dolfin.evaluate import evaluate
from rbnics.backends.dolfin.function import Function
from rbnics.backends.dolfin.matrix import Matrix
from rbnics.backends.dolfin.parametrized_tensor_factory import ParametrizedTensorFactory
from rbnics.backends.dolfin.vector import Vector
from rbnics.backends.dolfin.wrapping.dirichlet_bc import ProductOutputDirichletBC
from rbnics.utils.decorators import BackendFor, dict_of, list_of, overload
@BackendFor("dolfin", inputs=((Form, Matrix.Type(), ParametrizedTensorFactory, LinearProblemWrapper),
Function.Type(), (Form, ParametrizedTensorFactory, Vector.Type(), None),
(list_of(DirichletBC), ProductOutputDirichletBC, dict_of(str, list_of(DirichletBC)),
dict_of(str, ProductOutputDirichletBC), None)))
class LinearSolver(AbstractLinearSolver):
@overload((Form, Matrix.Type(), ParametrizedTensorFactory),
Function.Type(), (Form, ParametrizedTensorFactory, Vector.Type()),
(list_of(DirichletBC), ProductOutputDirichletBC, dict_of(str, list_of(DirichletBC)),
dict_of(str, ProductOutputDirichletBC), None))
def __init__(self, lhs, solution, rhs, bcs=None):
self.solution = solution
self._init_lhs(lhs, bcs)
self._init_rhs(rhs, bcs)
self._apply_bcs(bcs)
self._linear_solver = "default"
self.monitor = None
class LinearSolver(AbstractLinearSolver):
@overload((Form, Matrix.Type(), ParametrizedTensorFactory),
Function.Type(), (Form, ParametrizedTensorFactory, Vector.Type()),
(list_of(DirichletBC), ProductOutputDirichletBC, dict_of(str, list_of(DirichletBC)),
dict_of(str, ProductOutputDirichletBC), None))
def __init__(self, lhs, solution, rhs, bcs=None):
self.solution = solution
self._init_lhs(lhs, bcs)
self._init_rhs(rhs, bcs)
self._apply_bcs(bcs)
self._linear_solver = "default"
self.monitor = None
@overload(LinearProblemWrapper, Function.Type())
def __init__(self, problem_wrapper, solution):
self.__init__(problem_wrapper.matrix_eval(), solution, problem_wrapper.vector_eval(), problem_wrapper.bc_eval())
self.monitor = problem_wrapper.monitor
@overload(Form, (list_of(DirichletBC), ProductOutputDirichletBC, dict_of(str, list_of(DirichletBC)),
dict_of(str, ProductOutputDirichletBC), None))
def _init_lhs(self, lhs, bcs):
self.lhs = assemble(lhs, keep_diagonal=True)
@overload(ParametrizedTensorFactory, (list_of(DirichletBC), ProductOutputDirichletBC,
dict_of(str, list_of(DirichletBC)), dict_of(str, ProductOutputDirichletBC),
None))
def _init_lhs(self, lhs, bcs):
self.lhs = evaluate(lhs)
@overload(Matrix.Type(), None)
def _init_lhs(self, lhs, bcs):
self.lhs = lhs
@overload(Matrix.Type(), (list_of(DirichletBC), ProductOutputDirichletBC, dict_of(str, list_of(DirichletBC)),
dict_of(str, ProductOutputDirichletBC)))
def _init_lhs(self, lhs, bcs):
# Create a copy of lhs, in order not to change
# the original references when applying bcs
self.lhs = lhs.copy()
@overload(Form, (list_of(DirichletBC), ProductOutputDirichletBC, dict_of(str, list_of(DirichletBC)),
dict_of(str, ProductOutputDirichletBC), None))
def _init_rhs(self, rhs, bcs):
self.rhs = assemble(rhs)
@overload(ParametrizedTensorFactory, (list_of(DirichletBC), ProductOutputDirichletBC,
dict_of(str, list_of(DirichletBC)), dict_of(str, ProductOutputDirichletBC),
None))
def _init_rhs(self, rhs, bcs):
self.rhs = evaluate(rhs)
@overload(Vector.Type(), None)
def _init_rhs(self, rhs, bcs):
self.rhs = rhs
@overload(Vector.Type(), (list_of(DirichletBC), ProductOutputDirichletBC, dict_of(str, list_of(DirichletBC)),
dict_of(str, ProductOutputDirichletBC)))
def _init_rhs(self, rhs, bcs):
# Create a copy of rhs, in order not to change
# the original references when applying bcs
self.rhs = rhs.copy()
@overload(None)
def _apply_bcs(self, bcs):
pass
@overload((list_of(DirichletBC), ProductOutputDirichletBC))
def _apply_bcs(self, bcs):
for bc in bcs:
bc.apply(self.lhs, self.rhs)
@overload((dict_of(str, list_of(DirichletBC)), dict_of(str, ProductOutputDirichletBC)))
def _apply_bcs(self, bcs):
for key in bcs:
for bc in bcs[key]:
bc.apply(self.lhs, self.rhs)
def set_parameters(self, parameters):
assert len(parameters) in (0, 1)
if len(parameters) == 1:
assert "linear_solver" in parameters
self._linear_solver = parameters.get("linear_solver", "default")
def solve(self):
solver = PETScLUSolver(self._linear_solver)
solver.solve(self.lhs, self.solution.vector(), self.rhs)
if self.monitor is not None:
self.monitor(self.solution)
def _AffineExpansionStorage(args: tuple_of(Function.Type())):
return AffineExpansionStorage_Function(args)
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with RBniCS. If not, see <http://www.gnu.org/licenses/>.
#
from ufl import Form
from dolfin import assemble, DirichletBC
from rbnics.backends.abstract import AffineExpansionStorage as AbstractAffineExpansionStorage
from rbnics.backends.dolfin.matrix import Matrix
from rbnics.backends.dolfin.vector import Vector
from rbnics.backends.dolfin.function import Function
from rbnics.utils.decorators import backend_for, list_of, overload, tuple_of
# Generic backend
@backend_for("dolfin", inputs=((tuple_of(list_of(DirichletBC)), tuple_of(Form), tuple_of(Function.Type()), tuple_of(Matrix.Type()), tuple_of(Vector.Type()), tuple_of((Form, Matrix.Type())), tuple_of((Form, Vector.Type()))), ))
def AffineExpansionStorage(args):
return _AffineExpansionStorage(args)
# Base implementation
class AffineExpansionStorage_Base(AbstractAffineExpansionStorage):
def __init__(self, args):
self._content = None
def __getitem__(self, key):
return self._content[key]
def __iter__(self):
return self._content.__iter__()
def __len__(self):
from ufl import Form
from dolfin import assemble, DirichletBC, PETScLUSolver
from rbnics.backends.abstract import LinearSolver as AbstractLinearSolver, LinearProblemWrapper
from rbnics.backends.dolfin.evaluate import evaluate
from rbnics.backends.dolfin.function import Function
from rbnics.backends.dolfin.matrix import Matrix
from rbnics.backends.dolfin.parametrized_tensor_factory import ParametrizedTensorFactory
from rbnics.backends.dolfin.vector import Vector
from rbnics.backends.dolfin.wrapping.dirichlet_bc import ProductOutputDirichletBC
from rbnics.utils.decorators import BackendFor, dict_of, list_of, overload
@BackendFor("dolfin",
inputs=((Form, Matrix.Type(), ParametrizedTensorFactory,
LinearProblemWrapper), Function.Type(),
(Form, ParametrizedTensorFactory, Vector.Type(),
None), (list_of(DirichletBC), ProductOutputDirichletBC,
dict_of(str, list_of(DirichletBC)),
dict_of(str, ProductOutputDirichletBC), None)))
class LinearSolver(AbstractLinearSolver):
@overload((Form, Matrix.Type(), ParametrizedTensorFactory),
Function.Type(),
(Form, ParametrizedTensorFactory, Vector.Type()),
(list_of(DirichletBC), ProductOutputDirichletBC,
dict_of(str, list_of(DirichletBC)),
dict_of(str, ProductOutputDirichletBC), None))
def __init__(self, lhs, solution, rhs, bcs=None):
self.solution = solution
self._init_lhs(lhs, bcs)
self._init_rhs(rhs, bcs)
def _assign(object_to: list_of(Function.Type()), object_from: list_of(Function.Type())):
if object_from is not object_to:
del object_to[:]
object_to.extend(object_from)
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with RBniCS. If not, see <http://www.gnu.org/licenses/>.
#
from numbers import Number
from scipy.integrate import simps
from rbnics.backends.abstract import TimeQuadrature as AbstractTimeQuadrature
from rbnics.backends.dolfin.function import Function
from rbnics.backends.dolfin.wrapping import function_copy
from rbnics.utils.decorators import BackendFor, list_of, tuple_of
@BackendFor("dolfin", inputs=(tuple_of(Number), list_of(Function.Type())))
class TimeQuadrature(AbstractTimeQuadrature):
def __init__(self, time_interval, function_over_time):
assert len(function_over_time) > 1
self._time_step_size = (time_interval[1] - time_interval[0]) / (
len(function_over_time) - 1)
self._function_over_time = function_over_time
def integrate(self):
vector_over_time = list()
for function in self._function_over_time:
vector_over_time.append(function.vector().get_local())
integrated_vector = simps(vector_over_time,
dx=self._time_step_size,
axis=0)
integrated_function = function_copy(self._function_over_time[0])
from dolfin import GenericMatrix, GenericVector
from rbnics.backends.abstract import TimeStepping as AbstractTimeStepping, TimeDependentProblemWrapper
from rbnics.backends.basic.wrapping.petsc_ts_integrator import BasicPETScTSIntegrator
from rbnics.backends.dolfin.assign import assign
from rbnics.backends.dolfin.evaluate import evaluate
from rbnics.backends.dolfin.function import Function
from rbnics.backends.dolfin.parametrized_tensor_factory import ParametrizedTensorFactory
from rbnics.backends.dolfin.wrapping import get_default_linear_solver, get_mpi_comm, to_petsc4py
from rbnics.backends.dolfin.wrapping.dirichlet_bc import ProductOutputDirichletBC
from rbnics.utils.decorators import BackendFor, dict_of, list_of, ModuleWrapper, overload
backend = ModuleWrapper()
wrapping_for_wrapping = ModuleWrapper(get_default_linear_solver, get_mpi_comm, to_petsc4py)
PETScTSIntegrator = BasicPETScTSIntegrator(backend, wrapping_for_wrapping)
@BackendFor("dolfin", inputs=(TimeDependentProblemWrapper, Function.Type(), Function.Type(), (Function.Type(), None)))
class TimeStepping(AbstractTimeStepping):
def __init__(self, problem_wrapper, solution, solution_dot, solution_dot_dot=None):
assert problem_wrapper.time_order() in (1, 2)
if problem_wrapper.time_order() == 1:
assert solution_dot_dot is None
ic = problem_wrapper.ic_eval()
if ic is not None:
assign(solution, ic)
self.problem = _TimeDependentProblem1(problem_wrapper.residual_eval, solution, solution_dot, problem_wrapper.bc_eval, problem_wrapper.jacobian_eval, problem_wrapper.set_time)
self.solver = PETScTSIntegrator(self.problem, self.problem.solution.vector().copy(), self.problem.solution_dot.vector().copy()) # create copies to avoid internal storage overwriting
elif problem_wrapper.time_order() == 2:
assert solution_dot_dot is not None
ic_eval_output = problem_wrapper.ic_eval()
assert isinstance(ic_eval_output, tuple) or ic_eval_output is None
if ic_eval_output is not None:
from rbnics.backends.dolfin.assign import assign
from rbnics.backends.dolfin.evaluate import evaluate
from rbnics.backends.dolfin.function import Function
from rbnics.backends.dolfin.parametrized_tensor_factory import ParametrizedTensorFactory
from rbnics.backends.dolfin.wrapping import function_copy, get_default_linear_solver, get_mpi_comm, to_petsc4py
from rbnics.backends.dolfin.wrapping.dirichlet_bc import ProductOutputDirichletBC
from rbnics.utils.decorators import BackendFor, dict_of, list_of, ModuleWrapper, overload
backend = ModuleWrapper()
wrapping_for_wrapping = ModuleWrapper(function_copy, get_default_linear_solver,
get_mpi_comm, to_petsc4py)
PETScTSIntegrator = BasicPETScTSIntegrator(backend, wrapping_for_wrapping)
@BackendFor("dolfin",
inputs=(TimeDependentProblemWrapper, Function.Type(),
Function.Type()))
class TimeStepping(AbstractTimeStepping):
def __init__(self, problem_wrapper, solution, solution_dot):
ic = problem_wrapper.ic_eval()
if ic is not None:
assign(solution, ic)
self.problem = _TimeDependentProblem(problem_wrapper.residual_eval,
solution, solution_dot,
problem_wrapper.bc_eval,
problem_wrapper.jacobian_eval,
problem_wrapper.set_time)
self.solver = PETScTSIntegrator(self.problem, solution, solution_dot)
self.solver.monitor.monitor_callback = problem_wrapper.monitor
# Set default linear solver
self.set_parameters({"linear_solver": "default"})
from rbnics.backends.dolfin.vector import Vector
from rbnics.backends.dolfin.wrapping import (build_dof_map_reader_mapping,
form_argument_space,
function_extend_or_restrict,
function_load, get_function_space,
get_function_subspace,
to_petsc4py)
from rbnics.backends.dolfin.wrapping.tensor_load import basic_tensor_load
from rbnics.utils.decorators import backend_for, ModuleWrapper
from rbnics.utils.io import Folders
backend = ModuleWrapper(Function, Matrix, Vector)
wrapping_for_wrapping = ModuleWrapper(build_dof_map_reader_mapping,
form_argument_space, to_petsc4py)
tensor_load = basic_tensor_load(backend, wrapping_for_wrapping)
wrapping = ModuleWrapper(function_extend_or_restrict,
function_load,
get_function_space,
get_function_subspace,
tensor_load=tensor_load)
import_base = basic_import_(backend, wrapping)
# Import a solution from file
@backend_for("dolfin",
inputs=((Function.Type(), Matrix.Type(), Vector.Type()),
(Folders.Folder, str), str, (int, None), (int, str, None))
)
def import_(solution, directory, filename, suffix=None, component=None):
import_base(solution, directory, filename, suffix, component)
def _evaluate(expression: (Function.Type(), FunctionsList),
at: (ReducedMesh, ReducedVertices), **kwargs):
assert len(kwargs) == 0
return evaluate_base(expression, at)
function_extend_or_restrict, function_from_ufl_operators,
function_save, get_function_subspace, to_petsc4py)
from rbnics.backends.dolfin.wrapping.tensor_save import basic_tensor_save
from rbnics.utils.decorators import backend_for, ModuleWrapper, overload
from rbnics.utils.io import Folders
backend = ModuleWrapper(Function, Matrix, Vector)
wrapping_for_wrapping = ModuleWrapper(build_dof_map_writer_mapping, form_argument_space, to_petsc4py,
form_name=form_name)
tensor_save = basic_tensor_save(backend, wrapping_for_wrapping)
wrapping = ModuleWrapper(function_extend_or_restrict, function_save, get_function_subspace, tensor_save=tensor_save)
export_base = basic_export(backend, wrapping)
# Export a solution to file
@backend_for("dolfin", inputs=((Function.Type(), Matrix.Type(), Operator, Vector.Type()), (Folders.Folder, str),
str, (int, None), (int, str, None)))
def export(solution, directory, filename, suffix=None, component=None):
_export(solution, directory, filename, suffix, component)
@overload
def _export(
solution: (
Function.Type(),
Matrix.Type(),
Vector.Type()
),
directory: (
Folders.Folder,
str
is_problem_solution_dot,
is_problem_solution_type,
solution_dot_identify_component,
solution_identify_component,
solution_iterator,
expression_description=expression_description,
expression_name=expression_name,
get_auxiliary_problem_for_non_parametrized_function=
get_auxiliary_problem_for_non_parametrized_function,
is_parametrized=is_parametrized,
is_time_dependent=is_time_dependent)
ParametrizedExpressionFactory_Base = BasicParametrizedExpressionFactory(
backend, wrapping)
@BackendFor("dolfin", inputs=((BaseExpression, Function.Type(), Operator), ))
class ParametrizedExpressionFactory(ParametrizedExpressionFactory_Base):
def __init__(self, expression):
# Generate space
space = _generate_space(expression)
# Define inner product for POD
f = TrialFunction(space)
g = TestFunction(space)
inner_product = assemble(inner(f, g) * dx)
# Call Parent
ParametrizedExpressionFactory_Base.__init__(self, expression, space,
inner_product)
# Space generation for BaseExpression
@overload
evaluate_sparse_vector_at_dofs,
expression_on_reduced_mesh=expression_on_reduced_mesh,
expression_on_truth_mesh=expression_on_truth_mesh,
form_on_reduced_function_space=form_on_reduced_function_space,
form_on_truth_function_space=form_on_truth_function_space)
online_backend = ModuleWrapper(OnlineFunction=OnlineFunction,
OnlineMatrix=OnlineMatrix,
OnlineVector=OnlineVector)
online_wrapping = ModuleWrapper()
evaluate_base = basic_evaluate(backend, wrapping, online_backend,
online_wrapping)
# Evaluate a parametrized expression, possibly at a specific location
@backend_for("dolfin",
inputs=((Matrix.Type(), Vector.Type(), Function.Type(), Operator,
TensorsList, FunctionsList, ParametrizedTensorFactory,
ParametrizedExpressionFactory), (ReducedMesh,
ReducedVertices, None)))
def evaluate(expression, at=None, **kwargs):
return _evaluate(expression, at, **kwargs)
@overload
def _evaluate(expression: (Matrix.Type(), Vector.Type(), TensorsList),
at: ReducedMesh, **kwargs):
assert len(kwargs) == 0
return evaluate_base(expression, at)
@overload
from rbnics.backends.abstract import NonlinearSolver as AbstractNonlinearSolver, NonlinearProblemWrapper
from rbnics.backends.basic.wrapping.petsc_snes_solver import BasicPETScSNESSolver
from rbnics.backends.dolfin.evaluate import evaluate
from rbnics.backends.dolfin.function import Function
from rbnics.backends.dolfin.parametrized_tensor_factory import ParametrizedTensorFactory
from rbnics.backends.dolfin.wrapping import get_default_linear_solver, get_mpi_comm, to_petsc4py
from rbnics.backends.dolfin.wrapping.dirichlet_bc import ProductOutputDirichletBC
from rbnics.utils.decorators import BackendFor, dict_of, list_of, ModuleWrapper, overload
backend = ModuleWrapper()
wrapping_for_wrapping = ModuleWrapper(get_default_linear_solver, get_mpi_comm,
to_petsc4py)
PETScSNESSolver = BasicPETScSNESSolver(backend, wrapping_for_wrapping)
@BackendFor("dolfin", inputs=(NonlinearProblemWrapper, Function.Type()))
class NonlinearSolver(AbstractNonlinearSolver):
def __init__(self, problem_wrapper, solution):
self.problem = _NonlinearProblem(problem_wrapper.residual_eval,
solution, problem_wrapper.bc_eval(),
problem_wrapper.jacobian_eval)
self.solver = PETScSNESSolver(
self.problem,
self.problem.solution.vector().copy()
) # create copies to avoid internal storage overwriting by linesearch
def set_parameters(self, parameters):
self.solver.set_parameters(parameters)
def solve(self):
self.solver.solve()
def custom__mul__(self, other):
if isinstance(other, Function.Type()):
return original__mul__(self, other.vector())
else:
return original__mul__(self, other)
from ufl import Form
from dolfin import assemble, DirichletBC, PETScLUSolver
from rbnics.backends.abstract import LinearSolver as AbstractLinearSolver
from rbnics.backends.dolfin.evaluate import evaluate
from rbnics.backends.dolfin.function import Function
from rbnics.backends.dolfin.matrix import Matrix
from rbnics.backends.dolfin.parametrized_tensor_factory import ParametrizedTensorFactory
from rbnics.backends.dolfin.vector import Vector
from rbnics.backends.dolfin.wrapping.dirichlet_bc import ProductOutputDirichletBC
from rbnics.utils.decorators import BackendFor, dict_of, list_of, overload
@BackendFor("dolfin",
inputs=((Form, Matrix.Type(), ParametrizedTensorFactory),
Function.Type(), (Form, ParametrizedTensorFactory,
Vector.Type()),
(list_of(DirichletBC), ProductOutputDirichletBC,
dict_of(str, list_of(DirichletBC)),
dict_of(str, ProductOutputDirichletBC), None)))
class LinearSolver(AbstractLinearSolver):
def __init__(self, lhs, solution, rhs, bcs=None):
self.solution = solution
self._init_lhs(lhs, bcs)
self._init_rhs(rhs, bcs)
self._apply_bcs(bcs)
self._linear_solver = "default"
@overload
def _init_lhs(self, lhs: Form,
bcs: (list_of(DirichletBC), ProductOutputDirichletBC,