src/MEDLoader/Swig/MEDLoaderTest4.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2021  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         self.assertEqual(mm.getSpaceDimension(), m.getSpaceDimension())
1257         fam=DataArrayInt(8) ; fam.iota(0) ; mm.setFamilyFieldArr(0,fam) ; del fam
1258         num=DataArrayInt(8) ; num.iota(100) ; mm.setRenumFieldArr(0,num) ; del num
1259         #
1260         fieldName0="zeField0" ; # on cells
1261         fieldName1="zeField1" ; pfl1=DataArrayInt([2,3,6,7]) ; pfl1.setName("pfl1") # on cells
1262         fieldName2="zeField2" ; pfl2=DataArrayInt([2,3,4,7,8,9,12,13,14]) ; pfl2.setName("pfl2") # on nodes
1263         fieldName3="zeField3" ; pfl3=DataArrayInt([2,3,5,7]) ; pfl3.setName("pfl3") # on cells but different support
1264         fieldName4="zeField4" ;# on nodes
1265         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS() ; fs4=MEDFileFieldMultiTS()
1266         #
1267         for i in range(5):
1268             f=MEDFileField1TS()
1269             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1270             fNode.setName(fieldName0) ; fNode.setMesh(m)
1271             arr=DataArrayDouble(2*8) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1272             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkConsistencyLight()
1273             f.setFieldNoProfileSBT(fNode)
1274             fs0.pushBackTimeStep(f)
1275             #
1276             f=MEDFileField1TS()
1277             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1278             fNode.setName(fieldName1)
1279             arr=DataArrayDouble(2*4) ; arr.iota(100+1000*i) ; arr.rearrange(2)
1280             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
1281             f.setFieldProfile(fNode,mm,0,pfl1)
1282             self.assertEqual(pfl1.getName(),"pfl1")
1283             fs1.pushBackTimeStep(f)
1284             #
1285             f=MEDFileField1TS()
1286             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1287             fNode.setName(fieldName2)
1288             arr=DataArrayDouble(2*9) ; arr.iota(200+1000*i) ; arr.rearrange(2)
1289             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
1290             f.setFieldProfile(fNode,mm,0,pfl2)
1291             self.assertEqual(pfl2.getName(),"pfl2")
1292             fs2.pushBackTimeStep(f)
1293             #
1294             f=MEDFileField1TS()
1295             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1296             fNode.setName(fieldName3)
1297             arr=DataArrayDouble(2*4) ; arr.iota(300+1000*i) ; arr.rearrange(2)
1298             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_3 [m]","Com2_3 [s^2]"])
1299             f.setFieldProfile(fNode,mm,0,pfl3)
1300             self.assertEqual(pfl3.getName(),"pfl3")
1301             fs3.pushBackTimeStep(f)
1302             #
1303             f=MEDFileField1TS()
1304             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1305             fNode.setName(fieldName4) ; fNode.setMesh(m)
1306             arr=DataArrayDouble(2*15) ; arr.iota(400+1000*i) ; arr.rearrange(2)
1307             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_4 [m]","Com2_4 [s^2]"]) ; fNode.checkConsistencyLight()
1308             f.setFieldNoProfileSBT(fNode)
1309             fs4.pushBackTimeStep(f)
1310             pass
1311         mm.write(fname,2)
1312         fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0) ; fs4.write(fname,0)
1313         del m,mm,fs1,fs2,fs3,f,fNode
1314         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1315         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
1316         fields=MEDFileFields(fname,False)
1317         fields.removeFieldsWithoutAnyTimeStep()
1318         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1319         allFMTSLeavesToDisplay=[]
1320         for fields in fields_per_mesh:
1321             allFMTSLeavesToDisplay2=[]
1322             for fmts in fields:
1323                 tmp=fmts.splitDiscretizations()
1324                 for itmp in tmp:
1325                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
1326                     pass
1327                 allFMTSLeavesToDisplay2+=tmp
1328                 pass
1329             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1330             pass
1331         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1332         self.assertEqual(len(allFMTSLeavesToDisplay[0]),5)
1333         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1334         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 5 fields are defined on the same time steps
1335         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),5)
1336         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1337         self.assertEqual(len(allFMTSLeavesPerCommonSupport),3)
1338         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
1339         self.assertEqual(len(allFMTSLeavesPerCommonSupport[1][0]),2)
1340         self.assertEqual(len(allFMTSLeavesPerCommonSupport[2][0]),1)
1341         #
1342         mst=MEDFileMeshStruct.New(ms[0])
1343         #
1344         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1345         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1346         mml2=mml.prepare()
1347         self.assertTrue(isinstance(mml2,MEDCurveLinearMeshMultiLev))
1348         a,b,c=mml2.buildVTUArrays()
1349         self.assertTrue(c)#True here because a is directly coming from internal data without copy
1350         self.assertTrue(a.isEqual(a0Exp,1e-12))
1351         self.assertEqual(b,[5,3])
1352         a6,a7=mml2.retrieveFamilyIdsOnCells()
1353         self.assertTrue(a6.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
1354         self.assertTrue(a7) # True because no copy
1355         a8,a9=mml2.retrieveNumberIdsOnCells()
1356         self.assertTrue(a8.isEqual(DataArrayInt([100,101,102,103,104,105,106,107])))
1357         self.assertTrue(a9) # True because no copy
1358         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1359         for i in range(1, 5):
1360             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1361             pass
1362         for i in range(5):
1363             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1364             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1365             f.loadArraysIfNecessary()
1366             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1367             self.assertEqual(f.getName(),fieldName0)
1368             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1369             vExp=DataArrayDouble(8*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
1370             self.assertTrue(v.isEqual(vExp,1e-12))
1371             #
1372             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
1373             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1374             f.loadArraysIfNecessary()
1375             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1376             self.assertEqual(f.getName(),fieldName4)
1377             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1378             vExp=DataArrayDouble(15*2) ; vExp.iota(400+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_4 [m]','Com2_4 [s^2]'])
1379             self.assertTrue(v.isEqual(vExp,1e-12))
1380             pass
1381         #
1382         fcscp=allFMTSLeavesPerCommonSupport[1][1]
1383         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1384         mml2=mml.prepare()
1385         self.assertTrue(isinstance(mml2,MEDCurveLinearMeshMultiLev)) # here the 2nd support is a part of CMesh that is also a CMesh -> CMesh not a UMesh
1386         a,b,c=mml2.buildVTUArrays()
1387         self.assertTrue(not c)#False here because a is the result of a computation not the internal structure
1388         self.assertTrue(a.isEqual(a0Exp[pfl2],1e-12))
1389         self.assertEqual(b,[3,3])
1390         a6,a7=mml2.retrieveFamilyIdsOnCells()
1391         self.assertTrue(a6.isEqual(DataArrayInt([2,3,6,7])))
1392         self.assertTrue(not a7) # False because copy
1393         a8,a9=mml2.retrieveNumberIdsOnCells()
1394         self.assertTrue(a8.isEqual(DataArrayInt([102,103,106,107])))
1395         self.assertTrue(not a9) # False because copy
1396         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1397         for i in range(1, 5):
1398             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1399             pass
1400         for i in range(5):
1401             f=allFMTSLeavesPerCommonSupport[1][0][0][i]
1402             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1403             f.loadArraysIfNecessary()
1404             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1405             self.assertEqual(f.getName(),fieldName1)
1406             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1407             vExp=DataArrayDouble(4*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
1408             self.assertTrue(v.isEqual(vExp,1e-12))
1409             #
1410             f=allFMTSLeavesPerCommonSupport[1][0][1][i]
1411             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1412             f.loadArraysIfNecessary()
1413             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1414             self.assertEqual(f.getName(),fieldName2)
1415             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1416             vExp=DataArrayDouble(9*2) ; vExp.iota(200+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
1417             self.assertTrue(v.isEqual(vExp,1e-12))
1418             pass
1419         #
1420         fcscp=allFMTSLeavesPerCommonSupport[2][1]
1421         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1422         mml2=mml.prepare()
1423         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev)) # here the 3rd support is a part of CMesh but impossible to simplify more than a UMesh
1424         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1425         self.assertTrue(not ncc)
1426         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)
1427         a0Exp.setInfoOnComponents(["XX [m]","YYY [km]"])
1428         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
1429         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9])))
1430         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15])))
1431         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])))
1432         self.assertTrue(a4 is None)
1433         self.assertTrue(a5 is None)
1434         a6,a7=mml2.retrieveFamilyIdsOnCells()
1435         self.assertTrue(a6.isEqual(DataArrayInt([2,3,5,7])))
1436         self.assertTrue(not a7) # False because copy
1437         a8,a9=mml2.retrieveNumberIdsOnCells()
1438         self.assertTrue(a8.isEqual(DataArrayInt([102,103,105,107])))
1439         self.assertTrue(not a9) # False because copy
1440         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1441         for i in range(5):
1442             f=allFMTSLeavesPerCommonSupport[2][0][0][i]
1443             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1444             f.loadArraysIfNecessary()
1445             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1446             self.assertEqual(f.getName(),fieldName3)
1447             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1448             vExp=DataArrayDouble(4*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_3 [m]','Com2_3 [s^2]'])
1449             self.assertTrue(v.isEqual(vExp,1e-12))
1450             pass
1451         pass
1452
1453     @WriteInTmpDir
1454     def test8(self):
1455         """ This test plays with with gauss fields with no profiles.
1456         """
1457         fname="ForMEDReader8.med"
1458         # building a mesh containing 6 tri3 + 5 quad4
1459         m=MEDCouplingUMesh("mesh",2)
1460         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]"])
1461         m.setCoords(coords)
1462         m.allocateCells()
1463         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])
1464         m.insertNextCell(NORM_TRI3,[13,9,8]) ; m.insertNextCell(NORM_TRI3,[13,14,9])
1465         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])
1466         m.insertNextCell(NORM_QUAD4,[12,13,8,7])
1467         mm=MEDFileUMesh() ; mm.setMeshes([m])
1468         #
1469         fieldName0="zeField0"
1470         fieldName1="zeField1"
1471         fieldName2="zeField2"
1472         fieldName3="zeField3"
1473         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS()
1474         for i in range(5):
1475             f=MEDFileField1TS()
1476             fNode=MEDCouplingFieldDouble(ON_GAUSS_NE) ; fNode.setTime(float(i),i,0)
1477             fNode.setName(fieldName0) ; fNode.setMesh(m)
1478             arr=DataArrayDouble(2*38) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1479             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkConsistencyLight()
1480             f.setFieldNoProfileSBT(fNode)
1481             fs0.pushBackTimeStep(f)
1482             #
1483             f=MEDFileField1TS()
1484             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1485             fNode.setName(fieldName1) ; fNode.setMesh(m)
1486             arr=DataArrayDouble(2*11) ; arr.iota(100+1000*i) ; arr.rearrange(2)
1487             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"]) ; fNode.checkConsistencyLight()
1488             f.setFieldNoProfileSBT(fNode)
1489             fs1.pushBackTimeStep(f)
1490             #
1491             f=MEDFileField1TS()
1492             fNode=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fNode.setTime(float(i),i,0)
1493             fNode.setName(fieldName2) ; fNode.setMesh(m)
1494             fNode.setGaussLocalizationOnCells([0,1,2,3],[0.,0.,1.,0.,0.,1.],[0.5,0.5,0.7,0.7],[0.8,0.2])
1495             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])
1496             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])
1497             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])
1498             arr=DataArrayDouble(2*(4*2+2*5+3*4+2*7)) ; arr.iota(300+1000*i) ; arr.rearrange(2)
1499             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"]) ; fNode.checkConsistencyLight()
1500             f.setFieldNoProfileSBT(fNode)
1501             fs2.pushBackTimeStep(f)
1502             #
1503             f=MEDFileField1TS()
1504             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1505             fNode.setName(fieldName3) ; fNode.setMesh(m)
1506             arr=DataArrayDouble(2*15) ; arr.iota(400+1000*i) ; arr.rearrange(2)
1507             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_3 [m]","Com2_3 [s^2]"]) ; fNode.checkConsistencyLight()
1508             f.setFieldNoProfileSBT(fNode)
1509             fs3.pushBackTimeStep(f)
1510             #
1511             pass
1512         #
1513         mm.write(fname,2)
1514         fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0)
1515         a0Exp=mm.getCoords().deepCopy()
1516         del m,mm,fs1,fs2,fs3,f,fNode
1517         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1518         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
1519         fields=MEDFileFields(fname,False)
1520         fields.removeFieldsWithoutAnyTimeStep()
1521         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1522         allFMTSLeavesToDisplay=[]
1523         for fields in fields_per_mesh:
1524             allFMTSLeavesToDisplay2=[]
1525             for fmts in fields:
1526                 tmp=fmts.splitDiscretizations()
1527                 #for itmp in tmp:
1528                 #    self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
1529                 #    pass
1530                 allFMTSLeavesToDisplay2+=tmp
1531                 pass
1532             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1533             pass
1534         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1535         self.assertEqual(len(allFMTSLeavesToDisplay[0]),4)
1536         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1537         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 4 fields are defined on the same time steps
1538         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
1539         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1540         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
1541         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),4)
1542         #
1543         mst=MEDFileMeshStruct.New(ms[0])
1544         #
1545         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1546         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1547         mml2=mml.prepare()
1548         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
1549         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1550         self.assertTrue(not ncc)
1551         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
1552         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5,5,5,5,9,9,9,9,9])))
1553         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,12,16,20,24,29,34,39,44])))
1554         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])))
1555         self.assertTrue(a4 is None)
1556         self.assertTrue(a5 is None)
1557         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1558         for i in range(1, 5):
1559             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1560             pass
1561         for i in range(5):
1562             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1563             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1564             f.loadArraysIfNecessary()
1565             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1566             self.assertEqual(f.getName(),fieldName0)
1567             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1568             vExp=DataArrayDouble(38*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
1569             self.assertTrue(v.isEqual(vExp,1e-12))
1570             #
1571             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
1572             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1573             f.loadArraysIfNecessary()
1574             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1575             self.assertEqual(f.getName(),fieldName1)
1576             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1577             vExp=DataArrayDouble(11*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
1578             self.assertTrue(v.isEqual(vExp,1e-12))
1579             #
1580             f=allFMTSLeavesPerCommonSupport[0][0][2][i]
1581             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1582             f.loadArraysIfNecessary()
1583             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1584             self.assertEqual(f.getName(),fieldName2)
1585             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug
1586             vExp=DataArrayDouble(44*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
1587             self.assertTrue(v.isEqual(vExp,1e-12))
1588             #
1589             f=allFMTSLeavesPerCommonSupport[0][0][3][i]
1590             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1591             f.loadArraysIfNecessary()
1592             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1593             self.assertEqual(f.getName(),fieldName3)
1594             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1595             vExp=DataArrayDouble(15*2) ; vExp.iota(400+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_3 [m]','Com2_3 [s^2]'])
1596             self.assertTrue(v.isEqual(vExp,1e-12))
1597             pass
1598         #
1599         pass
1600
1601     @WriteInTmpDir
1602     def test9(self):
1603         """ This test plays with with gauss fields with profiles.
1604         """
1605         fname="ForMEDReader9.med"
1606         # building a mesh containing 6 tri3 + 5 quad4
1607         m=MEDCouplingUMesh("mesh",2)
1608         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]"])
1609         m.setCoords(coords)
1610         m.allocateCells()
1611         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])
1612         m.insertNextCell(NORM_TRI3,[13,9,8]) ; m.insertNextCell(NORM_TRI3,[13,14,9])
1613         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])
1614         m.insertNextCell(NORM_QUAD4,[12,13,8,7])
1615         mm=MEDFileUMesh() ; mm.setMeshes([m])
1616         #
1617         fieldName0="zeField0"
1618         fieldName1="zeField1"
1619         fieldName2="zeField2"
1620         fieldName3="zeField3"
1621         pfl1=DataArrayInt([0,1,7,9,10]) ; pfl1.setName("pfl1") # on cells
1622         pfl2=DataArrayInt([1,2,3,6,7,8,11,12,13]) ; pfl2.setName("pfl2") # on nodes
1623         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS()
1624         for i in range(5):
1625             f=MEDFileField1TS()
1626             fNode=MEDCouplingFieldDouble(ON_GAUSS_NE) ; fNode.setTime(float(i),i,0)
1627             fNode.setName(fieldName0)
1628             arr=DataArrayDouble(2*18) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1629             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
1630             f.setFieldProfile(fNode,mm,0,pfl1)
1631             fs0.pushBackTimeStep(f)
1632             #
1633             f=MEDFileField1TS()
1634             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1635             fNode.setName(fieldName1)
1636             arr=DataArrayDouble(2*5) ; arr.iota(100+1000*i) ; arr.rearrange(2)
1637             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
1638             f.setFieldProfile(fNode,mm,0,pfl1)
1639             fs1.pushBackTimeStep(f)
1640             #
1641             f=MEDFileField1TS()
1642             fNode=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fNode.setTime(float(i),i,0)
1643             fNode.setName(fieldName2) ; fNode.setMesh(m[pfl1])
1644             fNode.setGaussLocalizationOnCells([0],[0.,0.,1.,0.,0.,1.],[0.5,0.5,0.7,0.7],[0.8,0.2])
1645             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])
1646             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])
1647             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])
1648             arr=DataArrayDouble(2*(2*1+5*1+4*2+7*1)) ; arr.iota(300+1000*i) ; arr.rearrange(2)
1649             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"]) ; fNode.checkConsistencyLight()
1650             f.setFieldProfile(fNode,mm,0,pfl1)
1651             fs2.pushBackTimeStep(f)
1652             #
1653             f=MEDFileField1TS()
1654             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1655             fNode.setName(fieldName3)
1656             arr=DataArrayDouble(2*9) ; arr.iota(400+1000*i) ; arr.rearrange(2)
1657             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_3 [m]","Com2_3 [s^2]"])
1658             f.setFieldProfile(fNode,mm,0,pfl2)
1659             fs3.pushBackTimeStep(f)
1660             #
1661             pass
1662         #
1663         mm.write(fname,2)
1664         fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0)
1665         a0Exp=mm.getCoords().deepCopy()
1666         del m,mm,fs1,fs2,fs3,f,fNode
1667         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1668         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
1669         fields=MEDFileFields(fname,False)
1670         fields.removeFieldsWithoutAnyTimeStep()
1671         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1672         allFMTSLeavesToDisplay=[]
1673         for fields in fields_per_mesh:
1674             allFMTSLeavesToDisplay2=[]
1675             for fmts in fields:
1676                 tmp=fmts.splitDiscretizations()
1677                 #for itmp in tmp:
1678                 #    self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
1679                 #    pass
1680                 allFMTSLeavesToDisplay2+=tmp
1681                 pass
1682             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1683             pass
1684         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1685         self.assertEqual(len(allFMTSLeavesToDisplay[0]),4)
1686         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1687         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 4 fields are defined on the same time steps
1688         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
1689         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1690         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
1691         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),4)
1692         #
1693         mst=MEDFileMeshStruct.New(ms[0])
1694         #
1695         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1696         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1697         mml2=mml.prepare()
1698         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
1699         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1700         self.assertTrue(not ncc)
1701         self.assertTrue(a0.isEqual(a0Exp[pfl2].changeNbOfComponents(3,0.),1e-12))
1702         self.assertTrue(a1.isEqual(DataArrayByte([5,5,9,9,9])))
1703         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,13,18])))
1704         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])))
1705         self.assertTrue(a4 is None)
1706         self.assertTrue(a5 is None)
1707         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1708         for i in range(1, 5):
1709             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1710             pass
1711         for i in range(5):
1712             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1713             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1714             f.loadArraysIfNecessary()
1715             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1716             self.assertEqual(f.getName(),fieldName0)
1717             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1718             vExp=DataArrayDouble(18*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
1719             self.assertTrue(v.isEqual(vExp,1e-12))
1720             #
1721             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
1722             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1723             f.loadArraysIfNecessary()
1724             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1725             self.assertEqual(f.getName(),fieldName1)
1726             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1727             vExp=DataArrayDouble(5*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
1728             self.assertTrue(v.isEqual(vExp,1e-12))
1729             #
1730             f=allFMTSLeavesPerCommonSupport[0][0][2][i]
1731             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1732             f.loadArraysIfNecessary()
1733             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1734             self.assertEqual(f.getName(),fieldName2)
1735             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug
1736             vExp=DataArrayDouble(22*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
1737             self.assertTrue(v.isEqual(vExp,1e-12))
1738             #
1739             f=allFMTSLeavesPerCommonSupport[0][0][3][i]
1740             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1741             f.loadArraysIfNecessary()
1742             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1743             self.assertEqual(f.getName(),fieldName3)
1744             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1745             vExp=DataArrayDouble(9*2) ; vExp.iota(400+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_3 [m]','Com2_3 [s^2]'])
1746             self.assertTrue(v.isEqual(vExp,1e-12))
1747             pass
1748         pass
1749
1750     @WriteInTmpDir
1751     def test10(self):
1752         """ This test plays with fields only on nodes containing profiles.
1753         """
1754         fname="ForMEDReader10.med"
1755         # building a mesh containing 6 tri3 + 5 quad4
1756         m=MEDCouplingUMesh("mesh",2)
1757         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]"])
1758         m.setCoords(coords)
1759         m.allocateCells()
1760         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])
1761         m.insertNextCell(NORM_TRI3,[13,9,8]) ; m.insertNextCell(NORM_TRI3,[13,14,9])
1762         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])
1763         m.insertNextCell(NORM_QUAD4,[12,13,8,7])
1764         mm=MEDFileUMesh() ; mm.setMeshes([m])
1765         #
1766         fieldName0="zeField0"
1767         fieldName1="zeField1"
1768         fieldName2="zeField2"
1769         pfl1=DataArrayInt([1,2,3,6,7,8,11,12,13]) ; pfl1.setName("pfl1") # on nodes
1770         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS()
1771         for i in range(5):
1772             f=MEDFileField1TS()
1773             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1774             fNode.setName(fieldName0)
1775             arr=DataArrayDouble(2*9) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1776             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"])
1777             f.setFieldProfile(fNode,mm,0,pfl1)
1778             fs0.pushBackTimeStep(f)
1779             #
1780             f=MEDFileField1TS()
1781             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1782             fNode.setName(fieldName1)
1783             arr=DataArrayDouble(2*9) ; arr.iota(100+1000*i) ; arr.rearrange(2)
1784             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"])
1785             f.setFieldProfile(fNode,mm,0,pfl1)
1786             fs1.pushBackTimeStep(f)
1787             #
1788             f=MEDFileField1TS()
1789             fNode=MEDCouplingFieldDouble(ON_NODES) ; fNode.setTime(float(i),i,0)
1790             fNode.setName(fieldName2)
1791             arr=DataArrayDouble(2*9) ; arr.iota(200+1000*i) ; arr.rearrange(2)
1792             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"])
1793             f.setFieldProfile(fNode,mm,0,pfl1)
1794             fs2.pushBackTimeStep(f)
1795             #
1796             pass
1797         #
1798         mm.write(fname,2)
1799         fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0)
1800         a0Exp=mm.getCoords().deepCopy()
1801         del m,mm,fs1,fs2,f,fNode
1802         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1803         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
1804         fields=MEDFileFields(fname,False)
1805         fields.removeFieldsWithoutAnyTimeStep()
1806         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1807         allFMTSLeavesToDisplay=[]
1808         for fields in fields_per_mesh:
1809             allFMTSLeavesToDisplay2=[]
1810             for fmts in fields:
1811                 tmp=fmts.splitDiscretizations()
1812                 for itmp in tmp:
1813                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
1814                     pass
1815                 allFMTSLeavesToDisplay2+=tmp
1816                 pass
1817             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1818             pass
1819         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1820         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
1821         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1822         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 4 fields are defined on the same time steps
1823         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
1824         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1825         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
1826         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),3)
1827         #
1828         mst=MEDFileMeshStruct.New(ms[0])
1829         #
1830         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1831         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1832         mml2=mml.prepare()
1833         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
1834         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1835         self.assertTrue(not ncc)
1836         self.assertTrue(a0.isEqual(a0Exp[pfl1].changeNbOfComponents(3,0.),1e-12))
1837         self.assertTrue(a1.isEqual(DataArrayByte([5,5,9,9,9])))
1838         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,13,18])))
1839         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])))
1840         self.assertTrue(a4 is None)
1841         self.assertTrue(a5 is None)
1842         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1843         for i in range(1, 5):
1844             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1845             pass
1846         for i in range(5):
1847             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1848             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1849             f.loadArraysIfNecessary()
1850             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1851             self.assertEqual(f.getName(),fieldName0)
1852             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug
1853             vExp=DataArrayDouble(9*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
1854             self.assertTrue(v.isEqual(vExp,1e-12))
1855             #
1856             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
1857             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1858             f.loadArraysIfNecessary()
1859             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1860             self.assertEqual(f.getName(),fieldName1)
1861             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug
1862             vExp=DataArrayDouble(9*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
1863             self.assertTrue(v.isEqual(vExp,1e-12))
1864             #
1865             f=allFMTSLeavesPerCommonSupport[0][0][2][i]
1866             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1867             f.loadArraysIfNecessary()
1868             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1869             self.assertEqual(f.getName(),fieldName2)
1870             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug
1871             vExp=DataArrayDouble(9*2) ; vExp.iota(200+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
1872             self.assertTrue(v.isEqual(vExp,1e-12))
1873             pass
1874         pass
1875
1876     @WriteInTmpDir
1877     def test11(self):
1878         """ 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 !
1879         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.
1880         """
1881         fname="ForMEDReader11.med"
1882         m=MEDCouplingCMesh("mesh")
1883         arr=DataArrayDouble(5) ; arr.iota()
1884         m.setCoords(arr,arr)
1885         m=m.buildUnstructured() ; m.getCoords().setInfoOnComponents(["XX [m]","YYY [km]"])
1886         mm=MEDFileUMesh() ; mm.setMeshes([m])
1887         #
1888         fieldName0="zeField0"
1889         fs0=MEDFileFieldMultiTS()
1890         for i in range(5):
1891             f=MEDFileField1TS()
1892             fNode=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fNode.setTime(float(i),i,0)
1893             fNode.setName(fieldName0) ; fNode.setMesh(m)
1894             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])
1895             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])
1896             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])
1897             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])
1898             arr=DataArrayDouble(2*(2*6+5*4+4*3+7*3)) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1899             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkConsistencyLight()
1900             f.setFieldNoProfileSBT(fNode)
1901             fs0.pushBackTimeStep(f)
1902             pass
1903         mm.write(fname,2)
1904         fs0.write(fname,0)
1905         a0Exp=mm.getCoords().deepCopy()
1906         del m,mm,fs0,f,fNode
1907         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
1908         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
1909         fields=MEDFileFields(fname,False)
1910         fields.removeFieldsWithoutAnyTimeStep()
1911         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
1912         allFMTSLeavesToDisplay=[]
1913         for fields in fields_per_mesh:
1914             allFMTSLeavesToDisplay2=[]
1915             for fmts in fields:
1916                 tmp=fmts.splitDiscretizations()
1917                 #for itmp in tmp:
1918                 #    self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
1919                 #    pass
1920                 allFMTSLeavesToDisplay2+=tmp
1921                 pass
1922             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
1923             pass
1924         self.assertEqual(len(allFMTSLeavesToDisplay),1)
1925         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
1926         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
1927         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 1 field is defined on the same time steps
1928         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
1929         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
1930         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
1931         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),1)
1932         #
1933         mst=MEDFileMeshStruct.New(ms[0])
1934         #
1935         fcscp=allFMTSLeavesPerCommonSupport[0][1]
1936         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
1937         mml2=mml.prepare()
1938         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
1939         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
1940         self.assertTrue(not ncc)
1941         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
1942         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9])))
1943         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75])))
1944         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]]
1945         self.assertTrue(a4 is None)
1946         self.assertTrue(a5 is None)
1947         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
1948         for i in range(1, 5):
1949             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
1950             pass
1951         for i in range(5):
1952             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
1953             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
1954             f.loadArraysIfNecessary()
1955             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
1956             self.assertEqual(f.getName(),fieldName0)
1957             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
1958             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]'])
1959             vExp+=i*1000
1960             self.assertTrue(v.isEqual(vExp,1e-12))
1961             pass
1962         pass
1963
1964     @WriteInTmpDir
1965     def test12(self):
1966         """ This test is the second ultimate test for the profiles with gauss points.
1967         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.
1968         """
1969         fname="ForMEDReader12.med"
1970         m=MEDCouplingCMesh("mesh")
1971         arr=DataArrayDouble(5) ; arr.iota()
1972         m.setCoords(arr,arr)
1973         m=m.buildUnstructured() ; m.getCoords().setInfoOnComponents(["XX [m]","YYY [km]"])
1974         mm=MEDFileUMesh() ; mm.setMeshes([m])
1975         #
1976         fieldName0="zeField0"
1977         fieldName1="zeField1"
1978         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS()
1979         for i in range(5):
1980             f=MEDFileField1TS()
1981             fNode=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fNode.setTime(float(i),i,0)
1982             fNode.setName(fieldName0) ; fNode.setMesh(m)
1983             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])
1984             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])
1985             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])
1986             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])
1987             arr=DataArrayDouble(2*(2*6+5*4+4*3+7*3)) ; arr.iota(0+1000*i) ; arr.rearrange(2)
1988             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkConsistencyLight()
1989             f.setFieldNoProfileSBT(fNode)
1990             fs0.pushBackTimeStep(f)
1991             #
1992             f=MEDFileField1TS()
1993             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
1994             fNode.setName(fieldName1) ; fNode.setMesh(m)
1995             arr=DataArrayDouble(2*16) ; arr.iota(300+1000*i) ; arr.rearrange(2)
1996             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"]) ; fNode.checkConsistencyLight()
1997             f.setFieldNoProfileSBT(fNode)
1998             fs1.pushBackTimeStep(f)
1999             pass
2000         mm.write(fname,2)
2001         fs0.write(fname,0) ; fs1.write(fname,0)
2002         a0Exp=mm.getCoords().deepCopy()
2003         del m,mm,fs0,fs1,f,fNode
2004         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2005         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
2006         fields=MEDFileFields(fname,False)
2007         fields.removeFieldsWithoutAnyTimeStep()
2008         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2009         allFMTSLeavesToDisplay=[]
2010         for fields in fields_per_mesh:
2011             allFMTSLeavesToDisplay2=[]
2012             for fmts in fields:
2013                 tmp=fmts.splitDiscretizations()
2014                 #for itmp in tmp:
2015                 #    self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
2016                 #    pass
2017                 allFMTSLeavesToDisplay2+=tmp
2018                 pass
2019             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2020             pass
2021         self.assertEqual(len(allFMTSLeavesToDisplay),1)
2022         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
2023         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2024         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
2025         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
2026         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
2027         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
2028         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
2029         #
2030         mst=MEDFileMeshStruct.New(ms[0])
2031         #
2032         fcscp=allFMTSLeavesPerCommonSupport[0][1]
2033         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2034         mml2=mml.prepare()
2035         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2036         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2037         self.assertTrue(not ncc)
2038         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
2039         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9])))
2040         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75])))
2041         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
2042         self.assertTrue(a4 is None)
2043         self.assertTrue(a5 is None)
2044         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
2045         for i in range(1, 5):
2046             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2047             pass
2048         for i in range(5):
2049             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
2050             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2051             f.loadArraysIfNecessary()
2052             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2053             self.assertEqual(f.getName(),fieldName0)
2054             #self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug : huge reordering performed !
2055             vExp=DataArrayDouble(65*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
2056             self.assertTrue(v.isEqual(vExp,1e-12))
2057             #
2058             f=allFMTSLeavesPerCommonSupport[0][0][1][i]
2059             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2060             f.loadArraysIfNecessary()
2061             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2062             self.assertEqual(f.getName(),fieldName1)
2063             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer()) # not a bug : huge reordering performed !
2064             vExp=DataArrayDouble(16*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
2065             self.assertTrue(v.isEqual(vExp,1e-12))
2066             pass
2067
2068     @WriteInTmpDir
2069     def test13(self):
2070             """ Testing polyhedrons mixed with hexa8"""
2071             fname="ForMEDReader13.med"
2072             m=MEDCouplingUMesh("mesh",3)
2073             m.allocateCells()
2074             m.insertNextCell(NORM_HEXA8,[1,0,6,7,13,12,18,19]) ; m.insertNextCell(NORM_HEXA8,[2,1,7,8,14,13,19,20])
2075             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])
2076             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])
2077             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])
2078             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]"])
2079             m.setCoords(coords)
2080             mm=MEDFileUMesh() ; mm.setMeshes([m])
2081             fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS() ; fs2=MEDFileFieldMultiTS() ; fs3=MEDFileFieldMultiTS()
2082             fieldName0="zeField0"
2083             fieldName1="zeField1"
2084             fieldName2="zeField2" ; pfl1=DataArrayInt([2,3]) ; pfl1.setName("pfl1")
2085             fieldName3="zefield3" ; pfl2=DataArrayInt([2,3,4]) ; pfl2.setName("pfl2")
2086             for i in range(5):
2087                 f=MEDFileField1TS()
2088                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2089                 fNode.setName(fieldName0) ; fNode.setMesh(m)
2090                 arr=DataArrayDouble(2*5) ; arr.iota(0+1000*i) ; arr.rearrange(2)
2091                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkConsistencyLight()
2092                 f.setFieldNoProfileSBT(fNode)
2093                 fs0.pushBackTimeStep(f)
2094                 #
2095                 f=MEDFileField1TS()
2096                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2097                 fNode.setName(fieldName1) ; fNode.setMesh(m)
2098                 arr=DataArrayDouble(2*5) ; arr.iota(100+1000*i) ; arr.rearrange(2)
2099                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"]) ; fNode.checkConsistencyLight()
2100                 f.setFieldNoProfileSBT(fNode)
2101                 fs1.pushBackTimeStep(f)
2102                 #
2103                 f=MEDFileField1TS()
2104                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2105                 fNode.setName(fieldName2) ; fNode.setMesh(m[pfl1])
2106                 arr=DataArrayDouble(2*2) ; arr.iota(200+1000*i) ; arr.rearrange(2)
2107                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"]) ; fNode.checkConsistencyLight()
2108                 f.setFieldProfile(fNode,mm,0,pfl1)
2109                 fs2.pushBackTimeStep(f)
2110                 #
2111                 f=MEDFileField1TS()
2112                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2113                 fNode.setName(fieldName3) ; fNode.setMesh(m[pfl2])
2114                 arr=DataArrayDouble(2*3) ; arr.iota(300+1000*i) ; arr.rearrange(2)
2115                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_3 [m]","Com2_3 [s^2]"]) ; fNode.checkConsistencyLight()
2116                 f.setFieldProfile(fNode,mm,0,pfl2)
2117                 fs3.pushBackTimeStep(f)
2118                 pass
2119             mm.write(fname,2)
2120             fs0.write(fname,0) ; fs1.write(fname,0) ; fs2.write(fname,0) ; fs3.write(fname,0)
2121             a0Exp=mm.getCoords().deepCopy()
2122             del m,mm,fs0
2123             ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2124             ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
2125             fields=MEDFileFields(fname,False)
2126             fields.removeFieldsWithoutAnyTimeStep()
2127             fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2128             allFMTSLeavesToDisplay=[]
2129             for fields in fields_per_mesh:
2130                 allFMTSLeavesToDisplay2=[]
2131                 for fmts in fields:
2132                     tmp=fmts.splitDiscretizations()
2133                     for itmp in tmp:
2134                         self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
2135                         pass
2136                     allFMTSLeavesToDisplay2+=tmp
2137                     pass
2138                 allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2139                 pass
2140             self.assertEqual(len(allFMTSLeavesToDisplay),1)
2141             self.assertEqual(len(allFMTSLeavesToDisplay[0]),4)
2142             allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2143             self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
2144             self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
2145             allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
2146             self.assertEqual(len(allFMTSLeavesPerCommonSupport),3)
2147             self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
2148             self.assertEqual(len(allFMTSLeavesPerCommonSupport[1][0]),1)
2149             self.assertEqual(len(allFMTSLeavesPerCommonSupport[2][0]),1)
2150             #
2151             mst=MEDFileMeshStruct.New(ms[0])
2152             #
2153             fcscp=allFMTSLeavesPerCommonSupport[0][1]
2154             mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2155             mml2=mml.prepare()
2156             self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2157             ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2158             self.assertTrue(ncc)
2159             self.assertTrue(a0.isEqual(a0Exp,1e-12))
2160             self.assertTrue(a1.isEqual(DataArrayByte([12,12,42,42,42])))
2161             self.assertTrue(a2.isEqual(DataArrayInt([0,9,18,27,36])))
2162             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])))
2163             self.assertTrue(a4.isEqual(DataArrayInt([-1,-1,0,31,62])))
2164             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])))
2165             self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
2166             for i in range(1, 5):
2167                 self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2168                 pass
2169             pass
2170             for i in range(5):
2171                 f=allFMTSLeavesPerCommonSupport[0][0][0][i]
2172                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2173                 f.loadArraysIfNecessary()
2174                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2175                 self.assertEqual(f.getName(),fieldName0)
2176                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2177                 vExp=DataArrayDouble(5*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
2178                 self.assertTrue(v.isEqual(vExp,1e-12))
2179                 #
2180                 f=allFMTSLeavesPerCommonSupport[0][0][1][i]
2181                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2182                 f.loadArraysIfNecessary()
2183                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2184                 self.assertEqual(f.getName(),fieldName1)
2185                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2186                 vExp=DataArrayDouble(5*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
2187                 self.assertTrue(v.isEqual(vExp,1e-12))
2188                 pass
2189             #
2190             fcscp=allFMTSLeavesPerCommonSupport[1][1]
2191             mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2192             mml2=mml.prepare()
2193             self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2194             ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2195             self.assertTrue(ncc)
2196             self.assertTrue(a0.isEqual(a0Exp,1e-12))
2197             self.assertTrue(a1.isEqual(DataArrayByte([42,42])))
2198             self.assertTrue(a2.isEqual(DataArrayInt([0,9])))
2199             self.assertTrue(a3.isEqual(DataArrayInt([8,2,3,8,9,14,15,20,21,8,3,4,9,10,15,16,21,22])))
2200             self.assertTrue(a4.isEqual(DataArrayInt([0,31])))
2201             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])))
2202             self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
2203             for i in range(1, 5):
2204                 self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2205                 pass
2206             pass
2207             for i in range(5):
2208                 f=allFMTSLeavesPerCommonSupport[1][0][0][i]
2209                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2210                 f.loadArraysIfNecessary()
2211                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2212                 self.assertEqual(f.getName(),fieldName2)
2213                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2214                 vExp=DataArrayDouble(2*2) ; vExp.iota(200+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_2 [m]','Com2_2 [s^2]'])
2215                 self.assertTrue(v.isEqual(vExp,1e-12))
2216                 pass
2217             #
2218             fcscp=allFMTSLeavesPerCommonSupport[2][1]
2219             mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2220             mml2=mml.prepare()
2221             self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2222             ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2223             self.assertTrue(ncc)
2224             self.assertTrue(a0.isEqual(a0Exp,1e-12))
2225             self.assertTrue(a1.isEqual(DataArrayByte([42,42,42])))
2226             self.assertTrue(a2.isEqual(DataArrayInt([0,9,18])))
2227             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])))
2228             self.assertTrue(a4.isEqual(DataArrayInt([0,31,62])))
2229             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])))
2230             for i in range(1, 5):
2231                 self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2232                 pass
2233             pass
2234             for i in range(5):
2235                 f=allFMTSLeavesPerCommonSupport[2][0][0][i]
2236                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2237                 f.loadArraysIfNecessary()
2238                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2239                 self.assertEqual(f.getName(),fieldName3)
2240                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2241                 vExp=DataArrayDouble(3*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_3 [m]','Com2_3 [s^2]'])
2242                 self.assertTrue(v.isEqual(vExp,1e-12))
2243                 pass
2244             pass
2245
2246     @WriteInTmpDir
2247     def test14(self):
2248             """ Testing only polyhedrons"""
2249             fname="ForMEDReader14.med"
2250             m=MEDCouplingUMesh("mesh",3)
2251             m.allocateCells()
2252             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])
2253             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])
2254             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])
2255             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]"])
2256             m.setCoords(coords)
2257             mm=MEDFileUMesh() ; mm.setMeshes([m])
2258             fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS()
2259             fieldName0="zeField0"
2260             fieldName1="zeField1"
2261             for i in range(5):
2262                 f=MEDFileField1TS()
2263                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2264                 fNode.setName(fieldName0) ; fNode.setMesh(m)
2265                 arr=DataArrayDouble(2*3) ; arr.iota(0+1000*i) ; arr.rearrange(2)
2266                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkConsistencyLight()
2267                 f.setFieldNoProfileSBT(fNode)
2268                 fs0.pushBackTimeStep(f)
2269                 #
2270                 f=MEDFileField1TS()
2271                 fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
2272                 fNode.setName(fieldName1) ; fNode.setMesh(m)
2273                 arr=DataArrayDouble(2*3) ; arr.iota(100+1000*i) ; arr.rearrange(2)
2274                 fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"]) ; fNode.checkConsistencyLight()
2275                 f.setFieldNoProfileSBT(fNode)
2276                 fs1.pushBackTimeStep(f)
2277                 pass
2278             mm.write(fname,2)
2279             fs0.write(fname,0) ; fs1.write(fname,0)
2280             a0Exp=mm.getCoords().deepCopy()
2281             del m,mm,fs0
2282             ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2283             ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
2284             fields=MEDFileFields(fname,False)
2285             fields.removeFieldsWithoutAnyTimeStep()
2286             fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2287             allFMTSLeavesToDisplay=[]
2288             for fields in fields_per_mesh:
2289                 allFMTSLeavesToDisplay2=[]
2290                 for fmts in fields:
2291                     tmp=fmts.splitDiscretizations()
2292                     for itmp in tmp:
2293                         self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
2294                         pass
2295                     allFMTSLeavesToDisplay2+=tmp
2296                     pass
2297                 allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2298                 pass
2299             self.assertEqual(len(allFMTSLeavesToDisplay),1)
2300             self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
2301             allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2302             self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
2303             self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
2304             allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
2305             self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
2306             self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
2307             #
2308             mst=MEDFileMeshStruct.New(ms[0])
2309             #
2310             fcscp=allFMTSLeavesPerCommonSupport[0][1]
2311             mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2312             mml2=mml.prepare()
2313             self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2314             ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2315             self.assertTrue(ncc)
2316             self.assertTrue(a0.isEqual(a0Exp,1e-12))
2317             self.assertTrue(a1.isEqual(DataArrayByte([42,42,42])))
2318             self.assertTrue(a2.isEqual(DataArrayInt([0,9,18])))
2319             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])))
2320             self.assertTrue(a4.isEqual(DataArrayInt([0,31,62])))
2321             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])))
2322             self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
2323             for i in range(1, 5):
2324                 self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2325                 pass
2326             a6,a7=mml2.retrieveFamilyIdsOnCells()
2327             self.assertTrue(a6.isEqual(DataArrayInt([0,0,0])))
2328             self.assertTrue(a7)
2329             a8,a9=mml2.retrieveNumberIdsOnCells()
2330             self.assertTrue(a8 is None)
2331             self.assertTrue(a9)
2332             for i in range(5):
2333                 f=allFMTSLeavesPerCommonSupport[0][0][0][i]
2334                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2335                 f.loadArraysIfNecessary()
2336                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2337                 self.assertEqual(f.getName(),fieldName0)
2338                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2339                 vExp=DataArrayDouble(3*2) ; vExp.iota(0+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
2340                 self.assertTrue(v.isEqual(vExp,1e-12))
2341                 #
2342                 f=allFMTSLeavesPerCommonSupport[0][0][1][i]
2343                 fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2344                 f.loadArraysIfNecessary()
2345                 v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2346                 self.assertEqual(f.getName(),fieldName1)
2347                 self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2348                 vExp=DataArrayDouble(3*2) ; vExp.iota(100+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
2349                 self.assertTrue(v.isEqual(vExp,1e-12))
2350                 pass
2351             pass
2352
2353     @WriteInTmpDir
2354     def test15(self):
2355         """
2356         "ForMEDReader15.med" file has a spaceDim 3 mesh "mesh" (it is important !)
2357         and a field "zeField" lying on a single geometric type for Cell discr and node part.
2358         Test that can appear the most simple but it hides a big issue of MEDReader
2359         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.
2360         """
2361         fname="ForMEDReader15.med"
2362         m0=MEDCouplingCMesh()
2363         arr=DataArrayDouble(3) ; arr.iota(0)
2364         m0.setCoords(arr,arr,arr)
2365         m0.setName("mesh")
2366         m0=m0.buildUnstructured()
2367         #
2368         fieldName="zeField"
2369         fCell=MEDCouplingFieldDouble(ON_CELLS)
2370         fCell.setName(fieldName)
2371         fCell.setMesh(m0)
2372         #
2373         fNode=MEDCouplingFieldDouble(ON_NODES)
2374         fNode.setName(fieldName)
2375         fNode.setMesh(m0)
2376         #
2377         mm=MEDFileUMesh()
2378         mm.setMeshAtLevel(0,m0)
2379         fam=DataArrayInt(8) ; fam.iota(0) ; mm.setFamilyFieldArr(0,fam) ; del fam
2380         num=DataArrayInt(8) ; num.iota(100) ; mm.setRenumFieldArr(0,num) ; del num
2381         #
2382         ffs=MEDFileFieldMultiTS()
2383         # TimeStep 0
2384         t=(1.,0,0) ; off=0.
2385         f1ts=MEDFileField1TS()
2386         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2387         fCell.setArray(a)
2388         fCell.setTime(*t)
2389         fCell.checkConsistencyLight()
2390         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2391         a=a.negate()
2392         fNode.setArray(a)
2393         fNode.setTime(*t)
2394         fNode.checkConsistencyLight()
2395         f1ts.setFieldNoProfileSBT(fCell)
2396         f1ts.setFieldNoProfileSBT(fNode)
2397         ffs.pushBackTimeStep(f1ts)
2398         # TimeStep 1
2399         t=(2.1,1,0) ; off=100.
2400         f1ts=MEDFileField1TS()
2401         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2402         fCell.setArray(a)
2403         fCell.setTime(*t)
2404         fCell.checkConsistencyLight()
2405         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2406         a=a.negate()
2407         fNode.setArray(a)
2408         fNode.setTime(*t)
2409         fNode.checkConsistencyLight()
2410         f1ts.setFieldNoProfileSBT(fCell)
2411         f1ts.setFieldNoProfileSBT(fNode)
2412         ffs.pushBackTimeStep(f1ts)
2413         # TimeStep 2
2414         t=(3.2,2,0) ; off=200.
2415         f1ts=MEDFileField1TS()
2416         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2417         fCell.setArray(a)
2418         fCell.setTime(*t)
2419         fCell.checkConsistencyLight()
2420         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2421         a=a.negate()
2422         fNode.setArray(a)
2423         fNode.setTime(*t)
2424         fNode.checkConsistencyLight()
2425         f1ts.setFieldNoProfileSBT(fCell)
2426         f1ts.setFieldNoProfileSBT(fNode)
2427         ffs.pushBackTimeStep(f1ts)
2428         # TimeStep 3
2429         t=(4.3,3,1) ; off=300.
2430         f1ts=MEDFileField1TS()
2431         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2432         fCell.setArray(a)
2433         fCell.setTime(*t)
2434         fCell.checkConsistencyLight()
2435         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2436         a=a.negate()
2437         fNode.setArray(a)
2438         fNode.setTime(*t)
2439         fNode.checkConsistencyLight()
2440         f1ts.setFieldNoProfileSBT(fCell)
2441         f1ts.setFieldNoProfileSBT(fNode)
2442         ffs.pushBackTimeStep(f1ts)
2443         #
2444         mm.write(fname,2)
2445         ffs.write(fname,0)
2446         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2447         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
2448         fields=MEDFileFields(fname,False)
2449         fields.removeFieldsWithoutAnyTimeStep()
2450         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2451         allFMTSLeavesToDisplay=[]
2452         for fields in fields_per_mesh:
2453             allFMTSLeavesToDisplay2=[]
2454             for fmts in fields:
2455                 tmp=fmts.splitDiscretizations()
2456                 for itmp in tmp:
2457                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
2458                     pass
2459                 allFMTSLeavesToDisplay2+=tmp
2460                 pass
2461             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2462             pass
2463         self.assertEqual(len(allFMTSLeavesToDisplay),1)
2464         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
2465         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2466         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
2467         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
2468         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
2469         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
2470         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),2)
2471         #
2472         mst=MEDFileMeshStruct.New(ms[0])
2473         #
2474         fcscp=allFMTSLeavesPerCommonSupport[0][1]
2475         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2476         mml2=mml.prepare()
2477         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2478         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2479         self.assertTrue(ncc)
2480         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))
2481         self.assertTrue(a1.isEqual(DataArrayByte([12,12,12,12,12,12,12,12])))
2482         self.assertTrue(a2.isEqual(DataArrayInt([0,9,18,27,36,45,54,63])))
2483         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])))
2484         self.assertTrue(a4 is None)
2485         self.assertTrue(a5 is None)
2486         a6,a7=mml2.retrieveFamilyIdsOnCells()
2487         self.assertTrue(a6.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
2488         self.assertTrue(a7) # no copy here
2489         a8,a9=mml2.retrieveNumberIdsOnCells()
2490         self.assertTrue(a8.isEqual(DataArrayInt([100,101,102,103,104,105,106,107])))
2491         self.assertTrue(a9) # no copy here
2492         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
2493         pass
2494
2495     @WriteInTmpDir
2496     def test16(self):
2497         """ Here 2 meshes "mesh1" and "mesh2" and 4 fields (no profiles here) :
2498         - "zeField1_0" (CELLS) and "zeField2_0" (NODES) on "mesh1"
2499         - "zeField3_1" (CELLS) and "zeField4_1" (NODES) on "mesh2"
2500         time steps series are the same for the whole 4 fields
2501         """
2502         fname="ForMEDReader16.med"
2503         m0=MEDCouplingCMesh()
2504         arr=DataArrayDouble(3) ; arr.iota(0)
2505         m0.setCoords(arr,arr,arr)
2506         m0.setName("mesh1")
2507         m0=m0.buildUnstructured()
2508         #
2509         fCell1=MEDCouplingFieldDouble(ON_CELLS)
2510         fCell1.setName("zeField1_0")
2511         fCell1.setMesh(m0)
2512         #
2513         fNode1=MEDCouplingFieldDouble(ON_NODES)
2514         fNode1.setName("zeField2_0")
2515         fNode1.setMesh(m0)
2516         #
2517         mms=MEDFileMeshes()
2518         mm1=MEDFileUMesh()
2519         mm1.setMeshAtLevel(0,m0)
2520         fam=DataArrayInt([0,1,0,1,2,3,2,3]); mm1.setFamilyFieldArr(0,fam) ; del fam
2521         num=DataArrayInt(8) ; num.iota(100) ; mm1.setRenumFieldArr(0,num) ; del num
2522         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)
2523         mm1.setFamiliesIdsOnGroup("Grp1_1",[0,1]) ; mm1.setFamiliesIdsOnGroup("Grp1_2",[2,3])
2524         mms.pushMesh(mm1) ; del mm1
2525         #
2526         m1=m0.deepCopy() ; m1.translate([2.5,0.,0.]) ; m1.setName("mesh2")
2527         #
2528         fCell2=MEDCouplingFieldDouble(ON_CELLS)
2529         fCell2.setName("zeField3_1")
2530         fCell2.setMesh(m1)
2531         #
2532         fNode2=MEDCouplingFieldDouble(ON_NODES)
2533         fNode2.setName("zeField4_1")
2534         fNode2.setMesh(m1)
2535         #
2536         mm2=MEDFileUMesh()
2537         mm2.setMeshAtLevel(0,m1)
2538         fam=DataArrayInt([0,1,0,1,2,3,2,3]); mm2.setFamilyFieldArr(0,fam) ; del fam
2539         num=DataArrayInt(8) ; num.iota(200) ; mm2.setRenumFieldArr(0,num) ; del num
2540         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)
2541         mm2.setFamiliesIdsOnGroup("Grp2_1",[0,1]) ; mm2.setFamiliesIdsOnGroup("Grp2_2",[2,3]) ; mm2.setFamiliesIdsOnGroup("Grp2_3",[1,2,3])
2542         mms.pushMesh(mm2) ; del mm2
2543         ffs1_1=MEDFileFieldMultiTS()
2544         ffs1_2=MEDFileFieldMultiTS()
2545         ffs2_1=MEDFileFieldMultiTS()
2546         ffs2_2=MEDFileFieldMultiTS()
2547         mts=MEDFileFields()
2548         for elt in ffs1_1,ffs1_2,ffs2_1,ffs2_2:
2549             mts.pushField(elt)
2550             pass
2551         # TimeStep 0
2552         t=(1.,0,0) ; off=0.
2553         f1ts1=MEDFileField1TS()
2554         f1ts2=MEDFileField1TS()
2555         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2556         fCell1.setArray(a)
2557         fCell1.setTime(*t)
2558         fCell1.checkConsistencyLight()
2559         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2560         a=a.negate()
2561         fNode1.setArray(a)
2562         fNode1.setTime(*t)
2563         fNode1.checkConsistencyLight()
2564         f1ts1.setFieldNoProfileSBT(fCell1) ; ffs1_1.pushBackTimeStep(f1ts1)
2565         f1ts2.setFieldNoProfileSBT(fNode1) ; ffs1_2.pushBackTimeStep(f1ts2)
2566         #
2567         f1ts1=MEDFileField1TS()
2568         f1ts2=MEDFileField1TS()
2569         a=DataArrayDouble(m1.getNumberOfCells()) ; a.iota(1000.+off) ; a.setInfoOnComponents(["xx [m]"])
2570         fCell2.setArray(a)
2571         fCell2.setTime(*t)
2572         fCell2.checkConsistencyLight()
2573         a=DataArrayDouble(m1.getNumberOfNodes()) ; a.iota(1000+off) ; a.setInfoOnComponents(["xx [m]"])
2574         a=a.negate()
2575         fNode2.setArray(a)
2576         fNode2.setTime(*t)
2577         fNode2.checkConsistencyLight()
2578         f1ts1.setFieldNoProfileSBT(fCell2) ; ffs2_1.pushBackTimeStep(f1ts1)
2579         f1ts2.setFieldNoProfileSBT(fNode2) ; ffs2_2.pushBackTimeStep(f1ts2)
2580         # TimeStep 1
2581         t=(2.1,1,0) ; off=100.
2582         f1ts1=MEDFileField1TS()
2583         f1ts2=MEDFileField1TS()
2584         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2585         fCell1.setArray(a)
2586         fCell1.setTime(*t)
2587         fCell1.checkConsistencyLight()
2588         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2589         a=a.negate()
2590         fNode1.setArray(a)
2591         fNode1.setTime(*t)
2592         fNode1.checkConsistencyLight()
2593         f1ts1.setFieldNoProfileSBT(fCell1) ; ffs1_1.pushBackTimeStep(f1ts1)
2594         f1ts2.setFieldNoProfileSBT(fNode1) ; ffs1_2.pushBackTimeStep(f1ts2)
2595         #
2596         f1ts1=MEDFileField1TS()
2597         f1ts2=MEDFileField1TS()
2598         a=DataArrayDouble(m1.getNumberOfCells()) ; a.iota(1000.+off) ; a.setInfoOnComponents(["xx [m]"])
2599         fCell2.setArray(a)
2600         fCell2.setTime(*t)
2601         fCell2.checkConsistencyLight()
2602         a=DataArrayDouble(m1.getNumberOfNodes()) ; a.iota(1000+off) ; a.setInfoOnComponents(["xx [m]"])
2603         a=a.negate()
2604         fNode2.setArray(a)
2605         fNode2.setTime(*t)
2606         fNode2.checkConsistencyLight()
2607         f1ts1.setFieldNoProfileSBT(fCell2) ; ffs2_1.pushBackTimeStep(f1ts1)
2608         f1ts2.setFieldNoProfileSBT(fNode2) ; ffs2_2.pushBackTimeStep(f1ts2)
2609         # TimeStep 2
2610         t=(3.1,2,0) ; off=200.
2611         f1ts1=MEDFileField1TS()
2612         f1ts2=MEDFileField1TS()
2613         a=DataArrayDouble(m0.getNumberOfCells()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2614         fCell1.setArray(a)
2615         fCell1.setTime(*t)
2616         fCell1.checkConsistencyLight()
2617         a=DataArrayDouble(m0.getNumberOfNodes()) ; a.iota(off) ; a.setInfoOnComponents(["xx [m]"])
2618         a=a.negate()
2619         fNode1.setArray(a)
2620         fNode1.setTime(*t)
2621         fNode1.checkConsistencyLight()
2622         f1ts1.setFieldNoProfileSBT(fCell1) ; ffs1_1.pushBackTimeStep(f1ts1)
2623         f1ts2.setFieldNoProfileSBT(fNode1) ; ffs1_2.pushBackTimeStep(f1ts2)
2624         #
2625         f1ts1=MEDFileField1TS()
2626         f1ts2=MEDFileField1TS()
2627         a=DataArrayDouble(m1.getNumberOfCells()) ; a.iota(1000.+off) ; a.setInfoOnComponents(["xx [m]"])
2628         fCell2.setArray(a)
2629         fCell2.setTime(*t)
2630         fCell2.checkConsistencyLight()
2631         a=DataArrayDouble(m1.getNumberOfNodes()) ; a.iota(1000+off) ; a.setInfoOnComponents(["xx [m]"])
2632         a=a.negate()
2633         fNode2.setArray(a)
2634         fNode2.setTime(*t)
2635         fNode2.checkConsistencyLight()
2636         f1ts1.setFieldNoProfileSBT(fCell2) ; ffs2_1.pushBackTimeStep(f1ts1)
2637         f1ts2.setFieldNoProfileSBT(fNode2) ; ffs2_2.pushBackTimeStep(f1ts2)
2638         #
2639         mms.write(fname,2) ; mts.write(fname,0)
2640         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2641         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
2642         fields=MEDFileFields(fname,False)
2643         fields.removeFieldsWithoutAnyTimeStep()
2644         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2645         allFMTSLeavesToDisplay=[]
2646         for fields in fields_per_mesh:
2647             allFMTSLeavesToDisplay2=[]
2648             for fmts in fields:
2649                 tmp=fmts.splitDiscretizations()
2650                 for itmp in tmp:
2651                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
2652                     pass
2653                 allFMTSLeavesToDisplay2+=tmp
2654                 pass
2655             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2656             pass
2657         self.assertEqual(len(allFMTSLeavesToDisplay),2)
2658         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
2659         self.assertEqual(len(allFMTSLeavesToDisplay[1]),2)
2660         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2661         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
2662         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
2663         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
2664         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
2665         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),2)
2666         allFMTSLeavesPerCommonSupport2=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
2667         self.assertEqual(len(allFMTSLeavesPerCommonSupport2),1)
2668         self.assertEqual(len(allFMTSLeavesPerCommonSupport2[0][0]),2)
2669         pass
2670
2671     @WriteInTmpDir
2672     def test17(self):
2673         """ First test on GAUSS_NE (Elno). Here no Profiles.
2674         2 times steps.
2675         """
2676         fname="ForMEDReader17.med"
2677         fieldName1="MyFirstElno"
2678         fieldName2="ACellField"
2679         fieldName3="ANodeField"
2680         coo=DataArrayDouble([0.,0.,1.,0.,2.,0.,0.,1.,1.,1.,2.,1.],6,2)
2681         m=MEDCouplingUMesh("mesh",2)
2682         m.setCoords(coo)
2683         m.allocateCells()
2684         m.insertNextCell(NORM_QUAD4,[0,3,4,1])
2685         m.insertNextCell(NORM_QUAD4,[1,4,5,2])
2686         m.checkConsistency()
2687         #
2688         t=(1.1,0,-1)
2689         f=MEDCouplingFieldDouble(ON_GAUSS_NE) ; f.setTime(*t) ; f.setMesh(m)
2690         f.setArray(DataArrayDouble([3.,5.,7.,6.,2.,3.,11.,8.]))
2691         f.setName(fieldName1)
2692         f.checkConsistencyLight()
2693         WriteField(fname,f,True)
2694         f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setTime(*t) ; f2.setMesh(m)
2695         f2.setArray(DataArrayDouble([7.,11.],2,1))
2696         f2.setName(fieldName2)
2697         WriteFieldUsingAlreadyWrittenMesh(fname,f2)
2698         f3=MEDCouplingFieldDouble(ON_NODES) ; f3.setTime(*t) ; f3.setMesh(m)
2699         f3.setArray(DataArrayDouble([1.,2.,4.,1.,2.,4.],6,1))
2700         f3.setName(fieldName3)
2701         WriteFieldUsingAlreadyWrittenMesh(fname,f3)
2702         #
2703         t=(2.1,1,-1)
2704         f=MEDCouplingFieldDouble(ON_GAUSS_NE) ; f.setTime(*t) ; f.setMesh(m)
2705         f.setArray(DataArrayDouble([7.,6.,3.,5.,11.,8.,2.,3.]))
2706         f.setName(fieldName1)
2707         f.checkConsistencyLight()
2708         WriteFieldUsingAlreadyWrittenMesh(fname,f)
2709         f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setTime(*t) ; f2.setMesh(m)
2710         f2.setArray(DataArrayDouble([11.,7.],2,1))
2711         f2.setName(fieldName2)
2712         WriteFieldUsingAlreadyWrittenMesh(fname,f2)
2713         f3=MEDCouplingFieldDouble(ON_NODES) ; f3.setTime(*t) ; f3.setMesh(m)
2714         f3.setArray(DataArrayDouble([4.,2.,1.,4.,2.,1.],6,1))
2715         f3.setName(fieldName3)
2716         WriteFieldUsingAlreadyWrittenMesh(fname,f3)
2717         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2718         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
2719         fields=MEDFileFields(fname,False)
2720         fields.removeFieldsWithoutAnyTimeStep()
2721         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2722         allFMTSLeavesToDisplay=[]
2723         for fields in fields_per_mesh:
2724             allFMTSLeavesToDisplay2=[]
2725             for fmts in fields:
2726                 tmp=fmts.splitDiscretizations()
2727                 for itmp in tmp:
2728                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
2729                     pass
2730                 allFMTSLeavesToDisplay2+=tmp
2731                 pass
2732             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2733             pass
2734         self.assertEqual(len(allFMTSLeavesToDisplay),1)
2735         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
2736         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2737         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
2738         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
2739         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
2740         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
2741         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),3)
2742         #
2743         mst=MEDFileMeshStruct.New(ms[0])
2744         #
2745         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
2746         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2747         mml2=mml.prepare()
2748         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2749         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2750         self.assertTrue(not ncc) # spaceDim 2 -> VTK wants 3D
2751         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))
2752         self.assertTrue(a1.isEqual(DataArrayByte([9,9])))
2753         self.assertTrue(a2.isEqual(DataArrayInt([0,5])))
2754         self.assertTrue(a3.isEqual(DataArrayInt([4,0,3,4,1,4,1,4,5,2])))
2755         self.assertTrue(a4 is None)
2756         self.assertTrue(a5 is None)
2757         a6,a7=mml2.retrieveFamilyIdsOnCells()
2758         self.assertTrue(a6.isEqual(DataArrayInt([0,0])))
2759         self.assertTrue(a7) # no copy here
2760         a8,a9=mml2.retrieveNumberIdsOnCells()
2761         self.assertTrue(a8.isEqual(DataArrayInt([0,1])))
2762         self.assertTrue(a9) # no copy here
2763         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
2764         for i in range(1, 2):
2765             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2766             pass
2767         vExp0=[DataArrayDouble([7.,11.]),DataArrayDouble([11.,7.])]
2768         vExp1=[DataArrayDouble([3.,5.,7.,6.,2.,3.,11.,8.]),DataArrayDouble([7.,6.,3.,5.,11.,8.,2.,3.])]
2769         for i in range(2):
2770             f=allFMTSLeavesPerCommonSupport1[0][0][0][i]
2771             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2772             f.loadArraysIfNecessary()
2773             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2774             self.assertEqual(f.getName(),fieldName2)
2775             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2776             self.assertTrue(v.isEqual(vExp0[i],1e-12))
2777             #
2778             f=allFMTSLeavesPerCommonSupport1[0][0][1][i]
2779             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2780             f.loadArraysIfNecessary()
2781             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2782             self.assertEqual(f.getName(),fieldName1)
2783             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2784             self.assertTrue(v.isEqual(vExp1[i],1e-12))
2785             pass
2786         pass
2787
2788     @WriteInTmpDir
2789     def test18(self):
2790         """ First test on GAUSS_PT. Here no Profiles. 2 times steps.
2791         """
2792         fname="ForMEDReader18.med"
2793         fieldName1="MyFirstGauss"
2794         fieldName2="ACellField"
2795         fieldName3="ANodeField"
2796         coo=DataArrayDouble([0.,0.,1.,0.,2.,0.,0.,1.,1.,1.,2.,1.],6,2)
2797         m=MEDCouplingUMesh("mesh",2)
2798         m.setCoords(coo)
2799         m.allocateCells()
2800         m.insertNextCell(NORM_QUAD4,[0,3,4,1])
2801         m.insertNextCell(NORM_QUAD4,[1,4,5,2])
2802         m.checkConsistency()
2803         #
2804         t=(1.1,0,-1)
2805         f=MEDCouplingFieldDouble(ON_GAUSS_PT) ; f.setTime(*t) ; f.setMesh(m)
2806         f.setGaussLocalizationOnType(NORM_QUAD4,[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.2,0.2,0.8,0.8],[0.7,0.3])
2807         f.setArray(DataArrayDouble([3.,5.,4.,6.])) ; f.getArray().setInfoOnComponents(["Smth"])
2808         f.setName(fieldName1)
2809         f.checkConsistencyLight()
2810         WriteField(fname,f,True)
2811         f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setTime(*t) ; f2.setMesh(m)
2812         f2.setArray(DataArrayDouble([7.,11.],2,1))
2813         f2.setName(fieldName2)
2814         WriteFieldUsingAlreadyWrittenMesh(fname,f2)
2815         f3=MEDCouplingFieldDouble(ON_NODES) ; f3.setTime(*t) ; f3.setMesh(m)
2816         f3.setArray(DataArrayDouble([1.,2.,4.,1.,2.,4.],6,1))
2817         f3.setName(fieldName3)
2818         WriteFieldUsingAlreadyWrittenMesh(fname,f3)
2819         #
2820         t=(2.1,1,-1)
2821         f=MEDCouplingFieldDouble(ON_GAUSS_PT) ; f.setTime(*t) ; f.setMesh(m)
2822         f.setGaussLocalizationOnType(NORM_QUAD4,[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[0.2,0.2,0.8,0.8],[0.7,0.3])
2823         f.setArray(DataArrayDouble([5.,3.,6.,4.])) ; f.getArray().setInfoOnComponents(["Smth"])
2824         f.setName(fieldName1)
2825         f.checkConsistencyLight()
2826         WriteFieldUsingAlreadyWrittenMesh(fname,f)
2827         f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setTime(*t) ; f2.setMesh(m)
2828         f2.setArray(DataArrayDouble([11.,7.],2,1))
2829         f2.setName(fieldName2)
2830         WriteFieldUsingAlreadyWrittenMesh(fname,f2)
2831         f3=MEDCouplingFieldDouble(ON_NODES) ; f3.setTime(*t) ; f3.setMesh(m)
2832         f3.setArray(DataArrayDouble([4.,2.,1.,4.,2.,1.],6,1))
2833         f3.setName(fieldName3)
2834         WriteFieldUsingAlreadyWrittenMesh(fname,f3)
2835         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
2836         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
2837         fields=MEDFileFields(fname,False)
2838         fields.removeFieldsWithoutAnyTimeStep()
2839         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2840         allFMTSLeavesToDisplay=[]
2841         for fields in fields_per_mesh:
2842             allFMTSLeavesToDisplay2=[]
2843             for fmts in fields:
2844                 tmp=fmts.splitDiscretizations()
2845                 for itmp in tmp:
2846                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
2847                     pass
2848                 allFMTSLeavesToDisplay2+=tmp
2849                 pass
2850             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2851             pass
2852         self.assertEqual(len(allFMTSLeavesToDisplay),1)
2853         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
2854         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2855         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
2856         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
2857         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
2858         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
2859         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),3)
2860         #
2861         mst=MEDFileMeshStruct.New(ms[0])
2862         #
2863         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
2864         self.assertEqual([NORM_QUAD4],fcscp.getGeoTypesAt(0,ms[0]))
2865         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2866         mml2=mml.prepare()
2867         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2868         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2869         self.assertTrue(not ncc) # spaceDim 2 -> VTK wants 3D
2870         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))
2871         self.assertTrue(a1.isEqual(DataArrayByte([9,9])))
2872         self.assertTrue(a2.isEqual(DataArrayInt([0,5])))
2873         self.assertTrue(a3.isEqual(DataArrayInt([4,0,3,4,1,4,1,4,5,2])))
2874         self.assertTrue(a4 is None)
2875         self.assertTrue(a5 is None)
2876         a6,a7=mml2.retrieveFamilyIdsOnCells()
2877         self.assertTrue(a6.isEqual(DataArrayInt([0,0])))
2878         self.assertTrue(a7) # no copy here
2879         a8,a9=mml2.retrieveNumberIdsOnCells()
2880         self.assertTrue(a8.isEqual(DataArrayInt([0,1])))
2881         self.assertTrue(a9) # no copy here
2882         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
2883         for i in range(1, 2):
2884             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2885             pass
2886         vExp0=[DataArrayDouble([7.,11.]),DataArrayDouble([11.,7.])]
2887         vExp1=[DataArrayDouble([3.,5.,4.,6.]),DataArrayDouble([5.,3.,6.,4.])]
2888         for i in range(2):
2889             f=allFMTSLeavesPerCommonSupport1[0][0][0][i]
2890             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2891             f.loadArraysIfNecessary()
2892             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2893             self.assertEqual(f.getName(),fieldName2)
2894             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2895             self.assertTrue(v.isEqual(vExp0[i],1e-12))
2896             #
2897             f=allFMTSLeavesPerCommonSupport1[0][0][1][i]
2898             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
2899             f.loadArraysIfNecessary()
2900             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2901             self.assertEqual(f.getName(),fieldName1)
2902             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2903             vExp1[i].setInfoOnComponents(["Smth"])
2904             self.assertTrue(v.isEqual(vExp1[i],1e-12))
2905             pass
2906         ## Now same exercise but with a different load strategy. All is load directly.
2907         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
2908         fields=MEDFileFields(fname) # here all is read, the SauvReader (or other Reader) is emulated
2909         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
2910         allFMTSLeavesToDisplay=[]
2911         for fields in fields_per_mesh:
2912             allFMTSLeavesToDisplay2=[]
2913             for fmts in fields:
2914                 tmp=fmts.splitDiscretizations()
2915                 for itmp in tmp:
2916                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
2917                     pass
2918                 allFMTSLeavesToDisplay2+=tmp
2919                 pass
2920             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
2921             pass
2922         self.assertEqual(len(allFMTSLeavesToDisplay),1)
2923         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
2924         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
2925         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
2926         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
2927         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
2928         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
2929         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),3)
2930         #
2931         mst=MEDFileMeshStruct.New(ms[0])
2932         #
2933         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
2934         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
2935         mml2=mml.prepare()
2936         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
2937         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
2938         self.assertTrue(not ncc) # spaceDim 2 -> VTK wants 3D
2939         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))
2940         self.assertTrue(a1.isEqual(DataArrayByte([9,9])))
2941         self.assertTrue(a2.isEqual(DataArrayInt([0,5])))
2942         self.assertTrue(a3.isEqual(DataArrayInt([4,0,3,4,1,4,1,4,5,2])))
2943         self.assertTrue(a4 is None)
2944         self.assertTrue(a5 is None)
2945         a6,a7=mml2.retrieveFamilyIdsOnCells()
2946         self.assertTrue(a6.isEqual(DataArrayInt([0,0])))
2947         self.assertTrue(a7) # no copy here
2948         a8,a9=mml2.retrieveNumberIdsOnCells()
2949         self.assertTrue(a8.isEqual(DataArrayInt([0,1])))
2950         self.assertTrue(a9) # no copy here
2951         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
2952         for i in range(1, 2):
2953             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
2954             pass
2955         vExp0=[DataArrayDouble([7.,11.]),DataArrayDouble([11.,7.])]
2956         vExp1=[DataArrayDouble([3.,5.,4.,6.]),DataArrayDouble([5.,3.,6.,4.])]
2957         for i in range(2):
2958             f=allFMTSLeavesPerCommonSupport1[0][0][0][i]
2959             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst) # no load needed here
2960             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2961             self.assertEqual(f.getName(),fieldName2)
2962             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2963             self.assertTrue(v.isEqual(vExp0[i],1e-12))
2964             #
2965             f=allFMTSLeavesPerCommonSupport1[0][0][1][i]
2966             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst) # no load needed here
2967             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
2968             self.assertEqual(f.getName(),fieldName1)
2969             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
2970             vExp1[i].setInfoOnComponents(["Smth"])
2971             self.assertTrue(v.isEqual(vExp1[i],1e-12))
2972             pass
2973         pass
2974
2975     @WriteInTmpDir
2976     def test19(self):
2977         """
2978         This test is a simple non profile CELL field but lying on cells of dimension -1 (not 0 as "usual").
2979         """
2980         fname="ForMEDReader19.med"
2981         fieldName="ACellFieldOnDimM1"
2982         coo=DataArrayDouble(3) ; coo.iota()
2983         m=MEDCouplingCMesh() ; m.setCoords(coo,coo,coo) ; m.setName("mesh")
2984         m0=m.buildUnstructured() ; del m
2985         m1=m0.computeSkin()
2986         #
2987         mm=MEDFileUMesh()
2988         mm.setMeshAtLevel(0,m0)
2989         mm.setMeshAtLevel(-1,m1)
2990         ff=MEDFileFieldMultiTS()
2991         # time 0
2992         t=(1.1,1,-1)
2993         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setTime(*t) ; f.setMesh(m1)
2994         f.setName(fieldName)
2995         arr=DataArrayDouble(24) ; arr.iota() ; arr.setInfoOnComponents(["AStr"])
2996         f.setArray(arr)
2997         f.checkConsistencyLight()
2998         f1ts=MEDFileField1TS() ; f1ts.setFieldNoProfileSBT(f)
2999         ff.pushBackTimeStep(f1ts)
3000         # time 1
3001         t=(2.1,2,-2)
3002         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setTime(*t) ; f.setMesh(m1)
3003         f.setName(fieldName)
3004         arr=DataArrayDouble(24) ; arr.iota() ; arr.reverse() ; arr.setInfoOnComponents(["AStr"])
3005         f.setArray(arr)
3006         f.checkConsistencyLight()
3007         f1ts=MEDFileField1TS() ; f1ts.setFieldNoProfileSBT(f)
3008         ff.pushBackTimeStep(f1ts)
3009         #
3010         mm.write(fname,2)
3011         ff.write(fname,0)
3012         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3013         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
3014         fields=MEDFileFields(fname,False)
3015         fields.removeFieldsWithoutAnyTimeStep()
3016         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3017         allFMTSLeavesToDisplay=[]
3018         for fields in fields_per_mesh:
3019             allFMTSLeavesToDisplay2=[]
3020             for fmts in fields:
3021                 tmp=fmts.splitDiscretizations()
3022                 for itmp in tmp:
3023                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
3024                     pass
3025                 allFMTSLeavesToDisplay2+=tmp
3026                 pass
3027             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3028             pass
3029         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3030         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
3031         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3032         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3033         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
3034         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3035         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
3036         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
3037         #
3038         mst=MEDFileMeshStruct.New(ms[0])
3039         #
3040         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
3041         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3042         mml2=mml.prepare()
3043         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3044         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3045         self.assertTrue(ncc)
3046         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))
3047         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])))
3048         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])))
3049         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])))
3050         self.assertTrue(a4 is None)
3051         self.assertTrue(a5 is None)
3052         a6,a7=mml2.retrieveFamilyIdsOnCells()
3053         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])))
3054         self.assertTrue(a7) # no copy here
3055         a8,a9=mml2.retrieveNumberIdsOnCells()
3056         self.assertTrue(a8 is None)
3057         self.assertTrue(a9) # no copy here
3058         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3059         self.assertTrue(not a10)
3060         self.assertTrue(a11) # no copy here
3061         a12,a13=mml2.retrieveNumberIdsOnNodes()
3062         self.assertTrue(not a12)
3063         self.assertTrue(a13) # no copy here
3064         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3065         for i in range(1, 2):
3066             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
3067             pass
3068         for i in range(2):
3069             f=allFMTSLeavesPerCommonSupport1[0][0][0][i]
3070             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3071             f.loadArraysIfNecessary()
3072             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3073             self.assertEqual(f.getName(),fieldName)
3074             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3075             vExp=DataArrayDouble(24) ; vExp.iota()
3076             if i==1: vExp.reverse()
3077             vExp.setInfoOnComponents(["AStr"])
3078             self.assertTrue(v.isEqual(vExp,1e-12))
3079             pass
3080         pass
3081
3082     @WriteInTmpDir
3083     def test20(self):
3084         """ This test works with groups/families on cells AND on nodes. Here 4 fields each on same time steps (2).
3085         1 field on CELLS without profile, 1 field on CELLS with profile, 1 field on NODES without profile, 1 field on NODES with profile.
3086         All of these 4 fields lies on a single mesh "mesh". The 2 fields on profile lies on a same support.
3087         One drawback of this test : no multi geom type. Coming soon !
3088         """
3089         fname="ForMEDReader20.med"
3090         fieldName0="ANodeField"
3091         fieldName1="ACellField"
3092         fieldName2="ANodeFieldPfl"
3093         fieldName3="ACellFieldPfl"
3094         pfl2=DataArrayInt([5,6,7,10,11,12,15,16,17,20,21,22]) ; pfl2.setName("pfl2")
3095         pfl3=DataArrayInt([4,5,8,9,12,13]) ; pfl3.setName("pfl3")
3096         #
3097         arr=DataArrayDouble(5) ; arr.iota()
3098         m=MEDCouplingCMesh("mesh") ; m.setCoords(arr,arr)
3099         m=m.buildUnstructured()
3100         mm=MEDFileUMesh()
3101         mm.setMeshAtLevel(0,m)
3102         fs=MEDFileFields()
3103         fmts0=MEDFileFieldMultiTS() ; fs.pushField(fmts0)
3104         fmts0.setDtUnit("s")
3105         fmts1=MEDFileFieldMultiTS() ; fs.pushField(fmts1)
3106         fmts1.setDtUnit("s")
3107         fmts2=MEDFileFieldMultiTS() ; fs.pushField(fmts2)
3108         fmts2.setDtUnit("s")
3109         fmts3=MEDFileFieldMultiTS() ; fs.pushField(fmts3)
3110         fmts3.setDtUnit("s")
3111         ####
3112         t=(1.1,0,-2)
3113         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m)
3114         f0.setName(fieldName0) ; f0.setTime(*t)
3115         da=m.getCoords().magnitude() ; da.setInfoOnComponents(["zeInfo"])
3116         f0.setArray(da)
3117         f0.checkConsistencyLight()
3118         f1ts=MEDFileField1TS()
3119         f1ts.setFieldNoProfileSBT(f0)
3120         fmts0.pushBackTimeStep(f1ts)
3121         #
3122         f1=MEDCouplingFieldDouble(ON_CELLS) ; f1.setMesh(m)
3123         f1.setName(fieldName1) ; f1.setTime(*t)
3124         da=m.computeCellCenterOfMass().magnitude() ; da.setInfoOnComponents(["zeInfoCell"])
3125         f1.setArray(da)
3126         f1.checkConsistencyLight()
3127         f1ts=MEDFileField1TS()
3128         f1ts.setFieldNoProfileSBT(f1)
3129         fmts1.pushBackTimeStep(f1ts)
3130         #
3131         f2=MEDCouplingFieldDouble(ON_NODES) ; mTmp=m[pfl3] ; mTmp.zipCoords() ; mTmp.setName(m.getName()) ; f2.setMesh(mTmp)
3132         f2.setName(fieldName2) ; f2.setTime(*t)
3133         da=m.getCoords().magnitude()[pfl2] ; da.setInfoOnComponents(["zzzz"])
3134         f2.setArray(da)
3135         f2.checkConsistencyLight()
3136         f1ts=MEDFileField1TS()
3137         f1ts.setFieldProfile(f2,mm,0,pfl2)
3138         fmts2.pushBackTimeStep(f1ts)
3139         #
3140         f3=MEDCouplingFieldDouble(ON_CELLS) ; mTmp=m[pfl3] ; mTmp.setName(m.getName()) ; f3.setMesh(mTmp)
3141         f3.setName(fieldName3) ; f3.setTime(*t)
3142         da=mTmp.computeCellCenterOfMass().magnitude() ; da.setInfoOnComponents(["abcdefg"])
3143         f3.setArray(da)
3144         f3.checkConsistencyLight()
3145         f1ts=MEDFileField1TS()
3146         f1ts.setFieldProfile(f3,mm,0,pfl3)
3147         fmts3.pushBackTimeStep(f1ts)
3148         ####
3149         t=(2.1,1,-3)
3150         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m)
3151         f0.setName(fieldName0) ; f0.setTime(*t)
3152         da=m.getCoords().magnitude() ; da.reverse() ; da.setInfoOnComponents(["zeInfo"])
3153         f0.setArray(da)
3154         f0.checkConsistencyLight()
3155         f1ts=MEDFileField1TS()
3156         f1ts.setFieldNoProfileSBT(f0)
3157         fmts0.pushBackTimeStep(f1ts)
3158         #
3159         f1=MEDCouplingFieldDouble(ON_CELLS) ; f1.setMesh(m)
3160         f1.setName(fieldName1) ; f1.setTime(*t)
3161         da=m.computeCellCenterOfMass().magnitude() ; da.reverse() ; da.setInfoOnComponents(["zeInfoCell"])
3162         f1.setArray(da)
3163         f1.checkConsistencyLight()
3164         f1ts=MEDFileField1TS()
3165         f1ts.setFieldNoProfileSBT(f1)
3166         fmts1.pushBackTimeStep(f1ts)
3167         #
3168         f2=MEDCouplingFieldDouble(ON_NODES) ; mTmp=m[pfl3] ; mTmp.zipCoords() ; mTmp.setName(m.getName()) ; f2.setMesh(mTmp)
3169         f2.setName(fieldName2) ; f2.setTime(*t)
3170         da=m.getCoords().magnitude()[pfl2] ; da.reverse() ; da.setInfoOnComponents(["zzzz"])
3171         f2.setArray(da)
3172         f2.checkConsistencyLight()
3173         f1ts=MEDFileField1TS()
3174         f1ts.setFieldProfile(f2,mm,0,pfl2)
3175         fmts2.pushBackTimeStep(f1ts)
3176         #
3177         f3=MEDCouplingFieldDouble(ON_CELLS) ; mTmp=m[pfl3] ; mTmp.setName(m.getName()) ; f3.setMesh(mTmp)
3178         f3.setName(fieldName3) ; f3.setTime(*t)
3179         da=mTmp.computeCellCenterOfMass().magnitude() ; da.reverse() ; da.setInfoOnComponents(["abcdefg"])
3180         f3.setArray(da)
3181         f3.checkConsistencyLight()
3182         f1ts=MEDFileField1TS()
3183         f1ts.setFieldProfile(f3,mm,0,pfl3)
3184         fmts3.pushBackTimeStep(f1ts)
3185         ####
3186         grp1=DataArrayInt([6,7,8,11,12,13,16,17,18]) ; grp1.setName("grp1")
3187         grp2=DataArrayInt([10,11,15,16,20,21]) ; grp2.setName("grp2")
3188         mm.setGroupsAtLevel(1,[grp1,grp2])
3189         grp3=DataArrayInt([4,5,6]) ; grp3.setName("grp3")
3190         grp4=DataArrayInt([8,9,10]) ; grp4.setName("grp4")
3191         mm.setGroupsAtLevel(0,[grp3,grp4])
3192         d=DataArrayInt(25) ; d.iota() ; d*=10 ;  mm.setRenumFieldArr(1,d)
3193         d=DataArrayInt(16) ; d.iota() ; d*=11 ;  mm.setRenumFieldArr(0,d)
3194         mm.write(fname,2)
3195         fs.appendGlobs(fmts2,1e-12)
3196         fs.appendGlobs(fmts3,1e-12)
3197         fs.write(fname,0)
3198         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3199         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
3200         fields=MEDFileFields(fname,False)
3201         fields.removeFieldsWithoutAnyTimeStep()
3202         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3203         allFMTSLeavesToDisplay=[]
3204         for fields in fields_per_mesh:
3205             allFMTSLeavesToDisplay2=[]
3206             for fmts in fields:
3207                 tmp=fmts.splitDiscretizations()
3208                 for itmp in tmp:
3209                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
3210                     pass
3211                 allFMTSLeavesToDisplay2+=tmp
3212                 pass
3213             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3214             pass
3215         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3216         self.assertEqual(len(allFMTSLeavesToDisplay[0]),4)
3217         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3218         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3219         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
3220         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3221         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),2)
3222         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),2)
3223         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),2)
3224         #
3225         mst=MEDFileMeshStruct.New(ms[0])
3226         #
3227         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
3228         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3229         mml2=mml.prepare()
3230         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3231         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3232         self.assertTrue(not ncc)
3233         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))
3234         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9])))
3235         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75])))
3236         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])))
3237         self.assertTrue(a4 is None)
3238         self.assertTrue(a5 is None)
3239         a6,a7=mml2.retrieveFamilyIdsOnCells()
3240         self.assertTrue(a6.isEqual(DataArrayInt([-5,-5,-5,-5,-6,-6,-6,-5,-7,-7,-7,-5,-5,-5,-5,-5])))
3241         self.assertTrue(a7) # no copy here
3242         a8,a9=mml2.retrieveNumberIdsOnCells()
3243         self.assertTrue(a8.isEqual(DataArrayInt([0,11,22,33,44,55,66,77,88,99,110,121,132,143,154,165])))
3244         self.assertTrue(a9) # no copy here
3245         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3246         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])))
3247         self.assertTrue(a11) # no copy here
3248         a12,a13=mml2.retrieveNumberIdsOnNodes()
3249         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])))
3250         self.assertTrue(a13) # no copy here
3251         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3252         for i in range(1, 2):
3253             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
3254             pass
3255         for i in range(2):
3256             f=allFMTSLeavesPerCommonSupport1[0][0][0][i]
3257             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3258             f.loadArraysIfNecessary()
3259             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3260             self.assertEqual(f.getName(),fieldName1)
3261             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3262             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])
3263             if i==1: vExp.reverse()
3264             vExp.setInfoOnComponents(["zeInfoCell"])
3265             self.assertTrue(v.isEqual(vExp,1e-12))
3266             #
3267             f=allFMTSLeavesPerCommonSupport1[0][0][1][i]
3268             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3269             f.loadArraysIfNecessary()
3270             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3271             self.assertEqual(f.getName(),fieldName0)
3272             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3273             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])
3274             if i==1: vExp.reverse()
3275             vExp.setInfoOnComponents(["zeInfo"])
3276             self.assertTrue(v.isEqual(vExp,1e-12))
3277             pass
3278         ### Testing the 2nd support
3279         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
3280         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3281         mml2=mml.prepare()
3282         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3283         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3284         self.assertTrue(not ncc)
3285         self.assertTrue(not ncc)
3286         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))
3287         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9])))
3288         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25])))
3289         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])))
3290         self.assertTrue(a4 is None)
3291         self.assertTrue(a5 is None)
3292         a6,a7=mml2.retrieveFamilyIdsOnCells()
3293         self.assertTrue(a6.isEqual(DataArrayInt([-6,-6,-7,-7,-5,-5])))
3294         self.assertTrue(not a7) # copy here
3295         a8,a9=mml2.retrieveNumberIdsOnCells()
3296         self.assertTrue(a8.isEqual(DataArrayInt([44,55,88,99,132,143])))
3297         self.assertTrue(not a9) # copy here
3298         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3299         self.assertTrue(a10.isEqual(DataArrayInt([1,2,2,3,4,2,3,4,2,3,3,1])))
3300         self.assertTrue(not a11) # copy here
3301         a12,a13=mml2.retrieveNumberIdsOnNodes()
3302         self.assertTrue(a12.isEqual(DataArrayInt([50,60,70,100,110,120,150,160,170,200,210,220])))
3303         self.assertTrue(not a13) # copy here
3304         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3305         for i in range(2):
3306             f=allFMTSLeavesPerCommonSupport1[1][0][0][i]
3307             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3308             f.loadArraysIfNecessary()
3309             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3310             self.assertEqual(f.getName(),fieldName3)
3311             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3312             vExp=DataArrayDouble([1.5811388300842,2.1213203435596,2.5495097567964,2.9154759474227,3.5355339059327,3.807886552932])
3313             if i==1: vExp.reverse()
3314             vExp.setInfoOnComponents(["abcdefg"])
3315             self.assertTrue(v.isEqual(vExp,1e-12))
3316             #
3317             f=allFMTSLeavesPerCommonSupport1[1][0][1][i]
3318             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3319             f.loadArraysIfNecessary()
3320             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3321             self.assertEqual(f.getName(),fieldName2)
3322             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3323             vExp=DataArrayDouble([1.,1.4142135623731,2.2360679774998,2.,2.2360679774998,2.8284271247462,3.,3.1622776601684,3.605551275464,4.,4.1231056256177,4.4721359549996])
3324             if i==1: vExp.reverse()
3325             vExp.setInfoOnComponents(["zzzz"])
3326             self.assertTrue(v.isEqual(vExp,1e-12))
3327             pass
3328         pass
3329
3330     @WriteInTmpDir
3331     def test21(self):
3332         """ Here the created MED file contains only a mesh. The aim here is to test capability of MEDReader to support no fields.
3333         This test checks nothing but write a MED file to be used by MEDReader tests.
3334         """
3335         fname="ForMEDReader21.med"
3336         mm=MEDFileUMesh()
3337         #
3338         m0=MEDCouplingCMesh("mesh") ; arr=DataArrayDouble(5) ; arr.iota() ; m0.setCoords(arr,arr) ; m0=m0.buildUnstructured()
3339         mm.setMeshAtLevel(0,m0)
3340         grp0=DataArrayInt([5,6,9,10]) ; grp0.setName("Inside2D")
3341         grp1=DataArrayInt([0,1,2,3,4,7,8,11,12,13,14,15]) ; grp1.setName("Border2D")
3342         grp2=DataArrayInt([2,3,6,7]) ; grp2.setName("LowerRight2D")
3343         mm.setGroupsAtLevel(0,[grp0,grp1,grp2])
3344         #
3345         m1=MEDCouplingUMesh(m0.getName(),1) ; m1.setCoords(m0.getCoords()) ; m1.allocateCells()
3346         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],
3347                     [10,11],[11,12],[12,13],[13,14]]:
3348             m1.insertNextCell(NORM_SEG2,elt)
3349             pass
3350         mm.setMeshAtLevel(-1,m1)
3351         grp4=DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]) ; grp4.setName("Border1D")
3352         grp5=DataArrayInt([16,17,18,19,20,21,22,23]) ; grp5.setName("Inside1D")
3353         grp6=DataArrayInt([18,19,22,23]) ; grp6.setName("UpperRight1D")
3354         mm.setGroupsAtLevel(-1,[grp4,grp5,grp6])
3355         #
3356         grp7=DataArrayInt([1,2,3,6,7,8,11,12,13,16,17,18,21,22,23]) ; grp7.setName("InsideYNode")
3357         grp8=DataArrayInt([5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]) ; grp8.setName("InsideXNode")
3358         mm.setGroupsAtLevel(1,[grp7,grp8])
3359         #
3360         mm.write(fname,2)
3361         pass
3362
3363     @WriteInTmpDir
3364     def test22(self):
3365         """ Use case where a field on nodes (ANodeField) on a mesh defined both in meshdim 2 and meshdim 1.
3366         The only possible geometrical support that suits the field is those with meshdim equal to 1 (-1 in relative).
3367         """
3368         fname="ForMEDReader22.med"
3369         fieldName0="ANodeField"
3370         mm=MEDFileUMesh()
3371         coo=DataArrayDouble([(4.,3.),(7.,3.),(2.,5.),(6.,5.),(9.,5.),(4.,7.),(8.,7.),(3.,8.),(9.,8.)])
3372         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])
3373         mm.setMeshAtLevel(0,m0)
3374         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])
3375         m1.insertNextCell(NORM_SEG2,[3,5]) ; m1.insertNextCell(NORM_SEG2,[5,7]) ; m1.insertNextCell(NORM_SEG2,[3,6]) ; m1.insertNextCell(NORM_SEG2,[6,8])
3376         mm.setMeshAtLevel(-1,m1)
3377         fs=MEDFileFields()
3378         fmts0=MEDFileFieldMultiTS() ; fs.pushField(fmts0)
3379         fmts0.setDtUnit("s")
3380         #
3381         t=(1.1,0,-2)
3382         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m1)
3383         f0.setName(fieldName0) ; f0.setTime(*t)
3384         da=DataArrayDouble(9) ; da.iota() ; da.setInfoOnComponents(["zeInfo"])
3385         f0.setArray(da)
3386         f0.checkConsistencyLight()
3387         f1ts=MEDFileField1TS()
3388         f1ts.setFieldNoProfileSBT(f0)
3389         fmts0.pushBackTimeStep(f1ts)
3390         #
3391         t=(2.1,1,-3)
3392         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m1)
3393         f0.setName(fieldName0) ; f0.setTime(*t)
3394         da=DataArrayDouble(9) ; da.iota() ; da.reverse() ; da.setInfoOnComponents(["zeInfo"])
3395         f0.setArray(da)
3396         f0.checkConsistencyLight()
3397         f1ts=MEDFileField1TS()
3398         f1ts.setFieldNoProfileSBT(f0)
3399         fmts0.pushBackTimeStep(f1ts)
3400         #
3401         mm.write(fname,2)
3402         fs.write(fname,0)
3403         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3404         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
3405         fields=MEDFileFields(fname,False)
3406         fields.removeFieldsWithoutAnyTimeStep()
3407         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3408         allFMTSLeavesToDisplay=[]
3409         for fields in fields_per_mesh:
3410             allFMTSLeavesToDisplay2=[]
3411             for fmts in fields:
3412                 tmp=fmts.splitDiscretizations()
3413                 for itmp in tmp:
3414                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
3415                     pass
3416                 allFMTSLeavesToDisplay2+=tmp
3417                 pass
3418             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3419             pass
3420         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3421         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
3422         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3423         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3424         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
3425         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3426         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
3427         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
3428         #
3429         mst=MEDFileMeshStruct.New(ms[0])
3430         #
3431         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
3432         self.assertEqual([NORM_TRI3,NORM_SEG2],fcscp.getGeoTypesAt(0,ms[0]))#contains all cell types of underlying mesh because only nodes with no profiles
3433         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3434         mml2=mml.prepare()
3435         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3436         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3437         self.assertTrue(not ncc)
3438         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))
3439         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5,3,3,3,3,3,3,3])))
3440         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,12,15,18,21,24,27,30])))
3441         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])))
3442         self.assertTrue(a4 is None)
3443         self.assertTrue(a5 is None)
3444         a6,a7=mml2.retrieveFamilyIdsOnCells()
3445         self.assertTrue(a6.isEqual(DataArrayInt([0,0,0,0,0,0,0,0,0,0])))
3446         self.assertTrue(not a7) # copy here
3447         a8,a9=mml2.retrieveNumberIdsOnCells()
3448         self.assertTrue(not a8)
3449         self.assertTrue(a9) # nocopy here
3450         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3451         self.assertTrue(not a10)
3452         self.assertTrue(a11) # no copy here
3453         a12,a13=mml2.retrieveNumberIdsOnNodes()
3454         self.assertTrue(not a12)
3455         self.assertTrue(a13) # no copy here
3456         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3457         #
3458         f=allFMTSLeavesPerCommonSupport1[0][0][0][0]
3459         fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3460         f.loadArraysIfNecessary()
3461         v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3462         self.assertEqual(f.getName(),fieldName0)
3463         self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3464         vExp=DataArrayDouble(9) ; vExp.iota() ; vExp.setInfoOnComponents(["zeInfo"])
3465         self.assertTrue(v.isEqual(vExp,1e-12))
3466         #
3467         f=allFMTSLeavesPerCommonSupport1[0][0][0][1]
3468         fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3469         f.loadArraysIfNecessary()
3470         v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3471         self.assertEqual(f.getName(),fieldName0)
3472         self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3473         vExp=DataArrayDouble(9) ; vExp.iota() ; vExp.setInfoOnComponents(["zeInfo"]) ; vExp.reverse()
3474         self.assertTrue(v.isEqual(vExp,1e-12))
3475         pass
3476
3477     @WriteInTmpDir
3478     def test23(self):
3479         """ Non regression test 2219 of modes. Idem than test22 except that here the node field is on profile.
3480         """
3481         fname="ForMEDReader23.med"
3482         fieldName0="ANodeField"
3483         mm=MEDFileUMesh()
3484         coo=DataArrayDouble([(4.,3.),(7.,3.),(2.,5.),(6.,5.),(9.,5.),(4.,7.),(8.,7.),(3.,8.),(9.,8.)])
3485         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])
3486         mm.setMeshAtLevel(0,m0)
3487         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])
3488         m1.insertNextCell(NORM_SEG2,[3,5]) ; m1.insertNextCell(NORM_SEG2,[5,7]) ; m1.insertNextCell(NORM_SEG2,[3,6]) ; m1.insertNextCell(NORM_SEG2,[6,8])
3489         mm.setMeshAtLevel(-1,m1)
3490         fmts0=MEDFileFieldMultiTS()
3491         fmts0.setDtUnit("s")
3492         #
3493         pfl=DataArrayInt([0,1,2,4]) ; pfl.setName("pfl")
3494         pflCell=DataArrayInt([0,1,2]) ; m1Part=m1[pflCell] ; m1Part.zipCoords()
3495         #
3496         t=(1.1,0,-2)
3497         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m1Part)
3498         f0.setName(fieldName0) ; f0.setTime(*t)
3499         da=DataArrayDouble(4) ; da.iota() ; da.setInfoOnComponents(["zeInfo"])
3500         f0.setArray(da)
3501         f0.checkConsistencyLight()
3502         f1ts=MEDFileField1TS()
3503         f1ts.setFieldProfile(f0,mm,-1,pfl)
3504         fmts0.pushBackTimeStep(f1ts)
3505         #
3506         t=(2.1,1,-3)
3507         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m1Part)
3508         f0.setName(fieldName0) ; f0.setTime(*t)
3509         da=DataArrayDouble(4) ; da.iota() ; da.reverse() ; da.setInfoOnComponents(["zeInfo"])
3510         f0.setArray(da)
3511         f0.checkConsistencyLight()
3512         f1ts=MEDFileField1TS()
3513         f1ts.setFieldProfile(f0,mm,-1,pfl)
3514         fmts0.pushBackTimeStep(f1ts)
3515         mm.write(fname,2)
3516         fmts0.write(fname,0)
3517         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3518         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
3519         fields=MEDFileFields(fname,False)
3520         fields.removeFieldsWithoutAnyTimeStep()
3521         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3522         allFMTSLeavesToDisplay=[]
3523         for fields in fields_per_mesh:
3524             allFMTSLeavesToDisplay2=[]
3525             for fmts in fields:
3526                 tmp=fmts.splitDiscretizations()
3527                 for itmp in tmp:
3528                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
3529                     pass
3530                 allFMTSLeavesToDisplay2+=tmp
3531                 pass
3532             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3533             pass
3534         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3535         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
3536         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3537         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3538         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
3539         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3540         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
3541         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
3542         #
3543         mst=MEDFileMeshStruct.New(ms[0])
3544         #
3545         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
3546         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3547         mml2=mml.prepare()
3548         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3549         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3550         self.assertTrue(not ncc)
3551         self.assertTrue(a0.isEqual(DataArrayDouble([(4.,3.,0.),(7.,3.,0.),(2.,5.,0.),(9.,5.,0.)]),1e-12))
3552         self.assertTrue(a1.isEqual(DataArrayByte([3,3,3])))
3553         self.assertTrue(a2.isEqual(DataArrayInt([0,3,6])))
3554         self.assertTrue(a3.isEqual(DataArrayInt([2,2,0,2,0,1,2,1,3])))
3555         self.assertTrue(a4 is None)
3556         self.assertTrue(a5 is None)
3557         a6,a7=mml2.retrieveFamilyIdsOnCells()
3558         self.assertTrue(a6.isEqual(DataArrayInt([0,0,0])))
3559         self.assertTrue(not a7) # copy here
3560         a8,a9=mml2.retrieveNumberIdsOnCells()
3561         self.assertTrue(not a8)
3562         self.assertTrue(a9) # nocopy here
3563         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3564         self.assertTrue(not a10)
3565         self.assertTrue(a11) # no copy here
3566         a12,a13=mml2.retrieveNumberIdsOnNodes()
3567         self.assertTrue(not a12)
3568         self.assertTrue(a13) # no copy here
3569         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3570         #
3571         f=allFMTSLeavesPerCommonSupport1[0][0][0][0]
3572         fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3573         f.loadArraysIfNecessary()
3574         v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3575         self.assertEqual(f.getName(),fieldName0)
3576         vExp=DataArrayDouble(4) ; vExp.iota() ; vExp.setInfoOnComponents(["zeInfo"])
3577         self.assertTrue(v.isEqual(vExp,1e-12))
3578         #
3579         f=allFMTSLeavesPerCommonSupport1[0][0][0][1]
3580         fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3581         f.loadArraysIfNecessary()
3582         v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3583         self.assertEqual(f.getName(),fieldName0)
3584         vExp=DataArrayDouble(4) ; vExp.iota() ; vExp.setInfoOnComponents(["zeInfo"]) ; vExp.reverse()
3585         self.assertTrue(v.isEqual(vExp,1e-12))
3586         pass
3587
3588     @WriteInTmpDir
3589     def test24(self):
3590         """ Non regression test for cartesian mesh whose the 3rd direction has only one node. It a false 3D mesh.
3591         """
3592         fname="ForMEDReader24.med"
3593         fieldName0="zeFieldNode"
3594         cmesh=MEDCouplingCMesh("mesh")
3595         arr0=DataArrayDouble([0.,1.1,2.2,3.3,4.4])
3596         arr1=DataArrayDouble([0.,1.4,2.3])
3597         arr2=DataArrayDouble([5.])
3598         cmesh.setCoords(arr0,arr1,arr2)
3599         fmts0=MEDFileFieldMultiTS()
3600         fmts0.setDtUnit("s")
3601         #
3602         t=(1.1,2,3)
3603         f=MEDCouplingFieldDouble(ON_NODES) ; f.setName(fieldName0)
3604         f.setMesh(cmesh)
3605         arr=DataArrayDouble(15) ; arr.setInfoOnComponents(["tutu"]) ; arr.iota()
3606         f.setArray(arr)
3607         f.setTime(*t)
3608         f1ts=MEDFileField1TS()
3609         f1ts.setFieldNoProfileSBT(f)
3610         fmts0.pushBackTimeStep(f1ts)
3611         #
3612         t=(3.3,4,5)
3613         arr=DataArrayDouble(15) ; arr.setInfoOnComponents(["tutu"]) ; arr.iota()
3614         arr.reverse()
3615         f.setArray(arr)
3616         f.setTime(*t)
3617         f1ts=MEDFileField1TS()
3618         f1ts.setFieldNoProfileSBT(f)
3619         fmts0.pushBackTimeStep(f1ts)
3620         #
3621         mm=MEDFileCMesh() ; mm.setMesh(cmesh)
3622         mm.write(fname,2)
3623         fmts0.write(fname,0)
3624         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3625         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
3626         fields=MEDFileFields(fname,False)
3627         fields.removeFieldsWithoutAnyTimeStep()
3628         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3629         allFMTSLeavesToDisplay=[]
3630         for fields in fields_per_mesh:
3631             allFMTSLeavesToDisplay2=[]
3632             for fmts in fields:
3633                 tmp=fmts.splitDiscretizations()
3634                 for itmp in tmp:
3635                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
3636                     pass
3637                 allFMTSLeavesToDisplay2+=tmp
3638                 pass
3639             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3640             pass
3641         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3642         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
3643         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3644         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3645         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
3646         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3647         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
3648         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),1)
3649         #
3650         mst=MEDFileMeshStruct.New(ms[0])
3651         #
3652         fcscp=allFMTSLeavesPerCommonSupport[0][1]
3653         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3654         mml2=mml.prepare()
3655         self.assertTrue(isinstance(mml2,MEDCMeshMultiLev))
3656         (a,b,c),d=mml2.buildVTUArrays()
3657         self.assertTrue(d)#d is True because the a,b and c are directly those in the internal data structure
3658         self.assertTrue(a.isEqual(arr0,1e-12))
3659         self.assertTrue(b.isEqual(arr1,1e-12))
3660         self.assertTrue(c.isEqual(arr2,1e-12))
3661         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3662         for i in range(2):
3663             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
3664             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
3665             f.loadArraysIfNecessary()
3666             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
3667             self.assertEqual(f.getName(),fieldName0)
3668             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
3669             vExp=DataArrayDouble(15) ; vExp.iota(0) ; vExp.setInfoOnComponents(["tutu"])
3670             if i==1:
3671                 vExp.reverse()
3672                 pass
3673             self.assertTrue(v.isEqual(vExp,1e-12))
3674             pass
3675         pass
3676
3677     @WriteInTmpDir
3678     def test25(self):
3679         """ A tricky test that reproduces an invalid behaviour
3680         Here a same field is defined both on CELLS and GAUSS_PT, with a profile for each.
3681         The problem appears on array computation when performing CELLS then GAUSS_PT and CELLS again.
3682         """
3683         fname="ForMEDReader25.med"
3684         m=MEDFileUMesh()
3685         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)
3686         m0=MEDCouplingUMesh("mesh",2) ; m0.setCoords(coords)
3687         m0.allocateCells()
3688         m0.insertNextCell(NORM_QUAD4,[0,3,4,1])
3689         m0.insertNextCell(NORM_QUAD4,[1,4,5,2])
3690         m0.insertNextCell(NORM_QUAD4,[3,6,7,4])
3691         m0.insertNextCell(NORM_QUAD4,[4,7,8,5])
3692         m0.insertNextCell(NORM_QUAD4,[6,9,10,7])
3693         m0.insertNextCell(NORM_QUAD4,[7,10,11,8])
3694         m.setMeshAtLevel(0,m0)
3695         m1=MEDCouplingUMesh("mesh",1) ; m1.setCoords(coords)
3696         m1.allocateCells()
3697         m1.insertNextCell(NORM_SEG2,[10,12])
3698         m1.insertNextCell(NORM_SEG2,[12,13])
3699         m1.insertNextCell(NORM_SEG2,[13,14])
3700         m.setMeshAtLevel(-1,m1)
3701         m.setFamilyFieldArr(0,DataArrayInt([-1,-2,-3,-4,-5,-6]))
3702         m.setFamilyFieldArr(-1,DataArrayInt([-7,-8,-9]))
3703         m.setFamilyFieldArr(1,DataArrayInt([3,4,5,6,7,8,9,10,11,12,13,14,15,16,17]))
3704         m.setRenumFieldArr(0,DataArrayInt([101,102,103,104,105,106]))
3705         m.setRenumFieldArr(-1,DataArrayInt([107,108,109]))
3706         m.setRenumFieldArr(1,DataArrayInt([203,204,205,206,207,208,209,210,211,212,213,214,215,216,217]))
3707         #
3708         fmts=MEDFileFieldMultiTS()
3709         info0=["aa","bbb"]
3710         name0="zeField"
3711         pflName0="pfl"
3712         pflName1="pfl2"
3713         #
3714         f1ts=MEDFileField1TS()
3715         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setName(name0)
3716         arr=DataArrayDouble([(-1,-11),(-2,-22)]) ; arr.setInfoOnComponents(info0)
3717         f.setArray(arr)
3718         pfl0=DataArrayInt([0,1]) ; pfl0.setName(pflName0)
3719         f1ts.setFieldProfile(f,m,-1,pfl0)
3720         del f
3721         f2=MEDCouplingFieldDouble(ON_GAUSS_PT) ; f2.setName(name0)
3722         arr=DataArrayDouble(15) ; arr.iota(1)
3723         arr=DataArrayDouble.Meld(arr,arr+10) ; arr.setInfoOnComponents(info0)
3724         f2.setArray(arr)
3725         pfl1=DataArrayInt([1,3,5]) ; pfl1.setName(pflName1)
3726         tmp=m0[pfl1] ; f2.setMesh(tmp)
3727         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])
3728         f2.checkConsistencyLight()
3729         f1ts.setFieldProfile(f2,m,0,pfl1)
3730         fmts.pushBackTimeStep(f1ts)
3731         #
3732         m.write(fname,2)
3733         fmts.write(fname,0)
3734         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3735         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
3736         fields=MEDFileFields(fname,False) # false is absolutely necessary for the test
3737         fields.removeFieldsWithoutAnyTimeStep()
3738         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3739         allFMTSLeavesToDisplay=[]
3740         for fields in fields_per_mesh:
3741             allFMTSLeavesToDisplay2=[]
3742             for fmts in fields:
3743                 tmp=fmts.splitDiscretizations()
3744                 for itmp in tmp:
3745                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
3746                     pass
3747                 allFMTSLeavesToDisplay2+=tmp
3748                 pass
3749             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3750             pass
3751         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3752         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
3753         ### here the test is important !!! Pointers must be different !
3754         self.assertTrue(allFMTSLeavesToDisplay[0][0][0].getUndergroundDataArray().getHiddenCppPointer()!=allFMTSLeavesToDisplay[0][1][0].getUndergroundDataArray().getHiddenCppPointer())
3755         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3756         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3757         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
3758         ### here the test is important !!! Pointers must be different !
3759         self.assertTrue(allFMTSLeavesToDisplay[0][0][0].getUndergroundDataArray().getHiddenCppPointer()!=allFMTSLeavesToDisplay[0][1][0].getUndergroundDataArray().getHiddenCppPointer())
3760         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3761         self.assertTrue(allFMTSLeavesToDisplay[0][0][0].getUndergroundDataArray().getHiddenCppPointer()!=allFMTSLeavesToDisplay[0][1][0].getUndergroundDataArray().getHiddenCppPointer())
3762         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),2)
3763         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
3764         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),1)
3765         #
3766         mst=MEDFileMeshStruct.New(ms[0])
3767         # emulate first click
3768         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
3769         self.assertEqual([NORM_SEG2],fcscp.getGeoTypesAt(0,ms[0]))
3770         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3771         mml2=mml.prepare()
3772         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3773         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3774         self.assertTrue(not ncc) # copy here because 2D -> 3D
3775         expCoords=coords.changeNbOfComponents(3,0.)
3776         self.assertTrue(a0.isEqual(expCoords,1e-12))
3777         self.assertTrue(a1.isEqual(DataArrayByte([3,3])))
3778         self.assertTrue(a2.isEqual(DataArrayInt([0,3])))
3779         self.assertTrue(a3.isEqual(DataArrayInt([2,10,12,2,12,13])))
3780         self.assertTrue(a4 is None)
3781         self.assertTrue(a5 is None)
3782         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3783         a6,a7=mml2.retrieveFamilyIdsOnCells()
3784         self.assertTrue(a6.isEqual(DataArrayInt([-7,-8])))
3785         self.assertTrue(not a7) # copy here because profile on cells
3786         a8,a9=mml2.retrieveNumberIdsOnCells()
3787         self.assertTrue(a8.isEqual(DataArrayInt([107,108])))
3788         self.assertTrue(not a9) # copy here because profile on cells
3789         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3790         self.assertTrue(a10.isEqual(DataArrayInt([3,4,5,6,7,8,9,10,11,12,13,14,15,16,17])))
3791         self.assertTrue(a11) # no copy here
3792         a12,a13=mml2.retrieveNumberIdsOnNodes()
3793         self.assertTrue(a12.isEqual(DataArrayInt([203,204,205,206,207,208,209,210,211,212,213,214,215,216,217])))
3794         self.assertTrue(a13) # no copy here
3795         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3796         fff0=allFMTSLeavesPerCommonSupport1[0][0][0][0]
3797         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff0,mst)
3798         fff0.loadArraysIfNecessary()
3799         self.assertEqual([ON_CELLS],fff0.getTypesOfFieldAvailable())
3800         v=mml.buildDataArray(fsst,fields,fff0.getUndergroundDataArray())
3801         self.assertEqual(fff0.getName(),name0)
3802         self.assertEqual(v.getHiddenCppPointer(),fff0.getUndergroundDataArray().getHiddenCppPointer())
3803         vExp=DataArrayDouble([(-1,-11),(-2,-22)]) ; vExp.setInfoOnComponents(info0)
3804         self.assertTrue(v.isEqual(vExp,1e-12))
3805         del fff0
3806         # emulate second click
3807         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
3808         self.assertEqual([NORM_QUAD4],fcscp.getGeoTypesAt(0,ms[0]))
3809         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3810         mml2=mml.prepare()
3811         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3812         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3813         self.assertTrue(not ncc) # copy here because 2D -> 3D
3814         expCoords=coords.changeNbOfComponents(3,0.)
3815         self.assertTrue(a0.isEqual(expCoords,1e-12))
3816         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9])))
3817         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10])))
3818         self.assertTrue(a3.isEqual(DataArrayInt([4,1,4,5,2,4,4,7,8,5,4,7,10,11,8])))
3819         self.assertTrue(a4 is None)
3820         self.assertTrue(a5 is None)
3821         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3822         a6,a7=mml2.retrieveFamilyIdsOnCells()
3823         self.assertTrue(a6.isEqual(DataArrayInt([-2,-4,-6])))
3824         self.assertTrue(not a7) # copy here because profile on cells
3825         a8,a9=mml2.retrieveNumberIdsOnCells()
3826         self.assertTrue(a8.isEqual(DataArrayInt([102,104,106])))
3827         self.assertTrue(not a9) # copy here because profile on cells
3828         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3829         self.assertTrue(a10.isEqual(DataArrayInt([3,4,5,6,7,8,9,10,11,12,13,14,15,16,17])))
3830         self.assertTrue(a11) # no copy here
3831         a12,a13=mml2.retrieveNumberIdsOnNodes()
3832         self.assertTrue(a12.isEqual(DataArrayInt([203,204,205,206,207,208,209,210,211,212,213,214,215,216,217])))
3833         self.assertTrue(a13) # no copy here
3834         fff1=allFMTSLeavesPerCommonSupport1[1][0][0][0]
3835         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff1,mst)
3836         fff1.loadArraysIfNecessary()
3837         self.assertEqual([ON_GAUSS_PT],fff1.getTypesOfFieldAvailable())
3838         v=mml.buildDataArray(fsst,fields,fff1.getUndergroundDataArray())
3839         self.assertEqual(fff1.getName(),name0)
3840         self.assertEqual(v.getHiddenCppPointer(),fff1.getUndergroundDataArray().getHiddenCppPointer())
3841         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)
3842         self.assertTrue(v.isEqual(vExp,1e-12))
3843         # emulate third click
3844         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
3845         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3846         mml2=mml.prepare()
3847         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3848         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3849         self.assertTrue(not ncc) # copy here because 2D -> 3D
3850         expCoords=coords.changeNbOfComponents(3,0.)
3851         self.assertTrue(a0.isEqual(expCoords,1e-12))
3852         self.assertTrue(a1.isEqual(DataArrayByte([3,3])))
3853         self.assertTrue(a2.isEqual(DataArrayInt([0,3])))
3854         self.assertTrue(a3.isEqual(DataArrayInt([2,10,12,2,12,13])))
3855         self.assertTrue(a4 is None)
3856         self.assertTrue(a5 is None)
3857         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3858         a6,a7=mml2.retrieveFamilyIdsOnCells()
3859         self.assertTrue(a6.isEqual(DataArrayInt([-7,-8])))
3860         self.assertTrue(not a7) # copy here because profile on cells
3861         a8,a9=mml2.retrieveNumberIdsOnCells()
3862         self.assertTrue(a8.isEqual(DataArrayInt([107,108])))
3863         self.assertTrue(not a9) # copy here because profile on cells
3864         a10,a11=mml2.retrieveFamilyIdsOnNodes()
3865         self.assertTrue(a10.isEqual(DataArrayInt([3,4,5,6,7,8,9,10,11,12,13,14,15,16,17])))
3866         self.assertTrue(a11) # no copy here
3867         a12,a13=mml2.retrieveNumberIdsOnNodes()
3868         self.assertTrue(a12.isEqual(DataArrayInt([203,204,205,206,207,208,209,210,211,212,213,214,215,216,217])))
3869         self.assertTrue(a13) # no copy here
3870         fff0=allFMTSLeavesPerCommonSupport1[0][0][0][0]
3871         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff0,mst)
3872         fff0.loadArraysIfNecessary()
3873         self.assertEqual([ON_CELLS],fff0.getTypesOfFieldAvailable())
3874         v=mml.buildDataArray(fsst,fields,fff0.getUndergroundDataArray())
3875         self.assertEqual(fff0.getName(),name0)
3876         self.assertEqual(v.getHiddenCppPointer(),fff0.getUndergroundDataArray().getHiddenCppPointer())
3877         vExp=DataArrayDouble([(-1,-11),(-2,-22)]) ; vExp.setInfoOnComponents(info0)
3878         self.assertTrue(v.isEqual(vExp,1e-12)) # <- THE test is here !!!
3879         del fff0
3880         pass
3881
3882     @WriteInTmpDir
3883     def test26(self):
3884         """ 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.
3885         For this type of fields the support will contain only vertices.
3886         """
3887         fname="ForMEDReader26.med"
3888         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.)])
3889         m0=MEDCouplingUMesh("mesh",2)
3890         m0.allocateCells()
3891         for elt in [[2,6,3],[6,7,3],[9,6,5],[9,10,6]]:
3892             m0.insertNextCell(NORM_TRI3,elt)
3893             pass
3894         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]]:
3895             m0.insertNextCell(NORM_QUAD4,elt)
3896             pass
3897         m0.setCoords(coords)
3898         ##
3899         mm=MEDFileUMesh()
3900         mm.setMeshAtLevel(0,m0)
3901         mm.setFamilyFieldArr(0,DataArrayInt([-1,-2,-3,-4,-5,-6,-7,-8,-9,-10,-11]))
3902         mm.setFamilyFieldArr(1,DataArrayInt([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]))
3903         #
3904         f1ts0Node=MEDFileField1TS()
3905         f1ts1Node=MEDFileField1TS()
3906         f1ts2Cell=MEDFileField1TS()
3907         f1ts3Cell=MEDFileField1TS()
3908         f1ts4Cell=MEDFileField1TS()
3909         f1ts5Node=MEDFileField1TS()
3910         #
3911         pfl0=DataArrayInt([4,5,6,8,9,12]) ; pfl0.setName("pfl0")
3912         pfl1=DataArrayInt([0,1,4,5,7,10]) ; pfl1.setName("pfl1")
3913         pfl2=DataArrayInt([0,1,2,3,4,5,6,7,10,11,14,15]) ; pfl2.setName("pfl2")
3914         #
3915         f0Node=MEDCouplingFieldDouble(ON_NODES) ; f0Node.setName("f0Node")
3916         arr0=DataArrayDouble(6) ; arr0.iota()
3917         f0Node.setArray(arr0)
3918         f1ts0Node.setFieldProfile(f0Node,mm,0,pfl0)
3919         #
3920         f1Node=MEDCouplingFieldDouble(ON_NODES) ; f1Node.setName("f1Node")
3921         arr1=DataArrayDouble(6) ; arr1.iota() ; arr1.reverse()
3922         f1Node.setArray(arr1)
3923         f1ts1Node.setFieldProfile(f1Node,mm,0,pfl0)
3924         #
3925         f2Cell=MEDCouplingFieldDouble(ON_CELLS) ; f2Cell.setName("f2Cell")
3926         arr2=DataArrayDouble([2,3,0,1,4,5])
3927         f2Cell.setArray(arr2)
3928         f1ts2Cell.setFieldProfile(f2Cell,mm,0,pfl1)
3929         #
3930         f3Cell=MEDCouplingFieldDouble(ON_CELLS) ; f3Cell.setName("f3Cell")
3931         arr3=DataArrayDouble([5,4,3,2,1,0])
3932         f3Cell.setArray(arr3)
3933         f1ts3Cell.setFieldProfile(f3Cell,mm,0,pfl1)
3934         #
3935         f4Cell=MEDCouplingFieldDouble(ON_CELLS) ; f4Cell.setName("f4Cell")
3936         arr4=DataArrayDouble([2,2,0,1,1,0])
3937         f4Cell.setArray(arr4)
3938         f1ts4Cell.setFieldProfile(f4Cell,mm,0,pfl1)
3939         #
3940         f5Node=MEDCouplingFieldDouble(ON_NODES) ; f5Node.setName("f5Node")
3941         arr5=DataArrayDouble([0,1,2,3,10,11,13,2,11,1,10,0])
3942         f5Node.setArray(arr5)
3943         f1ts5Node.setFieldProfile(f5Node,mm,0,pfl2)
3944         #
3945         fs=MEDFileFields()
3946         for f in [f1ts0Node,f1ts1Node,f1ts2Cell,f1ts3Cell,f1ts4Cell,f1ts5Node]:
3947             fmts=MEDFileFieldMultiTS()
3948             fmts.pushBackTimeStep(f)
3949             fs.pushField(fmts)
3950             pass
3951         mm.write(fname,2)
3952         fs.write(fname,0)
3953         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
3954         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
3955         fields=MEDFileFields(fname,False)
3956         fields.removeFieldsWithoutAnyTimeStep()
3957         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
3958         allFMTSLeavesToDisplay=[]
3959         for fields in fields_per_mesh:
3960             allFMTSLeavesToDisplay2=[]
3961             for fmts in fields:
3962                 tmp=fmts.splitDiscretizations()
3963                 for itmp in tmp:
3964                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
3965                     pass
3966                 allFMTSLeavesToDisplay2+=tmp
3967                 pass
3968             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
3969             pass
3970         self.assertEqual(len(allFMTSLeavesToDisplay),1)
3971         self.assertEqual(len(allFMTSLeavesToDisplay[0]),6)
3972         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
3973         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
3974         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),6)
3975         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
3976         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),2)
3977         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),4)
3978         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),2)# <- the smart one is here
3979         #
3980         mst=MEDFileMeshStruct.New(ms[0])
3981         #
3982         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
3983         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
3984         mml2=mml.prepare()
3985         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
3986         self.assertEqual([3,4,0],mml2.getGeoTypes())
3987         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
3988         self.assertTrue(not ncc)
3989         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))
3990         self.assertTrue(a1.isEqual(DataArrayByte([5,9,1])))
3991         self.assertTrue(a2.isEqual(DataArrayInt([0,4,9])))
3992         self.assertTrue(a3.isEqual(DataArrayInt([3,4,2,1,4,0,3,4,1,1,5])))
3993         self.assertTrue(a4 is None)
3994         self.assertTrue(a5 is None)
3995         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
3996         a6,a7=mml2.retrieveFamilyIdsOnCells()
3997         self.assertTrue(a6.isEqual(DataArrayInt([-3,-7,13])))
3998         self.assertTrue(not a7) # copy here because profile on cells
3999         a8,a9=mml2.retrieveNumberIdsOnCells()
4000         self.assertTrue(a8 is None)
4001         self.assertTrue(a9) # no copy here because no number field
4002         a10,a11=mml2.retrieveFamilyIdsOnNodes()
4003         self.assertTrue(a10.isEqual(DataArrayInt([5,6,7,9,10,13])))
4004         self.assertTrue(not a11) # copy here
4005         a12,a13=mml2.retrieveNumberIdsOnNodes()
4006         self.assertTrue(a12 is None)
4007         self.assertTrue(a13) # no copy here because no number field
4008         #
4009         fff0=allFMTSLeavesPerCommonSupport1[1][0][0][0]
4010         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff0,mst)
4011         fff0.loadArraysIfNecessary()
4012         v=mml2.buildDataArray(fsst,fields,fff0.getUndergroundDataArray())
4013         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4014         self.assertEqual(fff0.getName(),"f0Node")
4015         self.assertEqual(v.getHiddenCppPointer(),fff0.getUndergroundDataArray().getHiddenCppPointer())
4016         vExp=DataArrayDouble([0.,1.,2.,3.,4.,5.])
4017         self.assertTrue(v.isEqual(vExp,1e-12)) # <- THE test is here !!!
4018         #
4019         fff1=allFMTSLeavesPerCommonSupport1[1][0][1][0]
4020         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff1,mst)
4021         fff1.loadArraysIfNecessary()
4022         v=mml2.buildDataArray(fsst,fields,fff1.getUndergroundDataArray())
4023         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4024         self.assertEqual(fff1.getName(),"f1Node")
4025         self.assertEqual(v.getHiddenCppPointer(),fff1.getUndergroundDataArray().getHiddenCppPointer())
4026         vExp=DataArrayDouble([5.,4.,3.,2.,1.,0.])
4027         self.assertTrue(v.isEqual(vExp,1e-12)) # <- THE test is here !!!
4028         pass
4029
4030     @WriteInTmpDir
4031     def test27(self):
4032         """ This test defines 2 fields f0 and f1 on nodes lying on an unstructured mesh with no cells.
4033         f0 is a field on all nodes. f1 is a partial field on nodes.
4034         """
4035         fname="ForMEDReader27.med"
4036         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.)])
4037         m0=MEDCouplingUMesh("mesh",2)
4038         m0.allocateCells()
4039         m0.setCoords(coords)
4040         ##
4041         mm=MEDFileUMesh()
4042         mm.setMeshAtLevel(0,m0)
4043         mm.setFamilyFieldArr(1,DataArrayInt([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]))
4044         #
4045         f1ts0=MEDFileField1TS()
4046         f1ts1=MEDFileField1TS()
4047         #
4048         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m0) ; f0.setName("f0NoPfl")
4049         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.])
4050         f0.setArray(arr0)
4051         f0.checkConsistencyLight()
4052         f1ts0.setFieldNoProfileSBT(f0)
4053         self.assertEqual(f1ts0.getMeshName(),"mesh")
4054         #
4055         pfl1=DataArrayInt([0,1,2,3,4,5,6,8,9,12]) ; pfl1.setName("pfl1")
4056         f1=MEDCouplingFieldDouble(ON_NODES) ; f1.setName("f1Pfl")
4057         arr1=DataArrayDouble([3.,2.,1.,0.,2.,1.5,0.,1.,0.,0.2])
4058         f1.setArray(arr1)
4059         f1ts1.setFieldProfile(f1,mm,0,pfl1)
4060         self.assertEqual(f1ts1.getMeshName(),"mesh")
4061         #
4062         fs=MEDFileFields()
4063         fmts0=MEDFileFieldMultiTS()
4064         fmts0.pushBackTimeStep(f1ts0)
4065         fmts1=MEDFileFieldMultiTS()
4066         fmts1.pushBackTimeStep(f1ts1)
4067         fs.pushField(fmts0) ; fs.pushField(fmts1)
4068         self.assertEqual(fs[0].getMeshName(),"mesh")
4069         self.assertEqual(fs[1].getMeshName(),"mesh")
4070         mm.write(fname,2)
4071         fs.write(fname,0)
4072         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
4073         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
4074         fields=MEDFileFields(fname,False)
4075         fields.removeFieldsWithoutAnyTimeStep()
4076         self.assertEqual(fields[0].getMeshName(),"mesh")
4077         self.assertEqual(fields[1].getMeshName(),"mesh")
4078         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
4079         self.assertEqual(fields_per_mesh[0][0].getMeshName(),"mesh")
4080         self.assertEqual(fields_per_mesh[0][1].getMeshName(),"mesh")
4081         allFMTSLeavesToDisplay=[]
4082         for fields in fields_per_mesh:
4083             allFMTSLeavesToDisplay2=[]
4084             for fmts in fields:
4085                 tmp=fmts.splitDiscretizations()
4086                 for itmp in tmp:
4087                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
4088                     pass
4089                 allFMTSLeavesToDisplay2+=tmp
4090                 pass
4091             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
4092             pass
4093         self.assertEqual(len(allFMTSLeavesToDisplay),1)
4094         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
4095         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
4096         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
4097         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
4098         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
4099         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),2)
4100         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
4101         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),1)
4102         #
4103         mst=MEDFileMeshStruct.New(ms[0])
4104         #
4105         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
4106         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4107         mml2=mml.prepare()
4108         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
4109         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4110         self.assertTrue(ncc)
4111         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))
4112         self.assertTrue(a1.isEqual(DataArrayByte([])))
4113         self.assertTrue(a2.isEqual(DataArrayInt([])))
4114         self.assertTrue(a3.isEqual(DataArrayInt([])))
4115         self.assertTrue(a4 is None)
4116         self.assertTrue(a5 is None)
4117         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4118         #
4119         fff0=allFMTSLeavesPerCommonSupport1[0][0][0][0]
4120         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff0,mst)
4121         fff0.loadArraysIfNecessary()
4122         v=mml2.buildDataArray(fsst,fields,fff0.getUndergroundDataArray())
4123         self.assertEqual(fff0.getName(),"f0NoPfl")
4124         self.assertEqual(v.getHiddenCppPointer(),fff0.getUndergroundDataArray().getHiddenCppPointer())
4125         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])
4126         self.assertTrue(v.isEqual(vExp,1e-12))
4127         #
4128         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
4129         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4130         mml2=mml.prepare()
4131         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
4132         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4133         self.assertTrue(not ncc)
4134         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))
4135         self.assertTrue(a1.isEqual(DataArrayByte([])))
4136         self.assertTrue(a2.isEqual(DataArrayInt([])))
4137         self.assertTrue(a3.isEqual(DataArrayInt([])))
4138         self.assertTrue(a4 is None)
4139         self.assertTrue(a5 is None)
4140         fff1=allFMTSLeavesPerCommonSupport1[1][0][0][0]
4141         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff1,mst)
4142         fff1.loadArraysIfNecessary()
4143         v=mml2.buildDataArray(fsst,fields,fff1.getUndergroundDataArray())
4144         self.assertEqual(fff1.getName(),"f1Pfl")
4145         self.assertNotEqual(v.getHiddenCppPointer(),fff1.getUndergroundDataArray().getHiddenCppPointer()) # pointers are not equal because Profile
4146         vExp=DataArrayDouble([3.,2.,1.,0.,2.,1.5,0.,1.,0.,0.2])
4147         self.assertTrue(v.isEqual(vExp,1e-12))
4148         pass
4149
4150     @WriteInTmpDir
4151     def test28(self):
4152         """ This test defines 2 fields f0,f1,f2,f3 lying on an unstructured mesh with cells including NORM_POINT1.
4153         Both f0 and f1 are on NODES and f2 and f3 are on cells. f1 and f2 share the same support.
4154         f0 is on a nodal support that is not matchable with any cells (including NORM_POINT1)
4155         This test is a more aggressive version of test26.
4156         """
4157         fname="ForMEDReader28.med"
4158         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.)])
4159         m0=MEDCouplingUMesh("mesh",2)
4160         m0.allocateCells()
4161         for elt in [[2,6,3],[6,7,3],[9,6,5],[9,10,6]]:
4162             m0.insertNextCell(NORM_TRI3,elt)
4163             pass
4164         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]]:
4165             m0.insertNextCell(NORM_QUAD4,elt)
4166             pass
4167         m0.setCoords(coords)
4168         m2=MEDCouplingUMesh("mesh",0) ; m2.setCoords(coords)
4169         m2.allocateCells()
4170         for elt in [[8],[13]]:
4171             m2.insertNextCell(NORM_POINT1,elt)
4172             pass
4173         ##
4174         mm=MEDFileUMesh()
4175         mm.setMeshAtLevel(0,m0)
4176         mm.setMeshAtLevel(-2,m2)
4177         mm.setFamilyFieldArr(0,DataArrayInt([-1,-2,-3,-4,-5,-6,-7,-8,-9,-10,-11]))
4178         mm.setFamilyFieldArr(-2,DataArrayInt([-12,-13]))
4179         mm.setFamilyFieldArr(1,DataArrayInt([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]))
4180         #
4181         f1ts0Node=MEDFileField1TS()
4182         f1ts1Node=MEDFileField1TS()
4183         f1ts2Cell=MEDFileField1TS()
4184         f1ts3Cell=MEDFileField1TS()
4185         #
4186         pfl0=DataArrayInt([4,5,6,8,9,12]) ; pfl0.setName("pfl0")
4187         pfl1=DataArrayInt([0,1,4,5,7,10]) ; pfl1.setName("pfl1")
4188         pfl2=DataArrayInt([0,1,2,3,4,5,6,7,10,11,14,15]) ; pfl2.setName("pfl2")
4189         #
4190         f0Node=MEDCouplingFieldDouble(ON_NODES) ; f0Node.setName("f0Node")
4191         arr0=DataArrayDouble(6) ; arr0.iota()
4192         f0Node.setArray(arr0)
4193         f1ts0Node.setFieldProfile(f0Node,mm,0,pfl0)
4194         #
4195         f1Node=MEDCouplingFieldDouble(ON_NODES) ; f1Node.setName("f1Node")
4196         arr1=DataArrayDouble(12) ; arr1.iota() ; arr1.reverse()
4197         f1Node.setArray(arr1)
4198         f1ts1Node.setFieldProfile(f1Node,mm,0,pfl2)
4199         #
4200         f2Cell=MEDCouplingFieldDouble(ON_CELLS) ; f2Cell.setName("f2Cell")
4201         arr2=DataArrayDouble([2,3,0,1,4,5])
4202         f2Cell.setArray(arr2)
4203         f1ts2Cell.setFieldProfile(f2Cell,mm,0,pfl1)
4204         #
4205         f3Cell=MEDCouplingFieldDouble(ON_CELLS) ; f3Cell.setName("f3Cell")
4206         arr3=DataArrayDouble([5,4,3,2,1,0]) ; f3Cell.setArray(arr3)
4207         f1ts3Cell.setFieldProfile(f3Cell,mm,0,pfl1)
4208         f3Cell.setMesh(m2)
4209         arr3=DataArrayDouble([-1.1,-3.1]) ; f3Cell.setArray(arr3)
4210         f1ts3Cell.setFieldNoProfileSBT(f3Cell)
4211         #
4212         fs=MEDFileFields()
4213         for f in [f1ts0Node,f1ts1Node,f1ts2Cell,f1ts3Cell]:
4214             fmts=MEDFileFieldMultiTS()
4215             fmts.pushBackTimeStep(f)
4216             fs.pushField(fmts)
4217             pass
4218         mm.write(fname,2)
4219         fs.write(fname,0)
4220         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
4221         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
4222         fields=MEDFileFields(fname,False)
4223         fields.removeFieldsWithoutAnyTimeStep()
4224         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
4225         allFMTSLeavesToDisplay=[]
4226         for fields in fields_per_mesh:
4227             allFMTSLeavesToDisplay2=[]
4228             for fmts in fields:
4229                 tmp=fmts.splitDiscretizations()
4230                 for itmp in tmp:
4231                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
4232                     pass
4233                 allFMTSLeavesToDisplay2+=tmp
4234                 pass
4235             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
4236             pass
4237         self.assertEqual(len(allFMTSLeavesToDisplay),1)
4238         self.assertEqual(len(allFMTSLeavesToDisplay[0]),4)
4239         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
4240         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
4241         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),4)
4242         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
4243         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),3)
4244         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),2)
4245         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),1)
4246         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[2][0]),1)
4247         #
4248         mst=MEDFileMeshStruct.New(ms[0])
4249         #
4250         fcscp=allFMTSLeavesPerCommonSupport1[2][1]
4251         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4252         mml2=mml.prepare()
4253         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
4254         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4255         self.assertTrue(not ncc)
4256         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))
4257         self.assertTrue(a1.isEqual(DataArrayByte([5,9,1,1])))
4258         self.assertTrue(a2.isEqual(DataArrayInt([0,4,9,11])))
4259         self.assertTrue(a3.isEqual(DataArrayInt([3,4,2,1,4,0,3,4,1,1,3,1,5])))
4260         self.assertTrue(a4 is None)
4261         self.assertTrue(a5 is None)
4262         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4263         a6,a7=mml2.retrieveFamilyIdsOnCells()
4264         self.assertTrue(a6.isEqual(DataArrayInt([-3,-7,-12,13])))
4265         self.assertTrue(not a7) # copy here because profile on cells
4266         a8,a9=mml2.retrieveNumberIdsOnCells()
4267         self.assertTrue(a8 is None)
4268         self.assertTrue(a9) # no copy here because no number field
4269         a10,a11=mml2.retrieveFamilyIdsOnNodes()
4270         self.assertTrue(a10.isEqual(DataArrayInt([5,6,7,9,10,13])))
4271         self.assertTrue(not a11) # copy here
4272         a12,a13=mml2.retrieveNumberIdsOnNodes()
4273         self.assertTrue(a12 is None)
4274         self.assertTrue(a13) # no copy here because no number field
4275         #
4276         fff0=allFMTSLeavesPerCommonSupport1[2][0][0][0]
4277         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff0,mst)
4278         fff0.loadArraysIfNecessary()
4279         v=mml2.buildDataArray(fsst,fields,fff0.getUndergroundDataArray())
4280         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4281         self.assertEqual(fff0.getName(),"f0Node")
4282         self.assertEqual(v.getHiddenCppPointer(),fff0.getUndergroundDataArray().getHiddenCppPointer())
4283         vExp=DataArrayDouble([0.,1.,2.,3.,4.,5.])
4284         self.assertTrue(v.isEqual(vExp,1e-12)) # <- THE test is here !!!
4285         ###
4286         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
4287         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4288         mml2=mml.prepare()
4289         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
4290         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4291         self.assertTrue(not ncc)
4292         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))
4293         self.assertTrue(a1.isEqual(DataArrayByte([5,5,9,9,9,9])))
4294         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,13,18,23])))
4295         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])))
4296         self.assertTrue(a4 is None)
4297         self.assertTrue(a5 is None)
4298         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4299         fff1=allFMTSLeavesPerCommonSupport1[0][0][0][0]
4300         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff1,mst)
4301         fff1.loadArraysIfNecessary()
4302         v=mml2.buildDataArray(fsst,fields,fff1.getUndergroundDataArray())
4303         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4304         self.assertEqual(fff1.getName(),"f2Cell")
4305         self.assertNotEqual(v.getHiddenCppPointer(),fff0.getUndergroundDataArray().getHiddenCppPointer())
4306         vExp=DataArrayDouble([2,3,0,1,4,5])
4307         self.assertTrue(v.isEqual(vExp,1e-12))
4308         fff2=allFMTSLeavesPerCommonSupport1[0][0][1][0]
4309         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff2,mst)
4310         fff2.loadArraysIfNecessary()
4311         v=mml2.buildDataArray(fsst,fields,fff2.getUndergroundDataArray())
4312         self.assertEqual(fff2.getName(),"f1Node")
4313         self.assertNotEqual(v.getHiddenCppPointer(),fff0.getUndergroundDataArray().getHiddenCppPointer())
4314         vExp=DataArrayDouble([11,10,9,8,7,6,5,4,3,2,1,0])
4315         self.assertTrue(v.isEqual(vExp,1e-12))
4316         ###
4317         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
4318         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4319         mml2=mml.prepare()
4320         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
4321         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4322         self.assertTrue(ncc)# here all the 16 nodes are taken
4323         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))
4324         self.assertTrue(a1.isEqual(DataArrayByte([1,1,5,5,9,9,9,9])))
4325         self.assertTrue(a2.isEqual(DataArrayInt([0,2,4,8,12,17,22,27])))
4326         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])))
4327         self.assertTrue(a4 is None)
4328         self.assertTrue(a5 is None)
4329         fff3=allFMTSLeavesPerCommonSupport1[1][0][0][0]
4330         fsst=MEDFileField1TSStructItem.BuildItemFrom(fff3,mst)
4331         fff3.loadArraysIfNecessary()
4332         v=mml2.buildDataArray(fsst,fields,fff3.getUndergroundDataArray())
4333         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4334         self.assertEqual(fff3.getName(),"f3Cell")
4335         self.assertNotEqual(v.getHiddenCppPointer(),fff0.getUndergroundDataArray().getHiddenCppPointer())
4336         vExp=DataArrayDouble([-1.1,-3.1,5,4,3,2,1,0])
4337         self.assertTrue(v.isEqual(vExp,1e-12))
4338         pass
4339
4340     @WriteInTmpDir
4341     def test29(self):
4342         """ 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).
4343         """
4344         fname="ForMEDReader29.med"
4345         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.]])
4346         m=MEDCouplingUMesh("mesh",3) ; m.setCoords(coo)
4347         m.allocateCells()
4348         # 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]
4349         # 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]
4350         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])
4351         fCell=MEDCouplingFieldDouble(ON_CELLS) ; fCell.setName("fCell")
4352         arrCell=DataArrayDouble([7.]) ; arrCell.setInfoOnComponent(0,"smth") ; fCell.setArray(arrCell)
4353         fCell.setMesh(m)
4354         WriteField(fname,fCell,True)
4355         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.]
4356         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]
4357         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]
4358         fGauss=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fGauss.setName("fGauss")
4359         fGauss.setMesh(m)
4360         fGauss.setGaussLocalizationOnType(NORM_HEXA27,refCoo,gCoords,weights)
4361         arrGauss=DataArrayDouble(fGauss.getNumberOfTuplesExpected()) ; arrGauss.setInfoOnComponent(0,"gaussc") ; arrGauss.iota()
4362         fGauss.setArray(arrGauss)
4363         WriteFieldUsingAlreadyWrittenMesh(fname,fGauss)
4364         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
4365         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
4366         fields=MEDFileFields(fname,False)
4367         fields.removeFieldsWithoutAnyTimeStep()
4368         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
4369         allFMTSLeavesToDisplay=[]
4370         for fields in fields_per_mesh:
4371             allFMTSLeavesToDisplay2=[]
4372             for fmts in fields:
4373                 tmp=fmts.splitDiscretizations()
4374                 for itmp in tmp:
4375                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
4376                     pass
4377                 allFMTSLeavesToDisplay2+=tmp
4378                 pass
4379             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
4380             pass
4381         self.assertEqual(len(allFMTSLeavesToDisplay),1)
4382         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
4383         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
4384         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
4385         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
4386         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
4387         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
4388         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),2)
4389         #
4390         mst=MEDFileMeshStruct.New(ms[0])
4391         #
4392         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
4393         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4394         mml2=mml.prepare()
4395         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
4396         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4397         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4398         self.assertTrue(a0.isEqual(coo,1e-12))
4399         self.assertTrue(a1.isEqual(DataArrayByte([29])))
4400         self.assertTrue(a2.isEqual(DataArrayInt([0])))
4401         # the connectivity must be not a iota as declared in m.insertNextCell
4402         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
4403         self.assertTrue(a4 is None)
4404         self.assertTrue(a5 is None)
4405         ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][0]
4406         fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
4407         ffCell.loadArraysIfNecessary()
4408         v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
4409         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4410         self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
4411         self.assertEqual(ffCell.getName(),"fCell")
4412         self.assertTrue(v.isEqual(arrCell,1e-12)) ; self.assertTrue(v.isEqualWithoutConsideringStr(DataArrayDouble([7.]),1e-12)) ; self.assertEqual(v.getInfoOnComponents(),["smth"])
4413         del ffCell
4414         #
4415         ffGauss=allFMTSLeavesPerCommonSupport1[0][0][1][0]
4416         fsst=MEDFileField1TSStructItem.BuildItemFrom(ffGauss,mst)
4417         ffGauss.loadArraysIfNecessary()
4418         v=mml2.buildDataArray(fsst,fields,ffGauss.getUndergroundDataArray())
4419         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4420         self.assertEqual(v.getHiddenCppPointer(),ffGauss.getUndergroundDataArray().getHiddenCppPointer())
4421         self.assertEqual(ffGauss.getName(),"fGauss")
4422         self.assertTrue(v.isEqual(arrGauss, 1e-12)) ; self.assertTrue(v.isEqualWithoutConsideringStr(DataArrayDouble(list(range(27))), 1e-12)) ; self.assertEqual(v.getInfoOnComponents(), ["gaussc"])
4423         ffGauss=allFMTSLeavesPerCommonSupport1[0][0][1][0]
4424         pass
4425
4426     @WriteInTmpDir
4427     def test30(self):
4428         """ This test is focused on cartesian meshes. Here the cartesian mesh "CartMesh" has a field on HEXA8 (FieldOnCells) and a field on QUAD4 (FieldOnFaces).
4429         So the first one (FieldOnCells) lies on a cartesian mesh whereas the second one lies on unstructured one.
4430         """
4431         fname="ForMEDReader30.med"
4432         c=MEDCouplingCMesh()
4433         arrX=DataArrayDouble(3) ; arrX.iota()
4434         arrY=DataArrayDouble(4) ; arrY.iota()
4435         arrZ=DataArrayDouble(5) ; arrZ.iota()
4436         c.setCoords(arrX,arrY,arrZ)
4437         c.setName("CartMesh")
4438         cc=MEDFileCMesh()
4439         cc.setMesh(c)
4440         tmpFacesMesh=c.build1SGTSubLevelMesh()
4441         famIdFaces=DataArrayInt(98) ; famIdFaces[:36]=-1 ; famIdFaces[36:68]=-2 ; famIdFaces[68:]=-3
4442         famIdCells=DataArrayInt(24) ; famIdCells[:]=0
4443         #cc.setFamilyFieldArr(0,famIdCells)
4444         #cc.setFamilyFieldArr(-1,famIdFaces)
4445         cc.addFamily("FacesX",-1) ; cc.addFamily("FacesY",-2) ; cc.addFamily("FacesZ",-3)
4446         cc.setFamiliesOnGroup("FacesX1",["FacesX"])
4447         cc.setFamiliesOnGroup("FacesY1",["FacesY"])
4448         cc.setFamiliesOnGroup("FacesZ1",["FacesZ"])
4449         #
4450         fmts0=MEDFileFieldMultiTS()
4451         fmts1=MEDFileFieldMultiTS()
4452         for i in range(30):
4453             f1ts=MEDFileField1TS()
4454             fFaces=MEDCouplingFieldDouble(ON_CELLS) ; fFaces.setName("FieldOnFaces")
4455             arr=DataArrayDouble(98) ; arr.iota() ; arr[i]=100.
4456             fFaces.setArray(arr)
4457             fFaces.setTime(float(i)+0.1,i,-1)
4458             fFaces.setMesh(tmpFacesMesh)
4459             f1ts.setFieldNoProfileSBT(fFaces)
4460             fmts0.pushBackTimeStep(f1ts)
4461             #
4462             f1ts=MEDFileField1TS()
4463             fCells=MEDCouplingFieldDouble(ON_CELLS) ; fCells.setName("FieldOnCells")
4464             arr=DataArrayDouble(24) ; arr.iota() ; arr[i%24]=30.
4465             fCells.setArray(arr)
4466             fCells.setTime(float(i)+0.1,i,-1)
4467             fCells.setMesh(c)
4468             f1ts.setFieldNoProfileSBT(fCells)
4469             fmts1.pushBackTimeStep(f1ts)
4470             pass
4471         fs=MEDFileFields()
4472         fs.pushField(fmts0)
4473         fs.pushField(fmts1)
4474         cc.write(fname,2)
4475         fs.write(fname,0)
4476         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
4477         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
4478         fields=MEDFileFields(fname,False)
4479         fields.removeFieldsWithoutAnyTimeStep()
4480         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
4481         allFMTSLeavesToDisplay=[]
4482         for fields in fields_per_mesh:
4483             allFMTSLeavesToDisplay2=[]
4484             for fmts in fields:
4485                 tmp=fmts.splitDiscretizations()
4486                 for itmp in tmp:
4487                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
4488                     pass
4489                 allFMTSLeavesToDisplay2+=tmp
4490                 pass
4491             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
4492             pass
4493         self.assertEqual(len(allFMTSLeavesToDisplay),1)
4494         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
4495         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
4496         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
4497         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
4498         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
4499         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),2)
4500         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
4501         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),1)
4502         #
4503         mst=MEDFileMeshStruct.New(ms[0])
4504         #
4505         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
4506         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4507         mml2=mml.prepare()
4508         self.assertTrue(isinstance(mml2,MEDCMeshMultiLev)) # here CMesh is important
4509         (a,b,c),d=mml2.buildVTUArrays()
4510         self.assertTrue(d)#d is True because the a,b and c are directly those in the internal data structure
4511         self.assertTrue(a.isEqual(arrX,1e-12))
4512         self.assertTrue(b.isEqual(arrY,1e-12))
4513         self.assertTrue(c.isEqual(arrZ,1e-12))
4514         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4515         for i in range(30):
4516             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
4517             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
4518             ffCell.loadArraysIfNecessary()
4519             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
4520             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
4521             myarr=DataArrayDouble(24) ; myarr.iota() ; myarr[i%24]=30.
4522             self.assertEqual(ffCell.getName(),"FieldOnCells")
4523             self.assertTrue(v.isEqual(myarr,1e-12))
4524             pass
4525         #
4526         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
4527         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4528         mml2=mml.prepare()
4529         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev)) # here UMesh is important
4530         ref=ms[0].getImplicitFaceMesh().getCoords().getHiddenCppPointer()
4531         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4532         self.assertEqual(ref,a0.getHiddenCppPointer())
4533         self.assertTrue(ncc)
4534         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])))
4535         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])))
4536         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])))
4537         self.assertTrue(a4 is None)
4538         self.assertTrue(a5 is None)
4539         for i in range(30):
4540             ffCell=allFMTSLeavesPerCommonSupport1[1][0][0][i]
4541             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
4542             ffCell.loadArraysIfNecessary()
4543             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
4544             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
4545             myarr=DataArrayDouble(98) ; myarr.iota() ; myarr[i]=100.
4546             self.assertEqual(ffCell.getName(),"FieldOnFaces")
4547             self.assertTrue(v.isEqual(myarr,1e-12))
4548             pass
4549         pass
4550
4551     @WriteInTmpDir
4552     def test31(self):
4553         """non regression test of EDF 7972"""
4554         fname="ForMEDReader31.med"
4555         c=MEDCouplingCMesh()
4556         arrX=DataArrayDouble(3) ; arrX.iota()
4557         arrY=DataArrayDouble(4) ; arrY.iota()
4558         arrZ=DataArrayDouble(5) ; arrZ.iota()
4559         c.setCoords(arrX,arrY,arrZ)
4560         c.setName("CartMesh")
4561         cc=MEDFileCMesh()
4562         cc.setMesh(c)
4563         famIdCells=DataArrayInt(24) ; famIdCells[:]=0
4564         cc.setFamilyFieldArr(0,famIdCells)
4565         #cc.setFamilyFieldArr(-1,famIdFaces)
4566         cc.addFamily("FacesX",-1) ; cc.addFamily("FacesY",-2) ; cc.addFamily("FacesZ",-3)
4567         cc.setFamiliesOnGroup("FacesX1",["FacesX"])
4568         cc.setFamiliesOnGroup("FacesY1",["FacesY"])
4569         cc.setFamiliesOnGroup("FacesZ1",["FacesZ"])
4570         fmts0=MEDFileFieldMultiTS()
4571         fmts1=MEDFileFieldMultiTS()
4572         pfl=DataArrayInt(11) ; pfl.iota() ; pfl.setName("PflOnHECA8")
4573         for i in range(30):
4574             f1ts=MEDFileField1TS()
4575             fFaces=MEDCouplingFieldDouble(ON_CELLS) ; fFaces.setName("FieldOnCells")
4576             arr=DataArrayDouble(11) ; arr.iota() ; arr[i%11]=100.
4577             fFaces.setArray(arr)
4578             fFaces.setTime(float(i)+0.1,i,-1)
4579             fFaces.setMesh(c.buildUnstructured()[:11])
4580             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.
4581             self.assertEqual("PflOnHECA8",pfl.getName())
4582             fmts0.pushBackTimeStep(f1ts)
4583             pass
4584         fs=MEDFileFields()
4585         fs.pushField(fmts0)
4586         cc.write(fname,2)
4587         fs.write(fname,0)
4588         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
4589         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
4590         fields=MEDFileFields(fname,False)
4591         fields.removeFieldsWithoutAnyTimeStep()
4592         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
4593         allFMTSLeavesToDisplay=[]
4594         for fields in fields_per_mesh:
4595             allFMTSLeavesToDisplay2=[]
4596             for fmts in fields:
4597                 tmp=fmts.splitDiscretizations()
4598                 for itmp in tmp:
4599                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
4600                     pass
4601                 allFMTSLeavesToDisplay2+=tmp
4602                 pass
4603             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
4604             pass
4605         self.assertEqual(len(allFMTSLeavesToDisplay),1)
4606         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
4607         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
4608         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
4609         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
4610         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
4611         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
4612         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
4613         #
4614         mst=MEDFileMeshStruct.New(ms[0])
4615         #
4616         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
4617         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4618         mml2=mml.prepare()
4619         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev)) # here UMesh is important
4620         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4621         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4622         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.
4623         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))
4624         self.assertTrue(a1.isEqual(DataArrayByte([12,12,12,12,12,12,12,12,12,12,12])))
4625         self.assertTrue(a2.isEqual(DataArrayInt([0,9,18,27,36,45,54,63,72,81,90])))
4626         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])))
4627         self.assertTrue(a4 is None)
4628         self.assertTrue(a5 is None)
4629         for i in range(30):
4630             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
4631             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
4632             ffCell.loadArraysIfNecessary()
4633             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
4634             # self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer()) # to be improved... maybe this line could be true
4635             myarr=DataArrayDouble(11) ; myarr.iota() ; myarr[i%11]=100.
4636             self.assertEqual(ffCell.getName(),"FieldOnCells")
4637             self.assertTrue(v.isEqual(myarr,1e-12))
4638             pass
4639         pass
4640
4641     @WriteInTmpDir
4642     def test32(self):
4643         """ This test is close to test30 except that here the profiles on dim-1 of structured mesh is considered here."""
4644         fname="ForMEDReader32.med"
4645         c=MEDCouplingCMesh()
4646         arrX=DataArrayDouble(3) ; arrX.iota()
4647         arrY=DataArrayDouble(4) ; arrY.iota()
4648         arrZ=DataArrayDouble(5) ; arrZ.iota()
4649         c.setCoords(arrX,arrY,arrZ)
4650         c.setName("CartMesh")
4651         cc=MEDFileCMesh()
4652         cc.setMesh(c)
4653         tmpFacesMesh=c.build1SGTSubLevelMesh()
4654         famIdFaces=DataArrayInt(98) ; famIdFaces[:36]=-1 ; famIdFaces[36:68]=-2 ; famIdFaces[68:]=-3
4655         famIdCells=DataArrayInt(24) ; famIdCells[:]=0
4656         cc.setFamilyFieldArr(0,famIdCells)
4657         #cc.setFamilyFieldArr(-1,famIdFaces)
4658         cc.addFamily("FacesX",-1) ; cc.addFamily("FacesY",-2) ; cc.addFamily("FacesZ",-3)
4659         cc.setFamiliesOnGroup("FacesX1",["FacesX"])
4660         cc.setFamiliesOnGroup("FacesY1",["FacesY"])
4661         cc.setFamiliesOnGroup("FacesZ1",["FacesZ"])
4662         fmts0=MEDFileFieldMultiTS()
4663         fmts1=MEDFileFieldMultiTS()
4664         pfl=DataArrayInt(31) ; pfl.iota() ; pfl.setName("PflOnQUAD4")
4665         for i in range(30):
4666             f1ts=MEDFileField1TS()
4667             fFaces=MEDCouplingFieldDouble(ON_CELLS) ; fFaces.setName("FieldOnFaces")
4668             arr=DataArrayDouble(31) ; arr.iota() ; arr[i]=100.
4669             fFaces.setArray(arr)
4670             fFaces.setTime(float(i)+0.1,i,-1)
4671             fFaces.setMesh(tmpFacesMesh[:31])
4672             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.
4673             self.assertEqual("PflOnQUAD4",pfl.getName())
4674             fmts0.pushBackTimeStep(f1ts)
4675             #
4676             f1ts=MEDFileField1TS()
4677             fCells=MEDCouplingFieldDouble(ON_CELLS) ; fCells.setName("FieldOnCells")
4678             arr=DataArrayDouble(24) ; arr.iota() ; arr[i%24]=30.
4679             fCells.setArray(arr)
4680             fCells.setTime(float(i)+0.1,i,-1)
4681             fCells.setMesh(c)
4682             f1ts.setFieldNoProfileSBT(fCells)
4683             fmts1.pushBackTimeStep(f1ts)
4684             pass
4685         fs=MEDFileFields()
4686         fs.pushField(fmts0)
4687         fs.pushField(fmts1)
4688         cc.write(fname,2)
4689         fs.write(fname,0)
4690         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
4691         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
4692         fields=MEDFileFields(fname,False)
4693         fields.removeFieldsWithoutAnyTimeStep()
4694         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
4695         allFMTSLeavesToDisplay=[]
4696         for fields in fields_per_mesh:
4697             allFMTSLeavesToDisplay2=[]
4698             for fmts in fields:
4699                 tmp=fmts.splitDiscretizations()
4700                 for itmp in tmp:
4701                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
4702                     pass
4703                 allFMTSLeavesToDisplay2+=tmp
4704                 pass
4705             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
4706             pass
4707         self.assertEqual(len(allFMTSLeavesToDisplay),1)
4708         self.assertEqual(len(allFMTSLeavesToDisplay[0]),2)
4709         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
4710         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
4711         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),2)
4712         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
4713         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),2)
4714         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
4715         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),1)
4716         #
4717         mst=MEDFileMeshStruct.New(ms[0])
4718         #
4719         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
4720         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4721         mml2=mml.prepare()
4722         self.assertTrue(isinstance(mml2,MEDCMeshMultiLev)) # here CMesh is important
4723         (a,b,c),d=mml2.buildVTUArrays()
4724         self.assertTrue(d)#d is True because the a,b and c are directly those in the internal data structure
4725         self.assertTrue(a.isEqual(arrX,1e-12))
4726         self.assertTrue(b.isEqual(arrY,1e-12))
4727         self.assertTrue(c.isEqual(arrZ,1e-12))
4728         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4729         for i in range(30):
4730             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
4731             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
4732             ffCell.loadArraysIfNecessary()
4733             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
4734             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
4735             myarr=DataArrayDouble(24) ; myarr.iota() ; myarr[i%24]=30.
4736             self.assertEqual(ffCell.getName(),"FieldOnCells")
4737             self.assertTrue(v.isEqual(myarr,1e-12))
4738             pass
4739         #
4740         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
4741         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4742         mml2=mml.prepare()
4743         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev)) # here UMesh is important
4744         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4745         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4746         self.assertTrue(ncc)# True because, the coords are computed by the implicit unstructured level -1 structured mesh
4747         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))
4748         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])))
4749         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])))
4750         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])))
4751         self.assertTrue(a4 is None)
4752         self.assertTrue(a5 is None)
4753         a6,a7=mml2.retrieveFamilyIdsOnCells()
4754         self.assertTrue(a6 is None)
4755         self.assertTrue(a7)
4756         for i in range(30):
4757             ffCell=allFMTSLeavesPerCommonSupport1[1][0][0][i]
4758             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
4759             ffCell.loadArraysIfNecessary()
4760             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
4761             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
4762             myarr=DataArrayDouble(31) ; myarr.iota() ; myarr[i]=100.
4763             self.assertEqual(ffCell.getName(),"FieldOnFaces")
4764             self.assertTrue(v.isEqual(myarr,1e-12))
4765             pass
4766         pass
4767
4768     @WriteInTmpDir
4769     def test33(self):
4770         """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."""
4771         fname="ForMEDReader33.med"
4772         fieldName="ACellField"
4773         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)])
4774         m=MEDCouplingUMesh("mesh",2)
4775         m.setCoords(coo)
4776         m.allocateCells()
4777         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)]):
4778             if i<6:
4779                 typ=NORM_QUAD4
4780                 pass
4781             else:
4782                 typ=NORM_POLYGON
4783                 pass
4784             m.insertNextCell(typ,c)
4785             pass
4786         mm=MEDFileUMesh()
4787         mm.setMeshAtLevel(0,m)
4788         mm.write(fname,2)
4789         for i in range(15):
4790             fCell0=MEDCouplingFieldDouble(ON_CELLS) ; fCell0.setTime(float(i)+0.1,i,0)
4791             fCell0.setName(fieldName) ; fCell0.setMesh(m)
4792             arr=DataArrayDouble(m.getNumberOfCells()) ; arr.iota(0) ; arr[i%10]=100.
4793             fCell0.setArray(arr) ; arr.setInfoOnComponents(["Comp1 [m]"])
4794             fCell0.checkConsistencyLight()
4795             WriteFieldUsingAlreadyWrittenMesh(fname,fCell0)
4796             pass
4797         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
4798         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
4799         fields=MEDFileFields(fname,False)
4800         fields.removeFieldsWithoutAnyTimeStep()
4801         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
4802         allFMTSLeavesToDisplay=[]
4803         for fields in fields_per_mesh:
4804             allFMTSLeavesToDisplay2=[]
4805             for fmts in fields:
4806                 tmp=fmts.splitDiscretizations()
4807                 for itmp in tmp:
4808                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
4809                     pass
4810                 allFMTSLeavesToDisplay2+=tmp
4811                 pass
4812             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
4813             pass
4814         self.assertEqual(len(allFMTSLeavesToDisplay),1)
4815         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
4816         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
4817         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
4818         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
4819         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
4820         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
4821         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),1)
4822         #
4823         mst=MEDFileMeshStruct.New(ms[0])
4824         #
4825         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
4826         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4827         mml2=mml.prepare()
4828         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
4829         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4830         self.assertTrue(not ncc)# false because 2D in MED file
4831         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))
4832         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9,7,7,7,7])))
4833         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45])))# the bug was here.
4834         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])))
4835         self.assertTrue(a4 is None)
4836         self.assertTrue(a5 is None)
4837         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4838         for i in range(15):
4839             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
4840             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
4841             ffCell.loadArraysIfNecessary()
4842             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
4843             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
4844             myarr=DataArrayDouble(10) ; myarr.iota() ; myarr[i%10]=100. ; myarr.setInfoOnComponent(0,"Comp1 [m]")
4845             self.assertEqual(ffCell.getName(),fieldName)
4846             self.assertTrue(v.isEqual(myarr,1e-12))
4847             pass
4848         pass
4849
4850     @WriteInTmpDir
4851     def test34(self):
4852         """ This test is the thirs ultimate test (base on test12) for the profiles with gauss points.
4853         This test highlight the hidden imp linked to bug #8655.
4854         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.
4855         """
4856         fname="ForMEDReader34.med"
4857         m=MEDCouplingCMesh("mesh")
4858         arr=DataArrayDouble(5) ; arr.iota()
4859         m.setCoords(arr,arr)
4860         m=m.buildUnstructured() ; m.getCoords().setInfoOnComponents(["XX [m]","YYY [km]"])
4861         mm=MEDFileUMesh() ; mm.setMeshes([m])
4862         #
4863         fieldName0="zeField0"
4864         fieldName1="zeField1"
4865         fs0=MEDFileFieldMultiTS() ; fs1=MEDFileFieldMultiTS()
4866         for i in range(5):
4867             f=MEDFileField1TS()
4868             fNode=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fNode.setTime(float(i),i,0)
4869             fNode.setName(fieldName0) ; fNode.setMesh(m)
4870             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])
4871             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])
4872             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])
4873             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])
4874             arr=DataArrayDouble(2*(2*6+5*4+4*3+7*3)) ; arr.iota(0+1000*i) ; arr.rearrange(2)
4875             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_0 [m]","Com2_0 [s^2]"]) ; fNode.checkConsistencyLight()
4876             f.setFieldNoProfileSBT(fNode)
4877             fs0.pushBackTimeStep(f)
4878             #
4879             f=MEDFileField1TS()
4880             fNode=MEDCouplingFieldDouble(ON_CELLS) ; fNode.setTime(float(i),i,0)
4881             fNode.setName(fieldName1) ; fNode.setMesh(m)
4882             arr=DataArrayDouble(2*16) ; arr.iota(300+1000*i) ; arr.rearrange(2)
4883             fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_1 [m]","Com2_1 [s^2]"]) ; fNode.checkConsistencyLight()
4884             f.setFieldNoProfileSBT(fNode)
4885             fs1.pushBackTimeStep(f)
4886             pass
4887         mm.write(fname,2)
4888         fs0.write(fname,0) ; fs1.write(fname,0)
4889         a0Exp=mm.getCoords().deepCopy()
4890         del m,mm,fs0,fs1,f,fNode
4891         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
4892         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
4893         fields=MEDFileFields(fname,False)
4894         fields.removeFieldsWithoutAnyTimeStep()
4895         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
4896         allFMTSLeavesToDisplay=[]
4897         for fields in fields_per_mesh:
4898             allFMTSLeavesToDisplay2=[]
4899             for fmts in fields:
4900                 tmp=fmts.splitDiscretizations()
4901                 for itmp in tmp:
4902                     if itmp.presenceOfMultiDiscPerGeoType():
4903                         tmp2=itmp.splitMultiDiscrPerGeoTypes()
4904                         for iii,itmp2 in enumerate(tmp2):
4905                             name="%s_%i"%(itmp2.getName(),iii)
4906                             itmp2.setName(name)
4907                             allFMTSLeavesToDisplay2.append(itmp2)
4908                             pass
4909                         pass
4910                     else:
4911                         allFMTSLeavesToDisplay2.append(itmp)
4912                         pass
4913                 pass
4914             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
4915             pass
4916         # 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
4917         self.assertEqual(len(allFMTSLeavesToDisplay),1)
4918         self.assertEqual(len(allFMTSLeavesToDisplay[0]),5)
4919         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
4920         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
4921         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),5)
4922         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
4923         self.assertEqual(len(allFMTSLeavesPerCommonSupport),5)
4924         for i in range(5):
4925             self.assertEqual(len(allFMTSLeavesPerCommonSupport[i][0]),1)
4926         #
4927         mst=MEDFileMeshStruct.New(ms[0])
4928         #
4929         fcscp=allFMTSLeavesPerCommonSupport[4][1]
4930         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
4931         mml2=mml.prepare()
4932         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
4933         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
4934         self.assertTrue(not ncc)
4935         self.assertTrue(a0.isEqual(a0Exp.changeNbOfComponents(3,0.),1e-12))
4936         self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9])))
4937         self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75])))
4938         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
4939         self.assertTrue(a4 is None)
4940         self.assertTrue(a5 is None)
4941         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
4942         for i in range(1, 5):
4943             self.assertTrue((fcscp.isDataSetSupportEqualToThePreviousOne(i,fields)))
4944             pass
4945         for i in range(5):
4946             f=allFMTSLeavesPerCommonSupport[0][0][0][i]
4947             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
4948             f.loadArraysIfNecessary()
4949             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
4950             self.assertEqual(f.getName(),fieldName0)
4951             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.)])
4952             vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
4953             vExp+=i*1000
4954             self.assertTrue(v.isEqual(vExp,1e-12))
4955             #
4956             f=allFMTSLeavesPerCommonSupport[1][0][0][i]
4957             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
4958             f.loadArraysIfNecessary()
4959             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
4960             self.assertEqual(f.getName(),fieldName0)
4961             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.)])
4962             vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
4963             vExp+=i*1000
4964             self.assertTrue(v.isEqual(vExp,1e-12))
4965             #
4966             f=allFMTSLeavesPerCommonSupport[2][0][0][i]
4967             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
4968             f.loadArraysIfNecessary()
4969             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
4970             self.assertEqual(f.getName(),fieldName0)
4971             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.)])
4972             vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
4973             vExp+=i*1000
4974             self.assertTrue(v.isEqual(vExp,1e-12))
4975             #
4976             f=allFMTSLeavesPerCommonSupport[3][0][0][i]
4977             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
4978             f.loadArraysIfNecessary()
4979             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
4980             self.assertEqual(f.getName(),fieldName0)
4981             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)])
4982             vExp.setInfoOnComponents(['Comp1_0 [m]','Com2_0 [s^2]'])
4983             vExp+=i*1000
4984             self.assertTrue(v.isEqual(vExp,1e-12))
4985             #
4986             f=allFMTSLeavesPerCommonSupport[4][0][0][i]
4987             fsst=MEDFileField1TSStructItem.BuildItemFrom(f,mst)
4988             f.loadArraysIfNecessary()
4989             v=mml.buildDataArray(fsst,fields,f.getUndergroundDataArray())
4990             self.assertEqual(f.getName(),fieldName1)
4991             self.assertEqual(v.getHiddenCppPointer(),f.getUndergroundDataArray().getHiddenCppPointer())
4992             vExp=DataArrayDouble(16*2) ; vExp.iota(300+i*1000) ; vExp.rearrange(2) ; vExp.setInfoOnComponents(['Comp1_1 [m]','Com2_1 [s^2]'])
4993             self.assertTrue(v.isEqual(vExp,1e-12))
4994             pass
4995         pass
4996
4997     @WriteInTmpDir
4998     def test35(self):
4999         """ Emulate MEDReader in // mode context. Here a Simple mesh having more nodes than really needed. This test focuses on that point particularly."""
5000         fname="ForMEDReader35.med"
5001         arrX=DataArrayDouble(7) ; arrX.iota()
5002         arrY=DataArrayDouble([0.,1.])
5003         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY) ; m=m.buildUnstructured() ; m=m[[0,5,1,4,2,3]] ; m.changeSpaceDimension(3,0.) ; m.setName("Mesh")
5004         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"])
5005         WriteUMesh(fname,m,True)
5006         WriteFieldUsingAlreadyWrittenMesh(fname,f)
5007         ########## GO for reading in MEDReader,by not loading all. Mesh is fully loaded but not fields values
5008         ms=MEDFileMeshes() # here we reproduce what is done by ParaMEDFileMeshes.ParaNew
5009         ms.pushMesh(MEDFileUMesh.LoadPartOf(fname,"Mesh",[NORM_QUAD4],[0,2,1],-1,-1));
5010         ms[0].zipCoords()
5011         ms.cartesianizeMe()
5012         #
5013         fields=MEDFileFields.LoadPartOf(fname,False,ms);
5014         fields.removeFieldsWithoutAnyTimeStep()
5015         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
5016         allFMTSLeavesToDisplay=[]
5017         for fields in fields_per_mesh:
5018             allFMTSLeavesToDisplay2=[]
5019             for fmts in fields:
5020                 tmp=fmts.splitDiscretizations()
5021                 for itmp in tmp:
5022                     if itmp.presenceOfMultiDiscPerGeoType():
5023                         tmp2=itmp.splitMultiDiscrPerGeoTypes()
5024                         for iii,itmp2 in enumerate(tmp2):
5025                             name="%s_%i"%(itmp2.getName(),iii)
5026                             itmp2.setName(name)
5027                             allFMTSLeavesToDisplay2.append(itmp2)
5028                             pass
5029                         pass
5030                     else:
5031                         allFMTSLeavesToDisplay2.append(itmp)
5032                         pass
5033                 pass
5034             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
5035             pass
5036         #
5037         self.assertEqual(len(allFMTSLeavesToDisplay),1)
5038         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
5039         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
5040         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1) # one time serie here : because the 2 fields are defined on the same time steps
5041         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),1)
5042         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
5043         self.assertEqual(len(allFMTSLeavesPerCommonSupport),1)
5044         self.assertEqual(len(allFMTSLeavesPerCommonSupport[0][0]),1)
5045         #
5046         mst=MEDFileMeshStruct.New(ms[0])
5047         #
5048         fcscp=allFMTSLeavesPerCommonSupport[0][1]
5049         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5050         mml2=mml.prepare()
5051         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
5052         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
5053         self.assertTrue(ncc)
5054         self.assertTrue(a0.isEqual(m.getCoords()[[0,1,5,6,7,8,12,13]],1e-12))# <- the aim of the test
5055         self.assertTrue(a1.isEqual(DataArrayByte([9,9])))
5056         self.assertTrue(a2.isEqual(DataArrayInt([0,5])))
5057         self.assertTrue(a3.isEqual(DataArrayInt([4,1,0,4,5,4,3,2,6,7])))
5058         self.assertTrue(a4 is None)
5059         self.assertTrue(a5 is None)
5060         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny().isEqual(DataArrayInt([0,1,5,6,7,8,12,13])))
5061         f2=allFMTSLeavesPerCommonSupport[0][0][0][0]
5062         fsst=MEDFileField1TSStructItem.BuildItemFrom(f2,mst)
5063         f2.loadArraysIfNecessary()
5064         v=mml.buildDataArray(fsst,fields,f2.getUndergroundDataArray())
5065         self.assertEqual(f2.getName(),f.getName())
5066         vExp=DataArrayDouble([(0.1,1.1),(2.1,3.1)])
5067         vExp.setInfoOnComponents(['aa','bbb'])
5068         self.assertTrue(v.isEqual(vExp,1e-12))
5069         pass
5070
5071     @WriteInTmpDir
5072     def test36(self):
5073         """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.
5074         aaa field on GAUSSPoints lying only on TRI3 share the same support than profile node field ccc.
5075         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."""
5076         meshName="mesh"
5077         fname="ForMEDReader36.med"
5078         c=DataArrayDouble([(0,0),(1,0),(1,1),(0,1),(2,0),(-1,0),(1,2)])
5079         m0=MEDCoupling1SGTUMesh(meshName,NORM_TRI3)
5080         m0.setCoords(c)
5081         m0.setNodalConnectivity(DataArrayInt([0,2,1,3,2,0,2,4,1]))
5082         mm=MEDFileUMesh()
5083         mm[0]=m0
5084         m1=MEDCoupling1SGTUMesh(meshName,NORM_SEG2)
5085         m1.setCoords(c)
5086         m1.setNodalConnectivity(DataArrayInt([5,0,0,3,3,2,2,6]))
5087         mm[-1]=m1
5088         #
5089         zeTime=(1.1,2,3)
5090         ff1=MEDFileField1TS()
5091         f1=MEDCouplingFieldDouble(ON_NODES) ; f1.setMesh(m0)
5092         arr=DataArrayDouble(7) ; arr.iota(2000)
5093         f1.setArray(arr)
5094         f1.setName("bbb")
5095         f1.checkConsistencyLight()
5096         f1.setTime(*zeTime)
5097         ff1.setFieldNoProfileSBT(f1)
5098         #
5099         ff2=MEDFileField1TS()
5100         f2=MEDCouplingFieldDouble(ON_GAUSS_NE) ; f2.setMesh(m0)
5101         arr=DataArrayDouble(9) ; arr.iota(4000)
5102         f2.setArray(arr)
5103         f2.setName("ddd")
5104         f2.checkConsistencyLight()
5105         f2.setTime(*zeTime)
5106         ff2.setFieldNoProfileSBT(f2)
5107         #
5108         ff3=MEDFileField1TS()
5109         f3=MEDCouplingFieldDouble(ON_GAUSS_PT) ; f3.setMesh(m0)
5110         f3.setGaussLocalizationOnType(NORM_TRI3,[0,0,1,0,0,1],[0.333333,0.333333],[0.5])
5111         arr=DataArrayDouble(3) ; arr.iota(1000)
5112         f3.setArray(arr)
5113         f3.checkConsistencyLight()
5114         f3.setTime(*zeTime)
5115         f3.setName("aaa")
5116         ff3.setFieldNoProfileSBT(f3)
5117         #
5118         ff4=MEDFileField1TS()
5119         m0d=m0.deepCopy() ; m0d.zipCoords()
5120         f4=MEDCouplingFieldDouble(ON_NODES) ; f4.setMesh(m0d)
5121         arr=DataArrayDouble(5) ; arr.iota(3000)
5122         f4.setArray(arr)
5123         f4.setName("ccc")
5124         f4.checkConsistencyLight()
5125         f4.setTime(*zeTime)
5126         pfl=DataArrayInt([0,1,2,3,4]) ; pfl.setName("PFL")
5127         ff4.setFieldProfile(f4,mm,0,pfl)
5128         #
5129         mm.write(fname,2)
5130         ff3.write(fname,0)
5131         ff1.write(fname,0)
5132         ff4.write(fname,0)
5133         ###
5134         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
5135         fields=MEDFileFields(fname,False)
5136         fields.removeFieldsWithoutAnyTimeStep()
5137         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
5138         allFMTSLeavesToDisplay=[]
5139         for fields in fields_per_mesh:
5140             allFMTSLeavesToDisplay2=[]
5141             for fmts in fields:
5142                 tmp=fmts.splitDiscretizations()
5143                 for itmp in tmp:
5144                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
5145                     pass
5146                 allFMTSLeavesToDisplay2+=tmp
5147                 pass
5148             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
5149             pass
5150         self.assertEqual(len(allFMTSLeavesToDisplay),1)
5151         self.assertEqual(len(allFMTSLeavesToDisplay[0]),3)
5152         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
5153         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
5154         self.assertEqual(len(allFMTSLeavesPerTimeSeries[0]),3)
5155         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
5156         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),2)
5157         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[0][0]),2)
5158         self.assertEqual(len(allFMTSLeavesPerCommonSupport1[1][0]),1)
5159         #
5160         mst=MEDFileMeshStruct.New(ms[0])
5161         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
5162         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5163         mml2=mml.prepare()
5164         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
5165         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
5166         self.assertTrue(not ncc)# here ncc=False because the coordinates are not in ms neither in children.
5167         self.assertTrue(a0.isEqual(DataArrayDouble([(0,0,0),(1,0,0),(1,1,0),(0,1,0),(2,0,0)]),1e-12))
5168         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5])))
5169         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8])))
5170         self.assertTrue(a3.isEqual(DataArrayInt([3,0,2,1,3,3,2,0,3,2,4,1])))
5171         self.assertTrue(a4 is None)
5172         self.assertTrue(a5 is None)
5173         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
5174         for i in range(1):
5175             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
5176             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
5177             ffCell.loadArraysIfNecessary()
5178             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
5179             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
5180             v.isEqual(DataArrayDouble([1000,1001,1002]),1e-12)
5181             #
5182             ffCell=allFMTSLeavesPerCommonSupport1[0][0][1][i]
5183             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
5184             ffCell.loadArraysIfNecessary()
5185             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
5186             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
5187             v.isEqual(DataArrayDouble([3000,3001,3002,3003,3004]),1e-12)
5188             pass
5189         fcscp=allFMTSLeavesPerCommonSupport1[1][1]
5190         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5191         mml2=mml.prepare()
5192         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
5193         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
5194         self.assertTrue(not ncc)# here ncc=False because the coordinates are not in ms neither in children.
5195         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))
5196         self.assertTrue(a1.isEqual(DataArrayByte([5,5,5,3,3,3,3])))
5197         self.assertTrue(a2.isEqual(DataArrayInt([0,4,8,12,15,18,21])))
5198         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])))
5199         self.assertTrue(a4 is None)
5200         self.assertTrue(a5 is None)
5201         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
5202         for i in range(1):
5203             ffCell=allFMTSLeavesPerCommonSupport1[1][0][0][i]
5204             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
5205             ffCell.loadArraysIfNecessary()
5206             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
5207             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
5208             v.isEqual(DataArrayDouble([2000,2001,2002,2003,2004,2005,2006]),1e-12)
5209             pass
5210         pass
5211
5212     @WriteInTmpDir
5213     def test37(self):
5214         """ Introduction of non cartesian meshes management. Here cylindrical."""
5215         fname="ForMEDReader37.med"
5216         meshName="mesh"
5217         description="Cylindrical grid"
5218         comps=["X [cm]","Y [cm]","Z [cm]"]
5219         arrX=DataArrayDouble(3) ; arrX.iota() ; arrX*=0.8 ; arrX.setInfoOnComponent(0,comps[0])
5220         arrY=DataArrayDouble(4) ; arrY.iota() ; arrY*=pi/(len(arrY)-1) ; arrY.setInfoOnComponent(0,comps[1])
5221         arrZ=DataArrayDouble(5) ; arrZ.iota() ; arrZ*=1.6 ; arrZ-=8. ; arrZ.setInfoOnComponent(0,comps[2])
5222         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ) ; m.setName(meshName)
5223         mm=MEDFileCMesh() ; mm.setMesh(m) ; mm.setDescription(description)
5224         mm.setAxisType(AX_CYL) # the test is here !
5225         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m) ; f.setName("Field")
5226         arr=DataArrayDouble(m.getNumberOfCells()) ; arr.iota() ; arr*=0.1 ; f.setArray(arr) ; f.checkConsistencyLight()
5227         ff=MEDFileField1TS() ; ff.setFieldNoProfileSBT(f)
5228         fmts=MEDFileFieldMultiTS() ; fmts.pushBackTimeStep(ff)
5229         #
5230         ms=MEDFileMeshes() ; ms.pushMesh(mm)
5231         fields=MEDFileFields() ; fields.pushField(fmts)
5232         ms.write(fname,2) ; fields.write(fname,0)
5233         #
5234         del mm,fmts,fields,ms
5235         ms=MEDFileMeshes(fname)
5236         fields=MEDFileFields(fname,False)
5237         ms.cartesianizeMe()
5238         #
5239         fields.removeFieldsWithoutAnyTimeStep()
5240         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
5241         allFMTSLeavesToDisplay=[]
5242         for fields in fields_per_mesh:
5243             allFMTSLeavesToDisplay2=[]
5244             for fmts in fields:
5245                 tmp=fmts.splitDiscretizations()
5246                 for itmp in tmp:
5247                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
5248                     pass
5249                 allFMTSLeavesToDisplay2+=tmp
5250                 pass
5251             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
5252             pass
5253         #
5254         self.assertEqual(len(allFMTSLeavesToDisplay),1)
5255         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
5256         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
5257         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
5258         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
5259         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
5260         #
5261         mst=MEDFileMeshStruct.New(ms[0])
5262         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
5263         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5264         mml2=mml.prepare()
5265         self.assertTrue(isinstance(mml2,MEDCurveLinearMeshMultiLev))# <- hehe it is a CurveLinear no more a CMesh !
5266         a,b,c=mml2.buildVTUArrays()
5267         self.assertTrue(c)# the array is thoose in structure
5268         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)
5269         ref_a.setInfoOnComponents(comps)
5270         self.assertTrue(a.isEqual(ref_a,1e-14))
5271         self.assertEqual(b,[3,4,5])
5272         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
5273         for i in range(1):
5274             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
5275             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
5276             ffCell.loadArraysIfNecessary()
5277             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
5278             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
5279             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))
5280             pass
5281         pass
5282
5283     @WriteInTmpDir
5284     def test38(self):
5285         """ Introduction of non cartesian meshes management. Here spherical."""
5286         fname="ForMEDReader38.med"
5287         meshName="mesh"
5288         description="Spherical grid"
5289         comps=["X [cm]","Y [cm]","Z [cm]"]
5290         arrX=DataArrayDouble(3) ; arrX.iota() ; arrX*=0.8 ; arrX.setInfoOnComponent(0,comps[0])
5291         arrY=DataArrayDouble(4) ; arrY.iota() ; arrY*=pi/(len(arrY)-1) ; arrY.setInfoOnComponent(0,comps[1])
5292         arrZ=DataArrayDouble(5) ; arrZ.iota() ; arrZ*=2*pi/(len(arrZ)-1) ; arrZ.setInfoOnComponent(0,comps[2])
5293         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ) ; m.setName(meshName)
5294         mm=MEDFileCMesh() ; mm.setMesh(m) ; mm.setDescription(description)
5295         mm.setAxisType(AX_SPHER) # the test is here !
5296         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m) ; f.setName("Field")
5297         arr=DataArrayDouble(m.getNumberOfCells()) ; arr.iota() ; arr*=0.1 ; f.setArray(arr) ; f.checkConsistencyLight()
5298         ff=MEDFileField1TS() ; ff.setFieldNoProfileSBT(f)
5299         fmts=MEDFileFieldMultiTS() ; fmts.pushBackTimeStep(ff)
5300         #
5301         ms=MEDFileMeshes() ; ms.pushMesh(mm)
5302         fields=MEDFileFields() ; fields.pushField(fmts)
5303         ms.write(fname,2) ; fields.write(fname,0)
5304         #
5305         del mm,fmts,fields,ms
5306         ms=MEDFileMeshes(fname)
5307         fields=MEDFileFields(fname,False)
5308         ms.cartesianizeMe()
5309         #
5310         fields.removeFieldsWithoutAnyTimeStep()
5311         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
5312         allFMTSLeavesToDisplay=[]
5313         for fields in fields_per_mesh:
5314             allFMTSLeavesToDisplay2=[]
5315             for fmts in fields:
5316                 tmp=fmts.splitDiscretizations()
5317                 for itmp in tmp:
5318                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
5319                     pass
5320                 allFMTSLeavesToDisplay2+=tmp
5321                 pass
5322             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
5323             pass
5324         #
5325         self.assertEqual(len(allFMTSLeavesToDisplay),1)
5326         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
5327         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
5328         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
5329         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
5330         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
5331         #
5332         mst=MEDFileMeshStruct.New(ms[0])
5333         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
5334         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5335         mml2=mml.prepare()
5336         self.assertTrue(isinstance(mml2,MEDCurveLinearMeshMultiLev))
5337         a,b,c=mml2.buildVTUArrays()
5338         self.assertTrue(c)# the array is thoose in structure
5339         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)
5340         ref_a.setInfoOnComponents(comps)
5341         self.assertTrue(a.isEqual(ref_a,1e-14))
5342         self.assertEqual(b,[3,4,5])
5343         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
5344         for i in range(1):
5345             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
5346             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
5347             ffCell.loadArraysIfNecessary()
5348             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
5349             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
5350             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))
5351             pass
5352         pass
5353
5354     @WriteInTmpDir
5355     def test39(self):
5356         """Idem test37, test38, test39, test40 except that here it is an unstructured mesh."""
5357         fname="ForMEDReader39.med"
5358         meshName="mesh"
5359         description="Spherical grid"
5360         comps=["X [cm]","Y [cm]","Z [cm]"]
5361         arrX=DataArrayDouble(3) ; arrX.iota() ; arrX*=0.8 ; arrX.setInfoOnComponent(0,comps[0])
5362         arrY=DataArrayDouble(4) ; arrY.iota() ; arrY*=pi/(len(arrY)-1) ; arrY.setInfoOnComponent(0,comps[1])
5363         arrZ=DataArrayDouble(5) ; arrZ.iota() ; arrZ*=2*pi/(len(arrZ)-1) ; arrZ.setInfoOnComponent(0,comps[2])
5364         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ) ; m.setName(meshName) ; m=m.buildUnstructured()
5365         mm=MEDFileUMesh() ; mm[0]=m ; mm.setDescription(description) # the test is here : UMesh !
5366         mm.setAxisType(AX_SPHER) # the test is here !
5367         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m) ; f.setName("Field")
5368         arr=DataArrayDouble(m.getNumberOfCells()) ; arr.iota() ; arr*=0.1 ; f.setArray(arr) ; f.checkConsistencyLight()
5369         ff=MEDFileField1TS() ; ff.setFieldNoProfileSBT(f)
5370         fmts=MEDFileFieldMultiTS() ; fmts.pushBackTimeStep(ff)
5371         #
5372         ms=MEDFileMeshes() ; ms.pushMesh(mm)
5373         fields=MEDFileFields() ; fields.pushField(fmts)
5374         ms.write(fname,2) ; fields.write(fname,0)
5375         #
5376         del mm,fmts,fields,ms
5377         ms=MEDFileMeshes(fname)
5378         fields=MEDFileFields(fname,False)
5379         #
5380         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
5381         fields=MEDFileFields(fname,False)
5382         fields.removeFieldsWithoutAnyTimeStep()
5383         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
5384         allFMTSLeavesToDisplay=[]
5385         for fields in fields_per_mesh:
5386             allFMTSLeavesToDisplay2=[]
5387             for fmts in fields:
5388                 tmp=fmts.splitDiscretizations()
5389                 for itmp in tmp:
5390                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
5391                     pass
5392                 allFMTSLeavesToDisplay2+=tmp
5393                 pass
5394             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
5395             pass
5396         #
5397         self.assertEqual(len(allFMTSLeavesToDisplay),1)
5398         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
5399         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
5400         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
5401         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
5402         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
5403         #
5404         mst=MEDFileMeshStruct.New(ms[0])
5405         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
5406         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5407         mml2=mml.prepare()
5408         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
5409         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
5410         self.assertTrue(ncc)
5411         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)
5412         ref_a.setInfoOnComponents(comps)
5413         self.assertTrue(a0.isEqual(ref_a,1e-14))#<- Test is here
5414         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
5415         for i in range(1):
5416             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
5417             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
5418             ffCell.loadArraysIfNecessary()
5419             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
5420             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
5421             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))
5422         pass
5423
5424     @WriteInTmpDir
5425     def test40(self):
5426         """Idem test37, test38, test39, test40 except that here it is a CL mesh."""
5427         fname="ForMEDReader40.med"
5428         meshName="mesh"
5429         description="Spherical grid"
5430         comps=["X [cm]","Y [cm]","Z [cm]"]
5431         arrX=DataArrayDouble(3) ; arrX.iota() ; arrX*=0.8 ; arrX.setInfoOnComponent(0,comps[0])
5432         arrY=DataArrayDouble(4) ; arrY.iota() ; arrY*=pi/(len(arrY)-1) ; arrY.setInfoOnComponent(0,comps[1])
5433         arrZ=DataArrayDouble(5) ; arrZ.iota() ; arrZ*=2*pi/(len(arrZ)-1) ; arrZ.setInfoOnComponent(0,comps[2])
5434         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ) ; m.setName(meshName) ; m=m.buildCurveLinear()
5435         mm=MEDFileCurveLinearMesh() ; mm.setMesh(m) ; mm.setDescription(description) # the test is here CLMesh!
5436         mm.setAxisType(AX_SPHER) # the test is here !
5437         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m) ; f.setName("Field")
5438         arr=DataArrayDouble(m.getNumberOfCells()) ; arr.iota() ; arr*=0.1 ; f.setArray(arr) ; f.checkConsistencyLight()
5439         ff=MEDFileField1TS() ; ff.setFieldNoProfileSBT(f)
5440         fmts=MEDFileFieldMultiTS() ; fmts.pushBackTimeStep(ff)
5441         #
5442         ms=MEDFileMeshes() ; ms.pushMesh(mm)
5443         fields=MEDFileFields() ; fields.pushField(fmts)
5444         ms.write(fname,2) ; fields.write(fname,0)
5445         #
5446         ms=MEDFileMeshes(fname) ; ms.cartesianizeMe()
5447         fields=MEDFileFields(fname,False)
5448         fields.removeFieldsWithoutAnyTimeStep()
5449         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
5450         allFMTSLeavesToDisplay=[]
5451         for fields in fields_per_mesh:
5452             allFMTSLeavesToDisplay2=[]
5453             for fmts in fields:
5454                 tmp=fmts.splitDiscretizations()
5455                 for itmp in tmp:
5456                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
5457                     pass
5458                 allFMTSLeavesToDisplay2+=tmp
5459                 pass
5460             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
5461             pass
5462         #
5463         self.assertEqual(len(allFMTSLeavesToDisplay),1)
5464         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
5465         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
5466         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
5467         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
5468         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
5469         #
5470         mst=MEDFileMeshStruct.New(ms[0])
5471         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
5472         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5473         mml2=mml.prepare()
5474         self.assertTrue(isinstance(mml2,MEDCurveLinearMeshMultiLev))
5475         a,b,c=mml2.buildVTUArrays()
5476         self.assertTrue(c)
5477         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)
5478         ref_a.setInfoOnComponents(comps)
5479         self.assertTrue(a.isEqual(ref_a,1e-14))#<- Test is here
5480         self.assertEqual(b,[3,4,5])
5481         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
5482         for i in range(1):
5483             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
5484             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
5485             ffCell.loadArraysIfNecessary()
5486             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
5487             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
5488             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))
5489         pass
5490
5491     @WriteInTmpDir
5492     def test41(self):
5493         """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 ! """
5494         fname="ForMEDReader41.med"
5495         meshName="mesh"
5496         nx=5
5497         arr=DataArrayDouble(nx) ; arr.iota()
5498         m=MEDCouplingCMesh() ; m.setCoords(arr,arr) ; m=m.buildUnstructured() ; m.setName(meshName)
5499         renum=DataArrayInt.Aggregate([DataArrayInt.Range(0,m.getNumberOfCells(),2),DataArrayInt.Range(1,m.getNumberOfCells(),2)])
5500         m=m[renum] # important think to renum if not we see nothing. The goal if to have dynamic_cast<DataPartDefinition>!=NULL
5501         mm=MEDFileUMesh() ; mm[0]=m
5502         mm.write(fname,2)
5503         f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m) ; f0.setName("aaa")
5504         arr0=DataArrayDouble(nx*nx) ; arr0.iota() ; f0.setArray(arr0)
5505         ff0=MEDFileField1TS() ; ff0.setFieldNoProfileSBT(f0)
5506         f1=MEDCouplingFieldDouble(ON_NODES) ; f1.setMesh(m) ; f1.setName("bbb")
5507         arr1=DataArrayDouble(nx*nx) ; arr1.iota() ; arr1+=100 ; f1.setArray(arr1)
5508         ff1=MEDFileField1TS() ; ff1.setFieldNoProfileSBT(f1)
5509         ff0.write(fname,0) ; ff1.write(fname,0)
5510         #
5511         a=8 ; b=16
5512         ms=MEDFileMeshes()
5513         mm=MEDFileUMesh.LoadPartOf(fname,meshName,[NORM_QUAD4],[a,b,1],-1,-1)
5514         ms.pushMesh(mm)
5515         ms[0].zipCoords()
5516         ms.cartesianizeMe()
5517         fields=MEDFileFields.LoadPartOf(fname,False,ms);
5518         fields.removeFieldsWithoutAnyTimeStep()
5519         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
5520         allFMTSLeavesToDisplay=[]
5521         for fields in fields_per_mesh:
5522             allFMTSLeavesToDisplay2=[]
5523             for fmts in fields:
5524                 tmp=fmts.splitDiscretizations()
5525                 for itmp in tmp:
5526                     if itmp.presenceOfMultiDiscPerGeoType():
5527                         tmp2=itmp.splitMultiDiscrPerGeoTypes()
5528                         for iii,itmp2 in enumerate(tmp2):
5529                             name="%s_%i"%(itmp2.getName(),iii)
5530                             itmp2.setName(name)
5531                             allFMTSLeavesToDisplay2.append(itmp2)
5532                             pass
5533                         pass
5534                     else:
5535                         allFMTSLeavesToDisplay2.append(itmp)
5536                         pass
5537                     pass
5538                 allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
5539                 pass
5540         # GO for reading in MEDReader, by not loading all. Mesh is fully loaded but not fields values
5541         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
5542         allFMTSLeavesPerCommonSupport=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesPerTimeSeries[0],ms[ms.getMeshesNames()[0]])
5543         mst=MEDFileMeshStruct.New(ms[0])
5544         fcscp=allFMTSLeavesPerCommonSupport[0][1]
5545         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5546         mml2=mml.prepare()
5547         #
5548         f2=allFMTSLeavesPerCommonSupport[0][0][0][0]
5549         fsst=MEDFileField1TSStructItem.BuildItemFrom(f2,mst)
5550         f2.loadArraysIfNecessary()
5551         v0=mml.buildDataArray(fsst,fields,f2.getUndergroundDataArray())
5552         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))
5553         #
5554         f2=allFMTSLeavesPerCommonSupport[0][0][1][0]
5555         fsst=MEDFileField1TSStructItem.BuildItemFrom(f2,mst)
5556         f2.loadArraysIfNecessary()
5557         v1=mml.buildDataArray(fsst,fields,f2.getUndergroundDataArray())
5558         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))
5559         pass
5560
5561     @WriteInTmpDir
5562     def test42(self):
5563         """ EDF14869 - SEG4 """
5564         fname="ForMEDReader42.med"
5565         meshName="mesh"
5566         #
5567         a0exp=DataArrayDouble([0.,1.,0.3,0.7])
5568         m=MEDCouplingUMesh("mesh",1)
5569         m.setCoords(a0exp)
5570         m.allocateCells()
5571         m.insertNextCell(NORM_SEG4,[0,1,2,3])
5572         mm=MEDFileUMesh() ; mm[0]=m
5573         #
5574         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m) ; f.setName("Field")
5575         arr=DataArrayDouble(m.getNumberOfCells()) ; arr.iota() ; arr*=0.1 ; f.setArray(arr) ; f.checkConsistencyLight()
5576         ff=MEDFileField1TS() ; ff.setFieldNoProfileSBT(f)
5577         fmts=MEDFileFieldMultiTS() ; fmts.pushBackTimeStep(ff)
5578         #
5579         ms=MEDFileMeshes() ; ms.pushMesh(mm)
5580         fields=MEDFileFields() ; fields.pushField(fmts)
5581         ms.write(fname,2) ; fields.write(fname,0)
5582         #
5583         ms=MEDFileMeshes(fname)
5584         fields=MEDFileFields(fname,False)
5585         fields.removeFieldsWithoutAnyTimeStep()
5586         fields_per_mesh=[fields.partOfThisLyingOnSpecifiedMeshName(meshName) for meshName in ms.getMeshesNames()]
5587         allFMTSLeavesToDisplay=[]
5588         for fields in fields_per_mesh:
5589             allFMTSLeavesToDisplay2=[]
5590             for fmts in fields:
5591                 tmp=fmts.splitDiscretizations()
5592                 for itmp in tmp:
5593                     self.assertTrue(not itmp.presenceOfMultiDiscPerGeoType())
5594                     pass
5595                 allFMTSLeavesToDisplay2+=tmp
5596                 pass
5597             allFMTSLeavesToDisplay.append(allFMTSLeavesToDisplay2)
5598             pass
5599         #
5600         self.assertEqual(len(allFMTSLeavesToDisplay),1)
5601         self.assertEqual(len(allFMTSLeavesToDisplay[0]),1)
5602         allFMTSLeavesPerTimeSeries=MEDFileAnyTypeFieldMultiTS.SplitIntoCommonTimeSeries(sum(allFMTSLeavesToDisplay,[]))
5603         self.assertEqual(len(allFMTSLeavesPerTimeSeries),1)
5604         allFMTSLeavesPerCommonSupport1=MEDFileAnyTypeFieldMultiTS.SplitPerCommonSupport(allFMTSLeavesToDisplay[0],ms[ms.getMeshesNames()[0]])
5605         self.assertEqual(len(allFMTSLeavesPerCommonSupport1),1)
5606         #
5607         mst=MEDFileMeshStruct.New(ms[0])
5608         fcscp=allFMTSLeavesPerCommonSupport1[0][1]
5609         mml=fcscp.buildFromScratchDataSetSupport(0,fields)
5610         mml2=mml.prepare()
5611         self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
5612         ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
5613         self.assertTrue(not ncc)
5614         self.assertTrue(a0.isEqual(a0exp.changeNbOfComponents(3,0.),1e-12))
5615         self.assertTrue(a1.isEqual(DataArrayByte([35])))# VTK_CUBIC_LINE
5616         self.assertTrue(a2.isEqual(DataArrayInt([0])))
5617         self.assertTrue(a3.isEqual(DataArrayInt([4,0,1,2,3])))
5618         self.assertTrue(a4 is None)
5619         self.assertTrue(a5 is None)
5620         self.assertTrue(mml2.retrieveGlobalNodeIdsIfAny() is None)
5621         for i in range(1):
5622             ffCell=allFMTSLeavesPerCommonSupport1[0][0][0][i]
5623             fsst=MEDFileField1TSStructItem.BuildItemFrom(ffCell,mst)
5624             ffCell.loadArraysIfNecessary()
5625             v=mml2.buildDataArray(fsst,fields,ffCell.getUndergroundDataArray())
5626             self.assertEqual(v.getHiddenCppPointer(),ffCell.getUndergroundDataArray().getHiddenCppPointer())
5627             self.assertTrue(v.isEqual(DataArrayDouble([0.0]),1e-14))
5628         pass
5629
5630     @WriteInTmpDir
5631     def test43(self):
5632         """
5633         EDF23724 : point to error during 64bit convertion into medcoupling a DataArrayMedInt class was created.
5634                    This class is not dynamic_castable to DataArrayInt32 nor DataArrayInt64. It lead previously to strange behaviour
5635         """
5636         fname = "tessss.med"
5637         arr=DataArrayDouble(10) ; arr.iota()
5638         m = MEDCouplingCMesh() ; m.setCoords(arr)
5639         m = m.buildUnstructured()
5640         m.setName("mesh")
5641         mm = MEDFileUMesh() ; mm[0] = m
5642         mm.setGlobalNumFieldAtLevel(1,DataArrayInt([0,4,5,6,10,12,16,17,19,20]))
5643         mm.write(fname,2)
5644         mm_reload = MEDFileMesh.New(fname)
5645         # DataArrayMedInt class no more exists. Check that.
5646         self.assertNotEqual(mm_reload.getGlobalNumFieldAtLevel(1).getClassName() , "DataArrayMedInt")
5647         pass
5648
5649     pass
5650
5651 if __name__ == "__main__":
5652   unittest.main()