def __init__(self, array, transposed=False, space_id=None, name=None): self._array = array.copy() if transposed: self.source = array.space self.range = NumpyVectorSpace(len(array), space_id) else: self.source = NumpyVectorSpace(len(array), space_id) self.range = array.space self.transposed = transposed self.space_id = space_id self.name = name
def __init__(self, matrix, source_id=None, range_id=None, solver_options=None, name=None): assert matrix.ndim <= 2 if matrix.ndim == 1: matrix = np.reshape(matrix, (1, -1)) self.source = NumpyVectorSpace(matrix.shape[1], source_id) self.range = NumpyVectorSpace(matrix.shape[0], range_id) self.solver_options = solver_options self.name = name self.matrix = matrix self.source_id = source_id self.range_id = range_id self.sparse = issparse(matrix)
def __init__(self, mapping, transpose_mapping=None, dim_source=1, dim_range=1, linear=False, parameter_type=None, source_id=None, range_id=None, solver_options=None, name=None): self.source = NumpyVectorSpace(dim_source, source_id) self.range = NumpyVectorSpace(dim_range, range_id) self.solver_options = solver_options self.name = name self._mapping = mapping self._transpose_mapping = transpose_mapping self.linear = linear if parameter_type is not None: self.build_parameter_type(parameter_type) self.source_id = source_id # needed for with_ self.range_id = range_id
def action_ZeroOperator(self, op): range_basis, source_basis = self.range_basis, self.source_basis if source_basis is not None and range_basis is not None: from pymor.operators.numpy import NumpyMatrixOperator return NumpyMatrixOperator(np.zeros( (len(range_basis), len(source_basis))), name=op.name) else: new_source = NumpyVectorSpace( len(source_basis)) if source_basis is not None else op.source new_range = NumpyVectorSpace( len(range_basis)) if range_basis is not None else op.range return ZeroOperator(new_range, new_source, name=op.name)
def __init__(self, matrix, source_id=None, range_id=None, solver_options=None, name=None): assert matrix.ndim <= 2 if matrix.ndim == 1: matrix = np.reshape(matrix, (1, -1)) try: matrix.setflags(write=False) # make numpy arrays read-only except AttributeError: pass self.__auto_init(locals()) self.source = NumpyVectorSpace(matrix.shape[1], source_id) self.range = NumpyVectorSpace(matrix.shape[0], range_id) self.sparse = issparse(matrix)
def __init__(self, mapping, adjoint_mapping=None, dim_source=1, dim_range=1, linear=False, parameter_type=None, source_id=None, range_id=None, solver_options=None, name=None): self.__auto_init(locals()) self.source = NumpyVectorSpace(dim_source, source_id) self.range = NumpyVectorSpace(dim_range, range_id)
def action_ZeroOperator(self, op, range_basis, source_basis, product=None): if source_basis is not None and range_basis is not None: from pymor.operators.numpy import NumpyMatrixOperator return NumpyMatrixOperator(np.zeros( (len(range_basis), len(source_basis))), source_id=op.source.id, range_id=op.range.id, name=op.name) else: new_source = (NumpyVectorSpace(len(source_basis), op.source.id) if source_basis is not None else op.source) new_range = (NumpyVectorSpace(len(range_basis), op.range.id) if range_basis is not None else op.range) return ZeroOperator(new_source, new_range, name=op.name)
def __init__(self, matrix, source_id=None, range_id=None, solver_options=None, name=None): super().__init__(matrix, source_id=source_id, range_id=range_id, solver_options=solver_options, name=name) functional = self.range_id is None vector = self.source_id is None if functional and vector: raise NotImplementedError if vector: self.source = NumpyVectorSpace(1, source_id) else: self.source = NumpyListVectorSpace(matrix.shape[1], source_id) if functional: self.range = NumpyVectorSpace(1, range_id) else: self.range = NumpyListVectorSpace(matrix.shape[0], range_id) self.functional = functional self.vector = vector
def __init__(self, grid, boundary_info, advection_function=None, advection_constant=None, dirichlet_clear_columns=False, dirichlet_clear_diag=False, solver_options=None, name=None): assert grid.reference_element(0) in {square }, 'A square grid is expected!' assert advection_function is None \ or (isinstance(advection_function, FunctionInterface) and advection_function.dim_domain == grid.dim_outer and advection_function.shape_range == (grid.dim_outer,)) self.source = self.range = NumpyVectorSpace(grid.size(grid.dim)) self.grid = grid self.boundary_info = boundary_info self.advection_constant = advection_constant self.advection_function = advection_function self.dirichlet_clear_columns = dirichlet_clear_columns self.dirichlet_clear_diag = dirichlet_clear_diag self.solver_options = solver_options self.name = name if advection_function is not None: self.build_parameter_type(inherits=(advection_function, ))
def __init__(self, grid, function): assert function.dim_domain == grid.dim_outer assert function.shape_range == () self.grid = grid self.function = function self.range = NumpyVectorSpace(grid.size(grid.dim)) self.build_parameter_type(inherits=(function, ))
class MonomOperator(Operator): source = range = NumpyVectorSpace(1) def __init__(self, order, monom=None): self.monom = monom if monom else Polynomial( np.identity(order + 1)[order]) assert isinstance(self.monom, Polynomial) self.order = order self.derivative = self.monom.deriv() self.linear = order == 1 def apply(self, U, mu=None): return self.source.make_array(self.monom(U.to_numpy())) def apply_adjoint(self, U, mu=None): return self.apply(U, mu=None) def jacobian(self, U, mu=None): assert len(U) == 1 return NumpyMatrixOperator( self.derivative(U.to_numpy()).reshape((1, 1))) def apply_inverse(self, V, mu=None, initial_guess=None, least_squares=False): return self.range.make_array(1. / V.to_numpy())
def __init__(self, mapping, dim_source=1, dim_range=1, linear=False, parameter_type=None, solver_options=None, name=None): self.source = NumpyVectorSpace(dim_source) self.range = NumpyVectorSpace(dim_range) self.solver_options = solver_options self.name = name self._mapping = mapping self.linear = linear if parameter_type is not None: self.build_parameter_type(parameter_type, local_global=True)
def apply(self, U, mu=None): """ Solves using step_hyperbolic() and refactoring result such that it is a dq quantity and time-step, dt is divided out. Step hyperbolic takes the current solution state and updates it as such: q^(n+1) = q^n - dt/dx*apdq - dt/dx*amdq - dt/dx*(F_(i) - F_(i-1))/kappa where apdq, amdq are the positive and negative waves from the Riemann solver, and F is the 2nd order correction flux into and out of the finite volume cell See Leveque, R.J., Finite Volume Methods for Hyperbolic Problems, Cambridge Texts in Applied Mathematics, 2002. for details, or check the Clawpack/PyClaw documentation at: http://www.clawpack.org/ """ assert U in self.source # Get current state and solve hyperbolic step with PyClaw q0 = np.copy(self.claw.solution.state.q, order='F') # Solution state before hyperbolic step print("t:", self.claw.solution.t, "dt:", self.claw.solver.dt) self.claw.solver.step_hyperbolic( self.claw.solution) # Solve FV using PyClaw # Refactor result to be compatible with axpy() in time-stepping routine q = -(self.claw.solution.state.q - q0) / self.claw.solver.dt q = np.reshape(q, self.claw.solution.state.q.size, order='F') self.claw.solution.t += self.claw.solver.dt # Update solution time # Using step() # self.claw.solver.step(self.claw.solution, take_one_step=True, tstart=0, tend=self.claw.solver.dt) # Return vector space with result return NumpyVectorSpace( self.claw.solution.state.q.size).make_array([q])
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)
class InterpolationOperator(NumpyMatrixBasedOperator): """Vector-like Lagrange interpolation |Operator| for continuous finite element spaces. Parameters ---------- grid The |Grid| on which to interpolate. function The |Function| to interpolate. """ source = NumpyVectorSpace(1) linear = True def __init__(self, grid, function): assert function.dim_domain == grid.dim assert function.shape_range == () self.grid = grid self.function = function self.range = CGVectorSpace(grid) self.build_parameter_type(function) def _assemble(self, mu=None): return self.function.evaluate(self.grid.centers(self.grid.dim), mu=mu).reshape((-1, 1))
def random_array(dims, length, seed): if isinstance(dims, Number): dims = (dims, ) return MPIVectorSpaceAutoComm(tuple(NumpyVectorSpace(dim) for dim in dims)).make_array( mpi.call(_random_array, dims, length, seed))
class VectorOperator(VectorArrayOperator): """Wrap a vector as a vector-like |Operator|. Given a vector `v` of dimension `d`, this class represents the operator :: op: R^1 ----> R^d x |---> x⋅v In particular:: VectorOperator(vector).as_range_array() == vector Parameters ---------- vector |VectorArray| of length 1 containing the vector `v`. name Name of the operator. """ linear = True source = NumpyVectorSpace(1) def __init__(self, vector, name=None): assert isinstance(vector, VectorArrayInterface) assert len(vector) == 1 super().__init__(vector, adjoint=False, name=name)
def __init__(self, T, initial_data, operator, rhs, mass=None, time_stepper=None, num_values=None, output_functional=None, products=None, error_estimator=None, visualizer=None, name=None): if isinstance(rhs, VectorArray): assert rhs in operator.range rhs = VectorOperator(rhs, name='rhs') if isinstance(initial_data, VectorArray): assert initial_data in operator.source initial_data = VectorOperator(initial_data, name='initial_data') mass = mass or IdentityOperator(operator.source) rhs = rhs or ZeroOperator(operator.source, NumpyVectorSpace(1)) assert isinstance(time_stepper, TimeStepper) assert initial_data.source.is_scalar assert operator.source == initial_data.range assert rhs.linear and rhs.range == operator.range and rhs.source.is_scalar assert mass.linear and mass.source == mass.range == operator.source assert output_functional is None or output_functional.source == operator.source super().__init__(products=products, error_estimator=error_estimator, visualizer=visualizer, name=name) self.parameters_internal = {'t': 1} self.__auto_init(locals()) self.solution_space = operator.source self.linear = operator.linear and (output_functional is None or output_functional.linear) if output_functional is not None: self.dim_output = output_functional.range.dim
def __init__(self, grid, boundary_info, numerical_flux, dirichlet_data=None, solver_options=None, name=None): assert dirichlet_data is None or isinstance(dirichlet_data, FunctionInterface) self.grid = grid self.boundary_info = boundary_info self.numerical_flux = numerical_flux self.dirichlet_data = dirichlet_data self.solver_options = solver_options self.name = name if (isinstance(dirichlet_data, FunctionInterface) and boundary_info.has_dirichlet and not dirichlet_data.parametric): self._dirichlet_values = self.dirichlet_data( grid.centers(1)[boundary_info.dirichlet_boundaries(1)]) self._dirichlet_values = self._dirichlet_values.ravel() self._dirichlet_values_flux_shaped = self._dirichlet_values.reshape( (-1, 1)) self.build_parameter_type(inherits=(numerical_flux, dirichlet_data)) self.source = self.range = NumpyVectorSpace(grid.size(0)) self.add_with_arguments = self.add_with_arguments.union( 'numerical_flux_{}'.format(arg) for arg in numerical_flux.with_arguments)
def action_ConstantOperator(self, op): dim_range, dim_source = self.dim_range, self.dim_source source = op.source if dim_source is None else NumpyVectorSpace( dim_source) value = op.value if dim_range is None else NumpyVectorSpace.make_array( op.value.to_numpy()[:, :dim_range]) return ConstantOperator(value, source, name=op.name)
def __init__(self, claw): self.claw = claw self.num_eqn = claw.solution.state.q.shape[0] self.mx = claw.solution.state.q.shape[1] self.my = claw.solution.state.q.shape[2] self.mz = claw.solution.state.q.shape[3] self.solution_space = NumpyVectorSpace(claw.solution.state.q.size) self.claw.start_frame = self.claw.solution.start_frame
def projected(self, range_basis, source_basis, product=None, name=None): 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 not None and range_basis is not None: from pymor.operators.numpy import NumpyMatrixOperator return NumpyMatrixOperator(np.zeros( (len(range_basis), len(source_basis))), name=self.name + '_projected') else: new_source = NumpyVectorSpace( len(source_basis)) if source_basis is not None else self.source new_range = NumpyVectorSpace( len(range_basis)) if range_basis is not None else self.range return ZeroOperator(new_source, new_range, name=self.name + '_projected')
def action_IdentityOperator(self, op): dim_range, dim_source = self.dim_range, self.dim_source if dim_range != dim_source: raise RuleNotMatchingError( 'dim_range and dim_source must be equal.') space = op.source if dim_source is None else NumpyVectorSpace( dim_source) return IdentityOperator(space, name=op.name)
def test_identity_lincomb(): space = NumpyVectorSpace(10) identity = IdentityOperator(space) ones = space.ones() idid = (identity + identity) assert almost_equal(ones * 2, idid.apply(ones)) assert almost_equal(ones * 2, idid.apply_adjoint(ones)) assert almost_equal(ones * 0.5, idid.apply_inverse(ones)) assert almost_equal(ones * 0.5, idid.apply_inverse_adjoint(ones))
def test_to_matrix_ComponentProjection(): dofs = np.array([0, 1, 2, 4, 8]) n = 10 A = np.zeros((len(dofs), n)) A[range(len(dofs)), dofs] = 1 source = NumpyVectorSpace(n) Aop = ComponentProjection(dofs, source) assert_type_and_allclose(A, Aop, 'sparse')
def __init__(self, restricted_operator, interpolation_matrix, source_basis_dofs, projected_collateral_basis, triangular, solver_options=None, name=None): name = name or f'{restricted_operator.name}_projected' self.__auto_init(locals()) self.source = NumpyVectorSpace(len(source_basis_dofs)) self.range = projected_collateral_basis.space self.linear = restricted_operator.linear
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 __init__(self, operator, range_basis, source_basis, product=None, solver_options=None): assert isinstance(operator, OperatorInterface) assert source_basis is None or source_basis in operator.source assert range_basis is None or range_basis in operator.range assert (product is None or (isinstance(product, OperatorInterface) and range_basis is not None and operator.range == product.source and product.range == product.source)) self.build_parameter_type(operator) self.source = NumpyVectorSpace(len(source_basis)) if source_basis is not None else operator.source self.range = NumpyVectorSpace(len(range_basis)) if range_basis is not None else operator.range self.solver_options = solver_options self.name = operator.name self.operator = operator self.source_basis = source_basis.copy() if source_basis is not None else None self.range_basis = range_basis.copy() if range_basis is not None else None self.linear = operator.linear self.product = product
def __init__(self, neural_network, output_functional=None, products=None, error_estimator=None, visualizer=None, name=None): super().__init__(products=products, error_estimator=error_estimator, visualizer=visualizer, name=name) self.__auto_init(locals()) self.solution_space = NumpyVectorSpace(neural_network.output_dimension) self.linear = output_functional is None or output_functional.linear if output_functional is not None: self.output_space = output_functional.range
def action_ConstantOperator(self, op): range_basis, source_basis = self.range_basis, self.source_basis if range_basis is not None: projected_value = NumpyVectorSpace.make_array(range_basis.dot(op.value).T) else: projected_value = op.value if source_basis is None: return ConstantOperator(projected_value, op.source, name=op.name) else: return ConstantOperator(projected_value, NumpyVectorSpace(len(source_basis)), name=op.name)