src/MEDLoader/Swig/MEDLoaderTest4.py

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