def __init__(self, blocks):
blocks = np.array(blocks)
assert isinstance(blocks, np.ndarray) and blocks.ndim == 2
self._blocks = blocks
assert all(
isinstance(op, OperatorInterface) for op in self._operators())
assert all(
any(self._blocks[i, j] is not None
for j in range(self._blocks.shape[1]))
for i in range(self._blocks.shape[0]))
assert all(
any(self._blocks[i, j] is not None
for i in range(self._blocks.shape[0]))
for j in range(self._blocks.shape[1]))
source_types = [None for j in range(self._blocks.shape[1])]
range_types = [None for i in range(self._blocks.shape[0])]
for (i, j), op in np.ndenumerate(self._blocks):
if op is not None:
assert source_types[j] is None or op.source == source_types[j]
source_types[j] = op.source
assert range_types[i] is None or op.range == range_types[i]
range_types[i] = op.range
self.source = VectorSpace(BlockVectorArray, tuple(source_types))
self.range = VectorSpace(BlockVectorArray, tuple(range_types))
self._source_dims = tuple(space.dim for space in self.source.subtype)
self._range_dims = tuple(space.dim for space in self.range.subtype)
self.num_source_blocks = len(source_types)
self.num_range_blocks = len(range_types)
self.linear = all(op.linear for op in self._operators())
self.build_parameter_type(inherits=list(self._operators()))
def __init__(self, op):
assert isinstance(op, DiffusionOperator)
self._impl = op
self.source = VectorSpace(ListVectorArray,
(WrappedVector, op.dim_source))
self.range = VectorSpace(ListVectorArray,
(WrappedVector, op.dim_range))
self.linear = True
def __init__(self, matrix, functional=False, vector=False, solver_options=None, name=None):
assert not (functional and vector)
super().__init__(matrix, solver_options=solver_options, name=name)
if not vector:
self.source = VectorSpace(ListVectorArray, (NumpyVector, matrix.shape[1]))
if not functional:
self.range = VectorSpace(ListVectorArray, (NumpyVector, matrix.shape[0]))
self.functional = functional
self.vector = vector
def __init__(self,
obj_id,
operators,
functionals,
vector_operators,
products=None,
pickle_subtypes=True,
array_type=MPIVectorArray):
d = mpi.get_object(obj_id)
visualizer = MPIVisualizer(obj_id)
super().__init__(operators,
functionals,
vector_operators,
products=products,
visualizer=visualizer,
cache_region=None,
name=d.name)
self.obj_id = obj_id
subtypes = mpi.call(_MPIDiscretization_get_subtypes, obj_id,
pickle_subtypes)
if all(subtype == subtypes[0] for subtype in subtypes):
subtypes = (subtypes[0], )
self.solution_space = VectorSpace(array_type,
(d.solution_space.type, subtypes))
self.build_parameter_type(inherits=(d, ))
self.parameter_space = d.parameter_space
def __init__(self,
obj_id,
functional=False,
vector=False,
with_apply2=False,
pickle_subtypes=True,
array_type=MPIVectorArray):
assert not (functional and vector)
self.obj_id = obj_id
self.op = op = mpi.get_object(obj_id)
self.functional = functional
self.vector = vector
self.with_apply2 = with_apply2
self.pickle_subtypes = pickle_subtypes
self.array_type = array_type
self.linear = op.linear
self.name = op.name
self.build_parameter_type(inherits=(op, ))
if vector:
self.source = NumpyVectorSpace(1)
assert self.source == op.source
else:
subtypes = mpi.call(_MPIOperator_get_source_subtypes, obj_id,
pickle_subtypes)
if all(subtype == subtypes[0] for subtype in subtypes):
subtypes = (subtypes[0], )
self.source = VectorSpace(array_type, (op.source.type, subtypes))
if functional:
self.range = NumpyVectorSpace(1)
assert self.range == op.range
else:
subtypes = mpi.call(_MPIOperator_get_range_subtypes, obj_id,
pickle_subtypes)
if all(subtype == subtypes[0] for subtype in subtypes):
subtypes = (subtypes[0], )
self.range = VectorSpace(array_type, (op.range.type, subtypes))
def FenicsVectorSpace(V):
return VectorSpace(ListVectorArray, (FenicsVector, V))
def NumpyVectorSpace(dim):
"""Shorthand for |VectorSpace| `(NumpyVectorArray, dim)`."""
return VectorSpace(NumpyVectorArray, dim)
