src/MEDMEM_SWIG/testMedMemGeneral.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 testing all functionalities of the Med Memory through its
  26 # Python API; for this purpose a battery of med file as well as gibi files are
  27 # scanned using the parser written in the Python script med_test1.py with some
  28 # addings to test other functionality written in othe Python scripts in the bin
  29 # directory of the installation of MED
  30 ###################################################################################
  31 #
  32 from libMEDMEM_Swig import *
  33 from random import *
  34
  35 import sys,os,string
  36
  37 filesPath = os.environ["MED_ROOT_DIR"]
  38 filesPath = os.path.join(filesPath, "share", "salome", "resources", "med")
  39
  40 tmpDir = os.getenv("TEMP")
  41 if tmpDir == None:
  42   tmpDir = "/tmp"
  43
  44 tmpMask = os.path.join(tmpDir, "*_test.*")
  45 os.system("rm -rf " + tmpMask)
  46
  47 fileNames = []
  48 meshNames = []
  49
  50 def print_ord(i):
  51     if i == 0:
  52         return 'first'
  53     elif i == 1:
  54         return 'second'
  55     elif i == 2:
  56         return 'third'
  57     else:
  58         return `i`+'th'
  59
  60 def add_one(i):
  61     return i+1
  62
  63 ###################################################################################
  64 #
  65 # Here is the part you should change to add another file to the test files battery
  66 #
  67 ###################################################################################
  68 #
  69 # med file list
  70 #
  71 # from CODE_ASTER
  72 #
  73
  74 ##fileNames.append("maill.0.med")
  75 ##meshNames.append("MAILTRQU")
  76
  77 ##fileNames.append("zzzz121b.med")
  78 ##meshNames.append("MUN")
  79
  80 #
  81 # from the SMESH Salome Module
  82 #
  83
  84 fileNames.append("mesh.med")
  85 meshNames.append("Mesh 1")
  86
  87 #
  88 # from other source including LGLS ones
  89 #
  90
  91 fileNames.append("maillage_UniSegFam.med")
  92 meshNames.append("maillage_CHEMVAL_100elts")
  93
  94 fileNames.append("carre_en_quad4.med")
  95 meshNames.append("carre_en_quad4")
  96
  97 fileNames.append("cube_hexa8.med")
  98 meshNames.append("CUBE_EN_HEXA8")
  99
 100 ##fileNames.append("test19.med")
 101 ##meshNames.append("CartGrid")
 102
 103 ##fileNames.append("test19.med")
 104 ##meshNames.append("bodyfitted")
 105
 106 ##fileNames.append("test19.med")
 107 ##meshNames.append("maa1")
 108
 109 fileNames.append("carre_en_quad4_seg2.med")
 110 meshNames.append("carre_en_quad4_seg2")
 111
 112 fileNames.append("cube_hexa8_quad4.med")
 113 meshNames.append("CUBE_EN_HEXA8_QUAD4")
 114
 115 fileNames.append("pointe.med")
 116 meshNames.append("maa1")
 117
 118 fileNames.append("Mistrat.med")
 119 meshNames.append("Mistrat_Hexa")
 120
 121 ##fileNames.append("TimeStamps.med")
 122 ##meshNames.append("dom")
 123
 124 fileNames.append("Darcy3_3D_H_10x10x10_2.med")
 125 meshNames.append("Darcy3_3D_H_10x10x10")
 126
 127 fileNames.append("elle_3D_HPr_10x10x10_2.med")
 128 meshNames.append("elle_3D_HPr_10x10x10")
 129
 130 fileNames.append("elle_3D_HPr_2x2x2_2.med")
 131 meshNames.append("elle_3D_HPr_2x2x2")
 132
 133 fileNames.append("elle_3D_HPr_4x4x4_2.med")
 134 meshNames.append("elle_3D_HPr_4x4x4")
 135
 136
 137
 138 fileNames.append("ChampsDarcy.med")
 139 meshNames.append("2D_I129")
 140
 141 fileNames.append("darcy_1.1_res.med")
 142 meshNames.append("mail_test1-1-tri")
 143
 144 fileNames.append("darcy_1.3_resCASTEM.med")
 145 meshNames.append("mail_ktest1-3-tetra")
 146
 147 fileNames.append("darcy_1.3_resPORFLOW.med")
 148 meshNames.append("mail_ktest1-3-hexa")
 149
 150 fileNames.append("darcy_1.3_resTRACES.med")
 151 meshNames.append("mail_ktest1-3-tetra")
 152
 153 fileNames.append("darcy2_Castem_EFMH.med")
 154 meshNames.append("mail_test1-2-tri")
 155
 156 fileNames.append("darcy2_Castem_qua_EFMH.med")
 157 meshNames.append("mail_test1-2-qua")
 158
 159 fileNames.append("darcy2_Castem_qua_VF.med")
 160 meshNames.append("mail_test1-2-qua")
 161
 162 # there is a field with too long name (38 > MED_TAILLE_NOM==32):
 163 # "analytical_field - CONCENTRATION of A1"
 164 # so that invalid writing is sometimes fatal
 165 # fileNames.append("Deff_fdt_5.8_castem_efmh_diff_conc_dom.med")
 166 # meshNames.append("maillage_deffec_fdt")
 167
 168 # there is a field with too long name (38 > MED_TAILLE_NOM==32):
 169 # "analytical_field - CONCENTRATION of A1"
 170 # so that invalid writing is sometimes fatal
 171 # fileNames.append("Deff_fdt_5.8_castem_vf_diff_conc_dom.med")
 172 # meshNames.append("maillage_deffec_fdt")
 173
 174 fileNames.append("extendedtransport53_triangles.med")
 175 meshNames.append("TestA3_2094_0.1_rsurf_tri")
 176
 177 fileNames.append("H_CastCast_EFMH_I129_COUPLEX1.med")
 178 meshNames.append("COUPLEX1")
 179
 180 fileNames.append("H_CastCast_VF_I129_COUPLEX1.med")
 181 meshNames.append("COUPLEX1")
 182
 183 fileNames.append("H_CastCast_VF_Se79_COUPLEX1.med")
 184 meshNames.append("COUPLEX1")
 185
 186 fileNames.append("H_CastPorf_I129_COUPLEX1.med")
 187 meshNames.append("COUPLEX1")
 188
 189 fileNames.append("H_CastPorf_Se79_COUPLEX1.med")
 190 meshNames.append("COUPLEX1")
 191
 192 fileNames.append("H_PorfCast_EFMH_I129_COUPLEX1.med")
 193 meshNames.append("COUPLEX1")
 194
 195 fileNames.append("H_PorfCast_EFMH_Se79_COUPLEX1.med")
 196 meshNames.append("COUPLEX1")
 197
 198 fileNames.append("H_PorfPorf_I129_COUPLEX1.med")
 199 meshNames.append("COUPLEX1")
 200
 201 fileNames.append("H_Traces_I129_COUPLEX1.med")
 202 meshNames.append("COUPLEX1")
 203
 204 fileNames.append("H_Traces_Se79_COUPLEX1.med")
 205 meshNames.append("COUPLEX1")
 206
 207 fileNames.append("maillage_5_5_5.med")
 208 meshNames.append("maillage_5_5_5")
 209
 210 fileNames.append("maillage_chemvalIV_cas1_40elts.med")
 211 meshNames.append("maillage_chemvalIV_cas1_40elts")
 212
 213
 214
 215
 216 #
 217 # Castem or Gibi file list
 218 #
 219
 220 fileNames.append("Darcy3_3D_H_10x10x10.sauve")
 221 meshNames.append("")
 222
 223 fileNames.append("dx200_dy1_avec_2couches.sauve")
 224 meshNames.append("")
 225
 226 fileNames.append("elle_2D_QT_10x10.sauve")
 227 meshNames.append("")
 228
 229 fileNames.append("elle_2D_QT_2x2.sauve")
 230 meshNames.append("")
 231
 232 fileNames.append("elle_2D_QT_40x40.sauve")
 233 meshNames.append("")
 234
 235 fileNames.append("elle_2D_QT_4x4.sauve")
 236 meshNames.append("")
 237
 238 fileNames.append("elle_3D_HPr_10x10x10.sauve")
 239 meshNames.append("")
 240
 241 fileNames.append("elle_3D_HPr_2x2x2.sauve")
 242 meshNames.append("")
 243
 244 fileNames.append("elle_3D_HPr_4x4x4.sauve")
 245 meshNames.append("")
 246
 247 fileNames.append("inclusion_2d_raf.sauve")
 248 meshNames.append("")
 249
 250 fileNames.append("inclusion_2d.sauve")
 251 meshNames.append("")
 252
 253 fileNames.append("mail_ktest1-3-hexa.sauve")
 254 meshNames.append("")
 255
 256 fileNames.append("mail_ktest1-3-tetra.sauve")
 257 meshNames.append("")
 258
 259 fileNames.append("mail_ktest3-1.sauve")
 260 meshNames.append("")
 261
 262 fileNames.append("mail_ktest3-2.sauve")
 263 meshNames.append("")
 264
 265 fileNames.append("maillage_andra2_100elts.sauve")
 266 meshNames.append("")
 267
 268 fileNames.append("maillage_cas2_2d.sauve")
 269 meshNames.append("")
 270
 271 fileNames.append("maillage_cas4_234elts.sauve")
 272 meshNames.append("")
 273
 274 fileNames.append("maillage_CHEMVAL_100elts.sauve")
 275 meshNames.append("")
 276
 277 fileNames.append("maillage_CHEMVAL_40elts.sauve")
 278 meshNames.append("")
 279
 280 fileNames.append("maillage_chemvalIV_cas1_100elts.sauve")
 281 meshNames.append("")
 282
 283 fileNames.append("maillage_chemvalIV_cas1_40elts.sauve")
 284 meshNames.append("")
 285
 286 fileNames.append("mail_test1-1-qua.sauve")
 287 meshNames.append("")
 288
 289 fileNames.append("mail_test1-1-tri.sauve")
 290 meshNames.append("")
 291
 292 fileNames.append("mail_test1-2-qua.sauve")
 293 meshNames.append("")
 294
 295 fileNames.append("mail_test1-2-tri.sauve")
 296 meshNames.append("")
 297
 298 fileNames.append("mail-test1-4-1.sauve")
 299 meshNames.append("")
 300
 301 fileNames.append("mail-test1-4-2.sauve")
 302 meshNames.append("")
 303
 304 #
 305 # Porflow file list
 306 #
 307
 308 fileNames.append("boitenew.inp")
 309 meshNames.append("")
 310
 311 fileNames.append("Case1.inp")
 312 meshNames.append("")
 313
 314 fileNames.append("cube.inp")
 315 meshNames.append("")
 316
 317 fileNames.append("test3.inp")
 318 meshNames.append("")
 319
 320 fileNames.append("titi.inp")
 321 meshNames.append("")
 322
 323 ###################################################################################
 324
 325 nbOfFiles = len(fileNames)
 326 filesFull = []
 327
 328 for i in range(nbOfFiles):
 329     filesFull.append(os.path.join(filesPath, fileNames[i]))
 330
 331 ###################################################################################
 332 #
 333 # Loop on all files
 334 #
 335 ###################################################################################
 336
 337 print " This test is running on ",nbOfFiles," files"
 338 print ""
 339
 340 for i in range(nbOfFiles):
 341     fileName = fileNames[i]
 342     fileFull = filesFull[i]
 343     decompFile = string.split(fileName,".")
 344     lenDecompFileM1 = len(decompFile)-1
 345
 346     if (lenDecompFileM1 == 0) :
 347         print "The file ",fileName," should have at least a . in its name "
 348         sys.exit(1)
 349
 350     extensionFile = decompFile[lenDecompFileM1]
 351
 352     rootFile = decompFile[0]
 353     for k in range(1,lenDecompFileM1):
 354         rootFile = rootFile + "." + decompFile[k]
 355
 356     rootFileFull = os.path.join(tmpDir, rootFile)
 357
 358     medV22FileName = rootFileFull + "V22_test.med"
 359     vtkFileName    = rootFileFull + "_test.vtk"
 360
 361     try:
 362         mesh = MESH()
 363         if (extensionFile == "med"):
 364             print "The file ",fileName," is a MED file and the name of the mesh is ", meshNames[i]
 365             meshDriver = MED_MESH_RDONLY_DRIVER(fileFull,mesh)
 366             meshDriver.setMeshName(meshNames[i])
 367         elif (extensionFile == "sauve"):
 368             print "The file ",fileName," is a GIBI file"
 369             meshDriver = GIBI_MESH_RDONLY_DRIVER(fileFull,mesh)
 370         elif (extensionFile == "inp"):
 371             print "The file ",fileName," is a PORFLOW file"
 372             meshDriver = PORFLOW_MESH_RDONLY_DRIVER(fileFull,mesh)
 373         else :
 374             print "the file ",fileName,"has an unknow extension"
 375             sys.exit(1)
 376
 377         mesh.read(meshDriver)
 378     except:
 379         print "The mesh stored in the file ",fileName," is perhaps a GRID."
 380         try:
 381             print "... of MED_CARTESIAN type ?"
 382             type = MED_CARTESIAN
 383             mesh = GRID()
 384             mesh.setGridType(type)
 385             if (extensionFile == "med"):
 386                 meshDriver = MED_MESH_RDONLY_DRIVER(fileFull,mesh)
 387                 meshDriver.setMeshName(meshNames[i])
 388             elif (extensionFile == "sauve"):
 389                 meshDriver = GIBI_MESH_RDONLY_DRIVER(fileFull,mesh)
 390             elif (extensionFile == "inp"):
 391                 print "The file ",fileName," is a PORFLOW file"
 392                 meshDriver = PORFLOW_MESH_RDONLY_DRIVER(fileFull,mesh)
 393             else :
 394                 print "the file ",fileName,"has an unknow extension"
 395                 sys.exit(1)
 396
 397             meshDriver.open()
 398             meshDriver.read()
 399         except:
 400             meshDriver.close()
 401             try:
 402                 print "... of MED_POLAR type ?"
 403                 mesh = GRID()
 404                 type = MED_POLAR
 405                 mesh.setGridType(type)
 406                 if (extensionFile == "med"):
 407                     meshDriver = MED_MESH_RDONLY_DRIVER(fileFull,mesh)
 408                     meshDriver.setMeshName(meshNames[i])
 409                 elif (extensionFile == "sauve"):
 410                     meshDriver = GIBI_MESH_RDONLY_DRIVER(fileFull,mesh)
 411                 else :
 412                     print "the file ",fileName,"has an unknow extension"
 413                     sys.exit(1)
 414
 415                 meshDriver.open()
 416                 meshDriver.read()
 417             except:
 418                 meshDriver.close()
 419                 print "... of MED_BODY_FITTED type ?"
 420                 mesh = GRID()
 421                 type = MED_BODY_FITTED
 422                 mesh.setGridType(type)
 423                 if (extensionFile == "med"):
 424                     meshDriver = MED_MESH_RDONLY_DRIVER(fileFull,mesh)
 425                     meshDriver.setMeshName(meshNames[i])
 426                 elif (extensionFile == "sauve"):
 427                     meshDriver = GIBI_MESH_RDONLY_DRIVER(fileFull,mesh)
 428                 else :
 429                     print "the file ",fileName,"has an unknow extension"
 430                     sys.exit(1)
 431
 432                 meshDriver.open()
 433                 meshDriver.read()
 434
 435     meshDriver.close()
 436
 437     meshName = mesh.getName()
 438     spaceDim = mesh.getSpaceDimension()
 439     meshDim = mesh.getMeshDimension()
 440     print "The mesh ",meshName," is a ",spaceDim,"D mesh on a ",meshDim,"D geometry"
 441
 442     if (extensionFile == "med"):
 443         print "and is mounted via the MED driver"
 444     elif (extensionFile == "sauve"):
 445         print "and is mounted via the GIBI driver"
 446     elif (extensionFile == "inp"):
 447         print "and is mounted via the PORFLOW driver"
 448
 449     nbNodes = mesh.getNumberOfNodes()
 450     print "The mesh ",meshName," has",nbNodes,"Nodes"
 451     coordSyst = mesh.getCoordinatesSystem()
 452     print "The coordinates system is",coordSyst
 453     print "The Coordinates :"
 454     coordNames = []
 455     coordUnits = []
 456     for isd in range(spaceDim):
 457         coordNames.append(mesh.getCoordinateName(isd))
 458         coordUnits.append(mesh.getCoordinateUnit(isd))
 459
 460     print "names:", coordNames
 461     print "units", coordUnits
 462     print "values:"
 463     coordinates = mesh.getCoordinates(MED_FULL_INTERLACE)
 464     for k in range(nbNodes):
 465         kp1 = k+1
 466         coords = []
 467         for isd in range(spaceDim):
 468             isdp1 = isd+1
 469             coords.append(mesh.getCoordinate(kp1,isdp1))
 470
 471         print coords," ---- ", coordinates[k*spaceDim:((k+1)*spaceDim)]
 472
 473     print ""
 474     print "Show the Cell Nodal Connectivity of the Cells:"
 475     nbTypesCell = mesh.getNumberOfTypes(MED_CELL)
 476     print ""
 477     if (nbTypesCell>0):
 478         print "The Mesh has",nbTypesCell,"Type(s) of Cell"
 479         types = mesh.getTypes(MED_CELL)
 480         for k in range(nbTypesCell):
 481             type = types[k]
 482             nbElemType = mesh.getNumberOfElements(MED_CELL,type)
 483             print "For the type:",type,"there is(are)",nbElemType,"elemnt(s)"
 484             connectivity = mesh.getConnectivity(MED_NODAL,MED_CELL,type)
 485             nbNodesPerCell = type%100
 486             for j in range(nbElemType):
 487                 print "Element",(j+1)," ",connectivity[j*nbNodesPerCell:(j+1)*nbNodesPerCell]
 488
 489     print ""
 490     print "Show the Cell Reverse Nodal Connectivity:"
 491     ReverseConnectivity = mesh.getReverseConnectivity(MED_NODAL)
 492     ReverseConnectivityIndex = mesh.getReverseConnectivityIndex(MED_NODAL)
 493     print ""
 494     for j in range(nbNodes):
 495         begin = ReverseConnectivityIndex[j]-1
 496         end = ReverseConnectivityIndex[j+1]-1
 497         print "Node",(j+1),"-->",ReverseConnectivity[begin:end]
 498
 499     print ""
 500     print "Show the Cell Descending Connectivity:"
 501     mesh.calculateConnectivity(MED_DESCENDING,MED_CELL)
 502     nbElemts = mesh.getNumberOfElements(MED_CELL,MED_ALL_ELEMENTS)
 503     Connectivity = mesh.getConnectivity(MED_DESCENDING,MED_CELL,MED_ALL_ELEMENTS)
 504     ConnectivityIndex = mesh.getConnectivityIndex(MED_DESCENDING,MED_CELL)
 505     print ""
 506     for j in range(nbElemts):
 507         begin = ConnectivityIndex[j]-1
 508         end = ConnectivityIndex[j+1]-1
 509         print "Element",(j+1),"-->",Connectivity[begin:end]
 510
 511     print ""
 512
 513     if (spaceDim == 3):
 514         constituent = MED_FACE
 515     elif (spaceDim == 2):
 516         constituent = MED_EDGE
 517
 518     print "Show the Face/Edge Nodal Connectivity:"
 519     nbTypesConst = mesh.getNumberOfTypes(constituent)
 520     print ""
 521     if (nbTypesConst>0):
 522         print "The Mesh has",nbTypesConst,"Type(s) of Constituent"
 523         types = mesh.getTypes(constituent)
 524         for k in range(nbTypesConst):
 525             type = types[k]
 526             nbElemType = mesh.getNumberOfElements(constituent,type)
 527             print "For the type:",type,"there is(are)",nbElemType,"elemnt(s)"
 528             connectivity = mesh.getConnectivity(MED_NODAL,constituent,type)
 529             nbNodesPerConst = type%100
 530             for j in range(nbElemType):
 531                 print "Element",(j+1)," ",connectivity[j*nbNodesPerConst:(j+1)*nbNodesPerConst]
 532
 533     if (meshDim == 3):
 534         print ""
 535         print "Show the Face/Edge Reverse Nodal Connectivity:"
 536         ReverseConnectivity = mesh.getReverseConnectivity(MED_NODAL,constituent)
 537         ReverseConnectivityIndex = mesh.getReverseConnectivityIndex(MED_NODAL,constituent)
 538         print ""
 539         for j in range(nbNodes):
 540             begin = ReverseConnectivityIndex[j]-1
 541             end = ReverseConnectivityIndex[j+1]-1
 542             print "Node",(j+1),"-->",ReverseConnectivity[begin:end]
 543
 544         print ""
 545         try:
 546             print "Show the Face/Edge Descending Connectivity:"
 547             mesh.calculateConnectivity(MED_DESCENDING,constituent)
 548             nbElemts = mesh.getNumberOfElements(constituent,MED_ALL_ELEMENTS)
 549             Connectivity = mesh.getConnectivity(MED_DESCENDING,constituent,MED_ALL_ELEMENTS)
 550             ConnectivityIndex = mesh.getConnectivityIndex(MED_DESCENDING,constituent)
 551             print ""
 552             for j in range(nbElemts):
 553                 begin = ConnectivityIndex[j]-1
 554                 end = ConnectivityIndex[j+1]-1
 555                 print "Element",(j+1),"-->",Connectivity[begin:end]
 556
 557             print ""
 558         except :
 559             pass
 560
 561     for entity in [MED_NODE,MED_CELL,MED_FACE,MED_EDGE]:
 562         nbFam = mesh.getNumberOfFamilies(entity)
 563         nbGrp = mesh.getNumberOfGroups(entity)
 564         if (entity == MED_NODE) :
 565             if (nbFam > 0) : print "This mesh has",nbFam,"Node Family(ies)"
 566             if (nbGrp > 0) : print "This mesh has",nbGrp,"Node Group(s)"
 567         elif (entity == MED_CELL) :
 568             if (nbFam > 0) : print "This mesh has",nbFam,"Cell Family(ies)"
 569             if (nbGrp > 0) : print "This mesh has",nbGrp,"Cell Group(s)"
 570         elif (entity == MED_FACE) :
 571             if (nbFam > 0) : print "This mesh has",nbFam,"Face Family(ies)"
 572             if (nbGrp > 0) : print "This mesh has",nbGrp,"Face Group(s)"
 573         elif (entity == MED_EDGE) :
 574             if (nbFam > 0) : print "This mesh has",nbFam,"Edge Family(ies)"
 575             if (nbGrp > 0) : print "This mesh has",nbGrp,"Edge Group(s)"
 576
 577     for entity in [MED_NODE,MED_CELL,MED_FACE,MED_EDGE]:
 578         nbFam = mesh.getNumberOfFamilies(entity)
 579         nbGrp = mesh.getNumberOfGroups(entity)
 580         if nbFam > 0:
 581             for j in range(nbFam):
 582                 print ""
 583                 family = mesh.getFamily(entity,j+1)
 584                 familyName = family.getName()
 585                 familyDescription = family.getDescription()
 586                 familyEntity = family.getEntity()
 587                 familyBool = family.isOnAllElements()
 588                 print "  -Name:",familyName
 589                 print "  -Description:",familyDescription
 590                 print "  -Entity:",familyEntity
 591                 familyIdentifier = family.getIdentifier()
 592                 nbOfAtt = family.getNumberOfAttributes()
 593                 print "  -Identifier:",familyIdentifier
 594                 print "  -Number Of Attributes:",nbOfAtt
 595                 attributesids = family.getAttributesIdentifiers()
 596                 attributesvals = family.getAttributesValues()
 597                 for k in range(nbOfAtt):
 598                     print "    * Attributes:",attributesids[k],":",attributesvals[k],",",family.getAttributeDescription(k+1)
 599                 nbOfGrp = family.getNumberOfGroups()
 600                 print "  -Number Of Groups:",nbOfGrp
 601                 for k in range(nbOfGrp):
 602                     print "    * Group:",family.getGroupName(k+1)
 603                 print "  -Entities list:"
 604                 if (familyBool):
 605                     print "  -Is on all entities"
 606                 else:
 607                     nbOfTypes = family.getNumberOfTypes()
 608                     types = family.getTypes()
 609                     print "  -Number Of Types:",nbOfTypes
 610                     for k in range(nbOfTypes):
 611                         type = types[k]
 612                         nbOfElmtsOfType = family.getNumberOfElements(type)
 613                         number = family.getNumber(type)
 614                         print "    * Type",type
 615                         print "    * Number",number[0:nbOfElmtsOfType]
 616                     print ""
 617         print ""
 618
 619         if nbGrp > 0:
 620             for j in range(nbGrp):
 621                 print ""
 622                 group = mesh.getGroup(entity,j+1)
 623                 groupName = group.getName()
 624                 groupDescription = group.getDescription()
 625                 groupEntity = group.getEntity()
 626                 groupBool = group.isOnAllElements()
 627                 print "  -Name:",groupName
 628                 print "  -Description:",groupDescription
 629                 print "  -Entity:",groupEntity
 630                 nbOfFam = group.getNumberOfFamilies()
 631                 print "  -Number Of Families:",nbOfFam
 632                 for k in range(nbOfFam):
 633                     print "    * Family:",group.getFamily(k+1).getName()
 634                 print "  -Entities list:"
 635                 if (groupBool):
 636                     print "  -Is on all entities"
 637                 else:
 638                     nbOfTypes = group.getNumberOfTypes()
 639                     types = group.getTypes()
 640                     print "  -Number Of Types:",nbOfTypes
 641                     for k in range(nbOfTypes):
 642                         type = types[k]
 643                         nbOfElmtsOfType = group.getNumberOfElements(type)
 644                         number = group.getNumber(type)
 645                         print "    * Type",type
 646                         print "    * Number",number[0:nbOfElmtsOfType]
 647                     print ""
 648             print ""
 649
 650
 651     print "Saving in file the mesh under the med and vtk format"
 652     print "Med V22 file = ",medV22FileName
 653     print "vtk file = ",vtkFileName
 654
 655     idMedV22 = mesh.addDriver(MED_DRIVER,medV22FileName,mesh.getName(),RDWR)
 656     mesh.write(idMedV22)
 657
 658     idVtk = mesh.addDriver(VTK_DRIVER,vtkFileName,mesh.getName())
 659     mesh.write(idVtk)
 660     print ""
 661
 662     print "Building of the support on all Cells of the mesh."
 663     supportCell = mesh.getSupportOnAll( MED_CELL )
 664     print ""
 665     barycenter = mesh.getBarycenter(supportCell)
 666     print "Getting barycenter of all Cells of the mesh"
 667     for j in range(nbElemts):
 668         barycenterCell = barycenter.getRow(j+1)
 669         print "    * ",barycenterCell[:spaceDim]
 670     print ""
 671
 672     print "Saving in file the cell barycenter field under the med and vtk format"
 673     print "Med V22 file = ",medV22FileName
 674     print "vtk file = ",vtkFileName
 675
 676     idMedV22 = barycenter.addDriver(MED_DRIVER,medV22FileName,barycenter.getName())
 677     barycenter.write(idMedV22)
 678
 679     idVtk = barycenter.addDriver(VTK_DRIVER,vtkFileName,barycenter.getName())
 680     barycenter.write(idVtk)
 681     print ""
 682
 683     if (spaceDim == 3) and (meshDim == spaceDim) :
 684         print "Getting volume of all Cells of the mesh:"
 685         volume = mesh.getVolume(supportCell)
 686         voltot = 0.
 687         for j in range(nbElemts):
 688             volumeCell = volume.getValueIJ(j+1,1)
 689             print "    * ",volumeCell
 690             voltot = voltot + volumeCell
 691         print "Volume of the mesh:",voltot
 692         print ""
 693
 694         print "Saving in file the cell volume field under the med and vtk format"
 695         print "Med V22 file = ",medV22FileName
 696         print "vtk file = ",vtkFileName
 697
 698         idMedV22 = volume.addDriver(MED_DRIVER,medV22FileName,volume.getName())
 699         volume.write(idMedV22)
 700
 701         idVtk = volume.addDriver(VTK_DRIVER,vtkFileName,volume.getName())
 702         volume.write(idVtk)
 703         print ""
 704
 705         print "Building of the support on all Faces of the mesh."
 706         supportFace = mesh.getSupportOnAll(MED_FACE)
 707         nbFace = mesh.getNumberOfElements(MED_FACE,MED_ALL_ELEMENTS)
 708         print ""
 709         print "Getting normal of each face of this support",nbFace
 710         nbTypeFace = mesh.getNumberOfTypes(MED_FACE)
 711         TypeFace = mesh.getTypes(MED_FACE)
 712         print "nbTypeFace:",nbTypeFace,"----",TypeFace[:nbTypeFace]
 713         normal = mesh.getNormal(supportFace)
 714         area = mesh.getArea(supportFace)
 715         for j in range(nbFace):
 716             normalFace = normal.getRow(j+1)
 717             areaFace = area.getRow(j+1)
 718             value1 = normalFace[0]
 719             value2 = normalFace[1]
 720             value3 = normalFace[2]
 721             norm = (value1*value1 + value2*value2 + value3*value3)**(0.5)
 722             print "    * ",normalFace[:spaceDim],"norm:",norm," --> area ",areaFace[0]
 723         print ""
 724
 725         print "Saving in file the face normal field under the med format"
 726         print "Med V22 file = ",medV22FileName
 727
 728         idMedV22 = normal.addDriver(MED_DRIVER,medV22FileName,normal.getName())
 729         normal.write(idMedV22)
 730
 731         print "but not in vtk format because vtk does not offer the possibility to view a field on edges or faces"
 732         print ""
 733
 734     elif (spaceDim == 2) and (meshDim == spaceDim):
 735         print "Getting area on all Cells of the mesh:"
 736         area = mesh.getArea(supportCell)
 737         areatot = 0.
 738         for j in range(nbElemts):
 739             areaCell = area.getValueIJ(j+1,1)
 740             print "    * ",areaCell
 741             areatot = areatot + areaCell
 742         print "Area of the mesh:",areatot
 743         print ""
 744
 745         print "Saving in file the cell area field under the med and vtk format"
 746         print "Med V22 file = ",medV22FileName
 747         print "vtk file = ",vtkFileName
 748
 749
 750         idMedV22 = area.addDriver(MED_DRIVER,medV22FileName,area.getName())
 751         area.write(idMedV22)
 752
 753         idVtk = area.addDriver(VTK_DRIVER,vtkFileName,area.getName())
 754         area.write(idVtk)
 755         print ""
 756
 757         print "Building of the support on all Edges of the mesh."
 758         supportEdge = mesh.getSupportOnAll(MED_EDGE)
 759         nbEdge = mesh.getNumberOfElements(MED_EDGE,MED_ALL_ELEMENTS)
 760         print ""
 761         print "Getting normal of each edge of this support",nbEdge
 762         nbTypeEdge = mesh.getNumberOfTypes(MED_EDGE)
 763         TypeEdge = mesh.getTypes(MED_EDGE)
 764         print "nbTypeEdge:",nbTypeEdge,"----",TypeEdge[:nbTypeEdge]
 765         normal = mesh.getNormal(supportEdge)
 766         length = mesh.getLength(supportEdge)
 767         for j in range(nbEdge):
 768             normalEdge = normal.getRow(j+1)
 769             lengthEdge = length.getRow(j+1)
 770             value1 = normalEdge[0]
 771             value2 = normalEdge[1]
 772             norm = (value1*value1 + value2*value2)**(0.5)
 773             print "    * ",normalEdge[:spaceDim],"norm:",norm," --> length ",lengthEdge[0]
 774         print ""
 775
 776         print "Saving in file the face normal field under the med format"
 777         print "Med V22 file = ",medV22FileName
 778
 779         idMedV22 = normal.addDriver(MED_DRIVER,medV22FileName,normal.getName())
 780         normal.write(idMedV22)
 781
 782         print "but no in vtk format because vtk does not offer the possibility to view a field on edges or faces"
 783
 784     print ""
 785     print "Building support on Elements of the boundary"
 786     if (spaceDim == 3) and (meshDim == spaceDim) :
 787         suppBound = mesh.getBoundaryElements(MED_FACE)
 788         nbElmBound = suppBound.getNumberOfElements(MED_ALL_ELEMENTS)
 789         print "Getting normal field on the boundary",nbElmBound
 790         normalBound = mesh.getNormal(suppBound)
 791         numberSuppBound = suppBound.getNumber(MED_ALL_ELEMENTS)
 792         for j in range(nbElmBound):
 793             valInd = numberSuppBound[j]
 794             normalBoundJ = normalBound.getRow(valInd)
 795             value1 = normalBoundJ[0]
 796             value2 = normalBoundJ[1]
 797             value3 = normalBoundJ[2]
 798             norm = (value1*value1 + value2*value2 + value3*value3)**(0.5)
 799             print "    * ",normalBoundJ[:spaceDim],"norm:",norm
 800     elif (spaceDim == 2) and (meshDim == spaceDim):
 801         suppBound = mesh.getBoundaryElements(MED_EDGE)
 802         nbElmBound = suppBound.getNumberOfElements(MED_ALL_ELEMENTS)
 803         print "Getting normal field on the boundary",nbElmBound
 804         normalBound = mesh.getNormal(suppBound)
 805         numberSuppBound = suppBound.getNumber(MED_ALL_ELEMENTS)
 806         for j in range(nbElmBound):
 807             valInd = numberSuppBound[j]
 808             normalBoundJ = normalBound.getRow(valInd)
 809             value1 = normalBoundJ[0]
 810             value2 = normalBoundJ[1]
 811             norm = (value1*value1 + value2*value2)**(0.5)
 812             print "    * ",normalBoundJ[:spaceDim],"norm:",norm
 813     print ""
 814
 815     if (extensionFile == "med"):
 816         md = MEDFILEBROWSER(fileFull)
 817
 818         nbMeshes = md.getNumberOfMeshes()
 819         nbFields = md.getNumberOfFields()
 820
 821         print "The med file", fileName, "contains", nbMeshes, "mesh(es) and", nbFields, "field(s)"
 822
 823         if (nbMeshes>0):
 824             print "Mesh(es) Name(s) is(are) "
 825
 826             for imsh in range(nbMeshes):
 827                 mesh_name = md.getMeshName(imsh)
 828                 print "   - ",mesh_name
 829         print ""
 830         if (nbFields>0):
 831             print "Field(s) Name(s) is(are) "
 832
 833             for ifld in range(nbFields):
 834                 field_name = md.getFieldName(ifld)
 835                 print "   - ",field_name
 836
 837         print ""
 838
 839 #        mesh_name = md.getMeshName(0)
 840         mesh_name = meshNames[i]
 841         if md.isStructuredMesh( mesh_name ):
 842             mesh = GRID(MED_DRIVER,md.getFileName(),mesh_name)
 843         else:
 844             mesh = MESH(MED_DRIVER,md.getFileName(),mesh_name)
 845         spaceDim = mesh.getSpaceDimension()
 846         meshDim = mesh.getMeshDimension()
 847         nbNodes = mesh.getNumberOfNodes()
 848         print "The first mesh",mesh_name,"is a",spaceDim,"D mesh on a",meshDim,"D geometry and has",nbNodes,"Nodes"
 849
 850         if (nbFields>0):
 851             print "Field(s) Analysis "
 852             for ifld in range(nbFields):
 853                 field_name = md.getFieldName(ifld)
 854                 dtits = md.getFieldIteration(field_name)
 855                 print "The",print_ord(ifld),"field is",field_name,"with",len(dtits),"iteration(s)"
 856                 for dtitfield in dtits:
 857                     dt = dtitfield.getdt()
 858                     it = dtitfield.getit()
 859                     type = md.getFieldType(field_name)
 860                     print "     * Iteration:",dt,"Order number:",it,"Type:",type
 861                     if type == MED_INT32:
 862                         fieldint = FIELDINT(MED_DRIVER,md.getFileName(),field_name,dt,it,mesh)
 863                         name = fieldint.getName()
 864                         desc = fieldint.getDescription()
 865                         nbOfComp = fieldint.getNumberOfComponents()
 866                         print "     Field",name," : ",desc
 867                         print "     Number Of Components:",nbOfComp
 868                         iterationNb = fieldint.getIterationNumber()
 869                         orderNb = fieldint.getOrderNumber()
 870                         time = fieldint.getTime()
 871                         print "     Iteration Number",iterationNb
 872                         print "     Order Number",orderNb
 873                         print "     Time",time
 874                         print "     Norme  2  : ", fieldint.norm2()
 875                         print "     Norme Max : ", fieldint.normMax()
 876
 877                         if fieldint.getSupport().getEntity()!=MED_NODE:
 878                             fieldint_vol=fieldint.getSupport().getMesh().getVolume(fieldint.getSupport())
 879                             print "     Norme L1  : ", fieldint.normL1()
 880                             print "     Norme L2  : ", fieldint.normL2()
 881                             print "     Norme L2(vol) : ", fieldint.normL2(fieldint_vol)
 882
 883                         for k in range(nbOfComp):
 884                             kp1 = k+1
 885                             compName = fieldint.getComponentName(kp1)
 886                             compDesc = fieldint.getComponentDescription(kp1)
 887                             compUnit = fieldint.getMEDComponentUnit(kp1)
 888                             print "      * Component:",kp1
 889                             print "          Name:",compName
 890                             print "          Description:",compDesc
 891                             print "          Unit:",compUnit
 892                             if fieldint.getSupport().getEntity()!=MED_NODE:
 893                                 print "          Norme L1  : ", fieldint.normL1(kp1)
 894                                 print "          Norme L2  : ", fieldint.normL2(kp1)
 895                                 print "          Norme L2(vol) : ", fieldint.normL2(kp1,fieldint_vol)
 896
 897                         support = fieldint.getSupport()
 898                         nbOf = support.getNumberOfElements(MED_ALL_ELEMENTS)
 899                         print "     Values:",nbOf
 900                         for k in range(nbOf):
 901                             valueI = fieldint.getRow(k+1)
 902                             print "     *",valueI[:nbOfComp]
 903                         fieldint2 = FIELDINT(fieldint)
 904                         print ""
 905                         fieldintadd = fieldint + fieldint2
 906                         print "Test of the addition of two integer fields with creation a new one"
 907                         print ""
 908                         name = fieldintadd.getName()
 909                         desc = fieldintadd.getDescription()
 910                         nbOfComp = fieldintadd.getNumberOfComponents()
 911                         print "     Field",name," : ",desc
 912                         print "     Number Of Components:",nbOfComp
 913                         iterationNb = fieldintadd.getIterationNumber()
 914                         orderNb = fieldintadd.getOrderNumber()
 915                         time = fieldintadd.getTime()
 916                         print "     Iteration Number",iterationNb
 917                         print "     Order Number",orderNb
 918                         print "     Time",time
 919                         for k in range(nbOfComp):
 920                             kp1 = k+1
 921                             compName = fieldintadd.getComponentName(kp1)
 922                             compDesc = fieldintadd.getComponentDescription(kp1)
 923                             compUnit = fieldintadd.getMEDComponentUnit(kp1)
 924                             print "      * Component:",kp1
 925                             print "          Name:",compName
 926                             print "          Description:",compDesc
 927                             print "          Unit:",compUnit
 928
 929                         support = fieldintadd.getSupport()
 930                         nbOf = support.getNumberOfElements(MED_ALL_ELEMENTS)
 931                         print "     Values:",nbOf
 932                         for k in range(nbOf):
 933                             valueI = fieldintadd.getRow(k+1)
 934                             print "     *",valueI[:nbOfComp]
 935                         print ""
 936                         fieldintsub = fieldint - fieldint2
 937                         print "Test of the substraction of two integer fields with creation a new one"
 938                         print ""
 939                         name = fieldintsub.getName()
 940                         desc = fieldintsub.getDescription()
 941                         nbOfComp = fieldintsub.getNumberOfComponents()
 942                         print "     Field",name," : ",desc
 943                         print "     Number Of Components:",nbOfComp
 944                         iterationNb = fieldintsub.getIterationNumber()
 945                         orderNb = fieldintsub.getOrderNumber()
 946                         time = fieldintsub.getTime()
 947                         print "     Iteration Number",iterationNb
 948                         print "     Order Number",orderNb
 949                         print "     Time",time
 950                         for k in range(nbOfComp):
 951                             kp1 = k+1
 952                             compName = fieldintsub.getComponentName(kp1)
 953                             compDesc = fieldintsub.getComponentDescription(kp1)
 954                             compUnit = fieldintsub.getMEDComponentUnit(kp1)
 955                             print "      * Component:",kp1
 956                             print "          Name:",compName
 957                             print "          Description:",compDesc
 958                             print "          Unit:",compUnit
 959
 960                         support = fieldintsub.getSupport()
 961                         nbOf = support.getNumberOfElements(MED_ALL_ELEMENTS)
 962                         print "     Values:",nbOf
 963                         for k in range(nbOf):
 964                             valueI = fieldintsub.getRow(k+1)
 965                             print "     *",valueI[:nbOfComp]
 966                         print ""
 967                         fieldintmul = fieldint * fieldint2
 968                         print "Test of the multiplication of two integer fields with creation a new one"
 969                         print ""
 970                         name = fieldintmul.getName()
 971                         desc = fieldintmul.getDescription()
 972                         nbOfComp = fieldintmul.getNumberOfComponents()
 973                         print "     Field",name," : ",desc
 974                         print "     Number Of Components:",nbOfComp
 975                         iterationNb = fieldintmul.getIterationNumber()
 976                         orderNb = fieldintmul.getOrderNumber()
 977                         time = fieldintmul.getTime()
 978                         print "     Iteration Number",iterationNb
 979                         print "     Order Number",orderNb
 980                         print "     Time",time
 981                         for k in range(nbOfComp):
 982                             kp1 = k+1
 983                             compName = fieldintmul.getComponentName(kp1)
 984                             compDesc = fieldintmul.getComponentDescription(kp1)
 985                             compUnit = fieldintmul.getMEDComponentUnit(kp1)
 986                             print "      * Component:",kp1
 987                             print "          Name:",compName
 988                             print "          Description:",compDesc
 989                             print "          Unit:",compUnit
 990
 991                         support = fieldintmul.getSupport()
 992                         nbOf = support.getNumberOfElements(MED_ALL_ELEMENTS)
 993                         print "     Values:",nbOf
 994                         for k in range(nbOf):
 995                             valueI = fieldintmul.getRow(k+1)
 996                             print "     *",valueI[:nbOfComp]
 997                         print ""
 998                         try:
 999                             fieldintdiv = fieldint / fieldint2
1000                             print "Test of the division of two integer fields with creation a new one"
1001                             print ""
1002                             name = fieldintdiv.getName()
1003                             desc = fieldintdiv.getDescription()
1004                             nbOfComp = fieldintdiv.getNumberOfComponents()
1005                             print "     Field",name," : ",desc
1006                             print "     Number Of Components:",nbOfComp
1007                             iterationNb = fieldintdiv.getIterationNumber()
1008                             orderNb = fieldintdiv.getOrderNumber()
1009                             time = fieldintdiv.getTime()
1010                             print "     Iteration Number",iterationNb
1011                             print "     Order Number",orderNb
1012                             print "     Time",time
1013                             for k in range(nbOfComp):
1014                                 kp1 = k+1
1015                                 compName = fieldintdiv.getComponentName(kp1)
1016                                 compDesc = fieldintdiv.getComponentDescription(kp1)
1017                                 compUnit = fieldintdiv.getMEDComponentUnit(kp1)
1018                                 print "      * Component:",kp1
1019                                 print "          Name:",compName
1020                                 print "          Description:",compDesc
1021                                 print "          Unit:",compUnit
1022
1023                             support = fieldintdiv.getSupport()
1024                             nbOf = support.getNumberOfElements(MED_ALL_ELEMENTS)
1025                             print "     Values:",nbOf
1026                             for k in range(nbOf):
1027                                 valueI = fieldintdiv.getRow(k+1)
1028                                 print "     *",valueI[:nbOfComp]
1029                             print ""
1030                             print "TESTS OPERATIONS SUR FIELDINT : "
1031                         except:
1032                             print "testMedMemGeneral  fieldintdiv = fieldint / fieldint2 catch/except error"
1033                         fieldintadd = fieldint+fieldint2
1034                         fieldintsub = fieldint-fieldint2
1035                         fieldintmul = fieldint*fieldint2
1036                         try:
1037                             fieldintdiv = fieldint/fieldint2
1038                         except:
1039                             fieldintdiv = None
1040                             print "testMedMemGeneral  fieldintdiv = fieldint/fieldint2 catch/except error"
1041                         fieldintasso = fieldint+fieldint*fieldint
1042                         fieldintSP=createFieldIntScalarProduct(fieldint, fieldint2)
1043
1044                         print " f1     : ",fieldint.getValue()
1045                         print " f2     : ",fieldint2.getValue()
1046                         print "--------------------------------------------------------------------------------------------------------------"
1047                         print "  +     : ",fieldintadd.getValue()
1048                         print "  -     : ",fieldintsub.getValue()
1049                         print "  *     : ",fieldintmul.getValue()
1050                         if fieldintdiv == None :
1051                             print "testMedMemGeneral   /     : None"
1052                         else:
1053                             print "  /     : ",fieldintdiv.getValue()
1054                         fieldint+=fieldint2;
1055                         print "  +=    : ",fieldint.getValue()
1056                         fieldint-=fieldint2;
1057                         print "  -=    : ",fieldint.getValue()
1058                         fieldint*=fieldint2;
1059                         print "  *=    : ",fieldint.getValue()
1060                         try:
1061                             fieldint/=fieldint2;
1062                             print "  /=    : ",fieldint.getValue()
1063                         except :
1064                             fieldint = None
1065                             print "  /=    : Catch/Except : None"
1066                         print "f1+f2*f2: ",fieldintasso.getValue()
1067                         if fieldint != None :
1068                             fieldint.applyLin(4,1);
1069                             print " 4f1+1  : ",fieldint.getValue()
1070                         print " f1.f2  : ",fieldintSP.getValue()
1071                         fieldint2.applyPyFunc(add_one)
1072                         print " CB:f2+1: ",fieldint2.getValue()
1073                     elif type == MED_REEL64:
1074                         fielddouble = FIELDDOUBLE(MED_DRIVER,md.getFileName(),field_name,dt,it,mesh)
1075                         name = fielddouble.getName()
1076                         desc = fielddouble.getDescription()
1077                         nbOfComp = fielddouble.getNumberOfComponents()
1078                         print "     Field",name," : ",desc
1079                         print "     Number Of Components:",nbOfComp
1080                         iterationNb = fielddouble.getIterationNumber()
1081                         orderNb = fielddouble.getOrderNumber()
1082                         time = fielddouble.getTime()
1083                         print "     Iteration Number",iterationNb
1084                         print "     Order Number",orderNb
1085                         print "     Time",time
1086                         print "     Norme  2  : ", fielddouble.norm2()
1087                         print "     Norme Max : ", fielddouble.normMax()
1088                         fielddouble.getSupport().update()
1089                         fieldEntity = fielddouble.getSupport().getEntity()
1090                         print "try sobolev",fieldEntity
1091                         if fieldEntity !=MED_NODE:
1092                             if (fieldEntity == MED_CELL):
1093                                 if (spaceDim == 3):
1094                                     fielddouble_vol=fielddouble.getSupport().getMesh().getVolume(fielddouble.getSupport())
1095                                 elif (spaceDim == 2):
1096                                     fielddouble_vol=fielddouble.getSupport().getMesh().getArea(fielddouble.getSupport())
1097                             elif (fieldEntity == MED_FACE):
1098                                 fielddouble_vol=fielddouble.getSupport().getMesh().getArea(fielddouble.getSupport())
1099                             elif (fieldEntity == MED_EDGE):
1100                                 fielddouble_vol=fielddouble.getSupport().getMesh().getLength(fielddouble.getSupport())
1101                             print "Norme L1  : ", fielddouble.normL1()
1102                             print "Norme L2  : ", fielddouble.normL2()
1103                             print "Norme L2(vol) : ", fielddouble.normL2(fielddouble_vol)
1104
1105                         for k in range(nbOfComp):
1106                             kp1 = k+1
1107                             compName = fielddouble.getComponentName(kp1)
1108                             compDesc = fielddouble.getComponentDescription(kp1)
1109                             compUnit = fielddouble.getMEDComponentUnit(kp1)
1110                             print "      * Component:",kp1
1111                             print "          Name:",compName
1112                             print "          Description:",compDesc
1113                             print "          Unit:",compUnit
1114                             if fielddouble.getSupport().getEntity()!=MED_NODE:
1115                                 print "          Norme L1  : ", fielddouble.normL1(kp1)
1116                                 print "          Norme L2  : ", fielddouble.normL2(kp1)
1117                                 print "          Norme L2(vol) : ", fielddouble.normL2(kp1, fielddouble_vol)
1118
1119                         support = fielddouble.getSupport()
1120                         nbOf = support.getNumberOfElements(MED_ALL_ELEMENTS)
1121                         print "     Values:",nbOf
1122                         for k in range(nbOf):
1123                             valueI = fielddouble.getRow(k+1)
1124                             print "     *",valueI[:nbOfComp]
1125                         fielddouble2 = FIELDDOUBLE(fielddouble)
1126                         print ""
1127                         fielddoubleadd = fielddouble + fielddouble2
1128                         print "Test of the addition of two double fields with creation a new one"
1129                         print ""
1130                         name = fielddoubleadd.getName()
1131                         desc = fielddoubleadd.getDescription()
1132                         nbOfComp = fielddoubleadd.getNumberOfComponents()
1133                         print "     Field",name," : ",desc
1134                         print "     Number Of Components:",nbOfComp
1135                         iterationNb = fielddoubleadd.getIterationNumber()
1136                         orderNb = fielddoubleadd.getOrderNumber()
1137                         time = fielddoubleadd.getTime()
1138                         print "     Iteration Number",iterationNb
1139                         print "     Order Number",orderNb
1140                         print "     Time",time
1141                         for k in range(nbOfComp):
1142                             kp1 = k+1
1143                             compName = fielddoubleadd.getComponentName(kp1)
1144                             compDesc = fielddoubleadd.getComponentDescription(kp1)
1145                             compUnit = fielddoubleadd.getMEDComponentUnit(kp1)
1146                             print "      * Component:",kp1
1147                             print "          Name:",compName
1148                             print "          Description:",compDesc
1149                             print "          Unit:",compUnit
1150
1151                         support = fielddoubleadd.getSupport()
1152                         nbOf = support.getNumberOfElements(MED_ALL_ELEMENTS)
1153                         print "     Values:",nbOf
1154                         for k in range(nbOf):
1155                             valueI = fielddoubleadd.getRow(k+1)
1156                             print "     *",valueI[:nbOfComp]
1157                         print ""
1158                         fielddoublesub = fielddouble - fielddouble2
1159                         print "Test of the substraction of two double fields with creation a new one"
1160                         print ""
1161                         name = fielddoublesub.getName()
1162                         desc = fielddoublesub.getDescription()
1163                         nbOfComp = fielddoublesub.getNumberOfComponents()
1164                         print "     Field",name," : ",desc
1165                         print "     Number Of Components:",nbOfComp
1166                         iterationNb = fielddoublesub.getIterationNumber()
1167                         orderNb = fielddoublesub.getOrderNumber()
1168                         time = fielddoublesub.getTime()
1169                         print "     Iteration Number",iterationNb
1170                         print "     Order Number",orderNb
1171                         print "     Time",time
1172                         for k in range(nbOfComp):
1173                             kp1 = k+1
1174                             compName = fielddoublesub.getComponentName(kp1)
1175                             compDesc = fielddoublesub.getComponentDescription(kp1)
1176                             compUnit = fielddoublesub.getMEDComponentUnit(kp1)
1177                             print "      * Component:",kp1
1178                             print "          Name:",compName
1179                             print "          Description:",compDesc
1180                             print "          Unit:",compUnit
1181
1182                         support = fielddoublesub.getSupport()
1183                         nbOf = support.getNumberOfElements(MED_ALL_ELEMENTS)
1184                         print "     Values:",nbOf
1185                         for k in range(nbOf):
1186                             valueI = fielddoublesub.getRow(k+1)
1187                             print "     *",valueI[:nbOfComp]
1188                         print ""
1189                         fielddoublemul = fielddouble * fielddouble2
1190                         print "Test of the multiplication of two double fields with creation a new one"
1191                         print ""
1192                         name = fielddoublemul.getName()
1193                         desc = fielddoublemul.getDescription()
1194                         nbOfComp = fielddoublemul.getNumberOfComponents()
1195                         print "     Field",name," : ",desc
1196                         print "     Number Of Components:",nbOfComp
1197                         iterationNb = fielddoublemul.getIterationNumber()
1198                         orderNb = fielddoublemul.getOrderNumber()
1199                         time = fielddoublemul.getTime()
1200                         print "     Iteration Number",iterationNb
1201                         print "     Order Number",orderNb
1202                         print "     Time",time
1203                         for k in range(nbOfComp):
1204                             kp1 = k+1
1205                             compName = fielddoublemul.getComponentName(kp1)
1206                             compDesc = fielddoublemul.getComponentDescription(kp1)
1207                             compUnit = fielddoublemul.getMEDComponentUnit(kp1)
1208                             print "      * Component:",kp1
1209                             print "          Name:",compName
1210                             print "          Description:",compDesc
1211                             print "          Unit:",compUnit
1212
1213                         support = fielddoublemul.getSupport()
1214                         nbOf = support.getNumberOfElements(MED_ALL_ELEMENTS)
1215                         print "     Values:",nbOf
1216                         for k in range(nbOf):
1217                             valueI = fielddoublemul.getRow(k+1)
1218                             print "     *",valueI[:nbOfComp]
1219                         print ""
1220                         try:
1221                             fielddoublediv = fielddouble / fielddouble2
1222                             print "Test of the division of two double fields with creation a new one"
1223                             print ""
1224                             name = fielddoublediv.getName()
1225                             desc = fielddoublediv.getDescription()
1226                             nbOfComp = fielddoublediv.getNumberOfComponents()
1227                             print "     Field",name," : ",desc
1228                             print "     Number Of Components:",nbOfComp
1229                             iterationNb = fielddoublediv.getIterationNumber()
1230                             orderNb = fielddoublediv.getOrderNumber()
1231                             time = fielddoublediv.getTime()
1232                             print "     Iteration Number",iterationNb
1233                             print "     Order Number",orderNb
1234                             print "     Time",time
1235                             for k in range(nbOfComp):
1236                                 kp1 = k+1
1237                                 compName = fielddoublediv.getComponentName(kp1)
1238                                 compDesc = fielddoublediv.getComponentDescription(kp1)
1239                                 compUnit = fielddoublediv.getMEDComponentUnit(kp1)
1240                                 print "      * Component:",kp1
1241                                 print "          Name:",compName
1242                                 print "          Description:",compDesc
1243                                 print "          Unit:",compUnit
1244
1245                             support = fielddoublediv.getSupport()
1246                             nbOf = support.getNumberOfElements(MED_ALL_ELEMENTS)
1247                             print "     Values:",nbOf
1248                             for k in range(nbOf):
1249                                 valueI = fielddoublediv.getRow(k+1)
1250                                 print "     *",valueI[:nbOfComp]
1251                         except:
1252                             print "testMedMemGeneral  fielddoublediv = fielddouble / fielddouble2 catch/except error"
1253
1254                         print ""
1255                         print "TESTS OPERATIONS SUR FIELDDOUBLE : "
1256                         fielddoublesub = fielddouble-fielddouble2
1257                         fielddoublemul = fielddouble*fielddouble2
1258                         try:
1259                             fielddoublediv = fielddouble/fielddouble2
1260                         except:
1261                             print "testMedMemGeneral    /=    : catch/except error"
1262                             fielddoublediv = None
1263                         fielddoubleasso = fielddouble+fielddouble2*fielddouble2
1264                         fielddoubleSP=createFieldDoubleScalarProduct(fielddouble, fielddouble2)
1265                         print " f1     : ",fielddouble.getValue()
1266                         print " f2     : ",fielddouble2.getValue()
1267                         print "--------------------------------------------------------------------------------------------------------------"
1268                         print "  +     : ",fielddoubleadd.getValue()
1269                         print "  -     : ",fielddoublesub.getValue()
1270                         print "  *     : ",fielddoublemul.getValue()
1271                         if fielddoublediv != None:
1272                             print "  /     : ",fielddoublediv.getValue()
1273                             pass
1274                         fielddouble+=fielddouble2;
1275                         print "  +=    : ",fielddouble.getValue()
1276                         fielddouble-=fielddouble2;
1277                         print "  -=    : ",fielddouble.getValue()
1278                         fielddouble*=fielddouble2;
1279                         print "  *=    : ",fielddouble.getValue()
1280                         try:
1281                             fielddouble/=fielddouble2;
1282                             print "  /=    : ",fielddouble.getValue()
1283                         except:
1284                             print "testMedMemGeneral   /=    : "
1285                         print "f1+f2*f2: ",fielddoubleasso.getValue()
1286                         fielddouble.applyLin(4,1);
1287                         print " 4f1+1  : ",fielddouble.getValue()
1288                         print " f1.f2  : ",fielddoubleSP.getValue()
1289                         fielddouble2.applyPyFunc(add_one)
1290                         print " CB:f2+1: ",fielddouble2.getValue()
1291                     else:
1292                         print "  !!!! Bad type of Field !!!!"
1293
1294 print "END of the Pyhton script ..... Ctrl D to exit"