CDMATH/tests/swig/mainTests.py

   1 # coding: latin-1
   2
   3 import math
   4 import unittest
   5
   6 from cdmath import *
   7
   8
   9 class TestsCDMATHSwig(unittest.TestCase):
  10
  11     def testClassPoint(self):
  12         P1 = Point(1., 2., 3.)
  13         self.assertTrue(P1.x() == 1.)
  14         self.assertTrue(P1.y() == 2.)
  15         self.assertTrue(P1.z() == 3.)
  16         self.assertTrue(P1[0] == 1.)
  17         self.assertTrue(P1[1] == 2.)
  18         self.assertTrue(P1[2] == 3.)
  19         P2 = Point(1., 2., 3.)
  20         self.assertTrue(14., P1.dot(P2))
  21
  22         P3 = P1 + P2
  23         self.assertTrue(2., P3.x())
  24         self.assertTrue(4., P3.y())
  25         self.assertTrue(6., P3.z())
  26
  27         P5 = Point(1., 2., 3.)
  28         P6 = Point(3., 5., 0.)
  29         P4 = P5 - P6
  30         self.assertTrue(-2., P4.x())
  31         self.assertTrue(-3., P4.y())
  32         self.assertTrue(3., P4.z())
  33
  34         P5 += P6
  35         self.assertTrue(4., P5.x())
  36         self.assertTrue(7., P5.y())
  37         self.assertTrue(3., P5.z())
  38
  39         P7 = Point()
  40         P7[0] = 1.0
  41         P7[1] = 2.0
  42         P7[2] = 3.0
  43         P8 = Point(3., 5., 0.)
  44         P7 -= P8
  45         self.assertTrue(-2., P7.x())
  46         self.assertTrue(-3., P7.y())
  47         self.assertTrue(3., P7.z())
  48
  49         P9 = Point()
  50         P9 = P1 * 3.0
  51         self.assertTrue(3., P9.x())
  52         self.assertTrue(6., P9.y())
  53         self.assertTrue(9., P9.z())
  54
  55         P10 = Point(1., 2., 3.)
  56         P10 *= 3.0
  57         self.assertTrue(3., P10.x())
  58         self.assertTrue(6., P10.y())
  59         self.assertTrue(9., P10.z())
  60
  61         norm = P1.norm()
  62         self.assertTrue(math.sqrt(14.), norm)
  63
  64         P11 = Point(1., 2., 3.)
  65         P12 = Point(4., 5., 6.)
  66         dx = P12.x() - P11.x()
  67         dy = P12.y() - P11.y()
  68         dz = P12.z() - P11.z()
  69         distance = math.sqrt(dx * dx + dy * dy + dz * dz)
  70         self.assertTrue(distance, P11.distance(P12))
  71
  72         P13 = Point(3., 6., 9.)
  73         P14 = Point()
  74         P14 = P13 / 3.0
  75         self.assertTrue(1., P14.x())
  76         self.assertTrue(2., P14.y())
  77         self.assertTrue(3., P14.z())
  78
  79         P15 = Point(3., 6., 9.)
  80         P15 /= 3.0
  81         self.assertTrue(1., P15.x())
  82         self.assertTrue(2., P15.y())
  83         self.assertTrue(3., P15.z())
  84         return
  85
  86     def testClassField(self):
  87         M = Mesh(0.0, 1.0, 10, 0., 1., 5)
  88
  89         conc1 = Field("CONCENTRATION", CELLS, M, 2, 1.2)
  90         self.assertTrue(1.2 == conc1.getTime())
  91         for j in range(conc1.getNumberOfComponents()):
  92             for i in range(conc1.getNumberOfElements()):
  93                 conc1[i, j] = i + j
  94
  95         conc1n = Field("CONCENTRATION", NODES, M, 2, 1.2)
  96         self.assertTrue(1.2 == conc1n.getTime())
  97         for j in range(conc1n.getNumberOfComponents()):
  98             for i in range(conc1n.getNumberOfElements()):
  99                 conc1n[i, j] = i
 100
 101         conc3 = Field("CONCENTRATION", CELLS, M, 2, 1.2)
 102         for j in range(conc3.getNumberOfComponents()):
 103             for i in range(conc3.getNumberOfElements()):
 104                 conc3[i, j] = -(i + j)
 105
 106         v1 = conc3.getValuesOnComponent(1)
 107         v2 = conc3.getValuesOnAllComponents(4)
 108
 109         for i in range(conc3.getNumberOfElements()):
 110             self.assertTrue(-(i + 1) == v1[i])
 111
 112         for j in range(conc3.getNumberOfComponents()):
 113             self.assertTrue(-(4 + j) == v2[j])
 114
 115         fileNameVTK = "champc"
 116         conc1.writeVTK(fileNameVTK)
 117
 118         fileNameMED = "champc"
 119         conc1.writeMED(fileNameMED)
 120         conc1.setTime(2.3, 1)
 121         conc1.writeMED(fileNameMED, False)
 122         for i in range(conc1.getNumberOfElements()):
 123             self.assertTrue(1.0 * i == conc1[i])
 124             pass
 125
 126         self.assertTrue(2 == conc1.getNumberOfComponents())
 127         self.assertTrue(50 == conc1.getNumberOfElements())
 128         self.assertTrue(2.3 == conc1.getTime())
 129
 130         fileNameVTK = "champn"
 131         conc1n.writeVTK(fileNameVTK)
 132
 133         fileNameMED = "champn"
 134         conc1n.writeMED(fileNameMED)
 135         conc1n.setTime(2.3, 1)
 136         conc1n.writeMED(fileNameMED, False)
 137         for i in range(conc1n.getNumberOfElements()):
 138             self.assertTrue(1.0 * i == conc1n[i])
 139             pass
 140
 141         self.assertTrue(2 == conc1n.getNumberOfComponents())
 142         self.assertTrue(66 == conc1n.getNumberOfElements())
 143         self.assertTrue(2.3 == conc1n.getTime())
 144
 145         conc6 = Field("CONCENTRATION", NODES, M, 2)
 146         for i in range(conc6.getNumberOfComponents()):
 147             for j in range(conc6.getNumberOfElements()):
 148                 conc6[j, i] = i * 1.0 + 2. * j
 149                 pass
 150             pass
 151         for i in range(conc6.getNumberOfComponents()):
 152             for j in range(conc6.getNumberOfElements()):
 153                 self.assertTrue(1.0 * i + 2. * j == conc6[j, i])
 154                 self.assertTrue(1.0 * i + 2. * j == conc6.getValues()
 155                                 [i + j * conc6.getNumberOfComponents()])
 156                 pass
 157             pass
 158
 159         conc6 = Field("CONCENTRATION", CELLS, M, 2)
 160         conc6.setInfoOnComponent(0, "compo1")
 161         conc6.setInfoOnComponent(1, "compo2")
 162         self.assertTrue(conc6.getInfoOnComponent(0) == "compo1")
 163         self.assertTrue(conc6.getInfoOnComponent(1) == "compo2")
 164         for i in range(conc6.getNumberOfComponents()):
 165             for j in range(conc6.getNumberOfElements()):
 166                 conc6[j, i] = i * 1.0 + 2. * j
 167                 pass
 168             pass
 169         for i in range(conc6.getNumberOfComponents()):
 170             for j in range(conc6.getNumberOfElements()):
 171                 self.assertTrue(1.0 * i + 2. * j == conc6[j, i])
 172                 self.assertTrue(1.0 * i + 2. * j == conc6.getValues()
 173                                 [i + j * conc6.getNumberOfComponents()])
 174                 pass
 175             pass
 176
 177         self.assertTrue(2 == conc1.getNumberOfComponents())
 178         self.assertTrue(50 == conc1.getNumberOfElements())
 179
 180         conc3 = conc1
 181         for i in range(conc3.getNumberOfElements()):
 182             conc3[i, 0] = i * 1.0
 183             pass
 184
 185         x = conc3[2]
 186         self.assertTrue(x == 2.0)
 187
 188         for i in range(conc3.getNumberOfElements()):
 189             self.assertTrue(1.0 * i == conc3[i])
 190             pass
 191         self.assertTrue(2 == conc3.getNumberOfComponents())
 192         self.assertTrue(50 == conc3.getNumberOfElements())
 193
 194         conc6 = conc3 + conc1
 195         for i in range(conc6.getNumberOfElements()):
 196             self.assertTrue(2.0 * i == conc6[i])
 197             pass
 198         self.assertTrue(2 == conc6.getNumberOfComponents())
 199         self.assertTrue(50 == conc6.getNumberOfElements())
 200
 201         conc6 = conc3 - conc1
 202         for i in range(conc6.getNumberOfElements()):
 203             self.assertTrue(0.0 == conc6[i])
 204             pass
 205         self.assertTrue(2 == conc6.getNumberOfComponents())
 206         self.assertTrue(50 == conc6.getNumberOfElements())
 207
 208         conc6 = conc1
 209         conc6 += conc1
 210         for i in range(conc6.getNumberOfElements()):
 211             self.assertTrue(2.0 * i == conc6[i, 0])
 212             pass
 213         self.assertTrue(2 == conc6.getNumberOfComponents())
 214         self.assertTrue(50 == conc6.getNumberOfElements())
 215
 216         for i in range(conc6.getNumberOfElements()):
 217             conc6[i, 0] = i * 1.0
 218             pass
 219         conc6 *= 2.0
 220         for i in range(conc6.getNumberOfElements()):
 221             self.assertTrue(2.0 * i == conc6[i])
 222         self.assertTrue(2 == conc6.getNumberOfComponents())
 223         self.assertTrue(50 == conc6.getNumberOfElements())
 224
 225 #       conc7=Field("CONCENTRATION",NODES,M,2) ;
 226 #        conc7.setFieldByMEDCouplingFieldDouble(conc1n.getField());
 227 #        conc7.setName("CONC")
 228 #        self.assertTrue( conc7.getName() == "CONC" );
 229 #        for i in range(conc7.getNumberOfElements()):
 230 #            self.assertTrue( conc1n[i] == conc7[i] );
 231 #            pass
 232 #        self.assertTrue( 2 == conc7.getNumberOfComponents() );
 233 #        self.assertTrue( 66 == conc7.getNumberOfElements() );
 234
 235 #        conc7=Field("CONCENTRATION",CELLS,M,2) ;
 236 #        conc7.setFieldByMEDCouplingFieldDouble(conc1.getField());
 237 #        conc7.setName("CONC")
 238 #        self.assertTrue( conc7.getName() == "CONC" );
 239 #        for i in range(conc7.getNumberOfElements()):
 240 #            self.assertTrue( conc1[i] == conc7[i] );
 241 #            pass
 242 #        self.assertTrue( 2 == conc7.getNumberOfComponents() );
 243 #        self.assertTrue( 50 == conc7.getNumberOfElements() );
 244
 245         conc8 = Field("CONCENTRATION", CELLS, M)
 246         for i in range(conc8.getNumberOfElements()):
 247             conc8[i] = i * 1.0
 248             pass
 249         for i in range(conc8.getNumberOfElements()):
 250             self.assertTrue(1.0 * i == conc8[i])
 251             pass
 252         self.assertTrue(1 == conc8.getNumberOfComponents())
 253         self.assertTrue(50 == conc8.getNumberOfElements())
 254
 255         conc8 = Field("CONCENTRATION", NODES, M)
 256         for i in range(conc8.getNumberOfElements()):
 257             conc8[i] = i * 1.0
 258             pass
 259         for i in range(conc8.getNumberOfElements()):
 260             self.assertTrue(1.0 * i == conc8[i])
 261             pass
 262         self.assertTrue(1 == conc8.getNumberOfComponents())
 263         self.assertTrue(66 == conc8.getNumberOfElements())
 264
 265         conc9 = Field("CONCENTRATION", CELLS, M)
 266         for i in range(conc9.getNumberOfElements()):
 267             conc9[i] = i * 1.0
 268             pass
 269         conc9 /= 2.0
 270         for i in range(conc9.getNumberOfElements()):
 271             self.assertTrue(1.0 * i / 2. == conc9[i])
 272             pass
 273
 274         conc10 = conc8
 275         for i in range(conc10.getNumberOfElements()):
 276             conc10[i] = i * 1.0
 277             pass
 278         conc10 -= 2.0
 279         for i in range(conc10.getNumberOfElements()):
 280             self.assertTrue(1.0 * i - 2.0 == conc10[i])
 281
 282         conc11 = conc8
 283         for i in range(conc11.getNumberOfElements()):
 284             conc11[i] = i * 1.0
 285             pass
 286         conc11 += 2.0
 287         for i in range(conc11.getNumberOfElements()):
 288             self.assertTrue(1.0 * i + 2. == conc11[i])
 289
 290         conc12 = conc8
 291         for i in range(conc12.getNumberOfElements()):
 292             conc12[i] = i * 1.0
 293             pass
 294         conc12 += conc8
 295         for i in range(conc12.getNumberOfElements()):
 296             self.assertTrue(2.0 * i == conc12[i])
 297
 298         conc13 = conc8
 299         for i in range(conc13.getNumberOfElements()):
 300             conc13[i] = i * 1.0
 301             pass
 302         conc13 -= conc8
 303         for i in range(conc13.getNumberOfElements()):
 304             self.assertTrue(0.0 == conc13[i])
 305
 306         conc15 = conc1 * 2.
 307         conc16 = conc1 * 0.3
 308
 309         for i in range(conc15.getNumberOfElements()):
 310             self.assertTrue(conc1[i] * 2. == conc15[i])
 311             self.assertTrue(conc1[i] * 0.3 == conc16[i])
 312
 313         MF = Mesh(0.0, 1.0, 3, 0., 1., 3)
 314         concF1 = Field("CONCENTRATION", FACES, MF)
 315         for j in range(concF1.getNumberOfComponents()):
 316             for i in range(concF1.getNumberOfElements()):
 317                 concF1[i, j] = i + j
 318
 319         for j in range(concF1.getNumberOfComponents()):
 320             for i in range(concF1.getNumberOfElements()):
 321                 self.assertTrue(i + j == concF1[i, j])
 322
 323         self.assertTrue(1 == concF1.getNumberOfComponents())
 324         self.assertTrue(0.0 == concF1.getTime())
 325         self.assertTrue(24 == concF1.getNumberOfElements())
 326         return
 327
 328     def testClassCell(self):
 329         P = Point(0.5, 0.5, 0.0)
 330         c1 = Cell(4, 4, 1.0, P)
 331         c1.addNormalVector(0, 0.2, 0.3, 0.0)
 332         self.assertTrue(0.2 == c1.getNormalVector(0, 0))
 333         self.assertTrue(0.3 == c1.getNormalVector(0, 1))
 334         self.assertTrue(0.2 == c1.getNormalVectors()[0])
 335         self.assertTrue(0.3 == c1.getNormalVectors()[1])
 336         c = Cell()
 337         c = c1
 338         self.assertTrue(1.0 == c.getMeasure())
 339         self.assertTrue(4 == c.getNumberOfNodes())
 340         self.assertTrue(4 == c.getNumberOfFaces())
 341         self.assertTrue(0.5 == c.getBarryCenter().x())
 342         self.assertTrue(0.5 == c.getBarryCenter().y())
 343         self.assertTrue(0.0 == c.getBarryCenter().z())
 344         self.assertTrue(0.5 == c.x())
 345         self.assertTrue(0.5 == c.y())
 346         self.assertTrue(0.0 == c.z())
 347         c2 = c1
 348         c2.addNormalVector(1, 0.4, 0.6, 0.0)
 349         self.assertTrue(0.2 == c2.getNormalVector(0, 0))
 350         self.assertTrue(0.3 == c2.getNormalVector(0, 1))
 351         self.assertTrue(0.4 == c2.getNormalVector(1, 0))
 352         self.assertTrue(0.6 == c2.getNormalVector(1, 1))
 353
 354         c2 = c1
 355         c2.addFaceId(0, 10)
 356         c2.addFaceId(1, 11)
 357         c2.addFaceId(2, 12)
 358         c2.addFaceId(3, 13)
 359         c2.addNodeId(0, 20)
 360         c2.addNodeId(1, 21)
 361         c2.addNodeId(2, 22)
 362         c2.addNodeId(3, 23)
 363
 364         self.assertTrue(10 == c2.getFacesId()[0])
 365         self.assertTrue(11 == c2.getFacesId()[1])
 366         self.assertTrue(12 == c2.getFacesId()[2])
 367         self.assertTrue(13 == c2.getFacesId()[3])
 368         self.assertTrue(20 == c2.getNodesId()[0])
 369         self.assertTrue(21 == c2.getNodesId()[1])
 370         self.assertTrue(22 == c2.getNodesId()[2])
 371         self.assertTrue(23 == c2.getNodesId()[3])
 372         return
 373
 374     def testClassNode(self):
 375         P = Point(0.5, 0.5, 0.0)
 376         n1 = Node(4, 4, 3, P)
 377         n = Node()
 378         n = n1
 379         self.assertTrue(4 == n.getNumberOfCells())
 380         self.assertTrue(4, n.getNumberOfFaces())
 381         self.assertTrue(3, n.getNumberOfEdges())
 382         self.assertTrue(0.5 == n.getPoint().x())
 383         self.assertTrue(0.5 == n.getPoint().y())
 384         self.assertTrue(0.0 == n.getPoint().z())
 385         self.assertTrue(0.5 == n.x())
 386         self.assertTrue(0.5 == n.y())
 387         self.assertTrue(0.0 == n.z())
 388         n2 = n1
 389         n2.addFaceId(0, 10)
 390         n2.addFaceId(1, 11)
 391         n2.addFaceId(2, 12)
 392         n2.addFaceId(3, 13)
 393         n2.addCellId(0, 20)
 394         n2.addCellId(1, 21)
 395         n2.addCellId(2, 22)
 396         n2.addCellId(3, 23)
 397
 398         self.assertTrue(10 == n2.getFacesId()[0])
 399         self.assertTrue(11 == n2.getFacesId()[1])
 400         self.assertTrue(12 == n2.getFacesId()[2])
 401         self.assertTrue(13 == n2.getFacesId()[3])
 402         self.assertTrue(20 == n2.getCellsId()[0])
 403         self.assertTrue(21 == n2.getCellsId()[1])
 404         self.assertTrue(22 == n2.getCellsId()[2])
 405         self.assertTrue(23 == n2.getCellsId()[3])
 406         n2 = n
 407         self.assertTrue(0. == n.distance(n2))
 408         return
 409
 410     def testClassFace(self):
 411         p = Point(0, 1, 2)
 412         f1 = Face(2, 2, 1.0, p, 1., 2., 3.)
 413         f = Face()
 414         f = f1
 415         self.assertTrue(1.0 == f.getMeasure())
 416         self.assertTrue(2 == f.getNumberOfNodes())
 417         self.assertTrue(2 == f.getNumberOfCells())
 418         self.assertTrue(p.x() == f.getBarryCenter().x())
 419         self.assertTrue(p.y() == f.getBarryCenter().y())
 420         self.assertTrue(p.z() == f.getBarryCenter().z())
 421         self.assertTrue(p.x() == f.x())
 422         self.assertTrue(p.y() == f.y())
 423         self.assertTrue(p.z() == f.z())
 424         self.assertTrue(-1 == f.getRegion())
 425         self.assertTrue(False == f.isBorder())
 426         f.setGroupName("Bord1")
 427         self.assertTrue(0 == f.getRegion())
 428         self.assertTrue(True == f.isBorder())
 429         self.assertTrue("Bord1" == f.getGroupName())
 430
 431         f2 = f1
 432         f2.addCellId(0, 10)
 433         f2.addCellId(1, 11)
 434         f2.addNodeId(0, 20)
 435         f2.addNodeId(1, 21)
 436
 437         self.assertTrue(10 == f2.getCellsId()[0])
 438         self.assertTrue(11 == f2.getCellsId()[1])
 439         self.assertTrue(20 == f2.getNodesId()[0])
 440         self.assertTrue(21 == f2.getNodesId()[1])
 441
 442         f2 = f
 443         self.assertTrue(1.0 == f2.getMeasure())
 444         self.assertTrue(2 == f2.getNumberOfNodes())
 445         self.assertTrue(2 == f2.getNumberOfCells())
 446         self.assertTrue(0 == f2.getRegion())
 447         self.assertTrue(True == f2.isBorder())
 448         self.assertTrue("Bord1" == f2.getGroupName())
 449         return
 450
 451     def testClassMesh(self):
 452         import os
 453         M1 = Mesh(0.0, 4.0, 4)
 454         self.assertTrue(1 == M1.getSpaceDimension())
 455         self.assertTrue(5 == M1.getNumberOfNodes())
 456         self.assertTrue(4 == M1.getNumberOfCells())
 457         self.assertTrue(5 == M1.getNumberOfFaces())
 458         self.assertTrue(0. == M1.getFace(0).x())
 459         self.assertTrue(0. == M1.getNode(0).x())
 460         self.assertTrue(1. == M1.getFace(1).x())
 461         self.assertTrue(1. == M1.getNode(1).x())
 462         self.assertTrue(2. == M1.getFace(2).x())
 463         self.assertTrue(2. == M1.getNode(2).x())
 464         self.assertTrue(3. == M1.getFace(3).x())
 465         self.assertTrue(3. == M1.getNode(3).x())
 466         self.assertTrue(4. == M1.getFace(4).x())
 467         self.assertTrue(4. == M1.getNode(4).x())
 468         x11 = M1.getCell(1).x()
 469         y11 = M1.getCell(1).y()
 470         self.assertTrue(x11 == 1.5)
 471         self.assertTrue(y11 == 0.0)
 472         M1.setGroupAtFaceByCoords(0., 0., 0., 1.E-14, "LeftEdge")
 473         M1.setGroupAtFaceByCoords(4., 0., 0., 1.E-14, "RightEdge")
 474         M1.setGroupAtNodeByCoords(0., 0., 0., 1.E-14, "LeftEdge")
 475         M1.setGroupAtNodeByCoords(4., 0., 0., 1.E-14, "RightEdge")
 476         self.assertTrue(M1.getFace(0).isBorder() == True)
 477         self.assertTrue(M1.getFace(1).isBorder() == False)
 478         self.assertTrue(M1.getFace(2).isBorder() == False)
 479         self.assertTrue(M1.getFace(3).isBorder() == False)
 480         self.assertTrue(M1.getFace(4).isBorder() == True)
 481         self.assertTrue(len(M1.getNameOfFaceGroups()) ==3)
 482         self.assertTrue(M1.getNameOfFaceGroups()[2] == "RightEdge")
 483         self.assertTrue(M1.getNameOfFaceGroups()[1] == "LeftEdge")
 484         self.assertTrue(M1.getNameOfFaceGroups()[0] == "Boundary")
 485         self.assertTrue(M1.getNameOfNodeGroups()[2] == "RightEdge")
 486         self.assertTrue(M1.getNameOfNodeGroups()[1] == "LeftEdge")
 487         self.assertTrue(M1.getNameOfNodeGroups()[0] == "Boundary")
 488
 489         M1 = Mesh(0.0, 1.0, 4)
 490         self.assertTrue(1 == M1.getSpaceDimension())
 491         self.assertTrue(5 == M1.getNumberOfNodes())
 492         self.assertTrue(4 == M1.getNumberOfCells())
 493         self.assertTrue(5 == M1.getNumberOfFaces())
 494
 495         xinf = 0.0
 496         xsup = 4.0
 497         yinf = 0.0
 498         ysup = 4.0
 499         M2 = Mesh(xinf, xsup, 4, yinf, ysup, 4)
 500
 501         self.assertEqual(4, M2.getNy())
 502         self.assertEqual(4, M2.getNx())
 503         self.assertEqual(2, M2.getSpaceDimension())
 504         self.assertEqual(25, M2.getNumberOfNodes())
 505         self.assertEqual(16, M2.getNumberOfCells())
 506         self.assertEqual(40, M2.getNumberOfFaces())
 507 #        x1=M2.getCells()[4].x();
 508 #        y1=M2.getCells()[4].y();
 509 #        self.assertTrue( x1==0.5 );
 510 #        self.assertTrue( y1==1.5 );
 511
 512 #        x2=M2.getNodes()[24].x();
 513 #        y2=M2.getNodes()[24].y();
 514 #        self.assertTrue( x2==4. );
 515 #        self.assertTrue( y2==4. );
 516         eps = 1.E-10
 517         M2.setGroupAtPlan(xsup, 0, eps, "RightEdge")
 518         M2.setGroupAtPlan(xinf, 0, eps, "LeftEdge")
 519         M2.setGroupAtPlan(yinf, 1, eps, "BottomEdge")
 520         M2.setGroupAtPlan(ysup, 1, eps, "TopEdge")
 521         self.assertTrue(len(M2.getNameOfFaceGroups()) == 5)
 522         self.assertTrue(M2.getNameOfFaceGroups()[0] == "Boundary")
 523         self.assertTrue(M2.getNameOfFaceGroups()[1] == "RightEdge")
 524         self.assertTrue(M2.getNameOfFaceGroups()[2] == "LeftEdge")
 525         self.assertTrue(M2.getNameOfFaceGroups()[3] == "BottomEdge")
 526         self.assertTrue(M2.getNameOfFaceGroups()[4] == "TopEdge")
 527         nbFaces = M2.getNumberOfFaces()
 528         M2.setPeriodicFaces()
 529         indexFaces = M2.getIndexFacePeriodic()
 530         for i in range(nbFaces):
 531             #            x=M2.getFaces()[i].x();
 532             #            y=M2.getFaces()[i].y();
 533             x = M2.getFace(i).x()
 534             y = M2.getFace(i).y()
 535             if (abs(y) < 1.E-10 and abs(x - 0.5) < 1.E-10):
 536                 indexFace = M2.getIndexFacePeriodic(i)
 537                 xi = M2.getFace(indexFace).x()
 538                 yi = M2.getFace(indexFace).y()
 539                 self.assertTrue(xi == x)
 540                 self.assertTrue(yi == ysup)
 541                 self.assertTrue(True == M2.getFace(indexFace).isBorder())
 542                 pass
 543                 pass
 544             pass
 545
 546         M2.writeMED("TestMesh")
 547         M22 = Mesh("TestMesh.med")
 548         self.assertTrue(2 == M22.getSpaceDimension())
 549         self.assertTrue(25 == M22.getNumberOfNodes())
 550         self.assertTrue(16 == M22.getNumberOfCells())
 551         self.assertTrue(40 == M22.getNumberOfFaces())
 552
 553         M23 = Mesh("meshSquare.med")
 554         self.assertTrue(len(M23.getNameOfFaceGroups()) == 5)
 555         print( M23.getNameOfFaceGroups() )
 556         self.assertTrue(M23.getNameOfFaceGroups()[1] == "Bottom")
 557         self.assertTrue(M23.getNameOfFaceGroups()[2] == "Left")
 558         self.assertTrue(M23.getNameOfFaceGroups()[3] == "Right")
 559         self.assertTrue(M23.getNameOfFaceGroups()[4] == "Top")
 560         self.assertTrue(M23.getNameOfFaceGroups()[0] == "Boundary")
 561
 562         M3 = M1
 563         self.assertTrue(1 == M3.getSpaceDimension())
 564         self.assertTrue(5 == M3.getNumberOfNodes())
 565         self.assertTrue(4 == M3.getNumberOfCells())
 566         self.assertTrue(5 == M3.getNumberOfFaces())
 567
 568         M3 = M2
 569         self.assertTrue(2 == M3.getSpaceDimension())
 570         self.assertTrue(25 == M3.getNumberOfNodes())
 571         self.assertTrue(16 == M3.getNumberOfCells())
 572         self.assertTrue(40 == M3.getNumberOfFaces())
 573
 574         M4 = M3
 575         self.assertTrue(2 == M4.getSpaceDimension())
 576         self.assertTrue(25 == M4.getNumberOfNodes())
 577         self.assertTrue(16 == M4.getNumberOfCells())
 578         self.assertTrue(40 == M4.getNumberOfFaces())
 579
 580         M5 = Mesh(0.0, 1.0, 4, 0.0, 1.0, 4, 0.0, 1.0, 4)
 581         self.assertTrue(3 == M5.getSpaceDimension())
 582         fileNameVTK = "TestMesh"
 583         M4.writeVTK(fileNameVTK)
 584         fileNameMED = "TestMesh"
 585         M4.writeMED(fileNameMED)
 586         M6 = Mesh(fileNameMED + ".med")
 587         self.assertTrue(2 == M6.getSpaceDimension())
 588         self.assertTrue(25 == M6.getNumberOfNodes())
 589         self.assertTrue(16 == M6.getNumberOfCells())
 590         self.assertTrue(40 == M6.getNumberOfFaces())
 591         return
 592
 593     def testClassMatrix(self):
 594         A = Matrix(2, 2)
 595         A[0, 0] = 1.
 596         A[0, 1] = 2.
 597         A[1, 0] = 3.
 598         A[1, 1] = 4.
 599
 600         self.assertTrue(1.0, A[0, 0])
 601         self.assertTrue(2.0, A[0, 1])
 602         self.assertTrue(3.0, A[1, 0])
 603         self.assertTrue(4.0, A[1, 1])
 604
 605         self.assertTrue(-2., A.determinant())
 606
 607         A1 = Matrix(2, 2)
 608         A1 = A
 609         self.assertTrue(1.0, A1[0, 0])
 610         self.assertTrue(2.0, A1[0, 1])
 611         self.assertTrue(3.0, A1[1, 0])
 612         self.assertTrue(4.0, A1[1, 1])
 613
 614         A11 = Matrix(2, 2)
 615
 616         A11 = A1 - A
 617
 618         self.assertTrue(0.0 == A11[0, 0])
 619         self.assertTrue(0.0 == A11[0, 1])
 620         self.assertTrue(0.0 == A11[1, 0])
 621         self.assertTrue(0.0 == A11[1, 1])
 622
 623         A11 = A1 + A
 624
 625         self.assertTrue(2.0 == A11[0, 0])
 626         self.assertTrue(4.0 == A11[0, 1])
 627         self.assertTrue(6.0 == A11[1, 0])
 628         self.assertTrue(8.0 == A11[1, 1])
 629
 630         A22 = Matrix(2, 2)
 631         A22 = A * 2
 632
 633         self.assertTrue(2.0 == A22[0, 0])
 634         self.assertTrue(4.0 == A22[0, 1])
 635         self.assertTrue(6.0 == A22[1, 0])
 636         self.assertTrue(8.0 == A22[1, 1])
 637
 638         A22 = A * 3
 639         self.assertTrue(3.0 == A22[0, 0])
 640         self.assertTrue(6.0 == A22[0, 1])
 641         self.assertTrue(9.0 == A22[1, 0])
 642         self.assertTrue(12.0 == A22[1, 1])
 643
 644         A22 = A *0.5
 645         self.assertTrue(0.5 == A22[0, 0])
 646         self.assertTrue(1.0 == A22[0, 1])
 647         self.assertTrue(1.5 == A22[1, 0])
 648         self.assertTrue(2.0 == A22[1, 1])
 649
 650         A2 = Matrix(A1)
 651         A2 *= 2
 652         self.assertTrue(2.0 == A2[0, 0])
 653         self.assertTrue(4.0 == A2[0, 1])
 654         self.assertTrue(6.0 == A2[1, 0])
 655         self.assertTrue(8.0 == A2[1, 1])
 656
 657         A2 /= 2
 658         self.assertTrue(1.0 == A2[0, 0])
 659         self.assertTrue(2.0 == A2[0, 1])
 660         self.assertTrue(3.0 == A2[1, 0])
 661         self.assertTrue(4.0 == A2[1, 1])
 662
 663         A2 -= A
 664         self.assertTrue(0.0 == A2[0, 0])
 665         self.assertTrue(0.0 == A2[0, 1])
 666         self.assertTrue(0.0 == A2[1, 0])
 667         self.assertTrue(0.0 == A2[1, 1])
 668
 669         A2 += A
 670         self.assertTrue(1.0 == A2[0, 0])
 671         self.assertTrue(2.0 == A2[0, 1])
 672         self.assertTrue(3.0 == A2[1, 0])
 673         self.assertTrue(4.0 == A2[1, 1])
 674
 675         X = Vector(2)
 676         X[0] = 1.
 677         X[1] = 2.
 678
 679         X1 = A * X
 680         self.assertTrue(5. == X1[0])
 681         self.assertTrue(11.0 == X1[1])
 682
 683         self.assertTrue(True == A2.isSquare())
 684         self.assertTrue(False == A2.isSymmetric())
 685
 686         A3 = Matrix(2, 3)
 687         A3[0, 0] = 1.
 688         A3[0, 1] = 2.
 689         A3[0, 2] = 2.
 690         A3[1, 0] = 3.
 691         A3[1, 1] = 4.
 692         A3[1, 2] = 4.
 693         self.assertTrue(False == A3.isSquare())
 694
 695         A[0, 0] = 1.
 696         A[0, 1] = -2.
 697         A[1, 0] = -2.
 698         A[1, 1] = 4.
 699         self.assertTrue(True == A.isSymmetric())
 700
 701         A4 = Matrix(4, 4)
 702         A4[0, 0] = 1.
 703         A4[0, 1] = 2.
 704         A4[0, 2] = 3.
 705         A4[0, 3] = 4.
 706         A4[1, 0] = 5.
 707         A4[1, 1] = 6.
 708         A4[1, 2] = 7.
 709         A4[1, 3] = 8.
 710         A4[2, 0] = 9.
 711         A4[2, 1] = 10.
 712         A4[2, 2] = 11.
 713         A4[2, 3] = 12.
 714         A4[3, 0] = 13.
 715         A4[3, 1] = 14.
 716         A4[3, 2] = 15.
 717         A4[3, 3] = 16.
 718         A5 = Matrix(A4.transpose())
 719         self.assertTrue(1. == A5[0, 0])
 720         self.assertTrue(5. == A5[0, 1])
 721         self.assertTrue(9. == A5[0, 2])
 722         self.assertTrue(13. == A5[0, 3])
 723         self.assertTrue(2. == A5[1, 0])
 724         self.assertTrue(6. == A5[1, 1])
 725         self.assertTrue(10. == A5[1, 2])
 726         self.assertTrue(14. == A5[1, 3])
 727         self.assertTrue(3. == A5[2, 0])
 728         self.assertTrue(7. == A5[2, 1])
 729         self.assertTrue(11. == A5[2, 2])
 730         self.assertTrue(15. == A5[2, 3])
 731         self.assertTrue(4. == A5[3, 0])
 732         self.assertTrue(8. == A5[3, 1])
 733         self.assertTrue(12. == A5[3, 2])
 734         self.assertTrue(16. == A5[3, 3])
 735
 736         self.assertTrue(0. == A5.determinant())
 737
 738     def testClassVector(self):
 739         A = Vector(2)
 740         A[0] = 1.
 741         A[1] = 2.
 742         self.assertTrue(1.0 == A[0])
 743         self.assertTrue(2.0 == A[1])
 744         self.assertTrue(math.sqrt(5.) == A.norm())
 745
 746         B = A
 747         self.assertTrue(1.0 == B[0])
 748         self.assertTrue(2.0 == B[1])
 749
 750         C = A + B
 751         self.assertTrue(2.0 == C[0])
 752         self.assertTrue(4.0 == C[1])
 753
 754         val = A * C
 755         self.assertTrue(10.0 == val)
 756
 757         D = A - B
 758         self.assertTrue(0.0 == D[0])
 759         self.assertTrue(0.0 == D[1])
 760
 761         E = A * 2
 762         self.assertTrue(2.0 == E[0])
 763         self.assertTrue(4.0 == E[1])
 764
 765         E *= 0.5
 766         self.assertTrue(1.0 == E[0])
 767         self.assertTrue(2.0 == E[1])
 768
 769         E = A * 2
 770         self.assertTrue(2.0, E[0])
 771         self.assertTrue(4.0, E[1])
 772
 773         F = A * 0.5
 774         self.assertTrue(A[0] / 2 == F[0])
 775         self.assertTrue(A[1] / 2 == F[1])
 776
 777         F *= 2
 778         self.assertTrue(A[0] == F[0])
 779         self.assertTrue(A[1] == F[1])
 780         a = A[0]
 781         self.assertTrue(A[0] == a)
 782
 783 #        v3=Vector(4);
 784 #        v3[0]=1;
 785 #        v3[1]=2;
 786 #        v3[2]=3;
 787 #        v3[3]=4;
 788
 789 #        v4=Vector(3);
 790 #        v4[0]=1.;
 791 #        v4[1]=2.;
 792 #        v4[2]=3.;
 793
 794 #        v5=v3^v4;
 795 #
 796 #         self.assertTrue( 1.==v5[0,0] );
 797 #         self.assertTrue( 2.==v5[0,1] );
 798 #         self.assertTrue( 3.==v5[0,2] );
 799 #         self.assertTrue( 2.==v5[1,0] );
 800 #         self.assertTrue( 4.==v5[1,1] );
 801 #         self.assertTrue( 6.==v5[1,2] );
 802 #         self.assertTrue( 3.==v5[2,0] );
 803 #         self.assertTrue( 6.==v5[2,1] );
 804 #         self.assertTrue( 9.==v5[2,2] );
 805 #         self.assertTrue( 4.==v5[3,0] );
 806 #         self.assertTrue( 8.==v5[3,1] );
 807 #         self.assertTrue( 12.==v5[3,2] );
 808
 809 if __name__ == '__main__':
 810     unittest.main()