X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDLoader%2FSwig%2FMEDLoaderTest3.py;h=bd37a82e26a481de2386700c0dbef689d8b30b85;hb=76dbe4d9a44823aca5e7e56b357d64d84db64f66;hp=3086649aa32be99210b3fcf4b3c5aafe5b7ace44;hpb=09367aea240ee78eefebf9ca444e2362ab5d322f;p=tools%2Fmedcoupling.git diff --git a/src/MEDLoader/Swig/MEDLoaderTest3.py b/src/MEDLoader/Swig/MEDLoaderTest3.py index 3086649aa..bd37a82e2 100644 --- a/src/MEDLoader/Swig/MEDLoaderTest3.py +++ b/src/MEDLoader/Swig/MEDLoaderTest3.py @@ -1,5 +1,5 @@ # -*- coding: iso-8859-1 -*- -# Copyright (C) 2007-2015 CEA/DEN, EDF R&D +# Copyright (C) 2007-2016 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 @@ -24,6 +24,7 @@ import unittest import platform from math import pi,e,sqrt from MEDLoaderDataForTest import MEDLoaderDataForTest +from distutils.version import LooseVersion class MEDLoaderTest3(unittest.TestCase): def testMEDMesh1(self): @@ -2147,25 +2148,25 @@ class MEDLoaderTest3(unittest.TestCase): # mm=MEDFileUMesh() mm.setMeshAtLevel(0,m) - self.assertIn(mm.getHeapMemorySize(),xrange(3889-100,3889+100+10*strMulFac)) + self.assertIn(mm.getHeapMemorySize(),xrange(3889-100,4225+100+10*strMulFac)) ff=MEDFileField1TS() ff.setFieldNoProfileSBT(f) - self.assertIn(ff.getHeapMemorySize(),xrange(771-40,771+21+(4+1)*strMulFac)) + self.assertIn(ff.getHeapMemorySize(),xrange(771-40,871+21+(4+1)*strMulFac)) # fff=MEDFileFieldMultiTS() fff.appendFieldNoProfileSBT(f) - self.assertIn(fff.getHeapMemorySize(),xrange(815-50,815+30+(6+2)*strMulFac)) + self.assertIn(fff.getHeapMemorySize(),xrange(815-50,915+30+(6+2)*strMulFac)) f.setTime(1.,0,-1) fff.appendFieldNoProfileSBT(f) - self.assertIn(fff.getHeapMemorySize(),xrange(1594-90,1594+50+(10+1)*strMulFac)) - self.assertIn(fff[0,-1].getHeapMemorySize(),xrange(771-40,771+20+(4+1)*strMulFac)) + self.assertIn(fff.getHeapMemorySize(),xrange(1594-90,1794+50+(10+1)*strMulFac)) + self.assertIn(fff[0,-1].getHeapMemorySize(),xrange(771-40,871+20+(4+1)*strMulFac)) f2=f[:50] f2.setTime(2.,1,-1) pfl=DataArrayInt.Range(0,50,1) ; pfl.setName("pfl") fff.appendFieldProfile(f2,mm,0,pfl) - self.assertIn(fff.getHeapMemorySize(),xrange(2348-130,2348+100+(10+2)*strMulFac)) + self.assertIn(fff.getHeapMemorySize(),xrange(2348-130,2608+100+(10+2)*strMulFac)) self.assertIn(fff.getProfile("pfl").getHeapMemorySize(),xrange(204-10,204+10+2*strMulFac)) - self.assertIn(fff[1,-1].getHeapMemorySize(),xrange(738-50,738+30+4*strMulFac)) + self.assertIn(fff[1,-1].getHeapMemorySize(),xrange(738-50,838+30+4*strMulFac)) pass def testCurveLinearMesh1(self): @@ -2578,8 +2579,7 @@ class MEDLoaderTest3(unittest.TestCase): def testInt32InMEDFileFieldStar1(self): fname="Pyfile63.med" f1=MEDLoaderDataForTest.buildVecFieldOnCells_1(); - arr=f1.getArray().convertToIntArr() - f1.setArray(None) + f1=f1.convertToIntField() m1=f1.getMesh() mm1=MEDFileUMesh.New() mm1.setCoords(m1.getCoords()) @@ -2587,19 +2587,17 @@ class MEDLoaderTest3(unittest.TestCase): mm1.setName(m1.getName()) mm1.write(fname,2) ff1=MEDFileIntField1TS() - ff1.setFieldNoProfileSBT(f1,arr) - a,b=ff1.getFieldOnMeshAtLevel(0,ON_CELLS,mm1) - self.assertEqual(b.getInfoOnComponents(),['power [MW/m^3]','density [g/cm^3]','temperature [K]']) - self.assertTrue(b.isEqual(arr)) + ff1.setFieldNoProfileSBT(f1) + a=ff1.getFieldOnMeshAtLevel(0,ON_CELLS,mm1) + self.assertEqual(a.getArray().getInfoOnComponents(),['power [MW/m^3]','density [g/cm^3]','temperature [K]']) self.assertTrue(a.isEqual(f1,1e-12,1e-12)) ff1.write(fname,0) ff2=MEDFileAnyTypeField1TS.New(fname) self.assertEqual(ff2.getName(),"VectorFieldOnCells") self.assertEqual(ff2.getTime(),[0,1,2.0]) self.assertTrue(isinstance(ff2,MEDFileIntField1TS)) - a,b=ff1.getFieldOnMeshAtLevel(0,ON_CELLS,mm1) - self.assertEqual(b.getInfoOnComponents(),['power [MW/m^3]','density [g/cm^3]','temperature [K]']) - self.assertTrue(b.isEqual(arr)) + a=ff1.getFieldOnMeshAtLevel(ON_CELLS,0,mm1) + self.assertEqual(a.getArray().getInfoOnComponents(),['power [MW/m^3]','density [g/cm^3]','temperature [K]']) self.assertTrue(a.isEqual(f1,1e-12,1e-12)) ff2.setTime(1,2,3.) c=ff2.getUndergroundDataArray() ; c*=2 @@ -2608,42 +2606,40 @@ class MEDLoaderTest3(unittest.TestCase): self.assertEqual(ffs1.getTimeSteps(),[(0, 1, 2.0), (1, 2, 3.0)]) self.assertEqual(len(ffs1),2) self.assertTrue(isinstance(ffs1,MEDFileIntFieldMultiTS)) - a,b=ffs1[2.].getFieldOnMeshAtLevel(0,ON_CELLS,mm1) - self.assertTrue(b.isEqual(arr)) + a=ffs1[2.].getFieldOnMeshAtLevel(ON_CELLS,0,mm1) self.assertTrue(a.isEqual(f1,1e-12,1e-12)) - a,b=ffs1[2.].getFieldOnMeshAtLevel(0,ON_CELLS,mm1) - self.assertTrue(b.isEqual(arr)) + a=ffs1.getFieldOnMeshAtLevel(ON_CELLS,0,1,0,mm1) self.assertTrue(a.isEqual(f1,1e-12,1e-12)) it=ffs1.__iter__() ; it.next() ; ff2bis=it.next() - a,b=ff2bis.getFieldOnMeshAtLevel(0,ON_CELLS,mm1) - self.assertTrue(b.isEqual(2*arr)) - f1.setTime(3.,1,2) - self.assertTrue(a.isEqual(f1,1e-12,1e-12)) + a=ff2bis.getFieldOnMeshAtLevel(0,ON_CELLS,mm1) + self.assertTrue(a.getArray().isEqual(2*f1.getArray())) + f1.setTime(3.,1,2) ; f1.getArray()[:]*=2 + self.assertTrue(a.isEqual(f1,1e-12,1e-12)) ; f1.getArray()[:]/=2 bc=DataArrayInt(6,3) ; bc[:]=0 ; bc.setInfoOnComponents(['power [MW/m^3]','density [g/cm^3]','temperature [K]']) for it in ffs1: - a,b=it.getFieldOnMeshAtLevel(0,ON_CELLS,mm1) - bc+=b + a=it.getFieldOnMeshAtLevel(ON_CELLS,0,mm1) + bc+=a.getArray() pass - self.assertTrue(bc.isEqual(3*arr)) - nf1=MEDCouplingFieldDouble(ON_NODES) + self.assertTrue(bc.isEqual(3*f1.getArray())) + nf1=MEDCouplingFieldInt(ON_NODES) nf1.setTime(9.,10,-1) nf1.setMesh(f1.getMesh()) narr=DataArrayInt(12,2) ; narr.setInfoOnComponents(["aa [u1]","bbbvv [ppp]"]) ; narr[:,0]=range(12) ; narr[:,1]=2*narr[:,0] - nf1.setName("VectorFieldOnNodes") + nf1.setName("VectorFieldOnNodes") ; nf1.setArray(narr) nff1=MEDFileIntField1TS.New() - nff1.setFieldNoProfileSBT(nf1,narr) + nff1.setFieldNoProfileSBT(nf1) self.assertEqual(nff1.getInfo(),('aa [u1]','bbbvv [ppp]')) self.assertEqual(nff1.getTime(),[10,-1,9.0]) nff1.write(fname,0) # - nf2=MEDCouplingFieldDouble(ON_NODES) + nf2=MEDCouplingFieldInt(ON_NODES) nf2.setTime(19.,20,-11) nf2.setMesh(f1.getMesh()) narr2=DataArrayInt(8,2) ; narr.setInfoOnComponents(["aapfl [u1]","bbbvvpfl [ppp]"]) ; narr2[:,0]=range(8) ; narr2[:,0]+=10 ; narr2[:,1]=3*narr2[:,0] - nf2.setName("VectorFieldOnNodesPfl") ; narr2.setName(nf2.getName()) + nf2.setName("VectorFieldOnNodesPfl") ; narr2.setName(nf2.getName()) ; nf2.setArray(narr2) nff2=MEDFileIntField1TS.New() npfl=DataArrayInt([1,2,4,5,6,7,10,11]) ; npfl.setName("npfl") - nff2.setFieldProfile(nf2,narr2,mm1,0,npfl) + nff2.setFieldProfile(nf2,mm1,0,npfl) nff2.getFieldWithProfile(ON_NODES,0,mm1) a,b=nff2.getFieldWithProfile(ON_NODES,0,mm1) ; b.setName(npfl.getName()) self.assertTrue(b.isEqual(npfl)) @@ -2670,8 +2666,8 @@ class MEDLoaderTest3(unittest.TestCase): self.assertTrue(isinstance(ffs[2],MEDFileFieldMultiTS)) self.assertTrue(isinstance(ffs[3],MEDFileIntFieldMultiTS)) # - self.assertTrue(fs["VectorFieldOnCells"][0].getUndergroundDataArray().isEqualWithoutConsideringStr(arr)) - self.assertTrue(fs["VectorFieldOnCells"][1,2].getUndergroundDataArray().isEqualWithoutConsideringStr(2*arr)) + self.assertTrue(fs["VectorFieldOnCells"][0].getUndergroundDataArray().isEqualWithoutConsideringStr(f1.getArray())) + self.assertTrue(fs["VectorFieldOnCells"][1,2].getUndergroundDataArray().isEqualWithoutConsideringStr(2*f1.getArray())) self.assertTrue(fs["VectorFieldOnNodesPfl"][0].getUndergroundDataArray().isEqualWithoutConsideringStr(narr2)) self.assertTrue(fs["VectorFieldOnNodes"][9.].getUndergroundDataArray().isEqualWithoutConsideringStr(narr)) self.assertTrue(fs["VectorFieldOnNodesDouble"][29.].getUndergroundDataArray().isEqualWithoutConsideringStr(f1.getMesh().getCoords(),1e-12)) @@ -3082,7 +3078,7 @@ class MEDLoaderTest3(unittest.TestCase): self.assertTrue(not ff0.getUndergroundDataArray().isAllocated()) self.assertEqual(ff0.getUndergroundDataArray().getInfoOnComponents(),['X [km]','YY [mm]']) heap_memory_ref=ff0.getHeapMemorySize() - self.assertIn(heap_memory_ref,xrange(182,298+2*strMulFac)) + self.assertIn(heap_memory_ref,xrange(182,465+2*strMulFac)) ff0.loadArrays() ## arr=DataArrayDouble(140) ; arr.iota() ; arr.rearrange(2) self.assertTrue(ff0.getUndergroundDataArray().isEqualWithoutConsideringStr(arr,1e-14)) @@ -3091,7 +3087,7 @@ class MEDLoaderTest3(unittest.TestCase): ff0=MEDFileField1TS(fname,"FieldCellPfl",False) self.assertEqual(ff0.getUndergroundDataArray().getInfoOnComponents(),["XX [pm]","YYY [hm]"]) heap_memory_ref=ff0.getHeapMemorySize() - self.assertIn(heap_memory_ref,xrange(350,415+6*strMulFac)) + self.assertIn(heap_memory_ref,xrange(350,520+6*strMulFac)) ff0.loadArrays() ## arr=DataArrayDouble(100) ; arr.iota() ; arr.rearrange(2) self.assertTrue(ff0.getUndergroundDataArray().isEqualWithoutConsideringStr(arr,1e-14)) @@ -3109,7 +3105,7 @@ class MEDLoaderTest3(unittest.TestCase): self.assertEqual(ff0.getUndergroundDataArray().getIJ(30,1),5.5) self.assertTrue(not ff0.getUndergroundDataArray().isEqualWithoutConsideringStr(arr,1e-14)) heap_memory_ref=ff0.getHeapMemorySize() - self.assertIn(heap_memory_ref,xrange(1100,1215+2*strMulFac)) + self.assertIn(heap_memory_ref,xrange(1100,1384+2*strMulFac)) ff0.unloadArrays() hmd=ff0.getHeapMemorySize()-heap_memory_ref self.assertEqual(hmd,-800) # -50*8*2 @@ -3118,7 +3114,7 @@ class MEDLoaderTest3(unittest.TestCase): # ff0=MEDFileField1TS(fname,"FieldCellPfl",-1,-1,False) heap_memory_ref=ff0.getHeapMemorySize() - self.assertIn(heap_memory_ref,xrange(299,415+6*strMulFac)) + self.assertIn(heap_memory_ref,xrange(299,520+6*strMulFac)) ff0.loadArrays() ## self.assertTrue(ff0.getUndergroundDataArray().isEqualWithoutConsideringStr(arr,1e-14)) self.assertEqual(ff0.getHeapMemorySize()-heap_memory_ref,50*8*2) @@ -3135,14 +3131,14 @@ class MEDLoaderTest3(unittest.TestCase): # ff0=MEDFileAnyTypeFieldMultiTS.New(fname,fieldName,False) heap_memory_ref=ff0.getHeapMemorySize() - self.assertIn(heap_memory_ref,xrange(5536,5956+(80+26)*strMulFac)) + self.assertIn(heap_memory_ref,xrange(5536,8212+(80+26)*strMulFac)) ff0.loadArrays() self.assertEqual(ff0.getHeapMemorySize()-heap_memory_ref,20*70*8*2) del ff0 # ffs=MEDFileFields(fname,False) heap_memory_ref=ffs.getHeapMemorySize() - self.assertIn(heap_memory_ref,xrange(5335,6687+(80+50)*strMulFac)) + self.assertIn(heap_memory_ref,xrange(5335,9031+(80+50)*strMulFac)) ffs.loadArrays() self.assertEqual(ffs.getHeapMemorySize()-heap_memory_ref,20*70*8*2+70*8*2+50*8*2) pass @@ -5064,7 +5060,7 @@ class MEDLoaderTest3(unittest.TestCase): def testCMeshSetFamilyFieldArrNull(self): meshName="mesh" - fname="file.med" + fname="Pyfile99.med" arrX=DataArrayDouble([0,1,2,3]) arrY=DataArrayDouble([0,1,2]) m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY) ; m.setName(meshName) @@ -5090,7 +5086,696 @@ class MEDLoaderTest3(unittest.TestCase): self.assertTrue(mm2.getFamilyFieldAtLevel(1) is None) pass + def testAppendFieldProfileOnIntField(self): + fname="Pyfile100.med" + arrX=DataArrayDouble([0,1,2,3]) + arrY=DataArrayDouble([0,1,2]) + mesh=MEDCouplingCMesh() ; mesh.setCoords(arrX,arrY) ; mesh.setName("Mesh") + mm=MEDFileCMesh() + mm.setMesh(mesh) + # + fmts=MEDFileIntFieldMultiTS() + pflName="PFL" + pfl=DataArrayInt([1,3,5]) ; pfl.setName(pflName) + f=MEDCouplingFieldInt(ON_CELLS) ; f.setMesh(mesh) + fieldName="FieldOnCell" + f.setTime(1.2,1,1) ; f.setName(fieldName) + arr=DataArrayInt([101,102,103]) ; f.setArray(arr) + fmts.appendFieldProfile(f,mm,0,pfl) + # + mm.write(fname,2) + fmts.write(fname,0) + # + mm=MEDFileMesh.New(fname) + fmts=MEDFileAnyTypeFieldMultiTS.New(fname) + self.assertTrue(isinstance(fmts,MEDFileIntFieldMultiTS)) + self.assertEqual(fmts.getName(),fieldName) + self.assertEqual(len(fmts),1) + f1ts=fmts[0] + ftest,pfltest=f1ts.getFieldWithProfile(ON_CELLS,0,mm) + self.assertEqual(pfltest.getName(),pflName) + self.assertEqual(ftest.getName(),fieldName) + self.assertTrue(ftest.isEqualWithoutConsideringStr(arr)) + ftest2=f1ts.getFieldOnMeshAtLevel(ON_CELLS,0,mm) + self.assertTrue(ftest2.getArray().isEqualWithoutConsideringStr(arr)) + self.assertEqual(ftest2.getTime(),f.getTime()) + self.assertEqual(ftest2.getMesh().getNumberOfCells(),len(arr)) + pass + + def testMEDFileFieldEasyField1(self): + """Check for all spatial discretization of field (cells,nodes,elno,gauss) for double field that all is OK. Here no profile and only top level is considered.""" + ## Basic test on cells on top level + fname="Pyfile101.med" + fieldName="field1" + mm=MEDFileUMesh() + coo=DataArrayDouble([(3,2,1),(8,7,6),(5,9,10)]) + m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo) + m.allocateCells() + m.insertNextCell(NORM_TRI3,[0,1,2]) + m.insertNextCell(NORM_TRI3,[3,4,5]) + m.insertNextCell(NORM_TRI3,[6,7,8]) + m.insertNextCell(NORM_TRI3,[9,10,11]) + m.insertNextCell(NORM_QUAD4,[100,101,102,103]) + m.insertNextCell(NORM_QUAD4,[104,105,106,107]) + mm[0]=m + mm.write(fname,2) + arr0=DataArrayDouble([10,11,12,13,100,101]) + f=MEDCouplingFieldDouble(ON_CELLS) ; f.setArray(arr0) ; f.setMesh(m) + f.setName(fieldName) ; f.setTime(2.,6,7) + f0=f.deepCopy() + ff=MEDFileFieldMultiTS() ; ff.appendFieldNoProfileSBT(f) + ff.write(fname,0) + arr2=arr0+1000 ; f.setArray(arr2) + f.setTime(3.,8,9) ; ff=MEDFileField1TS() ; ff.setFieldNoProfileSBT(f) + ff.write(fname,0) + f1=f.deepCopy() + ## + mm=MEDFileMesh.New(fname) + f1ts=MEDFileField1TS(fname,fieldName,6,7) + ftst0=f1ts.field(mm) + self.assertTrue(f0.isEqual(ftst0,1e-12,1e-12)) + f1ts=MEDFileField1TS(fname,fieldName,8,9) + ftst1=f1ts.field(mm) + self.assertTrue(f1.isEqual(ftst1,1e-12,1e-12)) + fmts=MEDFileFieldMultiTS(fname,fieldName) + self.assertTrue(f1.isEqual(fmts.field(8,9,mm),1e-12,1e-12)) + ## Basic test on nodes on top level + f2=MEDCouplingFieldDouble(ON_NODES) ; arr2=DataArrayDouble([200,201,202]) ; arr2.setInfoOnComponent(0,"tutu") ; f2.setArray(arr2) ; f2.setMesh(m) ; f2.setTime(22.,23,24) + f2.setName(fieldName) + mm.write(fname,2) + ff=MEDFileField1TS() ; ff.setFieldNoProfileSBT(f2) ; ff.write(fname,0) + # + mm=MEDFileMesh.New(fname) + f1ts=MEDFileField1TS(fname,fieldName,23,24) + self.assertTrue(f2.isEqual(f1ts.field(mm),1e-12,1e-12)) + fmts=MEDFileFieldMultiTS(fname,fieldName) + self.assertTrue(f2.isEqual(fmts.field(23,24,mm),1e-12,1e-12)) + ## Node on elements + f3=MEDCouplingFieldDouble(ON_GAUSS_NE) ; f3.setMesh(m) ; arr3=DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]) ; f3.setArray(arr3) ; f3.setTime(0.5,2,3) + f3.setName(fieldName) ; f3.checkConsistencyLight() + mm.write(fname,2) ; ff=MEDFileField1TS() ; ff.setFieldNoProfileSBT(f3) ; ff.write(fname,0) + # + mm=MEDFileMesh.New(fname) + f1ts=MEDFileField1TS(fname,fieldName,2,3) + self.assertTrue(f3.isEqual(f1ts.field(mm),1e-12,1e-12)) + ## Gauss + f4=MEDCouplingFieldDouble(ON_GAUSS_PT) ; f4.setMesh(m) ; f4.setName(fieldName) + f4.setGaussLocalizationOnType(NORM_TRI3,[0.,0.,1.,0.,1.,1.],[0.1,0.1, 0.2,0.2, 0.3,0.3, 0.4,0.4, 0.5,0.5],[0.2,0.3,0.1,0.05,0.35]) + f4.setGaussLocalizationOnType(NORM_QUAD4,[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.4, 0.6,0.7],[0.7,0.3]) ; f4.setTime(0.25,4,5) + arr4=DataArrayDouble([0,1,2,3,4 ,10,11,12,13,14, 20,21,22,23,24, 30,31,32,33,34, 45,46, 55,56]) ; arr4.setInfoOnComponent(0,"abc") ; f4.setArray(arr4) + f4.checkConsistencyLight() + mm.write(fname,2) ; ff=MEDFileField1TS() ; ff.setFieldNoProfileSBT(f4) ; ff.write(fname,0) + # + mm=MEDFileMesh.New(fname) + f1ts=MEDFileField1TS(fname,fieldName,4,5) + self.assertTrue(f4.isEqual(f1ts.field(mm),1e-12,1e-12)) + pass + + def testMEDFileFieldEasyField2(self): + """Same thantestMEDFileFieldEasyField1 except that here intfields are considered. + Check for all spatial discretization of field (cells,nodes,elno,gauss) for int field that all is OK. Here no profile and only top level is considered.""" + ## Basic test on cells on top level + fname="Pyfile102.med" + fieldName="field1" + mm=MEDFileUMesh() + coo=DataArrayDouble([(3,2,1),(8,7,6),(5,9,10)]) + m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo) + m.allocateCells() + m.insertNextCell(NORM_TRI3,[0,1,2]) + m.insertNextCell(NORM_TRI3,[3,4,5]) + m.insertNextCell(NORM_TRI3,[6,7,8]) + m.insertNextCell(NORM_TRI3,[9,10,11]) + m.insertNextCell(NORM_QUAD4,[100,101,102,103]) + m.insertNextCell(NORM_QUAD4,[104,105,106,107]) + mm[0]=m + mm.write(fname,2) + arr0=DataArrayInt([10,11,12,13,100,101]) + f=MEDCouplingFieldInt(ON_CELLS) ; f.setArray(arr0) ; f.setMesh(m) + f.setName(fieldName) ; f.setTime(2.,6,7) + f0=f.deepCopy() + ff=MEDFileIntFieldMultiTS() ; ff.appendFieldNoProfileSBT(f) + ff.write(fname,0) + arr2=arr0+1000 ; f.setArray(arr2) + f.setTime(3.,8,9) ; ff=MEDFileIntField1TS() ; ff.setFieldNoProfileSBT(f) + ff.write(fname,0) + f1=f.deepCopy() + ## + mm=MEDFileMesh.New(fname) + f1ts=MEDFileIntField1TS(fname,fieldName,6,7) + ftst0=f1ts.field(mm) + self.assertTrue(f0.isEqual(ftst0,1e-12,1e-12)) + f1ts=MEDFileIntField1TS(fname,fieldName,8,9) + ftst1=f1ts.field(mm) + self.assertTrue(f1.isEqual(ftst1,1e-12,1e-12)) + fmts=MEDFileIntFieldMultiTS(fname,fieldName) + self.assertTrue(f1.isEqual(fmts.field(8,9,mm),1e-12,1e-12)) + ## Basic test on nodes on top level + f2=MEDCouplingFieldInt(ON_NODES) ; arr2=DataArrayInt([200,201,202]) ; arr2.setInfoOnComponent(0,"tutu") ; f2.setArray(arr2) ; f2.setMesh(m) ; f2.setTime(22.,23,24) + f2.setName(fieldName) + mm.write(fname,2) + ff=MEDFileIntField1TS() ; ff.setFieldNoProfileSBT(f2) ; ff.write(fname,0) + # + mm=MEDFileMesh.New(fname) + f1ts=MEDFileIntField1TS(fname,fieldName,23,24) + self.assertTrue(f2.isEqual(f1ts.field(mm),1e-12,1e-12)) + fmts=MEDFileIntFieldMultiTS(fname,fieldName) + self.assertTrue(f2.isEqual(fmts.field(23,24,mm),1e-12,1e-12)) + ## Node on elements + f3=MEDCouplingFieldInt(ON_GAUSS_NE) ; f3.setMesh(m) ; arr3=DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]) ; f3.setArray(arr3) ; f3.setTime(0.5,2,3) + f3.setName(fieldName) ; f3.checkConsistencyLight() + mm.write(fname,2) ; ff=MEDFileIntField1TS() ; ff.setFieldNoProfileSBT(f3) ; ff.write(fname,0) + # + mm=MEDFileMesh.New(fname) + f1ts=MEDFileIntField1TS(fname,fieldName,2,3) + self.assertTrue(f3.isEqual(f1ts.field(mm),1e-12,1e-12)) + ## Gauss + f4=MEDCouplingFieldInt(ON_GAUSS_PT) ; f4.setMesh(m) ; f4.setName(fieldName) + f4.setGaussLocalizationOnType(NORM_TRI3,[0.,0.,1.,0.,1.,1.],[0.1,0.1, 0.2,0.2, 0.3,0.3, 0.4,0.4, 0.5,0.5],[0.2,0.3,0.1,0.05,0.35]) + f4.setGaussLocalizationOnType(NORM_QUAD4,[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.4, 0.6,0.7],[0.7,0.3]) ; f4.setTime(0.25,4,5) + arr4=DataArrayInt([0,1,2,3,4 ,10,11,12,13,14, 20,21,22,23,24, 30,31,32,33,34, 45,46, 55,56]) ; arr4.setInfoOnComponent(0,"abc") ; f4.setArray(arr4) + f4.checkConsistencyLight() + mm.write(fname,2) ; ff=MEDFileIntField1TS() ; ff.setFieldNoProfileSBT(f4) ; ff.write(fname,0) + # + mm=MEDFileMesh.New(fname) + f1ts=MEDFileIntField1TS(fname,fieldName,4,5) + self.assertTrue(f4.isEqual(f1ts.field(mm),1e-12,1e-12)) + pass + + def testMEDFileFieldEasyField3(self): + """Here a multi level mesh. And field on cells lying on different level of this mesh. Show how "field" method deal with that. Here on field double are considered.""" + fname="Pyfile103.med" + fieldName="field1" + mm=MEDFileUMesh() + coo=DataArrayDouble([(3,2,1),(8,7,6),(5,9,10)]) + m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo) + m.allocateCells() + m.insertNextCell(NORM_TRI3,[0,1,2]) + m.insertNextCell(NORM_TRI3,[3,4,5]) + m.insertNextCell(NORM_TRI3,[6,7,8]) + m.insertNextCell(NORM_TRI3,[9,10,11]) + m.insertNextCell(NORM_QUAD4,[100,101,102,103]) + m.insertNextCell(NORM_QUAD4,[104,105,106,107]) + mm[-1]=m + m0=MEDCouplingUMesh("mesh",3) ; m0.setCoords(coo) + m0.allocateCells() + m0.insertNextCell(NORM_TETRA4,[3,2,5,0]) + m0.insertNextCell(NORM_TETRA4,[7,6,3,2]) + mm[0]=m0 + mm.write(fname,2) + # start slowly + f1=MEDCouplingFieldDouble(ON_CELLS) ; f1.setName(fieldName) ; f1.setArray(DataArrayDouble([(0,100),(1,101)])) ; f1.setMesh(mm[0]) ; f1.setTime(4.,1,2) + f1ts=MEDFileField1TS() ; f1ts.setFieldNoProfileSBT(f1) ; f1ts.write(fname,0) + # + mm=MEDFileMesh.New(fname) ; f1ts=MEDFileField1TS(fname,fieldName,1,2) + self.assertTrue(f1.isEqual(f1ts.field(mm),1e-12,1e-12)) + # here f1 lying on level -1 not 0 check if "field" method detect it ! + f1=MEDCouplingFieldDouble(ON_CELLS) ; f1.setName(fieldName) ; f1.setArray(DataArrayDouble([(0,100),(1,101),(0,100),(1,101),(0,100),(1,101)])) + f1.setMesh(mm[-1]) # -1 is very important + f1.setTime(16.,3,4) + f1.checkConsistencyLight() + mm.write(fname,2) + f1ts=MEDFileField1TS() ; f1ts.setFieldNoProfileSBT(f1) ; f1ts.write(fname,0) + # + mm=MEDFileMesh.New(fname) ; f1ts=MEDFileField1TS(fname,fieldName,3,4) + self.assertTrue(f1.isEqual(f1ts.field(mm),1e-12,1e-12)) + # nodes on elements + f3=MEDCouplingFieldDouble(ON_GAUSS_NE) + f3.setMesh(mm[-1]) # this line is important + arr3=DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]) ; f3.setArray(arr3) ; f3.setTime(0.5,2,3) + f3.setName(fieldName) ; f3.checkConsistencyLight() + mm.write(fname,2) ; ff=MEDFileField1TS() ; ff.setFieldNoProfileSBT(f3) ; ff.write(fname,0) + # + mm=MEDFileMesh.New(fname) ; f1ts=MEDFileField1TS(fname,fieldName,2,3) + self.assertTrue(f3.isEqual(f1ts.field(mm),1e-12,1e-12)) + # gauss + f4=MEDCouplingFieldDouble(ON_GAUSS_PT) + f4.setMesh(mm[-1]) # this line is important + f4.setName(fieldName) + f4.setGaussLocalizationOnType(NORM_TRI3,[0.,0.,1.,0.,1.,1.],[0.1,0.1, 0.2,0.2, 0.3,0.3, 0.4,0.4, 0.5,0.5],[0.2,0.3,0.1,0.05,0.35]) + f4.setGaussLocalizationOnType(NORM_QUAD4,[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.4, 0.6,0.7],[0.7,0.3]) ; f4.setTime(0.25,4,5) + arr4=DataArrayDouble([0,1,2,3,4 ,10,11,12,13,14, 20,21,22,23,24, 30,31,32,33,34, 45,46, 55,56]) ; arr4.setInfoOnComponent(0,"abc") ; f4.setArray(arr4) + f4.checkConsistencyLight() + mm.write(fname,2) ; ff=MEDFileField1TS() ; ff.setFieldNoProfileSBT(f4) ; ff.write(fname,0) + mm=MEDFileMesh.New(fname) ; f1ts=MEDFileField1TS(fname,fieldName,4,5) + self.assertTrue(f4.isEqual(f1ts.field(mm),1e-12,1e-12)) + pass + + def testMEDFileFieldEasyField4(self): + """ Same than testMEDFileFieldEasyField3 but with integers""" + fname="Pyfile104.med" + fieldName="field1" + mm=MEDFileUMesh() + coo=DataArrayDouble([(3,2,1),(8,7,6),(5,9,10)]) + m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo) + m.allocateCells() + m.insertNextCell(NORM_TRI3,[0,1,2]) + m.insertNextCell(NORM_TRI3,[3,4,5]) + m.insertNextCell(NORM_TRI3,[6,7,8]) + m.insertNextCell(NORM_TRI3,[9,10,11]) + m.insertNextCell(NORM_QUAD4,[100,101,102,103]) + m.insertNextCell(NORM_QUAD4,[104,105,106,107]) + mm[-1]=m + m0=MEDCouplingUMesh("mesh",3) ; m0.setCoords(coo) + m0.allocateCells() + m0.insertNextCell(NORM_TETRA4,[3,2,5,0]) + m0.insertNextCell(NORM_TETRA4,[7,6,3,2]) + mm[0]=m0 + mm.write(fname,2) + # start slowly + f1=MEDCouplingFieldInt(ON_CELLS) ; f1.setName(fieldName) ; f1.setArray(DataArrayInt([(0,100),(1,101)])) ; f1.setMesh(mm[0]) ; f1.setTime(4.,1,2) + f1ts=MEDFileIntField1TS() ; f1ts.setFieldNoProfileSBT(f1) ; f1ts.write(fname,0) + # + mm=MEDFileMesh.New(fname) ; f1ts=MEDFileIntField1TS(fname,fieldName,1,2) + self.assertTrue(f1.isEqual(f1ts.field(mm),1e-12,1e-12)) + # here f1 lying on level -1 not 0 check if "field" method detect it ! + f1=MEDCouplingFieldInt(ON_CELLS) ; f1.setName(fieldName) ; f1.setArray(DataArrayInt([(0,100),(1,101),(0,100),(1,101),(0,100),(1,101)])) + f1.setMesh(mm[-1]) # -1 is very important + f1.setTime(16.,3,4) + f1.checkConsistencyLight() + mm.write(fname,2) + f1ts=MEDFileIntField1TS() ; f1ts.setFieldNoProfileSBT(f1) ; f1ts.write(fname,0) + # + mm=MEDFileMesh.New(fname) ; f1ts=MEDFileIntField1TS(fname,fieldName,3,4) + self.assertTrue(f1.isEqual(f1ts.field(mm),1e-12,1e-12)) + # nodes on elements + f3=MEDCouplingFieldInt(ON_GAUSS_NE) + f3.setMesh(mm[-1]) # this line is important + arr3=DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]) ; f3.setArray(arr3) ; f3.setTime(0.5,2,3) + f3.setName(fieldName) ; f3.checkConsistencyLight() + mm.write(fname,2) ; ff=MEDFileIntField1TS() ; ff.setFieldNoProfileSBT(f3) ; ff.write(fname,0) + # + mm=MEDFileMesh.New(fname) ; f1ts=MEDFileIntField1TS(fname,fieldName,2,3) + self.assertTrue(f3.isEqual(f1ts.field(mm),1e-12,1e-12)) + # gauss + f4=MEDCouplingFieldInt(ON_GAUSS_PT) + f4.setMesh(mm[-1]) # this line is important + f4.setName(fieldName) + f4.setGaussLocalizationOnType(NORM_TRI3,[0.,0.,1.,0.,1.,1.],[0.1,0.1, 0.2,0.2, 0.3,0.3, 0.4,0.4, 0.5,0.5],[0.2,0.3,0.1,0.05,0.35]) + f4.setGaussLocalizationOnType(NORM_QUAD4,[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.4, 0.6,0.7],[0.7,0.3]) ; f4.setTime(0.25,4,5) + arr4=DataArrayInt([0,1,2,3,4 ,10,11,12,13,14, 20,21,22,23,24, 30,31,32,33,34, 45,46, 55,56]) ; arr4.setInfoOnComponent(0,"abc") ; f4.setArray(arr4) + f4.checkConsistencyLight() + mm.write(fname,2) ; ff=MEDFileIntField1TS() ; ff.setFieldNoProfileSBT(f4) ; ff.write(fname,0) + mm=MEDFileMesh.New(fname) ; f1ts=MEDFileIntField1TS(fname,fieldName,4,5) + self.assertTrue(f4.isEqual(f1ts.field(mm),1e-12,1e-12)) + pass + + def testMEDFileFieldEasyField5(self): + """More and more difficult now look at how profiles are managed by "field" method.""" + fname="Pyfile105.med" + fieldName="field1" + mm=MEDFileUMesh() + coo=DataArrayDouble([(3,2,1),(8,7,6),(5,9,10)]) + m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo) + m.allocateCells() + m.insertNextCell(NORM_TRI3,[0,1,2]) + m.insertNextCell(NORM_TRI3,[3,4,5]) + m.insertNextCell(NORM_TRI3,[6,7,8]) + m.insertNextCell(NORM_TRI3,[9,10,11]) + m.insertNextCell(NORM_QUAD4,[100,101,102,103]) + m.insertNextCell(NORM_QUAD4,[104,105,106,107]) + mm[0]=m + mm.write(fname,2) + pfl=DataArrayInt([0,2,3,5]) ; pfl.setName("pfl") + m2=m.deepCopy()[pfl] ; m2.setName(m.getName()) + # + arr0=DataArrayDouble([10,11,12,13]) + f=MEDCouplingFieldDouble(ON_CELLS) ; f.setArray(arr0) ; f.setMesh(m2) + f.setName(fieldName) ; f.setTime(2.,6,7) ; f.checkConsistencyLight() + ff=MEDFileFieldMultiTS() ; ff.appendFieldProfile(f,mm,0,pfl) # ff is a field on profile + ff.write(fname,0) + # + mm=MEDFileMesh.New(fname) ; f1ts=MEDFileField1TS(fname,fieldName,6,7) + self.assertTrue(f.isEqual(f1ts.field(mm),1e-12,1e-12)) + # more complicated -> multi level + m0=MEDCouplingUMesh("mesh",3) ; m0.setCoords(coo) + m0.allocateCells() + m0.insertNextCell(NORM_TETRA4,[3,2,5,0]) + m0.insertNextCell(NORM_TETRA4,[7,6,3,2]) + mm2=MEDFileUMesh() + mm2[0]=m0 ; mm2[-1]=m + # + ff=MEDFileField1TS() ; ff.setFieldProfile(f,mm2,-1,pfl) + # + mm=MEDFileMesh.New(fname) ; f1ts=MEDFileField1TS(fname,fieldName,6,7) + self.assertTrue(f.isEqual(f1ts.field(mm),1e-12,1e-12)) + pass + + def testExtractPart1(self): + coo=DataArrayDouble([(0,0),(1,0),(2,0),(3,0),(4,0),(0,1),(1,1),(2,1),(3,1),(4,1),(0,2),(1,2),(2,2),(3,2),(4,2)]) + meshName="mesh" + m0=MEDCouplingUMesh(meshName,2) ; m0.setCoords(coo) ; m0.allocateCells() + m0.insertNextCell(NORM_TRI3,[8,4,3]) + m0.insertNextCell(NORM_TRI3,[8,9,4]) + m0.insertNextCell(NORM_TRI3,[7,13,8]) + m0.insertNextCell(NORM_TRI3,[7,12,13]) + m0.insertNextCell(NORM_TRI3,[0,6,1]) + m0.insertNextCell(NORM_TRI3,[0,5,6]) + m0.insertNextCell(NORM_QUAD4,[1,6,7,2]) + m0.insertNextCell(NORM_QUAD4,[2,7,8,3]) + m0.insertNextCell(NORM_QUAD4,[8,13,14,9]) + m0.insertNextCell(NORM_QUAD4,[6,11,12,7]) + m0.insertNextCell(NORM_QUAD4,[5,10,11,6]) + # + m1=MEDCouplingUMesh(meshName,1) ; m1.setCoords(coo) ; m1.allocateCells() + m1.insertNextCell(NORM_SEG2,[10,5]) + m1.insertNextCell(NORM_SEG2,[5,0]) + m1.insertNextCell(NORM_SEG2,[0,1]) + m1.insertNextCell(NORM_SEG2,[1,2]) + m1.insertNextCell(NORM_SEG2,[2,3]) + m1.insertNextCell(NORM_SEG2,[3,4]) + m1.insertNextCell(NORM_SEG2,[4,9]) + m1.insertNextCell(NORM_SEG2,[9,14]) + m1.insertNextCell(NORM_SEG2,[14,13]) + m1.insertNextCell(NORM_SEG2,[13,12]) + m1.insertNextCell(NORM_SEG2,[12,11]) + m1.insertNextCell(NORM_SEG2,[11,10]) + mm=MEDFileUMesh() + mm[0]=m0 ; mm[-1]=m1 + arr0=DataArrayInt([0,1,2,3,4,6,7,8,12,13]) + tab={} # + tab[0]=DataArrayInt([0,2,3,4,6,7]) + tab[-1]=DataArrayInt([2,3,4,5,9]) + fs=MEDFileFields() + self.assertTrue(mm.deduceNodeSubPartFromCellSubPart(tab).isEqual(arr0)) + tab[1]=arr0 + # + fname0="Field0" + fmts=MEDFileFieldMultiTS() ; fs.pushField(fmts) + t0=(16.5,3,4) + ic=["toto [m]"] + arr0_0=DataArrayDouble([100,101,102,103,104,105,106,107,108,109,110]) ; arr0_0.setInfoOnComponents(ic) + f0=MEDCouplingFieldDouble(ON_CELLS) ; f0.setTime(*t0) ; f0.setArray(arr0_0) + f0.setMesh(m0) ; f0.setName(fname0) + f1=MEDCouplingFieldDouble(ON_CELLS) ; f1.setTime(*t0) ; f1.setArray(DataArrayDouble([200,201,202,203,204,205,206,207,208,209,210,211])) + f1.setMesh(m1) ; f1.setName(fname0) ; f1.getArray().setInfoOnComponents(ic) + f2=MEDCouplingFieldDouble(ON_NODES) ; f2.setTime(*t0) ; f2.setArray(DataArrayDouble([300,301,302,303,304,305,306,307,308,309,310,311,312,313,314])) + f2.setMesh(m0) ; f2.setName(fname0) ; f2.getArray().setInfoOnComponents(ic) + f1ts=MEDFileField1TS() ; f1ts.setFieldNoProfileSBT(f0) ; f1ts.setFieldNoProfileSBT(f1) ; f1ts.setFieldNoProfileSBT(f2) + fmts.pushBackTimeStep(f1ts) + # + mmOut=mm.extractPart(tab) + # + fsPart0=fs.extractPart(tab,mm) + self.assertEqual(len(fsPart0),1) + fmtsP=fsPart0[0] + self.assertEqual(len(fmtsP),1) + f1ts=fmtsP[0] + self.assertRaises(InterpKernelException,f1ts.field,mmOut) + # + self.assertTrue(mmOut[0].computeCellCenterOfMass().isEqual(m0[tab[0]].computeCellCenterOfMass(),1e-12)) + self.assertTrue(mmOut[-1].computeCellCenterOfMass().isEqual(m1[tab[-1]].computeCellCenterOfMass(),1e-12)) + # + m0Part=m0.deepCopy()[tab[0]] ; m0Part.renumberNodes(tab[1].invertArrayN2O2O2N(mm.getNumberOfNodes()),len(tab[1])) ; m0Part.setName(m0.getName()) + self.assertTrue(mmOut[0].isEqual(m0Part,1e-12)) + m1Part=m1.deepCopy()[tab[-1]] ; m1Part.renumberNodes(tab[1].invertArrayN2O2O2N(mm.getNumberOfNodes()),len(tab[1])) ; m1Part.setName(m0.getName()) + self.assertTrue(mmOut[0].isEqual(m0Part,1e-12)) + self.assertTrue(mmOut[-1].isEqual(m1Part,1e-12)) + # + f0Part=f1ts.getFieldOnMeshAtLevel(ON_CELLS,0,mmOut) ; f0Part.checkConsistencyLight() + self.assertEqual(f0Part.getTypeOfField(),ON_CELLS) + self.assertTrue(f0Part.getMesh().isEqual(m0Part,1e-12)) + arr0Exp=DataArrayDouble([100,102,103,104,106,107]) ; arr0Exp.setInfoOnComponents(ic) + self.assertTrue(f0Part.getArray().isEqual(arr0Exp,1e-12)) ; self.assertEqual(f0Part.getTime(),list(t0)) + f1Part=f1ts.getFieldOnMeshAtLevel(ON_CELLS,-1,mmOut) ; f1Part.checkConsistencyLight() + self.assertEqual(f1Part.getTypeOfField(),ON_CELLS) + self.assertTrue(f1Part.getMesh().isEqual(m1Part,1e-12)) + arr1Exp=DataArrayDouble([202,203,204,205,209]) ; arr1Exp.setInfoOnComponents(ic) + self.assertTrue(f1Part.getArray().isEqual(arr1Exp,1e-12)) ; self.assertEqual(f1Part.getTime(),list(t0)) + # + f2Part=f1ts.getFieldOnMeshAtLevel(ON_NODES,0,mmOut) ; f2Part.checkConsistencyLight() + arr2Exp=DataArrayDouble([300,301,302,303,304,306,307,308,312,313]) ; arr2Exp.setInfoOnComponents(ic) + self.assertTrue(f2Part.getArray().isEqual(arr2Exp,1e-12)) ; self.assertEqual(f2Part.getTime(),list(t0)) + # multisteps + fs=MEDFileFields() ; fmts=MEDFileFieldMultiTS() ; fs.pushField(fmts) + tss=[(16.5,3,4),(17.5,4,5),(18.5,5,6)] + for i,tt in enumerate(tss): + f0=MEDCouplingFieldDouble(ON_CELLS) ; f0.setTime(*tt) + myarr=arr0_0+i*1000. + f0.setArray(myarr) + f0.setMesh(m0) ; f0.setName(fname0) ; f0.getArray().setInfoOnComponents(ic) + f1ts=MEDFileField1TS() ; f1ts.setFieldNoProfileSBT(f0) ; fmts.pushBackTimeStep(f1ts) + pass + fsPart1=fs.extractPart(tab,mm) + self.assertEqual(len(fsPart1),1) + fmtsP=fsPart1[0] + self.assertEqual(len(fmtsP),len(tss)) + for i,(f1tsP,tt) in enumerate(zip(fmtsP,tss)): + fPart=f1tsP.field(mmOut) ; fPart.checkConsistencyLight() + self.assertEqual(fPart.getTypeOfField(),ON_CELLS) + arr0Exp=DataArrayDouble([100,102,103,104,106,107]) ; arr0Exp.setInfoOnComponents(ic) ; arr0Exp+=i*1000. + self.assertTrue(fPart.getMesh().isEqual(m0Part,1e-12)) + self.assertTrue(fPart.getArray().isEqual(arr0Exp,1e-12)) + self.assertEqual(fPart.getTime(),list(tt)) + pass + pass + + def testSymmetryPlusAggregationMFD1(self): + """ Testing of MEDFileData::Aggregate and MEDFileUMesh::Aggregate and MEDFileUMesh::getAllDistributionOfType """ + fname1="Pyfile106_1.med" + fname2="Pyfile106_2.med" + fname3="Pyfile106_3.med" + meshName="mesh" + mm1=MEDFileUMesh() + da1=DataArrayDouble([1,2,10,3,4,11,5,6,12,7,8,13],4,3) ; da1.setInfoOnComponents(["aa [m]","bbb [kg]","cccc [MW]"]) + mm1.setCoords(da1) + mm1_0=MEDCouplingUMesh(meshName,3) ; mm1_0.allocateCells() + mm1_0.setCoords(da1) + mm1_0.insertNextCell(NORM_TETRA4,[0,1,2,3]) + mm1_0.insertNextCell(NORM_TETRA4,[4,5,6,7]) + mm1_0.insertNextCell(NORM_PENTA6,[8,9,10,11,12,13]) + mm1_0.insertNextCell(NORM_PENTA6,[14,15,16,17,18,19]) + mm1_0.insertNextCell(NORM_PENTA6,[20,21,22,23,24,25]) + mm1[0]=mm1_0 + mm1.setFamilyFieldArr(0,DataArrayInt([1,2,3,4,5])) + mm1.setRenumFieldArr(0,DataArrayInt([11,12,13,14,15])) + # + mm1_1=MEDCouplingUMesh(meshName,2) ; mm1_1.allocateCells() + mm1_1.setCoords(da1) + mm1_1.insertNextCell(NORM_TRI3,[0,1,2]) + mm1_1.insertNextCell(NORM_TRI3,[3,4,5]) + mm1_1.insertNextCell(NORM_QUAD4,[6,7,8,9]) + mm1_1.insertNextCell(NORM_QUAD4,[10,11,12,13]) + mm1_1.insertNextCell(NORM_QUAD4,[14,15,16,17]) + mm1_1.insertNextCell(NORM_QUAD4,[18,19,20,21]) + mm1[-1]=mm1_1 + mm1.setFamilyFieldArr(-1,DataArrayInt([6,7,8,9,10,11])) + mm1.setRenumFieldArr(-1,DataArrayInt([16,17,18,19,20,21])) + for i in range(1,10): + mm1.setFamilyId("F%d"%i,i) + mm1.setFamilyId("FAMILLE_ZERO",0) + mm1.setFamilyId("H1",100) + mm1.setFamiliesOnGroup("myGRP",["F2","F6"]) + mm1.setFamiliesOnGroup("myGRP1",["F2","F6"]) + mm1.setFamilyFieldArr(1,DataArrayInt([12,13,14,15])) + mm1.setRenumFieldArr(1,DataArrayInt([22,23,24,25])) + ############## + mm2=MEDFileUMesh() + da1=DataArrayDouble([9,10,30,11,12,31,13,14,32,15,16,33,17,18,34],5,3) ; da1.setInfoOnComponents(["aa [m]","bbb [kg]","cccc [MW]"]) + mm2.setCoords(da1) + mm2_0=MEDCouplingUMesh(meshName,3) ; mm2_0.allocateCells() + mm2_0.setCoords(da1) + mm2_0.insertNextCell(NORM_TETRA4,[100,101,102,103]) + mm2_0.insertNextCell(NORM_TETRA4,[104,105,106,107]) + mm2_0.insertNextCell(NORM_TETRA4,[108,109,110,111]) + mm2_0.insertNextCell(NORM_PENTA6,[112,113,114,115,116,117]) + mm2[0]=mm2_0 + mm2.setFamilyFieldArr(0,DataArrayInt([40,41,42,43])) + mm2.setRenumFieldArr(0,DataArrayInt([50,51,52,53])) + # + mm2_1=MEDCouplingUMesh(meshName,2) ; mm2_1.allocateCells() + mm2_1.setCoords(da1) + mm2_1.insertNextCell(NORM_TRI3,[100,101,102]) + mm2_1.insertNextCell(NORM_TRI3,[103,104,105]) + mm2_1.insertNextCell(NORM_TRI3,[106,107,108]) + mm2_1.insertNextCell(NORM_QUAD4,[109,110,111,112]) + mm2_1.insertNextCell(NORM_QUAD4,[113,114,115,116]) + mm2_1.insertNextCell(NORM_QUAD4,[117,118,119,120]) + mm2_1.insertNextCell(NORM_QUAD4,[121,122,123,124]) + mm2_1.insertNextCell(NORM_QUAD4,[125,126,127,128]) + mm2[-1]=mm2_1 + mm2.setFamilyFieldArr(-1,DataArrayInt([200,201,202,203,204,205,206,207])) + mm2.setRenumFieldArr(-1,DataArrayInt([300,301,302,303,304,305,306,307])) + for i in range(1,12): + mm2.setFamilyId("G%d"%i,i+30) + mm2.setFamilyId("H1",100) + mm2.setFamilyId("FAMILLE_ZERO",0) + mm2.setFamiliesOnGroup("myGRP",["G2","G6"]) + mm2.setFamiliesOnGroup("myGRP2",["G4","G7"]) + mm2.setFamilyFieldArr(1,DataArrayInt([112,113,114,115,116])) + mm2.setRenumFieldArr(1,DataArrayInt([122,123,124,125,126])) + # + mm=MEDFileUMesh.Aggregate([mm1,mm2]) + ####### + def CheckMesh(tester,mm): + cooExp=DataArrayDouble([(1,2,10),(3,4,11),(5,6,12),(7,8,13),(9,10,30),(11,12,31),(13,14,32),(15,16,33),(17,18,34)]) ; cooExp.setInfoOnComponents(["aa [m]","bbb [kg]","cccc [MW]"]) + tester.assertTrue(mm.getCoords().isEqual(cooExp,1e-12)) + tester.assertTrue(mm[0].getNodalConnectivity().isEqual(DataArrayInt([14,0,1,2,3,14,4,5,6,7,14,104,105,106,107,14,108,109,110,111,14,112,113,114,115,16,8,9,10,11,12,13,16,14,15,16,17,18,19,16,20,21,22,23,24,25,16,116,117,118,119,120,121]))) + tester.assertTrue(mm[0].getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,32,39,46,53]))) + tester.assertTrue(mm[-1].getNodalConnectivity().isEqual(DataArrayInt([3,0,1,2,3,3,4,5,3,104,105,106,3,107,108,109,3,110,111,112,4,6,7,8,9,4,10,11,12,13,4,14,15,16,17,4,18,19,20,21,4,113,114,115,116,4,117,118,119,120,4,121,122,123,124,4,125,126,127,128,4,129,130,131,132]))) + tester.assertTrue(mm[-1].getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20,25,30,35,40,45,50,55,60,65]))) + tester.assertTrue(mm.getFamilyFieldAtLevel(0).isEqual(DataArrayInt([1,2,40,41,42,3,4,5,43]))) + tester.assertTrue(mm.getNumberFieldAtLevel(0).isEqual(DataArrayInt([11,12,50,51,52,13,14,15,53]))) + tester.assertTrue(mm.getFamilyFieldAtLevel(-1).isEqual(DataArrayInt([6,7,200,201,202,8,9,10,11,203,204,205,206,207]))) + tester.assertTrue(mm.getNumberFieldAtLevel(-1).isEqual(DataArrayInt([16,17,300,301,302,18,19,20,21,303,304,305,306,307]))) + refFamIds=[("FAMILLE_ZERO",0),('F1',1),('F2',2),('F3',3),('F4',4),('F5',5),('F6',6),('F7',7),('F8',8),('F9',9),('G1',31),('G10',40),('G11',41),('G2',32),('G3',33),('G4',34),('G5',35),('G6',36),('G7',37),('G8',38),('G9',39),("H1",100)] + tester.assertEqual(set(mm.getFamiliesNames()),set([elt[0] for elt in refFamIds])) + tester.assertEqual(set([mm.getFamilyId(elt) for elt in mm.getFamiliesNames()]),set([elt[1] for elt in refFamIds])) + tester.assertEqual(mm.getGroupsNames(),('myGRP','myGRP1','myGRP2')) + tester.assertEqual(mm.getAllDistributionOfTypes(),[(NORM_TRI3,5),(NORM_QUAD4,9),(NORM_TETRA4,5),(NORM_PENTA6,4),(NORM_ERROR,9)]) + pass + CheckMesh(self,mm) + ## + fieldName="zeField" + t1=(2.3,3,5) + t2=(5.6,7,12) + infoc=["dd [W]","eee [kA]"] + ## + fmts1=MEDFileFieldMultiTS() + f1ts1=MEDFileField1TS() + f1_1=MEDCouplingFieldDouble(ON_CELLS) ; f1_1.setMesh(mm1[0]) ; f1_1.setName(fieldName) + arr1=DataArrayDouble([(10,110),(11,111),(12,112),(13,113),(14,114)]) + arr1.setInfoOnComponents(infoc) + f1_1.setArray(arr1) ; f1_1.setTime(*t1) ; f1_1.setTimeUnit("ms") + f1_1.checkConsistencyLight() + f1ts1.setFieldNoProfileSBT(f1_1) + # + f1_2=MEDCouplingFieldDouble(ON_CELLS) ; f1_2.setMesh(mm1[-1]) ; f1_2.setName(fieldName) + arr2=DataArrayDouble([(15,115),(16,116),(17,117),(18,118),(19,119),(20,120)]) + arr2.setInfoOnComponents(infoc) + f1_2.setArray(arr2) ; f1_2.setTime(*t1) ; f1_2.setTimeUnit("ms") + f1_2.checkConsistencyLight() + f1ts1.setFieldNoProfileSBT(f1_2) + f1_3=MEDCouplingFieldDouble(ON_NODES) ; f1_3.setMesh(mm1[0]) ; f1_3.setName(fieldName) + arr3=DataArrayDouble([(21,121),(22,122),(23,123),(24,124)]) + arr3.setInfoOnComponents(infoc) + f1_3.setArray(arr3) ; f1_3.setTime(*t1) ; f1_3.setTimeUnit("ms") + f1_3.checkConsistencyLight() + f1ts1.setFieldNoProfileSBT(f1_3) + fmts1.pushBackTimeStep(f1ts1) + # + f1ts2=f1ts1.deepCopy() + f1ts2.setTime(t2[1],t2[2],t2[0]) + f1ts2.getUndergroundDataArray()[:]+=2000 + fmts1.pushBackTimeStep(f1ts2) + ### fmts2 + fmts2=MEDFileFieldMultiTS() + f1ts3=MEDFileField1TS() + f2_1=MEDCouplingFieldDouble(ON_CELLS) ; f2_1.setMesh(mm2[0]) ; f2_1.setName(fieldName) + arr4=DataArrayDouble([(50,150),(51,151),(52,152),(53,153)]) + arr4.setInfoOnComponents(infoc) + f2_1.setArray(arr4) ; f2_1.setTime(*t1) ; f2_1.setTimeUnit("ms") + f2_1.checkConsistencyLight() + f1ts3.setFieldNoProfileSBT(f2_1) + f2_2=MEDCouplingFieldDouble(ON_CELLS) ; f2_2.setMesh(mm2[-1]) ; f2_2.setName(fieldName) + arr5=DataArrayDouble([(54,154),(55,155),(56,156),(57,157),(158,158),(59,159),(60,160),(61,161)]) + arr5.setInfoOnComponents(infoc) + f2_2.setArray(arr5) ; f2_2.setTime(*t1) ; f2_2.setTimeUnit("ms") + f2_2.checkConsistencyLight() + f1ts3.setFieldNoProfileSBT(f2_2) + f2_3=MEDCouplingFieldDouble(ON_NODES) ; f2_3.setMesh(mm2[0]) ; f2_3.setName(fieldName) + arr6=DataArrayDouble([(62,162),(63,163),(64,164),(65,165),(66,166)]) + arr6.setInfoOnComponents(infoc) + f2_3.setArray(arr6) ; f2_3.setTime(*t1) ; f2_3.setTimeUnit("ms") + f2_3.checkConsistencyLight() + f1ts3.setFieldNoProfileSBT(f2_3) + fmts2.pushBackTimeStep(f1ts3) + # + f1ts4=f1ts3.deepCopy() + f1ts4.setTime(t2[1],t2[2],t2[0]) + f1ts4.getUndergroundDataArray()[:]+=2000 + fmts2.pushBackTimeStep(f1ts4) + # + mfd1=MEDFileData() + mfd1.setMeshes(MEDFileMeshes()) + mfd1.getMeshes().pushMesh(mm1) + mfd1.setFields(MEDFileFields()) + mfd1.getFields().pushField(fmts1) + # + mfd2=MEDFileData() + mfd2.setMeshes(MEDFileMeshes()) + mfd2.getMeshes().pushMesh(mm2) + mfd2.setFields(MEDFileFields()) + mfd2.getFields().pushField(fmts2) + # ze Call ! + mfd=MEDFileData.Aggregate([mfd1,mfd2]) + def CheckMFD(tester,mfd): + tester.assertEqual(len(mfd.getMeshes()),1) + tester.assertEqual(len(mfd.getFields()),1) + CheckMesh(self,mfd.getMeshes()[0]) + tester.assertEqual(len(mfd.getFields()[0]),2) + zeF1=mfd.getFields()[0][0] + zeF1_1=zeF1.getFieldOnMeshAtLevel(ON_CELLS,0,mfd.getMeshes()[0]) + ref=MEDCouplingFieldDouble.MergeFields([f1_1,f2_1]) + o2n=ref.getMesh().deepCopy().sortCellsInMEDFileFrmt() + ref.renumberCells(o2n) + tester.assertTrue(ref.isEqual(zeF1_1,1e-12,1e-12)) + zeF1_2=zeF1.getFieldOnMeshAtLevel(ON_CELLS,-1,mfd.getMeshes()[0]) + ref=MEDCouplingFieldDouble.MergeFields([f1_2,f2_2]) + o2n=ref.getMesh().deepCopy().sortCellsInMEDFileFrmt() + ref.renumberCells(o2n) + tester.assertTrue(ref.isEqual(zeF1_2,1e-12,1e-12)) + zeF1_3=zeF1.getFieldOnMeshAtLevel(ON_NODES,0,mfd.getMeshes()[0]) + ref=MEDCouplingFieldDouble.MergeFields([f1_3,f2_3]) + o2n=ref.getMesh().deepCopy().sortCellsInMEDFileFrmt() + ref.renumberCells(o2n) + tester.assertTrue(ref.isEqual(zeF1_3,1e-12,1e-12)) + # + zeF2=mfd.getFields()[0][1] + zeF2_1=zeF2.getFieldOnMeshAtLevel(ON_CELLS,0,mfd.getMeshes()[0]) + ref=MEDCouplingFieldDouble.MergeFields([f1_1,f2_1]) + o2n=ref.getMesh().deepCopy().sortCellsInMEDFileFrmt() + ref.renumberCells(o2n) + ref.setTime(*t2) ; ref.getArray()[:]+=2000 + tester.assertTrue(ref.isEqual(zeF2_1,1e-12,1e-12)) + zeF2_2=zeF2.getFieldOnMeshAtLevel(ON_CELLS,-1,mfd.getMeshes()[0]) + ref=MEDCouplingFieldDouble.MergeFields([f1_2,f2_2]) + o2n=ref.getMesh().deepCopy().sortCellsInMEDFileFrmt() + ref.renumberCells(o2n) + ref.setTime(*t2) ; ref.getArray()[:]+=2000 + tester.assertTrue(ref.isEqual(zeF2_2,1e-12,1e-12)) + zeF2_3=zeF2.getFieldOnMeshAtLevel(ON_NODES,0,mfd.getMeshes()[0]) + ref=MEDCouplingFieldDouble.MergeFields([f1_3,f2_3]) + o2n=ref.getMesh().deepCopy().sortCellsInMEDFileFrmt() + ref.renumberCells(o2n) + ref.setTime(*t2) ; ref.getArray()[:]+=2000 + tester.assertTrue(ref.isEqual(zeF2_3,1e-12,1e-12)) + CheckMFD(self,mfd) + mfd1.write(fname1,2) ; mfd2.write(fname2,2) + mfd=MEDFileData.Aggregate([MEDFileData(fname1),MEDFileData(fname2)]) + CheckMFD(self,mfd) + pass + + def testExtrudedMesh1(self): + fname="Pyfile107.med" + arrX=DataArrayDouble([0,1,2,3]) ; arrY=DataArrayDouble([0,1,2,3,4]) ; arrZ=DataArrayDouble([0,1,2,3,4,5]) + mesh3D=MEDCouplingCMesh() ; mesh3D.setCoords(arrX,arrY,arrZ) ; mesh3D.setName("mesh") + ex=MEDCouplingMappedExtrudedMesh(mesh3D) + mm=MEDFileUMesh(ex) + mm.write(fname,2) + ex2=mm.convertToExtrudedMesh() + mm2=MEDFileMesh.New(fname) + ex3=mm2.convertToExtrudedMesh() + self.assertTrue(ex.isEqual(ex2,1e-12)) + self.assertTrue(ex.isEqual(ex3,1e-12)) + pass + + @unittest.skipUnless(LooseVersion(MEDFileVersionStr())>=LooseVersion('3.2.1'),"This test requires at least MEDFile version 3.2.1") + def testWriteInto30(self): + fname="Pyfile108.med" + fname2="Pyfile109.med" + m=MEDCouplingUMesh("mesh",1) ; m.setCoords(DataArrayDouble([0,0,1,1],2,2)) ; m.allocateCells() ; m.insertNextCell(NORM_SEG2,[1,0]) + mm=MEDFileUMesh() ; mm[0]=m + mm.setFamilyId("FAMILLE_ZERO",0) + # + mm.write30(fname,2) + assert(LooseVersion(MEDFileVersionOfFileStr(fname)).version[:2]==[3,0]) # checks that just written MED file has a version == 3.0.x + mm2=MEDFileUMesh(fname) + self.assertTrue(mm.isEqual(mm2,1e-12)) + # + mm.write(fname2,2) + assert(LooseVersion(MEDFileVersionOfFileStr(fname2)).version[:2]==list(MEDFileVersion()[:2])) # checks that MED file version of written mesh is thoose of the current MED file lib + pass pass if __name__ == "__main__": - unittest.main() + unittest.main()