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_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 action_BlockSpaceIdentityOperator(self, ops):
new_ops = tuple(
BlockDiagonalOperator(
[IdentityOperator(s) for s in op.source.
subspaces]) if isinstance(op, IdentityOperator) else op
for op in ops if not isinstance(op, ZeroOperator))
return self.apply(new_ops)
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 action_BlockDiagonalOperator(self, ops):
coefficients = self.coefficients
num_source_blocks = ops[0].num_source_blocks
blocks = np.empty((num_source_blocks,), dtype=object)
if len(ops) > 1:
for i in range(num_source_blocks):
operators_i = [op._blocks[i, i] for op in ops]
blocks[i] = assemble_lincomb(operators_i, coefficients,
solver_options=self.solver_options, name=self.name)
if blocks[i] is None:
return None
return BlockDiagonalOperator(blocks)
else:
c = coefficients[0]
if c == 1:
return ops[0]
for i in range(num_source_blocks):
blocks[i] = ops[0]._blocks[i, i] * c
return BlockDiagonalOperator(blocks)
def test_blk_diag_apply_inverse_adjoint():
np.random.seed(0)
A = np.random.randn(2, 2)
B = np.random.randn(3, 3)
C = spla.block_diag(A, B)
Aop = NumpyMatrixOperator(A)
Bop = NumpyMatrixOperator(B)
Cop = BlockDiagonalOperator((Aop, Bop))
v1 = np.random.randn(2)
v2 = np.random.randn(3)
v = np.hstack((v1, v2))
v1va = NumpyVectorSpace.from_numpy(v1)
v2va = NumpyVectorSpace.from_numpy(v2)
vva = BlockVectorSpace.make_array((v1va, v2va))
wva = Cop.apply_inverse_adjoint(vva)
w = np.hstack((wva.block(0).to_numpy(), wva.block(1).to_numpy()))
assert np.allclose(spla.solve(C.T, v), w)
def test_blk_diag_apply_inverse():
np.random.seed(0)
A = np.random.randn(2, 2)
B = np.random.randn(3, 3)
C = spla.block_diag(A, B)
Aop = NumpyMatrixOperator(A)
Bop = NumpyMatrixOperator(B)
Cop = BlockDiagonalOperator((Aop, Bop))
v1 = np.random.randn(2)
v2 = np.random.randn(3)
v = np.hstack((v1, v2))
v1va = NumpyVectorSpace.from_data(v1)
v2va = NumpyVectorSpace.from_data(v2)
vva = BlockVectorSpace.make_array((v1va, v2va))
wva = Cop.apply_inverse(vva)
w = np.hstack((wva.block(0).data, wva.block(1).data))
assert np.allclose(spla.solve(C, v), w)
def test_block_identity_lincomb():
space = NumpyVectorSpace(10)
space2 = BlockVectorSpace([space, space])
identity = BlockDiagonalOperator([IdentityOperator(space), IdentityOperator(space)])
identity2 = IdentityOperator(space2)
ones = space.ones()
ones2 = space2.make_array([ones, ones])
idid = identity + identity2
assert almost_equal(ones2 * 2, idid.apply(ones2))
assert almost_equal(ones2 * 2, idid.apply_adjoint(ones2))
assert almost_equal(ones2 * 0.5, idid.apply_inverse(ones2))
assert almost_equal(ones2 * 0.5, idid.apply_inverse_adjoint(ones2))
def discretize(grid_and_problem_data, solver_options, mpi_comm):
################ Setup
logger = getLogger('discretize_elliptic_block_swipdg.discretize')
logger.info('discretizing ... ')
grid, boundary_info = grid_and_problem_data['grid'], grid_and_problem_data[
'boundary_info']
local_all_dirichlet_boundary_info = make_subdomain_boundary_info(
grid, {'type': 'xt.grid.boundaryinfo.alldirichlet'})
local_subdomains, num_local_subdomains, num_global_subdomains = _get_subdomains(
grid)
local_all_neumann_boundary_info = make_subdomain_boundary_info(
grid, {'type': 'xt.grid.boundaryinfo.allneumann'})
block_space = make_block_dg_space(grid)
global_rt_space = make_rt_space(grid)
subdomain_rt_spaces = [
global_rt_space.restrict_to_dd_subdomain_view(grid, ii)
for ii in range(num_global_subdomains)
]
local_patterns = [
block_space.local_space(ii).compute_pattern('face_and_volume')
for ii in range(block_space.num_blocks)
]
coupling_patterns = {
'in_in': {},
'out_out': {},
'in_out': {},
'out_in': {}
}
coupling_matrices = {
'in_in': {},
'out_out': {},
'in_out': {},
'out_in': {}
}
for ii in range(num_global_subdomains):
ii_size = block_space.local_space(ii).size()
for jj in grid.neighboring_subdomains(ii):
jj_size = block_space.local_space(jj).size()
if ii < jj: # Assemble primally (visit each coupling only once).
coupling_patterns['in_in'][(ii, jj)] = block_space.local_space(
ii).compute_pattern('face_and_volume')
coupling_patterns['out_out'][(
ii, jj)] = block_space.local_space(jj).compute_pattern(
'face_and_volume')
coupling_patterns['in_out'][(
ii, jj)] = block_space.compute_coupling_pattern(
ii, jj, 'face')
coupling_patterns['out_in'][(
ii, jj)] = block_space.compute_coupling_pattern(
jj, ii, 'face')
coupling_matrices['in_in'][(ii, jj)] = Matrix(
ii_size, ii_size, coupling_patterns['in_in'][(ii, jj)])
coupling_matrices['out_out'][(ii, jj)] = Matrix(
jj_size, jj_size, coupling_patterns['out_out'][(ii, jj)])
coupling_matrices['in_out'][(ii, jj)] = Matrix(
ii_size, jj_size, coupling_patterns['in_out'][(ii, jj)])
coupling_matrices['out_in'][(ii, jj)] = Matrix(
jj_size, ii_size, coupling_patterns['out_in'][(ii, jj)])
boundary_patterns = {}
for ii in grid.boundary_subdomains():
boundary_patterns[ii] = block_space.local_space(ii).compute_pattern(
'face_and_volume')
################ Assemble LHS and RHS
lambda_, kappa = grid_and_problem_data['lambda'], grid_and_problem_data[
'kappa']
if isinstance(lambda_, dict):
lambda_funcs = lambda_['functions']
lambda_coeffs = lambda_['coefficients']
else:
lambda_funcs = [
lambda_,
]
lambda_coeffs = [
1,
]
logger.debug('block op ... ')
ops, block_ops = zip(*(discretize_lhs(
lf, grid, block_space, local_patterns, boundary_patterns,
coupling_matrices, kappa, local_all_neumann_boundary_info,
boundary_info, coupling_patterns, solver_options)
for lf in lambda_funcs))
global_operator = LincombOperator(ops,
lambda_coeffs,
solver_options=solver_options,
name='GlobalOperator')
logger.debug('block op global done ')
block_op = LincombOperator(block_ops,
lambda_coeffs,
name='lhs',
solver_options=solver_options)
logger.debug('block op done ')
f = grid_and_problem_data['f']
if isinstance(f, dict):
f_funcs = f['functions']
f_coeffs = f['coefficients']
else:
f_funcs = [
f,
]
f_coeffs = [
1,
]
rhss, block_rhss = zip(*(discretize_rhs(
ff, grid, block_space, global_operator, block_ops, block_op)
for ff in f_funcs))
global_rhs = LincombOperator(rhss, f_coeffs)
block_rhs = LincombOperator(block_rhss, f_coeffs)
solution_space = block_op.source
################ Assemble interpolation and reconstruction operators
logger.info('discretizing interpolation ')
# Oswald interpolation error operator
oi_op = BlockDiagonalOperator([
OswaldInterpolationErrorOperator(ii, block_op.source, grid,
block_space)
for ii in range(num_global_subdomains)
],
name='oswald_interpolation_error')
# Flux reconstruction operator
fr_op = LincombOperator([
BlockDiagonalOperator([
FluxReconstructionOperator(ii, block_op.source, grid, block_space,
global_rt_space, subdomain_rt_spaces,
lambda_xi, kappa)
for ii in range(num_global_subdomains)
]) for lambda_xi in lambda_funcs
],
lambda_coeffs,
name='flux_reconstruction')
################ Assemble inner products and error estimator operators
logger.info('discretizing inner products ')
lambda_bar, lambda_hat = grid_and_problem_data[
'lambda_bar'], grid_and_problem_data['lambda_hat']
mu_bar, mu_hat = grid_and_problem_data['mu_bar'], grid_and_problem_data[
'mu_hat']
operators = {}
local_projections = []
local_rt_projections = []
local_oi_projections = []
local_div_ops = []
local_l2_products = []
data = dict(grid=grid,
block_space=block_space,
local_projections=local_projections,
local_rt_projections=local_rt_projections,
local_oi_projections=local_oi_projections,
local_div_ops=local_div_ops,
local_l2_products=local_l2_products)
for ii in range(num_global_subdomains):
neighborhood = grid.neighborhood_of(ii)
################ Assemble local inner products
local_dg_space = block_space.local_space(ii)
# we want a larger pattern to allow for axpy with other matrices
tmp_local_matrix = Matrix(
local_dg_space.size(), local_dg_space.size(),
local_dg_space.compute_pattern('face_and_volume'))
local_energy_product_ops = []
local_energy_product_coeffs = []
for func, coeff in zip(lambda_funcs, lambda_coeffs):
local_energy_product_ops.append(
make_elliptic_matrix_operator(func,
kappa,
tmp_local_matrix.copy(),
local_dg_space,
over_integrate=0))
local_energy_product_coeffs.append(coeff)
local_energy_product_ops.append(
make_penalty_product_matrix_operator(
grid,
ii,
local_all_dirichlet_boundary_info,
local_dg_space,
func,
kappa,
over_integrate=0))
local_energy_product_coeffs.append(coeff)
local_l2_product = make_l2_matrix_operator(tmp_local_matrix.copy(),
local_dg_space)
del tmp_local_matrix
local_assembler = make_system_assembler(local_dg_space)
for local_product_op in local_energy_product_ops:
local_assembler.append(local_product_op)
local_assembler.append(local_l2_product)
local_assembler.assemble()
local_energy_product_name = 'local_energy_dg_product_{}'.format(ii)
local_energy_product = LincombOperator([
DuneXTMatrixOperator(op.matrix(),
source_id='domain_{}'.format(ii),
range_id='domain_{}'.format(ii))
for op in local_energy_product_ops
],
local_energy_product_coeffs,
name=local_energy_product_name)
operators[local_energy_product_name] = \
local_energy_product.assemble(mu_bar).with_(name=local_energy_product_name)
local_l2_product = DuneXTMatrixOperator(
local_l2_product.matrix(),
source_id='domain_{}'.format(ii),
range_id='domain_{}'.format(ii))
local_l2_products.append(local_l2_product)
# assemble local elliptic product
matrix = make_local_elliptic_matrix_operator(grid, ii, local_dg_space,
lambda_bar, kappa)
matrix.assemble()
local_elliptic_product = DuneXTMatrixOperator(
matrix.matrix(),
range_id='domain_{}'.format(ii),
source_id='domain_{}'.format(ii))
################ Assemble local to global projections
# assemble projection (solution space) -> (ii space)
local_projection = BlockProjectionOperator(block_op.source, ii)
local_projections.append(local_projection)
# assemble projection (RT spaces on neighborhoods of subdomains) -> (local RT space on ii)
ops = np.full(num_global_subdomains, None)
for kk in neighborhood:
component = grid.neighborhood_of(kk).index(ii)
assert fr_op.range.subspaces[kk].subspaces[
component].id == 'LOCALRT_{}'.format(ii)
ops[kk] = BlockProjectionOperator(fr_op.range.subspaces[kk],
component)
local_rt_projection = BlockRowOperator(
ops,
source_spaces=fr_op.range.subspaces,
name='local_rt_projection_{}'.format(ii))
local_rt_projections.append(local_rt_projection)
# assemble projection (OI spaces on neighborhoods of subdomains) -> (ii space)
ops = np.full(num_global_subdomains, None)
for kk in neighborhood:
component = grid.neighborhood_of(kk).index(ii)
assert oi_op.range.subspaces[kk].subspaces[
component].id == 'domain_{}'.format(ii)
ops[kk] = BlockProjectionOperator(oi_op.range.subspaces[kk],
component)
local_oi_projection = BlockRowOperator(
ops,
source_spaces=oi_op.range.subspaces,
name='local_oi_projection_{}'.format(ii))
local_oi_projections.append(local_oi_projection)
################ Assemble additional operators for error estimation
# assemble local divergence operator
local_rt_space = global_rt_space.restrict_to_dd_subdomain_view(
grid, ii)
local_div_op = make_divergence_matrix_operator_on_subdomain(
grid, ii, local_dg_space, local_rt_space)
local_div_op.assemble()
local_div_op = DuneXTMatrixOperator(
local_div_op.matrix(),
source_id='LOCALRT_{}'.format(ii),
range_id='domain_{}'.format(ii),
name='local_divergence_{}'.format(ii))
local_div_ops.append(local_div_op)
################ Assemble error estimator operators -- Nonconformity
operators['nc_{}'.format(ii)] = \
Concatenation([local_oi_projection.T, local_elliptic_product, local_oi_projection],
name='nonconformity_{}'.format(ii))
################ Assemble error estimator operators -- Residual
if len(f_funcs) == 1:
assert f_coeffs[0] == 1
local_div = Concatenation([local_div_op, local_rt_projection])
local_rhs = VectorFunctional(
block_rhs.operators[0]._array._blocks[ii])
operators['r_fd_{}'.format(ii)] = \
Concatenation([local_rhs, local_div], name='r1_{}'.format(ii))
operators['r_dd_{}'.format(ii)] = \
Concatenation([local_div.T, local_l2_product, local_div], name='r2_{}'.format(ii))
################ Assemble error estimator operators -- Diffusive flux
operators['df_aa_{}'.format(ii)] = LincombOperator(
[
assemble_estimator_diffusive_flux_aa(
lambda_xi, lambda_xi_prime, grid, ii, block_space,
lambda_hat, kappa, solution_space)
for lambda_xi in lambda_funcs
for lambda_xi_prime in lambda_funcs
], [
ProductParameterFunctional([c1, c2]) for c1 in lambda_coeffs
for c2 in lambda_coeffs
],
name='diffusive_flux_aa_{}'.format(ii))
operators['df_bb_{}'.format(
ii)] = assemble_estimator_diffusive_flux_bb(
grid, ii, subdomain_rt_spaces, lambda_hat, kappa,
local_rt_projection)
operators['df_ab_{}'.format(ii)] = LincombOperator(
[
assemble_estimator_diffusive_flux_ab(
lambda_xi, grid, ii, block_space, subdomain_rt_spaces,
lambda_hat, kappa, local_rt_projection, local_projection)
for lambda_xi in lambda_funcs
],
lambda_coeffs,
name='diffusive_flux_ab_{}'.format(ii))
################ Final assembly
logger.info('final assembly ')
# instantiate error estimator
min_diffusion_evs = np.array([
min_diffusion_eigenvalue(grid, ii, lambda_hat, kappa)
for ii in range(num_global_subdomains)
])
subdomain_diameters = np.array(
[subdomain_diameter(grid, ii) for ii in range(num_global_subdomains)])
if len(f_funcs) == 1:
assert f_coeffs[0] == 1
local_eta_rf_squared = np.array([
apply_l2_product(grid,
ii,
f_funcs[0],
f_funcs[0],
over_integrate=2)
for ii in range(num_global_subdomains)
])
else:
local_eta_rf_squared = None
estimator = EllipticEstimator(grid,
min_diffusion_evs,
subdomain_diameters,
local_eta_rf_squared,
lambda_coeffs,
mu_bar,
mu_hat,
fr_op,
oswald_interpolation_error=oi_op,
mpi_comm=mpi_comm)
l2_product = BlockDiagonalOperator(local_l2_products)
# instantiate discretization
neighborhoods = [
grid.neighborhood_of(ii) for ii in range(num_global_subdomains)
]
local_boundary_info = make_subdomain_boundary_info(
grid_and_problem_data['grid'],
{'type': 'xt.grid.boundaryinfo.alldirichlet'})
d = DuneDiscretization(global_operator=global_operator,
global_rhs=global_rhs,
neighborhoods=neighborhoods,
enrichment_data=(grid, local_boundary_info, lambda_,
kappa, f, block_space),
operator=block_op,
rhs=block_rhs,
visualizer=DuneGDTVisualizer(block_space),
operators=operators,
products={'l2': l2_product},
estimator=estimator,
data=data)
parameter_range = grid_and_problem_data['parameter_range']
logger.info('final assembly B')
d = d.with_(parameter_space=CubicParameterSpace(
d.parameter_type, parameter_range[0], parameter_range[1]))
logger.info('final assembly C')
return d, data
def misc_operator_with_arrays_and_products_factory(n):
if n == 0:
from pymor.operators.constructions import ComponentProjection
_, _, U, V, sp, rp = numpy_matrix_operator_with_arrays_and_products_factory(
100, 10, 4, 3, n)
op = ComponentProjection(np.random.randint(0, 100, 10), U.space)
return op, _, U, V, sp, rp
elif n == 1:
from pymor.operators.constructions import ComponentProjection
_, _, U, V, sp, rp = numpy_matrix_operator_with_arrays_and_products_factory(
100, 0, 4, 3, n)
op = ComponentProjection([], U.space)
return op, _, U, V, sp, rp
elif n == 2:
from pymor.operators.constructions import ComponentProjection
_, _, U, V, sp, rp = numpy_matrix_operator_with_arrays_and_products_factory(
100, 3, 4, 3, n)
op = ComponentProjection([3, 3, 3], U.space)
return op, _, U, V, sp, rp
elif n == 3:
from pymor.operators.constructions import AdjointOperator
op, _, U, V, sp, rp = numpy_matrix_operator_with_arrays_and_products_factory(
100, 20, 4, 3, n)
op = AdjointOperator(op, with_apply_inverse=True)
return op, _, V, U, rp, sp
elif n == 4:
from pymor.operators.constructions import AdjointOperator
op, _, U, V, sp, rp = numpy_matrix_operator_with_arrays_and_products_factory(
100, 20, 4, 3, n)
op = AdjointOperator(op, with_apply_inverse=False)
return op, _, V, U, rp, sp
elif 5 <= n <= 7:
from pymor.operators.constructions import SelectionOperator
from pymor.parameters.functionals import ProjectionParameterFunctional
op0, _, U, V, sp, rp = numpy_matrix_operator_with_arrays_and_products_factory(
30, 30, 4, 3, n)
op1 = NumpyMatrixOperator(np.random.random((30, 30)))
op2 = NumpyMatrixOperator(np.random.random((30, 30)))
op = SelectionOperator([op0, op1, op2],
ProjectionParameterFunctional('x'), [0.3, 0.6])
return op, op.parameters.parse((n - 5) / 2), V, U, rp, sp
elif n == 8:
from pymor.operators.block import BlockDiagonalOperator
op0, _, U0, V0, sp0, rp0 = numpy_matrix_operator_with_arrays_and_products_factory(
10, 10, 4, 3, n)
op1, _, U1, V1, sp1, rp1 = numpy_matrix_operator_with_arrays_and_products_factory(
20, 20, 4, 3, n + 1)
op2, _, U2, V2, sp2, rp2 = numpy_matrix_operator_with_arrays_and_products_factory(
30, 30, 4, 3, n + 2)
op = BlockDiagonalOperator([op0, op1, op2])
sp = BlockDiagonalOperator([sp0, sp1, sp2])
rp = BlockDiagonalOperator([rp0, rp1, rp2])
U = op.source.make_array([U0, U1, U2])
V = op.range.make_array([V0, V1, V2])
return op, _, U, V, sp, rp
elif n == 9:
from pymor.operators.block import BlockDiagonalOperator, BlockOperator
from pymor.parameters.functionals import ProjectionParameterFunctional
op0a, _, U0, V0, sp0, rp0 = numpy_matrix_operator_with_arrays_and_products_factory(
10, 10, 4, 3, n)
op0b, _, _, _, _, _ = numpy_matrix_operator_with_arrays_and_products_factory(
10, 10, 4, 3, n)
op0c, _, _, _, _, _ = numpy_matrix_operator_with_arrays_and_products_factory(
10, 10, 4, 3, n)
op1, _, U1, V1, sp1, rp1 = numpy_matrix_operator_with_arrays_and_products_factory(
20, 20, 4, 3, n + 1)
op2a, _, _, _, _, _ = numpy_matrix_operator_with_arrays_and_products_factory(
20, 10, 4, 3, n + 2)
op2b, _, _, _, _, _ = numpy_matrix_operator_with_arrays_and_products_factory(
20, 10, 4, 3, n + 2)
op0 = (op0a * ProjectionParameterFunctional('p', 3, 0) +
op0b * ProjectionParameterFunctional('p', 3, 1) +
op0c * ProjectionParameterFunctional('p', 3, 1))
op2 = (op2a * ProjectionParameterFunctional('p', 3, 0) +
op2b * ProjectionParameterFunctional('q', 1))
op = BlockOperator([[op0, op2], [None, op1]])
mu = op.parameters.parse({'p': [1, 2, 3], 'q': 4})
sp = BlockDiagonalOperator([sp0, sp1])
rp = BlockDiagonalOperator([rp0, rp1])
U = op.source.make_array([U0, U1])
V = op.range.make_array([V0, V1])
return op, mu, U, V, sp, rp
elif n == 10:
from pymor.operators.block import BlockDiagonalOperator, BlockColumnOperator
from pymor.parameters.functionals import ProjectionParameterFunctional
op0, _, U0, V0, sp0, rp0 = numpy_matrix_operator_with_arrays_and_products_factory(
10, 10, 4, 3, n)
op1, _, U1, V1, sp1, rp1 = numpy_matrix_operator_with_arrays_and_products_factory(
20, 20, 4, 3, n + 1)
op2a, _, _, _, _, _ = numpy_matrix_operator_with_arrays_and_products_factory(
20, 10, 4, 3, n + 2)
op2b, _, _, _, _, _ = numpy_matrix_operator_with_arrays_and_products_factory(
20, 10, 4, 3, n + 2)
op2 = (op2a * ProjectionParameterFunctional('p', 3, 0) +
op2b * ProjectionParameterFunctional('q', 1))
op = BlockColumnOperator([op2, op1])
mu = op.parameters.parse({'p': [1, 2, 3], 'q': 4})
sp = sp1
rp = BlockDiagonalOperator([rp0, rp1])
U = U1
V = op.range.make_array([V0, V1])
return op, mu, U, V, sp, rp
elif n == 11:
from pymor.operators.block import BlockDiagonalOperator, BlockRowOperator
from pymor.parameters.functionals import ProjectionParameterFunctional
op0, _, U0, V0, sp0, rp0 = numpy_matrix_operator_with_arrays_and_products_factory(
10, 10, 4, 3, n)
op1, _, U1, V1, sp1, rp1 = numpy_matrix_operator_with_arrays_and_products_factory(
20, 20, 4, 3, n + 1)
op2a, _, _, _, _, _ = numpy_matrix_operator_with_arrays_and_products_factory(
20, 10, 4, 3, n + 2)
op2b, _, _, _, _, _ = numpy_matrix_operator_with_arrays_and_products_factory(
20, 10, 4, 3, n + 2)
op2 = (op2a * ProjectionParameterFunctional('p', 3, 0) +
op2b * ProjectionParameterFunctional('q', 1))
op = BlockRowOperator([op0, op2])
mu = op.parameters.parse({'p': [1, 2, 3], 'q': 4})
sp = BlockDiagonalOperator([sp0, sp1])
rp = rp0
U = op.source.make_array([U0, U1])
V = V0
return op, mu, U, V, sp, rp
else:
assert False
def assemble_flux_reconstruction(lambda_xi):
fr_ops = [FluxReconstructionOperator(ii, ii, ii, block_op.source, grid, block_space,
global_rt_space, neighborhood_boundary_info,
lambda_hat, lambda_xi, lambda_xi, kappa)
for ii in range(grid.num_subdomains)]
return BlockDiagonalOperator(fr_ops)
def assemble_oswald_interpolation_error():
oi_ops = [OswaldInterpolationErrorOperator(ii, ii, ii, block_op.source, grid, block_space,
global_rt_space, neighborhood_boundary_info,
None, None, None, None)
for ii in range(grid.num_subdomains)]
return BlockDiagonalOperator(oi_ops, name='oswald_interpolation_error')
def misc_operator_with_arrays_and_products_factory(n):
if n == 0:
from pymor.operators.constructions import ComponentProjection
_, _, U, V, sp, rp = numpy_matrix_operator_with_arrays_and_products_factory(100, 10, 4, 3, n)
op = ComponentProjection(np.random.randint(0, 100, 10), U.space)
return op, _, U, V, sp, rp
elif n == 1:
from pymor.operators.constructions import ComponentProjection
_, _, U, V, sp, rp = numpy_matrix_operator_with_arrays_and_products_factory(100, 0, 4, 3, n)
op = ComponentProjection([], U.space)
return op, _, U, V, sp, rp
elif n == 2:
from pymor.operators.constructions import ComponentProjection
_, _, U, V, sp, rp = numpy_matrix_operator_with_arrays_and_products_factory(100, 3, 4, 3, n)
op = ComponentProjection([3, 3, 3], U.space)
return op, _, U, V, sp, rp
elif n == 3:
from pymor.operators.constructions import AdjointOperator
op, _, U, V, sp, rp = numpy_matrix_operator_with_arrays_and_products_factory(100, 20, 4, 3, n)
op = AdjointOperator(op, with_apply_inverse=True)
return op, _, V, U, rp, sp
elif n == 4:
from pymor.operators.constructions import AdjointOperator
op, _, U, V, sp, rp = numpy_matrix_operator_with_arrays_and_products_factory(100, 20, 4, 3, n)
op = AdjointOperator(op, with_apply_inverse=False)
return op, _, V, U, rp, sp
elif 5 <= n <= 7:
from pymor.operators.constructions import SelectionOperator
from pymor.parameters.functionals import ProjectionParameterFunctional
op0, _, U, V, sp, rp = numpy_matrix_operator_with_arrays_and_products_factory(30, 30, 4, 3, n)
op1 = NumpyMatrixOperator(np.random.random((30, 30)))
op2 = NumpyMatrixOperator(np.random.random((30, 30)))
op = SelectionOperator([op0, op1, op2], ProjectionParameterFunctional('x', ()), [0.3, 0.6])
return op, op.parse_parameter((n-5)/2), V, U, rp, sp
elif n == 8:
from pymor.operators.block import BlockDiagonalOperator
from pymor.vectorarrays.block import BlockVectorArray
op0, _, U0, V0, sp0, rp0 = numpy_matrix_operator_with_arrays_and_products_factory(10, 10, 4, 3, n)
op1, _, U1, V1, sp1, rp1 = numpy_matrix_operator_with_arrays_and_products_factory(20, 20, 4, 3, n+1)
op2, _, U2, V2, sp2, rp2 = numpy_matrix_operator_with_arrays_and_products_factory(30, 30, 4, 3, n+2)
op = BlockDiagonalOperator([op0, op1, op2])
sp = BlockDiagonalOperator([sp0, sp1, sp2])
rp = BlockDiagonalOperator([rp0, rp1, rp2])
U = BlockVectorArray([U0, U1, U2])
V = BlockVectorArray([V0, V1, V2])
return op, _, U, V, sp, rp
elif n == 9:
from pymor.operators.block import BlockDiagonalOperator, BlockOperator
from pymor.vectorarrays.block import BlockVectorArray
op0, _, U0, V0, sp0, rp0 = numpy_matrix_operator_with_arrays_and_products_factory(10, 10, 4, 3, n)
op1, _, U1, V1, sp1, rp1 = numpy_matrix_operator_with_arrays_and_products_factory(20, 20, 4, 3, n+1)
op2, _, U2, V2, sp2, rp2 = numpy_matrix_operator_with_arrays_and_products_factory(20, 10, 4, 3, n+2)
op = BlockOperator([[op0, op2],
[None, op1]])
sp = BlockDiagonalOperator([sp0, sp1])
rp = BlockDiagonalOperator([rp0, rp1])
U = BlockVectorArray([U0, U1])
V = BlockVectorArray([V0, V1])
return op, None, U, V, sp, rp
else:
assert False
