1from petsc4py import PETSc 2import unittest 3 4import numpy as N 5import numpy as np 6 7 8def mkgraph(comm, m, n): 9 start = m * n * comm.rank 10 end = start + m * n 11 idt = PETSc.IntType 12 rows = [] 13 for gridI in range(start, end): 14 rows.append([]) 15 adj = rows[-1] 16 i = gridI // n 17 j = gridI - i * n 18 if i > 0: 19 gridJ = gridI - n 20 adj.append(gridJ) 21 if j > 0: 22 gridJ = gridI - 1 23 adj.append(gridJ) 24 adj.append(gridI) 25 if j < n - 1: 26 gridJ = gridI + 1 27 adj.append(gridJ) 28 if i < m - 1: 29 gridJ = gridI + n 30 adj.append(gridJ) 31 nods = N.array(range(start, end), dtype=idt) 32 xadj = N.array([0] * (len(rows) + 1), dtype=idt) 33 xadj[0] = 0 34 xadj[1:] = N.cumsum([len(r) for r in rows], dtype=idt) 35 if not rows: 36 adjy = N.array([], dtype=idt) 37 else: 38 adjy = N.concatenate(rows).astype(idt) 39 return nods, xadj, adjy 40 41 42class BaseTestMatAnyAIJ: 43 COMM = PETSc.COMM_NULL 44 TYPE = None 45 GRID = 0, 0 46 BSIZE = None 47 48 def setUp(self): 49 COMM = self.COMM 50 GM, GN = self.GRID 51 BS = self.BSIZE 52 # 53 try: 54 rbs, cbs = BS 55 rbs = rbs or 1 56 cbs = cbs or 1 57 except (TypeError, ValueError): 58 rbs = cbs = BS or 1 59 sdt = PETSc.ScalarType 60 self.rows, self.xadj, self.adjy = mkgraph(COMM, GM, GN) 61 self.vals = N.array(range(1, 1 + len(self.adjy) * rbs * cbs), dtype=sdt) 62 self.vals.shape = (-1, rbs, cbs) 63 # 64 m, n = GM, GN 65 rowsz = (m * n * rbs, None) 66 colsz = (m * n * cbs, None) 67 A = self.A = PETSc.Mat().create(comm=COMM) 68 A.setType(self.TYPE) 69 A.setSizes([rowsz, colsz], BS) 70 71 def tearDown(self): 72 self.A.destroy() 73 self.A = None 74 PETSc.garbage_cleanup() 75 76 def testSetPreallocNNZ(self): 77 nnz = [5, 2] 78 self.A.setPreallocationNNZ(nnz) 79 self._chk_bs(self.A, self.BSIZE) 80 opt = PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR 81 self.A.setOption(opt, True) 82 ai, aj, av = self._set_values() 83 self.A.assemble() 84 self._chk_aij(self.A, ai, aj) 85 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 86 self.A.setOption(opt, True) 87 ai, aj, av = self._set_values_ijv() 88 self.A.assemble() 89 self._chk_aij(self.A, ai, aj) 90 91 def testSetPreallocNNZ_2(self): 92 _, ai, _, _ = self._get_aijv() 93 d_nnz = N.diff(ai) 94 nnz = [d_nnz, 3] 95 self.A.setPreallocationNNZ(nnz) 96 self._chk_bs(self.A, self.BSIZE) 97 opt = PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR 98 self.A.setOption(opt, True) 99 ai, aj, av = self._set_values() 100 self.A.assemble() 101 self._chk_aij(self.A, ai, aj) 102 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 103 self.A.setOption(opt, True) 104 ai, aj, av = self._set_values_ijv() 105 self.A.assemble() 106 self._chk_aij(self.A, ai, aj) 107 108 def testSetPreallocCSR(self): 109 if 'is' in self.A.getType(): 110 return # XXX 111 _, ai, aj, _ = self._get_aijv() 112 csr = [ai, aj] 113 self.A.setPreallocationCSR(csr) 114 self._chk_bs(self.A, self.BSIZE) 115 self._chk_aij(self.A, ai, aj) 116 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 117 self.A.setOption(opt, True) 118 self._set_values() 119 self.A.assemble() 120 self._chk_aij(self.A, ai, aj) 121 self._set_values_ijv() 122 self.A.assemble() 123 self._chk_aij(self.A, ai, aj) 124 125 def testSetPreallocCSR_2(self): 126 if 'is' in self.A.getType(): 127 return # XXX 128 _, ai, aj, av = self._get_aijv() 129 csr = [ai, aj, av] 130 self.A.setPreallocationCSR(csr) 131 self._chk_bs(self.A, self.BSIZE) 132 self._chk_aij(self.A, ai, aj) 133 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 134 self.A.setOption(opt, True) 135 self._set_values() 136 self.A.assemble() 137 self._chk_aij(self.A, ai, aj) 138 self._set_values_ijv() 139 self.A.assemble() 140 self._chk_aij(self.A, ai, aj) 141 142 def testSetValues(self): 143 self._preallocate() 144 opt = PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR 145 self.A.setOption(opt, True) 146 ai, aj, av = self._set_values() 147 self.A.assemble() 148 self._chk_aij(self.A, ai, aj) 149 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 150 self.A.setOption(opt, True) 151 ai, aj, av = self._set_values() 152 self.A.assemble() 153 self._chk_aij(self.A, ai, aj) 154 155 def testSetValuesIJV(self): 156 self._preallocate() 157 opt = PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR 158 self.A.setOption(opt, True) 159 ai, aj, av = self._set_values_ijv() 160 self.A.assemble() 161 self._chk_aij(self.A, ai, aj) 162 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 163 self.A.setOption(opt, True) 164 ai, aj, av = self._set_values_ijv() 165 self.A.assemble() 166 self._chk_aij(self.A, ai, aj) 167 168 def testGetValuesCSR(self): 169 if 'is' in self.A.getType(): 170 return # XXX 171 self._preallocate() 172 self._set_values_ijv() 173 A = self.A 174 A.assemble() 175 if 'sbaij' in A.getType(): 176 opt = PETSc.Mat.Option.GETROW_UPPERTRIANGULAR 177 self.A.setOption(opt, True) 178 ai, aj, av = A.getValuesCSR() 179 rstart, rend = A.getOwnershipRange() 180 for row in range(rstart, rend): 181 cols, vals = A.getRow(row) 182 i = row - rstart 183 self.assertTrue(N.allclose(aj[ai[i] : ai[i + 1]], cols)) 184 self.assertTrue(N.allclose(av[ai[i] : ai[i + 1]], vals)) 185 186 def testConvertToSAME(self): 187 self._preallocate() 188 self._set_values_ijv() 189 A = self.A 190 A.assemble() 191 A.convert('same') 192 193 def testConvertToDENSE(self): 194 self._preallocate() 195 self._set_values_ijv() 196 A = self.A 197 A.assemble() 198 x, y = A.getVecs() 199 x.setRandom() 200 z = y.duplicate() 201 A.mult(x, y) 202 if A.type.endswith('sbaij'): 203 return 204 B = PETSc.Mat() 205 A.convert('dense', B) # initial 206 B.mult(x, z) 207 self.assertTrue(np.allclose(y.array, z.array)) 208 A.convert('dense', B) # reuse 209 B.mult(x, z) 210 self.assertTrue(np.allclose(y.array, z.array)) 211 A.convert('dense') # inplace 212 A.mult(x, z) 213 self.assertTrue(np.allclose(y.array, z.array)) 214 215 def testConvertToAIJ(self): 216 self._preallocate() 217 self._set_values_ijv() 218 A = self.A 219 A.assemble() 220 x, y = A.getVecs() 221 x.setRandom() 222 z = y.duplicate() 223 A.mult(x, y) 224 if A.type.endswith('sbaij'): 225 return 226 B = PETSc.Mat() 227 A.convert('aij', B) # initial 228 B.mult(x, z) 229 self.assertTrue(np.allclose(y.array, z.array)) 230 A.convert('aij', B) # reuse 231 B.mult(x, z) 232 self.assertTrue(np.allclose(y.array, z.array)) 233 A.convert('aij') # inplace 234 A.mult(x, z) 235 self.assertTrue(np.allclose(y.array, z.array)) 236 237 def testGetDiagonalBlock(self): 238 if 'is' in self.A.getType(): 239 return # XXX 240 self._preallocate() 241 self._set_values_ijv() 242 self.A.assemble() 243 B = self.A.getDiagonalBlock() 244 self.assertEqual(self.A.getLocalSize(), B.getSize()) 245 B.destroy() 246 247 def testInvertBlockDiagonal(self): 248 if 'is' in self.A.getType(): 249 return # XXX 250 try: 251 _ = len(self.BSIZE) 252 return 253 except (TypeError, ValueError): 254 pass 255 self._preallocate() 256 rbs, cbs = self.A.getBlockSizes() 257 if rbs != cbs: 258 return 259 self._set_values_ijv() 260 self.A.assemble() 261 self.A.shift(1000) # Make nonsingular 262 ibdiag = self.A.invertBlockDiagonal() 263 bs = self.A.getBlockSize() 264 m, _ = self.A.getLocalSize() 265 self.assertEqual(ibdiag.shape, (m // bs, bs, bs)) 266 tmp = N.empty((m // bs, bs, bs), dtype=PETSc.ScalarType) 267 rstart, rend = self.A.getOwnershipRange() 268 s, e = rstart // bs, rend // bs 269 for i in range(s, e): 270 rows = cols = N.arange(i * bs, (i + 1) * bs, dtype=PETSc.IntType) 271 vals = self.A.getValues(rows, cols) 272 tmp[i - s, :, :] = N.linalg.inv(vals) 273 self.assertTrue(N.allclose(ibdiag, tmp)) 274 275 def testCreateSubMatrix(self): 276 if 'baij' in self.A.getType(): 277 return # XXX 278 self._preallocate() 279 self._set_values_ijv() 280 self.A.assemble() 281 # 282 rs, re = self.A.getOwnershipRange() 283 cs, ce = self.A.getOwnershipRangeColumn() 284 rows = N.array(range(rs, re), dtype=PETSc.IntType) 285 cols = N.array(range(cs, ce), dtype=PETSc.IntType) 286 rows = PETSc.IS().createGeneral(rows, comm=self.A.getComm()) 287 cols = PETSc.IS().createGeneral(cols, comm=self.A.getComm()) 288 # 289 S = self.A.createSubMatrix(rows, None) 290 S.zeroEntries() 291 self.A.createSubMatrix(rows, None, S) 292 S.destroy() 293 # 294 S = self.A.createSubMatrix(rows, cols) 295 S.zeroEntries() 296 self.A.createSubMatrix(rows, cols, S) 297 S.destroy() 298 299 def testCreateSubMatrices(self): 300 if 'baij' in self.A.getType(): 301 return # XXX 302 if 'is' in self.A.getType(): 303 return # XXX 304 self._preallocate() 305 self._set_values_ijv() 306 self.A.assemble() 307 # 308 rs, re = self.A.getOwnershipRange() 309 cs, ce = self.A.getOwnershipRangeColumn() 310 rows = N.array(range(rs, re), dtype=PETSc.IntType) 311 cols = N.array(range(cs, ce), dtype=PETSc.IntType) 312 rows = PETSc.IS().createGeneral(rows, comm=self.A.getComm()) 313 cols = PETSc.IS().createGeneral(cols, comm=self.A.getComm()) 314 # 315 (S,) = self.A.createSubMatrices(rows, cols) 316 S.zeroEntries() 317 self.A.createSubMatrices(rows, cols, submats=[S]) 318 S.destroy() 319 # 320 (S1,) = self.A.createSubMatrices([rows], [cols]) 321 (S2,) = self.A.createSubMatrices([rows], [cols]) 322 self.assertTrue(S1.equal(S2)) 323 S2.zeroEntries() 324 self.A.createSubMatrices([rows], [cols], [S2]) 325 self.assertTrue(S1.equal(S2)) 326 S1.destroy() 327 S2.destroy() 328 # 329 if 'seq' not in self.A.getType(): 330 return # XXX 331 S1, S2 = self.A.createSubMatrices([rows, rows], [cols, cols]) 332 self.assertTrue(S1.equal(S2)) 333 S1.zeroEntries() 334 S2.zeroEntries() 335 self.A.createSubMatrices([rows, rows], [cols, cols], [S1, S2]) 336 self.assertTrue(S1.equal(S2)) 337 S1.destroy() 338 S2.destroy() 339 340 def testGetRedundantMatrix(self): 341 if 'aijcrl' in self.A.getType(): 342 return # duplicate not supported 343 if 'mpisbaij' in self.A.getType(): 344 return # not working 345 if 'is' in self.A.getType(): 346 return # XXX 347 self._preallocate() 348 self._set_values_ijv() 349 self.A.assemble() 350 # Test the most simple case 351 sizecommA = self.A.getComm().getSize() 352 Ared = self.A.getRedundantMatrix(sizecommA) 353 sizecommAred = Ared.getComm().getSize() 354 self.assertEqual(1, sizecommAred) 355 Ared.destroy() 356 357 def testCreateTranspose(self): 358 self._preallocate() 359 self._set_values_ijv() 360 self.A.assemble() 361 A = self.A 362 AT = PETSc.Mat().createTranspose(A) 363 x, y = A.createVecs() 364 xt, yt = AT.createVecs() 365 # 366 y.setRandom() 367 A.multTranspose(y, x) 368 y.copy(xt) 369 AT.mult(xt, yt) 370 self.assertTrue(yt.equal(x)) 371 # 372 x.setRandom() 373 A.mult(x, y) 374 x.copy(yt) 375 AT.multTranspose(yt, xt) 376 self.assertTrue(xt.equal(y)) 377 378 def _get_aijv(self): 379 return ( 380 self.rows, 381 self.xadj, 382 self.adjy, 383 self.vals, 384 ) 385 386 def _preallocate(self): 387 self.A.setPreallocationNNZ([5, 2]) 388 389 def _set_values(self): 390 import sys 391 392 if hasattr(sys, 'gettotalrefcount'): 393 return self._set_values_ijv() 394 # XXX Why the code below leak refs as a beast ??? 395 row, ai, aj, av = self._get_aijv() 396 if not self.BSIZE: 397 setvalues = self.A.setValues 398 else: 399 setvalues = self.A.setValuesBlocked 400 for i, r in enumerate(row): 401 s, e = ai[i], ai[i + 1] 402 setvalues(r, aj[s:e], av[s:e]) 403 return ai, aj, av 404 405 def _set_values_ijv(self): 406 row, ai, aj, av = self._get_aijv() 407 if not self.BSIZE: 408 setvalues = self.A.setValuesIJV 409 else: 410 setvalues = self.A.setValuesBlockedIJV 411 setvalues(ai, aj, av, rowmap=row) 412 setvalues(ai, aj, av, rowmap=None) 413 return ai, aj, av 414 415 def _chk_bs(self, A, bs): 416 self.assertEqual(A.getBlockSize(), bs or 1) 417 418 def _chk_bsizes(self, A, bsizes): 419 try: 420 rbs, cbs = bsizes 421 except (TypeError, ValueError): 422 rbs = cbs = bsizes 423 self.assertEqual(A.getBlockSizes(), (rbs, cbs)) 424 425 def _chk_aij(self, A, i, j): 426 compressed = bool(self.BSIZE) 427 ai, aj = A.getRowIJ(compressed=compressed) 428 if ai is not None and aj is not None: 429 self.assertTrue(N.all(i == ai)) 430 self.assertTrue(N.all(j == aj)) 431 ai, aj = A.getColumnIJ(compressed=compressed) 432 if ai is not None and aj is not None: 433 self.assertTrue(N.all(i == ai)) 434 self.assertTrue(N.all(j == aj)) 435 436 437# -- AIJ --------------------- 438 439 440class BaseTestMatAIJ(BaseTestMatAnyAIJ, unittest.TestCase): 441 COMM = PETSc.COMM_WORLD 442 TYPE = PETSc.Mat.Type.AIJ 443 GRID = 0, 0 444 BSIZE = None 445 446 447# -- Seq AIJ -- 448 449 450class TestMatSeqAIJ(BaseTestMatAIJ): 451 COMM = PETSc.COMM_SELF 452 TYPE = PETSc.Mat.Type.SEQAIJ 453 454 455class TestMatSeqAIJ_G23(TestMatSeqAIJ): 456 GRID = 2, 3 457 458 459class TestMatSeqAIJ_G45(TestMatSeqAIJ): 460 GRID = 4, 5 461 462 463class TestMatSeqAIJ_G89(TestMatSeqAIJ): 464 GRID = 8, 9 465 466 467# -- MPI AIJ -- 468 469 470class TestMatMPIAIJ(BaseTestMatAIJ): 471 COMM = PETSc.COMM_WORLD 472 TYPE = PETSc.Mat.Type.MPIAIJ 473 474 475class TestMatMPIAIJ_G23(TestMatMPIAIJ): 476 GRID = 2, 3 477 478 479class TestMatMPIAIJ_G45(TestMatMPIAIJ): 480 GRID = 4, 5 481 482 483class TestMatMPIAIJ_G89(TestMatMPIAIJ): 484 GRID = 8, 9 485 486 487# -- Block AIJ --------------- 488 489 490class BaseTestMatBAIJ(BaseTestMatAnyAIJ, unittest.TestCase): 491 COMM = PETSc.COMM_WORLD 492 TYPE = PETSc.Mat.Type.BAIJ 493 GRID = 0, 0 494 BSIZE = 1 495 496 497# -- Seq Block AIJ -- 498 499 500class TestMatSeqBAIJ(BaseTestMatBAIJ): 501 COMM = PETSc.COMM_SELF 502 TYPE = PETSc.Mat.Type.SEQBAIJ 503 504 505# bs = 1 506class TestMatSeqBAIJ_G23(TestMatSeqBAIJ): 507 GRID = 2, 3 508 509 510class TestMatSeqBAIJ_G45(TestMatSeqBAIJ): 511 GRID = 4, 5 512 513 514class TestMatSeqBAIJ_G89(TestMatSeqBAIJ): 515 GRID = 8, 9 516 517 518# bs = 2 519class TestMatSeqBAIJ_G23_B2(TestMatSeqBAIJ_G23): 520 BSIZE = 2 521 522 523class TestMatSeqBAIJ_G45_B2(TestMatSeqBAIJ_G45): 524 BSIZE = 2 525 526 527class TestMatSeqBAIJ_G89_B2(TestMatSeqBAIJ_G89): 528 BSIZE = 2 529 530 531# bs = 3 532class TestMatSeqBAIJ_G23_B3(TestMatSeqBAIJ_G23): 533 BSIZE = 3 534 535 536class TestMatSeqBAIJ_G45_B3(TestMatSeqBAIJ_G45): 537 BSIZE = 3 538 539 540class TestMatSeqBAIJ_G89_B3(TestMatSeqBAIJ_G89): 541 BSIZE = 3 542 543 544# bs = 4 545class TestMatSeqBAIJ_G23_B4(TestMatSeqBAIJ_G23): 546 BSIZE = 4 547 548 549class TestMatSeqBAIJ_G45_B4(TestMatSeqBAIJ_G45): 550 BSIZE = 4 551 552 553class TestMatSeqBAIJ_G89_B4(TestMatSeqBAIJ_G89): 554 BSIZE = 4 555 556 557# bs = 5 558class TestMatSeqBAIJ_G23_B5(TestMatSeqBAIJ_G23): 559 BSIZE = 5 560 561 562class TestMatSeqBAIJ_G45_B5(TestMatSeqBAIJ_G45): 563 BSIZE = 5 564 565 566class TestMatSeqBAIJ_G89_B5(TestMatSeqBAIJ_G89): 567 BSIZE = 5 568 569 570# -- MPI Block AIJ -- 571 572 573class TestMatMPIBAIJ(BaseTestMatBAIJ): 574 COMM = PETSc.COMM_WORLD 575 TYPE = PETSc.Mat.Type.MPIBAIJ 576 577 578# bs = 1 579class TestMatMPIBAIJ_G23(TestMatMPIBAIJ): 580 GRID = 2, 3 581 582 583class TestMatMPIBAIJ_G45(TestMatMPIBAIJ): 584 GRID = 4, 5 585 586 587class TestMatMPIBAIJ_G89(TestMatMPIBAIJ): 588 GRID = 8, 9 589 590 591# bs = 2 592class TestMatMPIBAIJ_G23_B2(TestMatMPIBAIJ_G23): 593 BSIZE = 2 594 595 596class TestMatMPIBAIJ_G45_B2(TestMatMPIBAIJ_G45): 597 BSIZE = 2 598 599 600class TestMatMPIBAIJ_G89_B2(TestMatMPIBAIJ_G89): 601 BSIZE = 2 602 603 604# bs = 3 605class TestMatMPIBAIJ_G23_B3(TestMatMPIBAIJ_G23): 606 BSIZE = 3 607 608 609class TestMatMPIBAIJ_G45_B3(TestMatMPIBAIJ_G45): 610 BSIZE = 3 611 612 613class TestMatMPIBAIJ_G89_B3(TestMatMPIBAIJ_G89): 614 BSIZE = 3 615 616 617# bs = 4 618class TestMatMPIBAIJ_G23_B4(TestMatMPIBAIJ_G23): 619 BSIZE = 4 620 621 622class TestMatMPIBAIJ_G45_B4(TestMatMPIBAIJ_G45): 623 BSIZE = 4 624 625 626class TestMatMPIBAIJ_G89_B4(TestMatMPIBAIJ_G89): 627 BSIZE = 4 628 629 630# bs = 5 631class TestMatMPIBAIJ_G23_B5(TestMatMPIBAIJ_G23): 632 BSIZE = 5 633 634 635class TestMatMPIBAIJ_G45_B5(TestMatMPIBAIJ_G45): 636 BSIZE = 5 637 638 639class TestMatMPIBAIJ_G89_B5(TestMatMPIBAIJ_G89): 640 BSIZE = 5 641 642 643# -- SymmBlock AIJ --------------- 644 645 646class BaseTestMatSBAIJ(BaseTestMatAnyAIJ, unittest.TestCase): 647 COMM = PETSc.COMM_WORLD 648 TYPE = PETSc.Mat.Type.SBAIJ 649 GRID = 0, 0 650 BSIZE = 1 651 652 def testInvertBlockDiagonal(self): 653 pass 654 655 def _chk_aij(self, A, i, j): 656 ai, aj = A.getRowIJ(compressed=True) 657 if ai is not None and aj is not None: 658 if 0: # XXX Implement 659 self.assertTrue(N.all(i == ai)) 660 self.assertTrue(N.all(j == aj)) 661 ai, aj = A.getColumnIJ(compressed=True) 662 if ai is not None and aj is not None: 663 if 0: # XXX Implement 664 self.assertTrue(N.all(i == ai)) 665 self.assertTrue(N.all(j == aj)) 666 667 668# -- Seq SymmBlock AIJ -- 669 670 671class TestMatSeqSBAIJ(BaseTestMatSBAIJ): 672 COMM = PETSc.COMM_SELF 673 TYPE = PETSc.Mat.Type.SEQSBAIJ 674 675 676# bs = 1 677class TestMatSeqSBAIJ_G23(TestMatSeqSBAIJ): 678 GRID = 2, 3 679 680 681class TestMatSeqSBAIJ_G45(TestMatSeqSBAIJ): 682 GRID = 4, 5 683 684 685class TestMatSeqSBAIJ_G89(TestMatSeqSBAIJ): 686 GRID = 8, 9 687 688 689# bs = 2 690class TestMatSeqSBAIJ_G23_B2(TestMatSeqSBAIJ_G23): 691 BSIZE = 2 692 693 694class TestMatSeqSBAIJ_G45_B2(TestMatSeqSBAIJ_G45): 695 BSIZE = 2 696 697 698class TestMatSeqSBAIJ_G89_B2(TestMatSeqSBAIJ_G89): 699 BSIZE = 2 700 701 702# bs = 3 703class TestMatSeqSBAIJ_G23_B3(TestMatSeqSBAIJ_G23): 704 BSIZE = 3 705 706 707class TestMatSeqSBAIJ_G45_B3(TestMatSeqSBAIJ_G45): 708 BSIZE = 3 709 710 711class TestMatSeqSBAIJ_G89_B3(TestMatSeqSBAIJ_G89): 712 BSIZE = 3 713 714 715# bs = 4 716class TestMatSeqSBAIJ_G23_B4(TestMatSeqSBAIJ_G23): 717 BSIZE = 4 718 719 720class TestMatSeqSBAIJ_G45_B4(TestMatSeqSBAIJ_G45): 721 BSIZE = 4 722 723 724class TestMatSeqSBAIJ_G89_B4(TestMatSeqSBAIJ_G89): 725 BSIZE = 4 726 727 728# bs = 5 729class TestMatSeqSBAIJ_G23_B5(TestMatSeqSBAIJ_G23): 730 BSIZE = 5 731 732 733class TestMatSeqSBAIJ_G45_B5(TestMatSeqSBAIJ_G45): 734 BSIZE = 5 735 736 737class TestMatSeqSBAIJ_G89_B5(TestMatSeqSBAIJ_G89): 738 BSIZE = 5 739 740 741# -- MPI SymmBlock AIJ -- 742 743 744class TestMatMPISBAIJ(BaseTestMatSBAIJ): 745 COMM = PETSc.COMM_WORLD 746 TYPE = PETSc.Mat.Type.MPISBAIJ 747 748 749# bs = 1 750class TestMatMPISBAIJ_G23(TestMatMPISBAIJ): 751 GRID = 2, 3 752 753 754class TestMatMPISBAIJ_G45(TestMatMPISBAIJ): 755 GRID = 4, 5 756 757 758class TestMatMPISBAIJ_G89(TestMatMPISBAIJ): 759 GRID = 8, 9 760 761 762# bs = 2 763class TestMatMPISBAIJ_G23_B2(TestMatMPISBAIJ_G23): 764 BSIZE = 2 765 766 767class TestMatMPISBAIJ_G45_B2(TestMatMPISBAIJ_G45): 768 BSIZE = 2 769 770 771class TestMatMPISBAIJ_G89_B2(TestMatMPISBAIJ_G89): 772 BSIZE = 2 773 774 775# bs = 3 776class TestMatMPISBAIJ_G23_B3(TestMatMPISBAIJ_G23): 777 BSIZE = 3 778 779 780class TestMatMPISBAIJ_G45_B3(TestMatMPISBAIJ_G45): 781 BSIZE = 3 782 783 784class TestMatMPISBAIJ_G89_B3(TestMatMPISBAIJ_G89): 785 BSIZE = 3 786 787 788# bs = 4 789class TestMatMPISBAIJ_G23_B4(TestMatMPISBAIJ_G23): 790 BSIZE = 4 791 792 793class TestMatMPISBAIJ_G45_B4(TestMatMPISBAIJ_G45): 794 BSIZE = 4 795 796 797class TestMatMPISBAIJ_G89_B4(TestMatMPISBAIJ_G89): 798 BSIZE = 4 799 800 801# bs = 5 802class TestMatMPISBAIJ_G23_B5(TestMatMPISBAIJ_G23): 803 BSIZE = 5 804 805 806class TestMatMPISBAIJ_G45_B5(TestMatMPISBAIJ_G45): 807 BSIZE = 5 808 809 810class TestMatMPISBAIJ_G89_B5(TestMatMPISBAIJ_G89): 811 BSIZE = 5 812 813 814# -- AIJ + Block --------------- 815 816 817class BaseTestMatAIJ_B(BaseTestMatAnyAIJ, unittest.TestCase): 818 COMM = PETSc.COMM_WORLD 819 TYPE = PETSc.Mat.Type.AIJ 820 GRID = 0, 0 821 BSIZE = 1 822 823 def testSetPreallocNNZ(self): 824 pass 825 826 def testSetPreallocNNZ_2(self): 827 pass 828 829 def testSetPreallocCSR(self): 830 pass 831 832 def testSetPreallocCSR_2(self): 833 pass 834 835 def testSetValues(self): 836 self._preallocate() 837 opt = PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR 838 self.A.setOption(opt, True) 839 ai, aj, av = self._set_values() 840 self.A.assemble() 841 self._chk_aij(self.A, ai, aj) 842 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 843 self.A.setOption(opt, True) 844 ai, aj, av = self._set_values() 845 self.A.assemble() 846 self._chk_aij(self.A, ai, aj) 847 848 def testSetValuesIJV(self): 849 self._preallocate() 850 opt = PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR 851 self.A.setOption(opt, True) 852 ai, aj, av = self._set_values_ijv() 853 self.A.assemble() 854 self._chk_aij(self.A, ai, aj) 855 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 856 self.A.setOption(opt, True) 857 ai, aj, av = self._set_values_ijv() 858 self.A.assemble() 859 self._chk_aij(self.A, ai, aj) 860 861 def _preallocate(self): 862 self.A.setPreallocationNNZ([5 * self.BSIZE, 3 * self.BSIZE]) 863 self._chk_bs(self.A, self.BSIZE) 864 865 def _chk_aij(self, A, i, j): 866 ai, aj = A.getRowIJ() 867 if ai is not None and aj is not None: ## XXX map and check !! 868 # self.assertTrue(N.all(i==ai)) 869 # self.assertTrue(N.all(j==aj)) 870 pass 871 ai, aj = A.getColumnIJ(compressed=bool(self.BSIZE)) 872 if ai is not None and aj is not None: ## XXX map and check !! 873 # self.assertTrue(N.all(i==ai)) 874 # self.assertTrue(N.all(j==aj)) 875 pass 876 877 878# -- Seq AIJ + Block -- 879 880 881class TestMatSeqAIJ_B(BaseTestMatAIJ_B): 882 COMM = PETSc.COMM_SELF 883 TYPE = PETSc.Mat.Type.SEQAIJ 884 885 886# bs = 1 887class TestMatSeqAIJ_B_G23(TestMatSeqAIJ_B): 888 GRID = 2, 3 889 890 891class TestMatSeqAIJ_B_G45(TestMatSeqAIJ_B): 892 GRID = 4, 5 893 894 895class TestMatSeqAIJ_B_G89(TestMatSeqAIJ_B): 896 GRID = 8, 9 897 898 899# bs = 2 900class TestMatSeqAIJ_B_G23_B2(TestMatSeqAIJ_B_G23): 901 BSIZE = 2 902 903 904class TestMatSeqAIJ_B_G45_B2(TestMatSeqAIJ_B_G45): 905 BSIZE = 2 906 907 908class TestMatSeqAIJ_B_G89_B2(TestMatSeqAIJ_B_G89): 909 BSIZE = 2 910 911 912# bs = 3 913class TestMatSeqAIJ_B_G23_B3(TestMatSeqAIJ_B_G23): 914 BSIZE = 3 915 916 917class TestMatSeqAIJ_B_G45_B3(TestMatSeqAIJ_B_G45): 918 BSIZE = 3 919 920 921class TestMatSeqAIJ_B_G89_B3(TestMatSeqAIJ_B_G89): 922 BSIZE = 3 923 924 925# bs = 4 926class TestMatSeqAIJ_B_G23_B4(TestMatSeqAIJ_B_G23): 927 BSIZE = 4 928 929 930class TestMatSeqAIJ_B_G45_B4(TestMatSeqAIJ_B_G45): 931 BSIZE = 4 932 933 934class TestMatSeqAIJ_B_G89_B4(TestMatSeqAIJ_B_G89): 935 BSIZE = 4 936 937 938# bs = 5 939class TestMatSeqAIJ_B_G23_B5(TestMatSeqAIJ_B_G23): 940 BSIZE = 5 941 942 943class TestMatSeqAIJ_B_G45_B5(TestMatSeqAIJ_B_G45): 944 BSIZE = 5 945 946 947class TestMatSeqAIJ_B_G89_B5(TestMatSeqAIJ_B_G89): 948 BSIZE = 5 949 950 951# -- MPI AIJ + Block -- 952 953 954class TestMatMPIAIJ_B(BaseTestMatAIJ_B): 955 COMM = PETSc.COMM_WORLD 956 TYPE = PETSc.Mat.Type.MPIAIJ 957 958 959# bs = 1 960class TestMatMPIAIJ_B_G23(TestMatMPIAIJ_B): 961 GRID = 2, 3 962 963 964class TestMatMPIAIJ_B_G45(TestMatMPIAIJ_B): 965 GRID = 4, 5 966 967 968class TestMatMPIAIJ_B_G89(TestMatMPIAIJ_B): 969 GRID = 8, 9 970 971 972# bs = 2 973class TestMatMPIAIJ_B_G23_B2(TestMatMPIAIJ_B_G23): 974 BSIZE = 2 975 976 977class TestMatMPIAIJ_B_G45_B2(TestMatMPIAIJ_B_G45): 978 BSIZE = 2 979 980 981class TestMatMPIAIJ_B_G89_B2(TestMatMPIAIJ_B_G89): 982 BSIZE = 2 983 984 985# bs = 3 986class TestMatMPIAIJ_B_G23_B3(TestMatMPIAIJ_B_G23): 987 BSIZE = 3 988 989 990class TestMatMPIAIJ_B_G45_B3(TestMatMPIAIJ_B_G45): 991 BSIZE = 3 992 993 994class TestMatMPIAIJ_B_G89_B3(TestMatMPIAIJ_B_G89): 995 BSIZE = 3 996 997 998# bs = 4 999class TestMatMPIAIJ_B_G23_B4(TestMatMPIAIJ_B_G23): 1000 BSIZE = 4 1001 1002 1003class TestMatMPIAIJ_B_G45_B4(TestMatMPIAIJ_B_G45): 1004 BSIZE = 4 1005 1006 1007class TestMatMPIAIJ_B_G89_B4(TestMatMPIAIJ_B_G89): 1008 BSIZE = 4 1009 1010 1011# bs = 5 1012class TestMatMPIAIJ_B_G23_B5(TestMatMPIAIJ_B_G23): 1013 BSIZE = 5 1014 1015 1016class TestMatMPIAIJ_B_G45_B5(TestMatMPIAIJ_B_G45): 1017 BSIZE = 5 1018 1019 1020class TestMatMPIAIJ_B_G89_B5(TestMatMPIAIJ_B_G89): 1021 BSIZE = 5 1022 1023 1024# -- Non-square blocks -- 1025class BaseTestMatAIJ_B(BaseTestMatAnyAIJ, unittest.TestCase): 1026 COMM = PETSc.COMM_WORLD 1027 TYPE = PETSc.Mat.Type.AIJ 1028 GRID = 0, 0 1029 BSIZE = 4, 2 1030 1031 def _preallocate(self): 1032 try: 1033 rbs, cbs = self.BSIZE 1034 except (TypeError, ValueError): 1035 rbs = cbs = self.BSIZE 1036 self.A.setPreallocationNNZ([5 * rbs, 3 * cbs]) 1037 self._chk_bsizes(self.A, self.BSIZE) 1038 1039 def testSetPreallocNNZ(self): 1040 pass 1041 1042 def testSetPreallocNNZ_2(self): 1043 pass 1044 1045 def testSetPreallocCSR(self): 1046 pass 1047 1048 def testSetPreallocCSR_2(self): 1049 pass 1050 1051 def testSetValues(self): 1052 self._preallocate() 1053 opt = PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR 1054 self.A.setOption(opt, True) 1055 ai, aj, av = self._set_values() 1056 self.A.assemble() 1057 self._chk_aij(self.A, ai, aj) 1058 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 1059 self.A.setOption(opt, True) 1060 ai, aj, av = self._set_values() 1061 self.A.assemble() 1062 self._chk_aij(self.A, ai, aj) 1063 1064 def testSetValuesIJV(self): 1065 self._preallocate() 1066 opt = PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR 1067 self.A.setOption(opt, True) 1068 ai, aj, av = self._set_values_ijv() 1069 self.A.assemble() 1070 self._chk_aij(self.A, ai, aj) 1071 opt = PETSc.Mat.Option.NEW_NONZERO_LOCATION_ERR 1072 self.A.setOption(opt, True) 1073 ai, aj, av = self._set_values_ijv() 1074 self.A.assemble() 1075 self._chk_aij(self.A, ai, aj) 1076 1077 def _chk_aij(self, A, i, j): 1078 ai, aj = A.getRowIJ() 1079 if ai is not None and aj is not None: ## XXX map and check !! 1080 # self.assertTrue(N.all(i==ai)) 1081 # self.assertTrue(N.all(j==aj)) 1082 pass 1083 ai, aj = A.getColumnIJ() 1084 if ai is not None and aj is not None: ## XXX map and check !! 1085 # self.assertTrue(N.all(i==ai)) 1086 # self.assertTrue(N.all(j==aj)) 1087 pass 1088 1089 1090# -- AIJCRL --------------------- 1091 1092 1093class BaseTestMatAIJCRL(BaseTestMatAIJ, unittest.TestCase): 1094 TYPE = PETSc.Mat.Type.AIJCRL 1095 1096 1097# -- Seq AIJCRL -- 1098 1099 1100class TestMatSeqAIJCRL(BaseTestMatAIJCRL): 1101 COMM = PETSc.COMM_SELF 1102 TYPE = PETSc.Mat.Type.SEQAIJCRL 1103 1104 1105class TestMatSeqAIJCRL_G23(TestMatSeqAIJCRL): 1106 GRID = 2, 3 1107 1108 1109class TestMatSeqAIJCRL_G45(TestMatSeqAIJCRL): 1110 GRID = 4, 5 1111 1112 1113class TestMatSeqAIJCRL_G89(TestMatSeqAIJCRL): 1114 GRID = 8, 9 1115 1116 1117# -- MPI AIJCRL -- 1118 1119 1120class TestMatMPIAIJCRL(BaseTestMatAIJCRL): 1121 COMM = PETSc.COMM_WORLD 1122 TYPE = PETSc.Mat.Type.MPIAIJCRL 1123 1124 1125class TestMatMPIAIJCRL_G23(TestMatMPIAIJCRL): 1126 GRID = 2, 3 1127 1128 1129class TestMatMPIAIJCRL_G45(TestMatMPIAIJCRL): 1130 GRID = 4, 5 1131 1132 1133class TestMatMPIAIJCRL_G89(TestMatMPIAIJCRL): 1134 GRID = 8, 9 1135 1136 1137# -- AIJCRL + Block ------------- 1138 1139 1140class BaseTestMatAIJCRL_B(BaseTestMatAIJ_B, unittest.TestCase): 1141 TYPE = PETSc.Mat.Type.AIJCRL 1142 1143 1144# -- Seq AIJCRL + Block -- 1145 1146 1147class TestMatSeqAIJCRL_B(BaseTestMatAIJCRL_B): 1148 COMM = PETSc.COMM_SELF 1149 TYPE = PETSc.Mat.Type.SEQAIJCRL 1150 1151 1152# bs = 1 1153class TestMatSeqAIJCRL_B_G23(TestMatSeqAIJCRL_B): 1154 GRID = 2, 3 1155 1156 1157class TestMatSeqAIJCRL_B_G45(TestMatSeqAIJCRL_B): 1158 GRID = 4, 5 1159 1160 1161class TestMatSeqAIJCRL_B_G89(TestMatSeqAIJCRL_B): 1162 GRID = 8, 9 1163 1164 1165# bs = 2 1166class TestMatSeqAIJCRL_B_G23_B2(TestMatSeqAIJCRL_B_G23): 1167 BSIZE = 2 1168 1169 1170class TestMatSeqAIJCRL_B_G45_B2(TestMatSeqAIJCRL_B_G45): 1171 BSIZE = 2 1172 1173 1174class TestMatSeqAIJCRL_B_G89_B2(TestMatSeqAIJCRL_B_G89): 1175 BSIZE = 2 1176 1177 1178# bs = 3 1179class TestMatSeqAIJCRL_B_G23_B3(TestMatSeqAIJCRL_B_G23): 1180 BSIZE = 3 1181 1182 1183class TestMatSeqAIJCRL_B_G45_B3(TestMatSeqAIJCRL_B_G45): 1184 BSIZE = 3 1185 1186 1187class TestMatSeqAIJCRL_B_G89_B3(TestMatSeqAIJCRL_B_G89): 1188 BSIZE = 3 1189 1190 1191# bs = 4 1192class TestMatSeqAIJCRL_B_G23_B4(TestMatSeqAIJCRL_B_G23): 1193 BSIZE = 4 1194 1195 1196class TestMatSeqAIJCRL_B_G45_B4(TestMatSeqAIJCRL_B_G45): 1197 BSIZE = 4 1198 1199 1200class TestMatSeqAIJCRL_B_G89_B4(TestMatSeqAIJCRL_B_G89): 1201 BSIZE = 4 1202 1203 1204# bs = 5 1205class TestMatSeqAIJCRL_B_G23_B5(TestMatSeqAIJCRL_B_G23): 1206 BSIZE = 5 1207 1208 1209class TestMatSeqAIJCRL_B_G45_B5(TestMatSeqAIJCRL_B_G45): 1210 BSIZE = 5 1211 1212 1213class TestMatSeqAIJCRL_B_G89_B5(TestMatSeqAIJCRL_B_G89): 1214 BSIZE = 5 1215 1216 1217# -- MPI AIJCRL + Block -- 1218 1219 1220class TestMatMPIAIJCRL_B(BaseTestMatAIJCRL_B): 1221 COMM = PETSc.COMM_WORLD 1222 TYPE = PETSc.Mat.Type.MPIAIJCRL 1223 1224 1225# bs = 1 1226class TestMatMPIAIJCRL_B_G23(TestMatMPIAIJCRL_B): 1227 GRID = 2, 3 1228 1229 1230class TestMatMPIAIJCRL_B_G45(TestMatMPIAIJCRL_B): 1231 GRID = 4, 5 1232 1233 1234class TestMatMPIAIJCRL_B_G89(TestMatMPIAIJCRL_B): 1235 GRID = 8, 9 1236 1237 1238# bs = 2 1239class TestMatMPIAIJCRL_B_G23_B2(TestMatMPIAIJCRL_B_G23): 1240 BSIZE = 2 1241 1242 1243class TestMatMPIAIJCRL_B_G45_B2(TestMatMPIAIJCRL_B_G45): 1244 BSIZE = 2 1245 1246 1247class TestMatMPIAIJCRL_B_G89_B2(TestMatMPIAIJCRL_B_G89): 1248 BSIZE = 2 1249 1250 1251# bs = 3 1252class TestMatMPIAIJCRL_B_G23_B3(TestMatMPIAIJCRL_B_G23): 1253 BSIZE = 3 1254 1255 1256class TestMatMPIAIJCRL_B_G45_B3(TestMatMPIAIJCRL_B_G45): 1257 BSIZE = 3 1258 1259 1260class TestMatMPIAIJCRL_B_G89_B3(TestMatMPIAIJCRL_B_G89): 1261 BSIZE = 3 1262 1263 1264# bs = 4 1265class TestMatMPIAIJCRL_B_G23_B4(TestMatMPIAIJCRL_B_G23): 1266 BSIZE = 4 1267 1268 1269class TestMatMPIAIJCRL_B_G45_B4(TestMatMPIAIJCRL_B_G45): 1270 BSIZE = 4 1271 1272 1273class TestMatMPIAIJCRL_B_G89_B4(TestMatMPIAIJCRL_B_G89): 1274 BSIZE = 4 1275 1276 1277# bs = 5 1278class TestMatMPIAIJCRL_B_G23_B5(TestMatMPIAIJCRL_B_G23): 1279 BSIZE = 5 1280 1281 1282class TestMatMPIAIJCRL_B_G45_B5(TestMatMPIAIJCRL_B_G45): 1283 BSIZE = 5 1284 1285 1286class TestMatMPIAIJCRL_B_G89_B5(TestMatMPIAIJCRL_B_G89): 1287 BSIZE = 5 1288 1289 1290# -- MATIS -- 1291 1292 1293class TestMatIS(BaseTestMatAIJ): 1294 COMM = PETSc.COMM_WORLD 1295 TYPE = PETSc.Mat.Type.IS 1296 1297 1298class TestMatIS_G23(TestMatIS): 1299 GRID = 2, 3 1300 1301 1302class TestMatIS_G45(TestMatIS): 1303 GRID = 4, 5 1304 1305 1306class TestMatIS_G89(TestMatIS): 1307 GRID = 8, 9 1308 1309 1310# ----- 1311 1312 1313if __name__ == '__main__': 1314 unittest.main() 1315