def get_eigenvector(self, i): eigv_i = self.eigv[:, i] eigv_i_real = Vector.Type()(self.A.N, real(eigv_i)) eigv_i_imag = Vector.Type()(self.A.N, imag(eigv_i)) eigv_i_real_fun = Function(eigv_i_real) eigv_i_imag_fun = Function(eigv_i_imag) return (eigv_i_real_fun, eigv_i_imag_fun)
def integrate(self): vector_over_time = list() N = self._function_over_time[0].N for function in self._function_over_time: assert function.N == N vector_over_time.append(function.vector()) integrated_vector = simps(vector_over_time, dx=self._time_step_size, axis=0) integrated_function = Function(N) integrated_function.vector()[:] = integrated_vector return integrated_function
def __init__(self, residual_eval, solution, solution_dot, bc_eval, jacobian_eval, set_time, problem_type): self.residual_eval = residual_eval self.solution = solution self.solution_dot = solution_dot self.solution_previous = Function(solution.vector().N) # equal to zero self.zero = Function(self.solution.vector().N) # equal to zero self.bc_eval = bc_eval self.jacobian_eval = jacobian_eval self.set_time = set_time self.problem_type = problem_type # Setup solver if problem_type == "linear": class _LinearSolver(LinearSolver): def __init__(self_, t): self.set_time(t) minus_solution_previous_over_dt = self.solution_previous minus_solution_previous_over_dt.vector()[:] /= - self._time_step_size lhs = self.jacobian_eval(t, self.zero, self.zero, 1./self._time_step_size) rhs = - self.residual_eval(t, self.zero, minus_solution_previous_over_dt) bcs_t = self.bc_eval(t) LinearSolver.__init__(self_, lhs, self.solution, rhs, bcs_t) self.solver_generator = _LinearSolver elif problem_type == "nonlinear": class _NonlinearSolver(NonlinearSolver): def __init__(self_, t): class _NonlinearProblemWrapper(NonlinearProblemWrapper): def __init__(self_): self.set_time(t) def _store_solution_and_solution_dot(self_, solution): self.solution.vector()[:] = solution.vector() self.solution_dot.vector()[:] = (solution.vector() - self.solution_previous.vector())/self._time_step_size def jacobian_eval(self_, solution): self_._store_solution_and_solution_dot(solution) return self.jacobian_eval(t, self.solution, self.solution_dot, 1./self._time_step_size) def residual_eval(self_, solution): self_._store_solution_and_solution_dot(solution) return self.residual_eval(t, self.solution, self.solution_dot) def bc_eval(self_): return self.bc_eval(t) NonlinearSolver.__init__(self_, _NonlinearProblemWrapper(), self.solution) self.solver_generator = _NonlinearSolver # Additional storage which will be setup by set_parameters self._final_time = None self._initial_time = 0. self._nonlinear_solver_parameters = None self._max_time_steps = None self._monitor = None self._report = None self._time_step_size = None
# # 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 transpose as basic_transpose 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) wrapping = ModuleWrapper(function_to_vector, matrix_mul_vector, vector_mul_vector, vectorized_matrix_inner_vectorized_matrix) 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, Function.Type(), FunctionsList, TensorsList, Vector.Type()), )) def transpose(arg): return transpose_base(arg)
# # 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 if self.monitor is not None: self.monitor(self.solution)
# 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 numpy.linalg import solve from rbnics.backends.online.basic import LinearSolver as BasicLinearSolver from rbnics.backends.online.numpy.matrix import Matrix from rbnics.backends.online.numpy.product import DelayedTransposeWithArithmetic from rbnics.backends.online.numpy.vector import Vector from rbnics.backends.online.numpy.function import Function from rbnics.utils.decorators import BackendFor, DictOfThetaType, ModuleWrapper, ThetaType backend = ModuleWrapper(Matrix, Vector) wrapping = ModuleWrapper(DelayedTransposeWithArithmetic=DelayedTransposeWithArithmetic) LinearSolver_Base = BasicLinearSolver(backend, wrapping) @BackendFor("numpy", inputs=(Matrix.Type(), Function.Type(), Vector.Type(), 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 return self.solution
class _ScipyImplicitEuler(object): def __init__(self, residual_eval, solution, solution_dot, bc_eval, jacobian_eval, set_time, problem_type): self.residual_eval = residual_eval self.solution = solution self.solution_dot = solution_dot self.solution_previous = Function(solution.vector().N) # equal to zero self.zero = Function(self.solution.vector().N) # equal to zero self.bc_eval = bc_eval self.jacobian_eval = jacobian_eval self.set_time = set_time self.problem_type = problem_type # Setup solver if problem_type == "linear": class _LinearSolver(LinearSolver): def __init__(self_, t): self.set_time(t) minus_solution_previous_over_dt = self.solution_previous minus_solution_previous_over_dt.vector()[:] /= - self._time_step_size lhs = self.jacobian_eval(t, self.zero, self.zero, 1./self._time_step_size) rhs = - self.residual_eval(t, self.zero, minus_solution_previous_over_dt) bcs_t = self.bc_eval(t) LinearSolver.__init__(self_, lhs, self.solution, rhs, bcs_t) self.solver_generator = _LinearSolver elif problem_type == "nonlinear": class _NonlinearSolver(NonlinearSolver): def __init__(self_, t): class _NonlinearProblemWrapper(NonlinearProblemWrapper): def __init__(self_): self.set_time(t) def _store_solution_and_solution_dot(self_, solution): self.solution.vector()[:] = solution.vector() self.solution_dot.vector()[:] = (solution.vector() - self.solution_previous.vector())/self._time_step_size def jacobian_eval(self_, solution): self_._store_solution_and_solution_dot(solution) return self.jacobian_eval(t, self.solution, self.solution_dot, 1./self._time_step_size) def residual_eval(self_, solution): self_._store_solution_and_solution_dot(solution) return self.residual_eval(t, self.solution, self.solution_dot) def bc_eval(self_): return self.bc_eval(t) NonlinearSolver.__init__(self_, _NonlinearProblemWrapper(), self.solution) self.solver_generator = _NonlinearSolver # Additional storage which will be setup by set_parameters self._final_time = None self._initial_time = 0. self._nonlinear_solver_parameters = None self._max_time_steps = None self._monitor = None self._report = None self._time_step_size = None def set_parameters(self, parameters): for (key, value) in parameters.items(): if key == "final_time": self._final_time = value elif key == "initial_time": self._initial_time = value elif key == "integrator_type": assert value == "beuler" elif key == "max_time_steps": self._max_time_steps = value elif key == "monitor": self._monitor = value elif key == "nonlinear_solver": self._nonlinear_solver_parameters = value elif key == "problem_type": assert value == self.problem_type elif key == "report": if value is True: def print_time(t): print("# t = {0:g}".format(t)) self._report = print_time else: self._report = None elif key == "time_step_size": self._time_step_size = value else: raise ValueError("Invalid paramater passed to _ScipyImplicitEuler object.") def solve(self): assert self._max_time_steps is not None or self._time_step_size is not None if self._time_step_size is not None: all_t = arange(self._initial_time, self._final_time + self._time_step_size, self._time_step_size) elif self._max_time_steps is not None: all_t = linspace(self._initial_time, self._final_time, num=self._max_time_steps+1) self._time_step_size = float(all_t[2] - all_t[1]) all_solutions = list() all_solutions.append(function_copy(self.solution)) all_solutions_dot = list() all_solutions_dot.append(function_copy(self.solution_dot)) self.solution_previous.vector()[:] = self.solution.vector() for t in all_t[1:]: if self._report is not None: self._report(t) solver = self.solver_generator(t) if self.problem_type == "nonlinear": if self._nonlinear_solver_parameters is not None: solver.set_parameters(self._nonlinear_solver_parameters) solver.solve() all_solutions.append(function_copy(self.solution)) self.solution_dot.vector()[:] = (all_solutions[-1].vector() - all_solutions[-2].vector())/self._time_step_size all_solutions_dot.append(function_copy(self.solution_dot)) self.solution_previous.vector()[:] = self.solution.vector() if self._monitor is not None: self._monitor(t, self.solution, self.solution_dot) return all_t, all_solutions, all_solutions_dot
# 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.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, Function.Type(), FunctionsList, 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.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)
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 if self.monitor is not None: self.monitor(self.solution)
from scipy.optimize.nonlin import Jacobian, nonlin_solve from rbnics.backends.abstract import NonlinearSolver as AbstractNonlinearSolver, NonlinearProblemWrapper from rbnics.backends.online.basic.nonlinear_solver import _NonlinearProblem as _BasicNonlinearProblem 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, ModuleWrapper backend = ModuleWrapper(Matrix, Vector) wrapping = ModuleWrapper( DelayedTransposeWithArithmetic=DelayedTransposeWithArithmetic) _NonlinearProblem_Base = _BasicNonlinearProblem(backend, wrapping) @BackendFor("numpy", 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.monitor = problem_wrapper.monitor # Additional storage which will be setup by set_parameters self._absolute_tolerance = None self._line_search = True self._maximum_iterations = None self._monitor = None self._relative_tolerance = None self._report = False self._solution_tolerance = None
# 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 numbers import Number from scipy.integrate import simps from rbnics.backends.abstract import TimeQuadrature as AbstractTimeQuadrature from rbnics.backends.online.numpy.function import Function from rbnics.utils.decorators import BackendFor, list_of, tuple_of @BackendFor("numpy", 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() N = self._function_over_time[0].N for function in self._function_over_time: assert function.N == N vector_over_time.append(function.vector()) integrated_vector = simps(vector_over_time, dx=self._time_step_size, axis=0) integrated_function = Function(N) integrated_function.vector()[:] = integrated_vector
# Copyright (C) 2015-2020 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)
# 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.assign import assign as basic_assign 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.utils.decorators import backend_for, list_of, ModuleWrapper backend = ModuleWrapper(Function, Matrix, Vector) assign_base = basic_assign(backend) @backend_for("numpy", inputs=((Function.Type(), list_of(Function.Type()), Matrix.Type(), Vector.Type()), (Function.Type(), list_of(Function.Type()), Matrix.Type(), Vector.Type()))) def assign(object_to, object_from): assign_base(object_to, object_from)
except ImportError: has_IDA = False else: has_IDA = True from rbnics.backends.abstract import TimeStepping as AbstractTimeStepping, TimeDependentProblemWrapper from rbnics.backends.online.basic.wrapping import DirichletBC from rbnics.backends.online.numpy.assign import assign from rbnics.backends.online.numpy.copy import function_copy from rbnics.backends.online.numpy.function import Function from rbnics.backends.online.numpy.linear_solver import LinearSolver from rbnics.backends.online.numpy.nonlinear_solver import NonlinearSolver, NonlinearProblemWrapper from rbnics.utils.decorators import BackendFor @BackendFor("numpy", 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 solution_dot_dot is None 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,
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, Function.Type(), FunctionsList, TensorsList, Vector.Type()), )) def transpose(arg): return transpose_base(arg)
from assimulo.solvers.sundials import IDAError from assimulo.problem import Implicit_Problem except ImportError: has_IDA = False else: has_IDA = True from rbnics.backends.abstract import TimeStepping as AbstractTimeStepping, TimeDependentProblemWrapper from rbnics.backends.online.basic.wrapping import DirichletBC from rbnics.backends.online.numpy.assign import assign from rbnics.backends.online.numpy.copy import function_copy from rbnics.backends.online.numpy.function import Function from rbnics.backends.online.numpy.linear_solver import LinearSolver from rbnics.backends.online.numpy.nonlinear_solver import NonlinearSolver, NonlinearProblemWrapper from rbnics.utils.decorators import BackendFor @BackendFor("numpy", 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 = self.problem.create_solver({"problem_type": "linear"}) 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:
# 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)
# 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 numpy.linalg import solve from rbnics.backends.online.basic import LinearSolver as BasicLinearSolver from rbnics.backends.online.numpy.matrix import Matrix from rbnics.backends.online.numpy.vector import Vector from rbnics.backends.online.numpy.function import Function from rbnics.utils.decorators import BackendFor, DictOfThetaType, ThetaType LinearSolver_Base = BasicLinearSolver @BackendFor("numpy", inputs=(Matrix.Type(), Function.Type(), Vector.Type(), 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 return self.solution