src/MEDLoader/Swig/MEDLoaderTest4.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2013  CEA/DEN, EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 # Author : Anthony Geay (CEA/DEN)
  21
  22 from MEDLoader import *
  23 import unittest
  24 from math import pi,e,sqrt
  25
  26 class MEDLoaderTest4(unittest.TestCase):
  27     """
  28     Test series to emulate the future MEDReader plugin for PARAVIS.
  29     """
  30     def test1(self):
  31         """
  32         This test is the most simple one. One time serie of one field with only cell fields with no profiles.
  33         The only "difficulty" is that the cell field is lying on different levels (2D and 1D) to maximize the compatibility with ParaVIS.
  34         """
  35         fname="ForMEDReader1.med"
  36         # building a mesh containing 4 tri3 + 5 quad4
  37         tri=MEDCouplingUMesh("tri",2)
  38         tri.allocateCells() ; tri.insertNextCell(NORM_TRI3,[0,1,2])
  39         tri.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,0.)]))
  40         tris=[tri.deepCpy() for i in xrange(4)]
  41         for i,elt in enumerate(tris): elt.translate([i,0])
  42         tris=MEDCouplingUMesh.MergeUMeshes(tris)
  43         quad=MEDCouplingUMesh("quad",2)
  44         quad.allocateCells() ; quad.insertNextCell(NORM_QUAD4,[0,1,2,3])
  45         quad.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,1.),(1.,0.)]))
  46         quads=[quad.deepCpy() for i in xrange(5)]
  47         for i,elt in enumerate(quads): elt.translate([5+i,0])
  48         quads=MEDCouplingUMesh.MergeUMeshes(quads)
  49         m=MEDCouplingUMesh.MergeUMeshes(tris,quads)
  50         m.setName("mesh") ; m.getCoords().setInfoOnComponents(["XX [m]","YYY [km]"])
  51         m1=m.buildDescendingConnectivity()[0]
  52         mm=MEDFileUMesh() ; mm.setMeshes([m,m1])
  53         fam=DataArrayInt(9) ; fam.iota(0) ; mm.setFamilyFieldArr(0,fam)
  54         fam=DataArrayInt(32) ; fam.iota(20) ; mm.setFamilyFieldArr(-1,fam) ; del fam
  55         num=DataArrayInt(9) ; num.iota(100) ; mm.setRenumFieldArr(0,num)
  56         num=DataArrayInt(32) ; num.iota(120) ; mm.setRenumFieldArr(-1,num) ; del num
  57         #
  58         fieldName="zeField"
  59         fs=MEDFileFieldMultiTS()
  60         ##### Time step 0
  61         i=0
  62         f=MEDFileField1TS()
  63         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
  64         fCell0.setName(fieldName) ; fCell0.setMesh(m)
  65         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(100) ; arr.rearrange(2)
  66         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
  67         fCell0.checkCoherency()
  68         f.setFieldNoProfileSBT(fCell0)
  69         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
  70         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
  71         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(200) ; arr.rearrange(2)
  72         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
  73         fCell1.checkCoherency()
  74         f.setFieldNoProfileSBT(fCell1)
  75         fs.pushBackTimeStep(f)
  76         ##### Time step 1
  77         i=1
  78         f=MEDFileField1TS()
  79         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
  80         fCell0.setName(fieldName) ; fCell0.setMesh(m)
  81         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(1100) ; arr.rearrange(2)
  82         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
  83         fCell0.checkCoherency()
  84         f.setFieldNoProfileSBT(fCell0)
  85         #
  86         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
  87         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
  88         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(1200) ; arr.rearrange(2)
  89         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
  90         fCell1.checkCoherency()
  91         f.setFieldNoProfileSBT(fCell1)
  92         fs.pushBackTimeStep(f)
  93         ##### Time step 2
  94         i=2
  95         f=MEDFileField1TS()
  96         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
  97         fCell0.setName(fieldName) ; fCell0.setMesh(m)
  98         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(2100) ; arr.rearrange(2)
  99         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 100         fCell0.checkCoherency()
 101         f.setFieldNoProfileSBT(fCell0)
 102         #
 103         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 104         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 105         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(2200) ; arr.rearrange(2)
 106         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 107         fCell1.checkCoherency()
 108         f.setFieldNoProfileSBT(fCell1)
 109         fs.pushBackTimeStep(f)
 110         ##### Time step 3
 111         i=3
 112         f=MEDFileField1TS()
 113         #
 114         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 115         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 116         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(3100) ; arr.rearrange(2)
 117         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 118         fCell0.checkCoherency()
 119         f.setFieldNoProfileSBT(fCell0)
 120         #
 121         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 122         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 123         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(3200) ; arr.rearrange(2)
 124         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 125         fCell1.checkCoherency()
 126         f.setFieldNoProfileSBT(fCell1)
 127         #
 128         fs.pushBackTimeStep(f)
 129         ##### Time step 4
 130         i=4
 131         f=MEDFileField1TS()
 132         #
 133         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 134         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 135         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(4100) ; arr.rearrange(2)
 136         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 137         fCell0.checkCoherency()
 138         f.setFieldNoProfileSBT(fCell0)
 139         #
 140         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 141         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 142         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(4200) ; arr.rearrange(2)
 143         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 144         fCell1.checkCoherency()
 145         f.setFieldNoProfileSBT(fCell1)
 146         fs.pushBackTimeStep(f)
 147         mm.write(fname,2)
 148         fs.write(fname,0)
 149         a0Exp=mm.getCoords().deepCpy()
 150         del m,m1,mm,fs,f,fCell0,fCell1
 151         ########## GO for reading in MEDReader, by not loading all. Mesh is fully loaded but not fields values
 152         ms=MEDFileMeshes(fname)
 153         fields=MEDFileFields(fname,False) # False is important to not read the values
 154         refMem=fields.getHeapMemorySize()
 155         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
 156         allFMTSLeavesToDisplay=[]
 157         for fields in fields_per_mesh:
 158             allFMTSLeavesToDisplay2=[]
 159             for fmts in fields:
 160                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
 161                 pass
 162             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
 163             pass
 164         self.assertEqual(len(allFMTSLeavesToDisplay),1)
 165         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
 166         for fmts in allFMTSLeavesToDisplay[0]:
 167             self.assertEqual(fmts.getTimeSteps(),[(0,0,0.),(1,0,1.),(2,0,2.),(3,0,3.),(4,0,4.)]) # All discretizations have the same time series
 168             pass
 169         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
 170         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
 171         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
 172         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
 173         #
 174         mst=MEDFileMeshStruct.New(ms[0])
 175         fcscp=allFMTSLeavesPerCommonSupport[0][1]
 176         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
 177         mml2=mml.prepare()
 178         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
 179         for i in xrange(1,5):
 180             self.assertTrue(fcscp.isDataSetSupportEqualToThePreviousOne(i,fields))
 181             pass
 182         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
 183         self.assertTrue(not ncc)
 184         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
 185         self.assertTrue(a1.isEqual(DataArrayByte([3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,5,5,5,5,9,9,9,9,9])))
 186         self.assertTrue(a2.isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69,72,75,78,81,84,87,90,93,96,100,104,108,112,117,122,127,132])))
 187         self.assertTrue(a3.isEqual(DataArrayInt([2,0,1,2,1,2,2,2,0,2,3,4,2,4,5,2,5,3,2,6,7,2,7,8,2,8,6,2,9,10,2,10,11,2,11,9,2,12,13,2,13,14,2,14,15,2,15,12,2,16,17,2,17,18,2,18,19,2,19,16,2,20,21,2,21,22,2,22,23,2,23,20,2,24,25,2,25,26,2,26,27,2,27,24,2,28,29,2,29,30,2,30,31,2,31,28,3,0,1,2,3,3,4,5,3,6,7,8,3,9,10,11,4,12,13,14,15,4,16,17,18,19,4,20,21,22,23,4,24,25,26,27,4,28,29,30,31])))
 188         self.assertTrue(a4 is None)
 189         self.assertTrue(a5 is None)
 190         a6,a7=mml2.retrieveFamilyIdsOnCells()
 191         self.assertTrue(a6.isEqual(DataArrayInt([20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,0,1,2,3,4,5,6,7,8])))
 192         self.assertTrue(not a7)
 193         a8,a9=mml2.retrieveNumberIdsOnCells()
 194         self.assertTrue(a8.isEqual(DataArrayInt([120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,100,101,102,103,104,105,106,107,108])))
 195         self.assertTrue(not a9)
 196         for i in xrange(5):
 197             fsst=MEDFileField1TSStructItem.BuildItemFrom(fields[0][i],mst)
 198             fields[0][i].loadArraysIfNecessary()
 199             tmpMem=fields.getHeapMemorySize()
 200             self.assertTrue(tmpMem-refMem>=41*2*8)
 201             refMem=tmpMem
 202             v=mml.buildDataArray(fsst,fields,fields[0][i].getUndergroundDataArray())
 203             self.assertEqual(v.getHiddenCppPointer(),fields[0][i].getUndergroundDataArray().getHiddenCppPointer())
 204             vExp=DataArrayDouble([200.,201.,202.,203.,204.,205.,206.,207.,208.,209.,210.,211.,212.,213.,214.,215.,216.,217.,218.,219.,220.,221.,222.,223.,224.,225.,226.,227.,228.,229.,230.,231.,232.,233.,234.,235.,236.,237.,238.,239.,240.,241.,242.,243.,244.,245.,246.,247.,248.,249.,250.,251.,252.,253.,254.,255.,256.,257.,258.,259.,260.,261.,262.,263.,100.,101.,102.,103.,104.,105.,106.,107.,108.,109.,110.,111.,112.,113.,114.,115.,116.,117.],41,2) ; vExp.setInfoOnComponents(['Comp1 [m]','Com2 [s^2]']) ; vExp+=i*1000
 205             self.assertTrue(v.isEqual(vExp,1e-12))
 206             pass
 207         pass
 208
 209     def test2(self):
 210         """
 211         One time serie of one field with cell and node discretization in the same field with no profiles.
 212         Here as there is no profile only one VTK support is requested.
 213         """
 214         fname="ForMEDReader2.med"
 215         # building a mesh containing 4 tri3 + 5 quad4
 216         tri=MEDCouplingUMesh("tri",2)
 217         tri.allocateCells() ; tri.insertNextCell(NORM_TRI3,[0,1,2])
 218         tri.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,0.)]))
 219         tris=[tri.deepCpy() for i in xrange(4)]
 220         for i,elt in enumerate(tris): elt.translate([i,0])
 221         tris=MEDCouplingUMesh.MergeUMeshes(tris)
 222         quad=MEDCouplingUMesh("quad",2)
 223         quad.allocateCells() ; quad.insertNextCell(NORM_QUAD4,[0,1,2,3])
 224         quad.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,1.),(1.,0.)]))
 225         quads=[quad.deepCpy() for i in xrange(5)]
 226         for i,elt in enumerate(quads): elt.translate([5+i,0])
 227         quads=MEDCouplingUMesh.MergeUMeshes(quads)
 228         m=MEDCouplingUMesh.MergeUMeshes(tris,quads)
 229         m.setName("mesh") ; m.getCoords().setInfoOnComponents(["XX [m]","YYY [km]"])
 230         m1=m.buildDescendingConnectivity()[0]
 231         mm=MEDFileUMesh() ; mm.setMeshes([m,m1])
 232         #
 233         fieldName="zeField"
 234         fs=MEDFileFieldMultiTS()
 235         ##### Time step 0
 236         i=0
 237         f=MEDFileField1TS()
 238         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 239         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 240         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(100) ; arr.rearrange(2)
 241         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 242         fCell0.checkCoherency()
 243         f.setFieldNoProfileSBT(fCell0)
 244         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 245         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 246         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(200) ; arr.rearrange(2)
 247         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 248         fCell1.checkCoherency()
 249         f.setFieldNoProfileSBT(fCell1)
 250         #
 251         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 252         fNode.setName(fieldName) ; fNode.setMesh(m1)
 253         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(300) ; arr.rearrange(2)
 254         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 255         fNode.checkCoherency()
 256         f.setFieldNoProfileSBT(fNode)
 257         fs.pushBackTimeStep(f)
 258         ##### Time step 1
 259         i=1
 260         f=MEDFileField1TS()
 261         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 262         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 263         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(1100) ; arr.rearrange(2)
 264         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 265         fCell0.checkCoherency()
 266         f.setFieldNoProfileSBT(fCell0)
 267         #
 268         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 269         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 270         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(1200) ; arr.rearrange(2)
 271         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 272         fCell1.checkCoherency()
 273         f.setFieldNoProfileSBT(fCell1)
 274         #
 275         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 276         fNode.setName(fieldName) ; fNode.setMesh(m1)
 277         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(1300) ; arr.rearrange(2)
 278         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 279         fNode.checkCoherency()
 280         f.setFieldNoProfileSBT(fNode)
 281         fs.pushBackTimeStep(f)
 282         ##### Time step 2
 283         i=2
 284         f=MEDFileField1TS()
 285         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 286         fNode.setName(fieldName) ; fNode.setMesh(m1)
 287         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(2300) ; arr.rearrange(2)
 288         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 289         fNode.checkCoherency()
 290         f.setFieldNoProfileSBT(fNode)
 291         #
 292         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 293         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 294         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(2100) ; arr.rearrange(2)
 295         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 296         fCell0.checkCoherency()
 297         f.setFieldNoProfileSBT(fCell0)
 298         #
 299         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 300         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 301         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(2200) ; arr.rearrange(2)
 302         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 303         fCell1.checkCoherency()
 304         f.setFieldNoProfileSBT(fCell1)
 305         fs.pushBackTimeStep(f)
 306         ##### Time step 3
 307         i=3
 308         f=MEDFileField1TS()
 309         #
 310         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 311         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 312         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(3100) ; arr.rearrange(2)
 313         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 314         fCell0.checkCoherency()
 315         f.setFieldNoProfileSBT(fCell0)
 316         #
 317         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 318         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 319         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(3200) ; arr.rearrange(2)
 320         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 321         fCell1.checkCoherency()
 322         f.setFieldNoProfileSBT(fCell1)
 323         #
 324         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 325         fNode.setName(fieldName) ; fNode.setMesh(m1)
 326         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(3300) ; arr.rearrange(2)
 327         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 328         fNode.checkCoherency()
 329         f.setFieldNoProfileSBT(fNode)
 330         #
 331         fs.pushBackTimeStep(f)
 332         ##### Time step 4
 333         i=4
 334         f=MEDFileField1TS()
 335         #
 336         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 337         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 338         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(4100) ; arr.rearrange(2)
 339         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 340         fCell0.checkCoherency()
 341         f.setFieldNoProfileSBT(fCell0)
 342         #
 343         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 344         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 345         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(4200) ; arr.rearrange(2)
 346         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 347         fCell1.checkCoherency()
 348         f.setFieldNoProfileSBT(fCell1)
 349         #
 350         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 351         fNode.setName(fieldName) ; fNode.setMesh(m1)
 352         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(4300) ; arr.rearrange(2)
 353         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 354         fNode.checkCoherency()
 355         f.setFieldNoProfileSBT(fNode)
 356         #
 357         fs.pushBackTimeStep(f)
 358         mm.write(fname,2)
 359         fs.write(fname,0)
 360         a0Exp=mm.getCoords().deepCpy()
 361         del m,m1,mm,fs,f,fCell0,fCell1
 362         ########## GO for reading in MEDReader, by not loading all. Mesh is fully loaded but not fields values
 363         ms=MEDFileMeshes(fname)
 364         fields=MEDFileFields(fname,False)
 365         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
 366         allFMTSLeavesToDisplay=[]
 367         for fields in fields_per_mesh:
 368             allFMTSLeavesToDisplay2=[]
 369             for fmts in fields:
 370                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
 371                 pass
 372             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
 373             pass
 374         self.assertEqual(len(allFMTSLeavesToDisplay),1)
 375         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
 376         for fmts in allFMTSLeavesToDisplay[0]:
 377             self.assertEqual(fmts.getTimeSteps(),[(0,0,0.),(1,0,1.),(2,0,2.),(3,0,3.),(4,0,4.)]) # All discretizations have the same time series
 378             pass
 379         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
 380         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
 381         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
 382         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
 383         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
 384         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
 385         #
 386         mst=MEDFileMeshStruct.New(ms[0])
 387         fcscp=allFMTSLeavesPerCommonSupport[0][1]
 388         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
 389         mml2=mml.prepare()
 390         assert isinstance(mml2,MEDUMeshMultiLev)
 391         for i in xrange(1,5):
 392             self.assertTrue(fcscp.isDataSetSupportEqualToThePreviousOne(i,fields))
 393             pass
 394         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
 395         self.assertTrue(not ncc)
 396         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
 397         self.assertTrue(a1.isEqual(DataArrayByte([3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,5,5,5,5,9,9,9,9,9])))
 398         self.assertTrue(a2.isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69,72,75,78,81,84,87,90,93,96,100,104,108,112,117,122,127,132])))
 399         self.assertTrue(a3.isEqual(DataArrayInt([2,0,1,2,1,2,2,2,0,2,3,4,2,4,5,2,5,3,2,6,7,2,7,8,2,8,6,2,9,10,2,10,11,2,11,9,2,12,13,2,13,14,2,14,15,2,15,12,2,16,17,2,17,18,2,18,19,2,19,16,2,20,21,2,21,22,2,22,23,2,23,20,2,24,25,2,25,26,2,26,27,2,27,24,2,28,29,2,29,30,2,30,31,2,31,28,3,0,1,2,3,3,4,5,3,6,7,8,3,9,10,11,4,12,13,14,15,4,16,17,18,19,4,20,21,22,23,4,24,25,26,27,4,28,29,30,31])))
 400         self.assertTrue(a4 is None)
 401         self.assertTrue(a5 is None)
 402         # for cells
 403         for i in xrange(5):
 404             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
 405             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)# Second 0 is for cells
 406             f.loadArraysIfNecessary()
 407             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 408             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 409             vExp=DataArrayDouble([200.,201.,202.,203.,204.,205.,206.,207.,208.,209.,210.,211.,212.,213.,214.,215.,216.,217.,218.,219.,220.,221.,222.,223.,224.,225.,226.,227.,228.,229.,230.,231.,232.,233.,234.,235.,236.,237.,238.,239.,240.,241.,242.,243.,244.,245.,246.,247.,248.,249.,250.,251.,252.,253.,254.,255.,256.,257.,258.,259.,260.,261.,262.,263.,100.,101.,102.,103.,104.,105.,106.,107.,108.,109.,110.,111.,112.,113.,114.,115.,116.,117.],41,2) ; vExp.setInfoOnComponents(['Comp1 [m]','Com2 [s^2]']) ; vExp+=i*1000
 410             self.assertTrue(v.isEqual(vExp,1e-12))
 411             pass
 412         for i in xrange(5):
 413             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
 414             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)# Second 0 is for cells
 415             f.loadArraysIfNecessary()
 416             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 417             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 418             vExp=DataArrayDouble([300.,301.,302.,303.,304.,305.,306.,307.,308.,309.,310.,311.,312.,313.,314.,315.,316.,317.,318.,319.,320.,321.,322.,323.,324.,325.,326.,327.,328.,329.,330.,331.,332.,333.,334.,335.,336.,337.,338.,339.,340.,341.,342.,343.,344.,345.,346.,347.,348.,349.,350.,351.,352.,353.,354.,355.,356.,357.,358.,359.,360.,361.,362.,363.],32,2) ; vExp.setInfoOnComponents(['Comp1 [m]','Com2 [s^2]']) ; vExp.setInfoOnComponents(['Comp1 [m]','Com2 [s^2]']) ; vExp+=i*1000
 419             self.assertTrue(v.isEqual(vExp,1e-12))
 420             pass
 421         pass
 422
 423     def test3(self):
 424         """ This test is more advanced a same field is defined on CELLS for time steps 0, 2 and 4, and on NODES for time steps 1 and 3.
 425         So two time step series on the same field. No profile here neither on cells nor on nodes.
 426         """
 427         fname="ForMEDReader3.med"
 428         # building a mesh containing 4 tri3 + 5 quad4
 429         tri=MEDCouplingUMesh("tri",2)
 430         tri.allocateCells() ; tri.insertNextCell(NORM_TRI3,[0,1,2])
 431         tri.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,0.)]))
 432         tris=[tri.deepCpy() for i in xrange(4)]
 433         for i,elt in enumerate(tris): elt.translate([i,0])
 434         tris=MEDCouplingUMesh.MergeUMeshes(tris)
 435         quad=MEDCouplingUMesh("quad",2)
 436         quad.allocateCells() ; quad.insertNextCell(NORM_QUAD4,[0,1,2,3])
 437         quad.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,1.),(1.,0.)]))
 438         quads=[quad.deepCpy() for i in xrange(5)]
 439         for i,elt in enumerate(quads): elt.translate([5+i,0])
 440         quads=MEDCouplingUMesh.MergeUMeshes(quads)
 441         m=MEDCouplingUMesh.MergeUMeshes(tris,quads)
 442         m.setName("mesh") ; m.getCoords().setInfoOnComponents(["XX [m]","YYY [km]"])
 443         m1=m.buildDescendingConnectivity()[0]
 444         mm=MEDFileUMesh() ; mm.setMeshes([m,m1])
 445         #
 446         fieldName="zeField"
 447         fs=MEDFileFieldMultiTS()
 448         ##### Time step 0 on cells
 449         i=0
 450         f=MEDFileField1TS()
 451         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 452         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 453         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(100) ; arr.rearrange(2)
 454         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 455         fCell0.checkCoherency()
 456         f.setFieldNoProfileSBT(fCell0)
 457         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 458         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 459         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(200) ; arr.rearrange(2)
 460         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 461         fCell1.checkCoherency()
 462         f.setFieldNoProfileSBT(fCell1)
 463         fs.pushBackTimeStep(f)
 464         ##### Time step 1 on nodes
 465         i=1
 466         f=MEDFileField1TS()
 467         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 468         fNode.setName(fieldName) ; fNode.setMesh(m1)
 469         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(1300) ; arr.rearrange(2)
 470         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 471         fNode.checkCoherency()
 472         f.setFieldNoProfileSBT(fNode)
 473         fs.pushBackTimeStep(f)
 474         ##### Time step 2 on cells
 475         i=2
 476         f=MEDFileField1TS()
 477         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 478         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 479         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(2100) ; arr.rearrange(2)
 480         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 481         fCell0.checkCoherency()
 482         f.setFieldNoProfileSBT(fCell0)
 483         #
 484         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 485         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 486         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(2200) ; arr.rearrange(2)
 487         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 488         fCell1.checkCoherency()
 489         f.setFieldNoProfileSBT(fCell1)
 490         fs.pushBackTimeStep(f)
 491         ##### Time step 3 on nodes
 492         i=3
 493         f=MEDFileField1TS()
 494         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 495         fNode.setName(fieldName) ; fNode.setMesh(m1)
 496         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(3300) ; arr.rearrange(2)
 497         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 498         fNode.checkCoherency()
 499         f.setFieldNoProfileSBT(fNode)
 500         fs.pushBackTimeStep(f)
 501         ##### Time step 4
 502         i=4
 503         f=MEDFileField1TS()
 504         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 505         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 506         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(4100) ; arr.rearrange(2)
 507         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 508         fCell0.checkCoherency()
 509         f.setFieldNoProfileSBT(fCell0)
 510         #
 511         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 512         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 513         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(4200) ; arr.rearrange(2)
 514         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 515         fCell1.checkCoherency()
 516         f.setFieldNoProfileSBT(fCell1)
 517         #
 518         fs.pushBackTimeStep(f)
 519         mm.write(fname,2)
 520         fs.write(fname,0)
 521         a0Exp=mm.getCoords().deepCpy()
 522         del m,m1,mm,fs,f,fCell0,fCell1
 523         ########## GO for reading in MEDReader, by not loading all. Mesh is fully loaded but not fields values
 524         ms=MEDFileMeshes(fname)
 525         fields=MEDFileFields(fname,False)
 526         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
 527         allFMTSLeavesToDisplay=[]
 528         for fields in fields_per_mesh:
 529             allFMTSLeavesToDisplay2=[]
 530             for fmts in fields:
 531                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
 532                 pass
 533             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
 534             pass
 535         self.assertEqual(len(allFMTSLeavesToDisplay),1)
 536         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
 537         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
 538         self.assertEqual(len(allFMTSLeavesPerTimeSeries),2) # two time series here : one for the cells, the second one for the nodes
 539         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
 540         self.assertEqual(len(allFMTSLeavesPerTimeSeries[1]),1)
 541         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
 542         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
 543         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),1)
 544         #
 545         mst=MEDFileMeshStruct.New(ms[0])
 546         fcscp=allFMTSLeavesPerCommonSupport[0][1] # start with the cells
 547         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
 548         mml2=mml.prepare()
 549         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
 550         for i in xrange(1,3):
 551             self.assertTrue(fcscp.isDataSetSupportEqualToThePreviousOne(i,fields))
 552             pass
 553         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
 554         self.assertTrue(not ncc)
 555         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
 556         self.assertTrue(a1.isEqual(DataArrayByte([3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,5,5,5,5,9,9,9,9,9])))
 557         self.assertTrue(a2.isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69,72,75,78,81,84,87,90,93,96,100,104,108,112,117,122,127,132])))
 558         self.assertTrue(a3.isEqual(DataArrayInt([2,0,1,2,1,2,2,2,0,2,3,4,2,4,5,2,5,3,2,6,7,2,7,8,2,8,6,2,9,10,2,10,11,2,11,9,2,12,13,2,13,14,2,14,15,2,15,12,2,16,17,2,17,18,2,18,19,2,19,16,2,20,21,2,21,22,2,22,23,2,23,20,2,24,25,2,25,26,2,26,27,2,27,24,2,28,29,2,29,30,2,30,31,2,31,28,3,0,1,2,3,3,4,5,3,6,7,8,3,9,10,11,4,12,13,14,15,4,16,17,18,19,4,20,21,22,23,4,24,25,26,27,4,28,29,30,31])))
 559         assert a4 is None
 560         assert a5 is None
 561         # for cells
 562         for i in xrange(3):
 563             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
 564             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)# Second 0 is for cells
 565             f.loadArraysIfNecessary()
 566             self.assertEqual(f.getName(),"zeField")
 567             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 568             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 569             vExp=DataArrayDouble([200.,201.,202.,203.,204.,205.,206.,207.,208.,209.,210.,211.,212.,213.,214.,215.,216.,217.,218.,219.,220.,221.,222.,223.,224.,225.,226.,227.,228.,229.,230.,231.,232.,233.,234.,235.,236.,237.,238.,239.,240.,241.,242.,243.,244.,245.,246.,247.,248.,249.,250.,251.,252.,253.,254.,255.,256.,257.,258.,259.,260.,261.,262.,263.,100.,101.,102.,103.,104.,105.,106.,107.,108.,109.,110.,111.,112.,113.,114.,115.,116.,117.],41,2) ; vExp.setInfoOnComponents(['Comp1 [m]','Com2 [s^2]']) ; vExp+=i*2000
 570             self.assertTrue(v.isEqual(vExp,1e-12))
 571             pass
 572         # for nodes
 573         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[1],ms[ms.getMeshesNames()[0]])
 574         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
 575         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),1)
 576         fcscp=allFMTSLeavesPerCommonSupport[0][1]
 577         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
 578         mml2=mml.prepare()
 579         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
 580         for i in xrange(1,2):
 581             self.assertTrue(fcscp.isDataSetSupportEqualToThePreviousOne(i,fields))
 582             pass
 583         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
 584         self.assertTrue(not ncc)
 585         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
 586         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5,5,9,9,9,9,9,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3])))
 587         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,12,16,21,26,31,36,41,44,47,50,53,56,59,62,65,68,71,74,77,80,83,86,89,92,95,98,101,104,107,110,113,116,119,122,125,128,131,134])))
 588         self.assertTrue(a3.isEqual(DataArrayInt([3,0,1,2,3,3,4,5,3,6,7,8,3,9,10,11,4,12,13,14,15,4,16,17,18,19,4,20,21,22,23,4,24,25,26,27,4,28,29,30,31,2,0,1,2,1,2,2,2,0,2,3,4,2,4,5,2,5,3,2,6,7,2,7,8,2,8,6,2,9,10,2,10,11,2,11,9,2,12,13,2,13,14,2,14,15,2,15,12,2,16,17,2,17,18,2,18,19,2,19,16,2,20,21,2,21,22,2,22,23,2,23,20,2,24,25,2,25,26,2,26,27,2,27,24,2,28,29,2,29,30,2,30,31,2,31,28])))
 589         self.assertTrue(a4 is None)
 590         self.assertTrue(a5 is None)
 591         for i in xrange(2):
 592             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
 593             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)# Second 0 is for cells
 594             f.loadArraysIfNecessary()
 595             self.assertEqual(f.getName(),"zeField")
 596             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 597             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 598             vExp=DataArrayDouble([300.,301.,302.,303.,304.,305.,306.,307.,308.,309.,310.,311.,312.,313.,314.,315.,316.,317.,318.,319.,320.,321.,322.,323.,324.,325.,326.,327.,328.,329.,330.,331.,332.,333.,334.,335.,336.,337.,338.,339.,340.,341.,342.,343.,344.,345.,346.,347.,348.,349.,350.,351.,352.,353.,354.,355.,356.,357.,358.,359.,360.,361.,362.,363.],32,2) ; vExp.setInfoOnComponents(['Comp1 [m]','Com2 [s^2]']) ; vExp.setInfoOnComponents(['Comp1 [m]','Com2 [s^2]']) ; vExp+=i*2000+1000
 599             self.assertTrue(v.isEqual(vExp,1e-12))
 600             pass
 601         pass
 602
 603     def test4(self):
 604         """ This test defines 3 fields on nodes on the same mesh. All of these fields have no profile.
 605         """
 606         fname="ForMEDReader4.med"
 607         # building a mesh containing 4 tri3 + 5 quad4
 608         tri=MEDCouplingUMesh("tri",2)
 609         tri.allocateCells() ; tri.insertNextCell(NORM_TRI3,[0,1,2])
 610         tri.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,0.)]))
 611         tris=[tri.deepCpy() for i in xrange(4)]
 612         for i,elt in enumerate(tris): elt.translate([i,0])
 613         tris=MEDCouplingUMesh.MergeUMeshes(tris)
 614         quad=MEDCouplingUMesh("quad",2)
 615         quad.allocateCells() ; quad.insertNextCell(NORM_QUAD4,[0,1,2,3])
 616         quad.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,1.),(1.,0.)]))
 617         quads=[quad.deepCpy() for i in xrange(5)]
 618         for i,elt in enumerate(quads): elt.translate([5+i,0])
 619         quads=MEDCouplingUMesh.MergeUMeshes(quads)
 620         m=MEDCouplingUMesh.MergeUMeshes(tris,quads)
 621         m.setName("mesh") ; m.getCoords().setInfoOnComponents(["XX [m]","YYY [km]"])
 622         mm=MEDFileUMesh() ; mm.setMeshes([m])
 623         #
 624         fieldName1="zeField1"
 625         fieldName2="zeField2"
 626         fieldName3="zeField3"
 627         fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS()
 628         ##### Time step 0
 629         i=0
 630         f=MEDFileField1TS()
 631         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 632         fNode.setName(fieldName1) ; fNode.setMesh(m)
 633         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(0+1000*i) ; arr.rearrange(2)
 634         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
 635         fNode.checkCoherency()
 636         f.setFieldNoProfileSBT(fNode)
 637         fs1.pushBackTimeStep(f)
 638         #
 639         f=MEDFileField1TS()
 640         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 641         fNode.setName(fieldName2) ; fNode.setMesh(m)
 642         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(100+1000*i) ; arr.rearrange(2)
 643         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
 644         fNode.checkCoherency()
 645         f.setFieldNoProfileSBT(fNode)
 646         fs2.pushBackTimeStep(f)
 647         #
 648         f=MEDFileField1TS()
 649         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 650         fNode.setName(fieldName3) ; fNode.setMesh(m)
 651         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(200+1000*i) ; arr.rearrange(2)
 652         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
 653         fNode.checkCoherency()
 654         f.setFieldNoProfileSBT(fNode)
 655         fs3.pushBackTimeStep(f)
 656         ##### Time step 1
 657         i=1
 658         f=MEDFileField1TS()
 659         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 660         fNode.setName(fieldName1) ; fNode.setMesh(m)
 661         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(0+1000*i) ; arr.rearrange(2)
 662         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
 663         fNode.checkCoherency()
 664         f.setFieldNoProfileSBT(fNode)
 665         fs1.pushBackTimeStep(f)
 666         #
 667         f=MEDFileField1TS()
 668         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 669         fNode.setName(fieldName2) ; fNode.setMesh(m)
 670         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(100+1000*i) ; arr.rearrange(2)
 671         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
 672         fNode.checkCoherency()
 673         f.setFieldNoProfileSBT(fNode)
 674         fs2.pushBackTimeStep(f)
 675         #
 676         f=MEDFileField1TS()
 677         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 678         fNode.setName(fieldName3) ; fNode.setMesh(m)
 679         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(200+1000*i) ; arr.rearrange(2)
 680         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
 681         fNode.checkCoherency()
 682         f.setFieldNoProfileSBT(fNode)
 683         fs3.pushBackTimeStep(f)
 684         ##### Time step 2
 685         i=2
 686         f=MEDFileField1TS()
 687         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 688         fNode.setName(fieldName1) ; fNode.setMesh(m)
 689         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(0+1000*i) ; arr.rearrange(2)
 690         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
 691         fNode.checkCoherency()
 692         f.setFieldNoProfileSBT(fNode)
 693         fs1.pushBackTimeStep(f)
 694         #
 695         f=MEDFileField1TS()
 696         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 697         fNode.setName(fieldName2) ; fNode.setMesh(m)
 698         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(100+1000*i) ; arr.rearrange(2)
 699         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
 700         fNode.checkCoherency()
 701         f.setFieldNoProfileSBT(fNode)
 702         fs2.pushBackTimeStep(f)
 703         #
 704         f=MEDFileField1TS()
 705         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 706         fNode.setName(fieldName3) ; fNode.setMesh(m)
 707         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(200+1000*i) ; arr.rearrange(2)
 708         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
 709         fNode.checkCoherency()
 710         f.setFieldNoProfileSBT(fNode)
 711         fs3.pushBackTimeStep(f)
 712         ##### Time step 3
 713         i=3
 714         f=MEDFileField1TS()
 715         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 716         fNode.setName(fieldName1) ; fNode.setMesh(m)
 717         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(0+1000*i) ; arr.rearrange(2)
 718         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
 719         fNode.checkCoherency()
 720         f.setFieldNoProfileSBT(fNode)
 721         fs1.pushBackTimeStep(f)
 722         #
 723         f=MEDFileField1TS()
 724         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 725         fNode.setName(fieldName2) ; fNode.setMesh(m)
 726         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(100+1000*i) ; arr.rearrange(2)
 727         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
 728         fNode.checkCoherency()
 729         f.setFieldNoProfileSBT(fNode)
 730         fs2.pushBackTimeStep(f)
 731         #
 732         f=MEDFileField1TS()
 733         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 734         fNode.setName(fieldName3) ; fNode.setMesh(m)
 735         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(200+1000*i) ; arr.rearrange(2)
 736         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
 737         fNode.checkCoherency()
 738         f.setFieldNoProfileSBT(fNode)
 739         fs3.pushBackTimeStep(f)
 740         ##### Time step 4
 741         i=4
 742         f=MEDFileField1TS()
 743         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 744         fNode.setName(fieldName1) ; fNode.setMesh(m)
 745         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(0+1000*i) ; arr.rearrange(2)
 746         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
 747         fNode.checkCoherency()
 748         f.setFieldNoProfileSBT(fNode)
 749         fs1.pushBackTimeStep(f)
 750         #
 751         f=MEDFileField1TS()
 752         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 753         fNode.setName(fieldName2) ; fNode.setMesh(m)
 754         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(100+1000*i) ; arr.rearrange(2)
 755         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
 756         fNode.checkCoherency()
 757         f.setFieldNoProfileSBT(fNode)
 758         fs2.pushBackTimeStep(f)
 759         #
 760         f=MEDFileField1TS()
 761         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 762         fNode.setName(fieldName3) ; fNode.setMesh(m)
 763         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(200+1000*i) ; arr.rearrange(2)
 764         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
 765         fNode.checkCoherency()
 766         f.setFieldNoProfileSBT(fNode)
 767         fs3.pushBackTimeStep(f)
 768         #
 769         mm.write(fname,2)
 770         fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0)
 771         a0Exp=mm.getCoords().deepCpy()
 772         del m,mm,fs1,fs2,fs3,f,fNode
 773         ########## GO for reading in MEDReader, by not loading all. Mesh is fully loaded but not fields values
 774         ms=MEDFileMeshes(fname)
 775         fields=MEDFileFields(fname,False)
 776         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
 777         allFMTSLeavesToDisplay=[]
 778         for fields in fields_per_mesh:
 779             allFMTSLeavesToDisplay2=[]
 780             for fmts in fields:
 781                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
 782                 pass
 783             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
 784             pass
 785         self.assertEqual(len(allFMTSLeavesToDisplay),1)
 786         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
 787         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
 788         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 3 fields are defined on the same time steps
 789         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
 790         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
 791         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
 792         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),3)
 793         #
 794         mst=MEDFileMeshStruct.New(ms[0])
 795         fcscp=allFMTSLeavesPerCommonSupport[0][1]
 796         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
 797         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),3)
 798         fcscp=allFMTSLeavesPerCommonSupport[0][1]
 799         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
 800         mml2=mml.prepare()
 801         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
 802         for i in xrange(1,5):
 803             self.assertTrue(fcscp.isDataSetSupportEqualToThePreviousOne(i,fields))
 804             pass
 805         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
 806         self.assertTrue(not ncc)
 807         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
 808         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5,5,9,9,9,9,9])))
 809         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,12,16,21,26,31,36])))
 810         self.assertTrue(a3.isEqual(DataArrayInt([3,0,1,2,3,3,4,5,3,6,7,8,3,9,10,11,4,12,13,14,15,4,16,17,18,19,4,20,21,22,23,4,24,25,26,27,4,28,29,30,31])))
 811         self.assertTrue(a4 is None)
 812         self.assertTrue(a5 is None)
 813         # test all the time steps of the 1/1 time step serie, on field 1
 814         for i in xrange(5):
 815             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
 816             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
 817             f.loadArraysIfNecessary()
 818             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 819             self.assertEqual(f.getName(),fieldName1)
 820             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 821             vExp=DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,20.,21.,22.,23.,24.,25.,26.,27.,28.,29.,30.,31.,32.,33.,34.,35.,36.,37.,38.,39.,40.,41.,42.,43.,44.,45.,46.,47.,48.,49.,50.,51.,52.,53.,54.,55.,56.,57.,58.,59.,60.,61.,62.,63.],32,2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]']) ; vExp+=i*1000
 822             self.assertTrue(v.isEqual(vExp,1e-12))
 823             pass
 824         # test all the time steps of the 1/1 time step serie, on field 2
 825         for i in xrange(5):
 826             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
 827             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
 828             f.loadArraysIfNecessary()
 829             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 830             self.assertEqual(f.getName(),fieldName2)
 831             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 832             vExp=DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,20.,21.,22.,23.,24.,25.,26.,27.,28.,29.,30.,31.,32.,33.,34.,35.,36.,37.,38.,39.,40.,41.,42.,43.,44.,45.,46.,47.,48.,49.,50.,51.,52.,53.,54.,55.,56.,57.,58.,59.,60.,61.,62.,63.],32,2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]']) ; vExp+=i*1000+100
 833             self.assertTrue(v.isEqual(vExp,1e-12))
 834             pass
 835         # test all the time steps of the 1/1 time step serie, on field 3
 836         for i in xrange(5):
 837             f=allFMTSLeavesPerCommonSupport[0][0][2][i]
 838             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
 839             f.loadArraysIfNecessary()
 840             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 841             self.assertEqual(f.getName(),fieldName3)
 842             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 843             vExp=DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,20.,21.,22.,23.,24.,25.,26.,27.,28.,29.,30.,31.,32.,33.,34.,35.,36.,37.,38.,39.,40.,41.,42.,43.,44.,45.,46.,47.,48.,49.,50.,51.,52.,53.,54.,55.,56.,57.,58.,59.,60.,61.,62.,63.],32,2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]']) ; vExp+=i*1000+200
 844             self.assertTrue(v.isEqual(vExp,1e-12))
 845             pass
 846         pass
 847
 848     def test5(self):
 849         """ This test plays with profiles both cell profiles and node profiles. Two first fields (resp on cells and on nodes) lie on the same mesh support whereas the third
 850         mesh lies on a different mesh.
 851         """
 852         fname="ForMEDReader5.med"
 853         # building a mesh containing 6 tri3 + 5 quad4
 854         m=MEDCouplingUMesh("mesh",2)
 855         coords=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)]) ; coords.setInfoOnComponents(["XX [m]","YYY [km]"])
 856         m.setCoords(coords)
 857         m.allocateCells()
 858         m.insertNextCell(NORM_TRI3,[2,7,3]) ; m.insertNextCell(NORM_TRI3,[7,8,3]) ; m.insertNextCell(NORM_TRI3,[3,8,4]) ; m.insertNextCell(NORM_TRI3,[8,9,4])
 859         m.insertNextCell(NORM_TRI3,[13,9,8]) ; m.insertNextCell(NORM_TRI3,[13,14,9])
 860         m.insertNextCell(NORM_QUAD4,[0,5,6,1]) ; m.insertNextCell(NORM_QUAD4,[1,6,7,2]) ; m.insertNextCell(NORM_QUAD4,[5,10,11,6]) ; m.insertNextCell(NORM_QUAD4,[6,11,12,7])
 861         m.insertNextCell(NORM_QUAD4,[12,13,8,7])
 862         mm=MEDFileUMesh() ; mm.setMeshes([m])
 863         fam=DataArrayInt(11) ; fam.iota(0) ; mm.setFamilyFieldArr(0,fam) ; del fam
 864         num=DataArrayInt(11) ; num.iota(100) ; mm.setRenumFieldArr(0,num) ; del num
 865         #
 866         fieldName1="zeField1" ; pfl1=DataArrayInt([0,1,2,3,4,5]) ; pfl1.setName("pfl1") # on cells
 867         fieldName2="zeField2" ; pfl2=DataArrayInt([2,3,4,7,8,9,13,14]) ; pfl2.setName("pfl2") # on nodes
 868         fieldName3="zeField3" ; pfl3=DataArrayInt([0,1,2,3,4,5,9,10]) ; pfl3.setName("pfl3") # on cells but different support
 869         fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS()
 870         #
 871         for i in xrange(5):
 872             f=MEDFileField1TS()
 873             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
 874             fNode.setName(fieldName1)
 875             arr=DataArrayDouble(2*6) ; arr.iota(0+1000*i) ; arr.rearrange(2)
 876             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
 877             f.setFieldProfile(fNode,mm,0,pfl1)
 878             fs1.pushBackTimeStep(f)
 879             #
 880             f=MEDFileField1TS()
 881             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 882             fNode.setName(fieldName2)
 883             arr=DataArrayDouble(2*8) ; arr.iota(100+1000*i) ; arr.rearrange(2)
 884             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
 885             f.setFieldProfile(fNode,mm,0,pfl2)
 886             fs2.pushBackTimeStep(f)
 887             #
 888             f=MEDFileField1TS()
 889             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
 890             fNode.setName(fieldName3)
 891             arr=DataArrayDouble(2*8) ; arr.iota(200+1000*i) ; arr.rearrange(2)
 892             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
 893             f.setFieldProfile(fNode,mm,0,pfl3)
 894             fs3.pushBackTimeStep(f)
 895             pass
 896         mm.write(fname,2)
 897         fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0)
 898         a0Exp=mm.getCoords().deepCpy()
 899         del m,mm,fs1,fs2,fs3,f,fNode
 900         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
 901         ms=MEDFileMeshes(fname)
 902         fields=MEDFileFields(fname,False)
 903         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
 904         allFMTSLeavesToDisplay=[]
 905         for fields in fields_per_mesh:
 906             allFMTSLeavesToDisplay2=[]
 907             for fmts in fields:
 908                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
 909                 pass
 910             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
 911             pass
 912         self.assertEqual(len(allFMTSLeavesToDisplay),1)
 913         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
 914         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
 915         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 3 fields are defined on the same time steps
 916         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
 917         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
 918         ms[0].getDirectUndergroundSingleGeoTypeMeshes(0)
 919         self.assertEqual(len(allFMTSLeavesPerCommonSupport),2) # 2 support here
 920         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
 921         self.assertEqual(len(allFMTSLeavesPerCommonSupport[1][0]),1)
 922         #
 923         mst=MEDFileMeshStruct.New(ms[0])
 924         fcscp=allFMTSLeavesPerCommonSupport[0][1]
 925         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
 926         mml2=mml.prepare()
 927         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
 928         for i in xrange(1,5):
 929             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
 930             pass
 931         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
 932         self.assertTrue(not ncc)
 933         self.assertTrue(a0.isEqual(a0Exp[pfl2].changeNbOfComponents(3,0.),1e-12))
 934         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5,5,5,5])))
 935         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,12,16,20])))
 936         self.assertTrue(a3.isEqual(DataArrayInt([3,0,3,1,3,3,4,1,3,1,4,2,3,4,5,2,3,6,5,4,3,6,7,5])))
 937         assert a4 is None
 938         assert a5 is None
 939         a6,a7=mml2.retrieveFamilyIdsOnCells()
 940         self.assertTrue(a6.isEqual(DataArrayInt([0,1,2,3,4,5])))
 941         self.assertTrue(not a7)
 942         a8,a9=mml2.retrieveNumberIdsOnCells()
 943         self.assertTrue(a8.isEqual(DataArrayInt([100,101,102,103,104,105])))
 944         self.assertTrue(not a9)
 945         for i in xrange(5):
 946             nbOfT=[6,8]
 947             fieldNames=[fieldName1,fieldName2]
 948             for j in xrange(2):
 949                 m={"i":j}
 950                 f=allFMTSLeavesPerCommonSupport[0][0][j][i]
 951                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
 952                 f.loadArraysIfNecessary()
 953                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 954                 self.assertEqual(f.getName(),fieldNames[j])
 955                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 956                 vExp=DataArrayDouble(nbOfT[j]*2) ; vExp.iota(j*100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_%(i)i [m]'%m,'Com2_%(i)i [s^2]'%m])
 957                 self.assertTrue(v.isEqual(vExp,1e-12))
 958                 pass
 959             pass
 960         # Let's go for the 2nd support
 961         fcscp=allFMTSLeavesPerCommonSupport[1][1]
 962         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
 963         mml2=mml.prepare()
 964         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
 965         for i in xrange(1,5):
 966             self.assertTrue(fcscp.isDataSetSupportEqualToThePreviousOne(i,fields))
 967             pass
 968         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
 969         self.assertTrue(not ncc)
 970         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
 971         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5,5,5,5,9,9])))
 972         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,12,16,20,24,29])))
 973         self.assertTrue(a3.isEqual(DataArrayInt([3,2,7,3,3,7,8,3,3,3,8,4,3,8,9,4,3,13,9,8,3,13,14,9,4,6,11,12,7,4,12,13,8,7])))
 974         self.assertTrue(a4 is None)
 975         self.assertTrue(a5 is None)
 976         a6,a7=mml2.retrieveFamilyIdsOnCells()
 977         self.assertTrue(a6.isEqual(DataArrayInt([0,1,2,3,4,5,9,10])))
 978         self.assertTrue(not a7)
 979         a8,a9=mml2.retrieveNumberIdsOnCells()
 980         self.assertTrue(a8.isEqual(DataArrayInt([100,101,102,103,104,105,109,110])))
 981         self.assertTrue(not a9)
 982         for i in xrange(5):
 983             f=allFMTSLeavesPerCommonSupport[1][0][0][i]
 984             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
 985             f.loadArraysIfNecessary()
 986             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 987             self.assertEqual(f.getName(),"zeField3")
 988             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 989             vExp=DataArrayDouble(8*2) ; vExp.iota(200+1000*i) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]'%m,'Com2_2 [s^2]'%m])
 990             self.assertTrue(v.isEqual(vExp,1e-12))
 991             pass
 992         pass
 993
 994     def test6(self):
 995         """ This test plays with cartesian mesh and profiles. When a sub cartesian mesh can also be considered as a cartesian mesh it is done.
 996         """
 997         fname="ForMEDReader6.med"
 998         m=MEDCouplingCMesh("mesh")
 999         coordsX=DataArrayDouble([0,1.1,2.2,3.3,4.4]) ; coordsX.setInfoOnComponents(["XX [m]"])
1000         coordsY=DataArrayDouble([0,1.7,3.4]) ; coordsY.setInfoOnComponents(["YYY [km]"])
1001         m.setCoords(coordsX,coordsY)
1002         mm=MEDFileCMesh() ; mm.setMesh(m)
1003         fam=DataArrayInt(8) ; fam.iota(0) ; mm.setFamilyFieldArr(0,fam) ; del fam
1004         num=DataArrayInt(8) ; num.iota(100) ; mm.setRenumFieldArr(0,num) ; del num
1005         num=DataArrayInt(15) ; num.iota(200) ; mm.setRenumFieldArr(1,num) ; del num
1006         #
1007         fieldName0="zeField0" ; # on cells
1008         fieldName1="zeField1" ; pfl1=DataArrayInt([2,3,6,7]) ; pfl1.setName("pfl1") # on cells
1009         fieldName2="zeField2" ; pfl2=DataArrayInt([2,3,4,7,8,9,12,13,14]) ; pfl2.setName("pfl2") # on nodes
1010         fieldName3="zeField3" ; pfl3=DataArrayInt([2,3,5,7]) ; pfl3.setName("pfl3") # on cells but different support
1011         fieldName4="zeField4" ;# on nodes
1012         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS() ; fs4=MEDFileFieldMultiTS()
1013         #
1014         for i in xrange(5):
1015             f=MEDFileField1TS()
1016             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1017             fNode.setName(fieldName0) ; fNode.setMesh(m)
1018             arr=DataArrayDouble(2*8) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1019             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkCoherency()
1020             f.setFieldNoProfileSBT(fNode)
1021             fs0.pushBackTimeStep(f)
1022             #
1023             f=MEDFileField1TS()
1024             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1025             fNode.setName(fieldName1)
1026             arr=DataArrayDouble(2*4) ; arr.iota(100+1000*i) ; arr.rearrange(2)
1027             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
1028             f.setFieldProfile(fNode,mm,0,pfl1)
1029             self.assertEqual(pfl1.getName(),"pfl1")
1030             fs1.pushBackTimeStep(f)
1031             #
1032             f=MEDFileField1TS()
1033             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1034             fNode.setName(fieldName2)
1035             arr=DataArrayDouble(2*9) ; arr.iota(200+1000*i) ; arr.rearrange(2)
1036             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
1037             f.setFieldProfile(fNode,mm,0,pfl2)
1038             self.assertEqual(pfl2.getName(),"pfl2")
1039             fs2.pushBackTimeStep(f)
1040             #
1041             f=MEDFileField1TS()
1042             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1043             fNode.setName(fieldName3)
1044             arr=DataArrayDouble(2*4) ; arr.iota(300+1000*i) ; arr.rearrange(2)
1045             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_3 [m]","Com2_3 [s^2]"])
1046             f.setFieldProfile(fNode,mm,0,pfl3)
1047             self.assertEqual(pfl3.getName(),"pfl3")
1048             fs3.pushBackTimeStep(f)
1049             #
1050             f=MEDFileField1TS()
1051             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1052             fNode.setName(fieldName4) ; fNode.setMesh(m)
1053             arr=DataArrayDouble(2*15) ; arr.iota(400+1000*i) ; arr.rearrange(2)
1054             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_4 [m]","Com2_4 [s^2]"]) ; fNode.checkCoherency()
1055             f.setFieldNoProfileSBT(fNode)
1056             fs4.pushBackTimeStep(f)
1057             pass
1058         mm.write(fname,2)
1059         fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0) ; fs4.write(fname,0)
1060         del m,mm,fs1,fs2,fs3,f,fNode
1061         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1062         ms=MEDFileMeshes(fname)
1063         fields=MEDFileFields(fname,False)
1064         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1065         allFMTSLeavesToDisplay=[]
1066         for fields in fields_per_mesh:
1067             allFMTSLeavesToDisplay2=[]
1068             for fmts in fields:
1069                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
1070                 pass
1071             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1072             pass
1073         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1074         self.assertEqual(len(allFMTSLeavesToDisplay[0]),5)
1075         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1076         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 5 fields are defined on the same time steps
1077         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),5)
1078         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1079         self.assertEqual(len(allFMTSLeavesPerCommonSupport),3)
1080         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
1081         self.assertEqual(len(allFMTSLeavesPerCommonSupport[1][0]),2)
1082         self.assertEqual(len(allFMTSLeavesPerCommonSupport[2][0]),1)
1083         #
1084         mst=MEDFileMeshStruct.New(ms[0])
1085         #
1086         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1087         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1088         mml2=mml.prepare()
1089         a,b=mml2.buildVTUArrays()
1090         self.assertTrue(a.isEqual(coordsX,1e-12))
1091         self.assertTrue(b.isEqual(coordsY,1e-12))
1092         self.assertTrue(isinstance(mml2,MEDCMeshMultiLev))
1093         for i in xrange(1,5):
1094             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1095             pass
1096         a6,a7=mml2.retrieveFamilyIdsOnCells()
1097         self.assertTrue(a6.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
1098         self.assertTrue(a7) # True because no copy
1099         a8,a9=mml2.retrieveNumberIdsOnCells()
1100         self.assertTrue(a8.isEqual(DataArrayInt([100,101,102,103,104,105,106,107])))
1101         self.assertTrue(a9) # True because no copy
1102         a10,a11=mml2.retrieveNumberIdsOnNodes()
1103         self.assertTrue(a10.isEqual(DataArrayInt([200,201,202,203,204,205,206,207,208,209,210,211,212,213,214])))
1104         self.assertTrue(a11) # True because no copy
1105         for i in xrange(5):
1106             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1107             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1108             f.loadArraysIfNecessary()
1109             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1110             self.assertEqual(f.getName(),fieldName0)
1111             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1112             vExp=DataArrayDouble(8*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
1113             self.assertTrue(v.isEqual(vExp,1e-12))
1114             #
1115             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
1116             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1117             f.loadArraysIfNecessary()
1118             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1119             self.assertEqual(f.getName(),fieldName4)
1120             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1121             vExp=DataArrayDouble(15*2) ; vExp.iota(400+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_4 [m]','Com2_4 [s^2]'])
1122             self.assertTrue(v.isEqual(vExp,1e-12))
1123             pass
1124
1125         fcscp=allFMTSLeavesPerCommonSupport[1][1]
1126         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1127         mml2=mml.prepare()
1128         self.assertTrue(isinstance(mml2,MEDCMeshMultiLev)) # here the 2nd support is a part of CMesh that is also a CMesh -> CMesh not a UMesh
1129         a,b=mml2.buildVTUArrays()
1130         self.assertTrue(a.isEqual(coordsX[[2,3,4]],1e-12))
1131         self.assertTrue(b.isEqual(coordsY,1e-12))
1132         a6,a7=mml2.retrieveFamilyIdsOnCells()
1133         self.assertTrue(a6.isEqual(DataArrayInt([2,3,6,7])))
1134         self.assertTrue(not a7) # False because copy
1135         a8,a9=mml2.retrieveNumberIdsOnCells()
1136         self.assertTrue(a8.isEqual(DataArrayInt([102,103,106,107])))
1137         self.assertTrue(not a9) # False because copy
1138         a10,a11=mml2.retrieveNumberIdsOnNodes()
1139         self.assertTrue(a10.isEqual(DataArrayInt([202,203,204,207,208,209,212,213,214])))
1140         self.assertTrue(not a11) # False because copy
1141         for i in xrange(1,5):
1142             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1143             pass
1144         for i in xrange(5):
1145             f=allFMTSLeavesPerCommonSupport[1][0][0][i]
1146             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1147             f.loadArraysIfNecessary()
1148             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1149             self.assertEqual(f.getName(),fieldName1)
1150             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1151             vExp=DataArrayDouble(4*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
1152             self.assertTrue(v.isEqual(vExp,1e-12))
1153             #
1154             f=allFMTSLeavesPerCommonSupport[1][0][1][i]
1155             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1156             f.loadArraysIfNecessary()
1157             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1158             self.assertEqual(f.getName(),fieldName2)
1159             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1160             vExp=DataArrayDouble(9*2) ; vExp.iota(200+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
1161             self.assertTrue(v.isEqual(vExp,1e-12))
1162             pass
1163         #
1164         fcscp=allFMTSLeavesPerCommonSupport[2][1]
1165         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1166         mml2=mml.prepare()
1167         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev)) # here the 3rd support is a part of CMesh but impossible to simplify more than a UMesh
1168         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1169         self.assertTrue(not ncc)
1170         a0Exp=DataArrayDouble([0.,0.,1.1,0.,2.2,0.,3.3,0.,4.4,0.,0.,1.7,1.1,1.7,2.2,1.7,3.3,1.7,4.4,1.7,0.,3.4,1.1,3.4,2.2,3.4,3.3,3.4,4.4,3.4],15,2)
1171         a0Exp.setInfoOnComponents(["XX [m]","YYY [km]"])
1172         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
1173         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9])))
1174         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15])))
1175         self.assertTrue(a3.isEqual(DataArrayInt([4,3,2,7,8,4,4,3,8,9,4,7,6,11,12,4,9,8,13,14])))
1176         self.assertTrue(a4 is None)
1177         self.assertTrue(a5 is None)
1178         a6,a7=mml2.retrieveFamilyIdsOnCells()
1179         self.assertTrue(a6.isEqual(DataArrayInt([2,3,5,7])))
1180         self.assertTrue(not a7) # False because copy
1181         a8,a9=mml2.retrieveNumberIdsOnCells()
1182         self.assertTrue(a8.isEqual(DataArrayInt([102,103,105,107])))
1183         self.assertTrue(not a9) # False because copy
1184         for i in xrange(5):
1185             f=allFMTSLeavesPerCommonSupport[2][0][0][i]
1186             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1187             f.loadArraysIfNecessary()
1188             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1189             self.assertEqual(f.getName(),fieldName3)
1190             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1191             vExp=DataArrayDouble(4*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_3 [m]','Com2_3 [s^2]'])
1192             self.assertTrue(v.isEqual(vExp,1e-12))
1193             pass
1194         pass
1195
1196     def test7(self):
1197         """ This test plays with curvilinear mesh and profiles. When a sub curvilinear mesh can also be considered as a cartesian mesh it is done.
1198         This test is very similar to the test6.
1199         """
1200         fname="ForMEDReader7.med"
1201         m=MEDCouplingCurveLinearMesh("mesh") ; m.setNodeGridStructure([5,3])
1202         a0Exp=DataArrayDouble([0.,0.,1.1,0.,2.2,0.,3.3,0.,4.4,0.,0.,1.7,1.1,1.7,2.2,1.7,3.3,1.7,4.4,1.7,0.,3.4,1.1,3.4,2.2,3.4,3.3,3.4,4.4,3.4],15,2)
1203         a0Exp.setInfoOnComponents(["XX [m]","YYY [km]"])
1204         m.setCoords(a0Exp)
1205         mm=MEDFileCurveLinearMesh() ; mm.setMesh(m)
1206         fam=DataArrayInt(8) ; fam.iota(0) ; mm.setFamilyFieldArr(0,fam) ; del fam
1207         num=DataArrayInt(8) ; num.iota(100) ; mm.setRenumFieldArr(0,num) ; del num
1208         #
1209         fieldName0="zeField0" ; # on cells
1210         fieldName1="zeField1" ; pfl1=DataArrayInt([2,3,6,7]) ; pfl1.setName("pfl1") # on cells
1211         fieldName2="zeField2" ; pfl2=DataArrayInt([2,3,4,7,8,9,12,13,14]) ; pfl2.setName("pfl2") # on nodes
1212         fieldName3="zeField3" ; pfl3=DataArrayInt([2,3,5,7]) ; pfl3.setName("pfl3") # on cells but different support
1213         fieldName4="zeField4" ;# on nodes
1214         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS() ; fs4=MEDFileFieldMultiTS()
1215         #
1216         for i in xrange(5):
1217             f=MEDFileField1TS()
1218             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1219             fNode.setName(fieldName0) ; fNode.setMesh(m)
1220             arr=DataArrayDouble(2*8) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1221             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkCoherency()
1222             f.setFieldNoProfileSBT(fNode)
1223             fs0.pushBackTimeStep(f)
1224             #
1225             f=MEDFileField1TS()
1226             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1227             fNode.setName(fieldName1)
1228             arr=DataArrayDouble(2*4) ; arr.iota(100+1000*i) ; arr.rearrange(2)
1229             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
1230             f.setFieldProfile(fNode,mm,0,pfl1)
1231             self.assertEqual(pfl1.getName(),"pfl1")
1232             fs1.pushBackTimeStep(f)
1233             #
1234             f=MEDFileField1TS()
1235             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1236             fNode.setName(fieldName2)
1237             arr=DataArrayDouble(2*9) ; arr.iota(200+1000*i) ; arr.rearrange(2)
1238             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
1239             f.setFieldProfile(fNode,mm,0,pfl2)
1240             self.assertEqual(pfl2.getName(),"pfl2")
1241             fs2.pushBackTimeStep(f)
1242             #
1243             f=MEDFileField1TS()
1244             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1245             fNode.setName(fieldName3)
1246             arr=DataArrayDouble(2*4) ; arr.iota(300+1000*i) ; arr.rearrange(2)
1247             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_3 [m]","Com2_3 [s^2]"])
1248             f.setFieldProfile(fNode,mm,0,pfl3)
1249             self.assertEqual(pfl3.getName(),"pfl3")
1250             fs3.pushBackTimeStep(f)
1251             #
1252             f=MEDFileField1TS()
1253             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1254             fNode.setName(fieldName4) ; fNode.setMesh(m)
1255             arr=DataArrayDouble(2*15) ; arr.iota(400+1000*i) ; arr.rearrange(2)
1256             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_4 [m]","Com2_4 [s^2]"]) ; fNode.checkCoherency()
1257             f.setFieldNoProfileSBT(fNode)
1258             fs4.pushBackTimeStep(f)
1259             pass
1260         mm.write(fname,2)
1261         fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0) ; fs4.write(fname,0)
1262         del m,mm,fs1,fs2,fs3,f,fNode
1263         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1264         ms=MEDFileMeshes(fname)
1265         fields=MEDFileFields(fname,False)
1266         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1267         allFMTSLeavesToDisplay=[]
1268         for fields in fields_per_mesh:
1269             allFMTSLeavesToDisplay2=[]
1270             for fmts in fields:
1271                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
1272                 pass
1273             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1274             pass
1275         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1276         self.assertEqual(len(allFMTSLeavesToDisplay[0]),5)
1277         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1278         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 5 fields are defined on the same time steps
1279         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),5)
1280         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1281         self.assertEqual(len(allFMTSLeavesPerCommonSupport),3)
1282         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
1283         self.assertEqual(len(allFMTSLeavesPerCommonSupport[1][0]),2)
1284         self.assertEqual(len(allFMTSLeavesPerCommonSupport[2][0]),1)
1285         #
1286         mst=MEDFileMeshStruct.New(ms[0])
1287         #
1288         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1289         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1290         mml2=mml.prepare()
1291         self.assertTrue(isinstance(mml2,MEDCurveLinearMeshMultiLev))
1292         a,b=mml2.buildVTUArrays()
1293         self.assertTrue(a.isEqual(a0Exp,1e-12))
1294         self.assertEqual(b,[5,3])
1295         a6,a7=mml2.retrieveFamilyIdsOnCells()
1296         self.assertTrue(a6.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
1297         self.assertTrue(a7) # True because no copy
1298         a8,a9=mml2.retrieveNumberIdsOnCells()
1299         self.assertTrue(a8.isEqual(DataArrayInt([100,101,102,103,104,105,106,107])))
1300         self.assertTrue(a9) # True because no copy
1301         for i in xrange(1,5):
1302             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1303             pass
1304         for i in xrange(5):
1305             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1306             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1307             f.loadArraysIfNecessary()
1308             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1309             self.assertEqual(f.getName(),fieldName0)
1310             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1311             vExp=DataArrayDouble(8*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
1312             self.assertTrue(v.isEqual(vExp,1e-12))
1313             #
1314             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
1315             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1316             f.loadArraysIfNecessary()
1317             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1318             self.assertEqual(f.getName(),fieldName4)
1319             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1320             vExp=DataArrayDouble(15*2) ; vExp.iota(400+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_4 [m]','Com2_4 [s^2]'])
1321             self.assertTrue(v.isEqual(vExp,1e-12))
1322             pass
1323         #
1324         fcscp=allFMTSLeavesPerCommonSupport[1][1]
1325         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1326         mml2=mml.prepare()
1327         self.assertTrue(isinstance(mml2,MEDCurveLinearMeshMultiLev)) # here the 2nd support is a part of CMesh that is also a CMesh -> CMesh not a UMesh
1328         a,b=mml2.buildVTUArrays()
1329         self.assertTrue(a.isEqual(a0Exp[pfl2],1e-12))
1330         self.assertEqual(b,[3,3])
1331         a6,a7=mml2.retrieveFamilyIdsOnCells()
1332         self.assertTrue(a6.isEqual(DataArrayInt([2,3,6,7])))
1333         self.assertTrue(not a7) # False because copy
1334         a8,a9=mml2.retrieveNumberIdsOnCells()
1335         self.assertTrue(a8.isEqual(DataArrayInt([102,103,106,107])))
1336         self.assertTrue(not a9) # False because copy
1337         for i in xrange(1,5):
1338             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1339             pass
1340         for i in xrange(5):
1341             f=allFMTSLeavesPerCommonSupport[1][0][0][i]
1342             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1343             f.loadArraysIfNecessary()
1344             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1345             self.assertEqual(f.getName(),fieldName1)
1346             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1347             vExp=DataArrayDouble(4*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
1348             self.assertTrue(v.isEqual(vExp,1e-12))
1349             #
1350             f=allFMTSLeavesPerCommonSupport[1][0][1][i]
1351             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1352             f.loadArraysIfNecessary()
1353             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1354             self.assertEqual(f.getName(),fieldName2)
1355             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1356             vExp=DataArrayDouble(9*2) ; vExp.iota(200+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
1357             self.assertTrue(v.isEqual(vExp,1e-12))
1358             pass
1359         #
1360         fcscp=allFMTSLeavesPerCommonSupport[2][1]
1361         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1362         mml2=mml.prepare()
1363         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev)) # here the 3rd support is a part of CMesh but impossible to simplify more than a UMesh
1364         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1365         self.assertTrue(not ncc)
1366         a0Exp=DataArrayDouble([0.,0.,1.1,0.,2.2,0.,3.3,0.,4.4,0.,0.,1.7,1.1,1.7,2.2,1.7,3.3,1.7,4.4,1.7,0.,3.4,1.1,3.4,2.2,3.4,3.3,3.4,4.4,3.4],15,2)
1367         a0Exp.setInfoOnComponents(["XX [m]","YYY [km]"])
1368         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
1369         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9])))
1370         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15])))
1371         self.assertTrue(a3.isEqual(DataArrayInt([4,3,2,7,8,4,4,3,8,9,4,7,6,11,12,4,9,8,13,14])))
1372         self.assertTrue(a4 is None)
1373         self.assertTrue(a5 is None)
1374         a6,a7=mml2.retrieveFamilyIdsOnCells()
1375         self.assertTrue(a6.isEqual(DataArrayInt([2,3,5,7])))
1376         self.assertTrue(not a7) # False because copy
1377         a8,a9=mml2.retrieveNumberIdsOnCells()
1378         self.assertTrue(a8.isEqual(DataArrayInt([102,103,105,107])))
1379         self.assertTrue(not a9) # False because copy
1380         for i in xrange(5):
1381             f=allFMTSLeavesPerCommonSupport[2][0][0][i]
1382             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1383             f.loadArraysIfNecessary()
1384             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1385             self.assertEqual(f.getName(),fieldName3)
1386             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1387             vExp=DataArrayDouble(4*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_3 [m]','Com2_3 [s^2]'])
1388             self.assertTrue(v.isEqual(vExp,1e-12))
1389             pass
1390         pass
1391
1392     def test8(self):
1393         """ This test plays with with gauss fields with no profiles.
1394         """
1395         fname="ForMEDReader8.med"
1396         # building a mesh containing 6 tri3 + 5 quad4
1397         m=MEDCouplingUMesh("mesh",2)
1398         coords=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)]) ; coords.setInfoOnComponents(["XX [m]","YYY [km]"])
1399         m.setCoords(coords)
1400         m.allocateCells()
1401         m.insertNextCell(NORM_TRI3,[2,7,3]) ; m.insertNextCell(NORM_TRI3,[7,8,3]) ; m.insertNextCell(NORM_TRI3,[3,8,4]) ; m.insertNextCell(NORM_TRI3,[8,9,4])
1402         m.insertNextCell(NORM_TRI3,[13,9,8]) ; m.insertNextCell(NORM_TRI3,[13,14,9])
1403         m.insertNextCell(NORM_QUAD4,[0,5,6,1]) ; m.insertNextCell(NORM_QUAD4,[1,6,7,2]) ; m.insertNextCell(NORM_QUAD4,[5,10,11,6]) ; m.insertNextCell(NORM_QUAD4,[6,11,12,7])
1404         m.insertNextCell(NORM_QUAD4,[12,13,8,7])
1405         mm=MEDFileUMesh() ; mm.setMeshes([m])
1406         #
1407         fieldName0="zeField0"
1408         fieldName1="zeField1"
1409         fieldName2="zeField2"
1410         fieldName3="zeField3"
1411         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS()
1412         for i in xrange(5):
1413             f=MEDFileField1TS()
1414             fNode=MEDCouplingFieldDouble(ON_GAUSS_NE) ; fNode.setTime(float(i),i,0)
1415             fNode.setName(fieldName0) ; fNode.setMesh(m)
1416             arr=DataArrayDouble(2*38) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1417             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkCoherency()
1418             f.setFieldNoProfileSBT(fNode)
1419             fs0.pushBackTimeStep(f)
1420             #
1421             f=MEDFileField1TS()
1422             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1423             fNode.setName(fieldName1) ; fNode.setMesh(m)
1424             arr=DataArrayDouble(2*11) ; arr.iota(100+1000*i) ; arr.rearrange(2)
1425             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"]) ; fNode.checkCoherency()
1426             f.setFieldNoProfileSBT(fNode)
1427             fs1.pushBackTimeStep(f)
1428             #
1429             f=MEDFileField1TS()
1430             fNode=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fNode.setTime(float(i),i,0)
1431             fNode.setName(fieldName2) ; fNode.setMesh(m)
1432             fNode.setGaussLocalizationOnCells([0,1,2,3],[0.,0.,1.,0.,0.,1.],[0.5,0.5,0.7,0.7],[0.8,0.2])
1433             fNode.setGaussLocalizationOnCells([4,5],[0.,0.,1.,0.,0.,1.],[0.5,0.5,0.7,0.7,0.1,0.1,0.2,0.2,0.3,0.3],[0.8,0.05,0.1,0.04,0.01])
1434             fNode.setGaussLocalizationOnCells([6,7,8],[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.5,0.5,0.7,0.7,0.1,0.1,0.2,0.2],[0.8,0.05,0.1,0.04])
1435             fNode.setGaussLocalizationOnCells([9,10],[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.5,0.5,0.7,0.7,0.1,0.1,0.2,0.2,0.3,0.3,0.4,0.4,0.8,0.8],[0.8,0.05,0.1,0.01,0.02,0.005,0.005])
1436             arr=DataArrayDouble(2*(4*2+2*5+3*4+2*7)) ; arr.iota(300+1000*i) ; arr.rearrange(2)
1437             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"]) ; fNode.checkCoherency()
1438             f.setFieldNoProfileSBT(fNode)
1439             fs2.pushBackTimeStep(f)
1440             #
1441             f=MEDFileField1TS()
1442             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1443             fNode.setName(fieldName3) ; fNode.setMesh(m)
1444             arr=DataArrayDouble(2*15) ; arr.iota(400+1000*i) ; arr.rearrange(2)
1445             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_3 [m]","Com2_3 [s^2]"]) ; fNode.checkCoherency()
1446             f.setFieldNoProfileSBT(fNode)
1447             fs3.pushBackTimeStep(f)
1448             #
1449             pass
1450         #
1451         mm.write(fname,2)
1452         fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0)
1453         a0Exp=mm.getCoords().deepCpy()
1454         del m,mm,fs1,fs2,fs3,f,fNode
1455         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1456         ms=MEDFileMeshes(fname)
1457         fields=MEDFileFields(fname,False)
1458         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1459         allFMTSLeavesToDisplay=[]
1460         for fields in fields_per_mesh:
1461             allFMTSLeavesToDisplay2=[]
1462             for fmts in fields:
1463                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
1464                 pass
1465             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1466             pass
1467         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1468         self.assertEqual(len(allFMTSLeavesToDisplay[0]),4)
1469         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1470         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 4 fields are defined on the same time steps
1471         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
1472         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1473         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
1474         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),4)
1475         #
1476         mst=MEDFileMeshStruct.New(ms[0])
1477         #
1478         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1479         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1480         mml2=mml.prepare()
1481         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
1482         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1483         self.assertTrue(not ncc)
1484         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
1485         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5,5,5,5,9,9,9,9,9])))
1486         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,12,16,20,24,29,34,39,44])))
1487         self.assertTrue(a3.isEqual(DataArrayInt([3,2,7,3,3,7,8,3,3,3,8,4,3,8,9,4,3,13,9,8,3,13,14,9,4,0,5,6,1,4,1,6,7,2,4,5,10,11,6,4,6,11,12,7,4,12,13,8,7])))
1488         self.assertTrue(a4 is None)
1489         self.assertTrue(a5 is None)
1490         for i in xrange(1,5):
1491             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1492             pass
1493         for i in xrange(5):
1494             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1495             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1496             f.loadArraysIfNecessary()
1497             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1498             self.assertEqual(f.getName(),fieldName0)
1499             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1500             vExp=DataArrayDouble(38*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
1501             self.assertTrue(v.isEqual(vExp,1e-12))
1502             #
1503             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
1504             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1505             f.loadArraysIfNecessary()
1506             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1507             self.assertEqual(f.getName(),fieldName1)
1508             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1509             vExp=DataArrayDouble(11*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
1510             self.assertTrue(v.isEqual(vExp,1e-12))
1511             #
1512             f=allFMTSLeavesPerCommonSupport[0][0][2][i]
1513             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1514             f.loadArraysIfNecessary()
1515             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1516             self.assertEqual(f.getName(),fieldName2)
1517             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug
1518             vExp=DataArrayDouble(44*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
1519             self.assertTrue(v.isEqual(vExp,1e-12))
1520             #
1521             f=allFMTSLeavesPerCommonSupport[0][0][3][i]
1522             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1523             f.loadArraysIfNecessary()
1524             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1525             self.assertEqual(f.getName(),fieldName3)
1526             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1527             vExp=DataArrayDouble(15*2) ; vExp.iota(400+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_3 [m]','Com2_3 [s^2]'])
1528             self.assertTrue(v.isEqual(vExp,1e-12))
1529             pass
1530         #
1531         pass
1532
1533     def test9(self):
1534         """ This test plays with with gauss fields with profiles.
1535         """
1536         fname="ForMEDReader9.med"
1537         # building a mesh containing 6 tri3 + 5 quad4
1538         m=MEDCouplingUMesh("mesh",2)
1539         coords=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)]) ; coords.setInfoOnComponents(["XX [m]","YYY [km]"])
1540         m.setCoords(coords)
1541         m.allocateCells()
1542         m.insertNextCell(NORM_TRI3,[2,7,3]) ; m.insertNextCell(NORM_TRI3,[7,8,3]) ; m.insertNextCell(NORM_TRI3,[3,8,4]) ; m.insertNextCell(NORM_TRI3,[8,9,4])
1543         m.insertNextCell(NORM_TRI3,[13,9,8]) ; m.insertNextCell(NORM_TRI3,[13,14,9])
1544         m.insertNextCell(NORM_QUAD4,[0,5,6,1]) ; m.insertNextCell(NORM_QUAD4,[1,6,7,2]) ; m.insertNextCell(NORM_QUAD4,[5,10,11,6]) ; m.insertNextCell(NORM_QUAD4,[6,11,12,7])
1545         m.insertNextCell(NORM_QUAD4,[12,13,8,7])
1546         mm=MEDFileUMesh() ; mm.setMeshes([m])
1547         #
1548         fieldName0="zeField0"
1549         fieldName1="zeField1"
1550         fieldName2="zeField2"
1551         fieldName3="zeField3"
1552         pfl1=DataArrayInt([0,1,7,9,10]) ; pfl1.setName("pfl1") # on cells
1553         pfl2=DataArrayInt([1,2,3,6,7,8,11,12,13]) ; pfl2.setName("pfl2") # on nodes
1554         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS()
1555         for i in xrange(5):
1556             f=MEDFileField1TS()
1557             fNode=MEDCouplingFieldDouble(ON_GAUSS_NE) ; fNode.setTime(float(i),i,0)
1558             fNode.setName(fieldName0)
1559             arr=DataArrayDouble(2*18) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1560             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
1561             f.setFieldProfile(fNode,mm,0,pfl1)
1562             fs0.pushBackTimeStep(f)
1563             #
1564             f=MEDFileField1TS()
1565             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1566             fNode.setName(fieldName1)
1567             arr=DataArrayDouble(2*5) ; arr.iota(100+1000*i) ; arr.rearrange(2)
1568             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
1569             f.setFieldProfile(fNode,mm,0,pfl1)
1570             fs1.pushBackTimeStep(f)
1571             #
1572             f=MEDFileField1TS()
1573             fNode=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fNode.setTime(float(i),i,0)
1574             fNode.setName(fieldName2) ; fNode.setMesh(m[pfl1])
1575             fNode.setGaussLocalizationOnCells([0],[0.,0.,1.,0.,0.,1.],[0.5,0.5,0.7,0.7],[0.8,0.2])
1576             fNode.setGaussLocalizationOnCells([1],[0.,0.,1.,0.,0.,1.],[0.5,0.5,0.7,0.7,0.1,0.1,0.2,0.2,0.3,0.3],[0.8,0.05,0.1,0.04,0.01])
1577             fNode.setGaussLocalizationOnCells([2,3],[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.5,0.5,0.7,0.7,0.1,0.1,0.2,0.2],[0.8,0.05,0.1,0.04])
1578             fNode.setGaussLocalizationOnCells([4],[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.5,0.5,0.7,0.7,0.1,0.1,0.2,0.2,0.3,0.3,0.4,0.4,0.8,0.8],[0.8,0.05,0.1,0.01,0.02,0.005,0.005])
1579             arr=DataArrayDouble(2*(2*1+5*1+4*2+7*1)) ; arr.iota(300+1000*i) ; arr.rearrange(2)
1580             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"]) ; fNode.checkCoherency()
1581             f.setFieldProfile(fNode,mm,0,pfl1)
1582             fs2.pushBackTimeStep(f)
1583             #
1584             f=MEDFileField1TS()
1585             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1586             fNode.setName(fieldName3)
1587             arr=DataArrayDouble(2*9) ; arr.iota(400+1000*i) ; arr.rearrange(2)
1588             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_3 [m]","Com2_3 [s^2]"])
1589             f.setFieldProfile(fNode,mm,0,pfl2)
1590             fs3.pushBackTimeStep(f)
1591             #
1592             pass
1593         #
1594         mm.write(fname,2)
1595         fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0)
1596         a0Exp=mm.getCoords().deepCpy()
1597         del m,mm,fs1,fs2,fs3,f,fNode
1598         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1599         ms=MEDFileMeshes(fname)
1600         fields=MEDFileFields(fname,False)
1601         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1602         allFMTSLeavesToDisplay=[]
1603         for fields in fields_per_mesh:
1604             allFMTSLeavesToDisplay2=[]
1605             for fmts in fields:
1606                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
1607                 pass
1608             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1609             pass
1610         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1611         self.assertEqual(len(allFMTSLeavesToDisplay[0]),4)
1612         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1613         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 4 fields are defined on the same time steps
1614         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
1615         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1616         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
1617         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),4)
1618         #
1619         mst=MEDFileMeshStruct.New(ms[0])
1620         #
1621         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1622         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1623         mml2=mml.prepare()
1624         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
1625         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1626         self.assertTrue(not ncc)
1627         self.assertTrue(a0.isEqual(a0Exp[pfl2].changeNbOfComponents(3,0.),1e-12))
1628         self.assertTrue(a1.isEqual(DataArrayByte([5,5,9,9,9])))
1629         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,13,18])))
1630         self.assertTrue(a3.isEqual(DataArrayInt([3,1,4,2,3,4,5,2,4,0,3,4,1,4,3,6,7,4,4,7,8,5,4])))
1631         self.assertTrue(a4 is None)
1632         self.assertTrue(a5 is None)
1633         for i in xrange(1,5):
1634             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1635             pass
1636         for i in xrange(5):
1637             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1638             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1639             f.loadArraysIfNecessary()
1640             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1641             self.assertEqual(f.getName(),fieldName0)
1642             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1643             vExp=DataArrayDouble(18*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
1644             self.assertTrue(v.isEqual(vExp,1e-12))
1645             #
1646             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
1647             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1648             f.loadArraysIfNecessary()
1649             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1650             self.assertEqual(f.getName(),fieldName1)
1651             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1652             vExp=DataArrayDouble(5*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
1653             self.assertTrue(v.isEqual(vExp,1e-12))
1654             #
1655             f=allFMTSLeavesPerCommonSupport[0][0][2][i]
1656             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1657             f.loadArraysIfNecessary()
1658             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1659             self.assertEqual(f.getName(),fieldName2)
1660             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug
1661             vExp=DataArrayDouble(22*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
1662             self.assertTrue(v.isEqual(vExp,1e-12))
1663             #
1664             f=allFMTSLeavesPerCommonSupport[0][0][3][i]
1665             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1666             f.loadArraysIfNecessary()
1667             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1668             self.assertEqual(f.getName(),fieldName3)
1669             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1670             vExp=DataArrayDouble(9*2) ; vExp.iota(400+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_3 [m]','Com2_3 [s^2]'])
1671             self.assertTrue(v.isEqual(vExp,1e-12))
1672             pass
1673         pass
1674
1675     def test10(self):
1676         """ This test plays with fields only on nodes containing profiles.
1677         """
1678         fname="ForMEDReader10.med"
1679         # building a mesh containing 6 tri3 + 5 quad4
1680         m=MEDCouplingUMesh("mesh",2)
1681         coords=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)]) ; coords.setInfoOnComponents(["XX [m]","YYY [km]"])
1682         m.setCoords(coords)
1683         m.allocateCells()
1684         m.insertNextCell(NORM_TRI3,[2,7,3]) ; m.insertNextCell(NORM_TRI3,[7,8,3]) ; m.insertNextCell(NORM_TRI3,[3,8,4]) ; m.insertNextCell(NORM_TRI3,[8,9,4])
1685         m.insertNextCell(NORM_TRI3,[13,9,8]) ; m.insertNextCell(NORM_TRI3,[13,14,9])
1686         m.insertNextCell(NORM_QUAD4,[0,5,6,1]) ; m.insertNextCell(NORM_QUAD4,[1,6,7,2]) ; m.insertNextCell(NORM_QUAD4,[5,10,11,6]) ; m.insertNextCell(NORM_QUAD4,[6,11,12,7])
1687         m.insertNextCell(NORM_QUAD4,[12,13,8,7])
1688         mm=MEDFileUMesh() ; mm.setMeshes([m])
1689         #
1690         fieldName0="zeField0"
1691         fieldName1="zeField1"
1692         fieldName2="zeField2"
1693         pfl1=DataArrayInt([1,2,3,6,7,8,11,12,13]) ; pfl1.setName("pfl1") # on nodes
1694         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS()
1695         for i in xrange(5):
1696             f=MEDFileField1TS()
1697             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1698             fNode.setName(fieldName0)
1699             arr=DataArrayDouble(2*9) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1700             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
1701             f.setFieldProfile(fNode,mm,0,pfl1)
1702             fs0.pushBackTimeStep(f)
1703             #
1704             f=MEDFileField1TS()
1705             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1706             fNode.setName(fieldName1)
1707             arr=DataArrayDouble(2*9) ; arr.iota(100+1000*i) ; arr.rearrange(2)
1708             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
1709             f.setFieldProfile(fNode,mm,0,pfl1)
1710             fs1.pushBackTimeStep(f)
1711             #
1712             f=MEDFileField1TS()
1713             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1714             fNode.setName(fieldName2)
1715             arr=DataArrayDouble(2*9) ; arr.iota(200+1000*i) ; arr.rearrange(2)
1716             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
1717             f.setFieldProfile(fNode,mm,0,pfl1)
1718             fs2.pushBackTimeStep(f)
1719             #
1720             pass
1721         #
1722         mm.write(fname,2)
1723         fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0)
1724         a0Exp=mm.getCoords().deepCpy()
1725         del m,mm,fs1,fs2,f,fNode
1726         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1727         ms=MEDFileMeshes(fname)
1728         fields=MEDFileFields(fname,False)
1729         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1730         allFMTSLeavesToDisplay=[]
1731         for fields in fields_per_mesh:
1732             allFMTSLeavesToDisplay2=[]
1733             for fmts in fields:
1734                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
1735                 pass
1736             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1737             pass
1738         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1739         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
1740         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1741         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 4 fields are defined on the same time steps
1742         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
1743         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1744         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
1745         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),3)
1746         #
1747         mst=MEDFileMeshStruct.New(ms[0])
1748         #
1749         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1750         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1751         mml2=mml.prepare()
1752         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
1753         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1754         self.assertTrue(not ncc)
1755         self.assertTrue(a0.isEqual(a0Exp[pfl1].changeNbOfComponents(3,0.),1e-12))
1756         self.assertTrue(a1.isEqual(DataArrayByte([5,5,9,9,9])))
1757         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,13,18])))
1758         self.assertTrue(a3.isEqual(DataArrayInt([3,1,4,2,3,4,5,2,4,0,3,4,1,4,3,6,7,4,4,7,8,5,4])))
1759         self.assertTrue(a4 is None)
1760         self.assertTrue(a5 is None)
1761         for i in xrange(1,5):
1762             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1763             pass
1764         for i in xrange(5):
1765             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1766             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1767             f.loadArraysIfNecessary()
1768             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1769             self.assertEqual(f.getName(),fieldName0)
1770             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug
1771             vExp=DataArrayDouble(9*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
1772             self.assertTrue(v.isEqual(vExp,1e-12))
1773             #
1774             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
1775             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1776             f.loadArraysIfNecessary()
1777             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1778             self.assertEqual(f.getName(),fieldName1)
1779             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug
1780             vExp=DataArrayDouble(9*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
1781             self.assertTrue(v.isEqual(vExp,1e-12))
1782             #
1783             f=allFMTSLeavesPerCommonSupport[0][0][2][i]
1784             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1785             f.loadArraysIfNecessary()
1786             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1787             self.assertEqual(f.getName(),fieldName2)
1788             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug
1789             vExp=DataArrayDouble(9*2) ; vExp.iota(200+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
1790             self.assertTrue(v.isEqual(vExp,1e-12))
1791             pass
1792         pass
1793
1794     def test11(self):
1795         """ This test is the ultimate test for the profiles with gauss points. It tests that even if there is non contiguous parts in definition of gauss points, it works !
1796         WARNING here, as no other discretizations exists, the priority is given to the field -> the mesh is renumbered to accelerate the build of array of field.
1797         """
1798         fname="ForMEDReader11.med"
1799         m=MEDCouplingCMesh("mesh")
1800         arr=DataArrayDouble(5) ; arr.iota()
1801         m.setCoords(arr,arr)
1802         m=m.buildUnstructured() ; m.getCoords().setInfoOnComponents(["XX [m]","YYY [km]"])
1803         mm=MEDFileUMesh() ; mm.setMeshes([m])
1804         #
1805         fieldName0="zeField0"
1806         fs0=MEDFileFieldMultiTS()
1807         for i in xrange(5):
1808             f=MEDFileField1TS()
1809             fNode=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fNode.setTime(float(i),i,0)
1810             fNode.setName(fieldName0) ; fNode.setMesh(m)
1811             fNode.setGaussLocalizationOnCells([0,2,3,4,7,15],[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.5,0.5,0.7,0.7],[0.8,0.2])
1812             fNode.setGaussLocalizationOnCells([1,5,8,9],[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.5,0.5,0.7,0.7,0.1,0.1,0.2,0.2,0.3,0.3],[0.8,0.05,0.1,0.04,0.01])
1813             fNode.setGaussLocalizationOnCells([6,10,13],[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.5,0.5,0.7,0.7,0.1,0.1,0.2,0.2],[0.8,0.05,0.1,0.04])
1814             fNode.setGaussLocalizationOnCells([11,12,14],[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.5,0.5,0.7,0.7,0.1,0.1,0.2,0.2,0.3,0.3,0.4,0.4,0.8,0.8],[0.8,0.05,0.1,0.01,0.02,0.005,0.005])
1815             arr=DataArrayDouble(2*(2*6+5*4+4*3+7*3)) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1816             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkCoherency()
1817             f.setFieldNoProfileSBT(fNode)
1818             fs0.pushBackTimeStep(f)
1819             pass
1820         mm.write(fname,2)
1821         fs0.write(fname,0)
1822         a0Exp=mm.getCoords().deepCpy()
1823         del m,mm,fs0,f,fNode
1824         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1825         ms=MEDFileMeshes(fname)
1826         fields=MEDFileFields(fname,False)
1827         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1828         allFMTSLeavesToDisplay=[]
1829         for fields in fields_per_mesh:
1830             allFMTSLeavesToDisplay2=[]
1831             for fmts in fields:
1832                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
1833                 pass
1834             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1835             pass
1836         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1837         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
1838         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1839         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 1 field is defined on the same time steps
1840         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
1841         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1842         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
1843         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),1)
1844         #
1845         mst=MEDFileMeshStruct.New(ms[0])
1846         #
1847         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1848         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1849         mml2=mml.prepare()
1850         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
1851         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1852         self.assertTrue(not ncc)
1853         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
1854         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9])))
1855         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75])))
1856         self.assertTrue(a3.isEqual(DataArrayInt([4,1,0,5,6,4,3,2,7,8,4,4,3,8,9,4,6,5,10,11,4,9,8,13,14,4,19,18,23,24,4,2,1,6,7,4,7,6,11,12,4,11,10,15,16,4,12,11,16,17,4,8,7,12,13,4,13,12,17,18,4,17,16,21,22,4,14,13,18,19,4,16,15,20,21,4,18,17,22,23]))) # <- here the mesh is renumbered : the mesh is equal to m[[0,2,3,4,7,15, 1,5,8,9, 6,10,13, 11,12,14]]
1857         self.assertTrue(a4 is None)
1858         self.assertTrue(a5 is None)
1859         for i in xrange(1,5):
1860             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1861             pass
1862         for i in xrange(5):
1863             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1864             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1865             f.loadArraysIfNecessary()
1866             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1867             self.assertEqual(f.getName(),fieldName0)
1868             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1869             vExp=DataArrayDouble([0.,1.,2.,3.,14.,15.,16.,17.,18.,19.,20.,21.,22.,23.,24.,25.,44.,45.,46.,47.,126.,127.,128.,129.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,26.,27.,28.,29.,30.,31.,32.,33.,34.,35.,48.,49.,50.,51.,52.,53.,54.,55.,56.,57.,58.,59.,60.,61.,62.,63.,64.,65.,66.,67.,36.,37.,38.,39.,40.,41.,42.,43.,68.,69.,70.,71.,72.,73.,74.,75.,104.,105.,106.,107.,108.,109.,110.,111.,76.,77.,78.,79.,80.,81.,82.,83.,84.,85.,86.,87.,88.,89.,90.,91.,92.,93.,94.,95.,96.,97.,98.,99.,100.,101.,102.,103.,112.,113.,114.,115.,116.,117.,118.,119.,120.,121.,122.,123.,124.,125.],65,2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
1870             vExp+=i*1000
1871             self.assertTrue(v.isEqual(vExp,1e-12))
1872             pass
1873         pass
1874
1875     def test12(self):
1876         """ This test is the second ultimate test for the profiles with gauss points.
1877         This test is close to test11 but here a 2nd field on cells without profile. So here the mesh is expected to be the same than m.
1878         """
1879         fname="ForMEDReader12.med"
1880         m=MEDCouplingCMesh("mesh")
1881         arr=DataArrayDouble(5) ; arr.iota()
1882         m.setCoords(arr,arr)
1883         m=m.buildUnstructured() ; m.getCoords().setInfoOnComponents(["XX [m]","YYY [km]"])
1884         mm=MEDFileUMesh() ; mm.setMeshes([m])
1885         #
1886         fieldName0="zeField0"
1887         fieldName1="zeField1"
1888         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS()
1889         for i in xrange(5):
1890             f=MEDFileField1TS()
1891             fNode=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fNode.setTime(float(i),i,0)
1892             fNode.setName(fieldName0) ; fNode.setMesh(m)
1893             fNode.setGaussLocalizationOnCells([0,2,3,4,7,15],[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.5,0.5,0.7,0.7],[0.8,0.2])
1894             fNode.setGaussLocalizationOnCells([1,5,8,9],[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.5,0.5,0.7,0.7,0.1,0.1,0.2,0.2,0.3,0.3],[0.8,0.05,0.1,0.04,0.01])
1895             fNode.setGaussLocalizationOnCells([6,10,13],[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.5,0.5,0.7,0.7,0.1,0.1,0.2,0.2],[0.8,0.05,0.1,0.04])
1896             fNode.setGaussLocalizationOnCells([11,12,14],[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.5,0.5,0.7,0.7,0.1,0.1,0.2,0.2,0.3,0.3,0.4,0.4,0.8,0.8],[0.8,0.05,0.1,0.01,0.02,0.005,0.005])
1897             arr=DataArrayDouble(2*(2*6+5*4+4*3+7*3)) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1898             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkCoherency()
1899             f.setFieldNoProfileSBT(fNode)
1900             fs0.pushBackTimeStep(f)
1901             #
1902             f=MEDFileField1TS()
1903             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1904             fNode.setName(fieldName1) ; fNode.setMesh(m)
1905             arr=DataArrayDouble(2*16) ; arr.iota(300+1000*i) ; arr.rearrange(2)
1906             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"]) ; fNode.checkCoherency()
1907             f.setFieldNoProfileSBT(fNode)
1908             fs1.pushBackTimeStep(f)
1909             pass
1910         mm.write(fname,2)
1911         fs0.write(fname,0) ; fs1.write(fname,0)
1912         a0Exp=mm.getCoords().deepCpy()
1913         del m,mm,fs0,fs1,f,fNode
1914         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1915         ms=MEDFileMeshes(fname)
1916         fields=MEDFileFields(fname,False)
1917         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1918         allFMTSLeavesToDisplay=[]
1919         for fields in fields_per_mesh:
1920             allFMTSLeavesToDisplay2=[]
1921             for fmts in fields:
1922                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
1923                 pass
1924             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1925             pass
1926         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1927         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
1928         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1929         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
1930         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
1931         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1932         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
1933         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
1934         #
1935         mst=MEDFileMeshStruct.New(ms[0])
1936         #
1937         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1938         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1939         mml2=mml.prepare()
1940         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
1941         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1942         self.assertTrue(not ncc)
1943         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
1944         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9])))
1945         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75])))
1946         self.assertTrue(a3.isEqual(DataArrayInt([4,1,0,5,6,4,2,1,6,7,4,3,2,7,8,4,4,3,8,9,4,6,5,10,11,4,7,6,11,12,4,8,7,12,13,4,9,8,13,14,4,11,10,15,16,4,12,11,16,17,4,13,12,17,18,4,14,13,18,19,4,16,15,20,21,4,17,16,21,22,4,18,17,22,23,4,19,18,23,24]))) # <- here the mesh is NOT renumbered : the mesh is equal to m
1947         self.assertTrue(a4 is None)
1948         self.assertTrue(a5 is None)
1949         for i in xrange(1,5):
1950             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1951             pass
1952         for i in xrange(5):
1953             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1954             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1955             f.loadArraysIfNecessary()
1956             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1957             self.assertEqual(f.getName(),fieldName0)
1958             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug : huge reordering performed !
1959             vExp=DataArrayDouble(65*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
1960             self.assertTrue(v.isEqual(vExp,1e-12))
1961             #
1962             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
1963             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1964             f.loadArraysIfNecessary()
1965             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1966             self.assertEqual(f.getName(),fieldName1)
1967             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug : huge reordering performed !
1968             vExp=DataArrayDouble(16*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
1969             self.assertTrue(v.isEqual(vExp,1e-12))
1970             pass
1971
1972     def test13(self):
1973             """ Testing polyhedrons mixed with hexa8"""
1974             fname="ForMEDReader13.med"
1975             m=MEDCouplingUMesh("mesh",3)
1976             m.allocateCells()
1977             m.insertNextCell(NORM_HEXA8,[1,0,6,7,13,12,18,19]) ; m.insertNextCell(NORM_HEXA8,[2,1,7,8,14,13,19,20])
1978             m.insertNextCell(NORM_POLYHED,[3,2,8,9,-1,15,21,20,14,-1,3,15,14,2,-1,2,14,20,8,-1,8,20,21,9,-1,9,21,15,3])
1979             m.insertNextCell(NORM_POLYHED,[4,3,9,10,-1,16,22,21,15,-1,4,16,15,3,-1,3,15,21,9,-1,9,21,22,10,-1,10,22,16,4])
1980             m.insertNextCell(NORM_POLYHED,[5,4,10,11,-1,17,23,22,16,-1,5,17,16,4,-1,4,16,22,10,-1,10,22,23,11,-1,11,23,17,5])
1981             coords=DataArrayDouble([0.,0.,0.,1.,0.,0.,2.,0.,0.,3.,0.,0.,4.,0.,0.,5.,0.,0.,0.,1.,0.,1.,1.,0.,2.,1.,0.,3.,1.,0.,4.,1.,0.,5.,1.,0.,0.,0.,1.,1.,0.,1.,2.,0.,1.,3.,0.,1.,4.,0.,1.,5.,0.,1.,0.,1.,1.,1.,1.,1.,2.,1.,1.,3.,1.,1.,4.,1.,1.,5.,1.,1.],24,3) ; coords.setInfoOnComponents(["XX [m]","YYY [km]","ZZZZ [Mm]"])
1982             m.setCoords(coords)
1983             mm=MEDFileUMesh() ; mm.setMeshes([m])
1984             fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS()
1985             fieldName0="zeField0"
1986             fieldName1="zeField1"
1987             fieldName2="zeField2" ; pfl1=DataArrayInt([2,3]) ; pfl1.setName("pfl1")
1988             fieldName3="zefield3" ; pfl2=DataArrayInt([2,3,4]) ; pfl2.setName("pfl2")
1989             for i in xrange(5):
1990                 f=MEDFileField1TS()
1991                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1992                 fNode.setName(fieldName0) ; fNode.setMesh(m)
1993                 arr=DataArrayDouble(2*5) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1994                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkCoherency()
1995                 f.setFieldNoProfileSBT(fNode)
1996                 fs0.pushBackTimeStep(f)
1997                 #
1998                 f=MEDFileField1TS()
1999                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2000                 fNode.setName(fieldName1) ; fNode.setMesh(m)
2001                 arr=DataArrayDouble(2*5) ; arr.iota(100+1000*i) ; arr.rearrange(2)
2002                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"]) ; fNode.checkCoherency()
2003                 f.setFieldNoProfileSBT(fNode)
2004                 fs1.pushBackTimeStep(f)
2005                 #
2006                 f=MEDFileField1TS()
2007                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2008                 fNode.setName(fieldName2) ; fNode.setMesh(m[pfl1])
2009                 arr=DataArrayDouble(2*2) ; arr.iota(200+1000*i) ; arr.rearrange(2)
2010                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"]) ; fNode.checkCoherency()
2011                 f.setFieldProfile(fNode,mm,0,pfl1)
2012                 fs2.pushBackTimeStep(f)
2013                 #
2014                 f=MEDFileField1TS()
2015                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2016                 fNode.setName(fieldName3) ; fNode.setMesh(m[pfl2])
2017                 arr=DataArrayDouble(2*3) ; arr.iota(300+1000*i) ; arr.rearrange(2)
2018                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_3 [m]","Com2_3 [s^2]"]) ; fNode.checkCoherency()
2019                 f.setFieldProfile(fNode,mm,0,pfl2)
2020                 fs3.pushBackTimeStep(f)
2021                 pass
2022             mm.write(fname,2)
2023             fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0)
2024             a0Exp=mm.getCoords().deepCpy()
2025             del m,mm,fs0
2026             ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2027             ms=MEDFileMeshes(fname)
2028             fields=MEDFileFields(fname,False)
2029             fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2030             allFMTSLeavesToDisplay=[]
2031             for fields in fields_per_mesh:
2032                 allFMTSLeavesToDisplay2=[]
2033                 for fmts in fields:
2034                     allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
2035                     pass
2036                 allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2037                 pass
2038             self.assertEqual(len(allFMTSLeavesToDisplay),1)
2039             self.assertEqual(len(allFMTSLeavesToDisplay[0]),4)
2040             allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2041             self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
2042             self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
2043             allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
2044             self.assertEqual(len(allFMTSLeavesPerCommonSupport),3)
2045             self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
2046             self.assertEqual(len(allFMTSLeavesPerCommonSupport[1][0]),1)
2047             self.assertEqual(len(allFMTSLeavesPerCommonSupport[2][0]),1)
2048             #
2049             mst=MEDFileMeshStruct.New(ms[0])
2050             #
2051             fcscp=allFMTSLeavesPerCommonSupport[0][1]
2052             mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2053             mml2=mml.prepare()
2054             self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2055             ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2056             self.assertTrue(ncc)
2057             self.assertTrue(a0.isEqual(a0Exp,1e-12))
2058             self.assertTrue(a1.isEqual(DataArrayByte([12,12,42,42,42])))
2059             self.assertTrue(a2.isEqual(DataArrayInt([0,9,18,27,36])))
2060             self.assertTrue(a3.isEqual(DataArrayInt([8,1,0,6,7,13,12,18,19,8,2,1,7,8,14,13,19,20,8,2,3,8,9,14,15,20,21,8,3,4,9,10,15,16,21,22,8,4,5,10,11,16,17,22,23])))
2061             self.assertTrue(a4.isEqual(DataArrayInt([-1,-1,0,31,62])))
2062             self.assertTrue(a5.isEqual(DataArrayInt([6,4,3,2,8,9,4,15,21,20,14,4,3,15,14,2,4,2,14,20,8,4,8,20,21,9,4,9,21,15,3,6,4,4,3,9,10,4,16,22,21,15,4,4,16,15,3,4,3,15,21,9,4,9,21,22,10,4,10,22,16,4,6,4,5,4,10,11,4,17,23,22,16,4,5,17,16,4,4,4,16,22,10,4,10,22,23,11,4,11,23,17,5])))
2063             for i in xrange(1,5):
2064                 self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2065                 pass
2066             pass
2067             for i in xrange(5):
2068                 f=allFMTSLeavesPerCommonSupport[0][0][0][i]
2069                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2070                 f.loadArraysIfNecessary()
2071                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2072                 self.assertEqual(f.getName(),fieldName0)
2073                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2074                 vExp=DataArrayDouble(5*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
2075                 self.assertTrue(v.isEqual(vExp,1e-12))
2076                 #
2077                 f=allFMTSLeavesPerCommonSupport[0][0][1][i]
2078                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2079                 f.loadArraysIfNecessary()
2080                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2081                 self.assertEqual(f.getName(),fieldName1)
2082                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2083                 vExp=DataArrayDouble(5*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
2084                 self.assertTrue(v.isEqual(vExp,1e-12))
2085                 pass
2086             #
2087             fcscp=allFMTSLeavesPerCommonSupport[1][1]
2088             mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2089             mml2=mml.prepare()
2090             self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2091             ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2092             self.assertTrue(ncc)
2093             self.assertTrue(a0.isEqual(a0Exp,1e-12))
2094             self.assertTrue(a1.isEqual(DataArrayByte([42,42])))
2095             self.assertTrue(a2.isEqual(DataArrayInt([0,9])))
2096             self.assertTrue(a3.isEqual(DataArrayInt([8,2,3,8,9,14,15,20,21,8,3,4,9,10,15,16,21,22])))
2097             self.assertTrue(a4.isEqual(DataArrayInt([0,31])))
2098             self.assertTrue(a5.isEqual(DataArrayInt([6,4,3,2,8,9,4,15,21,20,14,4,3,15,14,2,4,2,14,20,8,4,8,20,21,9,4,9,21,15,3,6,4,4,3,9,10,4,16,22,21,15,4,4,16,15,3,4,3,15,21,9,4,9,21,22,10,4,10,22,16,4])))
2099             for i in xrange(1,5):
2100                 self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2101                 pass
2102             pass
2103             for i in xrange(5):
2104                 f=allFMTSLeavesPerCommonSupport[1][0][0][i]
2105                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2106                 f.loadArraysIfNecessary()
2107                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2108                 self.assertEqual(f.getName(),fieldName2)
2109                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2110                 vExp=DataArrayDouble(2*2) ; vExp.iota(200+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
2111                 self.assertTrue(v.isEqual(vExp,1e-12))
2112                 pass
2113             #
2114             fcscp=allFMTSLeavesPerCommonSupport[2][1]
2115             mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2116             mml2=mml.prepare()
2117             self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2118             ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2119             self.assertTrue(ncc)
2120             self.assertTrue(a0.isEqual(a0Exp,1e-12))
2121             self.assertTrue(a1.isEqual(DataArrayByte([42,42,42])))
2122             self.assertTrue(a2.isEqual(DataArrayInt([0,9,18])))
2123             self.assertTrue(a3.isEqual(DataArrayInt([8,2,3,8,9,14,15,20,21,8,3,4,9,10,15,16,21,22,8,4,5,10,11,16,17,22,23])))
2124             self.assertTrue(a4.isEqual(DataArrayInt([0,31,62])))
2125             self.assertTrue(a5.isEqual(DataArrayInt([6,4,3,2,8,9,4,15,21,20,14,4,3,15,14,2,4,2,14,20,8,4,8,20,21,9,4,9,21,15,3,6,4,4,3,9,10,4,16,22,21,15,4,4,16,15,3,4,3,15,21,9,4,9,21,22,10,4,10,22,16,4,6,4,5,4,10,11,4,17,23,22,16,4,5,17,16,4,4,4,16,22,10,4,10,22,23,11,4,11,23,17,5])))
2126             for i in xrange(1,5):
2127                 self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2128                 pass
2129             pass
2130             for i in xrange(5):
2131                 f=allFMTSLeavesPerCommonSupport[2][0][0][i]
2132                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2133                 f.loadArraysIfNecessary()
2134                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2135                 self.assertEqual(f.getName(),fieldName3)
2136                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2137                 vExp=DataArrayDouble(3*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_3 [m]','Com2_3 [s^2]'])
2138                 self.assertTrue(v.isEqual(vExp,1e-12))
2139                 pass
2140             pass
2141
2142     def test14(self):
2143             """ Testing only polyhedrons"""
2144             fname="ForMEDReader14.med"
2145             m=MEDCouplingUMesh("mesh",3)
2146             m.allocateCells()
2147             m.insertNextCell(NORM_POLYHED,[3,2,8,9,-1,15,21,20,14,-1,3,15,14,2,-1,2,14,20,8,-1,8,20,21,9,-1,9,21,15,3])
2148             m.insertNextCell(NORM_POLYHED,[4,3,9,10,-1,16,22,21,15,-1,4,16,15,3,-1,3,15,21,9,-1,9,21,22,10,-1,10,22,16,4])
2149             m.insertNextCell(NORM_POLYHED,[5,4,10,11,-1,17,23,22,16,-1,5,17,16,4,-1,4,16,22,10,-1,10,22,23,11,-1,11,23,17,5])
2150             coords=DataArrayDouble([0.,0.,0.,1.,0.,0.,2.,0.,0.,3.,0.,0.,4.,0.,0.,5.,0.,0.,0.,1.,0.,1.,1.,0.,2.,1.,0.,3.,1.,0.,4.,1.,0.,5.,1.,0.,0.,0.,1.,1.,0.,1.,2.,0.,1.,3.,0.,1.,4.,0.,1.,5.,0.,1.,0.,1.,1.,1.,1.,1.,2.,1.,1.,3.,1.,1.,4.,1.,1.,5.,1.,1.],24,3) ; coords.setInfoOnComponents(["XX [m]","YYY [km]","ZZZZ [Mm]"])
2151             m.setCoords(coords)
2152             mm=MEDFileUMesh() ; mm.setMeshes([m])
2153             fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS()
2154             fieldName0="zeField0"
2155             fieldName1="zeField1"
2156             for i in xrange(5):
2157                 f=MEDFileField1TS()
2158                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2159                 fNode.setName(fieldName0) ; fNode.setMesh(m)
2160                 arr=DataArrayDouble(2*3) ; arr.iota(0+1000*i) ; arr.rearrange(2)
2161                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkCoherency()
2162                 f.setFieldNoProfileSBT(fNode)
2163                 fs0.pushBackTimeStep(f)
2164                 #
2165                 f=MEDFileField1TS()
2166                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2167                 fNode.setName(fieldName1) ; fNode.setMesh(m)
2168                 arr=DataArrayDouble(2*3) ; arr.iota(100+1000*i) ; arr.rearrange(2)
2169                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"]) ; fNode.checkCoherency()
2170                 f.setFieldNoProfileSBT(fNode)
2171                 fs1.pushBackTimeStep(f)
2172                 pass
2173             mm.write(fname,2)
2174             fs0.write(fname,0) ; fs1.write(fname,0)
2175             a0Exp=mm.getCoords().deepCpy()
2176             del m,mm,fs0
2177             ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2178             ms=MEDFileMeshes(fname)
2179             fields=MEDFileFields(fname,False)
2180             fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2181             allFMTSLeavesToDisplay=[]
2182             for fields in fields_per_mesh:
2183                 allFMTSLeavesToDisplay2=[]
2184                 for fmts in fields:
2185                     allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
2186                     pass
2187                 allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2188                 pass
2189             self.assertEqual(len(allFMTSLeavesToDisplay),1)
2190             self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
2191             allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2192             self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
2193             self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
2194             allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
2195             self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
2196             self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
2197             #
2198             mst=MEDFileMeshStruct.New(ms[0])
2199             #
2200             fcscp=allFMTSLeavesPerCommonSupport[0][1]
2201             mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2202             mml2=mml.prepare()
2203             self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2204             ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2205             self.assertTrue(ncc)
2206             self.assertTrue(a0.isEqual(a0Exp,1e-12))
2207             self.assertTrue(a1.isEqual(DataArrayByte([42,42,42])))
2208             self.assertTrue(a2.isEqual(DataArrayInt([0,9,18])))
2209             self.assertTrue(a3.isEqual(DataArrayInt([8,2,3,8,9,14,15,20,21,8,3,4,9,10,15,16,21,22,8,4,5,10,11,16,17,22,23])))
2210             self.assertTrue(a4.isEqual(DataArrayInt([0,31,62])))
2211             self.assertTrue(a5.isEqual(DataArrayInt([6,4,3,2,8,9,4,15,21,20,14,4,3,15,14,2,4,2,14,20,8,4,8,20,21,9,4,9,21,15,3,6,4,4,3,9,10,4,16,22,21,15,4,4,16,15,3,4,3,15,21,9,4,9,21,22,10,4,10,22,16,4,6,4,5,4,10,11,4,17,23,22,16,4,5,17,16,4,4,4,16,22,10,4,10,22,23,11,4,11,23,17,5])))
2212             for i in xrange(1,5):
2213                 self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2214                 pass
2215             a6,a7=mml2.retrieveFamilyIdsOnCells()
2216             self.assertTrue(a6.isEqual(DataArrayInt([0,0,0])))
2217             self.assertTrue(a7)
2218             a8,a9=mml2.retrieveNumberIdsOnCells()
2219             self.assertTrue(a8 is None)
2220             self.assertTrue(a9)
2221             for i in xrange(5):
2222                 f=allFMTSLeavesPerCommonSupport[0][0][0][i]
2223                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2224                 f.loadArraysIfNecessary()
2225                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2226                 self.assertEqual(f.getName(),fieldName0)
2227                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2228                 vExp=DataArrayDouble(3*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
2229                 self.assertTrue(v.isEqual(vExp,1e-12))
2230                 #
2231                 f=allFMTSLeavesPerCommonSupport[0][0][1][i]
2232                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2233                 f.loadArraysIfNecessary()
2234                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2235                 self.assertEqual(f.getName(),fieldName1)
2236                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2237                 vExp=DataArrayDouble(3*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
2238                 self.assertTrue(v.isEqual(vExp,1e-12))
2239                 pass
2240             pass
2241
2242     def test15(self):
2243         """
2244         "ForMEDReader15.med" file has a spaceDim 3 mesh "mesh" (it is important !)
2245         and a field "zeField" lying on a single geometric type for Cell discr and node part.
2246         Test that can appear the most simple but it hides a big issue of MEDReader
2247         that copies are reduced at most. So it can leads to SIGSEGV if the memory management is not OK for int* and double * similar between VTK and MEDCoupling.
2248         """
2249         fname="ForMEDReader15.med"
2250         m0=MEDCouplingCMesh()
2251         arr=DataArrayDouble(3) ; arr.iota(0)
2252         m0.setCoords(arr,arr,arr)
2253         m0.setName("mesh")
2254         m0=m0.buildUnstructured()
2255         #
2256         fieldName="zeField"
2257         fCell=MEDCouplingFieldDouble(ON_CELLS)
2258         fCell.setName(fieldName)
2259         fCell.setMesh(m0)
2260         #
2261         fNode=MEDCouplingFieldDouble(ON_NODES)
2262         fNode.setName(fieldName)
2263         fNode.setMesh(m0)
2264         #
2265         mm=MEDFileUMesh()
2266         mm.setMeshAtLevel(0,m0)
2267         fam=DataArrayInt(8) ; fam.iota(0) ; mm.setFamilyFieldArr(0,fam) ; del fam
2268         num=DataArrayInt(8) ; num.iota(100) ; mm.setRenumFieldArr(0,num) ; del num
2269         #
2270         ffs=MEDFileFieldMultiTS()
2271         # TimeStep 0
2272         t=(1.,0,0) ; off=0.
2273         f1ts=MEDFileField1TS()
2274         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2275         fCell.setArray(a)
2276         fCell.setTime(*t)
2277         fCell.checkCoherency()
2278         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2279         a=a.negate()
2280         fNode.setArray(a)
2281         fNode.setTime(*t)
2282         fNode.checkCoherency()
2283         f1ts.setFieldNoProfileSBT(fCell)
2284         f1ts.setFieldNoProfileSBT(fNode)
2285         ffs.pushBackTimeStep(f1ts)
2286         # TimeStep 1
2287         t=(2.1,1,0) ; off=100.
2288         f1ts=MEDFileField1TS()
2289         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2290         fCell.setArray(a)
2291         fCell.setTime(*t)
2292         fCell.checkCoherency()
2293         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2294         a=a.negate()
2295         fNode.setArray(a)
2296         fNode.setTime(*t)
2297         fNode.checkCoherency()
2298         f1ts.setFieldNoProfileSBT(fCell)
2299         f1ts.setFieldNoProfileSBT(fNode)
2300         ffs.pushBackTimeStep(f1ts)
2301         # TimeStep 2
2302         t=(3.2,2,0) ; off=200.
2303         f1ts=MEDFileField1TS()
2304         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2305         fCell.setArray(a)
2306         fCell.setTime(*t)
2307         fCell.checkCoherency()
2308         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2309         a=a.negate()
2310         fNode.setArray(a)
2311         fNode.setTime(*t)
2312         fNode.checkCoherency()
2313         f1ts.setFieldNoProfileSBT(fCell)
2314         f1ts.setFieldNoProfileSBT(fNode)
2315         ffs.pushBackTimeStep(f1ts)
2316         # TimeStep 3
2317         t=(4.3,3,1) ; off=300.
2318         f1ts=MEDFileField1TS()
2319         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2320         fCell.setArray(a)
2321         fCell.setTime(*t)
2322         fCell.checkCoherency()
2323         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2324         a=a.negate()
2325         fNode.setArray(a)
2326         fNode.setTime(*t)
2327         fNode.checkCoherency()
2328         f1ts.setFieldNoProfileSBT(fCell)
2329         f1ts.setFieldNoProfileSBT(fNode)
2330         ffs.pushBackTimeStep(f1ts)
2331         #
2332         mm.write(fname,2)
2333         ffs.write(fname,0)
2334         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2335         ms=MEDFileMeshes(fname)
2336         fields=MEDFileFields(fname,False)
2337         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2338         allFMTSLeavesToDisplay=[]
2339         for fields in fields_per_mesh:
2340             allFMTSLeavesToDisplay2=[]
2341             for fmts in fields:
2342                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
2343                 pass
2344             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2345             pass
2346         self.assertEqual(len(allFMTSLeavesToDisplay),1)
2347         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
2348         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2349         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
2350         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
2351         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
2352         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
2353         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
2354         #
2355         mst=MEDFileMeshStruct.New(ms[0])
2356         #
2357         fcscp=allFMTSLeavesPerCommonSupport[0][1]
2358         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2359         mml2=mml.prepare()
2360         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2361         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2362         self.assertTrue(ncc)
2363         self.assertTrue(a0.isEqual(DataArrayDouble([0.,0.,0.,1.,0.,0.,2.,0.,0.,0.,1.,0.,1.,1.,0.,2.,1.,0.,0.,2.,0.,1.,2.,0.,2.,2.,0.,0.,0.,1.,1.,0.,1.,2.,0.,1.,0.,1.,1.,1.,1.,1.,2.,1.,1.,0.,2.,1.,1.,2.,1.,2.,2.,1.,0.,0.,2.,1.,0.,2.,2.,0.,2.,0.,1.,2.,1.,1.,2.,2.,1.,2.,0.,2.,2.,1.,2.,2.,2.,2.,2.0],27,3),1e-12))
2364         self.assertTrue(a1.isEqual(DataArrayByte([12,12,12,12,12,12,12,12])))
2365         self.assertTrue(a2.isEqual(DataArrayInt([0,9,18,27,36,45,54,63])))
2366         self.assertTrue(a3.isEqual(DataArrayInt([8,1,0,3,4,10,9,12,13,8,2,1,4,5,11,10,13,14,8,4,3,6,7,13,12,15,16,8,5,4,7,8,14,13,16,17,8,10,9,12,13,19,18,21,22,8,11,10,13,14,20,19,22,23,8,13,12,15,16,22,21,24,25,8,14,13,16,17,23,22,25,26])))
2367         self.assertTrue(a4 is None)
2368         self.assertTrue(a5 is None)
2369         a6,a7=mml2.retrieveFamilyIdsOnCells()
2370         self.assertTrue(a6.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
2371         self.assertTrue(a7) # no copy here
2372         a8,a9=mml2.retrieveNumberIdsOnCells()
2373         self.assertTrue(a8.isEqual(DataArrayInt([100,101,102,103,104,105,106,107])))
2374         self.assertTrue(a9) # no copy here
2375         pass
2376
2377     def test16(self):
2378         """ Here 2 meshes "mesh1" and "mesh2" and 4 fields (no profiles here) :
2379         - "zeField1_0" (CELLS) and "zeField2_0" (NODES) on "mesh1"
2380         - "zeField3_1" (CELLS) and "zeField4_1" (NODES) on "mesh2"
2381         time steps series are the same for the whole 4 fields
2382         """
2383         fname="ForMEDReader16.med"
2384         m0=MEDCouplingCMesh()
2385         arr=DataArrayDouble(3) ; arr.iota(0)
2386         m0.setCoords(arr,arr,arr)
2387         m0.setName("mesh1")
2388         m0=m0.buildUnstructured()
2389         #
2390         fCell1=MEDCouplingFieldDouble(ON_CELLS)
2391         fCell1.setName("zeField1_0")
2392         fCell1.setMesh(m0)
2393         #
2394         fNode1=MEDCouplingFieldDouble(ON_NODES)
2395         fNode1.setName("zeField2_0")
2396         fNode1.setMesh(m0)
2397         #
2398         mms=MEDFileMeshes()
2399         mm1=MEDFileUMesh()
2400         mm1.setMeshAtLevel(0,m0)
2401         fam=DataArrayInt([0,1,0,1,2,3,2,3]); mm1.setFamilyFieldArr(0,fam) ; del fam
2402         num=DataArrayInt(8) ; num.iota(100) ; mm1.setRenumFieldArr(0,num) ; del num
2403         mm1.setFamilyId("FAMILLE_ZERO",0) ; mm1.setFamilyId("Family1_1",1) ; mm1.setFamilyId("Family1_2",2) ; mm1.setFamilyId("Family1_3",3) ; mm1.setFamilyId("Family1_4",4)
2404         mm1.setFamiliesIdsOnGroup("Grp1_1",[0,1]) ; mm1.setFamiliesIdsOnGroup("Grp1_2",[2,3])
2405         mms.pushMesh(mm1) ; del mm1
2406         #
2407         m1=m0.deepCpy() ; m1.translate([2.5,0.,0.]) ; m1.setName("mesh2")
2408         #
2409         fCell2=MEDCouplingFieldDouble(ON_CELLS)
2410         fCell2.setName("zeField3_1")
2411         fCell2.setMesh(m1)
2412         #
2413         fNode2=MEDCouplingFieldDouble(ON_NODES)
2414         fNode2.setName("zeField4_1")
2415         fNode2.setMesh(m1)
2416         #
2417         mm2=MEDFileUMesh()
2418         mm2.setMeshAtLevel(0,m1)
2419         fam=DataArrayInt([0,1,0,1,2,3,2,3]); mm2.setFamilyFieldArr(0,fam) ; del fam
2420         num=DataArrayInt(8) ; num.iota(200) ; mm2.setRenumFieldArr(0,num) ; del num
2421         mm2.setFamilyId("FAMILLE_ZERO",0) ; mm2.setFamilyId("Family2_1",1) ; mm2.setFamilyId("Family2_2",2) ; mm2.setFamilyId("Family2_3",3) ; mm2.setFamilyId("Family2_4",4)
2422         mm2.setFamiliesIdsOnGroup("Grp2_1",[0,1]) ; mm2.setFamiliesIdsOnGroup("Grp2_2",[2,3]) ; mm2.setFamiliesIdsOnGroup("Grp2_3",[1,2,3])
2423         mms.pushMesh(mm2) ; del mm2
2424         ffs1_1=MEDFileFieldMultiTS()
2425         ffs1_2=MEDFileFieldMultiTS()
2426         ffs2_1=MEDFileFieldMultiTS()
2427         ffs2_2=MEDFileFieldMultiTS()
2428         mts=MEDFileFields()
2429         for elt in ffs1_1,ffs1_2,ffs2_1,ffs2_2:
2430             mts.pushField(elt)
2431             pass
2432         # TimeStep 0
2433         t=(1.,0,0) ; off=0.
2434         f1ts1=MEDFileField1TS()
2435         f1ts2=MEDFileField1TS()
2436         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2437         fCell1.setArray(a)
2438         fCell1.setTime(*t)
2439         fCell1.checkCoherency()
2440         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2441         a=a.negate()
2442         fNode1.setArray(a)
2443         fNode1.setTime(*t)
2444         fNode1.checkCoherency()
2445         f1ts1.setFieldNoProfileSBT(fCell1) ; ffs1_1.pushBackTimeStep(f1ts1)
2446         f1ts2.setFieldNoProfileSBT(fNode1) ; ffs1_2.pushBackTimeStep(f1ts2)
2447         #
2448         f1ts1=MEDFileField1TS()
2449         f1ts2=MEDFileField1TS()
2450         a=DataArrayDouble(m1.getNumberOfCells()) ; a.iota(1000.+off) ; a.setInfoOnComponents(["xx [m]"])
2451         fCell2.setArray(a)
2452         fCell2.setTime(*t)
2453         fCell2.checkCoherency()
2454         a=DataArrayDouble(m1.getNumberOfNodes()) ; a.iota(1000+off) ; a.setInfoOnComponents(["xx [m]"])
2455         a=a.negate()
2456         fNode2.setArray(a)
2457         fNode2.setTime(*t)
2458         fNode2.checkCoherency()
2459         f1ts1.setFieldNoProfileSBT(fCell2) ; ffs2_1.pushBackTimeStep(f1ts1)
2460         f1ts2.setFieldNoProfileSBT(fNode2) ; ffs2_2.pushBackTimeStep(f1ts2)
2461         # TimeStep 1
2462         t=(2.1,1,0) ; off=100.
2463         f1ts1=MEDFileField1TS()
2464         f1ts2=MEDFileField1TS()
2465         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2466         fCell1.setArray(a)
2467         fCell1.setTime(*t)
2468         fCell1.checkCoherency()
2469         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2470         a=a.negate()
2471         fNode1.setArray(a)
2472         fNode1.setTime(*t)
2473         fNode1.checkCoherency()
2474         f1ts1.setFieldNoProfileSBT(fCell1) ; ffs1_1.pushBackTimeStep(f1ts1)
2475         f1ts2.setFieldNoProfileSBT(fNode1) ; ffs1_2.pushBackTimeStep(f1ts2)
2476         #
2477         f1ts1=MEDFileField1TS()
2478         f1ts2=MEDFileField1TS()
2479         a=DataArrayDouble(m1.getNumberOfCells()) ; a.iota(1000.+off) ; a.setInfoOnComponents(["xx [m]"])
2480         fCell2.setArray(a)
2481         fCell2.setTime(*t)
2482         fCell2.checkCoherency()
2483         a=DataArrayDouble(m1.getNumberOfNodes()) ; a.iota(1000+off) ; a.setInfoOnComponents(["xx [m]"])
2484         a=a.negate()
2485         fNode2.setArray(a)
2486         fNode2.setTime(*t)
2487         fNode2.checkCoherency()
2488         f1ts1.setFieldNoProfileSBT(fCell2) ; ffs2_1.pushBackTimeStep(f1ts1)
2489         f1ts2.setFieldNoProfileSBT(fNode2) ; ffs2_2.pushBackTimeStep(f1ts2)
2490         # TimeStep 2
2491         t=(3.1,2,0) ; off=200.
2492         f1ts1=MEDFileField1TS()
2493         f1ts2=MEDFileField1TS()
2494         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2495         fCell1.setArray(a)
2496         fCell1.setTime(*t)
2497         fCell1.checkCoherency()
2498         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2499         a=a.negate()
2500         fNode1.setArray(a)
2501         fNode1.setTime(*t)
2502         fNode1.checkCoherency()
2503         f1ts1.setFieldNoProfileSBT(fCell1) ; ffs1_1.pushBackTimeStep(f1ts1)
2504         f1ts2.setFieldNoProfileSBT(fNode1) ; ffs1_2.pushBackTimeStep(f1ts2)
2505         #
2506         f1ts1=MEDFileField1TS()
2507         f1ts2=MEDFileField1TS()
2508         a=DataArrayDouble(m1.getNumberOfCells()) ; a.iota(1000.+off) ; a.setInfoOnComponents(["xx [m]"])
2509         fCell2.setArray(a)
2510         fCell2.setTime(*t)
2511         fCell2.checkCoherency()
2512         a=DataArrayDouble(m1.getNumberOfNodes()) ; a.iota(1000+off) ; a.setInfoOnComponents(["xx [m]"])
2513         a=a.negate()
2514         fNode2.setArray(a)
2515         fNode2.setTime(*t)
2516         fNode2.checkCoherency()
2517         f1ts1.setFieldNoProfileSBT(fCell2) ; ffs2_1.pushBackTimeStep(f1ts1)
2518         f1ts2.setFieldNoProfileSBT(fNode2) ; ffs2_2.pushBackTimeStep(f1ts2)
2519         #
2520         mms.write(fname,2) ; mts.write(fname,0)
2521         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2522         ms=MEDFileMeshes(fname)
2523         fields=MEDFileFields(fname,False)
2524         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2525         allFMTSLeavesToDisplay=[]
2526         for fields in fields_per_mesh:
2527             allFMTSLeavesToDisplay2=[]
2528             for fmts in fields:
2529                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
2530                 pass
2531             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2532             pass
2533         self.assertEqual(len(allFMTSLeavesToDisplay),2)
2534         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
2535         self.assertEqual(len(allFMTSLeavesToDisplay[1]),2)
2536         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2537         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
2538         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
2539         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
2540         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
2541         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),2)
2542         allFMTSLeavesPerCommonSupport2=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
2543         self.assertEqual(len(allFMTSLeavesPerCommonSupport2),1)
2544         self.assertEqual(len(allFMTSLeavesPerCommonSupport2[0][0]),2)
2545         pass
2546
2547     def test17(self):
2548         """ First test on GAUSS_NE (Elno). Here no Profiles.
2549         2 times steps.
2550         """
2551         fname="ForMEDReader17.med"
2552         fieldName1="MyFirstElno"
2553         fieldName2="ACellField"
2554         fieldName3="ANodeField"
2555         coo=DataArrayDouble([0.,0.,1.,0.,2.,0.,0.,1.,1.,1.,2.,1.],6,2)
2556         m=MEDCouplingUMesh("mesh",2)
2557         m.setCoords(coo)
2558         m.allocateCells()
2559         m.insertNextCell(NORM_QUAD4,[0,3,4,1])
2560         m.insertNextCell(NORM_QUAD4,[1,4,5,2])
2561         m.checkCoherency2()
2562         #
2563         t=(1.1,0,-1)
2564         f=MEDCouplingFieldDouble(ON_GAUSS_NE) ; f.setTime(*t) ; f.setMesh(m)
2565         f.setArray(DataArrayDouble([3.,5.,7.,6.,2.,3.,11.,8.]))
2566         f.setName(fieldName1)
2567         f.checkCoherency()
2568         MEDLoader.WriteField(fname,f,True)
2569         f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setTime(*t) ; f2.setMesh(m)
2570         f2.setArray(DataArrayDouble([7.,11.],2,1))
2571         f2.setName(fieldName2)
2572         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f2)
2573         f3=MEDCouplingFieldDouble(ON_NODES) ; f3.setTime(*t) ; f3.setMesh(m)
2574         f3.setArray(DataArrayDouble([1.,2.,4.,1.,2.,4.],6,1))
2575         f3.setName(fieldName3)
2576         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f3)
2577         #
2578         t=(2.1,1,-1)
2579         f=MEDCouplingFieldDouble(ON_GAUSS_NE) ; f.setTime(*t) ; f.setMesh(m)
2580         f.setArray(DataArrayDouble([7.,6.,3.,5.,11.,8.,2.,3.]))
2581         f.setName(fieldName1)
2582         f.checkCoherency()
2583         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f)
2584         f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setTime(*t) ; f2.setMesh(m)
2585         f2.setArray(DataArrayDouble([11.,7.],2,1))
2586         f2.setName(fieldName2)
2587         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f2)
2588         f3=MEDCouplingFieldDouble(ON_NODES) ; f3.setTime(*t) ; f3.setMesh(m)
2589         f3.setArray(DataArrayDouble([4.,2.,1.,4.,2.,1.],6,1))
2590         f3.setName(fieldName3)
2591         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f3)
2592         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2593         ms=MEDFileMeshes(fname)
2594         fields=MEDFileFields(fname,False)
2595         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2596         allFMTSLeavesToDisplay=[]
2597         for fields in fields_per_mesh:
2598             allFMTSLeavesToDisplay2=[]
2599             for fmts in fields:
2600                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
2601                 pass
2602             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2603             pass
2604         self.assertEqual(len(allFMTSLeavesToDisplay),1)
2605         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
2606         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2607         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
2608         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
2609         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
2610         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
2611         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),3)
2612         #
2613         mst=MEDFileMeshStruct.New(ms[0])
2614         #
2615         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
2616         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2617         mml2=mml.prepare()
2618         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2619         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2620         self.assertTrue(not ncc) # spaceDim 2 -> VTK wants 3D
2621         self.assertTrue(a0.isEqual(DataArrayDouble([0.,0.,0.,1.,0.,0.,2.,0.,0.,0.,1.,0.,1.,1.,0.,2.,1.,0.],6,3),1e-12))
2622         self.assertTrue(a1.isEqual(DataArrayByte([9,9])))
2623         self.assertTrue(a2.isEqual(DataArrayInt([0,5])))
2624         self.assertTrue(a3.isEqual(DataArrayInt([4,0,3,4,1,4,1,4,5,2])))
2625         self.assertTrue(a4 is None)
2626         self.assertTrue(a5 is None)
2627         a6,a7=mml2.retrieveFamilyIdsOnCells()
2628         self.assertTrue(a6.isEqual(DataArrayInt([0,0])))
2629         self.assertTrue(a7) # no copy here
2630         a8,a9=mml2.retrieveNumberIdsOnCells()
2631         self.assertTrue(a8.isEqual(DataArrayInt([0,1])))
2632         self.assertTrue(a9) # no copy here
2633         for i in xrange(1,2):
2634             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2635             pass
2636         vExp0=[DataArrayDouble([7.,11.]),DataArrayDouble([11.,7.])]
2637         vExp1=[DataArrayDouble([3.,5.,7.,6.,2.,3.,11.,8.]),DataArrayDouble([7.,6.,3.,5.,11.,8.,2.,3.])]
2638         for i in xrange(2):
2639             f=allFMTSLeavesPerCommonSupport1[0][0][0][i]
2640             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2641             f.loadArraysIfNecessary()
2642             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2643             self.assertEqual(f.getName(),fieldName2)
2644             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2645             self.assertTrue(v.isEqual(vExp0[i],1e-12))
2646             #
2647             f=allFMTSLeavesPerCommonSupport1[0][0][1][i]
2648             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2649             f.loadArraysIfNecessary()
2650             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2651             self.assertEqual(f.getName(),fieldName1)
2652             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2653             self.assertTrue(v.isEqual(vExp1[i],1e-12))
2654             pass
2655         pass
2656
2657     def test18(self):
2658         """ First test on GAUSS_PT. Here no Profiles. 2 times steps.
2659         """
2660         fname="ForMEDReader18.med"
2661         fieldName1="MyFirstGauss"
2662         fieldName2="ACellField"
2663         fieldName3="ANodeField"
2664         coo=DataArrayDouble([0.,0.,1.,0.,2.,0.,0.,1.,1.,1.,2.,1.],6,2)
2665         m=MEDCouplingUMesh("mesh",2)
2666         m.setCoords(coo)
2667         m.allocateCells()
2668         m.insertNextCell(NORM_QUAD4,[0,3,4,1])
2669         m.insertNextCell(NORM_QUAD4,[1,4,5,2])
2670         m.checkCoherency2()
2671         #
2672         t=(1.1,0,-1)
2673         f=MEDCouplingFieldDouble(ON_GAUSS_PT) ; f.setTime(*t) ; f.setMesh(m)
2674         f.setGaussLocalizationOnType(NORM_QUAD4,[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.2,0.2,0.8,0.8],[0.7,0.3])
2675         f.setArray(DataArrayDouble([3.,5.,4.,6.])) ; f.getArray().setInfoOnComponents(["Smth"])
2676         f.setName(fieldName1)
2677         f.checkCoherency()
2678         MEDLoader.WriteField(fname,f,True)
2679         f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setTime(*t) ; f2.setMesh(m)
2680         f2.setArray(DataArrayDouble([7.,11.],2,1))
2681         f2.setName(fieldName2)
2682         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f2)
2683         f3=MEDCouplingFieldDouble(ON_NODES) ; f3.setTime(*t) ; f3.setMesh(m)
2684         f3.setArray(DataArrayDouble([1.,2.,4.,1.,2.,4.],6,1))
2685         f3.setName(fieldName3)
2686         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f3)
2687         #
2688         t=(2.1,1,-1)
2689         f=MEDCouplingFieldDouble(ON_GAUSS_PT) ; f.setTime(*t) ; f.setMesh(m)
2690         f.setGaussLocalizationOnType(NORM_QUAD4,[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.2,0.2,0.8,0.8],[0.7,0.3])
2691         f.setArray(DataArrayDouble([5.,3.,6.,4.])) ; f.getArray().setInfoOnComponents(["Smth"])
2692         f.setName(fieldName1)
2693         f.checkCoherency()
2694         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f)
2695         f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setTime(*t) ; f2.setMesh(m)
2696         f2.setArray(DataArrayDouble([11.,7.],2,1))
2697         f2.setName(fieldName2)
2698         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f2)
2699         f3=MEDCouplingFieldDouble(ON_NODES) ; f3.setTime(*t) ; f3.setMesh(m)
2700         f3.setArray(DataArrayDouble([4.,2.,1.,4.,2.,1.],6,1))
2701         f3.setName(fieldName3)
2702         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f3)
2703         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2704         ms=MEDFileMeshes(fname)
2705         fields=MEDFileFields(fname,False)
2706         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2707         allFMTSLeavesToDisplay=[]
2708         for fields in fields_per_mesh:
2709             allFMTSLeavesToDisplay2=[]
2710             for fmts in fields:
2711                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
2712                 pass
2713             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2714             pass
2715         self.assertEqual(len(allFMTSLeavesToDisplay),1)
2716         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
2717         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2718         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
2719         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
2720         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
2721         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
2722         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),3)
2723         #
2724         mst=MEDFileMeshStruct.New(ms[0])
2725         #
2726         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
2727         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2728         mml2=mml.prepare()
2729         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2730         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2731         self.assertTrue(not ncc) # spaceDim 2 -> VTK wants 3D
2732         self.assertTrue(a0.isEqual(DataArrayDouble([0.,0.,0.,1.,0.,0.,2.,0.,0.,0.,1.,0.,1.,1.,0.,2.,1.,0.],6,3),1e-12))
2733         self.assertTrue(a1.isEqual(DataArrayByte([9,9])))
2734         self.assertTrue(a2.isEqual(DataArrayInt([0,5])))
2735         self.assertTrue(a3.isEqual(DataArrayInt([4,0,3,4,1,4,1,4,5,2])))
2736         self.assertTrue(a4 is None)
2737         self.assertTrue(a5 is None)
2738         a6,a7=mml2.retrieveFamilyIdsOnCells()
2739         self.assertTrue(a6.isEqual(DataArrayInt([0,0])))
2740         self.assertTrue(a7) # no copy here
2741         a8,a9=mml2.retrieveNumberIdsOnCells()
2742         self.assertTrue(a8.isEqual(DataArrayInt([0,1])))
2743         self.assertTrue(a9) # no copy here
2744         for i in xrange(1,2):
2745             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2746             pass
2747         vExp0=[DataArrayDouble([7.,11.]),DataArrayDouble([11.,7.])]
2748         vExp1=[DataArrayDouble([3.,5.,4.,6.]),DataArrayDouble([5.,3.,6.,4.])]
2749         for i in xrange(2):
2750             f=allFMTSLeavesPerCommonSupport1[0][0][0][i]
2751             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2752             f.loadArraysIfNecessary()
2753             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2754             self.assertEqual(f.getName(),fieldName2)
2755             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2756             self.assertTrue(v.isEqual(vExp0[i],1e-12))
2757             #
2758             f=allFMTSLeavesPerCommonSupport1[0][0][1][i]
2759             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2760             f.loadArraysIfNecessary()
2761             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2762             self.assertEqual(f.getName(),fieldName1)
2763             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2764             vExp1[i].setInfoOnComponents(["Smth"])
2765             self.assertTrue(v.isEqual(vExp1[i],1e-12))
2766             pass
2767         ## Now same exercise but with a different load strategy. All is load directly.
2768         ms=MEDFileMeshes(fname)
2769         fields=MEDFileFields(fname) # here all is read, the SauvReader (or other Reader) is emulated
2770         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2771         allFMTSLeavesToDisplay=[]
2772         for fields in fields_per_mesh:
2773             allFMTSLeavesToDisplay2=[]
2774             for fmts in fields:
2775                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
2776                 pass
2777             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2778             pass
2779         self.assertEqual(len(allFMTSLeavesToDisplay),1)
2780         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
2781         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2782         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
2783         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
2784         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
2785         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
2786         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),3)
2787         #
2788         mst=MEDFileMeshStruct.New(ms[0])
2789         #
2790         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
2791         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2792         mml2=mml.prepare()
2793         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2794         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2795         self.assertTrue(not ncc) # spaceDim 2 -> VTK wants 3D
2796         self.assertTrue(a0.isEqual(DataArrayDouble([0.,0.,0.,1.,0.,0.,2.,0.,0.,0.,1.,0.,1.,1.,0.,2.,1.,0.],6,3),1e-12))
2797         self.assertTrue(a1.isEqual(DataArrayByte([9,9])))
2798         self.assertTrue(a2.isEqual(DataArrayInt([0,5])))
2799         self.assertTrue(a3.isEqual(DataArrayInt([4,0,3,4,1,4,1,4,5,2])))
2800         self.assertTrue(a4 is None)
2801         self.assertTrue(a5 is None)
2802         a6,a7=mml2.retrieveFamilyIdsOnCells()
2803         self.assertTrue(a6.isEqual(DataArrayInt([0,0])))
2804         self.assertTrue(a7) # no copy here
2805         a8,a9=mml2.retrieveNumberIdsOnCells()
2806         self.assertTrue(a8.isEqual(DataArrayInt([0,1])))
2807         self.assertTrue(a9) # no copy here
2808         for i in xrange(1,2):
2809             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2810             pass
2811         vExp0=[DataArrayDouble([7.,11.]),DataArrayDouble([11.,7.])]
2812         vExp1=[DataArrayDouble([3.,5.,4.,6.]),DataArrayDouble([5.,3.,6.,4.])]
2813         for i in xrange(2):
2814             f=allFMTSLeavesPerCommonSupport1[0][0][0][i]
2815             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst) # no load needed here
2816             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2817             self.assertEqual(f.getName(),fieldName2)
2818             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2819             self.assertTrue(v.isEqual(vExp0[i],1e-12))
2820             #
2821             f=allFMTSLeavesPerCommonSupport1[0][0][1][i]
2822             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst) # no load needed here
2823             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2824             self.assertEqual(f.getName(),fieldName1)
2825             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2826             vExp1[i].setInfoOnComponents(["Smth"])
2827             self.assertTrue(v.isEqual(vExp1[i],1e-12))
2828             pass
2829         pass
2830
2831     def test19(self):
2832         """
2833         This test is a simple non profile CELL field but lying on cells of dimension -1 (not 0 as "usual").
2834         """
2835         fname="ForMEDReader19.med"
2836         fieldName="ACellFieldOnDimM1"
2837         coo=DataArrayDouble(3) ; coo.iota()
2838         m=MEDCouplingCMesh() ; m.setCoords(coo,coo,coo) ; m.setName("mesh")
2839         m0=m.buildUnstructured() ; del m
2840         m1=m0.computeSkin()
2841         #
2842         mm=MEDFileUMesh()
2843         mm.setMeshAtLevel(0,m0)
2844         mm.setMeshAtLevel(-1,m1)
2845         ff=MEDFileFieldMultiTS()
2846         # time 0
2847         t=(1.1,1,-1)
2848         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setTime(*t) ; f.setMesh(m1)
2849         f.setName(fieldName)
2850         arr=DataArrayDouble(24) ; arr.iota() ; arr.setInfoOnComponents(["AStr"])
2851         f.setArray(arr)
2852         f.checkCoherency()
2853         f1ts=MEDFileField1TS() ; f1ts.setFieldNoProfileSBT(f)
2854         ff.pushBackTimeStep(f1ts)
2855         # time 1
2856         t=(2.1,2,-2)
2857         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setTime(*t) ; f.setMesh(m1)
2858         f.setName(fieldName)
2859         arr=DataArrayDouble(24) ; arr.iota() ; arr.reverse() ; arr.setInfoOnComponents(["AStr"])
2860         f.setArray(arr)
2861         f.checkCoherency()
2862         f1ts=MEDFileField1TS() ; f1ts.setFieldNoProfileSBT(f)
2863         ff.pushBackTimeStep(f1ts)
2864         #
2865         mm.write(fname,2)
2866         ff.write(fname,0)
2867         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2868         ms=MEDFileMeshes(fname)
2869         fields=MEDFileFields(fname,False)
2870         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2871         allFMTSLeavesToDisplay=[]
2872         for fields in fields_per_mesh:
2873             allFMTSLeavesToDisplay2=[]
2874             for fmts in fields:
2875                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
2876                 pass
2877             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2878             pass
2879         self.assertEqual(len(allFMTSLeavesToDisplay),1)
2880         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
2881         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2882         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
2883         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
2884         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
2885         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
2886         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
2887         #
2888         mst=MEDFileMeshStruct.New(ms[0])
2889         #
2890         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
2891         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2892         mml2=mml.prepare()
2893         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2894         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2895         self.assertTrue(ncc)
2896         self.assertTrue(a0.isEqual(DataArrayDouble([0.,0.,0.,1.,0.,0.,2.,0.,0.,0.,1.,0.,1.,1.,0.,2.,1.,0.,0.,2.,0.,1.,2.,0.,2.,2.,0.,0.,0.,1.,1.,0.,1.,2.,0.,1.,0.,1.,1.,1.,1.,1.,2.,1.,1.,0.,2.,1.,1.,2.,1.,2.,2.,1.,0.,0.,2.,1.,0.,2.,2.,0.,2.,0.,1.,2.,1.,1.,2.,2.,1.,2.,0.,2.,2.,1.,2.,2.,2.,2.,2.],27,3),1e-12))
2897         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9])))
2898         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100,105,110,115])))
2899         self.assertTrue(a3.isEqual(DataArrayInt([4,1,0,3,4,4,1,10,9,0,4,0,9,12,3,4,2,1,4,5,4,2,11,10,1,4,5,14,11,2,4,4,3,6,7,4,3,12,15,6,4,6,15,16,7,4,5,4,7,8,4,7,16,17,8,4,8,17,14,5,4,19,22,21,18,4,10,19,18,9,4,9,18,21,12,4,20,23,22,19,4,11,20,19,10,4,14,23,20,11,4,22,25,24,21,4,12,21,24,15,4,15,24,25,16,4,23,26,25,22,4,16,25,26,17,4,17,26,23,14])))
2900         self.assertTrue(a4 is None)
2901         self.assertTrue(a5 is None)
2902         a6,a7=mml2.retrieveFamilyIdsOnCells()
2903         self.assertTrue(a6.isEqual(DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])))
2904         self.assertTrue(a7) # no copy here
2905         a8,a9=mml2.retrieveNumberIdsOnCells()
2906         self.assertTrue(a8 is None)
2907         self.assertTrue(a9) # no copy here
2908         a10,a11=mml2.retrieveFamilyIdsOnNodes()
2909         self.assertTrue(not a10)
2910         self.assertTrue(a11) # no copy here
2911         a12,a13=mml2.retrieveNumberIdsOnNodes()
2912         self.assertTrue(not a12)
2913         self.assertTrue(a13) # no copy here
2914         for i in xrange(1,2):
2915             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2916             pass
2917         for i in xrange(2):
2918             f=allFMTSLeavesPerCommonSupport1[0][0][0][i]
2919             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2920             f.loadArraysIfNecessary()
2921             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2922             self.assertEqual(f.getName(),fieldName)
2923             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2924             vExp=DataArrayDouble(24) ; vExp.iota()
2925             if i==1: vExp.reverse()
2926             vExp.setInfoOnComponents(["AStr"])
2927             self.assertTrue(v.isEqual(vExp,1e-12))
2928             pass
2929         pass
2930
2931     def test20(self):
2932         """ This test works with groups/families on cells AND on nodes. Here 4 fields each on same time steps (2).
2933         1 field on CELLS without profile, 1 field on CELLS with profile, 1 field on NODES without profile, 1 field on NODES with profile.
2934         All of these 4 fields lies on a single mesh "mesh". The 2 fields on profile lies on a same support.
2935         One drawback of this test : no multi geom type. Coming soon !
2936         """
2937         fname="ForMEDReader20.med"
2938         fieldName0="ANodeField"
2939         fieldName1="ACellField"
2940         fieldName2="ANodeFieldPfl"
2941         fieldName3="ACellFieldPfl"
2942         pfl2=DataArrayInt([5,6,7,10,11,12,15,16,17,20,21,22]) ; pfl2.setName("pfl2")
2943         pfl3=DataArrayInt([4,5,8,9,12,13]) ; pfl3.setName("pfl3")
2944         #
2945         arr=DataArrayDouble(5) ; arr.iota()
2946         m=MEDCouplingCMesh("mesh") ; m.setCoords(arr,arr)
2947         m=m.buildUnstructured()
2948         mm=MEDFileUMesh()
2949         mm.setMeshAtLevel(0,m)
2950         fs=MEDFileFields()
2951         fmts0=MEDFileFieldMultiTS() ; fs.pushField(fmts0)
2952         fmts0.setDtUnit("s")
2953         fmts1=MEDFileFieldMultiTS() ; fs.pushField(fmts1)
2954         fmts1.setDtUnit("s")
2955         fmts2=MEDFileFieldMultiTS() ; fs.pushField(fmts2)
2956         fmts2.setDtUnit("s")
2957         fmts3=MEDFileFieldMultiTS() ; fs.pushField(fmts3)
2958         fmts3.setDtUnit("s")
2959         ####
2960         t=(1.1,0,-2)
2961         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m)
2962         f0.setName(fieldName0) ; f0.setTime(*t)
2963         da=m.getCoords().magnitude() ; da.setInfoOnComponents(["zeInfo"])
2964         f0.setArray(da)
2965         f0.checkCoherency()
2966         f1ts=MEDFileField1TS()
2967         f1ts.setFieldNoProfileSBT(f0)
2968         fmts0.pushBackTimeStep(f1ts)
2969         #
2970         f1=MEDCouplingFieldDouble(ON_CELLS) ; f1.setMesh(m)
2971         f1.setName(fieldName1) ; f1.setTime(*t)
2972         da=m.getBarycenterAndOwner().magnitude() ; da.setInfoOnComponents(["zeInfoCell"])
2973         f1.setArray(da)
2974         f1.checkCoherency()
2975         f1ts=MEDFileField1TS()
2976         f1ts.setFieldNoProfileSBT(f1)
2977         fmts1.pushBackTimeStep(f1ts)
2978         #
2979         f2=MEDCouplingFieldDouble(ON_NODES) ; mTmp=m[pfl3] ; mTmp.zipCoords() ; mTmp.setName(m.getName()) ; f2.setMesh(mTmp)
2980         f2.setName(fieldName2) ; f2.setTime(*t)
2981         da=m.getCoords().magnitude()[pfl2] ; da.setInfoOnComponents(["zzzz"])
2982         f2.setArray(da)
2983         f2.checkCoherency()
2984         f1ts=MEDFileField1TS()
2985         f1ts.setFieldProfile(f2,mm,0,pfl2)
2986         fmts2.pushBackTimeStep(f1ts)
2987         #
2988         f3=MEDCouplingFieldDouble(ON_CELLS) ; mTmp=m[pfl3] ; mTmp.setName(m.getName()) ; f3.setMesh(mTmp)
2989         f3.setName(fieldName3) ; f3.setTime(*t)
2990         da=mTmp.getBarycenterAndOwner().magnitude() ; da.setInfoOnComponents(["abcdefg"])
2991         f3.setArray(da)
2992         f3.checkCoherency()
2993         f1ts=MEDFileField1TS()
2994         f1ts.setFieldProfile(f3,mm,0,pfl3)
2995         fmts3.pushBackTimeStep(f1ts)
2996         ####
2997         t=(2.1,1,-3)
2998         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m)
2999         f0.setName(fieldName0) ; f0.setTime(*t)
3000         da=m.getCoords().magnitude() ; da.reverse() ; da.setInfoOnComponents(["zeInfo"])
3001         f0.setArray(da)
3002         f0.checkCoherency()
3003         f1ts=MEDFileField1TS()
3004         f1ts.setFieldNoProfileSBT(f0)
3005         fmts0.pushBackTimeStep(f1ts)
3006         #
3007         f1=MEDCouplingFieldDouble(ON_CELLS) ; f1.setMesh(m)
3008         f1.setName(fieldName1) ; f1.setTime(*t)
3009         da=m.getBarycenterAndOwner().magnitude() ; da.reverse() ; da.setInfoOnComponents(["zeInfoCell"])
3010         f1.setArray(da)
3011         f1.checkCoherency()
3012         f1ts=MEDFileField1TS()
3013         f1ts.setFieldNoProfileSBT(f1)
3014         fmts1.pushBackTimeStep(f1ts)
3015         #
3016         f2=MEDCouplingFieldDouble(ON_NODES) ; mTmp=m[pfl3] ; mTmp.zipCoords() ; mTmp.setName(m.getName()) ; f2.setMesh(mTmp)
3017         f2.setName(fieldName2) ; f2.setTime(*t)
3018         da=m.getCoords().magnitude()[pfl2] ; da.reverse() ; da.setInfoOnComponents(["zzzz"])
3019         f2.setArray(da)
3020         f2.checkCoherency()
3021         f1ts=MEDFileField1TS()
3022         f1ts.setFieldProfile(f2,mm,0,pfl2)
3023         fmts2.pushBackTimeStep(f1ts)
3024         #
3025         f3=MEDCouplingFieldDouble(ON_CELLS) ; mTmp=m[pfl3] ; mTmp.setName(m.getName()) ; f3.setMesh(mTmp)
3026         f3.setName(fieldName3) ; f3.setTime(*t)
3027         da=mTmp.getBarycenterAndOwner().magnitude() ; da.reverse() ; da.setInfoOnComponents(["abcdefg"])
3028         f3.setArray(da)
3029         f3.checkCoherency()
3030         f1ts=MEDFileField1TS()
3031         f1ts.setFieldProfile(f3,mm,0,pfl3)
3032         fmts3.pushBackTimeStep(f1ts)
3033         ####
3034         grp1=DataArrayInt([6,7,8,11,12,13,16,17,18]) ; grp1.setName("grp1")
3035         grp2=DataArrayInt([10,11,15,16,20,21]) ; grp2.setName("grp2")
3036         mm.setGroupsAtLevel(1,[grp1,grp2])
3037         grp3=DataArrayInt([4,5,6]) ; grp3.setName("grp3")
3038         grp4=DataArrayInt([8,9,10]) ; grp4.setName("grp4")
3039         mm.setGroupsAtLevel(0,[grp3,grp4])
3040         d=DataArrayInt(25) ; d.iota() ; d*=10 ;  mm.setRenumFieldArr(1,d)
3041         d=DataArrayInt(16) ; d.iota() ; d*=11 ;  mm.setRenumFieldArr(0,d)
3042         mm.write(fname,2)
3043         fs.appendGlobs(fmts2,1e-12)
3044         fs.appendGlobs(fmts3,1e-12)
3045         fs.write(fname,0)
3046         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3047         ms=MEDFileMeshes(fname)
3048         fields=MEDFileFields(fname,False)
3049         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3050         allFMTSLeavesToDisplay=[]
3051         for fields in fields_per_mesh:
3052             allFMTSLeavesToDisplay2=[]
3053             for fmts in fields:
3054                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
3055                 pass
3056             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3057             pass
3058         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3059         self.assertEqual(len(allFMTSLeavesToDisplay[0]),4)
3060         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3061         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3062         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
3063         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3064         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),2)
3065         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),2)
3066         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),2)
3067         #
3068         mst=MEDFileMeshStruct.New(ms[0])
3069         #
3070         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
3071         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3072         mml2=mml.prepare()
3073         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3074         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3075         self.assertTrue(not ncc)
3076         self.assertTrue(a0.isEqual(DataArrayDouble([0.,0.,0.,1.,0.,0.,2.,0.,0.,3.,0.,0.,4.,0.,0.,0.,1.,0.,1.,1.,0.,2.,1.,0.,3.,1.,0.,4.,1.,0.,0.,2.,0.,1.,2.,0.,2.,2.,0.,3.,2.,0.,4.,2.,0.,0.,3.,0.,1.,3.,0.,2.,3.,0.,3.,3.,0.,4.,3.,0.,0.,4.,0.,1.,4.,0.,2.,4.,0.,3.,4.,0.,4.,4.,0.],25,3),1e-12))
3077         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9])))
3078         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75])))
3079         self.assertTrue(a3.isEqual(DataArrayInt([4,1,0,5,6,4,2,1,6,7,4,3,2,7,8,4,4,3,8,9,4,6,5,10,11,4,7,6,11,12,4,8,7,12,13,4,9,8,13,14,4,11,10,15,16,4,12,11,16,17,4,13,12,17,18,4,14,13,18,19,4,16,15,20,21,4,17,16,21,22,4,18,17,22,23,4,19,18,23,24])))
3080         self.assertTrue(a4 is None)
3081         self.assertTrue(a5 is None)
3082         a6,a7=mml2.retrieveFamilyIdsOnCells()
3083         self.assertTrue(a6.isEqual(DataArrayInt([-5,-5,-5,-5,-6,-6,-6,-5,-7,-7,-7,-5,-5,-5,-5,-5])))
3084         self.assertTrue(a7) # no copy here
3085         a8,a9=mml2.retrieveNumberIdsOnCells()
3086         self.assertTrue(a8.isEqual(DataArrayInt([0,11,22,33,44,55,66,77,88,99,110,121,132,143,154,165])))
3087         self.assertTrue(a9) # no copy here
3088         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3089         self.assertTrue(a10.isEqual(DataArrayInt([1,1,1,1,1,1,2,2,2,1,3,4,2,2,1,3,4,2,2,1,3,3,1,1,1])))
3090         self.assertTrue(a11) # no copy here
3091         a12,a13=mml2.retrieveNumberIdsOnNodes()
3092         self.assertTrue(a12.isEqual(DataArrayInt([0,10,20,30,40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200,210,220,230,240])))
3093         self.assertTrue(a13) # no copy here
3094         for i in xrange(1,2):
3095             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
3096             pass
3097         for i in xrange(2):
3098             f=allFMTSLeavesPerCommonSupport1[0][0][0][i]
3099             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3100             f.loadArraysIfNecessary()
3101             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3102             self.assertEqual(f.getName(),fieldName1)
3103             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3104             vExp=DataArrayDouble([0.7071067811865476,1.5811388300841898,2.5495097567963922,3.5355339059327378,1.5811388300841898,2.1213203435596424,2.9154759474226504,3.8078865529319543,2.5495097567963922,2.9154759474226504,3.5355339059327378,4.301162633521313,3.5355339059327378,3.8078865529319543,4.301162633521313,4.949747468305833])
3105             if i==1: vExp.reverse()
3106             vExp.setInfoOnComponents(["zeInfoCell"])
3107             self.assertTrue(v.isEqual(vExp,1e-12))
3108             #
3109             f=allFMTSLeavesPerCommonSupport1[0][0][1][i]
3110             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3111             f.loadArraysIfNecessary()
3112             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3113             self.assertEqual(f.getName(),fieldName0)
3114             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3115             vExp=DataArrayDouble([0.,1.,2.,3.,4.,1.,1.4142135623730951,2.23606797749979,3.1622776601683795,4.123105625617661,2.,2.23606797749979,2.8284271247461903,3.605551275463989,4.47213595499958,3.,3.1622776601683795,3.605551275463989,4.242640687119285,5.,4.,4.123105625617661,4.47213595499958,5.,5.656854249492381])
3116             if i==1: vExp.reverse()
3117             vExp.setInfoOnComponents(["zeInfo"])
3118             self.assertTrue(v.isEqual(vExp,1e-12))
3119             pass
3120         ### Testing the 2nd support
3121         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
3122         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3123         mml2=mml.prepare()
3124         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3125         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3126         self.assertTrue(not ncc)
3127         self.assertTrue(not ncc)
3128         self.assertTrue(a0.isEqual(DataArrayDouble([0.,1.,0.,1.,1.,0.,2.,1.,0.,0.,2.,0.,1.,2.,0.,2.,2.,0.,0.,3.,0.,1.,3.,0.,2.,3.,0.,0.,4.,0.,1.,4.,0.,2.,4.,0.],12,3),1e-12))
3129         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9])))
3130         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25])))
3131         self.assertTrue(a3.isEqual(DataArrayInt([4,1,0,3,4,4,2,1,4,5,4,4,3,6,7,4,5,4,7,8,4,7,6,9,10,4,8,7,10,11])))
3132         self.assertTrue(a4 is None)
3133         self.assertTrue(a5 is None)
3134         a6,a7=mml2.retrieveFamilyIdsOnCells()
3135         self.assertTrue(a6.isEqual(DataArrayInt([-6,-6,-7,-7,-5,-5])))
3136         self.assertTrue(not a7) # copy here
3137         a8,a9=mml2.retrieveNumberIdsOnCells()
3138         self.assertTrue(a8.isEqual(DataArrayInt([44,55,88,99,132,143])))
3139         self.assertTrue(not a9) # copy here
3140         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3141         self.assertTrue(a10.isEqual(DataArrayInt([1,2,2,3,4,2,3,4,2,3,3,1])))
3142         self.assertTrue(not a11) # copy here
3143         a12,a13=mml2.retrieveNumberIdsOnNodes()
3144         self.assertTrue(a12.isEqual(DataArrayInt([50,60,70,100,110,120,150,160,170,200,210,220])))
3145         self.assertTrue(not a13) # copy here
3146         for i in xrange(2):
3147             f=allFMTSLeavesPerCommonSupport1[1][0][0][i]
3148             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3149             f.loadArraysIfNecessary()
3150             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3151             self.assertEqual(f.getName(),fieldName3)
3152             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3153             vExp=DataArrayDouble([1.5811388300842,2.1213203435596,2.5495097567964,2.9154759474227,3.5355339059327,3.807886552932])
3154             if i==1: vExp.reverse()
3155             vExp.setInfoOnComponents(["abcdefg"])
3156             self.assertTrue(v.isEqual(vExp,1e-12))
3157             #
3158             f=allFMTSLeavesPerCommonSupport1[1][0][1][i]
3159             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3160             f.loadArraysIfNecessary()
3161             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3162             self.assertEqual(f.getName(),fieldName2)
3163             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3164             vExp=DataArrayDouble([1.,1.4142135623731,2.2360679774998,2.,2.2360679774998,2.8284271247462,3.,3.1622776601684,3.605551275464,4.,4.1231056256177,4.4721359549996])
3165             if i==1: vExp.reverse()
3166             vExp.setInfoOnComponents(["zzzz"])
3167             self.assertTrue(v.isEqual(vExp,1e-12))
3168             pass
3169         pass
3170
3171     def test21(self):
3172         """ Here the created MED file contains only a mesh. The aim here is to test capability of MEDReader to support no fields.
3173         This test checks nothing but write a MED file to be used by MEDReader tests.
3174         """
3175         fname="ForMEDReader21.med"
3176         mm=MEDFileUMesh()
3177         #
3178         m0=MEDCouplingCMesh("mesh") ; arr=DataArrayDouble(5) ; arr.iota() ; m0.setCoords(arr,arr) ; m0=m0.buildUnstructured()
3179         mm.setMeshAtLevel(0,m0)
3180         grp0=DataArrayInt([5,6,9,10]) ; grp0.setName("Inside2D")
3181         grp1=DataArrayInt([0,1,2,3,4,7,8,11,12,13,14,15]) ; grp1.setName("Border2D")
3182         grp2=DataArrayInt([2,3,6,7]) ; grp2.setName("LowerRight2D")
3183         mm.setGroupsAtLevel(0,[grp0,grp1,grp2])
3184         #
3185         m1=MEDCouplingUMesh(m0.getName(),1) ; m1.setCoords(m0.getCoords()) ; m1.allocateCells()
3186         for elt in [[0,1],[1,2],[2,3],[3,4],[4,9],[9,14],[14,19],[19,24],[24,23],[23,22],[22,21],[21,20],[20,15],[15,10],[10,5],[5,0],[2,7],[7,12],[12,17],[17,22],
3187                     [10,11],[11,12],[12,13],[13,14]]:
3188             m1.insertNextCell(NORM_SEG2,elt)
3189             pass
3190         mm.setMeshAtLevel(-1,m1)
3191         grp4=DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]) ; grp4.setName("Border1D")
3192         grp5=DataArrayInt([16,17,18,19,20,21,22,23]) ; grp5.setName("Inside1D")
3193         grp6=DataArrayInt([18,19,22,23]) ; grp6.setName("UpperRight1D")
3194         mm.setGroupsAtLevel(-1,[grp4,grp5,grp6])
3195         #
3196         grp7=DataArrayInt([1,2,3,6,7,8,11,12,13,16,17,18,21,22,23]) ; grp7.setName("InsideYNode")
3197         grp8=DataArrayInt([5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]) ; grp8.setName("InsideXNode")
3198         mm.setGroupsAtLevel(1,[grp7,grp8])
3199         #
3200         mm.write(fname,2)
3201         pass
3202
3203     def test22(self):
3204         """ Use case where a field on nodes (ANodeField) on a mesh defined both in meshdim 2 and meshdim 1.
3205         The only possible geometrical support that suits the field is those with meshdim equal to 1 (-1 in relative).
3206         """
3207         fname="ForMEDReader22.med"
3208         fieldName0="ANodeField"
3209         mm=MEDFileUMesh()
3210         coo=DataArrayDouble([(4.,3.),(7.,3.),(2.,5.),(6.,5.),(9.,5.),(4.,7.),(8.,7.),(3.,8.),(9.,8.)])
3211         m0=MEDCouplingUMesh("mesh",2) ; m0.setCoords(coo) ; m0.allocateCells() ; m0.insertNextCell(NORM_TRI3,[2,3,0]) ; m0.insertNextCell(NORM_TRI3,[3,1,0]) ; m0.insertNextCell(NORM_TRI3,[3,4,1])
3212         mm.setMeshAtLevel(0,m0)
3213         m1=MEDCouplingUMesh("mesh",1) ; m1.setCoords(coo) ; m1.allocateCells() ; m1.insertNextCell(NORM_SEG2,[2,0]) ;  m1.insertNextCell(NORM_SEG2,[0,1]) ; m1.insertNextCell(NORM_SEG2,[1,4])
3214         m1.insertNextCell(NORM_SEG2,[3,5]) ; m1.insertNextCell(NORM_SEG2,[5,7]) ; m1.insertNextCell(NORM_SEG2,[3,6]) ; m1.insertNextCell(NORM_SEG2,[6,8])
3215         mm.setMeshAtLevel(-1,m1)
3216         fs=MEDFileFields()
3217         fmts0=MEDFileFieldMultiTS() ; fs.pushField(fmts0)
3218         fmts0.setDtUnit("s")
3219         #
3220         t=(1.1,0,-2)
3221         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m1)
3222         f0.setName(fieldName0) ; f0.setTime(*t)
3223         da=DataArrayDouble(9) ; da.iota() ; da.setInfoOnComponents(["zeInfo"])
3224         f0.setArray(da)
3225         f0.checkCoherency()
3226         f1ts=MEDFileField1TS()
3227         f1ts.setFieldNoProfileSBT(f0)
3228         fmts0.pushBackTimeStep(f1ts)
3229         #
3230         t=(2.1,1,-3)
3231         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m1)
3232         f0.setName(fieldName0) ; f0.setTime(*t)
3233         da=DataArrayDouble(9) ; da.iota() ; da.reverse() ; da.setInfoOnComponents(["zeInfo"])
3234         f0.setArray(da)
3235         f0.checkCoherency()
3236         f1ts=MEDFileField1TS()
3237         f1ts.setFieldNoProfileSBT(f0)
3238         fmts0.pushBackTimeStep(f1ts)
3239         #
3240         mm.write(fname,2)
3241         fs.write(fname,0)
3242         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3243         ms=MEDFileMeshes(fname)
3244         fields=MEDFileFields(fname,False)
3245         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3246         allFMTSLeavesToDisplay=[]
3247         for fields in fields_per_mesh:
3248             allFMTSLeavesToDisplay2=[]
3249             for fmts in fields:
3250                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
3251                 pass
3252             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3253             pass
3254         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3255         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
3256         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3257         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3258         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
3259         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3260         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
3261         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
3262         #
3263         mst=MEDFileMeshStruct.New(ms[0])
3264         #
3265         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
3266         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3267         mml2=mml.prepare()
3268         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3269         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3270         self.assertTrue(not ncc)
3271         self.assertTrue(a0.isEqual(DataArrayDouble([(4.,3.,0.),(7.,3.,0.),(2.,5.,0.),(6.,5.,0.),(9.,5.,0.),(4.,7.,0.),(8.,7.,0.),(3.,8.,0.),(9.,8.,0.)]),1e-12))
3272         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5,3,3,3,3,3,3,3])))
3273         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,12,15,18,21,24,27,30])))
3274         self.assertTrue(a3.isEqual(DataArrayInt([3,2,3,0,3,3,1,0,3,3,4,1,2,2,0,2,0,1,2,1,4,2,3,5,2,5,7,2,3,6,2,6,8])))
3275         self.assertTrue(a4 is None)
3276         self.assertTrue(a5 is None)
3277         a6,a7=mml2.retrieveFamilyIdsOnCells()
3278         self.assertTrue(a6.isEqual(DataArrayInt([0,0,0,0,0,0,0,0,0,0])))
3279         self.assertTrue(not a7) # copy here
3280         a8,a9=mml2.retrieveNumberIdsOnCells()
3281         self.assertTrue(not a8)
3282         self.assertTrue(a9) # nocopy here
3283         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3284         self.assertTrue(not a10)
3285         self.assertTrue(a11) # no copy here
3286         a12,a13=mml2.retrieveNumberIdsOnNodes()
3287         self.assertTrue(not a12)
3288         self.assertTrue(a13) # no copy here
3289         #
3290         f=allFMTSLeavesPerCommonSupport1[0][0][0][0]
3291         fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3292         f.loadArraysIfNecessary()
3293         v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3294         self.assertEqual(f.getName(),fieldName0)
3295         self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3296         vExp=DataArrayDouble(9) ; vExp.iota() ; vExp.setInfoOnComponents(["zeInfo"])
3297         self.assertTrue(v.isEqual(vExp,1e-12))
3298         #
3299         f=allFMTSLeavesPerCommonSupport1[0][0][0][1]
3300         fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3301         f.loadArraysIfNecessary()
3302         v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3303         self.assertEqual(f.getName(),fieldName0)
3304         self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3305         vExp=DataArrayDouble(9) ; vExp.iota() ; vExp.setInfoOnComponents(["zeInfo"]) ; vExp.reverse()
3306         self.assertTrue(v.isEqual(vExp,1e-12))
3307         pass
3308
3309     def test23(self):
3310         """ Non regression test 2219 of modes. Idem than test22 except that here the node field is on profile.
3311         """
3312         fname="ForMEDReader23.med"
3313         fieldName0="ANodeField"
3314         mm=MEDFileUMesh()
3315         coo=DataArrayDouble([(4.,3.),(7.,3.),(2.,5.),(6.,5.),(9.,5.),(4.,7.),(8.,7.),(3.,8.),(9.,8.)])
3316         m0=MEDCouplingUMesh("mesh",2) ; m0.setCoords(coo) ; m0.allocateCells() ; m0.insertNextCell(NORM_TRI3,[2,3,0]) ; m0.insertNextCell(NORM_TRI3,[3,1,0]) ; m0.insertNextCell(NORM_TRI3,[3,4,1])
3317         mm.setMeshAtLevel(0,m0)
3318         m1=MEDCouplingUMesh("mesh",1) ; m1.setCoords(coo) ; m1.allocateCells() ; m1.insertNextCell(NORM_SEG2,[2,0]) ;  m1.insertNextCell(NORM_SEG2,[0,1]) ; m1.insertNextCell(NORM_SEG2,[1,4])
3319         m1.insertNextCell(NORM_SEG2,[3,5]) ; m1.insertNextCell(NORM_SEG2,[5,7]) ; m1.insertNextCell(NORM_SEG2,[3,6]) ; m1.insertNextCell(NORM_SEG2,[6,8])
3320         mm.setMeshAtLevel(-1,m1)
3321         fmts0=MEDFileFieldMultiTS()
3322         fmts0.setDtUnit("s")
3323         #
3324         pfl=DataArrayInt([0,1,2,4]) ; pfl.setName("pfl")
3325         pflCell=DataArrayInt([0,1,2]) ; m1Part=m1[pflCell] ; m1Part.zipCoords()
3326         #
3327         t=(1.1,0,-2)
3328         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m1Part)
3329         f0.setName(fieldName0) ; f0.setTime(*t)
3330         da=DataArrayDouble(4) ; da.iota() ; da.setInfoOnComponents(["zeInfo"])
3331         f0.setArray(da)
3332         f0.checkCoherency()
3333         f1ts=MEDFileField1TS()
3334         f1ts.setFieldProfile(f0,mm,-1,pfl)
3335         fmts0.pushBackTimeStep(f1ts)
3336         #
3337         t=(2.1,1,-3)
3338         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m1Part)
3339         f0.setName(fieldName0) ; f0.setTime(*t)
3340         da=DataArrayDouble(4) ; da.iota() ; da.reverse() ; da.setInfoOnComponents(["zeInfo"])
3341         f0.setArray(da)
3342         f0.checkCoherency()
3343         f1ts=MEDFileField1TS()
3344         f1ts.setFieldProfile(f0,mm,-1,pfl)
3345         fmts0.pushBackTimeStep(f1ts)
3346         mm.write(fname,2)
3347         fmts0.write(fname,0)
3348         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3349         ms=MEDFileMeshes(fname)
3350         fields=MEDFileFields(fname,False)
3351         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3352         allFMTSLeavesToDisplay=[]
3353         for fields in fields_per_mesh:
3354             allFMTSLeavesToDisplay2=[]
3355             for fmts in fields:
3356                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
3357                 pass
3358             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3359             pass
3360         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3361         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
3362         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3363         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3364         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
3365         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3366         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
3367         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
3368         #
3369         mst=MEDFileMeshStruct.New(ms[0])
3370         #
3371         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
3372         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3373         mml2=mml.prepare()
3374         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3375         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3376         self.assertTrue(not ncc)
3377         self.assertTrue(a0.isEqual(DataArrayDouble([(4.,3.,0.),(7.,3.,0.),(2.,5.,0.),(9.,5.,0.)]),1e-12))
3378         self.assertTrue(a1.isEqual(DataArrayByte([3,3,3])))
3379         self.assertTrue(a2.isEqual(DataArrayInt([0,3,6])))
3380         self.assertTrue(a3.isEqual(DataArrayInt([2,2,0,2,0,1,2,1,3])))
3381         self.assertTrue(a4 is None)
3382         self.assertTrue(a5 is None)
3383         a6,a7=mml2.retrieveFamilyIdsOnCells()
3384         self.assertTrue(a6.isEqual(DataArrayInt([0,0,0])))
3385         self.assertTrue(not a7) # copy here
3386         a8,a9=mml2.retrieveNumberIdsOnCells()
3387         self.assertTrue(not a8)
3388         self.assertTrue(a9) # nocopy here
3389         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3390         self.assertTrue(not a10)
3391         self.assertTrue(a11) # no copy here
3392         a12,a13=mml2.retrieveNumberIdsOnNodes()
3393         self.assertTrue(not a12)
3394         self.assertTrue(a13) # no copy here
3395         #
3396         f=allFMTSLeavesPerCommonSupport1[0][0][0][0]
3397         fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3398         f.loadArraysIfNecessary()
3399         v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3400         self.assertEqual(f.getName(),fieldName0)
3401         vExp=DataArrayDouble(4) ; vExp.iota() ; vExp.setInfoOnComponents(["zeInfo"])
3402         self.assertTrue(v.isEqual(vExp,1e-12))
3403         #
3404         f=allFMTSLeavesPerCommonSupport1[0][0][0][1]
3405         fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3406         f.loadArraysIfNecessary()
3407         v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3408         self.assertEqual(f.getName(),fieldName0)
3409         vExp=DataArrayDouble(4) ; vExp.iota() ; vExp.setInfoOnComponents(["zeInfo"]) ; vExp.reverse()
3410         self.assertTrue(v.isEqual(vExp,1e-12))
3411         pass
3412
3413     def test24(self):
3414         """ Non regression test for cartesian mesh whose the 3rd direction has only one node. It a false 3D mesh.
3415         """
3416         fname="ForMEDReader24.med"
3417         fieldName0="zeFieldNode"
3418         cmesh=MEDCouplingCMesh("mesh")
3419         arr0=DataArrayDouble([0.,1.1,2.2,3.3,4.4])
3420         arr1=DataArrayDouble([0.,1.4,2.3])
3421         arr2=DataArrayDouble([5.])
3422         cmesh.setCoords(arr0,arr1,arr2)
3423         fmts0=MEDFileFieldMultiTS()
3424         fmts0.setDtUnit("s")
3425         #
3426         t=(1.1,2,3)
3427         f=MEDCouplingFieldDouble(ON_NODES) ; f.setName(fieldName0)
3428         f.setMesh(cmesh)
3429         arr=DataArrayDouble(15) ; arr.setInfoOnComponents(["tutu"]) ; arr.iota()
3430         f.setArray(arr)
3431         f.setTime(*t)
3432         f1ts=MEDFileField1TS()
3433         f1ts.setFieldNoProfileSBT(f)
3434         fmts0.pushBackTimeStep(f1ts)
3435         #
3436         t=(3.3,4,5)
3437         arr=DataArrayDouble(15) ; arr.setInfoOnComponents(["tutu"]) ; arr.iota()
3438         arr.reverse()
3439         f.setArray(arr)
3440         f.setTime(*t)
3441         f1ts=MEDFileField1TS()
3442         f1ts.setFieldNoProfileSBT(f)
3443         fmts0.pushBackTimeStep(f1ts)
3444         #
3445         mm=MEDFileCMesh() ; mm.setMesh(cmesh)
3446         mm.write(fname,2)
3447         fmts0.write(fname,0)
3448         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3449         ms=MEDFileMeshes(fname)
3450         fields=MEDFileFields(fname,False)
3451         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3452         allFMTSLeavesToDisplay=[]
3453         for fields in fields_per_mesh:
3454             allFMTSLeavesToDisplay2=[]
3455             for fmts in fields:
3456                 allFMTSLeavesToDisplay2+=fmts.splitDiscretizations()
3457                 pass
3458             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3459             pass
3460         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3461         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
3462         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3463         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3464         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
3465         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3466         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
3467         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),1)
3468         #
3469         mst=MEDFileMeshStruct.New(ms[0])
3470         #
3471         fcscp=allFMTSLeavesPerCommonSupport[0][1]
3472         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3473         mml2=mml.prepare()
3474         self.assertTrue(isinstance(mml2,MEDCMeshMultiLev))
3475         a,b,c=mml2.buildVTUArrays()
3476         self.assertTrue(a.isEqual(arr0,1e-12))
3477         self.assertTrue(b.isEqual(arr1,1e-12))
3478         self.assertTrue(c.isEqual(arr2,1e-12))
3479         for i in xrange(2):
3480             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
3481             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3482             f.loadArraysIfNecessary()
3483             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3484             self.assertEqual(f.getName(),fieldName0)
3485             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3486             vExp=DataArrayDouble(15) ; vExp.iota(0) ; vExp.setInfoOnComponents(["tutu"])
3487             if i==1:
3488                 vExp.reverse()
3489                 pass
3490             self.assertTrue(v.isEqual(vExp,1e-12))
3491             pass
3492         pass
3493
3494     pass
3495
3496 unittest.main()