self.assertEqual(1, len(dis));
self.assertEqual(NORM_HEXA8, dis[0][0]);
self.assertEqual(27, dis[0][1]);
- self.assertEqual(0, dis[0][2]);
+ self.assertEqual(-1, dis[0][2]);
- idsPerType=[]
- self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
- dis[0][2]=-1;
idsPerType=[]
self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
dis[0][0]=NORM_QUAD4;
self.assertEqual(2,len(code));
self.assertEqual(3,code[0][0]);
self.assertEqual(2,code[0][1]);
- self.assertEqual(0,code[0][2]);
+ self.assertEqual(-1,code[0][2]);
self.assertEqual(4,code[1][0]);
self.assertEqual(3,code[1][1]);
- self.assertEqual(0,code[1][2]);
+ self.assertEqual(-1,code[1][2]);
pass
def testNorm2_1(self):
self.assertTrue(a.isEqual(DataArrayInt([])))
pass
+ def testSwig21SGTUMesh1(self):
+ m=MEDCoupling1GTUMesh.New("m",NORM_PENTA6)
+ m.__repr__() ; m.__str__()
+ self.assertTrue(isinstance(m,MEDCoupling1SGTUMesh))
+ m.setCoords(DataArrayDouble(20,3))
+ m.allocateCells()
+ m.__repr__() ; m.__str__()
+ m.insertNextCell([0,1,2,5,7,2])
+ self.assertEqual(1,m.getNumberOfCells())
+ self.assertTrue(DataArrayInt([6]).isEqual(m.computeNbOfNodesPerCell()))
+ self.assertTrue(DataArrayInt([5]).isEqual(m.computeNbOfFacesPerCell()))
+ m.__repr__() ; m.__str__()
+ m.checkCoherency()
+ m.checkCoherency2()
+ #
+ cm=MEDCouplingCMesh() ; cm.setName("m")
+ arr0=DataArrayDouble(6) ; arr0.iota()
+ arr1=DataArrayDouble([0,1])
+ cm.setCoords(arr0,arr1,arr1) ; um=cm.buildUnstructured()
+ #
+ m=MEDCoupling1SGTUMesh("m",NORM_QUAD4)
+ m.allocateCells(5)
+ self.assertIn(m.getHeapMemorySize(),xrange(80,90))
+ self.assertEqual(m.getNodalConnectivity().getNbOfElemAllocated(),20)
+ m.setCoords(um.getCoords())
+ m.insertNextCell([1,0,6,7])
+ self.assertEqual(1,m.getNumberOfCells())
+ m.insertNextCell([2,1,7,8])
+ m.insertNextCell([3,2,8,9])
+ m.insertNextCell([4,3,9,10])
+ m.insertNextCell([5,4,10,11])
+ self.assertEqual(5,m.getNumberOfCells())
+ self.assertRaises(InterpKernelException,m.insertNextCell,[0,6,7])
+ self.assertRaises(InterpKernelException,m.insertNextCell,[0,6,7,1,2])
+ self.assertEqual(m.getNodalConnectivity().getNbOfElemAllocated(),20)
+ f=m.getMeasureField(ON_CELLS)
+ self.assertEqual(f.getMesh().getHiddenCppPointer(),m.getHiddenCppPointer())
+ self.assertTrue(f.getArray().isUniform(1,1e-14))
+ self.assertEqual(m.getType(),10)
+ self.assertEqual(m.getCellModelEnum(),NORM_QUAD4)
+ mo=MEDCoupling1SGTUMesh("m",NORM_QUAD4) ; mo.setCoords(m.getCoords())
+ mo.setNodalConnectivity(DataArrayInt([1,0,6,7,2,1,7,8,3,2,8,9,4,3,9,10,5,4,10,11]))
+ self.assertTrue(m.isEqual(mo,1e-12))
+ #
+ mo2=MEDCoupling1SGTUMesh.Merge1SGTUMeshesOnSameCoords([m[[0,1]],m[[2]],m[[3,4]]])
+ mo2.setName(m.getName())
+ self.assertTrue(m.isEqual(mo2,1e-12))
+ #
+ mp0=m[[0]] ; mp0.zipCoords() ; mp1=m[2] ; mp1.zipCoords() ; mp2=m[4] ; mp2.zipCoords()
+ mo3=MEDCoupling1SGTUMesh.Merge1SGTUMeshes([mp0,mp1,mp2])
+ self.assertTrue(isinstance(mo3,MEDCoupling1SGTUMesh))
+ mo3.setName(m.getName())
+ m_ref=m[(0,2,4)] ; m_ref.zipCoords()
+ m_ref.tryToShareSameCoordsPermute(mo3,1e-12)
+ self.assertTrue(m_ref.isEqual(mo3,1e-12))
+ #
+ m1=um.buildDescendingConnectivity()[0]
+ ids=m1.getCellIdsFullyIncludedInNodeIds(DataArrayInt.Range(0,12,1))
+ m1=m1[ids]
+ m1c=m1.convertIntoSingleGeoTypeMesh()
+ self.assertTrue(isinstance(m1c,MEDCoupling1SGTUMesh))
+ self.assertEqual(m1c.getCoords().getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
+ m1c.checkCoherency2()
+ self.assertTrue(m1c.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,2,1,7,8,3,2,8,9,4,3,9,10,5,4,10,11])))
+ self.assertEqual(20,m1c.getNodalConnectivityLength())
+ self.assertTrue(m.isEqual(m1c,1e-12))
+ m.getNodalConnectivity().setIJ(1,0,1)
+ self.assertTrue(not m.isEqual(m1c,1e-12))
+ m.getNodalConnectivity().setIJ(1,0,0)
+ self.assertTrue(m.isEqual(m1c,1e-12))
+ m1c.setCoords(m.getCoords().deepCpy())
+ self.assertTrue(m.isEqual(m1c,1e-12))
+ m1c.getCoords().setIJ(0,1,0.1)
+ self.assertTrue(not m.isEqual(m1c,1e-12))
+ m1c.getCoords().setIJ(0,1,0)
+ self.assertTrue(m.isEqual(m1c,1e-12))
+ m1c.getCoords().setInfoOnComponent(1,"X")
+ self.assertTrue(not m.isEqual(m1c,1e-12) and m.isEqualWithoutConsideringStr(m1c,1e-12))
+ m.getCoords().setInfoOnComponent(1,"X")
+ self.assertTrue(m.isEqual(m1c,1e-12) and m.isEqualWithoutConsideringStr(m1c,1e-12))
+ m.setName("m2")
+ self.assertTrue(not m.isEqual(m1c,1e-12) and m.isEqualWithoutConsideringStr(m1c,1e-12))
+ #
+ m.checkCoherency() ; m.checkCoherency1() ; m.checkCoherency2()
+ self.assertEqual(m.getMeshDimension(),2)
+ self.assertTrue(m.giveCellsWithType(NORM_QUAD4).isEqual(DataArrayInt([0,1,2,3,4])))
+ self.assertTrue(m.giveCellsWithType(NORM_TRI3).isEqual(DataArrayInt([])))
+ self.assertEqual(m.getNumberOfCellsWithType(NORM_QUAD4),5)
+ self.assertEqual(m.getNumberOfCellsWithType(NORM_TRI3),0)
+ self.assertEqual(m.getTypeOfCell(3),NORM_QUAD4)
+ self.assertRaises(InterpKernelException,m.getTypeOfCell,5)
+ self.assertEqual(m.getAllGeoTypes(),[NORM_QUAD4])
+ self.assertEqual(m.getDistributionOfTypes(),[[NORM_QUAD4,5,-1]])
+ ##
+ pfl1=DataArrayInt([1,3,4])
+ a,b,c=m.splitProfilePerType(pfl1)
+ d,e,f=m.buildUnstructured().splitProfilePerType(pfl1)
+ self.assertTrue(a==[[4,3,0]] and len(b)==1 and b[0].isEqual(DataArrayInt([0,1,2])) and len(c)==1 and c[0].getHiddenCppPointer()==pfl1.getHiddenCppPointer())
+ self.assertTrue(a==d and len(b)==1 and b[0].isEqual(e[0]) and len(c)==1 and c[0].isEqual(f[0]))
+ #
+ pfl2=DataArrayInt([0,1,2,3])
+ a,b,c=m.splitProfilePerType(pfl2)
+ d,e,f=m.buildUnstructured().splitProfilePerType(pfl2)
+ self.assertTrue(a==[[4,4,0]] and len(b)==1 and b[0].isEqual(DataArrayInt([0,1,2,3])) and len(c)==1 and c[0].getHiddenCppPointer()==pfl2.getHiddenCppPointer())
+ self.assertTrue(a==d and len(b)==1 and b[0].isEqual(e[0]) and len(c)==1 and c[0].isEqual(f[0]))
+ #
+ pfl3=DataArrayInt([0,1,2,3,4])
+ a,b,c=m.splitProfilePerType(pfl3)
+ d,e,f=m.buildUnstructured().splitProfilePerType(pfl3)
+ self.assertTrue(a==[[4,5,-1]] and len(b)==1 and b[0].isEqual(DataArrayInt([0,1,2,3,4])) and c==[])
+ self.assertTrue(a==d and len(b)==1 and b[0].isEqual(e[0]) and c==[])
+ #
+ invalidPfl=DataArrayInt([1,2,3,4,5])
+ self.assertRaises(InterpKernelException,m.splitProfilePerType,invalidPfl)
+ self.assertRaises(InterpKernelException,m.buildUnstructured().splitProfilePerType,invalidPfl)
+ ##
+ pfl1=DataArrayInt([1,2,3])
+ a=m.checkTypeConsistencyAndContig([NORM_QUAD4,3,0],[pfl1])
+ b=m.buildUnstructured().checkTypeConsistencyAndContig([NORM_QUAD4,3,0],[pfl1])
+ self.assertTrue(a.isEqual(b) and pfl1.getHiddenCppPointer(),a.getHiddenCppPointer())
+ #
+ pfl2=DataArrayInt([0,1,2,3])
+ a=m.checkTypeConsistencyAndContig([NORM_QUAD4,4,0],[pfl2])
+ b=m.buildUnstructured().checkTypeConsistencyAndContig([NORM_QUAD4,4,0],[pfl2])
+ self.assertTrue(a.isEqual(b) and pfl2.getHiddenCppPointer()==a.getHiddenCppPointer())
+ #
+ pfl3=DataArrayInt([0,1,2,3,4])
+ a=m.checkTypeConsistencyAndContig([NORM_QUAD4,4,0],[pfl3])
+ b=m.buildUnstructured().checkTypeConsistencyAndContig([NORM_QUAD4,5,0],[pfl3])
+ self.assertTrue(a.isEqual(b) and pfl3.getHiddenCppPointer()==a.getHiddenCppPointer())
+ #
+ invalidPfl=DataArrayInt([1,2,3,4,5])
+ self.assertRaises(InterpKernelException,m.checkTypeConsistencyAndContig,[NORM_QUAD4,5,0],[invalidPfl])
+ self.assertRaises(InterpKernelException,m.buildUnstructured().checkTypeConsistencyAndContig,[NORM_QUAD4,5,0],[invalidPfl])
+ ##
+ self.assertTrue(DataArrayInt([4,4,4,4,4]).isEqual(m.computeNbOfNodesPerCell()))
+ ##
+ self.assertEqual(m.getNodeIdsOfCell(1),[2,1,7,8])
+ ##
+ self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(DataArrayDouble([(0.5,0.5,0),(1.5,0.5,0),(2.5,0.5,0),(3.5,0.5,0),(4.5,0.5,0)]),1e-13))
+ ##
+ ref=m.getCoords().getHiddenCppPointer()
+ mcpy=m.deepCpy() ; mcpy.insertNextCell([1,0,6,7])
+ c=m.getNodalConnectivity().deepCpy()
+ o2n=DataArrayInt([2,0,1,4,3])
+ m.renumberCells(o2n,False)
+ c.rearrange(4) ; c.renumberInPlace(o2n) ; c.rearrange(1)
+ self.assertTrue(c.isEqual(m.getNodalConnectivity()))
+ self.assertEqual(ref,m.getCoords().getHiddenCppPointer())
+ m2=mcpy.mergeMyselfWith(m)
+ self.assertTrue(isinstance(m2,MEDCoupling1SGTUMesh))
+ self.assertEqual(11,m2.getNumberOfCells())
+ self.assertEqual(48,m2.getNumberOfNodes())
+ self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.Aggregate([m.getCoords(),m.getCoords()]),1e-12))
+ self.assertTrue(m2.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,2,1,7,8,3,2,8,9,4,3,9,10,5,4,10,11,1,0,6,7,26,25,31,32,27,26,32,33,25,24,30,31,29,28,34,35,28,27,33,34])))
+ ##
+ mu=m.buildUnstructured()
+ mu.checkCoherency2()
+ self.assertEqual(mu.getCoords().getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
+ self.assertEqual(2,mu.getMeshDimension())
+ self.assertEqual([NORM_QUAD4],mu.getAllGeoTypes())
+ self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([4,2,1,7,8,4,3,2,8,9,4,1,0,6,7,4,5,4,10,11,4,4,3,9,10])))
+ self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25])))
+ ##
+ for typ in [0,1]:
+ mcpy2=m.deepCpy() ; umcpy2=mcpy2.buildUnstructured()
+ ids=mcpy2.simplexize(typ) ; ids2=umcpy2.simplexize(typ)
+ self.assertTrue(ids.isEqual(ids2))
+ mcpy3=umcpy2.convertIntoSingleGeoTypeMesh()
+ self.assertTrue(mcpy2.isEqual(mcpy3,1e-14))
+ pass
+ um1=um.convertIntoSingleGeoTypeMesh()
+ self.assertEqual(8,um1.getNumberOfNodesPerCell())
+ for typ in [PLANAR_FACE_5,PLANAR_FACE_6]:
+ mcpy2=um1.deepCpy() ; umcpy2=mcpy2.buildUnstructured()
+ ids=mcpy2.simplexize(typ) ; ids2=umcpy2.simplexize(typ)
+ self.assertTrue(ids.isEqual(ids2))
+ mcpy3=umcpy2.convertIntoSingleGeoTypeMesh()
+ self.assertTrue(mcpy2.isEqual(mcpy3,1e-14))
+ pass
+ ##
+ self.assertRaises(InterpKernelException,mcpy.mergeMyselfWithOnSameCoords,m)
+ mcpy.tryToShareSameCoords(m,1e-14)
+ m3=mcpy.mergeMyselfWithOnSameCoords(m)
+ self.assertTrue(isinstance(m3,MEDCoupling1SGTUMesh))
+ self.assertEqual(11,m3.getNumberOfCells())
+ self.assertEqual(24,m3.getNumberOfNodes())
+ self.assertEqual(m3.getCoords().getHiddenCppPointer(),mcpy.getCoords().getHiddenCppPointer())
+ self.assertTrue(m3.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,2,1,7,8,3,2,8,9,4,3,9,10,5,4,10,11,1,0,6,7,2,1,7,8,3,2,8,9,1,0,6,7,5,4,10,11,4,3,9,10])))
+ ##
+ ref=mcpy.getCoords().deepCpy()
+ c3=mcpy.getNodalConnectivity()[:]
+ mcpy.getNodalConnectivity().setIJ(int(c3.getIdsEqual(11)),0,24)
+ c2=DataArrayDouble.Aggregate([mcpy.getCoords(),mcpy.getCoords()[11:]])
+ mcpy.setCoords(c2)
+ mcpy.checkCoherency2()
+ a,b=mcpy.getNodeIdsInUse()
+ self.assertEqual(12,b)
+ self.assertTrue(a.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,11,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1])))
+ ids=mcpy.zipCoordsTraducer()
+ self.assertTrue(ids.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,11,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1])))
+ self.assertTrue(mcpy.getCoords().isEqual(ref[:12],1e-12))
+ self.assertTrue(mcpy.getNodalConnectivity().isEqual(c3))
+ mcpy.checkCoherency2()
+ ##
+ m4=mcpy[DataArrayInt([0,3,4])]
+ m5=mcpy.buildPartOfMySelfKeepCoords(DataArrayInt([0,3,4]))
+ self.assertTrue(isinstance(m4,MEDCoupling1SGTUMesh))
+ self.assertTrue(m4.isEqual(m5,-1e-14))# < 0 not a bug it proves that coordinates pointer are equal
+ self.assertTrue(m4.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,4,3,9,10,5,4,10,11])))
+ m6=mcpy[::2]
+ self.assertTrue(isinstance(m6,MEDCoupling1SGTUMesh))
+ self.assertTrue(m6.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,3,2,8,9,5,4,10,11])))
+ ##
+ mcpy.setCoords(DataArrayDouble.Aggregate([mcpy.getCoords(),mcpy.getCoords()]))
+ mcpy.checkCoherency2()
+ ##
+ mcppy=mcpy.deepCpyConnectivityOnly()
+ self.assertTrue(mcppy.isEqual(mcpy,1e-12))
+ self.assertTrue(mcppy.getCoords().getHiddenCppPointer()==mcpy.getCoords().getHiddenCppPointer())
+ self.assertTrue(mcppy.getNodalConnectivity().isEqual(mcpy.getNodalConnectivity()))
+ self.assertTrue(mcppy.getNodalConnectivity().getHiddenCppPointer()!=mcpy.getNodalConnectivity().getHiddenCppPointer())
+ ##
+ a,b=mcpy.getReverseNodalConnectivity()
+ self.assertTrue(a.isEqual(DataArrayInt([0,5,0,1,5,1,2,2,3,3,4,4,0,5,0,1,5,1,2,2,3,3,4,4])))
+ self.assertTrue(b.isEqual(DataArrayInt([0,2,5,7,9,11,12,14,17,19,21,23,24,24,24,24,24,24,24,24,24,24,24,24,24])))
+ self.assertTrue(mcpy.fillCellIdsToKeepFromNodeIds([0,1,6,7],False).isEqual(DataArrayInt([0,1,5])))
+ self.assertTrue(mcpy.fillCellIdsToKeepFromNodeIds([0,1,6,7],True).isEqual(DataArrayInt([0,5])))
+ self.assertTrue(mcpy.getCellsInBoundingBox([(0,1),(0,1),(0,1)],1e-12).isEqual(DataArrayInt([0,1,5])))
+ f=mcpy.buildOrthogonalField()
+ self.assertEqual(f.getMesh().getHiddenCppPointer(),mcpy.getHiddenCppPointer())
+ self.assertTrue(f.getArray().isEqual(DataArrayDouble(6*[(0,0,-1)]),1e-12))
+ mcpy.changeSpaceDimension(2)
+ self.assertEqual(1,mcpy.getCellContainingPoint([1.5,0.5],1e-12))
+ ##
+ self.assertTrue(mcpy.fillCellIdsToKeepFromNodeIds(DataArrayInt([6,7]),False).isEqual(DataArrayInt([0,1,5])))
+ ##
+ mcpy2=mcpy.deepCpy()
+ self.assertEqual([None,None],mcpy.checkGeoEquivalWith(mcpy2,1,1e-12))#fast equal
+ mcpy.checkFastEquivalWith(mcpy2,1e-12)
+ mcpy2.renumberCells([0,2,4,3,1,5])
+ mcpy.checkFastEquivalWith(mcpy2,1e-12)
+ self.assertEqual([None,None],mcpy.checkGeoEquivalWith(mcpy2,1,1e-12))#fast equal
+ mcpy2.renumberCells([0,2,4,3,1,5])
+ mcpy2.renumberCells([1,3,5,0,2,4])
+ self.assertRaises(InterpKernelException,mcpy.checkFastEquivalWith,mcpy2,1e-12)
+ self.assertRaises(InterpKernelException,mcpy.checkGeoEquivalWith,mcpy2,1,1e-12)#fast equal
+ pass
+
+ def testSwig21DGTUMesh1(self):
+ a0=DataArrayInt([0,2,3,5,6,8])
+ a1=DataArrayInt([0,4,7,11,14,18,21,25])
+ a2=DataArrayInt([0,1,4,5])
+ self.assertTrue(DataArrayInt.AggregateIndexes([a0,a1,a2]).isEqual(DataArrayInt([0,2,3,5,6,8,12,15,19,22,26,29,33,34,37,38])))
+ self.assertEqual(a1[3:].front(),11)
+ self.assertEqual(a1[4:].convertToDblArr().front(),14.)
+ a1c=DataArrayInt([5,7,1,2, 8,11,0, 5,6,3,12, 1,5,2, 13,12,11,7, 6,1,0, 20,21,19,17])
+ d,e=MEDCouplingUMesh.ExtractFromIndexedArrays2(1,5,2,a1c,a1)
+ self.assertTrue(d.isEqual(DataArrayInt([8,11,0,1,5,2])))
+ self.assertTrue(e.isEqual(DataArrayInt([0,3,6])))
+ #
+ m=MEDCouplingDataForTest.build2DTargetMesh_1()[0,3,4]
+ ref=DataArrayInt([0,3,4,1,6,7,4,3,7,8,5,4])
+ self.assertTrue(m.convertNodalConnectivityToStaticGeoTypeMesh().isEqual(ref))
+ d,e=m.convertNodalConnectivityToDynamicGeoTypeMesh()
+ self.assertTrue(d.isEqual(ref))
+ self.assertTrue(e.isEqual(DataArrayInt.Range(0,13,4)))
+ self.assertTrue(m.fillCellIdsToKeepFromNodeIds(DataArrayInt([6,7]),False).isEqual(DataArrayInt([1,2])))
+ #
+ m=MEDCoupling1GTUMesh.New("m",NORM_POLYHED)
+ self.assertTrue(isinstance(m,MEDCoupling1DGTUMesh))
+ m.__repr__() ; m.__str__()
+ m.setCoords(DataArrayDouble(20,3))
+ m.allocateCells()
+ m.__repr__() ; m.__str__()
+ m.insertNextCell([0,1,2,5,7,2,-1,1,3])
+ self.assertEqual(1,m.getNumberOfCells())
+ self.assertTrue(DataArrayInt([8]).isEqual(m.computeNbOfNodesPerCell()))
+ self.assertTrue(DataArrayInt([2]).isEqual(m.computeNbOfFacesPerCell()))
+ m.__repr__() ; m.__str__()
+ m.checkCoherency()
+ m.checkCoherency2()
+ #
+ cm=MEDCouplingCMesh() ; cm.setName("m")
+ arr0=DataArrayDouble(6) ; arr0.iota()
+ arr1=DataArrayDouble([0,1])
+ cm.setCoords(arr0,arr1,arr1) ; um=cm.buildUnstructured() ; um.convertAllToPoly()
+ um2=um.deepCpyConnectivityOnly()
+ self.assertTrue(um2.isEqual(um,1e-12))
+ self.assertEqual(um2.getCoords().getHiddenCppPointer(),um.getCoords().getHiddenCppPointer())
+ self.assertTrue(um2.getNodalConnectivity().isEqual(um.getNodalConnectivity()))
+ self.assertTrue(um2.getNodalConnectivity().getHiddenCppPointer()!=um.getNodalConnectivity().getHiddenCppPointer())
+ self.assertTrue(um2.getNodalConnectivityIndex().isEqual(um.getNodalConnectivityIndex()))
+ self.assertTrue(um2.getNodalConnectivityIndex().getHiddenCppPointer()!=um.getNodalConnectivityIndex().getHiddenCppPointer())
+ #
+ self.assertRaises(InterpKernelException,MEDCoupling1SGTUMesh.New,"m",NORM_POLYHED)
+ m=MEDCoupling1DGTUMesh("m",NORM_POLYHED)
+ m.allocateCells(5)
+ self.assertEqual(15,m.getNodalConnectivity().getNbOfElemAllocated())
+ self.assertEqual(6,m.getNodalConnectivityIndex().getNbOfElemAllocated())
+ m.setCoords(um.getCoords())
+ m.insertNextCell([1,0,6,7,-1,7,6,1])
+ self.assertEqual(1,m.getNumberOfCells())
+ m.insertNextCell([2,1,7,8,-1,2,1,-1,8,-1,7])
+ m.insertNextCell([3,2,8,9])
+ m.insertNextCell([4,3,9,10,-1,5,3,9])
+ m.insertNextCell([5,4,10,11,-1,11,10,-1,5])
+ m.checkCoherency()
+ m.checkCoherency2()
+ self.assertEqual(5,m.getNumberOfCells())
+ self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,8,19,23,31,40])))
+ self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,3,2,8,9,4,3,9,10,-1,5,3,9,5,4,10,11,-1,11,10,-1,5])))
+ #
+ m4=m.deepCpy()
+ self.assertTrue(m.isEqual(m4,1e-12))
+ m4.getNodalConnectivity().setIJ(2,0,5)
+ self.assertTrue(not m.isEqual(m4,1e-12))
+ m4.getNodalConnectivity().setIJ(2,0,6)
+ self.assertTrue(m.isEqual(m4,1e-12))
+ m4.getNodalConnectivityIndex().setIJ(2,0,21)
+ self.assertTrue(not m.isEqual(m4,1e-12))
+ m4.getNodalConnectivityIndex().setIJ(2,0,19)
+ self.assertTrue(m.isEqual(m4,1e-12))
+ m4.getCoords().setIJ(10,1,1.1)
+ self.assertTrue(not m.isEqual(m4,1e-12))
+ m4.getCoords().setIJ(10,1,1.)
+ self.assertTrue(m.isEqual(m4,1e-12))
+ m4.getNodalConnectivity().pushBackSilent(7)
+ self.assertTrue(not m.isEqual(m4,1e-12))
+ self.assertEqual(7,m4.getNodalConnectivity().popBackSilent())
+ self.assertTrue(m.isEqual(m4,1e-12))
+ m4.setName("m4")
+ self.assertTrue(not m.isEqual(m4,1e-12))
+ m4.setName("m")
+ self.assertTrue(m.isEqual(m4,1e-12))
+ #
+ self.assertEqual(6,m.getNodalConnectivityIndex().getNbOfElemAllocated())
+ self.assertEqual(60,m.getNodalConnectivity().getNbOfElemAllocated())
+ self.assertTrue(m.computeNbOfNodesPerCell().isEqual(DataArrayInt([7,8,4,7,7])))
+ self.assertTrue(m.computeNbOfFacesPerCell().isEqual(DataArrayInt([2,4,1,2,3])))
+ self.assertEqual(m.getNodeIdsOfCell(1),[2,1,7,8,-1,2,1,-1,8,-1,7])
+ f=m.computeIsoBarycenterOfNodesPerCell()
+ self.assertTrue(DataArrayDouble([(0.5714285714285714,0.5714285714285714,0),(1.5,0.5,0),(2.5,0.5,0),(3.5714285714285712,0.42857142857142855,0),(4.5714285714285712,0.5714285714285714,0)]).isEqual(f,1e-14))
+ mu0=m.buildUnstructured()
+ o2n=[1,2,0,4,3]
+ m2=m.deepCpy()
+ m3=m.deepCpyConnectivityOnly()
+ self.assertTrue(m3.isEqual(m,1e-12))
+ self.assertEqual(m3.getCoords().getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
+ self.assertTrue(m3.getNodalConnectivity().getHiddenCppPointer()!=m.getNodalConnectivity().getHiddenCppPointer())
+ self.assertTrue(m3.getNodalConnectivity().isEqual(m.getNodalConnectivity()))
+ self.assertTrue(m3.getNodalConnectivityIndex().getHiddenCppPointer()!=m.getNodalConnectivityIndex().getHiddenCppPointer())
+ self.assertTrue(m3.getNodalConnectivityIndex().isEqual(m.getNodalConnectivityIndex()))
+ m.renumberCells(o2n)
+ mu0.renumberCells(o2n)
+ self.assertTrue(mu0.isEqual(m.buildUnstructured(),1e-12))
+ self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,12,23,32,40])))
+ self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([3,2,8,9,1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,5,4,10,11,-1,11,10,-1,5,4,3,9,10,-1,5,3,9])))
+ #
+ mcpy0=m.buildUnstructured()
+ 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])
+ mcpy0.checkCoherency()
+ mcpy0.checkCoherency2()
+ mcpy1=mcpy0.convertIntoSingleGeoTypeMesh()
+ self.assertTrue(mcpy1.isEqual(m,1e-12))
+ #
+ m_mrg=MEDCoupling1DGTUMesh.Merge1DGTUMeshes([m2,m,m2])
+ self.assertTrue(m_mrg.getNodalConnectivityIndex().isEqual(DataArrayInt([0,8,19,23,31,40,44,52,63,72,80,88,99,103,111,120])))
+ self.assertTrue(m_mrg.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,3,2,8,9,4,3,9,10,-1,5,3,9,5,4,10,11,-1,11,10,-1,5,27,26,32,33,25,24,30,31,-1,31,30,25,26,25,31,32,-1,26,25,-1,32,-1,31,29,28,34,35,-1,35,34,-1,29,28,27,33,34,-1,29,27,33,49,48,54,55,-1,55,54,49,50,49,55,56,-1,50,49,-1,56,-1,55,51,50,56,57,52,51,57,58,-1,53,51,57,53,52,58,59,-1,59,58,-1,53])))
+ m_mrg2=MEDCoupling1DGTUMesh.Merge1DGTUMeshesOnSameCoords([m3,m,m3])
+ self.assertTrue(m_mrg2.getNodalConnectivityIndex().isEqual(DataArrayInt([0,8,19,23,31,40,44,52,63,72,80,88,99,103,111,120])))
+ self.assertTrue(m_mrg2.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,3,2,8,9,4,3,9,10,-1,5,3,9,5,4,10,11,-1,11,10,-1,5,3,2,8,9,1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,5,4,10,11,-1,11,10,-1,5,4,3,9,10,-1,5,3,9,1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,3,2,8,9,4,3,9,10,-1,5,3,9,5,4,10,11,-1,11,10,-1,5])))
+ a,b=m_mrg2.getReverseNodalConnectivity()
+ self.assertTrue(b.isEqual(DataArrayInt([0,3,15,24,33,39,48,54,66,75,84,93,99,99,99,99,99,99,99,99,99,99,99,99,99])))
+ self.assertTrue(a.isEqual(DataArrayInt([0,6,10,0,0,1,1,6,6,7,7,10,10,11,11,1,1,2,5,7,7,11,11,12,2,3,3,5,9,9,12,13,13,3,4,8,9,13,14,3,4,4,8,8,9,13,14,14,0,0,6,6,10,10,0,0,1,1,6,6,7,7,10,10,11,11,1,1,2,5,7,7,11,11,12,2,3,3,5,9,9,12,13,13,3,4,4,8,8,9,13,14,14,4,4,8,8,14,14])))
+ self.assertTrue(m_mrg2.fillCellIdsToKeepFromNodeIds([7],False).isEqual(DataArrayInt([0,1,6,7,10,11])))
+ self.assertTrue(m_mrg2.fillCellIdsToKeepFromNodeIds([0,1,6,7],True).isEqual(DataArrayInt([0,6,10])))
+ #
+ self.assertTrue(m_mrg2.isPacked())
+ self.assertEqual(120,m_mrg2.getNodalConnectivityIndex().popBackSilent())
+ self.assertEqual(m_mrg2.getNumberOfCells(),14)
+ m_mrg2.checkCoherency2()
+ self.assertTrue(not m_mrg2.isPacked())
+ m_mrg4,b=m_mrg2.copyWithNodalConnectivityPacked()
+ self.assertTrue(not b)
+ m_mrg4.checkCoherency2()
+ self.assertEqual(m_mrg4.getNumberOfCells(),14)
+ self.assertTrue(m_mrg4.getNodalConnectivityIndex().isEqual(m_mrg2.getNodalConnectivityIndex()))
+ self.assertEqual(len(m_mrg4.getNodalConnectivity()),111)
+ self.assertEqual(len(m_mrg2.getNodalConnectivity()),120)
+ self.assertTrue(m_mrg4.getNodalConnectivity().isEqual(m_mrg2.getNodalConnectivity()[:111]))
+ #
+ m0=m_mrg2[:5]
+ m1=m_mrg2[[5,6,7,8,9]]
+ m2=m_mrg2[10:]
+ self.assertTrue(m1.isEqualWithoutConsideringStr(m,1e-12))
+ a,b=m.checkGeoEquivalWith(m0,12,1e-12)
+ self.assertTrue(a.isEqual(DataArrayInt(o2n)))
+ self.assertTrue(b is None)
+ pass
+
+ def testSwig2DADAreIncludedInMe1(self):
+ a=DataArrayDouble(30) ; a.iota() ; a.rearrange(3)
+ p=DataArrayInt([5,2,1,9])
+ b,c=a.areIncludedInMe(a[p],1e-12)
+ self.assertTrue(b)
+ self.assertTrue(c.isEqual(p))
+ d=a[p]
+ d.setIJ(3,1,28.1)
+ b,c=a.areIncludedInMe(d,1e-12)
+ self.assertTrue(not b)
+ self.assertTrue(c.isEqual(DataArrayInt([5,2,1,10])))
+ pass
+
+ def testSwig2DADesallocate1(self):
+ d=DataArrayDouble([(1,2),(6,7),(6,8)]) ; d.setInfoOnComponents(["aa","bbb"])
+ self.assertTrue(d.isAllocated())
+ d.checkAllocated()
+ self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
+ ref=d.getHeapMemorySize()
+ d.desallocate()
+ self.assertEqual(ref-d.getHeapMemorySize(),6*8)
+ self.assertTrue(not d.isAllocated())
+ self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
+ self.assertRaises(InterpKernelException,d.checkAllocated)
+ #
+ d=DataArrayInt([(1,2),(6,7),(6,8)]) ; d.setInfoOnComponents(["aa","bbb"])
+ self.assertTrue(d.isAllocated())
+ d.checkAllocated()
+ self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
+ ref=d.getHeapMemorySize()
+ d.desallocate()
+ self.assertEqual(ref-d.getHeapMemorySize(),6*4)
+ self.assertTrue(not d.isAllocated())
+ self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
+ self.assertRaises(InterpKernelException,d.checkAllocated)
+ pass
+
def setUp(self):
pass
pass
