X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDCoupling_Swig%2FMEDCouplingBasicsTest.py;h=314850a4980fa2c46f765d5892453b81bd046afe;hb=659f8c67d0348350e12fde38fe8c4de1ff95dffe;hp=739813d1c7793e959aa32d09fa50495d4fcdc507;hpb=242f7a012ce29c935e76bb29cf72f9225909c8b3;p=tools%2Fmedcoupling.git diff --git a/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py b/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py index 739813d1c..314850a49 100644 --- a/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py +++ b/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py @@ -1,10 +1,10 @@ # -*- coding: iso-8859-1 -*- -# Copyright (C) 2007-2013 CEA/DEN, EDF R&D +# Copyright (C) 2007-2014 CEA/DEN, EDF R&D # # This library 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 2.1 of the License. +# version 2.1 of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -123,7 +123,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): self.assertTrue(myCoords.getIJ(3,2)==-0.305) mesh.setCoords(myCoords); mesh.checkCoherency(); - self.assertTrue(mesh.getAllTypes()==[4]) + self.assertTrue(mesh.getAllGeoTypes()==[4]) myFalseConn=DataArrayInt.New() myFalseConn.setValues(tab4,6,4) self.assertTrue(myFalseConn.getIJ(1,1)==3) @@ -385,11 +385,11 @@ class MEDCouplingBasicsTest(unittest.TestCase): subMesh=mesh.buildPartOfMySelf(tab1,True); self.assertTrue(isinstance(subMesh,MEDCouplingUMesh)) name=subMesh.getName(); - self.assertEqual(2,len(mesh.getAllTypes())); - self.assertEqual(NORM_TRI3,mesh.getAllTypes()[0]); - self.assertEqual(NORM_QUAD4,mesh.getAllTypes()[1]); - self.assertEqual(1,len(subMesh.getAllTypes())); - self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]); + self.assertEqual(2,len(mesh.getAllGeoTypes())); + self.assertEqual(NORM_TRI3,mesh.getAllGeoTypes()[0]); + self.assertEqual(NORM_QUAD4,mesh.getAllGeoTypes()[1]); + self.assertEqual(1,len(subMesh.getAllGeoTypes())); + self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]); self.assertEqual(name,"Toto"); self.assertEqual(2,subMesh.getNumberOfCells()); subConn=[4,0,3,4,1,4,7,8,5,4]; @@ -402,9 +402,9 @@ class MEDCouplingBasicsTest(unittest.TestCase): subMesh=mesh.buildPartOfMySelf(tab2[0:3],True); self.assertTrue(isinstance(subMesh,MEDCouplingUMesh)); name=subMesh.getName(); - self.assertEqual(2,len(subMesh.getAllTypes())); - self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]); - self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]); + self.assertEqual(2,len(subMesh.getAllGeoTypes())); + self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]); + self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]); self.assertEqual(name,"Toto"); self.assertEqual(3,subMesh.getNumberOfCells()); subConn2=[4,0,3,4,1,3,4,5,2,4,6,7,4,3] @@ -426,8 +426,8 @@ class MEDCouplingBasicsTest(unittest.TestCase): tab1=[5,7,8,4] subMesh=mesh.buildPartOfMySelfNode(tab1[0:4],True); self.assertTrue(isinstance(subMesh,MEDCouplingUMesh)) - self.assertEqual(1,len(subMesh.getAllTypes())); - self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]); + self.assertEqual(1,len(subMesh.getAllGeoTypes())); + self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]); self.assertEqual(1,subMesh.getNumberOfCells()); self.assertEqual(5,subMesh.getNodalConnectivity().getNbOfElems()); self.assertEqual(2,subMesh.getNodalConnectivityIndex().getNbOfElems()); @@ -442,9 +442,9 @@ class MEDCouplingBasicsTest(unittest.TestCase): subMesh=mesh.buildPartOfMySelfNode(ddd,False); self.assertEqual("ddd",subMesh.getName()) self.assertTrue(isinstance(subMesh,MEDCouplingUMesh)) - self.assertEqual(2,len(subMesh.getAllTypes())); - self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]); - self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]); + self.assertEqual(2,len(subMesh.getAllGeoTypes())); + self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]); + self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]); self.assertEqual(3,subMesh.getNumberOfCells()); self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems()); self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems()); @@ -456,15 +456,15 @@ class MEDCouplingBasicsTest(unittest.TestCase): tab2=[0,3,2,1,4,5,6] subMesh=mesh.buildPartOfMySelfNode(tab2[0:7],True); self.assertTrue(isinstance(subMesh,MEDCouplingUMesh)) - self.assertEqual(2,len(subMesh.getAllTypes())); - self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]); - self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]); + self.assertEqual(2,len(subMesh.getAllGeoTypes())); + self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]); + self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]); self.assertEqual(3,subMesh.getNumberOfCells()); pass def testZipCoords(self): mesh=MEDCouplingDataForTest.build2DTargetMesh_1(); - self.assertEqual(2,len(mesh.getAllTypes())); + self.assertEqual(2,len(mesh.getAllGeoTypes())); self.assertEqual(2,mesh.getSpaceDimension()); self.assertEqual(9,mesh.getNumberOfNodes()); self.assertEqual(5,mesh.getNumberOfCells()); @@ -472,7 +472,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): oldConnIndex=mesh.getNodalConnectivityIndex().getValues()[0:mesh.getNumberOfCells()+1] oldCoords=mesh.getCoords(); mesh.zipCoords(); - self.assertEqual(2,len(mesh.getAllTypes())); + self.assertEqual(2,len(mesh.getAllGeoTypes())); self.assertEqual(2,mesh.getSpaceDimension()); self.assertEqual(9,mesh.getNumberOfNodes()); self.assertEqual(5,mesh.getNumberOfCells()); @@ -486,7 +486,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): traducer=subMesh.zipCoordsTraducer(); expectedTraducer=[0, 1, -1, 2, 3, 4, -1, 5, 6] self.assertEqual(expectedTraducer,list(traducer.getValues())); - self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]); + self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]); self.assertEqual(2,subMesh.getNumberOfCells()); subConn=[4,0,2,3,1,4,5,6,4,3] subConnIndex=[0,5,10] @@ -498,7 +498,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): # subMesh=mesh.buildPartOfMySelf(tab1,False); self.assertTrue(isinstance(subMesh,MEDCouplingUMesh)) - self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]); + self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]); self.assertEqual(2,subMesh.getNumberOfCells()); self.assertEqual(7,subMesh.getNumberOfNodes()); self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems()); @@ -2619,7 +2619,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): def testConvertQuadraticCellsToLinear(self): mesh=MEDCouplingDataForTest.build2DTargetMesh_3(); mesh.checkCoherency(); - types=mesh.getAllTypes(); + types=mesh.getAllGeoTypes(); types.sort() self.assertEqual(5,len(types)); expected1=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8] @@ -2636,7 +2636,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): f2=mesh.getMeasureField(False); self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12)); self.assertEqual(48,mesh.getMeshLength()); - types2=mesh.getAllTypes(); + types2=mesh.getAllGeoTypes(); types2.sort() self.assertEqual(3,len(types2)); expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4] @@ -5195,7 +5195,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): for i in xrange(7): self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10); pass - types=m.getAllTypes(); + types=m.getAllGeoTypes(); self.assertEqual([NORM_TRI3,NORM_POLYGON],types); # m=MEDCouplingDataForTest.build3DSurfTargetMesh_1(); @@ -5207,7 +5207,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): self.assertEqual(expected2[i],da.getIJ(i,0)); pass m.checkCoherency(); - types=m.getAllTypes(); + types=m.getAllGeoTypes(); self.assertEqual([NORM_TRI3,NORM_POLYGON],types); self.assertEqual(7,m.getNumberOfCells()); self.assertEqual(NORM_TRI3,m.getTypeOfCell(0)); @@ -6630,7 +6630,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): self.assertEqual(4,m.getNumberOfCells()); self.assertEqual(3,m.getSpaceDimension()); self.assertEqual(0,m.getMeshDimension()); - types1=m.getAllTypes(); + types1=m.getAllGeoTypes(); self.assertEqual([NORM_POINT1],types1); for i in xrange(4): conn=m.getNodeIdsOfCell(i); @@ -8101,8 +8101,8 @@ class MEDCouplingBasicsTest(unittest.TestCase): self.assertEqual(1,cI.getNbOfElems()); self.assertEqual([0],cI.getValues()) - array12=[0.]*(6*4) - da.setValues(array12,6,4) #bad NumberOfComponents + array12=[0.]*(6*5) + da.setValues(array12,6,5) #bad NumberOfComponents self.assertRaises(InterpKernelException, da.findCommonTuples, 1e-2); pass @@ -8443,6 +8443,24 @@ class MEDCouplingBasicsTest(unittest.TestCase): self.assertEqual(expected4,m12.getNodalConnectivityIndex().getValues()); pass + def testUMeshTessellate2DCurve1(self): + # A quarter of circle: + mcoords = [0.4,0.0, 0.0,-0.4, 0.283,-0.283] + mconnec = [0,1,2] + + m1 = MEDCouplingUMesh.New() + m1.setMeshDimension(1) + m1.allocateCells(1) + m1.insertNextCell(NORM_SEG3, mconnec) + + myCoords = DataArrayDouble.New(mcoords, 3, 2) + m1.setCoords(myCoords) + + m2 = m1.deepCpy() + m2.tessellate2DCurve(0.1) + # If the following raises, the test will fail automatically: + m2.checkCoherency1(0.0) # eps param not used + def testIntersect2DMeshesTmp4(self): m1Coords=[0.,0.,1.,0.,1.5,0.,0.,1.,0.,1.5,-1.,0.,-1.5,0.,0.,-1,0.,-1.5,0.5,0.,1.25,0.,0.70710678118654757,0.70710678118654757,1.0606601717798214,1.0606601717798214,0.,0.5,0.,1.25,-0.70710678118654757,0.70710678118654757,-1.0606601717798214,1.0606601717798214,-0.5,0.,-1.25,0.,-0.70710678118654757,-0.70710678118654757,-1.0606601717798214,-1.0606601717798214,0.,-0.5,0.,-1.25,0.70710678118654757,-0.70710678118654757,1.0606601717798214,-1.0606601717798214]; m1Conn=[0,3,1,13,11,9, 3,4,2,1,14,12,10,11, 5,3,0,15,13,17, 6,4,3,5,16,14,15,18, 5,0,7,17,21,19, 6,5,7,8,18,19,22,20, 0,1,7,9,23,21, 1,2,8,7,10,24,22,23]; @@ -10132,14 +10150,14 @@ class MEDCouplingBasicsTest(unittest.TestCase): def testUMeshSetPartOfMySelf2(self): # resize with explicit ids list m=MEDCouplingDataForTest.build2DTargetMesh_1() - self.assertEqual([3,4],m.getAllTypes()) + self.assertEqual([3,4],m.getAllGeoTypes()) part=m[[0,3,4]] part.simplexize(0) part2=part[[1,2,5]] m[[0,3,4]]=part2 self.assertEqual([3,0,4,1,3,1,4,2,3,4,5,2,3,6,7,4,3,7,5,4],m.getNodalConnectivity().getValues()) self.assertEqual([0,4,8,12,16,20],m.getNodalConnectivityIndex().getValues()) - self.assertEqual([3],m.getAllTypes()) + self.assertEqual([3],m.getAllGeoTypes()) # no resize with explicit ids list m=MEDCouplingDataForTest.build2DTargetMesh_1() part=m[[0,3]] @@ -10147,14 +10165,14 @@ class MEDCouplingBasicsTest(unittest.TestCase): m[[3,4]]=part self.assertEqual([4,0,3,4,1,3,1,4,2,3,4,5,2,5,0,3,4,1,5,6,7,4,3],m.getNodalConnectivity().getValues()) self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues()) - self.assertEqual([3,4,5],m.getAllTypes()) + self.assertEqual([3,4,5],m.getAllGeoTypes()) # resize with range ids m=MEDCouplingDataForTest.build2DTargetMesh_1() part=m[3:] m[1:3]=part self.assertEqual([4,0,3,4,1,4,6,7,4,3,4,7,8,5,4,4,6,7,4,3,4,7,8,5,4],m.getNodalConnectivity().getValues()) self.assertEqual([0,5,10,15,20,25],m.getNodalConnectivityIndex().getValues()) - self.assertEqual([4],m.getAllTypes()) + self.assertEqual([4],m.getAllGeoTypes()) # no resize with range ids m=MEDCouplingDataForTest.build2DTargetMesh_1() part=m[0::3] @@ -10162,7 +10180,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): m[3:]=part self.assertEqual([4,0,3,4,1,3,1,4,2,3,4,5,2,5,0,3,4,1,5,6,7,4,3],m.getNodalConnectivity().getValues()) self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues()) - self.assertEqual([3,4,5],m.getAllTypes()) + self.assertEqual([3,4,5],m.getAllGeoTypes()) # no resize with range ids negative direction m=MEDCouplingDataForTest.build2DTargetMesh_1() part=m[3::-3] @@ -10170,7 +10188,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): m[:-3:-1]=part self.assertEqual([4,0,3,4,1,3,1,4,2,3,4,5,2,5,0,3,4,1,5,6,7,4,3],m.getNodalConnectivity().getValues()) self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues()) - self.assertEqual([3,4,5],m.getAllTypes()) + self.assertEqual([3,4,5],m.getAllGeoTypes()) pass def testUnPolyze3(self): @@ -10190,7 +10208,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): # m.unPolyze(); # - self.assertEqual([NORM_PENTA6],m.getAllTypes()) + self.assertEqual([NORM_PENTA6],m.getAllGeoTypes()) self.assertTrue(DataArrayInt([0,7]).isEqual(m.getNodalConnectivityIndex())) self.assertTrue(DataArrayInt([16,0,2,1,3,5,4]).isEqual(m.getNodalConnectivity())) # @@ -10349,6 +10367,58 @@ class MEDCouplingBasicsTest(unittest.TestCase): self.assertEqual(expected2,d2.getValues()) pass + def testSwig2Intersect2DMeshesQuadra1(self): + import cmath + def createDiagCircle(lX, lY, R, cells=[0,1]): + """ A circle in a square box, cut along the diagonal. + """ + c = [] + for i in range(8): + c.append(cmath.rect(R, i*pi/4)) + + coords = [0.0,0.0, c[3].real,c[3].imag, -lX/2.0, lY/2.0, + 0.0, lY/2.0, lX/2.0,lY/2.0, lX/2.0,0.0, + # 6 7 8 + lX/2.0,-lY/2.0, c[7].real,c[7].imag, c[1].real,c[1].imag, + # 9 10 11 + c[5].real,c[5].imag, -lX/2.0,-lY/2.0, 0.0, -lY/2.0, + # 12 13 14 + -lX/2.0,0.0, 0.0,0.0, 0.0, 0.0] + # Points 13 (reps. 14) are average of points (6,7) (resp (1,2)) + coords[13*2] = 0.5*(coords[6*2]+coords[7*2]) + coords[13*2+1] = 0.5*(coords[6*2+1]+coords[7*2+1]) + coords[14*2] = 0.5*(coords[1*2]+coords[2*2]) + coords[14*2+1] = 0.5*(coords[1*2+1]+coords[2*2+1]) + connec = [1,7,8,0] # half circle up right + connec3 = [6,7,1,2,4,13,8,14,3,5] + + baseMesh = MEDCouplingUMesh.New("box_circle", 2) + baseMesh.allocateCells(2) + meshCoords = DataArrayDouble.New(coords, len(coords)/2, 2) + meshCoords.setInfoOnComponents(["X [au]", "Y [au]"]) + baseMesh.setCoords(meshCoords) + + if 0 in cells: + baseMesh.insertNextCell(NORM_QPOLYG, connec) + if 1 in cells: + baseMesh.insertNextCell(NORM_QPOLYG, connec3) + baseMesh.finishInsertingCells() + baseMesh.checkCoherency() + return baseMesh + + eps = 1.0e-7 + m1 = createDiagCircle(1.0, 1.0, 0.5*0.90, cells=[0,1]) + m2 = createDiagCircle(1.0, 1.0, 0.5*0.95, cells=[0]) + m3, _, _= MEDCouplingUMesh.Intersect2DMeshes(m1, m2, eps) + m3.mergeNodes(eps) + m3.convertDegeneratedCells() + m3.zipCoords() + m4 = m3.deepCpy() + m5, _, _ = MEDCouplingUMesh.Intersect2DMeshes(m3, m4, eps) + m5.mergeNodes(eps) + # Check coordinates: + self.assertTrue(m3.getCoords().isEqual(m5.getCoords(), eps)) + def testDAIBuildUnique1(self): d=DataArrayInt([1,2,2,3,3,3,3,4,5,5,7,7,7,19]) e=d.buildUnique() @@ -11028,9 +11098,13 @@ class MEDCouplingBasicsTest(unittest.TestCase): m=MEDCouplingUMesh("toto",3) m.allocateCells(0) m.insertNextCell(NORM_TETRA4,[0,1,2,3]) + self.assertEqual([NORM_TETRA4],m.getAllGeoTypesSorted()) m.insertNextCell(NORM_HEXA8,[4,5,6,7,8,9,10,11]) + self.assertEqual([NORM_TETRA4,NORM_HEXA8],m.getAllGeoTypesSorted()) m.insertNextCell(NORM_HEXA8,[12,13,14,15,16,17,18,19]) + self.assertEqual([NORM_TETRA4,NORM_HEXA8],m.getAllGeoTypesSorted()) m.insertNextCell(NORM_TETRA4,[20,21,22,23]) + self.assertEqual([NORM_TETRA4,NORM_HEXA8,NORM_TETRA4],m.getAllGeoTypesSorted()) c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3) c2=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0., 0.,0.,1.,0.,1.,1.,1.,1.,1.,1.,0.,1.],8,3) ; c2+=[2.,0.,0.] c3=c2+[2.,0.,0.] @@ -11792,7 +11866,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): def testSwigRepr1(self): d=DataArrayDouble() - self.assertTrue(len(d.__repr__())<100) + self.assertTrue(len(d.__repr__())<120) d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100) for i in xrange(100): d.alloc(i,1) ; d.iota(1.1234567890123456) ; d*=1e123 @@ -11807,7 +11881,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): d.alloc(362880,1) ; d.iota() ; d.rearrange(i) ; self.assertTrue(len(d.__repr__())<500) pass d.alloc(0,9) - self.assertTrue(len(d.__repr__())<100) + self.assertTrue(len(d.__repr__())<120) # d=DataArrayInt() self.assertTrue(len(d.__repr__())<100) @@ -11834,7 +11908,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): d.alloc(2000,16) ; d[:]='1234567890ABCDEF' self.assertTrue(len(d.__repr__())<500) d.alloc(0,16) ; d[:]='1234567890ABCDEF' - self.assertTrue(len(d.__repr__())<100) + self.assertTrue(len(d.__repr__())<120) # d=DataArrayByte() self.assertTrue(len(d.__repr__())<100) @@ -11866,7 +11940,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): m.getNodalConnectivity().setIJ(87,0,21)# put again 21 as at the beginning # self.assertTrue(m.unPolyze()) - self.assertEqual([NORM_HEXGP12],m.getAllTypes()) + self.assertEqual([NORM_HEXGP12],m.getAllGeoTypes()) self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(dReference,1e-12)) m.getNodalConnectivity().setIJ(25,0,24) self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell) @@ -12973,8 +13047,9 @@ class MEDCouplingBasicsTest(unittest.TestCase): cm.setCoords(arr0,arr1,arr1) ; um=cm.buildUnstructured() # m=MEDCoupling1SGTUMesh("m",NORM_QUAD4) + mem_m=m.getHeapMemorySize() m.allocateCells(5) - self.assertIn(m.getHeapMemorySize(),xrange(80,90)) + self.assertIn(m.getHeapMemorySize()-mem_m,xrange(5*4*4,5*4*4+32)) self.assertEqual(m.getNodalConnectivity().getNbOfElemAllocated(),20) m.setCoords(um.getCoords()) m.insertNextCell([1,0,6,7]) @@ -13315,7 +13390,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): self.assertTrue(isinstance(mcpy0,MEDCouplingUMesh)) self.assertTrue(mcpy0.getNodalConnectivity().isEqual(DataArrayInt([31,3,2,8,9,31,1,0,6,7,-1,7,6,1,31,2,1,7,8,-1,2,1,-1,8,-1,7,31,5,4,10,11,-1,11,10,-1,5,31,4,3,9,10,-1,5,3,9]))) self.assertTrue(mcpy0.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,14,26,36,45]))) - self.assertEqual(mcpy0.getAllTypes(),[NORM_POLYHED]) + self.assertEqual(mcpy0.getAllGeoTypes(),[NORM_POLYHED]) mcpy0.checkCoherency() mcpy0.checkCoherency2() mcpy1=mcpy0.convertIntoSingleGeoTypeMesh() @@ -13752,7 +13827,6 @@ class MEDCouplingBasicsTest(unittest.TestCase): self.assertTrue(bbt.computeNbOfInteractionsWith(bbs,1e-12).isEqual(wExp)) pass - def testKrSpatialDiscretization2(self): srcPointCoordsXY=DataArrayDouble([0.8401877171547095,0.39438292681909304,0.7830992237586059,0.7984400334760733,0.9116473579367843,0.19755136929338396,0.335222755714889,0.768229594811904,0.2777747108031878,0.5539699557954305,0.47739705186216025,0.6288709247619244,0.36478447279184334,0.5134009101956155,0.9522297251747128,0.9161950680037007,0.6357117279599009,0.7172969294326831,0.14160255535580338,0.6069688762570586,0.01630057162432958,0.24288677062973696,0.13723157678601872,0.8041767542269904,0.15667908925408455,0.4009443942461835,0.12979044678145574,0.10880880202576929,0.998924518003559,0.21825690531090688,0.5129323944043984,0.8391122346926072,0.6126398325956612,0.29603161769734304,0.6375522677030192,0.5242871900667843,0.493582986990727,0.9727750238835695,0.29251678441302703,0.7713576977939148,0.5267449792133388,0.7699138362751873,0.4002286220901779,0.8915294520051822,0.2833147460051415,0.3524583472648907,0.8077245200088827,0.9190264739650424,0.06975527623191256,0.9493270753646861,0.5259953502221011,0.08605584785624214,0.19221384599442307,0.6632269270081198,0.8902326025488938,0.3488929352485076,0.06417132078864207,0.02002304886468828,0.4577017372742769,0.06309583832653977,0.23827995417559517,0.9706341316786754,0.9022080734848082,0.8509197867712563,0.2666657493760184,0.5397603407221662,0.3752069763723793,0.7602487363667454,0.5125353641400744,0.6677237607854063,0.5316064341606602,0.039280343353413204,0.4376375965949323,0.9318350562508382,0.9308097953585953,0.7209523430657351,0.28429340305006756,0.7385343149018168,0.6399788165651163,0.3540486797476414,0.687861390266503,0.16597416632155615,0.4401045276038835,0.880075236260926,0.829201093329676,0.3303371296871161,0.22896817104377232,0.8933724145839793,0.35036017855180435,0.6866699083180492,0.9564682529105192,0.5886401331930609,0.6573040395310633,0.8586763259296661,0.4395599194986559,0.9239697889070817,0.39843666665183225,0.8147668963366965,0.6842185252738271,0.9109720307919067,0.4824906566564416,0.21582495896882609,0.9502523741453198,0.9201282537170352,0.14766001475400292,0.8810621695039152,0.641080596317109,0.43195341826973177,0.6195964839400707,0.281059412416564,0.7860020980173732,0.3074578737409124,0.44703357920378145,0.22610662515559543,0.18753310953617705,0.27623467206779617,0.5564437553083728,0.4165012805799494,0.16960708618611428,0.9068039338601771,0.10317118843233734,0.1260753390966334,0.49544406658757667,0.7604752284290619,0.9847516650262995,0.9350039865518939,0.6844450168704823,0.3831883312124705,0.7497708824229291,0.36866354167864823,0.2941603620043771,0.2322615386137094,0.5844885006474743,0.24441273568403568,0.15238979186508328,0.7321485158671385,0.12547490472228962,0.7934703881821923,0.164101933671209,0.7450713891280216,0.07452980059875632,0.9501040316885822,0.05252926240327268,0.5215633798025378,0.1762106563785163,0.24006237240511102,0.797798051870334,0.732654411686889,0.6565636529850605,0.9674051385221095,0.6394583455470663,0.7597348418830591,0.09348047715308166,0.13490241166898162,0.5202100698464597,0.07823214171371988,0.06990639775521419,0.2046550862512808,0.4614204733918516,0.8196772801781433,0.5733186283955903,0.7555808353962288,0.05193881879185271,0.1578071285774033,0.9999935710802644,0.204328610656936,0.8899556444445419,0.12546847580255405,0.9977989993047895,0.054057577650089554,0.8705398649305757,0.07232879943788462,0.004161608873010431,0.9230691273338484,0.5938921792404224,0.180372265717188,0.16313149927329806,0.3916902306450951,0.9130266774040771,0.8196951527240198,0.35909536870154335,0.552485022485482,0.5794299941414176,0.452575845854625,0.687387434620125,0.09964006352221597,0.5308079880340062,0.7572938323753392,0.30429514977349675,0.9922284614258579,0.5769711125534824,0.877613778169087,0.7478092963564253,0.6289099313453351,0.03542090674649035,0.7478028669710285,0.8332385420022712,0.9253765511910322,0.8732713427735824,0.8310375408413995],100,2) srcFieldValsOnPoints=DataArrayDouble([0.7643742528498438,-0.023507696856211995,1.1082895131907775,0.6299357452572031,0.8892623544912389,0.72212114810697,0.9196401044320336,-0.759961711221917,0.40801932617748826,0.8441134300809151,0.982483804252809,0.6752368914020778,0.9924403977479798,1.1063334970204484,0.9403055261137516,0.3624481886322733,1.1344772505996308,0.7522965618948239,0.17077741651388564,0.6504551671311436,0.45843479588425423,0.41098905950326753,1.0681420394050904,-0.3483587903820091,0.5620151050607809,1.384969776596035,0.7948875141132845,0.7931192000237167,1.062498042490183,1.3709072529577366,0.44929346605311893,-0.4469683401788374,0.9035857424514101,0.6137249300593463,0.6355610879026966,1.4318174829507697,0.3097567072129551,-0.20515052260807165,0.6922559820922779,1.0341638749443423,1.3072652153341024,0.38511367353000436,0.9160514929274943,0.54513408530581,0.722252267913328,0.06684522818576251,0.10571899758067793,0.3193844999960903,0.5213532270828706,-0.04834998649603944,1.2408805068350615,-0.7632951295676795,0.5980054665011202,0.9064738717547436,1.1541070755096696,1.008234260272265,1.2225806960553827,1.0788560195121106,0.9818990282104452,0.5621951325841853,1.0796757508374188,0.5082872315589883,-0.9153702001062469,0.9560418838920791,0.9251098559152824,1.1603063610984021,1.2122303611181837,0.7379539363312343,0.6877611899207183,0.723966552446608,0.5596025827162566,0.8849725005989729,1.0908363665075547,0.08956512916455672,-0.10247645571248344,0.3236718069555875,1.069478546398975,1.3900071080692746,1.0322398863403262,0.45315515354558034,0.4249870238786733,1.030226761858634,0.974024629584669,1.2838885424020365,1.3451943506525155,1.4029933267831995,0.6025539675442462,1.2947650597767038,1.0006061239483002,-0.4017336259949164,0.8771165113201297,0.9158909024218246,1.403798605551443,0.4742904006425974,0.3671787905896653,0.20646491720419674,0.40739337434288925,0.7341932402033597,-0.4295893651836911,-0.3187777570661546],100,1) @@ -13783,12 +13857,362 @@ class MEDCouplingBasicsTest(unittest.TestCase): coeffs,isDrift=fd.computeVectorOfCoefficients(mesh,srcFieldValsOnPoints) self.assertEqual(3,isDrift) self.assertTrue(coeffsExpected.isEqual(coeffs,1e-8)) + # testing matrix + pts3=[-0.5,-0.5,-0.5,-0.35,-0.35,-0.2] + mesh.setCoords(srcPointCoordsXY[:4]) + m,nbCols=fd.computeEvaluationMatrixOnGivenPts(mesh,pts3) + self.assertTrue(m.isEqual(DataArrayDouble([0.05768877688524917,-4.438982030395039,1.9495386255911573,3.431754627918642,0.11803848510231275,-4.138339658420563,1.6630742187104417,3.357226954607818,0.14630203028580618,-3.5156045565871734,1.414680070737206,2.954622455564169]),1e-12)) + if MEDCouplingHasNumPyBindings(): + import numpy as np + m0=m.toNumPyArray() ; m0=m0.reshape(3,nbCols) ; m0=np.matrix(m0) + srcFieldValsOnPoints2=DataArrayDouble(4,2) ; srcFieldValsOnPoints2[:,0]=srcFieldValsOnPoints[:4] ; srcFieldValsOnPoints2[:,1]=2*srcFieldValsOnPoints[:4] + n0=srcFieldValsOnPoints2.toNumPyArray() ; n0=n0.reshape(4,2) ; n0=np.matrix(n0) + # + f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME) ; f.setMesh(mesh) ; f.setArray(srcFieldValsOnPoints2) ; f.checkCoherency() + self.assertTrue(DataArrayDouble(np.array((m0*n0))).isEqual(f.getValueOnMulti(pts3),1e-14)) + pass + # + pass + + # test the when input slice is all the same object is return by MEDCouplingMesh.buildPartRange + def testSwig2MeshPartSlice1(self): + a=DataArrayDouble(4) ; a.iota() + c=MEDCouplingCMesh() ; c.setCoords(a,a) ; m=c.buildUnstructured() + fc0=c.getMeasureField(False) ; fc1=fc0[:] ; fc2=fc0*fc1 ; fc2.setName(fc0.getName()) + self.assertEqual(fc0.getMesh().getHiddenCppPointer(),fc1.getMesh().getHiddenCppPointer()) + self.assertEqual(fc2.getMesh().getHiddenCppPointer(),fc1.getMesh().getHiddenCppPointer()) + self.assertTrue(fc2.isEqual(fc1,1e-12,1e-12)) + # + fm0=m.getMeasureField(False) ; fm1=fm0[:] ; fm2=fm0*fm1 ; fm2.setName(fm0.getName()) + self.assertEqual(fm0.getMesh().getHiddenCppPointer(),fm1.getMesh().getHiddenCppPointer()) + self.assertEqual(fm2.getMesh().getHiddenCppPointer(),fm1.getMesh().getHiddenCppPointer()) + self.assertTrue(fm2.isEqual(fm1,1e-12,1e-12)) + pass + + # test the correct behaviour when attempting to aggregate two fields whose mesh is null + def testSwig2MergeFieldsOnFieldsHavingNoMesh(self): + a=DataArrayDouble(4) ; a.iota() ; a*=1.5 + c=MEDCouplingCMesh() ; c.setCoords(a,a) ; f1=c.getMeasureField(False) + f1.setMesh(None) ; f2=f1.deepCpy() ; f2*=2 + f3=MEDCouplingFieldDouble.MergeFields(f1,f2) + daExp=DataArrayDouble([2.25,2.25,2.25,2.25,2.25,2.25,2.25,2.25,2.25,4.5,4.5,4.5,4.5,4.5,4.5,4.5,4.5,4.5]) + self.assertTrue(f3.getArray().isEqual(daExp,1e-12)) + self.assertEqual(f3.getTypeOfField(),ON_CELLS) + self.assertEqual(f3.getMesh(),None) + f4=MEDCouplingFieldDouble.MergeFields([f1,f2]) + self.assertTrue(f4.getArray().isEqual(daExp,1e-12)) + self.assertEqual(f4.getTypeOfField(),ON_CELLS) + self.assertEqual(f4.getMesh(),None) + pass + + # test a simple node to cell convertion of a field + def testSwig2NodeToCellDiscretization1(self): + f=MEDCouplingFieldDouble(ON_NODES) ; f.setTime(1.1,2,3) + a1=DataArrayDouble(4) ; a1.iota() + a2=DataArrayDouble(3) ; a2.iota() + m=MEDCouplingCMesh() ; m.setCoords(a1,a2) + f.setMesh(m) + arr=DataArrayDouble([21.,121.,20.,120.,19.,119.,18.,118.,17.,117.,16.,116.,15.,115.,14.,114.,13.,113.,12.,112.,11.,111.,10.,110.],12,2) ; arr.setInfoOnComponents(["aa [km]","bbb [kJ]"]) + f.setArray(arr) ; f.setName("toto") + # + f2=f.nodeToCellDiscretization() + self.assertEqual(ON_CELLS,f2.getTypeOfField()) + self.assertEqual("toto",f2.getName()) + self.assertEqual([1.1,2,3],f2.getTime()) + self.assertEqual(["aa [km]","bbb [kJ]"],f2.getArray().getInfoOnComponents()) + self.assertEqual(6,f2.getArray().getNumberOfTuples()) + self.assertEqual(f.getMesh().getHiddenCppPointer(),f2.getMesh().getHiddenCppPointer()) + exp=DataArrayDouble([18.5,118.5,17.5,117.5,16.5,116.5,14.5,114.5,13.5,113.5,12.5,112.5],6,2) ; exp.setInfoOnComponents(["aa [km]","bbb [kJ]"]) + self.assertTrue(f2.getArray().isEqual(exp,1e-13)) + pass + + def testSwig2NonRegressionBugIntersectMeshes1(self): + src=MEDCouplingUMesh("src",2) + src.setCoords(DataArrayDouble([-2.5,-3,-2.5,3,2.5,3],3,2)) + src.allocateCells() + src.insertNextCell(NORM_TRI3,[0,1,2]) + # + trg=MEDCouplingUMesh("trg",2) + trg.setCoords(DataArrayDouble([-2.5,-3.,0.,-3.,0.,-2.,-2.,0.,-2.25,0.,-2.5,0.,-2.5,-1.5,0.,-2.5,-1.25,-3.,-1.414213562373095,-1.414213562373095],10,2)) + trg.allocateCells() + trg.insertNextCell(NORM_QPOLYG,[2,1,0,5,3,7,8,6,4,9]) + # + a,b,c=MEDCouplingUMesh.Intersect2DMeshes(src,trg,1.0e-8) + a.mergeNodes(1e-8) + self.assertTrue(a.getCoords().isEqual(DataArrayDouble([-2.5,-3.,-2.5,3.,2.5,3.,0.,-3.,0.,-2.,-2.,0.,-2.25,0.,-2.5,0.,-2.5,-1.5,0.,-2.5,-1.25,-3.,-1.414213562373095,-1.414213562373095,-1.2803687993289596,-1.5364425591947515,-1.8901843996644798,-2.2682212795973755,-1.81117884244736,-0.8483107924994473,-2.5,1.5,0.,3.,0.6098156003355202,0.7317787204026243],18,2),1e-12)) + self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([32,12,0,7,5,13,8,6,14,32,7,1,2,12,5,15,16,17,14,6]))) + self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,9,20]))) + self.assertTrue(b.isEqual(DataArrayInt([0,0]))) + self.assertTrue(c.isEqual(DataArrayInt([0,-1]))) + pass + + def testSwig2MeshOrientCorrectly2DCells1(self): + m=MEDCouplingUMesh("mesh",2) + coo=DataArrayDouble([1.,0.,0.5,-0.1,0.,1.,0.,0.,0.07,0.5,0.59,0.5],6,2) + m.setCoords(coo) + m.allocateCells() + m.insertNextCell(NORM_TRI6,[3,0,2,1,5,4]) + m.insertNextCell(NORM_QPOLYG,[3,0,2,1,5,4]) + self.assertTrue(DataArrayDouble([-0.58093333350930543,-0.58093333350930543]).isEqual(m.getMeasureField(False).getArray(),1e-12)) + m.changeSpaceDimension(3) + m.orientCorrectly2DCells([0.,0.,-1.],False) + # + m.checkCoherency() + self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([6,3,2,0,4,5,1, 32,3,2,0,4,5,1]))) + self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,7,14]))) + m.changeSpaceDimension(2) + self.assertTrue(DataArrayDouble([0.58093333350930543,0.58093333350930543]).isEqual(m.getMeasureField(False).getArray(),1e-12)) + pass + + def testSwig2Hexa8HavingFacesWarped1(self): + """ This test is bases on a "error" of interpolation detected. After investigation cell #3 of src is warped that leads to the fact that when trg is + intersected with src the sum of intersection volume is greater than the volume of the trg cell. + A test that can be done is to split the cell #3 of src into tetrohedrons and by summing all the volumes it does not fit the volume computed of cell#3 unsplitted (expect for + GENERAL_24). + """ + srcCoo=DataArrayDouble([0.15694071546650565,0.09383333333333337,6.920842121738133,0.15774332475430292,0.185486666666667,6.920682472824616,0.1585459340420992,0.27713999999999994,6.9205228239111,0.07427195882345167,0.05782666666666668,6.937285959830335,0.06343673343819695,0.11347333333333297,6.939441220162809,0.05260150805294228,0.16911999999999996,6.941596480495282,0.014076262238703396,0.04800666666666667,6.949259628344076,0.014076262238703396,0.07092000000000007,6.949259628344076,0.15407499632681992,0.09383333333333338,6.897607484780063,0.15489234394181514,0.18548666666666702,6.897567331066572,0.15570969155680933,0.27714,6.897527177353081,0.06988819198237989,0.05782666666666669,6.901743317269663,0.05885399917995321,0.11347333333333298,6.9022853924017955,0.047819806377526586,0.16912,6.902827467533927,0.0085871208577874,0.048006666666666684,6.9047548457815076,0.0085871208577874,0.07092000000000008,6.9047548457815076,0.153883333333333,0.09383333333333338,6.820902,0.154701666666667,0.18548666666666702,6.820902,0.15551999999999996,0.27714,6.820902,0.06959499999999999,0.05782666666666669,6.820902,0.058547499999999975,0.11347333333333298,6.820902,0.04749999999999999,0.16912,6.820902],22,3) + src=MEDCouplingUMesh("TBmesh3D",3) ; src.setCoords(srcCoo) + src.allocateCells() + src.insertNextCell(NORM_HEXA8,[0,1,4,3,8,9,12,11]) + src.insertNextCell(NORM_HEXA8,[1,2,5,4,9,10,13,12]) + src.insertNextCell(NORM_HEXA8,[4,5,7,6,12,13,15,14]) + src.insertNextCell(NORM_HEXA8,[8,9,12,11,16,17,20,19]) + src.insertNextCell(NORM_HEXA8,[9,10,13,12,17,18,21,20]) + src.checkCoherency2() + # trg is useless here but I keep it in case of MEDCouplingRemapper were expected to do something about warped NORM_HEXA8 + trgCoo=DataArrayDouble([0.0960891897852753,0.105088620541845,6.8598,0.0599574480546212,0.118434267436059,6.8598,0.113514510609589,0.14874473653263,6.8598,0.0831322609794463,0.167319109733883,6.8598,0.0960891897852753,0.105088620541845,6.92146666666667,0.0599574480546212,0.118434267436059,6.92146666666667,0.113514510609589,0.14874473653263,6.92146666666667,0.0831322609794463,0.167319109733883,6.92146666666667],8,3) + trg=MEDCouplingUMesh("MESH",3) ; trg.setCoords(trgCoo) + trg.allocateCells() + trg.insertNextCell(NORM_HEXA8,[0,1,3,2,4,5,7,6]) + # + srcFace=src.buildDescendingConnectivity()[0] + conn=MEDCoupling1SGTUMesh(srcFace).getNodalConnectivity() ; conn.rearrange(4) + eqFaces=srcFace.computePlaneEquationOf3DFaces() + nodeIdInCell=3 + e=(srcFace.getCoords()[conn[:,nodeIdInCell]]*eqFaces[:,:-1]).sumPerTuple()+eqFaces[:,3]# e represent the error between the expected 'a*X+b*Y+c*Z+d' in eqFaces and 0. Closer e to 0. is closer the 4th point is to the plane built with the 3 first points + lambd=-e/(eqFaces[:,:3]**2).sumPerTuple() + pts=lambd*eqFaces[:,:-1]+srcFace.getCoords()[conn[:,nodeIdInCell]]#pts represent the projection of the last points of each NORM_QUAD4 to the plane defined by the 3 first points of the NORM_QUAD4 cell + shouldBeZero=(pts*eqFaces[:,:-1]).sumPerTuple()+eqFaces[:,3]# this line is useless only to be sure that pts are on the plane. + check=(pts-srcFace.getCoords()[conn[:,nodeIdInCell]]).magnitude() # check contains the distance of the last point to its plane + idsToTest=check.getIdsNotInRange(0.,1e-10) + self.assertTrue(idsToTest.isEqual(DataArrayInt([17,18,19,20,22,23,24]))) + idsToTest2=idsToTest.getIdsNotInRange(18,22) + self.assertTrue(idsToTest2.isEqual(DataArrayInt([0,4,5,6]))) + idsToTest2.rearrange(2) + self.assertTrue(idsToTest2.sumPerTuple().isEqual(DataArrayInt([4,11]))) + pass + + def testSwig2SortHexa8EachOther1(self): + """ + testing MEDCoupling1SGTUMesh.sortHexa8EachOther method + """ + coords1=DataArrayDouble([(-0.5,0.5,-0.5),(0.5,-0.5,-0.5),(-0.5,-0.5,0.5),(-0.5,-0.5,-0.5),(0.5,-0.5,0.5),(-0.5,0.5,0.5),(0.5,0.5,0.5),(0.5,0.5,-0.5)]) + m1=MEDCouplingUMesh("m1",3) ; m1.setCoords(coords1) + m1.allocateCells() ; m1.insertNextCell(NORM_HEXA8,[7,1,3,0,6,4,2,5]) + m1.checkCoherency() + # + m2=m1.deepCpy() ; m2.setName("m2") + # + trs=[[0.,0.,-1.],[0.,0.,1.],[1.,0.,0.],[0.,-1.,0.],[-1.,0.,0.],[0.,1.,0.]] + for i,t in enumerate(trs): + for j in xrange(64): + j2=(j//16) ; j1=((j%16)//4) ; j0=(j%4) + m11=m1.deepCpy() + m11.rotate([0.,0.,0.],[0.,0.,1.],float(j0)*pi/2) + m11.rotate([0.,0.,0.],[0.,1.,0.],float(j1)*pi/2) + m11.rotate([0.,0.,0.],[1.,0.,0.],float(j2)*pi/2) + m11.translate(t) + # + m=MEDCouplingUMesh.MergeUMeshes(m2,m11) + m.mergeNodes(1e-12) + self.assertEqual(12,m.getNumberOfNodes()) + m=MEDCoupling1SGTUMesh(m) + m.sortHexa8EachOther() + tmp0=m.buildUnstructured().tetrahedrize(PLANAR_FACE_6)[0].buildUnstructured() + self.assertEqual(20,tmp0.computeSkin().getNumberOfCells()) + pass + pass + pass + + def testSwig2normMinComputeAbs1(self): + d=DataArrayDouble([4,-5,2,6.1,-7.33,1,-1,3e2,0.07,-0.009,-6,-1e30],4,3) + d.setInfoOnComponents(["XX [m]","YYY [km]","ABSJJ [MW]"]) + d0=d.computeAbs() + dExp=d.deepCpy() ; dExp.abs() + self.assertTrue(dExp.isEqual(d0,1e-12)) + e=d0-DataArrayDouble([4,5,2,6.1,7.33,1,1,3e2,0.07,0.009,6,1e30],4,3) + self.assertAlmostEqual(0.,e.normMin(),13) + self.assertAlmostEqual(0.009,d.normMin(),13) # + di=DataArrayInt([3,-12,5,6,14,16,-23,100,23,-1,0,-6],4,3) + di.setInfoOnComponents(["XX [m]","YYY [km]","ABSJJ [MW]"]) + d0i=di.computeAbs() + diExp=di.deepCpy() ; diExp.abs() + self.assertTrue(diExp.isEqual(d0i)) + self.assertEqual([3,12,5,6,14,16,23,100,23,1,0,6],d0i.getValues()) pass + + def testSwig2GetCellsContainingPointsForNonConvexPolygon1(self): + coo=DataArrayDouble([-0.5,-0.5,-0.5,0.5,0.5,0.5,0.5,-0.5,0.,-0.5,0.,0.,0.5,0.,],7,2) + m=MEDCouplingUMesh("Intersect2D",2) ; m.setCoords(coo) ; m.allocateCells() + m.insertNextCell(NORM_POLYGON,[6,3,4,5]) + m.insertNextCell(NORM_POLYGON,[4,0,1,2,6,5]) + m.checkCoherency2() + # + self.assertTrue(m.getCellsContainingPoint((0.4,-0.4),1e-12).isEqual(DataArrayInt([0]))) + self.assertTrue(m.getCellsContainingPoint((-0.4,-0.4),1e-12).isEqual(DataArrayInt([1]))) + self.assertTrue(m.getCellsContainingPoint((0.,-0.4),1e-12).isEqual(DataArrayInt([0,1]))) + pass + + def testSwig2GetCellsContainingPointsForNonConvexPolygon2(self): + coo=DataArrayDouble([-0.5,-0.5,-0.5,0.5,0.5,0.5,0.5,-0.5,-2.0816681711721685e-17,-2.0816681711721685e-17,-0.17677669529663687,0.1767766952966369,0.,0.5,0.5,0.,0.17677669529663684,-0.17677669529663692,0.17677669529663692,0.17677669529663684,-0.17677669529663692,-0.17677669529663687,0.,-0.5,-0.5,0.,0.33838834764831843,-0.3383883476483185,-0.33838834764831843,0.33838834764831843,-0.21213203435596423,0.21213203435596426,0.2121320343559642,-0.2121320343559643,0.21213203435596426,0.2121320343559642,-0.21213203435596423,-0.21213203435596428,0.3560660171779821,-0.35606601717798214,-0.35606601717798214,0.35606601717798214,0.19445436482630052,-0.19445436482630063,-0.19445436482630055,0.19445436482630057,0.,0.27],24,2) + m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo) ; m.allocateCells() + m.insertNextCell(NORM_QPOLYG,[8,5,4,9]) + m.insertNextCell(NORM_QPOLYG,[5,8,4,10]) + m.insertNextCell(NORM_QPOLYG,[16,8,5,15,21,9,22,17]) + m.insertNextCell(NORM_QPOLYG,[15,1,2,3,16,20,6,7,19,17]) + m.insertNextCell(NORM_QPOLYG,[15,5,8,16,22,10,21,18]) + m.insertNextCell(NORM_QPOLYG,[16,3,0,1,15,19,11,12,20,18]) + m.checkCoherency2() + self.assertTrue(m.getCellsContainingPoint([0.,0.27],1e-12).isEqual(DataArrayInt([2]))) + pass + + def testSwig2DAIGetIdsEqualTuple1(self): + da=DataArrayInt([0,7,1,2,4,1,2,1,1,2,0,1,2,1,5,1,1,2],9,2) + self.assertTrue(da.getIdsEqualTuple([1,2]).isEqual(DataArrayInt([1,4,8]))) + self.assertTrue(da.getIdsEqualTuple((1,2)).isEqual(DataArrayInt([1,4,8]))) + self.assertTrue(da.getIdsEqualTuple(DataArrayInt([1,2])).isEqual(DataArrayInt([1,4,8]))) + da.rearrange(3) + self.assertRaises(InterpKernelException,da.getIdsEqualTuple,[1,2])# mismatch nb of compo (3) and nb of elts in input tuple (2) + self.assertTrue(da.getIdsEqualTuple([2,0,1]).isEqual(DataArrayInt([3]))) + self.assertTrue(da.getIdsEqualTuple([2,0,7]).isEqual(DataArrayInt([]))) + da.rearrange(1) + self.assertTrue(da.getIdsEqualTuple(2).isEqual(DataArrayInt([3,6,9,12,17]))) + self.assertTrue(da.getIdsEqualTuple(2).isEqual(da.getIdsEqual(2))) + pass + + def testSwig2GaussNEStaticInfo1(self): + self.assertTrue(DataArrayDouble(MEDCouplingFieldDiscretizationGaussNE.GetWeightArrayFromGeometricType(NORM_TRI3)).isEqual(DataArrayDouble([0.16666666666666666,0.16666666666666666,0.16666666666666666]),1e-12)) + self.assertTrue(DataArrayDouble(MEDCouplingFieldDiscretizationGaussNE.GetRefCoordsFromGeometricType(NORM_TRI3)).isEqual(DataArrayDouble([0.,0.,1.,0.,0.,1.]),1e-12)) + self.assertTrue(DataArrayDouble(MEDCouplingFieldDiscretizationGaussNE.GetLocsFromGeometricType(NORM_TRI3)).isEqual(DataArrayDouble([0.16666666666666666,0.16666666666666666,0.6666666666666667,0.16666666666666666,0.16666666666666666,0.6666666666666667]),1e-12)) + pass + + def testSwigReverseNodalConnOnStructuredMesh(self): + # 1D - standard + c=MEDCouplingCMesh() ; arr=DataArrayDouble(10) ; arr.iota() + c.setCoordsAt(0,arr) + rn,rni=c.getReverseNodalConnectivity() + rn2,rni2=c.buildUnstructured().getReverseNodalConnectivity() + self.assertTrue(rn.isEqual(DataArrayInt([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8]))) + self.assertTrue(rni.isEqual(DataArrayInt([0,1,3,5,7,9,11,13,15,17,18]))) + self.assertTrue(rn.isEqual(rn2)) ; self.assertTrue(rni.isEqual(rni2)) + # 1D - limit + c=MEDCouplingCMesh() ; arr=DataArrayDouble(1) ; arr.iota() + c.setCoordsAt(0,arr) + rn,rni=c.getReverseNodalConnectivity() + rn2,rni2=c.buildUnstructured().getReverseNodalConnectivity() + self.assertTrue(rn.isEqual(DataArrayInt([0]))) + self.assertTrue(rni.isEqual(DataArrayInt([0,1]))) + self.assertTrue(rn.isEqual(rn2)) ; self.assertTrue(rni.isEqual(rni2)) + # 1D - limit + c=MEDCouplingCMesh() ; arr=DataArrayDouble(0) ; arr.iota() + c.setCoordsAt(0,arr) + rn,rni=c.getReverseNodalConnectivity() + rn.isEqual(DataArrayInt([])) + rni.isEqual(DataArrayInt([0])) + # 2D - standard + c=MEDCouplingCMesh() ; arr=DataArrayDouble(5) ; arr.iota() ; arr2=DataArrayDouble(4) ; arr.iota() + c.setCoords(arr,arr2) + rn,rni=c.getReverseNodalConnectivity() + rn2,rni2=c.buildUnstructured().getReverseNodalConnectivity() + self.assertTrue(rn.isEqual(DataArrayInt([0,0,1,1,2,2,3,3,0,4,0,1,4,5,1,2,5,6,2,3,6,7,3,7,4,8,4,5,8,9,5,6,9,10,6,7,10,11,7,11,8,8,9,9,10,10,11,11]))) + self.assertTrue(rni.isEqual(DataArrayInt([0,1,3,5,7,8,10,14,18,22,24,26,30,34,38,40,41,43,45,47,48]))) + self.assertTrue(rn.isEqual(rn2)) ; self.assertTrue(rni.isEqual(rni2)) + # 2D - limit + c=MEDCouplingCMesh() ; arr=DataArrayDouble(10) ; arr.iota() ; arr2=DataArrayDouble(1) ; arr.iota() + c.setCoords(arr,arr2) + rn,rni=c.getReverseNodalConnectivity() + self.assertTrue(rn.isEqual(DataArrayInt([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8]))) + self.assertTrue(rni.isEqual(DataArrayInt([0,1,3,5,7,9,11,13,15,17,18]))) + # 2D - limit + c=MEDCouplingCMesh() ; arr=DataArrayDouble(10) ; arr.iota() ; arr2=DataArrayDouble(1) ; arr.iota() + c.setCoords(arr2,arr) + rn,rni=c.getReverseNodalConnectivity() + self.assertTrue(rn.isEqual(DataArrayInt([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8]))) + self.assertTrue(rni.isEqual(DataArrayInt([0,1,3,5,7,9,11,13,15,17,18]))) + # 3D - standard + c=MEDCouplingCMesh() ; arr0=DataArrayDouble(5) ; arr0.iota() ; arr1=DataArrayDouble(3) ; arr1.iota() ; arr2=DataArrayDouble(4) ; arr2.iota() + c.setCoords(arr0,arr1,arr2) + rn,rni=c.getReverseNodalConnectivity() + self.assertTrue(rn.isEqual(DataArrayInt([0,0,1,1,2,2,3,3,0,4,0,1,4,5,1,2,5,6,2,3,6,7,3,7,4,4,5,5,6,6,7,7,0,8,0,1,8,9,1,2,9,10,2,3,10,11,3,11,0,4,8,12,0,1,4,5,8,9,12,13,1,2,5,6,9,10,13,14,2,3,6,7,10,11,14,15,3,7,11,15,4,12,4,5,12,13,5,6,13,14,6,7,14,15,7,15,8,16,8,9,16,17,9,10,17,18,10,11,18,19,11,19,8,12,16,20,8,9,12,13,16,17,20,21,9,10,13,14,17,18,21,22,10,11,14,15,18,19,22,23,11,15,19,23,12,20,12,13,20,21,13,14,21,22,14,15,22,23,15,23,16,16,17,17,18,18,19,19,16,20,16,17,20,21,17,18,21,22,18,19,22,23,19,23,20,20,21,21,22,22,23,23]))) + self.assertTrue(rni.isEqual(DataArrayInt([0,1,3,5,7,8,10,14,18,22,24,25,27,29,31,32,34,38,42,46,48,52,60,68,76,80,82,86,90,94,96,98,102,106,110,112,116,124,132,140,144,146,150,154,158,160,161,163,165,167,168,170,174,178,182,184,185,187,189,191,192]))) + rn2,rni2=c.buildUnstructured().getReverseNodalConnectivity() + self.assertTrue(rn.isEqual(rn2)) ; self.assertTrue(rni.isEqual(rni2)) + pass + + def testSwig2CellToNodeDiscretization1(self): + m=MEDCouplingCMesh() ; arr0=DataArrayDouble(5) ; arr0.iota() ; arr1=DataArrayDouble(4) ; arr1.iota() ; m.setCoords(arr0,arr1) + f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m) ; f.setTime(1.1,5,6) + arr=DataArrayDouble(12) ; arr.iota() + arr=DataArrayDouble.Meld(arr,arr+100.) ; arr.setInfoOnComponents(["aaa","bbb"]) + f.setArray(arr) + f.checkCoherency() + # + ref=DataArrayDouble([0.,0.5,1.5,2.5,3.,2.,2.5,3.5,4.5,5.,6.,6.5,7.5,8.5,9.,8.,8.5,9.5,10.5,11.]) + ref=DataArrayDouble.Meld(ref,ref+100.) ; ref.setInfoOnComponents(["aaa","bbb"]) + f2=f.cellToNodeDiscretization() + f2.checkCoherency() + self.assertEqual(f2.getTime()[1:],[5,6]) + self.assertAlmostEqual(f2.getTime()[0],1.1,15) + self.assertEqual(f2.getMesh().getHiddenCppPointer(),m.getHiddenCppPointer()) + self.assertTrue(f2.getArray().isEqual(ref,1e-12)) + rn,rni=m.getReverseNodalConnectivity() + rni2=(rni.deltaShiftIndex()).convertToDblArr() + arr2=(f.getArray()[rn]).accumulatePerChunck(rni)/rni2 + self.assertTrue(f2.getArray().isEqual(arr2,1e-12)) + del f2 + # + u=m.buildUnstructured() ; f.setMesh(u) ; del m + f3=f.cellToNodeDiscretization() + f3.checkCoherency() + self.assertEqual(f3.getTime()[1:],[5,6]) + self.assertAlmostEqual(f3.getTime()[0],1.1,15) + self.assertEqual(f3.getMesh().getHiddenCppPointer(),u.getHiddenCppPointer()) + self.assertTrue(f3.getArray().isEqual(ref,1e-12)) + pass + + def testSwig2GetMeshSpaceDimensionCMesh1(self): + c=MEDCouplingCMesh() + arr0=DataArrayDouble([0,1,2]) + arr1=DataArrayDouble([0]) + c.setCoords(arr0,arr0,arr0) + self.assertEqual(c.getMeshDimension(),3) + self.assertEqual(c.getSpaceDimension(),3) + # + c.setCoords(arr0,arr0,arr1) + self.assertEqual(c.getMeshDimension(),2) + self.assertEqual(c.getSpaceDimension(),3) + # + c.setCoords(arr0,arr0) + self.assertEqual(c.getMeshDimension(),2) + self.assertEqual(c.getSpaceDimension(),2) + # + c.setCoords(arr0,arr1) + self.assertEqual(c.getMeshDimension(),1) + self.assertEqual(c.getSpaceDimension(),2) + # + c.setCoords(arr0) + self.assertEqual(c.getMeshDimension(),1) + self.assertEqual(c.getSpaceDimension(),1) + # + c.setCoords(arr1) + self.assertEqual(c.getMeshDimension(),0) + self.assertEqual(c.getSpaceDimension(),1) pass def setUp(self): pass pass -unittest.main() +if __name__ == '__main__': + unittest.main()