1from petsc4py import PETSc 2import unittest 3 4import numpy as N 5import numpy as np 6 7def mkgraph(comm, m, n): 8 start = m*n * comm.rank 9 end = start + m*n 10 idt = PETSc.IntType 11 rows = [] 12 for I in range(start, end) : 13 rows.append([]) 14 adj = rows[-1] 15 i = I//n; j = I - i*n 16 if i> 0 : J = I-n; adj.append(J) 17 if j> 0 : J = I-1; adj.append(J) 18 adj.append(I) 19 if j< n-1: J = I+1; adj.append(J) 20 if i< m-1: J = I+n; adj.append(J) 21 nods = N.array(range(start, end), dtype=idt) 22 xadj = N.array([0]*(len(rows)+1), dtype=idt) 23 xadj[0] = 0 24 xadj[1:] = N.cumsum([len(r) for r in rows], dtype=idt) 25 if not rows: adjy = N.array([],dtype=idt) 26 else: adjy = N.concatenate(rows).astype(idt) 27 return nods, xadj, adjy 28 29 30class BaseTestMatAnyAIJ(object): 31 32 COMM = PETSc.COMM_NULL 33 TYPE = None 34 GRID = 0, 0 35 BSIZE = None 36 37 def setUp(self): 38 COMM = self.COMM 39 GM, GN = self.GRID 40 BS = self.BSIZE 41 # 42 try: 43 rbs, cbs = BS 44 rbs = rbs or 1 45 cbs = cbs or 1 46 except (TypeError, ValueError): 47 rbs = cbs = BS or 1 48 sdt = dtype = PETSc.ScalarType 49 self.rows, self.xadj, self.adjy = mkgraph(COMM, GM, GN) 50 self.vals = N.array(range(1, 1 + len(self.adjy)* rbs*cbs), dtype=sdt) 51 self.vals.shape = (-1, rbs, cbs) 52 # 53 m, n = GM, GN 54 rowsz = (m*n*rbs, None) 55 colsz = (m*n*cbs, None) 56 A = self.A = PETSc.Mat().create(comm=COMM) 57 A.setType(self.TYPE) 58 A.setSizes([rowsz, colsz], BS) 59 60 def tearDown(self): 61 self.A.destroy() 62 self.A = None 63 64 def testSetPreallocNNZ(self): 65 nnz = [5, 2] 66 self.A.setPreallocationNNZ(nnz) 67 self._chk_bs(self.A, self.BSIZE) 68 opt = PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR 69 self.A.setOption(opt, True) 70 ai, aj, av = self._set_values() 71 self.A.assemble() 72 self._chk_aij(self.A, ai, aj) 73 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 74 self.A.setOption(opt, True) 75 ai, aj, av = self._set_values_ijv() 76 self.A.assemble() 77 self._chk_aij(self.A, ai, aj) 78 79 def testSetPreallocNNZ_2(self): 80 _, ai, _, _ =self._get_aijv() 81 d_nnz = N.diff(ai) 82 nnz = [d_nnz, 3] 83 self.A.setPreallocationNNZ(nnz) 84 self._chk_bs(self.A, self.BSIZE) 85 opt = PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR 86 self.A.setOption(opt, True) 87 ai, aj, av = self._set_values() 88 self.A.assemble() 89 self._chk_aij(self.A, ai, aj) 90 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 91 self.A.setOption(opt, True) 92 ai, aj, av =self._set_values_ijv() 93 self.A.assemble() 94 self._chk_aij(self.A, ai, aj) 95 96 def testSetPreallocCSR(self): 97 _, ai, aj, _ = self._get_aijv() 98 csr = [ai, aj] 99 self.A.setPreallocationCSR(csr) 100 self._chk_bs(self.A, self.BSIZE) 101 self._chk_aij(self.A, ai, aj) 102 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 103 self.A.setOption(opt, True) 104 self._set_values() 105 self.A.assemble() 106 self._chk_aij(self.A, ai, aj) 107 self._set_values_ijv() 108 self.A.assemble() 109 self._chk_aij(self.A, ai, aj) 110 111 def testSetPreallocCSR_2(self): 112 _, ai, aj, av =self._get_aijv() 113 csr = [ai, aj, av] 114 self.A.setPreallocationCSR(csr) 115 self._chk_bs(self.A, self.BSIZE) 116 self._chk_aij(self.A, ai, aj) 117 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 118 self.A.setOption(opt, True) 119 self._set_values() 120 self.A.assemble() 121 self._chk_aij(self.A, ai, aj) 122 self._set_values_ijv() 123 self.A.assemble() 124 self._chk_aij(self.A, ai, aj) 125 126 def testSetValues(self): 127 self._preallocate() 128 opt = PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR 129 self.A.setOption(opt, True) 130 ai, aj, av = self._set_values() 131 self.A.assemble() 132 self._chk_aij(self.A, ai, aj) 133 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 134 self.A.setOption(opt, True) 135 ai, aj, av = self._set_values() 136 self.A.assemble() 137 self._chk_aij(self.A, ai, aj) 138 139 def testSetValuesIJV(self): 140 self._preallocate() 141 opt = PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR 142 self.A.setOption(opt, True) 143 ai, aj, av = self._set_values_ijv() 144 self.A.assemble() 145 self._chk_aij(self.A, ai, aj) 146 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 147 self.A.setOption(opt, True) 148 ai, aj, av = self._set_values_ijv() 149 self.A.assemble() 150 self._chk_aij(self.A, ai, aj) 151 152 def testGetValuesCSR(self): 153 self._preallocate() 154 self._set_values_ijv() 155 A = self.A 156 A.assemble() 157 if 'sbaij' in A.getType(): 158 opt = PETSc.Mat.Option.GETROW_UPPERTRIANGULAR 159 self.A.setOption(opt, True) 160 ai, aj, av = A.getValuesCSR() 161 rstart, rend = A.getOwnershipRange() 162 for row in range(rstart, rend): 163 cols, vals = A.getRow(row) 164 i = row - rstart 165 self.assertTrue(N.allclose(aj[ai[i]:ai[i+1]], cols)) 166 self.assertTrue(N.allclose(av[ai[i]:ai[i+1]], vals)) 167 168 def testConvertToSAME(self): 169 self._preallocate() 170 self._set_values_ijv() 171 A = self.A 172 A.assemble() 173 A.convert('same') 174 175 def testConvertToDENSE(self): 176 self._preallocate() 177 self._set_values_ijv() 178 A = self.A 179 A.assemble() 180 x, y = A.getVecs() 181 x.setRandom() 182 z = y.duplicate() 183 A.mult(x, y) 184 if A.type.endswith('sbaij'): return 185 B = PETSc.Mat() 186 A.convert('dense', B) # initial 187 B.mult(x, z) 188 self.assertTrue(np.allclose(y.array, z.array)) 189 A.convert('dense', B) # reuse 190 B.mult(x, z) 191 self.assertTrue(np.allclose(y.array, z.array)) 192 A.convert('dense') # inplace 193 A.mult(x, z) 194 self.assertTrue(np.allclose(y.array, z.array)) 195 196 def testConvertToAIJ(self): 197 self._preallocate() 198 self._set_values_ijv() 199 A = self.A 200 A.assemble() 201 x, y = A.getVecs() 202 x.setRandom() 203 z = y.duplicate() 204 A.mult(x, y) 205 if A.type.endswith('sbaij'): return 206 B = PETSc.Mat() 207 A.convert('aij', B) # initial 208 B.mult(x, z) 209 self.assertTrue(np.allclose(y.array, z.array)) 210 A.convert('aij', B) # reuse 211 B.mult(x, z) 212 self.assertTrue(np.allclose(y.array, z.array)) 213 A.convert('aij') # inplace 214 A.mult(x, z) 215 self.assertTrue(np.allclose(y.array, z.array)) 216 217 def testGetDiagonalBlock(self): 218 self._preallocate() 219 self._set_values_ijv() 220 self.A.assemble() 221 B = self.A.getDiagonalBlock() 222 self.assertEqual(self.A.getLocalSize(), B.getSize()) 223 B.destroy() 224 225 def testInvertBlockDiagonal(self): 226 try: 227 _ = len(self.BSIZE) 228 return 229 except (TypeError, ValueError): 230 pass 231 self._preallocate() 232 rbs, cbs = self.A.getBlockSizes() 233 if rbs != cbs: return 234 self._set_values_ijv() 235 self.A.assemble() 236 self.A.shift(1000) # Make nonsingular 237 ibdiag = self.A.invertBlockDiagonal() 238 bs = self.A.getBlockSize() 239 m, _ = self.A.getLocalSize() 240 self.assertEqual(ibdiag.shape, (m//bs, bs, bs)) 241 tmp = N.empty((m//bs, bs, bs), dtype=PETSc.ScalarType) 242 rstart, rend = self.A.getOwnershipRange() 243 s, e = rstart//bs, rend//bs 244 for i in range(s, e): 245 rows = cols = N.arange(i*bs,(i+1)*bs, dtype=PETSc.IntType) 246 vals = self.A.getValues(rows,cols) 247 tmp[i-s,:,:] = N.linalg.inv(vals) 248 self.assertTrue(N.allclose(ibdiag, tmp)) 249 250 def testCreateSubMatrix(self): 251 if 'baij' in self.A.getType(): return # XXX 252 self._preallocate() 253 self._set_values_ijv() 254 self.A.assemble() 255 # 256 rank = self.A.getComm().getRank() 257 rs, re = self.A.getOwnershipRange() 258 cs, ce = self.A.getOwnershipRangeColumn() 259 rows = N.array(range(rs, re), dtype=PETSc.IntType) 260 cols = N.array(range(cs, ce), dtype=PETSc.IntType) 261 rows = PETSc.IS().createGeneral(rows, comm=self.A.getComm()) 262 cols = PETSc.IS().createGeneral(cols, comm=self.A.getComm()) 263 # 264 S = self.A.createSubMatrix(rows, None) 265 S.zeroEntries() 266 self.A.createSubMatrix(rows, None, S) 267 S.destroy() 268 # 269 S = self.A.createSubMatrix(rows, cols) 270 S.zeroEntries() 271 self.A.createSubMatrix(rows, cols, S) 272 S.destroy() 273 274 def testCreateSubMatrices(self): 275 if 'baij' in self.A.getType(): return # XXX 276 self._preallocate() 277 self._set_values_ijv() 278 self.A.assemble() 279 # 280 rs, re = self.A.getOwnershipRange() 281 cs, ce = self.A.getOwnershipRangeColumn() 282 rows = N.array(range(rs, re), dtype=PETSc.IntType) 283 cols = N.array(range(cs, ce), dtype=PETSc.IntType) 284 rows = PETSc.IS().createGeneral(rows, comm=self.A.getComm()) 285 cols = PETSc.IS().createGeneral(cols, comm=self.A.getComm()) 286 # 287 (S,) = self.A.createSubMatrices(rows, cols) 288 S.zeroEntries() 289 self.A.createSubMatrices(rows, cols, submats=[S]) 290 S.destroy() 291 # 292 (S1,) = self.A.createSubMatrices([rows], [cols]) 293 (S2,) = self.A.createSubMatrices([rows], [cols]) 294 self.assertTrue(S1.equal(S2)) 295 S2.zeroEntries() 296 self.A.createSubMatrices([rows], [cols], [S2]) 297 self.assertTrue(S1.equal(S2)) 298 S1.destroy() 299 S2.destroy() 300 # 301 if 'seq' not in self.A.getType(): return # XXX 302 S1, S2 = self.A.createSubMatrices([rows, rows], [cols, cols]) 303 self.assertTrue(S1.equal(S2)) 304 S1.zeroEntries() 305 S2.zeroEntries() 306 self.A.createSubMatrices([rows, rows], [cols, cols], [S1, S2]) 307 self.assertTrue(S1.equal(S2)) 308 S1.destroy() 309 S2.destroy() 310 311 def testGetRedundantMatrix(self): 312 if 'aijcrl' in self.A.getType(): return # duplicate not supported 313 if 'mpisbaij' in self.A.getType(): return # not working 314 self._preallocate() 315 self._set_values_ijv() 316 self.A.assemble() 317 #Test the most simple case 318 sizecommA = self.A.getComm().getSize() 319 Ared = self.A.getRedundantMatrix(sizecommA) 320 sizecommAred = Ared.getComm().getSize() 321 self.assertEqual(1, sizecommAred) 322 Ared.destroy() 323 324 def testCreateTranspose(self): 325 self._preallocate() 326 self._set_values_ijv() 327 self.A.assemble() 328 A = self.A 329 AT = PETSc.Mat().createTranspose(A) 330 x, y = A.createVecs() 331 xt, yt = AT.createVecs() 332 # 333 y.setRandom() 334 A.multTranspose(y, x) 335 y.copy(xt) 336 AT.mult(xt, yt) 337 self.assertTrue(yt.equal(x)) 338 # 339 x.setRandom() 340 A.mult(x, y) 341 x.copy(yt) 342 AT.multTranspose(yt, xt) 343 self.assertTrue(xt.equal(y)) 344 345 def _get_aijv(self): 346 return (self.rows, self.xadj, self.adjy, self.vals,) 347 348 def _preallocate(self): 349 self.A.setPreallocationNNZ([5, 2]) 350 351 def _set_values(self): 352 import sys 353 if hasattr(sys, 'gettotalrefcount'): 354 return self._set_values_ijv() 355 # XXX Why the code below leak refs as a beast ??? 356 row, ai, aj, av =self._get_aijv() 357 if not self.BSIZE: 358 setvalues = self.A.setValues 359 else: 360 setvalues = self.A.setValuesBlocked 361 for i, r in enumerate(row): 362 s, e = ai[i], ai[i+1] 363 setvalues(r, aj[s:e], av[s:e]) 364 return ai, aj, av 365 366 def _set_values_ijv(self): 367 row, ai, aj, av =self._get_aijv() 368 if not self.BSIZE: 369 setvalues = self.A.setValuesIJV 370 else: 371 setvalues = self.A.setValuesBlockedIJV 372 setvalues(ai, aj, av, rowmap=row) 373 setvalues(ai, aj, av, rowmap=None) 374 return ai, aj, av 375 376 def _chk_bs(self, A, bs): 377 self.assertEqual(A.getBlockSize(), bs or 1) 378 379 def _chk_bsizes(self, A, bsizes): 380 try: 381 rbs, cbs = bsizes 382 except (TypeError, ValueError): 383 rbs = cbs = bsizes 384 self.assertEqual(A.getBlockSizes(), (rbs, cbs)) 385 386 def _chk_aij(self, A, i, j): 387 compressed = bool(self.BSIZE) 388 ai, aj = A.getRowIJ(compressed=compressed) 389 if ai is not None and aj is not None: 390 self.assertTrue(N.all(i==ai)) 391 self.assertTrue(N.all(j==aj)) 392 ai, aj = A.getColumnIJ(compressed=compressed) 393 if ai is not None and aj is not None: 394 self.assertTrue(N.all(i==ai)) 395 self.assertTrue(N.all(j==aj)) 396 397# -- AIJ --------------------- 398 399class BaseTestMatAIJ(BaseTestMatAnyAIJ, unittest.TestCase): 400 COMM = PETSc.COMM_WORLD 401 TYPE = PETSc.Mat.Type.AIJ 402 GRID = 0, 0 403 BSIZE = None 404 405# -- Seq AIJ -- 406 407class TestMatSeqAIJ(BaseTestMatAIJ): 408 COMM = PETSc.COMM_SELF 409 TYPE = PETSc.Mat.Type.SEQAIJ 410class TestMatSeqAIJ_G23(TestMatSeqAIJ): 411 GRID = 2, 3 412class TestMatSeqAIJ_G45(TestMatSeqAIJ): 413 GRID = 4, 5 414class TestMatSeqAIJ_G89(TestMatSeqAIJ): 415 GRID = 8, 9 416 417# -- MPI AIJ -- 418 419class TestMatMPIAIJ(BaseTestMatAIJ): 420 COMM = PETSc.COMM_WORLD 421 TYPE = PETSc.Mat.Type.MPIAIJ 422class TestMatMPIAIJ_G23(TestMatMPIAIJ): 423 GRID = 2, 3 424class TestMatMPIAIJ_G45(TestMatMPIAIJ): 425 GRID = 4, 5 426class TestMatMPIAIJ_G89(TestMatMPIAIJ): 427 GRID = 8, 9 428 429 430# -- Block AIJ --------------- 431 432class BaseTestMatBAIJ(BaseTestMatAnyAIJ, unittest.TestCase): 433 COMM = PETSc.COMM_WORLD 434 TYPE = PETSc.Mat.Type.BAIJ 435 GRID = 0, 0 436 BSIZE = 1 437 438# -- Seq Block AIJ -- 439 440class TestMatSeqBAIJ(BaseTestMatBAIJ): 441 COMM = PETSc.COMM_SELF 442 TYPE = PETSc.Mat.Type.SEQBAIJ 443# bs = 1 444class TestMatSeqBAIJ_G23(TestMatSeqBAIJ): 445 GRID = 2, 3 446class TestMatSeqBAIJ_G45(TestMatSeqBAIJ): 447 GRID = 4, 5 448class TestMatSeqBAIJ_G89(TestMatSeqBAIJ): 449 GRID = 8, 9 450# bs = 2 451class TestMatSeqBAIJ_G23_B2(TestMatSeqBAIJ_G23): 452 BSIZE = 2 453class TestMatSeqBAIJ_G45_B2(TestMatSeqBAIJ_G45): 454 BSIZE = 2 455class TestMatSeqBAIJ_G89_B2(TestMatSeqBAIJ_G89): 456 BSIZE = 2 457# bs = 3 458class TestMatSeqBAIJ_G23_B3(TestMatSeqBAIJ_G23): 459 BSIZE = 3 460class TestMatSeqBAIJ_G45_B3(TestMatSeqBAIJ_G45): 461 BSIZE = 3 462class TestMatSeqBAIJ_G89_B3(TestMatSeqBAIJ_G89): 463 BSIZE = 3 464# bs = 4 465class TestMatSeqBAIJ_G23_B4(TestMatSeqBAIJ_G23): 466 BSIZE = 4 467class TestMatSeqBAIJ_G45_B4(TestMatSeqBAIJ_G45): 468 BSIZE = 4 469class TestMatSeqBAIJ_G89_B4(TestMatSeqBAIJ_G89): 470 BSIZE = 4 471# bs = 5 472class TestMatSeqBAIJ_G23_B5(TestMatSeqBAIJ_G23): 473 BSIZE = 5 474class TestMatSeqBAIJ_G45_B5(TestMatSeqBAIJ_G45): 475 BSIZE = 5 476class TestMatSeqBAIJ_G89_B5(TestMatSeqBAIJ_G89): 477 BSIZE = 5 478 479 480# -- MPI Block AIJ -- 481 482class TestMatMPIBAIJ(BaseTestMatBAIJ): 483 COMM = PETSc.COMM_WORLD 484 TYPE = PETSc.Mat.Type.MPIBAIJ 485# bs = 1 486class TestMatMPIBAIJ_G23(TestMatMPIBAIJ): 487 GRID = 2, 3 488class TestMatMPIBAIJ_G45(TestMatMPIBAIJ): 489 GRID = 4, 5 490class TestMatMPIBAIJ_G89(TestMatMPIBAIJ): 491 GRID = 8, 9 492# bs = 2 493class TestMatMPIBAIJ_G23_B2(TestMatMPIBAIJ_G23): 494 BSIZE = 2 495class TestMatMPIBAIJ_G45_B2(TestMatMPIBAIJ_G45): 496 BSIZE = 2 497class TestMatMPIBAIJ_G89_B2(TestMatMPIBAIJ_G89): 498 BSIZE = 2 499# bs = 3 500class TestMatMPIBAIJ_G23_B3(TestMatMPIBAIJ_G23): 501 BSIZE = 3 502class TestMatMPIBAIJ_G45_B3(TestMatMPIBAIJ_G45): 503 BSIZE = 3 504class TestMatMPIBAIJ_G89_B3(TestMatMPIBAIJ_G89): 505 BSIZE = 3 506# bs = 4 507class TestMatMPIBAIJ_G23_B4(TestMatMPIBAIJ_G23): 508 BSIZE = 4 509class TestMatMPIBAIJ_G45_B4(TestMatMPIBAIJ_G45): 510 BSIZE = 4 511class TestMatMPIBAIJ_G89_B4(TestMatMPIBAIJ_G89): 512 BSIZE = 4 513# bs = 5 514class TestMatMPIBAIJ_G23_B5(TestMatMPIBAIJ_G23): 515 BSIZE = 5 516class TestMatMPIBAIJ_G45_B5(TestMatMPIBAIJ_G45): 517 BSIZE = 5 518class TestMatMPIBAIJ_G89_B5(TestMatMPIBAIJ_G89): 519 BSIZE = 5 520 521# -- SymmBlock AIJ --------------- 522 523class BaseTestMatSBAIJ(BaseTestMatAnyAIJ, unittest.TestCase): 524 COMM = PETSc.COMM_WORLD 525 TYPE = PETSc.Mat.Type.SBAIJ 526 GRID = 0, 0 527 BSIZE = 1 528 def testInvertBlockDiagonal(self): pass 529 def _chk_aij(self, A, i, j): 530 ai, aj = A.getRowIJ(compressed=True) 531 if ai is not None and aj is not None: 532 if 0: # XXX Implement 533 self.assertTrue(N.all(i==ai)) 534 self.assertTrue(N.all(j==aj)) 535 ai, aj = A.getColumnIJ(compressed=True) 536 if ai is not None and aj is not None: 537 if 0: # XXX Implement 538 self.assertTrue(N.all(i==ai)) 539 self.assertTrue(N.all(j==aj)) 540 541# -- Seq SymmBlock AIJ -- 542 543class TestMatSeqSBAIJ(BaseTestMatSBAIJ): 544 COMM = PETSc.COMM_SELF 545 TYPE = PETSc.Mat.Type.SEQSBAIJ 546# bs = 1 547class TestMatSeqSBAIJ_G23(TestMatSeqSBAIJ): 548 GRID = 2, 3 549class TestMatSeqSBAIJ_G45(TestMatSeqSBAIJ): 550 GRID = 4, 5 551class TestMatSeqSBAIJ_G89(TestMatSeqSBAIJ): 552 GRID = 8, 9 553# bs = 2 554class TestMatSeqSBAIJ_G23_B2(TestMatSeqSBAIJ_G23): 555 BSIZE = 2 556class TestMatSeqSBAIJ_G45_B2(TestMatSeqSBAIJ_G45): 557 BSIZE = 2 558class TestMatSeqSBAIJ_G89_B2(TestMatSeqSBAIJ_G89): 559 BSIZE = 2 560# bs = 3 561class TestMatSeqSBAIJ_G23_B3(TestMatSeqSBAIJ_G23): 562 BSIZE = 3 563class TestMatSeqSBAIJ_G45_B3(TestMatSeqSBAIJ_G45): 564 BSIZE = 3 565class TestMatSeqSBAIJ_G89_B3(TestMatSeqSBAIJ_G89): 566 BSIZE = 3 567# bs = 4 568class TestMatSeqSBAIJ_G23_B4(TestMatSeqSBAIJ_G23): 569 BSIZE = 4 570class TestMatSeqSBAIJ_G45_B4(TestMatSeqSBAIJ_G45): 571 BSIZE = 4 572class TestMatSeqSBAIJ_G89_B4(TestMatSeqSBAIJ_G89): 573 BSIZE = 4 574# bs = 5 575class TestMatSeqSBAIJ_G23_B5(TestMatSeqSBAIJ_G23): 576 BSIZE = 5 577class TestMatSeqSBAIJ_G45_B5(TestMatSeqSBAIJ_G45): 578 BSIZE = 5 579class TestMatSeqSBAIJ_G89_B5(TestMatSeqSBAIJ_G89): 580 BSIZE = 5 581 582 583# -- MPI SymmBlock AIJ -- 584 585class TestMatMPISBAIJ(BaseTestMatSBAIJ): 586 COMM = PETSc.COMM_WORLD 587 TYPE = PETSc.Mat.Type.MPISBAIJ 588# bs = 1 589class TestMatMPISBAIJ_G23(TestMatMPISBAIJ): 590 GRID = 2, 3 591class TestMatMPISBAIJ_G45(TestMatMPISBAIJ): 592 GRID = 4, 5 593class TestMatMPISBAIJ_G89(TestMatMPISBAIJ): 594 GRID = 8, 9 595# bs = 2 596class TestMatMPISBAIJ_G23_B2(TestMatMPISBAIJ_G23): 597 BSIZE = 2 598class TestMatMPISBAIJ_G45_B2(TestMatMPISBAIJ_G45): 599 BSIZE = 2 600class TestMatMPISBAIJ_G89_B2(TestMatMPISBAIJ_G89): 601 BSIZE = 2 602# bs = 3 603class TestMatMPISBAIJ_G23_B3(TestMatMPISBAIJ_G23): 604 BSIZE = 3 605class TestMatMPISBAIJ_G45_B3(TestMatMPISBAIJ_G45): 606 BSIZE = 3 607class TestMatMPISBAIJ_G89_B3(TestMatMPISBAIJ_G89): 608 BSIZE = 3 609# bs = 4 610class TestMatMPISBAIJ_G23_B4(TestMatMPISBAIJ_G23): 611 BSIZE = 4 612class TestMatMPISBAIJ_G45_B4(TestMatMPISBAIJ_G45): 613 BSIZE = 4 614class TestMatMPISBAIJ_G89_B4(TestMatMPISBAIJ_G89): 615 BSIZE = 4 616# bs = 5 617class TestMatMPISBAIJ_G23_B5(TestMatMPISBAIJ_G23): 618 BSIZE = 5 619class TestMatMPISBAIJ_G45_B5(TestMatMPISBAIJ_G45): 620 BSIZE = 5 621class TestMatMPISBAIJ_G89_B5(TestMatMPISBAIJ_G89): 622 BSIZE = 5 623 624# -- AIJ + Block --------------- 625 626class BaseTestMatAIJ_B(BaseTestMatAnyAIJ, unittest.TestCase): 627 COMM = PETSc.COMM_WORLD 628 TYPE = PETSc.Mat.Type.AIJ 629 GRID = 0, 0 630 BSIZE = 1 631 632 def testSetPreallocNNZ(self):pass 633 def testSetPreallocNNZ_2(self):pass 634 def testSetPreallocCSR(self):pass 635 def testSetPreallocCSR_2(self):pass 636 def testSetValues(self): 637 self._preallocate() 638 opt = PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR 639 self.A.setOption(opt, True) 640 ai, aj, av = self._set_values() 641 self.A.assemble() 642 self._chk_aij(self.A, ai, aj) 643 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 644 self.A.setOption(opt, True) 645 ai, aj, av = self._set_values() 646 self.A.assemble() 647 self._chk_aij(self.A, ai, aj) 648 def testSetValuesIJV(self): 649 self._preallocate() 650 opt = PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR 651 self.A.setOption(opt, True) 652 ai, aj, av = self._set_values_ijv() 653 self.A.assemble() 654 self._chk_aij(self.A, ai, aj) 655 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 656 self.A.setOption(opt, True) 657 ai, aj, av = self._set_values_ijv() 658 self.A.assemble() 659 self._chk_aij(self.A, ai, aj) 660 def _preallocate(self): 661 self.A.setPreallocationNNZ([5*self.BSIZE, 3*self.BSIZE]) 662 self._chk_bs(self.A, self.BSIZE) 663 def _chk_aij(self, A, i, j): 664 bs = self.BSIZE or 1 665 ai, aj = A.getRowIJ() 666 if ai is not None and aj is not None: ## XXX map and check !! 667 #self.assertTrue(N.all(i==ai)) 668 #self.assertTrue(N.all(j==aj)) 669 pass 670 ai, aj = A.getColumnIJ(compressed=bool(self.BSIZE)) 671 if ai is not None and aj is not None: ## XXX map and check !! 672 #self.assertTrue(N.all(i==ai)) 673 #self.assertTrue(N.all(j==aj)) 674 pass 675 676# -- Seq AIJ + Block -- 677 678class TestMatSeqAIJ_B(BaseTestMatAIJ_B): 679 COMM = PETSc.COMM_SELF 680 TYPE = PETSc.Mat.Type.SEQAIJ 681# bs = 1 682class TestMatSeqAIJ_B_G23(TestMatSeqAIJ_B): 683 GRID = 2, 3 684class TestMatSeqAIJ_B_G45(TestMatSeqAIJ_B): 685 GRID = 4, 5 686class TestMatSeqAIJ_B_G89(TestMatSeqAIJ_B): 687 GRID = 8, 9 688# bs = 2 689class TestMatSeqAIJ_B_G23_B2(TestMatSeqAIJ_B_G23): 690 BSIZE = 2 691class TestMatSeqAIJ_B_G45_B2(TestMatSeqAIJ_B_G45): 692 BSIZE = 2 693class TestMatSeqAIJ_B_G89_B2(TestMatSeqAIJ_B_G89): 694 BSIZE = 2 695# bs = 3 696class TestMatSeqAIJ_B_G23_B3(TestMatSeqAIJ_B_G23): 697 BSIZE = 3 698class TestMatSeqAIJ_B_G45_B3(TestMatSeqAIJ_B_G45): 699 BSIZE = 3 700class TestMatSeqAIJ_B_G89_B3(TestMatSeqAIJ_B_G89): 701 BSIZE = 3 702# bs = 4 703class TestMatSeqAIJ_B_G23_B4(TestMatSeqAIJ_B_G23): 704 BSIZE = 4 705class TestMatSeqAIJ_B_G45_B4(TestMatSeqAIJ_B_G45): 706 BSIZE = 4 707class TestMatSeqAIJ_B_G89_B4(TestMatSeqAIJ_B_G89): 708 BSIZE = 4 709# bs = 5 710class TestMatSeqAIJ_B_G23_B5(TestMatSeqAIJ_B_G23): 711 BSIZE = 5 712class TestMatSeqAIJ_B_G45_B5(TestMatSeqAIJ_B_G45): 713 BSIZE = 5 714class TestMatSeqAIJ_B_G89_B5(TestMatSeqAIJ_B_G89): 715 BSIZE = 5 716 717 718# -- MPI AIJ + Block -- 719 720class TestMatMPIAIJ_B(BaseTestMatAIJ_B): 721 COMM = PETSc.COMM_WORLD 722 TYPE = PETSc.Mat.Type.MPIAIJ 723# bs = 1 724class TestMatMPIAIJ_B_G23(TestMatMPIAIJ_B): 725 GRID = 2, 3 726class TestMatMPIAIJ_B_G45(TestMatMPIAIJ_B): 727 GRID = 4, 5 728class TestMatMPIAIJ_B_G89(TestMatMPIAIJ_B): 729 GRID = 8, 9 730# bs = 2 731class TestMatMPIAIJ_B_G23_B2(TestMatMPIAIJ_B_G23): 732 BSIZE = 2 733class TestMatMPIAIJ_B_G45_B2(TestMatMPIAIJ_B_G45): 734 BSIZE = 2 735class TestMatMPIAIJ_B_G89_B2(TestMatMPIAIJ_B_G89): 736 BSIZE = 2 737# bs = 3 738class TestMatMPIAIJ_B_G23_B3(TestMatMPIAIJ_B_G23): 739 BSIZE = 3 740class TestMatMPIAIJ_B_G45_B3(TestMatMPIAIJ_B_G45): 741 BSIZE = 3 742class TestMatMPIAIJ_B_G89_B3(TestMatMPIAIJ_B_G89): 743 BSIZE = 3 744# bs = 4 745class TestMatMPIAIJ_B_G23_B4(TestMatMPIAIJ_B_G23): 746 BSIZE = 4 747class TestMatMPIAIJ_B_G45_B4(TestMatMPIAIJ_B_G45): 748 BSIZE = 4 749class TestMatMPIAIJ_B_G89_B4(TestMatMPIAIJ_B_G89): 750 BSIZE = 4 751# bs = 5 752class TestMatMPIAIJ_B_G23_B5(TestMatMPIAIJ_B_G23): 753 BSIZE = 5 754class TestMatMPIAIJ_B_G45_B5(TestMatMPIAIJ_B_G45): 755 BSIZE = 5 756class TestMatMPIAIJ_B_G89_B5(TestMatMPIAIJ_B_G89): 757 BSIZE = 5 758 759# -- Non-square blocks -- 760class BaseTestMatAIJ_B(BaseTestMatAnyAIJ, unittest.TestCase): 761 COMM = PETSc.COMM_WORLD 762 TYPE = PETSc.Mat.Type.AIJ 763 GRID = 0, 0 764 BSIZE = 4, 2 765 766 def _preallocate(self): 767 try: 768 rbs, cbs = self.BSIZE 769 except (TypeError, ValueError): 770 rbs = cbs = self.BSIZE 771 self.A.setPreallocationNNZ([5*rbs, 3*cbs]) 772 self._chk_bsizes(self.A, self.BSIZE) 773 def testSetPreallocNNZ(self):pass 774 def testSetPreallocNNZ_2(self):pass 775 def testSetPreallocCSR(self):pass 776 def testSetPreallocCSR_2(self):pass 777 def testSetValues(self): 778 self._preallocate() 779 opt = PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR 780 self.A.setOption(opt, True) 781 ai, aj, av = self._set_values() 782 self.A.assemble() 783 self._chk_aij(self.A, ai, aj) 784 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 785 self.A.setOption(opt, True) 786 ai, aj, av = self._set_values() 787 self.A.assemble() 788 self._chk_aij(self.A, ai, aj) 789 def testSetValuesIJV(self): 790 self._preallocate() 791 opt = PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR 792 self.A.setOption(opt, True) 793 ai, aj, av = self._set_values_ijv() 794 self.A.assemble() 795 self._chk_aij(self.A, ai, aj) 796 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 797 self.A.setOption(opt, True) 798 ai, aj, av = self._set_values_ijv() 799 self.A.assemble() 800 self._chk_aij(self.A, ai, aj) 801 def _chk_aij(self, A, i, j): 802 bs = self.BSIZE or 1 803 ai, aj = A.getRowIJ() 804 if ai is not None and aj is not None: ## XXX map and check !! 805 #self.assertTrue(N.all(i==ai)) 806 #self.assertTrue(N.all(j==aj)) 807 pass 808 ai, aj = A.getColumnIJ() 809 if ai is not None and aj is not None: ## XXX map and check !! 810 #self.assertTrue(N.all(i==ai)) 811 #self.assertTrue(N.all(j==aj)) 812 pass 813 814# -- AIJCRL --------------------- 815 816class BaseTestMatAIJCRL(BaseTestMatAIJ, unittest.TestCase): 817 TYPE = PETSc.Mat.Type.AIJCRL 818 819# -- Seq AIJCRL -- 820 821class TestMatSeqAIJCRL(BaseTestMatAIJCRL): 822 COMM = PETSc.COMM_SELF 823 TYPE = PETSc.Mat.Type.SEQAIJCRL 824class TestMatSeqAIJCRL_G23(TestMatSeqAIJCRL): 825 GRID = 2, 3 826class TestMatSeqAIJCRL_G45(TestMatSeqAIJCRL): 827 GRID = 4, 5 828class TestMatSeqAIJCRL_G89(TestMatSeqAIJCRL): 829 GRID = 8, 9 830 831# -- MPI AIJCRL -- 832 833class TestMatMPIAIJCRL(BaseTestMatAIJCRL): 834 COMM = PETSc.COMM_WORLD 835 TYPE = PETSc.Mat.Type.MPIAIJCRL 836class TestMatMPIAIJCRL_G23(TestMatMPIAIJCRL): 837 GRID = 2, 3 838class TestMatMPIAIJCRL_G45(TestMatMPIAIJCRL): 839 GRID = 4, 5 840class TestMatMPIAIJCRL_G89(TestMatMPIAIJCRL): 841 GRID = 8, 9 842 843# -- AIJCRL + Block ------------- 844 845class BaseTestMatAIJCRL_B(BaseTestMatAIJ_B, unittest.TestCase): 846 TYPE = PETSc.Mat.Type.AIJCRL 847 848# -- Seq AIJCRL + Block -- 849 850class TestMatSeqAIJCRL_B(BaseTestMatAIJCRL_B): 851 COMM = PETSc.COMM_SELF 852 TYPE = PETSc.Mat.Type.SEQAIJCRL 853# bs = 1 854class TestMatSeqAIJCRL_B_G23(TestMatSeqAIJCRL_B): 855 GRID = 2, 3 856class TestMatSeqAIJCRL_B_G45(TestMatSeqAIJCRL_B): 857 GRID = 4, 5 858class TestMatSeqAIJCRL_B_G89(TestMatSeqAIJCRL_B): 859 GRID = 8, 9 860# bs = 2 861class TestMatSeqAIJCRL_B_G23_B2(TestMatSeqAIJCRL_B_G23): 862 BSIZE = 2 863class TestMatSeqAIJCRL_B_G45_B2(TestMatSeqAIJCRL_B_G45): 864 BSIZE = 2 865class TestMatSeqAIJCRL_B_G89_B2(TestMatSeqAIJCRL_B_G89): 866 BSIZE = 2 867# bs = 3 868class TestMatSeqAIJCRL_B_G23_B3(TestMatSeqAIJCRL_B_G23): 869 BSIZE = 3 870class TestMatSeqAIJCRL_B_G45_B3(TestMatSeqAIJCRL_B_G45): 871 BSIZE = 3 872class TestMatSeqAIJCRL_B_G89_B3(TestMatSeqAIJCRL_B_G89): 873 BSIZE = 3 874# bs = 4 875class TestMatSeqAIJCRL_B_G23_B4(TestMatSeqAIJCRL_B_G23): 876 BSIZE = 4 877class TestMatSeqAIJCRL_B_G45_B4(TestMatSeqAIJCRL_B_G45): 878 BSIZE = 4 879class TestMatSeqAIJCRL_B_G89_B4(TestMatSeqAIJCRL_B_G89): 880 BSIZE = 4 881# bs = 5 882class TestMatSeqAIJCRL_B_G23_B5(TestMatSeqAIJCRL_B_G23): 883 BSIZE = 5 884class TestMatSeqAIJCRL_B_G45_B5(TestMatSeqAIJCRL_B_G45): 885 BSIZE = 5 886class TestMatSeqAIJCRL_B_G89_B5(TestMatSeqAIJCRL_B_G89): 887 BSIZE = 5 888 889 890# -- MPI AIJCRL + Block -- 891 892class TestMatMPIAIJCRL_B(BaseTestMatAIJCRL_B): 893 COMM = PETSc.COMM_WORLD 894 TYPE = PETSc.Mat.Type.MPIAIJCRL 895# bs = 1 896class TestMatMPIAIJCRL_B_G23(TestMatMPIAIJCRL_B): 897 GRID = 2, 3 898class TestMatMPIAIJCRL_B_G45(TestMatMPIAIJCRL_B): 899 GRID = 4, 5 900class TestMatMPIAIJCRL_B_G89(TestMatMPIAIJCRL_B): 901 GRID = 8, 9 902# bs = 2 903class TestMatMPIAIJCRL_B_G23_B2(TestMatMPIAIJCRL_B_G23): 904 BSIZE = 2 905class TestMatMPIAIJCRL_B_G45_B2(TestMatMPIAIJCRL_B_G45): 906 BSIZE = 2 907class TestMatMPIAIJCRL_B_G89_B2(TestMatMPIAIJCRL_B_G89): 908 BSIZE = 2 909# bs = 3 910class TestMatMPIAIJCRL_B_G23_B3(TestMatMPIAIJCRL_B_G23): 911 BSIZE = 3 912class TestMatMPIAIJCRL_B_G45_B3(TestMatMPIAIJCRL_B_G45): 913 BSIZE = 3 914class TestMatMPIAIJCRL_B_G89_B3(TestMatMPIAIJCRL_B_G89): 915 BSIZE = 3 916# bs = 4 917class TestMatMPIAIJCRL_B_G23_B4(TestMatMPIAIJCRL_B_G23): 918 BSIZE = 4 919class TestMatMPIAIJCRL_B_G45_B4(TestMatMPIAIJCRL_B_G45): 920 BSIZE = 4 921class TestMatMPIAIJCRL_B_G89_B4(TestMatMPIAIJCRL_B_G89): 922 BSIZE = 4 923# bs = 5 924class TestMatMPIAIJCRL_B_G23_B5(TestMatMPIAIJCRL_B_G23): 925 BSIZE = 5 926class TestMatMPIAIJCRL_B_G45_B5(TestMatMPIAIJCRL_B_G45): 927 BSIZE = 5 928class TestMatMPIAIJCRL_B_G89_B5(TestMatMPIAIJCRL_B_G89): 929 BSIZE = 5 930 931# ----- 932 933 934 935if __name__ == '__main__': 936 unittest.main() 937