X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDLoader%2FSwig%2FMEDLoaderTest3.py;h=54c30077701e75726b5748e68050e523dd826167;hb=a988fcb09671c95bafbcba8cdcacf29e04ef5841;hp=8536b2a1d5641307ab6040c544c574cf08d8fce1;hpb=be0d06d101f8497d5d51a05c993b4e73da84c947;p=tools%2Fmedcoupling.git diff --git a/src/MEDLoader/Swig/MEDLoaderTest3.py b/src/MEDLoader/Swig/MEDLoaderTest3.py index 8536b2a1d..54c300777 100644 --- a/src/MEDLoader/Swig/MEDLoaderTest3.py +++ b/src/MEDLoader/Swig/MEDLoaderTest3.py @@ -32,6 +32,36 @@ if sys.version_info.major < 3: else: import pickle +class StdOutRedirect(object): + def __init__(self,fileName): + import os,sys + sys.stderr.flush() + self.stdoutOld=os.dup(2) + self.fdOfSinkFile=os.open(fileName,os.O_CREAT | os.O_RDWR) + fd2=os.dup2(self.fdOfSinkFile,2) + self.origPyVal=sys.stderr + class FlushFile(object): + def __init__(self,f): + self.f=f + def write(self,st): + self.f.write(st) + self.f.flush() + def flush(self): + return self.f.flush() + def isatty(self): + return self.f.isatty() + sys.stderr=FlushFile(os.fdopen(self.fdOfSinkFile,"w")) + def __del__(self): + import os,sys + sys.stderr=self.origPyVal + if sys.version_info.major >= 3: + self.fdOfSinkFile.close() + pass + #os.fsync(self.fdOfSinkFile) + os.fsync(2) + os.dup2(self.stdoutOld,2) + os.close(self.stdoutOld) + class MEDLoaderTest3(unittest.TestCase): def testMEDMesh1(self): fileName="Pyfile18.med" @@ -2596,7 +2626,7 @@ class MEDLoaderTest3(unittest.TestCase): 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)) + self.assertTrue(a.isEqual(f1,1e-12,0)) ff1.write(fname,0) ff2=MEDFileAnyTypeField1TS.New(fname) self.assertEqual(ff2.getName(),"VectorFieldOnCells") @@ -2604,7 +2634,7 @@ class MEDLoaderTest3(unittest.TestCase): self.assertTrue(isinstance(ff2,MEDFileIntField1TS)) 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)) + self.assertTrue(a.isEqual(f1,1e-12,0)) ff2.setTime(1,2,3.) c=ff2.getUndergroundDataArray() ; c*=2 ff2.write(fname,0) # 2 time steps in @@ -2613,14 +2643,14 @@ class MEDLoaderTest3(unittest.TestCase): self.assertEqual(len(ffs1),2) self.assertTrue(isinstance(ffs1,MEDFileIntFieldMultiTS)) a=ffs1[2.].getFieldOnMeshAtLevel(ON_CELLS,0,mm1) - self.assertTrue(a.isEqual(f1,1e-12,1e-12)) + self.assertTrue(a.isEqual(f1,1e-12,0)) a=ffs1.getFieldOnMeshAtLevel(ON_CELLS,0,1,0,mm1) - self.assertTrue(a.isEqual(f1,1e-12,1e-12)) + self.assertTrue(a.isEqual(f1,1e-12,0)) it=ffs1.__iter__() ; it.next() ; ff2bis=it.next() 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 + self.assertTrue(a.isEqual(f1,1e-12,0)) ; 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=it.getFieldOnMeshAtLevel(ON_CELLS,0,mm1) @@ -4523,8 +4553,7 @@ class MEDLoaderTest3(unittest.TestCase): grpExp=grp+delta ; grpExp.setName("%s_node"%grp.getName()) self.assertTrue(mm.getGroupArr(1,"%s_node"%grp.getName()).isEqual(grpExp)) pass - - pass + def testMEDFileJoint1(self): fileName="Pyfile92.med" coo=DataArrayDouble([(0,0,0),(1,0,0),(2,0,0)]) @@ -4562,8 +4591,8 @@ class MEDLoaderTest3(unittest.TestCase): self.assertRaises( InterpKernelException, jointsR.getJointAtPos,1) self.assertRaises( InterpKernelException, jointsR.destroyJointAtPos,1) jointsR.destroyJointAtPos(0) - - pass + pass + def testMEDFileJoint2(self): fileNameWr="Pyfile93.med" coo=DataArrayDouble([(0,0,0),(1,0,0),(2,0,0)]) @@ -4656,35 +4685,7 @@ class MEDLoaderTest3(unittest.TestCase): """ EDF11242 : check status of MED file calls to detect problems immediately. Sorry this test generates awful messages !""" fname="Pyfile94.med" errfname="Pyfile94.err" - class StdOutRedirect(object): - def __init__(self,fileName): - import os,sys - sys.stderr.flush() - self.stdoutOld=os.dup(2) - self.fdOfSinkFile=os.open(fileName,os.O_CREAT | os.O_RDWR) - fd2=os.dup2(self.fdOfSinkFile,2) - self.origPyVal=sys.stderr - class FlushFile(object): - def __init__(self,f): - self.f=f - def write(self,st): - self.f.write(st) - self.f.flush() - def flush(self): - return self.f.flush() - def isatty(self): - return self.f.isatty() - sys.stderr=FlushFile(os.fdopen(self.fdOfSinkFile,"w")) - def __del__(self): - import os,sys - sys.stderr=self.origPyVal - if sys.version_info.major >= 3: - self.fdOfSinkFile.close() - pass - #os.fsync(self.fdOfSinkFile) - os.fsync(2) - os.dup2(self.stdoutOld,2) - os.close(self.stdoutOld) + import os # first clean file if needed if os.path.exists(fname): @@ -5230,12 +5231,12 @@ class MEDLoaderTest3(unittest.TestCase): mm=MEDFileMesh.New(fname) f1ts=MEDFileIntField1TS(fname,fieldName,6,7) ftst0=f1ts.field(mm) - self.assertTrue(f0.isEqual(ftst0,1e-12,1e-12)) + self.assertTrue(f0.isEqual(ftst0,1e-12,0)) f1ts=MEDFileIntField1TS(fname,fieldName,8,9) ftst1=f1ts.field(mm) - self.assertTrue(f1.isEqual(ftst1,1e-12,1e-12)) + self.assertTrue(f1.isEqual(ftst1,1e-12,0)) fmts=MEDFileIntFieldMultiTS(fname,fieldName) - self.assertTrue(f1.isEqual(fmts.field(8,9,mm),1e-12,1e-12)) + self.assertTrue(f1.isEqual(fmts.field(8,9,mm),1e-12,0)) ## 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) @@ -5244,9 +5245,9 @@ class MEDLoaderTest3(unittest.TestCase): # mm=MEDFileMesh.New(fname) f1ts=MEDFileIntField1TS(fname,fieldName,23,24) - self.assertTrue(f2.isEqual(f1ts.field(mm),1e-12,1e-12)) + self.assertTrue(f2.isEqual(f1ts.field(mm),1e-12,0)) fmts=MEDFileIntFieldMultiTS(fname,fieldName) - self.assertTrue(f2.isEqual(fmts.field(23,24,mm),1e-12,1e-12)) + self.assertTrue(f2.isEqual(fmts.field(23,24,mm),1e-12,0)) ## 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() @@ -5254,7 +5255,7 @@ class MEDLoaderTest3(unittest.TestCase): # mm=MEDFileMesh.New(fname) f1ts=MEDFileIntField1TS(fname,fieldName,2,3) - self.assertTrue(f3.isEqual(f1ts.field(mm),1e-12,1e-12)) + self.assertTrue(f3.isEqual(f1ts.field(mm),1e-12,0)) ## 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]) @@ -5265,7 +5266,7 @@ class MEDLoaderTest3(unittest.TestCase): # mm=MEDFileMesh.New(fname) f1ts=MEDFileIntField1TS(fname,fieldName,4,5) - self.assertTrue(f4.isEqual(f1ts.field(mm),1e-12,1e-12)) + self.assertTrue(f4.isEqual(f1ts.field(mm),1e-12,0)) pass def testMEDFileFieldEasyField3(self): @@ -5353,7 +5354,7 @@ class MEDLoaderTest3(unittest.TestCase): 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)) + self.assertTrue(f1.isEqual(f1ts.field(mm),1e-12,0)) # 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 @@ -5363,7 +5364,7 @@ class MEDLoaderTest3(unittest.TestCase): 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)) + self.assertTrue(f1.isEqual(f1ts.field(mm),1e-12,0)) # nodes on elements f3=MEDCouplingFieldInt(ON_GAUSS_NE) f3.setMesh(mm[-1]) # this line is important @@ -5372,7 +5373,7 @@ class MEDLoaderTest3(unittest.TestCase): 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)) + self.assertTrue(f3.isEqual(f1ts.field(mm),1e-12,0)) # gauss f4=MEDCouplingFieldInt(ON_GAUSS_PT) f4.setMesh(mm[-1]) # this line is important @@ -5383,7 +5384,7 @@ class MEDLoaderTest3(unittest.TestCase): 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)) + self.assertTrue(f4.isEqual(f1ts.field(mm),1e-12,0)) pass def testMEDFileFieldEasyField5(self): @@ -5900,12 +5901,12 @@ class MEDLoaderTest3(unittest.TestCase): fmts5=pickle.loads(st) self.assertEqual(len(fs4[0]),len(fmts5)) self.assertTrue(isinstance(fmts5,MEDFileIntFieldMultiTS)) - self.assertTrue(fmts5[0].field(ms4[0]).isEqual((fs4[0][0]).field(ms4[0]),1e-12,1e-12)) + self.assertTrue(fmts5[0].field(ms4[0]).isEqual((fs4[0][0]).field(ms4[0]),1e-12,0)) # MEDFileIntField1TS st=pickle.dumps(fs4[0][0],pickle.HIGHEST_PROTOCOL) f1ts6=pickle.loads(st) self.assertTrue(isinstance(f1ts6,MEDFileIntField1TS)) - self.assertTrue(f1ts6.field(ms4[0]).isEqual((fs4[0][0]).field(ms4[0]),1e-12,1e-12)) + self.assertTrue(f1ts6.field(ms4[0]).isEqual((fs4[0][0]).field(ms4[0]),1e-12,0)) # MEDFileParameters self.testParameters1()# generates Pyfile56.med params=MEDFileParameters("Pyfile56.med") @@ -5989,6 +5990,190 @@ class MEDLoaderTest3(unittest.TestCase): self.assertTrue(ff1.field(mm).isEqual(f3,1e-12,1e-12)) pass + def testFloat32InMEDFileFieldStar1(self): + """Like testInt32InMEDFileFieldStar1 but with float32 :)""" + fname="Pyfile114.med" + f1=MEDLoaderDataForTest.buildVecFieldOnCells_1(); + f1=f1.convertToFloatField() + m1=f1.getMesh() + mm1=MEDFileUMesh.New() + mm1.setCoords(m1.getCoords()) + mm1.setMeshAtLevel(0,m1) + mm1.setName(m1.getName()) + mm1.write(fname,2) + ff1=MEDFileFloatField1TS() + 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,MEDFileFloatField1TS)) + 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 + ff2.write(fname,0) # 2 time steps in + ffs1=MEDFileAnyTypeFieldMultiTS.New(fname,"VectorFieldOnCells") + self.assertEqual(ffs1.getTimeSteps(),[(0, 1, 2.0), (1, 2, 3.0)]) + self.assertEqual(len(ffs1),2) + self.assertTrue(isinstance(ffs1,MEDFileFloatFieldMultiTS)) + a=ffs1[2.].getFieldOnMeshAtLevel(ON_CELLS,0,mm1) + self.assertTrue(a.isEqual(f1,1e-12,1e-12)) + 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=ff2bis.getFieldOnMeshAtLevel(0,ON_CELLS,mm1) + self.assertTrue(a.getArray().isEqual(2*f1.getArray(),1e-7)) + f1.setTime(3.,1,2) ; f1.getArray()[:]*=2 + self.assertTrue(a.isEqual(f1,1e-12,1e-12)) ; f1.getArray()[:]/=2 + bc=DataArrayFloat(6,3) ; bc[:]=0 ; bc.setInfoOnComponents(['power [MW/m^3]','density [g/cm^3]','temperature [K]']) + for it in ffs1: + a=it.getFieldOnMeshAtLevel(ON_CELLS,0,mm1) + bc+=a.getArray() + pass + self.assertTrue(bc.isEqual(3*f1.getArray(),1e-7)) + nf1=MEDCouplingFieldFloat(ON_NODES) + nf1.setTime(9.,10,-1) + nf1.setMesh(f1.getMesh()) + narr=DataArrayFloat(12,2) ; narr.setInfoOnComponents(["aa [u1]","bbbvv [ppp]"]) ; narr[:,0]=list(range(12)) ; narr[:,1]=2*narr[:,0] + nf1.setName("VectorFieldOnNodes") ; nf1.setArray(narr) + nff1=MEDFileFloatField1TS.New() + nff1.setFieldNoProfileSBT(nf1) + self.assertEqual(nff1.getInfo(),('aa [u1]','bbbvv [ppp]')) + self.assertEqual(nff1.getTime(),[10,-1,9.0]) + nff1.write(fname,0) + # + nf2=MEDCouplingFieldFloat(ON_NODES) + nf2.setTime(19.,20,-11) + nf2.setMesh(f1.getMesh()) + narr2=DataArrayFloat(8,2) ; narr.setInfoOnComponents(["aapfl [u1]","bbbvvpfl [ppp]"]) ; narr2[:,0]=list(range(8)) ; narr2[:,0]+=10 ; narr2[:,1]=3*narr2[:,0] + nf2.setName("VectorFieldOnNodesPfl") ; narr2.setName(nf2.getName()) ; nf2.setArray(narr2) + nff2=MEDFileFloatField1TS.New() + npfl=DataArrayInt([1,2,4,5,6,7,10,11]) ; npfl.setName("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)) + self.assertTrue(a.isEqual(narr2,1e-7)) + nff2.write(fname,0) + nff2bis=MEDFileFloatField1TS(fname,"VectorFieldOnNodesPfl") + a,b=nff2bis.getFieldWithProfile(ON_NODES,0,mm1) ; b.setName(npfl.getName()) + self.assertTrue(b.isEqual(npfl)) + self.assertTrue(a.isEqual(narr2,1e-7)) + # + nf3=MEDCouplingFieldDouble(ON_NODES) + nf3.setName("VectorFieldOnNodesDouble") + nf3.setTime(29.,30,-21) + nf3.setMesh(f1.getMesh()) + nf3.setArray(f1.getMesh().getCoords()) + nff3=MEDFileField1TS.New() + nff3.setFieldNoProfileSBT(nf3) + nff3.write(fname,0) + fs=MEDFileFields(fname) + self.assertEqual(len(fs),4) + ffs=[it for it in fs] + self.assertTrue(isinstance(ffs[0],MEDFileFloatFieldMultiTS)) + self.assertTrue(isinstance(ffs[1],MEDFileFloatFieldMultiTS)) + self.assertTrue(isinstance(ffs[2],MEDFileFieldMultiTS)) + self.assertTrue(isinstance(ffs[3],MEDFileFloatFieldMultiTS)) + # + self.assertTrue(fs["VectorFieldOnCells"][0].getUndergroundDataArray().isEqualWithoutConsideringStr(f1.getArray(),1e-7)) + self.assertTrue(fs["VectorFieldOnCells"][1,2].getUndergroundDataArray().isEqualWithoutConsideringStr(2*f1.getArray(),1e-7)) + self.assertTrue(fs["VectorFieldOnNodesPfl"][0].getUndergroundDataArray().isEqualWithoutConsideringStr(narr2,1e-7)) + self.assertTrue(fs["VectorFieldOnNodes"][9.].getUndergroundDataArray().isEqualWithoutConsideringStr(narr,1e-7)) + self.assertTrue(fs["VectorFieldOnNodesDouble"][29.].getUndergroundDataArray().isEqualWithoutConsideringStr(f1.getMesh().getCoords(),1e-12)) + # + nf3_read=MEDFileFieldMultiTS(fname,"VectorFieldOnNodesDouble") + self.assertTrue(nf3_read[29.].getUndergroundDataArray().isEqualWithoutConsideringStr(f1.getMesh().getCoords(),1e-12)) + self.assertRaises(InterpKernelException,MEDFileFloatFieldMultiTS.New,fname,"VectorFieldOnNodesDouble")# exception because trying to read a double field with int instance + self.assertRaises(InterpKernelException,MEDFileFieldMultiTS.New,fname,"VectorFieldOnNodes")# exception because trying to read a int field with double instance + MEDFileField1TS.New(fname,"VectorFieldOnNodesDouble",30,-21) + self.assertRaises(InterpKernelException,MEDFileFloatField1TS.New,fname,"VectorFieldOnNodesDouble",30,-21)# exception because trying to read a double field with int instance + MEDFileFloatField1TS.New(fname,"VectorFieldOnNodes",10,-1) + self.assertRaises(InterpKernelException,MEDFileField1TS.New,fname,"VectorFieldOnNodes",10,-1)# exception because trying to read a double field with int instance + # + self.assertEqual(fs.getMeshesNames(),('3DSurfMesh_1','3DSurfMesh_1','3DSurfMesh_1','3DSurfMesh_1')) + self.assertTrue(fs.changeMeshNames([('3DSurfMesh_1','3DSurfMesh')])) + self.assertEqual(fs.getMeshesNames(),('3DSurfMesh','3DSurfMesh','3DSurfMesh','3DSurfMesh')) + self.assertTrue(not fs.changeMeshNames([('3DSurfMesh_1','3DSurfMesh')])) + pass + + def testPenta18_1(self): + """EDF8478 : Test of read/write of penta18""" + fname="Pyfile115.med" + arr=DataArrayDouble([ + (0.,1.,1.),(0.,0.,1.),(1.,0.,1.), + (0.,1.,0.),(0.,0.,0.),(1.,0.,0.), + (0.,0.5,1.),(0.5,0.,1.),(0.5,0.5,1.), + (0.,0.5,0.),(0.5,0.,0.),(0.5,0.5,0.), + (0.,1.,0.5),(0.,0.,0.5),(1.,0.,0.5), + (0.,0.5,0.5),(0.5,0.,0.5),(0.5,0.5,0.5)]) + m=MEDCouplingUMesh("mesh",3) + m.setCoords(arr) + m.allocateCells(1) + m.insertNextCell(NORM_PENTA18,list(range(18))) + m.checkConsistencyLight() + # + f=MEDCouplingFieldDouble(ON_NODES) + f.setMesh(m) + f.setName("FieldOnPenta18") + f.setArray(DataArrayDouble(list(range(18)))) + f.checkConsistencyLight() + # + m2,d,di,rd,rdi=m.buildDescendingConnectivity() + # + f2=MEDCouplingFieldDouble(ON_NODES) + f2.setMesh(m) + f2.setName("FieldOnPenta18Sub") + f2.setArray(DataArrayDouble(list(range(18)))) + f2.checkConsistencyLight() + WriteField(fname,f2,True) + f3=ReadField(fname) + self.assertTrue(f2.isEqual(f3,1e-12,1e-12)) + self.assertEqual(f3.getMesh().getNumberOfCells(),1) + self.assertEqual(f3.getMesh().getTypeOfCell(0),NORM_PENTA18) + pass + + @unittest.skipUnless('linux'==platform.system().lower(),"stderr redirection not ported on Windows ?") + def testMedFileCapabilityToCryOnNewFeatureWritingIntoOldFiles(self): + fname="Pyfile116.med" + errfname="Pyfile116.err" + c=DataArrayDouble([0,1,2,3]) + m=MEDCouplingCMesh() + m.setCoords(c,c) + m=m.buildUnstructured() + m.setName("mesh") + mm=MEDFileUMesh() + mm[0]=m + f=MEDCouplingFieldInt(ON_CELLS) + f.setMesh(m) ; arr2=DataArrayInt(m.getNumberOfCells()) ; arr2.iota() + f.setArray(arr2) + f.setName("field") + f1ts=MEDFileIntField1TS() + f1ts.setFieldNoProfileSBT(f) + mm.write30(fname,2) + f1ts.write30(fname,0) + # + f=MEDCouplingFieldFloat(ON_CELLS) + f.setMesh(m) ; arr2=DataArrayFloat(m.getNumberOfCells()) ; arr2.iota() + f.setArray(arr2) + f.setName("field2") + f1ts=MEDFileFloatField1TS() + f1ts.setFieldNoProfileSBT(f) + # + import os,gc + tmp=StdOutRedirect(errfname) + self.assertRaises(InterpKernelException,f1ts.write30,fname,0) + del tmp + gc.collect(0) + if os.path.exists(errfname): + os.remove(errfname) + pass + pass if __name__ == "__main__":