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,
# 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 export as basic_export
from rbnics.backends.online.numpy.function import Function
from rbnics.backends.online.numpy.matrix import Matrix
from rbnics.backends.online.numpy.vector import Vector
from rbnics.backends.online.numpy.wrapping import function_save, tensor_save
from rbnics.utils.decorators import backend_for, ModuleWrapper
from rbnics.utils.io import Folders
backend = ModuleWrapper(Function, Matrix, Vector)
wrapping = ModuleWrapper(function_save, tensor_save)
export_base = basic_export(backend, wrapping)
# Export a solution to file
@backend_for("numpy",
inputs=((Function.Type(), Matrix.Type(), Vector.Type()),
(Folders.Folder, str), str, (int, None), (int, str, None))
)
def export(solution, directory, filename, suffix=None, component=None):
export_base(solution, directory, filename, suffix, component)
for node in iterator(expression_or_form):
# ... parametrized expressions
if isinstance(node, BaseExpression):
if is_pull_back_expression(
node) and is_pull_back_expression_time_dependent(node):
return True
else:
parameters = node._parameters
if "t" in parameters:
return True
# ... problem solutions related to nonlinear terms
elif wrapping.is_problem_solution_type(node):
if wrapping.is_problem_solution(node):
(preprocessed_node, component, truth_solution
) = wrapping.solution_identify_component(node)
truth_problem = get_problem_from_solution(truth_solution)
if hasattr(truth_problem, "set_time"):
return True
elif wrapping.is_problem_solution_dot(node):
return True
return False
return _basic_is_time_dependent
backend = ModuleWrapper()
wrapping = ModuleWrapper(is_problem_solution, is_problem_solution_dot,
is_problem_solution_type, solution_identify_component,
solution_iterator)
is_time_dependent = basic_is_time_dependent(backend, wrapping)
# Copyright (C) 2015-2020 by the RBniCS authors
#
# This file is part of RBniCS.
#
# SPDX-License-Identifier: LGPL-3.0-or-later
from dolfin import FunctionSpace
from rbnics.backends.basic import BasisFunctionsMatrix as BasicBasisFunctionsMatrix
from rbnics.backends.dolfin.function import Function
from rbnics.backends.dolfin.functions_list import FunctionsList
from rbnics.backends.dolfin.wrapping import (basis_functions_matrix_mul_online_matrix,
basis_functions_matrix_mul_online_vector,
function_to_vector, get_function_subspace, get_mpi_comm)
from rbnics.backends.online import OnlineFunction, OnlineMatrix, OnlineVector
from rbnics.backends.online.wrapping import function_to_vector as online_function_to_online_vector
from rbnics.utils.decorators import BackendFor, list_of, ModuleWrapper
backend = ModuleWrapper(Function, FunctionsList)
wrapping = ModuleWrapper(basis_functions_matrix_mul_online_matrix, basis_functions_matrix_mul_online_vector,
function_to_vector, get_function_subspace, get_mpi_comm)
online_backend = ModuleWrapper(OnlineFunction=OnlineFunction, OnlineMatrix=OnlineMatrix, OnlineVector=OnlineVector)
online_wrapping = ModuleWrapper(online_function_to_online_vector)
BasisFunctionsMatrix_Base = BasicBasisFunctionsMatrix(backend, wrapping, online_backend, online_wrapping)
@BackendFor("dolfin", inputs=(FunctionSpace, (list_of(str), str, None)))
class BasisFunctionsMatrix(BasisFunctionsMatrix_Base):
pass
#
# You should have received a copy of the GNU Lesser General Public License
# along with RBniCS. If not, see <http://www.gnu.org/licenses/>.
#
def basic_form_description(backend, wrapping):
def _basic_form_description(form):
coefficients_repr = dict()
for integral in form.integrals():
coefficients_repr_integral = wrapping.expression_description(
integral.integrand())
# Check consistency
intersection = set(coefficients_repr_integral.keys()).intersection(
set(coefficients_repr.keys()))
for key in intersection:
assert coefficients_repr_integral[key] == coefficients_repr[
key]
# Update
coefficients_repr.update(coefficients_repr_integral)
return coefficients_repr
return _basic_form_description
from rbnics.backends.dolfin.wrapping.expression_description import expression_description
from rbnics.utils.decorators import ModuleWrapper
backend = ModuleWrapper()
wrapping = ModuleWrapper(expression_description=expression_description)
form_description = basic_form_description(backend, wrapping)
evaluate_sparse_vector_at_dofs, expression_iterator, expression_replace,
form_argument_replace, form_iterator, form_replace,
function_from_ufl_operators,
get_auxiliary_problem_for_non_parametrized_function, is_problem_solution,
is_problem_solution_dot, is_problem_solution_type,
solution_dot_identify_component, solution_identify_component,
solution_iterator)
from rbnics.backends.dolfin.wrapping.expression_on_reduced_mesh import basic_expression_on_reduced_mesh
from rbnics.backends.dolfin.wrapping.expression_on_truth_mesh import basic_expression_on_truth_mesh
from rbnics.backends.dolfin.wrapping.form_on_reduced_function_space import basic_form_on_reduced_function_space
from rbnics.backends.dolfin.wrapping.form_on_truth_function_space import basic_form_on_truth_function_space
from rbnics.backends.online import online_assign, OnlineFunction, OnlineMatrix, OnlineVector
from rbnics.utils.decorators import backend_for, ModuleWrapper, overload
backend = ModuleWrapper(assign, copy, Function, FunctionsList, Matrix,
ParametrizedExpressionFactory,
ParametrizedTensorFactory, ReducedMesh,
ReducedVertices, TensorsList, Vector)
wrapping_for_wrapping = ModuleWrapper(
assemble,
evaluate_expression,
expression_iterator,
expression_replace,
form_argument_replace,
form_iterator,
form_replace,
is_problem_solution,
is_problem_solution_dot,
is_problem_solution_type,
solution_dot_identify_component,
solution_identify_component,
solution_iterator,
if index is None:
return max(self.reduced_mesh.keys())
else:
return index
def _get_next_index(self):
N = len(self.reduced_mesh)
if N > 0:
assert min(self.reduced_mesh.keys()) == 0
assert max(self.reduced_mesh.keys()) == N - 1
return N
return _BasicReducedMesh
from rbnics.backends.dolfin.basis_functions_matrix import BasisFunctionsMatrix
from rbnics.backends.dolfin.wrapping import build_dof_map_reader_mapping, build_dof_map_writer_mapping, create_submesh, convert_meshfunctions_to_submesh, convert_functionspace_to_submesh, evaluate_basis_functions_matrix_at_dofs, evaluate_sparse_function_at_dofs, map_functionspaces_between_mesh_and_submesh
backend = ModuleWrapper(BasisFunctionsMatrix)
wrapping = ModuleWrapper(build_dof_map_reader_mapping, build_dof_map_writer_mapping, create_submesh, convert_meshfunctions_to_submesh, convert_functionspace_to_submesh, evaluate_sparse_function_at_dofs, map_functionspaces_between_mesh_and_submesh, evaluate_basis_functions_matrix_at_dofs=evaluate_basis_functions_matrix_at_dofs)
ReducedMesh_Base = BasicReducedMesh(backend, wrapping)
@BackendFor("dolfin", inputs=(FunctionSpace, ))
class ReducedMesh(ReducedMesh_Base):
def _compute_dof_to_cells(self, V_component):
assert isinstance(V_component, FunctionSpace)
dof_to_cells = dict() # from global dof to cell
for cell in cells(self.mesh):
local_dofs = V_component.dofmap().cell_dofs(cell.index())
for local_dof in local_dofs:
global_dof = V_component.dofmap().local_to_global_index(local_dof)
if global_dof not in dof_to_cells:
dof_to_cells[global_dof] = list()
if cell not in dof_to_cells[global_dof]:
# Copyright (C) 2015-2021 by the RBniCS authors
#
# This file is part of RBniCS.
#
# SPDX-License-Identifier: LGPL-3.0-or-later
from numpy.linalg import solve
from rbnics.backends.abstract import LinearProblemWrapper
from rbnics.backends.online.basic import LinearSolver as BasicLinearSolver
from rbnics.backends.online.numpy.function import Function
from rbnics.backends.online.numpy.matrix import Matrix
from rbnics.backends.online.numpy.transpose import DelayedTransposeWithArithmetic
from rbnics.backends.online.numpy.vector import Vector
from rbnics.utils.decorators import BackendFor, DictOfThetaType, ModuleWrapper, ThetaType
backend = ModuleWrapper(Function, Matrix, Vector)
wrapping = ModuleWrapper(DelayedTransposeWithArithmetic=DelayedTransposeWithArithmetic)
LinearSolver_Base = BasicLinearSolver(backend, wrapping)
@BackendFor("numpy", inputs=((Matrix.Type(), DelayedTransposeWithArithmetic, LinearProblemWrapper),
Function.Type(),
(Vector.Type(), DelayedTransposeWithArithmetic, None),
ThetaType + DictOfThetaType + (None,)))
class LinearSolver(LinearSolver_Base):
def set_parameters(self, parameters):
assert len(parameters) == 0, "NumPy linear solver does not accept parameters yet"
def solve(self):
solution = solve(self.lhs, self.rhs)
self.solution.vector()[:] = solution
#
# This file is part of RBniCS.
#
# SPDX-License-Identifier: LGPL-3.0-or-later
from numpy import zeros
from rbnics.backends.online.basic import Vector as BasicVector
from rbnics.backends.online.numpy.wrapping import Slicer
from rbnics.utils.decorators import backend_for, ModuleWrapper, OnlineSizeType
def VectorBaseType(N):
return zeros(N)
backend = ModuleWrapper()
wrapping = ModuleWrapper(Slicer=Slicer)
_Vector_Type_Base = BasicVector(backend, wrapping, VectorBaseType)
class _Vector_Type(_Vector_Type_Base):
def __getitem__(self, key):
if isinstance(key, int):
return float(_Vector_Type_Base.__getitem__(
self, key)) # convert from numpy numbers wrappers
else:
return _Vector_Type_Base.__getitem__(self, key)
def __iter__(self):
return map(float, self.content.flat)
index=None):
return self._reduced_mesh.get_auxiliary_reduced_function_space(
auxiliary_problem, component, index)
def get_auxiliary_basis_functions_matrix(self,
auxiliary_problem,
auxiliary_reduced_problem,
component,
index=None):
return self._reduced_mesh.get_auxiliary_basis_functions_matrix(
auxiliary_problem, auxiliary_reduced_problem, component, index)
def get_auxiliary_function_interpolator(self,
auxiliary_problem,
component,
index=None):
return self._reduced_mesh.get_auxiliary_function_interpolator(
auxiliary_problem, component, index)
return _BasicReducedVertices
backend = ModuleWrapper(ReducedMesh)
wrapping = ModuleWrapper()
ReducedVertices_Base = BasicReducedVertices(backend, wrapping)
@BackendFor("dolfin", inputs=(FunctionSpace, ))
class ReducedVertices(ReducedVertices_Base):
pass
output_basis_functions_matrix, reduced_dofs_list):
components = output_basis_functions_matrix._components_name
reduced_space = output_basis_functions_matrix.space
if len(components) > 1:
for component in components:
input_functions_list = input_basis_functions_matrix._components[
component]
for basis_function in input_functions_list:
reduced_basis_function = wrapping.evaluate_sparse_function_at_dofs(
basis_function, dofs_list, reduced_space,
reduced_dofs_list)
output_basis_functions_matrix.enrich(
reduced_basis_function, component=component)
else:
input_functions_list = input_basis_functions_matrix._components[
components[0]]
for basis_function in input_functions_list:
reduced_basis_function = wrapping.evaluate_sparse_function_at_dofs(
basis_function, dofs_list, reduced_space,
reduced_dofs_list)
output_basis_functions_matrix.enrich(reduced_basis_function)
return output_basis_functions_matrix
return _basic_evaluate_basis_functions_matrix_at_dofs
backend = ModuleWrapper()
wrapping = ModuleWrapper(evaluate_sparse_function_at_dofs)
evaluate_basis_functions_matrix_at_dofs = basic_evaluate_basis_functions_matrix_at_dofs(
backend, wrapping)
AuxiliaryProblemForNonParametrizedFunction.__name__ + "_" +
str(len(
_auxiliary_problem_for_non_parametrized_function_cache)))
class AuxiliaryProblemForNonParametrizedFunction_Local(
AuxiliaryProblemForNonParametrizedFunction):
def name(self):
return auxiliary_problem_for_non_parametrized_function_name
AuxiliaryProblemForNonParametrizedFunction_Local.__name__ = auxiliary_problem_for_non_parametrized_function_name
auxiliary_problem_for_non_parametrized_function = AuxiliaryProblemForNonParametrizedFunction_Local(
V)
_auxiliary_problem_for_non_parametrized_function_cache[
V] = auxiliary_problem_for_non_parametrized_function
return (preprocessed_node, component,
auxiliary_problem_for_non_parametrized_function)
_auxiliary_problem_for_non_parametrized_function_cache = Cache(
) # over function spaces rather than nodes, as after preprocessing all nodes sharing the same function space can use the same auxiliary problem
return _basic_get_auxiliary_problem_for_non_parametrized_function
from rbnics.backends.dolfin.wrapping.get_function_space import get_function_space
from rbnics.utils.decorators import ModuleWrapper
backend = ModuleWrapper()
wrapping = ModuleWrapper(get_function_space)
get_auxiliary_problem_for_non_parametrized_function = basic_get_auxiliary_problem_for_non_parametrized_function(
backend, wrapping)
#
from ufl import Form
from ufl.algorithms import expand_derivatives
from dolfin import assemble
from rbnics.backends.basic import ParametrizedTensorFactory as BasicParametrizedTensorFactory
from rbnics.backends.dolfin.copy import copy
from rbnics.backends.dolfin.high_order_proper_orthogonal_decomposition import HighOrderProperOrthogonalDecomposition
from rbnics.backends.dolfin.function import Function
from rbnics.backends.dolfin.reduced_mesh import ReducedMesh
from rbnics.backends.dolfin.tensor_basis_list import TensorBasisList
from rbnics.backends.dolfin.tensor_snapshots_list import TensorSnapshotsList
from rbnics.backends.dolfin.wrapping import form_argument_space, form_description, form_iterator, form_name, get_auxiliary_problem_for_non_parametrized_function, is_parametrized, is_problem_solution, is_problem_solution_dot, is_problem_solution_type, is_time_dependent, remove_complex_nodes, solution_dot_identify_component, solution_identify_component, solution_iterator
from rbnics.utils.decorators import BackendFor, ModuleWrapper
backend = ModuleWrapper(copy, Function, HighOrderProperOrthogonalDecomposition,
ReducedMesh, TensorBasisList, TensorSnapshotsList)
wrapping = ModuleWrapper(form_iterator,
is_problem_solution,
is_problem_solution_dot,
is_problem_solution_type,
solution_dot_identify_component,
solution_identify_component,
solution_iterator,
form_description=form_description,
form_name=form_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)
ParametrizedTensorFactory_Base = BasicParametrizedTensorFactory(
backend, wrapping)
#
# SPDX-License-Identifier: LGPL-3.0-or-later
from ufl.core.operator import Operator
from rbnics.backends.basic import export as basic_export
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 (build_dof_map_writer_mapping, form_argument_space, form_name,
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
from rbnics.backends.dolfin.wrapping import function_extend_or_restrict, function_from_ufl_operators, function_load, function_save, function_to_vector, functions_list_mul_online_matrix, functions_list_mul_online_vector, get_function_subspace, get_mpi_comm
from rbnics.backends.online import OnlineFunction, OnlineMatrix, OnlineVector
from rbnics.backends.online.wrapping import function_to_vector as online_function_to_online_vector
from rbnics.utils.decorators import BackendFor, dict_of, list_of, ModuleWrapper, overload
def AdditionalIsFunction(arg):
return isinstance(arg, Operator)
def ConvertAdditionalFunctionTypes(arg):
assert isinstance(arg, Operator)
return function_from_ufl_operators(arg)
backend = ModuleWrapper(Function)
wrapping = ModuleWrapper(function_extend_or_restrict, function_load,
function_save, function_to_vector,
functions_list_mul_online_matrix,
functions_list_mul_online_vector,
get_function_subspace, get_mpi_comm)
online_backend = ModuleWrapper(OnlineFunction=OnlineFunction,
OnlineMatrix=OnlineMatrix,
OnlineVector=OnlineVector)
online_wrapping = ModuleWrapper(online_function_to_online_vector)
FunctionsList_Base = BasicFunctionsList(backend, wrapping, online_backend,
online_wrapping, AdditionalIsFunction,
ConvertAdditionalFunctionTypes)
@BackendFor("dolfin", inputs=(FunctionSpace, (str, None)))
#
# This file is part of RBniCS.
#
# RBniCS is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# RBniCS is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# 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 rbnics.backends.basic import GramSchmidt as BasicGramSchmidt
from rbnics.backends.online.numpy.matrix import Matrix
from rbnics.backends.online.numpy.transpose import transpose
from rbnics.backends.online.numpy.wrapping import gram_schmidt_projection_step
from rbnics.utils.decorators import BackendFor, ModuleWrapper
backend = ModuleWrapper(transpose)
wrapping = ModuleWrapper(gram_schmidt_projection_step)
GramSchmidt_Base = BasicGramSchmidt(backend, wrapping)
@BackendFor("numpy", inputs=(Matrix.Type(), ))
class GramSchmidt(GramSchmidt_Base):
pass
from petsc4py import PETSc
from ufl import Form
from dolfin import assemble, DirichletBC, PETScMatrix, PETScVector
from dolfin.cpp.la 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 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,
# 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.online.basic import product as basic_product
from rbnics.backends.online.numpy.affine_expansion_storage import AffineExpansionStorage
from rbnics.backends.online.numpy.function import Function
from rbnics.backends.online.numpy.matrix import Matrix
from rbnics.backends.online.numpy.non_affine_expansion_storage import NonAffineExpansionStorage
from rbnics.backends.online.numpy.transpose import DelayedTransposeWithArithmetic
from rbnics.backends.online.numpy.vector import Vector
from rbnics.utils.decorators import backend_for, ModuleWrapper, ThetaType
backend = ModuleWrapper(AffineExpansionStorage, Function, Matrix, NonAffineExpansionStorage, Vector)
wrapping = ModuleWrapper(DelayedTransposeWithArithmetic=DelayedTransposeWithArithmetic)
(product_base, ProductOutput) = basic_product(backend, wrapping)
# product function to assemble truth/reduced affine expansions. To be used in combination with sum,
# even though this one actually carries out both the sum and the product!
@backend_for("numpy", inputs=(ThetaType, (AffineExpansionStorage, NonAffineExpansionStorage), ThetaType + (None,)))
def product(thetas, operators, thetas2=None):
return product_base(thetas, operators, thetas2)
# 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 rbnics.backends.online.basic import AffineExpansionStorage as BasicAffineExpansionStorage
from rbnics.backends.online.numpy.copy import function_copy, tensor_copy
from rbnics.backends.online.numpy.function import Function
from rbnics.backends.online.numpy.matrix import Matrix
from rbnics.backends.online.numpy.vector import Vector
from rbnics.backends.online.numpy.wrapping import function_load, function_save, tensor_load, tensor_save
from rbnics.utils.decorators import BackendFor, ModuleWrapper, tuple_of
backend = ModuleWrapper(Function, Matrix, Vector)
wrapping = ModuleWrapper(function_load,
function_save,
tensor_load,
tensor_save,
function_copy=function_copy,
tensor_copy=tensor_copy)
AffineExpansionStorage_Base = BasicAffineExpansionStorage(backend, wrapping)
@BackendFor("numpy",
inputs=((int, tuple_of(Matrix.Type()), tuple_of(Vector.Type())),
(int, None)))
class AffineExpansionStorage(AffineExpansionStorage_Base):
def __init__(self, arg1, arg2=None):
AffineExpansionStorage_Base.__init__(self, arg1, arg2)
#
# SPDX-License-Identifier: LGPL-3.0-or-later
from numpy import zeros
from rbnics.backends.online.basic import Matrix as BasicMatrix
from rbnics.backends.online.numpy.function import Function
from rbnics.backends.online.numpy.vector import Vector
from rbnics.backends.online.numpy.wrapping import Slicer
from rbnics.utils.decorators import backend_for, ModuleWrapper, OnlineSizeType
def MatrixBaseType(M, N):
return zeros((M, N))
backend = ModuleWrapper(Function, Vector)
wrapping = ModuleWrapper(Slicer=Slicer)
_Matrix_Type_Base = BasicMatrix(backend, wrapping, MatrixBaseType)
class _Matrix_Type(_Matrix_Type_Base):
def __getitem__(self, key):
if all([isinstance(key_i, int) for key_i in key]):
return float(_Matrix_Type_Base.__getitem__(self, key)) # convert from numpy numbers wrappers
else:
return _Matrix_Type_Base.__getitem__(self, key)
def __mul__(self, other):
if isinstance(other, Vector.Type()):
# copied from BasicMatrix because ndarray uses __matul__ instead of __mul__ for matrix-vector product
self._arithmetic_operations_assert_attributes(other, other_order=1)
from rbnics.backends.online.basic import transpose as basic_transpose
from rbnics.backends.online.basic.wrapping import DelayedTransposeWithArithmetic as BasicDelayedTransposeWithArithmetic
from rbnics.backends.online.numpy.basis_functions_matrix import BasisFunctionsMatrix
from rbnics.backends.online.numpy.function import Function
from rbnics.backends.online.numpy.functions_list import FunctionsList
from rbnics.backends.online.numpy.matrix import Matrix
from rbnics.backends.online.numpy.non_affine_expansion_storage import NonAffineExpansionStorage
from rbnics.backends.online.numpy.tensors_list import TensorsList
from rbnics.backends.online.numpy.vector import Vector
from rbnics.backends.online.numpy.wrapping import (
function_to_vector, matrix_mul_vector, vector_mul_vector,
vectorized_matrix_inner_vectorized_matrix)
from rbnics.utils.decorators import backend_for, ModuleWrapper
backend = ModuleWrapper(BasisFunctionsMatrix, Function, FunctionsList, Matrix,
NonAffineExpansionStorage, TensorsList, Vector)
DelayedTransposeWithArithmetic = BasicDelayedTransposeWithArithmetic(backend)
wrapping = ModuleWrapper(
function_to_vector,
matrix_mul_vector,
vector_mul_vector,
vectorized_matrix_inner_vectorized_matrix,
DelayedTransposeWithArithmetic=DelayedTransposeWithArithmetic)
online_backend = ModuleWrapper(OnlineMatrix=Matrix, OnlineVector=Vector)
online_wrapping = ModuleWrapper()
transpose_base = basic_transpose(backend, wrapping, online_backend,
online_wrapping)
@backend_for("numpy",
inputs=((BasisFunctionsMatrix, DelayedTransposeWithArithmetic,
# This file is part of RBniCS.
#
# RBniCS is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# RBniCS is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# 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 ufl import Form
from rbnics.backends.basic import NonAffineExpansionStorage as BasicNonAffineExpansionStorage
from rbnics.backends.dolfin.parametrized_tensor_factory import ParametrizedTensorFactory
from rbnics.utils.decorators import BackendFor, ModuleWrapper, tuple_of
backend = ModuleWrapper(ParametrizedTensorFactory)
wrapping = ModuleWrapper()
NonAffineExpansionStorage_Base = BasicNonAffineExpansionStorage(
backend, wrapping)
@BackendFor("dolfin", inputs=(tuple_of(Form), ))
class NonAffineExpansionStorage(NonAffineExpansionStorage_Base):
pass
# 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.online.numpy.function import Function
from rbnics.backends.online.numpy.matrix import Matrix
from rbnics.backends.online.numpy.vector import Vector
from rbnics.backends.online.numpy.wrapping.function_copy import basic_function_copy
from rbnics.backends.online.numpy.wrapping.tensor_copy import basic_tensor_copy
from rbnics.utils.decorators import backend_for, list_of, ModuleWrapper
backend = ModuleWrapper(Function, Matrix, Vector)
wrapping_for_wrapping = ModuleWrapper()
function_copy = basic_function_copy(backend, wrapping_for_wrapping)
tensor_copy = basic_tensor_copy(backend, wrapping_for_wrapping)
wrapping = ModuleWrapper(function_copy=function_copy, tensor_copy=tensor_copy)
copy_base = basic_copy(backend, wrapping)
@backend_for("numpy",
inputs=((Function.Type(), list_of(Function.Type()), Matrix.Type(),
Vector.Type()), ))
def copy(arg):
return copy_base(arg)
def replace_placeholders(self, i, new_coefficients):
assert len(new_coefficients) == len(self._placeholders[i])
replacements = dict(
(placeholder, new_coefficient)
for (placeholder, new_coefficient
) in zip(self._placeholders[i], new_coefficients))
return replace(self._form_with_placeholders[i], replacements)
def placeholders_names(self, i):
return self._placeholder_names[i]
return _BasicSeparatedParametrizedForm
from rbnics.backends.dolfin.wrapping import expression_name, is_problem_solution, is_problem_solution_dot, is_problem_solution_type, is_pull_back_expression, is_pull_back_expression_parametrized, solution_dot_identify_component, solution_identify_component
backend = ModuleWrapper()
wrapping = ModuleWrapper(is_problem_solution,
is_problem_solution_dot,
is_problem_solution_type,
is_pull_back_expression,
is_pull_back_expression_parametrized,
solution_dot_identify_component,
solution_identify_component,
expression_name=expression_name)
SeparatedParametrizedForm_Base = BasicSeparatedParametrizedForm(
backend, wrapping)
@BackendFor("dolfin", inputs=(Form, ))
class SeparatedParametrizedForm(SeparatedParametrizedForm_Base):
pass
# This file is part of RBniCS.
#
# SPDX-License-Identifier: LGPL-3.0-or-later
from rbnics.backends.abstract import FunctionsList as AbstractFunctionsList
from rbnics.backends.abstract import ProperOrthogonalDecomposition as AbstractProperOrthogonalDecomposition
from rbnics.backends.basic import ProperOrthogonalDecompositionBase as BasicProperOrthogonalDecomposition
from rbnics.backends.online.numpy.eigen_solver import EigenSolver
from rbnics.backends.online.numpy.functions_list import FunctionsList
from rbnics.backends.online.numpy.matrix import Matrix
from rbnics.backends.online.numpy.snapshots_matrix import SnapshotsMatrix
from rbnics.backends.online.numpy.transpose import transpose
from rbnics.backends.online.numpy.wrapping import get_mpi_comm
from rbnics.utils.decorators import BackendFor, ModuleWrapper
backend = ModuleWrapper(transpose)
wrapping = ModuleWrapper(get_mpi_comm)
online_backend = ModuleWrapper(OnlineEigenSolver=EigenSolver)
online_wrapping = ModuleWrapper()
ProperOrthogonalDecomposition_Base = BasicProperOrthogonalDecomposition(
backend, wrapping, online_backend, online_wrapping, AbstractProperOrthogonalDecomposition, SnapshotsMatrix,
FunctionsList)
@BackendFor("numpy", inputs=(AbstractFunctionsList, Matrix.Type(), (str, None)))
class ProperOrthogonalDecomposition(ProperOrthogonalDecomposition_Base):
def __init__(self, basis_functions, inner_product, component=None):
ProperOrthogonalDecomposition_Base.__init__(self, basis_functions, inner_product, component)
def store_snapshot(self, snapshot, component=None, weight=None):
self.snapshots_matrix.enrich(snapshot, component, weight)
# Copyright (C) 2015-2021 by the RBniCS authors
#
# This file is part of RBniCS.
#
# SPDX-License-Identifier: LGPL-3.0-or-later
from dolfin import FunctionSpace
from rbnics.backends.basic import TensorsList as BasicTensorsList
from rbnics.backends.dolfin.export import tensor_save
from rbnics.backends.dolfin.import_ import tensor_load
from rbnics.backends.dolfin.matrix import Matrix
from rbnics.backends.dolfin.vector import Vector
from rbnics.backends.dolfin.wrapping import get_mpi_comm, tensor_copy
from rbnics.backends.dolfin.wrapping.tensors_list_mul import basic_tensors_list_mul_online_function
from rbnics.backends.online import OnlineFunction
from rbnics.utils.decorators import BackendFor, ModuleWrapper
backend = ModuleWrapper(Matrix, Vector)
wrapping_for_wrapping = ModuleWrapper(tensor_copy)
tensors_list_mul_online_function = basic_tensors_list_mul_online_function(backend, wrapping_for_wrapping)
wrapping = ModuleWrapper(get_mpi_comm, tensor_copy, tensor_load=tensor_load, tensor_save=tensor_save,
tensors_list_mul_online_function=tensors_list_mul_online_function)
online_backend = ModuleWrapper(OnlineFunction=OnlineFunction)
online_wrapping = ModuleWrapper()
TensorsList_Base = BasicTensorsList(backend, wrapping, online_backend, online_wrapping)
@BackendFor("dolfin", inputs=(FunctionSpace, ))
class TensorsList(TensorsList_Base):
pass
#
# SPDX-License-Identifier: LGPL-3.0-or-later
from ufl import Form
from ufl.core.operator import Operator
from dolfin import FunctionSpace
from rbnics.backends.basic import GramSchmidt as BasicGramSchmidt
from rbnics.backends.dolfin.function import Function
from rbnics.backends.dolfin.matrix import Matrix
from rbnics.backends.dolfin.transpose import transpose
from rbnics.backends.dolfin.wrapping import (function_extend_or_restrict,
function_from_ufl_operators,
get_function_subspace,
gram_schmidt_projection_step)
from rbnics.utils.decorators import BackendFor, dict_of, ModuleWrapper, overload
backend = ModuleWrapper(Function, transpose)
wrapping = ModuleWrapper(function_extend_or_restrict, get_function_subspace,
gram_schmidt_projection_step)
GramSchmidt_Base = BasicGramSchmidt(backend, wrapping)
@BackendFor("dolfin",
inputs=(FunctionSpace, (Form, Matrix.Type()), (str, None)))
class GramSchmidt(GramSchmidt_Base):
@overload(Operator, (None, str, dict_of(str, str)))
def _extend_or_restrict_if_needed(self, function, component):
function = function_from_ufl_operators(function)
return GramSchmidt_Base._extend_or_restrict_if_needed(
self, function, component)
from rbnics.backends.basic import import_ as basic_import_
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 (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))
visited.add(preprocessed_n)
for parent_n in wrapping.solution_iterator(preprocessed_n):
visited.add(parent_n)
elif isinstance(n, Constant):
vals = n.values()
coefficients_replacement[repr(n)] = str(vals)
str_repr += repr(str(vals))
visited.add(n)
else:
str_repr += repr(n)
visited.add(n)
for key, value in coefficients_replacement.items():
str_repr = str_repr.replace(key, value)
hash_code = hashlib.sha1(str_repr.encode("utf-8")).hexdigest()
return hash_code
return _basic_expression_name
from rbnics.backends.dolfin.wrapping.expression_iterator import expression_iterator
from rbnics.backends.dolfin.wrapping.get_auxiliary_problem_for_non_parametrized_function import get_auxiliary_problem_for_non_parametrized_function
from rbnics.backends.dolfin.wrapping.is_problem_solution import is_problem_solution
from rbnics.backends.dolfin.wrapping.is_problem_solution_dot import is_problem_solution_dot
from rbnics.backends.dolfin.wrapping.is_problem_solution_type import is_problem_solution_type
from rbnics.backends.dolfin.wrapping.solution_dot_identify_component import solution_dot_identify_component
from rbnics.backends.dolfin.wrapping.solution_identify_component import solution_identify_component
from rbnics.backends.dolfin.wrapping.solution_iterator import solution_iterator
from rbnics.utils.decorators import ModuleWrapper
backend = ModuleWrapper()
wrapping = ModuleWrapper(expression_iterator, is_problem_solution, is_problem_solution_dot, is_problem_solution_type, solution_dot_identify_component, solution_identify_component, solution_iterator, get_auxiliary_problem_for_non_parametrized_function=get_auxiliary_problem_for_non_parametrized_function)
expression_name = basic_expression_name(backend, wrapping)
# RBniCS is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# 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/>.
#
import hashlib
def basic_form_name(backend, wrapping):
def _basic_form_name(form):
str_repr = ""
for integral in form.integrals():
str_repr += wrapping.expression_name(integral.integrand())
str_repr += "measure(" + integral.integral_type() + ")[" + str(
integral.subdomain_id()) + "]"
hash_code = hashlib.sha1(str_repr.encode("utf-8")).hexdigest()
return hash_code
return _basic_form_name
from rbnics.utils.decorators import ModuleWrapper
from rbnics.backends.dolfin.wrapping.expression_name import expression_name
backend = ModuleWrapper()
wrapping = ModuleWrapper(expression_name=expression_name)
form_name = basic_form_name(backend, wrapping)
