def jacobian(self, U, mu=None):
assert len(U) == 1
assert self.parameters.assert_compatible(mu)
options = self.solver_options.get(
'jacobian') if self.solver_options else None
if self.interpolation_matrix.shape[0] == 0:
return NumpyMatrixOperator(np.zeros(
(self.range.dim, self.source.dim)),
solver_options=options,
name=self.name + '_jacobian')
U_dofs = self.source_basis_dofs.lincomb(U.to_numpy()[0])
J = self.restricted_operator.jacobian(U_dofs, mu=mu).apply(
self.source_basis_dofs)
try:
if self.triangular:
interpolation_coefficients = solve_triangular(
self.interpolation_matrix,
J.to_numpy().T,
lower=True,
unit_diagonal=True).T
else:
interpolation_coefficients = solve(self.interpolation_matrix,
J.to_numpy().T).T
except ValueError: # this exception occurs when J contains NaNs ...
interpolation_coefficients = (np.empty(
(len(self.source_basis_dofs),
len(self.projected_collateral_basis))) + np.nan)
M = self.projected_collateral_basis.lincomb(interpolation_coefficients)
if isinstance(M.space, NumpyVectorSpace):
return NumpyMatrixOperator(M.to_numpy().T, solver_options=options)
else:
assert not options
return VectorArrayOperator(M)
def assemble(self, mu=None):
"""Assembles the operator for a given |Parameter|.
Parameters
----------
mu
The |Parameter| for which to assemble the operator.
Returns
-------
The assembled **parameter independent** |Operator|.
"""
if hasattr(self, '_assembled_operator'):
if self._defaults_sid != defaults_sid():
self.logger.warn(
'Re-assembling since state of global defaults has changed.'
)
op = self._assembled_operator = NumpyMatrixOperator(
self._assemble(), solver_options=self.solver_options)
self._defaults_sid = defaults_sid()
return op
else:
return self._assembled_operator
elif not self.parameter_type:
op = self._assembled_operator = NumpyMatrixOperator(
self._assemble(), solver_options=self.solver_options)
self._defaults_sid = defaults_sid()
return op
else:
return NumpyMatrixOperator(self._assemble(
self.parse_parameter(mu)),
solver_options=self.solver_options)
def test_to_matrix():
np.random.seed(0)
A = np.random.randn(2, 2)
B = np.random.randn(3, 3)
C = np.random.randn(3, 3)
X = np.bmat([[np.eye(2) + A, np.zeros((2, 3))],
[np.zeros((3, 2)), B.dot(C.T)]])
C = sps.csc_matrix(C)
Aop = NumpyMatrixOperator(A)
Bop = NumpyMatrixOperator(B)
Cop = NumpyMatrixOperator(C)
Xop = BlockDiagonalOperator([
LincombOperator([IdentityOperator(NumpyVectorSpace(2)), Aop], [1, 1]),
Concatenation(Bop, AdjointOperator(Cop))
])
assert np.allclose(X, to_matrix(Xop))
assert np.allclose(X, to_matrix(Xop, format='csr').toarray())
np.random.seed(0)
V = np.random.randn(10, 2)
Vva = NumpyVectorArray(V.T)
Vop = VectorArrayOperator(Vva)
assert np.allclose(V, to_matrix(Vop))
Vop = VectorArrayOperator(Vva, transposed=True)
assert np.allclose(V, to_matrix(Vop).T)
def jacobian(self, U, mu=None):
mu = self.parse_parameter(mu)
options = self.solver_options.get('jacobian') if self.solver_options else None
if len(self.interpolation_dofs) == 0:
if isinstance(self.source, NumpyVectorSpace) and isinstance(self.range, NumpyVectorSpace):
return NumpyMatrixOperator(np.zeros((self.range.dim, self.source.dim)), solver_options=options,
source_id=self.source.id, range_id=self.range.id,
name=self.name + '_jacobian')
else:
return ZeroOperator(self.range, self.source, name=self.name + '_jacobian')
elif hasattr(self, 'operator'):
return EmpiricalInterpolatedOperator(self.operator.jacobian(U, mu=mu), self.interpolation_dofs,
self.collateral_basis, self.triangular,
solver_options=options, name=self.name + '_jacobian')
else:
restricted_source = self.restricted_operator.source
U_dofs = restricted_source.make_array(U.dofs(self.source_dofs))
JU = self.restricted_operator.jacobian(U_dofs, mu=mu) \
.apply(restricted_source.make_array(np.eye(len(self.source_dofs))))
try:
if self.triangular:
interpolation_coefficients = solve_triangular(self.interpolation_matrix, JU.to_numpy().T,
lower=True, unit_diagonal=True).T
else:
interpolation_coefficients = solve(self.interpolation_matrix, JU.to_numpy().T).T
except ValueError: # this exception occurs when AU contains NaNs ...
interpolation_coefficients = np.empty((len(JU), len(self.collateral_basis))) + np.nan
J = self.collateral_basis.lincomb(interpolation_coefficients)
if isinstance(J.space, NumpyVectorSpace):
J = NumpyMatrixOperator(J.to_numpy().T, range_id=self.range.id)
else:
J = VectorArrayOperator(J)
return Concatenation([J, ComponentProjection(self.source_dofs, self.source)],
solver_options=options, name=self.name + '_jacobian')
def numpy_matrix_operator_with_arrays_and_products_factory(dim_source, dim_range, count_source, count_range, seed,
source_id=None, range_id=None):
from scipy.linalg import eigh
op, _, U, V = numpy_matrix_operator_with_arrays_factory(dim_source, dim_range, count_source, count_range, seed,
source_id=source_id, range_id=range_id)
if dim_source > 0:
while True:
sp = np.random.random((dim_source, dim_source))
sp = sp.T.dot(sp)
evals = eigh(sp, eigvals_only=True)
if np.min(evals) > 1e-6:
break
sp = NumpyMatrixOperator(sp, source_id=source_id, range_id=source_id)
else:
sp = NumpyMatrixOperator(np.zeros((0, 0)), source_id=source_id, range_id=source_id)
if dim_range > 0:
while True:
rp = np.random.random((dim_range, dim_range))
rp = rp.T.dot(rp)
evals = eigh(rp, eigvals_only=True)
if np.min(evals) > 1e-6:
break
rp = NumpyMatrixOperator(rp, source_id=range_id, range_id=range_id)
else:
rp = NumpyMatrixOperator(np.zeros((0, 0)), source_id=range_id, range_id=range_id)
return op, None, U, V, sp, rp
def test_lincomb_op_with_zero_coefficients():
p1 = MonomOperator(1)
p2 = MonomOperator(2)
p10 = p1 + 0 * p2
p0 = 0 * p1 + 0 * p1
x = np.linspace(-1., 1., num=3)
vx = p1.source.make_array((x[:, np.newaxis]))
pc1 = NumpyMatrixOperator(np.eye(p1.source.dim))
pc2 = NumpyMatrixOperator(2 * np.eye(p1.source.dim))
pc10 = pc1 + 0 * pc2
pc0 = 0 * pc1 + 0 * pc2
assert np.allclose(p0.apply(vx).to_numpy(), [0.])
assert len(p0.apply(vx)) == len(vx)
assert almost_equal(p10.apply(vx), p1.apply(vx)).all()
assert np.allclose(p0.apply2(vx, vx), [0.])
assert len(p0.apply2(vx, vx)) == len(vx)
assert np.allclose(p10.apply2(vx, vx), p1.apply2(vx, vx))
assert np.allclose(p0.pairwise_apply2(vx, vx), [0.])
assert len(p0.pairwise_apply2(vx, vx)) == len(vx)
assert np.allclose(p10.pairwise_apply2(vx, vx), p1.pairwise_apply2(vx, vx))
assert np.allclose(pc0.apply_adjoint(vx).to_numpy(), [0.])
assert len(pc0.apply_adjoint(vx)) == len(vx)
assert almost_equal(pc10.apply_adjoint(vx), pc1.apply_adjoint(vx)).all()
def action_apply_basis(self, op):
range_basis, source_basis = self.range_basis, self.source_basis
if source_basis is None:
try:
V = op.apply_adjoint(range_basis)
except NotImplementedError:
raise RuleNotMatchingError('apply_adjoint not implemented')
if isinstance(op.source, NumpyVectorSpace):
from pymor.operators.numpy import NumpyMatrixOperator
return NumpyMatrixOperator(V.to_numpy(),
source_id=op.source.id,
name=op.name)
else:
from pymor.operators.constructions import VectorArrayOperator
return VectorArrayOperator(V, adjoint=True, name=op.name)
else:
if range_basis is None:
V = op.apply(source_basis)
if isinstance(op.range, NumpyVectorSpace):
from pymor.operators.numpy import NumpyMatrixOperator
return NumpyMatrixOperator(V.to_numpy().T,
range_id=op.range.id,
name=op.name)
else:
from pymor.operators.constructions import VectorArrayOperator
return VectorArrayOperator(V, adjoint=False, name=op.name)
else:
from pymor.operators.numpy import NumpyMatrixOperator
return NumpyMatrixOperator(op.apply2(range_basis,
source_basis),
name=op.name)
def jacobian(self, U, mu=None):
mu = self.parse_parameter(mu)
if len(self.interpolation_dofs) == 0:
if self.source.type == self.range.type == NumpyVectorArray:
return NumpyMatrixOperator(np.zeros((0, self.source.dim)), name=self.name + '_jacobian')
else:
return ZeroOperator(self.source, self.range, name=self.name + '_jacobian')
elif hasattr(self, 'operator'):
return EmpiricalInterpolatedOperator(self.operator.jacobian(U, mu=mu), self.interpolation_dofs,
self.collateral_basis, self.triangular, self.name + '_jacobian')
else:
U_components = NumpyVectorArray(U.components(self.source_dofs), copy=False)
JU = self.restricted_operator.jacobian(U_components, mu=mu) \
.apply(NumpyVectorArray(np.eye(len(self.source_dofs)), copy=False))
try:
if self.triangular:
interpolation_coefficients = solve_triangular(self.interpolation_matrix, JU.data.T,
lower=True, unit_diagonal=True).T
else:
interpolation_coefficients = np.linalg.solve(self.interpolation_matrix, JU._array.T).T
except ValueError: # this exception occurs when AU contains NaNs ...
interpolation_coefficients = np.empty((len(JU), len(self.collateral_basis))) + np.nan
J = self.collateral_basis.lincomb(interpolation_coefficients)
if isinstance(J, NumpyVectorArray):
J = NumpyMatrixOperator(J.data.T)
else:
J = VectorArrayOperator(J, copy=False)
return Concatenation(J, ComponentProjection(self.source_dofs, self.source), name=self.name + '_jacobian')
def test_block_diagonal():
np.random.seed(0)
A = np.random.randn(2, 3)
B = np.random.randn(4, 5)
Aop = NumpyMatrixOperator(A)
Bop = NumpyMatrixOperator(B)
Cop = BlockDiagonalOperator((Aop, Bop))
assert Cop.source.dim == 8
assert Cop.range.dim == 6
def test_to_matrix_NumpyMatrixOperator():
np.random.seed(0)
A = np.random.randn(2, 2)
Aop = NumpyMatrixOperator(A)
assert_type_and_allclose(A, Aop, 'dense')
Aop = NumpyMatrixOperator(sps.csc_matrix(A))
assert_type_and_allclose(A, Aop, 'csc')
def test_vstack():
np.random.seed(0)
A = np.random.randn(2, 3)
B = np.random.randn(4, 3)
Aop = NumpyMatrixOperator(A)
Bop = NumpyMatrixOperator(B)
Cop = BlockOperator.vstack((Aop, Bop))
assert Cop.source.dim == 3
assert Cop.range.dim == 6
def test_complex():
np.random.seed(0)
I = np.eye(5)
A = np.random.randn(5, 5)
B = np.random.randn(5, 5)
C = np.random.randn(3, 5)
Iop = NumpyMatrixOperator(I)
Aop = NumpyMatrixOperator(A)
Bop = NumpyMatrixOperator(B)
Cva = NumpyVectorSpace.from_data(C)
# assemble_lincomb
assert not np.iscomplexobj(
Aop.assemble_lincomb((Iop, Bop), (1, 1))._matrix)
assert not np.iscomplexobj(
Aop.assemble_lincomb((Aop, Bop), (1, 1))._matrix)
assert np.iscomplexobj(
Aop.assemble_lincomb((Aop, Bop), (1 + 0j, 1 + 0j))._matrix)
assert np.iscomplexobj(Aop.assemble_lincomb((Aop, Bop), (1j, 1))._matrix)
assert np.iscomplexobj(Aop.assemble_lincomb((Bop, Aop), (1, 1j))._matrix)
# apply_inverse
assert not np.iscomplexobj(Aop.apply_inverse(Cva).data)
assert np.iscomplexobj((Aop * 1j).apply_inverse(Cva).data)
assert np.iscomplexobj(
Aop.assemble_lincomb((Aop, Bop), (1, 1j)).apply_inverse(Cva).data)
assert np.iscomplexobj(Aop.apply_inverse(Cva * 1j).data)
# append
for rsrv in (0, 10):
for o_ind in (slice(None), [0]):
va = NumpyVectorSpace(5).empty(reserve=rsrv)
va.append(Cva)
D = np.random.randn(1, 5) + 1j * np.random.randn(1, 5)
Dva = NumpyVectorSpace.from_data(D)
assert not np.iscomplexobj(va.data)
assert np.iscomplexobj(Dva.data)
va.append(Dva[o_ind])
assert np.iscomplexobj(va.data)
# scal
assert not np.iscomplexobj(Cva.data)
assert np.iscomplexobj((Cva * 1j).data)
assert np.iscomplexobj((Cva * (1 + 0j)).data)
# axpy
assert not np.iscomplexobj(Cva.data)
Cva[0].axpy(1, Dva)
assert np.iscomplexobj(Cva.data)
Cva = NumpyVectorSpace.from_data(C)
assert not np.iscomplexobj(Cva.data)
Cva[0].axpy(1j, Dva)
assert np.iscomplexobj(Cva.data)
def test_lincomb_adjoint():
op = LincombOperator([NumpyMatrixOperator(np.eye(10)), NumpyMatrixOperator(np.eye(10))],
[1+3j, ExpressionParameterFunctional('c[0] + 3', {'c': 1})])
mu = op.parameters.parse(1j)
U = op.range.random()
V = op.apply_adjoint(U, mu=mu)
VV = op.H.apply(U, mu=mu)
assert np.all(almost_equal(V, VV))
VVV = op.apply(U, mu=mu).conj()
assert np.all(almost_equal(V, VVV))
def projected(self, source_basis, range_basis, product=None, name=None):
name = name or '{}_projected'.format(self.name)
if self.linear and not self.parametric:
assert source_basis is None or source_basis in self.source
assert range_basis is None or range_basis in self.range
assert product is None or product.source == product.range == self.range
if source_basis is None:
if range_basis is None:
return self
else:
V = self.apply_adjoint(range_basis, range_product=product)
if self.source.type == NumpyVectorArray:
from pymor.operators.numpy import NumpyMatrixOperator
return NumpyMatrixOperator(V.data, name=name)
else:
from pymor.operators.constructions import VectorArrayOperator
return VectorArrayOperator(V,
transposed=True,
copy=False,
name=name)
else:
if range_basis is None:
V = self.apply(source_basis)
if self.range.type == NumpyVectorArray:
from pymor.operators.numpy import NumpyMatrixOperator
return NumpyMatrixOperator(V.data.T, name=name)
else:
from pymor.operators.constructions import VectorArrayOperator
return VectorArrayOperator(V,
transposed=False,
copy=False,
name=name)
elif product is None:
from pymor.operators.numpy import NumpyMatrixOperator
return NumpyMatrixOperator(self.apply2(range_basis,
source_basis,
pairwise=False),
name=name)
else:
from pymor.operators.numpy import NumpyMatrixOperator
V = self.apply(source_basis)
return NumpyMatrixOperator(product.apply2(range_basis,
V,
pairwise=False),
name=name)
else:
self.logger.warn('Using inefficient generic projection operator')
# Since the bases are not immutable and we do not own them,
# the ProjectedOperator will have to create copies of them.
return ProjectedOperator(self,
source_basis,
range_basis,
product,
copy=True,
name=name)
def projected(self, range_basis, source_basis, product=None, name=None):
name = name or '{}_projected'.format(self.name)
if self.linear and not self.parametric:
assert source_basis is None or source_basis in self.source
assert range_basis is None or range_basis in self.range
assert product is None or product.source == product.range == self.range
if source_basis is None:
if range_basis is None:
return self
else:
try:
V = self.apply_adjoint(range_basis,
range_product=product)
except NotImplementedError:
return ProjectedOperator(self,
range_basis,
None,
product,
name=name)
if self.source.type == NumpyVectorArray:
from pymor.operators.numpy import NumpyMatrixOperator
return NumpyMatrixOperator(V.data, name=name)
else:
from pymor.operators.constructions import VectorArrayOperator
return VectorArrayOperator(V,
transposed=True,
name=name)
else:
if range_basis is None:
V = self.apply(source_basis)
if self.range.type == NumpyVectorArray:
from pymor.operators.numpy import NumpyMatrixOperator
return NumpyMatrixOperator(V.data.T, name=name)
else:
from pymor.operators.constructions import VectorArrayOperator
return VectorArrayOperator(V,
transposed=False,
name=name)
elif product is None:
from pymor.operators.numpy import NumpyMatrixOperator
return NumpyMatrixOperator(self.apply2(
range_basis, source_basis),
name=name)
else:
from pymor.operators.numpy import NumpyMatrixOperator
V = self.apply(source_basis)
return NumpyMatrixOperator(product.apply2(range_basis, V),
name=name)
else:
self.logger.warn('Using inefficient generic projection operator')
return ProjectedOperator(self,
range_basis,
source_basis,
product,
name=name)
def action_apply_basis(self, op):
range_basis, source_basis, product = self.range_basis, self.source_basis, self.product
if source_basis is None:
if range_basis is None:
return op
else:
try:
V = op.apply_transpose(
product.apply(range_basis) if product else range_basis)
except NotImplementedError:
raise RuleNotMatchingError(
'apply_transpose not implemented')
if isinstance(op.source, NumpyVectorSpace):
from pymor.operators.numpy import NumpyMatrixOperator
return NumpyMatrixOperator(V.data,
source_id=op.source.id,
range_id=op.range.id,
name=op.name)
else:
from pymor.operators.constructions import VectorArrayOperator
return VectorArrayOperator(V,
transposed=True,
space_id=op.range.id,
name=op.name)
else:
if range_basis is None:
V = op.apply(source_basis)
if isinstance(op.range, NumpyVectorSpace):
from pymor.operators.numpy import NumpyMatrixOperator
return NumpyMatrixOperator(V.data.T,
source_id=op.source.id,
range_id=op.range.id,
name=op.name)
else:
from pymor.operators.constructions import VectorArrayOperator
return VectorArrayOperator(V,
transposed=False,
space_id=op.source.id,
name=op.name)
elif product is None:
from pymor.operators.numpy import NumpyMatrixOperator
return NumpyMatrixOperator(op.apply2(range_basis,
source_basis),
source_id=op.source.id,
range_id=op.range.id,
name=op.name)
else:
from pymor.operators.numpy import NumpyMatrixOperator
V = op.apply(source_basis)
return NumpyMatrixOperator(product.apply2(range_basis, V),
source_id=op.source.id,
range_id=op.range.id,
name=op.name)
def thermalblock_vectorarray_factory(adjoint, xblocks, yblocks, diameter, seed):
from pymor.operators.constructions import VectorArrayOperator
_, _, U, V, sp, rp = thermalblock_factory(xblocks, yblocks, diameter, seed)
op = VectorArrayOperator(U, adjoint)
if adjoint:
U = V
V = op.range.make_array(np.random.random((7, op.range.dim)))
sp = rp
rp = NumpyMatrixOperator(np.eye(op.range.dim) * 2)
else:
U = op.source.make_array(np.random.random((7, op.source.dim)))
sp = NumpyMatrixOperator(np.eye(op.source.dim) * 2)
return op, None, U, V, sp, rp
def thermalblock_vectorarray_factory(transposed, xblocks, yblocks, diameter, seed):
from pymor.operators.constructions import VectorArrayOperator
_, _, U, V, sp, rp = thermalblock_factory(xblocks, yblocks, diameter, seed)
op = VectorArrayOperator(U, transposed)
if transposed:
U = V
V = NumpyVectorArray(np.random.random((7, op.range.dim)), copy=False)
sp = rp
rp = NumpyMatrixOperator(np.eye(op.range.dim) * 2)
else:
U = NumpyVectorArray(np.random.random((7, op.source.dim)), copy=False)
sp = NumpyMatrixOperator(np.eye(op.source.dim) * 2)
return op, None, U, V, sp, rp
def test_to_matrix_LincombOperator():
np.random.seed(0)
A = np.random.randn(3, 3)
B = np.random.randn(3, 2)
a = np.random.randn()
b = np.random.randn()
C = a * A + b * B.dot(B.T)
Aop = NumpyMatrixOperator(A)
Bop = NumpyMatrixOperator(B)
Cop = Aop * a + (Bop @ Bop.T) * b
assert_type_and_allclose(C, Cop, 'dense')
Aop = NumpyMatrixOperator(sps.csc_matrix(A))
Bop = NumpyMatrixOperator(B)
Cop = Aop * a + (Bop @ Bop.T) * b
assert_type_and_allclose(C, Cop, 'dense')
Aop = NumpyMatrixOperator(A)
Bop = NumpyMatrixOperator(sps.csc_matrix(B))
Cop = Aop * a + (Bop @ Bop.T) * b
assert_type_and_allclose(C, Cop, 'dense')
Aop = NumpyMatrixOperator(sps.csc_matrix(A))
Bop = NumpyMatrixOperator(sps.csc_matrix(B))
Cop = Aop * a + (Bop @ Bop.T) * b
assert_type_and_allclose(C, Cop, 'sparse')
def test_to_matrix_Concatenation():
np.random.seed(0)
A = np.random.randn(2, 3)
B = np.random.randn(3, 4)
C = A.dot(B)
Aop = NumpyMatrixOperator(A)
Bop = NumpyMatrixOperator(B)
Cop = Aop @ Bop
assert_type_and_allclose(C, Cop, 'dense')
Aop = NumpyMatrixOperator(sps.csc_matrix(A))
Bop = NumpyMatrixOperator(B)
Cop = Aop @ Bop
assert_type_and_allclose(C, Cop, 'dense')
Aop = NumpyMatrixOperator(A)
Bop = NumpyMatrixOperator(sps.csc_matrix(B))
Cop = Aop @ Bop
assert_type_and_allclose(C, Cop, 'dense')
Aop = NumpyMatrixOperator(sps.csc_matrix(A))
Bop = NumpyMatrixOperator(sps.csc_matrix(B))
Cop = Aop @ Bop
assert_type_and_allclose(A, Aop, 'sparse')
def test_to_matrix_LincombOperator():
np.random.seed(0)
A = np.random.randn(3, 3)
B = np.random.randn(3, 2)
a = np.random.randn()
b = np.random.randn()
C = a * A + b * B.dot(B.T)
Aop = NumpyMatrixOperator(A)
Bop = NumpyMatrixOperator(B)
Cop = LincombOperator([Aop, Concatenation([Bop, Bop.T])], [a, b])
assert_type_and_allclose(C, Cop, 'dense')
Aop = NumpyMatrixOperator(sps.csc_matrix(A))
Bop = NumpyMatrixOperator(B)
Cop = LincombOperator([Aop, Concatenation([Bop, Bop.T])], [a, b])
assert_type_and_allclose(C, Cop, 'dense')
Aop = NumpyMatrixOperator(A)
Bop = NumpyMatrixOperator(sps.csc_matrix(B))
Cop = LincombOperator([Aop, Concatenation([Bop, Bop.T])], [a, b])
assert_type_and_allclose(C, Cop, 'dense')
Aop = NumpyMatrixOperator(sps.csc_matrix(A))
Bop = NumpyMatrixOperator(sps.csc_matrix(B))
Cop = LincombOperator([Aop, Concatenation([Bop, Bop.T])], [a, b])
assert_type_and_allclose(C, Cop, 'sparse')
def test_to_matrix_BlockDiagonalOperator():
np.random.seed(0)
A1 = np.random.randn(2, 2)
A2 = np.random.randn(3, 3)
B = np.asarray(np.bmat([[A1, np.zeros((2, 3))], [np.zeros((3, 2)), A2]]))
A1op = NumpyMatrixOperator(A1)
A2op = NumpyMatrixOperator(A2)
Bop = BlockDiagonalOperator([A1op, A2op])
assert_type_and_allclose(B, Bop, 'sparse')
A1op = NumpyMatrixOperator(sps.csc_matrix(A1))
A2op = NumpyMatrixOperator(A2)
Bop = BlockDiagonalOperator([A1op, A2op])
assert_type_and_allclose(B, Bop, 'sparse')
def _reduce(self):
d = self.d
self.logger.info('Computing oswald interpolations ...')
oi = d.estimator.oswald_interpolation_error
oi_red = []
for i, OI_i_space in enumerate(oi.range.subspaces):
oi_i = oi._blocks[i, i]
basis = self.bases[oi_i.source.id]
self.bases[OI_i_space.id] = oi_i.apply(basis)
oi_red.append(
NumpyMatrixOperator(np.eye(len(basis)),
source_id=oi_i.source.id,
range_id=oi_i.range.id))
oi_red = unblock(BlockDiagonalOperator(oi_red))
self.logger.info('Computing flux reconstructions ...')
fr = d.estimator.flux_reconstruction
for i, RT_i_space in enumerate(fr.range.subspaces):
self.bases[RT_i_space.id] = RT_i_space.empty()
red_aff_components = []
for i_aff, aff_component in enumerate(fr.operators):
red_aff_component = []
for i, RT_i_space in enumerate(aff_component.range.subspaces):
fr_i = aff_component._blocks[i, i]
basis = self.bases[fr_i.source.id]
self.bases[RT_i_space.id].append(fr_i.apply(basis))
M = np.zeros((len(basis) * len(fr.operators), len(basis)))
M[i_aff * len(basis):(i_aff + 1) * len(basis), :] = np.eye(
len(basis))
red_aff_component.append(
NumpyMatrixOperator(M,
source_id=fr_i.source.id,
range_id=fr_i.range.id))
red_aff_components.append(BlockDiagonalOperator(red_aff_component))
fr_red = LincombOperator(red_aff_components, fr.coefficients)
fr_red = unblock(fr_red)
red_estimator = d.estimator.with_(flux_reconstruction=fr_red,
oswald_interpolation_error=oi_red)
rd = super()._reduce()
rd = rd.with_(estimator=red_estimator)
return rd
def test_expand():
ops = [NumpyMatrixOperator(np.eye(1) * i) for i in range(8)]
pfs = [ProjectionParameterFunctional('p', 9, i) for i in range(8)]
prods = [o * p for o, p in zip(ops, pfs)]
op = ((prods[0] + prods[1] + prods[2]) @ (prods[3] + prods[4] + prods[5])
@ (prods[6] + prods[7]))
eop = expand(op)
assert isinstance(eop, LincombOperator)
assert len(eop.operators) == 3 * 3 * 2
assert all(
isinstance(o, ConcatenationOperator) and len(o.operators) == 3
for o in eop.operators)
assert ({to_matrix(o)[0, 0]
for o in eop.operators} == {
i0 * i1 * i2
for i0, i1, i2 in product([0, 1, 2], [3, 4, 5], [6, 7])
})
assert ({
frozenset(p.index for p in pf.factors)
for pf in eop.coefficients
} == {
frozenset([i0, i1, i2])
for i0, i1, i2 in product([0, 1, 2], [3, 4, 5], [6, 7])
})
def project_operators(self):
fom = self.fom
RB = self.bases['RB']
product = self.products['RB']
if self.initial_data_product != product:
# TODO there should be functionality for this somewhere else
projection_matrix = RB.gramian(self.initial_data_product)
projection_op = NumpyMatrixOperator(projection_matrix)
inverse_projection_op = InverseOperator(projection_op, 'inverse_projection_op')
pid = project(fom.initial_data, range_basis=RB, source_basis=None, product=self.initial_data_product)
projected_initial_data = ConcatenationOperator([inverse_projection_op, pid])
else:
projected_initial_data = project(fom.initial_data, range_basis=RB, source_basis=None,
product=product)
projected_operators = {
'mass': (None if (isinstance(fom.mass, IdentityOperator) and product is None
or self.product_is_mass) else
project(fom.mass, RB, RB)),
'operator': project(fom.operator, RB, RB),
'rhs': project(fom.rhs, RB, None),
'initial_data': projected_initial_data,
'products': {k: project(v, RB, RB) for k, v in fom.products.items()},
'output_functional': project(fom.output_functional, None, RB) if fom.output_functional else None
}
return projected_operators
def numpy_matrix_operator_with_arrays_factory(dim_source, dim_range, count_source, count_range, seed,
source_id=None, range_id=None):
np.random.seed(seed)
op = NumpyMatrixOperator(np.random.random((dim_range, dim_source)), source_id=source_id, range_id=range_id)
s = op.source.make_array(np.random.random((count_source, dim_source)))
r = op.range.make_array(np.random.random((count_range, dim_range)))
return op, None, s, r
def thermalblock_vector_factory(xblocks, yblocks, diameter, seed):
from pymor.operators.constructions import VectorOperator
_, _, U, V, sp, rp = thermalblock_factory(xblocks, yblocks, diameter, seed)
op = VectorOperator(U.copy(ind=0))
U = NumpyVectorArray(np.random.random((7, 1)), copy=False)
sp = NumpyMatrixOperator(np.eye(1) * 2)
return op, None, U, V, sp, rp
def jacobian(self, U, mu=None):
assert U in self.source and len(U) == 1
UU = self.op.source.zeros()
UU._list[0].real_part.impl[:] = U.data[0]
JJ = self.op.jacobian(UU, mu=mu)
return NumpyMatrixOperator(
JJ.matrix.array()[self.restricted_range_dofs, :])
def thermalblock_vector_factory(xblocks, yblocks, diameter, seed):
from pymor.operators.constructions import VectorOperator
_, _, U, V, sp, rp = thermalblock_factory(xblocks, yblocks, diameter, seed)
op = VectorOperator(U[0])
U = op.source.make_array(np.random.random((7, 1)))
sp = NumpyMatrixOperator(np.eye(1) * 2)
return op, None, U, V, sp, rp
def create_cl_fom(Re=110, level=2, palpha=1e-3, control='bc'):
"""Create model which is used to evaluate the H2-Gap norm."""
setup_str = 'lvl_' + str(level) + ('_' + control if control is not None else '') \
+ '_re_' + str(Re) + ('_palpha_' + str(palpha) if control == 'bc' else '')
fom = load_fom(Re, level, palpha, control)
Bra = fom.B.as_range_array()
Cva = fom.C.as_source_array()
Z = solve_ricc_lrcf(fom.A, fom.E, Bra, Cva, trans=False)
K = fom.E.apply(Z).lincomb(Z.dot(Cva).T)
KC = LowRankOperator(K, np.eye(len(K)), Cva)
mKB = cat_arrays([-K, Bra]).to_numpy().T
mKBop = NumpyMatrixOperator(mKB)
mKBop_proj = LerayProjectedOperator(mKBop,
fom.A.source.G,
fom.A.source.E,
projection_space='range')
cl_fom = LTIModel(fom.A - KC, mKBop_proj, fom.C, None, fom.E)
with open(setup_str + '/cl_fom', 'wb') as cl_fom_file:
pickle.dump({'cl_fom': cl_fom}, cl_fom_file)
