def _product(thetas: ThetaType, operators: (array_of(DelayedLinearSolver), list_of(DelayedLinearSolver)), thetas2: None):
output = None
assert len(thetas) == len(operators)
for (theta, operator) in zip(thetas, operators):
assert isinstance(operator._rhs, (AbstractParametrizedTensorFactory, DelayedProduct))
if isinstance(operator._rhs, AbstractParametrizedTensorFactory):
rhs = DelayedProduct(theta)
rhs *= operator._rhs
elif isinstance(operator._rhs, DelayedProduct):
assert len(operator._rhs._args) == 3
assert operator._rhs._args[0] == -1
assert isinstance(operator._rhs._args[1], AbstractParametrizedTensorFactory)
rhs = DelayedProduct(theta*operator._rhs._args[0])
rhs *= operator._rhs._args[1]
rhs *= operator._rhs._args[2]
else:
raise TypeError("Invalid rhs")
if output is None:
output = DelayedLinearSolver(operator._lhs, operator._solution, DelayedSum(rhs), operator._bcs)
output.set_parameters(operator._parameters)
else:
assert output._lhs is operator._lhs
assert output._solution is operator._solution
output._rhs += rhs
assert output._bcs is operator._bcs
assert output._parameters == operator._parameters
output.solve()
return ProductOutput(output._solution)
def _product(thetas: ThetaType,
operators: array_of(DelayedBasisFunctionsMatrix), thetas2: None):
from rbnics.backends import BasisFunctionsMatrix
space = operators[0].space
assert all([op.space == space for op in operators])
components_name = operators[0]._components_name
assert all([op._components_name == components_name for op in operators])
output = BasisFunctionsMatrix(space)
output.init(components_name)
for component_name in components_name:
operator_memory_over_basis_functions_index = None # list (over basis functions index) of list (over theta)
for operator in operators:
operator_memory = operator._enrich_memory[
component_name] # list (over basis functions index) for current theta
if operator_memory_over_basis_functions_index is None:
operator_memory_over_basis_functions_index = [
list() for _ in operator_memory
]
assert len(operator_memory_over_basis_functions_index) == len(
operator_memory)
for (basis_functions_index,
delayed_function) in enumerate(operator_memory):
operator_memory_over_basis_functions_index[
basis_functions_index].append(delayed_function)
for delayed_functions_over_theta in operator_memory_over_basis_functions_index:
output.enrich(
_product(thetas, delayed_functions_over_theta,
None).sum_product_return_value,
component=component_name if len(components_name) > 1 else None)
return ProductOutput(output)
# 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.abstract import ParametrizedTensorFactory as AbstractParametrizedTensorFactory
from rbnics.backends.basic.wrapping import DelayedBasisFunctionsMatrix, DelayedLinearSolver, DelayedProduct, DelayedSum
from rbnics.backends.common.affine_expansion_storage import AffineExpansionStorage
from rbnics.backends.common.non_affine_expansion_storage import NonAffineExpansionStorage
from rbnics.utils.decorators import array_of, backend_for, list_of, overload, ThetaType
# 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("common", inputs=(ThetaType, (AffineExpansionStorage, array_of(DelayedBasisFunctionsMatrix), array_of(DelayedLinearSolver), NonAffineExpansionStorage), ThetaType + (None,)))
def product(thetas, operators, thetas2=None):
return _product(thetas, operators, thetas2)
@overload
def _product(thetas: ThetaType, operators: (AffineExpansionStorage, NonAffineExpansionStorage), thetas2: None):
output = 0.
assert len(thetas) == len(operators)
for (theta, operator) in zip(thetas, operators):
output += theta*operator
return ProductOutput(output)
@overload
def _product(thetas: ThetaType, operators: (AffineExpansionStorage, NonAffineExpansionStorage), thetas2: ThetaType):
output = 0.
# no checks here on the first dimension of operators should be equal to len(thetas), and
# This file is part of RBniCS.
#
# SPDX-License-Identifier: LGPL-3.0-or-later
from rbnics.backends.abstract import ParametrizedTensorFactory as AbstractParametrizedTensorFactory
from rbnics.backends.basic.wrapping import DelayedBasisFunctionsMatrix, DelayedLinearSolver, DelayedProduct, DelayedSum
from rbnics.backends.common.affine_expansion_storage import AffineExpansionStorage
from rbnics.backends.common.non_affine_expansion_storage import NonAffineExpansionStorage
from rbnics.utils.decorators import array_of, backend_for, list_of, overload, ThetaType
# 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("common",
inputs=(ThetaType, (AffineExpansionStorage,
array_of(DelayedBasisFunctionsMatrix),
array_of(DelayedLinearSolver),
NonAffineExpansionStorage),
ThetaType + (None, )))
def product(thetas, operators, thetas2=None):
return _product(thetas, operators, thetas2)
@overload
def _product(thetas: ThetaType,
operators: (AffineExpansionStorage, NonAffineExpansionStorage),
thetas2: None):
output = 0.
assert len(thetas) == len(operators)
for (theta, operator) in zip(thetas, operators):
output += theta * operator
