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
