"""Unit tests for the linear algebra interface""" # Copyright (C) 2008 Johan Hake # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # 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 DOLFIN. If not, see . # # First added: 2008-09-30 # Last changed: 2014-05-30 import pytest from dolfin import * import sys from dolfin_utils.test import * # Lists of backends supporting or not supporting data access data_backends = [] no_data_backends = [("PETSc", ""), ("Tpetra", "")] # Add serial only backends if MPI.size(MPI.comm_world) == 1: # TODO: What about "Dense" and "Sparse"? The sub_backend wasn't # used in the old test. data_backends += [("Eigen", "")] # Remove backends we haven't built with data_backends = [b for b in data_backends if has_linear_algebra_backend(b[0])] no_data_backends = [b for b in no_data_backends if has_linear_algebra_backend(b[0])] any_backends = data_backends + no_data_backends # Fixtures setting up and resetting the global linear algebra backend # for a list of backends any_backend = set_parameters_fixture("linear_algebra_backend", any_backends, lambda x: x[0]) data_backend = set_parameters_fixture("linear_algebra_backend", data_backends, lambda x: x[0]) no_data_backend = set_parameters_fixture("linear_algebra_backend", no_data_backends, lambda x: x[0]) # With and without explicit backend choice use_backend = true_false_fixture def xtest_deterministic_partition(): # Works with parmetis, not with scotch with mpirun -np 3 mesh1 = UnitSquareMesh(3, 3) mesh2 = UnitSquareMesh(3, 3) V1 = FunctionSpace(mesh1, "Lagrange", 1) V2 = FunctionSpace(mesh2, "Lagrange", 1) assert V1.dofmap().ownership_range() == V2.dofmap().ownership_range() def assemble_vectors(mesh): V = FunctionSpace(mesh, "Lagrange", 2) W = FunctionSpace(mesh, "Lagrange", 1) v = TestFunction(V) t = TestFunction(W) return assemble(v*dx), assemble(t*dx) def get_forms(mesh): V = FunctionSpace(mesh, "Lagrange", 2) W = FunctionSpace(mesh, "Lagrange", 1) v = TestFunction(V) u = TrialFunction(V) s = TrialFunction(W) # Forms a = dot(grad(u),grad(v))*dx b = v*s*dx return a, b class TestBasicLaOperations: def test_vector(self, any_backend): self.backend, self.sub_backend = any_backend from numpy import ndarray, linspace, array, fromiter from numpy import intp,int16,int32,int64 from numpy import uint,uintp,uint16,uint32,uint64 mesh = UnitSquareMesh(3, 3) v, w = assemble_vectors(mesh) # Get local ownership range (relevant for parallel vectors) n0, n1 = v.local_range() distributed = True if (n1 - n0) == v.size(): distributed = False # Test set and access with different integers lind = 2 for T in [int,int16,int32,int64,uint,uintp,uint16,uint32,uint64,\ intp]: v[T(lind)] = 2.0 assert round(v[T(lind)] - 2.0, 7) == 0 A = v.copy() B = as_backend_type(v.copy()) gind = 5 lind = gind-n0 # Test global index access if A.owns_index(gind): assert round(A[lind] - B[lind], 7) == 0 lind0 = 5 round(A[lind0] - B[lind0], 7) == 0 B *= 0.5 A *= 2 assert round(A[lind0] - 4*B[lind0], 7) == 0 B /= 2 A /= 0.5 assert round(A[lind0] - 16*B[lind0], 7) == 0 val1 = A[lind0] val2 = B[lind0] A += B assert round(A[lind0] - val1 - val2, 7) == 0 A -= B assert round(A[lind0] - val1, 7) == 0 C = 16*B assert round(A[lind0] - C[lind0], 7) == 0 D = (C + B)*5 assert round(D[lind0] - (val1 + val2)*5, 7) == 0 F = (A-B)/4 assert round(F[lind0] - (val1 - val2)/4, 7) == 0 A.axpy(100, B) assert round(A[lind0] - val1 - val2*100, 7) == 0 A2 = A.get_local() assert isinstance(A2,ndarray) assert A2.shape == (n1 - n0, ) assert round(A2[lind0] - A[lind0], 7) == 0 assert round(MPI.sum(A.mpi_comm(), A2.sum()) - A.sum(), 7) == 0 B2 = B.get_local() inds = [1,3,6,9,15,20,24,28,32,40,50,60,70,100000] # Extract owned local indices inds0 = array([i for i in inds if v.owns_index(i)]) linds0 = [i-n0 for i in inds0] linds1 = array(linds0, 'i') linds2 = array(linds0, 'I') A[linds2] = inds0 A2[linds0] = inds0 G = A[linds0] G1 = A[linds1] G2 = A2[linds2] G3 = A[A > 1] G4 = A2[A2 > 1] A3 = fromiter(A, "d") if A.owns_index(15): a = A[15-n0] b = 1.e10 assert round(G1.sum() - G.sum(), 7) == 0 assert round(G2.sum() - G.sum(), 7) == 0 assert len(G3) == len(G4) assert round(G3.sum() - G4.sum(), 7) == 0 assert all(val==G[i] for i, val in enumerate(G)) assert (G==G1).all() assert (G<=G1).all() assert (G>=G1).all() assert not (GG1).any() if A.owns_index(15): assert a in A assert b not in A assert (A3==A2).all() A[:] = A2 assert (A.get_local()==A2).all() H = A.copy() H[linds0] = G C[:] = 2 D[:] = 2 assert round(C[0] - 2, 7) == 0 assert round(C[len(linds0)-1] - 2, 7) == 0 assert round(C.sum() - D.sum(), 7) == 0 C[linds0] = 3 assert round(C[linds0].sum() - 3*len(linds0), 7) == 0 def wrong_index(ind): A[ind] with pytest.raises(IndexError): wrong_index(-len(A)-1) with pytest.raises(IndexError): wrong_index(A[-1]) with pytest.raises(IndexError): wrong_index(len(A)+1) with pytest.raises(TypeError): wrong_index("jada") with pytest.raises(TypeError): wrong_index(.5) with pytest.raises(IndexError): wrong_index([-len(A)-1, 2]) with pytest.raises(IndexError): wrong_index([len(A), 2]) def wrong_dim(ind0, ind1): A[ind0] = B[ind1] with pytest.raises(IndexError): wrong_dim([0,2], [0,2,4]) with pytest.raises(IndexError): wrong_dim([0,2], slice(0,4,1)) A2 = A.get_local() A *= B A2 *= B2 I = A*B I2 = A2*B2 assert round(A.sum() - MPI.sum(A.mpi_comm(), A2.sum()), 7) == 0 assert round(I.sum() - MPI.sum(A.mpi_comm(), I2.sum()), 7) == 0 def wrong_assign(A, ind): A[linds0[::2]] = linds0[::2] def test_matrix_vector(self, any_backend, use_backend): self.backend, self.sub_backend = any_backend from numpy import dot, absolute mesh = UnitSquareMesh(3, 3) a, b = get_forms(mesh) if use_backend: backend = getattr(cpp.la, self.backend+self.sub_backend+'Factory').instance() else: backend = None A = assemble(a, backend=backend) B = assemble(b, backend=backend) v, w = assemble_vectors(mesh) # Get local ownership range (relevant for parallel vectors) n0, n1 = v.local_range() distributed = True if (n1 - n0) == v.size(): distributed = False # Reference values v_norm = 0.181443684651 w_norm = 0.278394377377 A_norm = 31.947874212 B_norm = 0.11052313564 Av_norm = 0.575896483442 Bw_norm = 0.0149136743079 Cv_norm = 0.00951459156865 assert round(v.norm('l2') - v_norm, 7) == 0 assert round(w.norm('l2') - w_norm, 7) == 0 assert round(A.norm('frobenius') - A_norm, 7) == 0 assert round(B.norm('frobenius') - B_norm, 7) == 0 u = A*v assert len(u) == len(v) # Test basic square matrix multiply results assert round(v.norm('l2') - v_norm, 7) == 0 assert round(u.norm('l2') - Av_norm, 7) == 0 # Test rectangular matrix multiply results assert round((B*w).norm('l2') - Bw_norm, 7) == 0 # Test transpose multiply (rectangular) x = Vector() B.transpmult(v, x) assert round(x.norm('l2') - Cv_norm, 7) == 0 # Miscellaneous tests u2 = 2*u - A*v assert round(u2[4] - u[4], 7) == 0 u3 = 2*u + -1.0*(A*v) assert round(u3[4] - u[4], 7) == 0 # Numpy arrays are not aligned in parallel if distributed: return v_numpy = v.get_local() A_numpy = A.array() u_numpy = dot(A_numpy, v_numpy) u_numpy2 = A*v_numpy assert absolute(u.get_local() - u_numpy).sum() < DOLFIN_EPS*len(v) assert absolute(u_numpy2 - u_numpy).sum() < DOLFIN_EPS*len(v) def test_vector_data(self, no_data_backend): mesh = UnitSquareMesh(3, 3) v, w = assemble_vectors(mesh) v = as_backend_type(v) def no_attribute(): v.data() with pytest.raises(AttributeError): no_attribute() def test_vector_negation(self): V = FunctionSpace(UnitSquareMesh(10,10), "CG",1) u = TestFunction(V) v = Function(V) b = u*v*dx B = assemble(b) assert((-B == -1*B).all())