src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx

   1 //
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //
  23 //
  24 //  File   :
  25 //  Author :
  26 //  Module :
  27 //  $Header$
  28
  29 #include "MED_V2_2_Wrapper.hxx"
  30 #include "MED_Algorithm.hxx"
  31 #include "MED_Utilities.hxx"
  32
  33
  34
  35 //#include <med.h>
  36 //using namespace med_2_2;
  37
  38 extern "C"
  39 {
  40 #include <med.h>
  41
  42 med_err
  43 MEDgaussInfo(med_idt fid, int indice, char * locname, med_geometrie_element * type_geo,
  44              med_int * ngauss );
  45
  46 med_int
  47 MEDnMaa(med_idt fid);
  48
  49 }
  50
  51 #ifdef _DEBUG_
  52 static int MYDEBUG = 0;
  53 #else
  54 static int MYDEBUG = 0;
  55 #endif
  56
  57
  58
  59 namespace MED
  60 {
  61   template<>
  62   TInt
  63   GetDESCLength<eV2_2>()
  64   {
  65     return 200;
  66   }
  67
  68   template<>
  69   TInt
  70   GetIDENTLength<eV2_2>()
  71   {
  72     return 8;
  73   }
  74
  75   template<>
  76   TInt
  77   GetNOMLength<eV2_2>()
  78   {
  79     return 32;
  80   }
  81
  82   template<>
  83   TInt
  84   GetLNOMLength<eV2_2>()
  85   {
  86     return 80;
  87   }
  88
  89   template<>
  90   TInt
  91   GetPNOMLength<eV2_2>()
  92   {
  93     return 16;
  94   }
  95
  96   template<>
  97   void
  98   GetVersionRelease<eV2_2>(TInt& majeur, TInt& mineur, TInt& release)
  99   {
 100     MEDversionDonner(&majeur, &mineur, &release);
 101   }
 102
 103   template<>
 104   TInt
 105   GetNbConn<eV2_2>(EGeometrieElement typmai,
 106                    EEntiteMaillage typent,
 107                    TInt mdim)
 108   {
 109     return typmai%100;
 110   }
 111
 112   namespace V2_2
 113   {
 114
 115     //---------------------------------------------------------------
 116     class TFile{
 117       TFile();
 118       TFile(const TFile&);
 119
 120     public:
 121       TFile(const std::string& theFileName):
 122         myFid(0),
 123         myCount(0),
 124         myFileName(theFileName)
 125       {}
 126
 127       ~TFile()
 128       {
 129         Close();
 130       }
 131
 132       void
 133       Open(EModeAcces theMode, TErr* theErr = NULL)
 134       {
 135         if(myCount++ == 0){
 136           char* aFileName = const_cast<char*>(myFileName.c_str());
 137           myFid = MEDouvrir(aFileName,med_mode_acces(theMode));
 138         }
 139         if(theErr)
 140           *theErr = TErr(myFid);
 141         else if(myFid < 0)
 142           EXCEPTION(std::runtime_error,"TFile - MEDouvrir('"<<myFileName<<"',"<<theMode<<")");
 143       }
 144
 145       const TIdt& Id() const
 146       {
 147         if(myFid < 0)
 148           EXCEPTION(std::runtime_error,"TFile - GetFid() < 0");
 149         return myFid;
 150       }
 151
 152       void Close()
 153       {
 154         if(--myCount == 0)
 155           MEDfermer(myFid);
 156       }
 157
 158     protected:
 159       std::string myFileName;
 160       TInt myCount;
 161       TIdt myFid;
 162     };
 163
 164
 165     //---------------------------------------------------------------
 166     class TFileWrapper
 167     {
 168       PFile myFile;
 169
 170     public:
 171       TFileWrapper(const PFile& theFile, EModeAcces theMode, TErr* theErr = NULL):
 172         myFile(theFile)
 173       {
 174         myFile->Open(theMode,theErr);
 175       }
 176
 177       ~TFileWrapper()
 178       {
 179         myFile->Close();
 180       }
 181     };
 182
 183
 184     //---------------------------------------------------------------
 185     TVWrapper::TVWrapper(const std::string& theFileName):
 186       myFile(new TFile(theFileName))
 187     {}
 188
 189
 190     //----------------------------------------------------------------------------
 191     TInt
 192     TVWrapper
 193     ::GetNbMeshes(TErr* theErr)
 194     {
 195       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 196
 197       if(theErr && *theErr < 0)
 198         return -1;
 199
 200       return MEDnMaa(myFile->Id());
 201     }
 202
 203
 204     //----------------------------------------------------------------------------
 205     void
 206     TVWrapper
 207     ::GetMeshInfo(TInt theMeshId,
 208                   MED::TMeshInfo& theInfo,
 209                   TErr* theErr)
 210     {
 211       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 212
 213       if(theErr && *theErr < 0)
 214         return;
 215
 216       TValueHolder<TString, char> aMeshName(theInfo.myName);
 217       TValueHolder<TInt, med_int> aDim(theInfo.myDim);
 218       TValueHolder<EMaillage, med_maillage> aType(theInfo.myType);
 219
 220       TErr aRet = MEDmaaInfo(myFile->Id(),
 221                              theMeshId,
 222                              &aMeshName,
 223                              &aDim,
 224                              &aType,
 225                              &theInfo.myDesc[0]);
 226       if(theErr)
 227         *theErr = aRet;
 228       else if(aRet < 0)
 229         EXCEPTION(std::runtime_error,"GetMeshInfo - MEDmaaInfo(...)");
 230     }
 231
 232
 233     //----------------------------------------------------------------------------
 234     void
 235     TVWrapper
 236     ::SetMeshInfo(const MED::TMeshInfo& theInfo,
 237                   EModeAcces theMode,
 238                   TErr* theErr)
 239     {
 240       TFileWrapper aFileWrapper(myFile,theMode,theErr);
 241
 242       if(theErr && *theErr < 0)
 243         return;
 244
 245       MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
 246
 247       TValueHolder<TString, char> aMeshName(anInfo.myName);
 248       TValueHolder<TInt, med_int> aDim(anInfo.myDim);
 249       TValueHolder<EMaillage, med_maillage> aType(anInfo.myType);
 250       TValueHolder<TString, char> aDesc(anInfo.myDesc);
 251
 252       TErr aRet = MEDmaaCr(myFile->Id(),
 253                            &aMeshName,
 254                            aDim,
 255                            aType,
 256                            &aDesc);
 257       if(aRet == 0){
 258         aRet = MEDunvCr(myFile->Id(),
 259                         &aMeshName);
 260       }
 261
 262       INITMSG(MYDEBUG,"TVWrapper::SetMeshInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
 263
 264       if(theErr)
 265         *theErr = aRet;
 266       else if(aRet < 0)
 267         EXCEPTION(std::runtime_error,"SetMeshInfo - MEDmaaCr(...)");
 268     }
 269
 270
 271     //----------------------------------------------------------------------------
 272     void
 273     TVWrapper
 274     ::SetMeshInfo(const MED::TMeshInfo& theInfo,
 275                   TErr* theErr)
 276     {
 277       TErr aRet;
 278       SetMeshInfo(theInfo,eLECTURE_ECRITURE,&aRet);
 279
 280       if(aRet < 0)
 281         SetMeshInfo(theInfo,eLECTURE_AJOUT,&aRet);
 282
 283       if(aRet < 0)
 284         SetMeshInfo(theInfo,eCREATION,&aRet);
 285
 286       if(theErr)
 287         *theErr = aRet;
 288     }
 289
 290
 291     //----------------------------------------------------------------------------
 292     TInt
 293     TVWrapper
 294     ::GetNbFamilies(const MED::TMeshInfo& theInfo,
 295                     TErr* theErr)
 296     {
 297       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 298
 299       if(theErr && *theErr < 0)
 300         return -1;
 301
 302       MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
 303       TValueHolder<TString, char> aName(anInfo.myName);
 304       return MEDnFam(myFile->Id(),
 305                      &aName);
 306     }
 307
 308
 309     //----------------------------------------------------------------------------
 310     TInt
 311     TVWrapper
 312     ::GetNbFamAttr(TInt theFamId,
 313                    const MED::TMeshInfo& theInfo,
 314                    TErr* theErr)
 315     {
 316       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 317
 318       if(theErr && *theErr < 0)
 319         return -1;
 320
 321       MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
 322
 323       TValueHolder<TString, char> aName(anInfo.myName);
 324
 325       return MEDnAttribut(myFile->Id(),
 326                           &aName,
 327                           theFamId);
 328     }
 329
 330
 331     //----------------------------------------------------------------------------
 332     TInt
 333     TVWrapper
 334     ::GetNbFamGroup(TInt theFamId,
 335                     const MED::TMeshInfo& theInfo,
 336                     TErr* theErr)
 337     {
 338       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 339
 340       if(theErr && *theErr < 0)
 341         return -1;
 342
 343       MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
 344
 345       TValueHolder<TString, char> aName(anInfo.myName);
 346
 347       return MEDnGroupe(myFile->Id(),
 348                         &aName,
 349                         theFamId);
 350     }
 351
 352
 353     //----------------------------------------------------------------------------
 354     void
 355     TVWrapper
 356     ::GetFamilyInfo(TInt theFamId,
 357                     MED::TFamilyInfo& theInfo,
 358                     TErr* theErr)
 359     {
 360       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 361
 362       if(theErr && *theErr < 0)
 363         return;
 364
 365       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
 366
 367       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 368       TValueHolder<TString, char> aFamilyName(theInfo.myName);
 369       TValueHolder<TInt, med_int> aFamilyId(theInfo.myId);
 370       TValueHolder<TFamAttr, med_int> anAttrId(theInfo.myAttrId);
 371       TValueHolder<TFamAttr, med_int> anAttrVal(theInfo.myAttrVal);
 372       TValueHolder<TInt, med_int> aNbAttr(theInfo.myNbAttr);
 373       TValueHolder<TString, char> anAttrDesc(theInfo.myAttrDesc);
 374       TValueHolder<TInt, med_int> aNbGroup(theInfo.myNbGroup);
 375       TValueHolder<TString, char> aGroupNames(theInfo.myGroupNames);
 376
 377       TErr aRet = MEDfamInfo(myFile->Id(),
 378                              &aMeshName,
 379                              theFamId,
 380                              &aFamilyName,
 381                              &aFamilyId,
 382                              &anAttrId,
 383                              &anAttrVal,
 384                              &anAttrDesc,
 385                              &aNbAttr,
 386                              &aGroupNames,
 387                              &aNbGroup);
 388
 389       if(theErr)
 390         *theErr = aRet;
 391       else if(aRet < 0)
 392         EXCEPTION(std::runtime_error,"GetFamilyInfo - MEDfamInfo(...) - "<<
 393                   " aMeshInfo.myName = '"<<&aMeshName<<
 394                   "'; theFamId = "<<theFamId<<
 395                   "; theInfo.myNbGroup = "<<aNbGroup()<<
 396                   "; theInfo.myNbAttr = "<<aNbAttr());
 397     }
 398
 399
 400     //----------------------------------------------------------------------------
 401     void
 402     TVWrapper
 403     ::SetFamilyInfo(const MED::TFamilyInfo& theInfo,
 404                     EModeAcces theMode,
 405                     TErr* theErr)
 406     {
 407       TFileWrapper aFileWrapper(myFile,theMode,theErr);
 408
 409       if(theErr && *theErr < 0)
 410         return;
 411
 412       MED::TFamilyInfo& anInfo = const_cast<MED::TFamilyInfo&>(theInfo);
 413       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
 414
 415       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 416       TValueHolder<TString, char> aFamilyName(anInfo.myName);
 417       TValueHolder<TInt, med_int> aFamilyId(anInfo.myId);
 418       TValueHolder<TFamAttr, med_int> anAttrId(anInfo.myAttrId);
 419       TValueHolder<TFamAttr, med_int> anAttrVal(anInfo.myAttrVal);
 420       TValueHolder<TInt, med_int> aNbAttr(anInfo.myNbAttr);
 421       TValueHolder<TString, char> anAttrDesc(anInfo.myAttrDesc);
 422       TValueHolder<TInt, med_int> aNbGroup(anInfo.myNbGroup);
 423       TValueHolder<TString, char> aGroupNames(anInfo.myGroupNames);
 424
 425       TErr aRet = MEDfamCr(myFile->Id(),
 426                            &aMeshName,
 427                            &aFamilyName,
 428                            aFamilyId,
 429                            &anAttrId,
 430                            &anAttrVal,
 431                            &anAttrDesc,
 432                            aNbAttr,
 433                            &aGroupNames,
 434                            aNbGroup);
 435
 436       INITMSG(MYDEBUG,"TVWrapper::GetFamilyInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
 437
 438       if(theErr)
 439         *theErr = aRet;
 440       else if(aRet < 0)
 441         EXCEPTION(std::runtime_error,"SetFamilyInfo - MEDfamCr(...)");
 442     }
 443
 444
 445     //----------------------------------------------------------------------------
 446     void
 447     TVWrapper
 448     ::SetFamilyInfo(const MED::TFamilyInfo& theInfo,
 449                     TErr* theErr)
 450     {
 451       TErr aRet;
 452       SetFamilyInfo(theInfo,eLECTURE_ECRITURE,&aRet);
 453
 454       if(aRet < 0)
 455         SetFamilyInfo(theInfo,eLECTURE_AJOUT,&aRet);
 456
 457       if(theErr)
 458         *theErr = aRet;
 459     }
 460
 461     //----------------------------------------------------------------------------
 462     void
 463     TVWrapper
 464     ::GetNames(TElemInfo& theInfo,
 465                TInt theNb,
 466                EEntiteMaillage theEntity,
 467                EGeometrieElement theGeom,
 468                TErr* theErr)
 469     {
 470       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 471
 472       if(theErr && *theErr < 0)
 473         return;
 474
 475       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
 476
 477       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 478       TValueHolder<TString, char> anElemNames(theInfo.myElemNames);
 479       TValueHolder<EEntiteMaillage, med_entite_maillage> anEntity(theEntity);
 480       TValueHolder<EGeometrieElement, med_geometrie_element> aGeom(theGeom);
 481
 482       TErr aRet = MEDnomLire(myFile->Id(),
 483                              &aMeshName,
 484                              &anElemNames,
 485                              theNb,
 486                              anEntity,
 487                              aGeom);
 488
 489       theInfo.myIsElemNames = aRet != 0? eFAUX : eVRAI ;
 490
 491       if(theErr)
 492         *theErr = aRet;
 493     }
 494
 495     //----------------------------------------------------------------------------
 496     void
 497     TVWrapper
 498     ::GetNumeration(TElemInfo& theInfo,
 499                     TInt theNb,
 500                     EEntiteMaillage theEntity,
 501                     EGeometrieElement theGeom,
 502                     TErr* theErr)
 503     {
 504       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 505
 506       if(theErr && *theErr < 0)
 507         return;
 508
 509       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
 510
 511       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 512       TValueHolder<TElemNum, med_int> anElemNum(theInfo.myElemNum);
 513       TValueHolder<EEntiteMaillage, med_entite_maillage> anEntity(theEntity);
 514       TValueHolder<EGeometrieElement, med_geometrie_element> aGeom(theGeom);
 515
 516       TErr aRet = MEDnumLire(myFile->Id(),
 517                              &aMeshName,
 518                              &anElemNum,
 519                              theNb,
 520                              anEntity,
 521                              aGeom);
 522
 523       theInfo.myIsElemNum = aRet != 0? eFAUX : eVRAI;
 524
 525       if(theErr)
 526         *theErr = aRet;
 527     }
 528
 529     //----------------------------------------------------------------------------
 530     void
 531     TVWrapper
 532     ::GetFamilies(TElemInfo& theInfo,
 533                   TInt theNb,
 534                   EEntiteMaillage theEntity,
 535                   EGeometrieElement theGeom,
 536                   TErr* theErr)
 537     {
 538       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 539
 540       if(theErr && *theErr < 0)
 541         return;
 542
 543       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
 544
 545       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 546       TValueHolder<TElemNum, med_int> aFamNum(theInfo.myFamNum);
 547       TValueHolder<EEntiteMaillage, med_entite_maillage> anEntity(theEntity);
 548       TValueHolder<EGeometrieElement, med_geometrie_element> aGeom(theGeom);
 549
 550       TErr aRet = MEDfamLire(myFile->Id(),
 551                              &aMeshName,
 552                              &aFamNum,
 553                              theNb,
 554                              anEntity,
 555                              aGeom);
 556
 557       if(theErr)
 558         *theErr = aRet;
 559       else if(aRet < 0)
 560         EXCEPTION(std::runtime_error,"GetFamilies - MEDfamLire(...)");
 561     }
 562
 563
 564     //----------------------------------------------------------------------------
 565     void
 566     TVWrapper
 567     ::SetNames(const TElemInfo& theInfo,
 568                EEntiteMaillage theEntity,
 569                EGeometrieElement theGeom,
 570                TErr* theErr)
 571     {
 572       SetNames(theInfo,eLECTURE_ECRITURE,theEntity,theGeom,theErr);
 573     }
 574
 575
 576     //----------------------------------------------------------------------------
 577     void
 578     TVWrapper
 579     ::SetNames(const TElemInfo& theInfo,
 580                EModeAcces theMode,
 581                EEntiteMaillage theEntity,
 582                EGeometrieElement theGeom,
 583                TErr* theErr)
 584     {
 585       TFileWrapper aFileWrapper(myFile,theMode,theErr);
 586
 587       if(theErr && *theErr < 0)
 588         return;
 589
 590       MED::TElemInfo& anInfo = const_cast<MED::TElemInfo&>(theInfo);
 591       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
 592
 593       TErr aRet = 0;
 594       if(theInfo.myIsElemNames){
 595         TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 596         TValueHolder<TString, char> anElemNames(anInfo.myElemNames);
 597         TValueHolder<EEntiteMaillage, med_entite_maillage> anEntity(theEntity);
 598         TValueHolder<EGeometrieElement, med_geometrie_element> aGeom(theGeom);
 599
 600         aRet  = MEDnomEcr(myFile->Id(),
 601                           &aMeshName,
 602                           &anElemNames,
 603                           (TInt)anInfo.myElemNames->size(),
 604                           anEntity,
 605                           aGeom);
 606         if(theErr)
 607           *theErr = aRet;
 608         else if(aRet < 0)
 609           EXCEPTION(std::runtime_error,"SetNames - MEDnomEcr(...)");
 610       }
 611     }
 612
 613
 614     //----------------------------------------------------------------------------
 615     void
 616     TVWrapper
 617     ::SetNumeration(const TElemInfo& theInfo,
 618                     EEntiteMaillage theEntity,
 619                     EGeometrieElement theGeom,
 620                     TErr* theErr)
 621     {
 622       SetNumeration(theInfo,eLECTURE_ECRITURE,theEntity,theGeom,theErr);
 623     }
 624
 625
 626     //----------------------------------------------------------------------------
 627     void
 628     TVWrapper
 629     ::SetNumeration(const TElemInfo& theInfo,
 630                     EModeAcces theMode,
 631                     EEntiteMaillage theEntity,
 632                     EGeometrieElement theGeom,
 633                     TErr* theErr)
 634     {
 635       TFileWrapper aFileWrapper(myFile,theMode,theErr);
 636
 637       if(theErr && *theErr < 0)
 638         return;
 639
 640       MED::TElemInfo& anInfo = const_cast<MED::TElemInfo&>(theInfo);
 641       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
 642
 643       TErr aRet = 0;
 644       if(theInfo.myIsElemNum){
 645         TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 646         TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
 647         TValueHolder<EEntiteMaillage, med_entite_maillage> anEntity(theEntity);
 648         TValueHolder<EGeometrieElement, med_geometrie_element> aGeom(theGeom);
 649
 650         aRet  = MEDnumEcr(myFile->Id(),
 651                           &aMeshName,
 652                           &anElemNum,
 653                           (TInt)anInfo.myElemNum->size(),
 654                           anEntity,
 655                           aGeom);
 656         if(theErr)
 657           *theErr = aRet;
 658         else if(aRet < 0)
 659           EXCEPTION(std::runtime_error,"SetNumeration - MEDnumEcr(...)");
 660       }
 661     }
 662
 663     //----------------------------------------------------------------------------
 664     void
 665     TVWrapper
 666     ::SetFamilies(const TElemInfo& theInfo,
 667                   EEntiteMaillage theEntity,
 668                   EGeometrieElement theGeom,
 669                   TErr* theErr)
 670     {
 671       SetFamilies(theInfo,eLECTURE_ECRITURE,theEntity,theGeom,theErr);
 672     }
 673
 674     //----------------------------------------------------------------------------
 675     void
 676     TVWrapper
 677     ::SetFamilies(const TElemInfo& theInfo,
 678                   EModeAcces theMode,
 679                   EEntiteMaillage theEntity,
 680                   EGeometrieElement theGeom,
 681                   TErr* theErr)
 682     {
 683       TFileWrapper aFileWrapper(myFile,theMode,theErr);
 684
 685       if(theErr && *theErr < 0)
 686         return;
 687
 688       MED::TElemInfo& anInfo = const_cast<MED::TElemInfo&>(theInfo);
 689       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
 690
 691       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 692       TValueHolder<TElemNum, med_int> aFamNum(anInfo.myFamNum);
 693       TValueHolder<EEntiteMaillage, med_entite_maillage> anEntity(theEntity);
 694       TValueHolder<EGeometrieElement, med_geometrie_element> aGeom(theGeom);
 695
 696       TErr aRet = MEDfamEcr(myFile->Id(),
 697                             &aMeshName,
 698                             &aFamNum,
 699                             (TInt)anInfo.myFamNum->size(),
 700                             anEntity,
 701                             aGeom);
 702
 703       if(theErr)
 704         *theErr = aRet;
 705       else if(aRet < 0)
 706         EXCEPTION(std::runtime_error,"SetFamilies - MEDfamEcr(...)");
 707     }
 708
 709     //----------------------------------------------------------------------------
 710     TInt
 711     TVWrapper
 712     ::GetNbNodes(const MED::TMeshInfo& theMeshInfo,
 713                  ETable theTable,
 714                  TErr* theErr)
 715     {
 716       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 717
 718       if(theErr && *theErr < 0)
 719         return -1;
 720
 721       MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
 722
 723       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 724       TValueHolder<ETable, med_table> aTable(theTable);
 725
 726       return MEDnEntMaa(myFile->Id(),
 727                         &aMeshName,
 728                         aTable,
 729                         MED_NOEUD,
 730                         med_geometrie_element(0),
 731                         med_connectivite(0));
 732     }
 733
 734
 735     //----------------------------------------------------------------------------
 736     void
 737     TVWrapper
 738     ::GetNodeInfo(MED::TNodeInfo& theInfo,
 739                   TErr* theErr)
 740     {
 741       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 742
 743       if(theErr && *theErr < 0)
 744         return;
 745
 746       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
 747
 748       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 749       TValueHolder<TInt, med_int> aDim(aMeshInfo.myDim);
 750       TValueHolder<TNodeCoord, med_float> aCoord(theInfo.myCoord);
 751       TValueHolder<EModeSwitch, med_mode_switch> aModeSwitch(theInfo.myModeSwitch);
 752       TValueHolder<ERepere, med_repere> aSystem(theInfo.mySystem);
 753       TValueHolder<TString, char> aCoordNames(theInfo.myCoordNames);
 754       TValueHolder<TString, char> aCoordUnits(theInfo.myCoordUnits);
 755       TValueHolder<TString, char> anElemNames(theInfo.myElemNames);
 756       TValueHolder<EBooleen, med_booleen> anIsElemNames(theInfo.myIsElemNames);
 757       TValueHolder<TElemNum, med_int> anElemNum(theInfo.myElemNum);
 758       TValueHolder<EBooleen, med_booleen> anIsElemNum(theInfo.myIsElemNum);
 759       TValueHolder<TElemNum, med_int> aFamNum(theInfo.myFamNum);
 760       TValueHolder<TInt, med_int> aNbElem(theInfo.myNbElem);
 761
 762       TErr aRet = MEDnoeudsLire(myFile->Id(),
 763                                 &aMeshName,
 764                                 aDim,
 765                                 &aCoord,
 766                                 aModeSwitch,
 767                                 &aSystem,
 768                                 &aCoordNames,
 769                                 &aCoordUnits,
 770                                 &anElemNames,
 771                                 &anIsElemNames,
 772                                 &anElemNum,
 773                                 &anIsElemNum,
 774                                 &aFamNum,
 775                                 aNbElem);
 776       if(theErr)
 777         *theErr = aRet;
 778       else if(aRet < 0)
 779         EXCEPTION(std::runtime_error,"GetNodeInfo - MEDnoeudsLire(...)");
 780     }
 781
 782
 783     //----------------------------------------------------------------------------
 784     void
 785     TVWrapper
 786     ::SetNodeInfo(const MED::TNodeInfo& theInfo,
 787                   EModeAcces theMode,
 788                   TErr* theErr)
 789     {
 790       TFileWrapper aFileWrapper(myFile,theMode,theErr);
 791
 792       if(theErr && *theErr < 0)
 793         return;
 794
 795       MED::TNodeInfo& anInfo = const_cast<MED::TNodeInfo&>(theInfo);
 796       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
 797
 798       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 799       TValueHolder<TInt, med_int> aDim(aMeshInfo.myDim);
 800       TValueHolder<TNodeCoord, med_float> aCoord(anInfo.myCoord);
 801       TValueHolder<EModeSwitch, med_mode_switch> aModeSwitch(anInfo.myModeSwitch);
 802       TValueHolder<ERepere, med_repere> aSystem(anInfo.mySystem);
 803       TValueHolder<TString, char> aCoordNames(anInfo.myCoordNames);
 804       TValueHolder<TString, char> aCoordUnits(anInfo.myCoordUnits);
 805       TValueHolder<TString, char> anElemNames(anInfo.myElemNames);
 806       TValueHolder<EBooleen, med_booleen> anIsElemNames(anInfo.myIsElemNames);
 807       TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
 808       TValueHolder<EBooleen, med_booleen> anIsElemNum(anInfo.myIsElemNum);
 809       TValueHolder<TElemNum, med_int> aFamNum(anInfo.myFamNum);
 810       TValueHolder<TInt, med_int> aNbElem(anInfo.myNbElem);
 811
 812       TErr aRet = MEDnoeudsEcr(myFile->Id(),
 813                                &aMeshName,
 814                                aDim,
 815                                &aCoord,
 816                                aModeSwitch,
 817                                aSystem,
 818                                &aCoordNames,
 819                                &aCoordUnits,
 820                                &anElemNames,
 821                                anIsElemNames,
 822                                &anElemNum,
 823                                anIsElemNum,
 824                                &aFamNum,
 825                                aNbElem);
 826       if(theErr)
 827         *theErr = aRet;
 828       else if(aRet < 0)
 829         EXCEPTION(std::runtime_error,"SetNodeInfo - MEDnoeudsEcr(...)");
 830     }
 831
 832
 833     //----------------------------------------------------------------------------
 834     void
 835     TVWrapper
 836     ::SetNodeInfo(const MED::TNodeInfo& theInfo,
 837                   TErr* theErr)
 838     {
 839       TErr aRet;
 840       SetNodeInfo(theInfo,eLECTURE_ECRITURE,&aRet);
 841
 842       if(aRet < 0)
 843         SetNodeInfo(theInfo,eLECTURE_AJOUT,&aRet);
 844
 845       if(theErr)
 846         *theErr = aRet;
 847     }
 848
 849
 850     //-----------------------------------------------------------------
 851     void
 852     TVWrapper
 853     ::GetPolygoneInfo(MED::TPolygoneInfo& theInfo,
 854                       TErr* theErr)
 855     {
 856       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 857
 858       if(theErr && *theErr < 0)
 859         return;
 860
 861       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
 862
 863       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 864       TValueHolder<TElemNum, med_int> anIndex(theInfo.myIndex);
 865       TInt aNbElem = (TInt)theInfo.myElemNum->size();
 866       TValueHolder<TElemNum, med_int> aConn(theInfo.myConn);
 867       TValueHolder<EEntiteMaillage, med_entite_maillage> anEntity(theInfo.myEntity);
 868       TValueHolder<EConnectivite, med_connectivite> aConnMode(theInfo.myConnMode);
 869
 870       TErr aRet;
 871       aRet = MEDpolygoneConnLire(myFile->Id(),
 872                                  &aMeshName,
 873                                  &anIndex,
 874                                  aNbElem+1,
 875                                  &aConn,
 876                                  anEntity,
 877                                  aConnMode);
 878
 879       if(theErr)
 880         *theErr = aRet;
 881       else if(aRet < 0)
 882         EXCEPTION(std::runtime_error,"GetPolygoneInfo - MEDpolygoneInfo(...)");
 883
 884       if(theInfo.myIsElemNames){
 885         GetNames(theInfo,aNbElem,theInfo.myEntity,ePOLYGONE,&aRet);
 886         if(theErr)
 887           *theErr = aRet;
 888       }
 889
 890       if(theInfo.myIsElemNum){
 891         GetNumeration(theInfo,aNbElem,theInfo.myEntity,ePOLYGONE,&aRet);
 892         if(theErr)
 893           *theErr = aRet;
 894       }
 895
 896       GetFamilies(theInfo,aNbElem,theInfo.myEntity,ePOLYGONE,&aRet);
 897       if(theErr)
 898         *theErr = aRet;
 899     }
 900
 901     //----------------------------------------------------------------------------
 902     void
 903     TVWrapper
 904     ::SetPolygoneInfo(const MED::TPolygoneInfo& theInfo,
 905                       TErr* theErr)
 906     {
 907       SetPolygoneInfo(theInfo,eLECTURE_ECRITURE,theErr);
 908     }
 909
 910     //----------------------------------------------------------------------------
 911     void
 912     TVWrapper
 913     ::SetPolygoneInfo(const MED::TPolygoneInfo& theInfo,
 914                       EModeAcces theMode,
 915                       TErr* theErr)
 916     {
 917       TFileWrapper aFileWrapper(myFile,theMode,theErr);
 918
 919       if(theErr && *theErr < 0)
 920         return;
 921
 922       MED::TPolygoneInfo& anInfo = const_cast<MED::TPolygoneInfo&>(theInfo);
 923       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
 924
 925       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 926       TValueHolder<TElemNum, med_int> anIndex(anInfo.myIndex);
 927       TValueHolder<TElemNum, med_int> aConn(anInfo.myConn);
 928       TValueHolder<EEntiteMaillage, med_entite_maillage> anEntity(anInfo.myEntity);
 929       TValueHolder<EConnectivite, med_connectivite> aConnMode(anInfo.myConnMode);
 930
 931       TErr aRet = MEDpolygoneConnEcr(myFile->Id(),
 932                                      &aMeshName,
 933                                      &anIndex,
 934                                      anInfo.myNbElem + 1,
 935                                      &aConn,
 936                                      anEntity,
 937                                      aConnMode);
 938
 939       if(theErr)
 940         *theErr = aRet;
 941       else if(aRet < 0)
 942         EXCEPTION(std::runtime_error,"SetPolygoneInfo - MEDpolygoneConnEcr(...)");
 943
 944       SetNames(anInfo,theInfo.myEntity,ePOLYGONE,&aRet);
 945       if(theErr)
 946         *theErr = aRet;
 947
 948       SetNumeration(anInfo,theInfo.myEntity,ePOLYGONE,&aRet);
 949       if(theErr)
 950         *theErr = aRet;
 951
 952       SetFamilies(anInfo,theInfo.myEntity,ePOLYGONE,&aRet);
 953       if(theErr)
 954         *theErr = aRet;
 955     }
 956
 957     //----------------------------------------------------------------------------
 958     TInt
 959     TVWrapper
 960     ::GetNbPolygones(const MED::TMeshInfo& theMeshInfo,
 961                      EEntiteMaillage theEntity,
 962                      EGeometrieElement theGeom,
 963                      EConnectivite theConnMode,
 964                      TErr* theErr)
 965     {
 966       return GetNbCells(theMeshInfo,theEntity,theGeom,theConnMode,theErr);
 967     }
 968
 969     //----------------------------------------------------------------------------
 970     TInt
 971     TVWrapper
 972     ::GetPolygoneConnSize(const MED::TMeshInfo& theMeshInfo,
 973                           EEntiteMaillage theEntity,
 974                           EGeometrieElement theGeom,
 975                           EConnectivite theConnMode,
 976                           TErr* theErr)
 977     {
 978       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 979
 980       if(theErr && *theErr < 0)
 981         return 0;
 982
 983       MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
 984
 985       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 986       med_int aTaille = 0;
 987
 988       TErr aRet;
 989       aRet = MEDpolygoneInfo(myFile->Id(),
 990                              &aMeshName,
 991                              med_entite_maillage(theEntity),
 992                              med_connectivite(theConnMode),
 993                              &aTaille);
 994
 995       if(theErr)
 996         *theErr = aRet;
 997       else if(aRet < 0)
 998         EXCEPTION(std::runtime_error,"GetPolygoneInfo - MEDpolygoneInfo(...)");
 999
1000       return TInt(aTaille);
1001     }
1002
1003     //-----------------------------------------------------------------
1004     void
1005     TVWrapper
1006     ::GetPolyedreInfo(TPolyedreInfo& theInfo,
1007                       TErr* theErr)
1008     {
1009       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1010
1011       if(theErr && *theErr < 0)
1012         return;
1013
1014       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
1015
1016       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1017       TInt aNbElem = (TInt)theInfo.myElemNum->size();
1018       TValueHolder<TElemNum, med_int> anIndex(theInfo.myIndex);
1019       TValueHolder<TElemNum, med_int> aFaces(theInfo.myFaces);
1020       TValueHolder<TElemNum, med_int> aConn(theInfo.myConn);
1021       TValueHolder<EConnectivite, med_connectivite> aConnMode(theInfo.myConnMode);
1022
1023       TErr aRet;
1024       aRet = MEDpolyedreConnLire(myFile->Id(),
1025                                  &aMeshName,
1026                                  &anIndex,
1027                                  aNbElem + 1,
1028                                  &aFaces,
1029                                  (TInt)theInfo.myFaces->size(),
1030                                  &aConn,
1031                                  aConnMode);
1032
1033       if(theErr)
1034         *theErr = aRet;
1035       else if(aRet < 0)
1036         EXCEPTION(std::runtime_error,"GetPolygoneInfo - MEDpolyedreConnLire(...)");
1037
1038       if(theInfo.myIsElemNames){
1039         GetNames(theInfo,aNbElem,theInfo.myEntity,ePOLYEDRE,&aRet);
1040         if(theErr)
1041           *theErr = aRet;
1042       }
1043
1044       if(theInfo.myIsElemNum){
1045         GetNumeration(theInfo,aNbElem,theInfo.myEntity,ePOLYEDRE,&aRet);
1046         if(theErr)
1047           *theErr = aRet;
1048       }
1049
1050       GetFamilies(theInfo,aNbElem,theInfo.myEntity,ePOLYEDRE,&aRet);
1051       if(theErr)
1052         *theErr = aRet;
1053     }
1054
1055     //----------------------------------------------------------------------------
1056     void
1057     TVWrapper
1058     ::SetPolyedreInfo(const TPolyedreInfo& theInfo,
1059                       TErr* theErr)
1060     {
1061       SetPolyedreInfo(theInfo,eLECTURE_ECRITURE,theErr);
1062     }
1063
1064     //----------------------------------------------------------------------------
1065     void
1066     TVWrapper
1067     ::SetPolyedreInfo(const MED::TPolyedreInfo& theInfo,
1068                       EModeAcces theMode,
1069                       TErr* theErr)
1070     {
1071       TFileWrapper aFileWrapper(myFile,theMode,theErr);
1072
1073       if(theErr && *theErr < 0)
1074         return;
1075
1076       MED::TPolyedreInfo& anInfo = const_cast<MED::TPolyedreInfo&>(theInfo);
1077       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
1078
1079       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1080       TValueHolder<TElemNum, med_int> anIndex(anInfo.myIndex);
1081       TValueHolder<TElemNum, med_int> aFaces(anInfo.myFaces);
1082       TValueHolder<TElemNum, med_int> aConn(anInfo.myConn);
1083       TValueHolder<EConnectivite, med_connectivite> aConnMode(anInfo.myConnMode);
1084
1085       TErr aRet;
1086       aRet = MEDpolyedreConnEcr(myFile->Id(),
1087                                 &aMeshName,
1088                                 &anIndex,
1089                                 anInfo.myNbElem + 1,
1090                                 &aFaces,
1091                                 (TInt)anInfo.myFaces->size(),
1092                                 &aConn,
1093                                 aConnMode);
1094
1095       if(theErr)
1096         *theErr = aRet;
1097       else if(aRet < 0)
1098         EXCEPTION(std::runtime_error,"SetPolyedreInfo - MEDpolyedreConnEcr(...)");
1099
1100       TValueHolder<EEntiteMaillage, med_entite_maillage> anEntity(anInfo.myEntity);
1101
1102       if(theInfo.myIsElemNames){
1103         TValueHolder<TString, char> anElemNames(anInfo.myElemNames);
1104         aRet  = MEDnomEcr(myFile->Id(),
1105                           &aMeshName,
1106                           &anElemNames,
1107                           (TInt)anInfo.myElemNames->size(),
1108                           anEntity,
1109                           MED_POLYEDRE);
1110         if(theErr)
1111           *theErr = aRet;
1112         else if(aRet < 0)
1113           EXCEPTION(std::runtime_error,"SetPolyedreInfo - MEDnomEcr(...)");
1114       }
1115
1116       if(theInfo.myIsElemNum){
1117         TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
1118         aRet  = MEDnumEcr(myFile->Id(),
1119                           &aMeshName,
1120                           &anElemNum,
1121                           (TInt)anInfo.myElemNum->size(),
1122                           anEntity,
1123                           MED_POLYEDRE);
1124         if(theErr)
1125           *theErr = aRet;
1126         else if(aRet < 0)
1127           EXCEPTION(std::runtime_error,"SetPolyedreInfo - MEDnumEcr(...)");
1128       }
1129
1130
1131       TValueHolder<TElemNum, med_int> aFamNum(anInfo.myFamNum);
1132       aRet = MEDfamEcr(myFile->Id(),
1133                        &aMeshName,
1134                        &aFamNum,
1135                        (TInt)anInfo.myFamNum->size(),
1136                        anEntity,
1137                        MED_POLYEDRE);
1138
1139       if(theErr)
1140         *theErr = aRet;
1141       else if(aRet < 0)
1142         EXCEPTION(std::runtime_error,"SetPolyedreInfo - MEDfamEcr(...)");
1143     }
1144
1145     //----------------------------------------------------------------------------
1146     TInt
1147     TVWrapper
1148     ::GetNbPolyedres(const MED::TMeshInfo& theMeshInfo,
1149                      EEntiteMaillage theEntity,
1150                      EGeometrieElement theGeom,
1151                      EConnectivite theConnMode,
1152                      TErr* theErr)
1153     {
1154       return GetNbCells(theMeshInfo,theEntity,theGeom,theConnMode,theErr);
1155     }
1156
1157     //----------------------------------------------------------------------------
1158     void
1159     TVWrapper
1160     ::GetPolyedreConnSize(const TMeshInfo& theMeshInfo,
1161                           TInt& theNbFaces,
1162                           TInt& theConnSize,
1163                           EConnectivite theConnMode,
1164                           TErr* theErr)
1165     {
1166       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1167
1168       if(theErr && *theErr < 0)
1169         EXCEPTION(std::runtime_error,"GetPolyedreConnSize - (...)");
1170
1171       MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
1172
1173       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1174       TValueHolder<EConnectivite, med_connectivite> aConnMode(theConnMode);
1175       TValueHolder<TInt, med_int> aNbFaces(theNbFaces);
1176       TValueHolder<TInt, med_int> aConnSize(theConnSize);
1177
1178       TErr aRet = MEDpolyedreInfo(myFile->Id(),
1179                                   &aMeshName,
1180                                   aConnMode,
1181                                   &aNbFaces,
1182                                   &aConnSize);
1183
1184       if(theErr)
1185         *theErr = aRet;
1186       else if(aRet < 0)
1187         EXCEPTION(std::runtime_error,"GetPolygoneInfo - MEDpolyedreInfo(...)");
1188
1189     }
1190
1191     //-----------------------------------------------------------------
1192     TEntityInfo
1193     TVWrapper
1194     ::GetEntityInfo(const MED::TMeshInfo& theMeshInfo,
1195                     EConnectivite theConnMode,
1196                     TErr* theErr)
1197     {
1198       TEntityInfo anInfo;
1199
1200       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1201
1202       if(theErr && *theErr < 0)
1203         return anInfo;
1204
1205       if(theMeshInfo.GetType() == eNON_STRUCTURE) {
1206         TInt aNbElem = GetNbNodes(theMeshInfo);
1207         if(aNbElem > 0){
1208           anInfo[eNOEUD][ePOINT1] = aNbElem;
1209           const TEntity2GeomSet& anEntity2GeomSet = GetEntity2GeomSet();
1210           TEntity2GeomSet::const_iterator anIter = anEntity2GeomSet.begin();
1211           TEntity2GeomSet::const_iterator anIterEnd = anEntity2GeomSet.end();
1212           for(; anIter != anIterEnd; anIter++){
1213             const EEntiteMaillage& anEntity = anIter->first;
1214             const TGeomSet& aGeomSet = anIter->second;
1215             TGeomSet::const_iterator anIter2 = aGeomSet.begin();
1216             TGeomSet::const_iterator anIterEnd2 = aGeomSet.end();
1217             for(; anIter2 != anIterEnd2; anIter2++){
1218               const EGeometrieElement& aGeom = *anIter2;
1219               aNbElem = GetNbCells(theMeshInfo,anEntity,aGeom,theConnMode,theErr);
1220               if(aNbElem > 0)
1221                 anInfo[anEntity][aGeom] = aNbElem;
1222             }
1223           }
1224         }
1225       } else { // eSTRUCTURE
1226         EGrilleType aGrilleType;
1227         TInt aNbNodes = 1;
1228         TInt aNbElem  = 1;
1229         TInt aDim = theMeshInfo.GetDim();
1230         EGeometrieElement aGeom;
1231         EEntiteMaillage anEntity = eMAILLE;
1232         switch(aDim){
1233         case 1:
1234           aGeom = eSEG2;
1235           break;
1236         case 2:
1237           aGeom = eQUAD4;
1238           break;
1239         case 3:
1240           aGeom = eHEXA8;
1241           break;
1242         }
1243
1244         GetGrilleType(theMeshInfo, aGrilleType);
1245
1246         if(aGrilleType == eGRILLE_STANDARD){
1247           TIntVector aStruct(aDim);
1248           GetGrilleStruct(theMeshInfo, aStruct, theErr);
1249           for(med_int i = 0; i < aDim; i++){
1250             aNbNodes = aNbNodes * aStruct[i];
1251             aNbElem = aNbElem * (aStruct[i] - 1);
1252           }
1253         }else{ // eGRILLE_CARTESIENNE and eGRILLE_POLAIRE
1254           ETable aTable;
1255           for(med_int anAxis = 1; anAxis <= aDim; anAxis++){
1256             switch(anAxis){
1257             case 1 :
1258               aTable = eCOOR_IND1;
1259               break;
1260             case 2 :
1261               aTable = eCOOR_IND2;
1262               break;
1263             case 3 :
1264               aTable = eCOOR_IND3;
1265               break;
1266             }
1267             TInt aNbNodes = GetNbNodes(theMeshInfo, aTable);
1268             aNbNodes = aNbNodes * aNbNodes;
1269             aNbElem =  aNbElem * (aNbNodes - 1);
1270           }
1271         }
1272         anInfo[eNOEUD][ePOINT1] = aNbNodes;
1273         anInfo[anEntity][aGeom] = aNbElem;
1274       }
1275       return anInfo;
1276     }
1277
1278
1279     //-----------------------------------------------------------------
1280     TInt
1281     TVWrapper
1282     ::GetNbCells(const MED::TMeshInfo& theMeshInfo,
1283                  EEntiteMaillage theEntity,
1284                  EGeometrieElement theGeom,
1285                  EConnectivite theConnMode,
1286                  TErr* theErr)
1287     {
1288       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1289
1290       if(theErr && *theErr < 0)
1291         return -1;
1292
1293       MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
1294       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1295
1296       return MEDnEntMaa(myFile->Id(),
1297                         &aMeshName,
1298                         MED_CONN,
1299                         med_entite_maillage(theEntity),
1300                         med_geometrie_element(theGeom),
1301                         med_connectivite(theConnMode));
1302     }
1303
1304
1305     //----------------------------------------------------------------------------
1306     void
1307     TVWrapper
1308     ::GetCellInfo(MED::TCellInfo& theInfo,
1309                   TErr* theErr)
1310     {
1311       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1312
1313       if(theErr && *theErr < 0)
1314         return;
1315
1316       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
1317       TInt aNbElem = (TInt)theInfo.myElemNum->size();
1318
1319       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1320       TValueHolder<TInt, med_int> aDim(aMeshInfo.myDim);
1321       TValueHolder<TElemNum, med_int> aConn(theInfo.myConn);
1322       TValueHolder<EModeSwitch, med_mode_switch> aModeSwitch(theInfo.myModeSwitch);
1323       TValueHolder<TString, char> anElemNames(theInfo.myElemNames);
1324       TValueHolder<EBooleen, med_booleen> anIsElemNames(theInfo.myIsElemNames);
1325       TValueHolder<TElemNum, med_int> anElemNum(theInfo.myElemNum);
1326       TValueHolder<EBooleen, med_booleen> anIsElemNum(theInfo.myIsElemNum);
1327       TValueHolder<TElemNum, med_int> aFamNum(theInfo.myFamNum);
1328       TValueHolder<EEntiteMaillage, med_entite_maillage> anEntity(theInfo.myEntity);
1329       TValueHolder<EGeometrieElement, med_geometrie_element> aGeom(theInfo.myGeom);
1330       TValueHolder<EConnectivite, med_connectivite> aConnMode(theInfo.myConnMode);
1331
1332       TErr aRet;
1333       aRet = MEDelementsLire(myFile->Id(),
1334                              &aMeshName,
1335                              aDim,
1336                              &aConn,
1337                              aModeSwitch,
1338                              &anElemNames,
1339                              &anIsElemNames,
1340                              &anElemNum,
1341                              &anIsElemNum,
1342                              &aFamNum,
1343                              aNbElem,
1344                              anEntity,
1345                              aGeom,
1346                              aConnMode);
1347       if(theErr)
1348         *theErr = aRet;
1349       else if(aRet < 0)
1350         EXCEPTION(std::runtime_error,"GetCellInfo - MEDelementsLire(...)");
1351     }
1352
1353
1354     //----------------------------------------------------------------------------
1355     void
1356     TVWrapper
1357     ::SetCellInfo(const MED::TCellInfo& theInfo,
1358                   EModeAcces theMode,
1359                   TErr* theErr)
1360     {
1361       TFileWrapper aFileWrapper(myFile,theMode,theErr);
1362
1363       if(theErr && *theErr < 0)
1364         return;
1365
1366       MED::TCellInfo& anInfo = const_cast<MED::TCellInfo&>(theInfo);
1367       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
1368
1369       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1370       TValueHolder<TInt, med_int> aDim(aMeshInfo.myDim);
1371       TValueHolder<TElemNum, med_int> aConn(anInfo.myConn);
1372       TValueHolder<EModeSwitch, med_mode_switch> aModeSwitch(anInfo.myModeSwitch);
1373       TValueHolder<TString, char> anElemNames(anInfo.myElemNames);
1374       TValueHolder<EBooleen, med_booleen> anIsElemNames(anInfo.myIsElemNames);
1375       TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
1376       TValueHolder<EBooleen, med_booleen> anIsElemNum(anInfo.myIsElemNum);
1377       TValueHolder<TElemNum, med_int> aFamNum(anInfo.myFamNum);
1378       TValueHolder<EEntiteMaillage, med_entite_maillage> anEntity(anInfo.myEntity);
1379       TValueHolder<EGeometrieElement, med_geometrie_element> aGeom(anInfo.myGeom);
1380       TValueHolder<EConnectivite, med_connectivite> aConnMode(anInfo.myConnMode);
1381
1382       TErr aRet;
1383       aRet = MEDelementsEcr(myFile->Id(),
1384                             &aMeshName,
1385                             aDim,
1386                             &aConn,
1387                             aModeSwitch,
1388                             &anElemNames,
1389                             anIsElemNames,
1390                             &anElemNum,
1391                             anIsElemNum,
1392                             &aFamNum,
1393                             anInfo.myNbElem,
1394                             anEntity,
1395                             aGeom,
1396                             aConnMode);
1397
1398       if(theErr)
1399         *theErr = aRet;
1400       else if(aRet < 0)
1401         EXCEPTION(std::runtime_error,"SetCellInfo - MEDelementsLire(...)");
1402     }
1403
1404
1405     //----------------------------------------------------------------------------
1406     void
1407     TVWrapper
1408     ::SetCellInfo(const MED::TCellInfo& theInfo,
1409                   TErr* theErr)
1410     {
1411       SetCellInfo(theInfo,eLECTURE_ECRITURE,theErr);
1412     }
1413
1414
1415     //-----------------------------------------------------------------
1416     TInt
1417     TVWrapper
1418     ::GetNbFields(TErr* theErr)
1419     {
1420       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1421
1422       if(theErr && *theErr < 0)
1423         return -1;
1424
1425       return MEDnChamp(myFile->Id(),0);
1426     }
1427
1428
1429     //----------------------------------------------------------------------------
1430     TInt
1431     TVWrapper
1432     ::GetNbComp(TInt theFieldId,
1433                 TErr* theErr)
1434     {
1435       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1436
1437       if(theErr && *theErr < 0)
1438         return -1;
1439
1440       return MEDnChamp(myFile->Id(),theFieldId);
1441     }
1442
1443
1444     //----------------------------------------------------------------------------
1445     void
1446     TVWrapper
1447     ::GetFieldInfo(TInt theFieldId,
1448                    MED::TFieldInfo& theInfo,
1449                    TErr* theErr)
1450     {
1451       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1452
1453       if(theErr && *theErr < 0)
1454         return;
1455
1456       TString aFieldName(256); // Protect from memory problems with too long names
1457       TValueHolder<ETypeChamp, med_type_champ> aType(theInfo.myType);
1458       TValueHolder<TString, char> aCompNames(theInfo.myCompNames);
1459       TValueHolder<TString, char> anUnitNames(theInfo.myUnitNames);
1460
1461       TErr aRet;
1462       aRet = MEDchampInfo(myFile->Id(),
1463                           theFieldId,
1464                           &aFieldName[0],
1465                           &aType,
1466                           &aCompNames,
1467                           &anUnitNames,
1468                           theInfo.myNbComp);
1469
1470       theInfo.SetName(aFieldName);
1471
1472       if(theErr)
1473         *theErr = aRet;
1474       else if(aRet < 0)
1475         EXCEPTION(std::runtime_error,"GetFieldInfo - MEDchampInfo(...)");
1476     }
1477
1478
1479     //----------------------------------------------------------------------------
1480     void
1481     TVWrapper
1482     ::SetFieldInfo(const MED::TFieldInfo& theInfo,
1483                    EModeAcces theMode,
1484                    TErr* theErr)
1485     {
1486       TFileWrapper aFileWrapper(myFile,theMode,theErr);
1487
1488       if(theErr && *theErr < 0)
1489         return;
1490
1491       MED::TFieldInfo& anInfo = const_cast<MED::TFieldInfo&>(theInfo);
1492
1493       TValueHolder<TString, char> aFieldName(anInfo.myName);
1494       TValueHolder<ETypeChamp, med_type_champ> aType(anInfo.myType);
1495       TValueHolder<TString, char> aCompNames(anInfo.myCompNames);
1496       TValueHolder<TString, char> anUnitNames(anInfo.myUnitNames);
1497
1498       TErr aRet;
1499       aRet = MEDchampCr(myFile->Id(),
1500                         &aFieldName,
1501                         aType,
1502                         &aCompNames,
1503                         &anUnitNames,
1504                         anInfo.myNbComp);
1505       if(theErr)
1506         *theErr = aRet;
1507       else if(aRet < 0)
1508         EXCEPTION(std::runtime_error,"SetFieldInfo - MEDchampEcr(...)");
1509     }
1510
1511
1512     //----------------------------------------------------------------------------
1513     void
1514     TVWrapper
1515     ::SetFieldInfo(const MED::TFieldInfo& theInfo,
1516                    TErr* theErr)
1517     {
1518       TErr aRet;
1519       SetFieldInfo(theInfo,eLECTURE_ECRITURE,&aRet);
1520
1521       if(aRet < 0)
1522         SetFieldInfo(theInfo,eLECTURE_AJOUT,&aRet);
1523
1524       if(theErr)
1525         *theErr = aRet;
1526     }
1527
1528
1529     //----------------------------------------------------------------------------
1530     TInt
1531     TVWrapper
1532     ::GetNbGauss(TErr* theErr)
1533     {
1534       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1535
1536       if(theErr && *theErr < 0)
1537         return -1;
1538
1539       return MEDnGauss(myFile->Id());
1540     }
1541
1542
1543     //----------------------------------------------------------------------------
1544     TGaussInfo::TInfo
1545     TVWrapper
1546     ::GetGaussPreInfo(TInt theId,
1547                       TErr* theErr)
1548     {
1549       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1550
1551       if(theErr && *theErr < 0)
1552         return TGaussInfo::TInfo( TGaussInfo::TKey(ePOINT1,""),0 );
1553
1554       med_int aNbGaussPoints = med_int();
1555       TVector<char> aName(GetNOMLength<eV2_2>()+1);
1556       med_geometrie_element aGeom = MED_NONE;
1557
1558       TErr aRet;
1559       aRet = MEDgaussInfo(myFile->Id(),
1560                           theId,
1561                           &aName[0],
1562                           &aGeom,
1563                           &aNbGaussPoints);
1564       if(theErr)
1565         *theErr = aRet;
1566       else if(aRet < 0)
1567         EXCEPTION(std::runtime_error,"GetGaussPreInfo - MEDgaussInfo(...)");
1568
1569       return TGaussInfo::TInfo(TGaussInfo::TKey(EGeometrieElement(aGeom),&aName[0]),
1570                                TInt(aNbGaussPoints));
1571     }
1572
1573
1574     //----------------------------------------------------------------------------
1575     void
1576     TVWrapper
1577     ::GetGaussInfo(TInt theId,
1578                    TGaussInfo& theInfo,
1579                    TErr* theErr)
1580     {
1581       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1582
1583       if(theErr && *theErr < 0)
1584         return;
1585
1586       TValueHolder<TNodeCoord, med_float> aRefCoord(theInfo.myRefCoord);
1587       TValueHolder<TNodeCoord, med_float> aGaussCoord(theInfo.myGaussCoord);
1588       TValueHolder<TWeight, med_float> aWeight(theInfo.myWeight);
1589       TValueHolder<EModeSwitch, med_mode_switch> aModeSwitch(theInfo.myModeSwitch);
1590       TValueHolder<TString, char> aGaussName(theInfo.myName);
1591
1592       TErr aRet;
1593       aRet = MEDgaussLire(myFile->Id(),
1594                           &aRefCoord,
1595                           &aGaussCoord,
1596                           &aWeight,
1597                           aModeSwitch,
1598                           &aGaussName);
1599
1600       if(theErr)
1601         *theErr = aRet;
1602       else if(aRet < 0)
1603         EXCEPTION(std::runtime_error,"GetGaussInfo - MEDgaussLire(...)");
1604     }
1605
1606
1607     //----------------------------------------------------------------------------
1608     TInt
1609     TVWrapper
1610     ::GetNbProfiles(TErr* theErr)
1611     {
1612       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1613
1614       if(theErr && *theErr < 0)
1615         return -1;
1616
1617       return MEDnProfil(myFile->Id());
1618     }
1619
1620     TProfileInfo::TInfo
1621     TVWrapper
1622     ::GetProfilePreInfo(TInt theId,
1623                         TErr* theErr)
1624     {
1625       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1626
1627       if(theErr && *theErr < 0)
1628         return TProfileInfo::TInfo();
1629
1630       med_int aSize = -1;
1631       TVector<char> aName(GetNOMLength<eV2_2>()+1);
1632
1633       TErr aRet;
1634       aRet = MEDprofilInfo(myFile->Id(),
1635                            theId,
1636                            &aName[0],
1637                            &aSize);
1638       if(theErr)
1639         *theErr = aRet;
1640       else if(aRet < 0)
1641         EXCEPTION(std::runtime_error,"GetProfilePreInfo - MEDprofilInfo(...)");
1642
1643       return TProfileInfo::TInfo(&aName[0],aSize);
1644     }
1645
1646     void
1647     TVWrapper
1648     ::GetProfileInfo(TInt theId,
1649                      TProfileInfo& theInfo,
1650                      TErr* theErr)
1651     {
1652       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1653
1654       if(theErr && *theErr < 0)
1655         return;
1656
1657       TProfileInfo& anInfo = const_cast<TProfileInfo&>(theInfo);
1658       TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
1659       TValueHolder<TString, char>     aProfileName(anInfo.myName);
1660
1661       TErr aRet;
1662       aRet = MEDprofilLire(myFile->Id(),
1663                            &anElemNum,
1664                            &aProfileName);
1665       if(theErr)
1666         *theErr = aRet;
1667       else if(aRet < 0)
1668         EXCEPTION(std::runtime_error,"GetProfileInfo - MEDprofilLire(...)");
1669     }
1670
1671     void
1672     TVWrapper
1673     ::SetProfileInfo(const TProfileInfo& theInfo,
1674                      EModeAcces          theMode,
1675                      TErr*               theErr)
1676     {
1677       TFileWrapper aFileWrapper(myFile,theMode,theErr);
1678
1679       if(theErr && *theErr < 0)
1680         return;
1681
1682       TProfileInfo& anInfo = const_cast<TProfileInfo&>(theInfo);
1683       TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
1684       TValueHolder<TString, char>     aProfileName(anInfo.myName);
1685
1686       TErr aRet;
1687       aRet = MEDprofilEcr(myFile->Id(),      // descripteur du fichier.
1688                           &anElemNum,        // tableau de valeurs du profil.
1689                           theInfo.GetSize(), // taille du profil.
1690                           &aProfileName);    // nom profil.
1691       if(theErr)
1692         *theErr = aRet;
1693       else if(aRet < 0)
1694         EXCEPTION(std::runtime_error,"SetProfileInfo - MEDprofilEcr(...)");
1695     }
1696
1697     void
1698     TVWrapper
1699     ::SetProfileInfo(const TProfileInfo& theInfo,
1700                      TErr*               theErr)
1701     {
1702       TErr aRet;
1703       SetProfileInfo(theInfo,eLECTURE_ECRITURE,&aRet);
1704
1705       if(aRet < 0)
1706         SetProfileInfo(theInfo,eLECTURE_AJOUT,&aRet);
1707
1708       if(aRet < 0)
1709         SetProfileInfo(theInfo,eCREATION,&aRet);
1710
1711       if(theErr)
1712         *theErr = aRet;
1713     }
1714
1715     //-----------------------------------------------------------------
1716     TInt
1717     TVWrapper
1718     ::GetNbTimeStamps(const MED::TFieldInfo& theInfo,
1719                       const MED::TEntityInfo& theEntityInfo,
1720                       EEntiteMaillage& theEntity,
1721                       TGeom2Size& theGeom2Size,
1722                       TErr* theErr)
1723     {
1724       theEntity = EEntiteMaillage(-1);
1725       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1726
1727       if(theErr){
1728         if(theEntityInfo.empty())
1729           *theErr = -1;
1730         if(*theErr < 0)
1731           return -1;
1732       }else if(theEntityInfo.empty())
1733         EXCEPTION(std::runtime_error,"GetNbTimeStamps - There is no any Entity on the Mesh");
1734
1735       bool anIsPerformAdditionalCheck = GetNbMeshes() > 1;
1736
1737       theGeom2Size.clear();
1738       TInt aNbTimeStamps = 0;
1739       TIdt anId = myFile->Id();
1740
1741       MED::TFieldInfo& anInfo = const_cast<MED::TFieldInfo&>(theInfo);
1742       TValueHolder<TString, char> aFieldName(anInfo.myName);
1743       MED::TMeshInfo& aMeshInfo = anInfo.myMeshInfo;
1744
1745       TEntityInfo::const_iterator anIter = theEntityInfo.begin();
1746       for(; anIter != theEntityInfo.end(); anIter++){
1747         med_entite_maillage anEntity = med_entite_maillage(anIter->first);
1748         const TGeom2Size& aGeom2Size = anIter->second;
1749         TGeom2Size::const_iterator anGeomIter = aGeom2Size.begin();
1750         for(; anGeomIter != aGeom2Size.end(); anGeomIter++){
1751           med_geometrie_element aGeom = med_geometrie_element(anGeomIter->first);
1752           TInt aNbStamps = MEDnPasdetemps(anId,
1753                                           &aFieldName,
1754                                           anEntity,
1755                                           aGeom);
1756           bool anIsSatisfied = aNbStamps > 0;
1757           if(anIsSatisfied){
1758             INITMSG(MYDEBUG,
1759                     "GetNbTimeStamps aNbTimeStamps = "<<aNbStamps<<
1760                     "; aGeom = "<<aGeom<<"; anEntity = "<<anEntity<<"\n");
1761             if(anIsPerformAdditionalCheck){
1762               TInt iTimeStampEnd = aNbStamps;
1763               for(TInt iTimeStamp = 1; iTimeStamp <= iTimeStampEnd; iTimeStamp++){
1764                 TVector<char> aMeshName(GetNOMLength<eV2_2>()+1);
1765                 TVector<char> aDtUnit(GetPNOMLength<eV2_2>()+1);
1766                 med_int aNbGauss;
1767                 med_int aNumDt;
1768                 med_int aNumOrd;
1769                 med_float aDt;
1770                 med_booleen anIsLocal;
1771                 med_int aNbRef;
1772                 TErr aRet = MEDpasdetempsInfo(anId,
1773                                               &aFieldName,
1774                                               anEntity,
1775                                               aGeom,
1776                                               iTimeStamp,
1777                                               &aNbGauss,
1778                                               &aNumDt,
1779                                               &aNumOrd,
1780                                               &aDtUnit[0],
1781                                               &aDt,
1782                                               &aMeshName[0],
1783                                               &anIsLocal,
1784                                               &aNbRef);
1785
1786                 anIsSatisfied = (aRet == 0 && (!strcmp(&aMeshName[0],&aMeshInfo.myName[0])));
1787                 if(!anIsSatisfied){
1788                   INITMSG(MYDEBUG,
1789                           "GetNbTimeStamps aMeshName = '"<<&aMeshName[0]<<"' != "<<
1790                           "; aMeshInfo.myName = '"<<&aMeshInfo.myName[0]<<"'\n");
1791                   break;
1792                 }
1793               }
1794             }
1795           }
1796           if(anIsSatisfied){
1797             theGeom2Size[EGeometrieElement(aGeom)] = anGeomIter->second;
1798             theEntity = EEntiteMaillage(anEntity);
1799             aNbTimeStamps = aNbStamps;
1800           }
1801         }
1802         if(!theGeom2Size.empty())
1803           break;
1804       }
1805       return aNbTimeStamps;
1806     }
1807
1808
1809     //----------------------------------------------------------------------------
1810     void
1811     TVWrapper
1812     ::GetTimeStampInfo(TInt theTimeStampId,
1813                        MED::TTimeStampInfo& theInfo,
1814                        TErr* theErr)
1815     {
1816       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1817
1818       const TGeom2Size& aGeom2Size = theInfo.myGeom2Size;
1819
1820       if(theErr){
1821         if(aGeom2Size.empty())
1822           *theErr = -1;
1823         if(*theErr < 0)
1824           return;
1825       }else if(aGeom2Size.empty())
1826         EXCEPTION(std::runtime_error,"GetTimeStampInfo - There is no any cell");
1827
1828       MED::TFieldInfo& aFieldInfo = *theInfo.myFieldInfo;
1829       MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo;
1830
1831       TValueHolder<TString, char> aFieldName(aFieldInfo.myName);
1832       TValueHolder<EEntiteMaillage, med_entite_maillage> anEntity(theInfo.myEntity);
1833       TValueHolder<TInt, med_int> aNumDt(theInfo.myNumDt);
1834       TValueHolder<TInt, med_int> aNumOrd(theInfo.myNumOrd);
1835       TValueHolder<TString, char> anUnitDt(theInfo.myUnitDt);
1836       TValueHolder<TFloat, med_float> aDt(theInfo.myDt);
1837       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1838       TValueHolder<EBooleen, med_booleen> anIsLocal(aFieldInfo.myIsLocal);
1839       TValueHolder<TInt, med_int> aNbRef(aFieldInfo.myNbRef);
1840
1841       TGeom2NbGauss& aGeom2NbGauss = theInfo.myGeom2NbGauss;
1842
1843       TGeom2Size::const_iterator anIter = aGeom2Size.begin();
1844       for(; anIter != aGeom2Size.end(); anIter++){
1845         const EGeometrieElement& aGeom = anIter->first;
1846         med_int aNbGauss = -1;
1847
1848         TErr aRet;
1849         aRet = MEDpasdetempsInfo(myFile->Id(),
1850                                  &aFieldName,
1851                                  anEntity,
1852                                  med_geometrie_element(aGeom),
1853                                  theTimeStampId,
1854                                  &aNbGauss,
1855                                  &aNumDt,
1856                                  &aNumOrd,
1857                                  &anUnitDt,
1858                                  &aDt,
1859                                  &aMeshName,
1860                                  &anIsLocal,
1861                                  &aNbRef);
1862
1863         static TInt MAX_NB_GAUSS_POINTS = 32;
1864         if(aNbGauss <= 0 || aNbGauss > MAX_NB_GAUSS_POINTS)
1865           aNbGauss = 1;
1866
1867         aGeom2NbGauss[aGeom] = aNbGauss;
1868
1869         if(theErr)
1870           *theErr = aRet;
1871         else if(aRet < 0)
1872           EXCEPTION(std::runtime_error,"GetTimeStampInfo - MEDpasdetempsInfo(...)");
1873       }
1874     }
1875
1876
1877     //----------------------------------------------------------------------------
1878     void
1879     TVWrapper
1880     ::GetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
1881                         const TMKey2Profile& theMKey2Profile,
1882                         const TKey2Gauss& theKey2Gauss,
1883                         TErr* theErr)
1884     {
1885       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1886
1887       if(theErr && *theErr < 0)
1888         return;
1889
1890       TIdt anId = myFile->Id();
1891
1892       TValueHolder<EModeSwitch, med_mode_switch> aModeSwitch(theTimeStampValue->myModeSwitch);
1893       MED::TGeom2Profile& aGeom2Profile = theTimeStampValue->myGeom2Profile;
1894
1895       MED::PTimeStampInfo aTimeStampInfo = theTimeStampValue->myTimeStampInfo;
1896       TValueHolder<EEntiteMaillage, med_entite_maillage> anEntity(aTimeStampInfo->myEntity);
1897       TValueHolder<TInt, med_int> aNumDt(aTimeStampInfo->myNumDt);
1898       TValueHolder<TInt, med_int> aNumOrd(aTimeStampInfo->myNumOrd);
1899
1900       MED::PFieldInfo aFieldInfo = aTimeStampInfo->myFieldInfo;
1901       TValueHolder<TString, char> aFieldName(aFieldInfo->myName);
1902       TValueHolder<EBooleen, med_booleen> anIsLocal(aFieldInfo->myIsLocal);
1903
1904       MED::PMeshInfo aMeshInfo = aFieldInfo->myMeshInfo;
1905       TValueHolder<TString, char> aMeshName(aMeshInfo->myName);
1906
1907       TGeom2Gauss& aGeom2Gauss = aTimeStampInfo->myGeom2Gauss;
1908       TVector<char> aGaussName(GetNOMLength<eV2_2>()+1);
1909
1910       med_mode_profil aProfileMode = med_mode_profil(boost::get<0>(theMKey2Profile));
1911       MED::TKey2Profile aKey2Profile = boost::get<1>(theMKey2Profile);
1912       TVector<char> aProfileName(GetNOMLength<eV2_2>()+1);
1913
1914       TGeom2Size& aGeom2Size = aTimeStampInfo->myGeom2Size;
1915       TGeom2Size::iterator anIter = aGeom2Size.begin();
1916       for(; anIter != aGeom2Size.end(); anIter++){
1917         EGeometrieElement aGeom = anIter->first;
1918         TInt aNbElem = anIter->second;
1919
1920         TInt aNbMeshRef = MEDnChampRef(anId,
1921                                        &aFieldName,
1922                                        anEntity,
1923                                        med_geometrie_element(aGeom),
1924                                        aNumDt,
1925                                        aNumOrd);
1926         if(aNbMeshRef < 1){
1927           if(theErr){
1928             *theErr = MED_FAUX;
1929             return;
1930           }
1931           EXCEPTION(std::runtime_error,"GetTimeStampValue - MEDnChampRef(...) < 1");
1932         }
1933
1934         TErr aRet;
1935         med_int aNbGauss = -1;
1936         aRet = MEDchampRefInfo(anId,
1937                                &aFieldName,
1938                                anEntity,
1939                                med_geometrie_element(aGeom),
1940                                aNbMeshRef,
1941                                aNumDt,
1942                                aNumOrd,
1943                                &aMeshName,
1944                                &anIsLocal,
1945                                &aNbGauss);
1946
1947         if(aRet < 0){
1948           if(theErr){
1949             *theErr = MED_FAUX;
1950             return;
1951           }
1952           EXCEPTION(std::runtime_error,"GetTimeStampValue - MEDchampRefInfo(...)");
1953         }
1954
1955         TInt aNbVal = MEDnVal(anId,
1956                               &aFieldName,
1957                               anEntity,
1958                               med_geometrie_element(aGeom),
1959                               aNumDt,
1960                               aNumOrd,
1961                               &aMeshName,
1962                               aProfileMode);
1963         if(aNbVal <= 0){
1964           if(theErr){
1965             *theErr = -1;
1966             return;
1967           }
1968           EXCEPTION(std::runtime_error,"GetTimeStampValue - MEDnVal(...) - aNbVal == "<<aNbVal<<" <= 0");
1969         }
1970
1971         TInt aNbComp = aFieldInfo->myNbComp;
1972         TInt aNbValue = aNbVal / aNbGauss;
1973         theTimeStampValue->AllocateValue(aGeom,
1974                                          aNbValue,
1975                                          aNbGauss,
1976                                          aNbComp);
1977         TInt aValueSize = theTimeStampValue->GetValueSize(aGeom);
1978
1979         INITMSG(MYDEBUG,
1980                 "TVWrapper::GetTimeStampValue - aGeom = "<<aGeom<<
1981                 "; aNbVal = "<<aNbVal<<
1982                 "; aNbValue = "<<aNbValue<<
1983                 "; aNbGauss = "<<aNbGauss<<
1984                 "; aNbComp = "<<aNbComp<<
1985                 std::endl);
1986
1987         aRet = MEDchampLire(anId,
1988                             &aMeshName,
1989                             &aFieldName,
1990                             theTimeStampValue->GetValuePtr(aGeom),
1991                             aModeSwitch,
1992                             MED_ALL,
1993                             &aGaussName[0],
1994                             &aProfileName[0],
1995                             aProfileMode,
1996                             anEntity,
1997                             med_geometrie_element(aGeom),
1998                             aNumDt,
1999                             aNumOrd);
2000         if(aRet < 0){
2001           if(theErr){
2002             *theErr = MED_FAUX;
2003             return;
2004           }
2005           EXCEPTION(std::runtime_error,"GetTimeStampValue - MEDchampLire(...)");
2006         }
2007
2008         MED::PGaussInfo aGaussInfo;
2009         TGaussInfo::TKey aKey(aGeom,&aGaussName[0]);
2010         if(strcmp(&aGaussName[0],"") != 0){
2011           MED::TKey2Gauss::const_iterator anIter = theKey2Gauss.find(aKey);
2012           if(anIter != theKey2Gauss.end()){
2013             aGaussInfo = anIter->second;
2014             aGeom2Gauss[aGeom] = aGaussInfo;
2015           }
2016         }
2017
2018         MED::PProfileInfo aProfileInfo;
2019         if(strcmp(&aProfileName[0],"") != 0){
2020           MED::TKey2Profile::const_iterator anIter = aKey2Profile.find(&aProfileName[0]);
2021           if(anIter != aKey2Profile.end()){
2022             aProfileInfo = anIter->second;
2023             aGeom2Profile[aGeom] = aProfileInfo;
2024           }
2025         }
2026
2027         if(aNbGauss > 1 && !aGaussInfo){
2028           if(theErr){
2029             *theErr = MED_FAUX;
2030             return;
2031           }
2032           EXCEPTION(std::runtime_error,"GetTimeStampValue "<<
2033                     "- aNbGauss("<<aNbGauss<<") > 1 && !aGaussInfo"<<
2034                     "; aGaussName = '"<<&aGaussName[0]<<"'"<<
2035                     "; aGeom = "<<aGeom<<
2036                     "");
2037         }
2038
2039         if(aGaussInfo && aNbGauss != aGaussInfo->GetNbGauss()){
2040           if(theErr){
2041             *theErr = MED_FAUX;
2042             return;
2043           }
2044           EXCEPTION(std::runtime_error,"GetTimeStampValue - aNbGauss != aGaussInfo->GetNbGauss()");
2045         }
2046
2047         if(aProfileInfo && aProfileInfo->IsPresent()){
2048           TInt aNbSubElem = aProfileInfo->GetSize();
2049           TInt aProfileSize = aNbSubElem*aNbComp*aNbGauss;
2050           if(aProfileSize != aValueSize){
2051             if(theErr){
2052               *theErr = -1;
2053               return;
2054             }
2055             EXCEPTION(std::runtime_error,
2056                       "GetTimeStampValue - aProfileSize("<<aProfileSize<<
2057                       ") != aValueSize("<<aValueSize<<
2058                       "); aNbVal = "<<aNbVal<<
2059                       "; anEntity = "<<anEntity<<
2060                       "; aGeom = "<<aGeom<<
2061                       "; aNbElem = "<<aNbElem<<
2062                       "; aNbSubElem = "<<aNbSubElem<<
2063                       "; aNbComp = "<<aNbComp<<
2064                       "; aNbGauss = "<<aNbGauss<<
2065                       "");
2066           }
2067         }else{
2068           if(aNbElem != aNbValue){
2069             if(theErr){
2070               *theErr = -1;
2071               return;
2072             }
2073             EXCEPTION(std::runtime_error,
2074                       "GetTimeStampValue - aNbElem("<<aNbElem<<
2075                       ") != aNbValue("<<aNbValue<<
2076                       "); aNbVal = "<<aNbVal<<
2077                       "; anEntity = "<<anEntity<<
2078                       "; aGeom = "<<aGeom<<
2079                       "; aNbElem = "<<aNbElem<<
2080                       "; aNbComp = "<<aNbComp<<
2081                       "; aNbGauss = "<<aNbGauss<<
2082                       "");
2083           }
2084         }
2085       }
2086     }
2087
2088
2089     //----------------------------------------------------------------------------
2090     void
2091     TVWrapper
2092     ::SetTimeStampValue(const MED::PTimeStampValueBase& theTimeStampValue,
2093                         EModeAcces theMode,
2094                         TErr* theErr)
2095     {
2096       TFileWrapper aFileWrapper(myFile,theMode,theErr);
2097
2098       if(theErr && *theErr < 0)
2099         return;
2100
2101       TErr aRet;
2102       TIdt anId = myFile->Id();
2103
2104       TValueHolder<EModeSwitch, med_mode_switch> aModeSwitch(theTimeStampValue->myModeSwitch);
2105       MED::TGeom2Profile& aGeom2Profile = theTimeStampValue->myGeom2Profile;
2106
2107       MED::PTimeStampInfo aTimeStampInfo = theTimeStampValue->myTimeStampInfo;
2108       TValueHolder<EEntiteMaillage, med_entite_maillage> anEntity(aTimeStampInfo->myEntity);
2109       TValueHolder<TInt, med_int> aNumDt(aTimeStampInfo->myNumDt);
2110       TValueHolder<TInt, med_int> aNumOrd(aTimeStampInfo->myNumOrd);
2111       TValueHolder<TString, char> anUnitDt(aTimeStampInfo->myUnitDt);
2112       TValueHolder<TFloat, med_float> aDt(aTimeStampInfo->myDt);
2113       MED::TGeom2Gauss& aGeom2Gauss = aTimeStampInfo->myGeom2Gauss;
2114
2115       MED::PFieldInfo aFieldInfo = aTimeStampInfo->myFieldInfo;
2116       TValueHolder<TString, char> aFieldName(aFieldInfo->myName);
2117
2118       MED::PMeshInfo aMeshInfo = aFieldInfo->myMeshInfo;
2119       TValueHolder<TString, char> aMeshName(aMeshInfo->myName);
2120
2121       const TGeomSet& aGeomSet = theTimeStampValue->myGeomSet;
2122       TGeomSet::const_iterator anIter = aGeomSet.begin();
2123       for(; anIter != aGeomSet.end(); anIter++){
2124         EGeometrieElement aGeom = *anIter;
2125
2126         TVector<char> aGaussName(GetNOMLength<eV2_2>()+1);
2127         MED::TGeom2Gauss::const_iterator aGaussIter = aGeom2Gauss.find(aGeom);
2128         if(aGaussIter != aGeom2Gauss.end()){
2129           MED::PGaussInfo aGaussInfo = aGaussIter->second;
2130           strcpy(&aGaussName[0],&aGaussInfo->myName[0]);
2131         }
2132
2133         TVector<char> aProfileName(GetNOMLength<eV2_2>()+1);
2134         med_mode_profil aProfileMode = med_mode_profil(eNO_PFLMOD);
2135         MED::TGeom2Profile::const_iterator aProfileIter = aGeom2Profile.find(aGeom);
2136         if(aProfileIter != aGeom2Profile.end()){
2137           MED::PProfileInfo aProfileInfo = aProfileIter->second;
2138           aProfileMode = med_mode_profil(aProfileInfo->myMode);
2139           strcpy(&aProfileName[0],&aProfileInfo->myName[0]);
2140         }
2141
2142         med_int aNbVal = theTimeStampValue->GetNbVal(aGeom);
2143
2144         aRet = MEDchampEcr(anId,
2145                            &aMeshName,
2146                            &aFieldName,
2147                            theTimeStampValue->GetValuePtr(aGeom),
2148                            aModeSwitch,
2149                            aNbVal,
2150                            &aGaussName[0],
2151                            MED_ALL,
2152                            &aProfileName[0],
2153                            aProfileMode,
2154                            anEntity,
2155                            med_geometrie_element(aGeom),
2156                            aNumDt,
2157                            &anUnitDt,
2158                            aDt,
2159                            aNumOrd);
2160         if(aRet < 0){
2161           if(theErr){
2162             *theErr = MED_FAUX;
2163             break;
2164           }
2165           EXCEPTION(std::runtime_error,"SetTimeStampValue - MEDchampEcr(...)");
2166         }
2167
2168       }
2169
2170       INITMSG(MYDEBUG,"TVWrapper::SetTimeStampValue - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
2171     }
2172
2173
2174     //----------------------------------------------------------------------------
2175     void
2176     TVWrapper
2177     ::SetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
2178                         TErr* theErr)
2179     {
2180       TErr aRet;
2181       SetTimeStampValue(theTimeStampValue,eLECTURE_ECRITURE,&aRet);
2182
2183       if(aRet < 0)
2184         SetTimeStampValue(theTimeStampValue,eLECTURE_AJOUT,&aRet);
2185
2186       if(theErr)
2187         *theErr = aRet;
2188     }
2189
2190     //----------------------------------------------------------------------------
2191     void
2192     TVWrapper
2193     ::SetGrilleInfo(const MED::TGrilleInfo& theInfo,
2194                     TErr* theErr)
2195     {
2196       SetGrilleInfo(theInfo,eLECTURE_ECRITURE,theErr);
2197     }
2198
2199     //----------------------------------------------------------------------------
2200     void
2201     TVWrapper
2202     ::SetGrilleInfo(const MED::TGrilleInfo& theInfo,
2203                     EModeAcces theMode,
2204                     TErr* theErr)
2205     {
2206       if(theInfo.myMeshInfo->myType != eSTRUCTURE)
2207         return;
2208       TFileWrapper aFileWrapper(myFile,theMode,theErr);
2209
2210       if(theErr && *theErr < 0)
2211           return;
2212
2213       MED::TGrilleInfo& anInfo = const_cast<MED::TGrilleInfo&>(theInfo);
2214
2215       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
2216       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
2217       TValueHolder<TInt, med_int> aDim(aMeshInfo.myDim);
2218
2219       TValueHolder<EGrilleType, med_type_grille> aGrilleType(anInfo.myGrilleType);
2220
2221       TErr aRet = 0;
2222       aRet = MEDnatureGrilleEcr(myFile->Id(),
2223                                 &aMeshName,
2224                                 aGrilleType);
2225       if(theErr)
2226         *theErr = aRet;
2227       else if(aRet < 0)
2228         EXCEPTION(std::runtime_error,"SetGrilleInfo - MEDnatureGrilleEcr(...)");
2229
2230       if(anInfo.myGrilleType == eGRILLE_STANDARD){
2231         TValueHolder<TNodeCoord, med_float> aCoord(anInfo.myCoord);
2232         TValueHolder<EModeSwitch, med_mode_switch> aModeSwitch(anInfo.myModeSwitch);
2233         TValueHolder<TString, char> aCoordNames(anInfo.myCoordNames);
2234         TValueHolder<TString, char> aCoordUnits(anInfo.myCoordUnits);
2235         med_int aNbNoeuds = med_int(anInfo.myCoord.size() / aMeshInfo.myDim);
2236         med_repere aRepere = MED_CART;
2237
2238         aRet = MEDcoordEcr(myFile->Id(),
2239                            &aMeshName,
2240                            aDim,
2241                            &aCoord,
2242                            aModeSwitch,
2243                            aNbNoeuds,
2244                            aRepere,
2245                            &aCoordNames,
2246                            &aCoordUnits);
2247
2248         if(aRet < 0)
2249           EXCEPTION(std::runtime_error,"SetGrilleInfo - MEDcoordEcr(...)");
2250
2251         TValueHolder<TIntVector, med_int> aGrilleStructure(anInfo.myGrilleStructure);
2252         aRet = MEDstructureCoordEcr(myFile->Id(),
2253                                     &aMeshName,
2254                                     aDim,
2255                                     &aGrilleStructure);
2256         if(aRet < 0)
2257           EXCEPTION(std::runtime_error,"SetGrilleInfo - MEDstructureCoordEcr(...)");
2258
2259       } else {
2260         for(med_int aAxis = 0; aAxis < aMeshInfo.myDim; aAxis++){
2261           aRet = MEDindicesCoordEcr(myFile->Id(),
2262                                     &aMeshName,
2263                                     aDim,
2264                                     &anInfo.GetIndexes(aAxis)[0],
2265                                     anInfo.GetIndexes(aAxis).size(),
2266                                     aAxis + 1,
2267                                     &anInfo.GetCoordName(aAxis)[0],
2268                                     &anInfo.GetCoordUnit(aAxis)[0]);
2269           if(aRet < 0)
2270             EXCEPTION(std::runtime_error,"SetGrilleInfo - MEDindicesCoordEcr(...)");
2271         }
2272
2273       }
2274
2275       return;
2276     }
2277
2278     //----------------------------------------------------------------------------
2279     void
2280     TVWrapper
2281     ::GetGrilleInfo(TGrilleInfo& theInfo,
2282                     TErr* theErr)
2283     {
2284       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
2285
2286       if(theErr && *theErr < 0)
2287           return;
2288
2289       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
2290       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
2291       TValueHolder<TInt, med_int> aDim(aMeshInfo.myDim);
2292       EMaillage aMaillageType = aMeshInfo.myType;
2293
2294       GetGrilleType(aMeshInfo, theInfo.myGrilleType, theErr);
2295       EGrilleType aGrilleType = theInfo.myGrilleType;
2296
2297       TErr aRet = 0;
2298       if(aMaillageType == eSTRUCTURE && aGrilleType == eGRILLE_STANDARD){
2299         GetGrilleStruct(aMeshInfo, theInfo.myGrilleStructure, theErr);
2300
2301         TValueHolder<TNodeCoord, med_float> aCoord(theInfo.myCoord);
2302         TValueHolder<EModeSwitch, med_mode_switch> aModeSwitch(theInfo.myModeSwitch);
2303         TValueHolder<TString, char> aCoordNames(theInfo.myCoordNames);
2304         TValueHolder<TString, char> aCoordUnits(theInfo.myCoordUnits);
2305         med_repere aRepere;
2306
2307         aRet = MEDcoordLire(myFile->Id(),
2308                             &aMeshName,
2309                             aDim,
2310                             &aCoord,
2311                             aModeSwitch,
2312                             MED_ALL, // all coordinates must be return
2313                             NULL,
2314                             0,
2315                             &aRepere,
2316                             &aCoordNames,
2317                             &aCoordUnits);
2318
2319         if(theErr)
2320           *theErr = aRet;
2321         else if(aRet < 0)
2322           EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDcoordLire(...)");
2323
2324         TInt aNbNodes = theInfo.GetNbNodes();//GetNbFamilies(aMeshInfo);
2325         TValueHolder<TElemNum, med_int> aFamNumNode(theInfo.myFamNumNode);
2326
2327         aRet = MEDfamLire(myFile->Id(),
2328                           &aMeshName,
2329                           &aFamNumNode,
2330                           aNbNodes,
2331                           med_entite_maillage(eNOEUD),
2332                           med_geometrie_element(ePOINT1));
2333
2334         if(theErr)
2335           *theErr = aRet;
2336         else if(aRet < 0)
2337           EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDfamLire(...) of NODES");
2338
2339         //============================
2340       }
2341
2342       if(aMaillageType == eSTRUCTURE && aGrilleType != eGRILLE_STANDARD){
2343         ETable aTable;
2344         for(med_int anAxis = 1; anAxis <= aMeshInfo.myDim; anAxis++){
2345           switch(anAxis){
2346           case 1 :
2347             aTable = eCOOR_IND1;
2348             break;
2349           case 2 :
2350             aTable = eCOOR_IND2;
2351             break;
2352           case 3 :
2353             aTable = eCOOR_IND3;
2354             break;
2355           default :
2356             aRet = -1;
2357           }
2358
2359           if(theErr)
2360             *theErr = aRet;
2361           else if(aRet < 0)
2362             EXCEPTION(std::runtime_error,"GetGrilleInfo - anAxis number out of range(...)");
2363
2364           TInt aNbIndexes = GetNbNodes(aMeshInfo,aTable);
2365           if(aNbIndexes < 0)
2366             EXCEPTION(std::runtime_error,"GetGrilleInfo - Erreur a la lecture de la taille de l'indice");
2367
2368           TValueHolder<TFloatVector, med_float> anIndexes(theInfo.GetIndexes(anAxis-1));
2369           char aCompNames[MED_TAILLE_PNOM+1];
2370           char anUnitNames[MED_TAILLE_PNOM+1];
2371
2372           aRet = MEDindicesCoordLire(myFile->Id(),
2373                                      &aMeshName,
2374                                      aDim,
2375                                      &anIndexes,
2376                                      aNbIndexes,
2377                                      anAxis,
2378                                      aCompNames,
2379                                      anUnitNames);
2380
2381           theInfo.SetCoordName(anAxis-1, aCompNames);
2382           theInfo.SetCoordUnit(anAxis-1, anUnitNames);
2383
2384           if(theErr)
2385             *theErr = aRet;
2386           else if(aRet < 0)
2387             EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDindicesCoordLire(...)");
2388         }
2389       }
2390
2391       EGeometrieElement aGeom = theInfo.GetGeom();
2392       EEntiteMaillage aEntity = theInfo.GetEntity();
2393       TInt aNbCells = theInfo.GetNbCells();
2394
2395       theInfo.myFamNum.resize(aNbCells);
2396       TValueHolder<TElemNum, med_int> aFamNum(theInfo.myFamNum);
2397
2398       aRet = MEDfamLire(myFile->Id(),
2399                         &aMeshName,
2400                         &aFamNum,
2401                         aNbCells,
2402                         med_entite_maillage(aEntity),
2403                         med_geometrie_element(aGeom));
2404
2405       if(theErr)
2406         *theErr = aRet;
2407       else if(aRet < 0){
2408         //EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDfamLire(...) of CELLS");
2409         aRet = 0;
2410         theInfo.myFamNum.resize(0);
2411       }
2412
2413     }
2414
2415     void
2416     TVWrapper
2417     ::GetGrilleType(const MED::TMeshInfo& theMeshInfo,
2418                     EGrilleType& theGrilleType,
2419                     TErr* theErr)
2420     {
2421       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
2422
2423       if(theErr && *theErr < 0)
2424         EXCEPTION(std::runtime_error," GetGrilleType - aFileWrapper (...)");
2425
2426       MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
2427
2428       if(aMeshInfo.myType == eSTRUCTURE){
2429         TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
2430         TValueHolder<EGrilleType, med_type_grille> aGrilleType(theGrilleType);
2431
2432         TErr aRet = MEDnatureGrilleLire(myFile->Id(),
2433                                         &aMeshName,
2434                                         &aGrilleType);
2435         if(aRet < 0)
2436           EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDnatureGrilleLire(...)");
2437       }
2438     }
2439
2440     void
2441     TVWrapper
2442     ::GetGrilleStruct(const MED::TMeshInfo& theMeshInfo,
2443                       TIntVector& theStruct,
2444                       TErr* theErr)
2445     {
2446       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
2447
2448       if(theErr && *theErr < 0)
2449           return;
2450
2451       TErr aRet;
2452       MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
2453
2454       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
2455       TValueHolder<TInt, med_int> aDim(aMeshInfo.myDim);
2456       TValueHolder<TIntVector, med_int> aGrilleStructure(theStruct);
2457
2458       aRet = MEDstructureCoordLire(myFile->Id(),
2459                                    &aMeshName,
2460                                    aDim,
2461                                    &aGrilleStructure);
2462       if(theErr)
2463         *theErr = aRet;
2464       else if(aRet < 0)
2465         EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDstructureCoordLire(...)");
2466     }
2467
2468   }
2469 }