src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx

   1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  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, or (at your option) any later version.
  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 #include "MED_V2_2_Wrapper.hxx"
  24 #include "MED_Algorithm.hxx"
  25 #include "MED_Utilities.hxx"
  26
  27 #include <med.h>
  28 #include <med_err.h>
  29
  30 #ifdef _DEBUG_
  31 static int MYDEBUG = 0;
  32 // #else
  33 // static int MYDEBUG = 0;
  34 #endif
  35
  36
  37
  38 namespace MED
  39 {
  40   template<>
  41   TInt
  42   GetDESCLength<eV2_2>()
  43   {
  44     return 200;
  45   }
  46
  47   template<>
  48   TInt
  49   GetIDENTLength<eV2_2>()
  50   {
  51     return 8;
  52   }
  53
  54   template<>
  55   TInt
  56   GetNOMLength<eV2_2>()
  57   {
  58     return 64;
  59   }
  60
  61   template<>
  62   TInt
  63   GetLNOMLength<eV2_2>()
  64   {
  65     return 80;
  66   }
  67
  68   template<>
  69   TInt
  70   GetPNOMLength<eV2_2>()
  71   {
  72     return 16;
  73   }
  74
  75   template<>
  76   void
  77   GetVersionRelease<eV2_2>(TInt& majeur, TInt& mineur, TInt& release)
  78   {
  79     majeur=MED_MAJOR_NUM;
  80     mineur=MED_MINOR_NUM;
  81     release=MED_RELEASE_NUM;
  82   }
  83
  84   template<>
  85   TInt
  86   GetNbConn<eV2_2>(EGeometrieElement typmai,
  87                    EEntiteMaillage typent,
  88                    TInt mdim)
  89   {
  90     return typmai%100;
  91   }
  92
  93   namespace V2_2
  94   {
  95
  96     //---------------------------------------------------------------
  97     class TFile{
  98       TFile();
  99       TFile(const TFile&);
 100
 101     public:
 102       TFile(const std::string& theFileName):
 103         myCount(0),
 104         myFid(0),
 105         myFileName(theFileName)
 106       {}
 107
 108       ~TFile()
 109       {
 110         Close();
 111       }
 112
 113       void
 114       Open(EModeAcces theMode, TErr* theErr = NULL)
 115       {
 116         if(myCount++ == 0){
 117           const char* aFileName = myFileName.c_str();
 118           myFid = MEDfileOpen(aFileName,med_access_mode(theMode));
 119         }
 120         if(theErr)
 121           *theErr = TErr(myFid);
 122         else if(myFid < 0)
 123           EXCEPTION(std::runtime_error,"TFile - MEDfileOpen('"<<myFileName<<"',"<<theMode<<")");
 124       }
 125
 126       const TIdt& Id() const
 127       {
 128         if(myFid < 0)
 129           EXCEPTION(std::runtime_error,"TFile - GetFid() < 0");
 130         return myFid;
 131       }
 132
 133       void Close()
 134       {
 135         if(--myCount == 0)
 136           MEDfileClose(myFid);
 137       }
 138
 139     protected:
 140       TInt myCount;
 141       TIdt myFid;
 142       std::string myFileName;
 143     };
 144
 145
 146     //---------------------------------------------------------------
 147     class TFileWrapper
 148     {
 149       PFile myFile;
 150
 151     public:
 152       TFileWrapper(const PFile& theFile, EModeAcces theMode, TErr* theErr = NULL):
 153         myFile(theFile)
 154       {
 155         myFile->Open(theMode,theErr);
 156       }
 157
 158       ~TFileWrapper()
 159       {
 160         myFile->Close();
 161       }
 162     };
 163
 164
 165     //---------------------------------------------------------------
 166     TVWrapper::TVWrapper(const std::string& theFileName):
 167       myFile(new TFile(theFileName))
 168     {
 169       TErr aRet;
 170       myFile->Open( eLECTURE_ECRITURE, &aRet );
 171       // if(aRet < 0)
 172       //   myFile->Close();
 173       //   myFile->Open( eLECTURE_AJOUT, &aRet );
 174       // }
 175       if(aRet < 0) {
 176         myFile->Close();
 177         myFile->Open( eLECTURE, &aRet );
 178       }
 179       if(aRet < 0) {
 180         myFile->Close();
 181         myFile->Open( eCREATION, &aRet );
 182       }
 183     }
 184
 185
 186     //----------------------------------------------------------------------------
 187     TInt
 188     TVWrapper
 189     ::GetNbMeshes(TErr* theErr)
 190     {
 191       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 192
 193       if(theErr && *theErr < 0)
 194         return -1;
 195
 196       return MEDnMesh(myFile->Id());
 197     }
 198
 199
 200     //----------------------------------------------------------------------------
 201     void
 202     TVWrapper
 203     ::GetMeshInfo(TInt theMeshId,
 204                   MED::TMeshInfo& theInfo,
 205                   TErr* theErr)
 206     {
 207       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 208
 209       if(theErr && *theErr < 0)
 210         return;
 211
 212       TValueHolder<TString, char> aMeshName(theInfo.myName);
 213       TValueHolder<TInt, med_int> aDim(theInfo.myDim);
 214       TValueHolder<TInt, med_int> aSpaceDim(theInfo.mySpaceDim);
 215       TValueHolder<EMaillage, med_mesh_type> aType(theInfo.myType);
 216       char dtunit[MED_SNAME_SIZE+1];
 217       med_sorting_type sorttype;
 218       med_int nstep;
 219       med_axis_type at;
 220       int naxis=MEDmeshnAxis(myFile->Id(),theMeshId);
 221       char *axisname=new char[naxis*MED_SNAME_SIZE+1];
 222       char *axisunit=new char[naxis*MED_SNAME_SIZE+1];
 223       TErr aRet = MEDmeshInfo(myFile->Id(),
 224                               theMeshId,
 225                               &aMeshName,
 226                               &aSpaceDim,
 227                               &aDim,
 228                               &aType,
 229                               &theInfo.myDesc[0],
 230                               dtunit,
 231                               &sorttype,
 232                               &nstep,
 233                               &at,
 234                               axisname,
 235                               axisunit);
 236       delete [] axisname;
 237       delete [] axisunit;
 238       if(aRet < 0)
 239         EXCEPTION(std::runtime_error,"GetMeshInfo - MEDmeshInfo(...)");
 240     }
 241
 242
 243     //----------------------------------------------------------------------------
 244     void
 245     TVWrapper
 246     ::SetMeshInfo(const MED::TMeshInfo& theInfo,
 247                   EModeAcces theMode,
 248                   TErr* theErr)
 249     {
 250       TFileWrapper aFileWrapper(myFile,theMode,theErr);
 251
 252       if(theErr && *theErr < 0)
 253         return;
 254
 255       MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
 256
 257       TValueHolder<TString, char> aMeshName(anInfo.myName);
 258       TValueHolder<TInt, med_int> aDim(anInfo.myDim);
 259       TValueHolder<TInt, med_int> aSpaceDim(anInfo.mySpaceDim);
 260       TValueHolder<EMaillage, med_mesh_type> aType(anInfo.myType);
 261       TValueHolder<TString, char> aDesc(anInfo.myDesc);
 262
 263       char *nam=new char[aSpaceDim*MED_SNAME_SIZE+1];
 264       std::fill(nam,nam+aSpaceDim*MED_SNAME_SIZE+1,'\0');
 265       char *unit=new char[aSpaceDim*MED_SNAME_SIZE+1];
 266       std::fill(unit,unit+aSpaceDim*MED_SNAME_SIZE+1,'\0');
 267       TErr aRet = MEDmeshCr(myFile->Id(),
 268                             &aMeshName,
 269                             aSpaceDim,
 270                             aDim,
 271                             aType,
 272                             &aDesc,
 273                             "",
 274                             MED_SORT_DTIT,
 275                             MED_CARTESIAN,
 276                             nam,
 277                             unit);
 278       delete [] nam;
 279       delete [] unit;
 280
 281       //if(aRet == 0)
 282       //  aRet = MEDunvCr(myFile->Id(),&aMeshName);
 283
 284       INITMSG(MYDEBUG,"TVWrapper::SetMeshInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
 285
 286       if(theErr)
 287         *theErr = aRet;
 288       else if(aRet < 0)
 289         EXCEPTION(std::runtime_error,"SetMeshInfo - MEDmeshCr(...)");
 290     }
 291
 292
 293     //----------------------------------------------------------------------------
 294     void
 295     TVWrapper
 296     ::SetMeshInfo(const MED::TMeshInfo& theInfo,
 297                   TErr* theErr)
 298     {
 299       TErr aRet;
 300       SetMeshInfo(theInfo,eLECTURE_ECRITURE,&aRet);
 301
 302       if(aRet < 0)
 303         SetMeshInfo(theInfo,eLECTURE_AJOUT,&aRet);
 304
 305       if(aRet < 0)
 306         SetMeshInfo(theInfo,eCREATION,&aRet);
 307
 308       if(theErr)
 309         *theErr = aRet;
 310     }
 311
 312
 313     //----------------------------------------------------------------------------
 314     TInt
 315     TVWrapper
 316     ::GetNbFamilies(const MED::TMeshInfo& theInfo,
 317                     TErr* theErr)
 318     {
 319       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 320
 321       if(theErr && *theErr < 0)
 322         return -1;
 323
 324       MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
 325       TValueHolder<TString, char> aName(anInfo.myName);
 326       return MEDnFamily(myFile->Id(),&aName);
 327     }
 328
 329
 330     //----------------------------------------------------------------------------
 331     TInt
 332     TVWrapper
 333     ::GetNbFamAttr(TInt theFamId,
 334                    const MED::TMeshInfo& theInfo,
 335                    TErr* theErr)
 336     {
 337       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 338
 339       if(theErr && *theErr < 0)
 340         return -1;
 341
 342       MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
 343
 344       TValueHolder<TString, char> aName(anInfo.myName);
 345
 346       return MEDnFamily23Attribute(myFile->Id(),&aName,theFamId);
 347     }
 348
 349
 350     //----------------------------------------------------------------------------
 351     TInt
 352     TVWrapper
 353     ::GetNbFamGroup(TInt theFamId,
 354                     const MED::TMeshInfo& theInfo,
 355                     TErr* theErr)
 356     {
 357       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 358
 359       if(theErr && *theErr < 0)
 360         return -1;
 361
 362       MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
 363
 364       TValueHolder<TString, char> aName(anInfo.myName);
 365
 366       return MEDnFamilyGroup(myFile->Id(),&aName,theFamId);
 367     }
 368
 369
 370     //----------------------------------------------------------------------------
 371     void
 372     TVWrapper
 373     ::GetFamilyInfo(TInt theFamId,
 374                     MED::TFamilyInfo& theInfo,
 375                     TErr* theErr)
 376     {
 377       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 378
 379       if(theErr && *theErr < 0)
 380         return;
 381
 382       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
 383
 384       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 385       TValueHolder<TString, char> aFamilyName(theInfo.myName);
 386       TValueHolder<TInt, med_int> aFamilyId(theInfo.myId);
 387       TValueHolder<TFamAttr, med_int> anAttrId(theInfo.myAttrId);
 388       TValueHolder<TFamAttr, med_int> anAttrVal(theInfo.myAttrVal);
 389       TValueHolder<TString, char> anAttrDesc(theInfo.myAttrDesc);
 390       TValueHolder<TString, char> aGroupNames(theInfo.myGroupNames);
 391
 392       TErr aRet = MEDfamily23Info(myFile->Id(),
 393                                   &aMeshName,
 394                                   theFamId,
 395                                   &aFamilyName,
 396                                   &anAttrId,
 397                                   &anAttrVal,
 398                                   &anAttrDesc,
 399                                   &aFamilyId,
 400                                   &aGroupNames);
 401
 402       if(theErr)
 403         *theErr = aRet;
 404       else if(aRet < 0)
 405         EXCEPTION(std::runtime_error,"GetFamilyInfo - MEDfamily23Info(...) - "<<
 406                   " aMeshInfo.myName = '"<<&aMeshName<<
 407                   "'; theFamId = "<<theFamId<<
 408                   "; theInfo.myNbGroup = "<<theInfo.myNbGroup<<
 409                   "; theInfo.myNbAttr = "<<theInfo.myNbAttr);
 410     }
 411
 412
 413     //----------------------------------------------------------------------------
 414     void
 415     TVWrapper
 416     ::SetFamilyInfo(const MED::TFamilyInfo& theInfo,
 417                     EModeAcces theMode,
 418                     TErr* theErr)
 419     {
 420       TFileWrapper aFileWrapper(myFile,theMode,theErr);
 421
 422       if(theErr && *theErr < 0)
 423         return;
 424
 425       MED::TFamilyInfo& anInfo = const_cast<MED::TFamilyInfo&>(theInfo);
 426       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
 427
 428       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 429       TValueHolder<TString, char> aFamilyName(anInfo.myName);
 430       TValueHolder<TInt, med_int> aFamilyId(anInfo.myId);
 431       TValueHolder<TFamAttr, med_int> anAttrId(anInfo.myAttrId);
 432       TValueHolder<TFamAttr, med_int> anAttrVal(anInfo.myAttrVal);
 433       TValueHolder<TInt, med_int> aNbAttr(anInfo.myNbAttr);
 434       TValueHolder<TString, char> anAttrDesc(anInfo.myAttrDesc);
 435       TValueHolder<TInt, med_int> aNbGroup(anInfo.myNbGroup);
 436       TValueHolder<TString, char> aGroupNames(anInfo.myGroupNames);
 437
 438       TErr aRet = MEDfamilyCr(myFile->Id(),
 439                               &aMeshName,
 440                               &aFamilyName,
 441                               aFamilyId,
 442                               aNbGroup,
 443                               &aGroupNames);
 444
 445       INITMSG(MYDEBUG,"TVWrapper::SetFamilyInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
 446
 447       if(theErr)
 448         *theErr = aRet;
 449       else if(aRet < 0)
 450         EXCEPTION(std::runtime_error,"SetFamilyInfo - MEDfamilyCr(...)");
 451     }
 452
 453
 454     //----------------------------------------------------------------------------
 455     void
 456     TVWrapper
 457     ::SetFamilyInfo(const MED::TFamilyInfo& theInfo,
 458                     TErr* theErr)
 459     {
 460       TErr aRet;
 461       SetFamilyInfo(theInfo,eLECTURE_ECRITURE,&aRet);
 462
 463       if(aRet < 0)
 464         SetFamilyInfo(theInfo,eLECTURE_AJOUT,&aRet);
 465
 466       if(theErr)
 467         *theErr = aRet;
 468     }
 469
 470     //----------------------------------------------------------------------------
 471     void
 472     TVWrapper
 473     ::GetNames(TElemInfo&        theInfo,
 474                TInt              theNb,
 475                EEntiteMaillage   theEntity,
 476                EGeometrieElement theGeom,
 477                TErr*             theErr)
 478     {
 479       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 480
 481       if(theErr && *theErr < 0)
 482         return;
 483
 484       if ( theGeom == eBALL )
 485         theGeom = GetBallGeom( theInfo.myMeshInfo );
 486
 487       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
 488
 489       TValueHolder<TString, char>                        aMeshName  (aMeshInfo.myName);
 490       TValueHolder<TString, char>                        anElemNames(theInfo.myElemNames);
 491       TValueHolder<EEntiteMaillage, med_entity_type>     anEntity   (theEntity);
 492       TValueHolder<EGeometrieElement, med_geometry_type> aGeom      (theGeom);
 493
 494       TErr aRet = MEDmeshEntityNameRd(myFile->Id(),
 495                                       &aMeshName,
 496                                       MED_NO_DT,
 497                                       MED_NO_IT,
 498                                       anEntity,
 499                                       aGeom,
 500                                       &anElemNames);
 501
 502       theInfo.myIsElemNames = aRet != 0? eFAUX : eVRAI ;
 503
 504       if(theErr)
 505         *theErr = aRet;
 506     }
 507
 508     //----------------------------------------------------------------------------
 509     void
 510     TVWrapper
 511     ::GetNumeration(TElemInfo&        theInfo,
 512                     TInt              theNb,
 513                     EEntiteMaillage   theEntity,
 514                     EGeometrieElement theGeom,
 515                     TErr*             theErr)
 516     {
 517       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 518
 519       if(theErr && *theErr < 0)
 520         return;
 521
 522       if ( theGeom == eBALL )
 523         theGeom = GetBallGeom( theInfo.myMeshInfo );
 524
 525       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
 526
 527       TValueHolder<TString, char>                        aMeshName(aMeshInfo.myName);
 528       TValueHolder<TElemNum, med_int>                    anElemNum(theInfo.myElemNum);
 529       TValueHolder<EEntiteMaillage, med_entity_type>     anEntity (theEntity);
 530       TValueHolder<EGeometrieElement, med_geometry_type> aGeom    (theGeom);
 531
 532       TErr aRet = MEDmeshEntityNumberRd(myFile->Id(),
 533                                         &aMeshName,
 534                                         MED_NO_DT,
 535                                         MED_NO_IT,
 536                                         anEntity,
 537                                         aGeom,
 538                                         &anElemNum);
 539
 540       theInfo.myIsElemNum = aRet != 0? eFAUX : eVRAI;
 541
 542       if(theErr)
 543         *theErr = aRet;
 544     }
 545
 546     //----------------------------------------------------------------------------
 547     void
 548     TVWrapper
 549     ::GetFamilies(TElemInfo&        theInfo,
 550                   TInt              theNb,
 551                   EEntiteMaillage   theEntity,
 552                   EGeometrieElement theGeom,
 553                   TErr*             theErr)
 554     {
 555       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 556
 557       if(theErr && *theErr < 0)
 558         return;
 559
 560       if ( theGeom == eBALL )
 561         theGeom = GetBallGeom( theInfo.myMeshInfo );
 562
 563       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
 564
 565       TValueHolder<TString, char>                        aMeshName(aMeshInfo.myName);
 566       TValueHolder<TElemNum, med_int>                    aFamNum  (theInfo.myFamNum);
 567       TValueHolder<EEntiteMaillage, med_entity_type>     anEntity (theEntity);
 568       TValueHolder<EGeometrieElement, med_geometry_type> aGeom    (theGeom);
 569
 570       TErr aRet = MEDmeshEntityFamilyNumberRd(myFile->Id(),
 571                                               &aMeshName,
 572                                               MED_NO_DT,
 573                                               MED_NO_IT,
 574                                               anEntity,
 575                                               aGeom,
 576                                               &aFamNum);
 577
 578       if(aRet < 0)
 579       {
 580 //        if (aRet == MED_ERR_DOESNTEXIST) // --- only valid with MED3.x files
 581           {
 582             int aSize = (int)theInfo.myFamNum->size();
 583             theInfo.myFamNum->clear();
 584             theInfo.myFamNum->resize(aSize,0);
 585             aRet = 0;
 586           }
 587 //        else
 588 //          EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshEntityFamilyNumberRd(...) of CELLS");
 589       }
 590       if(theErr)
 591         *theErr = aRet;
 592     }
 593
 594
 595     //----------------------------------------------------------------------------
 596     void
 597     TVWrapper
 598     ::SetNames(const TElemInfo& theInfo,
 599                EEntiteMaillage theEntity,
 600                EGeometrieElement theGeom,
 601                TErr* theErr)
 602     {
 603       SetNames(theInfo,eLECTURE_ECRITURE,theEntity,theGeom,theErr);
 604     }
 605
 606
 607     //----------------------------------------------------------------------------
 608     void
 609     TVWrapper
 610     ::SetNames(const TElemInfo&  theInfo,
 611                EModeAcces        theMode,
 612                EEntiteMaillage   theEntity,
 613                EGeometrieElement theGeom,
 614                TErr*             theErr)
 615     {
 616       TFileWrapper aFileWrapper(myFile,theMode,theErr);
 617
 618       if(theErr && *theErr < 0)
 619         return;
 620
 621       if ( theGeom == eBALL )
 622         theGeom = GetBallGeom( theInfo.myMeshInfo );
 623
 624       MED::TElemInfo& anInfo = const_cast<MED::TElemInfo&>(theInfo);
 625       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
 626
 627       TErr aRet = 0;
 628       if(theInfo.myIsElemNames)
 629       {
 630         TValueHolder<TString, char>                        aMeshName  (aMeshInfo.myName);
 631         TValueHolder<TString, char>                        anElemNames(anInfo.myElemNames);
 632         TValueHolder<EEntiteMaillage, med_entity_type>     anEntity   (theEntity);
 633         TValueHolder<EGeometrieElement, med_geometry_type> aGeom      (theGeom);
 634
 635         aRet  = MEDmeshEntityNameWr(myFile->Id(),
 636                                     &aMeshName,
 637                                     MED_NO_DT,
 638                                     MED_NO_IT,
 639                                     anEntity,
 640                                     aGeom,
 641                                     (TInt)anInfo.myElemNames->size(),
 642                                     &anElemNames);
 643         if(theErr)
 644           *theErr = aRet;
 645         else if(aRet < 0)
 646           EXCEPTION(std::runtime_error,"SetNames - MEDmeshEntityNameWr(...)");
 647       }
 648     }
 649
 650
 651     //----------------------------------------------------------------------------
 652     void
 653     TVWrapper
 654     ::SetNumeration(const TElemInfo& theInfo,
 655                     EEntiteMaillage theEntity,
 656                     EGeometrieElement theGeom,
 657                     TErr* theErr)
 658     {
 659       SetNumeration(theInfo,eLECTURE_ECRITURE,theEntity,theGeom,theErr);
 660     }
 661
 662
 663     //----------------------------------------------------------------------------
 664     void
 665     TVWrapper
 666     ::SetNumeration(const TElemInfo&  theInfo,
 667                     EModeAcces        theMode,
 668                     EEntiteMaillage   theEntity,
 669                     EGeometrieElement theGeom,
 670                     TErr*             theErr)
 671     {
 672       TFileWrapper aFileWrapper(myFile,theMode,theErr);
 673
 674       if(theErr && *theErr < 0)
 675         return;
 676
 677       if ( theGeom == eBALL )
 678         theGeom = GetBallGeom( theInfo.myMeshInfo );
 679
 680       MED::TElemInfo& anInfo = const_cast<MED::TElemInfo&>(theInfo);
 681       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
 682
 683       TErr aRet = 0;
 684       if(theInfo.myIsElemNum)
 685       {
 686         TValueHolder<TString, char>                        aMeshName(aMeshInfo.myName);
 687         TValueHolder<TElemNum, med_int>                    anElemNum(anInfo.myElemNum);
 688         TValueHolder<EEntiteMaillage, med_entity_type>     anEntity (theEntity);
 689         TValueHolder<EGeometrieElement, med_geometry_type> aGeom    (theGeom);
 690
 691         aRet  = MEDmeshEntityNumberWr(myFile->Id(),
 692                                       &aMeshName,
 693                                       MED_NO_DT,
 694                                       MED_NO_IT,
 695                                       anEntity,
 696                                       aGeom,
 697                                       (TInt)anInfo.myElemNum->size(),
 698                                       &anElemNum);
 699         if(theErr)
 700           *theErr = aRet;
 701         else if(aRet < 0)
 702           EXCEPTION(std::runtime_error,"SetNumeration - MEDmeshEntityNumberWr(...)");
 703       }
 704     }
 705
 706     //----------------------------------------------------------------------------
 707     void
 708     TVWrapper
 709     ::SetFamilies(const TElemInfo&  theInfo,
 710                   EEntiteMaillage   theEntity,
 711                   EGeometrieElement theGeom,
 712                   TErr*             theErr)
 713     {
 714       SetFamilies(theInfo,eLECTURE_ECRITURE,theEntity,theGeom,theErr);
 715     }
 716
 717     //----------------------------------------------------------------------------
 718     void
 719     TVWrapper
 720     ::SetFamilies(const TElemInfo&  theInfo,
 721                   EModeAcces        theMode,
 722                   EEntiteMaillage   theEntity,
 723                   EGeometrieElement theGeom,
 724                   TErr*             theErr)
 725     {
 726       TFileWrapper aFileWrapper(myFile,theMode,theErr);
 727
 728       if(theErr && *theErr < 0)
 729         return;
 730
 731       if ( theGeom == eBALL )
 732         theGeom = GetBallGeom( theInfo.myMeshInfo );
 733
 734       MED::TElemInfo& anInfo = const_cast<MED::TElemInfo&>(theInfo);
 735       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
 736
 737       TValueHolder<TString, char>                        aMeshName(aMeshInfo.myName);
 738       TValueHolder<TElemNum, med_int>                    aFamNum  (anInfo.myFamNum);
 739       TValueHolder<EEntiteMaillage, med_entity_type>     anEntity (theEntity);
 740       TValueHolder<EGeometrieElement, med_geometry_type> aGeom    (theGeom);
 741
 742       TErr aRet = MEDmeshEntityFamilyNumberWr(myFile->Id(),
 743                                               &aMeshName,
 744                                               MED_NO_DT,
 745                                               MED_NO_IT,
 746                                               anEntity,
 747                                               aGeom,
 748                                               (TInt)anInfo.myFamNum->size(),
 749                                               &aFamNum);
 750
 751       if(theErr)
 752         *theErr = aRet;
 753       else if(aRet < 0)
 754         EXCEPTION(std::runtime_error,"SetFamilies - MEDmeshEntityFamilyNumberWr(...)");
 755     }
 756
 757     //----------------------------------------------------------------------------
 758     TInt
 759     TVWrapper
 760     ::GetNbNodes(const MED::TMeshInfo& theMeshInfo,
 761                  ETable theTable,
 762                  TErr* theErr)
 763     {
 764       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 765
 766       if(theErr && *theErr < 0)
 767         return -1;
 768
 769       MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
 770
 771       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 772       TValueHolder<ETable, med_data_type > aTable(theTable);
 773       med_bool chgt,trsf;
 774       return MEDmeshnEntity(myFile->Id(),
 775                             &aMeshName,
 776                             MED_NO_DT,
 777                             MED_NO_IT,
 778                             MED_NODE,
 779                             MED_NO_GEOTYPE,
 780                             aTable,
 781                             MED_NO_CMODE,
 782                             &chgt,
 783                             &trsf);
 784     }
 785
 786
 787     //----------------------------------------------------------------------------
 788     void
 789     TVWrapper
 790     ::GetNodeInfo(MED::TNodeInfo& theInfo,
 791                   TErr* theErr)
 792     {
 793       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 794
 795       if(theErr && *theErr < 0)
 796         return;
 797
 798       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
 799
 800       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
 801       TValueHolder<TInt, med_int> aDim(aMeshInfo.myDim);
 802       TValueHolder<TNodeCoord, med_float> aCoord(theInfo.myCoord);
 803       TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(theInfo.myModeSwitch);
 804       TValueHolder<ERepere, med_axis_type> aSystem(theInfo.mySystem);
 805       TValueHolder<TString, char> aCoordNames(theInfo.myCoordNames);
 806       TValueHolder<TString, char> aCoordUnits(theInfo.myCoordUnits);
 807       TValueHolder<TString, char> anElemNames(theInfo.myElemNames);
 808       //TValueHolder<EBooleen, med_bool> anIsElemNames(theInfo.myIsElemNames);
 809       TValueHolder<TElemNum, med_int> anElemNum(theInfo.myElemNum);
 810       //TValueHolder<EBooleen, med_bool> anIsElemNum(theInfo.myIsElemNum);
 811       TValueHolder<TElemNum, med_int> aFamNum(theInfo.myFamNum);
 812       TValueHolder<TInt, med_int> aNbElem(theInfo.myNbElem);
 813
 814       TErr aRet = MEDmeshNodeCoordinateRd(myFile->Id(),
 815                                           &aMeshName,
 816                                           MED_NO_DT,
 817                                           MED_NO_IT,
 818                                           aModeSwitch,
 819                                           &aCoord);
 820
 821       TErr aRet2 =MEDmeshEntityFamilyNumberRd(myFile->Id(),
 822                                   &aMeshName,
 823                                   MED_NO_DT,
 824                                   MED_NO_IT,
 825                                   MED_NODE,
 826                                   MED_NO_GEOTYPE ,
 827                                   &aFamNum);
 828       if (aRet2  < 0)
 829       {
 830 //        if (aRet2 == MED_ERR_DOESNTEXIST) // --- only valid with MED3.x files
 831           {
 832             int mySize = (int)theInfo.myFamNum->size();
 833             theInfo.myFamNum->clear();
 834             theInfo.myFamNum->resize(mySize,0);
 835           }
 836 //        else
 837 //          EXCEPTION(std::runtime_error,"GetNodeInfo - MEDmeshEntityFamilyNumberRd(...)");
 838       }
 839
 840       if ( MEDmeshEntityNameRd(myFile->Id(),
 841                           &aMeshName,
 842                           MED_NO_DT,
 843                           MED_NO_IT,
 844                           MED_NODE,
 845                           MED_NO_GEOTYPE ,
 846                           &anElemNames) < 0) theInfo.myIsElemNames=eFAUX;
 847
 848       if ( MEDmeshEntityNumberRd(myFile->Id(),
 849                             &aMeshName,
 850                             MED_NO_DT,
 851                             MED_NO_IT,
 852                             MED_NODE,
 853                             MED_NO_GEOTYPE ,
 854                             &anElemNum) < 0 ) theInfo.myIsElemNum=eFAUX;
 855
 856       if(theErr)
 857         *theErr = aRet;
 858       else if(aRet < 0)
 859         EXCEPTION(std::runtime_error,"GetNodeInfo - MEDmeshNodeCoordinateRd(...)");
 860     }
 861
 862
 863     //----------------------------------------------------------------------------
 864     void
 865     TVWrapper
 866     ::SetNodeInfo(const MED::TNodeInfo& theInfo,
 867                   EModeAcces theMode,
 868                   TErr* theErr)
 869     {
 870       TFileWrapper aFileWrapper(myFile,theMode,theErr);
 871
 872       if(theErr && *theErr < 0)
 873         return;
 874
 875       MED::TNodeInfo& anInfo = const_cast<MED::TNodeInfo&>(theInfo);
 876       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
 877
 878       TValueHolder<TString, char>                aMeshName    (aMeshInfo.myName);
 879       TValueHolder<TNodeCoord, med_float>        aCoord       (anInfo.myCoord);
 880       TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch  (anInfo.myModeSwitch);
 881       TValueHolder<ERepere, med_axis_type>       aSystem      (anInfo.mySystem);
 882       TValueHolder<TString, char>                aCoordNames  (anInfo.myCoordNames);
 883       TValueHolder<TString, char>                aCoordUnits  (anInfo.myCoordUnits);
 884       TValueHolder<TString, char>                anElemNames  (anInfo.myElemNames);
 885       TValueHolder<EBooleen, med_bool>           anIsElemNames(anInfo.myIsElemNames);
 886       TValueHolder<TElemNum, med_int>            anElemNum    (anInfo.myElemNum);
 887       TValueHolder<EBooleen, med_bool>           anIsElemNum  (anInfo.myIsElemNum);
 888       TValueHolder<TElemNum, med_int>            aFamNum      (anInfo.myFamNum);
 889       TValueHolder<TInt, med_int>                aNbElem      (anInfo.myNbElem);
 890
 891       TErr aRet = MEDmeshNodeCoordinateWr(myFile->Id(),
 892                                           &aMeshName,
 893                                           MED_NO_DT,
 894                                           MED_NO_IT,
 895                                           MED_NO_DT,
 896                                           aModeSwitch,
 897                                           aNbElem,
 898                                           &aCoord);
 899
 900       MEDmeshEntityFamilyNumberWr(myFile->Id(),
 901                                   &aMeshName,
 902                                   MED_NO_DT,
 903                                   MED_NO_IT,
 904                                   MED_NODE,
 905                                   MED_NO_GEOTYPE,
 906                                   aNbElem,
 907                                   &aFamNum);
 908       if(anIsElemNames)
 909         MEDmeshEntityNameWr(myFile->Id(),
 910                             &aMeshName,
 911                             MED_NO_DT,
 912                             MED_NO_IT,
 913                             MED_NODE,
 914                             MED_NO_GEOTYPE,
 915                             aNbElem,
 916                             &anElemNames);
 917       if(anIsElemNum)
 918         MEDmeshEntityNumberWr(myFile->Id(),
 919                               &aMeshName,
 920                               MED_NO_DT,
 921                               MED_NO_IT,
 922                               MED_NODE,
 923                               MED_NO_GEOTYPE,
 924                               aNbElem,
 925                               &anElemNum);
 926       if(theErr)
 927         *theErr = aRet;
 928       else if(aRet < 0)
 929         EXCEPTION(std::runtime_error,"SetNodeInfo - MEDmeshNodeCoordinateWr(...)");
 930     }
 931
 932
 933     //----------------------------------------------------------------------------
 934     void
 935     TVWrapper
 936     ::SetNodeInfo(const MED::TNodeInfo& theInfo,
 937                   TErr* theErr)
 938     {
 939       TErr aRet;
 940       SetNodeInfo(theInfo,eLECTURE_ECRITURE,&aRet);
 941
 942       if(aRet < 0)
 943         SetNodeInfo(theInfo,eLECTURE_AJOUT,&aRet);
 944
 945       if(theErr)
 946         *theErr = aRet;
 947     }
 948
 949
 950     //-----------------------------------------------------------------
 951     void
 952     TVWrapper
 953     ::GetPolygoneInfo(MED::TPolygoneInfo& theInfo,
 954                       TErr* theErr)
 955     {
 956       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
 957
 958       if(theErr && *theErr < 0)
 959         return;
 960
 961       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
 962
 963       TValueHolder<TString, char                       > aMeshName(aMeshInfo.myName);
 964       TValueHolder<TElemNum, med_int                   > anIndex  (theInfo.myIndex);
 965       TValueHolder<TElemNum, med_int                   > aConn    (theInfo.myConn);
 966       TValueHolder<EEntiteMaillage, med_entity_type    > anEntity (theInfo.myEntity);
 967       TValueHolder<EGeometrieElement, med_geometry_type> aGeom    (theInfo.myGeom);
 968       TValueHolder<EConnectivite, med_connectivity_mode> aConnMode(theInfo.myConnMode);
 969       TInt aNbElem = (TInt)theInfo.myElemNum->size();
 970
 971       TErr aRet;
 972       aRet = MEDmeshPolygon2Rd(myFile->Id(), &aMeshName,
 973                                MED_NO_DT, MED_NO_IT,
 974                                anEntity, aGeom,
 975                                aConnMode, &anIndex, &aConn);
 976
 977       if(theErr)
 978         *theErr = aRet;
 979       else if(aRet < 0)
 980         EXCEPTION(std::runtime_error,"GetPolygoneInfo - MEDmeshPolygonRd(...)");
 981
 982       if(theInfo.myIsElemNames){
 983         GetNames(theInfo,aNbElem,theInfo.myEntity,theInfo.myGeom,&aRet);
 984         if(theErr)
 985           *theErr = aRet;
 986       }
 987
 988       if(theInfo.myIsElemNum){
 989         GetNumeration(theInfo,aNbElem,theInfo.myEntity,theInfo.myGeom,&aRet);
 990         if(theErr)
 991           *theErr = aRet;
 992       }
 993
 994       GetFamilies(theInfo,aNbElem,theInfo.myEntity,theInfo.myGeom,&aRet);
 995       if(theErr)
 996         *theErr = aRet;
 997     }
 998
 999     //----------------------------------------------------------------------------
1000     void
1001     TVWrapper
1002     ::SetPolygoneInfo(const MED::TPolygoneInfo& theInfo,
1003                       TErr* theErr)
1004     {
1005       SetPolygoneInfo(theInfo,eLECTURE_ECRITURE,theErr);
1006     }
1007
1008     //----------------------------------------------------------------------------
1009     void
1010     TVWrapper
1011     ::SetPolygoneInfo(const MED::TPolygoneInfo& theInfo,
1012                       EModeAcces theMode,
1013                       TErr* theErr)
1014     {
1015       TFileWrapper aFileWrapper(myFile,theMode,theErr);
1016
1017       if(theErr && *theErr < 0)
1018         return;
1019
1020       MED::TPolygoneInfo& anInfo = const_cast<MED::TPolygoneInfo&>(theInfo);
1021       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
1022
1023       TValueHolder<TString, char                       > aMeshName(aMeshInfo.myName);
1024       TValueHolder<TElemNum, med_int                   > anIndex  (anInfo.myIndex);
1025       TValueHolder<TElemNum, med_int                   > aConn    (anInfo.myConn);
1026       TValueHolder<EEntiteMaillage, med_entity_type    > anEntity (anInfo.myEntity);
1027       TValueHolder<EGeometrieElement, med_geometry_type> aGeom    (anInfo.myGeom);
1028       TValueHolder<EConnectivite, med_connectivity_mode> aConnMode(anInfo.myConnMode);
1029
1030       TErr aRet = MEDmeshPolygon2Wr(myFile->Id(), &aMeshName,
1031                                     MED_NO_DT, MED_NO_IT, MED_UNDEF_DT,
1032                                     anEntity, aGeom,
1033                                     aConnMode, anInfo.myNbElem + 1,
1034                                     &anIndex, &aConn);
1035       if(theErr)
1036         *theErr = aRet;
1037       else if(aRet < 0)
1038         EXCEPTION(std::runtime_error,"SetPolygoneInfo - MEDmeshPolygonWr(...)");
1039
1040       SetNames(anInfo,theInfo.myEntity,anInfo.myGeom,&aRet);
1041       if(theErr)
1042         *theErr = aRet;
1043
1044       SetNumeration(anInfo,theInfo.myEntity,anInfo.myGeom,&aRet);
1045       if(theErr)
1046         *theErr = aRet;
1047
1048       SetFamilies(anInfo,theInfo.myEntity,anInfo.myGeom,&aRet);
1049       if(theErr)
1050         *theErr = aRet;
1051     }
1052
1053     //----------------------------------------------------------------------------
1054     TInt
1055     TVWrapper
1056     ::GetNbPolygones(const MED::TMeshInfo& theMeshInfo,
1057                      EEntiteMaillage theEntity,
1058                      EGeometrieElement theGeom,
1059                      EConnectivite theConnMode,
1060                      TErr* theErr)
1061     {
1062       return GetNbCells(theMeshInfo,theEntity,theGeom,theConnMode,theErr);
1063     }
1064
1065     //----------------------------------------------------------------------------
1066     TInt
1067     TVWrapper
1068     ::GetPolygoneConnSize(const MED::TMeshInfo& theMeshInfo,
1069                           EEntiteMaillage theEntity,
1070                           EGeometrieElement theGeom,
1071                           EConnectivite theConnMode,
1072                           TErr* theErr)
1073     {
1074       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1075
1076       if(theErr && *theErr < 0)
1077         return 0;
1078
1079       MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
1080
1081       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1082       med_int aTaille = 0;
1083       med_bool chgt,trsf;
1084       aTaille=MEDmeshnEntity(myFile->Id(),
1085                              &aMeshName,
1086                              MED_NO_DT,
1087                              MED_NO_IT,
1088                              med_entity_type(theEntity),
1089                              med_geometry_type(theGeom),
1090                              MED_CONNECTIVITY,
1091                              med_connectivity_mode(theConnMode),
1092                              &chgt,
1093                              &trsf);
1094
1095
1096       if(aTaille < 0)
1097         EXCEPTION(std::runtime_error,"GetPolygoneInfo - MEDmeshnEntity(...)");
1098
1099       return TInt(aTaille);
1100     }
1101
1102     //-----------------------------------------------------------------
1103     void
1104     TVWrapper
1105     ::GetPolyedreInfo(TPolyedreInfo& theInfo,
1106                       TErr* theErr)
1107     {
1108       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1109
1110       if(theErr && *theErr < 0)
1111         return;
1112
1113       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
1114
1115       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1116       TInt aNbElem = (TInt)theInfo.myElemNum->size();
1117       TValueHolder<TElemNum, med_int> anIndex(theInfo.myIndex);
1118       TValueHolder<TElemNum, med_int> aFaces(theInfo.myFaces);
1119       TValueHolder<TElemNum, med_int> aConn(theInfo.myConn);
1120       TValueHolder<EConnectivite, med_connectivity_mode> aConnMode(theInfo.myConnMode);
1121
1122       TErr aRet;
1123       aRet = MEDmeshPolyhedronRd(myFile->Id(),
1124                                  &aMeshName,
1125                                  MED_NO_DT,
1126                                  MED_NO_IT,
1127                                  MED_CELL,
1128                                  aConnMode,
1129                                  &anIndex,
1130                                  &aFaces,
1131                                  &aConn);
1132
1133       if(theErr)
1134         *theErr = aRet;
1135       else if(aRet < 0)
1136         EXCEPTION(std::runtime_error,"GetPolygoneInfo - MEDmeshPolyhedronRd(...)");
1137
1138       if(theInfo.myIsElemNames){
1139         GetNames(theInfo,aNbElem,theInfo.myEntity,ePOLYEDRE,&aRet);
1140         if(theErr)
1141           *theErr = aRet;
1142       }
1143
1144       if(theInfo.myIsElemNum){
1145         GetNumeration(theInfo,aNbElem,theInfo.myEntity,ePOLYEDRE,&aRet);
1146         if(theErr)
1147           *theErr = aRet;
1148       }
1149
1150       GetFamilies(theInfo,aNbElem,theInfo.myEntity,ePOLYEDRE,&aRet);
1151       if(theErr)
1152         *theErr = aRet;
1153     }
1154
1155     //----------------------------------------------------------------------------
1156     void
1157     TVWrapper
1158     ::SetPolyedreInfo(const TPolyedreInfo& theInfo,
1159                       TErr* theErr)
1160     {
1161       SetPolyedreInfo(theInfo,eLECTURE_ECRITURE,theErr);
1162     }
1163
1164     //----------------------------------------------------------------------------
1165     void
1166     TVWrapper
1167     ::SetPolyedreInfo(const MED::TPolyedreInfo& theInfo,
1168                       EModeAcces theMode,
1169                       TErr* theErr)
1170     {
1171       TFileWrapper aFileWrapper(myFile,theMode,theErr);
1172
1173       if(theErr && *theErr < 0)
1174         return;
1175
1176       MED::TPolyedreInfo& anInfo = const_cast<MED::TPolyedreInfo&>(theInfo);
1177       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
1178
1179       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1180       TValueHolder<TElemNum, med_int> anIndex(anInfo.myIndex);
1181       TValueHolder<TElemNum, med_int> aFaces(anInfo.myFaces);
1182       TValueHolder<TElemNum, med_int> aConn(anInfo.myConn);
1183       TValueHolder<EConnectivite, med_connectivity_mode> aConnMode(anInfo.myConnMode);
1184
1185       TErr aRet;
1186       aRet = MEDmeshPolyhedronWr(myFile->Id(),
1187                                  &aMeshName,
1188                                  MED_NO_DT,
1189                                  MED_NO_IT,
1190                                  MED_UNDEF_DT,
1191                                  MED_CELL,
1192                                  aConnMode,
1193                                  anInfo.myNbElem+1,
1194                                  &anIndex,
1195                                  (TInt)anInfo.myFaces->size(),
1196                                  &aFaces,
1197                                  &aConn);
1198
1199       if(theErr)
1200         *theErr = aRet;
1201       else if(aRet < 0)
1202         EXCEPTION(std::runtime_error,"SetPolyedreInfo - MEDmeshPolyhedronWr(...)");
1203
1204       TValueHolder<EEntiteMaillage, med_entity_type> anEntity(anInfo.myEntity);
1205
1206       if(theInfo.myIsElemNames){
1207         TValueHolder<TString, char> anElemNames(anInfo.myElemNames);
1208         aRet  = MEDmeshEntityNameWr(myFile->Id(),
1209                                     &aMeshName,
1210                                     MED_NO_DT,
1211                                     MED_NO_IT,
1212                                     anEntity,
1213                                     MED_POLYHEDRON,
1214                                     (TInt)anInfo.myElemNames->size(),
1215                                     &anElemNames);
1216         if(theErr)
1217           *theErr = aRet;
1218         else if(aRet < 0)
1219           EXCEPTION(std::runtime_error,"SetPolyedreInfo - MEDmeshEntityNameWr(...)");
1220       }
1221
1222       if(theInfo.myIsElemNum){
1223         TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
1224         aRet = MEDmeshEntityNumberWr(myFile->Id(),
1225                                      &aMeshName,
1226                                      MED_NO_DT,
1227                                      MED_NO_IT,
1228                                      anEntity,
1229                                      MED_POLYHEDRON,
1230                                      (TInt)anInfo.myElemNum->size(),
1231                                      &anElemNum);
1232         if(theErr)
1233           *theErr = aRet;
1234         else if(aRet < 0)
1235           EXCEPTION(std::runtime_error,"SetPolyedreInfo - MEDmeshEntityNumberWr(...)");
1236       }
1237
1238
1239       TValueHolder<TElemNum, med_int> aFamNum(anInfo.myFamNum);
1240       aRet = MEDmeshEntityFamilyNumberWr(myFile->Id(),
1241                                          &aMeshName,
1242                                          MED_NO_DT,
1243                                          MED_NO_IT,
1244                                          anEntity,
1245                                          MED_POLYHEDRON,
1246                                          (TInt)anInfo.myFamNum->size(),
1247                                          &aFamNum);
1248
1249       if(theErr)
1250         *theErr = aRet;
1251       else if(aRet < 0)
1252         EXCEPTION(std::runtime_error,"SetPolyedreInfo - MEDmeshEntityFamilyNumberWr(...)");
1253     }
1254
1255     //----------------------------------------------------------------------------
1256     TInt
1257     TVWrapper
1258     ::GetNbPolyedres(const MED::TMeshInfo& theMeshInfo,
1259                      EEntiteMaillage theEntity,
1260                      EGeometrieElement theGeom,
1261                      EConnectivite theConnMode,
1262                      TErr* theErr)
1263     {
1264       return GetNbCells(theMeshInfo,theEntity,theGeom,theConnMode,theErr);
1265     }
1266
1267     //----------------------------------------------------------------------------
1268     void
1269     TVWrapper    ::GetPolyedreConnSize(const TMeshInfo& theMeshInfo,
1270                           TInt& theNbFaces,
1271                           TInt& theConnSize,
1272                           EConnectivite theConnMode,
1273                           TErr* theErr)
1274     {
1275       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1276
1277       if(theErr && *theErr < 0)
1278         EXCEPTION(std::runtime_error,"GetPolyedreConnSize - (...)");
1279
1280       MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
1281
1282       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1283       TValueHolder<EConnectivite, med_connectivity_mode> aConnMode(theConnMode);
1284       //TValueHolder<TInt, med_int> aNbFaces(theNbFaces);
1285       //TValueHolder<TInt, med_int> aConnSize(theConnSize);
1286
1287       med_bool chgt,trsf;
1288       theNbFaces = MEDmeshnEntity(myFile->Id(),
1289                                   &aMeshName,
1290                                   MED_NO_DT,
1291                                   MED_NO_IT,
1292                                   MED_CELL,
1293                                   MED_POLYHEDRON,
1294                                   MED_INDEX_NODE,
1295                                   aConnMode,
1296                                   &chgt,
1297                                   &trsf);
1298
1299       theConnSize = MEDmeshnEntity(myFile->Id(),
1300                                   &aMeshName,
1301                                   MED_NO_DT,
1302                                   MED_NO_IT,
1303                                   MED_CELL,
1304                                   MED_POLYHEDRON,
1305                                   MED_CONNECTIVITY,
1306                                   aConnMode,
1307                                   &chgt,
1308                                   &trsf);
1309
1310       if(theNbFaces < 0 || theConnSize<0)
1311         EXCEPTION(std::runtime_error,"GetPolygoneInfo - MEDmeshnEntity(...)");
1312
1313     }
1314
1315     //-----------------------------------------------------------------
1316     TEntityInfo
1317     TVWrapper
1318     ::GetEntityInfo(const MED::TMeshInfo& theMeshInfo,
1319                     EConnectivite theConnMode,
1320                     TErr* theErr)
1321     {
1322       TEntityInfo anInfo;
1323
1324       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1325
1326       if(theErr && *theErr < 0)
1327         return anInfo;
1328
1329       if(theMeshInfo.GetType() == eNON_STRUCTURE) {
1330         TInt aNbElem = GetNbNodes(theMeshInfo);
1331         if(aNbElem > 0){
1332           anInfo[eNOEUD][ePOINT1] = aNbElem;
1333           const TEntity2GeomSet& anEntity2GeomSet = GetEntity2GeomSet();
1334           TEntity2GeomSet::const_iterator anIter = anEntity2GeomSet.begin();
1335           TEntity2GeomSet::const_iterator anIterEnd = anEntity2GeomSet.end();
1336           for(; anIter != anIterEnd; anIter++){
1337             const EEntiteMaillage& anEntity = anIter->first;
1338             const TGeomSet& aGeomSet = anIter->second;
1339             TGeomSet::const_iterator anIter2 = aGeomSet.begin();
1340             TGeomSet::const_iterator anIterEnd2 = aGeomSet.end();
1341             for(; anIter2 != anIterEnd2; anIter2++){
1342               const EGeometrieElement& aGeom = *anIter2;
1343               aNbElem = GetNbCells(theMeshInfo,anEntity,aGeom,theConnMode,theErr);
1344               if(aNbElem > 0) {
1345                 if ( anEntity == eSTRUCT_ELEMENT ) {
1346                   const TInt nbStructTypes = aNbElem;
1347                   for ( TInt structType = 0; structType < nbStructTypes; ++structType ) {
1348                     // check type name to keep only "MED_BALL" structured element
1349                     TValueHolder<TString, char> aMeshName((TString&) theMeshInfo.myName );
1350                     char                        geotypename[ MED_NAME_SIZE + 1] = "";
1351                     med_geometry_type           geotype;
1352                     MEDmeshEntityInfo( myFile->Id(), &aMeshName, MED_NO_DT, MED_NO_IT,
1353                                        med_entity_type(anEntity), structType+1,
1354                                        geotypename, &geotype);
1355                     if ( strcmp( geotypename, MED_BALL_NAME ) == 0 ) {
1356                       aNbElem = GetNbCells( theMeshInfo, anEntity, EGeometrieElement(geotype),
1357                                             theConnMode, theErr);
1358                       if ( aNbElem > 0 )
1359                         anInfo[anEntity][EGeometrieElement(geotype)] = aNbElem;
1360                     }
1361                   }
1362                 }
1363                 else {
1364                   anInfo[anEntity][aGeom] = aNbElem;
1365                 }
1366               }
1367             }
1368           }
1369         }
1370       } else { // eSTRUCTURE
1371         EGrilleType aGrilleType;
1372         TInt aNbNodes = 1;
1373         TInt aNbElem  = 1;
1374         TInt aNbSub   = 0;
1375         TInt aDim = theMeshInfo.GetDim();
1376         EGeometrieElement aGeom, aSubGeom;
1377         EEntiteMaillage aSubEntity = eMAILLE;
1378
1379         GetGrilleType(theMeshInfo, aGrilleType);
1380
1381         TIntVector aStruct(aDim);
1382         if(aGrilleType == eGRILLE_STANDARD)
1383         {
1384           GetGrilleStruct(theMeshInfo, aStruct, theErr);
1385         }
1386         else
1387         { // eGRILLE_CARTESIENNE and eGRILLE_POLAIRE
1388           ETable aTable[3] = { eCOOR_IND1, eCOOR_IND2, eCOOR_IND3 };
1389           for(med_int anAxis = 0; anAxis < aDim; anAxis++)
1390             aStruct[ anAxis ] = GetNbNodes(theMeshInfo, aTable[anAxis]);
1391         }
1392         for(med_int i = 0; i < aDim; i++){
1393           aNbNodes = aNbNodes * aStruct[i];
1394           aNbElem = aNbElem * (aStruct[i] - 1);
1395         }
1396         switch(aDim){
1397         case 1:
1398           aGeom = eSEG2;
1399           break;
1400         case 2:
1401           aGeom = eQUAD4;
1402           aSubGeom = eSEG2;
1403           aSubEntity = eARETE;
1404           aNbSub =
1405             (aStruct[0]  ) * (aStruct[1]-1) +
1406             (aStruct[0]-1) * (aStruct[1]  );
1407           break;
1408         case 3:
1409           aGeom = eHEXA8;
1410           aSubGeom = eQUAD4;
1411           aSubEntity = eFACE;
1412           aNbSub =
1413             (aStruct[0]  ) * (aStruct[1]-1) * (aStruct[2]-1) +
1414             (aStruct[0]-1) * (aStruct[1]  ) * (aStruct[2]-1) +
1415             (aStruct[0]-1) * (aStruct[1]-1) * (aStruct[2]  );
1416           break;
1417         }
1418         anInfo[eNOEUD][ePOINT1] = aNbNodes;
1419         anInfo[eMAILLE][aGeom] = aNbElem;
1420         if ( aDim > 1 )
1421           anInfo[aSubEntity][aSubGeom] = aNbSub;
1422       }
1423       return anInfo;
1424     }
1425
1426
1427     //-----------------------------------------------------------------
1428     TInt TVWrapper::GetNbCells(const MED::TMeshInfo& theMeshInfo,
1429                                EEntiteMaillage theEntity,
1430                                EGeometrieElement theGeom,
1431                                EConnectivite theConnMode,
1432                                TErr* theErr)
1433     {
1434       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1435
1436       if(theErr && *theErr < 0)
1437         return -1;
1438
1439       MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
1440       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1441       med_bool chgt,trsf;
1442       switch ( theGeom )
1443       {
1444       case MED::ePOLYGONE:
1445       case MED::ePOLYGON2:
1446       {
1447         return MEDmeshnEntity(myFile->Id(),&aMeshName,
1448                               MED_NO_DT,MED_NO_IT,
1449                               med_entity_type(theEntity),med_geometry_type(theGeom),
1450                               MED_INDEX_NODE,med_connectivity_mode(theConnMode),
1451                               &chgt,&trsf)-1;
1452       }
1453       case MED::ePOLYEDRE:
1454       {
1455         return MEDmeshnEntity(myFile->Id(),&aMeshName,
1456                               MED_NO_DT,MED_NO_IT,
1457                               med_entity_type(theEntity),MED_POLYHEDRON,
1458                               MED_INDEX_FACE,med_connectivity_mode(theConnMode),
1459                               &chgt,&trsf)-1;
1460       }
1461       case MED::eBALL:
1462       {
1463         return GetNbBalls( theMeshInfo );
1464       }
1465       default:
1466       {
1467         return MEDmeshnEntity(myFile->Id(),&aMeshName,
1468                               MED_NO_DT,MED_NO_IT,
1469                               med_entity_type(theEntity),med_geometry_type(theGeom),
1470                               MED_CONNECTIVITY,med_connectivity_mode(theConnMode),
1471                               &chgt,&trsf);
1472       }
1473       }
1474       return 0;
1475     }
1476
1477
1478     //----------------------------------------------------------------------------
1479     void TVWrapper::GetCellInfo(MED::TCellInfo& theInfo, TErr* theErr)
1480     {
1481       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1482
1483       if(theErr && *theErr < 0)
1484         return;
1485
1486       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
1487
1488       TValueHolder<TString, char>                        aMeshName    (aMeshInfo.myName);
1489       TValueHolder<TElemNum, med_int>                    aConn        (theInfo.myConn);
1490       TValueHolder<EModeSwitch, med_switch_mode>         aModeSwitch  (theInfo.myModeSwitch);
1491       TValueHolder<TString, char>                        anElemNames  (theInfo.myElemNames);
1492       TValueHolder<EBooleen, med_bool>                   anIsElemNames(theInfo.myIsElemNames);
1493       TValueHolder<TElemNum, med_int>                    anElemNum    (theInfo.myElemNum);
1494       TValueHolder<EBooleen, med_bool>                   anIsElemNum  (theInfo.myIsElemNum);
1495       TValueHolder<TElemNum, med_int>                    aFamNum      (theInfo.myFamNum);
1496       TValueHolder<EBooleen, med_bool>                   anIsFamNum   (theInfo.myIsFamNum);
1497       TValueHolder<EEntiteMaillage, med_entity_type>     anEntity     (theInfo.myEntity);
1498       TValueHolder<EGeometrieElement, med_geometry_type> aGeom        (theInfo.myGeom);
1499       TValueHolder<EConnectivite, med_connectivity_mode> aConnMode    (theInfo.myConnMode);
1500
1501       TErr aRet;
1502       aRet = MEDmeshElementRd(myFile->Id(),
1503                               &aMeshName,
1504                               MED_NO_DT,
1505                               MED_NO_IT,
1506                               anEntity,
1507                               aGeom,
1508                               aConnMode,
1509                               aModeSwitch,
1510                               &aConn,
1511                               &anIsElemNames,
1512                               &anElemNames,
1513                               &anIsElemNum,
1514                               &anElemNum,
1515                               &anIsFamNum,
1516                               &aFamNum);
1517
1518       if(theErr)
1519         *theErr = aRet;
1520       else if(aRet < 0)
1521         EXCEPTION(std::runtime_error,"GetCellInfo - MEDmeshElementRd(...)");
1522
1523       if (anIsFamNum == MED_FALSE)
1524         {
1525           int mySize = (int) theInfo.myFamNum->size();
1526           theInfo.myFamNum->clear();
1527           theInfo.myFamNum->resize(mySize, 0);
1528         }
1529
1530     }
1531
1532
1533     //----------------------------------------------------------------------------
1534     void
1535     TVWrapper
1536     ::SetCellInfo(const MED::TCellInfo& theInfo,
1537                   EModeAcces theMode,
1538                   TErr* theErr)
1539     {
1540       TFileWrapper aFileWrapper(myFile,theMode,theErr);
1541
1542       if(theErr && *theErr < 0)
1543         return;
1544
1545       MED::TCellInfo& anInfo    = const_cast<MED::TCellInfo&>(theInfo);
1546       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
1547
1548       TValueHolder<TString, char>                        aMeshName    (aMeshInfo.myName);
1549       TValueHolder<TElemNum, med_int>                    aConn        (anInfo.myConn);
1550       TValueHolder<EModeSwitch, med_switch_mode>         aModeSwitch  (anInfo.myModeSwitch);
1551       TValueHolder<TString, char>                        anElemNames  (anInfo.myElemNames);
1552       TValueHolder<EBooleen, med_bool>                   anIsElemNames(anInfo.myIsElemNames);
1553       TValueHolder<TElemNum, med_int>                    anElemNum    (anInfo.myElemNum);
1554       TValueHolder<EBooleen, med_bool>                   anIsElemNum  (anInfo.myIsElemNum);
1555       TValueHolder<TElemNum, med_int>                    aFamNum      (anInfo.myFamNum);
1556       TValueHolder<EBooleen, med_bool>                   anIsFamNum   (anInfo.myIsFamNum);
1557       TValueHolder<EEntiteMaillage, med_entity_type>     anEntity     (anInfo.myEntity);
1558       TValueHolder<EGeometrieElement, med_geometry_type> aGeom        (anInfo.myGeom);
1559       TValueHolder<EConnectivite, med_connectivity_mode> aConnMode    (anInfo.myConnMode);
1560       TValueHolder<TInt, med_int>                        aNbElem      (anInfo.myNbElem);
1561
1562       TErr aRet;
1563       aRet = MEDmeshElementConnectivityWr(myFile->Id(),
1564                                           &aMeshName,
1565                                           MED_NO_DT,
1566                                           MED_NO_IT,
1567                                           MED_UNDEF_DT,
1568                                           anEntity,
1569                                           aGeom,
1570                                           aConnMode,
1571                                           aModeSwitch,
1572                                           aNbElem,
1573                                           &aConn);
1574
1575       MEDmeshEntityFamilyNumberWr(myFile->Id(),
1576                                   &aMeshName,
1577                                   MED_NO_DT,
1578                                   MED_NO_IT,
1579                                   anEntity,
1580                                   aGeom,
1581                                   aNbElem,
1582                                   &aFamNum);
1583       if(anIsElemNames)
1584         MEDmeshEntityNameWr(myFile->Id(),
1585                             &aMeshName,
1586                             MED_NO_DT,
1587                             MED_NO_IT,
1588                             anEntity,
1589                             aGeom,
1590                             aNbElem,
1591                             &anElemNames);
1592       if(anIsElemNum)
1593         MEDmeshEntityNumberWr(myFile->Id(),
1594                               &aMeshName,
1595                               MED_NO_DT,
1596                               MED_NO_IT,
1597                               anEntity,
1598                               aGeom,
1599                               aNbElem,
1600                               &anElemNum);
1601       if(theErr)
1602         *theErr = aRet;
1603       else if(aRet < 0)
1604         EXCEPTION(std::runtime_error,"SetCellInfo - MEDmeshElementWr(...)");
1605     }
1606
1607
1608     //----------------------------------------------------------------------------
1609     void
1610     TVWrapper
1611     ::SetCellInfo(const MED::TCellInfo& theInfo,
1612                   TErr* theErr)
1613     {
1614       SetCellInfo(theInfo,eLECTURE_ECRITURE,theErr);
1615     }
1616
1617     //----------------------------------------------------------------------------
1618     //! Read geom type of MED_BALL structural element
1619     EGeometrieElement TVWrapper::GetBallGeom(const TMeshInfo& theMeshInfo)
1620     {
1621       TFileWrapper aFileWrapper(myFile,eLECTURE);
1622
1623       // read med_geometry_type of "MED_BALL" element
1624       char geotypename[ MED_NAME_SIZE + 1] = MED_BALL_NAME;
1625       return EGeometrieElement( MEDstructElementGeotype( myFile->Id(), geotypename ) );
1626     }
1627
1628     //----------------------------------------------------------------------------
1629     //! Read number of balls in the Mesh
1630     TInt TVWrapper::GetNbBalls(const TMeshInfo& theMeshInfo)
1631     {
1632       TFileWrapper aFileWrapper(myFile,eLECTURE);
1633
1634       EGeometrieElement ballType = GetBallGeom( theMeshInfo );
1635       if ( ballType < 0 )
1636         return 0;
1637
1638       return GetNbCells( theMeshInfo, eSTRUCT_ELEMENT, ballType, eNOD );
1639     }
1640
1641     //----------------------------------------------------------------------------
1642     //! Read a MEDWrapped representation of MED_BALL from the MED file
1643     void TVWrapper::GetBallInfo(TBallInfo& theInfo, TErr* theErr)
1644     {
1645       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1646
1647       // check geometry of MED_BALL
1648       if ( theInfo.myGeom == eBALL )
1649       {
1650         theInfo.myGeom = GetBallGeom( *theInfo.myMeshInfo );
1651         if ( theInfo.myGeom < 0 ) {
1652           if ( !theErr )
1653             EXCEPTION(std::runtime_error,"GetBallInfo - no balls in the mesh");
1654           *theErr = theInfo.myGeom;
1655           return;
1656         }
1657       }
1658
1659       // read nodes ids
1660       GetCellInfo( theInfo );
1661
1662       // read diameters
1663       TValueHolder<TString, char>                        aMeshName (theInfo.myMeshInfo->myName);
1664       TValueHolder<EGeometrieElement, med_geometry_type> aGeom     (theInfo.myGeom);
1665       TValueHolder<TFloatVector, void>                   aDiam     (theInfo.myDiameters);
1666       char varattname[ MED_NAME_SIZE + 1] = MED_BALL_DIAMETER;
1667
1668       TErr aRet = MEDmeshStructElementVarAttRd( myFile->Id(), &aMeshName,
1669                                                 MED_NO_DT, MED_NO_IT,
1670                                                 aGeom,
1671                                                 varattname,
1672                                                 &aDiam);
1673       if ( theErr )
1674         *theErr = aRet;
1675       else if ( aRet < 0 )
1676         EXCEPTION(std::runtime_error,"GetBallInfo - pb at reading diameters");
1677     }
1678
1679
1680     //----------------------------------------------------------------------------
1681     //! Write a MEDWrapped representation of MED_BALL to the MED file
1682     void  TVWrapper::SetBallInfo(const TBallInfo& theInfo, EModeAcces theMode, TErr* theErr)
1683     {
1684       TFileWrapper aFileWrapper(myFile,theMode,theErr);
1685
1686       TErr ret;
1687       char ballsupportname[MED_NAME_SIZE+1]="BALL_SUPPORT_MESH";
1688       EGeometrieElement ballGeom = GetBallGeom( *theInfo.myMeshInfo );
1689       if ( ballGeom < 0 )
1690       {
1691         // no ball model in the file, create support mesh for it
1692         char dummyname [MED_NAME_SIZE*3+1]="";
1693         if (( ret = MEDsupportMeshCr( myFile->Id(),
1694                                       ballsupportname,
1695                                       theInfo.myMeshInfo->GetSpaceDim(),
1696                                       theInfo.myMeshInfo->GetDim(),
1697                                       "Support mesh for a ball model",
1698                                       MED_CARTESIAN,
1699                                       /*axisname=*/dummyname, /*unitname=*/dummyname)) < 0) {
1700           if ( !theErr )
1701             EXCEPTION(std::runtime_error,"SetBallInfo - MEDsupportMeshCr");
1702           *theErr = ret;
1703           return;
1704         }
1705         // write coordinates of 1 node
1706         med_float coord[3] = {0,0,0};
1707         if ((ret = MEDmeshNodeCoordinateWr(myFile->Id(),
1708                                            ballsupportname, MED_NO_DT, MED_NO_IT, 0.0,
1709                                            MED_FULL_INTERLACE, /*nnode=*/1, coord)) < 0) {
1710           if ( !theErr )
1711             EXCEPTION(std::runtime_error,"SetBallInfo - MEDmeshNodeCoordinateWr");
1712           *theErr = ret;
1713           return;
1714         }
1715         // ball model creation
1716         char geotypename[ MED_NAME_SIZE + 1] = MED_BALL_NAME;
1717         if (( ballGeom = (EGeometrieElement) MEDstructElementCr(myFile->Id(),
1718                                                                 geotypename,
1719                                                                 theInfo.myMeshInfo->GetSpaceDim(),
1720                                                                 ballsupportname,
1721                                                                 MED_NODE,MED_NONE)) < 0 ) {
1722           if ( !theErr )
1723             EXCEPTION(std::runtime_error,"SetBallInfo - MEDstructElementCr");
1724           *theErr = ret;
1725           return;
1726         }
1727         // create diameter attribute
1728         if (( ret = MEDstructElementVarAttCr(myFile->Id(),
1729                                              geotypename, MED_BALL_DIAMETER,
1730                                              MED_ATT_FLOAT64, /*ncomp=*/1)) < 0) {
1731           if ( !theErr )
1732             EXCEPTION(std::runtime_error,"SetBallInfo - MEDstructElementVarAttCr");
1733           *theErr = ret;
1734           return;
1735         }
1736       } // ballGeom < 0
1737
1738       TBallInfo& aBallInfo = ((TBallInfo&) theInfo );
1739       aBallInfo.myGeom = ballGeom;
1740
1741       // write node ids
1742       SetCellInfo(theInfo,theMode,theErr);
1743       if ( theErr && theErr < 0 )
1744         return;
1745
1746       // write diameter
1747       TValueHolder<TString, char>                        aMeshName (aBallInfo.myMeshInfo->myName);
1748       TValueHolder<EGeometrieElement, med_geometry_type> aGeom     (aBallInfo.myGeom);
1749       TValueHolder<TFloatVector, void>                   aDiam     (aBallInfo.myDiameters);
1750       ret = MEDmeshStructElementVarAttWr(myFile->Id(), &aMeshName,
1751                                          MED_NO_DT, MED_NO_IT,
1752                                          aGeom, MED_BALL_DIAMETER,
1753                                          theInfo.myNbElem, &aDiam);
1754       if ( theErr )
1755         *theErr = ret;
1756       else if ( ret < 0 )
1757         EXCEPTION(std::runtime_error,"SetBallInfo - MEDmeshStructElementVarAttWr");
1758     }
1759
1760     //----------------------------------------------------------------------------
1761     //! Write a MEDWrapped representation of MED_BALL to the MED file
1762     void  TVWrapper::SetBallInfo(const TBallInfo& theInfo, TErr* theErr)
1763     {
1764       SetBallInfo( theInfo, eLECTURE_ECRITURE, theErr );
1765     }
1766
1767     //-----------------------------------------------------------------
1768     TInt
1769     TVWrapper
1770     ::GetNbFields(TErr* theErr)
1771     {
1772       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1773
1774       if(theErr && *theErr < 0)
1775         return -1;
1776
1777       return MEDnField(myFile->Id());
1778     }
1779
1780
1781     //----------------------------------------------------------------------------
1782     TInt
1783     TVWrapper
1784     ::GetNbComp(TInt theFieldId,
1785                 TErr* theErr)
1786     {
1787       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1788
1789       if(theErr && *theErr < 0)
1790         return -1;
1791
1792       return MEDfieldnComponent(myFile->Id(),theFieldId);
1793     }
1794
1795
1796     //----------------------------------------------------------------------------
1797     void
1798     TVWrapper
1799     ::GetFieldInfo(TInt theFieldId,
1800                    MED::TFieldInfo& theInfo,
1801                    TErr* theErr)
1802     {
1803       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1804
1805       if(theErr && *theErr < 0)
1806         return;
1807
1808       TString aFieldName(256); // Protect from memory problems with too long names
1809       TValueHolder<ETypeChamp, med_field_type> aType(theInfo.myType);
1810       TValueHolder<TString, char> aCompNames(theInfo.myCompNames);
1811       TValueHolder<TString, char> anUnitNames(theInfo.myUnitNames);
1812       MED::TMeshInfo& aMeshInfo = theInfo.myMeshInfo;
1813
1814       TErr aRet;
1815       med_bool local;
1816       char dtunit[MED_SNAME_SIZE+1];
1817           char local_mesh_name[MED_NAME_SIZE+1]="";
1818       med_int nbofstp;
1819       theInfo.myNbComp = MEDfieldnComponent(myFile->Id(),theFieldId);
1820       aRet = MEDfieldInfo(myFile->Id(),
1821                           theFieldId,
1822                           &aFieldName[0],
1823                           local_mesh_name,
1824                           &local,
1825                           &aType,
1826                           &aCompNames,
1827                           &anUnitNames,
1828                           dtunit,
1829                           &nbofstp);
1830
1831           if(strcmp(&aMeshInfo.myName[0],local_mesh_name) != 0 ) {
1832                   if(theErr)
1833                         *theErr = -1;
1834                   return;
1835           }
1836
1837       theInfo.SetName(aFieldName);
1838
1839       if(theErr)
1840         *theErr = aRet;
1841       else if(aRet < 0)
1842         EXCEPTION(std::runtime_error,"GetFieldInfo - MEDfieldInfo(...)");
1843     }
1844
1845
1846     //----------------------------------------------------------------------------
1847     void
1848     TVWrapper
1849     ::SetFieldInfo(const MED::TFieldInfo& theInfo,
1850                    EModeAcces theMode,
1851                    TErr* theErr)
1852     {
1853       TFileWrapper aFileWrapper(myFile,theMode,theErr);
1854
1855       if(theErr && *theErr < 0)
1856         return;
1857
1858       MED::TFieldInfo& anInfo = const_cast<MED::TFieldInfo&>(theInfo);
1859
1860       TValueHolder<TString, char> aFieldName(anInfo.myName);
1861       TValueHolder<ETypeChamp, med_field_type> aType(anInfo.myType);
1862       TValueHolder<TString, char> aCompNames(anInfo.myCompNames);
1863       TValueHolder<TString, char> anUnitNames(anInfo.myUnitNames);
1864       MED::TMeshInfo& aMeshInfo = anInfo.myMeshInfo;
1865       TErr aRet;
1866       char dtunit[MED_SNAME_SIZE+1];
1867       std::fill(dtunit,dtunit+MED_SNAME_SIZE+1,'\0');
1868       aRet = MEDfieldCr(myFile->Id(),
1869                         &aFieldName,
1870                         aType,
1871                         anInfo.myNbComp,
1872                         &aCompNames,
1873                         &anUnitNames,
1874                         dtunit,
1875                         &aMeshInfo.myName[0]);
1876       if(theErr)
1877         *theErr = aRet;
1878       else if(aRet < 0)
1879         EXCEPTION(std::runtime_error,"SetFieldInfo - MEDfieldCr(...)");
1880     }
1881
1882
1883     //----------------------------------------------------------------------------
1884     void
1885     TVWrapper
1886     ::SetFieldInfo(const MED::TFieldInfo& theInfo,
1887                    TErr* theErr)
1888     {
1889       TErr aRet;
1890       SetFieldInfo(theInfo,eLECTURE_ECRITURE,&aRet);
1891
1892       if(aRet < 0)
1893         SetFieldInfo(theInfo,eLECTURE_AJOUT,&aRet);
1894
1895       if(theErr)
1896         *theErr = aRet;
1897     }
1898
1899
1900     //----------------------------------------------------------------------------
1901     TInt
1902     TVWrapper
1903     ::GetNbGauss(TErr* theErr)
1904     {
1905       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1906
1907       if(theErr && *theErr < 0)
1908         return -1;
1909
1910       return MEDnLocalization(myFile->Id());
1911     }
1912
1913
1914     //----------------------------------------------------------------------------
1915     TGaussInfo::TInfo
1916     TVWrapper
1917     ::GetGaussPreInfo(TInt theId,
1918                       TErr* theErr)
1919     {
1920       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1921
1922       if(theErr && *theErr < 0)
1923         return TGaussInfo::TInfo( TGaussInfo::TKey(ePOINT1,""),0 );
1924
1925       med_int aNbGaussPoints = med_int();
1926       TVector<char> aName(GetNOMLength<eV2_2>()+1);
1927       med_geometry_type aGeom = MED_NONE;
1928
1929       TErr aRet;
1930       med_int dim;
1931       char geointerpname[MED_NAME_SIZE+1]="";
1932       char ipointstructmeshname[MED_NAME_SIZE+1]="";
1933       med_int nsectionmeshcell;
1934       med_geometry_type sectiongeotype;
1935       aRet = MEDlocalizationInfo (myFile->Id(),
1936                                   theId,
1937                                   &aName[0],
1938                                   &aGeom,
1939                                   &dim,
1940                                   &aNbGaussPoints,
1941                                   geointerpname,
1942                                   ipointstructmeshname,
1943                                   &nsectionmeshcell,
1944                                   &sectiongeotype);
1945       if(theErr)
1946         *theErr = aRet;
1947       else if(aRet < 0)
1948         EXCEPTION(std::runtime_error,"GetGaussPreInfo - MEDlocalizationInfo(...)");
1949       return TGaussInfo::TInfo(TGaussInfo::TKey(EGeometrieElement(aGeom),&aName[0]),
1950                                TInt(aNbGaussPoints));
1951     }
1952
1953
1954     //----------------------------------------------------------------------------
1955     void
1956     TVWrapper
1957     ::GetGaussInfo(TInt theId,
1958                    TGaussInfo& theInfo,
1959                    TErr* theErr)
1960     {
1961       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1962
1963       if(theErr && *theErr < 0)
1964         return;
1965
1966       TValueHolder<TNodeCoord, med_float> aRefCoord(theInfo.myRefCoord);
1967       TValueHolder<TNodeCoord, med_float> aGaussCoord(theInfo.myGaussCoord);
1968       TValueHolder<TWeight, med_float> aWeight(theInfo.myWeight);
1969       TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(theInfo.myModeSwitch);
1970       TValueHolder<TString, char> aGaussName(theInfo.myName);
1971
1972       TErr aRet;
1973       aRet = MEDlocalizationRd(myFile->Id(),
1974                                &aGaussName,
1975                                aModeSwitch,
1976                                &aRefCoord,
1977                                &aGaussCoord,
1978                                &aWeight);
1979
1980       if(theErr)
1981         *theErr = aRet;
1982       else if(aRet < 0)
1983         EXCEPTION(std::runtime_error,"GetGaussInfo - MEDlocalizationRd(...)");
1984     }
1985
1986
1987     //----------------------------------------------------------------------------
1988     TInt
1989     TVWrapper
1990     ::GetNbProfiles(TErr* theErr)
1991     {
1992       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
1993
1994       if(theErr && *theErr < 0)
1995         return -1;
1996
1997       return MEDnProfile(myFile->Id());
1998     }
1999
2000     TProfileInfo::TInfo
2001     TVWrapper
2002     ::GetProfilePreInfo(TInt theId,
2003                         TErr* theErr)
2004     {
2005       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
2006
2007       if(theErr && *theErr < 0)
2008         return TProfileInfo::TInfo();
2009
2010       med_int aSize = -1;
2011       TVector<char> aName(GetNOMLength<eV2_2>()+1);
2012
2013       TErr aRet;
2014       aRet = MEDprofileInfo(myFile->Id(),
2015                             theId,
2016                             &aName[0],
2017                             &aSize);
2018       if(theErr)
2019         *theErr = aRet;
2020       else if(aRet < 0)
2021         EXCEPTION(std::runtime_error,"GetProfilePreInfo - MEDprofileInfo(...)");
2022
2023       return TProfileInfo::TInfo(&aName[0],aSize);
2024     }
2025
2026     void
2027     TVWrapper
2028     ::GetProfileInfo(TInt theId,
2029                      TProfileInfo& theInfo,
2030                      TErr* theErr)
2031     {
2032       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
2033
2034       if(theErr && *theErr < 0)
2035         return;
2036
2037       TProfileInfo& anInfo = const_cast<TProfileInfo&>(theInfo);
2038       TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
2039       TValueHolder<TString, char>     aProfileName(anInfo.myName);
2040
2041       TErr aRet;
2042       aRet = MEDprofileRd(myFile->Id(),
2043                           &aProfileName,
2044                           &anElemNum);
2045       if(theErr)
2046         *theErr = aRet;
2047       else if(aRet < 0)
2048         EXCEPTION(std::runtime_error,"GetProfileInfo - MEDprofileRd(...)");
2049     }
2050
2051     void
2052     TVWrapper
2053     ::SetProfileInfo(const TProfileInfo& theInfo,
2054                      EModeAcces          theMode,
2055                      TErr*               theErr)
2056     {
2057       TFileWrapper aFileWrapper(myFile,theMode,theErr);
2058
2059       if(theErr && *theErr < 0)
2060         return;
2061
2062       TProfileInfo& anInfo = const_cast<TProfileInfo&>(theInfo);
2063       TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
2064       TValueHolder<TString, char>     aProfileName(anInfo.myName);
2065
2066       TErr aRet;
2067       aRet = MEDprofileWr(myFile->Id(),      // descripteur du fichier.
2068                           &aProfileName,        // tableau de valeurs du profil.
2069                           theInfo.GetSize(), // taille du profil.
2070                           &anElemNum);    // nom profil.
2071       if(theErr)
2072         *theErr = aRet;
2073       else if(aRet < 0)
2074         EXCEPTION(std::runtime_error,"SetProfileInfo - MEDprofileWr(...)");
2075     }
2076
2077     void
2078     TVWrapper
2079     ::SetProfileInfo(const TProfileInfo& theInfo,
2080                      TErr*               theErr)
2081     {
2082       TErr aRet;
2083       SetProfileInfo(theInfo,eLECTURE_ECRITURE,&aRet);
2084
2085       if(aRet < 0)
2086         SetProfileInfo(theInfo,eLECTURE_AJOUT,&aRet);
2087
2088       if(aRet < 0)
2089         SetProfileInfo(theInfo,eCREATION,&aRet);
2090
2091       if(theErr)
2092         *theErr = aRet;
2093     }
2094
2095     //-----------------------------------------------------------------
2096     TInt
2097     TVWrapper
2098     ::GetNbTimeStamps(const MED::TFieldInfo& theInfo,
2099                       const MED::TEntityInfo& theEntityInfo,
2100                       EEntiteMaillage& theEntity,
2101                       TGeom2Size& theGeom2Size,
2102                       TErr* theErr)
2103     {
2104       theEntity = EEntiteMaillage(-1);
2105       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
2106
2107       if(theErr){
2108         if(theEntityInfo.empty())
2109           *theErr = -1;
2110         if(*theErr < 0)
2111           return -1;
2112       }else if(theEntityInfo.empty())
2113         EXCEPTION(std::runtime_error,"GetNbTimeStamps - There is no any Entity on the Mesh");
2114
2115       bool anIsPerformAdditionalCheck = GetNbMeshes() > 1;
2116
2117       theGeom2Size.clear();
2118       TInt aNbTimeStamps = 0;
2119       TIdt anId = myFile->Id();
2120
2121       MED::TFieldInfo& anInfo = const_cast<MED::TFieldInfo&>(theInfo);
2122       TValueHolder<TString, char> aFieldName(anInfo.myName);
2123       MED::TMeshInfo& aMeshInfo = anInfo.myMeshInfo;
2124
2125       // workaround for IPAL13676
2126       MED::TEntityInfo localEntityInfo = theEntityInfo;
2127       TEntityInfo::iterator anLocalIter = localEntityInfo.find(eMAILLE);
2128       if(anLocalIter != localEntityInfo.end()){
2129         localEntityInfo[eNOEUD_ELEMENT] = anLocalIter->second;
2130       }
2131
2132       TEntityInfo::const_iterator anIter = localEntityInfo.begin();
2133       for(; anIter != localEntityInfo.end(); anIter++){
2134         med_entity_type anEntity = med_entity_type(anIter->first);
2135         const TGeom2Size& aGeom2Size = anIter->second;
2136         TGeom2Size::const_iterator anGeomIter = aGeom2Size.begin();
2137         for(; anGeomIter != aGeom2Size.end(); anGeomIter++){
2138           med_geometry_type aGeom = med_geometry_type(anGeomIter->first);
2139           char aMeshName[MED_NAME_SIZE+1];
2140           med_bool islocal;
2141           med_field_type ft;
2142           char dtunit[MED_SNAME_SIZE+1];
2143           med_int myNbComp = MEDfieldnComponentByName(anId,&aFieldName);
2144           char *cname=new char[myNbComp*MED_SNAME_SIZE+1];
2145           char *unitname=new char[myNbComp*MED_SNAME_SIZE+1];
2146           TInt aNbStamps;
2147           MEDfieldInfoByName(anId,
2148                              &aFieldName,
2149                              aMeshName,
2150                              &islocal,
2151                              &ft,
2152                              cname,
2153                              unitname,
2154                              dtunit,
2155                              &aNbStamps);
2156           delete [] cname;
2157           delete [] unitname;
2158           med_int nval = 0;
2159           med_int aNumDt;
2160           med_int aNumOrd;
2161           med_float aDt;
2162           if (aNbStamps > 0)
2163             {
2164               MEDfieldComputingStepInfo(anId,
2165                                         &aFieldName,
2166                                         1,
2167                                         &aNumDt,
2168                                         &aNumOrd,
2169                                         &aDt);
2170               char profilename[MED_NAME_SIZE+1];
2171               char locname[MED_NAME_SIZE+1];
2172               med_int profilsize;
2173               med_int aNbGauss;
2174
2175               // protection from crash (division by zero)
2176               // inside MEDfieldnValueWithProfile function
2177               // caused by the workaround for IPAL13676 (see above)
2178               if( anEntity == MED_NODE_ELEMENT && aGeom % 100 == 0 )
2179                 continue;
2180
2181               nval = MEDfieldnValueWithProfile(anId,
2182                                                &aFieldName,
2183                                                aNumDt,
2184                                                aNumOrd,
2185                                                anEntity,
2186                                                med_geometry_type(aGeom),
2187                                                1,
2188                                                MED_COMPACT_STMODE,
2189                                                profilename,
2190                                                &profilsize,
2191                                                locname,
2192                                                &aNbGauss);
2193             }
2194           bool anIsSatisfied =(nval > 0);
2195           if(anIsSatisfied){
2196             INITMSG(MYDEBUG,
2197                     "GetNbTimeStamps aNbTimeStamps = "<<aNbStamps<<
2198                     "; aGeom = "<<aGeom<<"; anEntity = "<<anEntity<<"\n");
2199             if(anIsPerformAdditionalCheck){
2200               anIsSatisfied = !strcmp(&aMeshName[0],&aMeshInfo.myName[0]);
2201               if(!anIsSatisfied){
2202                 INITMSG(MYDEBUG,
2203                         "GetNbTimeStamps aMeshName = '"<<&aMeshName[0]<<"' != "<<
2204                         "; aMeshInfo.myName = '"<<&aMeshInfo.myName[0]<<"'\n");
2205               }
2206             }
2207           }
2208           if(anIsSatisfied){
2209             theGeom2Size[EGeometrieElement(aGeom)] = anGeomIter->second;
2210             theEntity = EEntiteMaillage(anEntity);
2211             aNbTimeStamps = aNbStamps;
2212           }
2213         }
2214         if(!theGeom2Size.empty())
2215           break;
2216       }
2217       return aNbTimeStamps;
2218     }
2219
2220
2221     //----------------------------------------------------------------------------
2222     void
2223     TVWrapper
2224     ::GetTimeStampInfo(TInt theTimeStampId,
2225                        MED::TTimeStampInfo& theInfo,
2226                        TErr* theErr)
2227     {
2228       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
2229
2230       const TGeom2Size& aGeom2Size = theInfo.myGeom2Size;
2231
2232       if(theErr){
2233         if(aGeom2Size.empty())
2234           *theErr = -1;
2235         if(*theErr < 0)
2236           return;
2237       }else if(aGeom2Size.empty())
2238         EXCEPTION(std::runtime_error,"GetTimeStampInfo - There is no any cell");
2239
2240       MED::TFieldInfo& aFieldInfo = *theInfo.myFieldInfo;
2241       MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo;
2242
2243       TValueHolder<TString, char> aFieldName(aFieldInfo.myName);
2244       TValueHolder<EEntiteMaillage, med_entity_type> anEntity(theInfo.myEntity);
2245       TValueHolder<TInt, med_int> aNumDt(theInfo.myNumDt);
2246       TValueHolder<TInt, med_int> aNumOrd(theInfo.myNumOrd);
2247       TValueHolder<TString, char> anUnitDt(theInfo.myUnitDt);
2248       TValueHolder<TFloat, med_float> aDt(theInfo.myDt);
2249       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
2250       TValueHolder<EBooleen, med_bool> anIsLocal(aFieldInfo.myIsLocal);
2251       TValueHolder<TInt, med_int> aNbRef(aFieldInfo.myNbRef);
2252
2253       TGeom2NbGauss& aGeom2NbGauss = theInfo.myGeom2NbGauss;
2254
2255       // just to get a time stamp unit (anUnitDt)
2256       med_field_type aFieldType;
2257       med_int aNbComp = MEDfieldnComponentByName(myFile->Id(), &aFieldName);
2258       char *aCompName = new char[aNbComp*MED_SNAME_SIZE+1];
2259       char *aCompUnit = new char[aNbComp*MED_SNAME_SIZE+1];
2260       TInt aNbStamps;
2261       MEDfieldInfoByName(myFile->Id(),
2262                          &aFieldName,
2263                          &aMeshName,
2264                          &anIsLocal,
2265                          &aFieldType,
2266                          aCompName,
2267                          aCompUnit,
2268                          &anUnitDt,
2269                          &aNbStamps);
2270       delete [] aCompName;
2271       delete [] aCompUnit;
2272
2273       TGeom2Size::const_iterator anIter = aGeom2Size.begin();
2274       for(; anIter != aGeom2Size.end(); anIter++){
2275         const EGeometrieElement& aGeom = anIter->first;
2276         med_int aNbGauss = -1;
2277
2278         TErr aRet;
2279         aRet = MEDfieldComputingStepInfo(myFile->Id(),
2280                                          &aFieldName,
2281                                          theTimeStampId,
2282                                          &aNumDt,
2283                                          &aNumOrd,
2284                                          &aDt);
2285         char profilename[MED_NAME_SIZE+1];
2286         med_int profilsize;
2287         char locname[MED_NAME_SIZE+1];
2288         MEDfieldnValueWithProfile(myFile->Id(),
2289                                   &aFieldName,
2290                                   aNumDt,
2291                                   aNumOrd,
2292                                   anEntity,
2293                                   med_geometry_type(aGeom),
2294                                   1,
2295                                   MED_COMPACT_STMODE,
2296                                   profilename,
2297                                   &profilsize,
2298                                   locname,
2299                                   &aNbGauss);
2300
2301         static TInt MAX_NB_GAUSS_POINTS = 32;
2302         if(aNbGauss <= 0 || aNbGauss > MAX_NB_GAUSS_POINTS)
2303           aNbGauss = 1;
2304
2305         aGeom2NbGauss[aGeom] = aNbGauss;
2306
2307         if(theErr)
2308           *theErr = aRet;
2309         else if(aRet < 0)
2310           EXCEPTION(std::runtime_error,"GetTimeStampInfo - MEDfieldnValueWithProfile(...)");
2311       }
2312     }
2313
2314
2315     //----------------------------------------------------------------------------
2316     void
2317     TVWrapper
2318     ::GetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
2319                         const TMKey2Profile& theMKey2Profile,
2320                         const TKey2Gauss& theKey2Gauss,
2321                         TErr* theErr)
2322     {
2323       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
2324
2325       if(theErr && *theErr < 0)
2326         return;
2327
2328       TIdt anId = myFile->Id();
2329
2330       TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(theTimeStampValue->myModeSwitch);
2331       MED::TGeom2Profile& aGeom2Profile = theTimeStampValue->myGeom2Profile;
2332
2333       MED::PTimeStampInfo aTimeStampInfo = theTimeStampValue->myTimeStampInfo;
2334       TValueHolder<EEntiteMaillage, med_entity_type> anEntity(aTimeStampInfo->myEntity);
2335       TValueHolder<TInt, med_int> aNumDt(aTimeStampInfo->myNumDt);
2336       TValueHolder<TInt, med_int> aNumOrd(aTimeStampInfo->myNumOrd);
2337
2338       MED::PFieldInfo aFieldInfo = aTimeStampInfo->myFieldInfo;
2339       TValueHolder<TString, char> aFieldName(aFieldInfo->myName);
2340       TValueHolder<EBooleen, med_bool> anIsLocal(aFieldInfo->myIsLocal);
2341
2342       MED::PMeshInfo aMeshInfo = aFieldInfo->myMeshInfo;
2343       TValueHolder<TString, char> aMeshName(aMeshInfo->myName);
2344
2345       TGeom2Gauss& aGeom2Gauss = aTimeStampInfo->myGeom2Gauss;
2346       TVector<char> aGaussName(GetNOMLength<eV2_2>()+1);
2347
2348       med_storage_mode aProfileMode = med_storage_mode(boost::get<0>(theMKey2Profile));
2349       MED::TKey2Profile aKey2Profile = boost::get<1>(theMKey2Profile);
2350       TVector<char> aProfileName(GetNOMLength<eV2_2>()+1);
2351
2352       TGeom2Size& aGeom2Size = aTimeStampInfo->myGeom2Size;
2353       TGeom2Size::iterator anIter = aGeom2Size.begin();
2354       for(; anIter != aGeom2Size.end(); anIter++){
2355         EGeometrieElement aGeom = anIter->first;
2356         TInt aNbElem = anIter->second;
2357         med_int profilesize,aNbGauss;
2358
2359         TInt aNbVal = MEDfieldnValueWithProfile(anId,
2360                                                 &aFieldName,
2361                                                 aNumDt,
2362                                                 aNumOrd,
2363                                                 anEntity,
2364                                                 med_geometry_type(aGeom),
2365                                                 1,
2366                                                 aProfileMode,
2367                                                 &aProfileName[0],
2368                                                 &profilesize,
2369                                                 &aGaussName[0],
2370                                                 &aNbGauss);
2371
2372         if(aNbVal <= 0){
2373           if(theErr){
2374             *theErr = -1;
2375             return;
2376           }
2377           EXCEPTION(std::runtime_error,"GetTimeStampValue - MEDfieldnValueWithProfile(...) - aNbVal == "<<aNbVal<<" <= 0");
2378         }
2379
2380         TInt aNbComp = aFieldInfo->myNbComp;
2381         TInt aNbValue = aNbVal;// / aNbGauss; rules in MED changed
2382         theTimeStampValue->AllocateValue(aGeom,
2383                                          aNbValue,
2384                                          aNbGauss,
2385                                          aNbComp);
2386         TInt aValueSize = theTimeStampValue->GetValueSize(aGeom);
2387
2388         INITMSG(MYDEBUG,
2389                 "TVWrapper::GetTimeStampValue - aGeom = "<<aGeom<<
2390                 "; aNbVal = "<<aNbVal<<
2391                 "; aNbValue = "<<aNbValue<<
2392                 "; aNbGauss = "<<aNbGauss<<
2393                 "; aNbComp = "<<aNbComp<<
2394                 std::endl);
2395
2396         TErr aRet = MEDfieldValueWithProfileRd(anId,
2397                                                &aFieldName,
2398                                                aNumDt,
2399                                                aNumOrd,
2400                                                anEntity,
2401                                                med_geometry_type(aGeom),
2402                                                aProfileMode,
2403                                                &aProfileName[0],
2404                                                aModeSwitch,
2405                                                MED_ALL_CONSTITUENT,
2406                                                theTimeStampValue->GetValuePtr(aGeom));
2407         if(aRet < 0){
2408           if(theErr){
2409             *theErr = MED_FALSE;
2410             return;
2411           }
2412           EXCEPTION(std::runtime_error,"GetTimeStampValue - MEDfieldValueWithProfileRd(...)");
2413         }
2414
2415         MED::PGaussInfo aGaussInfo;
2416         TGaussInfo::TKey aKey(aGeom,&aGaussName[0]);
2417         if(strcmp(&aGaussName[0],"") != 0){
2418           MED::TKey2Gauss::const_iterator anIter = theKey2Gauss.find(aKey);
2419           if(anIter != theKey2Gauss.end()){
2420             aGaussInfo = anIter->second;
2421             aGeom2Gauss[aGeom] = aGaussInfo;
2422           }
2423         }
2424
2425         MED::PProfileInfo aProfileInfo;
2426         if(strcmp(&aProfileName[0],MED_NO_PROFILE) != 0){
2427           MED::TKey2Profile::const_iterator anIter = aKey2Profile.find(&aProfileName[0]);
2428           if(anIter != aKey2Profile.end()){
2429             aProfileInfo = anIter->second;
2430             aGeom2Profile[aGeom] = aProfileInfo;
2431           }
2432         }
2433
2434         if(aGaussInfo && aNbGauss != aGaussInfo->GetNbGauss()){
2435           if(theErr){
2436             *theErr = MED_FALSE;
2437             return;
2438           }
2439           EXCEPTION(std::runtime_error,"GetTimeStampValue - aNbGauss != aGaussInfo->GetNbGauss()");
2440         }
2441
2442         if(aProfileInfo && aProfileInfo->IsPresent()){
2443           TInt aNbSubElem = aProfileInfo->GetSize();
2444           TInt aProfileSize = aNbSubElem*aNbComp*aNbGauss;
2445           if(aProfileSize != aValueSize){
2446             if(theErr){
2447               *theErr = -1;
2448               return;
2449             }
2450             EXCEPTION(std::runtime_error,
2451                       "GetTimeStampValue - aProfileSize("<<aProfileSize<<
2452                       ") != aValueSize("<<aValueSize<<
2453                       "); aNbVal = "<<aNbVal<<
2454                       "; anEntity = "<<anEntity<<
2455                       "; aGeom = "<<aGeom<<
2456                       "; aNbElem = "<<aNbElem<<
2457                       "; aNbSubElem = "<<aNbSubElem<<
2458                       "; aNbComp = "<<aNbComp<<
2459                       "; aNbGauss = "<<aNbGauss<<
2460                       "");
2461           }
2462         }else{
2463           if((aProfileMode == MED_GLOBAL_STMODE) && (aNbElem != aNbValue)){
2464             if(theErr){
2465               *theErr = -1;
2466               return;
2467             }
2468             EXCEPTION(std::runtime_error,
2469                       "GetTimeStampValue - aNbElem("<<aNbElem<<
2470                       ") != aNbValue("<<aNbValue<<
2471                       "); aNbVal = "<<aNbVal<<
2472                       "; anEntity = "<<anEntity<<
2473                       "; aGeom = "<<aGeom<<
2474                       "; aNbElem = "<<aNbElem<<
2475                       "; aNbComp = "<<aNbComp<<
2476                       "; aNbGauss = "<<aNbGauss<<
2477                       "");
2478           }
2479         }
2480       }
2481     }
2482
2483
2484     //----------------------------------------------------------------------------
2485     void
2486     TVWrapper
2487     ::SetTimeStampValue(const MED::PTimeStampValueBase& theTimeStampValue,
2488                         EModeAcces theMode,
2489                         TErr* theErr)
2490     {
2491       TFileWrapper aFileWrapper(myFile,theMode,theErr);
2492
2493       if(theErr && *theErr < 0)
2494         return;
2495
2496       TErr aRet;
2497       TIdt anId = myFile->Id();
2498
2499       TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(theTimeStampValue->myModeSwitch);
2500       MED::TGeom2Profile& aGeom2Profile = theTimeStampValue->myGeom2Profile;
2501
2502       MED::PTimeStampInfo aTimeStampInfo = theTimeStampValue->myTimeStampInfo;
2503       TValueHolder<EEntiteMaillage, med_entity_type> anEntity(aTimeStampInfo->myEntity);
2504       TValueHolder<TInt, med_int> aNumDt(aTimeStampInfo->myNumDt);
2505       TValueHolder<TInt, med_int> aNumOrd(aTimeStampInfo->myNumOrd);
2506       TValueHolder<TString, char> anUnitDt(aTimeStampInfo->myUnitDt);
2507       TValueHolder<TFloat, med_float> aDt(aTimeStampInfo->myDt);
2508       MED::TGeom2Gauss& aGeom2Gauss = aTimeStampInfo->myGeom2Gauss;
2509
2510       MED::PFieldInfo aFieldInfo = aTimeStampInfo->myFieldInfo;
2511       TValueHolder<TString, char> aFieldName(aFieldInfo->myName);
2512
2513       MED::PMeshInfo aMeshInfo = aFieldInfo->myMeshInfo;
2514       TValueHolder<TString, char> aMeshName(aMeshInfo->myName);
2515
2516       const TGeomSet& aGeomSet = theTimeStampValue->myGeomSet;
2517       TGeomSet::const_iterator anIter = aGeomSet.begin();
2518       for(; anIter != aGeomSet.end(); anIter++){
2519         EGeometrieElement aGeom = *anIter;
2520
2521         TVector<char> aGaussName(GetNOMLength<eV2_2>()+1);
2522         MED::TGeom2Gauss::const_iterator aGaussIter = aGeom2Gauss.find(aGeom);
2523         if(aGaussIter != aGeom2Gauss.end()){
2524           MED::PGaussInfo aGaussInfo = aGaussIter->second;
2525           strcpy(&aGaussName[0],&aGaussInfo->myName[0]);
2526         }
2527
2528         TVector<char> aProfileName(GetNOMLength<eV2_2>()+1);
2529         med_storage_mode aProfileMode = med_storage_mode(eNO_PFLMOD);
2530         MED::TGeom2Profile::const_iterator aProfileIter = aGeom2Profile.find(aGeom);
2531         if(aProfileIter != aGeom2Profile.end()){
2532           MED::PProfileInfo aProfileInfo = aProfileIter->second;
2533           aProfileMode = med_storage_mode(aProfileInfo->myMode);
2534           strcpy(&aProfileName[0],&aProfileInfo->myName[0]);
2535         }
2536
2537         med_int aNbVal = theTimeStampValue->GetNbVal(aGeom);
2538
2539         aRet = MEDfieldValueWithProfileWr(anId,
2540                                           &aFieldName,
2541                                           aNumDt,
2542                                           aNumOrd,
2543                                           aDt,
2544                                           anEntity,
2545                                           med_geometry_type(aGeom),
2546                                           aProfileMode,
2547                                           &aProfileName[0],
2548                                           &aGaussName[0],
2549                                           aModeSwitch,
2550                                           MED_ALL_CONSTITUENT,
2551                                           aNbVal,
2552                                           theTimeStampValue->GetValuePtr(aGeom));
2553         if(aRet < 0){
2554           if(theErr){
2555             *theErr = MED_FALSE;
2556             break;
2557           }
2558           EXCEPTION(std::runtime_error,"SetTimeStampValue - MEDfieldValueWithProfileWr(...)");
2559         }
2560
2561       }
2562
2563       INITMSG(MYDEBUG,"TVWrapper::SetTimeStampValue - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
2564     }
2565
2566
2567     //----------------------------------------------------------------------------
2568     void
2569     TVWrapper
2570     ::SetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
2571                         TErr* theErr)
2572     {
2573       TErr aRet;
2574       SetTimeStampValue(theTimeStampValue,eLECTURE_ECRITURE,&aRet);
2575
2576       if(aRet < 0)
2577         SetTimeStampValue(theTimeStampValue,eLECTURE_AJOUT,&aRet);
2578
2579       if(theErr)
2580         *theErr = aRet;
2581     }
2582
2583     //----------------------------------------------------------------------------
2584     void
2585     TVWrapper
2586     ::SetGrilleInfo(const MED::TGrilleInfo& theInfo,
2587                     TErr* theErr)
2588     {
2589       SetGrilleInfo(theInfo,eLECTURE_ECRITURE,theErr);
2590     }
2591
2592     //----------------------------------------------------------------------------
2593     void
2594     TVWrapper
2595     ::SetGrilleInfo(const MED::TGrilleInfo& theInfo,
2596                     EModeAcces theMode,
2597                     TErr* theErr)
2598     {
2599       if(theInfo.myMeshInfo->myType != eSTRUCTURE)
2600         return;
2601       TFileWrapper aFileWrapper(myFile,theMode,theErr);
2602
2603       if(theErr && *theErr < 0)
2604           return;
2605
2606       MED::TGrilleInfo& anInfo = const_cast<MED::TGrilleInfo&>(theInfo);
2607
2608       MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
2609       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
2610
2611       TValueHolder<EGrilleType, med_grid_type > aGrilleType(anInfo.myGrilleType);
2612
2613       TErr aRet = 0;
2614       aRet = MEDmeshGridTypeRd(myFile->Id(),
2615                                &aMeshName,
2616                                &aGrilleType);
2617       if(theErr)
2618         *theErr = aRet;
2619       else if(aRet < 0)
2620         EXCEPTION(std::runtime_error,"SetGrilleInfo - MEDmeshGridTypeRd(...)");
2621
2622       if(anInfo.myGrilleType == eGRILLE_STANDARD){
2623         TValueHolder<TNodeCoord, med_float> aCoord(anInfo.myCoord);
2624         TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(anInfo.myModeSwitch);
2625         TValueHolder<TString, char> aCoordNames(anInfo.myCoordNames);
2626         TValueHolder<TString, char> aCoordUnits(anInfo.myCoordUnits);
2627         med_int aNbNoeuds = med_int(anInfo.myCoord.size() / aMeshInfo.myDim);
2628         //med_axis_type aRepere = MED_CARTESIAN;
2629
2630         aRet = MEDmeshNodeCoordinateWr(myFile->Id(),
2631                                        &aMeshName,
2632                                        MED_NO_DT,
2633                                        MED_NO_IT,
2634                                        MED_UNDEF_DT,
2635                                        aModeSwitch,
2636                                        aNbNoeuds,
2637                                        &aCoord);
2638
2639         if(aRet < 0)
2640           EXCEPTION(std::runtime_error,"SetGrilleInfo - MEDmeshNodeCoordinateWr(...)");
2641
2642         TValueHolder<TIntVector, med_int> aGrilleStructure(anInfo.myGrilleStructure);
2643         aRet = MEDmeshGridStructWr(myFile->Id(),
2644                                     &aMeshName,
2645                                    MED_NO_DT,
2646                                    MED_NO_IT,
2647                                    MED_UNDEF_DT,
2648                                    &aGrilleStructure);
2649         if(aRet < 0)
2650           EXCEPTION(std::runtime_error,"SetGrilleInfo - MEDmeshGridStructWr(...)");
2651
2652       } else {
2653         for(med_int aAxis = 0; aAxis < aMeshInfo.myDim; aAxis++){
2654           aRet = MEDmeshGridIndexCoordinateWr(myFile->Id(),
2655                                               &aMeshName,
2656                                               MED_NO_DT,
2657                                               MED_NO_IT,
2658                                               MED_UNDEF_DT,
2659                                               aAxis+1,
2660                                               anInfo.GetIndexes(aAxis).size(),
2661                                               &anInfo.GetIndexes(aAxis)[0]);
2662
2663           if(aRet < 0)
2664             EXCEPTION(std::runtime_error,"SetGrilleInfo - MEDmeshGridIndexCoordinateWr(...)");
2665         }
2666
2667       }
2668
2669       return;
2670     }
2671
2672     //----------------------------------------------------------------------------
2673     void
2674     TVWrapper
2675     ::GetGrilleInfo(TGrilleInfo& theInfo,
2676                     TErr* theErr)
2677     {
2678       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
2679
2680       if(theErr && *theErr < 0)
2681           return;
2682
2683       MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
2684       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
2685       EMaillage aMaillageType = aMeshInfo.myType;
2686
2687       GetGrilleType(aMeshInfo, theInfo.myGrilleType, theErr);
2688       EGrilleType aGrilleType = theInfo.myGrilleType;
2689
2690       TErr aRet = 0;
2691       if(aMaillageType == eSTRUCTURE && aGrilleType == eGRILLE_STANDARD) {
2692         GetGrilleStruct(aMeshInfo, theInfo.myGrilleStructure, theErr);
2693
2694         TValueHolder<TNodeCoord, med_float> aCoord(theInfo.myCoord);
2695         TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(theInfo.myModeSwitch);
2696         TValueHolder<TString, char> aCoordNames(theInfo.myCoordNames);
2697         TValueHolder<TString, char> aCoordUnits(theInfo.myCoordUnits);
2698         //med_axis_type aRepere;
2699
2700         aRet = MEDmeshNodeCoordinateRd(myFile->Id(),
2701                                        &aMeshName,
2702                                        MED_NO_DT,
2703                                        MED_NO_IT,
2704                                        aModeSwitch,
2705                                        &aCoord);
2706
2707         if(theErr)
2708           *theErr = aRet;
2709         else if(aRet < 0)
2710           EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshNodeCoordinateRd(...)");
2711
2712         //TInt aNbNodes = theInfo.GetNbNodes();//GetNbFamilies(aMeshInfo);
2713         TValueHolder<TElemNum, med_int> aFamNumNode(theInfo.myFamNumNode);
2714
2715         aRet = MEDmeshEntityFamilyNumberRd(myFile->Id(),
2716                                            &aMeshName,
2717                                            MED_NO_DT,
2718                                            MED_NO_IT,
2719                                            MED_NODE,
2720                                            MED_NO_GEOTYPE,
2721                                            &aFamNumNode);
2722
2723         if(aRet < 0)
2724         {
2725 //            if (aRet == MED_ERR_DOESNTEXIST) // --- only valid with MED3.x files
2726               {
2727                 int mySize = (int)theInfo.myFamNumNode.size();
2728                 theInfo.myFamNumNode.clear();
2729                 theInfo.myFamNumNode.resize(mySize,0);
2730                 aRet = 0;
2731               }
2732 //            else
2733 //              EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshEntityFamilyNumberRd(...)");
2734         }
2735         if(theErr)
2736           *theErr = aRet;
2737
2738         //============================
2739       }
2740
2741       if(aMaillageType == eSTRUCTURE && aGrilleType != eGRILLE_STANDARD){
2742         ETable aTable = eCOOR_IND1;
2743         for(med_int anAxis = 1; anAxis <= aMeshInfo.myDim; anAxis++){
2744           switch(anAxis){
2745           case 1 :
2746             aTable = eCOOR_IND1;
2747             break;
2748           case 2 :
2749             aTable = eCOOR_IND2;
2750             break;
2751           case 3 :
2752             aTable = eCOOR_IND3;
2753             break;
2754           default :
2755             aRet = -1;
2756           }
2757
2758           if(theErr)
2759             *theErr = aRet;
2760           else if(aRet < 0)
2761             EXCEPTION(std::runtime_error,"GetGrilleInfo - anAxis number out of range(...)");
2762
2763           TInt aNbIndexes = GetNbNodes(aMeshInfo,aTable);
2764           if(aNbIndexes < 0)
2765             EXCEPTION(std::runtime_error,"GetGrilleInfo - Erreur a la lecture de la taille de l'indice");
2766
2767           TValueHolder<TFloatVector, med_float> anIndexes(theInfo.GetIndexes(anAxis-1));
2768           //TValueHolder<ETable, med_data_type > table(aTable);
2769           //char aCompNames[MED_SNAME_SIZE+1];
2770           //char anUnitNames[MED_SNAME_SIZE+1];
2771           aRet=MEDmeshGridIndexCoordinateRd(myFile->Id(),&aMeshName,
2772                                             MED_NO_DT,MED_NO_IT,
2773                                             anAxis,
2774                                             &anIndexes);
2775
2776           //theInfo.SetCoordName(anAxis-1, aCompNames);
2777           //theInfo.SetCoordUnit(anAxis-1, anUnitNames);
2778           theInfo.SetGrilleStructure(anAxis-1, aNbIndexes);
2779
2780           if(theErr)
2781             *theErr = aRet;
2782           else if(aRet < 0)
2783             EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDindicesCoordLire(...)");
2784         }
2785       }
2786
2787       EGeometrieElement aGeom = theInfo.GetGeom();
2788       EEntiteMaillage aEntity = theInfo.GetEntity();
2789       TInt aNbCells = theInfo.GetNbCells();
2790
2791       theInfo.myFamNum.resize(aNbCells);
2792       TValueHolder<TElemNum, med_int> aFamNum(theInfo.myFamNum);
2793
2794       aRet = MEDmeshEntityFamilyNumberRd(myFile->Id(),
2795                                          &aMeshName,MED_NO_DT,MED_NO_IT,med_entity_type(aEntity),
2796                                          med_geometry_type(aGeom),&aFamNum);
2797
2798       if ( aMeshInfo.myDim == 3 )
2799       {
2800         aGeom = theInfo.GetSubGeom();
2801         aEntity = theInfo.GetSubEntity();
2802         aNbCells = theInfo.GetNbSubCells();
2803
2804         theInfo.myFamSubNum.resize(aNbCells,0);
2805         TValueHolder<TElemNum, med_int> aFamNum(theInfo.myFamSubNum);
2806
2807         aRet = MEDmeshEntityFamilyNumberRd(myFile->Id(),
2808                                     &aMeshName,MED_NO_DT,MED_NO_IT,
2809                                     med_entity_type(aEntity),
2810                                     med_geometry_type(aGeom),&aFamNum);
2811       }
2812       if(aRet < 0)
2813       {
2814 //          if (aRet == MED_ERR_DOESNTEXIST) // --- only valid with MED3.x files
2815             {
2816               int mySize = (int)theInfo.myFamNumNode.size();
2817               theInfo.myFamNumNode.clear();
2818               theInfo.myFamNumNode.resize(mySize,0);
2819               aRet = 0;
2820             }
2821 //          else
2822 //            EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshEntityFamilyNumberRd(...)");
2823       }
2824       if(theErr)
2825         *theErr = aRet;
2826     }
2827
2828     void
2829     TVWrapper
2830     ::GetGrilleType(const MED::TMeshInfo& theMeshInfo,
2831                     EGrilleType& theGridType,
2832                     TErr* theErr)
2833     {
2834       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
2835
2836       if(theErr && *theErr < 0)
2837         EXCEPTION(std::runtime_error," GetGrilleType - aFileWrapper (...)");
2838
2839       MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
2840
2841       if(aMeshInfo.myType == eSTRUCTURE){
2842         TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
2843         TValueHolder<EGrilleType, med_grid_type> aGridType(theGridType);
2844         TErr aRet = MEDmeshGridTypeRd(myFile->Id(),
2845                                       &aMeshName,
2846                                       &aGridType);
2847
2848         if(aRet < 0)
2849           EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshGridTypeRd(...)");
2850       }
2851     }
2852
2853     void
2854     TVWrapper
2855     ::GetGrilleStruct(const MED::TMeshInfo& theMeshInfo,
2856                       TIntVector& theStruct,
2857                       TErr* theErr)
2858     {
2859       TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
2860
2861       if(theErr && *theErr < 0)
2862           return;
2863
2864       TErr aRet;
2865       MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
2866
2867       TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
2868       TValueHolder<TIntVector, med_int> aGridStructure(theStruct);
2869
2870       aRet = MEDmeshGridStructRd(myFile->Id(),
2871                                  &aMeshName,
2872                                  MED_NO_DT,
2873                                  MED_NO_IT,
2874                                  &aGridStructure);
2875       if(theErr)
2876         *theErr = aRet;
2877       else if(aRet < 0)
2878         EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshGridStructRd(...)");
2879     }
2880
2881   }
2882 }