src/MEDMEM_SWIG/med_test1.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2013  CEA/DEN, EDF R&D, OPEN CASCADE
   3 #
   4 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   5 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   6 #
   7 # This library is free software; you can redistribute it and/or
   8 # modify it under the terms of the GNU Lesser General Public
   9 # License as published by the Free Software Foundation; either
  10 # version 2.1 of the License.
  11 #
  12 # This library is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 # Lesser General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU Lesser General Public
  18 # License along with this library; if not, write to the Free Software
  19 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20 #
  21 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  22 #
  23
  24 ###################################################################################
  25 # This Python script is parsing a MED file using MED Memory from SALOME platform:
  26 # It analyses all meshes in the MED file (coordinates, connectivity of d-cells as
  27 # well as (d-1)-cells, families). It analyses fields stored in the MED file (d is
  28 # the space dimension). You can assume that it is a kind of MED file parser.
  29 ###################################################################################
  30 #
  31 from libMEDMEM_Swig import *
  32 from random import *
  33 import os
  34 #
  35 #befor running this script, please be sure about the path the file fileName
  36 #
  37 filePath=os.environ["MED_ROOT_DIR"]
  38 filePath=os.path.join(filePath, "share", "salome", "resources", "med")
  39
  40 medFile = os.path.join(filePath, "carre_en_quad4_seg2.med")
  41 #medFile = os.path.join(filePath, "cube_hexa8_quad4.med")
  42
  43 def print_ord(i):
  44     if i == 0:
  45         return 'first'
  46     elif i == 1:
  47         return 'second'
  48     elif i == 2:
  49         return 'third'
  50     else:
  51         return `i`+'th'
  52
  53 md = MEDFILEBROWSER(medFile)
  54
  55 nbMeshes = md.getNumberOfMeshes()
  56
  57 nbFields = md.getNumberOfFields()
  58
  59 print "The med file", medFile, "contains", nbMeshes, "mesh(es) and", nbFields, "field(s)"
  60
  61 if (nbMeshes>0):
  62     print "Mesh(es) Name(s) is(are) "
  63
  64     for i in range(nbMeshes):
  65         mesh_name = md.getMeshName(i)
  66         print "   - ",mesh_name
  67
  68 if (nbFields>0):
  69     print "Field(s) Name(s) is(are) "
  70
  71     for i in range(nbFields):
  72         field_name = md.getFieldName(i)
  73         print "   - ",field_name
  74
  75 print ""
  76
  77 if (nbMeshes>0):
  78     print "Mesh(es) Analysis "
  79     for i in range(nbMeshes):
  80         mesh_name = md.getMeshName(i)
  81         mesh = MESH(MED_DRIVER,md.getFileName(),mesh_name)
  82         spaceDim = mesh.getSpaceDimension()
  83         meshDim = mesh.getMeshDimension()
  84         print "The",print_ord(i), "mesh, '",mesh_name,"', is a",spaceDim,"D mesh on a",meshDim,"D geometry"
  85         nbNodes = mesh.getNumberOfNodes()
  86         print "The mesh has",nbNodes,"Nodes"
  87         coordSyst = mesh.getCoordinatesSystem()
  88         print "The coordinates system is",coordSyst
  89         print "The Coordinates :"
  90         coordNames = []
  91         coordUnits = []
  92         for isd in range(spaceDim):
  93             coordNames.append(mesh.getCoordinateName(isd))
  94             coordUnits.append(mesh.getCoordinateUnit(isd))
  95
  96         print "names:", coordNames
  97         print "units", coordUnits
  98         print "values:"
  99         coordinates = mesh.getCoordinates(MED_FULL_INTERLACE)
 100         for k in range(nbNodes):
 101             kp1 = k+1
 102             coords = []
 103             for isd in range(spaceDim):
 104                 isdp1 = isd+1
 105                 coords.append(mesh.getCoordinate(kp1,isdp1))
 106
 107             print coords," ---- ", coordinates[k*spaceDim:((k+1)*spaceDim)]
 108
 109         print ""
 110         print "Show the Nodal Connectivity of Cells:"
 111         nbTypesCell = mesh.getNumberOfTypes(MED_CELL)
 112         print ""
 113         if (nbTypesCell>0):
 114             print "The Mesh has",nbTypesCell,"Type(s) of Cell"
 115             types = mesh.getTypes(MED_CELL)
 116             for k in range(nbTypesCell):
 117                 type = types[k]
 118                 nbElemType = mesh.getNumberOfElements(MED_CELL,type)
 119                 print "For the type:",type,"there is(are)",nbElemType,"elemnt(s)"
 120                 connectivity = mesh.getConnectivity(MED_NODAL,MED_CELL,type)
 121                 nbNodesPerCell = type%100
 122                 for j in range(nbElemType):
 123                     print "Element",(j+1)," ",connectivity[j*nbNodesPerCell:(j+1)*nbNodesPerCell]
 124
 125         print ""
 126         print "Show the Nodal Connectivity of constituents (Faces in 3D or Edges in 2D):"
 127
 128         if (spaceDim == 3) : constituent = MED_FACE
 129         elif (spaceDim == 2) : constituent = MED_EDGE
 130         else : print "proble with the sapce dimension : ",spaceDim
 131
 132         nbTypesConst = mesh.getNumberOfTypes(constituent)
 133         print ""
 134         if (nbTypesConst>0):
 135             print "The Mesh has",nbTypesConst,"Type(s) of Constituent"
 136             types = mesh.getTypes(constituent)
 137             for k in range(nbTypesConst):
 138                 type = types[k]
 139                 nbElemType = mesh.getNumberOfElements(constituent,type)
 140                 print "For the type:",type,"there is(are)",nbElemType,"elemnt(s)"
 141                 connectivity = mesh.getConnectivity(MED_NODAL,constituent,type)
 142                 nbNodesPerCell = type%100
 143                 for j in range(nbElemType):
 144                     print "Element",(j+1)," ",connectivity[j*nbNodesPerCell:(j+1)*nbNodesPerCell]
 145
 146         print ""
 147         print "Show the Reverse Nodal Connectivity:"
 148         ReverseConnectivity = mesh.getReverseConnectivity(MED_NODAL)
 149         ReverseConnectivityIndex = mesh.getReverseConnectivityIndex(MED_NODAL)
 150         print ""
 151         for j in range(nbNodes):
 152             begin = ReverseConnectivityIndex[j]-1
 153             end = ReverseConnectivityIndex[j+1]-1
 154             print "Node",(j+1),"-->",ReverseConnectivity[begin:end]
 155
 156         print ""
 157         print "Show the Descending Connectivity:"
 158         mesh.calculateConnectivity(MED_DESCENDING,MED_CELL)
 159         nbElemts = mesh.getNumberOfElements(MED_CELL,MED_ALL_ELEMENTS)
 160         Connectivity = mesh.getConnectivity(MED_DESCENDING,MED_CELL,MED_ALL_ELEMENTS)
 161         ConnectivityIndex = mesh.getConnectivityIndex(MED_DESCENDING,MED_CELL)
 162         print ""
 163         for j in range(nbElemts):
 164             begin = ConnectivityIndex[j]-1
 165             end = ConnectivityIndex[j+1]-1
 166             print "Element",(j+1),"-->",Connectivity[begin:end]
 167
 168         print ""
 169         for entity in [MED_NODE,MED_CELL,MED_FACE,MED_EDGE]:
 170             nbFam = mesh.getNumberOfFamilies(entity)
 171             if (entity == MED_NODE) & (nbFam > 0):
 172                 print "This mesh has",nbFam,"Node Family(ies)"
 173             elif (entity == MED_CELL) & (nbFam > 0):
 174                 print "This mesh has",nbFam,"Cell Family(ies)"
 175             elif (entity == MED_FACE) & (nbFam > 0):
 176                 print "This mesh has",nbFam,"Face Family(ies)"
 177             elif (entity == MED_EDGE) & (nbFam > 0):
 178                 print "This mesh has",nbFam,"Edge Family(ies)"
 179
 180             if nbFam > 0:
 181                 for j in range(nbFam):
 182                     print ""
 183                     family = mesh.getFamily(entity,j+1)
 184                     familyName = family.getName()
 185                     familyDescription = family.getDescription()
 186                     familyEntity = family.getEntity()
 187                     familyBool = family.isOnAllElements()
 188                     print "  -Name:",familyName
 189                     print "  -Description:",familyDescription
 190                     print "  -Entity:",familyEntity
 191                     familyIdentifier = family.getIdentifier()
 192                     nbOfAtt = family.getNumberOfAttributes()
 193                     print "  -Identifier:",familyIdentifier
 194                     print "  -Number Of Attributes:",nbOfAtt
 195                     attributesids = family.getAttributesIdentifiers()
 196                     attributesvals = family.getAttributesValues()
 197                     for k in range(nbOfAtt):
 198                         print "    * Attributes:",attributesids[k],":",attributesvals[k],",",family.getAttributeDescription(k+1)
 199                     nbOfGrp = family.getNumberOfGroups()
 200                     print "  -Number Of Groups:",nbOfGrp
 201                     for k in range(nbOfGrp):
 202                         print "    * Group:",family.getGroupName(k+1)
 203                     print "  -Entities list:"
 204                     if (familyBool):
 205                         print "  -Is on all entities"
 206                     else:
 207                         nbOfTypes = family.getNumberOfTypes()
 208                         types = family.getTypes()
 209                         print "  -Number Of Types:",nbOfTypes
 210                         for k in range(nbOfTypes):
 211                             type = types[k]
 212                             nbOfElmtsOfType = family.getNumberOfElements(type)
 213                             number = family.getNumber(type)
 214                             print "    * Type",type
 215                             print "    * Number",number[0:nbOfElmtsOfType]
 216                         print ""
 217                         numberFamily = family.getNumber(MED_ALL_ELEMENTS)
 218                         print "    * Getting an Integer Field on the family ",familyName
 219                         fieldFamilyIntg = FIELDINT(family,spaceDim)
 220                         fieldFamilyIntg.setIterationNumber(0)
 221                         fieldFamilyIntg.setOrderNumber(0)
 222                         fieldFamilyIntg.setTime(0.0)
 223                         for kcomp in range(spaceDim):
 224                             kcomp1 = kcomp+1
 225                             if kcomp == 0:
 226                                 fieldCompName = "comp1"
 227                                 fieldCompDesc = "desc1"
 228                                 fieldCompUnit = "unit1"
 229                             if kcomp == 1:
 230                                 fieldCompName = "comp2"
 231                                 fieldCompDesc = "desc2"
 232                                 fieldCompUnit = "unit2"
 233                             if kcomp == 2:
 234                                 fieldCompName = "comp2"
 235                                 fieldCompDesc = "desc2"
 236                                 fieldCompUnit = "unit2"
 237
 238                             fieldFamilyIntg.setComponentName(kcomp1,fieldCompName)
 239                             fieldFamilyIntg.setComponentDescription(kcomp1,fieldCompDesc)
 240                             fieldFamilyIntg.setMEDComponentUnit(kcomp1,fieldCompUnit)
 241                         fieldFamilyName = "Integer Field on "+familyName
 242                         fieldFamilyIntg.setName(fieldFamilyName)
 243                         field_name = fieldFamilyIntg.getName()
 244                         type_field = fieldFamilyIntg.getValueType()
 245                         nbOfComp = fieldFamilyIntg.getNumberOfComponents()
 246                         print "      The field",field_name,"is with the type",type_field
 247                         print "      It has",nbOfComp,"Component(s)"
 248                         for kcomp in range(nbOfComp):
 249                             kcomp1 = kcomp+1
 250                             compName = fieldFamilyIntg.getComponentName(kcomp1)
 251                             compDesc = fieldFamilyIntg.getComponentDescription(kcomp1)
 252                             compUnit = fieldFamilyIntg.getMEDComponentUnit(kcomp1)
 253                             print "      * Component:",kcomp1
 254                             print "          Name:",compName
 255                             print "          Description:",compDesc
 256                             print "          Unit:",compUnit
 257
 258                         nbOf = fieldFamilyIntg.getSupport().getNumberOfElements(MED_ALL_ELEMENTS)
 259                         print "      Values:",nbOf
 260                         print "      Randomly set and get to check ..!"
 261                         for k in range(nbOf):
 262                             valueI = []
 263                             for kcomp in range(nbOfComp):
 264                                 valueI.append(randint(0,100))
 265
 266 #                            print "     Set Entry *",(k+1)," ",valueI[:nbOfComp]
 267                             valInd = numberFamily[k]
 268                             fieldFamilyIntg.setRow(valInd,valueI)
 269                             valueIverif = fieldFamilyIntg.getRow(valInd)
 270                             print "     Set/Get Entry *",(k+1)," ",valueI[:nbOfComp],"  /  ",valueIverif[:nbOfComp]
 271                         print "    * Getting a Real Field"
 272                         fieldFamilyDble = FIELDDOUBLE(family,spaceDim)
 273                         fieldFamilyDble.setIterationNumber(0)
 274                         fieldFamilyDble.setOrderNumber(0)
 275                         fieldFamilyDble.setTime(0.0)
 276                         for kcomp in range(spaceDim):
 277                             kcomp1 = kcomp+1
 278                             if kcomp == 0:
 279                                 fieldCompName = "comp1"
 280                                 fieldCompDesc = "desc1"
 281                                 fieldCompUnit = "unit1"
 282                             if kcomp == 1:
 283                                 fieldCompName = "comp2"
 284                                 fieldCompDesc = "desc2"
 285                                 fieldCompUnit = "unit2"
 286                             if kcomp == 2:
 287                                 fieldCompName = "comp2"
 288                                 fieldCompDesc = "desc2"
 289                                 fieldCompUnit = "unit2"
 290
 291                             fieldFamilyDble.setComponentName(kcomp1,fieldCompName)
 292                             fieldFamilyDble.setComponentDescription(kcomp1,fieldCompDesc)
 293                             fieldFamilyDble.setMEDComponentUnit(kcomp1,fieldCompUnit)
 294
 295                         fieldFamilyName = "Real Field on "+familyName
 296                         fieldFamilyDble.setName(fieldFamilyName)
 297                         field_name = fieldFamilyDble.getName()
 298                         type_field = fieldFamilyDble.getValueType()
 299                         nbOfComp = fieldFamilyDble.getNumberOfComponents()
 300                         print "      The field",field_name,"is with the type",type_field
 301                         print "      It has",nbOfComp,"Component(s)"
 302                         for kcomp in range(nbOfComp):
 303                             kcomp1 = kcomp+1
 304                             compName = fieldFamilyDble.getComponentName(kcomp1)
 305                             compDesc = fieldFamilyDble.getComponentDescription(kcomp1)
 306                             compUnit = fieldFamilyDble.getMEDComponentUnit(kcomp1)
 307                             print "      * Component:",kcomp1
 308                             print "          Name:",compName
 309                             print "          Description:",compDesc
 310                             print "          Unit:",compUnit
 311
 312                         nbOf = fieldFamilyDble.getSupport().getNumberOfElements(MED_ALL_ELEMENTS)
 313                         print "      Values:",nbOf
 314                         print "      Randomly set and get to check ..!"
 315                         for k in range(nbOf):
 316                             valueI = []
 317                             for kcomp in range(nbOfComp):
 318                                 valueI.append(random())
 319
 320 #                            print "     Set Entry *",(k+1)," ",valueI[:nbOfComp]
 321                             valInd = numberFamily[k]
 322                             fieldFamilyDble.setRow(valInd,valueI)
 323                             valueIverif = fieldFamilyDble.getRow(valInd)
 324                             print "     Set/Get Entry *",(k+1)," ",valueI[:nbOfComp],"  /  ",valueIverif[:nbOfComp]
 325                 print ""
 326         print ""
 327         for entity in [MED_NODE,MED_CELL,MED_FACE,MED_EDGE]:
 328             nbGrp = mesh.getNumberOfGroups(entity)
 329             if (entity == MED_NODE) & (nbGrp > 0):
 330                 print "This mesh has",nbGrp,"Node Group(s)"
 331             elif (entity == MED_CELL) & (nbGrp > 0):
 332                 print "This mesh has",nbGrp,"Cell Group(s)"
 333             elif (entity == MED_FACE) & (nbGrp > 0):
 334                 print "This mesh has",nbGrp,"Face Group(s)"
 335             elif (entity == MED_EDGE) & (nbGrp > 0):
 336                 print "This mesh has",nbGrp,"Edge Group(s)"
 337
 338             if nbGrp > 0:
 339                 for j in range(nbGrp):
 340                     print ""
 341                     group = mesh.getGroup(entity,j+1)
 342                     groupName = group.getName()
 343                     groupDescription = group.getDescription()
 344                     groupEntity = group.getEntity()
 345                     groupBool = group.isOnAllElements()
 346                     print "  -Name:",groupName
 347                     print "  -Description:",groupDescription
 348                     print "  -Entity:",groupEntity
 349                     nbOfFam = group.getNumberOfFamilies()
 350                     print "  -Number Of Families:",nbOfFam
 351                     for k in range(nbOfFam):
 352                         print "    * Family:",group.getFamily(k+1).getName()
 353                     print "  -Entities list:"
 354                     if (groupBool):
 355                         print "  -Is on all entities"
 356                     else:
 357                         nbOfTypes = group.getNumberOfTypes()
 358                         types = group.getTypes()
 359                         print "  -Number Of Types:",nbOfTypes
 360                         for k in range(nbOfTypes):
 361                             type = types[k]
 362                             nbOfElmtsOfType = group.getNumberOfElements(type)
 363                             number = group.getNumber(type)
 364                             print "    * Type",type
 365                             print "    * Number",number[0:nbOfElmtsOfType]
 366                         print ""
 367                 print ""
 368
 369         print "Building of the support on all Cells of the mesh."
 370         supportCell = mesh.getSupportOnAll( MED_CELL )
 371         print ""
 372         barycenter = mesh.getBarycenter(supportCell)
 373         print "Getting barycenter of all Cells of the mesh"
 374         for j in range(nbElemts):
 375             barycenterCell = barycenter.getRow(j+1)
 376             print "    * ",barycenterCell[:spaceDim]
 377         print ""
 378         if spaceDim == 3 :
 379             print "Getting volume of all Cells of the mesh:"
 380             volume = mesh.getVolume(supportCell)
 381             voltot = 0.
 382             for j in range(nbElemts):
 383                 volumeCell = volume.getValueIJ(j+1,1)
 384                 print "    * ",volumeCell
 385                 voltot = voltot + volumeCell
 386             print "Volume of the mesh:",voltot
 387             print ""
 388             print "Building of the support on all Faces of the mesh."
 389             supportFace = SUPPORT(mesh,"Support on all faces of the mesh",MED_FACE)
 390             nbFace = mesh.getNumberOfElements(MED_FACE,MED_ALL_ELEMENTS)
 391             print ""
 392             print "Getting normal of each face of this support",nbFace
 393             nbTypeFace = mesh.getNumberOfTypes(MED_FACE)
 394             TypeFace = mesh.getTypes(MED_FACE)
 395             print "nbTypeFace:",nbTypeFace,"----",TypeFace[:nbTypeFace]
 396             normal = mesh.getNormal(supportFace)
 397             area = mesh.getArea(supportFace)
 398             for j in range(nbFace):
 399                 normalFace = normal.getRow(j+1)
 400                 areaFace = area.getRow(j+1)
 401                 value1 = normalFace[0]
 402                 value2 = normalFace[1]
 403                 value3 = normalFace[2]
 404                 norm = (value1*value1 + value2*value2 + value3*value3)**(0.5)
 405                 print "    * ",normalFace[:spaceDim],"norm:",norm," --> area ",areaFace[0]
 406         elif spaceDim == 2:
 407             print "Getting area on all Cells of the mesh:"
 408             area = mesh.getArea(supportCell)
 409             areatot = 0.
 410             for j in range(nbElemts):
 411                 areaCell = area.getValueIJ(j+1,1)
 412                 print "    * ",areaCell
 413                 areatot = areatot + areaCell
 414             print "Area of the mesh:",areatot
 415             print ""
 416             print "Building of the support on all Edges of the mesh."
 417             supportEdge = mesh.getSupportOnAll(MED_EDGE)
 418             nbEdge = mesh.getNumberOfElements(MED_EDGE,MED_ALL_ELEMENTS)
 419             print ""
 420             print "Getting normal of each edge of this support",nbEdge
 421             nbTypeEdge = mesh.getNumberOfTypes(MED_EDGE)
 422             TypeEdge = mesh.getTypes(MED_EDGE)
 423             print "nbTypeEdge:",nbTypeEdge,"----",TypeEdge[:nbTypeEdge]
 424             normal = mesh.getNormal(supportEdge)
 425             length = mesh.getLength(supportEdge)
 426             for j in range(nbEdge):
 427                 normalEdge = normal.getRow(j+1)
 428                 lengthEdge = length.getRow(j+1)
 429                 value1 = normalEdge[0]
 430                 value2 = normalEdge[1]
 431                 norm = (value1*value1 + value2*value2)**(0.5)
 432                 print "    * ",normalEdge[:spaceDim],"norm:",norm," --> length ",lengthEdge[0]
 433         print ""
 434         print "Building support on Elements of the boundary"
 435         if spaceDim == 3 :
 436             suppBound = mesh.getBoundaryElements(MED_FACE)
 437             nbElmBound = suppBound.getNumberOfElements(MED_ALL_ELEMENTS)
 438             print "Getting normal field on the boundary",nbElmBound
 439             normalBound = mesh.getNormal(suppBound)
 440             if suppBound.isOnAllElements():
 441                 numberSuppBound = range(1,nbElmBound+1)
 442             else:
 443                 numberSuppBound = suppBound.getNumber(MED_ALL_ELEMENTS)
 444             for j in range(nbElmBound):
 445                 valInd = numberSuppBound[j]
 446                 normalBoundJ = normalBound.getRow(valInd)
 447                 value1 = normalBoundJ[0]
 448                 value2 = normalBoundJ[1]
 449                 value3 = normalBoundJ[2]
 450                 norm = (value1*value1 + value2*value2 + value3*value3)**(0.5)
 451                 print "    * ",normalBoundJ[:spaceDim],"norm:",norm
 452         elif spaceDim == 2:
 453             suppBound = mesh.getBoundaryElements(MED_EDGE)
 454             nbElmBound = suppBound.getNumberOfElements(MED_ALL_ELEMENTS)
 455             print "Getting normal field on the boundary",nbElmBound
 456             normalBound = mesh.getNormal(suppBound)
 457             if suppBound.isOnAllElements():
 458                 numberSuppBound = range(1,nbElmBound+1)
 459             else:
 460                 numberSuppBound = suppBound.getNumber(MED_ALL_ELEMENTS)
 461             for j in range(nbElmBound):
 462                 valInd = numberSuppBound[j]
 463                 normalBoundJ = normalBound.getRow(valInd)
 464                 value1 = normalBoundJ[0]
 465                 value2 = normalBoundJ[1]
 466                 norm = (value1*value1 + value2*value2)**(0.5)
 467                 print "    * ",normalBoundJ[:spaceDim],"norm:",norm
 468         print ""
 469 if (nbFields>0):
 470     print "Field(s) Analysis "
 471     for i in range(nbFields):
 472         field_name = md.getFieldName(i)
 473         dtits = md.getFieldIteration(field_name)
 474         nbOfIt = len(dtits)
 475         print "The",print_ord(i),"field is",field_name,"with",nbOfIt,"iteration(s)"
 476         for dtitfield in dtits:
 477             dt = dtitfield.getdt()
 478             it = dtitfield.getit()
 479             type = md.getFieldType(field_name)
 480             print "     * Iteration:",dt,"Order number:",it,"Type:",type
 481             if type == MED_INT32:
 482                 fieldint = FIELDINT(MED_DRIVER,md.getFileName(),field_name,dt,it,mesh)
 483                 name = fieldint.getName()
 484                 desc = fieldint.getDescription()
 485                 nbOfComp = fieldint.getNumberOfComponents()
 486                 print "     Field",name," : ",desc
 487                 print "     Number Of Components:",nbOfComp
 488                 iterationNb = fieldint.getIterationNumber()
 489                 orderNb = fieldint.getOrderNumber()
 490                 time = fieldint.getTime()
 491                 print "     Iteration Number",iterationNb
 492                 print "     Order Number",orderNb
 493                 print "     Time",time
 494                 for k in range(nbOfComp):
 495                     kp1 = k+1
 496                     compName = fieldint.getComponentName(kp1)
 497                     compDesc = fieldint.getComponentDescription(kp1)
 498                     compUnit = fieldint.getMEDComponentUnit(kp1)
 499                     print "      * Component:",kp1
 500                     print "          Name:",compName
 501                     print "          Description:",compDesc
 502                     print "          Unit:",compUnit
 503
 504                 support = fieldint.getSupport()
 505                 nbOf = support.getNumberOfElements(MED_ALL_ELEMENTS)
 506                 print "     Values:",nbOf
 507                 for k in range(nbOf):
 508                     valueI = fieldint.getRow(k+1)
 509                     print "     *",valueI[:nbOfComp]
 510             elif type == MED_REEL64:
 511                 fielddouble = FIELDDOUBLE(MED_DRIVER,md.getFileName(),field_name,dt,it,mesh)
 512                 name = fielddouble.getName()
 513                 desc = fielddouble.getDescription()
 514                 nbOfComp = fielddouble.getNumberOfComponents()
 515                 print "     Field",name," : ",desc
 516                 print "     Number Of Components:",nbOfComp
 517                 iterationNb = fielddouble.getIterationNumber()
 518                 orderNb = fielddouble.getOrderNumber()
 519                 time = fielddouble.getTime()
 520                 print "     Iteration Number",iterationNb
 521                 print "     Order Number",orderNb
 522                 print "     Time",time
 523                 for k in range(nbOfComp):
 524                     kp1 = k+1
 525                     compName = fielddouble.getComponentName(kp1)
 526                     compDesc = fielddouble.getComponentDescription(kp1)
 527                     compUnit = fielddouble.getMEDComponentUnit(kp1)
 528                     print "      * Component:",kp1
 529                     print "          Name:",compName
 530                     print "          Description:",compDesc
 531                     print "          Unit:",compUnit
 532
 533                 support = fielddouble.getSupport()
 534                 nbOf = support.getNumberOfElements(MED_ALL_ELEMENTS)
 535                 print "     Values:",nbOf
 536                 for k in range(nbOf):
 537                     valueI = fielddouble.getRow(k+1)
 538                     print "     *",valueI[:nbOfComp]
 539             else:
 540                 print "  !!!! Bad type of Field !!!!"
 541
 542 print "END of the Pyhton script ..... Ctrl D to exit"