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)