src/MEDLoader/Swig/MEDLoaderTest4.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2019  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, or (at your option) any later version.
   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 (EDF R&D)
  21
  22 from MEDLoader import *
  23 import unittest
  24 from math import pi,e,sqrt
  25 from MEDLoaderDataForTest import WriteInTmpDir
  26
  27 class MEDLoaderTest4(unittest.TestCase):
  28     """
  29     Test series to emulate the future MEDReader plugin for PARAVIS.
  30     """
  31     @WriteInTmpDir
  32     def test1(self):
  33         """
  34         This test is the most simple one. One time serie of one field with only cell fields with no profiles.
  35         The only "difficulty" is that the cell field is lying on different levels (2D and 1D) to maximize the compatibility with ParaVIS.
  36         """
  37         fname="ForMEDReader1.med"
  38         # building a mesh containing 4 tri3 + 5 quad4
  39         tri=MEDCouplingUMesh("tri",2)
  40         tri.allocateCells() ; tri.insertNextCell(NORM_TRI3,[0,1,2])
  41         tri.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,0.)]))
  42         tris = [tri.deepCopy() for i in range(4)]
  43         for i,elt in enumerate(tris): elt.translate([i,0])
  44         tris=MEDCouplingUMesh.MergeUMeshes(tris)
  45         quad=MEDCouplingUMesh("quad",2)
  46         quad.allocateCells() ; quad.insertNextCell(NORM_QUAD4,[0,1,2,3])
  47         quad.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,1.),(1.,0.)]))
  48         quads = [quad.deepCopy() for i in range(5)]
  49         for i,elt in enumerate(quads): elt.translate([5+i,0])
  50         quads=MEDCouplingUMesh.MergeUMeshes(quads)
  51         m=MEDCouplingUMesh.MergeUMeshes(tris,quads)
  52         m.setName("mesh") ; m.getCoords().setInfoOnComponents(["XX [m]","YYY [km]"])
  53         m1=m.buildDescendingConnectivity()[0]
  54         mm=MEDFileUMesh() ; mm.setMeshes([m,m1])
  55         fam=DataArrayInt(9) ; fam.iota(0) ; mm.setFamilyFieldArr(0,fam)
  56         fam=DataArrayInt(32) ; fam.iota(20) ; mm.setFamilyFieldArr(-1,fam) ; del fam
  57         num=DataArrayInt(9) ; num.iota(100) ; mm.setRenumFieldArr(0,num)
  58         num=DataArrayInt(32) ; num.iota(120) ; mm.setRenumFieldArr(-1,num) ; del num
  59         #
  60         fieldName="zeField"
  61         fs=MEDFileFieldMultiTS()
  62         ##### Time step 0
  63         i=0
  64         f=MEDFileField1TS()
  65         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
  66         fCell0.setName(fieldName) ; fCell0.setMesh(m)
  67         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(100) ; arr.rearrange(2)
  68         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
  69         fCell0.checkConsistencyLight()
  70         f.setFieldNoProfileSBT(fCell0)
  71         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
  72         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
  73         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(200) ; arr.rearrange(2)
  74         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
  75         fCell1.checkConsistencyLight()
  76         f.setFieldNoProfileSBT(fCell1)
  77         fs.pushBackTimeStep(f)
  78         ##### Time step 1
  79         i=1
  80         f=MEDFileField1TS()
  81         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
  82         fCell0.setName(fieldName) ; fCell0.setMesh(m)
  83         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(1100) ; arr.rearrange(2)
  84         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
  85         fCell0.checkConsistencyLight()
  86         f.setFieldNoProfileSBT(fCell0)
  87         #
  88         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
  89         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
  90         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(1200) ; arr.rearrange(2)
  91         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
  92         fCell1.checkConsistencyLight()
  93         f.setFieldNoProfileSBT(fCell1)
  94         fs.pushBackTimeStep(f)
  95         ##### Time step 2
  96         i=2
  97         f=MEDFileField1TS()
  98         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
  99         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 100         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(2100) ; arr.rearrange(2)
 101         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 102         fCell0.checkConsistencyLight()
 103         f.setFieldNoProfileSBT(fCell0)
 104         #
 105         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 106         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 107         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(2200) ; arr.rearrange(2)
 108         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 109         fCell1.checkConsistencyLight()
 110         f.setFieldNoProfileSBT(fCell1)
 111         fs.pushBackTimeStep(f)
 112         ##### Time step 3
 113         i=3
 114         f=MEDFileField1TS()
 115         #
 116         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 117         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 118         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(3100) ; arr.rearrange(2)
 119         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 120         fCell0.checkConsistencyLight()
 121         f.setFieldNoProfileSBT(fCell0)
 122         #
 123         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 124         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 125         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(3200) ; arr.rearrange(2)
 126         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 127         fCell1.checkConsistencyLight()
 128         f.setFieldNoProfileSBT(fCell1)
 129         #
 130         fs.pushBackTimeStep(f)
 131         ##### Time step 4
 132         i=4
 133         f=MEDFileField1TS()
 134         #
 135         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 136         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 137         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(4100) ; arr.rearrange(2)
 138         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 139         fCell0.checkConsistencyLight()
 140         f.setFieldNoProfileSBT(fCell0)
 141         #
 142         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 143         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 144         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(4200) ; arr.rearrange(2)
 145         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 146         fCell1.checkConsistencyLight()
 147         f.setFieldNoProfileSBT(fCell1)
 148         fs.pushBackTimeStep(f)
 149         mm.write(fname,2)
 150         fs.write(fname,0)
 151         a0Exp=mm.getCoords().deepCopy()
 152         del m,m1,mm,fs,f,fCell0,fCell1
 153         ########## GO for reading in MEDReader, by not loading all. Mesh is fully loaded but not fields values
 154         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
 155         fields=MEDFileFields(fname,False) # False is important to not read the values
 156         fields.removeFieldsWithoutAnyTimeStep()
 157         refMem=fields.getHeapMemorySize()
 158         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
 159         allFMTSLeavesToDisplay=[]
 160         for fields in fields_per_mesh:
 161             allFMTSLeavesToDisplay2=[]
 162             for fmts in fields:
 163                 tmp=fmts.splitDiscretizations()
 164                 for itmp in tmp:
 165                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
 166                     pass
 167                 allFMTSLeavesToDisplay2+=tmp
 168                 pass
 169             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
 170             pass
 171         self.assertEqual(len(allFMTSLeavesToDisplay),1)
 172         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
 173         for fmts in allFMTSLeavesToDisplay[0]:
 174             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
 175             pass
 176         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
 177         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
 178         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
 179         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
 180         #
 181         mst=MEDFileMeshStruct.New(ms[0])
 182         fcscp=allFMTSLeavesPerCommonSupport[0][1]
 183         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
 184         mml2=mml.prepare()
 185         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
 186         for i in range(1, 5):
 187             self.assertTrue(fcscp.isDataSetSupportEqualToThePreviousOne(i,fields))
 188             pass
 189         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
 190         self.assertTrue(not ncc)
 191         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
 192         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])))
 193         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])))
 194         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])))
 195         self.assertTrue(a4 is None)
 196         self.assertTrue(a5 is None)
 197         a6,a7=mml2.retrieveFamilyIdsOnCells()
 198         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])))
 199         self.assertTrue(not a7)
 200         a8,a9=mml2.retrieveNumberIdsOnCells()
 201         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])))
 202         self.assertTrue(not a9)
 203         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
 204         for i in range(5):
 205             fsst=MEDFileField1TSStructItem.BuildItemFrom(fields[0][i],mst)
 206             fields[0][i].loadArraysIfNecessary()
 207             tmpMem=fields.getHeapMemorySize()
 208             self.assertTrue(tmpMem-refMem>=41*2*8)
 209             refMem=tmpMem
 210             v=mml.buildDataArray(fsst,fields,fields[0][i].getUndergroundDataArray())
 211             self.assertEqual(v.getHiddenCppPointer(),fields[0][i].getUndergroundDataArray().getHiddenCppPointer())
 212             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
 213             self.assertTrue(v.isEqual(vExp,1e-12))
 214             pass
 215         pass
 216
 217     @WriteInTmpDir
 218     def test2(self):
 219         """
 220         One time serie of one field with cell and node discretization in the same field with no profiles.
 221         Here as there is no profile only one VTK support is requested.
 222         """
 223         fname="ForMEDReader2.med"
 224         # building a mesh containing 4 tri3 + 5 quad4
 225         tri=MEDCouplingUMesh("tri",2)
 226         tri.allocateCells() ; tri.insertNextCell(NORM_TRI3,[0,1,2])
 227         tri.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,0.)]))
 228         tris = [tri.deepCopy() for i in range(4)]
 229         for i,elt in enumerate(tris): elt.translate([i,0])
 230         tris=MEDCouplingUMesh.MergeUMeshes(tris)
 231         quad=MEDCouplingUMesh("quad",2)
 232         quad.allocateCells() ; quad.insertNextCell(NORM_QUAD4,[0,1,2,3])
 233         quad.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,1.),(1.,0.)]))
 234         quads = [quad.deepCopy() for i in range(5)]
 235         for i,elt in enumerate(quads): elt.translate([5+i,0])
 236         quads=MEDCouplingUMesh.MergeUMeshes(quads)
 237         m=MEDCouplingUMesh.MergeUMeshes(tris,quads)
 238         m.setName("mesh") ; m.getCoords().setInfoOnComponents(["XX [m]","YYY [km]"])
 239         m1=m.buildDescendingConnectivity()[0]
 240         mm=MEDFileUMesh() ; mm.setMeshes([m,m1])
 241         #
 242         fieldName="zeField"
 243         fs=MEDFileFieldMultiTS()
 244         ##### Time step 0
 245         i=0
 246         f=MEDFileField1TS()
 247         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 248         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 249         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(100) ; arr.rearrange(2)
 250         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 251         fCell0.checkConsistencyLight()
 252         f.setFieldNoProfileSBT(fCell0)
 253         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 254         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 255         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(200) ; arr.rearrange(2)
 256         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 257         fCell1.checkConsistencyLight()
 258         f.setFieldNoProfileSBT(fCell1)
 259         #
 260         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 261         fNode.setName(fieldName) ; fNode.setMesh(m1)
 262         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(300) ; arr.rearrange(2)
 263         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 264         fNode.checkConsistencyLight()
 265         f.setFieldNoProfileSBT(fNode)
 266         fs.pushBackTimeStep(f)
 267         ##### Time step 1
 268         i=1
 269         f=MEDFileField1TS()
 270         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 271         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 272         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(1100) ; arr.rearrange(2)
 273         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 274         fCell0.checkConsistencyLight()
 275         f.setFieldNoProfileSBT(fCell0)
 276         #
 277         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 278         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 279         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(1200) ; arr.rearrange(2)
 280         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 281         fCell1.checkConsistencyLight()
 282         f.setFieldNoProfileSBT(fCell1)
 283         #
 284         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 285         fNode.setName(fieldName) ; fNode.setMesh(m1)
 286         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(1300) ; arr.rearrange(2)
 287         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 288         fNode.checkConsistencyLight()
 289         f.setFieldNoProfileSBT(fNode)
 290         fs.pushBackTimeStep(f)
 291         ##### Time step 2
 292         i=2
 293         f=MEDFileField1TS()
 294         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 295         fNode.setName(fieldName) ; fNode.setMesh(m1)
 296         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(2300) ; arr.rearrange(2)
 297         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 298         fNode.checkConsistencyLight()
 299         f.setFieldNoProfileSBT(fNode)
 300         #
 301         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 302         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 303         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(2100) ; arr.rearrange(2)
 304         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 305         fCell0.checkConsistencyLight()
 306         f.setFieldNoProfileSBT(fCell0)
 307         #
 308         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 309         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 310         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(2200) ; arr.rearrange(2)
 311         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 312         fCell1.checkConsistencyLight()
 313         f.setFieldNoProfileSBT(fCell1)
 314         fs.pushBackTimeStep(f)
 315         ##### Time step 3
 316         i=3
 317         f=MEDFileField1TS()
 318         #
 319         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 320         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 321         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(3100) ; arr.rearrange(2)
 322         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 323         fCell0.checkConsistencyLight()
 324         f.setFieldNoProfileSBT(fCell0)
 325         #
 326         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 327         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 328         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(3200) ; arr.rearrange(2)
 329         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 330         fCell1.checkConsistencyLight()
 331         f.setFieldNoProfileSBT(fCell1)
 332         #
 333         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 334         fNode.setName(fieldName) ; fNode.setMesh(m1)
 335         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(3300) ; arr.rearrange(2)
 336         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 337         fNode.checkConsistencyLight()
 338         f.setFieldNoProfileSBT(fNode)
 339         #
 340         fs.pushBackTimeStep(f)
 341         ##### Time step 4
 342         i=4
 343         f=MEDFileField1TS()
 344         #
 345         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 346         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 347         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(4100) ; arr.rearrange(2)
 348         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 349         fCell0.checkConsistencyLight()
 350         f.setFieldNoProfileSBT(fCell0)
 351         #
 352         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 353         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 354         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(4200) ; arr.rearrange(2)
 355         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 356         fCell1.checkConsistencyLight()
 357         f.setFieldNoProfileSBT(fCell1)
 358         #
 359         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 360         fNode.setName(fieldName) ; fNode.setMesh(m1)
 361         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(4300) ; arr.rearrange(2)
 362         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 363         fNode.checkConsistencyLight()
 364         f.setFieldNoProfileSBT(fNode)
 365         #
 366         fs.pushBackTimeStep(f)
 367         mm.write(fname,2)
 368         fs.write(fname,0)
 369         a0Exp=mm.getCoords().deepCopy()
 370         del m,m1,mm,fs,f,fCell0,fCell1
 371         ########## GO for reading in MEDReader, by not loading all. Mesh is fully loaded but not fields values
 372         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
 373         fields=MEDFileFields(fname,False)
 374         fields.removeFieldsWithoutAnyTimeStep()
 375         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
 376         allFMTSLeavesToDisplay=[]
 377         for fields in fields_per_mesh:
 378             allFMTSLeavesToDisplay2=[]
 379             for fmts in fields:
 380                 tmp=fmts.splitDiscretizations()
 381                 for itmp in tmp:
 382                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
 383                     pass
 384                 allFMTSLeavesToDisplay2+=tmp
 385                 pass
 386             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
 387             pass
 388         self.assertEqual(len(allFMTSLeavesToDisplay),1)
 389         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
 390         for fmts in allFMTSLeavesToDisplay[0]:
 391             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
 392             pass
 393         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
 394         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
 395         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
 396         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
 397         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
 398         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
 399         #
 400         mst=MEDFileMeshStruct.New(ms[0])
 401         fcscp=allFMTSLeavesPerCommonSupport[0][1]
 402         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
 403         mml2=mml.prepare()
 404         assert isinstance(mml2,MEDUMeshMultiLev)
 405         for i in range(1, 5):
 406             self.assertTrue(fcscp.isDataSetSupportEqualToThePreviousOne(i,fields))
 407             pass
 408         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
 409         self.assertTrue(not ncc)
 410         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
 411         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])))
 412         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])))
 413         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])))
 414         self.assertTrue(a4 is None)
 415         self.assertTrue(a5 is None)
 416         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
 417         # for cells
 418         for i in range(5):
 419             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
 420             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)# Second 0 is for cells
 421             f.loadArraysIfNecessary()
 422             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 423             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 424             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
 425             self.assertTrue(v.isEqual(vExp,1e-12))
 426             pass
 427         for i in range(5):
 428             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
 429             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)# Second 0 is for cells
 430             f.loadArraysIfNecessary()
 431             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 432             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 433             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
 434             self.assertTrue(v.isEqual(vExp,1e-12))
 435             pass
 436         pass
 437
 438     @WriteInTmpDir
 439     def test3(self):
 440         """ 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.
 441         So two time step series on the same field. No profile here neither on cells nor on nodes.
 442         """
 443         fname="ForMEDReader3.med"
 444         # building a mesh containing 4 tri3 + 5 quad4
 445         tri=MEDCouplingUMesh("tri",2)
 446         tri.allocateCells() ; tri.insertNextCell(NORM_TRI3,[0,1,2])
 447         tri.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,0.)]))
 448         tris = [tri.deepCopy() for i in range(4)]
 449         for i,elt in enumerate(tris): elt.translate([i,0])
 450         tris=MEDCouplingUMesh.MergeUMeshes(tris)
 451         quad=MEDCouplingUMesh("quad",2)
 452         quad.allocateCells() ; quad.insertNextCell(NORM_QUAD4,[0,1,2,3])
 453         quad.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,1.),(1.,0.)]))
 454         quads = [quad.deepCopy() for i in range(5)]
 455         for i,elt in enumerate(quads): elt.translate([5+i,0])
 456         quads=MEDCouplingUMesh.MergeUMeshes(quads)
 457         m=MEDCouplingUMesh.MergeUMeshes(tris,quads)
 458         m.setName("mesh") ; m.getCoords().setInfoOnComponents(["XX [m]","YYY [km]"])
 459         m1=m.buildDescendingConnectivity()[0]
 460         mm=MEDFileUMesh() ; mm.setMeshes([m,m1])
 461         #
 462         fieldName="zeField"
 463         fs=MEDFileFieldMultiTS()
 464         ##### Time step 0 on cells
 465         i=0
 466         f=MEDFileField1TS()
 467         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 468         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 469         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(100) ; arr.rearrange(2)
 470         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 471         fCell0.checkConsistencyLight()
 472         f.setFieldNoProfileSBT(fCell0)
 473         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 474         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 475         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(200) ; arr.rearrange(2)
 476         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 477         fCell1.checkConsistencyLight()
 478         f.setFieldNoProfileSBT(fCell1)
 479         fs.pushBackTimeStep(f)
 480         ##### Time step 1 on nodes
 481         i=1
 482         f=MEDFileField1TS()
 483         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 484         fNode.setName(fieldName) ; fNode.setMesh(m1)
 485         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(1300) ; arr.rearrange(2)
 486         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 487         fNode.checkConsistencyLight()
 488         f.setFieldNoProfileSBT(fNode)
 489         fs.pushBackTimeStep(f)
 490         ##### Time step 2 on cells
 491         i=2
 492         f=MEDFileField1TS()
 493         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 494         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 495         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(2100) ; arr.rearrange(2)
 496         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 497         fCell0.checkConsistencyLight()
 498         f.setFieldNoProfileSBT(fCell0)
 499         #
 500         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 501         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 502         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(2200) ; arr.rearrange(2)
 503         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 504         fCell1.checkConsistencyLight()
 505         f.setFieldNoProfileSBT(fCell1)
 506         fs.pushBackTimeStep(f)
 507         ##### Time step 3 on nodes
 508         i=3
 509         f=MEDFileField1TS()
 510         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 511         fNode.setName(fieldName) ; fNode.setMesh(m1)
 512         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(3300) ; arr.rearrange(2)
 513         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 514         fNode.checkConsistencyLight()
 515         f.setFieldNoProfileSBT(fNode)
 516         fs.pushBackTimeStep(f)
 517         ##### Time step 4
 518         i=4
 519         f=MEDFileField1TS()
 520         fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i),i,0)
 521         fCell0.setName(fieldName) ; fCell0.setMesh(m)
 522         arr=DataArrayDouble(2*m.getNumberOfCells()) ; arr.iota(4100) ; arr.rearrange(2)
 523         fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 524         fCell0.checkConsistencyLight()
 525         f.setFieldNoProfileSBT(fCell0)
 526         #
 527         fCell1=MEDCouplingFieldDouble(ON_CELLS) ; fCell1.setTime(float(i),i,0)
 528         fCell1.setName(fieldName) ; fCell1.setMesh(m1)
 529         arr=DataArrayDouble(2*m1.getNumberOfCells()) ; arr.iota(4200) ; arr.rearrange(2)
 530         fCell1.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]","Com2 [s^2]"])
 531         fCell1.checkConsistencyLight()
 532         f.setFieldNoProfileSBT(fCell1)
 533         #
 534         fs.pushBackTimeStep(f)
 535         mm.write(fname,2)
 536         fs.write(fname,0)
 537         a0Exp=mm.getCoords().deepCopy()
 538         del m,m1,mm,fs,f,fCell0,fCell1
 539         ########## GO for reading in MEDReader, by not loading all. Mesh is fully loaded but not fields values
 540         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
 541         fields=MEDFileFields(fname,False)
 542         fields.removeFieldsWithoutAnyTimeStep()
 543         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
 544         allFMTSLeavesToDisplay=[]
 545         for fields in fields_per_mesh:
 546             allFMTSLeavesToDisplay2=[]
 547             for fmts in fields:
 548                 tmp=fmts.splitDiscretizations()
 549                 for itmp in tmp:
 550                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
 551                     pass
 552                 allFMTSLeavesToDisplay2+=tmp
 553                 pass
 554             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
 555             pass
 556         self.assertEqual(len(allFMTSLeavesToDisplay),1)
 557         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
 558         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
 559         self.assertEqual(len(allFMTSLeavesPerTimeSeries),2) # two time series here : one for the cells, the second one for the nodes
 560         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
 561         self.assertEqual(len(allFMTSLeavesPerTimeSeries[1]),1)
 562         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
 563         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
 564         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),1)
 565         #
 566         mst=MEDFileMeshStruct.New(ms[0])
 567         fcscp=allFMTSLeavesPerCommonSupport[0][1] # start with the cells
 568         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
 569         mml2=mml.prepare()
 570         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
 571         for i in range(1, 3):
 572             self.assertTrue(fcscp.isDataSetSupportEqualToThePreviousOne(i,fields))
 573             pass
 574         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
 575         self.assertTrue(not ncc)
 576         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
 577         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])))
 578         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])))
 579         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])))
 580         assert a4 is None
 581         assert a5 is None
 582         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
 583         # for cells
 584         for i in range(3):
 585             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
 586             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)# Second 0 is for cells
 587             f.loadArraysIfNecessary()
 588             self.assertEqual(f.getName(),"zeField")
 589             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 590             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 591             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
 592             self.assertTrue(v.isEqual(vExp,1e-12))
 593             pass
 594         # for nodes
 595         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[1],ms[ms.getMeshesNames()[0]])
 596         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
 597         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),1)
 598         fcscp=allFMTSLeavesPerCommonSupport[0][1]
 599         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
 600         mml2=mml.prepare()
 601         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
 602         for i in range(1, 2):
 603             self.assertTrue(fcscp.isDataSetSupportEqualToThePreviousOne(i,fields))
 604             pass
 605         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
 606         self.assertTrue(not ncc)
 607         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
 608         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])))
 609         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])))
 610         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])))
 611         self.assertTrue(a4 is None)
 612         self.assertTrue(a5 is None)
 613         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
 614         for i in range(2):
 615             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
 616             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)# Second 0 is for cells
 617             f.loadArraysIfNecessary()
 618             self.assertEqual(f.getName(),"zeField")
 619             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 620             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 621             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
 622             self.assertTrue(v.isEqual(vExp,1e-12))
 623             pass
 624         pass
 625
 626     @WriteInTmpDir
 627     def test4(self):
 628         """ This test defines 3 fields on nodes on the same mesh. All of these fields have no profile.
 629         """
 630         fname="ForMEDReader4.med"
 631         # building a mesh containing 4 tri3 + 5 quad4
 632         tri=MEDCouplingUMesh("tri",2)
 633         tri.allocateCells() ; tri.insertNextCell(NORM_TRI3,[0,1,2])
 634         tri.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,0.)]))
 635         tris = [tri.deepCopy() for i in range(4)]
 636         for i,elt in enumerate(tris): elt.translate([i,0])
 637         tris=MEDCouplingUMesh.MergeUMeshes(tris)
 638         quad=MEDCouplingUMesh("quad",2)
 639         quad.allocateCells() ; quad.insertNextCell(NORM_QUAD4,[0,1,2,3])
 640         quad.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,1.),(1.,0.)]))
 641         quads = [quad.deepCopy() for i in range(5)]
 642         for i,elt in enumerate(quads): elt.translate([5+i,0])
 643         quads=MEDCouplingUMesh.MergeUMeshes(quads)
 644         m=MEDCouplingUMesh.MergeUMeshes(tris,quads)
 645         m.setName("mesh") ; m.getCoords().setInfoOnComponents(["XX [m]","YYY [km]"])
 646         mm=MEDFileUMesh() ; mm.setMeshes([m])
 647         #
 648         fieldName1="zeField1"
 649         fieldName2="zeField2"
 650         fieldName3="zeField3"
 651         fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS()
 652         ##### Time step 0
 653         i=0
 654         f=MEDFileField1TS()
 655         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 656         fNode.setName(fieldName1) ; fNode.setMesh(m)
 657         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(0+1000*i) ; arr.rearrange(2)
 658         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
 659         fNode.checkConsistencyLight()
 660         f.setFieldNoProfileSBT(fNode)
 661         fs1.pushBackTimeStep(f)
 662         #
 663         f=MEDFileField1TS()
 664         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 665         fNode.setName(fieldName2) ; fNode.setMesh(m)
 666         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(100+1000*i) ; arr.rearrange(2)
 667         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
 668         fNode.checkConsistencyLight()
 669         f.setFieldNoProfileSBT(fNode)
 670         fs2.pushBackTimeStep(f)
 671         #
 672         f=MEDFileField1TS()
 673         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 674         fNode.setName(fieldName3) ; fNode.setMesh(m)
 675         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(200+1000*i) ; arr.rearrange(2)
 676         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
 677         fNode.checkConsistencyLight()
 678         f.setFieldNoProfileSBT(fNode)
 679         fs3.pushBackTimeStep(f)
 680         ##### Time step 1
 681         i=1
 682         f=MEDFileField1TS()
 683         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 684         fNode.setName(fieldName1) ; fNode.setMesh(m)
 685         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(0+1000*i) ; arr.rearrange(2)
 686         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
 687         fNode.checkConsistencyLight()
 688         f.setFieldNoProfileSBT(fNode)
 689         fs1.pushBackTimeStep(f)
 690         #
 691         f=MEDFileField1TS()
 692         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 693         fNode.setName(fieldName2) ; fNode.setMesh(m)
 694         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(100+1000*i) ; arr.rearrange(2)
 695         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
 696         fNode.checkConsistencyLight()
 697         f.setFieldNoProfileSBT(fNode)
 698         fs2.pushBackTimeStep(f)
 699         #
 700         f=MEDFileField1TS()
 701         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 702         fNode.setName(fieldName3) ; fNode.setMesh(m)
 703         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(200+1000*i) ; arr.rearrange(2)
 704         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
 705         fNode.checkConsistencyLight()
 706         f.setFieldNoProfileSBT(fNode)
 707         fs3.pushBackTimeStep(f)
 708         ##### Time step 2
 709         i=2
 710         f=MEDFileField1TS()
 711         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 712         fNode.setName(fieldName1) ; fNode.setMesh(m)
 713         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(0+1000*i) ; arr.rearrange(2)
 714         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
 715         fNode.checkConsistencyLight()
 716         f.setFieldNoProfileSBT(fNode)
 717         fs1.pushBackTimeStep(f)
 718         #
 719         f=MEDFileField1TS()
 720         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 721         fNode.setName(fieldName2) ; fNode.setMesh(m)
 722         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(100+1000*i) ; arr.rearrange(2)
 723         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
 724         fNode.checkConsistencyLight()
 725         f.setFieldNoProfileSBT(fNode)
 726         fs2.pushBackTimeStep(f)
 727         #
 728         f=MEDFileField1TS()
 729         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 730         fNode.setName(fieldName3) ; fNode.setMesh(m)
 731         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(200+1000*i) ; arr.rearrange(2)
 732         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
 733         fNode.checkConsistencyLight()
 734         f.setFieldNoProfileSBT(fNode)
 735         fs3.pushBackTimeStep(f)
 736         ##### Time step 3
 737         i=3
 738         f=MEDFileField1TS()
 739         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 740         fNode.setName(fieldName1) ; fNode.setMesh(m)
 741         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(0+1000*i) ; arr.rearrange(2)
 742         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
 743         fNode.checkConsistencyLight()
 744         f.setFieldNoProfileSBT(fNode)
 745         fs1.pushBackTimeStep(f)
 746         #
 747         f=MEDFileField1TS()
 748         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 749         fNode.setName(fieldName2) ; fNode.setMesh(m)
 750         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(100+1000*i) ; arr.rearrange(2)
 751         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
 752         fNode.checkConsistencyLight()
 753         f.setFieldNoProfileSBT(fNode)
 754         fs2.pushBackTimeStep(f)
 755         #
 756         f=MEDFileField1TS()
 757         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 758         fNode.setName(fieldName3) ; fNode.setMesh(m)
 759         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(200+1000*i) ; arr.rearrange(2)
 760         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
 761         fNode.checkConsistencyLight()
 762         f.setFieldNoProfileSBT(fNode)
 763         fs3.pushBackTimeStep(f)
 764         ##### Time step 4
 765         i=4
 766         f=MEDFileField1TS()
 767         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 768         fNode.setName(fieldName1) ; fNode.setMesh(m)
 769         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(0+1000*i) ; arr.rearrange(2)
 770         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
 771         fNode.checkConsistencyLight()
 772         f.setFieldNoProfileSBT(fNode)
 773         fs1.pushBackTimeStep(f)
 774         #
 775         f=MEDFileField1TS()
 776         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 777         fNode.setName(fieldName2) ; fNode.setMesh(m)
 778         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(100+1000*i) ; arr.rearrange(2)
 779         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
 780         fNode.checkConsistencyLight()
 781         f.setFieldNoProfileSBT(fNode)
 782         fs2.pushBackTimeStep(f)
 783         #
 784         f=MEDFileField1TS()
 785         fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 786         fNode.setName(fieldName3) ; fNode.setMesh(m)
 787         arr=DataArrayDouble(2*m.getNumberOfNodes()) ; arr.iota(200+1000*i) ; arr.rearrange(2)
 788         fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
 789         fNode.checkConsistencyLight()
 790         f.setFieldNoProfileSBT(fNode)
 791         fs3.pushBackTimeStep(f)
 792         #
 793         mm.write(fname,2)
 794         fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0)
 795         a0Exp=mm.getCoords().deepCopy()
 796         del m,mm,fs1,fs2,fs3,f,fNode
 797         ########## GO for reading in MEDReader, by not loading all. Mesh is fully loaded but not fields values
 798         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
 799         fields=MEDFileFields(fname,False)
 800         fields.removeFieldsWithoutAnyTimeStep()
 801         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
 802         allFMTSLeavesToDisplay=[]
 803         for fields in fields_per_mesh:
 804             allFMTSLeavesToDisplay2=[]
 805             for fmts in fields:
 806                 tmp=fmts.splitDiscretizations()
 807                 for itmp in tmp:
 808                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
 809                     pass
 810                 allFMTSLeavesToDisplay2+=tmp
 811                 pass
 812             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
 813             pass
 814         self.assertEqual(len(allFMTSLeavesToDisplay),1)
 815         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
 816         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
 817         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 3 fields are defined on the same time steps
 818         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
 819         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
 820         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
 821         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),3)
 822         #
 823         mst=MEDFileMeshStruct.New(ms[0])
 824         fcscp=allFMTSLeavesPerCommonSupport[0][1]
 825         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
 826         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),3)
 827         fcscp=allFMTSLeavesPerCommonSupport[0][1]
 828         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
 829         mml2=mml.prepare()
 830         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
 831         for i in range(1, 5):
 832             self.assertTrue(fcscp.isDataSetSupportEqualToThePreviousOne(i,fields))
 833             pass
 834         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
 835         self.assertTrue(not ncc)
 836         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
 837         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5,5,9,9,9,9,9])))
 838         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,12,16,21,26,31,36])))
 839         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])))
 840         self.assertTrue(a4 is None)
 841         self.assertTrue(a5 is None)
 842         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
 843         # test all the time steps of the 1/1 time step serie, on field 1
 844         for i in range(5):
 845             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
 846             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
 847             f.loadArraysIfNecessary()
 848             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 849             self.assertEqual(f.getName(),fieldName1)
 850             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 851             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
 852             self.assertTrue(v.isEqual(vExp,1e-12))
 853             pass
 854         # test all the time steps of the 1/1 time step serie, on field 2
 855         for i in range(5):
 856             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
 857             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
 858             f.loadArraysIfNecessary()
 859             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 860             self.assertEqual(f.getName(),fieldName2)
 861             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 862             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
 863             self.assertTrue(v.isEqual(vExp,1e-12))
 864             pass
 865         # test all the time steps of the 1/1 time step serie, on field 3
 866         for i in range(5):
 867             f=allFMTSLeavesPerCommonSupport[0][0][2][i]
 868             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
 869             f.loadArraysIfNecessary()
 870             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 871             self.assertEqual(f.getName(),fieldName3)
 872             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 873             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
 874             self.assertTrue(v.isEqual(vExp,1e-12))
 875             pass
 876         pass
 877
 878     @WriteInTmpDir
 879     def test5(self):
 880         """ 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
 881         mesh lies on a different mesh.
 882         """
 883         fname="ForMEDReader5.med"
 884         # building a mesh containing 6 tri3 + 5 quad4
 885         m=MEDCouplingUMesh("mesh",2)
 886         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]"])
 887         m.setCoords(coords)
 888         m.allocateCells()
 889         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])
 890         m.insertNextCell(NORM_TRI3,[13,9,8]) ; m.insertNextCell(NORM_TRI3,[13,14,9])
 891         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])
 892         m.insertNextCell(NORM_QUAD4,[12,13,8,7])
 893         mm=MEDFileUMesh() ; mm.setMeshes([m])
 894         fam=DataArrayInt(11) ; fam.iota(0) ; mm.setFamilyFieldArr(0,fam) ; del fam
 895         num=DataArrayInt(11) ; num.iota(100) ; mm.setRenumFieldArr(0,num) ; del num
 896         #
 897         fieldName1="zeField1" ; pfl1=DataArrayInt([0,1,2,3,4,5]) ; pfl1.setName("pfl1") # on cells
 898         fieldName2="zeField2" ; pfl2=DataArrayInt([2,3,4,7,8,9,13,14]) ; pfl2.setName("pfl2") # on nodes
 899         fieldName3="zeField3" ; pfl3=DataArrayInt([0,1,2,3,4,5,9,10]) ; pfl3.setName("pfl3") # on cells but different support
 900         fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS()
 901         #
 902         for i in range(5):
 903             f=MEDFileField1TS()
 904             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
 905             fNode.setName(fieldName1)
 906             arr=DataArrayDouble(2*6) ; arr.iota(0+1000*i) ; arr.rearrange(2)
 907             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
 908             f.setFieldProfile(fNode,mm,0,pfl1)
 909             fs1.pushBackTimeStep(f)
 910             #
 911             f=MEDFileField1TS()
 912             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
 913             fNode.setName(fieldName2)
 914             arr=DataArrayDouble(2*8) ; arr.iota(100+1000*i) ; arr.rearrange(2)
 915             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
 916             f.setFieldProfile(fNode,mm,0,pfl2)
 917             fs2.pushBackTimeStep(f)
 918             #
 919             f=MEDFileField1TS()
 920             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
 921             fNode.setName(fieldName3)
 922             arr=DataArrayDouble(2*8) ; arr.iota(200+1000*i) ; arr.rearrange(2)
 923             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
 924             f.setFieldProfile(fNode,mm,0,pfl3)
 925             fs3.pushBackTimeStep(f)
 926             pass
 927         mm.write(fname,2)
 928         fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0)
 929         a0Exp=mm.getCoords().deepCopy()
 930         del m,mm,fs1,fs2,fs3,f,fNode
 931         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
 932         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
 933         fields=MEDFileFields(fname,False)
 934         fields.removeFieldsWithoutAnyTimeStep()
 935         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
 936         allFMTSLeavesToDisplay=[]
 937         for fields in fields_per_mesh:
 938             allFMTSLeavesToDisplay2=[]
 939             for fmts in fields:
 940                 tmp=fmts.splitDiscretizations()
 941                 for itmp in tmp:
 942                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
 943                     pass
 944                 allFMTSLeavesToDisplay2+=tmp
 945                 pass
 946             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
 947             pass
 948         self.assertEqual(len(allFMTSLeavesToDisplay),1)
 949         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
 950         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
 951         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 3 fields are defined on the same time steps
 952         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
 953         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
 954         ms[0].getDirectUndergroundSingleGeoTypeMeshes(0)
 955         self.assertEqual(len(allFMTSLeavesPerCommonSupport),2) # 2 support here
 956         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
 957         self.assertEqual(len(allFMTSLeavesPerCommonSupport[1][0]),1)
 958         #
 959         mst=MEDFileMeshStruct.New(ms[0])
 960         fcscp=allFMTSLeavesPerCommonSupport[0][1]
 961         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
 962         mml2=mml.prepare()
 963         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
 964         for i in range(1, 5):
 965             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
 966             pass
 967         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
 968         self.assertTrue(not ncc)
 969         self.assertTrue(a0.isEqual(a0Exp[pfl2].changeNbOfComponents(3,0.),1e-12))
 970         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5,5,5,5])))
 971         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,12,16,20])))
 972         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])))
 973         assert a4 is None
 974         assert a5 is None
 975         a6,a7=mml2.retrieveFamilyIdsOnCells()
 976         self.assertTrue(a6.isEqual(DataArrayInt([0,1,2,3,4,5])))
 977         self.assertTrue(not a7)
 978         a8,a9=mml2.retrieveNumberIdsOnCells()
 979         self.assertTrue(a8.isEqual(DataArrayInt([100,101,102,103,104,105])))
 980         self.assertTrue(not a9)
 981         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
 982         for i in range(5):
 983             nbOfT=[6,8]
 984             fieldNames=[fieldName1,fieldName2]
 985             for j in range(2):
 986                 m={"i":j}
 987                 f=allFMTSLeavesPerCommonSupport[0][0][j][i]
 988                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
 989                 f.loadArraysIfNecessary()
 990                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
 991                 self.assertEqual(f.getName(),fieldNames[j])
 992                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
 993                 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])
 994                 self.assertTrue(v.isEqual(vExp,1e-12))
 995                 pass
 996             pass
 997         # Let's go for the 2nd support
 998         fcscp=allFMTSLeavesPerCommonSupport[1][1]
 999         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1000         mml2=mml.prepare()
1001         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
1002         for i in range(1, 5):
1003             self.assertTrue(fcscp.isDataSetSupportEqualToThePreviousOne(i,fields))
1004             pass
1005         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1006         self.assertTrue(not ncc)
1007         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
1008         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5,5,5,5,9,9])))
1009         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,12,16,20,24,29])))
1010         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])))
1011         self.assertTrue(a4 is None)
1012         self.assertTrue(a5 is None)
1013         a6,a7=mml2.retrieveFamilyIdsOnCells()
1014         self.assertTrue(a6.isEqual(DataArrayInt([0,1,2,3,4,5,9,10])))
1015         self.assertTrue(not a7)
1016         a8,a9=mml2.retrieveNumberIdsOnCells()
1017         self.assertTrue(a8.isEqual(DataArrayInt([100,101,102,103,104,105,109,110])))
1018         self.assertTrue(not a9)
1019         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1020         for i in range(5):
1021             f=allFMTSLeavesPerCommonSupport[1][0][0][i]
1022             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1023             f.loadArraysIfNecessary()
1024             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1025             self.assertEqual(f.getName(),"zeField3")
1026             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1027             vExp=DataArrayDouble(8*2) ; vExp.iota(200+1000*i) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]'%m,'Com2_2 [s^2]'%m])
1028             self.assertTrue(v.isEqual(vExp,1e-12))
1029             pass
1030         pass
1031
1032     @WriteInTmpDir
1033     def test6(self):
1034         """ This test plays with cartesian mesh and profiles. When a sub cartesian mesh can also be considered as a cartesian mesh it is done.
1035         """
1036         fname="ForMEDReader6.med"
1037         m=MEDCouplingCMesh("mesh")
1038         coordsX=DataArrayDouble([0,1.1,2.2,3.3,4.4]) ; coordsX.setInfoOnComponents(["XX [m]"])
1039         coordsY=DataArrayDouble([0,1.7,3.4]) ; coordsY.setInfoOnComponents(["YYY [km]"])
1040         m.setCoords(coordsX,coordsY)
1041         mm=MEDFileCMesh() ; mm.setMesh(m)
1042         fam=DataArrayInt(8) ; fam.iota(0) ; mm.setFamilyFieldArr(0,fam) ; del fam
1043         num=DataArrayInt(8) ; num.iota(100) ; mm.setRenumFieldArr(0,num) ; del num
1044         num=DataArrayInt(15) ; num.iota(200) ; mm.setRenumFieldArr(1,num) ; del num
1045         #
1046         fieldName0="zeField0" ; # on cells
1047         fieldName1="zeField1" ; pfl1=DataArrayInt([2,3,6,7]) ; pfl1.setName("pfl1") # on cells
1048         fieldName2="zeField2" ; pfl2=DataArrayInt([2,3,4,7,8,9,12,13,14]) ; pfl2.setName("pfl2") # on nodes
1049         fieldName3="zeField3" ; pfl3=DataArrayInt([2,3,5,7]) ; pfl3.setName("pfl3") # on cells but different support
1050         fieldName4="zeField4" ;# on nodes
1051         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS() ; fs4=MEDFileFieldMultiTS()
1052         #
1053         for i in range(5):
1054             f=MEDFileField1TS()
1055             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1056             fNode.setName(fieldName0) ; fNode.setMesh(m)
1057             arr=DataArrayDouble(2*8) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1058             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkConsistencyLight()
1059             f.setFieldNoProfileSBT(fNode)
1060             fs0.pushBackTimeStep(f)
1061             #
1062             f=MEDFileField1TS()
1063             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1064             fNode.setName(fieldName1)
1065             arr=DataArrayDouble(2*4) ; arr.iota(100+1000*i) ; arr.rearrange(2)
1066             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
1067             f.setFieldProfile(fNode,mm,0,pfl1)
1068             self.assertEqual(pfl1.getName(),"pfl1")
1069             fs1.pushBackTimeStep(f)
1070             #
1071             f=MEDFileField1TS()
1072             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1073             fNode.setName(fieldName2)
1074             arr=DataArrayDouble(2*9) ; arr.iota(200+1000*i) ; arr.rearrange(2)
1075             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
1076             f.setFieldProfile(fNode,mm,0,pfl2)
1077             self.assertEqual(pfl2.getName(),"pfl2")
1078             fs2.pushBackTimeStep(f)
1079             #
1080             f=MEDFileField1TS()
1081             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1082             fNode.setName(fieldName3)
1083             arr=DataArrayDouble(2*4) ; arr.iota(300+1000*i) ; arr.rearrange(2)
1084             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_3 [m]","Com2_3 [s^2]"])
1085             f.setFieldProfile(fNode,mm,0,pfl3)
1086             self.assertEqual(pfl3.getName(),"pfl3")
1087             fs3.pushBackTimeStep(f)
1088             #
1089             f=MEDFileField1TS()
1090             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1091             fNode.setName(fieldName4) ; fNode.setMesh(m)
1092             arr=DataArrayDouble(2*15) ; arr.iota(400+1000*i) ; arr.rearrange(2)
1093             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_4 [m]","Com2_4 [s^2]"]) ; fNode.checkConsistencyLight()
1094             f.setFieldNoProfileSBT(fNode)
1095             fs4.pushBackTimeStep(f)
1096             pass
1097         mm.write(fname,2)
1098         fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0) ; fs4.write(fname,0)
1099         del m,mm,fs1,fs2,fs3,f,fNode
1100         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1101         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
1102         fields=MEDFileFields(fname,False)
1103         fields.removeFieldsWithoutAnyTimeStep()
1104         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1105         allFMTSLeavesToDisplay=[]
1106         for fields in fields_per_mesh:
1107             allFMTSLeavesToDisplay2=[]
1108             for fmts in fields:
1109                 tmp=fmts.splitDiscretizations()
1110                 for itmp in tmp:
1111                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
1112                     pass
1113                 allFMTSLeavesToDisplay2+=tmp
1114                 pass
1115             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1116             pass
1117         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1118         self.assertEqual(len(allFMTSLeavesToDisplay[0]),5)
1119         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1120         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 5 fields are defined on the same time steps
1121         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),5)
1122         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1123         self.assertEqual(len(allFMTSLeavesPerCommonSupport),3)
1124         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
1125         self.assertEqual(len(allFMTSLeavesPerCommonSupport[1][0]),2)
1126         self.assertEqual(len(allFMTSLeavesPerCommonSupport[2][0]),1)
1127         #
1128         mst=MEDFileMeshStruct.New(ms[0])
1129         #
1130         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1131         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1132         mml2=mml.prepare()
1133         (a,b),c=mml2.buildVTUArrays()
1134         self.assertTrue(c)# c is True here because the returned array is directly those coming from internal structure
1135         self.assertTrue(a.isEqual(coordsX,1e-12))
1136         self.assertTrue(b.isEqual(coordsY,1e-12))
1137         self.assertTrue(isinstance(mml2,MEDCMeshMultiLev))
1138         for i in range(1, 5):
1139             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1140             pass
1141         a6,a7=mml2.retrieveFamilyIdsOnCells()
1142         self.assertTrue(a6.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
1143         self.assertTrue(a7) # True because no copy
1144         a8,a9=mml2.retrieveNumberIdsOnCells()
1145         self.assertTrue(a8.isEqual(DataArrayInt([100,101,102,103,104,105,106,107])))
1146         self.assertTrue(a9) # True because no copy
1147         a10,a11=mml2.retrieveNumberIdsOnNodes()
1148         self.assertTrue(a10.isEqual(DataArrayInt([200,201,202,203,204,205,206,207,208,209,210,211,212,213,214])))
1149         self.assertTrue(a11) # True because no copy
1150         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1151         for i in range(5):
1152             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1153             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1154             f.loadArraysIfNecessary()
1155             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1156             self.assertEqual(f.getName(),fieldName0)
1157             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1158             vExp=DataArrayDouble(8*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
1159             self.assertTrue(v.isEqual(vExp,1e-12))
1160             #
1161             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
1162             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1163             f.loadArraysIfNecessary()
1164             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1165             self.assertEqual(f.getName(),fieldName4)
1166             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1167             vExp=DataArrayDouble(15*2) ; vExp.iota(400+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_4 [m]','Com2_4 [s^2]'])
1168             self.assertTrue(v.isEqual(vExp,1e-12))
1169             pass
1170
1171         fcscp=allFMTSLeavesPerCommonSupport[1][1]
1172         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1173         mml2=mml.prepare()
1174         self.assertTrue(isinstance(mml2,MEDCMeshMultiLev)) # here the 2nd support is a part of CMesh that is also a CMesh -> CMesh not a UMesh
1175         (a,b),c=mml2.buildVTUArrays()
1176         self.assertTrue(not c)# c is False because this a sub support specially built for buildVTUArrays
1177         self.assertTrue(a.isEqual(coordsX[[2,3,4]],1e-12))
1178         self.assertTrue(b.isEqual(coordsY,1e-12))
1179         a6,a7=mml2.retrieveFamilyIdsOnCells()
1180         self.assertTrue(a6.isEqual(DataArrayInt([2,3,6,7])))
1181         self.assertTrue(not a7) # False because copy
1182         a8,a9=mml2.retrieveNumberIdsOnCells()
1183         self.assertTrue(a8.isEqual(DataArrayInt([102,103,106,107])))
1184         self.assertTrue(not a9) # False because copy
1185         a10,a11=mml2.retrieveNumberIdsOnNodes()
1186         self.assertTrue(a10.isEqual(DataArrayInt([202,203,204,207,208,209,212,213,214])))
1187         self.assertTrue(not a11) # False because copy
1188         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1189         for i in range(1, 5):
1190             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1191             pass
1192         for i in range(5):
1193             f=allFMTSLeavesPerCommonSupport[1][0][0][i]
1194             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1195             f.loadArraysIfNecessary()
1196             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1197             self.assertEqual(f.getName(),fieldName1)
1198             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1199             vExp=DataArrayDouble(4*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
1200             self.assertTrue(v.isEqual(vExp,1e-12))
1201             #
1202             f=allFMTSLeavesPerCommonSupport[1][0][1][i]
1203             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1204             f.loadArraysIfNecessary()
1205             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1206             self.assertEqual(f.getName(),fieldName2)
1207             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1208             vExp=DataArrayDouble(9*2) ; vExp.iota(200+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
1209             self.assertTrue(v.isEqual(vExp,1e-12))
1210             pass
1211         #
1212         fcscp=allFMTSLeavesPerCommonSupport[2][1]
1213         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1214         mml2=mml.prepare()
1215         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev)) # here the 3rd support is a part of CMesh but impossible to simplify more than a UMesh
1216         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1217         self.assertTrue(not ncc)
1218         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)
1219         a0Exp.setInfoOnComponents(["XX [m]","YYY [km]"])
1220         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
1221         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9])))
1222         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15])))
1223         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])))
1224         self.assertTrue(a4 is None)
1225         self.assertTrue(a5 is None)
1226         a6,a7=mml2.retrieveFamilyIdsOnCells()
1227         self.assertTrue(a6.isEqual(DataArrayInt([2,3,5,7])))
1228         self.assertTrue(not a7) # False because copy
1229         a8,a9=mml2.retrieveNumberIdsOnCells()
1230         self.assertTrue(a8.isEqual(DataArrayInt([102,103,105,107])))
1231         self.assertTrue(not a9) # False because copy
1232         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1233         for i in range(5):
1234             f=allFMTSLeavesPerCommonSupport[2][0][0][i]
1235             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1236             f.loadArraysIfNecessary()
1237             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1238             self.assertEqual(f.getName(),fieldName3)
1239             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1240             vExp=DataArrayDouble(4*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_3 [m]','Com2_3 [s^2]'])
1241             self.assertTrue(v.isEqual(vExp,1e-12))
1242             pass
1243         pass
1244
1245     @WriteInTmpDir
1246     def test7(self):
1247         """ This test plays with curvilinear mesh and profiles. When a sub curvilinear mesh can also be considered as a cartesian mesh it is done.
1248         This test is very similar to the test6.
1249         """
1250         fname="ForMEDReader7.med"
1251         m=MEDCouplingCurveLinearMesh("mesh") ; m.setNodeGridStructure([5,3])
1252         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)
1253         a0Exp.setInfoOnComponents(["XX [m]","YYY [km]"])
1254         m.setCoords(a0Exp)
1255         mm=MEDFileCurveLinearMesh() ; mm.setMesh(m)
1256         fam=DataArrayInt(8) ; fam.iota(0) ; mm.setFamilyFieldArr(0,fam) ; del fam
1257         num=DataArrayInt(8) ; num.iota(100) ; mm.setRenumFieldArr(0,num) ; del num
1258         #
1259         fieldName0="zeField0" ; # on cells
1260         fieldName1="zeField1" ; pfl1=DataArrayInt([2,3,6,7]) ; pfl1.setName("pfl1") # on cells
1261         fieldName2="zeField2" ; pfl2=DataArrayInt([2,3,4,7,8,9,12,13,14]) ; pfl2.setName("pfl2") # on nodes
1262         fieldName3="zeField3" ; pfl3=DataArrayInt([2,3,5,7]) ; pfl3.setName("pfl3") # on cells but different support
1263         fieldName4="zeField4" ;# on nodes
1264         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS() ; fs4=MEDFileFieldMultiTS()
1265         #
1266         for i in range(5):
1267             f=MEDFileField1TS()
1268             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1269             fNode.setName(fieldName0) ; fNode.setMesh(m)
1270             arr=DataArrayDouble(2*8) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1271             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkConsistencyLight()
1272             f.setFieldNoProfileSBT(fNode)
1273             fs0.pushBackTimeStep(f)
1274             #
1275             f=MEDFileField1TS()
1276             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1277             fNode.setName(fieldName1)
1278             arr=DataArrayDouble(2*4) ; arr.iota(100+1000*i) ; arr.rearrange(2)
1279             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
1280             f.setFieldProfile(fNode,mm,0,pfl1)
1281             self.assertEqual(pfl1.getName(),"pfl1")
1282             fs1.pushBackTimeStep(f)
1283             #
1284             f=MEDFileField1TS()
1285             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1286             fNode.setName(fieldName2)
1287             arr=DataArrayDouble(2*9) ; arr.iota(200+1000*i) ; arr.rearrange(2)
1288             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
1289             f.setFieldProfile(fNode,mm,0,pfl2)
1290             self.assertEqual(pfl2.getName(),"pfl2")
1291             fs2.pushBackTimeStep(f)
1292             #
1293             f=MEDFileField1TS()
1294             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1295             fNode.setName(fieldName3)
1296             arr=DataArrayDouble(2*4) ; arr.iota(300+1000*i) ; arr.rearrange(2)
1297             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_3 [m]","Com2_3 [s^2]"])
1298             f.setFieldProfile(fNode,mm,0,pfl3)
1299             self.assertEqual(pfl3.getName(),"pfl3")
1300             fs3.pushBackTimeStep(f)
1301             #
1302             f=MEDFileField1TS()
1303             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1304             fNode.setName(fieldName4) ; fNode.setMesh(m)
1305             arr=DataArrayDouble(2*15) ; arr.iota(400+1000*i) ; arr.rearrange(2)
1306             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_4 [m]","Com2_4 [s^2]"]) ; fNode.checkConsistencyLight()
1307             f.setFieldNoProfileSBT(fNode)
1308             fs4.pushBackTimeStep(f)
1309             pass
1310         mm.write(fname,2)
1311         fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0) ; fs4.write(fname,0)
1312         del m,mm,fs1,fs2,fs3,f,fNode
1313         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1314         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
1315         fields=MEDFileFields(fname,False)
1316         fields.removeFieldsWithoutAnyTimeStep()
1317         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1318         allFMTSLeavesToDisplay=[]
1319         for fields in fields_per_mesh:
1320             allFMTSLeavesToDisplay2=[]
1321             for fmts in fields:
1322                 tmp=fmts.splitDiscretizations()
1323                 for itmp in tmp:
1324                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
1325                     pass
1326                 allFMTSLeavesToDisplay2+=tmp
1327                 pass
1328             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1329             pass
1330         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1331         self.assertEqual(len(allFMTSLeavesToDisplay[0]),5)
1332         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1333         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 5 fields are defined on the same time steps
1334         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),5)
1335         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1336         self.assertEqual(len(allFMTSLeavesPerCommonSupport),3)
1337         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
1338         self.assertEqual(len(allFMTSLeavesPerCommonSupport[1][0]),2)
1339         self.assertEqual(len(allFMTSLeavesPerCommonSupport[2][0]),1)
1340         #
1341         mst=MEDFileMeshStruct.New(ms[0])
1342         #
1343         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1344         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1345         mml2=mml.prepare()
1346         self.assertTrue(isinstance(mml2,MEDCurveLinearMeshMultiLev))
1347         a,b,c=mml2.buildVTUArrays()
1348         self.assertTrue(c)#True here because a is directly coming from internal data without copy
1349         self.assertTrue(a.isEqual(a0Exp,1e-12))
1350         self.assertEqual(b,[5,3])
1351         a6,a7=mml2.retrieveFamilyIdsOnCells()
1352         self.assertTrue(a6.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
1353         self.assertTrue(a7) # True because no copy
1354         a8,a9=mml2.retrieveNumberIdsOnCells()
1355         self.assertTrue(a8.isEqual(DataArrayInt([100,101,102,103,104,105,106,107])))
1356         self.assertTrue(a9) # True because no copy
1357         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1358         for i in range(1, 5):
1359             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1360             pass
1361         for i in range(5):
1362             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1363             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1364             f.loadArraysIfNecessary()
1365             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1366             self.assertEqual(f.getName(),fieldName0)
1367             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1368             vExp=DataArrayDouble(8*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
1369             self.assertTrue(v.isEqual(vExp,1e-12))
1370             #
1371             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
1372             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1373             f.loadArraysIfNecessary()
1374             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1375             self.assertEqual(f.getName(),fieldName4)
1376             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1377             vExp=DataArrayDouble(15*2) ; vExp.iota(400+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_4 [m]','Com2_4 [s^2]'])
1378             self.assertTrue(v.isEqual(vExp,1e-12))
1379             pass
1380         #
1381         fcscp=allFMTSLeavesPerCommonSupport[1][1]
1382         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1383         mml2=mml.prepare()
1384         self.assertTrue(isinstance(mml2,MEDCurveLinearMeshMultiLev)) # here the 2nd support is a part of CMesh that is also a CMesh -> CMesh not a UMesh
1385         a,b,c=mml2.buildVTUArrays()
1386         self.assertTrue(not c)#False here because a is the result of a computation not the internal structure
1387         self.assertTrue(a.isEqual(a0Exp[pfl2],1e-12))
1388         self.assertEqual(b,[3,3])
1389         a6,a7=mml2.retrieveFamilyIdsOnCells()
1390         self.assertTrue(a6.isEqual(DataArrayInt([2,3,6,7])))
1391         self.assertTrue(not a7) # False because copy
1392         a8,a9=mml2.retrieveNumberIdsOnCells()
1393         self.assertTrue(a8.isEqual(DataArrayInt([102,103,106,107])))
1394         self.assertTrue(not a9) # False because copy
1395         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1396         for i in range(1, 5):
1397             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1398             pass
1399         for i in range(5):
1400             f=allFMTSLeavesPerCommonSupport[1][0][0][i]
1401             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1402             f.loadArraysIfNecessary()
1403             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1404             self.assertEqual(f.getName(),fieldName1)
1405             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1406             vExp=DataArrayDouble(4*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
1407             self.assertTrue(v.isEqual(vExp,1e-12))
1408             #
1409             f=allFMTSLeavesPerCommonSupport[1][0][1][i]
1410             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1411             f.loadArraysIfNecessary()
1412             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1413             self.assertEqual(f.getName(),fieldName2)
1414             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1415             vExp=DataArrayDouble(9*2) ; vExp.iota(200+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
1416             self.assertTrue(v.isEqual(vExp,1e-12))
1417             pass
1418         #
1419         fcscp=allFMTSLeavesPerCommonSupport[2][1]
1420         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1421         mml2=mml.prepare()
1422         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev)) # here the 3rd support is a part of CMesh but impossible to simplify more than a UMesh
1423         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1424         self.assertTrue(not ncc)
1425         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)
1426         a0Exp.setInfoOnComponents(["XX [m]","YYY [km]"])
1427         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
1428         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9])))
1429         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15])))
1430         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])))
1431         self.assertTrue(a4 is None)
1432         self.assertTrue(a5 is None)
1433         a6,a7=mml2.retrieveFamilyIdsOnCells()
1434         self.assertTrue(a6.isEqual(DataArrayInt([2,3,5,7])))
1435         self.assertTrue(not a7) # False because copy
1436         a8,a9=mml2.retrieveNumberIdsOnCells()
1437         self.assertTrue(a8.isEqual(DataArrayInt([102,103,105,107])))
1438         self.assertTrue(not a9) # False because copy
1439         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1440         for i in range(5):
1441             f=allFMTSLeavesPerCommonSupport[2][0][0][i]
1442             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1443             f.loadArraysIfNecessary()
1444             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1445             self.assertEqual(f.getName(),fieldName3)
1446             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1447             vExp=DataArrayDouble(4*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_3 [m]','Com2_3 [s^2]'])
1448             self.assertTrue(v.isEqual(vExp,1e-12))
1449             pass
1450         pass
1451
1452     @WriteInTmpDir
1453     def test8(self):
1454         """ This test plays with with gauss fields with no profiles.
1455         """
1456         fname="ForMEDReader8.med"
1457         # building a mesh containing 6 tri3 + 5 quad4
1458         m=MEDCouplingUMesh("mesh",2)
1459         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]"])
1460         m.setCoords(coords)
1461         m.allocateCells()
1462         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])
1463         m.insertNextCell(NORM_TRI3,[13,9,8]) ; m.insertNextCell(NORM_TRI3,[13,14,9])
1464         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])
1465         m.insertNextCell(NORM_QUAD4,[12,13,8,7])
1466         mm=MEDFileUMesh() ; mm.setMeshes([m])
1467         #
1468         fieldName0="zeField0"
1469         fieldName1="zeField1"
1470         fieldName2="zeField2"
1471         fieldName3="zeField3"
1472         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS()
1473         for i in range(5):
1474             f=MEDFileField1TS()
1475             fNode=MEDCouplingFieldDouble(ON_GAUSS_NE) ; fNode.setTime(float(i),i,0)
1476             fNode.setName(fieldName0) ; fNode.setMesh(m)
1477             arr=DataArrayDouble(2*38) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1478             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkConsistencyLight()
1479             f.setFieldNoProfileSBT(fNode)
1480             fs0.pushBackTimeStep(f)
1481             #
1482             f=MEDFileField1TS()
1483             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1484             fNode.setName(fieldName1) ; fNode.setMesh(m)
1485             arr=DataArrayDouble(2*11) ; arr.iota(100+1000*i) ; arr.rearrange(2)
1486             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"]) ; fNode.checkConsistencyLight()
1487             f.setFieldNoProfileSBT(fNode)
1488             fs1.pushBackTimeStep(f)
1489             #
1490             f=MEDFileField1TS()
1491             fNode=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fNode.setTime(float(i),i,0)
1492             fNode.setName(fieldName2) ; fNode.setMesh(m)
1493             fNode.setGaussLocalizationOnCells([0,1,2,3],[0.,0.,1.,0.,0.,1.],[0.5,0.5,0.7,0.7],[0.8,0.2])
1494             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])
1495             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])
1496             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])
1497             arr=DataArrayDouble(2*(4*2+2*5+3*4+2*7)) ; arr.iota(300+1000*i) ; arr.rearrange(2)
1498             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"]) ; fNode.checkConsistencyLight()
1499             f.setFieldNoProfileSBT(fNode)
1500             fs2.pushBackTimeStep(f)
1501             #
1502             f=MEDFileField1TS()
1503             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1504             fNode.setName(fieldName3) ; fNode.setMesh(m)
1505             arr=DataArrayDouble(2*15) ; arr.iota(400+1000*i) ; arr.rearrange(2)
1506             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_3 [m]","Com2_3 [s^2]"]) ; fNode.checkConsistencyLight()
1507             f.setFieldNoProfileSBT(fNode)
1508             fs3.pushBackTimeStep(f)
1509             #
1510             pass
1511         #
1512         mm.write(fname,2)
1513         fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0)
1514         a0Exp=mm.getCoords().deepCopy()
1515         del m,mm,fs1,fs2,fs3,f,fNode
1516         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1517         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
1518         fields=MEDFileFields(fname,False)
1519         fields.removeFieldsWithoutAnyTimeStep()
1520         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1521         allFMTSLeavesToDisplay=[]
1522         for fields in fields_per_mesh:
1523             allFMTSLeavesToDisplay2=[]
1524             for fmts in fields:
1525                 tmp=fmts.splitDiscretizations()
1526                 #for itmp in tmp:
1527                 #    self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
1528                 #    pass
1529                 allFMTSLeavesToDisplay2+=tmp
1530                 pass
1531             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1532             pass
1533         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1534         self.assertEqual(len(allFMTSLeavesToDisplay[0]),4)
1535         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1536         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 4 fields are defined on the same time steps
1537         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
1538         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1539         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
1540         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),4)
1541         #
1542         mst=MEDFileMeshStruct.New(ms[0])
1543         #
1544         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1545         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1546         mml2=mml.prepare()
1547         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
1548         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1549         self.assertTrue(not ncc)
1550         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
1551         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5,5,5,5,9,9,9,9,9])))
1552         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,12,16,20,24,29,34,39,44])))
1553         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])))
1554         self.assertTrue(a4 is None)
1555         self.assertTrue(a5 is None)
1556         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1557         for i in range(1, 5):
1558             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1559             pass
1560         for i in range(5):
1561             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1562             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1563             f.loadArraysIfNecessary()
1564             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1565             self.assertEqual(f.getName(),fieldName0)
1566             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1567             vExp=DataArrayDouble(38*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
1568             self.assertTrue(v.isEqual(vExp,1e-12))
1569             #
1570             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
1571             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1572             f.loadArraysIfNecessary()
1573             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1574             self.assertEqual(f.getName(),fieldName1)
1575             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1576             vExp=DataArrayDouble(11*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
1577             self.assertTrue(v.isEqual(vExp,1e-12))
1578             #
1579             f=allFMTSLeavesPerCommonSupport[0][0][2][i]
1580             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1581             f.loadArraysIfNecessary()
1582             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1583             self.assertEqual(f.getName(),fieldName2)
1584             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug
1585             vExp=DataArrayDouble(44*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
1586             self.assertTrue(v.isEqual(vExp,1e-12))
1587             #
1588             f=allFMTSLeavesPerCommonSupport[0][0][3][i]
1589             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1590             f.loadArraysIfNecessary()
1591             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1592             self.assertEqual(f.getName(),fieldName3)
1593             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1594             vExp=DataArrayDouble(15*2) ; vExp.iota(400+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_3 [m]','Com2_3 [s^2]'])
1595             self.assertTrue(v.isEqual(vExp,1e-12))
1596             pass
1597         #
1598         pass
1599
1600     @WriteInTmpDir
1601     def test9(self):
1602         """ This test plays with with gauss fields with profiles.
1603         """
1604         fname="ForMEDReader9.med"
1605         # building a mesh containing 6 tri3 + 5 quad4
1606         m=MEDCouplingUMesh("mesh",2)
1607         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]"])
1608         m.setCoords(coords)
1609         m.allocateCells()
1610         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])
1611         m.insertNextCell(NORM_TRI3,[13,9,8]) ; m.insertNextCell(NORM_TRI3,[13,14,9])
1612         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])
1613         m.insertNextCell(NORM_QUAD4,[12,13,8,7])
1614         mm=MEDFileUMesh() ; mm.setMeshes([m])
1615         #
1616         fieldName0="zeField0"
1617         fieldName1="zeField1"
1618         fieldName2="zeField2"
1619         fieldName3="zeField3"
1620         pfl1=DataArrayInt([0,1,7,9,10]) ; pfl1.setName("pfl1") # on cells
1621         pfl2=DataArrayInt([1,2,3,6,7,8,11,12,13]) ; pfl2.setName("pfl2") # on nodes
1622         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS()
1623         for i in range(5):
1624             f=MEDFileField1TS()
1625             fNode=MEDCouplingFieldDouble(ON_GAUSS_NE) ; fNode.setTime(float(i),i,0)
1626             fNode.setName(fieldName0)
1627             arr=DataArrayDouble(2*18) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1628             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
1629             f.setFieldProfile(fNode,mm,0,pfl1)
1630             fs0.pushBackTimeStep(f)
1631             #
1632             f=MEDFileField1TS()
1633             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1634             fNode.setName(fieldName1)
1635             arr=DataArrayDouble(2*5) ; arr.iota(100+1000*i) ; arr.rearrange(2)
1636             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
1637             f.setFieldProfile(fNode,mm,0,pfl1)
1638             fs1.pushBackTimeStep(f)
1639             #
1640             f=MEDFileField1TS()
1641             fNode=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fNode.setTime(float(i),i,0)
1642             fNode.setName(fieldName2) ; fNode.setMesh(m[pfl1])
1643             fNode.setGaussLocalizationOnCells([0],[0.,0.,1.,0.,0.,1.],[0.5,0.5,0.7,0.7],[0.8,0.2])
1644             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])
1645             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])
1646             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])
1647             arr=DataArrayDouble(2*(2*1+5*1+4*2+7*1)) ; arr.iota(300+1000*i) ; arr.rearrange(2)
1648             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"]) ; fNode.checkConsistencyLight()
1649             f.setFieldProfile(fNode,mm,0,pfl1)
1650             fs2.pushBackTimeStep(f)
1651             #
1652             f=MEDFileField1TS()
1653             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1654             fNode.setName(fieldName3)
1655             arr=DataArrayDouble(2*9) ; arr.iota(400+1000*i) ; arr.rearrange(2)
1656             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_3 [m]","Com2_3 [s^2]"])
1657             f.setFieldProfile(fNode,mm,0,pfl2)
1658             fs3.pushBackTimeStep(f)
1659             #
1660             pass
1661         #
1662         mm.write(fname,2)
1663         fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0)
1664         a0Exp=mm.getCoords().deepCopy()
1665         del m,mm,fs1,fs2,fs3,f,fNode
1666         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1667         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
1668         fields=MEDFileFields(fname,False)
1669         fields.removeFieldsWithoutAnyTimeStep()
1670         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1671         allFMTSLeavesToDisplay=[]
1672         for fields in fields_per_mesh:
1673             allFMTSLeavesToDisplay2=[]
1674             for fmts in fields:
1675                 tmp=fmts.splitDiscretizations()
1676                 #for itmp in tmp:
1677                 #    self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
1678                 #    pass
1679                 allFMTSLeavesToDisplay2+=tmp
1680                 pass
1681             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1682             pass
1683         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1684         self.assertEqual(len(allFMTSLeavesToDisplay[0]),4)
1685         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1686         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 4 fields are defined on the same time steps
1687         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
1688         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1689         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
1690         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),4)
1691         #
1692         mst=MEDFileMeshStruct.New(ms[0])
1693         #
1694         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1695         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1696         mml2=mml.prepare()
1697         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
1698         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1699         self.assertTrue(not ncc)
1700         self.assertTrue(a0.isEqual(a0Exp[pfl2].changeNbOfComponents(3,0.),1e-12))
1701         self.assertTrue(a1.isEqual(DataArrayByte([5,5,9,9,9])))
1702         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,13,18])))
1703         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])))
1704         self.assertTrue(a4 is None)
1705         self.assertTrue(a5 is None)
1706         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1707         for i in range(1, 5):
1708             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1709             pass
1710         for i in range(5):
1711             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1712             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1713             f.loadArraysIfNecessary()
1714             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1715             self.assertEqual(f.getName(),fieldName0)
1716             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1717             vExp=DataArrayDouble(18*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
1718             self.assertTrue(v.isEqual(vExp,1e-12))
1719             #
1720             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
1721             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1722             f.loadArraysIfNecessary()
1723             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1724             self.assertEqual(f.getName(),fieldName1)
1725             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1726             vExp=DataArrayDouble(5*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
1727             self.assertTrue(v.isEqual(vExp,1e-12))
1728             #
1729             f=allFMTSLeavesPerCommonSupport[0][0][2][i]
1730             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1731             f.loadArraysIfNecessary()
1732             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1733             self.assertEqual(f.getName(),fieldName2)
1734             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug
1735             vExp=DataArrayDouble(22*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
1736             self.assertTrue(v.isEqual(vExp,1e-12))
1737             #
1738             f=allFMTSLeavesPerCommonSupport[0][0][3][i]
1739             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1740             f.loadArraysIfNecessary()
1741             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1742             self.assertEqual(f.getName(),fieldName3)
1743             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1744             vExp=DataArrayDouble(9*2) ; vExp.iota(400+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_3 [m]','Com2_3 [s^2]'])
1745             self.assertTrue(v.isEqual(vExp,1e-12))
1746             pass
1747         pass
1748
1749     @WriteInTmpDir
1750     def test10(self):
1751         """ This test plays with fields only on nodes containing profiles.
1752         """
1753         fname="ForMEDReader10.med"
1754         # building a mesh containing 6 tri3 + 5 quad4
1755         m=MEDCouplingUMesh("mesh",2)
1756         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]"])
1757         m.setCoords(coords)
1758         m.allocateCells()
1759         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])
1760         m.insertNextCell(NORM_TRI3,[13,9,8]) ; m.insertNextCell(NORM_TRI3,[13,14,9])
1761         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])
1762         m.insertNextCell(NORM_QUAD4,[12,13,8,7])
1763         mm=MEDFileUMesh() ; mm.setMeshes([m])
1764         #
1765         fieldName0="zeField0"
1766         fieldName1="zeField1"
1767         fieldName2="zeField2"
1768         pfl1=DataArrayInt([1,2,3,6,7,8,11,12,13]) ; pfl1.setName("pfl1") # on nodes
1769         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS()
1770         for i in range(5):
1771             f=MEDFileField1TS()
1772             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1773             fNode.setName(fieldName0)
1774             arr=DataArrayDouble(2*9) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1775             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
1776             f.setFieldProfile(fNode,mm,0,pfl1)
1777             fs0.pushBackTimeStep(f)
1778             #
1779             f=MEDFileField1TS()
1780             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1781             fNode.setName(fieldName1)
1782             arr=DataArrayDouble(2*9) ; arr.iota(100+1000*i) ; arr.rearrange(2)
1783             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
1784             f.setFieldProfile(fNode,mm,0,pfl1)
1785             fs1.pushBackTimeStep(f)
1786             #
1787             f=MEDFileField1TS()
1788             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1789             fNode.setName(fieldName2)
1790             arr=DataArrayDouble(2*9) ; arr.iota(200+1000*i) ; arr.rearrange(2)
1791             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
1792             f.setFieldProfile(fNode,mm,0,pfl1)
1793             fs2.pushBackTimeStep(f)
1794             #
1795             pass
1796         #
1797         mm.write(fname,2)
1798         fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0)
1799         a0Exp=mm.getCoords().deepCopy()
1800         del m,mm,fs1,fs2,f,fNode
1801         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1802         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
1803         fields=MEDFileFields(fname,False)
1804         fields.removeFieldsWithoutAnyTimeStep()
1805         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1806         allFMTSLeavesToDisplay=[]
1807         for fields in fields_per_mesh:
1808             allFMTSLeavesToDisplay2=[]
1809             for fmts in fields:
1810                 tmp=fmts.splitDiscretizations()
1811                 for itmp in tmp:
1812                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
1813                     pass
1814                 allFMTSLeavesToDisplay2+=tmp
1815                 pass
1816             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1817             pass
1818         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1819         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
1820         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1821         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 4 fields are defined on the same time steps
1822         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
1823         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1824         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
1825         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),3)
1826         #
1827         mst=MEDFileMeshStruct.New(ms[0])
1828         #
1829         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1830         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1831         mml2=mml.prepare()
1832         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
1833         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1834         self.assertTrue(not ncc)
1835         self.assertTrue(a0.isEqual(a0Exp[pfl1].changeNbOfComponents(3,0.),1e-12))
1836         self.assertTrue(a1.isEqual(DataArrayByte([5,5,9,9,9])))
1837         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,13,18])))
1838         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])))
1839         self.assertTrue(a4 is None)
1840         self.assertTrue(a5 is None)
1841         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1842         for i in range(1, 5):
1843             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1844             pass
1845         for i in range(5):
1846             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1847             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1848             f.loadArraysIfNecessary()
1849             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1850             self.assertEqual(f.getName(),fieldName0)
1851             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug
1852             vExp=DataArrayDouble(9*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
1853             self.assertTrue(v.isEqual(vExp,1e-12))
1854             #
1855             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
1856             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1857             f.loadArraysIfNecessary()
1858             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1859             self.assertEqual(f.getName(),fieldName1)
1860             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug
1861             vExp=DataArrayDouble(9*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
1862             self.assertTrue(v.isEqual(vExp,1e-12))
1863             #
1864             f=allFMTSLeavesPerCommonSupport[0][0][2][i]
1865             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1866             f.loadArraysIfNecessary()
1867             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1868             self.assertEqual(f.getName(),fieldName2)
1869             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug
1870             vExp=DataArrayDouble(9*2) ; vExp.iota(200+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
1871             self.assertTrue(v.isEqual(vExp,1e-12))
1872             pass
1873         pass
1874
1875     @WriteInTmpDir
1876     def test11(self):
1877         """ 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 !
1878         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.
1879         """
1880         fname="ForMEDReader11.med"
1881         m=MEDCouplingCMesh("mesh")
1882         arr=DataArrayDouble(5) ; arr.iota()
1883         m.setCoords(arr,arr)
1884         m=m.buildUnstructured() ; m.getCoords().setInfoOnComponents(["XX [m]","YYY [km]"])
1885         mm=MEDFileUMesh() ; mm.setMeshes([m])
1886         #
1887         fieldName0="zeField0"
1888         fs0=MEDFileFieldMultiTS()
1889         for i in range(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.checkConsistencyLight()
1899             f.setFieldNoProfileSBT(fNode)
1900             fs0.pushBackTimeStep(f)
1901             pass
1902         mm.write(fname,2)
1903         fs0.write(fname,0)
1904         a0Exp=mm.getCoords().deepCopy()
1905         del m,mm,fs0,f,fNode
1906         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1907         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
1908         fields=MEDFileFields(fname,False)
1909         fields.removeFieldsWithoutAnyTimeStep()
1910         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1911         allFMTSLeavesToDisplay=[]
1912         for fields in fields_per_mesh:
1913             allFMTSLeavesToDisplay2=[]
1914             for fmts in fields:
1915                 tmp=fmts.splitDiscretizations()
1916                 #for itmp in tmp:
1917                 #    self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
1918                 #    pass
1919                 allFMTSLeavesToDisplay2+=tmp
1920                 pass
1921             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1922             pass
1923         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1924         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
1925         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1926         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 1 field is defined on the same time steps
1927         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
1928         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1929         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
1930         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),1)
1931         #
1932         mst=MEDFileMeshStruct.New(ms[0])
1933         #
1934         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1935         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1936         mml2=mml.prepare()
1937         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
1938         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1939         self.assertTrue(not ncc)
1940         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
1941         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9])))
1942         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75])))
1943         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]]
1944         self.assertTrue(a4 is None)
1945         self.assertTrue(a5 is None)
1946         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1947         for i in range(1, 5):
1948             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1949             pass
1950         for i in range(5):
1951             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1952             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1953             f.loadArraysIfNecessary()
1954             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1955             self.assertEqual(f.getName(),fieldName0)
1956             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1957             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]'])
1958             vExp+=i*1000
1959             self.assertTrue(v.isEqual(vExp,1e-12))
1960             pass
1961         pass
1962
1963     @WriteInTmpDir
1964     def test12(self):
1965         """ This test is the second ultimate test for the profiles with gauss points.
1966         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.
1967         """
1968         fname="ForMEDReader12.med"
1969         m=MEDCouplingCMesh("mesh")
1970         arr=DataArrayDouble(5) ; arr.iota()
1971         m.setCoords(arr,arr)
1972         m=m.buildUnstructured() ; m.getCoords().setInfoOnComponents(["XX [m]","YYY [km]"])
1973         mm=MEDFileUMesh() ; mm.setMeshes([m])
1974         #
1975         fieldName0="zeField0"
1976         fieldName1="zeField1"
1977         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS()
1978         for i in range(5):
1979             f=MEDFileField1TS()
1980             fNode=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fNode.setTime(float(i),i,0)
1981             fNode.setName(fieldName0) ; fNode.setMesh(m)
1982             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])
1983             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])
1984             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])
1985             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])
1986             arr=DataArrayDouble(2*(2*6+5*4+4*3+7*3)) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1987             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkConsistencyLight()
1988             f.setFieldNoProfileSBT(fNode)
1989             fs0.pushBackTimeStep(f)
1990             #
1991             f=MEDFileField1TS()
1992             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1993             fNode.setName(fieldName1) ; fNode.setMesh(m)
1994             arr=DataArrayDouble(2*16) ; arr.iota(300+1000*i) ; arr.rearrange(2)
1995             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"]) ; fNode.checkConsistencyLight()
1996             f.setFieldNoProfileSBT(fNode)
1997             fs1.pushBackTimeStep(f)
1998             pass
1999         mm.write(fname,2)
2000         fs0.write(fname,0) ; fs1.write(fname,0)
2001         a0Exp=mm.getCoords().deepCopy()
2002         del m,mm,fs0,fs1,f,fNode
2003         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2004         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
2005         fields=MEDFileFields(fname,False)
2006         fields.removeFieldsWithoutAnyTimeStep()
2007         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2008         allFMTSLeavesToDisplay=[]
2009         for fields in fields_per_mesh:
2010             allFMTSLeavesToDisplay2=[]
2011             for fmts in fields:
2012                 tmp=fmts.splitDiscretizations()
2013                 #for itmp in tmp:
2014                 #    self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
2015                 #    pass
2016                 allFMTSLeavesToDisplay2+=tmp
2017                 pass
2018             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2019             pass
2020         self.assertEqual(len(allFMTSLeavesToDisplay),1)
2021         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
2022         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2023         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
2024         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
2025         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
2026         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
2027         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
2028         #
2029         mst=MEDFileMeshStruct.New(ms[0])
2030         #
2031         fcscp=allFMTSLeavesPerCommonSupport[0][1]
2032         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2033         mml2=mml.prepare()
2034         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2035         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2036         self.assertTrue(not ncc)
2037         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
2038         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9])))
2039         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75])))
2040         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
2041         self.assertTrue(a4 is None)
2042         self.assertTrue(a5 is None)
2043         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
2044         for i in range(1, 5):
2045             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2046             pass
2047         for i in range(5):
2048             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
2049             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2050             f.loadArraysIfNecessary()
2051             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2052             self.assertEqual(f.getName(),fieldName0)
2053             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug : huge reordering performed !
2054             vExp=DataArrayDouble(65*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
2055             self.assertTrue(v.isEqual(vExp,1e-12))
2056             #
2057             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
2058             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2059             f.loadArraysIfNecessary()
2060             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2061             self.assertEqual(f.getName(),fieldName1)
2062             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug : huge reordering performed !
2063             vExp=DataArrayDouble(16*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
2064             self.assertTrue(v.isEqual(vExp,1e-12))
2065             pass
2066
2067     @WriteInTmpDir
2068     def test13(self):
2069             """ Testing polyhedrons mixed with hexa8"""
2070             fname="ForMEDReader13.med"
2071             m=MEDCouplingUMesh("mesh",3)
2072             m.allocateCells()
2073             m.insertNextCell(NORM_HEXA8,[1,0,6,7,13,12,18,19]) ; m.insertNextCell(NORM_HEXA8,[2,1,7,8,14,13,19,20])
2074             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])
2075             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])
2076             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])
2077             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]"])
2078             m.setCoords(coords)
2079             mm=MEDFileUMesh() ; mm.setMeshes([m])
2080             fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS()
2081             fieldName0="zeField0"
2082             fieldName1="zeField1"
2083             fieldName2="zeField2" ; pfl1=DataArrayInt([2,3]) ; pfl1.setName("pfl1")
2084             fieldName3="zefield3" ; pfl2=DataArrayInt([2,3,4]) ; pfl2.setName("pfl2")
2085             for i in range(5):
2086                 f=MEDFileField1TS()
2087                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2088                 fNode.setName(fieldName0) ; fNode.setMesh(m)
2089                 arr=DataArrayDouble(2*5) ; arr.iota(0+1000*i) ; arr.rearrange(2)
2090                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkConsistencyLight()
2091                 f.setFieldNoProfileSBT(fNode)
2092                 fs0.pushBackTimeStep(f)
2093                 #
2094                 f=MEDFileField1TS()
2095                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2096                 fNode.setName(fieldName1) ; fNode.setMesh(m)
2097                 arr=DataArrayDouble(2*5) ; arr.iota(100+1000*i) ; arr.rearrange(2)
2098                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"]) ; fNode.checkConsistencyLight()
2099                 f.setFieldNoProfileSBT(fNode)
2100                 fs1.pushBackTimeStep(f)
2101                 #
2102                 f=MEDFileField1TS()
2103                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2104                 fNode.setName(fieldName2) ; fNode.setMesh(m[pfl1])
2105                 arr=DataArrayDouble(2*2) ; arr.iota(200+1000*i) ; arr.rearrange(2)
2106                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"]) ; fNode.checkConsistencyLight()
2107                 f.setFieldProfile(fNode,mm,0,pfl1)
2108                 fs2.pushBackTimeStep(f)
2109                 #
2110                 f=MEDFileField1TS()
2111                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2112                 fNode.setName(fieldName3) ; fNode.setMesh(m[pfl2])
2113                 arr=DataArrayDouble(2*3) ; arr.iota(300+1000*i) ; arr.rearrange(2)
2114                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_3 [m]","Com2_3 [s^2]"]) ; fNode.checkConsistencyLight()
2115                 f.setFieldProfile(fNode,mm,0,pfl2)
2116                 fs3.pushBackTimeStep(f)
2117                 pass
2118             mm.write(fname,2)
2119             fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0)
2120             a0Exp=mm.getCoords().deepCopy()
2121             del m,mm,fs0
2122             ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2123             ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
2124             fields=MEDFileFields(fname,False)
2125             fields.removeFieldsWithoutAnyTimeStep()
2126             fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2127             allFMTSLeavesToDisplay=[]
2128             for fields in fields_per_mesh:
2129                 allFMTSLeavesToDisplay2=[]
2130                 for fmts in fields:
2131                     tmp=fmts.splitDiscretizations()
2132                     for itmp in tmp:
2133                         self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
2134                         pass
2135                     allFMTSLeavesToDisplay2+=tmp
2136                     pass
2137                 allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2138                 pass
2139             self.assertEqual(len(allFMTSLeavesToDisplay),1)
2140             self.assertEqual(len(allFMTSLeavesToDisplay[0]),4)
2141             allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2142             self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
2143             self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
2144             allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
2145             self.assertEqual(len(allFMTSLeavesPerCommonSupport),3)
2146             self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
2147             self.assertEqual(len(allFMTSLeavesPerCommonSupport[1][0]),1)
2148             self.assertEqual(len(allFMTSLeavesPerCommonSupport[2][0]),1)
2149             #
2150             mst=MEDFileMeshStruct.New(ms[0])
2151             #
2152             fcscp=allFMTSLeavesPerCommonSupport[0][1]
2153             mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2154             mml2=mml.prepare()
2155             self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2156             ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2157             self.assertTrue(ncc)
2158             self.assertTrue(a0.isEqual(a0Exp,1e-12))
2159             self.assertTrue(a1.isEqual(DataArrayByte([12,12,42,42,42])))
2160             self.assertTrue(a2.isEqual(DataArrayInt([0,9,18,27,36])))
2161             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])))
2162             self.assertTrue(a4.isEqual(DataArrayInt([-1,-1,0,31,62])))
2163             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])))
2164             self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
2165             for i in range(1, 5):
2166                 self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2167                 pass
2168             pass
2169             for i in range(5):
2170                 f=allFMTSLeavesPerCommonSupport[0][0][0][i]
2171                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2172                 f.loadArraysIfNecessary()
2173                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2174                 self.assertEqual(f.getName(),fieldName0)
2175                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2176                 vExp=DataArrayDouble(5*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
2177                 self.assertTrue(v.isEqual(vExp,1e-12))
2178                 #
2179                 f=allFMTSLeavesPerCommonSupport[0][0][1][i]
2180                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2181                 f.loadArraysIfNecessary()
2182                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2183                 self.assertEqual(f.getName(),fieldName1)
2184                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2185                 vExp=DataArrayDouble(5*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
2186                 self.assertTrue(v.isEqual(vExp,1e-12))
2187                 pass
2188             #
2189             fcscp=allFMTSLeavesPerCommonSupport[1][1]
2190             mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2191             mml2=mml.prepare()
2192             self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2193             ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2194             self.assertTrue(ncc)
2195             self.assertTrue(a0.isEqual(a0Exp,1e-12))
2196             self.assertTrue(a1.isEqual(DataArrayByte([42,42])))
2197             self.assertTrue(a2.isEqual(DataArrayInt([0,9])))
2198             self.assertTrue(a3.isEqual(DataArrayInt([8,2,3,8,9,14,15,20,21,8,3,4,9,10,15,16,21,22])))
2199             self.assertTrue(a4.isEqual(DataArrayInt([0,31])))
2200             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])))
2201             self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
2202             for i in range(1, 5):
2203                 self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2204                 pass
2205             pass
2206             for i in range(5):
2207                 f=allFMTSLeavesPerCommonSupport[1][0][0][i]
2208                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2209                 f.loadArraysIfNecessary()
2210                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2211                 self.assertEqual(f.getName(),fieldName2)
2212                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2213                 vExp=DataArrayDouble(2*2) ; vExp.iota(200+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
2214                 self.assertTrue(v.isEqual(vExp,1e-12))
2215                 pass
2216             #
2217             fcscp=allFMTSLeavesPerCommonSupport[2][1]
2218             mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2219             mml2=mml.prepare()
2220             self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2221             ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2222             self.assertTrue(ncc)
2223             self.assertTrue(a0.isEqual(a0Exp,1e-12))
2224             self.assertTrue(a1.isEqual(DataArrayByte([42,42,42])))
2225             self.assertTrue(a2.isEqual(DataArrayInt([0,9,18])))
2226             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])))
2227             self.assertTrue(a4.isEqual(DataArrayInt([0,31,62])))
2228             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])))
2229             for i in range(1, 5):
2230                 self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2231                 pass
2232             pass
2233             for i in range(5):
2234                 f=allFMTSLeavesPerCommonSupport[2][0][0][i]
2235                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2236                 f.loadArraysIfNecessary()
2237                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2238                 self.assertEqual(f.getName(),fieldName3)
2239                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2240                 vExp=DataArrayDouble(3*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_3 [m]','Com2_3 [s^2]'])
2241                 self.assertTrue(v.isEqual(vExp,1e-12))
2242                 pass
2243             pass
2244
2245     @WriteInTmpDir
2246     def test14(self):
2247             """ Testing only polyhedrons"""
2248             fname="ForMEDReader14.med"
2249             m=MEDCouplingUMesh("mesh",3)
2250             m.allocateCells()
2251             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])
2252             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])
2253             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])
2254             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]"])
2255             m.setCoords(coords)
2256             mm=MEDFileUMesh() ; mm.setMeshes([m])
2257             fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS()
2258             fieldName0="zeField0"
2259             fieldName1="zeField1"
2260             for i in range(5):
2261                 f=MEDFileField1TS()
2262                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2263                 fNode.setName(fieldName0) ; fNode.setMesh(m)
2264                 arr=DataArrayDouble(2*3) ; arr.iota(0+1000*i) ; arr.rearrange(2)
2265                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkConsistencyLight()
2266                 f.setFieldNoProfileSBT(fNode)
2267                 fs0.pushBackTimeStep(f)
2268                 #
2269                 f=MEDFileField1TS()
2270                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2271                 fNode.setName(fieldName1) ; fNode.setMesh(m)
2272                 arr=DataArrayDouble(2*3) ; arr.iota(100+1000*i) ; arr.rearrange(2)
2273                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"]) ; fNode.checkConsistencyLight()
2274                 f.setFieldNoProfileSBT(fNode)
2275                 fs1.pushBackTimeStep(f)
2276                 pass
2277             mm.write(fname,2)
2278             fs0.write(fname,0) ; fs1.write(fname,0)
2279             a0Exp=mm.getCoords().deepCopy()
2280             del m,mm,fs0
2281             ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2282             ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
2283             fields=MEDFileFields(fname,False)
2284             fields.removeFieldsWithoutAnyTimeStep()
2285             fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2286             allFMTSLeavesToDisplay=[]
2287             for fields in fields_per_mesh:
2288                 allFMTSLeavesToDisplay2=[]
2289                 for fmts in fields:
2290                     tmp=fmts.splitDiscretizations()
2291                     for itmp in tmp:
2292                         self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
2293                         pass
2294                     allFMTSLeavesToDisplay2+=tmp
2295                     pass
2296                 allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2297                 pass
2298             self.assertEqual(len(allFMTSLeavesToDisplay),1)
2299             self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
2300             allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2301             self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
2302             self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
2303             allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
2304             self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
2305             self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
2306             #
2307             mst=MEDFileMeshStruct.New(ms[0])
2308             #
2309             fcscp=allFMTSLeavesPerCommonSupport[0][1]
2310             mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2311             mml2=mml.prepare()
2312             self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2313             ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2314             self.assertTrue(ncc)
2315             self.assertTrue(a0.isEqual(a0Exp,1e-12))
2316             self.assertTrue(a1.isEqual(DataArrayByte([42,42,42])))
2317             self.assertTrue(a2.isEqual(DataArrayInt([0,9,18])))
2318             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])))
2319             self.assertTrue(a4.isEqual(DataArrayInt([0,31,62])))
2320             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])))
2321             self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
2322             for i in range(1, 5):
2323                 self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2324                 pass
2325             a6,a7=mml2.retrieveFamilyIdsOnCells()
2326             self.assertTrue(a6.isEqual(DataArrayInt([0,0,0])))
2327             self.assertTrue(a7)
2328             a8,a9=mml2.retrieveNumberIdsOnCells()
2329             self.assertTrue(a8 is None)
2330             self.assertTrue(a9)
2331             for i in range(5):
2332                 f=allFMTSLeavesPerCommonSupport[0][0][0][i]
2333                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2334                 f.loadArraysIfNecessary()
2335                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2336                 self.assertEqual(f.getName(),fieldName0)
2337                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2338                 vExp=DataArrayDouble(3*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
2339                 self.assertTrue(v.isEqual(vExp,1e-12))
2340                 #
2341                 f=allFMTSLeavesPerCommonSupport[0][0][1][i]
2342                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2343                 f.loadArraysIfNecessary()
2344                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2345                 self.assertEqual(f.getName(),fieldName1)
2346                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2347                 vExp=DataArrayDouble(3*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
2348                 self.assertTrue(v.isEqual(vExp,1e-12))
2349                 pass
2350             pass
2351
2352     @WriteInTmpDir
2353     def test15(self):
2354         """
2355         "ForMEDReader15.med" file has a spaceDim 3 mesh "mesh" (it is important !)
2356         and a field "zeField" lying on a single geometric type for Cell discr and node part.
2357         Test that can appear the most simple but it hides a big issue of MEDReader
2358         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.
2359         """
2360         fname="ForMEDReader15.med"
2361         m0=MEDCouplingCMesh()
2362         arr=DataArrayDouble(3) ; arr.iota(0)
2363         m0.setCoords(arr,arr,arr)
2364         m0.setName("mesh")
2365         m0=m0.buildUnstructured()
2366         #
2367         fieldName="zeField"
2368         fCell=MEDCouplingFieldDouble(ON_CELLS)
2369         fCell.setName(fieldName)
2370         fCell.setMesh(m0)
2371         #
2372         fNode=MEDCouplingFieldDouble(ON_NODES)
2373         fNode.setName(fieldName)
2374         fNode.setMesh(m0)
2375         #
2376         mm=MEDFileUMesh()
2377         mm.setMeshAtLevel(0,m0)
2378         fam=DataArrayInt(8) ; fam.iota(0) ; mm.setFamilyFieldArr(0,fam) ; del fam
2379         num=DataArrayInt(8) ; num.iota(100) ; mm.setRenumFieldArr(0,num) ; del num
2380         #
2381         ffs=MEDFileFieldMultiTS()
2382         # TimeStep 0
2383         t=(1.,0,0) ; off=0.
2384         f1ts=MEDFileField1TS()
2385         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2386         fCell.setArray(a)
2387         fCell.setTime(*t)
2388         fCell.checkConsistencyLight()
2389         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2390         a=a.negate()
2391         fNode.setArray(a)
2392         fNode.setTime(*t)
2393         fNode.checkConsistencyLight()
2394         f1ts.setFieldNoProfileSBT(fCell)
2395         f1ts.setFieldNoProfileSBT(fNode)
2396         ffs.pushBackTimeStep(f1ts)
2397         # TimeStep 1
2398         t=(2.1,1,0) ; off=100.
2399         f1ts=MEDFileField1TS()
2400         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2401         fCell.setArray(a)
2402         fCell.setTime(*t)
2403         fCell.checkConsistencyLight()
2404         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2405         a=a.negate()
2406         fNode.setArray(a)
2407         fNode.setTime(*t)
2408         fNode.checkConsistencyLight()
2409         f1ts.setFieldNoProfileSBT(fCell)
2410         f1ts.setFieldNoProfileSBT(fNode)
2411         ffs.pushBackTimeStep(f1ts)
2412         # TimeStep 2
2413         t=(3.2,2,0) ; off=200.
2414         f1ts=MEDFileField1TS()
2415         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2416         fCell.setArray(a)
2417         fCell.setTime(*t)
2418         fCell.checkConsistencyLight()
2419         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2420         a=a.negate()
2421         fNode.setArray(a)
2422         fNode.setTime(*t)
2423         fNode.checkConsistencyLight()
2424         f1ts.setFieldNoProfileSBT(fCell)
2425         f1ts.setFieldNoProfileSBT(fNode)
2426         ffs.pushBackTimeStep(f1ts)
2427         # TimeStep 3
2428         t=(4.3,3,1) ; off=300.
2429         f1ts=MEDFileField1TS()
2430         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2431         fCell.setArray(a)
2432         fCell.setTime(*t)
2433         fCell.checkConsistencyLight()
2434         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2435         a=a.negate()
2436         fNode.setArray(a)
2437         fNode.setTime(*t)
2438         fNode.checkConsistencyLight()
2439         f1ts.setFieldNoProfileSBT(fCell)
2440         f1ts.setFieldNoProfileSBT(fNode)
2441         ffs.pushBackTimeStep(f1ts)
2442         #
2443         mm.write(fname,2)
2444         ffs.write(fname,0)
2445         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2446         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
2447         fields=MEDFileFields(fname,False)
2448         fields.removeFieldsWithoutAnyTimeStep()
2449         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2450         allFMTSLeavesToDisplay=[]
2451         for fields in fields_per_mesh:
2452             allFMTSLeavesToDisplay2=[]
2453             for fmts in fields:
2454                 tmp=fmts.splitDiscretizations()
2455                 for itmp in tmp:
2456                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
2457                     pass
2458                 allFMTSLeavesToDisplay2+=tmp
2459                 pass
2460             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2461             pass
2462         self.assertEqual(len(allFMTSLeavesToDisplay),1)
2463         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
2464         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2465         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
2466         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
2467         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
2468         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
2469         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
2470         #
2471         mst=MEDFileMeshStruct.New(ms[0])
2472         #
2473         fcscp=allFMTSLeavesPerCommonSupport[0][1]
2474         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2475         mml2=mml.prepare()
2476         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2477         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2478         self.assertTrue(ncc)
2479         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))
2480         self.assertTrue(a1.isEqual(DataArrayByte([12,12,12,12,12,12,12,12])))
2481         self.assertTrue(a2.isEqual(DataArrayInt([0,9,18,27,36,45,54,63])))
2482         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])))
2483         self.assertTrue(a4 is None)
2484         self.assertTrue(a5 is None)
2485         a6,a7=mml2.retrieveFamilyIdsOnCells()
2486         self.assertTrue(a6.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
2487         self.assertTrue(a7) # no copy here
2488         a8,a9=mml2.retrieveNumberIdsOnCells()
2489         self.assertTrue(a8.isEqual(DataArrayInt([100,101,102,103,104,105,106,107])))
2490         self.assertTrue(a9) # no copy here
2491         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
2492         pass
2493
2494     @WriteInTmpDir
2495     def test16(self):
2496         """ Here 2 meshes "mesh1" and "mesh2" and 4 fields (no profiles here) :
2497         - "zeField1_0" (CELLS) and "zeField2_0" (NODES) on "mesh1"
2498         - "zeField3_1" (CELLS) and "zeField4_1" (NODES) on "mesh2"
2499         time steps series are the same for the whole 4 fields
2500         """
2501         fname="ForMEDReader16.med"
2502         m0=MEDCouplingCMesh()
2503         arr=DataArrayDouble(3) ; arr.iota(0)
2504         m0.setCoords(arr,arr,arr)
2505         m0.setName("mesh1")
2506         m0=m0.buildUnstructured()
2507         #
2508         fCell1=MEDCouplingFieldDouble(ON_CELLS)
2509         fCell1.setName("zeField1_0")
2510         fCell1.setMesh(m0)
2511         #
2512         fNode1=MEDCouplingFieldDouble(ON_NODES)
2513         fNode1.setName("zeField2_0")
2514         fNode1.setMesh(m0)
2515         #
2516         mms=MEDFileMeshes()
2517         mm1=MEDFileUMesh()
2518         mm1.setMeshAtLevel(0,m0)
2519         fam=DataArrayInt([0,1,0,1,2,3,2,3]); mm1.setFamilyFieldArr(0,fam) ; del fam
2520         num=DataArrayInt(8) ; num.iota(100) ; mm1.setRenumFieldArr(0,num) ; del num
2521         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)
2522         mm1.setFamiliesIdsOnGroup("Grp1_1",[0,1]) ; mm1.setFamiliesIdsOnGroup("Grp1_2",[2,3])
2523         mms.pushMesh(mm1) ; del mm1
2524         #
2525         m1=m0.deepCopy() ; m1.translate([2.5,0.,0.]) ; m1.setName("mesh2")
2526         #
2527         fCell2=MEDCouplingFieldDouble(ON_CELLS)
2528         fCell2.setName("zeField3_1")
2529         fCell2.setMesh(m1)
2530         #
2531         fNode2=MEDCouplingFieldDouble(ON_NODES)
2532         fNode2.setName("zeField4_1")
2533         fNode2.setMesh(m1)
2534         #
2535         mm2=MEDFileUMesh()
2536         mm2.setMeshAtLevel(0,m1)
2537         fam=DataArrayInt([0,1,0,1,2,3,2,3]); mm2.setFamilyFieldArr(0,fam) ; del fam
2538         num=DataArrayInt(8) ; num.iota(200) ; mm2.setRenumFieldArr(0,num) ; del num
2539         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)
2540         mm2.setFamiliesIdsOnGroup("Grp2_1",[0,1]) ; mm2.setFamiliesIdsOnGroup("Grp2_2",[2,3]) ; mm2.setFamiliesIdsOnGroup("Grp2_3",[1,2,3])
2541         mms.pushMesh(mm2) ; del mm2
2542         ffs1_1=MEDFileFieldMultiTS()
2543         ffs1_2=MEDFileFieldMultiTS()
2544         ffs2_1=MEDFileFieldMultiTS()
2545         ffs2_2=MEDFileFieldMultiTS()
2546         mts=MEDFileFields()
2547         for elt in ffs1_1,ffs1_2,ffs2_1,ffs2_2:
2548             mts.pushField(elt)
2549             pass
2550         # TimeStep 0
2551         t=(1.,0,0) ; off=0.
2552         f1ts1=MEDFileField1TS()
2553         f1ts2=MEDFileField1TS()
2554         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2555         fCell1.setArray(a)
2556         fCell1.setTime(*t)
2557         fCell1.checkConsistencyLight()
2558         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2559         a=a.negate()
2560         fNode1.setArray(a)
2561         fNode1.setTime(*t)
2562         fNode1.checkConsistencyLight()
2563         f1ts1.setFieldNoProfileSBT(fCell1) ; ffs1_1.pushBackTimeStep(f1ts1)
2564         f1ts2.setFieldNoProfileSBT(fNode1) ; ffs1_2.pushBackTimeStep(f1ts2)
2565         #
2566         f1ts1=MEDFileField1TS()
2567         f1ts2=MEDFileField1TS()
2568         a=DataArrayDouble(m1.getNumberOfCells()) ; a.iota(1000.+off) ; a.setInfoOnComponents(["xx [m]"])
2569         fCell2.setArray(a)
2570         fCell2.setTime(*t)
2571         fCell2.checkConsistencyLight()
2572         a=DataArrayDouble(m1.getNumberOfNodes()) ; a.iota(1000+off) ; a.setInfoOnComponents(["xx [m]"])
2573         a=a.negate()
2574         fNode2.setArray(a)
2575         fNode2.setTime(*t)
2576         fNode2.checkConsistencyLight()
2577         f1ts1.setFieldNoProfileSBT(fCell2) ; ffs2_1.pushBackTimeStep(f1ts1)
2578         f1ts2.setFieldNoProfileSBT(fNode2) ; ffs2_2.pushBackTimeStep(f1ts2)
2579         # TimeStep 1
2580         t=(2.1,1,0) ; off=100.
2581         f1ts1=MEDFileField1TS()
2582         f1ts2=MEDFileField1TS()
2583         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2584         fCell1.setArray(a)
2585         fCell1.setTime(*t)
2586         fCell1.checkConsistencyLight()
2587         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2588         a=a.negate()
2589         fNode1.setArray(a)
2590         fNode1.setTime(*t)
2591         fNode1.checkConsistencyLight()
2592         f1ts1.setFieldNoProfileSBT(fCell1) ; ffs1_1.pushBackTimeStep(f1ts1)
2593         f1ts2.setFieldNoProfileSBT(fNode1) ; ffs1_2.pushBackTimeStep(f1ts2)
2594         #
2595         f1ts1=MEDFileField1TS()
2596         f1ts2=MEDFileField1TS()
2597         a=DataArrayDouble(m1.getNumberOfCells()) ; a.iota(1000.+off) ; a.setInfoOnComponents(["xx [m]"])
2598         fCell2.setArray(a)
2599         fCell2.setTime(*t)
2600         fCell2.checkConsistencyLight()
2601         a=DataArrayDouble(m1.getNumberOfNodes()) ; a.iota(1000+off) ; a.setInfoOnComponents(["xx [m]"])
2602         a=a.negate()
2603         fNode2.setArray(a)
2604         fNode2.setTime(*t)
2605         fNode2.checkConsistencyLight()
2606         f1ts1.setFieldNoProfileSBT(fCell2) ; ffs2_1.pushBackTimeStep(f1ts1)
2607         f1ts2.setFieldNoProfileSBT(fNode2) ; ffs2_2.pushBackTimeStep(f1ts2)
2608         # TimeStep 2
2609         t=(3.1,2,0) ; off=200.
2610         f1ts1=MEDFileField1TS()
2611         f1ts2=MEDFileField1TS()
2612         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2613         fCell1.setArray(a)
2614         fCell1.setTime(*t)
2615         fCell1.checkConsistencyLight()
2616         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2617         a=a.negate()
2618         fNode1.setArray(a)
2619         fNode1.setTime(*t)
2620         fNode1.checkConsistencyLight()
2621         f1ts1.setFieldNoProfileSBT(fCell1) ; ffs1_1.pushBackTimeStep(f1ts1)
2622         f1ts2.setFieldNoProfileSBT(fNode1) ; ffs1_2.pushBackTimeStep(f1ts2)
2623         #
2624         f1ts1=MEDFileField1TS()
2625         f1ts2=MEDFileField1TS()
2626         a=DataArrayDouble(m1.getNumberOfCells()) ; a.iota(1000.+off) ; a.setInfoOnComponents(["xx [m]"])
2627         fCell2.setArray(a)
2628         fCell2.setTime(*t)
2629         fCell2.checkConsistencyLight()
2630         a=DataArrayDouble(m1.getNumberOfNodes()) ; a.iota(1000+off) ; a.setInfoOnComponents(["xx [m]"])
2631         a=a.negate()
2632         fNode2.setArray(a)
2633         fNode2.setTime(*t)
2634         fNode2.checkConsistencyLight()
2635         f1ts1.setFieldNoProfileSBT(fCell2) ; ffs2_1.pushBackTimeStep(f1ts1)
2636         f1ts2.setFieldNoProfileSBT(fNode2) ; ffs2_2.pushBackTimeStep(f1ts2)
2637         #
2638         mms.write(fname,2) ; mts.write(fname,0)
2639         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2640         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
2641         fields=MEDFileFields(fname,False)
2642         fields.removeFieldsWithoutAnyTimeStep()
2643         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2644         allFMTSLeavesToDisplay=[]
2645         for fields in fields_per_mesh:
2646             allFMTSLeavesToDisplay2=[]
2647             for fmts in fields:
2648                 tmp=fmts.splitDiscretizations()
2649                 for itmp in tmp:
2650                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
2651                     pass
2652                 allFMTSLeavesToDisplay2+=tmp
2653                 pass
2654             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2655             pass
2656         self.assertEqual(len(allFMTSLeavesToDisplay),2)
2657         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
2658         self.assertEqual(len(allFMTSLeavesToDisplay[1]),2)
2659         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2660         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
2661         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
2662         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
2663         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
2664         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),2)
2665         allFMTSLeavesPerCommonSupport2=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
2666         self.assertEqual(len(allFMTSLeavesPerCommonSupport2),1)
2667         self.assertEqual(len(allFMTSLeavesPerCommonSupport2[0][0]),2)
2668         pass
2669
2670     @WriteInTmpDir
2671     def test17(self):
2672         """ First test on GAUSS_NE (Elno). Here no Profiles.
2673         2 times steps.
2674         """
2675         fname="ForMEDReader17.med"
2676         fieldName1="MyFirstElno"
2677         fieldName2="ACellField"
2678         fieldName3="ANodeField"
2679         coo=DataArrayDouble([0.,0.,1.,0.,2.,0.,0.,1.,1.,1.,2.,1.],6,2)
2680         m=MEDCouplingUMesh("mesh",2)
2681         m.setCoords(coo)
2682         m.allocateCells()
2683         m.insertNextCell(NORM_QUAD4,[0,3,4,1])
2684         m.insertNextCell(NORM_QUAD4,[1,4,5,2])
2685         m.checkConsistency()
2686         #
2687         t=(1.1,0,-1)
2688         f=MEDCouplingFieldDouble(ON_GAUSS_NE) ; f.setTime(*t) ; f.setMesh(m)
2689         f.setArray(DataArrayDouble([3.,5.,7.,6.,2.,3.,11.,8.]))
2690         f.setName(fieldName1)
2691         f.checkConsistencyLight()
2692         WriteField(fname,f,True)
2693         f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setTime(*t) ; f2.setMesh(m)
2694         f2.setArray(DataArrayDouble([7.,11.],2,1))
2695         f2.setName(fieldName2)
2696         WriteFieldUsingAlreadyWrittenMesh(fname,f2)
2697         f3=MEDCouplingFieldDouble(ON_NODES) ; f3.setTime(*t) ; f3.setMesh(m)
2698         f3.setArray(DataArrayDouble([1.,2.,4.,1.,2.,4.],6,1))
2699         f3.setName(fieldName3)
2700         WriteFieldUsingAlreadyWrittenMesh(fname,f3)
2701         #
2702         t=(2.1,1,-1)
2703         f=MEDCouplingFieldDouble(ON_GAUSS_NE) ; f.setTime(*t) ; f.setMesh(m)
2704         f.setArray(DataArrayDouble([7.,6.,3.,5.,11.,8.,2.,3.]))
2705         f.setName(fieldName1)
2706         f.checkConsistencyLight()
2707         WriteFieldUsingAlreadyWrittenMesh(fname,f)
2708         f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setTime(*t) ; f2.setMesh(m)
2709         f2.setArray(DataArrayDouble([11.,7.],2,1))
2710         f2.setName(fieldName2)
2711         WriteFieldUsingAlreadyWrittenMesh(fname,f2)
2712         f3=MEDCouplingFieldDouble(ON_NODES) ; f3.setTime(*t) ; f3.setMesh(m)
2713         f3.setArray(DataArrayDouble([4.,2.,1.,4.,2.,1.],6,1))
2714         f3.setName(fieldName3)
2715         WriteFieldUsingAlreadyWrittenMesh(fname,f3)
2716         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2717         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
2718         fields=MEDFileFields(fname,False)
2719         fields.removeFieldsWithoutAnyTimeStep()
2720         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2721         allFMTSLeavesToDisplay=[]
2722         for fields in fields_per_mesh:
2723             allFMTSLeavesToDisplay2=[]
2724             for fmts in fields:
2725                 tmp=fmts.splitDiscretizations()
2726                 for itmp in tmp:
2727                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
2728                     pass
2729                 allFMTSLeavesToDisplay2+=tmp
2730                 pass
2731             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2732             pass
2733         self.assertEqual(len(allFMTSLeavesToDisplay),1)
2734         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
2735         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2736         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
2737         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
2738         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
2739         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
2740         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),3)
2741         #
2742         mst=MEDFileMeshStruct.New(ms[0])
2743         #
2744         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
2745         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2746         mml2=mml.prepare()
2747         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2748         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2749         self.assertTrue(not ncc) # spaceDim 2 -> VTK wants 3D
2750         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))
2751         self.assertTrue(a1.isEqual(DataArrayByte([9,9])))
2752         self.assertTrue(a2.isEqual(DataArrayInt([0,5])))
2753         self.assertTrue(a3.isEqual(DataArrayInt([4,0,3,4,1,4,1,4,5,2])))
2754         self.assertTrue(a4 is None)
2755         self.assertTrue(a5 is None)
2756         a6,a7=mml2.retrieveFamilyIdsOnCells()
2757         self.assertTrue(a6.isEqual(DataArrayInt([0,0])))
2758         self.assertTrue(a7) # no copy here
2759         a8,a9=mml2.retrieveNumberIdsOnCells()
2760         self.assertTrue(a8.isEqual(DataArrayInt([0,1])))
2761         self.assertTrue(a9) # no copy here
2762         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
2763         for i in range(1, 2):
2764             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2765             pass
2766         vExp0=[DataArrayDouble([7.,11.]),DataArrayDouble([11.,7.])]
2767         vExp1=[DataArrayDouble([3.,5.,7.,6.,2.,3.,11.,8.]),DataArrayDouble([7.,6.,3.,5.,11.,8.,2.,3.])]
2768         for i in range(2):
2769             f=allFMTSLeavesPerCommonSupport1[0][0][0][i]
2770             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2771             f.loadArraysIfNecessary()
2772             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2773             self.assertEqual(f.getName(),fieldName2)
2774             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2775             self.assertTrue(v.isEqual(vExp0[i],1e-12))
2776             #
2777             f=allFMTSLeavesPerCommonSupport1[0][0][1][i]
2778             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2779             f.loadArraysIfNecessary()
2780             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2781             self.assertEqual(f.getName(),fieldName1)
2782             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2783             self.assertTrue(v.isEqual(vExp1[i],1e-12))
2784             pass
2785         pass
2786
2787     @WriteInTmpDir
2788     def test18(self):
2789         """ First test on GAUSS_PT. Here no Profiles. 2 times steps.
2790         """
2791         fname="ForMEDReader18.med"
2792         fieldName1="MyFirstGauss"
2793         fieldName2="ACellField"
2794         fieldName3="ANodeField"
2795         coo=DataArrayDouble([0.,0.,1.,0.,2.,0.,0.,1.,1.,1.,2.,1.],6,2)
2796         m=MEDCouplingUMesh("mesh",2)
2797         m.setCoords(coo)
2798         m.allocateCells()
2799         m.insertNextCell(NORM_QUAD4,[0,3,4,1])
2800         m.insertNextCell(NORM_QUAD4,[1,4,5,2])
2801         m.checkConsistency()
2802         #
2803         t=(1.1,0,-1)
2804         f=MEDCouplingFieldDouble(ON_GAUSS_PT) ; f.setTime(*t) ; f.setMesh(m)
2805         f.setGaussLocalizationOnType(NORM_QUAD4,[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.2,0.2,0.8,0.8],[0.7,0.3])
2806         f.setArray(DataArrayDouble([3.,5.,4.,6.])) ; f.getArray().setInfoOnComponents(["Smth"])
2807         f.setName(fieldName1)
2808         f.checkConsistencyLight()
2809         WriteField(fname,f,True)
2810         f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setTime(*t) ; f2.setMesh(m)
2811         f2.setArray(DataArrayDouble([7.,11.],2,1))
2812         f2.setName(fieldName2)
2813         WriteFieldUsingAlreadyWrittenMesh(fname,f2)
2814         f3=MEDCouplingFieldDouble(ON_NODES) ; f3.setTime(*t) ; f3.setMesh(m)
2815         f3.setArray(DataArrayDouble([1.,2.,4.,1.,2.,4.],6,1))
2816         f3.setName(fieldName3)
2817         WriteFieldUsingAlreadyWrittenMesh(fname,f3)
2818         #
2819         t=(2.1,1,-1)
2820         f=MEDCouplingFieldDouble(ON_GAUSS_PT) ; f.setTime(*t) ; f.setMesh(m)
2821         f.setGaussLocalizationOnType(NORM_QUAD4,[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.2,0.2,0.8,0.8],[0.7,0.3])
2822         f.setArray(DataArrayDouble([5.,3.,6.,4.])) ; f.getArray().setInfoOnComponents(["Smth"])
2823         f.setName(fieldName1)
2824         f.checkConsistencyLight()
2825         WriteFieldUsingAlreadyWrittenMesh(fname,f)
2826         f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setTime(*t) ; f2.setMesh(m)
2827         f2.setArray(DataArrayDouble([11.,7.],2,1))
2828         f2.setName(fieldName2)
2829         WriteFieldUsingAlreadyWrittenMesh(fname,f2)
2830         f3=MEDCouplingFieldDouble(ON_NODES) ; f3.setTime(*t) ; f3.setMesh(m)
2831         f3.setArray(DataArrayDouble([4.,2.,1.,4.,2.,1.],6,1))
2832         f3.setName(fieldName3)
2833         WriteFieldUsingAlreadyWrittenMesh(fname,f3)
2834         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2835         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
2836         fields=MEDFileFields(fname,False)
2837         fields.removeFieldsWithoutAnyTimeStep()
2838         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2839         allFMTSLeavesToDisplay=[]
2840         for fields in fields_per_mesh:
2841             allFMTSLeavesToDisplay2=[]
2842             for fmts in fields:
2843                 tmp=fmts.splitDiscretizations()
2844                 for itmp in tmp:
2845                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
2846                     pass
2847                 allFMTSLeavesToDisplay2+=tmp
2848                 pass
2849             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2850             pass
2851         self.assertEqual(len(allFMTSLeavesToDisplay),1)
2852         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
2853         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2854         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
2855         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
2856         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
2857         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
2858         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),3)
2859         #
2860         mst=MEDFileMeshStruct.New(ms[0])
2861         #
2862         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
2863         self.assertEqual([NORM_QUAD4],fcscp.getGeoTypesAt(0,ms[0]))
2864         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2865         mml2=mml.prepare()
2866         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2867         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2868         self.assertTrue(not ncc) # spaceDim 2 -> VTK wants 3D
2869         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))
2870         self.assertTrue(a1.isEqual(DataArrayByte([9,9])))
2871         self.assertTrue(a2.isEqual(DataArrayInt([0,5])))
2872         self.assertTrue(a3.isEqual(DataArrayInt([4,0,3,4,1,4,1,4,5,2])))
2873         self.assertTrue(a4 is None)
2874         self.assertTrue(a5 is None)
2875         a6,a7=mml2.retrieveFamilyIdsOnCells()
2876         self.assertTrue(a6.isEqual(DataArrayInt([0,0])))
2877         self.assertTrue(a7) # no copy here
2878         a8,a9=mml2.retrieveNumberIdsOnCells()
2879         self.assertTrue(a8.isEqual(DataArrayInt([0,1])))
2880         self.assertTrue(a9) # no copy here
2881         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
2882         for i in range(1, 2):
2883             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2884             pass
2885         vExp0=[DataArrayDouble([7.,11.]),DataArrayDouble([11.,7.])]
2886         vExp1=[DataArrayDouble([3.,5.,4.,6.]),DataArrayDouble([5.,3.,6.,4.])]
2887         for i in range(2):
2888             f=allFMTSLeavesPerCommonSupport1[0][0][0][i]
2889             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2890             f.loadArraysIfNecessary()
2891             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2892             self.assertEqual(f.getName(),fieldName2)
2893             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2894             self.assertTrue(v.isEqual(vExp0[i],1e-12))
2895             #
2896             f=allFMTSLeavesPerCommonSupport1[0][0][1][i]
2897             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2898             f.loadArraysIfNecessary()
2899             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2900             self.assertEqual(f.getName(),fieldName1)
2901             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2902             vExp1[i].setInfoOnComponents(["Smth"])
2903             self.assertTrue(v.isEqual(vExp1[i],1e-12))
2904             pass
2905         ## Now same exercise but with a different load strategy. All is load directly.
2906         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
2907         fields=MEDFileFields(fname) # here all is read, the SauvReader (or other Reader) is emulated
2908         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2909         allFMTSLeavesToDisplay=[]
2910         for fields in fields_per_mesh:
2911             allFMTSLeavesToDisplay2=[]
2912             for fmts in fields:
2913                 tmp=fmts.splitDiscretizations()
2914                 for itmp in tmp:
2915                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
2916                     pass
2917                 allFMTSLeavesToDisplay2+=tmp
2918                 pass
2919             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2920             pass
2921         self.assertEqual(len(allFMTSLeavesToDisplay),1)
2922         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
2923         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2924         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
2925         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
2926         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
2927         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
2928         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),3)
2929         #
2930         mst=MEDFileMeshStruct.New(ms[0])
2931         #
2932         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
2933         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2934         mml2=mml.prepare()
2935         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2936         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2937         self.assertTrue(not ncc) # spaceDim 2 -> VTK wants 3D
2938         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))
2939         self.assertTrue(a1.isEqual(DataArrayByte([9,9])))
2940         self.assertTrue(a2.isEqual(DataArrayInt([0,5])))
2941         self.assertTrue(a3.isEqual(DataArrayInt([4,0,3,4,1,4,1,4,5,2])))
2942         self.assertTrue(a4 is None)
2943         self.assertTrue(a5 is None)
2944         a6,a7=mml2.retrieveFamilyIdsOnCells()
2945         self.assertTrue(a6.isEqual(DataArrayInt([0,0])))
2946         self.assertTrue(a7) # no copy here
2947         a8,a9=mml2.retrieveNumberIdsOnCells()
2948         self.assertTrue(a8.isEqual(DataArrayInt([0,1])))
2949         self.assertTrue(a9) # no copy here
2950         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
2951         for i in range(1, 2):
2952             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2953             pass
2954         vExp0=[DataArrayDouble([7.,11.]),DataArrayDouble([11.,7.])]
2955         vExp1=[DataArrayDouble([3.,5.,4.,6.]),DataArrayDouble([5.,3.,6.,4.])]
2956         for i in range(2):
2957             f=allFMTSLeavesPerCommonSupport1[0][0][0][i]
2958             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst) # no load needed here
2959             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2960             self.assertEqual(f.getName(),fieldName2)
2961             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2962             self.assertTrue(v.isEqual(vExp0[i],1e-12))
2963             #
2964             f=allFMTSLeavesPerCommonSupport1[0][0][1][i]
2965             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst) # no load needed here
2966             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2967             self.assertEqual(f.getName(),fieldName1)
2968             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2969             vExp1[i].setInfoOnComponents(["Smth"])
2970             self.assertTrue(v.isEqual(vExp1[i],1e-12))
2971             pass
2972         pass
2973
2974     @WriteInTmpDir
2975     def test19(self):
2976         """
2977         This test is a simple non profile CELL field but lying on cells of dimension -1 (not 0 as "usual").
2978         """
2979         fname="ForMEDReader19.med"
2980         fieldName="ACellFieldOnDimM1"
2981         coo=DataArrayDouble(3) ; coo.iota()
2982         m=MEDCouplingCMesh() ; m.setCoords(coo,coo,coo) ; m.setName("mesh")
2983         m0=m.buildUnstructured() ; del m
2984         m1=m0.computeSkin()
2985         #
2986         mm=MEDFileUMesh()
2987         mm.setMeshAtLevel(0,m0)
2988         mm.setMeshAtLevel(-1,m1)
2989         ff=MEDFileFieldMultiTS()
2990         # time 0
2991         t=(1.1,1,-1)
2992         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setTime(*t) ; f.setMesh(m1)
2993         f.setName(fieldName)
2994         arr=DataArrayDouble(24) ; arr.iota() ; arr.setInfoOnComponents(["AStr"])
2995         f.setArray(arr)
2996         f.checkConsistencyLight()
2997         f1ts=MEDFileField1TS() ; f1ts.setFieldNoProfileSBT(f)
2998         ff.pushBackTimeStep(f1ts)
2999         # time 1
3000         t=(2.1,2,-2)
3001         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setTime(*t) ; f.setMesh(m1)
3002         f.setName(fieldName)
3003         arr=DataArrayDouble(24) ; arr.iota() ; arr.reverse() ; arr.setInfoOnComponents(["AStr"])
3004         f.setArray(arr)
3005         f.checkConsistencyLight()
3006         f1ts=MEDFileField1TS() ; f1ts.setFieldNoProfileSBT(f)
3007         ff.pushBackTimeStep(f1ts)
3008         #
3009         mm.write(fname,2)
3010         ff.write(fname,0)
3011         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3012         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
3013         fields=MEDFileFields(fname,False)
3014         fields.removeFieldsWithoutAnyTimeStep()
3015         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3016         allFMTSLeavesToDisplay=[]
3017         for fields in fields_per_mesh:
3018             allFMTSLeavesToDisplay2=[]
3019             for fmts in fields:
3020                 tmp=fmts.splitDiscretizations()
3021                 for itmp in tmp:
3022                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
3023                     pass
3024                 allFMTSLeavesToDisplay2+=tmp
3025                 pass
3026             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3027             pass
3028         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3029         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
3030         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3031         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3032         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
3033         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3034         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
3035         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
3036         #
3037         mst=MEDFileMeshStruct.New(ms[0])
3038         #
3039         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
3040         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3041         mml2=mml.prepare()
3042         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3043         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3044         self.assertTrue(ncc)
3045         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))
3046         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])))
3047         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])))
3048         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])))
3049         self.assertTrue(a4 is None)
3050         self.assertTrue(a5 is None)
3051         a6,a7=mml2.retrieveFamilyIdsOnCells()
3052         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])))
3053         self.assertTrue(a7) # no copy here
3054         a8,a9=mml2.retrieveNumberIdsOnCells()
3055         self.assertTrue(a8 is None)
3056         self.assertTrue(a9) # no copy here
3057         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3058         self.assertTrue(not a10)
3059         self.assertTrue(a11) # no copy here
3060         a12,a13=mml2.retrieveNumberIdsOnNodes()
3061         self.assertTrue(not a12)
3062         self.assertTrue(a13) # no copy here
3063         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3064         for i in range(1, 2):
3065             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
3066             pass
3067         for i in range(2):
3068             f=allFMTSLeavesPerCommonSupport1[0][0][0][i]
3069             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3070             f.loadArraysIfNecessary()
3071             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3072             self.assertEqual(f.getName(),fieldName)
3073             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3074             vExp=DataArrayDouble(24) ; vExp.iota()
3075             if i==1: vExp.reverse()
3076             vExp.setInfoOnComponents(["AStr"])
3077             self.assertTrue(v.isEqual(vExp,1e-12))
3078             pass
3079         pass
3080
3081     @WriteInTmpDir
3082     def test20(self):
3083         """ This test works with groups/families on cells AND on nodes. Here 4 fields each on same time steps (2).
3084         1 field on CELLS without profile, 1 field on CELLS with profile, 1 field on NODES without profile, 1 field on NODES with profile.
3085         All of these 4 fields lies on a single mesh "mesh". The 2 fields on profile lies on a same support.
3086         One drawback of this test : no multi geom type. Coming soon !
3087         """
3088         fname="ForMEDReader20.med"
3089         fieldName0="ANodeField"
3090         fieldName1="ACellField"
3091         fieldName2="ANodeFieldPfl"
3092         fieldName3="ACellFieldPfl"
3093         pfl2=DataArrayInt([5,6,7,10,11,12,15,16,17,20,21,22]) ; pfl2.setName("pfl2")
3094         pfl3=DataArrayInt([4,5,8,9,12,13]) ; pfl3.setName("pfl3")
3095         #
3096         arr=DataArrayDouble(5) ; arr.iota()
3097         m=MEDCouplingCMesh("mesh") ; m.setCoords(arr,arr)
3098         m=m.buildUnstructured()
3099         mm=MEDFileUMesh()
3100         mm.setMeshAtLevel(0,m)
3101         fs=MEDFileFields()
3102         fmts0=MEDFileFieldMultiTS() ; fs.pushField(fmts0)
3103         fmts0.setDtUnit("s")
3104         fmts1=MEDFileFieldMultiTS() ; fs.pushField(fmts1)
3105         fmts1.setDtUnit("s")
3106         fmts2=MEDFileFieldMultiTS() ; fs.pushField(fmts2)
3107         fmts2.setDtUnit("s")
3108         fmts3=MEDFileFieldMultiTS() ; fs.pushField(fmts3)
3109         fmts3.setDtUnit("s")
3110         ####
3111         t=(1.1,0,-2)
3112         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m)
3113         f0.setName(fieldName0) ; f0.setTime(*t)
3114         da=m.getCoords().magnitude() ; da.setInfoOnComponents(["zeInfo"])
3115         f0.setArray(da)
3116         f0.checkConsistencyLight()
3117         f1ts=MEDFileField1TS()
3118         f1ts.setFieldNoProfileSBT(f0)
3119         fmts0.pushBackTimeStep(f1ts)
3120         #
3121         f1=MEDCouplingFieldDouble(ON_CELLS) ; f1.setMesh(m)
3122         f1.setName(fieldName1) ; f1.setTime(*t)
3123         da=m.computeCellCenterOfMass().magnitude() ; da.setInfoOnComponents(["zeInfoCell"])
3124         f1.setArray(da)
3125         f1.checkConsistencyLight()
3126         f1ts=MEDFileField1TS()
3127         f1ts.setFieldNoProfileSBT(f1)
3128         fmts1.pushBackTimeStep(f1ts)
3129         #
3130         f2=MEDCouplingFieldDouble(ON_NODES) ; mTmp=m[pfl3] ; mTmp.zipCoords() ; mTmp.setName(m.getName()) ; f2.setMesh(mTmp)
3131         f2.setName(fieldName2) ; f2.setTime(*t)
3132         da=m.getCoords().magnitude()[pfl2] ; da.setInfoOnComponents(["zzzz"])
3133         f2.setArray(da)
3134         f2.checkConsistencyLight()
3135         f1ts=MEDFileField1TS()
3136         f1ts.setFieldProfile(f2,mm,0,pfl2)
3137         fmts2.pushBackTimeStep(f1ts)
3138         #
3139         f3=MEDCouplingFieldDouble(ON_CELLS) ; mTmp=m[pfl3] ; mTmp.setName(m.getName()) ; f3.setMesh(mTmp)
3140         f3.setName(fieldName3) ; f3.setTime(*t)
3141         da=mTmp.computeCellCenterOfMass().magnitude() ; da.setInfoOnComponents(["abcdefg"])
3142         f3.setArray(da)
3143         f3.checkConsistencyLight()
3144         f1ts=MEDFileField1TS()
3145         f1ts.setFieldProfile(f3,mm,0,pfl3)
3146         fmts3.pushBackTimeStep(f1ts)
3147         ####
3148         t=(2.1,1,-3)
3149         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m)
3150         f0.setName(fieldName0) ; f0.setTime(*t)
3151         da=m.getCoords().magnitude() ; da.reverse() ; da.setInfoOnComponents(["zeInfo"])
3152         f0.setArray(da)
3153         f0.checkConsistencyLight()
3154         f1ts=MEDFileField1TS()
3155         f1ts.setFieldNoProfileSBT(f0)
3156         fmts0.pushBackTimeStep(f1ts)
3157         #
3158         f1=MEDCouplingFieldDouble(ON_CELLS) ; f1.setMesh(m)
3159         f1.setName(fieldName1) ; f1.setTime(*t)
3160         da=m.computeCellCenterOfMass().magnitude() ; da.reverse() ; da.setInfoOnComponents(["zeInfoCell"])
3161         f1.setArray(da)
3162         f1.checkConsistencyLight()
3163         f1ts=MEDFileField1TS()
3164         f1ts.setFieldNoProfileSBT(f1)
3165         fmts1.pushBackTimeStep(f1ts)
3166         #
3167         f2=MEDCouplingFieldDouble(ON_NODES) ; mTmp=m[pfl3] ; mTmp.zipCoords() ; mTmp.setName(m.getName()) ; f2.setMesh(mTmp)
3168         f2.setName(fieldName2) ; f2.setTime(*t)
3169         da=m.getCoords().magnitude()[pfl2] ; da.reverse() ; da.setInfoOnComponents(["zzzz"])
3170         f2.setArray(da)
3171         f2.checkConsistencyLight()
3172         f1ts=MEDFileField1TS()
3173         f1ts.setFieldProfile(f2,mm,0,pfl2)
3174         fmts2.pushBackTimeStep(f1ts)
3175         #
3176         f3=MEDCouplingFieldDouble(ON_CELLS) ; mTmp=m[pfl3] ; mTmp.setName(m.getName()) ; f3.setMesh(mTmp)
3177         f3.setName(fieldName3) ; f3.setTime(*t)
3178         da=mTmp.computeCellCenterOfMass().magnitude() ; da.reverse() ; da.setInfoOnComponents(["abcdefg"])
3179         f3.setArray(da)
3180         f3.checkConsistencyLight()
3181         f1ts=MEDFileField1TS()
3182         f1ts.setFieldProfile(f3,mm,0,pfl3)
3183         fmts3.pushBackTimeStep(f1ts)
3184         ####
3185         grp1=DataArrayInt([6,7,8,11,12,13,16,17,18]) ; grp1.setName("grp1")
3186         grp2=DataArrayInt([10,11,15,16,20,21]) ; grp2.setName("grp2")
3187         mm.setGroupsAtLevel(1,[grp1,grp2])
3188         grp3=DataArrayInt([4,5,6]) ; grp3.setName("grp3")
3189         grp4=DataArrayInt([8,9,10]) ; grp4.setName("grp4")
3190         mm.setGroupsAtLevel(0,[grp3,grp4])
3191         d=DataArrayInt(25) ; d.iota() ; d*=10 ;  mm.setRenumFieldArr(1,d)
3192         d=DataArrayInt(16) ; d.iota() ; d*=11 ;  mm.setRenumFieldArr(0,d)
3193         mm.write(fname,2)
3194         fs.appendGlobs(fmts2,1e-12)
3195         fs.appendGlobs(fmts3,1e-12)
3196         fs.write(fname,0)
3197         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3198         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
3199         fields=MEDFileFields(fname,False)
3200         fields.removeFieldsWithoutAnyTimeStep()
3201         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3202         allFMTSLeavesToDisplay=[]
3203         for fields in fields_per_mesh:
3204             allFMTSLeavesToDisplay2=[]
3205             for fmts in fields:
3206                 tmp=fmts.splitDiscretizations()
3207                 for itmp in tmp:
3208                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
3209                     pass
3210                 allFMTSLeavesToDisplay2+=tmp
3211                 pass
3212             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3213             pass
3214         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3215         self.assertEqual(len(allFMTSLeavesToDisplay[0]),4)
3216         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3217         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3218         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
3219         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3220         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),2)
3221         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),2)
3222         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),2)
3223         #
3224         mst=MEDFileMeshStruct.New(ms[0])
3225         #
3226         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
3227         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3228         mml2=mml.prepare()
3229         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3230         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3231         self.assertTrue(not ncc)
3232         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))
3233         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9])))
3234         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75])))
3235         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])))
3236         self.assertTrue(a4 is None)
3237         self.assertTrue(a5 is None)
3238         a6,a7=mml2.retrieveFamilyIdsOnCells()
3239         self.assertTrue(a6.isEqual(DataArrayInt([-5,-5,-5,-5,-6,-6,-6,-5,-7,-7,-7,-5,-5,-5,-5,-5])))
3240         self.assertTrue(a7) # no copy here
3241         a8,a9=mml2.retrieveNumberIdsOnCells()
3242         self.assertTrue(a8.isEqual(DataArrayInt([0,11,22,33,44,55,66,77,88,99,110,121,132,143,154,165])))
3243         self.assertTrue(a9) # no copy here
3244         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3245         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])))
3246         self.assertTrue(a11) # no copy here
3247         a12,a13=mml2.retrieveNumberIdsOnNodes()
3248         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])))
3249         self.assertTrue(a13) # no copy here
3250         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3251         for i in range(1, 2):
3252             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
3253             pass
3254         for i in range(2):
3255             f=allFMTSLeavesPerCommonSupport1[0][0][0][i]
3256             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3257             f.loadArraysIfNecessary()
3258             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3259             self.assertEqual(f.getName(),fieldName1)
3260             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3261             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])
3262             if i==1: vExp.reverse()
3263             vExp.setInfoOnComponents(["zeInfoCell"])
3264             self.assertTrue(v.isEqual(vExp,1e-12))
3265             #
3266             f=allFMTSLeavesPerCommonSupport1[0][0][1][i]
3267             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3268             f.loadArraysIfNecessary()
3269             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3270             self.assertEqual(f.getName(),fieldName0)
3271             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3272             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])
3273             if i==1: vExp.reverse()
3274             vExp.setInfoOnComponents(["zeInfo"])
3275             self.assertTrue(v.isEqual(vExp,1e-12))
3276             pass
3277         ### Testing the 2nd support
3278         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
3279         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3280         mml2=mml.prepare()
3281         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3282         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3283         self.assertTrue(not ncc)
3284         self.assertTrue(not ncc)
3285         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))
3286         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9])))
3287         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25])))
3288         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])))
3289         self.assertTrue(a4 is None)
3290         self.assertTrue(a5 is None)
3291         a6,a7=mml2.retrieveFamilyIdsOnCells()
3292         self.assertTrue(a6.isEqual(DataArrayInt([-6,-6,-7,-7,-5,-5])))
3293         self.assertTrue(not a7) # copy here
3294         a8,a9=mml2.retrieveNumberIdsOnCells()
3295         self.assertTrue(a8.isEqual(DataArrayInt([44,55,88,99,132,143])))
3296         self.assertTrue(not a9) # copy here
3297         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3298         self.assertTrue(a10.isEqual(DataArrayInt([1,2,2,3,4,2,3,4,2,3,3,1])))
3299         self.assertTrue(not a11) # copy here
3300         a12,a13=mml2.retrieveNumberIdsOnNodes()
3301         self.assertTrue(a12.isEqual(DataArrayInt([50,60,70,100,110,120,150,160,170,200,210,220])))
3302         self.assertTrue(not a13) # copy here
3303         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3304         for i in range(2):
3305             f=allFMTSLeavesPerCommonSupport1[1][0][0][i]
3306             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3307             f.loadArraysIfNecessary()
3308             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3309             self.assertEqual(f.getName(),fieldName3)
3310             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3311             vExp=DataArrayDouble([1.5811388300842,2.1213203435596,2.5495097567964,2.9154759474227,3.5355339059327,3.807886552932])
3312             if i==1: vExp.reverse()
3313             vExp.setInfoOnComponents(["abcdefg"])
3314             self.assertTrue(v.isEqual(vExp,1e-12))
3315             #
3316             f=allFMTSLeavesPerCommonSupport1[1][0][1][i]
3317             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3318             f.loadArraysIfNecessary()
3319             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3320             self.assertEqual(f.getName(),fieldName2)
3321             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3322             vExp=DataArrayDouble([1.,1.4142135623731,2.2360679774998,2.,2.2360679774998,2.8284271247462,3.,3.1622776601684,3.605551275464,4.,4.1231056256177,4.4721359549996])
3323             if i==1: vExp.reverse()
3324             vExp.setInfoOnComponents(["zzzz"])
3325             self.assertTrue(v.isEqual(vExp,1e-12))
3326             pass
3327         pass
3328
3329     @WriteInTmpDir
3330     def test21(self):
3331         """ Here the created MED file contains only a mesh. The aim here is to test capability of MEDReader to support no fields.
3332         This test checks nothing but write a MED file to be used by MEDReader tests.
3333         """
3334         fname="ForMEDReader21.med"
3335         mm=MEDFileUMesh()
3336         #
3337         m0=MEDCouplingCMesh("mesh") ; arr=DataArrayDouble(5) ; arr.iota() ; m0.setCoords(arr,arr) ; m0=m0.buildUnstructured()
3338         mm.setMeshAtLevel(0,m0)
3339         grp0=DataArrayInt([5,6,9,10]) ; grp0.setName("Inside2D")
3340         grp1=DataArrayInt([0,1,2,3,4,7,8,11,12,13,14,15]) ; grp1.setName("Border2D")
3341         grp2=DataArrayInt([2,3,6,7]) ; grp2.setName("LowerRight2D")
3342         mm.setGroupsAtLevel(0,[grp0,grp1,grp2])
3343         #
3344         m1=MEDCouplingUMesh(m0.getName(),1) ; m1.setCoords(m0.getCoords()) ; m1.allocateCells()
3345         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],
3346                     [10,11],[11,12],[12,13],[13,14]]:
3347             m1.insertNextCell(NORM_SEG2,elt)
3348             pass
3349         mm.setMeshAtLevel(-1,m1)
3350         grp4=DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]) ; grp4.setName("Border1D")
3351         grp5=DataArrayInt([16,17,18,19,20,21,22,23]) ; grp5.setName("Inside1D")
3352         grp6=DataArrayInt([18,19,22,23]) ; grp6.setName("UpperRight1D")
3353         mm.setGroupsAtLevel(-1,[grp4,grp5,grp6])
3354         #
3355         grp7=DataArrayInt([1,2,3,6,7,8,11,12,13,16,17,18,21,22,23]) ; grp7.setName("InsideYNode")
3356         grp8=DataArrayInt([5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]) ; grp8.setName("InsideXNode")
3357         mm.setGroupsAtLevel(1,[grp7,grp8])
3358         #
3359         mm.write(fname,2)
3360         pass
3361
3362     @WriteInTmpDir
3363     def test22(self):
3364         """ Use case where a field on nodes (ANodeField) on a mesh defined both in meshdim 2 and meshdim 1.
3365         The only possible geometrical support that suits the field is those with meshdim equal to 1 (-1 in relative).
3366         """
3367         fname="ForMEDReader22.med"
3368         fieldName0="ANodeField"
3369         mm=MEDFileUMesh()
3370         coo=DataArrayDouble([(4.,3.),(7.,3.),(2.,5.),(6.,5.),(9.,5.),(4.,7.),(8.,7.),(3.,8.),(9.,8.)])
3371         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])
3372         mm.setMeshAtLevel(0,m0)
3373         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])
3374         m1.insertNextCell(NORM_SEG2,[3,5]) ; m1.insertNextCell(NORM_SEG2,[5,7]) ; m1.insertNextCell(NORM_SEG2,[3,6]) ; m1.insertNextCell(NORM_SEG2,[6,8])
3375         mm.setMeshAtLevel(-1,m1)
3376         fs=MEDFileFields()
3377         fmts0=MEDFileFieldMultiTS() ; fs.pushField(fmts0)
3378         fmts0.setDtUnit("s")
3379         #
3380         t=(1.1,0,-2)
3381         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m1)
3382         f0.setName(fieldName0) ; f0.setTime(*t)
3383         da=DataArrayDouble(9) ; da.iota() ; da.setInfoOnComponents(["zeInfo"])
3384         f0.setArray(da)
3385         f0.checkConsistencyLight()
3386         f1ts=MEDFileField1TS()
3387         f1ts.setFieldNoProfileSBT(f0)
3388         fmts0.pushBackTimeStep(f1ts)
3389         #
3390         t=(2.1,1,-3)
3391         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m1)
3392         f0.setName(fieldName0) ; f0.setTime(*t)
3393         da=DataArrayDouble(9) ; da.iota() ; da.reverse() ; da.setInfoOnComponents(["zeInfo"])
3394         f0.setArray(da)
3395         f0.checkConsistencyLight()
3396         f1ts=MEDFileField1TS()
3397         f1ts.setFieldNoProfileSBT(f0)
3398         fmts0.pushBackTimeStep(f1ts)
3399         #
3400         mm.write(fname,2)
3401         fs.write(fname,0)
3402         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3403         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
3404         fields=MEDFileFields(fname,False)
3405         fields.removeFieldsWithoutAnyTimeStep()
3406         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3407         allFMTSLeavesToDisplay=[]
3408         for fields in fields_per_mesh:
3409             allFMTSLeavesToDisplay2=[]
3410             for fmts in fields:
3411                 tmp=fmts.splitDiscretizations()
3412                 for itmp in tmp:
3413                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
3414                     pass
3415                 allFMTSLeavesToDisplay2+=tmp
3416                 pass
3417             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3418             pass
3419         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3420         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
3421         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3422         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3423         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
3424         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3425         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
3426         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
3427         #
3428         mst=MEDFileMeshStruct.New(ms[0])
3429         #
3430         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
3431         self.assertEqual([NORM_TRI3,NORM_SEG2],fcscp.getGeoTypesAt(0,ms[0]))#contains all cell types of underlying mesh because only nodes with no profiles
3432         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3433         mml2=mml.prepare()
3434         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3435         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3436         self.assertTrue(not ncc)
3437         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))
3438         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5,3,3,3,3,3,3,3])))
3439         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,12,15,18,21,24,27,30])))
3440         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])))
3441         self.assertTrue(a4 is None)
3442         self.assertTrue(a5 is None)
3443         a6,a7=mml2.retrieveFamilyIdsOnCells()
3444         self.assertTrue(a6.isEqual(DataArrayInt([0,0,0,0,0,0,0,0,0,0])))
3445         self.assertTrue(not a7) # copy here
3446         a8,a9=mml2.retrieveNumberIdsOnCells()
3447         self.assertTrue(not a8)
3448         self.assertTrue(a9) # nocopy here
3449         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3450         self.assertTrue(not a10)
3451         self.assertTrue(a11) # no copy here
3452         a12,a13=mml2.retrieveNumberIdsOnNodes()
3453         self.assertTrue(not a12)
3454         self.assertTrue(a13) # no copy here
3455         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3456         #
3457         f=allFMTSLeavesPerCommonSupport1[0][0][0][0]
3458         fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3459         f.loadArraysIfNecessary()
3460         v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3461         self.assertEqual(f.getName(),fieldName0)
3462         self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3463         vExp=DataArrayDouble(9) ; vExp.iota() ; vExp.setInfoOnComponents(["zeInfo"])
3464         self.assertTrue(v.isEqual(vExp,1e-12))
3465         #
3466         f=allFMTSLeavesPerCommonSupport1[0][0][0][1]
3467         fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3468         f.loadArraysIfNecessary()
3469         v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3470         self.assertEqual(f.getName(),fieldName0)
3471         self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3472         vExp=DataArrayDouble(9) ; vExp.iota() ; vExp.setInfoOnComponents(["zeInfo"]) ; vExp.reverse()
3473         self.assertTrue(v.isEqual(vExp,1e-12))
3474         pass
3475
3476     @WriteInTmpDir
3477     def test23(self):
3478         """ Non regression test 2219 of modes. Idem than test22 except that here the node field is on profile.
3479         """
3480         fname="ForMEDReader23.med"
3481         fieldName0="ANodeField"
3482         mm=MEDFileUMesh()
3483         coo=DataArrayDouble([(4.,3.),(7.,3.),(2.,5.),(6.,5.),(9.,5.),(4.,7.),(8.,7.),(3.,8.),(9.,8.)])
3484         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])
3485         mm.setMeshAtLevel(0,m0)
3486         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])
3487         m1.insertNextCell(NORM_SEG2,[3,5]) ; m1.insertNextCell(NORM_SEG2,[5,7]) ; m1.insertNextCell(NORM_SEG2,[3,6]) ; m1.insertNextCell(NORM_SEG2,[6,8])
3488         mm.setMeshAtLevel(-1,m1)
3489         fmts0=MEDFileFieldMultiTS()
3490         fmts0.setDtUnit("s")
3491         #
3492         pfl=DataArrayInt([0,1,2,4]) ; pfl.setName("pfl")
3493         pflCell=DataArrayInt([0,1,2]) ; m1Part=m1[pflCell] ; m1Part.zipCoords()
3494         #
3495         t=(1.1,0,-2)
3496         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m1Part)
3497         f0.setName(fieldName0) ; f0.setTime(*t)
3498         da=DataArrayDouble(4) ; da.iota() ; da.setInfoOnComponents(["zeInfo"])
3499         f0.setArray(da)
3500         f0.checkConsistencyLight()
3501         f1ts=MEDFileField1TS()
3502         f1ts.setFieldProfile(f0,mm,-1,pfl)
3503         fmts0.pushBackTimeStep(f1ts)
3504         #
3505         t=(2.1,1,-3)
3506         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m1Part)
3507         f0.setName(fieldName0) ; f0.setTime(*t)
3508         da=DataArrayDouble(4) ; da.iota() ; da.reverse() ; da.setInfoOnComponents(["zeInfo"])
3509         f0.setArray(da)
3510         f0.checkConsistencyLight()
3511         f1ts=MEDFileField1TS()
3512         f1ts.setFieldProfile(f0,mm,-1,pfl)
3513         fmts0.pushBackTimeStep(f1ts)
3514         mm.write(fname,2)
3515         fmts0.write(fname,0)
3516         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3517         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
3518         fields=MEDFileFields(fname,False)
3519         fields.removeFieldsWithoutAnyTimeStep()
3520         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3521         allFMTSLeavesToDisplay=[]
3522         for fields in fields_per_mesh:
3523             allFMTSLeavesToDisplay2=[]
3524             for fmts in fields:
3525                 tmp=fmts.splitDiscretizations()
3526                 for itmp in tmp:
3527                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
3528                     pass
3529                 allFMTSLeavesToDisplay2+=tmp
3530                 pass
3531             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3532             pass
3533         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3534         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
3535         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3536         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3537         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
3538         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3539         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
3540         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
3541         #
3542         mst=MEDFileMeshStruct.New(ms[0])
3543         #
3544         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
3545         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3546         mml2=mml.prepare()
3547         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3548         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3549         self.assertTrue(not ncc)
3550         self.assertTrue(a0.isEqual(DataArrayDouble([(4.,3.,0.),(7.,3.,0.),(2.,5.,0.),(9.,5.,0.)]),1e-12))
3551         self.assertTrue(a1.isEqual(DataArrayByte([3,3,3])))
3552         self.assertTrue(a2.isEqual(DataArrayInt([0,3,6])))
3553         self.assertTrue(a3.isEqual(DataArrayInt([2,2,0,2,0,1,2,1,3])))
3554         self.assertTrue(a4 is None)
3555         self.assertTrue(a5 is None)
3556         a6,a7=mml2.retrieveFamilyIdsOnCells()
3557         self.assertTrue(a6.isEqual(DataArrayInt([0,0,0])))
3558         self.assertTrue(not a7) # copy here
3559         a8,a9=mml2.retrieveNumberIdsOnCells()
3560         self.assertTrue(not a8)
3561         self.assertTrue(a9) # nocopy here
3562         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3563         self.assertTrue(not a10)
3564         self.assertTrue(a11) # no copy here
3565         a12,a13=mml2.retrieveNumberIdsOnNodes()
3566         self.assertTrue(not a12)
3567         self.assertTrue(a13) # no copy here
3568         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3569         #
3570         f=allFMTSLeavesPerCommonSupport1[0][0][0][0]
3571         fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3572         f.loadArraysIfNecessary()
3573         v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3574         self.assertEqual(f.getName(),fieldName0)
3575         vExp=DataArrayDouble(4) ; vExp.iota() ; vExp.setInfoOnComponents(["zeInfo"])
3576         self.assertTrue(v.isEqual(vExp,1e-12))
3577         #
3578         f=allFMTSLeavesPerCommonSupport1[0][0][0][1]
3579         fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3580         f.loadArraysIfNecessary()
3581         v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3582         self.assertEqual(f.getName(),fieldName0)
3583         vExp=DataArrayDouble(4) ; vExp.iota() ; vExp.setInfoOnComponents(["zeInfo"]) ; vExp.reverse()
3584         self.assertTrue(v.isEqual(vExp,1e-12))
3585         pass
3586
3587     @WriteInTmpDir
3588     def test24(self):
3589         """ Non regression test for cartesian mesh whose the 3rd direction has only one node. It a false 3D mesh.
3590         """
3591         fname="ForMEDReader24.med"
3592         fieldName0="zeFieldNode"
3593         cmesh=MEDCouplingCMesh("mesh")
3594         arr0=DataArrayDouble([0.,1.1,2.2,3.3,4.4])
3595         arr1=DataArrayDouble([0.,1.4,2.3])
3596         arr2=DataArrayDouble([5.])
3597         cmesh.setCoords(arr0,arr1,arr2)
3598         fmts0=MEDFileFieldMultiTS()
3599         fmts0.setDtUnit("s")
3600         #
3601         t=(1.1,2,3)
3602         f=MEDCouplingFieldDouble(ON_NODES) ; f.setName(fieldName0)
3603         f.setMesh(cmesh)
3604         arr=DataArrayDouble(15) ; arr.setInfoOnComponents(["tutu"]) ; arr.iota()
3605         f.setArray(arr)
3606         f.setTime(*t)
3607         f1ts=MEDFileField1TS()
3608         f1ts.setFieldNoProfileSBT(f)
3609         fmts0.pushBackTimeStep(f1ts)
3610         #
3611         t=(3.3,4,5)
3612         arr=DataArrayDouble(15) ; arr.setInfoOnComponents(["tutu"]) ; arr.iota()
3613         arr.reverse()
3614         f.setArray(arr)
3615         f.setTime(*t)
3616         f1ts=MEDFileField1TS()
3617         f1ts.setFieldNoProfileSBT(f)
3618         fmts0.pushBackTimeStep(f1ts)
3619         #
3620         mm=MEDFileCMesh() ; mm.setMesh(cmesh)
3621         mm.write(fname,2)
3622         fmts0.write(fname,0)
3623         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3624         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
3625         fields=MEDFileFields(fname,False)
3626         fields.removeFieldsWithoutAnyTimeStep()
3627         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3628         allFMTSLeavesToDisplay=[]
3629         for fields in fields_per_mesh:
3630             allFMTSLeavesToDisplay2=[]
3631             for fmts in fields:
3632                 tmp=fmts.splitDiscretizations()
3633                 for itmp in tmp:
3634                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
3635                     pass
3636                 allFMTSLeavesToDisplay2+=tmp
3637                 pass
3638             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3639             pass
3640         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3641         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
3642         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3643         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3644         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
3645         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3646         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
3647         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),1)
3648         #
3649         mst=MEDFileMeshStruct.New(ms[0])
3650         #
3651         fcscp=allFMTSLeavesPerCommonSupport[0][1]
3652         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3653         mml2=mml.prepare()
3654         self.assertTrue(isinstance(mml2,MEDCMeshMultiLev))
3655         (a,b,c),d=mml2.buildVTUArrays()
3656         self.assertTrue(d)#d is True because the a,b and c are directly those in the internal data structure
3657         self.assertTrue(a.isEqual(arr0,1e-12))
3658         self.assertTrue(b.isEqual(arr1,1e-12))
3659         self.assertTrue(c.isEqual(arr2,1e-12))
3660         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3661         for i in range(2):
3662             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
3663             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3664             f.loadArraysIfNecessary()
3665             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3666             self.assertEqual(f.getName(),fieldName0)
3667             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3668             vExp=DataArrayDouble(15) ; vExp.iota(0) ; vExp.setInfoOnComponents(["tutu"])
3669             if i==1:
3670                 vExp.reverse()
3671                 pass
3672             self.assertTrue(v.isEqual(vExp,1e-12))
3673             pass
3674         pass
3675
3676     @WriteInTmpDir
3677     def test25(self):
3678         """ A tricky test that reproduces an invalid behaviour
3679         Here a same field is defined both on CELLS and GAUSS_PT, with a profile for each.
3680         The problem appears on array computation when performing CELLS then GAUSS_PT and CELLS again.
3681         """
3682         fname="ForMEDReader25.med"
3683         m=MEDFileUMesh()
3684         coords=DataArrayDouble([0.,0.,1.,0.,2.,0.,0.,1.,1.,1.,2.,1.,0.,2.,1.,2.,2.,2.,0.,3.,1.,3.,2.,3.,1.,4.,1.,5.,1.,6.],15,2)
3685         m0=MEDCouplingUMesh("mesh",2) ; m0.setCoords(coords)
3686         m0.allocateCells()
3687         m0.insertNextCell(NORM_QUAD4,[0,3,4,1])
3688         m0.insertNextCell(NORM_QUAD4,[1,4,5,2])
3689         m0.insertNextCell(NORM_QUAD4,[3,6,7,4])
3690         m0.insertNextCell(NORM_QUAD4,[4,7,8,5])
3691         m0.insertNextCell(NORM_QUAD4,[6,9,10,7])
3692         m0.insertNextCell(NORM_QUAD4,[7,10,11,8])
3693         m.setMeshAtLevel(0,m0)
3694         m1=MEDCouplingUMesh("mesh",1) ; m1.setCoords(coords)
3695         m1.allocateCells()
3696         m1.insertNextCell(NORM_SEG2,[10,12])
3697         m1.insertNextCell(NORM_SEG2,[12,13])
3698         m1.insertNextCell(NORM_SEG2,[13,14])
3699         m.setMeshAtLevel(-1,m1)
3700         m.setFamilyFieldArr(0,DataArrayInt([-1,-2,-3,-4,-5,-6]))
3701         m.setFamilyFieldArr(-1,DataArrayInt([-7,-8,-9]))
3702         m.setFamilyFieldArr(1,DataArrayInt([3,4,5,6,7,8,9,10,11,12,13,14,15,16,17]))
3703         m.setRenumFieldArr(0,DataArrayInt([101,102,103,104,105,106]))
3704         m.setRenumFieldArr(-1,DataArrayInt([107,108,109]))
3705         m.setRenumFieldArr(1,DataArrayInt([203,204,205,206,207,208,209,210,211,212,213,214,215,216,217]))
3706         #
3707         fmts=MEDFileFieldMultiTS()
3708         info0=["aa","bbb"]
3709         name0="zeField"
3710         pflName0="pfl"
3711         pflName1="pfl2"
3712         #
3713         f1ts=MEDFileField1TS()
3714         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setName(name0)
3715         arr=DataArrayDouble([(-1,-11),(-2,-22)]) ; arr.setInfoOnComponents(info0)
3716         f.setArray(arr)
3717         pfl0=DataArrayInt([0,1]) ; pfl0.setName(pflName0)
3718         f1ts.setFieldProfile(f,m,-1,pfl0)
3719         del f
3720         f2=MEDCouplingFieldDouble(ON_GAUSS_PT) ; f2.setName(name0)
3721         arr=DataArrayDouble(15) ; arr.iota(1)
3722         arr=DataArrayDouble.Meld(arr,arr+10) ; arr.setInfoOnComponents(info0)
3723         f2.setArray(arr)
3724         pfl1=DataArrayInt([1,3,5]) ; pfl1.setName(pflName1)
3725         tmp=m0[pfl1] ; f2.setMesh(tmp)
3726         f2.setGaussLocalizationOnType(NORM_QUAD4,[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[-0.5,-0.5,0.5,-0.5,0.5,0.5,-0.5,0.5,0.,0.],[0.1,0.1,0.1,0.1,0.6])
3727         f2.checkConsistencyLight()
3728         f1ts.setFieldProfile(f2,m,0,pfl1)
3729         fmts.pushBackTimeStep(f1ts)
3730         #
3731         m.write(fname,2)
3732         fmts.write(fname,0)
3733         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3734         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
3735         fields=MEDFileFields(fname,False) # false is absolutely necessary for the test
3736         fields.removeFieldsWithoutAnyTimeStep()
3737         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3738         allFMTSLeavesToDisplay=[]
3739         for fields in fields_per_mesh:
3740             allFMTSLeavesToDisplay2=[]
3741             for fmts in fields:
3742                 tmp=fmts.splitDiscretizations()
3743                 for itmp in tmp:
3744                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
3745                     pass
3746                 allFMTSLeavesToDisplay2+=tmp
3747                 pass
3748             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3749             pass
3750         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3751         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
3752         ### here the test is important !!! Pointers must be different !
3753         self.assertTrue(allFMTSLeavesToDisplay[0][0][0].getUndergroundDataArray().getHiddenCppPointer()!=allFMTSLeavesToDisplay[0][1][0].getUndergroundDataArray().getHiddenCppPointer())
3754         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3755         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3756         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
3757         ### here the test is important !!! Pointers must be different !
3758         self.assertTrue(allFMTSLeavesToDisplay[0][0][0].getUndergroundDataArray().getHiddenCppPointer()!=allFMTSLeavesToDisplay[0][1][0].getUndergroundDataArray().getHiddenCppPointer())
3759         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3760         self.assertTrue(allFMTSLeavesToDisplay[0][0][0].getUndergroundDataArray().getHiddenCppPointer()!=allFMTSLeavesToDisplay[0][1][0].getUndergroundDataArray().getHiddenCppPointer())
3761         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),2)
3762         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
3763         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),1)
3764         #
3765         mst=MEDFileMeshStruct.New(ms[0])
3766         # emulate first click
3767         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
3768         self.assertEqual([NORM_SEG2],fcscp.getGeoTypesAt(0,ms[0]))
3769         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3770         mml2=mml.prepare()
3771         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3772         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3773         self.assertTrue(not ncc) # copy here because 2D -> 3D
3774         expCoords=coords.changeNbOfComponents(3,0.)
3775         self.assertTrue(a0.isEqual(expCoords,1e-12))
3776         self.assertTrue(a1.isEqual(DataArrayByte([3,3])))
3777         self.assertTrue(a2.isEqual(DataArrayInt([0,3])))
3778         self.assertTrue(a3.isEqual(DataArrayInt([2,10,12,2,12,13])))
3779         self.assertTrue(a4 is None)
3780         self.assertTrue(a5 is None)
3781         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3782         a6,a7=mml2.retrieveFamilyIdsOnCells()
3783         self.assertTrue(a6.isEqual(DataArrayInt([-7,-8])))
3784         self.assertTrue(not a7) # copy here because profile on cells
3785         a8,a9=mml2.retrieveNumberIdsOnCells()
3786         self.assertTrue(a8.isEqual(DataArrayInt([107,108])))
3787         self.assertTrue(not a9) # copy here because profile on cells
3788         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3789         self.assertTrue(a10.isEqual(DataArrayInt([3,4,5,6,7,8,9,10,11,12,13,14,15,16,17])))
3790         self.assertTrue(a11) # no copy here
3791         a12,a13=mml2.retrieveNumberIdsOnNodes()
3792         self.assertTrue(a12.isEqual(DataArrayInt([203,204,205,206,207,208,209,210,211,212,213,214,215,216,217])))
3793         self.assertTrue(a13) # no copy here
3794         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3795         fff0=allFMTSLeavesPerCommonSupport1[0][0][0][0]
3796         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff0,mst)
3797         fff0.loadArraysIfNecessary()
3798         self.assertEqual([ON_CELLS],fff0.getTypesOfFieldAvailable())
3799         v=mml.buildDataArray(fsst,fields,fff0.getUndergroundDataArray())
3800         self.assertEqual(fff0.getName(),name0)
3801         self.assertEqual(v.getHiddenCppPointer(),fff0.getUndergroundDataArray().getHiddenCppPointer())
3802         vExp=DataArrayDouble([(-1,-11),(-2,-22)]) ; vExp.setInfoOnComponents(info0)
3803         self.assertTrue(v.isEqual(vExp,1e-12))
3804         del fff0
3805         # emulate second click
3806         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
3807         self.assertEqual([NORM_QUAD4],fcscp.getGeoTypesAt(0,ms[0]))
3808         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3809         mml2=mml.prepare()
3810         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3811         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3812         self.assertTrue(not ncc) # copy here because 2D -> 3D
3813         expCoords=coords.changeNbOfComponents(3,0.)
3814         self.assertTrue(a0.isEqual(expCoords,1e-12))
3815         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9])))
3816         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10])))
3817         self.assertTrue(a3.isEqual(DataArrayInt([4,1,4,5,2,4,4,7,8,5,4,7,10,11,8])))
3818         self.assertTrue(a4 is None)
3819         self.assertTrue(a5 is None)
3820         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3821         a6,a7=mml2.retrieveFamilyIdsOnCells()
3822         self.assertTrue(a6.isEqual(DataArrayInt([-2,-4,-6])))
3823         self.assertTrue(not a7) # copy here because profile on cells
3824         a8,a9=mml2.retrieveNumberIdsOnCells()
3825         self.assertTrue(a8.isEqual(DataArrayInt([102,104,106])))
3826         self.assertTrue(not a9) # copy here because profile on cells
3827         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3828         self.assertTrue(a10.isEqual(DataArrayInt([3,4,5,6,7,8,9,10,11,12,13,14,15,16,17])))
3829         self.assertTrue(a11) # no copy here
3830         a12,a13=mml2.retrieveNumberIdsOnNodes()
3831         self.assertTrue(a12.isEqual(DataArrayInt([203,204,205,206,207,208,209,210,211,212,213,214,215,216,217])))
3832         self.assertTrue(a13) # no copy here
3833         fff1=allFMTSLeavesPerCommonSupport1[1][0][0][0]
3834         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff1,mst)
3835         fff1.loadArraysIfNecessary()
3836         self.assertEqual([ON_GAUSS_PT],fff1.getTypesOfFieldAvailable())
3837         v=mml.buildDataArray(fsst,fields,fff1.getUndergroundDataArray())
3838         self.assertEqual(fff1.getName(),name0)
3839         self.assertEqual(v.getHiddenCppPointer(),fff1.getUndergroundDataArray().getHiddenCppPointer())
3840         vExp=DataArrayDouble([1.,11.,2.,12.,3.,13.,4.,14.,5.,15.,6.,16.,7.,17.,8.,18.,9.,19.,10.,20.,11.,21.,12.,22.,13.,23.,14.,24.,15.,25.],15,2) ; vExp.setInfoOnComponents(info0)
3841         self.assertTrue(v.isEqual(vExp,1e-12))
3842         # emulate third click
3843         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
3844         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3845         mml2=mml.prepare()
3846         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3847         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3848         self.assertTrue(not ncc) # copy here because 2D -> 3D
3849         expCoords=coords.changeNbOfComponents(3,0.)
3850         self.assertTrue(a0.isEqual(expCoords,1e-12))
3851         self.assertTrue(a1.isEqual(DataArrayByte([3,3])))
3852         self.assertTrue(a2.isEqual(DataArrayInt([0,3])))
3853         self.assertTrue(a3.isEqual(DataArrayInt([2,10,12,2,12,13])))
3854         self.assertTrue(a4 is None)
3855         self.assertTrue(a5 is None)
3856         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3857         a6,a7=mml2.retrieveFamilyIdsOnCells()
3858         self.assertTrue(a6.isEqual(DataArrayInt([-7,-8])))
3859         self.assertTrue(not a7) # copy here because profile on cells
3860         a8,a9=mml2.retrieveNumberIdsOnCells()
3861         self.assertTrue(a8.isEqual(DataArrayInt([107,108])))
3862         self.assertTrue(not a9) # copy here because profile on cells
3863         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3864         self.assertTrue(a10.isEqual(DataArrayInt([3,4,5,6,7,8,9,10,11,12,13,14,15,16,17])))
3865         self.assertTrue(a11) # no copy here
3866         a12,a13=mml2.retrieveNumberIdsOnNodes()
3867         self.assertTrue(a12.isEqual(DataArrayInt([203,204,205,206,207,208,209,210,211,212,213,214,215,216,217])))
3868         self.assertTrue(a13) # no copy here
3869         fff0=allFMTSLeavesPerCommonSupport1[0][0][0][0]
3870         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff0,mst)
3871         fff0.loadArraysIfNecessary()
3872         self.assertEqual([ON_CELLS],fff0.getTypesOfFieldAvailable())
3873         v=mml.buildDataArray(fsst,fields,fff0.getUndergroundDataArray())
3874         self.assertEqual(fff0.getName(),name0)
3875         self.assertEqual(v.getHiddenCppPointer(),fff0.getUndergroundDataArray().getHiddenCppPointer())
3876         vExp=DataArrayDouble([(-1,-11),(-2,-22)]) ; vExp.setInfoOnComponents(info0)
3877         self.assertTrue(v.isEqual(vExp,1e-12)) # <- THE test is here !!!
3878         del fff0
3879         pass
3880
3881     @WriteInTmpDir
3882     def test26(self):
3883         """ Test focused on field on nodes (here f0Node and f1Node) lying on a profile of nodes that do not match perfectly a sub set of cells of its underlying mesh. See bug EDF 2405 and 2177.
3884         For this type of fields the support will contain only vertices.
3885         """
3886         fname="ForMEDReader26.med"
3887         coords=DataArrayDouble([(0.,0.,0.),(1.,0.,0.),(2.,0.,0.),(3.,0.,0.),(0.,1.,0.),(1.,1.,0.),(2.,1.,0.),(3.,1.,0.),(0.,2.,0.),(1.,2.,0.),(2.,2.,0.),(3.,2.,0.),(0.,3.,0.),(1.,3.,0.),(2.,3.,0.),(3.,3.,0.)])
3888         m0=MEDCouplingUMesh("mesh",2)
3889         m0.allocateCells()
3890         for elt in [[2,6,3],[6,7,3],[9,6,5],[9,10,6]]:
3891             m0.insertNextCell(NORM_TRI3,elt)
3892             pass
3893         for elt in [[0,4,5,1],[1,5,6,2],[4,8,9,5],[6,10,11,7],[8,12,13,9],[9,13,14,10],[10,14,15,11]]:
3894             m0.insertNextCell(NORM_QUAD4,elt)
3895             pass
3896         m0.setCoords(coords)
3897         ##
3898         mm=MEDFileUMesh()
3899         mm.setMeshAtLevel(0,m0)
3900         mm.setFamilyFieldArr(0,DataArrayInt([-1,-2,-3,-4,-5,-6,-7,-8,-9,-10,-11]))
3901         mm.setFamilyFieldArr(1,DataArrayInt([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]))
3902         #
3903         f1ts0Node=MEDFileField1TS()
3904         f1ts1Node=MEDFileField1TS()
3905         f1ts2Cell=MEDFileField1TS()
3906         f1ts3Cell=MEDFileField1TS()
3907         f1ts4Cell=MEDFileField1TS()
3908         f1ts5Node=MEDFileField1TS()
3909         #
3910         pfl0=DataArrayInt([4,5,6,8,9,12]) ; pfl0.setName("pfl0")
3911         pfl1=DataArrayInt([0,1,4,5,7,10]) ; pfl1.setName("pfl1")
3912         pfl2=DataArrayInt([0,1,2,3,4,5,6,7,10,11,14,15]) ; pfl2.setName("pfl2")
3913         #
3914         f0Node=MEDCouplingFieldDouble(ON_NODES) ; f0Node.setName("f0Node")
3915         arr0=DataArrayDouble(6) ; arr0.iota()
3916         f0Node.setArray(arr0)
3917         f1ts0Node.setFieldProfile(f0Node,mm,0,pfl0)
3918         #
3919         f1Node=MEDCouplingFieldDouble(ON_NODES) ; f1Node.setName("f1Node")
3920         arr1=DataArrayDouble(6) ; arr1.iota() ; arr1.reverse()
3921         f1Node.setArray(arr1)
3922         f1ts1Node.setFieldProfile(f1Node,mm,0,pfl0)
3923         #
3924         f2Cell=MEDCouplingFieldDouble(ON_CELLS) ; f2Cell.setName("f2Cell")
3925         arr2=DataArrayDouble([2,3,0,1,4,5])
3926         f2Cell.setArray(arr2)
3927         f1ts2Cell.setFieldProfile(f2Cell,mm,0,pfl1)
3928         #
3929         f3Cell=MEDCouplingFieldDouble(ON_CELLS) ; f3Cell.setName("f3Cell")
3930         arr3=DataArrayDouble([5,4,3,2,1,0])
3931         f3Cell.setArray(arr3)
3932         f1ts3Cell.setFieldProfile(f3Cell,mm,0,pfl1)
3933         #
3934         f4Cell=MEDCouplingFieldDouble(ON_CELLS) ; f4Cell.setName("f4Cell")
3935         arr4=DataArrayDouble([2,2,0,1,1,0])
3936         f4Cell.setArray(arr4)
3937         f1ts4Cell.setFieldProfile(f4Cell,mm,0,pfl1)
3938         #
3939         f5Node=MEDCouplingFieldDouble(ON_NODES) ; f5Node.setName("f5Node")
3940         arr5=DataArrayDouble([0,1,2,3,10,11,13,2,11,1,10,0])
3941         f5Node.setArray(arr5)
3942         f1ts5Node.setFieldProfile(f5Node,mm,0,pfl2)
3943         #
3944         fs=MEDFileFields()
3945         for f in [f1ts0Node,f1ts1Node,f1ts2Cell,f1ts3Cell,f1ts4Cell,f1ts5Node]:
3946             fmts=MEDFileFieldMultiTS()
3947             fmts.pushBackTimeStep(f)
3948             fs.pushField(fmts)
3949             pass
3950         mm.write(fname,2)
3951         fs.write(fname,0)
3952         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3953         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
3954         fields=MEDFileFields(fname,False)
3955         fields.removeFieldsWithoutAnyTimeStep()
3956         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3957         allFMTSLeavesToDisplay=[]
3958         for fields in fields_per_mesh:
3959             allFMTSLeavesToDisplay2=[]
3960             for fmts in fields:
3961                 tmp=fmts.splitDiscretizations()
3962                 for itmp in tmp:
3963                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
3964                     pass
3965                 allFMTSLeavesToDisplay2+=tmp
3966                 pass
3967             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3968             pass
3969         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3970         self.assertEqual(len(allFMTSLeavesToDisplay[0]),6)
3971         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3972         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3973         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),6)
3974         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3975         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),2)
3976         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),4)
3977         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),2)# <- the smart one is here
3978         #
3979         mst=MEDFileMeshStruct.New(ms[0])
3980         #
3981         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
3982         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3983         mml2=mml.prepare()
3984         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3985         self.assertEqual([3,4,0],mml2.getGeoTypes())
3986         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3987         self.assertTrue(not ncc)
3988         self.assertTrue(a0.isEqual(DataArrayDouble([0.,1.,0.,1.,1.,0.,2.,1.,0.,0.,2.,0.,1.,2.,0.,0.,3.,0.],6,3),1e-12))
3989         self.assertTrue(a1.isEqual(DataArrayByte([5,9,1])))
3990         self.assertTrue(a2.isEqual(DataArrayInt([0,4,9])))
3991         self.assertTrue(a3.isEqual(DataArrayInt([3,4,2,1,4,0,3,4,1,1,5])))
3992         self.assertTrue(a4 is None)
3993         self.assertTrue(a5 is None)
3994         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3995         a6,a7=mml2.retrieveFamilyIdsOnCells()
3996         self.assertTrue(a6.isEqual(DataArrayInt([-3,-7,13])))
3997         self.assertTrue(not a7) # copy here because profile on cells
3998         a8,a9=mml2.retrieveNumberIdsOnCells()
3999         self.assertTrue(a8 is None)
4000         self.assertTrue(a9) # no copy here because no number field
4001         a10,a11=mml2.retrieveFamilyIdsOnNodes()
4002         self.assertTrue(a10.isEqual(DataArrayInt([5,6,7,9,10,13])))
4003         self.assertTrue(not a11) # copy here
4004         a12,a13=mml2.retrieveNumberIdsOnNodes()
4005         self.assertTrue(a12 is None)
4006         self.assertTrue(a13) # no copy here because no number field
4007         #
4008         fff0=allFMTSLeavesPerCommonSupport1[1][0][0][0]
4009         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff0,mst)
4010         fff0.loadArraysIfNecessary()
4011         v=mml2.buildDataArray(fsst,fields,fff0.getUndergroundDataArray())
4012         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4013         self.assertEqual(fff0.getName(),"f0Node")
4014         self.assertEqual(v.getHiddenCppPointer(),fff0.getUndergroundDataArray().getHiddenCppPointer())
4015         vExp=DataArrayDouble([0.,1.,2.,3.,4.,5.])
4016         self.assertTrue(v.isEqual(vExp,1e-12)) # <- THE test is here !!!
4017         #
4018         fff1=allFMTSLeavesPerCommonSupport1[1][0][1][0]
4019         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff1,mst)
4020         fff1.loadArraysIfNecessary()
4021         v=mml2.buildDataArray(fsst,fields,fff1.getUndergroundDataArray())
4022         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4023         self.assertEqual(fff1.getName(),"f1Node")
4024         self.assertEqual(v.getHiddenCppPointer(),fff1.getUndergroundDataArray().getHiddenCppPointer())
4025         vExp=DataArrayDouble([5.,4.,3.,2.,1.,0.])
4026         self.assertTrue(v.isEqual(vExp,1e-12)) # <- THE test is here !!!
4027         pass
4028
4029     @WriteInTmpDir
4030     def test27(self):
4031         """ This test defines 2 fields f0 and f1 on nodes lying on an unstructured mesh with no cells.
4032         f0 is a field on all nodes. f1 is a partial field on nodes.
4033         """
4034         fname="ForMEDReader27.med"
4035         coords=DataArrayDouble([(0.,0.,0.),(1.,0.,0.),(2.,0.,0.),(3.,0.,0.),(0.,1.,0.),(1.,1.,0.),(2.,1.,0.),(3.,1.,0.),(0.,2.,0.),(1.,2.,0.),(2.,2.,0.),(3.,2.,0.),(0.,3.,0.),(1.,3.,0.),(2.,3.,0.),(3.,3.,0.)])
4036         m0=MEDCouplingUMesh("mesh",2)
4037         m0.allocateCells()
4038         m0.setCoords(coords)
4039         ##
4040         mm=MEDFileUMesh()
4041         mm.setMeshAtLevel(0,m0)
4042         mm.setFamilyFieldArr(1,DataArrayInt([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]))
4043         #
4044         f1ts0=MEDFileField1TS()
4045         f1ts1=MEDFileField1TS()
4046         #
4047         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m0) ; f0.setName("f0NoPfl")
4048         arr0=DataArrayDouble([0.,1.,2.,3.,1.,1.5,2.2,3.1,2.,2.2,3.,3.1,3.,3.1,3.5,4.])
4049         f0.setArray(arr0)
4050         f0.checkConsistencyLight()
4051         f1ts0.setFieldNoProfileSBT(f0)
4052         self.assertEqual(f1ts0.getMeshName(),"mesh")
4053         #
4054         pfl1=DataArrayInt([0,1,2,3,4,5,6,8,9,12]) ; pfl1.setName("pfl1")
4055         f1=MEDCouplingFieldDouble(ON_NODES) ; f1.setName("f1Pfl")
4056         arr1=DataArrayDouble([3.,2.,1.,0.,2.,1.5,0.,1.,0.,0.2])
4057         f1.setArray(arr1)
4058         f1ts1.setFieldProfile(f1,mm,0,pfl1)
4059         self.assertEqual(f1ts1.getMeshName(),"mesh")
4060         #
4061         fs=MEDFileFields()
4062         fmts0=MEDFileFieldMultiTS()
4063         fmts0.pushBackTimeStep(f1ts0)
4064         fmts1=MEDFileFieldMultiTS()
4065         fmts1.pushBackTimeStep(f1ts1)
4066         fs.pushField(fmts0) ; fs.pushField(fmts1)
4067         self.assertEqual(fs[0].getMeshName(),"mesh")
4068         self.assertEqual(fs[1].getMeshName(),"mesh")
4069         mm.write(fname,2)
4070         fs.write(fname,0)
4071         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
4072         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
4073         fields=MEDFileFields(fname,False)
4074         fields.removeFieldsWithoutAnyTimeStep()
4075         self.assertEqual(fields[0].getMeshName(),"mesh")
4076         self.assertEqual(fields[1].getMeshName(),"mesh")
4077         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
4078         self.assertEqual(fields_per_mesh[0][0].getMeshName(),"mesh")
4079         self.assertEqual(fields_per_mesh[0][1].getMeshName(),"mesh")
4080         allFMTSLeavesToDisplay=[]
4081         for fields in fields_per_mesh:
4082             allFMTSLeavesToDisplay2=[]
4083             for fmts in fields:
4084                 tmp=fmts.splitDiscretizations()
4085                 for itmp in tmp:
4086                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
4087                     pass
4088                 allFMTSLeavesToDisplay2+=tmp
4089                 pass
4090             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
4091             pass
4092         self.assertEqual(len(allFMTSLeavesToDisplay),1)
4093         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
4094         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
4095         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
4096         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
4097         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
4098         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),2)
4099         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
4100         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),1)
4101         #
4102         mst=MEDFileMeshStruct.New(ms[0])
4103         #
4104         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
4105         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4106         mml2=mml.prepare()
4107         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
4108         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4109         self.assertTrue(ncc)
4110         self.assertTrue(a0.isEqual(DataArrayDouble([(0.,0.,0.),(1.,0.,0.),(2.,0.,0.),(3.,0.,0.),(0.,1.,0.),(1.,1.,0.),(2.,1.,0.),(3.,1.,0.),(0.,2.,0.),(1.,2.,0.),(2.,2.,0.),(3.,2.,0.),(0.,3.,0.),(1.,3.,0.),(2.,3.,0.),(3.,3.,0.)]),1e-12))
4111         self.assertTrue(a1.isEqual(DataArrayByte([])))
4112         self.assertTrue(a2.isEqual(DataArrayInt([])))
4113         self.assertTrue(a3.isEqual(DataArrayInt([])))
4114         self.assertTrue(a4 is None)
4115         self.assertTrue(a5 is None)
4116         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4117         #
4118         fff0=allFMTSLeavesPerCommonSupport1[0][0][0][0]
4119         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff0,mst)
4120         fff0.loadArraysIfNecessary()
4121         v=mml2.buildDataArray(fsst,fields,fff0.getUndergroundDataArray())
4122         self.assertEqual(fff0.getName(),"f0NoPfl")
4123         self.assertEqual(v.getHiddenCppPointer(),fff0.getUndergroundDataArray().getHiddenCppPointer())
4124         vExp=DataArrayDouble([0.,1.,2.,3.,1.,1.5,2.2,3.1,2.,2.2,3.,3.1,3.,3.1,3.5,4])
4125         self.assertTrue(v.isEqual(vExp,1e-12))
4126         #
4127         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
4128         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4129         mml2=mml.prepare()
4130         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
4131         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4132         self.assertTrue(not ncc)
4133         self.assertTrue(a0.isEqual(DataArrayDouble([(0,0,0),(1,0,0),(2,0,0),(3,0,0),(0,1,0),(1,1,0),(2,1,0),(0,2,0),(1,2,0),(0,3,0)]),1e-12))
4134         self.assertTrue(a1.isEqual(DataArrayByte([])))
4135         self.assertTrue(a2.isEqual(DataArrayInt([])))
4136         self.assertTrue(a3.isEqual(DataArrayInt([])))
4137         self.assertTrue(a4 is None)
4138         self.assertTrue(a5 is None)
4139         fff1=allFMTSLeavesPerCommonSupport1[1][0][0][0]
4140         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff1,mst)
4141         fff1.loadArraysIfNecessary()
4142         v=mml2.buildDataArray(fsst,fields,fff1.getUndergroundDataArray())
4143         self.assertEqual(fff1.getName(),"f1Pfl")
4144         self.assertNotEqual(v.getHiddenCppPointer(),fff1.getUndergroundDataArray().getHiddenCppPointer()) # pointers are not equal because Profile
4145         vExp=DataArrayDouble([3.,2.,1.,0.,2.,1.5,0.,1.,0.,0.2])
4146         self.assertTrue(v.isEqual(vExp,1e-12))
4147         pass
4148
4149     @WriteInTmpDir
4150     def test28(self):
4151         """ This test defines 2 fields f0,f1,f2,f3 lying on an unstructured mesh with cells including NORM_POINT1.
4152         Both f0 and f1 are on NODES and f2 and f3 are on cells. f1 and f2 share the same support.
4153         f0 is on a nodal support that is not matchable with any cells (including NORM_POINT1)
4154         This test is a more aggressive version of test26.
4155         """
4156         fname="ForMEDReader28.med"
4157         coords=DataArrayDouble([(0.,0.,0.),(1.,0.,0.),(2.,0.,0.),(3.,0.,0.),(0.,1.,0.),(1.,1.,0.),(2.,1.,0.),(3.,1.,0.),(0.,2.,0.),(1.,2.,0.),(2.,2.,0.),(3.,2.,0.),(0.,3.,0.),(1.,3.,0.),(2.,3.,0.),(3.,3.,0.)])
4158         m0=MEDCouplingUMesh("mesh",2)
4159         m0.allocateCells()
4160         for elt in [[2,6,3],[6,7,3],[9,6,5],[9,10,6]]:
4161             m0.insertNextCell(NORM_TRI3,elt)
4162             pass
4163         for elt in [[0,4,5,1],[1,5,6,2],[4,8,9,5],[6,10,11,7],[8,12,13,9],[9,13,14,10],[10,14,15,11]]:
4164             m0.insertNextCell(NORM_QUAD4,elt)
4165             pass
4166         m0.setCoords(coords)
4167         m2=MEDCouplingUMesh("mesh",0) ; m2.setCoords(coords)
4168         m2.allocateCells()
4169         for elt in [[8],[13]]:
4170             m2.insertNextCell(NORM_POINT1,elt)
4171             pass
4172         ##
4173         mm=MEDFileUMesh()
4174         mm.setMeshAtLevel(0,m0)
4175         mm.setMeshAtLevel(-2,m2)
4176         mm.setFamilyFieldArr(0,DataArrayInt([-1,-2,-3,-4,-5,-6,-7,-8,-9,-10,-11]))
4177         mm.setFamilyFieldArr(-2,DataArrayInt([-12,-13]))
4178         mm.setFamilyFieldArr(1,DataArrayInt([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]))
4179         #
4180         f1ts0Node=MEDFileField1TS()
4181         f1ts1Node=MEDFileField1TS()
4182         f1ts2Cell=MEDFileField1TS()
4183         f1ts3Cell=MEDFileField1TS()
4184         #
4185         pfl0=DataArrayInt([4,5,6,8,9,12]) ; pfl0.setName("pfl0")
4186         pfl1=DataArrayInt([0,1,4,5,7,10]) ; pfl1.setName("pfl1")
4187         pfl2=DataArrayInt([0,1,2,3,4,5,6,7,10,11,14,15]) ; pfl2.setName("pfl2")
4188         #
4189         f0Node=MEDCouplingFieldDouble(ON_NODES) ; f0Node.setName("f0Node")
4190         arr0=DataArrayDouble(6) ; arr0.iota()
4191         f0Node.setArray(arr0)
4192         f1ts0Node.setFieldProfile(f0Node,mm,0,pfl0)
4193         #
4194         f1Node=MEDCouplingFieldDouble(ON_NODES) ; f1Node.setName("f1Node")
4195         arr1=DataArrayDouble(12) ; arr1.iota() ; arr1.reverse()
4196         f1Node.setArray(arr1)
4197         f1ts1Node.setFieldProfile(f1Node,mm,0,pfl2)
4198         #
4199         f2Cell=MEDCouplingFieldDouble(ON_CELLS) ; f2Cell.setName("f2Cell")
4200         arr2=DataArrayDouble([2,3,0,1,4,5])
4201         f2Cell.setArray(arr2)
4202         f1ts2Cell.setFieldProfile(f2Cell,mm,0,pfl1)
4203         #
4204         f3Cell=MEDCouplingFieldDouble(ON_CELLS) ; f3Cell.setName("f3Cell")
4205         arr3=DataArrayDouble([5,4,3,2,1,0]) ; f3Cell.setArray(arr3)
4206         f1ts3Cell.setFieldProfile(f3Cell,mm,0,pfl1)
4207         f3Cell.setMesh(m2)
4208         arr3=DataArrayDouble([-1.1,-3.1]) ; f3Cell.setArray(arr3)
4209         f1ts3Cell.setFieldNoProfileSBT(f3Cell)
4210         #
4211         fs=MEDFileFields()
4212         for f in [f1ts0Node,f1ts1Node,f1ts2Cell,f1ts3Cell]:
4213             fmts=MEDFileFieldMultiTS()
4214             fmts.pushBackTimeStep(f)
4215             fs.pushField(fmts)
4216             pass
4217         mm.write(fname,2)
4218         fs.write(fname,0)
4219         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
4220         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
4221         fields=MEDFileFields(fname,False)
4222         fields.removeFieldsWithoutAnyTimeStep()
4223         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
4224         allFMTSLeavesToDisplay=[]
4225         for fields in fields_per_mesh:
4226             allFMTSLeavesToDisplay2=[]
4227             for fmts in fields:
4228                 tmp=fmts.splitDiscretizations()
4229                 for itmp in tmp:
4230                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
4231                     pass
4232                 allFMTSLeavesToDisplay2+=tmp
4233                 pass
4234             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
4235             pass
4236         self.assertEqual(len(allFMTSLeavesToDisplay),1)
4237         self.assertEqual(len(allFMTSLeavesToDisplay[0]),4)
4238         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
4239         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
4240         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
4241         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
4242         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),3)
4243         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),2)
4244         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),1)
4245         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[2][0]),1)
4246         #
4247         mst=MEDFileMeshStruct.New(ms[0])
4248         #
4249         fcscp=allFMTSLeavesPerCommonSupport1[2][1]
4250         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4251         mml2=mml.prepare()
4252         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
4253         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4254         self.assertTrue(not ncc)
4255         self.assertTrue(a0.isEqual(DataArrayDouble([0.,1.,0.,1.,1.,0.,2.,1.,0.,0.,2.,0.,1.,2.,0.,0.,3.,0.],6,3),1e-12))
4256         self.assertTrue(a1.isEqual(DataArrayByte([5,9,1,1])))
4257         self.assertTrue(a2.isEqual(DataArrayInt([0,4,9,11])))
4258         self.assertTrue(a3.isEqual(DataArrayInt([3,4,2,1,4,0,3,4,1,1,3,1,5])))
4259         self.assertTrue(a4 is None)
4260         self.assertTrue(a5 is None)
4261         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4262         a6,a7=mml2.retrieveFamilyIdsOnCells()
4263         self.assertTrue(a6.isEqual(DataArrayInt([-3,-7,-12,13])))
4264         self.assertTrue(not a7) # copy here because profile on cells
4265         a8,a9=mml2.retrieveNumberIdsOnCells()
4266         self.assertTrue(a8 is None)
4267         self.assertTrue(a9) # no copy here because no number field
4268         a10,a11=mml2.retrieveFamilyIdsOnNodes()
4269         self.assertTrue(a10.isEqual(DataArrayInt([5,6,7,9,10,13])))
4270         self.assertTrue(not a11) # copy here
4271         a12,a13=mml2.retrieveNumberIdsOnNodes()
4272         self.assertTrue(a12 is None)
4273         self.assertTrue(a13) # no copy here because no number field
4274         #
4275         fff0=allFMTSLeavesPerCommonSupport1[2][0][0][0]
4276         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff0,mst)
4277         fff0.loadArraysIfNecessary()
4278         v=mml2.buildDataArray(fsst,fields,fff0.getUndergroundDataArray())
4279         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4280         self.assertEqual(fff0.getName(),"f0Node")
4281         self.assertEqual(v.getHiddenCppPointer(),fff0.getUndergroundDataArray().getHiddenCppPointer())
4282         vExp=DataArrayDouble([0.,1.,2.,3.,4.,5.])
4283         self.assertTrue(v.isEqual(vExp,1e-12)) # <- THE test is here !!!
4284         ###
4285         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
4286         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4287         mml2=mml.prepare()
4288         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
4289         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4290         self.assertTrue(not ncc)
4291         self.assertTrue(a0.isEqual(DataArrayDouble([(0,0,0),(1,0,0),(2,0,0),(3,0,0),(0,1,0),(1,1,0),(2,1,0),(3,1,0),(2,2,0),(3,2,0),(2,3,0),(3,3,0)]),1e-12))
4292         self.assertTrue(a1.isEqual(DataArrayByte([5,5,9,9,9,9])))
4293         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,13,18,23])))
4294         self.assertTrue(a3.isEqual(DataArrayInt([3,2,6,3,3,6,7,3,4,0,4,5,1,4,1,5,6,2,4,6,8,9,7,4,8,10,11,9])))
4295         self.assertTrue(a4 is None)
4296         self.assertTrue(a5 is None)
4297         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4298         fff1=allFMTSLeavesPerCommonSupport1[0][0][0][0]
4299         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff1,mst)
4300         fff1.loadArraysIfNecessary()
4301         v=mml2.buildDataArray(fsst,fields,fff1.getUndergroundDataArray())
4302         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4303         self.assertEqual(fff1.getName(),"f2Cell")
4304         self.assertNotEqual(v.getHiddenCppPointer(),fff0.getUndergroundDataArray().getHiddenCppPointer())
4305         vExp=DataArrayDouble([2,3,0,1,4,5])
4306         self.assertTrue(v.isEqual(vExp,1e-12))
4307         fff2=allFMTSLeavesPerCommonSupport1[0][0][1][0]
4308         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff2,mst)
4309         fff2.loadArraysIfNecessary()
4310         v=mml2.buildDataArray(fsst,fields,fff2.getUndergroundDataArray())
4311         self.assertEqual(fff2.getName(),"f1Node")
4312         self.assertNotEqual(v.getHiddenCppPointer(),fff0.getUndergroundDataArray().getHiddenCppPointer())
4313         vExp=DataArrayDouble([11,10,9,8,7,6,5,4,3,2,1,0])
4314         self.assertTrue(v.isEqual(vExp,1e-12))
4315         ###
4316         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
4317         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4318         mml2=mml.prepare()
4319         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
4320         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4321         self.assertTrue(ncc)# here all the 16 nodes are taken
4322         self.assertTrue(a0.isEqual(DataArrayDouble([(0.,0.,0.),(1.,0.,0.),(2.,0.,0.),(3.,0.,0.),(0.,1.,0.),(1.,1.,0.),(2.,1.,0.),(3.,1.,0.),(0.,2.,0.),(1.,2.,0.),(2.,2.,0.),(3.,2.,0.),(0.,3.,0.),(1.,3.,0.),(2.,3.,0.),(3.,3.,0.)]),1e-12))
4323         self.assertTrue(a1.isEqual(DataArrayByte([1,1,5,5,9,9,9,9])))
4324         self.assertTrue(a2.isEqual(DataArrayInt([0,2,4,8,12,17,22,27])))
4325         self.assertTrue(a3.isEqual(DataArrayInt([1,8,1,13,3,2,6,3,3,6,7,3,4,0,4,5,1,4,1,5,6,2,4,6,10,11,7,4,10,14,15,11])))
4326         self.assertTrue(a4 is None)
4327         self.assertTrue(a5 is None)
4328         fff3=allFMTSLeavesPerCommonSupport1[1][0][0][0]
4329         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff3,mst)
4330         fff3.loadArraysIfNecessary()
4331         v=mml2.buildDataArray(fsst,fields,fff3.getUndergroundDataArray())
4332         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4333         self.assertEqual(fff3.getName(),"f3Cell")
4334         self.assertNotEqual(v.getHiddenCppPointer(),fff0.getUndergroundDataArray().getHiddenCppPointer())
4335         vExp=DataArrayDouble([-1.1,-3.1,5,4,3,2,1,0])
4336         self.assertTrue(v.isEqual(vExp,1e-12))
4337         pass
4338
4339     @WriteInTmpDir
4340     def test29(self):
4341         """ This test focused on HEXA27 cell for which the MED numbering is not equal to the VTK numbering. So here the HEXA27 cell is those in MED file documentation (reference element).
4342         """
4343         fname="ForMEDReader29.med"
4344         coo=DataArrayDouble([[0.,2.,2.],[0.,0.,2.],[2.,0.,2.],[2.,2.,2.],[0.,2.,0.],[0.,0.,0.],[2.,0.,0.],[2.,2.,0.], [0.,1.,2.],[1.,0.,2.],[2.,1.,2.],[1.,2.,2.], [0.,1.,0.],[1.,0.,0.],[2.,1.,0.],[1.,2.,0.], [0.,2.,1.],[0.,0.,1.],[2.,0.,1.],[2.,2.,1.], [1.,1.,2.], [0.,1.,1.],[1.,0.,1.],[2.,1.,1.],[1.,2.,1.], [1.,1.,0.], [1.,1.,1.]])
4345         m=MEDCouplingUMesh("mesh",3) ; m.setCoords(coo)
4346         m.allocateCells()
4347         # MED = [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]
4348         # VTK = [0,1,2,3,4,5,6,7, 8,9,10,11,12,13,14,15,16,17,18,19,24,22,21,23,20,25,26]
4349         m.insertNextCell(NORM_HEXA27,[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])
4350         fCell=MEDCouplingFieldDouble(ON_CELLS) ; fCell.setName("fCell")
4351         arrCell=DataArrayDouble([7.]) ; arrCell.setInfoOnComponent(0,"smth") ; fCell.setArray(arrCell)
4352         fCell.setMesh(m)
4353         WriteField(fname,fCell,True)
4354         refCoo=[-1.,-1.,-1.,-1.,1.,-1.,1.,1.,-1.,1.,-1.,-1.,-1.,-1.,1.,-1.,1.,1.,1.,1.,1.,1.,-1.,1.,-1.,0.,-1.,0.,1.,-1.,1.,0.,-1.,0.,-1.,-1.,-1.,0.,1.,0.,1.,1.,1.,0.,1.,0.,-1.,1.,-1.,-1.,0.,-1.,1.,0.,1.,1.,0.,1.,-1.,0.,0.,0.,-1.,-1.,0.,0.,0.,1.,0.,1.,0.,0.,0.,-1.,0.,0.,0.,1.,0.,0.,0.]
4355         weights=[0.1714677640603571,0.27434842249657115,0.1714677640603571,0.27434842249657115,0.43895747599451346,0.27434842249657115,0.1714677640603571,0.27434842249657115,0.1714677640603571,0.27434842249657115,0.43895747599451346,0.27434842249657115,0.43895747599451346,0.7023319615912209,0.43895747599451346,0.27434842249657115,0.43895747599451346,0.27434842249657115,0.1714677640603571,0.27434842249657115,0.1714677640603571,0.27434842249657115,0.43895747599451346,0.27434842249657115,0.1714677640603571,0.27434842249657115,0.1714677640603571]
4356         gCoords=[-0.774596669241483,-0.774596669241483,-0.774596669241483,-0.774596669241483,-0.774596669241483,0.0,-0.774596669241483,-0.774596669241483,0.774596669241483,-0.774596669241483,0.0,-0.774596669241483,-0.774596669241483,0.0,0.0,-0.774596669241483,0.0,0.774596669241483,-0.774596669241483,0.774596669241483,-0.774596669241483,-0.774596669241483,0.774596669241483,0.0,-0.774596669241483,0.774596669241483,0.774596669241483,0.0,-0.774596669241483,-0.774596669241483,0.0,-0.774596669241483,0.0,0.0,-0.774596669241483,0.774596669241483,0.0,0.0,-0.774596669241483,0.0,0.0,0.0,0.0,0.0,0.774596669241483,0.0,0.774596669241483,-0.774596669241483,0.0,0.774596669241483,0.0,0.0,0.774596669241483,0.774596669241483,0.774596669241483,-0.774596669241483,-0.774596669241483,0.774596669241483,-0.774596669241483,0.0,0.774596669241483,-0.774596669241483,0.774596669241483,0.774596669241483,0.0,-0.774596669241483,0.774596669241483,0.0,0.0,0.774596669241483,0.0,0.774596669241483,0.774596669241483,0.774596669241483,-0.774596669241483,0.774596669241483,0.774596669241483,0.0,0.774596669241483,0.774596669241483,0.774596669241483]
4357         fGauss=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fGauss.setName("fGauss")
4358         fGauss.setMesh(m)
4359         fGauss.setGaussLocalizationOnType(NORM_HEXA27,refCoo,gCoords,weights)
4360         arrGauss=DataArrayDouble(fGauss.getNumberOfTuplesExpected()) ; arrGauss.setInfoOnComponent(0,"gaussc") ; arrGauss.iota()
4361         fGauss.setArray(arrGauss)
4362         WriteFieldUsingAlreadyWrittenMesh(fname,fGauss)
4363         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
4364         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
4365         fields=MEDFileFields(fname,False)
4366         fields.removeFieldsWithoutAnyTimeStep()
4367         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
4368         allFMTSLeavesToDisplay=[]
4369         for fields in fields_per_mesh:
4370             allFMTSLeavesToDisplay2=[]
4371             for fmts in fields:
4372                 tmp=fmts.splitDiscretizations()
4373                 for itmp in tmp:
4374                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
4375                     pass
4376                 allFMTSLeavesToDisplay2+=tmp
4377                 pass
4378             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
4379             pass
4380         self.assertEqual(len(allFMTSLeavesToDisplay),1)
4381         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
4382         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
4383         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
4384         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
4385         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
4386         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
4387         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),2)
4388         #
4389         mst=MEDFileMeshStruct.New(ms[0])
4390         #
4391         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
4392         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4393         mml2=mml.prepare()
4394         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
4395         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4396         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4397         self.assertTrue(a0.isEqual(coo,1e-12))
4398         self.assertTrue(a1.isEqual(DataArrayByte([29])))
4399         self.assertTrue(a2.isEqual(DataArrayInt([0])))
4400         # the connectivity must be not a iota as declared in m.insertNextCell
4401         self.assertTrue(a3.isEqual(DataArrayInt([27,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,24,22,21,23,20,25,26])))# the test is on this line to check that connectivity has been processed for HEXA27
4402         self.assertTrue(a4 is None)
4403         self.assertTrue(a5 is None)
4404         ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][0]
4405         fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
4406         ffCell.loadArraysIfNecessary()
4407         v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
4408         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4409         self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
4410         self.assertEqual(ffCell.getName(),"fCell")
4411         self.assertTrue(v.isEqual(arrCell,1e-12)) ; self.assertTrue(v.isEqualWithoutConsideringStr(DataArrayDouble([7.]),1e-12)) ; self.assertEqual(v.getInfoOnComponents(),["smth"])
4412         del ffCell
4413         #
4414         ffGauss=allFMTSLeavesPerCommonSupport1[0][0][1][0]
4415         fsst=MEDFileField1TSStructItem.BuildItemFrom(ffGauss,mst)
4416         ffGauss.loadArraysIfNecessary()
4417         v=mml2.buildDataArray(fsst,fields,ffGauss.getUndergroundDataArray())
4418         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4419         self.assertEqual(v.getHiddenCppPointer(),ffGauss.getUndergroundDataArray().getHiddenCppPointer())
4420         self.assertEqual(ffGauss.getName(),"fGauss")
4421         self.assertTrue(v.isEqual(arrGauss, 1e-12)) ; self.assertTrue(v.isEqualWithoutConsideringStr(DataArrayDouble(list(range(27))), 1e-12)) ; self.assertEqual(v.getInfoOnComponents(), ["gaussc"])
4422         ffGauss=allFMTSLeavesPerCommonSupport1[0][0][1][0]
4423         pass
4424
4425     @WriteInTmpDir
4426     def test30(self):
4427         """ This test is focused on cartesian meshes. Here the cartesian mesh "CartMesh" has a field on HEXA8 (FieldOnCells) and a field on QUAD4 (FieldOnFaces).
4428         So the first one (FieldOnCells) lies on a cartesian mesh whereas the second one lies on unstructured one.
4429         """
4430         fname="ForMEDReader30.med"
4431         c=MEDCouplingCMesh()
4432         arrX=DataArrayDouble(3) ; arrX.iota()
4433         arrY=DataArrayDouble(4) ; arrY.iota()
4434         arrZ=DataArrayDouble(5) ; arrZ.iota()
4435         c.setCoords(arrX,arrY,arrZ)
4436         c.setName("CartMesh")
4437         cc=MEDFileCMesh()
4438         cc.setMesh(c)
4439         tmpFacesMesh=c.build1SGTSubLevelMesh()
4440         famIdFaces=DataArrayInt(98) ; famIdFaces[:36]=-1 ; famIdFaces[36:68]=-2 ; famIdFaces[68:]=-3
4441         famIdCells=DataArrayInt(24) ; famIdCells[:]=0
4442         #cc.setFamilyFieldArr(0,famIdCells)
4443         #cc.setFamilyFieldArr(-1,famIdFaces)
4444         cc.addFamily("FacesX",-1) ; cc.addFamily("FacesY",-2) ; cc.addFamily("FacesZ",-3)
4445         cc.setFamiliesOnGroup("FacesX1",["FacesX"])
4446         cc.setFamiliesOnGroup("FacesY1",["FacesY"])
4447         cc.setFamiliesOnGroup("FacesZ1",["FacesZ"])
4448         #
4449         fmts0=MEDFileFieldMultiTS()
4450         fmts1=MEDFileFieldMultiTS()
4451         for i in range(30):
4452             f1ts=MEDFileField1TS()
4453             fFaces=MEDCouplingFieldDouble(ON_CELLS) ; fFaces.setName("FieldOnFaces")
4454             arr=DataArrayDouble(98) ; arr.iota() ; arr[i]=100.
4455             fFaces.setArray(arr)
4456             fFaces.setTime(float(i)+0.1,i,-1)
4457             fFaces.setMesh(tmpFacesMesh)
4458             f1ts.setFieldNoProfileSBT(fFaces)
4459             fmts0.pushBackTimeStep(f1ts)
4460             #
4461             f1ts=MEDFileField1TS()
4462             fCells=MEDCouplingFieldDouble(ON_CELLS) ; fCells.setName("FieldOnCells")
4463             arr=DataArrayDouble(24) ; arr.iota() ; arr[i%24]=30.
4464             fCells.setArray(arr)
4465             fCells.setTime(float(i)+0.1,i,-1)
4466             fCells.setMesh(c)
4467             f1ts.setFieldNoProfileSBT(fCells)
4468             fmts1.pushBackTimeStep(f1ts)
4469             pass
4470         fs=MEDFileFields()
4471         fs.pushField(fmts0)
4472         fs.pushField(fmts1)
4473         cc.write(fname,2)
4474         fs.write(fname,0)
4475         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
4476         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
4477         fields=MEDFileFields(fname,False)
4478         fields.removeFieldsWithoutAnyTimeStep()
4479         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
4480         allFMTSLeavesToDisplay=[]
4481         for fields in fields_per_mesh:
4482             allFMTSLeavesToDisplay2=[]
4483             for fmts in fields:
4484                 tmp=fmts.splitDiscretizations()
4485                 for itmp in tmp:
4486                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
4487                     pass
4488                 allFMTSLeavesToDisplay2+=tmp
4489                 pass
4490             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
4491             pass
4492         self.assertEqual(len(allFMTSLeavesToDisplay),1)
4493         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
4494         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
4495         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
4496         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
4497         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
4498         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),2)
4499         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
4500         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),1)
4501         #
4502         mst=MEDFileMeshStruct.New(ms[0])
4503         #
4504         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
4505         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4506         mml2=mml.prepare()
4507         self.assertTrue(isinstance(mml2,MEDCMeshMultiLev)) # here CMesh is important
4508         (a,b,c),d=mml2.buildVTUArrays()
4509         self.assertTrue(d)#d is True because the a,b and c are directly those in the internal data structure
4510         self.assertTrue(a.isEqual(arrX,1e-12))
4511         self.assertTrue(b.isEqual(arrY,1e-12))
4512         self.assertTrue(c.isEqual(arrZ,1e-12))
4513         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4514         for i in range(30):
4515             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
4516             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
4517             ffCell.loadArraysIfNecessary()
4518             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
4519             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
4520             myarr=DataArrayDouble(24) ; myarr.iota() ; myarr[i%24]=30.
4521             self.assertEqual(ffCell.getName(),"FieldOnCells")
4522             self.assertTrue(v.isEqual(myarr,1e-12))
4523             pass
4524         #
4525         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
4526         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4527         mml2=mml.prepare()
4528         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev)) # here UMesh is important
4529         ref=ms[0].getImplicitFaceMesh().getCoords().getHiddenCppPointer()
4530         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4531         self.assertEqual(ref,a0.getHiddenCppPointer())
4532         self.assertTrue(ncc)
4533         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,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9])))
4534         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,120,125,130,135,140,145,150,155,160,165,170,175,180,185,190,195,200,205,210,215,220,225,230,235,240,245,250,255,260,265,270,275,280,285,290,295,300,305,310,315,320,325,330,335,340,345,350,355,360,365,370,375,380,385,390,395,400,405,410,415,420,425,430,435,440,445,450,455,460,465,470,475,480,485])))
4535         self.assertTrue(a3.isEqual(DataArrayInt([4,0,12,15,3,4,12,24,27,15,4,24,36,39,27,4,36,48,51,39,4,3,15,18,6,4,15,27,30,18,4,27,39,42,30,4,39,51,54,42,4,6,18,21,9,4,18,30,33,21,4,30,42,45,33,4,42,54,57,45,4,1,13,16,4,4,13,25,28,16,4,25,37,40,28,4,37,49,52,40,4,4,16,19,7,4,16,28,31,19,4,28,40,43,31,4,40,52,55,43,4,7,19,22,10,4,19,31,34,22,4,31,43,46,34,4,43,55,58,46,4,2,14,17,5,4,14,26,29,17,4,26,38,41,29,4,38,50,53,41,4,5,17,20,8,4,17,29,32,20,4,29,41,44,32,4,41,53,56,44,4,8,20,23,11,4,20,32,35,23,4,32,44,47,35,4,44,56,59,47,4,0,12,13,1,4,12,24,25,13,4,24,36,37,25,4,36,48,49,37,4,1,13,14,2,4,13,25,26,14,4,25,37,38,26,4,37,49,50,38,4,3,15,16,4,4,15,27,28,16,4,27,39,40,28,4,39,51,52,40,4,4,16,17,5,4,16,28,29,17,4,28,40,41,29,4,40,52,53,41,4,6,18,19,7,4,18,30,31,19,4,30,42,43,31,4,42,54,55,43,4,7,19,20,8,4,19,31,32,20,4,31,43,44,32,4,43,55,56,44,4,9,21,22,10,4,21,33,34,22,4,33,45,46,34,4,45,57,58,46,4,10,22,23,11,4,22,34,35,23,4,34,46,47,35,4,46,58,59,47,4,0,1,4,3,4,3,4,7,6,4,6,7,10,9,4,1,2,5,4,4,4,5,8,7,4,7,8,11,10,4,12,13,16,15,4,15,16,19,18,4,18,19,22,21,4,13,14,17,16,4,16,17,20,19,4,19,20,23,22,4,24,25,28,27,4,27,28,31,30,4,30,31,34,33,4,25,26,29,28,4,28,29,32,31,4,31,32,35,34,4,36,37,40,39,4,39,40,43,42,4,42,43,46,45,4,37,38,41,40,4,40,41,44,43,4,43,44,47,46,4,48,49,52,51,4,51,52,55,54,4,54,55,58,57,4,49,50,53,52,4,52,53,56,55,4,55,56,59,58])))
4536         self.assertTrue(a4 is None)
4537         self.assertTrue(a5 is None)
4538         for i in range(30):
4539             ffCell=allFMTSLeavesPerCommonSupport1[1][0][0][i]
4540             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
4541             ffCell.loadArraysIfNecessary()
4542             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
4543             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
4544             myarr=DataArrayDouble(98) ; myarr.iota() ; myarr[i]=100.
4545             self.assertEqual(ffCell.getName(),"FieldOnFaces")
4546             self.assertTrue(v.isEqual(myarr,1e-12))
4547             pass
4548         pass
4549
4550     @WriteInTmpDir
4551     def test31(self):
4552         """non regression test of EDF 7972"""
4553         fname="ForMEDReader31.med"
4554         c=MEDCouplingCMesh()
4555         arrX=DataArrayDouble(3) ; arrX.iota()
4556         arrY=DataArrayDouble(4) ; arrY.iota()
4557         arrZ=DataArrayDouble(5) ; arrZ.iota()
4558         c.setCoords(arrX,arrY,arrZ)
4559         c.setName("CartMesh")
4560         cc=MEDFileCMesh()
4561         cc.setMesh(c)
4562         famIdCells=DataArrayInt(24) ; famIdCells[:]=0
4563         cc.setFamilyFieldArr(0,famIdCells)
4564         #cc.setFamilyFieldArr(-1,famIdFaces)
4565         cc.addFamily("FacesX",-1) ; cc.addFamily("FacesY",-2) ; cc.addFamily("FacesZ",-3)
4566         cc.setFamiliesOnGroup("FacesX1",["FacesX"])
4567         cc.setFamiliesOnGroup("FacesY1",["FacesY"])
4568         cc.setFamiliesOnGroup("FacesZ1",["FacesZ"])
4569         fmts0=MEDFileFieldMultiTS()
4570         fmts1=MEDFileFieldMultiTS()
4571         pfl=DataArrayInt(11) ; pfl.iota() ; pfl.setName("PflOnHECA8")
4572         for i in range(30):
4573             f1ts=MEDFileField1TS()
4574             fFaces=MEDCouplingFieldDouble(ON_CELLS) ; fFaces.setName("FieldOnCells")
4575             arr=DataArrayDouble(11) ; arr.iota() ; arr[i%11]=100.
4576             fFaces.setArray(arr)
4577             fFaces.setTime(float(i)+0.1,i,-1)
4578             fFaces.setMesh(c.buildUnstructured()[:11])
4579             f1ts.setFieldProfile(fFaces,cc,0,pfl)# here, a test is done to check that "NORM_HEXA8" string is not 30 times appended at the end of pfl name.
4580             self.assertEqual("PflOnHECA8",pfl.getName())
4581             fmts0.pushBackTimeStep(f1ts)
4582             pass
4583         fs=MEDFileFields()
4584         fs.pushField(fmts0)
4585         cc.write(fname,2)
4586         fs.write(fname,0)
4587         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
4588         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
4589         fields=MEDFileFields(fname,False)
4590         fields.removeFieldsWithoutAnyTimeStep()
4591         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
4592         allFMTSLeavesToDisplay=[]
4593         for fields in fields_per_mesh:
4594             allFMTSLeavesToDisplay2=[]
4595             for fmts in fields:
4596                 tmp=fmts.splitDiscretizations()
4597                 for itmp in tmp:
4598                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
4599                     pass
4600                 allFMTSLeavesToDisplay2+=tmp
4601                 pass
4602             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
4603             pass
4604         self.assertEqual(len(allFMTSLeavesToDisplay),1)
4605         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
4606         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
4607         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
4608         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
4609         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
4610         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
4611         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
4612         #
4613         mst=MEDFileMeshStruct.New(ms[0])
4614         #
4615         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
4616         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4617         mml2=mml.prepare()
4618         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev)) # here UMesh is important
4619         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4620         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4621         self.assertTrue(not ncc)# here ncc=False because the coordinates are not in ms neither in children. This is the most important line in the test.
4622         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.,3.,0.,1.,3.,0.,2.,3.,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.,3.,1.,1.,3.,1.,2.,3.,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.,3.,2.,1.,3.,2.,2.,3.,2.,0.,0.,3.,1.,0.,3.,2.,0.,3.,0.,1.,3.,1.,1.,3.,2.,1.,3.,0.,2.,3.,1.,2.,3.,2.,2.,3.,0.,3.,3.,1.,3.,3.,2.,3.,3.,0.,0.,4.,1.,0.,4.,2.,0.,4.,0.,1.,4.,1.,1.,4.,2.,1.,4.,0.,2.,4.,1.,2.,4.,2.,2.,4.,0.,3.,4.,1.,3.,4.,2.,3.,4.],60,3),1e-12))
4623         self.assertTrue(a1.isEqual(DataArrayByte([12,12,12,12,12,12,12,12,12,12,12])))
4624         self.assertTrue(a2.isEqual(DataArrayInt([0,9,18,27,36,45,54,63,72,81,90])))
4625         self.assertTrue(a3.isEqual(DataArrayInt([8,1,0,3,4,13,12,15,16,8,2,1,4,5,14,13,16,17,8,4,3,6,7,16,15,18,19,8,5,4,7,8,17,16,19,20,8,7,6,9,10,19,18,21,22,8,8,7,10,11,20,19,22,23,8,13,12,15,16,25,24,27,28,8,14,13,16,17,26,25,28,29,8,16,15,18,19,28,27,30,31,8,17,16,19,20,29,28,31,32,8,19,18,21,22,31,30,33,34])))
4626         self.assertTrue(a4 is None)
4627         self.assertTrue(a5 is None)
4628         for i in range(30):
4629             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
4630             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
4631             ffCell.loadArraysIfNecessary()
4632             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
4633             # self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer()) # to be improved... maybe this line could be true
4634             myarr=DataArrayDouble(11) ; myarr.iota() ; myarr[i%11]=100.
4635             self.assertEqual(ffCell.getName(),"FieldOnCells")
4636             self.assertTrue(v.isEqual(myarr,1e-12))
4637             pass
4638         pass
4639
4640     @WriteInTmpDir
4641     def test32(self):
4642         """ This test is close to test30 except that here the profiles on dim-1 of structured mesh is considered here."""
4643         fname="ForMEDReader32.med"
4644         c=MEDCouplingCMesh()
4645         arrX=DataArrayDouble(3) ; arrX.iota()
4646         arrY=DataArrayDouble(4) ; arrY.iota()
4647         arrZ=DataArrayDouble(5) ; arrZ.iota()
4648         c.setCoords(arrX,arrY,arrZ)
4649         c.setName("CartMesh")
4650         cc=MEDFileCMesh()
4651         cc.setMesh(c)
4652         tmpFacesMesh=c.build1SGTSubLevelMesh()
4653         famIdFaces=DataArrayInt(98) ; famIdFaces[:36]=-1 ; famIdFaces[36:68]=-2 ; famIdFaces[68:]=-3
4654         famIdCells=DataArrayInt(24) ; famIdCells[:]=0
4655         cc.setFamilyFieldArr(0,famIdCells)
4656         #cc.setFamilyFieldArr(-1,famIdFaces)
4657         cc.addFamily("FacesX",-1) ; cc.addFamily("FacesY",-2) ; cc.addFamily("FacesZ",-3)
4658         cc.setFamiliesOnGroup("FacesX1",["FacesX"])
4659         cc.setFamiliesOnGroup("FacesY1",["FacesY"])
4660         cc.setFamiliesOnGroup("FacesZ1",["FacesZ"])
4661         fmts0=MEDFileFieldMultiTS()
4662         fmts1=MEDFileFieldMultiTS()
4663         pfl=DataArrayInt(31) ; pfl.iota() ; pfl.setName("PflOnQUAD4")
4664         for i in range(30):
4665             f1ts=MEDFileField1TS()
4666             fFaces=MEDCouplingFieldDouble(ON_CELLS) ; fFaces.setName("FieldOnFaces")
4667             arr=DataArrayDouble(31) ; arr.iota() ; arr[i]=100.
4668             fFaces.setArray(arr)
4669             fFaces.setTime(float(i)+0.1,i,-1)
4670             fFaces.setMesh(tmpFacesMesh[:31])
4671             f1ts.setFieldProfile(fFaces,cc,-1,pfl)# here, a test is done to check that "NORM_QUAD4" string is not 30 times appended at the end of pfl name.
4672             self.assertEqual("PflOnQUAD4",pfl.getName())
4673             fmts0.pushBackTimeStep(f1ts)
4674             #
4675             f1ts=MEDFileField1TS()
4676             fCells=MEDCouplingFieldDouble(ON_CELLS) ; fCells.setName("FieldOnCells")
4677             arr=DataArrayDouble(24) ; arr.iota() ; arr[i%24]=30.
4678             fCells.setArray(arr)
4679             fCells.setTime(float(i)+0.1,i,-1)
4680             fCells.setMesh(c)
4681             f1ts.setFieldNoProfileSBT(fCells)
4682             fmts1.pushBackTimeStep(f1ts)
4683             pass
4684         fs=MEDFileFields()
4685         fs.pushField(fmts0)
4686         fs.pushField(fmts1)
4687         cc.write(fname,2)
4688         fs.write(fname,0)
4689         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
4690         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
4691         fields=MEDFileFields(fname,False)
4692         fields.removeFieldsWithoutAnyTimeStep()
4693         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
4694         allFMTSLeavesToDisplay=[]
4695         for fields in fields_per_mesh:
4696             allFMTSLeavesToDisplay2=[]
4697             for fmts in fields:
4698                 tmp=fmts.splitDiscretizations()
4699                 for itmp in tmp:
4700                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
4701                     pass
4702                 allFMTSLeavesToDisplay2+=tmp
4703                 pass
4704             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
4705             pass
4706         self.assertEqual(len(allFMTSLeavesToDisplay),1)
4707         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
4708         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
4709         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
4710         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
4711         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
4712         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),2)
4713         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
4714         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),1)
4715         #
4716         mst=MEDFileMeshStruct.New(ms[0])
4717         #
4718         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
4719         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4720         mml2=mml.prepare()
4721         self.assertTrue(isinstance(mml2,MEDCMeshMultiLev)) # here CMesh is important
4722         (a,b,c),d=mml2.buildVTUArrays()
4723         self.assertTrue(d)#d is True because the a,b and c are directly those in the internal data structure
4724         self.assertTrue(a.isEqual(arrX,1e-12))
4725         self.assertTrue(b.isEqual(arrY,1e-12))
4726         self.assertTrue(c.isEqual(arrZ,1e-12))
4727         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4728         for i in range(30):
4729             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
4730             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
4731             ffCell.loadArraysIfNecessary()
4732             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
4733             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
4734             myarr=DataArrayDouble(24) ; myarr.iota() ; myarr[i%24]=30.
4735             self.assertEqual(ffCell.getName(),"FieldOnCells")
4736             self.assertTrue(v.isEqual(myarr,1e-12))
4737             pass
4738         #
4739         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
4740         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4741         mml2=mml.prepare()
4742         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev)) # here UMesh is important
4743         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4744         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4745         self.assertTrue(ncc)# True because, the coords are computed by the implicit unstructured level -1 structured mesh
4746         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.,3.,0.,1.,3.,0.,2.,3.,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.,3.,1.,1.,3.,1.,2.,3.,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.,3.,2.,1.,3.,2.,2.,3.,2.,0.,0.,3.,1.,0.,3.,2.,0.,3.,0.,1.,3.,1.,1.,3.,2.,1.,3.,0.,2.,3.,1.,2.,3.,2.,2.,3.,0.,3.,3.,1.,3.,3.,2.,3.,3.,0.,0.,4.,1.,0.,4.,2.,0.,4.,0.,1.,4.,1.,1.,4.,2.,1.,4.,0.,2.,4.,1.,2.,4.,2.,2.,4.,0.,3.,4.,1.,3.,4.,2.,3.,4.],60,3),1e-12))
4747         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,9,9,9,9,9,9,9])))
4748         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,120,125,130,135,140,145,150])))
4749         self.assertTrue(a3.isEqual(DataArrayInt([4,0,12,15,3,4,12,24,27,15,4,24,36,39,27,4,36,48,51,39,4,3,15,18,6,4,15,27,30,18,4,27,39,42,30,4,39,51,54,42,4,6,18,21,9,4,18,30,33,21,4,30,42,45,33,4,42,54,57,45,4,1,13,16,4,4,13,25,28,16,4,25,37,40,28,4,37,49,52,40,4,4,16,19,7,4,16,28,31,19,4,28,40,43,31,4,40,52,55,43,4,7,19,22,10,4,19,31,34,22,4,31,43,46,34,4,43,55,58,46,4,2,14,17,5,4,14,26,29,17,4,26,38,41,29,4,38,50,53,41,4,5,17,20,8,4,17,29,32,20,4,29,41,44,32])))
4750         self.assertTrue(a4 is None)
4751         self.assertTrue(a5 is None)
4752         a6,a7=mml2.retrieveFamilyIdsOnCells()
4753         self.assertTrue(a6 is None)
4754         self.assertTrue(a7)
4755         for i in range(30):
4756             ffCell=allFMTSLeavesPerCommonSupport1[1][0][0][i]
4757             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
4758             ffCell.loadArraysIfNecessary()
4759             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
4760             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
4761             myarr=DataArrayDouble(31) ; myarr.iota() ; myarr[i]=100.
4762             self.assertEqual(ffCell.getName(),"FieldOnFaces")
4763             self.assertTrue(v.isEqual(myarr,1e-12))
4764             pass
4765         pass
4766
4767     @WriteInTmpDir
4768     def test33(self):
4769         """Non regression test concerning polygons. Thanks Adrien. This bug can't be shown by simply reading an displaying a MED file containing only polygons. A filter must be applied on it to show it. The a2 array was responsible of that bug."""
4770         fname="ForMEDReader33.med"
4771         fieldName="ACellField"
4772         coo=DataArrayDouble([(5.5,0.5),(5.5,-0.5),(6.5,0.5),(6.5,-0.5),(6.5,1.5),(7.5,0.5),(7.5,-0.5),(7.5,1.5),(7.5,2.5),(8.5,0.5),(8.5,-0.5),(8.5,1.5),(8.5,2.5),(8.5,3.5),(8.55,0.5),(8.55,-0.5),(8.55,1.5),(8.55,2.5),(8.55,3.5)])
4773         m=MEDCouplingUMesh("mesh",2)
4774         m.setCoords(coo)
4775         m.allocateCells()
4776         for i,c in enumerate([(1,0,2,3),(3,2,5,6),(2,4,7,5),(6,5,9,10),(5,7,11,9),(7,8,12,11),(10,9,14,15),(9,11,16,14),(11,12,17,16),(12,13,18,17)]):
4777             if i<6:
4778                 typ=NORM_QUAD4
4779                 pass
4780             else:
4781                 typ=NORM_POLYGON
4782                 pass
4783             m.insertNextCell(typ,c)
4784             pass
4785         mm=MEDFileUMesh()
4786         mm.setMeshAtLevel(0,m)
4787         mm.write(fname,2)
4788         for i in range(15):
4789             fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i)+0.1,i,0)
4790             fCell0.setName(fieldName) ; fCell0.setMesh(m)
4791             arr=DataArrayDouble(m.getNumberOfCells()) ; arr.iota(0) ; arr[i%10]=100.
4792             fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]"])
4793             fCell0.checkConsistencyLight()
4794             WriteFieldUsingAlreadyWrittenMesh(fname,fCell0)
4795             pass
4796         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
4797         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
4798         fields=MEDFileFields(fname,False)
4799         fields.removeFieldsWithoutAnyTimeStep()
4800         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
4801         allFMTSLeavesToDisplay=[]
4802         for fields in fields_per_mesh:
4803             allFMTSLeavesToDisplay2=[]
4804             for fmts in fields:
4805                 tmp=fmts.splitDiscretizations()
4806                 for itmp in tmp:
4807                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
4808                     pass
4809                 allFMTSLeavesToDisplay2+=tmp
4810                 pass
4811             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
4812             pass
4813         self.assertEqual(len(allFMTSLeavesToDisplay),1)
4814         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
4815         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
4816         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
4817         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
4818         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
4819         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
4820         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
4821         #
4822         mst=MEDFileMeshStruct.New(ms[0])
4823         #
4824         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
4825         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4826         mml2=mml.prepare()
4827         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
4828         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4829         self.assertTrue(not ncc)# false because 2D in MED file
4830         self.assertTrue(a0.isEqual(DataArrayDouble([(5.5,0.5,0),(5.5,-0.5,0),(6.5,0.5,0),(6.5,-0.5,0),(6.5,1.5,0),(7.5,0.5,0),(7.5,-0.5,0),(7.5,1.5,0),(7.5,2.5,0),(8.5,0.5,0),(8.5,-0.5,0),(8.5,1.5,0),(8.5,2.5,0),(8.5,3.5,0),(8.55,0.5,0),(8.55,-0.5,0),(8.55,1.5,0),(8.55,2.5,0),(8.55,3.5,0)]),1e-12))
4831         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9,7,7,7,7])))
4832         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45])))# the bug was here.
4833         self.assertTrue(a3.isEqual(DataArrayInt([4,1,0,2,3,4,3,2,5,6,4,2,4,7,5,4,6,5,9,10,4,5,7,11,9,4,7,8,12,11,4,10,9,14,15,4,9,11,16,14,4,11,12,17,16,4,12,13,18,17])))
4834         self.assertTrue(a4 is None)
4835         self.assertTrue(a5 is None)
4836         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4837         for i in range(15):
4838             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
4839             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
4840             ffCell.loadArraysIfNecessary()
4841             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
4842             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
4843             myarr=DataArrayDouble(10) ; myarr.iota() ; myarr[i%10]=100. ; myarr.setInfoOnComponent(0,"Comp1 [m]")
4844             self.assertEqual(ffCell.getName(),fieldName)
4845             self.assertTrue(v.isEqual(myarr,1e-12))
4846             pass
4847         pass
4848
4849     @WriteInTmpDir
4850     def test34(self):
4851         """ This test is the thirs ultimate test (base on test12) for the profiles with gauss points.
4852         This test highlight the hidden imp linked to bug #8655.
4853         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.
4854         """
4855         fname="ForMEDReader34.med"
4856         m=MEDCouplingCMesh("mesh")
4857         arr=DataArrayDouble(5) ; arr.iota()
4858         m.setCoords(arr,arr)
4859         m=m.buildUnstructured() ; m.getCoords().setInfoOnComponents(["XX [m]","YYY [km]"])
4860         mm=MEDFileUMesh() ; mm.setMeshes([m])
4861         #
4862         fieldName0="zeField0"
4863         fieldName1="zeField1"
4864         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS()
4865         for i in range(5):
4866             f=MEDFileField1TS()
4867             fNode=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fNode.setTime(float(i),i,0)
4868             fNode.setName(fieldName0) ; fNode.setMesh(m)
4869             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])
4870             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])
4871             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])
4872             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])
4873             arr=DataArrayDouble(2*(2*6+5*4+4*3+7*3)) ; arr.iota(0+1000*i) ; arr.rearrange(2)
4874             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkConsistencyLight()
4875             f.setFieldNoProfileSBT(fNode)
4876             fs0.pushBackTimeStep(f)
4877             #
4878             f=MEDFileField1TS()
4879             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
4880             fNode.setName(fieldName1) ; fNode.setMesh(m)
4881             arr=DataArrayDouble(2*16) ; arr.iota(300+1000*i) ; arr.rearrange(2)
4882             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"]) ; fNode.checkConsistencyLight()
4883             f.setFieldNoProfileSBT(fNode)
4884             fs1.pushBackTimeStep(f)
4885             pass
4886         mm.write(fname,2)
4887         fs0.write(fname,0) ; fs1.write(fname,0)
4888         a0Exp=mm.getCoords().deepCopy()
4889         del m,mm,fs0,fs1,f,fNode
4890         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
4891         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
4892         fields=MEDFileFields(fname,False)
4893         fields.removeFieldsWithoutAnyTimeStep()
4894         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
4895         allFMTSLeavesToDisplay=[]
4896         for fields in fields_per_mesh:
4897             allFMTSLeavesToDisplay2=[]
4898             for fmts in fields:
4899                 tmp=fmts.splitDiscretizations()
4900                 for itmp in tmp:
4901                     if itmp.presenceOfMultiDiscPerGeoType():
4902                         tmp2=itmp.splitMultiDiscrPerGeoTypes()
4903                         for iii,itmp2 in enumerate(tmp2):
4904                             name="%s_%i"%(itmp2.getName(),iii)
4905                             itmp2.setName(name)
4906                             allFMTSLeavesToDisplay2.append(itmp2)
4907                             pass
4908                         pass
4909                     else:
4910                         allFMTSLeavesToDisplay2.append(itmp)
4911                         pass
4912                 pass
4913             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
4914             pass
4915         # Here 2 MED fields in input and at the end 5 ! 1+4 ! 4 fields have been built from zeField0 due to subsplitting per dis / per geo type
4916         self.assertEqual(len(allFMTSLeavesToDisplay),1)
4917         self.assertEqual(len(allFMTSLeavesToDisplay[0]),5)
4918         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
4919         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
4920         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),5)
4921         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
4922         self.assertEqual(len(allFMTSLeavesPerCommonSupport),5)
4923         for i in range(5):
4924             self.assertEqual(len(allFMTSLeavesPerCommonSupport[i][0]),1)
4925         #
4926         mst=MEDFileMeshStruct.New(ms[0])
4927         #
4928         fcscp=allFMTSLeavesPerCommonSupport[4][1]
4929         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4930         mml2=mml.prepare()
4931         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
4932         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4933         self.assertTrue(not ncc)
4934         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
4935         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9])))
4936         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75])))
4937         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
4938         self.assertTrue(a4 is None)
4939         self.assertTrue(a5 is None)
4940         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4941         for i in range(1, 5):
4942             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
4943             pass
4944         for i in range(5):
4945             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
4946             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
4947             f.loadArraysIfNecessary()
4948             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
4949             self.assertEqual(f.getName(),fieldName0)
4950             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.)])
4951             vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
4952             vExp+=i*1000
4953             self.assertTrue(v.isEqual(vExp,1e-12))
4954             #
4955             f=allFMTSLeavesPerCommonSupport[1][0][0][i]
4956             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
4957             f.loadArraysIfNecessary()
4958             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
4959             self.assertEqual(f.getName(),fieldName0)
4960             vExp=DataArrayDouble([(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.)])
4961             vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
4962             vExp+=i*1000
4963             self.assertTrue(v.isEqual(vExp,1e-12))
4964             #
4965             f=allFMTSLeavesPerCommonSupport[2][0][0][i]
4966             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
4967             f.loadArraysIfNecessary()
4968             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
4969             self.assertEqual(f.getName(),fieldName0)
4970             vExp=DataArrayDouble([(36.,37.),(38.,39.),(40.,41.),(42.,43.),(68.,69.),(70.,71.),(72.,73.),(74.,75.),(104.,105.),(106.,107.),(108.,109.),(110.,111.)])
4971             vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
4972             vExp+=i*1000
4973             self.assertTrue(v.isEqual(vExp,1e-12))
4974             #
4975             f=allFMTSLeavesPerCommonSupport[3][0][0][i]
4976             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
4977             f.loadArraysIfNecessary()
4978             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
4979             self.assertEqual(f.getName(),fieldName0)
4980             vExp=DataArrayDouble([(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)])
4981             vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
4982             vExp+=i*1000
4983             self.assertTrue(v.isEqual(vExp,1e-12))
4984             #
4985             f=allFMTSLeavesPerCommonSupport[4][0][0][i]
4986             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
4987             f.loadArraysIfNecessary()
4988             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
4989             self.assertEqual(f.getName(),fieldName1)
4990             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
4991             vExp=DataArrayDouble(16*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
4992             self.assertTrue(v.isEqual(vExp,1e-12))
4993             pass
4994         pass
4995
4996     @WriteInTmpDir
4997     def test35(self):
4998         """ Emulate MEDReader in // mode context. Here a Simple mesh having more nodes than really needed. This test focuses on that point particularly."""
4999         fname="ForMEDReader35.med"
5000         arrX=DataArrayDouble(7) ; arrX.iota()
5001         arrY=DataArrayDouble([0.,1.])
5002         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY) ; m=m.buildUnstructured() ; m=m[[0,5,1,4,2,3]] ; m.changeSpaceDimension(3,0.) ; m.setName("Mesh")
5003         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m) ; f.setName("Field") ; f.setArray(DataArrayDouble([(0.1,1.1),(2.1,3.1),(4.1,5.1),(6.1,7.1),(8.1,9.1),(10.1,11.1)])) ; f.getArray().setInfoOnComponents(["aa","bbb"])
5004         WriteUMesh(fname,m,True)
5005         WriteFieldUsingAlreadyWrittenMesh(fname,f)
5006         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
5007         ms=MEDFileMeshes() # here we reproduce what is done by ParaMEDFileMeshes.ParaNew
5008         ms.pushMesh(MEDFileUMesh.LoadPartOf(fname,"Mesh",[NORM_QUAD4],[0,2,1],-1,-1));
5009         ms[0].zipCoords()
5010         ms.cartesianizeMe()
5011         #
5012         fields=MEDFileFields.LoadPartOf(fname,False,ms);
5013         fields.removeFieldsWithoutAnyTimeStep()
5014         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
5015         allFMTSLeavesToDisplay=[]
5016         for fields in fields_per_mesh:
5017             allFMTSLeavesToDisplay2=[]
5018             for fmts in fields:
5019                 tmp=fmts.splitDiscretizations()
5020                 for itmp in tmp:
5021                     if itmp.presenceOfMultiDiscPerGeoType():
5022                         tmp2=itmp.splitMultiDiscrPerGeoTypes()
5023                         for iii,itmp2 in enumerate(tmp2):
5024                             name="%s_%i"%(itmp2.getName(),iii)
5025                             itmp2.setName(name)
5026                             allFMTSLeavesToDisplay2.append(itmp2)
5027                             pass
5028                         pass
5029                     else:
5030                         allFMTSLeavesToDisplay2.append(itmp)
5031                         pass
5032                 pass
5033             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
5034             pass
5035         #
5036         self.assertEqual(len(allFMTSLeavesToDisplay),1)
5037         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
5038         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
5039         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
5040         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
5041         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
5042         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
5043         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),1)
5044         #
5045         mst=MEDFileMeshStruct.New(ms[0])
5046         #
5047         fcscp=allFMTSLeavesPerCommonSupport[0][1]
5048         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5049         mml2=mml.prepare()
5050         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
5051         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
5052         self.assertTrue(ncc)
5053         self.assertTrue(a0.isEqual(m.getCoords()[[0,1,5,6,7,8,12,13]],1e-12))# <- the aim of the test
5054         self.assertTrue(a1.isEqual(DataArrayByte([9,9])))
5055         self.assertTrue(a2.isEqual(DataArrayInt([0,5])))
5056         self.assertTrue(a3.isEqual(DataArrayInt([4,1,0,4,5,4,3,2,6,7])))
5057         self.assertTrue(a4 is None)
5058         self.assertTrue(a5 is None)
5059         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny().isEqual(DataArrayInt([0,1,5,6,7,8,12,13])))
5060         f2=allFMTSLeavesPerCommonSupport[0][0][0][0]
5061         fsst=MEDFileField1TSStructItem.BuildItemFrom(f2,mst)
5062         f2.loadArraysIfNecessary()
5063         v=mml.buildDataArray(fsst,fields,f2.getUndergroundDataArray())
5064         self.assertEqual(f2.getName(),f.getName())
5065         vExp=DataArrayDouble([(0.1,1.1),(2.1,3.1)])
5066         vExp.setInfoOnComponents(['aa','bbb'])
5067         self.assertTrue(v.isEqual(vExp,1e-12))
5068         pass
5069
5070     @WriteInTmpDir
5071     def test36(self):
5072         """Bug EDF11027. Here mesh at level 0 (TRI3) does not fetch all the nodes. Level -1 (SEG2) does not fetch all the nodes neither. But all TRI3 + all SEG2 fetch all nodes.
5073         aaa field on GAUSSPoints lying only on TRI3 share the same support than profile node field ccc.
5074         But bbb field on all nodes is not on the same support. Past optimization that make the assumtion a support on all lev0 cells lies on all nodes is now over."""
5075         meshName="mesh"
5076         fname="ForMEDReader36.med"
5077         c=DataArrayDouble([(0,0),(1,0),(1,1),(0,1),(2,0),(-1,0),(1,2)])
5078         m0=MEDCoupling1SGTUMesh(meshName,NORM_TRI3)
5079         m0.setCoords(c)
5080         m0.setNodalConnectivity(DataArrayInt([0,2,1,3,2,0,2,4,1]))
5081         mm=MEDFileUMesh()
5082         mm[0]=m0
5083         m1=MEDCoupling1SGTUMesh(meshName,NORM_SEG2)
5084         m1.setCoords(c)
5085         m1.setNodalConnectivity(DataArrayInt([5,0,0,3,3,2,2,6]))
5086         mm[-1]=m1
5087         #
5088         zeTime=(1.1,2,3)
5089         ff1=MEDFileField1TS()
5090         f1=MEDCouplingFieldDouble(ON_NODES) ; f1.setMesh(m0)
5091         arr=DataArrayDouble(7) ; arr.iota(2000)
5092         f1.setArray(arr)
5093         f1.setName("bbb")
5094         f1.checkConsistencyLight()
5095         f1.setTime(*zeTime)
5096         ff1.setFieldNoProfileSBT(f1)
5097         #
5098         ff2=MEDFileField1TS()
5099         f2=MEDCouplingFieldDouble(ON_GAUSS_NE) ; f2.setMesh(m0)
5100         arr=DataArrayDouble(9) ; arr.iota(4000)
5101         f2.setArray(arr)
5102         f2.setName("ddd")
5103         f2.checkConsistencyLight()
5104         f2.setTime(*zeTime)
5105         ff2.setFieldNoProfileSBT(f2)
5106         #
5107         ff3=MEDFileField1TS()
5108         f3=MEDCouplingFieldDouble(ON_GAUSS_PT) ; f3.setMesh(m0)
5109         f3.setGaussLocalizationOnType(NORM_TRI3,[0,0,1,0,0,1],[0.333333,0.333333],[0.5])
5110         arr=DataArrayDouble(3) ; arr.iota(1000)
5111         f3.setArray(arr)
5112         f3.checkConsistencyLight()
5113         f3.setTime(*zeTime)
5114         f3.setName("aaa")
5115         ff3.setFieldNoProfileSBT(f3)
5116         #
5117         ff4=MEDFileField1TS()
5118         m0d=m0.deepCopy() ; m0d.zipCoords()
5119         f4=MEDCouplingFieldDouble(ON_NODES) ; f4.setMesh(m0d)
5120         arr=DataArrayDouble(5) ; arr.iota(3000)
5121         f4.setArray(arr)
5122         f4.setName("ccc")
5123         f4.checkConsistencyLight()
5124         f4.setTime(*zeTime)
5125         pfl=DataArrayInt([0,1,2,3,4]) ; pfl.setName("PFL")
5126         ff4.setFieldProfile(f4,mm,0,pfl)
5127         #
5128         mm.write(fname,2)
5129         ff3.write(fname,0)
5130         ff1.write(fname,0)
5131         ff4.write(fname,0)
5132         ###
5133         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
5134         fields=MEDFileFields(fname,False)
5135         fields.removeFieldsWithoutAnyTimeStep()
5136         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
5137         allFMTSLeavesToDisplay=[]
5138         for fields in fields_per_mesh:
5139             allFMTSLeavesToDisplay2=[]
5140             for fmts in fields:
5141                 tmp=fmts.splitDiscretizations()
5142                 for itmp in tmp:
5143                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
5144                     pass
5145                 allFMTSLeavesToDisplay2+=tmp
5146                 pass
5147             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
5148             pass
5149         self.assertEqual(len(allFMTSLeavesToDisplay),1)
5150         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
5151         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
5152         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
5153         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
5154         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
5155         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),2)
5156         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),2)
5157         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),1)
5158         #
5159         mst=MEDFileMeshStruct.New(ms[0])
5160         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
5161         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5162         mml2=mml.prepare()
5163         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
5164         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
5165         self.assertTrue(not ncc)# here ncc=False because the coordinates are not in ms neither in children.
5166         self.assertTrue(a0.isEqual(DataArrayDouble([(0,0,0),(1,0,0),(1,1,0),(0,1,0),(2,0,0)]),1e-12))
5167         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5])))
5168         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8])))
5169         self.assertTrue(a3.isEqual(DataArrayInt([3,0,2,1,3,3,2,0,3,2,4,1])))
5170         self.assertTrue(a4 is None)
5171         self.assertTrue(a5 is None)
5172         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
5173         for i in range(1):
5174             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
5175             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
5176             ffCell.loadArraysIfNecessary()
5177             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
5178             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
5179             v.isEqual(DataArrayDouble([1000,1001,1002]),1e-12)
5180             #
5181             ffCell=allFMTSLeavesPerCommonSupport1[0][0][1][i]
5182             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
5183             ffCell.loadArraysIfNecessary()
5184             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
5185             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
5186             v.isEqual(DataArrayDouble([3000,3001,3002,3003,3004]),1e-12)
5187             pass
5188         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
5189         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5190         mml2=mml.prepare()
5191         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
5192         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
5193         self.assertTrue(not ncc)# here ncc=False because the coordinates are not in ms neither in children.
5194         self.assertTrue(a0.isEqual(DataArrayDouble([(0,0,0),(1,0,0),(1,1,0),(0,1,0),(2,0,0),(-1,0,0),(1,2,0)]),1e-12))
5195         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5,3,3,3,3])))
5196         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,12,15,18,21])))
5197         self.assertTrue(a3.isEqual(DataArrayInt([3,0,2,1,3,3,2,0,3,2,4,1,2,5,0,2,0,3,2,3,2,2,2,6])))
5198         self.assertTrue(a4 is None)
5199         self.assertTrue(a5 is None)
5200         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
5201         for i in range(1):
5202             ffCell=allFMTSLeavesPerCommonSupport1[1][0][0][i]
5203             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
5204             ffCell.loadArraysIfNecessary()
5205             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
5206             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
5207             v.isEqual(DataArrayDouble([2000,2001,2002,2003,2004,2005,2006]),1e-12)
5208             pass
5209         pass
5210
5211     @WriteInTmpDir
5212     def test37(self):
5213         """ Introduction of non cartesian meshes management. Here cylindrical."""
5214         fname="ForMEDReader37.med"
5215         meshName="mesh"
5216         description="Cylindrical grid"
5217         comps=["X [cm]","Y [cm]","Z [cm]"]
5218         arrX=DataArrayDouble(3) ; arrX.iota() ; arrX*=0.8 ; arrX.setInfoOnComponent(0,comps[0])
5219         arrY=DataArrayDouble(4) ; arrY.iota() ; arrY*=pi/(len(arrY)-1) ; arrY.setInfoOnComponent(0,comps[1])
5220         arrZ=DataArrayDouble(5) ; arrZ.iota() ; arrZ*=1.6 ; arrZ-=8. ; arrZ.setInfoOnComponent(0,comps[2])
5221         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ) ; m.setName(meshName)
5222         mm=MEDFileCMesh() ; mm.setMesh(m) ; mm.setDescription(description)
5223         mm.setAxisType(AX_CYL) # the test is here !
5224         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m) ; f.setName("Field")
5225         arr=DataArrayDouble(m.getNumberOfCells()) ; arr.iota() ; arr*=0.1 ; f.setArray(arr) ; f.checkConsistencyLight()
5226         ff=MEDFileField1TS() ; ff.setFieldNoProfileSBT(f)
5227         fmts=MEDFileFieldMultiTS() ; fmts.pushBackTimeStep(ff)
5228         #
5229         ms=MEDFileMeshes() ; ms.pushMesh(mm)
5230         fields=MEDFileFields() ; fields.pushField(fmts)
5231         ms.write(fname,2) ; fields.write(fname,0)
5232         #
5233         del mm,fmts,fields,ms
5234         ms=MEDFileMeshes(fname)
5235         fields=MEDFileFields(fname,False)
5236         ms.cartesianizeMe()
5237         #
5238         fields.removeFieldsWithoutAnyTimeStep()
5239         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
5240         allFMTSLeavesToDisplay=[]
5241         for fields in fields_per_mesh:
5242             allFMTSLeavesToDisplay2=[]
5243             for fmts in fields:
5244                 tmp=fmts.splitDiscretizations()
5245                 for itmp in tmp:
5246                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
5247                     pass
5248                 allFMTSLeavesToDisplay2+=tmp
5249                 pass
5250             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
5251             pass
5252         #
5253         self.assertEqual(len(allFMTSLeavesToDisplay),1)
5254         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
5255         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
5256         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
5257         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
5258         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
5259         #
5260         mst=MEDFileMeshStruct.New(ms[0])
5261         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
5262         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5263         mml2=mml.prepare()
5264         self.assertTrue(isinstance(mml2,MEDCurveLinearMeshMultiLev))# <- hehe it is a CurveLinear no more a CMesh !
5265         a,b,c=mml2.buildVTUArrays()
5266         self.assertTrue(c)# the array is thoose in structure
5267         ref_a=DataArrayDouble([0.,0.,-8.,0.8,0.,-8.,1.6,0.,-8.,0.,0.,-8.,0.4,0.6928203230275509,-8.,0.8,1.3856406460551018,-8.,-0.,0.,-8.,-0.4,0.692820323027551,-8.,-0.8,1.385640646055102,-8.,-0.,0.,-8.,-0.8,0.,-8.,-1.6,0.,-8.,0.,0.,-6.4,0.8,0.,-6.4,1.6,0.,-6.4,0.,0.,-6.4,0.4,0.6928203230275509,-6.4,0.8,1.3856406460551018,-6.4,-0.,0.,-6.4,-0.4,0.692820323027551,-6.4,-0.8,1.385640646055102,-6.4,-0.,0.,-6.4,-0.8,0.,-6.4,-1.6,0.,-6.4,0.,0.,-4.8,0.8,0.,-4.8,1.6,0.,-4.8,0.,0.,-4.8,0.4,0.6928203230275509,-4.8,0.8,1.3856406460551018,-4.8,-0.,0.,-4.8,-0.4,0.692820323027551,-4.8,-0.8,1.385640646055102,-4.8,-0.,0.,-4.8,-0.8,0.,-4.8,-1.6,0.,-4.8,0.,0.,-3.2,0.8,0.,-3.2,1.6,0.,-3.2,0.,0.,-3.2,0.4,0.6928203230275509,-3.2,0.8,1.3856406460551018,-3.2,-0.,0.,-3.2,-0.4,0.692820323027551,-3.2,-0.8,1.385640646055102,-3.2,-0.,0.,-3.2,-0.8,0.,-3.2,-1.6,0.,-3.2,0.,0.,-1.6,0.8,0.,-1.6,1.6,0.,-1.6,0.,0.,-1.6,0.4,0.6928203230275509,-1.6,0.8,1.3856406460551018,-1.6,-0.,0.,-1.6,-0.4,0.692820323027551,-1.6,-0.8,1.385640646055102,-1.6,-0.,0.,-1.6,-0.8,0.,-1.6,-1.6,0.,-1.6],60,3)
5268         ref_a.setInfoOnComponents(comps)
5269         self.assertTrue(a.isEqual(ref_a,1e-14))
5270         self.assertEqual(b,[3,4,5])
5271         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
5272         for i in range(1):
5273             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
5274             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
5275             ffCell.loadArraysIfNecessary()
5276             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
5277             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
5278             self.assertTrue(v.isEqual(DataArrayDouble([0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0,2.1,2.2,2.3]),1e-14))
5279             pass
5280         pass
5281
5282     @WriteInTmpDir
5283     def test38(self):
5284         """ Introduction of non cartesian meshes management. Here spherical."""
5285         fname="ForMEDReader38.med"
5286         meshName="mesh"
5287         description="Spherical grid"
5288         comps=["X [cm]","Y [cm]","Z [cm]"]
5289         arrX=DataArrayDouble(3) ; arrX.iota() ; arrX*=0.8 ; arrX.setInfoOnComponent(0,comps[0])
5290         arrY=DataArrayDouble(4) ; arrY.iota() ; arrY*=pi/(len(arrY)-1) ; arrY.setInfoOnComponent(0,comps[1])
5291         arrZ=DataArrayDouble(5) ; arrZ.iota() ; arrZ*=2*pi/(len(arrZ)-1) ; arrZ.setInfoOnComponent(0,comps[2])
5292         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ) ; m.setName(meshName)
5293         mm=MEDFileCMesh() ; mm.setMesh(m) ; mm.setDescription(description)
5294         mm.setAxisType(AX_SPHER) # the test is here !
5295         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m) ; f.setName("Field")
5296         arr=DataArrayDouble(m.getNumberOfCells()) ; arr.iota() ; arr*=0.1 ; f.setArray(arr) ; f.checkConsistencyLight()
5297         ff=MEDFileField1TS() ; ff.setFieldNoProfileSBT(f)
5298         fmts=MEDFileFieldMultiTS() ; fmts.pushBackTimeStep(ff)
5299         #
5300         ms=MEDFileMeshes() ; ms.pushMesh(mm)
5301         fields=MEDFileFields() ; fields.pushField(fmts)
5302         ms.write(fname,2) ; fields.write(fname,0)
5303         #
5304         del mm,fmts,fields,ms
5305         ms=MEDFileMeshes(fname)
5306         fields=MEDFileFields(fname,False)
5307         ms.cartesianizeMe()
5308         #
5309         fields.removeFieldsWithoutAnyTimeStep()
5310         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
5311         allFMTSLeavesToDisplay=[]
5312         for fields in fields_per_mesh:
5313             allFMTSLeavesToDisplay2=[]
5314             for fmts in fields:
5315                 tmp=fmts.splitDiscretizations()
5316                 for itmp in tmp:
5317                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
5318                     pass
5319                 allFMTSLeavesToDisplay2+=tmp
5320                 pass
5321             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
5322             pass
5323         #
5324         self.assertEqual(len(allFMTSLeavesToDisplay),1)
5325         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
5326         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
5327         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
5328         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
5329         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
5330         #
5331         mst=MEDFileMeshStruct.New(ms[0])
5332         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
5333         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5334         mml2=mml.prepare()
5335         self.assertTrue(isinstance(mml2,MEDCurveLinearMeshMultiLev))
5336         a,b,c=mml2.buildVTUArrays()
5337         self.assertTrue(c)# the array is thoose in structure
5338         ref_a=DataArrayDouble([0.,0.,0.,0.,0.,0.8,0.,0.,1.6,0.,0.,0.,0.6928203230275509,0.,0.4,1.3856406460551018,0.,0.8,0.,0.,-0.,0.692820323027551,0.,-0.4,1.385640646055102,0.,-0.8,0.,0.,-0.,0.,0.,-0.8,0.,0.,-1.6,0.,0.,0.,0.,0.,0.8,0.,0.,1.6,0.,0.,0.,0.,0.6928203230275509,0.4,0.,1.3856406460551018,0.8,0.,0.,-0.,0.,0.692820323027551,-0.4,0.,1.385640646055102,-0.8,0.,0.,-0.,0.,0.,-0.8,0.,0.,-1.6,-0.,0.,0.,-0.,0.,0.8,-0.,0.,1.6,-0.,0.,0.,-0.6928203230275509,0.,0.4,-1.3856406460551018,0.,0.8,-0.,0.,-0.,-0.692820323027551,0.,-0.4,-1.385640646055102,0.,-0.8,-0.,0.,-0.,0.,0.,-0.8,0.,0.,-1.6,-0.,-0.,0.,-0.,-0.,0.8,-0.,-0.,1.6,-0.,-0.,0.,0.,-0.6928203230275509,0.4,0.,-1.3856406460551018,0.8,-0.,-0.,-0.,0.,-0.692820323027551,-0.4,0.,-1.385640646055102,-0.8,-0.,-0.,-0.,0.,0.,-0.8,0.,0.,-1.6,0.,-0.,0.,0.,-0.,0.8,0.,-0.,1.6,0.,-0.,0.,0.6928203230275509,0.,0.4,1.3856406460551018,0.,0.8,0.,-0.,-0.,0.692820323027551,0.,-0.4,1.385640646055102,0.,-0.8,0.,-0.,-0.,0.,0.,-0.8,0.,0.,-1.6],60,3)
5339         ref_a.setInfoOnComponents(comps)
5340         self.assertTrue(a.isEqual(ref_a,1e-14))
5341         self.assertEqual(b,[3,4,5])
5342         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
5343         for i in range(1):
5344             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
5345             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
5346             ffCell.loadArraysIfNecessary()
5347             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
5348             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
5349             self.assertTrue(v.isEqual(DataArrayDouble([0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0,2.1,2.2,2.3]),1e-14))
5350             pass
5351         pass
5352
5353     @WriteInTmpDir
5354     def test39(self):
5355         """Idem test37, test38, test39, test40 except that here it is an unstructured mesh."""
5356         fname="ForMEDReader39.med"
5357         meshName="mesh"
5358         description="Spherical grid"
5359         comps=["X [cm]","Y [cm]","Z [cm]"]
5360         arrX=DataArrayDouble(3) ; arrX.iota() ; arrX*=0.8 ; arrX.setInfoOnComponent(0,comps[0])
5361         arrY=DataArrayDouble(4) ; arrY.iota() ; arrY*=pi/(len(arrY)-1) ; arrY.setInfoOnComponent(0,comps[1])
5362         arrZ=DataArrayDouble(5) ; arrZ.iota() ; arrZ*=2*pi/(len(arrZ)-1) ; arrZ.setInfoOnComponent(0,comps[2])
5363         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ) ; m.setName(meshName) ; m=m.buildUnstructured()
5364         mm=MEDFileUMesh() ; mm[0]=m ; mm.setDescription(description) # the test is here : UMesh !
5365         mm.setAxisType(AX_SPHER) # the test is here !
5366         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m) ; f.setName("Field")
5367         arr=DataArrayDouble(m.getNumberOfCells()) ; arr.iota() ; arr*=0.1 ; f.setArray(arr) ; f.checkConsistencyLight()
5368         ff=MEDFileField1TS() ; ff.setFieldNoProfileSBT(f)
5369         fmts=MEDFileFieldMultiTS() ; fmts.pushBackTimeStep(ff)
5370         #
5371         ms=MEDFileMeshes() ; ms.pushMesh(mm)
5372         fields=MEDFileFields() ; fields.pushField(fmts)
5373         ms.write(fname,2) ; fields.write(fname,0)
5374         #
5375         del mm,fmts,fields,ms
5376         ms=MEDFileMeshes(fname)
5377         fields=MEDFileFields(fname,False)
5378         #
5379         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
5380         fields=MEDFileFields(fname,False)
5381         fields.removeFieldsWithoutAnyTimeStep()
5382         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
5383         allFMTSLeavesToDisplay=[]
5384         for fields in fields_per_mesh:
5385             allFMTSLeavesToDisplay2=[]
5386             for fmts in fields:
5387                 tmp=fmts.splitDiscretizations()
5388                 for itmp in tmp:
5389                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
5390                     pass
5391                 allFMTSLeavesToDisplay2+=tmp
5392                 pass
5393             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
5394             pass
5395         #
5396         self.assertEqual(len(allFMTSLeavesToDisplay),1)
5397         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
5398         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
5399         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
5400         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
5401         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
5402         #
5403         mst=MEDFileMeshStruct.New(ms[0])
5404         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
5405         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5406         mml2=mml.prepare()
5407         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
5408         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
5409         self.assertTrue(ncc)
5410         ref_a=DataArrayDouble([0.,0.,0.,0.,0.,0.8,0.,0.,1.6,0.,0.,0.,0.6928203230275509,0.,0.4,1.3856406460551018,0.,0.8,0.,0.,-0.,0.692820323027551,0.,-0.4,1.385640646055102,0.,-0.8,0.,0.,-0.,0.,0.,-0.8,0.,0.,-1.6,0.,0.,0.,0.,0.,0.8,0.,0.,1.6,0.,0.,0.,0.,0.6928203230275509,0.4,0.,1.3856406460551018,0.8,0.,0.,-0.,0.,0.692820323027551,-0.4,0.,1.385640646055102,-0.8,0.,0.,-0.,0.,0.,-0.8,0.,0.,-1.6,-0.,0.,0.,-0.,0.,0.8,-0.,0.,1.6,-0.,0.,0.,-0.6928203230275509,0.,0.4,-1.3856406460551018,0.,0.8,-0.,0.,-0.,-0.692820323027551,0.,-0.4,-1.385640646055102,0.,-0.8,-0.,0.,-0.,0.,0.,-0.8,0.,0.,-1.6,-0.,-0.,0.,-0.,-0.,0.8,-0.,-0.,1.6,-0.,-0.,0.,0.,-0.6928203230275509,0.4,0.,-1.3856406460551018,0.8,-0.,-0.,-0.,0.,-0.692820323027551,-0.4,0.,-1.385640646055102,-0.8,-0.,-0.,-0.,0.,0.,-0.8,0.,0.,-1.6,0.,-0.,0.,0.,-0.,0.8,0.,-0.,1.6,0.,-0.,0.,0.6928203230275509,0.,0.4,1.3856406460551018,0.,0.8,0.,-0.,-0.,0.692820323027551,0.,-0.4,1.385640646055102,0.,-0.8,0.,-0.,-0.,0.,0.,-0.8,0.,0.,-1.6],60,3)
5411         ref_a.setInfoOnComponents(comps)
5412         self.assertTrue(a0.isEqual(ref_a,1e-14))#<- Test is here
5413         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
5414         for i in range(1):
5415             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
5416             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
5417             ffCell.loadArraysIfNecessary()
5418             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
5419             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
5420             self.assertTrue(v.isEqual(DataArrayDouble([0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0,2.1,2.2,2.3]),1e-14))
5421         pass
5422
5423     @WriteInTmpDir
5424     def test40(self):
5425         """Idem test37, test38, test39, test40 except that here it is a CL mesh."""
5426         fname="ForMEDReader40.med"
5427         meshName="mesh"
5428         description="Spherical grid"
5429         comps=["X [cm]","Y [cm]","Z [cm]"]
5430         arrX=DataArrayDouble(3) ; arrX.iota() ; arrX*=0.8 ; arrX.setInfoOnComponent(0,comps[0])
5431         arrY=DataArrayDouble(4) ; arrY.iota() ; arrY*=pi/(len(arrY)-1) ; arrY.setInfoOnComponent(0,comps[1])
5432         arrZ=DataArrayDouble(5) ; arrZ.iota() ; arrZ*=2*pi/(len(arrZ)-1) ; arrZ.setInfoOnComponent(0,comps[2])
5433         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ) ; m.setName(meshName) ; m=m.buildCurveLinear()
5434         mm=MEDFileCurveLinearMesh() ; mm.setMesh(m) ; mm.setDescription(description) # the test is here CLMesh!
5435         mm.setAxisType(AX_SPHER) # the test is here !
5436         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m) ; f.setName("Field")
5437         arr=DataArrayDouble(m.getNumberOfCells()) ; arr.iota() ; arr*=0.1 ; f.setArray(arr) ; f.checkConsistencyLight()
5438         ff=MEDFileField1TS() ; ff.setFieldNoProfileSBT(f)
5439         fmts=MEDFileFieldMultiTS() ; fmts.pushBackTimeStep(ff)
5440         #
5441         ms=MEDFileMeshes() ; ms.pushMesh(mm)
5442         fields=MEDFileFields() ; fields.pushField(fmts)
5443         ms.write(fname,2) ; fields.write(fname,0)
5444         #
5445         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
5446         fields=MEDFileFields(fname,False)
5447         fields.removeFieldsWithoutAnyTimeStep()
5448         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
5449         allFMTSLeavesToDisplay=[]
5450         for fields in fields_per_mesh:
5451             allFMTSLeavesToDisplay2=[]
5452             for fmts in fields:
5453                 tmp=fmts.splitDiscretizations()
5454                 for itmp in tmp:
5455                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
5456                     pass
5457                 allFMTSLeavesToDisplay2+=tmp
5458                 pass
5459             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
5460             pass
5461         #
5462         self.assertEqual(len(allFMTSLeavesToDisplay),1)
5463         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
5464         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
5465         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
5466         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
5467         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
5468         #
5469         mst=MEDFileMeshStruct.New(ms[0])
5470         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
5471         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5472         mml2=mml.prepare()
5473         self.assertTrue(isinstance(mml2,MEDCurveLinearMeshMultiLev))
5474         a,b,c=mml2.buildVTUArrays()
5475         self.assertTrue(c)
5476         ref_a=DataArrayDouble([0.,0.,0.,0.,0.,0.8,0.,0.,1.6,0.,0.,0.,0.6928203230275509,0.,0.4,1.3856406460551018,0.,0.8,0.,0.,-0.,0.692820323027551,0.,-0.4,1.385640646055102,0.,-0.8,0.,0.,-0.,0.,0.,-0.8,0.,0.,-1.6,0.,0.,0.,0.,0.,0.8,0.,0.,1.6,0.,0.,0.,0.,0.6928203230275509,0.4,0.,1.3856406460551018,0.8,0.,0.,-0.,0.,0.692820323027551,-0.4,0.,1.385640646055102,-0.8,0.,0.,-0.,0.,0.,-0.8,0.,0.,-1.6,-0.,0.,0.,-0.,0.,0.8,-0.,0.,1.6,-0.,0.,0.,-0.6928203230275509,0.,0.4,-1.3856406460551018,0.,0.8,-0.,0.,-0.,-0.692820323027551,0.,-0.4,-1.385640646055102,0.,-0.8,-0.,0.,-0.,0.,0.,-0.8,0.,0.,-1.6,-0.,-0.,0.,-0.,-0.,0.8,-0.,-0.,1.6,-0.,-0.,0.,0.,-0.6928203230275509,0.4,0.,-1.3856406460551018,0.8,-0.,-0.,-0.,0.,-0.692820323027551,-0.4,0.,-1.385640646055102,-0.8,-0.,-0.,-0.,0.,0.,-0.8,0.,0.,-1.6,0.,-0.,0.,0.,-0.,0.8,0.,-0.,1.6,0.,-0.,0.,0.6928203230275509,0.,0.4,1.3856406460551018,0.,0.8,0.,-0.,-0.,0.692820323027551,0.,-0.4,1.385640646055102,0.,-0.8,0.,-0.,-0.,0.,0.,-0.8,0.,0.,-1.6],60,3)
5477         ref_a.setInfoOnComponents(comps)
5478         self.assertTrue(a.isEqual(ref_a,1e-14))#<- Test is here
5479         self.assertEqual(b,[3,4,5])
5480         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
5481         for i in range(1):
5482             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
5483             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
5484             ffCell.loadArraysIfNecessary()
5485             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
5486             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
5487             self.assertTrue(v.isEqual(DataArrayDouble([0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0,2.1,2.2,2.3]),1e-14))
5488         pass
5489
5490     @WriteInTmpDir
5491     def test41(self):
5492         """This test focused on bug revealed with // load of multi nodes field with no profile. The error was the first node field (dataarray partdef) change the partdef for the others ! """
5493         fname="ForMEDReader41.med"
5494         meshName="mesh"
5495         nx=5
5496         arr=DataArrayDouble(nx) ; arr.iota()
5497         m=MEDCouplingCMesh() ; m.setCoords(arr,arr) ; m=m.buildUnstructured() ; m.setName(meshName)
5498         renum=DataArrayInt.Aggregate([DataArrayInt.Range(0,m.getNumberOfCells(),2),DataArrayInt.Range(1,m.getNumberOfCells(),2)])
5499         m=m[renum] # important think to renum if not we see nothing. The goal if to have dynamic_cast<DataPartDefinition>!=NULL
5500         mm=MEDFileUMesh() ; mm[0]=m
5501         mm.write(fname,2)
5502         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m) ; f0.setName("aaa")
5503         arr0=DataArrayDouble(nx*nx) ; arr0.iota() ; f0.setArray(arr0)
5504         ff0=MEDFileField1TS() ; ff0.setFieldNoProfileSBT(f0)
5505         f1=MEDCouplingFieldDouble(ON_NODES) ; f1.setMesh(m) ; f1.setName("bbb")
5506         arr1=DataArrayDouble(nx*nx) ; arr1.iota() ; arr1+=100 ; f1.setArray(arr1)
5507         ff1=MEDFileField1TS() ; ff1.setFieldNoProfileSBT(f1)
5508         ff0.write(fname,0) ; ff1.write(fname,0)
5509         #
5510         a=8 ; b=16
5511         ms=MEDFileMeshes()
5512         mm=MEDFileUMesh.LoadPartOf(fname,meshName,[NORM_QUAD4],[a,b,1],-1,-1)
5513         ms.pushMesh(mm)
5514         ms[0].zipCoords()
5515         ms.cartesianizeMe()
5516         fields=MEDFileFields.LoadPartOf(fname,False,ms);
5517         fields.removeFieldsWithoutAnyTimeStep()
5518         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
5519         allFMTSLeavesToDisplay=[]
5520         for fields in fields_per_mesh:
5521             allFMTSLeavesToDisplay2=[]
5522             for fmts in fields:
5523                 tmp=fmts.splitDiscretizations()
5524                 for itmp in tmp:
5525                     if itmp.presenceOfMultiDiscPerGeoType():
5526                         tmp2=itmp.splitMultiDiscrPerGeoTypes()
5527                         for iii,itmp2 in enumerate(tmp2):
5528                             name="%s_%i"%(itmp2.getName(),iii)
5529                             itmp2.setName(name)
5530                             allFMTSLeavesToDisplay2.append(itmp2)
5531                             pass
5532                         pass
5533                     else:
5534                         allFMTSLeavesToDisplay2.append(itmp)
5535                         pass
5536                     pass
5537                 allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
5538                 pass
5539         # GO for reading in MEDReader, by not loading all. Mesh is fully loaded but not fields values
5540         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
5541         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
5542         mst=MEDFileMeshStruct.New(ms[0])
5543         fcscp=allFMTSLeavesPerCommonSupport[0][1]
5544         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5545         mml2=mml.prepare()
5546         #
5547         f2=allFMTSLeavesPerCommonSupport[0][0][0][0]
5548         fsst=MEDFileField1TSStructItem.BuildItemFrom(f2,mst)
5549         f2.loadArraysIfNecessary()
5550         v0=mml.buildDataArray(fsst,fields,f2.getUndergroundDataArray())
5551         assert(v0.isEqual(DataArrayDouble([1,2,3,4,6,7,8,9,11,12,13,14,16,17,18,19,21,22,23,24]),1e-12))
5552         #
5553         f2=allFMTSLeavesPerCommonSupport[0][0][1][0]
5554         fsst=MEDFileField1TSStructItem.BuildItemFrom(f2,mst)
5555         f2.loadArraysIfNecessary()
5556         v1=mml.buildDataArray(fsst,fields,f2.getUndergroundDataArray())
5557         assert(v1.isEqual(DataArrayDouble([101,102,103,104,106,107,108,109,111,112,113,114,116,117,118,119,121,122,123,124]),1e-12))
5558         pass
5559
5560     @WriteInTmpDir
5561     def test42(self):
5562         """ EDF14869 - SEG4 """
5563         fname="ForMEDReader42.med"
5564         meshName="mesh"
5565         #
5566         a0exp=DataArrayDouble([0.,1.,0.3,0.7])
5567         m=MEDCouplingUMesh("mesh",1)
5568         m.setCoords(a0exp)
5569         m.allocateCells()
5570         m.insertNextCell(NORM_SEG4,[0,1,2,3])
5571         mm=MEDFileUMesh() ; mm[0]=m
5572         #
5573         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m) ; f.setName("Field")
5574         arr=DataArrayDouble(m.getNumberOfCells()) ; arr.iota() ; arr*=0.1 ; f.setArray(arr) ; f.checkConsistencyLight()
5575         ff=MEDFileField1TS() ; ff.setFieldNoProfileSBT(f)
5576         fmts=MEDFileFieldMultiTS() ; fmts.pushBackTimeStep(ff)
5577         #
5578         ms=MEDFileMeshes() ; ms.pushMesh(mm)
5579         fields=MEDFileFields() ; fields.pushField(fmts)
5580         ms.write(fname,2) ; fields.write(fname,0)
5581         #
5582         ms=MEDFileMeshes(fname)
5583         fields=MEDFileFields(fname,False)
5584         fields.removeFieldsWithoutAnyTimeStep()
5585         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
5586         allFMTSLeavesToDisplay=[]
5587         for fields in fields_per_mesh:
5588             allFMTSLeavesToDisplay2=[]
5589             for fmts in fields:
5590                 tmp=fmts.splitDiscretizations()
5591                 for itmp in tmp:
5592                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
5593                     pass
5594                 allFMTSLeavesToDisplay2+=tmp
5595                 pass
5596             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
5597             pass
5598         #
5599         self.assertEqual(len(allFMTSLeavesToDisplay),1)
5600         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
5601         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
5602         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
5603         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
5604         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
5605         #
5606         mst=MEDFileMeshStruct.New(ms[0])
5607         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
5608         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5609         mml2=mml.prepare()
5610         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
5611         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
5612         self.assertTrue(not ncc)
5613         self.assertTrue(a0.isEqual(a0exp.changeNbOfComponents(3,0.),1e-12))
5614         self.assertTrue(a1.isEqual(DataArrayByte([35])))# VTK_CUBIC_LINE
5615         self.assertTrue(a2.isEqual(DataArrayInt([0])))
5616         self.assertTrue(a3.isEqual(DataArrayInt([4,0,1,2,3])))
5617         self.assertTrue(a4 is None)
5618         self.assertTrue(a5 is None)
5619         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
5620         for i in range(1):
5621             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
5622             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
5623             ffCell.loadArraysIfNecessary()
5624             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
5625             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
5626             self.assertTrue(v.isEqual(DataArrayDouble([0.0]),1e-14))
5627         pass
5628
5629     pass
5630
5631 if __name__ == "__main__":
5632   unittest.main()