]> SALOME platform Git repositories - modules/kernel.git/commitdiff
Salome HOME
PR: merge from tag mergeto_trunk_18Jan05
authorprascle <prascle>
Mon, 17 Jan 2005 15:48:36 +0000 (15:48 +0000)
committerprascle <prascle>
Mon, 17 Jan 2005 15:48:36 +0000 (15:48 +0000)
154 files changed:
src/MEDWrapper/Base/MED_Algorithm.cxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_Algorithm.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_Common.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_Structures.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_TStructures.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_TWrapper.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_Utilities.cxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_Utilities.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_Wrapper.cxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_Wrapper.hxx [new file with mode: 0644]
src/MEDWrapper/Base/Makefile.in [new file with mode: 0644]
src/MEDWrapper/Factory/MED_Factory.cxx [new file with mode: 0644]
src/MEDWrapper/Factory/MED_Factory.hxx [new file with mode: 0644]
src/MEDWrapper/Factory/MED_Test.cxx [new file with mode: 0644]
src/MEDWrapper/Factory/Makefile.in [new file with mode: 0644]
src/MEDWrapper/MEDA_Algorithm.cxx [deleted file]
src/MEDWrapper/MEDA_Algorithm.hxx [deleted file]
src/MEDWrapper/MEDA_Structures.cxx [deleted file]
src/MEDWrapper/MEDA_Structures.hxx [deleted file]
src/MEDWrapper/MEDA_Test.cxx [deleted file]
src/MEDWrapper/MEDA_Test1.cxx [deleted file]
src/MEDWrapper/MEDA_Wrapper.cxx [deleted file]
src/MEDWrapper/MEDA_Wrapper.hxx [deleted file]
src/MEDWrapper/MED_Common.hxx [deleted file]
src/MEDWrapper/MED_Structures.cxx [deleted file]
src/MEDWrapper/MED_Structures.hxx [deleted file]
src/MEDWrapper/MED_Test.cxx [deleted file]
src/MEDWrapper/MED_Utilities.cxx [deleted file]
src/MEDWrapper/MED_Utilities.hxx [deleted file]
src/MEDWrapper/MED_Wrapper.cxx [deleted file]
src/MEDWrapper/MED_Wrapper.hxx [deleted file]
src/MEDWrapper/Makefile.in
src/MEDWrapper/V2_1/MED1cstring.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MED2cstring.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDGeometrieElement.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MED_V2_1_Wrapper.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MED_V2_1_Wrapper.hxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDattrFermer.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDattrNumEcrire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDattrNumLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDattrOuvrir.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDattrStringEcrire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDattrStringLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDbodyFittedEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDbodyFittedLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDchampCr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDchampEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDchampInfo.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDchampLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDconnEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDconnLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDcoordEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDcoordLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDcstringFree.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDdatagroupCreer.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDdatagroupFermer.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDdatagroupOuvrir.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDdatasetFermer.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDdatasetNumEcrire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDdatasetNumLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDdatasetOuvrir.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDdatasetStringEcrire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDdatasetStringLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDdimLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDelementsEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDelementsLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDequivCr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDequivEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDequivInfo.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDequivLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfam2groA.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfam2groB.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfamCr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfamEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfamGridEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfamGridLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfamInfo.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfamLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfamMaaCr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfamMaaInfo.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfamMaaLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfermer.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfichDesEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfichEntete.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfichierCreer.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfichierFermer.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfichierOuvrir.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDformatConforme.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDfstring.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDgridCr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDgridEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDgridInfo.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDgridLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDgro2famA.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDgro2famB.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDindiceInfo.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDindiceNum.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDlFichDes.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDmaaCr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDmaaInfo.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDmodeErreurVerrouiller.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnChamp.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnCorres.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnEntMaa.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnEntites.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnEquiv.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnFam.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnGrid.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnMaa.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnObjets.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnPasdetemps.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnProfil.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnVal.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnValProfil.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnbnoisEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnbnoisLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnbnomaEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnbnomaLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnbnosoEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnbnosoLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnoeudsEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnoeudsLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnomDataset.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnomEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnomEntite.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnomGeometrie.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnomLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnumEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDnumLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDobjetIdentifer.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDouvrir.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDparametresGeometrie.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDpasdetempsInfo.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDprofilEcr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDprofilInfo.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDprofilLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDunvCr.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDunvLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDversionConforme.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDversionDonner.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/MEDversionLire.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/Makefile.in [new file with mode: 0644]
src/MEDWrapper/V2_1/mdump_V2_1.cxx [new file with mode: 0644]
src/MEDWrapper/V2_1/med.hxx [new file with mode: 0644]
src/MEDWrapper/V2_1/med_hdfi.hxx [new file with mode: 0644]
src/MEDWrapper/V2_1/med_misc.hxx [new file with mode: 0644]
src/MEDWrapper/V2_1/med_outils.hxx [new file with mode: 0644]
src/MEDWrapper/V2_1/med_proto.hxx [new file with mode: 0644]
src/MEDWrapper/V2_1/med_utils.hxx [new file with mode: 0644]
src/MEDWrapper/V2_1/test1_V2_1.cxx [new file with mode: 0644]
src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx [new file with mode: 0644]
src/MEDWrapper/V2_2/MED_V2_2_Wrapper.hxx [new file with mode: 0644]
src/MEDWrapper/V2_2/Makefile.in [new file with mode: 0644]
src/Utils/Utils_CorbaException.hxx

diff --git a/src/MEDWrapper/Base/MED_Algorithm.cxx b/src/MEDWrapper/Base/MED_Algorithm.cxx
new file mode 100644 (file)
index 0000000..cafc21b
--- /dev/null
@@ -0,0 +1,264 @@
+//  
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : 
+//  Author : 
+//  Module : 
+//  $Header$
+
+#include "MED_Algorithm.hxx"
+#include "MED_Utilities.hxx"
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+static int MYVALUEDEBUG = 0;
+#else
+static int MYDEBUG = 0;
+static int MYVALUEDEBUG = 0;
+#endif
+
+namespace MED{
+  //---------------------------------------------------------------
+  TCellGroup 
+  GetCellsByEntity(TWrapper& theWrapper, 
+                  const PMeshInfo& theMeshInfo,
+                  const MED::TEntityInfo& theEntityInfo)
+  {
+    MSG(MYDEBUG,"GetCellsByEntity(...)");
+    TCellGroup aGroup;
+    MED::TEntityInfo::const_iterator anIter = theEntityInfo.begin();
+    for(; anIter != theEntityInfo.end(); anIter++){
+      const EEntiteMaillage& anEntity = anIter->first;
+      if(anEntity == eNOEUD) continue;
+      const MED::TGeom& aGeom = anIter->second;
+      TCellSet& aCellSet = aGroup[anEntity];
+      MED::TGeom::const_iterator anGeomIter = aGeom.begin();
+      for(; anGeomIter != aGeom.end(); anGeomIter++){
+       const EGeometrieElement& aGeo = anGeomIter->first;
+       PCellInfo aCellInfo = theWrapper.GetPCellInfo(theMeshInfo,anEntity,aGeo);
+       aCellSet.insert(aCellInfo);
+       if(MYDEBUG){
+         TInt aNbElem = aCellInfo->GetNbElem();
+         INITMSG(MYDEBUG,"aGeo = "<<aGeo<<"; aNbElem = "<<aNbElem<<": ");
+         for(TInt iElem = 0; iElem < aNbElem; iElem++){
+           TInt iConnEnd = aCellInfo->GetConnDim();
+           for(TInt iConn = 0; iConn < iConnEnd; iConn++){
+             ADDMSG(MYVALUEDEBUG,aCellInfo->GetConn(iElem,iConn)<<",");
+           }
+           ADDMSG(MYVALUEDEBUG," ");
+         }
+         ADDMSG(MYDEBUG,"\n");
+       }
+      }
+    }
+    ADDMSG(MYDEBUG,"\n");
+    return aGroup;
+  }
+  
+  
+  //---------------------------------------------------------------
+  TFamilyGroup 
+  GetFamilies(TWrapper& theWrapper,
+             const PMeshInfo& theMeshInfo)
+  {
+    MSG(MYDEBUG,"GetFamilies(...)");
+    TFamilyGroup aGroup;
+    TInt aNbFam = theWrapper.GetNbFamilies(*theMeshInfo);
+    INITMSG(MYDEBUG,"GetNbFamilies() = "<<aNbFam<<"\n");
+    for(TInt iFam = 1; iFam <= aNbFam; iFam++){
+      PFamilyInfo aFamilyInfo = theWrapper.GetPFamilyInfo(theMeshInfo,iFam);
+      aGroup.insert(aFamilyInfo);
+      if(MYDEBUG){
+       string aName = aFamilyInfo->GetName();
+       TInt aNbAttr = aFamilyInfo->GetNbAttr();
+       TInt aNbGroup = aFamilyInfo->GetNbGroup();
+       INITMSG(MYDEBUG,
+               "aFamilyName = '"<<aName<<"'; andId = "<<aFamilyInfo->GetId()<<
+               "; aNbAttr = "<<aNbAttr<<"; aNbGroup = "<<aNbGroup<<"\n");
+       for(TInt iGroup = 0; iGroup < aNbGroup; iGroup++){
+         aName = aFamilyInfo->GetGroupName(iGroup);
+         INITMSG(MYDEBUG,"aGroupName = '"<<aName<<"'\n");
+       }
+      }
+    }
+    ADDMSG(MYDEBUG,"\n");
+    return aGroup;
+  }
+
+
+  TGroupInfo 
+  GetFamiliesByGroup(const TFamilyGroup& theGroupInfo)
+  {
+    MSG(MYDEBUG,"GetFamiliesByGroup(...)");
+    TGroupInfo aGroup;
+    TFamilyGroup::const_iterator anIter = theGroupInfo.begin();
+    for(; anIter != theGroupInfo.end(); anIter++){
+      const PFamilyInfo& aFamilyInfo = *anIter;
+      TInt aNbGroup = aFamilyInfo->GetNbGroup();
+      for(TInt iGroup = 0; iGroup < aNbGroup; iGroup++){
+       aGroup[aFamilyInfo->GetGroupName(iGroup)].insert(aFamilyInfo);
+      } 
+    }
+    if(MYDEBUG){
+      TGroupInfo::const_iterator anIter = aGroup.begin();
+      for(; anIter != aGroup.end(); anIter++){
+       string aName = anIter->first;
+       INITMSG(MYDEBUG,"aGroupName = '"<<aName<<"'\n");
+       const TFamilyGroup& aFamilyGroup = anIter->second;
+       TFamilyGroup::const_iterator anFamIter = aFamilyGroup.begin();
+       for(; anFamIter != aFamilyGroup.end(); anFamIter++){
+         const PFamilyInfo& aFamilyInfo = *anFamIter;
+         INITMSG(MYDEBUG,"aFamilyName = '"<<aFamilyInfo->GetName()<<"'\n");
+       }
+      }
+      ADDMSG(MYDEBUG,"\n");
+    }
+    return aGroup;
+  }
+
+
+  //---------------------------------------------------------------
+  TTimeStampGroup 
+  GetFieldsByEntity(TWrapper& theWrapper, 
+                   const PMeshInfo& theMeshInfo,
+                   const MED::TEntityInfo& theEntityInfo)
+  {
+    MSG(MYDEBUG,"GetFieldsByEntity(...)");
+    TTimeStampGroup aGroup;
+    TInt aNbFields = theWrapper.GetNbFields();
+    INITMSG(MYDEBUG,"GetNbFields() = "<<aNbFields<<"\n");
+    for(TInt iField = 1; iField <= aNbFields; iField++){
+      PFieldInfo aFieldInfo = theWrapper.GetPFieldInfo(theMeshInfo,iField);
+      TInt aNbComp = aFieldInfo->GetNbComp();
+      string aName = aFieldInfo->GetName();
+      INITMSG(MYDEBUG,"aFieldName = '"<<aName<<"'; aNbComp = "<<aNbComp<<"; ");
+      MED::TGeom aGeom;
+      EEntiteMaillage anEntity = EEntiteMaillage(-1);
+      TInt aNbTimeStamps = theWrapper.GetNbTimeStamps(aFieldInfo,theEntityInfo,anEntity,aGeom);
+      ADDMSG(MYDEBUG,"anEntity = "<<anEntity<<"; GetNbTimeStamps = "<<aNbTimeStamps<<"\n");
+      for(TInt iTimeStamp = 1; iTimeStamp <= aNbTimeStamps; iTimeStamp++){
+       PTimeStampInfo aTimeStamp = 
+         theWrapper.GetPTimeStampInfo(aFieldInfo,anEntity,aGeom,iTimeStamp);
+       aGroup[aFieldInfo].insert(aTimeStamp);
+       INITMSG(MYDEBUG,"aDt = "<<aTimeStamp->GetDt()
+               <<", Unit = \'"<<aTimeStamp->GetUnitDt()
+               <<"\', aNbGauss = "<<aTimeStamp->GetNbGauss()<<"\n");
+      }
+    }
+    ADDMSG(MYDEBUG,"\n");
+    return aGroup;
+  }
+  
+
+  TFieldGroup 
+  GetFieldsByEntity(const TTimeStampGroup& theTimeStampGroup)
+  {
+    TFieldGroup aGroup;
+    TTimeStampGroup::const_iterator anIter = theTimeStampGroup.begin();
+    for(; anIter != theTimeStampGroup.end(); anIter++){
+      //const PFieldInfo& aFieldInfo = anIter->first;
+      const TTimeStampSet& aTimeStampSet = anIter->second;
+      if(aTimeStampSet.empty()) continue;
+      const PTimeStampInfo& aTimeStampInfo = *aTimeStampSet.begin();
+      aGroup[aTimeStampInfo->GetEntity()].insert(*anIter);
+    }
+    return aGroup;
+  }
+  
+
+  TFamilyByEntity
+  GetFamiliesByEntity(TWrapper& theWrapper, 
+                     const PNodeInfo& theNodeInfo,
+                     const TCellGroup& theCellGroup,
+                     const TFamilyGroup& theFamilyGroup)
+  {
+    MSG(MYDEBUG,"GetFamiliesByEntity(...)");
+    TFamilyByEntity aFamilyByEntity;
+    
+    typedef map<TInt,PFamilyInfo> TFamilyByIdMap;
+    TFamilyByIdMap aFamilyByIdMap;
+    TFamilyGroup::const_iterator anIter = theFamilyGroup.begin();
+    for(; anIter != theFamilyGroup.end(); anIter++){
+      const PFamilyInfo& aFamilyInfo = *anIter;
+      aFamilyByIdMap.insert(TFamilyByIdMap::value_type(aFamilyInfo->GetId(),aFamilyInfo));
+    }
+    
+    if(!aFamilyByIdMap.empty()){
+      typedef set<TInt> TFamilyIdSet;
+      typedef map<EEntiteMaillage,TFamilyIdSet> TFamilyIdByEntity;
+      TFamilyIdByEntity aFamilyIdByEntity;
+      
+      if(theNodeInfo!=0){
+       if(TInt aNbElem = theNodeInfo->GetNbElem()){
+         TFamilyIdSet& aFamilyIdSet = aFamilyIdByEntity[eNOEUD];
+         for(TInt i = 0; i < aNbElem; i++){
+           aFamilyIdSet.insert(theNodeInfo->GetFamNum(i));
+         }
+       }
+      }
+      
+      if(!theCellGroup.empty()){
+       TCellGroup::const_iterator anIter = theCellGroup.begin();
+       for(; anIter != theCellGroup.end(); anIter++){
+         const EEntiteMaillage& anEntity = anIter->first;
+         TFamilyIdSet& aFamilyIdSet = aFamilyIdByEntity[anEntity];
+         const TCellSet& aCellSet = anIter->second;
+         TCellSet::const_iterator anCellIter = aCellSet.begin();
+         for(; anCellIter != aCellSet.end(); anCellIter++){
+           const PCellInfo& aCellInfo = *anCellIter;
+           if(TInt aNbElem = aCellInfo->GetNbElem()){
+             for(TInt i = 0; i < aNbElem; i++){
+               aFamilyIdSet.insert(aCellInfo->GetFamNum(i));
+             }
+           }
+         }
+       }
+      }
+      
+      if(!aFamilyIdByEntity.empty()){
+       TFamilyIdByEntity::const_iterator anIter = aFamilyIdByEntity.begin();
+       for(; anIter != aFamilyIdByEntity.end(); anIter++){
+         const EEntiteMaillage& anEntity = anIter->first;
+         INITMSG(MYDEBUG,"anEntity = "<<anEntity<<":\n");
+         const TFamilyIdSet& aFamilyIdSet = anIter->second;
+         TFamilyIdSet::const_iterator anFamilyIdIter = aFamilyIdSet.begin();
+         for(; anFamilyIdIter != aFamilyIdSet.end(); anFamilyIdIter++){
+           const TInt& aFamilyId = *anFamilyIdIter;
+           TFamilyByIdMap::const_iterator 
+             anFamilyByIdMapIter = aFamilyByIdMap.find(aFamilyId);
+           if(anFamilyByIdMapIter != aFamilyByIdMap.end()){
+             const PFamilyInfo& aFamilyInfo = anFamilyByIdMapIter->second;
+           aFamilyByEntity[anEntity].insert(aFamilyInfo);
+           INITMSG(MYDEBUG,
+                   "aFamilyName = '"<<aFamilyInfo->GetName()<<
+                   "' anId = "<<aFamilyInfo->GetId()<<"\n");
+           }
+         }
+       }
+      }
+    }    
+    ADDMSG(MYDEBUG,"\n");
+    return aFamilyByEntity;
+  }
+  
+}
diff --git a/src/MEDWrapper/Base/MED_Algorithm.hxx b/src/MEDWrapper/Base/MED_Algorithm.hxx
new file mode 100644 (file)
index 0000000..7d519c0
--- /dev/null
@@ -0,0 +1,85 @@
+//  
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : 
+//  Author : 
+//  Module : 
+//  $Header$
+
+#ifndef MED_Algorithm_HeaderFile
+#define MED_Algorithm_HeaderFile
+
+#include "MED_Structures.hxx"
+#include "MED_Wrapper.hxx"
+
+#include <set>
+
+namespace MED{
+  //---------------------------------------------------------------
+  typedef std::set<PCellInfo> TCellSet;
+  typedef std::map<EEntiteMaillage,TCellSet> TCellGroup;
+
+  TCellGroup GetCellsByEntity(TWrapper& theWrapper, 
+                             const PMeshInfo& theMeshInfo,
+                             const MED::TEntityInfo& theEntityInfo);
+
+
+  //---------------------------------------------------------------
+  typedef std::set<PFamilyInfo> TFamilyGroup;
+
+  TFamilyGroup GetFamilies(TWrapper& theWrapper, 
+                          const PMeshInfo& theMeshInfo);
+
+
+  //---------------------------------------------------------------
+  typedef std::map<EEntiteMaillage,TFamilyGroup> TFamilyByEntity;
+  
+  TFamilyByEntity GetFamiliesByEntity(TWrapper& theWrapper, 
+                                     const PNodeInfo& theNodeInfo, 
+                                     const TCellGroup& theCellGroup,
+                                     const TFamilyGroup& theFamilyGroup);
+
+
+  //---------------------------------------------------------------
+  typedef std::map<std::string,TFamilyGroup> TGroupInfo;
+  
+  TGroupInfo GetFamiliesByGroup(const TFamilyGroup& theGroupInfo);
+
+  
+  //---------------------------------------------------------------
+  typedef std::set<PTimeStampInfo> TTimeStampSet;
+  typedef std::map<PFieldInfo,TTimeStampSet> TTimeStampGroup;
+
+  TTimeStampGroup GetFieldsByEntity(TWrapper& theWrapper, 
+                                   const PMeshInfo& theMeshInfo,
+                                   const MED::TEntityInfo& theEntityInfo);
+
+
+  //---------------------------------------------------------------
+  typedef std::map<EEntiteMaillage,TTimeStampGroup> TFieldGroup;
+
+  TFieldGroup GetFieldsByEntity(const TTimeStampGroup& theTimeStampGroup);
+
+}
+
+#endif
diff --git a/src/MEDWrapper/Base/MED_Common.hxx b/src/MEDWrapper/Base/MED_Common.hxx
new file mode 100644 (file)
index 0000000..51307ab
--- /dev/null
@@ -0,0 +1,141 @@
+//  
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : 
+//  Author : 
+//  Module : 
+//  $Header$
+
+#ifndef MED_Common_HeaderFile
+#define MED_Common_HeaderFile
+
+#include <string>
+#include <vector>
+#include <set>
+#include <map>
+
+extern "C"{
+#include <hdf5.h>
+}  
+
+#include <boost/shared_ptr.hpp>
+
+namespace MED{
+
+  template<class T> class shared_ptr: public boost::shared_ptr<T>
+  {
+  public:
+    shared_ptr() {}
+
+    template<class Y>
+    explicit shared_ptr(Y * p): boost::shared_ptr<T>(p) {}
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r): boost::shared_ptr<T>(r) {}
+
+    operator const T& () const { return *get();}
+
+    operator T& () { return *get();}
+  };
+
+
+  typedef enum {eFAUX, eVRAI} EBooleen ; 
+  typedef double TFloat;
+  typedef int TInt;
+
+  typedef hid_t TIdt;
+  typedef herr_t TErr;
+
+  typedef enum {eFLOAT64=6, eINT=26} ETypeChamp;
+
+  typedef enum {eNON_STRUCTURE, eSTRUCTURE} EMaillage;
+
+  typedef enum {eCART, eCYL, eSPHER} ERepere; 
+
+  typedef enum {eNOD, eDESC} EConnectivite ; 
+
+  typedef enum {ePOINT1=1, eSEG2=102, eSEG3=103, eTRIA3=203,
+               eQUAD4=204, eTRIA6=206,eQUAD8=208, eTETRA4=304,
+               ePYRA5=305, ePENTA6=306, eHEXA8=308, eTETRA10=310, 
+               ePYRA13=313, ePENTA15=315, eHEXA20=320, 
+               ePOLYGONE=400, ePOLYEDRE=500, eNONE=0} EGeometrieElement;
+
+  typedef enum {eMAILLE, eFACE, eARETE, eNOEUD} EEntiteMaillage; 
+
+  typedef enum {eNO_PFLMOD, eGLOBAL, eCOMPACT}  EModeProfil; 
+
+  typedef std::vector<TFloat> TFloatVector;
+  typedef std::vector<std::string> TStringVector;
+  typedef std::vector<TInt> TIntVector;
+  typedef std::set<std::string> TStringSet;
+  
+  typedef std::map<EGeometrieElement,TInt> TGeom;
+  typedef std::map<EEntiteMaillage,TGeom> TEntityInfo;
+
+  typedef std::set<EGeometrieElement> TGeomSet;
+  typedef std::map<EEntiteMaillage,TGeomSet> TEntity2GeomSet;
+
+  const TEntity2GeomSet& GetEntity2GeomSet();
+
+  inline TInt GetNbConn(EEntiteMaillage theEntity, 
+                       EGeometrieElement theElem,
+                       TInt theMeshDim)
+  {
+    TInt anElemDim = theElem / 100, nsup = 0;
+    if(theEntity == eMAILLE && anElemDim < theMeshDim) nsup = 1;
+    return nsup + theElem % 100;
+  }
+
+  struct TNameInfo;
+  typedef MED::shared_ptr<TNameInfo> PNameInfo;
+  
+  struct TMeshInfo;
+  typedef MED::shared_ptr<TMeshInfo> PMeshInfo;
+  
+  struct TFamilyInfo;
+  typedef MED::shared_ptr<TFamilyInfo> PFamilyInfo;
+
+  struct TElemInfo;
+  typedef MED::shared_ptr<TElemInfo> PElemInfo;
+
+  struct TNodeInfo;
+  typedef MED::shared_ptr<TNodeInfo> PNodeInfo;
+
+  struct TCellInfo;
+  typedef MED::shared_ptr<TCellInfo> PCellInfo;
+
+  struct TFieldInfo;
+  typedef MED::shared_ptr<TFieldInfo> PFieldInfo;
+
+  struct TTimeStampInfo;
+  typedef MED::shared_ptr<TTimeStampInfo> PTimeStampInfo;
+  
+  struct TTimeStampVal;
+  typedef MED::shared_ptr<TTimeStampVal> PTimeStampVal;
+
+  class TWrapper;
+  typedef MED::shared_ptr<TWrapper> PWrapper;
+};
+
+
+#endif
diff --git a/src/MEDWrapper/Base/MED_Structures.hxx b/src/MEDWrapper/Base/MED_Structures.hxx
new file mode 100644 (file)
index 0000000..8ade5eb
--- /dev/null
@@ -0,0 +1,304 @@
+//  
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : 
+//  Author : 
+//  Module : 
+//  $Header$
+
+#ifndef MED_Structures_HeaderFile
+#define MED_Structures_HeaderFile
+
+#include "MED_Common.hxx"
+
+namespace MED{
+
+  //---------------------------------------------------------------
+  typedef std::vector<char> TString;
+
+  inline std::string GetString(TInt theId, TInt theStep, 
+                              const TString& theString)
+  {
+    const char* aPos = &theString[theId*theStep];
+    TInt aSize = std::min(TInt(strlen(aPos)),theStep);
+    return std::string(aPos,aSize);
+  }
+
+  inline void SetString(TInt theId, TInt theStep, 
+                       TString& theString, 
+                       const std::string& theValue)
+  {
+    TInt aSize = std::min(TInt(theValue.size()+1),theStep);
+    strncpy(&theString[theId*theStep],theValue.c_str(),aSize);
+  }
+
+
+  //---------------------------------------------------------------
+  struct TBase
+  {
+    virtual ~TBase() {} 
+  };
+
+
+  //---------------------------------------------------------------
+  struct TNameInfo: virtual TBase
+  {
+    TString myName;
+    virtual std::string GetName() const = 0;
+    virtual void SetName(const std::string& theValue) = 0;
+  };
+
+
+  //---------------------------------------------------------------
+  struct TMeshInfo: virtual TNameInfo
+  {
+    TInt myDim;
+    TInt GetDim() const { return myDim;}
+
+    EMaillage myType;
+    EMaillage GetType() const { return myType;}
+
+    TString myDesc;
+    virtual std::string GetDesc() const = 0;
+    virtual void SetDesc(const std::string& theValue) = 0;
+  };
+  
+
+  //---------------------------------------------------------------
+  typedef std::vector<TInt> TFamAttr;
+
+  struct TFamilyInfo: virtual TNameInfo
+  {
+    PMeshInfo myMeshInfo;
+    const PMeshInfo& GetMeshInfo() const { return myMeshInfo;}
+
+    TInt myId;
+    TInt GetId() const { return myId;}
+    void SetId(TInt theId) { myId = theId;}
+
+    TInt myNbGroup;
+    TInt GetNbGroup() const { return myNbGroup;}
+
+    TString myGroupNames;
+    virtual std::string GetGroupName(TInt theId) const = 0;
+    virtual void SetGroupName(TInt theId, const std::string& theValue) = 0;
+
+    TInt myNbAttr;
+    TInt GetNbAttr() const { return myNbAttr;}
+
+    TFamAttr myAttrId;
+    TInt GetAttrId(TInt theId) const { return myAttrId[theId];}
+    void SetAttrId(TInt theId, TInt theVal) { myAttrId[theId] = theVal;}
+
+    TFamAttr myAttrVal;
+    TInt GetAttrVal(TInt theId) const { return myAttrVal[theId];}
+    void SetAttrVal(TInt theId, TInt theVal) { myAttrVal[theId] = theVal;}
+
+    TString myAttrDesc;
+    virtual std::string GetAttrDesc(TInt theId) const = 0;
+    virtual void SetAttrDesc(TInt theId, const std::string& theValue) = 0;
+  };
+
+
+  //---------------------------------------------------------------
+  typedef std::vector<TInt> TElemNum;
+  
+  struct TElemInfo: virtual TBase
+  {
+    PMeshInfo myMeshInfo;
+    const PMeshInfo& GetMeshInfo() const { return myMeshInfo;}
+
+    TInt myNbElem;
+    TInt GetNbElem() const { return myNbElem;}
+    
+    TElemNum myFamNum;
+    TInt GetFamNum(TInt theId) const { return myFamNum[theId];}
+    void SetFamNum(TInt theId, TInt theVal) { myFamNum[theId] = theVal;}
+
+    EBooleen myIsElemNum;
+    EBooleen IsElemNum() const { return myIsElemNum;}
+
+    TElemNum myElemNum;
+    TInt GetElemNum(TInt theId) const { return myElemNum[theId];}
+    void SetElemNum(TInt theId, TInt theVal) { myElemNum[theId] = theVal;}
+
+    EBooleen myIsElemNames;
+    EBooleen IsElemNames() const { return myIsElemNames;}
+
+    TString myElemNames;
+    virtual std::string GetElemName(TInt theId) const = 0;
+    virtual void SetElemName(TInt theId, const std::string& theValue) = 0;
+  };
+
+
+  //---------------------------------------------------------------
+  typedef std::vector<TFloat> TNodeCoord;
+
+  struct TNodeInfo: virtual TElemInfo
+  {
+    TNodeCoord myCoord;
+    TFloat GetNodeCoord(TInt theId, TInt theComp) const {
+      return myCoord[myMeshInfo->myDim*theId + theComp];
+    }
+    void SetNodeCoord(TInt theId, TInt theComp, TFloat theVal){
+      myCoord[myMeshInfo->myDim*theId + theComp] = theVal;
+    }
+
+    ERepere mySystem;
+    ERepere GetSystem() const { return mySystem;}
+    void SetSystem(ERepere theSystem) { mySystem = theSystem;}
+
+    TString myCoordNames;
+    virtual std::string GetCoordName(TInt theId) const = 0;
+    virtual void SetCoordName(TInt theId, const std::string& theValue) = 0;
+
+    TString myCoordUnits;
+    virtual std::string GetCoordUnit(TInt theId) const = 0;
+    virtual void SetCoordUnit(TInt theId, const std::string& theValue) = 0;
+  };
+
+
+  //---------------------------------------------------------------
+  struct TCellInfo: virtual TElemInfo
+  {
+    EEntiteMaillage myTEntity;
+    EEntiteMaillage GetEntity() const { return myTEntity;}
+
+    EGeometrieElement myTGeom;
+    EGeometrieElement GetGeom() const { return myTGeom;}
+
+    EConnectivite myTConn;
+    EConnectivite GetConn() const { return myTConn;}
+
+    TInt myConnDim;
+    TInt GetConnDim() const { return myConnDim;}
+
+    TElemNum myConn;
+    TInt GetConn(TInt theElemId, TInt theConnId) const {
+      return myConn[myConnDim*theElemId + theConnId];
+    }
+    void SetConn(TInt theElemId, TInt theConnId, TInt theVal){
+      myConn[myConnDim*theElemId + theConnId] = theVal;
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  struct TFieldInfo: virtual TNameInfo
+  {
+    PMeshInfo myMeshInfo;
+    const PMeshInfo& GetMeshInfo() const { return myMeshInfo;}
+
+    ETypeChamp myType;
+    ETypeChamp GetType() const { return myType;}
+
+    TInt myNbComp;
+    TInt GetNbComp() const { return myNbComp;}
+
+    EBooleen myIsLocal;
+    EBooleen GetIsLocal() const { return myIsLocal;}
+
+    TInt myNbRef;
+    TInt GetNbRef() const { return myNbRef;}
+
+    TString myCompNames; 
+    virtual std::string GetCompName(TInt theId) const = 0;
+    virtual void SetCompName(TInt theId, const std::string& theValue) = 0;
+
+    TString myUnitNames; 
+    virtual std::string GetUnitName(TInt theId) const = 0;
+    virtual void SetUnitName(TInt theId, const std::string& theValue) = 0;
+  };
+
+
+  //---------------------------------------------------------------
+  struct TTimeStampInfo: virtual TBase
+  {
+    PFieldInfo myFieldInfo;
+    const PFieldInfo& GetFieldInfo() const { return myFieldInfo;}
+
+    EEntiteMaillage myEntity;
+    EEntiteMaillage GetEntity() const { return myEntity;}
+
+    TGeom myGeom;
+    const TGeom& GetGeom() const { return myGeom;}
+
+    TInt myNbGauss, myNumDt, myNumOrd;
+    TInt GetNbGauss() const { return myNbGauss;}
+    TInt GetNumDt() const { return myNumDt;}
+    TInt GetNumOrd() const { return myNumOrd;}
+
+    TFloat myDt;
+    TFloat GetDt() const { return myDt;}
+
+    TString myGaussName;
+    virtual std::string GetGaussName() const = 0;
+    virtual void SetGaussName(const std::string& theValue) = 0;
+
+    TString myUnitDt;
+    virtual std::string GetUnitDt() const = 0;
+    virtual void SetUnitDt(const std::string& theValue) = 0;
+  };
+  
+
+  //---------------------------------------------------------------
+  typedef std::vector<TFloat> TValue;
+  typedef std::map<EGeometrieElement,TValue> TMeshValue;
+
+  struct TTimeStampVal: virtual TBase
+  {
+    PTimeStampInfo myTimeStampInfo;
+    const PTimeStampInfo& GetTimeStampInfo() const { return myTimeStampInfo;}
+
+    TMeshValue myMeshValue;
+    TFloat GetVal(EGeometrieElement theGeom, TInt theId, 
+                 TInt theComp, TInt theGauss = 0) const
+    {
+      TInt aNbComp = myTimeStampInfo->myFieldInfo->myNbComp;
+      TInt aNbGauss = myTimeStampInfo->myNbGauss;
+      TInt aStep = aNbComp*aNbGauss;
+      TMeshValue::const_iterator anIter = myMeshValue.find(theGeom);
+      if(anIter != myMeshValue.end())
+       return anIter->second[theId*aStep + theComp*aNbGauss + theGauss];
+      return TFloat();
+    }
+    void SetVal(EGeometrieElement theGeom, TInt theId, 
+               TInt theComp, TFloat theVal, TInt theGauss = 0)
+    {
+      TInt aNbComp = myTimeStampInfo->myFieldInfo->myNbComp;
+      TInt aNbGauss = myTimeStampInfo->myNbGauss;
+      TInt aStep = aNbComp*aNbGauss;
+      myMeshValue[theGeom][theId*aStep + theComp*aNbGauss + theGauss] = theVal;
+    }
+    EModeProfil myPflMode;
+    EModeProfil GetPflMode() const { return myPflMode;}
+    void GetPflMode(EModeProfil theVal) { myPflMode = theVal;}
+
+    TString myPflName;
+    virtual std::string GetPflName() const = 0;
+    virtual void SetPflName(const std::string& theValue) = 0;
+  };
+
+}
+
+#endif
diff --git a/src/MEDWrapper/Base/MED_TStructures.hxx b/src/MEDWrapper/Base/MED_TStructures.hxx
new file mode 100644 (file)
index 0000000..93dc7b6
--- /dev/null
@@ -0,0 +1,668 @@
+//  
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : 
+//  Author : 
+//  Module : 
+//  $Header$
+
+#ifndef MED_TStructures_HeaderFile
+#define MED_TStructures_HeaderFile
+
+#include "MED_Structures.hxx"
+
+namespace MED{
+
+  const TInt DESC = 200;
+  const TInt IDENT = 8;
+  const TInt NOM = 32;
+  const TInt LNOM = 80;
+
+  //---------------------------------------------------------------
+  template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM>
+  struct TTNameInfo: virtual TNameInfo
+  {
+    TTNameInfo(const std::string& theValue = "")
+    {
+      myName.resize(nNOM+1);
+      SetName(theValue);
+    }
+
+    virtual std::string GetName() const { 
+      return GetString(0,nNOM,myName);
+    }
+
+    virtual void SetName(const std::string& theValue){
+      SetString(0,nNOM,myName,theValue);
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM>
+  struct TTMeshInfo: TMeshInfo, TTNameInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+  {
+    typedef TTNameInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM> TNameInfoBase;
+
+    TTMeshInfo(const PMeshInfo& theInfo):
+      TNameInfoBase(theInfo->GetName())
+    {
+      myDim = theInfo->GetDim();
+      myType = theInfo->GetType();
+      
+      myDesc.resize(nDESC+1);
+      SetDesc(theInfo->GetDesc());
+    }
+
+    TTMeshInfo(TInt theDim = 0,
+              const std::string& theValue = "",
+              EMaillage theType = eNON_STRUCTURE,
+              const std::string& theDesc = ""):
+      TNameInfoBase(theValue)
+    {
+      myDim = theDim;
+      myType = theType;
+      
+      myDesc.resize(nDESC+1);
+      SetDesc(theDesc);
+    }
+
+    virtual std::string GetDesc() const { 
+      return GetString(0,nDESC,myDesc);
+    }
+
+    virtual void SetDesc(const std::string& theValue){
+      SetString(0,nDESC,myDesc,theValue);
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM>
+  struct TTFamilyInfo: TFamilyInfo, TTNameInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+  {
+    typedef TTNameInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM> TNameInfoBase;
+
+    TTFamilyInfo(const PMeshInfo& theMeshInfo, const PFamilyInfo& theInfo):
+      TNameInfoBase(theInfo->GetName())
+    {
+      myMeshInfo = theMeshInfo;
+
+      myId = theInfo->GetId();
+
+      myNbGroup = theInfo->GetNbGroup();
+      myGroupNames.resize(myNbGroup*nLNOM+1);
+      if(myNbGroup){
+       for(TInt anId = 0; anId < myNbGroup; anId++){
+         SetGroupName(anId,theInfo->GetGroupName(anId));
+       }
+      }
+
+      myNbAttr = theInfo->GetNbAttr();
+      myAttrId.resize(myNbAttr);
+      myAttrVal.resize(myNbAttr);
+      myAttrDesc.resize(myNbAttr*nDESC+1);
+      if(myNbAttr){
+       for(TInt anId = 0; anId < myNbAttr; anId++){
+         SetAttrDesc(anId,theInfo->GetAttrDesc(anId));
+         myAttrVal[anId] = theInfo->GetAttrVal(anId);
+         myAttrId[anId] = theInfo->GetAttrId(anId);
+       }
+      }
+    }
+
+    TTFamilyInfo(const PMeshInfo& theMeshInfo,
+                TInt theNbGroup = 0, 
+                TInt theNbAttr = 0,
+                TInt theId = 0,
+                const std::string& theValue = ""):
+      TNameInfoBase(theValue)
+    {
+      myMeshInfo = theMeshInfo;
+
+      myId = theId;
+
+      myNbGroup = theNbGroup;
+      myGroupNames.resize(theNbGroup*nLNOM+1);
+
+      myNbAttr = theNbAttr;
+      myAttrId.resize(theNbAttr);
+      myAttrVal.resize(theNbAttr);
+      myAttrDesc.resize(theNbAttr*nDESC+1);
+    }
+
+    TTFamilyInfo(const PMeshInfo& theMeshInfo,
+                const std::string& theValue,
+                TInt theId,
+                const TStringSet& theGroupNames, 
+                const TStringVector& theAttrDescs = TStringVector(), 
+                const TIntVector& theAttrIds = TIntVector(), 
+                const TIntVector& theAttrVals = TIntVector()):
+      TNameInfoBase(theValue)
+    {
+      myMeshInfo = theMeshInfo;
+
+      myId = theId;
+
+      myNbGroup = theGroupNames.size();
+      myGroupNames.resize(myNbGroup*nLNOM+1);
+      if(myNbGroup){
+       TStringSet::const_iterator anIter = theGroupNames.begin();
+       for(TInt anId = 0; anIter != theGroupNames.end(); anIter++, anId++){
+         const std::string& aVal = *anIter;
+         SetGroupName(anId,aVal);
+       }
+      }
+
+      myNbAttr = theAttrDescs.size();
+      myAttrId.resize(myNbAttr);
+      myAttrVal.resize(myNbAttr);
+      myAttrDesc.resize(myNbAttr*nDESC+1);
+      if(myNbAttr){
+       for(TInt anId = 0, anEnd = theAttrDescs.size(); anId < anEnd; anId++){
+         SetAttrDesc(anId,theAttrDescs[anId]);
+         myAttrVal[anId] = theAttrVals[anId];
+         myAttrId[anId] = theAttrIds[anId];
+       }
+      }
+    }
+
+    virtual std::string GetGroupName(TInt theId) const { 
+      return GetString(theId,nLNOM,myGroupNames);
+    }
+
+    virtual void SetGroupName(TInt theId, const std::string& theValue){
+      SetString(theId,nLNOM,myGroupNames,theValue);
+    }
+
+    virtual std::string GetAttrDesc(TInt theId) const { 
+      return GetString(theId,nDESC,myAttrDesc);
+    }
+
+    virtual void SetAttrDesc(TInt theId, const std::string& theValue){
+      SetString(theId,nDESC,myAttrDesc,theValue);
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM>
+  struct TTElemInfo: virtual TElemInfo
+  {
+    TTElemInfo(const PMeshInfo& theMeshInfo, const PElemInfo& theInfo)
+    {
+      myMeshInfo = theMeshInfo;
+      
+      myNbElem = theInfo->GetNbElem();
+      myFamNum.resize(myNbElem);
+
+      myIsElemNum = theInfo->IsElemNum();
+      myElemNum.resize(myIsElemNum == eFAUX? 0: myNbElem);
+
+      myIsElemNames = theInfo->IsElemNames();
+      myElemNames.resize(myNbElem*nPNOM+1);
+
+      if(myNbElem){
+       for(TInt anId = 0; anId < myNbElem; anId++){
+         myFamNum[anId] = theInfo->GetFamNum(anId);
+       }
+       if(myIsElemNum == eVRAI){
+         for(TInt anId = 0; anId < myNbElem; anId++){
+           myElemNum[anId] = theInfo->GetElemNum(anId);
+         }
+       }
+       if(myIsElemNames == eVRAI){
+         for(TInt anId = 0; anId < myNbElem; anId++){
+           SetElemName(anId,theInfo->GetElemName(anId));
+         }
+       }
+      }
+    }
+
+    TTElemInfo(const PMeshInfo& theMeshInfo, 
+              TInt theNbElem,
+              EBooleen theIsElemNum = eVRAI,
+              EBooleen theIsElemNames = eVRAI)
+    {
+      myMeshInfo = theMeshInfo;
+
+      myNbElem = theNbElem;
+      myFamNum.resize(theNbElem);
+
+      myIsElemNum = theIsElemNum;
+      myElemNum.resize(theIsElemNum == eFAUX? 0: theNbElem);
+
+      myIsElemNames = theIsElemNames;
+      myElemNames.resize(theNbElem*nPNOM+1);
+    }
+    
+    TTElemInfo(const PMeshInfo& theMeshInfo, 
+              const TIntVector& theFamilyNums,
+              const TIntVector& theElemNums,
+              const TStringVector& theElemNames = TStringVector())
+    {
+      myMeshInfo = theMeshInfo;
+      
+      myNbElem = theFamilyNums.size();
+      myFamNum.resize(myNbElem);
+      
+      myIsElemNum = theElemNums.size()? eVRAI: eFAUX;
+      myElemNum.resize(theElemNums.size());
+      
+      myIsElemNames = theElemNames.size()? eVRAI: eFAUX;
+      myElemNames.resize(theElemNames.size()*nPNOM+1);
+      
+      if(myNbElem){
+       for(TInt anId = 0; anId < myNbElem; anId++){
+         myFamNum[anId] = theFamilyNums[anId];
+       }
+       if(myIsElemNum == eVRAI){
+         for(TInt anId = 0; anId < myNbElem; anId++){
+           myElemNum[anId] = theElemNums[anId];
+         }
+       }
+       if(myIsElemNames == eVRAI){
+         for(TInt anId = 0; anId < myNbElem; anId++){
+           const std::string& aVal = theElemNames[anId];
+           SetElemName(anId,aVal);
+         }
+       }
+      }
+    }
+
+    virtual std::string GetElemName(TInt theId) const { 
+      return GetString(theId,nPNOM,myElemNames);
+    }
+
+    virtual void SetElemName(TInt theId, const std::string& theValue){
+      SetString(theId,nPNOM,myElemNames,theValue);
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM>
+  struct TTNodeInfo: TNodeInfo, TTElemInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+  {
+    typedef TTElemInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM> TElemInfoBase;
+
+    TTNodeInfo(const PMeshInfo& theMeshInfo, const PNodeInfo& theInfo):
+      TElemInfoBase(theMeshInfo,theInfo)
+    {
+      mySystem = theInfo->GetSystem();
+
+      TInt aDim = theMeshInfo->GetDim();
+      TInt aNbElem = theInfo->GetNbElem();
+      myCoord.resize(aNbElem*aDim);
+      
+      for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
+       for(TInt anDimId = 0; anDimId < aDim; anDimId++){
+         SetNodeCoord(anElemId,anDimId,theInfo->GetNodeCoord(anElemId,anDimId));
+       }
+      }
+
+      myCoordNames.resize(aDim*nPNOM+1);
+      for(TInt anId = 0; anId < aDim; anId++){
+       SetCoordName(anId,theInfo->GetCoordName(anId));
+      }
+      
+      myCoordUnits.resize(aDim*nPNOM+1);
+      for(TInt anId = 0; anId < aDim; anId++){
+       SetCoordUnit(anId,theInfo->GetCoordUnit(anId));
+      }
+    }
+
+    TTNodeInfo(const PMeshInfo& theMeshInfo, 
+              TInt theNbElem,
+              ERepere theSystem = eCART, 
+              EBooleen theIsElemNum = eVRAI,
+              EBooleen theIsElemNames = eVRAI):
+      TElemInfoBase(theMeshInfo,
+                   theNbElem,
+                   theIsElemNum,
+                   theIsElemNames)
+    {
+      mySystem = theSystem;
+      myCoord.resize(theNbElem*theMeshInfo->myDim);
+      myCoordNames.resize(theMeshInfo->myDim*nPNOM+1);
+      myCoordUnits.resize(theMeshInfo->myDim*nPNOM+1);
+    }
+
+    
+    TTNodeInfo(const PMeshInfo& theMeshInfo, 
+              ERepere theSystem, 
+              const TFloatVector& theNodeCoords,
+              const TStringVector& theCoordNames,
+              const TStringVector& theCoordUnits,
+              const TIntVector& theFamilyNums,
+              const TIntVector& theElemNums,
+              const TStringVector& theElemNames = TStringVector()):
+      TElemInfoBase(theMeshInfo,
+                   theFamilyNums,
+                   theElemNums,
+                   theElemNames)
+    {
+      mySystem = theSystem;
+      myCoord.resize(theNodeCoords.size());
+      
+      for(TInt anId = 0, anEnd = myCoord.size(); anId < anEnd; anId++){
+       myCoord[anId] = theNodeCoords[anId];
+      }
+
+      TInt aDim = theMeshInfo->GetDim();
+      myCoordNames.resize(aDim*nPNOM+1);
+      for(TInt anId = 0; anId < aDim; anId++){
+       SetCoordName(anId,theCoordNames[anId]);
+      }
+      
+      myCoordUnits.resize(aDim*nPNOM+1);
+      for(TInt anId = 0; anId < aDim; anId++){
+       SetCoordUnit(anId,theCoordUnits[anId]);
+      }
+    }
+
+    virtual std::string GetCoordName(TInt theId) const { 
+      return GetString(theId,nPNOM,myCoordNames);
+    }
+
+    virtual void SetCoordName(TInt theId, const std::string& theValue){
+      SetString(theId,nPNOM,myCoordNames,theValue);
+    }
+
+    virtual std::string GetCoordUnit(TInt theId) const { 
+      return GetString(theId,nPNOM,myCoordUnits);
+    }
+
+    virtual void SetCoordUnit(TInt theId, const std::string& theValue){
+      SetString(theId,nPNOM,myCoordUnits,theValue);
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM>
+  struct TTCellInfo: TCellInfo, TTElemInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+  {
+    typedef TTElemInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM> TElemInfoBase;
+
+    TTCellInfo(const PMeshInfo& theMeshInfo, const PCellInfo& theInfo):
+      TElemInfoBase(theMeshInfo,theInfo)
+    {
+      myTEntity = theInfo->GetEntity();
+      myTGeom = theInfo->GetGeom();
+      myTConn  = theInfo->GetConn();
+      myConnDim = theInfo->GetConnDim();
+      
+      myConn.resize(myNbElem*myConnDim);
+      for(TInt anElemId = 0; anElemId < myNbElem; anElemId++){
+       for(TInt anConnId = 0; anConnId < myConnDim; anConnId++){
+         SetConn(anElemId,anConnId,theInfo->GetConn(anElemId,anConnId));
+       }
+      }
+    }
+
+    TTCellInfo(const PMeshInfo& theMeshInfo, 
+              TInt theNbElem,
+              EEntiteMaillage theTEntity, 
+              EGeometrieElement theTGeom,
+              EConnectivite theTConn = eNOD,
+              EBooleen theIsElemNum = eVRAI,
+              EBooleen theIsElemNames = eVRAI):
+      TElemInfoBase(theMeshInfo,
+                   theNbElem,
+                   theIsElemNum,
+                   theIsElemNames)
+    {
+      myTEntity = theTEntity;
+      myTGeom = theTGeom;
+      myTConn  = theTConn;
+      myConnDim = GetNbConn(myTEntity,myTGeom,theMeshInfo->myDim);
+      myConn.resize(theNbElem*myConnDim);
+    }
+    
+    TTCellInfo(const PMeshInfo& theMeshInfo, 
+              EEntiteMaillage theTEntity, 
+              EGeometrieElement theTGeom,
+              EConnectivite theTConn,
+              const TIntVector& theConnectivities,
+              const TIntVector& theFamilyNums,
+              const TIntVector& theElemNums,
+              const TStringVector& theElemNames = TStringVector()):
+      TTElemInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>(theMeshInfo,
+                                               theFamilyNums,
+                                               theElemNums,
+                                               theElemNames)
+    {
+      myTEntity = theTEntity;
+      myTGeom = theTGeom;
+      myTConn  = theTConn;
+      myConnDim = GetNbConn(myTEntity,myTGeom,theMeshInfo->myDim);
+      myConn.resize(theConnectivities.size());
+      for(TInt anId = 0, anEnd = myConn.size(); anId < anEnd; anId++){
+       myConn[anId] = theConnectivities[anId];
+      }
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM>
+  struct TTFieldInfo: TFieldInfo, TTNameInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+  {
+    typedef TTNameInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM> TNameInfoBase;
+
+    TTFieldInfo(const PMeshInfo& theMeshInfo, const PFieldInfo& theInfo):
+      TNameInfoBase(theInfo->GetName())
+    {
+      myMeshInfo = theMeshInfo;
+
+      myNbComp = theInfo->GetNbComp();
+      myCompNames.resize(myNbComp*nPNOM+1);
+      for(TInt anId = 0; anId < myNbComp; anId++){
+       SetCompName(anId,theInfo->GetCompName(anId));
+      }
+
+      myUnitNames.resize(myNbComp*nPNOM+1);
+      for(TInt anId = 0; anId < myNbComp; anId++){
+       SetUnitName(anId,theInfo->GetUnitName(anId));
+      }
+
+      myType = theInfo->GetType();
+
+      myIsLocal = theInfo->GetIsLocal();
+      myNbRef = theInfo->GetNbRef();
+    }
+
+    TTFieldInfo(const PMeshInfo& theMeshInfo, 
+               TInt theNbComp = 0,
+               ETypeChamp theType = eFLOAT64,
+               const std::string& theValue = "",
+               EBooleen theIsLocal = eVRAI,
+               TInt theNbRef = 1):
+      TNameInfoBase(theValue)
+    {
+      myMeshInfo = theMeshInfo;
+
+      myNbComp = theNbComp;
+      myCompNames.resize(theNbComp*nPNOM+1);
+      myUnitNames.resize(theNbComp*nPNOM+1);
+
+      myType = theType;
+
+      myIsLocal = theIsLocal;
+      myNbRef = theNbRef;
+    }
+    
+    virtual std::string GetCompName(TInt theId) const { 
+      return GetString(theId,nPNOM,myCompNames);
+    }
+
+    virtual void SetCompName(TInt theId, const std::string& theValue){
+      SetString(theId,nPNOM,myCompNames,theValue);
+    }
+
+    virtual std::string GetUnitName(TInt theId) const { 
+      return GetString(theId,nPNOM,myUnitNames);
+    }
+
+    virtual void SetUnitName(TInt theId, const std::string& theValue){
+      SetString(theId,nPNOM,myUnitNames,theValue);
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM>
+  struct TTTimeStampInfo: TTimeStampInfo
+  {
+    TTTimeStampInfo(const PFieldInfo& theFieldInfo, const PTimeStampInfo& theInfo)
+    {
+      myFieldInfo = theFieldInfo;
+
+      myEntity = theInfo->GetEntity();
+      myGeom = theInfo->GetGeom();
+
+      myNbGauss = theInfo->GetNbGauss();
+      myNumDt = theInfo->GetNumDt();
+      myNumOrd = theInfo->GetNumOrd();
+      myDt = theInfo->GetDt();
+
+      myUnitDt.resize(nPNOM+1);
+      SetUnitDt(theInfo->GetUnitDt());
+
+      myGaussName.resize(nNOM+1);
+      SetGaussName(theInfo->GetGaussName());
+    }
+
+    TTTimeStampInfo(const PFieldInfo& theFieldInfo, 
+                   EEntiteMaillage theEntity,
+                   const TGeom& theGeom,
+                   TInt theNbGauss = 0,
+                   TInt theNumDt = 0,
+                   TInt theNumOrd = 0,
+                   TFloat theDt = 0,
+                   const std::string& theUnitDt = "",
+                   const std::string& theGaussName = "")
+    {
+      myFieldInfo = theFieldInfo;
+
+      myEntity = theEntity;
+      myGeom = theGeom;
+
+      myNbGauss = theNbGauss;
+      myNumDt = theNumDt;
+      myNumOrd = theNumDt;
+      myDt = theDt;
+
+      myUnitDt.resize(nPNOM+1);
+      SetUnitDt(theUnitDt);
+
+      myGaussName.resize(nNOM+1);
+      SetGaussName(theGaussName);
+    }
+
+    virtual std::string GetGaussName() const { 
+      return GetString(0,nNOM,myGaussName);
+    }
+
+    virtual void SetGaussName(const std::string& theValue){
+      SetString(0,nNOM,myGaussName,theValue);
+    }
+
+    virtual std::string GetUnitDt() const { 
+      return GetString(0,nPNOM,myUnitDt);
+    }
+
+    virtual void SetUnitDt(const std::string& theValue){
+      SetString(0,nPNOM,myUnitDt,theValue);
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM>
+  struct TTTimeStampVal: TTimeStampVal
+  {
+    TTTimeStampVal(const PTimeStampInfo& theTimeStampInfo, const PTimeStampVal& theInfo)
+    {
+      myTimeStampInfo = theTimeStampInfo;
+
+      myPflMode = theInfo->GetPflMode();
+
+      myPflName.resize(nNOM+1);
+      SetPflName(theInfo->GetPflName());
+
+      TInt aNbComp = theTimeStampInfo->GetFieldInfo()->GetNbComp();
+      const TGeom& aTGeom = theTimeStampInfo->GetGeom();
+      TInt aNbGauss = theTimeStampInfo->GetNbGauss();
+      TGeom::const_iterator anIter = aTGeom.begin();
+      for(; anIter != aTGeom.end(); anIter++){
+       const EGeometrieElement& aGeom = anIter->first;
+       TInt aNbElem = anIter->second;
+       TInt aSize = aNbElem*aNbComp*aNbGauss;
+       TValue& aValue = myMeshValue[aGeom];
+       aValue.resize(aSize);
+       for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
+         for(TInt aCompId = 0; aCompId < aNbComp; aCompId++){
+           for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+             SetVal(aGeom,anElemId,aCompId,theInfo->GetVal(aGeom,anElemId,aCompId,aGaussId),aGaussId);
+           }
+         }
+       }
+      }
+    }
+
+    TTTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
+                  const std::string& thePflName = "",
+                  EModeProfil thePflMode = eCOMPACT)
+    {
+      myTimeStampInfo = theTimeStampInfo;
+
+      myPflMode = thePflMode;
+
+      myPflName.resize(nNOM+1);
+      SetPflName(thePflName);
+
+      TInt aNbComp = theTimeStampInfo->myFieldInfo->myNbComp;
+      TInt aNbGauss = theTimeStampInfo->myNbGauss;
+      const TGeom& aTGeom = theTimeStampInfo->myGeom;
+      TGeom::const_iterator anIter = aTGeom.begin();
+      for(; anIter != aTGeom.end(); anIter++){
+       const EGeometrieElement& aGeom = anIter->first;
+       TInt aNb = anIter->second*aNbComp*aNbGauss;
+       myMeshValue[aGeom].resize(aNb);
+      }
+    }
+
+    virtual std::string GetPflName() const { 
+      return GetString(0,nNOM,myPflName);
+    }
+    
+    virtual void SetPflName(const std::string& theValue){
+      SetString(0,nNOM,myPflName,theValue);
+    }
+  };
+
+}
+
+#endif
diff --git a/src/MEDWrapper/Base/MED_TWrapper.hxx b/src/MEDWrapper/Base/MED_TWrapper.hxx
new file mode 100644 (file)
index 0000000..b5811b0
--- /dev/null
@@ -0,0 +1,275 @@
+//  
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : 
+//  Author : 
+//  Module : 
+//  $Header$
+
+#ifndef MED_TWrapper_HeaderFile
+#define MED_TWrapper_HeaderFile
+
+#include "MED_TStructures.hxx"
+#include "MED_Wrapper.hxx"
+
+namespace MED{
+
+  template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM>
+  class TTWrapper: public TWrapper{
+  public:
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    virtual PMeshInfo CrMeshInfo(TInt theDim = 0,
+                                const std::string& theValue = "",
+                                EMaillage theType = eNON_STRUCTURE,
+                                const std::string& theDesc = "")
+    {
+      return PMeshInfo(new TTMeshInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+                      (theDim,
+                       theValue,
+                       theType,
+                       theDesc));
+    }
+
+    virtual PMeshInfo CrMeshInfo(const PMeshInfo& theInfo)
+    {
+      return PMeshInfo(new TTMeshInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>(theInfo));
+    }
+
+
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    virtual PFamilyInfo CrFamilyInfo(const PMeshInfo& theMeshInfo,
+                                    TInt theNbGroup = 0, 
+                                    TInt theNbAttr = 0,
+                                    TInt theId = 0,
+                                    const std::string& theValue = "")
+    {
+      return PFamilyInfo(new TTFamilyInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+                        (theMeshInfo,
+                         theNbGroup,
+                         theNbAttr,
+                         theId,
+                         theValue));
+    }
+
+    virtual PFamilyInfo CrFamilyInfo(const PMeshInfo& theMeshInfo,
+                                    const std::string& theValue,
+                                    TInt theId,
+                                    const MED::TStringSet& theGroupNames, 
+                                    const MED::TStringVector& theAttrDescs = MED::TStringVector(), 
+                                    const MED::TIntVector& theAttrIds = MED::TIntVector(), 
+                                    const MED::TIntVector& theAttrVals = MED::TIntVector())
+    {
+      return PFamilyInfo(new TTFamilyInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+                        (theMeshInfo,
+                         theValue,
+                         theId,
+                         theGroupNames,
+                         theAttrDescs,
+                         theAttrIds,
+                         theAttrVals));
+    }
+
+    virtual PFamilyInfo CrFamilyInfo(const PMeshInfo& theMeshInfo,
+                                    const PFamilyInfo& theInfo)
+    {
+      return PFamilyInfo(new TTFamilyInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+                        (theMeshInfo,
+                         theInfo));
+    }
+
+
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    virtual PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo, 
+                                TInt theNbElem,
+                                ERepere theSystem = eCART, 
+                                EBooleen theIsElemNum = eVRAI,
+                                EBooleen theIsElemNames = eVRAI)
+    {
+      return PNodeInfo(new TTNodeInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+                      (theMeshInfo,
+                       theNbElem,
+                       theSystem,
+                       theIsElemNum,
+                       theIsElemNames));
+    }
+
+    virtual PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo, 
+                                ERepere theSystem, 
+                                const TFloatVector& theNodeCoords,
+                                const TStringVector& theCoordNames,
+                                const TStringVector& theCoordUnits,
+                                const TIntVector& theFamilyNums,
+                                const TIntVector& theElemNums,
+                                const TStringVector& theElemNames = TStringVector())
+    {
+      return PNodeInfo(new TTNodeInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+                      (theMeshInfo,
+                       theSystem,
+                       theNodeCoords,
+                       theCoordNames,
+                       theCoordUnits,
+                       theFamilyNums,
+                       theElemNums,
+                       theElemNames));
+    }
+
+    virtual PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo,
+                                const PNodeInfo& theInfo)
+    {
+      return PNodeInfo(new TTNodeInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+                      (theMeshInfo,
+                       theInfo));
+    }
+    
+    
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    virtual PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo, 
+                                TInt theNbElem,
+                                EEntiteMaillage theTEntity, 
+                                EGeometrieElement theTGeom,
+                                EConnectivite theTConn = eNOD,
+                                EBooleen theIsElemNum = eVRAI,
+                                EBooleen theIsElemNames = eVRAI)
+    {
+      return PCellInfo(new TTCellInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+                      (theMeshInfo,
+                       theNbElem,
+                       theTEntity,
+                       theTGeom,
+                       theTConn,
+                       theIsElemNum,
+                       theIsElemNames));
+    }
+
+    virtual PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo, 
+                                EEntiteMaillage theTEntity, 
+                                EGeometrieElement theTGeom,
+                                EConnectivite theTConn,
+                                const TIntVector& theConnectivities,
+                                const TIntVector& theFamilyNums,
+                                const TIntVector& theElemNums,
+                                const TStringVector& theElemNames = TStringVector())
+    {
+      return PCellInfo(new TTCellInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+                      (theMeshInfo,
+                       theTEntity,
+                       theTGeom,
+                       theTConn,
+                       theConnectivities,
+                       theFamilyNums,
+                       theElemNums,
+                       theElemNames));
+    }
+
+    virtual PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo,
+                                const PCellInfo& theInfo)
+    {
+      return PCellInfo(new TTCellInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+                      (theMeshInfo,
+                       theInfo));
+    }
+    
+
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    virtual PFieldInfo CrFieldInfo(const PMeshInfo& theMeshInfo, 
+                                  TInt theNbComp = 0,
+                                  ETypeChamp theType = eFLOAT64,
+                                  const std::string& theValue = "",
+                                  EBooleen theIsLocal = eVRAI,
+                                  TInt theNbRef = 1)
+    {
+      return PFieldInfo(new TTFieldInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+                       (theMeshInfo,
+                        theNbComp,
+                        theType,
+                        theValue,
+                        theIsLocal,
+                        theNbRef));
+    }
+
+    virtual PFieldInfo CrFieldInfo(const PMeshInfo& theMeshInfo,
+                                  const PFieldInfo& theInfo)
+    {
+      return PFieldInfo(new TTFieldInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+                       (theMeshInfo,
+                        theInfo));
+    }
+    
+
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    virtual PTimeStampInfo CrTimeStampInfo(const PFieldInfo& theFieldInfo, 
+                                          EEntiteMaillage theEntity,
+                                          const TGeom& theGeom,
+                                          TInt theNbGauss = 0,
+                                          TInt theNumDt = 0,
+                                          TInt theNumOrd = 0,
+                                          TFloat theDt = 0,
+                                          const std::string& theUnitDt = "",
+                                          const std::string& theGaussName = "")
+    {
+      return PTimeStampInfo(new TTTimeStampInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+                           (theFieldInfo,
+                            theEntity,
+                            theGeom,
+                            theNbGauss,
+                            theNumDt,
+                            theNumOrd,
+                            theDt,
+                            theUnitDt,
+                            theGaussName));
+    }
+
+    virtual PTimeStampInfo CrTimeStampInfo(const PFieldInfo& theFieldInfo,
+                                          const PTimeStampInfo& theInfo)
+    {
+      return PTimeStampInfo(new TTTimeStampInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+                           (theFieldInfo,
+                            theInfo));
+    }
+    
+
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    virtual PTimeStampVal CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
+                                        const std::string& thePflName = "",
+                                        EModeProfil thePflMode = eCOMPACT)
+    {
+      return PTimeStampVal(new TTTimeStampVal<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+                          (theTimeStampInfo,
+                           thePflName,
+                           thePflMode));
+    }
+
+    virtual PTimeStampVal CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
+                                        const PTimeStampVal& theInfo)
+    {
+      return PTimeStampVal(new TTTimeStampVal<nPNOM,nDESC,nIDENT,nNOM,nLNOM>
+                          (theTimeStampInfo,
+                           theInfo));
+    }
+    
+  };
+
+}
+
+
+#endif
diff --git a/src/MEDWrapper/Base/MED_Utilities.cxx b/src/MEDWrapper/Base/MED_Utilities.cxx
new file mode 100644 (file)
index 0000000..1454a96
--- /dev/null
@@ -0,0 +1,104 @@
+//  
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : 
+//  Author : 
+//  Module : 
+//  $Header$
+
+#include "MED_Utilities.hxx"
+#include "MED_Common.hxx"
+
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+#else
+static int MYDEBUG = 0;
+#endif
+
+
+int MED::PrefixPrinter::myCounter = 0;
+
+MED::PrefixPrinter::PrefixPrinter(bool theIsActive):
+  myIsActive(theIsActive)
+{
+  if(myIsActive)
+    myCounter++;
+  MSG(MYDEBUG,"MED::PrefixPrinter::PrefixPrinter(...)- "<<myCounter);
+}
+
+MED::PrefixPrinter::~PrefixPrinter()
+{
+  if(myIsActive)
+    myCounter--;
+}
+
+string MED::PrefixPrinter::GetPrefix()
+{
+  if(myCounter)
+    return string(myCounter*2,' ');
+  return "";
+}
+
+
+static MED::TEntity2GeomSet Entity2GeomSet;
+
+bool InitEntity2GeomSet()
+{
+  using namespace MED;
+
+  TGeomSet& aGeomARETESet = Entity2GeomSet[eARETE];
+  aGeomARETESet.insert(eSEG2);
+  aGeomARETESet.insert(eSEG3);
+
+  TGeomSet& aGeomFACESet = Entity2GeomSet[eFACE];
+  aGeomFACESet.insert(eTRIA3);
+  aGeomFACESet.insert(eQUAD4);
+  aGeomFACESet.insert(eTRIA6);
+  aGeomFACESet.insert(eQUAD8);
+
+  TGeomSet& aGeomMAILLESet = Entity2GeomSet[eMAILLE];
+  aGeomMAILLESet.insert(ePOINT1);
+  aGeomMAILLESet.insert(aGeomARETESet.begin(),aGeomARETESet.end());
+  aGeomMAILLESet.insert(aGeomFACESet.begin(),aGeomFACESet.end());
+  aGeomMAILLESet.insert(eTETRA4);
+  aGeomMAILLESet.insert(ePYRA5);
+  aGeomMAILLESet.insert(ePENTA6);
+  aGeomMAILLESet.insert(eHEXA8);
+  aGeomMAILLESet.insert(eTETRA10);
+  aGeomMAILLESet.insert(ePYRA13);
+  aGeomMAILLESet.insert(ePENTA15);
+  aGeomMAILLESet.insert(eHEXA20);
+  
+  return true;
+}
+
+static bool anIsInited = InitEntity2GeomSet();
+
+const MED::TEntity2GeomSet& MED::GetEntity2GeomSet()
+{
+  return Entity2GeomSet;
+}
+
+
diff --git a/src/MEDWrapper/Base/MED_Utilities.hxx b/src/MEDWrapper/Base/MED_Utilities.hxx
new file mode 100644 (file)
index 0000000..96f1b30
--- /dev/null
@@ -0,0 +1,75 @@
+//  
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : 
+//  Author : 
+//  Module : 
+//  $Header$
+
+#ifndef MED_Utilities_HeaderFile
+#define MED_Utilities_HeaderFile
+
+#include <iostream>    
+#include <sstream>     
+#include <string>
+#include <stdexcept>
+
+
+namespace MED{
+  using namespace std;
+  class PrefixPrinter{
+    static int myCounter;
+    bool myIsActive;
+  public:
+    PrefixPrinter(bool theIsActive = true);
+    ~PrefixPrinter();
+
+    static string GetPrefix();
+  };
+};
+
+
+#ifdef _DEBUG_
+  #define MSG(deb,msg) if(deb) std::cout<<MED::PrefixPrinter::GetPrefix()<<msg<<" ("<<__FILE__<<" ["<<__LINE__<<"])\n"
+  #define BEGMSG(deb,msg) if(deb) std::cout<<MED::PrefixPrinter::GetPrefix()<<msg
+  #define INITMSG(deb,msg) MED::PrefixPrinter aPrefixPrinter(deb); BEGMSG(deb,msg)
+  #define ADDMSG(deb,msg) if(deb) std::cout<<msg
+#else
+  #define MSG(deb,msg)
+  #define BEGMSG(deb,msg)
+  #define INITMSG(deb,msg)
+  #define ADDMSG(deb,msg)
+#endif
+
+
+#ifndef EXCEPTION
+
+#define EXCEPTION(TYPE, MSG) {\
+  std::ostringstream aStream;\
+  aStream<<__FILE__<<"["<<__LINE__<<"]::"<<MSG;\
+  throw TYPE(aStream.str());\
+}
+
+#endif
+
+#endif
diff --git a/src/MEDWrapper/Base/MED_Wrapper.cxx b/src/MEDWrapper/Base/MED_Wrapper.cxx
new file mode 100644 (file)
index 0000000..bc76b56
--- /dev/null
@@ -0,0 +1,85 @@
+//  Copyright (C) 2003  CEA/DEN, EDF R&D
+//
+//
+//
+//  File   : VISU_DatConvertor.cxx
+//  Author : Alexey PETROV
+//  Module : VISU
+
+#include "MED_Wrapper.hxx"
+#include "MED_Utilities.hxx"
+namespace MED{
+  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  PMeshInfo TWrapper::GetPMeshInfo(TInt theId)
+  {
+    PMeshInfo anInfo = CrMeshInfo();
+    GetMeshInfo(theId,*anInfo);
+    return anInfo;
+  }
+
+
+  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  PFamilyInfo TWrapper::GetPFamilyInfo(const PMeshInfo& theMeshInfo, TInt theId)
+  {
+    TInt aNbAttr = GetNbFamAttr(theId,*theMeshInfo);
+    TInt aNbGroup = GetNbFamGroup(theId,*theMeshInfo);
+    PFamilyInfo anInfo = CrFamilyInfo(theMeshInfo,aNbGroup,aNbAttr);
+    GetFamilyInfo(theId,*anInfo);
+    return anInfo;
+  }
+
+
+  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  PNodeInfo TWrapper::GetPNodeInfo(const PMeshInfo& theMeshInfo)
+  {
+    TInt aNbElems = GetNbNodes(*theMeshInfo);
+    PNodeInfo anInfo = CrNodeInfo(theMeshInfo,aNbElems);
+    GetNodeInfo(*anInfo);
+    return anInfo;
+  }
+
+
+  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  PCellInfo TWrapper::GetPCellInfo(const PMeshInfo& theMeshInfo,
+                                  EEntiteMaillage theEntity, 
+                                  EGeometrieElement theGeom, 
+                                  EConnectivite theConn)
+  {
+    TInt aNbElem = GetNbCells(*theMeshInfo,theEntity,theGeom,theConn);
+    PCellInfo anInfo = CrCellInfo(theMeshInfo,aNbElem,theEntity,theGeom,theConn);
+    GetCellInfo(*anInfo);
+    return anInfo;
+  }
+
+
+  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  PFieldInfo TWrapper::GetPFieldInfo(const PMeshInfo& theMeshInfo, TInt theId)
+  {
+    TInt aNbComp = GetNbComp(theId);
+    PFieldInfo anInfo = CrFieldInfo(theMeshInfo,aNbComp);
+    GetFieldInfo(theId,*anInfo);
+    return anInfo;
+  }
+
+
+  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  PTimeStampInfo TWrapper::GetPTimeStampInfo(const PFieldInfo& theFieldInfo,
+                                            EEntiteMaillage theEntity,
+                                            const MED::TGeom& theGeom,
+                                            TInt theId)
+  {
+    PTimeStampInfo anInfo = CrTimeStampInfo(theFieldInfo,theEntity,theGeom);
+    GetTimeStampInfo(theId,*anInfo);
+    return anInfo;
+  }
+
+
+  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  PTimeStampVal TWrapper::GetPTimeStampVal(const PTimeStampInfo& theTimeStampInfo)
+  {
+    PTimeStampVal anInfo = CrTimeStampVal(theTimeStampInfo);
+    GetTimeStampVal(*anInfo);
+    return anInfo;
+  }
+}
diff --git a/src/MEDWrapper/Base/MED_Wrapper.hxx b/src/MEDWrapper/Base/MED_Wrapper.hxx
new file mode 100644 (file)
index 0000000..102e38e
--- /dev/null
@@ -0,0 +1,246 @@
+//  
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : 
+//  Author : 
+//  Module : 
+//  $Header$
+
+#ifndef MED_Wrapper_HeaderFile
+#define MED_Wrapper_HeaderFile
+
+#include "MED_Structures.hxx"
+
+namespace MED{
+
+  struct TWrapper{
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    virtual PMeshInfo CrMeshInfo(TInt theDim = 0,
+                                const std::string& theValue = "",
+                                EMaillage theType = eNON_STRUCTURE,
+                                const std::string& theDesc = "") = 0;
+
+    virtual PMeshInfo CrMeshInfo(const PMeshInfo& theInfo) = 0;
+
+    virtual TInt GetNbMeshes(TErr* theErr = NULL) = 0;
+    
+    virtual void GetMeshInfo(TInt theMeshId, TMeshInfo&,
+                            TErr* theErr = NULL) = 0;
+
+    virtual void SetMeshInfo(const TMeshInfo& theInfo,
+                            TErr* theErr = NULL) = 0;
+    
+    virtual PMeshInfo GetPMeshInfo(TInt theId);
+
+
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    virtual TInt GetNbFamilies(const TMeshInfo& theMeshInfo,
+                              TErr* theErr = NULL) = 0;
+
+    virtual TInt GetNbFamAttr(TInt theFamId, 
+                             const TMeshInfo& theInfo,
+                             TErr* theErr = NULL) = 0;
+
+    virtual TInt GetNbFamGroup(TInt theFamId, 
+                              const TMeshInfo& theInfo,
+                              TErr* theErr = NULL) = 0;
+    
+    virtual void GetFamilyInfo(TInt theFamId, 
+                              TFamilyInfo& theInfo,
+                              TErr* theErr = NULL) = 0;
+    
+    virtual void SetFamilyInfo(const TFamilyInfo& theInfo,
+                              TErr* theErr = NULL) = 0;
+    
+    virtual PFamilyInfo CrFamilyInfo(const PMeshInfo& theMeshInfo,
+                                    TInt theNbGroup = 0, 
+                                    TInt theNbAttr = 0,
+                                    TInt theId = 0,
+                                    const std::string& theValue = "") = 0;
+    
+    virtual PFamilyInfo CrFamilyInfo(const PMeshInfo& theMeshInfo,
+                                    const std::string& theValue,
+                                    TInt theId,
+                                    const TStringSet& theGroupNames, 
+                                    const TStringVector& theAttrDescs = TStringVector(), 
+                                    const TIntVector& theAttrIds = TIntVector(), 
+                                    const TIntVector& theAttrVals = TIntVector()) = 0;
+
+    virtual PFamilyInfo CrFamilyInfo(const PMeshInfo& theMeshInfo,
+                                    const PFamilyInfo& theInfo) = 0;
+
+    PFamilyInfo GetPFamilyInfo(const PMeshInfo& theMeshInfo, TInt theId);
+
+
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    virtual TInt GetNbNodes(const TMeshInfo& theMeshInfo,
+                           TErr* theErr = NULL) = 0;
+    
+    virtual void GetNodeInfo(TNodeInfo& theInfo,
+                            TErr* theErr = NULL) = 0;
+
+    virtual void SetNodeInfo(const TNodeInfo& theInfo,
+                            TErr* theErr = NULL) = 0;
+    
+    virtual PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo, 
+                                TInt theNbElem,
+                                ERepere theSystem = eCART, 
+                                EBooleen theIsElemNum = eVRAI,
+                                EBooleen theIsElemNames = eVRAI) = 0;
+
+    virtual PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo, 
+                                ERepere theSystem, 
+                                const TFloatVector& theNodeCoords,
+                                const TStringVector& theCoordNames,
+                                const TStringVector& theCoordUnits,
+                                const TIntVector& theFamilyNums,
+                                const TIntVector& theElemNums,
+                                const TStringVector& theElemNames = TStringVector()) = 0;
+
+    virtual PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo,
+                                const PNodeInfo& theInfo) = 0;
+
+    PNodeInfo GetPNodeInfo(const PMeshInfo& theMeshInfo);
+
+
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    virtual TEntityInfo GetEntityInfo(const TMeshInfo& theMeshInfo,
+                                     EConnectivite theTConn = eNOD,
+                                     TErr* theErr = NULL) = 0;
+    
+    virtual TInt GetNbCells(const TMeshInfo& theMeshInfo, 
+                           EEntiteMaillage, 
+                           EGeometrieElement, 
+                           EConnectivite theTConn = eNOD,
+                           TErr* theErr = NULL) = 0;
+    
+    virtual void GetCellInfo(TCellInfo& theInfo,
+                            TErr* theErr = NULL) = 0;
+
+    virtual void SetCellInfo(const TCellInfo& theInfo,
+                            TErr* theErr = NULL) = 0;
+    
+    virtual PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo, 
+                                TInt theNbElem,
+                                EEntiteMaillage theTEntity, 
+                                EGeometrieElement theTGeom,
+                                EConnectivite theTConn = eNOD,
+                                EBooleen theIsElemNum = eVRAI,
+                                EBooleen theIsElemNames = eVRAI) = 0;
+
+    virtual PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo, 
+                                EEntiteMaillage theTEntity, 
+                                EGeometrieElement theTGeom,
+                                EConnectivite theTConn,
+                                const TIntVector& theConnectivities,
+                                const TIntVector& theFamilyNums,
+                                const TIntVector& theElemNums,
+                                const TStringVector& theElemNames = TStringVector()) = 0;
+
+    virtual PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo,
+                                const PCellInfo& theInfo) = 0;
+
+    PCellInfo GetPCellInfo(const PMeshInfo& theMeshInfo,
+                          EEntiteMaillage theEntity, 
+                          EGeometrieElement theGeom, 
+                          EConnectivite theConn = eNOD);
+
+
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    virtual TInt GetNbFields(TErr* theErr = NULL) = 0;
+    
+    virtual TInt GetNbComp(TInt theFieldId,
+                          TErr* theErr = NULL) = 0;
+    
+    virtual void GetFieldInfo(TInt theFieldId, 
+                             TFieldInfo& theInfo,
+                             TErr* theErr = NULL) = 0;
+
+    virtual void SetFieldInfo(const TFieldInfo& theInfo,
+                             TErr* theErr = NULL) = 0;
+    
+
+    virtual PFieldInfo CrFieldInfo(const PMeshInfo& theMeshInfo, 
+                                  TInt theNbComp = 0,
+                                  ETypeChamp theType = eFLOAT64,
+                                  const std::string& theValue = "",
+                                  EBooleen theIsLocal = eVRAI,
+                                  TInt theNbRef = 1) = 0;
+
+    virtual PFieldInfo CrFieldInfo(const PMeshInfo& theMeshInfo,
+                                  const PFieldInfo& theInfo) = 0;
+
+    PFieldInfo GetPFieldInfo(const PMeshInfo& theMeshInfo, TInt theId);
+
+
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    virtual TInt GetNbTimeStamps(const TFieldInfo& theInfo, 
+                                const TEntityInfo& theEntityInfo,
+                                EEntiteMaillage& theEntity,
+                                TGeom& theGeom,
+                                TErr* theErr = NULL) = 0;
+    
+    virtual void GetTimeStampInfo(TInt theTimeStampId, 
+                                 TTimeStampInfo& theInfo,
+                                 TErr* theErr = NULL) = 0;
+
+    virtual PTimeStampInfo CrTimeStampInfo(const PFieldInfo& theFieldInfo, 
+                                          EEntiteMaillage theEntity,
+                                          const TGeom& theGeom,
+                                          TInt theNbGauss = 0,
+                                          TInt theNumDt = 0,
+                                          TInt theNumOrd = 0,
+                                          TFloat theDt = 0,
+                                          const std::string& theUnitDt = "",
+                                          const std::string& theGaussName = "") = 0;
+
+    virtual PTimeStampInfo CrTimeStampInfo(const PFieldInfo& theFieldInfo,
+                                          const PTimeStampInfo& theInfo) = 0;
+
+    PTimeStampInfo GetPTimeStampInfo(const PFieldInfo& theFieldInfo,
+                                    EEntiteMaillage theEntity,
+                                    const MED::TGeom& theGeom,
+                                    TInt theId);
+    
+
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    virtual void GetTimeStampVal(TTimeStampVal& theVal,
+                                TErr* theErr = NULL) = 0;
+    
+    virtual void SetTimeStamp(const TTimeStampVal& theTimeStampVal,
+                             TErr* theErr = NULL) = 0;
+
+    virtual PTimeStampVal CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
+                                        const std::string& thePflName = "",
+                                        EModeProfil thePflMode = eCOMPACT) = 0;
+
+    virtual PTimeStampVal CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
+                                        const PTimeStampVal& theInfo) = 0;
+
+    PTimeStampVal GetPTimeStampVal(const PTimeStampInfo& theTimeStampInfo);
+
+  };
+
+}
+
+#endif
diff --git a/src/MEDWrapper/Base/Makefile.in b/src/MEDWrapper/Base/Makefile.in
new file mode 100644 (file)
index 0000000..b32b028
--- /dev/null
@@ -0,0 +1,59 @@
+#  
+#
+#  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+#  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+# 
+#  This library is free software; you can redistribute it and/or 
+#  modify it under the terms of the GNU Lesser General Public 
+#  License as published by the Free Software Foundation; either 
+#  version 2.1 of the License. 
+# 
+#  This library is distributed in the hope that it will be useful, 
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+#  Lesser General Public License for more details. 
+# 
+#  You should have received a copy of the GNU Lesser General Public 
+#  License along with this library; if not, write to the Free Software 
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+# 
+#  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+#
+#
+#
+#  File   : 
+#  Author : 
+#  Module : 
+#  $Header$
+
+top_srcdir=@top_srcdir@
+top_builddir=../../..
+srcdir=@srcdir@
+VPATH=.:@srcdir@:@top_srcdir@/idl
+
+
+@COMMENCE@
+
+EXPORT_HEADERS = \
+       MED_Common.hxx \
+       MED_Wrapper.hxx \
+       MED_TWrapper.hxx \
+       MED_Structures.hxx \
+       MED_TStructures.hxx \
+       MED_Algorithm.hxx \
+       MED_Utilities.hxx
+
+# Libraries targets
+
+LIB = libMEDWrapperBase.la
+LIB_SRC = MED_Wrapper.cxx MED_Algorithm.cxx MED_Utilities.cxx
+
+# Executables targets
+BIN = 
+BIN_SRC = 
+
+CPPFLAGS+= $(BOOST_CPPFLAGS) $(HDF5_INCLUDES)
+
+LDFLAGS+=
+
+@CONCLUDE@
diff --git a/src/MEDWrapper/Factory/MED_Factory.cxx b/src/MEDWrapper/Factory/MED_Factory.cxx
new file mode 100644 (file)
index 0000000..cec1589
--- /dev/null
@@ -0,0 +1,103 @@
+//  
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : 
+//  Author : 
+//  Module : 
+//  $Header$
+
+#include "MED_Factory.hxx"
+#include "MED_Utilities.hxx"
+#include "MED_V2_2_Wrapper.hxx"
+#include "MED_V2_1_Wrapper.hxx"
+
+#include <stdio.h>
+
+extern "C"{
+#include <med.h>
+}
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+#else
+static int MYDEBUG = 0;
+#endif
+
+namespace MED{
+  
+  EVersion GetVersionId(const std::string& theFileName)
+  {
+    EVersion aVersion = eVUnknown;
+    char* aFileName = const_cast<char*>(theFileName.c_str());
+    med_idt aFid = MEDouvrir(aFileName,MED_LECTURE);
+    MSG(MYDEBUG,"GetVersionId - theFileName = '"<<theFileName<<"'; aFid = "<<aFid<<endl);
+    if(aFid >= 0){
+      med_int aMajor, aMinor, aRelease;
+      med_err aRet = MEDversionLire(aFid,&aMajor,&aMinor,&aRelease);
+      INITMSG(MYDEBUG,"GetVersionId - theFileName = '"<<theFileName<<"'; aRet = "<<aRet<<endl);
+      if(aRet >= 0){
+       if(aMajor >= 2 && aMinor >= 2)
+         aVersion = eV2_2;
+       else
+         aVersion = eV2_1;
+      }
+    }
+    INITMSG(MYDEBUG,"GetVersionId - theFileName = '"<<theFileName<<"'; aVersion = "<<aVersion<<endl);
+    return aVersion;
+  }
+
+  PWrapper CrWrapper(const std::string& theFileName)
+  {
+    PWrapper aWrapper;
+    EVersion aVersion = GetVersionId(theFileName);
+    switch(aVersion){
+    case eV2_2:
+      aWrapper.reset(new MED::V2_2::TVWrapper(theFileName));
+      break;
+    case eV2_1:
+    default:
+      aWrapper.reset(new MED::V2_1::TVWrapper(theFileName));
+    }
+    return aWrapper;
+  }
+
+  PWrapper CrWrapper(const std::string& theFileName, EVersion theId)
+  {
+    EVersion aVersion = GetVersionId(theFileName);
+
+    if(aVersion != theId)
+      remove(theFileName.c_str());
+    
+    PWrapper aWrapper;
+    switch(theId){
+    case eV2_2:
+      aWrapper.reset(new MED::V2_2::TVWrapper(theFileName));
+      break;
+    case eV2_1:
+      aWrapper.reset(new MED::V2_1::TVWrapper(theFileName));
+      break;
+    }
+    return aWrapper;
+  }
+
+}
diff --git a/src/MEDWrapper/Factory/MED_Factory.hxx b/src/MEDWrapper/Factory/MED_Factory.hxx
new file mode 100644 (file)
index 0000000..3bdb2ae
--- /dev/null
@@ -0,0 +1,46 @@
+//  
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : 
+//  Author : 
+//  Module : 
+//  $Header$
+
+#ifndef MED_Factory_HeaderFile
+#define MED_Factory_HeaderFile
+
+#include "MED_Wrapper.hxx"
+
+namespace MED{
+
+  enum EVersion {eVUnknown = -1, eV2_1, eV2_2};
+
+  EVersion GetVersionId(const std::string& theFileName);
+
+  PWrapper CrWrapper(const std::string& theFileName);
+
+  PWrapper CrWrapper(const std::string& theFileName, EVersion theId);
+
+}
+
+#endif
diff --git a/src/MEDWrapper/Factory/MED_Test.cxx b/src/MEDWrapper/Factory/MED_Test.cxx
new file mode 100644 (file)
index 0000000..e7c8940
--- /dev/null
@@ -0,0 +1,283 @@
+//  
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : 
+//  Author : 
+//  Module : 
+//  $Header$
+
+#include "MED_Utilities.hxx"
+#include "MED_Algorithm.hxx"
+#include "MED_Factory.hxx"
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+static int MYVALUEDEBUG = 1;
+
+static int MYWRITEDEBUG = 1;
+
+using namespace MED;
+
+
+void CheckMed(const std::string& theFileName)
+{
+  MSG(MYDEBUG,"CheckMed - theFileName = '"<<theFileName<<"'");
+  {
+    PWrapper aMed = CrWrapper(theFileName);
+    TInt aNbMeshes = aMed->GetNbMeshes();
+    INITMSG(MYDEBUG,"GetNbMeshes() = "<<aNbMeshes<<endl);
+    for(TInt iMesh = 1; iMesh <= aNbMeshes; iMesh++){
+      
+      PMeshInfo aMeshInfo = aMed->GetPMeshInfo(iMesh);
+      INITMSG(MYDEBUG,"aMeshInfo->GetName() = "<<aMeshInfo->GetName()<<endl);
+
+      //continue;
+
+      PNodeInfo aNodeInfo = aMed->GetPNodeInfo(aMeshInfo);
+      
+      TEntityInfo aEntityInfo = aMed->GetEntityInfo(aMeshInfo);
+      
+      TCellGroup aCellGroup = GetCellsByEntity(aMed,aMeshInfo,aEntityInfo);
+      
+      TFamilyGroup aFamilyGroup = GetFamilies(aMed,aMeshInfo);
+      
+      TFamilyByEntity aFamilyByEntity = GetFamiliesByEntity(aMed,aNodeInfo,aCellGroup,aFamilyGroup);
+      
+      TGroupInfo aGroupInfo = GetFamiliesByGroup(aFamilyGroup);
+      
+      TTimeStampGroup aTimeStampGroup = GetFieldsByEntity(aMed,aMeshInfo,aEntityInfo);
+      
+      TFieldGroup aFieldGroup = GetFieldsByEntity(aTimeStampGroup);
+    }
+  }
+  MSG(MYDEBUG,"OK");
+}
+
+
+void CopyMed(const PWrapper& theMed, 
+            const PWrapper& theMed2, 
+            int theIncr)
+{
+  TInt aNbMeshes = theMed->GetNbMeshes();
+  MSG(MYDEBUG,"aNbMeshes = "<<aNbMeshes);
+  std::string aName;
+  for(TInt iMesh = 0; iMesh < aNbMeshes; iMesh++){
+    PMeshInfo aMeshInfo = theMed->GetPMeshInfo(iMesh+1);
+    TInt aDim = aMeshInfo->myDim;
+    aName = aMeshInfo->GetName();
+    INITMSG(MYDEBUG,"GetMeshInfo - aName = '"<<aName<<"'; aDim = "<<aDim<<"\n");
+    PMeshInfo aMeshInfo2 = theMed2->CrMeshInfo(aMeshInfo);
+    if(MYWRITEDEBUG){
+      aName = aMeshInfo2->GetName();
+
+      aName[0] += theIncr;
+      aMeshInfo2->SetName(aName);
+      theMed2->SetMeshInfo(aMeshInfo2);
+      BEGMSG(MYDEBUG,"aNbMeshes2 = "<<theMed2->GetNbMeshes()<<"\n");
+    }
+    
+    TEntityInfo aEntityInfo = theMed->GetEntityInfo(aMeshInfo);
+
+    //continue;
+
+    TInt aNbFields = theMed->GetNbFields(); 
+    MSG(MYDEBUG,"GetNbFields() = "<<aNbFields);
+    for(TInt iField = 0; iField < aNbFields; iField++){
+      PFieldInfo aFieldInfo = theMed->GetPFieldInfo(aMeshInfo,iField+1);
+      TInt aNbComp = aFieldInfo->GetNbComp();
+      INITMSG(MYDEBUG,"aName = '"<<aFieldInfo->GetName()<<"'; aNbComp = "<<aNbComp<<";\n");
+      PFieldInfo aFieldInfo2 = theMed->CrFieldInfo(aMeshInfo2,aFieldInfo);
+
+      if(MYWRITEDEBUG){
+       aName = aFieldInfo->GetName();
+       aName[0] += theIncr;
+       aFieldInfo2->SetName(aName);
+       theMed2->SetFieldInfo(aFieldInfo2);
+      }
+
+      EEntiteMaillage anEntity;
+      TGeom aTGeom;
+      TInt aNbTimeStamps = 
+       theMed->GetNbTimeStamps(aFieldInfo,aEntityInfo,anEntity,aTGeom);
+      {
+       INITMSG(MYDEBUG,"GetNbTimeStamps = "<<aNbTimeStamps<<endl);
+       for(TInt iTimeStamp = 0; iTimeStamp < aNbTimeStamps; iTimeStamp++){
+         PTimeStampInfo aTimeStampInfo = 
+         theMed->GetPTimeStampInfo(aFieldInfo,anEntity,aTGeom,iTimeStamp+1);
+         TInt aNumDt = aTimeStampInfo->GetNumDt();
+         TInt aNbGauss = aTimeStampInfo->GetNbGauss();
+         INITMSG(MYDEBUG,"aNbGauss = "<<aNbGauss<<"; aNumDt = "<<aNumDt<<"\n");
+         
+         PTimeStampInfo aTimeStampInfo2 = 
+           theMed->CrTimeStampInfo(aFieldInfo2,aTimeStampInfo);
+         
+         PTimeStampVal aTimeStampVal = theMed->GetPTimeStampVal(aTimeStampInfo);
+         
+         PTimeStampVal aTimeStampVal2 = theMed->CrTimeStampVal(aTimeStampInfo2,aTimeStampVal);
+         
+         if(MYWRITEDEBUG) theMed2->SetTimeStamp(aTimeStampVal2);
+         
+         TMeshValue& aMeshValue = aTimeStampVal->myMeshValue;
+         TMeshValue::iterator aMeshValueIter = aMeshValue.begin();
+         for(; aMeshValueIter != aMeshValue.end(); aMeshValueIter++){
+           EGeometrieElement aGeom = aMeshValueIter->first;
+           TValue aValue = aMeshValueIter->second;
+           INITMSG(MYDEBUG,"aGeom = "<<aGeom<<"; aValue = "<<aValue.size()<<": ");
+           for(TInt i = 0, iEnd = aValue.size()/aNbComp; i < iEnd; i++){
+             for(TInt j = 0, ij = i*aNbComp; j < aNbComp; j++, ij++){
+               ADDMSG(MYVALUEDEBUG,aValue[ij]<<",");
+             }
+             ADDMSG(MYVALUEDEBUG," ");
+           }
+           ADDMSG(MYDEBUG,"\n");
+         }
+       }
+      }
+    }
+
+    TInt aNbFam = theMed->GetNbFamilies(aMeshInfo);
+    MSG(MYDEBUG,"GetNbFamilies() = "<<aNbFam);
+    for(TInt iFam = 0; iFam < aNbFam; iFam++){
+      PFamilyInfo aFamilyInfo = theMed->GetPFamilyInfo(aMeshInfo,iFam+1);
+      TInt aNbGroup = aFamilyInfo->GetNbGroup();
+      TInt aNbAttr = aFamilyInfo->GetNbAttr();
+      TInt anId = aFamilyInfo->GetId();
+      aName = aFamilyInfo->GetName();
+      INITMSG(MYDEBUG,"aName = '"<<aName<<"'; anId = "<<anId<<
+             "; aNbAttr = "<<aNbAttr<<"; aNbGroup = "<<aNbGroup<<"\n");
+      PFamilyInfo aFamilyInfo2 = theMed->CrFamilyInfo(aMeshInfo2,aFamilyInfo);
+      for(TInt iGroup = 0; iGroup < aNbGroup; iGroup++){
+       aName = aFamilyInfo->GetGroupName(iGroup);
+       INITMSG(MYDEBUG,"aGroupName = '"<<aName<<"'\n");
+       aName[0] += theIncr;
+       aFamilyInfo2->SetGroupName(iGroup,aName);
+      }
+
+      if(MYWRITEDEBUG){
+       aName = aFamilyInfo->GetName();
+       aName[0] += theIncr;
+       aFamilyInfo2->SetName(aName);
+       theMed2->SetFamilyInfo(aFamilyInfo2);
+       INITMSG(MYDEBUG,"GetNbFamilies = "<<theMed2->GetNbFamilies(aMeshInfo2)<<endl);
+      }
+    }
+
+    MSG(MYDEBUG,"GetEntityInfo - aNbEntities = "<<aEntityInfo.size());
+    TEntityInfo::iterator anEntityInfoIter = aEntityInfo.begin();
+    for(; anEntityInfoIter != aEntityInfo.end(); anEntityInfoIter++){
+      const EEntiteMaillage& anEntity = anEntityInfoIter->first;
+      INITMSG(MYDEBUG,"anEntity = "<<anEntity<<"\n");
+      if(anEntity == eNOEUD){
+       PNodeInfo aNodeInfo = theMed->GetPNodeInfo(aMeshInfo);
+       TInt aNbNodes = aNodeInfo->GetNbElem();
+       INITMSG(MYDEBUG,"GetNodeInfo - aNbNodes = "<<aNbNodes<<": ");
+       TNodeCoord& aCoord = aNodeInfo->myCoord;
+       for(TInt iNode = 0; iNode < aNbNodes; iNode++){
+         for(TInt iDim = 0, anId = iNode*aDim; iDim < aDim; iDim++, anId++){
+           ADDMSG(MYVALUEDEBUG,aCoord[anId]<<",");
+           aCoord[anId] += theIncr;
+         }
+         ADDMSG(MYVALUEDEBUG," ");
+       }
+       ADDMSG(MYDEBUG,endl);
+       PNodeInfo aNodeInfo2 = theMed->CrNodeInfo(aMeshInfo2,aNodeInfo);
+       if(MYWRITEDEBUG) theMed2->SetNodeInfo(aNodeInfo2);
+       continue;
+      }
+      TGeom& aTGeom = anEntityInfoIter->second;
+      TGeom::iterator anTGeomIter = aTGeom.begin();
+      for(; anTGeomIter != aTGeom.end(); anTGeomIter++){
+       const EGeometrieElement& aGeom = anTGeomIter->first;
+       const TInt& aNbElem = anTGeomIter->second;
+       INITMSG(MYDEBUG,"aGeom = "<<aGeom<<"; aNbElem = "<<aNbElem<<": ");
+       PCellInfo aCellInfo = theMed->GetPCellInfo(aMeshInfo,anEntity,aGeom);
+       TInt aConnDim = aCellInfo->GetConnDim();
+       for(TInt iElem = 0; iElem < aNbElem; iElem++){
+         for(TInt iConn = 0; iConn < aConnDim; iConn++){
+           ADDMSG(MYVALUEDEBUG,aCellInfo->GetConn(iElem,iConn)<<",");
+         }
+         ADDMSG(MYVALUEDEBUG," ");
+       }
+       ADDMSG(MYDEBUG,endl);
+       PCellInfo aCellInfo2 = theMed->CrCellInfo(aMeshInfo2,aCellInfo);
+       if(MYWRITEDEBUG) theMed2->SetCellInfo(aCellInfo2);
+      }
+    }
+    
+  }
+  MSG(MYDEBUG,"OK");
+}
+
+
+void CopyMed(const std::string& theFileName, 
+            const std::string& theFileName2, 
+            MED::EVersion theVersion,
+            int theNbCopy)
+{
+  MSG(MYDEBUG,"CopyMed - theFileName = '"<<theFileName<<"'; theFileName2 = '"<<theFileName2<<"'");
+
+  PWrapper aMed = CrWrapper(theFileName);
+
+  PWrapper aMed2 = CrWrapper(theFileName2,theVersion);
+
+  for(int i = 0; i < theNbCopy; i++) 
+    CopyMed(aMed,aMed2,i);
+}
+
+
+void ReadMed(const char* theFileName, 
+            const char* theFileName2,
+            MED::EVersion theVersion = eV2_1,
+            int theNbCopy = 1)
+{
+  MSG(MYDEBUG,"theFileName = '"<<theFileName<<"'; "<<
+      "theFileName2 = '"<<theFileName2<<"'; "<<
+      "theVersion = "<<theVersion<<"; "<<
+      "theNbCopy = "<<theNbCopy);
+
+  CopyMed(theFileName,theFileName2,theVersion,theNbCopy);
+}
+
+
+int main(int argc, char** argv){ 
+  try{
+    if(argc == 2)
+      CheckMed(argv[1]);
+    if(argc == 3)
+      ReadMed(argv[1],argv[2]);
+    if(argc == 4)
+      ReadMed(argv[1],argv[2],MED::EVersion(atoi(argv[3])));
+    if(argc == 5)
+      ReadMed(argv[1],argv[2],MED::EVersion(atoi(argv[3])),atoi(argv[4]));
+    return 0;
+  }catch(std::exception& exc){
+    MSG(MYDEBUG,"Follow exception was accured :\n"<<exc.what());
+  }catch(...){
+    MSG(MYDEBUG,"Unknown exception was accured in VISU_Convertor_impl");
+  } 
+  return 1;
+}
diff --git a/src/MEDWrapper/Factory/Makefile.in b/src/MEDWrapper/Factory/Makefile.in
new file mode 100644 (file)
index 0000000..18b82be
--- /dev/null
@@ -0,0 +1,54 @@
+#  
+#
+#  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+#  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+# 
+#  This library is free software; you can redistribute it and/or 
+#  modify it under the terms of the GNU Lesser General Public 
+#  License as published by the Free Software Foundation; either 
+#  version 2.1 of the License. 
+# 
+#  This library is distributed in the hope that it will be useful, 
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+#  Lesser General Public License for more details. 
+# 
+#  You should have received a copy of the GNU Lesser General Public 
+#  License along with this library; if not, write to the Free Software 
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+# 
+#  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+#
+#
+#
+#  File   : 
+#  Author : 
+#  Module : 
+#  $Header$
+
+top_srcdir=@top_srcdir@
+top_builddir=../../..
+srcdir=@srcdir@
+VPATH=.:@srcdir@:@top_srcdir@/idl
+
+
+@COMMENCE@
+
+# Libraries targets
+
+LIB = libMEDWrapper.la
+LIB_SRC = \
+       MED_Factory.cxx
+
+EXPORT_HEADERS = \
+       MED_Factory.hxx
+
+# Executables targets
+BIN = MED_Test
+BIN_SRC = 
+
+CPPFLAGS+= $(BOOST_CPPFLAGS) $(MED2_INCLUDES)
+
+LDFLAGS+= -lMEDWrapper_V2_2 -lMEDWrapper_V2_1
+
+@CONCLUDE@
diff --git a/src/MEDWrapper/MEDA_Algorithm.cxx b/src/MEDWrapper/MEDA_Algorithm.cxx
deleted file mode 100644 (file)
index 1f090c0..0000000
+++ /dev/null
@@ -1,252 +0,0 @@
-//  Copyright (C) 2003  CEA/DEN, EDF R&D
-//
-//
-//
-//  File   : VISU_DatConvertor.cxx
-//  Author : Alexey PETROV
-//  Module : VISU
-
-#include "MEDA_Algorithm.hxx"
-#include "MED_Utilities.hxx"
-using namespace std;
-using namespace MEDA;
-
-#ifdef _DEBUG_
-static int MYDEBUG = 1;
-#else
-static int MYDEBUG = 0;
-#endif
-
-
-//---------------------------------------------------------------
-TCellGroup MEDA::GetCellsByEntity(TWrapper& theWrapper, 
-                                 const PMeshInfo& theMeshInfo,
-                                 const MED::TEntityInfo theEntityInfo)
-{
-  if(MYDEBUG) MESSAGE("GetCellsByEntity(...)");
-  TCellGroup aGroup;
-  MED::TEntityInfo::const_iterator anIter = theEntityInfo.begin();
-  for(; anIter != theEntityInfo.end(); anIter++){
-    const med_entite_maillage& anEntity = anIter->first;
-    if(anEntity == MED_NOEUD) continue;
-    const MED::TGeom& aGeom = anIter->second;
-    TCellSet& aCellSet = aGroup[anEntity];
-    MED::TGeom::const_iterator anGeomIter = aGeom.begin();
-    for(; anGeomIter != aGeom.end(); anGeomIter++){
-      const med_geometrie_element& aGeo = anGeomIter->first;
-      PCellInfo aCellInfo = theWrapper.GetCellInfo(theMeshInfo,anEntity,aGeo);
-      aCellSet.insert(aCellInfo);
-      if(MYDEBUG){
-       med_int aNbElem = aCellInfo->GetNbElem();
-       MED::PrefixPrinter aPrefixPrinter;
-       BEGMSG("aGeo = "<<aGeo<<"; aNbElem = "<<aNbElem<<": ");
-       for(int iElem = 0; iElem < aNbElem; iElem++){
-         int iConnEnd = aCellInfo->GetConnDim();
-         for(int iConn = 0; iConn < iConnEnd; iConn++){
-           ADDMSG(aCellInfo->GetConn(iElem,iConn)<<",");
-         }
-         ADDMSG(" ");
-       }
-       ADDMSG("\n");
-      }
-    }
-  }
-  if(MYDEBUG) ADDMSG("\n");
-  return aGroup;
-}
-
-
-//---------------------------------------------------------------
-TFamilyGroup 
-MEDA::GetFamilies(TWrapper& theWrapper,
-                 const PMeshInfo& theMeshInfo)
-{
-  if(MYDEBUG) MESSAGE("GetFamilies(...)");
-  TFamilyGroup aGroup;
-  int aNbFam = theWrapper.GetNbFamilies(theMeshInfo);
-  MED::PrefixPrinter aPrefixPrinter;
-  if(MYDEBUG) BEGMSG("GetNbFamilies() = "<<aNbFam<<"\n");
-  for(int iFam = 0; iFam < aNbFam; iFam++){
-    PFamilyInfo aFamilyInfo = theWrapper.GetFamilyInfo(theMeshInfo,iFam);
-    aGroup.insert(aFamilyInfo);
-    if(MYDEBUG){
-      MED::PrefixPrinter aPrefixPrinter;
-      string aName = aFamilyInfo->GetName();
-      med_int aNbAttr = aFamilyInfo->GetNbAttr();
-      med_int aNbGroup = aFamilyInfo->GetNbGroup();
-      BEGMSG("aFamilyName = '"<<aName<<"'; andId = "<<aFamilyInfo->GetId()<<
-            "; aNbAttr = "<<aNbAttr<<"; aNbGroup = "<<aNbGroup<<"\n");
-      for(int iGroup = 0; iGroup < aNbGroup; iGroup++){
-       aName = aFamilyInfo->GetGroupName(iGroup);
-       MED::PrefixPrinter aPrefixPrinter;
-       BEGMSG("aGroupName = '"<<aName<<"'\n");
-      }
-    }
-  }
-  if(MYDEBUG) ADDMSG("\n");
-  return aGroup;
-}
-
-
-TGroupInfo 
-MEDA::GetFamiliesByGroup(const TFamilyGroup& theGroupInfo)
-{
-  if(MYDEBUG) MESSAGE("GetFamiliesByGroup(...)");
-  TGroupInfo aGroup;
-  TFamilyGroup::const_iterator anIter = theGroupInfo.begin();
-  for(; anIter != theGroupInfo.end(); anIter++){
-    const PFamilyInfo& aFamilyInfo = *anIter;
-    int aNbGroup = aFamilyInfo->GetNbGroup();
-    for(int iGroup = 0; iGroup < aNbGroup; iGroup++){
-      aGroup[aFamilyInfo->GetGroupName(iGroup)].insert(aFamilyInfo);
-    } 
-  }
-  if(MYDEBUG){
-    TGroupInfo::const_iterator anIter = aGroup.begin();
-    for(; anIter != aGroup.end(); anIter++){
-      string aName = anIter->first;
-      MED::PrefixPrinter aPrefixPrinter;
-      BEGMSG("aGroupName = '"<<aName<<"'\n");
-      const TFamilyGroup& aFamilyGroup = anIter->second;
-      TFamilyGroup::const_iterator anFamIter = aFamilyGroup.begin();
-      for(; anFamIter != aFamilyGroup.end(); anFamIter++){
-       const PFamilyInfo& aFamilyInfo = *anFamIter;
-       MED::PrefixPrinter aPrefixPrinter;
-       BEGMSG("aFamilyName = '"<<aFamilyInfo->GetName()<<"'\n");
-      }
-    }
-    ADDMSG("\n");
-  }
-  return aGroup;
-}
-
-
-//---------------------------------------------------------------
-TTimeStampGroup 
-MEDA::GetFieldsByEntity(TWrapper& theWrapper, 
-                       const PMeshInfo& theMeshInfo,
-                       const MED::TEntityInfo theEntityInfo)
-{
-  if(MYDEBUG) MESSAGE("GetFieldsByEntity(...)");
-  TTimeStampGroup aGroup;
-  med_int aNbFields = theWrapper.GetNbFields(); 
-  MED::PrefixPrinter aPrefixPrinter;
-  if(MYDEBUG) BEGMSG("GetNbFields() = "<<aNbFields<<"\n");
-  for(int iField = 0; iField < aNbFields; iField++){
-    PFieldInfo aFieldInfo = theWrapper.GetFieldInfo(theMeshInfo,iField);
-    med_int aNbComp = aFieldInfo->GetNbComp();
-    string aName = aFieldInfo->GetName();
-    MED::PrefixPrinter aPrefixPrinter;
-    if(MYDEBUG) BEGMSG("aFieldName = '"<<aName<<"'; aNbComp = "<<aNbComp<<"; ");
-    MED::TGeom aGeom;
-    med_entite_maillage anEntity;
-    med_int aNbTimeStamps = theWrapper.GetNbTimeStamps(aFieldInfo,theEntityInfo,anEntity,aGeom);
-    if(MYDEBUG) BEGMSG("anEntity = "<<anEntity<<"; GetNbTimeStamps = "<<aNbTimeStamps<<"\n");
-    for(int iTimeStamp = 0; iTimeStamp < aNbTimeStamps; iTimeStamp++){
-      PTimeStampInfo aTimeStamp = 
-       theWrapper.GetTimeStampInfo(aFieldInfo,iTimeStamp,anEntity,aGeom);
-      aGroup[aFieldInfo].insert(aTimeStamp);
-      med_int aNbGauss = aTimeStamp->GetNbGauss();
-      MED::PrefixPrinter aPrefixPrinter;
-      if(MYDEBUG) BEGMSG("aDt = "<<aTimeStamp->GetDt()<<", "<<aTimeStamp->GetUnitDt()<<"\n");
-    }
-  }
-  if(MYDEBUG) ADDMSG("\n");
-  return aGroup;
-}
-
-
-TFieldGroup 
-MEDA::GetFieldsByEntity(const TTimeStampGroup& theTimeStampGroup)
-{
-  TFieldGroup aGroup;
-  TTimeStampGroup::const_iterator anIter = theTimeStampGroup.begin();
-  for(; anIter != theTimeStampGroup.end(); anIter++){
-    const PFieldInfo& aFieldInfo = anIter->first;
-    const TTimeStampSet& aTimeStampSet = anIter->second;
-    if(aTimeStampSet.empty()) continue;
-    const PTimeStampInfo& aTimeStampInfo = *aTimeStampSet.begin();
-    aGroup[aTimeStampInfo->GetEntity()].insert(*anIter);
-  }
-  return aGroup;
-}
-
-
-TFamilyByEntity
-MEDA::GetFamiliesByEntity(TWrapper& theWrapper, 
-                         const PNodeInfo& theNodeInfo,
-                         const TCellGroup& theCellGroup,
-                         const TFamilyGroup& theFamilyGroup)
-{
-  if(MYDEBUG) MESSAGE("GetFamiliesByEntity(...)");
-  TFamilyByEntity aFamilyByEntity;
-
-  typedef map<med_int,PFamilyInfo> TFamilyByIdMap;
-  TFamilyByIdMap aFamilyByIdMap;
-  TFamilyGroup::const_iterator anIter = theFamilyGroup.begin();
-  for(; anIter != theFamilyGroup.end(); anIter++){
-    const PFamilyInfo& aFamilyInfo = *anIter;
-    aFamilyByIdMap.insert(TFamilyByIdMap::value_type(aFamilyInfo->GetId(),aFamilyInfo));
-  }
-
-  if(!aFamilyByIdMap.empty()){
-    typedef set<med_int> TFamilyIdSet;
-    typedef map<med_entite_maillage,TFamilyIdSet> TFamilyIdByEntity;
-    TFamilyIdByEntity aFamilyIdByEntity;
-
-    if(theNodeInfo!=0){
-      if(med_int aNbElem = theNodeInfo->GetNbElem()){
-       TFamilyIdSet& aFamilyIdSet = aFamilyIdByEntity[MED_NOEUD];
-       for(med_int i = 0; i < aNbElem; i++){
-         aFamilyIdSet.insert(theNodeInfo->GetFamNum(i));
-       }
-      }
-    }
-    
-    if(!theCellGroup.empty()){
-      TCellGroup::const_iterator anIter = theCellGroup.begin();
-      for(; anIter != theCellGroup.end(); anIter++){
-       const med_entite_maillage& anEntity = anIter->first;
-       TFamilyIdSet& aFamilyIdSet = aFamilyIdByEntity[anEntity];
-       const TCellSet& aCellSet = anIter->second;
-       TCellSet::const_iterator anCellIter = aCellSet.begin();
-       for(; anCellIter != aCellSet.end(); anCellIter++){
-         const PCellInfo& aCellInfo = *anCellIter;
-         if(med_int aNbElem = aCellInfo->GetNbElem()){
-           for(med_int i = 0; i < aNbElem; i++){
-             aFamilyIdSet.insert(aCellInfo->GetFamNum(i));
-           }
-         }
-       }
-      }
-    }
-    
-    if(!aFamilyIdByEntity.empty()){
-      TFamilyIdByEntity::const_iterator anIter = aFamilyIdByEntity.begin();
-      for(; anIter != aFamilyIdByEntity.end(); anIter++){
-       const med_entite_maillage& anEntity = anIter->first;
-       MED::PrefixPrinter aPrefixPrinter;
-       if(MYDEBUG) BEGMSG("anEntity = "<<anEntity<<":\n");
-       const TFamilyIdSet& aFamilyIdSet = anIter->second;
-       TFamilyIdSet::const_iterator anFamilyIdIter = aFamilyIdSet.begin();
-       for(; anFamilyIdIter != aFamilyIdSet.end(); anFamilyIdIter++){
-         const med_int& aFamilyId = *anFamilyIdIter;
-         TFamilyByIdMap::const_iterator 
-           anFamilyByIdMapIter = aFamilyByIdMap.find(aFamilyId);
-         if(anFamilyByIdMapIter != aFamilyByIdMap.end()){
-           const PFamilyInfo& aFamilyInfo = anFamilyByIdMapIter->second;
-           aFamilyByEntity[anEntity].insert(aFamilyInfo);
-           MED::PrefixPrinter aPrefixPrinter;
-           if(MYDEBUG) 
-             BEGMSG("aFamilyName = '"<<aFamilyInfo->GetName()<<
-                    "' anId = "<<aFamilyInfo->GetId()<<"\n");
-         }
-       }
-      }
-    }
-  }    
-  if(MYDEBUG) ADDMSG("\n");
-  return aFamilyByEntity;
-}
-
diff --git a/src/MEDWrapper/MEDA_Algorithm.hxx b/src/MEDWrapper/MEDA_Algorithm.hxx
deleted file mode 100644 (file)
index 326da0d..0000000
+++ /dev/null
@@ -1,69 +0,0 @@
-//  Copyright (C) 2003  CEA/DEN, EDF R&D
-//
-//
-//
-//  File   : VISU_DatConvertor.hxx
-//  Author : Alexey PETROV
-//  Module : VISU
-
-#ifndef MEDA_Algorithm_HeaderFile
-#define MEDA_Algorithm_HeaderFile
-
-#include "MEDA_Structures.hxx"
-#include "MEDA_Wrapper.hxx"
-
-#include <set>
-
-namespace MEDA{
-  using namespace std;
-  using namespace boost;
-
-
-  //---------------------------------------------------------------
-  typedef set<PCellInfo> TCellSet;
-  typedef map<med_entite_maillage,TCellSet> TCellGroup;
-
-  TCellGroup GetCellsByEntity(TWrapper& theWrapper, 
-                             const PMeshInfo& theMeshInfo,
-                             const MED::TEntityInfo theEntityInfo);
-
-
-  //---------------------------------------------------------------
-  typedef set<PFamilyInfo> TFamilyGroup;
-
-  TFamilyGroup GetFamilies(TWrapper& theWrapper, 
-                          const PMeshInfo& theMeshInfo);
-
-
-  //---------------------------------------------------------------
-  typedef map<med_entite_maillage,TFamilyGroup> TFamilyByEntity;
-  
-  TFamilyByEntity GetFamiliesByEntity(TWrapper& theWrapper, 
-                                     const PNodeInfo& theNodeInfo, 
-                                     const TCellGroup& theCellGroup,
-                                     const TFamilyGroup& theFamilyGroup);
-
-
-  //---------------------------------------------------------------
-  typedef map<string,TFamilyGroup> TGroupInfo;
-  
-  TGroupInfo GetFamiliesByGroup(const TFamilyGroup& theGroupInfo);
-
-
-  //---------------------------------------------------------------
-  typedef set<PTimeStampInfo> TTimeStampSet;
-  typedef map<PFieldInfo,TTimeStampSet> TTimeStampGroup;
-
-  TTimeStampGroup GetFieldsByEntity(TWrapper& theWrapper, 
-                                   const PMeshInfo& theMeshInfo,
-                                   const MED::TEntityInfo theEntityInfo);
-
-
-  //---------------------------------------------------------------
-  typedef map<med_entite_maillage,TTimeStampGroup> TFieldGroup;
-
-  TFieldGroup GetFieldsByEntity(const TTimeStampGroup& theTimeStampGroup);
-
-};
-
-#endif
diff --git a/src/MEDWrapper/MEDA_Structures.cxx b/src/MEDWrapper/MEDA_Structures.cxx
deleted file mode 100644 (file)
index eb10c07..0000000
+++ /dev/null
@@ -1,333 +0,0 @@
-//  Copyright (C) 2003  CEA/DEN, EDF R&D
-//
-//
-//
-//  File   : VISU_DatConvertor.cxx
-//  Author : Alexey PETROV
-//  Module : VISU
-
-#include "MEDA_Structures.hxx"
-#include "MED_Structures.hxx"
-#include "MED_Utilities.hxx"
-
-using namespace std;
-using namespace MEDA;
-
-#ifdef _DEBUG_
-static int MYDEBUG = 1;
-#else
-static int MYDEBUG = 0;
-#endif
-
-
-//---------------------------------------------------------------
-TNameInfo::TNameInfo(const MED::PNameInfo& theInfo): 
-  myInfo(theInfo) 
-{}
-
-string TNameInfo::GetName() const{
-  return myInfo->GetName();
-}
-
-void TNameInfo::SetName(const string& theValue){
-  myInfo->SetName(theValue);
-}
-
-
-//---------------------------------------------------------------
-TMeshInfo::TMeshInfo(const MED::PMeshInfo& theInfo): 
-  TNameInfo(theInfo),
-  myInfo(theInfo)
-{}
-
-med_int TMeshInfo::GetDim() const{
-  return myInfo->myDim;
-}
-
-
-//---------------------------------------------------------------
-TFamilyInfo::TFamilyInfo(const MED::PFamilyInfo& theInfo): 
-  TNameInfo(theInfo),
-  myInfo(theInfo) 
-{}
-
-med_int TFamilyInfo::GetId() const{
-  return myInfo->myId;
-}
-
-void TFamilyInfo::SetId(med_int theId){
-  myInfo->myId = theId;
-}
-
-med_int TFamilyInfo::GetNbGroup() const{
-  return myInfo->myNbGroup;
-}
-
-string TFamilyInfo::GetGroupName(med_int theId) const{
-  return myInfo->GetGroupName(theId);
-}
-
-void TFamilyInfo::SetGroupName(med_int theId, const string& theValue){
-  myInfo->SetGroupName(theId,theValue);
-}
-
-med_int TFamilyInfo::GetNbAttr() const{
-  return myInfo->myNbAttr;
-}
-
-string TFamilyInfo::GetAttrDesc(med_int theId) const{
-  return myInfo->GetAttrDesc(theId);
-}
-
-void TFamilyInfo::SetAttrDesc(med_int theId, const string& theValue){
-  myInfo->SetAttrDesc(theId,theValue);
-}
-
-med_int TFamilyInfo::GetAttrId(med_int theId) const{
-  return myInfo->myAttrId[theId];
-}
-
-void TFamilyInfo::SetAttrId(med_int theId, med_int theVal){
-  myInfo->myAttrId[theId] = theVal;
-}
-
-med_int TFamilyInfo::GetAttrVal(med_int theId) const{
-  return myInfo->myAttrVal[theId];
-}
-
-void TFamilyInfo::SetAttrVal(med_int theId, med_int theVal){
-  myInfo->myAttrVal[theId] = theVal;
-}
-
-
-//---------------------------------------------------------------
-TElemInfo::TElemInfo(const MED::PElemInfo& theInfo): 
-  myInfo(theInfo) 
-{}
-
-med_int TElemInfo::GetNbElem() const{
-  return myInfo->myNbElem;
-}
-
-med_int TElemInfo::GetFamNum(med_int theId) const{
-  return myInfo->myFamNum[theId];
-}
-
-void TElemInfo::SetFamNum(med_int theId, med_int theValue){
-  myInfo->myFamNum[theId] = theValue;
-}
-
-med_booleen TElemInfo::IsElemNum() const{
-  return myInfo->myIsElemNum;
-}
-
-med_int TElemInfo::GetElemNum(med_int theId) const{
-  if(theId < 0 || myInfo->myElemNum.size() < theId)
-    EXCEPTION(runtime_error,"TElemInfo::GetElemNum - myInfo->myElemNum.size() = "<<
-             myInfo->myElemNum.size()<<"; theId = "<<theId<<")");
-  return myInfo->myElemNum[theId];
-}
-
-void TElemInfo::SetElemNum(med_int theId, med_int theValue){
-  if(theId < 0 || myInfo->myElemNum.size() < theId)
-    EXCEPTION(runtime_error,"TElemInfo::SetElemNum - myInfo->myElemNum.size() = "<<
-             myInfo->myElemNum.size()<<"; theId = "<<theId<<")");
-  myInfo->myElemNum[theId] = theValue;
-}
-
-med_booleen TElemInfo::IsElemNames() const{
-  return myInfo->myIsElemNames;
-}
-
-string TElemInfo::GetElemName(med_int theId) const{
-  return myInfo->GetElemName(theId);
-}
-
-void TElemInfo::SetElemName(med_int theId, const string& theValue){
-  myInfo->SetElemName(theId,theValue);
-}
-
-
-//---------------------------------------------------------------
-TNodeInfo::TNodeInfo(const MED::PNodeInfo& theInfo): 
-  TElemInfo(theInfo),
-  myInfo(theInfo) 
-{}
-
-med_repere TNodeInfo::GetSystem() const{
-  return myInfo->mySystem;
-}
-
-void TNodeInfo::GetSystem(med_repere theSystem){
-  myInfo->mySystem = theSystem;
-}
-
-med_float TNodeInfo::GetNodeCoord(med_int theId, med_int theComp) const{
-  return myInfo->myCoord[myInfo->myMeshInfo->myDim*theId + theComp];
-}
-
-void TNodeInfo::SetNodeCoord(med_int theId, med_int theComp, med_float theVal){
-  myInfo->myCoord[myInfo->myMeshInfo->myDim*theId + theComp] = theVal;
-}
-
-string TNodeInfo::GetCoordName(med_int theId) const{
-  return myInfo->GetCoordName(theId);
-}
-
-void TNodeInfo::SetCoordName(med_int theId, const string& theValue){
-  myInfo->SetCoordName(theId,theValue);
-}
-
-string TNodeInfo::GetCoordUnit(med_int theId) const{
-  return myInfo->GetCoordUnit(theId);
-}
-
-void TNodeInfo::SetCoordUnit(med_int theId, const string& theValue){
-  myInfo->SetCoordUnit(theId,theValue);
-}
-
-
-//---------------------------------------------------------------
-TCellInfo::TCellInfo(const MED::PCellInfo& theInfo): 
-  TElemInfo(theInfo),
-  myInfo(theInfo) 
-{}
-
-med_entite_maillage TCellInfo::GetEntity() const{
-  return myInfo->myTEntity;
-}
-
-med_geometrie_element TCellInfo::GetGeom() const{
-  return myInfo->myTGeom;
-}
-
-med_connectivite TCellInfo::GetConn() const{
-  return myInfo->myTConn;
-}
-
-med_int TCellInfo::GetConnDim() const{
-  return myInfo->myConnDim;
-}
-
-med_int TCellInfo::GetConn(med_int theElemId, med_int theConnId) const{
-  med_int anId = myInfo->myConnDim*theElemId + theConnId;
-  if(anId < 0 || myInfo->myConn.size() < anId)
-    EXCEPTION(runtime_error,"TElemInfo::GetConn - myInfo->myConn.size() = "<<
-             myInfo->myConn.size()<<"; anId = "<<anId<<")");
-  return myInfo->myConn[anId];
-}
-void TCellInfo::SetConn(med_int theElemId, med_int theConnId, med_int theVal){
-  med_int anId = myInfo->myConnDim*theElemId + theConnId;
-  if(anId < 0 || myInfo->myConn.size() < anId)
-    EXCEPTION(runtime_error,"TElemInfo::SetConn - myInfo->myConn.size() = "<<
-             myInfo->myConn.size()<<"; anId = "<<anId<<")");
-  myInfo->myConn[myInfo->myConnDim*theElemId + theConnId] = theVal;
-}
-
-
-//---------------------------------------------------------------
-TFieldInfo::TFieldInfo(const MED::PFieldInfo& theInfo): 
-  TNameInfo(theInfo),
-  myInfo(theInfo) 
-{}
-
-med_type_champ TFieldInfo::GetType() const{
-  return myInfo->myType;
-}
-
-med_int TFieldInfo::GetNbComp() const{
-  return myInfo->myNbComp;
-}
-
-string TFieldInfo::GetCompName(med_int theId) const{
-  return myInfo->GetCompName(theId);
-}
-
-void TFieldInfo::SetCompName(med_int theId, const string& theValue){
-  myInfo->SetCompName(theId,theValue);
-}
-
-string TFieldInfo::GetUnitName(med_int theId) const{
-  return myInfo->GetUnitName(theId);
-}
-
-void TFieldInfo::SetUnitName(med_int theId, const string& theValue){
-  myInfo->SetUnitName(theId,theValue);
-}
-
-
-//---------------------------------------------------------------
-TTimeStampInfo::TTimeStampInfo(const MED::PTimeStampInfo& theInfo): 
-  myInfo(theInfo) 
-{}
-
-med_entite_maillage TTimeStampInfo::GetEntity() const{
-  return myInfo->myEntity;
-}
-
-const MED::TGeom& TTimeStampInfo::GetGeom() const{
-  return myInfo->myGeom;
-}
-
-med_int TTimeStampInfo::GetNbGauss() const{
-  return myInfo->myNbGauss;
-}
-
-med_int TTimeStampInfo::GetNumDt() const{
-  return myInfo->myNumDt;
-}
-
-med_int TTimeStampInfo::GetNumOrd() const{
-  return myInfo->myNumOrd;
-}
-
-med_float TTimeStampInfo::GetDt() const{
-  return myInfo->myDt;
-}
-
-string TTimeStampInfo::GetUnitDt() const{
-  return myInfo->GetUnitDt();
-}
-
-void TTimeStampInfo::SetUnitDt(const string& theValue){
-  myInfo->SetUnitDt(theValue);
-}
-
-
-//---------------------------------------------------------------
-TTimeStampVal::TTimeStampVal(const MED::PTimeStampVal& theInfo): 
-  myInfo(theInfo) 
-{}
-
-med_float TTimeStampVal::GetVal(med_geometrie_element theGeom, 
-                               med_int theId, 
-                               med_int theComp, 
-                               med_int theGauss) const
-{
-  med_int aNbComp = myInfo->myTimeStampInfo->myFieldInfo->myNbComp;
-  med_int aNbGauss = myInfo->myTimeStampInfo->myNbGauss;
-  med_int aStep = aNbComp*aNbGauss;
-  return myInfo->myMeshValue[theGeom][theId*aStep + theComp*aNbGauss + theGauss];
-}
-
-void TTimeStampVal::SetVal(med_geometrie_element theGeom,
-                          med_int theId, 
-                          med_int theComp, 
-                          med_float theVal, 
-                          med_int theGauss)
-{
-  med_int aNbComp = myInfo->myTimeStampInfo->myFieldInfo->myNbComp;
-  med_int aNbGauss = myInfo->myTimeStampInfo->myNbGauss;
-  med_int aStep = aNbComp*aNbGauss;
-  myInfo->myMeshValue[theGeom][theId*aStep + theComp*aNbGauss + theGauss] = theVal;
-}
-
-string TTimeStampVal::GetPflName() const{
-  return myInfo->GetPflName();
-}
-
-void TTimeStampVal::SetPflName(const string& theValue){
-  myInfo->SetPflName(theValue);
-}
-
diff --git a/src/MEDWrapper/MEDA_Structures.hxx b/src/MEDWrapper/MEDA_Structures.hxx
deleted file mode 100644 (file)
index 674600a..0000000
+++ /dev/null
@@ -1,205 +0,0 @@
-//  Copyright (C) 2003  CEA/DEN, EDF R&D
-//
-//
-//
-//  File   : VISU_DatConvertor.hxx
-//  Author : Alexey PETROV
-//  Module : VISU
-
-#ifndef MEDA_Structures_HeaderFile
-#define MEDA_Structures_HeaderFile
-
-#include "MED_Common.hxx"
-
-namespace MEDA{
-  using namespace std;
-  using namespace boost;
-
-//---------------------------------------------------------------
-  class TNameInfo{
-    friend class TWrapper;
-    TNameInfo();
-  protected:
-    MED::PNameInfo myInfo;
-    TNameInfo(const MED::PNameInfo& theInfo);
-  public:
-    virtual ~TNameInfo() {} 
-
-    string GetName() const;
-    void SetName(const string& theValue);
-  };
-
-
-//---------------------------------------------------------------
-  class TMeshInfo: public TNameInfo{
-    friend class TWrapper;
-    TMeshInfo();
-  protected:
-    MED::PMeshInfo myInfo;
-    TMeshInfo(const MED::PMeshInfo& theInfo);
-
-  public:
-    med_int GetDim() const;
-  };
-  typedef shared_ptr<TMeshInfo> PMeshInfo;
-
-
-//---------------------------------------------------------------
-  class TFamilyInfo: public TNameInfo{
-    friend class TWrapper;
-    TFamilyInfo();
-  protected:
-    MED::PFamilyInfo myInfo;
-    TFamilyInfo(const MED::PFamilyInfo& theInfo);
-  public:
-    med_int GetId() const;
-    void SetId(med_int theId);
-
-    med_int GetNbGroup() const;
-    string GetGroupName(med_int theId) const;
-    void SetGroupName(med_int theId, const string& theValue);
-
-    med_int GetNbAttr() const;
-    string GetAttrDesc(med_int theId) const;
-    void SetAttrDesc(med_int theId, const string& theValue);
-    
-    med_int GetAttrId(med_int theId) const;
-    void SetAttrId(med_int theId, med_int theVal);
-
-    med_int GetAttrVal(med_int theId) const;
-    void SetAttrVal(med_int theId, med_int theVal);
-  };
-  typedef shared_ptr<TFamilyInfo> PFamilyInfo;
-
-
-//---------------------------------------------------------------
-  class TElemInfo{
-    friend class TWrapper;
-    TElemInfo();
-  protected:
-    MED::PElemInfo myInfo;
-    TElemInfo(const MED::PElemInfo& theInfo);
-  public:
-    virtual ~TElemInfo() {} 
-
-    med_int GetNbElem() const;
-
-    med_int GetFamNum(med_int theId) const;
-    void SetFamNum(med_int theId, med_int theValue);
-
-    med_booleen IsElemNum() const;
-    med_int GetElemNum(med_int theId) const;
-    void SetElemNum(med_int theId, med_int theValue);
-
-    med_booleen IsElemNames() const;
-    string GetElemName(med_int theId) const;
-    void SetElemName(med_int theId, const string& theValue);
-  };
-
-
-//---------------------------------------------------------------
-  class TNodeInfo: public TElemInfo{
-    friend class TWrapper;
-    TNodeInfo();
-  protected:
-    MED::PNodeInfo myInfo;
-    TNodeInfo(const MED::PNodeInfo& theInfo);
-  public:
-    med_repere GetSystem() const;
-    void GetSystem(med_repere theSystem);
-    
-    med_float GetNodeCoord(med_int theId, med_int theComp) const;
-    void SetNodeCoord(med_int theId, med_int theComp, med_float theVal);
-
-    string GetCoordName(med_int theId) const;
-    void SetCoordName(med_int theId, const string& theValue);
-
-    string GetCoordUnit(med_int theId) const;
-    void SetCoordUnit(med_int theId, const string& theValue);
-  };
-  typedef shared_ptr<TNodeInfo> PNodeInfo;
-
-
-//---------------------------------------------------------------
-  class TCellInfo: public TElemInfo{
-    friend class TWrapper;
-    TCellInfo();
-  protected:
-    MED::PCellInfo myInfo;
-    TCellInfo(const MED::PCellInfo& theInfo);
-  public:
-    med_entite_maillage GetEntity() const;
-    med_geometrie_element GetGeom() const;
-    med_connectivite GetConn() const;
-    
-    med_int GetConnDim() const;
-    med_int GetConn(med_int theElemId, med_int theConnId) const;
-    void SetConn(med_int theElemId, med_int theConnId, med_int theVal);
-  };
-  typedef shared_ptr<TCellInfo> PCellInfo;
-
-
-//---------------------------------------------------------------
-  class TFieldInfo: public TNameInfo{
-    friend class TWrapper;
-    TFieldInfo();
-  protected:
-    MED::PFieldInfo myInfo;
-    TFieldInfo(const MED::PFieldInfo& theInfo);
-  public:
-    med_type_champ GetType() const;
-    med_int GetNbComp() const;
-
-    string GetCompName(med_int theId) const;
-    void SetCompName(med_int theId, const string& theValue);
-
-    string GetUnitName(med_int theId) const;
-    void SetUnitName(med_int theId, const string& theValue);
-  };
-  typedef shared_ptr<TFieldInfo> PFieldInfo;
-
-
-//---------------------------------------------------------------
-  class TTimeStampInfo{
-    friend class TWrapper;
-    TTimeStampInfo();
-  protected:
-    MED::PTimeStampInfo myInfo;
-    TTimeStampInfo(const MED::PTimeStampInfo& theInfo);
-  public:
-    med_entite_maillage GetEntity() const;
-    const MED::TGeom& GetGeom() const;
-
-    med_int GetNbGauss() const;
-    med_int GetNumDt() const;
-    med_int GetNumOrd() const;
-
-    med_float GetDt() const;
-
-    string GetUnitDt() const;
-    void SetUnitDt(const string& theValue);
-  };
-  typedef shared_ptr<TTimeStampInfo> PTimeStampInfo;
-  
-
-//---------------------------------------------------------------
-  class TTimeStampVal{
-    friend class TWrapper;
-    TTimeStampVal();
-  protected:
-    MED::PTimeStampVal myInfo;
-    TTimeStampVal(const MED::PTimeStampVal& theInfo);
-  public:
-    med_float GetVal(med_geometrie_element theGeom, med_int theId, 
-                    med_int theComp, med_int theGauss = 0) const;
-    void SetVal(med_geometrie_element theGeom, med_int theId, 
-               med_int theComp, med_float theVal, med_int theGauss = 0);
-    
-    string GetPflName() const;
-    void SetPflName(const string& theValue);
-  };
-  typedef shared_ptr<TTimeStampVal> PTimeStampVal;
-  
-};
-
-#endif
diff --git a/src/MEDWrapper/MEDA_Test.cxx b/src/MEDWrapper/MEDA_Test.cxx
deleted file mode 100644 (file)
index 396dd1d..0000000
+++ /dev/null
@@ -1,182 +0,0 @@
-//  VISU OBJECT : interactive object for VISU entities implementation
-//
-//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
-// 
-//  This library is free software; you can redistribute it and/or 
-//  modify it under the terms of the GNU Lesser General Public 
-//  License as published by the Free Software Foundation; either 
-//  version 2.1 of the License. 
-// 
-//  This library is distributed in the hope that it will be useful, 
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
-//  Lesser General Public License for more details. 
-// 
-//  You should have received a copy of the GNU Lesser General Public 
-//  License along with this library; if not, write to the Free Software 
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
-// 
-//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
-//
-//
-//  File:    VISUConvertor.cxx
-//  Author:  Alexey PETROV
-//  Module : VISU
-
-#include "MEDA_Structures.hxx"
-#include "MEDA_Wrapper.hxx"
-#include "MED_Utilities.hxx"
-
-using namespace std;
-
-#ifdef DEBUG
-static int MYDEBUG = 1;
-#else
-static int MYDEBUG = 0;
-#endif
-
-
-void ReadMed(const char* theFileName){
-  using namespace MEDA;
-  TWrapper aMed(theFileName);
-  string aFileName = theFileName;
-  aFileName += "+";
-  TWrapper aMedW(aFileName);
-
-  int aNbMeshes = aMed.GetNbMeshes();
-  cout<<"GetNbMeshes() = "<<aNbMeshes<<endl;
-
-  string aName;
-  for(int iMesh = 0; iMesh < aNbMeshes; iMesh++){
-    PMeshInfo aMeshInfo = aMed.GetMeshInfo(iMesh);
-    int aDim = aMeshInfo->GetDim();
-    PMeshInfo aMeshInfoW = TWrapper::CrMeshInfo(aMeshInfo);
-    aName = aMeshInfoW->GetName();
-    cout<<"GetMeshInfo - aName = '"<<aName<<"'; aDim = "<<aDim<<endl;
-    aName[0] += 1;
-    aMeshInfoW->SetName(aName);
-    aMedW.SetMeshInfo(aMeshInfoW);
-  
-    int aNbFam = aMed.GetNbFamilies(aMeshInfo);
-    cout<<"GetNbFamilies() = "<<aNbFam<<endl;
-    for(int iFam = 0; iFam < aNbFam; iFam++){
-      PFamilyInfo aFamilyInfo = aMed.GetFamilyInfo(aMeshInfo,iFam);
-      PFamilyInfo aFamilyInfoW = TWrapper::CrFamilyInfo(aMeshInfoW,aFamilyInfo);
-      aName = aFamilyInfo->GetName();
-      int aNbAttr = aFamilyInfo->GetNbAttr();
-      int aNbGroup = aFamilyInfo->GetNbGroup();
-      cout<<"\taName = '"<<aName<<"'; aNbAttr = "<<aNbAttr<<"; aNbGroup = "<<aNbGroup<<endl;
-      aName[0] += 1;
-      aFamilyInfoW->SetName(aName);
-      for(int iGroup = 0; iGroup < aNbGroup; iGroup++){
-       aName = aFamilyInfo->GetGroupName(iGroup);
-       cout<<"\t\taGroupName = '"<<aName<<"'\n";
-       aName[0] += 1;
-       aFamilyInfoW->SetGroupName(iGroup,aName);
-      }
-      aMedW.SetFamilyInfo(aFamilyInfoW);
-    }
-
-    MED::TEntityInfo aEntityInfo = aMed.GetEntityInfo(aMeshInfo);
-    cout<<"GetEntityInfo - aNbEntities = "<<aEntityInfo.size()<<endl;
-    MED::TEntityInfo::iterator anEntityIter = aEntityInfo.begin();
-    for(; anEntityIter != aEntityInfo.end(); anEntityIter++){
-      const med_entite_maillage& anEntity = anEntityIter->first;
-      cout<<"\tanEntity = "<<anEntity<<endl;
-      if(anEntity == MED_NOEUD){
-       PNodeInfo aNodeInfo = aMed.GetNodeInfo(aMeshInfo);
-       PNodeInfo aNodeInfoW = TWrapper::CrNodeInfo(aMeshInfoW,aNodeInfo);
-       int aNbNodes = aNodeInfo->GetNbElem();
-       cout<<"\tGetNodeInfo - aNbNodes = "<<aNbNodes<<": ";
-       for(int iNode = 0; iNode < aNbNodes; iNode++){
-         for(int iDim = 0; iDim < aDim; iDim++){
-           //cout<<aNodeInfo->GetNodeCoord(iNode,iDim)<<",";
-         }
-         cout<<" ";
-       }
-       cout<<endl;
-       aMedW.SetNodeInfo(aNodeInfoW);
-       continue;
-      }
-      const MED::TGeom& aTGeom = anEntityIter->second;
-      MED::TGeom::const_iterator anTGeomIter = aTGeom.begin();
-      for(; anTGeomIter != aTGeom.end(); anTGeomIter++){
-       const med_geometrie_element& aGeom = anTGeomIter->first;
-       PCellInfo aCellInfo = aMed.GetCellInfo(aMeshInfo,anEntity,aGeom);
-       PCellInfo aCellInfoW = TWrapper::CrCellInfo(aMeshInfoW,aCellInfo);
-       med_int aNbElem = aCellInfo->GetNbElem();
-       cout<<"\t\taGeom = "<<aGeom<<"; aNbElem = "<<aNbElem<<": ";
-       for(int iElem = 0; iElem < aNbElem; iElem++){
-         int iConnEnd = aCellInfo->GetConnDim();
-         for(int iConn = 0; iConn < iConnEnd; iConn++){
-           //cout<<aCellInfo->GetConn(iElem,iConn)<<",";
-         }
-         cout<<" ";
-       }
-       cout<<endl;
-       aMedW.SetCellInfo(aCellInfoW);
-      }
-    }
-
-    med_int aNbFields = aMed.GetNbFields(); 
-    cout<<"GetNbFields() = "<<aNbFields<<endl;
-    for(int iField = 0; iField < aNbFields; iField++){
-      PFieldInfo aFieldInfo = aMed.GetFieldInfo(aMeshInfo,iField);
-      PFieldInfo aFieldInfoW = TWrapper::CrFieldInfo(aMeshInfoW,aFieldInfo);
-      med_int aNbComp = aFieldInfo->GetNbComp();
-      aName = aFieldInfo->GetName();
-      cout<<"\taName = '"<<aName<<"'; aNbComp = "<<aNbComp<<"; ";
-      aName[0] += 1;
-      aFieldInfoW->SetName(aName);
-      aMedW.SetFieldInfo(aFieldInfoW);
-      MED::TGeom aTGeom;
-      med_entite_maillage anEntity;
-      med_int aNbTimeStamps = aMed.GetNbTimeStamps(aFieldInfo,aEntityInfo,anEntity,aTGeom);
-      cout<<"anEntity = "<<anEntity<<"; GetNbTimeStamps = "<<aNbTimeStamps<<endl;
-      for(int iTimeStamp = 0; iTimeStamp < aNbTimeStamps; iTimeStamp++){
-       PTimeStampInfo aTimeStamp = aMed.GetTimeStampInfo(aFieldInfo,iTimeStamp,
-                                                         anEntity,aTGeom);
-       PTimeStampInfo aTimeStampW = TWrapper::CrTimeStampInfo(aFieldInfoW,aTimeStamp);
-       med_int aNbGauss = aTimeStamp->GetNbGauss();
-       cout<<"\t\taDt = "<<aTimeStamp->GetDt()<<", "<<aTimeStamp->GetUnitDt()<<endl;
-       PTimeStampVal aTimeStampVal = aMed.GetTimeStampVal(aTimeStamp);
-       PTimeStampVal aTimeStampValW = TWrapper::CrTimeStampVal(aTimeStampW,aTimeStampVal);
-       MED::TGeom::const_iterator anTGeomIter = aTGeom.begin();
-       for(; anTGeomIter != aTGeom.end(); anTGeomIter++){
-         const med_geometrie_element& aGeom = anTGeomIter->first;
-         med_int aNbElem = anTGeomIter->second;
-         cout<<"\t\taGeom = "<<aGeom<<"; aNbElem = "<<aNbElem<<": ";
-         for(int iElem = 0; iElem < aNbElem; iElem++){
-           for(int j = 0; j < aNbComp; j++){
-             for(int k = 0; k < aNbGauss; k++){
-               //cout<<aTimeStampValW->GetVal(aGeom,iElem,j,k)<<",";
-             }
-           }
-           cout<<" ";
-         }
-         cout<<"\n";
-       }
-       aMedW.SetTimeStamp(aTimeStampValW);
-      }
-    }    
-  }
-  cout<<"OK"<<endl;
-}
-
-
-int main(int argc, char** argv){ 
-    if(argc > 1)
-      ReadMed(argv[1]);
-    return 0;
-  try{
-    if(argc > 1)
-      ReadMed(argv[1]);
-    return 0;
-  }catch(std::exception& exc){
-    cout<<"Follow exception was accured :\n"<<exc.what()<<endl;
-  }catch(...){
-    cout<<"Unknown exception was accured in VISU_Convertor_impl"<<endl;
-  } 
-  return 1;
-}
diff --git a/src/MEDWrapper/MEDA_Test1.cxx b/src/MEDWrapper/MEDA_Test1.cxx
deleted file mode 100644 (file)
index 4b0158c..0000000
+++ /dev/null
@@ -1,92 +0,0 @@
-//  VISU OBJECT : interactive object for VISU entities implementation
-//
-//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
-// 
-//  This library is free software; you can redistribute it and/or 
-//  modify it under the terms of the GNU Lesser General Public 
-//  License as published by the Free Software Foundation; either 
-//  version 2.1 of the License. 
-// 
-//  This library is distributed in the hope that it will be useful, 
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
-//  Lesser General Public License for more details. 
-// 
-//  You should have received a copy of the GNU Lesser General Public 
-//  License along with this library; if not, write to the Free Software 
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
-// 
-//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
-//
-//
-//  File:    VISUConvertor.cxx
-//  Author:  Alexey PETROV
-//  Module : VISU
-
-#include "MEDA_Algorithm.hxx"
-#include "MED_Utilities.hxx"
-
-using namespace std;
-using namespace MEDA;
-
-#ifdef DEBUG
-static int MYDEBUG = 1;
-#else
-static int MYDEBUG = 0;
-#endif
-
-
-namespace MEDA{
-  using namespace std;
-  using namespace boost;
-  
-  
-};
-
-void ReadMed(const char* theFileName){
-  TWrapper aMed(theFileName);
-  string aFileName = theFileName;
-  aFileName += "+";
-  TWrapper aMedW(aFileName);
-
-  int aNbMeshes = aMed.GetNbMeshes();
-  cout<<"GetNbMeshes() = "<<aNbMeshes<<endl;
-
-  string aName;
-  for(int iMesh = 0; iMesh < aNbMeshes; iMesh++){
-    PMeshInfo aMeshInfo = aMed.GetMeshInfo(iMesh);
-  
-    PNodeInfo aNodeInfo = aMed.GetNodeInfo(aMeshInfo);
-
-    MED::TEntityInfo aEntityInfo = aMed.GetEntityInfo(aMeshInfo);
-
-    TCellGroup aCellGroup = GetCellsByEntity(aMed,aMeshInfo,aEntityInfo);
-
-    TFamilyGroup aFamilyGroup = GetFamilies(aMed,aMeshInfo);
-
-    TFamilyByEntity aFamilyByEntity = GetFamiliesByEntity(aMed,aNodeInfo,aCellGroup,aFamilyGroup);
-
-    TGroupInfo aGroupInfo = GetFamiliesByGroup(aFamilyGroup);
-
-    TTimeStampGroup aTimeStampGroup = GetFieldsByEntity(aMed,aMeshInfo,aEntityInfo);
-
-    TFieldGroup aFieldGroup = GetFieldsByEntity(aTimeStampGroup);
-
-  }
-  cout<<"OK"<<endl;
-}
-
-
-int main(int argc, char** argv){ 
-  try{
-    if(argc > 1)
-      ReadMed(argv[1]);
-    return 0;
-  }catch(std::exception& exc){
-    cout<<"Follow exception was accured :\n"<<exc.what()<<endl;
-  }catch(...){
-    cout<<"Unknown exception was accured in VISU_Convertor_impl"<<endl;
-  } 
-  return 1;
-}
diff --git a/src/MEDWrapper/MEDA_Wrapper.cxx b/src/MEDWrapper/MEDA_Wrapper.cxx
deleted file mode 100644 (file)
index f48e7b4..0000000
+++ /dev/null
@@ -1,355 +0,0 @@
-//  Copyright (C) 2003  CEA/DEN, EDF R&D
-//
-//
-//
-//  File   : VISU_DatConvertor.cxx
-//  Author : Alexey PETROV
-//  Module : VISU
-
-#include "MEDA_Wrapper.hxx"
-#include "MED_Wrapper.hxx"
-#include "MED_Utilities.hxx"
-
-using namespace std;
-using namespace MEDA;
-
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-#else
-static int MYDEBUG = 0;
-#endif
-
-
-//---------------------------------------------------------------
-TWrapper::TWrapper(const string& theFileName):
-  myWrapper(new MED::TWrapper(theFileName))
-{}
-
-
-//---------------------------------------------------------------
-PMeshInfo TWrapper::CrMeshInfo(med_int theDim,
-                              const string& theValue)
-{
-  MED::PMeshInfo anInfo(new MED::TMeshInfo(theDim,theValue));
-  return PMeshInfo(new TMeshInfo(anInfo));
-}
-
-PMeshInfo TWrapper::CrMeshInfo(const PMeshInfo& theInfo){
-  MED::PMeshInfo anInfo(new MED::TMeshInfo(*theInfo->myInfo));
-  return PMeshInfo(new TMeshInfo(anInfo));
-}
-
-med_int TWrapper::GetNbMeshes(){
-  return myWrapper->GetNbMeshes();
-}
-
-PMeshInfo TWrapper::GetMeshInfo(med_int theId){
-  PMeshInfo anInfo = CrMeshInfo();
-  myWrapper->GetMeshInfo(theId+1,*anInfo->myInfo);
-  if(MYDEBUG){
-    MESSAGE("GetMeshInfo(...)");
-    MED::PrefixPrinter aPrefixPrinter;
-    BEGMSG("aName = '"<<anInfo->GetName()<<"'; aDim = "<<anInfo->GetDim()<<"\n");
-    ADDMSG("\n");
-  }
-  return anInfo;
-}
-
-void TWrapper::SetMeshInfo(const PMeshInfo& theInfo){
-  myWrapper->SetMeshInfo(*theInfo->myInfo);
-}
-
-
-//---------------------------------------------------------------
-PFamilyInfo TWrapper::CrFamilyInfo(const PMeshInfo& theMeshInfo, 
-                                  med_int theNbGroup,
-                                  med_int theNbAttr,
-                                  med_int theId,
-                                  const string& theValue)
-{
-  const MED::PMeshInfo& aMeshInfo = theMeshInfo->myInfo;
-  MED::PFamilyInfo anInfo(new MED::TFamilyInfo(aMeshInfo,
-                                              theNbGroup,
-                                              theNbAttr,
-                                              theId,
-                                              theValue));
-  return PFamilyInfo(new TFamilyInfo(anInfo));
-}
-
-PFamilyInfo TWrapper::CrFamilyInfo(const PMeshInfo& theMeshInfo,
-                                  const string& theValue,
-                                  med_int theId,
-                                  const MED::TStringSet& theGroupNames, 
-                                  const MED::TStringVector& theAttrDescs, 
-                                  const MED::TIntVector& theAttrIds, 
-                                  const MED::TIntVector& theAttrVals)
-{
-  const MED::PMeshInfo& aMeshInfo = theMeshInfo->myInfo;
-  MED::PFamilyInfo anInfo(new MED::TFamilyInfo(aMeshInfo,
-                                              theValue,
-                                              theId,
-                                              theGroupNames,
-                                              theAttrDescs,
-                                              theAttrIds,
-                                              theAttrVals));
-  return PFamilyInfo(new TFamilyInfo(anInfo));
-}
-
-PFamilyInfo TWrapper::CrFamilyInfo(const PMeshInfo& theMeshInfo,
-                                  const PFamilyInfo& theInfo)
-{
-  MED::PFamilyInfo anInfo(new MED::TFamilyInfo(*theInfo->myInfo));
-  anInfo->myMeshInfo = theMeshInfo->myInfo;
-  return PFamilyInfo(new TFamilyInfo(anInfo));
-}
-
-med_int TWrapper::GetNbFamilies(const PMeshInfo& theMeshInfo){
-  return myWrapper->GetNbFamilies(*theMeshInfo->myInfo);
-}
-
-PFamilyInfo TWrapper::GetFamilyInfo(const PMeshInfo& theMeshInfo, med_int theId){
-  med_int aNbAttr = myWrapper->GetNbFamAttr(theId+1,*theMeshInfo->myInfo);
-  med_int aNbGroup = myWrapper->GetNbFamGroup(theId+1,*theMeshInfo->myInfo);
-  PFamilyInfo anInfo = CrFamilyInfo(theMeshInfo,aNbGroup,aNbAttr);
-  myWrapper->GetFamilyInfo(theId+1,*anInfo->myInfo);
-  if(MYDEBUG){
-    MESSAGE("GetFamilyInfo(...)");
-    MED::PrefixPrinter aPrefixPrinter;
-    BEGMSG("aName = '"<<anInfo->GetName()<<"'; anId = "<<anInfo->GetId()<<"\n");
-    ADDMSG("\n");
-  }
-  return anInfo;
-}
-
-void TWrapper::SetFamilyInfo(const PFamilyInfo& theInfo){
-  myWrapper->SetFamilyInfo(*theInfo->myInfo);
-}
-
-
-//---------------------------------------------------------------
-PNodeInfo TWrapper::CrNodeInfo(const PMeshInfo& theMeshInfo, 
-                              med_int theNbElem,
-                              med_repere theSystem, 
-                              med_booleen theIsElemNum,
-                              med_booleen theIsElemNames)
-{
-  const MED::PMeshInfo& aMeshInfo = theMeshInfo->myInfo;
-  MED::PNodeInfo anInfo(new MED::TNodeInfo(aMeshInfo,
-                                          theNbElem,
-                                          theSystem,
-                                          theIsElemNum,
-                                          theIsElemNames));
-  return PNodeInfo(new TNodeInfo(anInfo));
-}
-
-PNodeInfo TWrapper::CrNodeInfo(const PMeshInfo& theMeshInfo, 
-                              med_repere theSystem, 
-                              const MED::TFloatVector& theNodeCoords,
-                              const MED::TStringVector& theCoordNames,
-                              const MED::TStringVector& theCoordUnits,
-                              const MED::TIntVector& theFamilyNums,
-                              const MED::TIntVector& theElemNums,
-                              const MED::TStringVector& theElemNames)
-{
-  const MED::PMeshInfo& aMeshInfo = theMeshInfo->myInfo;
-  MED::PNodeInfo anInfo(new MED::TNodeInfo(aMeshInfo,
-                                          theSystem,
-                                          theNodeCoords,
-                                          theCoordNames,
-                                          theCoordUnits,
-                                          theFamilyNums,
-                                          theElemNums,
-                                          theElemNames));
-  return PNodeInfo(new TNodeInfo(anInfo));
-}
-
-PNodeInfo TWrapper::CrNodeInfo(const PMeshInfo& theMeshInfo,
-                              const PNodeInfo& theInfo)
-{
-  MED::PNodeInfo anInfo(new MED::TNodeInfo(*theInfo->myInfo));
-  anInfo->myMeshInfo = theMeshInfo->myInfo;
-  return PNodeInfo(new TNodeInfo(anInfo));
-}
-
-PNodeInfo TWrapper::GetNodeInfo(const PMeshInfo& theMeshInfo){
-  med_int aNbElems = myWrapper->GetNbNodes(*theMeshInfo->myInfo);
-  PNodeInfo anInfo = CrNodeInfo(theMeshInfo,aNbElems);
-  myWrapper->GetNodeInfo(*anInfo->myInfo);
-  return anInfo;
-}
-
-void TWrapper::SetNodeInfo(const PNodeInfo& theInfo){
-  myWrapper->SetNodeInfo(*theInfo->myInfo);
-}
-
-
-//---------------------------------------------------------------
-MED::TEntityInfo TWrapper::GetEntityInfo(const PMeshInfo& theMeshInfo){
-  return myWrapper->GetEntityInfo(*theMeshInfo->myInfo);
-}
-
-PCellInfo TWrapper::CrCellInfo(const PMeshInfo& theMeshInfo, 
-                              med_int theNbElem,
-                              med_entite_maillage theEntity, 
-                              med_geometrie_element theGeom,
-                              med_connectivite theConn,
-                              med_booleen theIsElemNum,
-                              med_booleen theIsElemNames)
-{
-  MED::PCellInfo anInfo(new MED::TCellInfo(theMeshInfo->myInfo,
-                                          theNbElem,
-                                          theEntity,
-                                          theGeom,
-                                          theConn,
-                                          theIsElemNum,
-                                          theIsElemNames));
-  return PCellInfo(new TCellInfo(anInfo));
-}
-
-PCellInfo TWrapper::CrCellInfo(const PMeshInfo& theMeshInfo, 
-                              med_entite_maillage theEntity, 
-                              med_geometrie_element theGeom,
-                              med_connectivite theConn,
-                              const MED::TIntVector& theConnectivities,
-                              const MED::TIntVector& theFamilyNums,
-                              const MED::TIntVector& theElemNums,
-                              const MED::TStringVector& theElemNames)
-{
-  MED::PCellInfo anInfo(new MED::TCellInfo(theMeshInfo->myInfo,
-                                          theEntity,
-                                          theGeom,
-                                          theConn,
-                                          theConnectivities,
-                                          theFamilyNums,
-                                          theElemNums,
-                                          theElemNames));
-  return PCellInfo(new TCellInfo(anInfo));
-}
-
-PCellInfo TWrapper::CrCellInfo(const PMeshInfo& theMeshInfo,
-                              const PCellInfo& theInfo)
-{
-  MED::PCellInfo anInfo(new MED::TCellInfo(*theInfo->myInfo));
-  anInfo->myMeshInfo = theMeshInfo->myInfo;
-  return PCellInfo(new TCellInfo(anInfo));
-}
-
-PCellInfo TWrapper::GetCellInfo(const PMeshInfo& theMeshInfo, 
-                               med_entite_maillage theEntity, 
-                               med_geometrie_element theGeom, 
-                               med_connectivite theConn)
-{
-  med_int aNbElem = myWrapper->GetNbCells(*theMeshInfo->myInfo,theEntity,theGeom,theConn);
-  PCellInfo anInfo = CrCellInfo(theMeshInfo,aNbElem,theEntity,theGeom,theConn);
-  myWrapper->GetCellInfo(*anInfo->myInfo);
-  return anInfo;
-}
-
-void TWrapper::SetCellInfo(const PCellInfo& theInfo){
-  myWrapper->SetCellInfo(*theInfo->myInfo);
-}
-
-
-//---------------------------------------------------------------
-PFieldInfo TWrapper::CrFieldInfo(const PMeshInfo& theMeshInfo, 
-                                med_int theNbComp,
-                                med_type_champ theType,
-                                const string& theValue)
-{
-  MED::PFieldInfo anInfo(new MED::TFieldInfo(theMeshInfo->myInfo,
-                                            theNbComp,
-                                            theType,
-                                            theValue));
-  return PFieldInfo(new TFieldInfo(anInfo));
-}
-
-PFieldInfo TWrapper::CrFieldInfo(const PMeshInfo& theMeshInfo,
-                                const PFieldInfo& theInfo)
-{
-  MED::PFieldInfo anInfo(new MED::TFieldInfo(*theInfo->myInfo));
-  anInfo->myMeshInfo = theMeshInfo->myInfo;
-  return PFieldInfo(new TFieldInfo(anInfo));
-}
-
-med_int TWrapper::GetNbFields(){
-  return myWrapper->GetNbFields();
-}
-
-PFieldInfo TWrapper::GetFieldInfo(const PMeshInfo& theMeshInfo, med_int theId){
-  med_int aNbComp = myWrapper->GetNbComp(theId+1);
-  PFieldInfo anInfo = CrFieldInfo(theMeshInfo,aNbComp);
-  myWrapper->GetFieldInfo(theId+1,*anInfo->myInfo);
-  return anInfo;
-}
-
-void TWrapper::SetFieldInfo(const PFieldInfo& theInfo){
-  myWrapper->SetFieldInfo(*theInfo->myInfo);
-}
-
-
-//---------------------------------------------------------------
-PTimeStampInfo TWrapper::CrTimeStampInfo(const PFieldInfo& theFieldInfo, 
-                                        med_entite_maillage theEntity,
-                                        const MED::TGeom& theGeom)
-{
-  MED::PTimeStampInfo anInfo(new MED::TTimeStampInfo(theFieldInfo->myInfo,
-                                                    theEntity,
-                                                    theGeom));
-  return PTimeStampInfo(new TTimeStampInfo(anInfo));
-}
-
-PTimeStampInfo TWrapper::CrTimeStampInfo(const PFieldInfo& theFieldInfo,
-                                        const PTimeStampInfo& theInfo)
-{
-  MED::PTimeStampInfo anInfo(new MED::TTimeStampInfo(*theInfo->myInfo));
-  anInfo->myFieldInfo = theFieldInfo->myInfo;
-  return PTimeStampInfo(new TTimeStampInfo(anInfo));
-}
-
-med_int TWrapper::GetNbTimeStamps(const PFieldInfo& theFieldInfo, 
-                                 const MED::TEntityInfo& theEntityInfo,
-                                 med_entite_maillage& theEntity,
-                                 MED::TGeom& theGeom)
-{
-  return myWrapper->GetNbTimeStamps(*theFieldInfo->myInfo,
-                                   theEntityInfo,
-                                   theEntity,
-                                   theGeom);
-}
-
-PTimeStampInfo TWrapper::GetTimeStampInfo(const PFieldInfo& theFieldInfo,
-                                         med_int theId,
-                                         med_entite_maillage theEntity,
-                                         const MED::TGeom& theGeom)
-{
-  PTimeStampInfo anInfo = CrTimeStampInfo(theFieldInfo,theEntity,theGeom);
-  myWrapper->GetTimeStampInfo(theId+1,*anInfo->myInfo);
-  return anInfo;
-}
-
-
-//---------------------------------------------------------------
-PTimeStampVal TWrapper::CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo)
-{
-  MED::PTimeStampVal anInfo(new MED::TTimeStampVal(theTimeStampInfo->myInfo));
-  return PTimeStampVal(new TTimeStampVal(anInfo));
-}
-
-PTimeStampVal TWrapper::CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
-                                      const PTimeStampVal& theInfo)
-{
-  MED::PTimeStampVal anInfo(new MED::TTimeStampVal(*theInfo->myInfo));
-  anInfo->myTimeStampInfo = theTimeStampInfo->myInfo;
-  return PTimeStampVal(new TTimeStampVal(anInfo));
-}
-
-PTimeStampVal TWrapper::GetTimeStampVal(const PTimeStampInfo& theTimeStampInfo)
-{
-  PTimeStampVal anInfo = CrTimeStampVal(theTimeStampInfo);
-  myWrapper->GetTimeStampVal(*anInfo->myInfo);
-  return anInfo;
-}
-
-void TWrapper::SetTimeStamp(const PTimeStampVal& theTimeStampVal){
-  myWrapper->SetTimeStamp(*theTimeStampVal->myInfo);
-}
diff --git a/src/MEDWrapper/MEDA_Wrapper.hxx b/src/MEDWrapper/MEDA_Wrapper.hxx
deleted file mode 100644 (file)
index e135e21..0000000
+++ /dev/null
@@ -1,161 +0,0 @@
-//  Copyright (C) 2003  CEA/DEN, EDF R&D
-//
-//
-//
-//  File   : VISU_DatConvertor.hxx
-//  Author : Alexey PETROV
-//  Module : VISU
-
-#ifndef MEDA_Wrapper_HeaderFile
-#define MEDA_Wrapper_HeaderFile
-
-#include "MEDA_Structures.hxx"
-
-namespace MEDA{
-  class TWrapper{
-    TWrapper();
-    TWrapper(const TWrapper&);
-  protected:
-    MED::PWrapper myWrapper;
-    
-  public:
-    TWrapper(const string& theFileName);
-
-
-    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    static PMeshInfo CrMeshInfo(med_int theDim = 0,
-                               const string& theValue = "");
-
-    static PMeshInfo CrMeshInfo(const PMeshInfo& theMeshInfo);
-
-    med_int GetNbMeshes();
-
-    PMeshInfo GetMeshInfo(med_int theId);
-
-    void SetMeshInfo(const PMeshInfo& theInfo);
-
-    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    static PFamilyInfo CrFamilyInfo(const PMeshInfo& theMeshInfo,
-                                   med_int theNbGroup = 0, 
-                                   med_int theNbAttr = 0,
-                                   med_int theId = 0,
-                                   const string& theValue = "");
-
-    static PFamilyInfo CrFamilyInfo(const PMeshInfo& theMeshInfo,
-                                   const string& theValue,
-                                   med_int theId,
-                                   const MED::TStringSet& theGroupNames, 
-                                   const MED::TStringVector& theAttrDescs = MED::TStringVector(), 
-                                   const MED::TIntVector& theAttrIds = MED::TIntVector(), 
-                                   const MED::TIntVector& theAttrVals = MED::TIntVector());
-
-    static PFamilyInfo CrFamilyInfo(const PMeshInfo& theMeshInfo,
-                                   const PFamilyInfo& theInfo);
-
-    med_int GetNbFamilies(const PMeshInfo& theMeshInfo);
-
-    PFamilyInfo GetFamilyInfo(const PMeshInfo& theMeshInfo, med_int theId);
-
-    void SetFamilyInfo(const PFamilyInfo& theInfo);
-
-    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    static PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo, 
-                               med_int theNbElem,
-                               med_repere theSystem = MED_CART, 
-                               med_booleen theIsElemNum = MED_VRAI,
-                               med_booleen theIsElemNames = MED_VRAI);
-
-    static PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo, 
-                               med_repere theSystem, 
-                               const MED::TFloatVector& theNodeCoords,
-                               const MED::TStringVector& theCoordNames,
-                               const MED::TStringVector& theCoordUnits,
-                               const MED::TIntVector& theFamilyNums,
-                               const MED::TIntVector& theElemNums,
-                               const MED::TStringVector& theElemNames = MED::TStringVector());
-
-    static PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo,
-                               const PNodeInfo& theInfo);
-
-    PNodeInfo GetNodeInfo(const PMeshInfo& theMeshInfo);
-
-    void SetNodeInfo(const PNodeInfo& theInfo);
-
-    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    MED::TEntityInfo GetEntityInfo(const PMeshInfo& theMeshInfo);
-
-    static PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo, 
-                               med_int theNbElem,
-                               med_entite_maillage theEntity, 
-                               med_geometrie_element theGeom,
-                               med_connectivite theConn = MED_NOD,
-                               med_booleen theIsElemNum = MED_VRAI,
-                               med_booleen theIsElemNames = MED_VRAI);
-
-    static PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo, 
-                               med_entite_maillage theEntity, 
-                               med_geometrie_element theGeom,
-                               med_connectivite theConn,
-                               const MED::TIntVector& theConnectivities,
-                               const MED::TIntVector& theFamilyNums,
-                               const MED::TIntVector& theElemNums,
-                               const MED::TStringVector& theElemNames = MED::TStringVector());
-
-    static PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo,
-                               const PCellInfo& theInfo);
-
-    PCellInfo GetCellInfo(const PMeshInfo& theMeshInfo, 
-                         med_entite_maillage theEntity, 
-                         med_geometrie_element theGeom, 
-                         med_connectivite theConn = MED_NOD);
-
-    void SetCellInfo(const PCellInfo& theInfo);
-
-    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    static PFieldInfo CrFieldInfo(const PMeshInfo& theMeshInfo, 
-                                 med_int theNbComp = 0,
-                                 med_type_champ theType = MED_REEL64,
-                                 const string& theValue = "");
-
-    static PFieldInfo CrFieldInfo(const PMeshInfo& theMeshInfo,
-                                 const PFieldInfo& theInfo);
-    med_int GetNbFields();
-
-    PFieldInfo GetFieldInfo(const PMeshInfo& theMeshInfo, med_int theId);
-
-    void SetFieldInfo(const PFieldInfo& theInfo);
-
-    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    static PTimeStampInfo CrTimeStampInfo(const PFieldInfo& theFieldInfo, 
-                                         med_entite_maillage theEntity,
-                                         const MED::TGeom& theGeom);
-
-    static PTimeStampInfo CrTimeStampInfo(const PFieldInfo& theFieldInfo,
-                                         const PTimeStampInfo& theInfo);
-
-    med_int GetNbTimeStamps(const PFieldInfo& theFieldInfo, 
-                           const MED::TEntityInfo& theEntityInfo,
-                           med_entite_maillage& theEntity,
-                           MED::TGeom& theGeom);
-
-    PTimeStampInfo GetTimeStampInfo(const PFieldInfo& theFieldInfo,
-                                   med_int theId,
-                                   med_entite_maillage theEntity,
-                                   const MED::TGeom& theGeom);
-
-    
-    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    static PTimeStampVal CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo);
-
-    static PTimeStampVal CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
-                                       const PTimeStampVal& theInfo);
-
-    PTimeStampVal GetTimeStampVal(const PTimeStampInfo& theTimeStampInfo);
-
-    void SetTimeStamp(const PTimeStampVal& theTimeStampVal);
-  };
-
-};
-
-
-#endif
diff --git a/src/MEDWrapper/MED_Common.hxx b/src/MEDWrapper/MED_Common.hxx
deleted file mode 100644 (file)
index 0afa3b4..0000000
+++ /dev/null
@@ -1,71 +0,0 @@
-//  Copyright (C) 2003  CEA/DEN, EDF R&D
-//
-//
-//
-//  File   : VISU_DatConvertor.hxx
-//  Author : Alexey PETROV
-//  Module : VISU
-
-#ifndef MED_Common_HeaderFile
-#define MED_Common_HeaderFile
-
-#include <string>
-#include <vector>
-#include <set>
-#include <map>
-
-extern "C"{
-#include <med.h>
-}  
-
-#include <boost/shared_ptr.hpp>
-
-namespace MED{
-  using namespace std;
-  using namespace boost;
-
-  typedef vector<med_float> TFloatVector;
-  typedef vector<string> TStringVector;
-  typedef vector<med_int> TIntVector;
-  typedef set<string> TStringSet;
-
-  typedef map<med_geometrie_element,med_int> TGeom;
-  typedef map<med_entite_maillage,TGeom> TEntityInfo;
-
-  med_int GetNbConn(med_entite_maillage theMedEntity, 
-                   med_geometrie_element theMedType,
-                   med_int theMeshDim);
-
-  struct TNameInfo;
-  typedef shared_ptr<TNameInfo> PNameInfo;
-  
-  struct TMeshInfo;
-  typedef shared_ptr<TMeshInfo> PMeshInfo;
-  
-  struct TFamilyInfo;
-  typedef shared_ptr<TFamilyInfo> PFamilyInfo;
-
-  struct TElemInfo;
-  typedef shared_ptr<TElemInfo> PElemInfo;
-
-  struct TNodeInfo;
-  typedef shared_ptr<TNodeInfo> PNodeInfo;
-
-  struct TCellInfo;
-  typedef shared_ptr<TCellInfo> PCellInfo;
-
-  struct TFieldInfo;
-  typedef shared_ptr<TFieldInfo> PFieldInfo;
-
-  struct TTimeStampInfo;
-  typedef shared_ptr<TTimeStampInfo> PTimeStampInfo;
-  
-  struct TTimeStampVal;
-  typedef shared_ptr<TTimeStampVal> PTimeStampVal;
-
-  class TWrapper;
-  typedef shared_ptr<TWrapper> PWrapper;
-};
-
-
-#endif
diff --git a/src/MEDWrapper/MED_Structures.cxx b/src/MEDWrapper/MED_Structures.cxx
deleted file mode 100644 (file)
index 500a3e9..0000000
+++ /dev/null
@@ -1,440 +0,0 @@
-//  Copyright (C) 2003  CEA/DEN, EDF R&D
-//
-//
-//
-//  File   : VISU_DatConvertor.cxx
-//  Author : Alexey PETROV
-//  Module : VISU
-
-#include "MED_Structures.hxx"
-#include "MED_Utilities.hxx"
-#include <string>
-using namespace std;
-using namespace MED;
-
-#ifdef _DEBUG_
-static int MYDEBUG = 1;
-#else
-static int MYDEBUG = 0;
-#endif
-
-#if defined __GNUC__
-  #if __GNUC__ == 2
-    #define __GNUC_2__
-  #endif
-#endif
-
-//---------------------------------------------------------------
-string MED::GetString(med_int theId, med_int theStep,
-                     const TString& theString)
-{
-  const char* aPos = &theString[theId*theStep];
-  med_int aSize = min(med_int(strlen(aPos)),theStep);
-  return string(aPos,aSize);
-}
-
-void MED::SetString(med_int theId, med_int theStep,
-                   TString& theString, const string& theValue)
-{
-  med_int aSize = min(med_int(theValue.size()+1),theStep);
-  if(aSize > theStep)
-    EXCEPTION(runtime_error,"SetString(...): aSize =="<<aSize<<"of '"<<theValue<<"' > theStep");
-  strncpy(&theString[theId*theStep],theValue.c_str(),aSize);
-}
-
-med_int MED::GetNbConn(med_entite_maillage theMedEntity, 
-                      med_geometrie_element theMedType,
-                      med_int theMeshDim)
-{
-  med_int anElemDim = theMedType / 100, nsup = 0;
-  if(theMedEntity == MED_MAILLE && anElemDim < theMeshDim) nsup = 1;
-  return nsup + theMedType % 100;
-}
-
-
-//---------------------------------------------------------------
-TNameInfo::TNameInfo(const string& theValue):
-#if defined __GNUC_2__
-  // _CS_phb Attention, il s'agit dans ce cas (gcc2.*) d'un vector.
-  // L'appel des arguments est inversé.
-  myName(MED_TAILLE_NOM+1,'\0')
-#else
-  myName('\0',MED_TAILLE_NOM+1)
-#endif
-{
-  if(theValue != "") SetName(theValue);
-}
-
-string TNameInfo::GetName() const { 
-  return GetString(0,MED_TAILLE_NOM,myName);
-}
-
-void TNameInfo::SetName(const string& theValue){
-  SetString(0,MED_TAILLE_NOM,myName,theValue);
-}
-
-
-//---------------------------------------------------------------
-TMeshInfo::TMeshInfo(med_int theDim,
-                    const string& theValue):
-  TNameInfo(theValue),
-  myDim(theDim)
-{}
-
-//---------------------------------------------------------------
-TFamilyInfo::TFamilyInfo(const PMeshInfo& theMeshInfo, 
-                        med_int theNbGroup, 
-                        med_int theNbAttr,
-                        med_int theId,
-                        const string& theValue):
-  TNameInfo(theValue),
-  myMeshInfo(theMeshInfo),
-  myId(theId),
-  myNbGroup(theNbGroup),
-#if defined __GNUC_2__
-  // _CS_phb Attention, il s'agit dans ce cas (gcc2.*) d'un vector
-  // L'appel des arguments est inversé.
-  myGroupNames(theNbGroup*MED_TAILLE_LNOM+1,'\0'),
-#else
-  myGroupNames('\0',theNbGroup*MED_TAILLE_LNOM+1),
-#endif
-  myNbAttr(theNbAttr), 
-  myAttrId(theNbAttr), 
-  myAttrVal(theNbAttr),
-#if defined __GNUC_2__
-  myAttrDesc(theNbAttr*MED_TAILLE_DESC+1,'\0')
-#else
-  myAttrDesc('\0',theNbAttr*MED_TAILLE_DESC+1)
-#endif
-{}  
-
-TFamilyInfo::TFamilyInfo(const PMeshInfo& theMeshInfo,
-                        const string& theValue,
-                        med_int theId,
-                        const TStringSet& theGroupNames, 
-                        const TStringVector& theAttrDescs, 
-                        const TIntVector& theAttrIds, 
-                        const TIntVector& theAttrVals):
-  TNameInfo(theValue),
-  myMeshInfo(theMeshInfo),
-  myId(theId),
-  myNbGroup(theGroupNames.size()),
-#if defined __GNUC_2__
-  // _CS_phb Attention, il s'agit dans ce cas (gcc2.*) d'un vector
-  // L'appel des arguments est inversé.
-  myGroupNames(theGroupNames.size()*MED_TAILLE_LNOM+1,'\0'),
-#else
-  myGroupNames('\0',theGroupNames.size()*MED_TAILLE_LNOM+1),
-#endif
-  myNbAttr(theAttrDescs.size()), 
-  myAttrId(theAttrDescs.size()), 
-  myAttrVal(theAttrDescs.size()),
-#if defined __GNUC_2__
-  myAttrDesc(theAttrDescs.size()*MED_TAILLE_DESC+1,'\0')
-#else
-  myAttrDesc('\0',theAttrDescs.size()*MED_TAILLE_DESC+1)
-#endif
-
-{
-  if(myNbGroup){
-    TStringSet::const_iterator anIter = theGroupNames.begin();
-    for(med_int anId = 0; anIter != theGroupNames.end(); anIter++, anId++){
-      const string& aVal = *anIter;
-      SetGroupName(anId,aVal);
-    }
-  }
-  if(myNbAttr){
-    for(med_int anId = 0, anEnd = theAttrDescs.size(); anId < anEnd; anId++){
-      const string& aVal = theAttrDescs[anId];
-      SetAttrDesc(anId,aVal);
-      myAttrId[anId] = theAttrIds[anId];
-      myAttrVal[anId] = theAttrVals[anId];
-    }
-  }
-}  
-
-string TFamilyInfo::GetGroupName(med_int theId) const { 
-  return GetString(theId,MED_TAILLE_LNOM,myGroupNames);
-}
-
-void TFamilyInfo::SetGroupName(med_int theId, const string& theValue){
-  SetString(theId,MED_TAILLE_LNOM,myGroupNames,theValue);
-}
-
-string TFamilyInfo::GetAttrDesc(med_int theId) const { 
-  return GetString(theId,MED_TAILLE_DESC,myAttrDesc);
-}
-
-void TFamilyInfo::SetAttrDesc(med_int theId, const string& theValue){
-  SetString(theId,MED_TAILLE_DESC,myAttrDesc,theValue);
-}
-
-
-//---------------------------------------------------------------
-TElemInfo::TElemInfo(const PMeshInfo& theMeshInfo, 
-                    med_int theNbElem,
-                    med_booleen theIsElemNum,
-                    med_booleen theIsElemNames):
-  myMeshInfo(theMeshInfo), 
-  myNbElem(theNbElem),
-  myFamNum(theNbElem),
-  myIsElemNum(theIsElemNum), 
-  myElemNum(theIsElemNum == MED_FAUX? 0: theNbElem),
-  myIsElemNames(theIsElemNames),
-#if defined __GNUC_2__
-  myElemNames((theIsElemNames == MED_FAUX? 0: theNbElem)*MED_TAILLE_PNOM+1,'\0')
-#else
-  myElemNames('\0',(theIsElemNames == MED_FAUX? 0: theNbElem)*MED_TAILLE_PNOM+1)
-#endif
-{}
-
-TElemInfo::TElemInfo(const PMeshInfo& theMeshInfo, 
-                    const TIntVector& theFamilyNums,
-                    const TIntVector& theElemNums,
-                    const TStringVector& theElemNames):
-  myMeshInfo(theMeshInfo), 
-  myNbElem(theFamilyNums.size()),
-  myFamNum(theFamilyNums.size()),
-  myIsElemNum(theElemNums.size()? MED_VRAI: MED_FAUX), 
-  myElemNum(theElemNums.size()),
-  myIsElemNames(theElemNames.size()? MED_VRAI: MED_FAUX),
-#if defined __GNUC_2__
-  myElemNames(theElemNames.size()*MED_TAILLE_PNOM+1,'\0')
-#else
-  myElemNames('\0',theElemNames.size()*MED_TAILLE_PNOM+1)
-#endif
-{
-  if(myNbElem){
-    for(med_int anId = 0; anId < myNbElem; anId++){
-      myFamNum[anId] = theFamilyNums[anId];
-    }
-    if(myIsElemNum == MED_VRAI){
-      for(med_int anId = 0; anId < myNbElem; anId++){
-       myElemNum[anId] = theElemNums[anId];
-      }
-    }
-    if(myIsElemNames == MED_VRAI){
-      for(med_int anId = 0; anId < myNbElem; anId++){
-       const string& aVal = theElemNames[anId];
-       SetElemName(anId,aVal);
-      }
-    }
-  }
-}
-
-string TElemInfo::GetElemName(med_int theId) const { 
-  return GetString(theId,MED_TAILLE_PNOM,myElemNames);
-}
-
-void TElemInfo::SetElemName(med_int theId, const string& theValue){
-  SetString(theId,MED_TAILLE_PNOM,myElemNames,theValue);
-}
-
-
-//---------------------------------------------------------------
-TNodeInfo::TNodeInfo(const PMeshInfo& theMeshInfo, 
-                    med_int theNbElem,
-                    med_repere theSystem, 
-                    med_booleen theIsElemNum,
-                    med_booleen theIsElemNames):
-  TElemInfo(theMeshInfo,theNbElem,theIsElemNum,theIsElemNames),
-  myCoord(theNbElem*theMeshInfo->myDim), 
-  mySystem(theSystem), 
-#if defined __GNUC_2__
-  myCoordNames(theMeshInfo->myDim*MED_TAILLE_PNOM+1,'\0'),
-  myCoordUnits(theMeshInfo->myDim*MED_TAILLE_PNOM+1,'\0')
-#else
-  myCoordNames('\0',theMeshInfo->myDim*MED_TAILLE_PNOM+1),
-  myCoordUnits('\0',theMeshInfo->myDim*MED_TAILLE_PNOM+1)
-#endif
-{}
-
-TNodeInfo::TNodeInfo(const PMeshInfo& theMeshInfo, 
-                    med_repere theSystem, 
-                    const TFloatVector& theNodeCoords,
-                    const TStringVector& theCoordNames,
-                    const TStringVector& theCoordUnits,
-                    const TIntVector& theFamilyNums,
-                    const TIntVector& theElemNums,
-                    const TStringVector& theElemNames):
-  TElemInfo(theMeshInfo,theFamilyNums,theElemNums,theElemNames),
-  myCoord(theNodeCoords.size()), 
-  mySystem(theSystem), 
-#if defined __GNUC_2__
-  myCoordNames(theMeshInfo->myDim*MED_TAILLE_PNOM+1,'\0'),
-  myCoordUnits(theMeshInfo->myDim*MED_TAILLE_PNOM+1,'\0')
-#else
-  myCoordNames('\0',theMeshInfo->myDim*MED_TAILLE_PNOM+1),
-  myCoordUnits('\0',theMeshInfo->myDim*MED_TAILLE_PNOM+1)
-#endif
-{
-  if(myCoord.size() == myNbElem*theMeshInfo->myDim){
-    for(med_int anId = 0, anEnd = myCoord.size(); anId < anEnd; anId++){
-      myCoord[anId] = theNodeCoords[anId];
-    }
-  }else 
-    EXCEPTION(runtime_error,"myCoord.size() != myNbElem*theMeshInfo->myDim");
-
-  for(med_int anId = 0; anId < theMeshInfo->myDim; anId++){
-#if defined __GNUC_2__
-    const string& aVal = theCoordNames[anId];
-#else
-    const string& aVal = theCoordNames.at(anId);
-#endif
-    SetCoordName(anId,aVal);
-  }
-
-  for(med_int anId = 0; anId < theMeshInfo->myDim; anId++){
-#if defined __GNUC_2__
-    const string& aVal = theCoordUnits[anId];
-#else
-    const string& aVal = theCoordUnits.at(anId);
-#endif
-    SetCoordUnit(anId,aVal);
-  }
-}
-
-string TNodeInfo::GetCoordName(med_int theId) const { 
-  return GetString(theId,MED_TAILLE_PNOM,myCoordNames);
-}
-
-void TNodeInfo::SetCoordName(med_int theId, const string& theValue){
-  SetString(theId,MED_TAILLE_PNOM,myCoordNames,theValue);
-}
-
-string TNodeInfo::GetCoordUnit(med_int theId) const { 
-  return GetString(theId,MED_TAILLE_PNOM,myCoordUnits);
-}
-
-void TNodeInfo::SetCoordUnit(med_int theId, const string& theValue){
-  SetString(theId,MED_TAILLE_PNOM,myCoordUnits,theValue);
-}
-
-
-//---------------------------------------------------------------
-TCellInfo::TCellInfo(const PMeshInfo& theMeshInfo, 
-                    med_int theNbElem,
-                    med_entite_maillage theTEntity, 
-                    med_geometrie_element theTGeom,
-                    med_connectivite theTConn,
-                    med_booleen theIsElemNum,
-                    med_booleen theIsElemNames):
-  TElemInfo(theMeshInfo,theNbElem,theIsElemNum,theIsElemNames),
-  myTEntity(theTEntity), 
-  myTGeom(theTGeom), 
-  myTConn(theTConn),
-  myConnDim(GetNbConn(myTEntity,myTGeom,theMeshInfo->myDim)),
-  myConn(theNbElem*myConnDim)
-{}
-
-TCellInfo::TCellInfo(const PMeshInfo& theMeshInfo, 
-                    med_entite_maillage theTEntity, 
-                    med_geometrie_element theTGeom,
-                    med_connectivite theTConn,
-                    const TIntVector& theConnectivities,
-                    const TIntVector& theFamilyNums,
-                    const TIntVector& theElemNums,
-                    const TStringVector& theElemNames):
-  TElemInfo(theMeshInfo,theFamilyNums,theElemNums,theElemNames),
-  myTEntity(theTEntity), 
-  myTGeom(theTGeom), 
-  myTConn(theTConn),
-  myConnDim(GetNbConn(myTEntity,myTGeom,theMeshInfo->myDim)),
-  myConn(theConnectivities.size())
-{
-  if(myConn.size() == myConnDim*theFamilyNums.size()){
-    for(med_int anId = 0, anEnd = myConn.size(); anId < anEnd; anId++){
-      myConn[anId] = theConnectivities[anId];
-    }
-  }else 
-    EXCEPTION(runtime_error,"myConn.size() == myConnDim*theFamilyNums.size()");
-}
-
-//---------------------------------------------------------------
-TFieldInfo::TFieldInfo(const PMeshInfo& theMeshInfo, 
-                      med_int theNbComp,
-                      med_type_champ theType,
-                      const string& theValue):
-  TNameInfo(theValue),
-  myMeshInfo(theMeshInfo), 
-  myNbComp(theNbComp),
-  myType(theType),
-#if defined __GNUC_2__
-  myCompNames(theNbComp*MED_TAILLE_PNOM + 1,'\0'),
-  myUnitNames(theNbComp*MED_TAILLE_PNOM + 1,'\0')
-#else
-  myCompNames('\0',theNbComp*MED_TAILLE_PNOM + 1),
-  myUnitNames('\0',theNbComp*MED_TAILLE_PNOM + 1)
-#endif
-{}
-
-string TFieldInfo::GetCompName(med_int theId) const { 
-  return GetString(theId,MED_TAILLE_PNOM,myCompNames);
-}
-
-void TFieldInfo::SetCompName(med_int theId, const string& theValue){
-  SetString(theId,MED_TAILLE_PNOM,myCompNames,theValue);
-}
-
-string TFieldInfo::GetUnitName(med_int theId) const { 
-  return GetString(theId,MED_TAILLE_PNOM,myUnitNames);
-}
-
-void TFieldInfo::SetUnitName(med_int theId, const string& theValue){
-  SetString(theId,MED_TAILLE_PNOM,myUnitNames,theValue);
-}
-
-
-//---------------------------------------------------------------
-TTimeStampInfo::TTimeStampInfo(const PFieldInfo& theFieldInfo, 
-                              med_entite_maillage theEntity,
-                              const TGeom& theGeom):
-  myFieldInfo(theFieldInfo), 
-  myEntity(theEntity), 
-  myGeom(theGeom), 
-#if defined __GNUC_2__
-  myUnitDt(MED_TAILLE_PNOM+1,'\0')
-#else
-  myUnitDt('\0',MED_TAILLE_PNOM+1)
-#endif
-{}
-
-string TTimeStampInfo::GetUnitDt() const { 
-  return GetString(0,MED_TAILLE_PNOM,myUnitDt);
-}
-
-void TTimeStampInfo::SetUnitDt(const string& theValue){
-  SetString(0,MED_TAILLE_PNOM,myUnitDt,theValue);
-}
-
-
-//---------------------------------------------------------------
-TTimeStampVal::TTimeStampVal(const PTimeStampInfo& theTimeStampInfo):
-  myTimeStampInfo(theTimeStampInfo),
-#if defined __GNUC_2__
-  myPflName(MED_TAILLE_NOM+1,'\0')
-#else
-  myPflName('\0',MED_TAILLE_NOM+1)
-#endif
-{
-  med_int aNbComp = theTimeStampInfo->myFieldInfo->myNbComp;
-  med_int aNbGauss = theTimeStampInfo->myNbGauss;
-  const TGeom& aTGeom = theTimeStampInfo->myGeom;
-  TGeom::const_iterator anIter = aTGeom.begin();
-  for(; anIter != aTGeom.end(); anIter++){
-    const med_geometrie_element& aGeom = anIter->first;
-    med_int aNb = anIter->second*aNbComp*aNbGauss;
-    myMeshValue[aGeom].resize(aNb);
-  }
-}
-
-string TTimeStampVal::GetPflName() const { 
-  return GetString(0,MED_TAILLE_NOM,myPflName);
-}
-
-void TTimeStampVal::SetPflName(const string& theValue){
-  SetString(0,MED_TAILLE_NOM,myPflName,theValue);
-}
-
-
diff --git a/src/MEDWrapper/MED_Structures.hxx b/src/MEDWrapper/MED_Structures.hxx
deleted file mode 100644 (file)
index 727e83c..0000000
+++ /dev/null
@@ -1,243 +0,0 @@
-//  Copyright (C) 2003  CEA/DEN, EDF R&D
-//
-//
-//
-//  File   : VISU_DatConvertor.hxx
-//  Author : Alexey PETROV
-//  Module : VISU
-
-#ifndef MED_Structures_HeaderFile
-#define MED_Structures_HeaderFile
-
-#if defined __GNUC__
-  #if __GNUC__ == 2
-    #define __GNUC_2__
-  #endif
-#endif
-
-#if defined __GNUC_2__
-#include <vector>
-#endif
-#include <valarray>
-
-#include "MED_Common.hxx"
-
-namespace MED{
-  using namespace std;
-  using namespace boost;
-
-//---------------------------------------------------------------
-#if defined __GNUC_2__
-  typedef vector<char> TString;
-#else
-  typedef valarray<char> TString;
-#endif
-
-  string GetString(med_int theId, med_int theStep, const TString& theString);
-  void SetString(med_int theId, med_int theStep, TString& theString, 
-                const string& theValue);
-
-
-//---------------------------------------------------------------
-  struct TNameInfo{
-    TNameInfo(const string& theValue = "");
-    virtual ~TNameInfo() {} 
-
-    TString myName;
-    string GetName() const;
-    void SetName(const string& theValue);
-  };
-
-
-//---------------------------------------------------------------
-  struct TMeshInfo: TNameInfo{
-    TMeshInfo(med_int theDim = 0,
-             const string& theValue = "");
-
-    med_int myDim;
-  };
-  
-
-//---------------------------------------------------------------
-  typedef valarray<med_int> TFamAttr;
-
-  struct TFamilyInfo: TNameInfo{
-    TFamilyInfo(const PMeshInfo& theMeshInfo,
-               med_int theNbGroup = 0, 
-               med_int theNbAttr = 0,
-               med_int theId = 0,
-               const string& theValue = "");
-
-    TFamilyInfo(const PMeshInfo& theMeshInfo,
-               const string& theValue,
-               med_int theId,
-               const TStringSet& theGroupNames, 
-               const TStringVector& theAttrDescs = TStringVector(), 
-               const TIntVector& theAttrIds = TIntVector(), 
-               const TIntVector& theAttrVals = TIntVector());
-
-    PMeshInfo myMeshInfo;
-    med_int myId;
-
-    med_int myNbGroup;
-    TString myGroupNames;
-    string GetGroupName(med_int theId) const;
-    void SetGroupName(med_int theId, const string& theValue);
-
-    med_int myNbAttr;
-    TFamAttr myAttrId;
-    TFamAttr myAttrVal;
-
-    TString myAttrDesc;
-    string GetAttrDesc(med_int theId) const;
-    void SetAttrDesc(med_int theId, const string& theValue);
-  };
-
-
-//---------------------------------------------------------------
-  typedef valarray<med_int> TElemNum;
-
-  struct TElemInfo{
-    TElemInfo(const PMeshInfo& theMeshInfo, 
-             med_int theNbElem,
-             med_booleen theIsElemNum = MED_VRAI,
-             med_booleen theIsElemNames = MED_VRAI);
-    TElemInfo(const PMeshInfo& theMeshInfo, 
-             const TIntVector& theFamilyNums,
-             const TIntVector& theElemNums,
-             const TStringVector& theElemNames = TStringVector());
-    virtual ~TElemInfo() {} 
-
-    PMeshInfo myMeshInfo;
-    med_int myNbElem;
-    
-    TElemNum myFamNum;
-
-    med_booleen myIsElemNum;
-    TElemNum myElemNum;
-
-    med_booleen myIsElemNames;
-    TString myElemNames;
-    string GetElemName(med_int theId) const;
-    void SetElemName(med_int theId, const string& theValue);
-  };
-
-
-//---------------------------------------------------------------
-  typedef valarray<med_float> TNodeCoord;
-
-  struct TNodeInfo: TElemInfo{
-    TNodeInfo(const PMeshInfo& theMeshInfo, 
-             med_int theNbElem,
-             med_repere theSystem = MED_CART, 
-             med_booleen theIsElemNum = MED_VRAI,
-             med_booleen theIsElemNames = MED_VRAI);
-
-    TNodeInfo(const PMeshInfo& theMeshInfo, 
-             med_repere theSystem, 
-             const TFloatVector& theNodeCoords,
-             const TStringVector& theCoordNames,
-             const TStringVector& theCoordUnits,
-             const TIntVector& theFamilyNums,
-             const TIntVector& theElemNums,
-             const TStringVector& theElemNames = TStringVector());
-
-    TNodeCoord myCoord;
-    med_repere mySystem;
-
-    TString myCoordNames;
-    string GetCoordName(med_int theId) const;
-    void SetCoordName(med_int theId, const string& theValue);
-
-    TString myCoordUnits;
-    string GetCoordUnit(med_int theId) const;
-    void SetCoordUnit(med_int theId, const string& theValue);
-  };
-
-
-//---------------------------------------------------------------
-  struct TCellInfo: TElemInfo{
-    TCellInfo(const PMeshInfo& theMeshInfo, 
-             med_int theNbElem,
-             med_entite_maillage theTEntity, 
-             med_geometrie_element theTGeom,
-             med_connectivite theTConn = MED_NOD,
-             med_booleen theIsElemNum = MED_VRAI,
-             med_booleen theIsElemNames = MED_VRAI);
-
-    TCellInfo(const PMeshInfo& theMeshInfo, 
-             med_entite_maillage theTEntity, 
-             med_geometrie_element theTGeom,
-             med_connectivite theTConn,
-             const TIntVector& theConnectivities,
-             const TIntVector& theFamilyNums,
-             const TIntVector& theElemNums,
-             const TStringVector& theElemNames = TStringVector());
-
-    med_entite_maillage myTEntity;
-    med_geometrie_element myTGeom;
-    med_connectivite myTConn;
-
-    med_int myConnDim;
-    TElemNum myConn;
-  };
-
-
-//---------------------------------------------------------------
-  struct TFieldInfo: TNameInfo{
-    TFieldInfo(const PMeshInfo& theMeshInfo, 
-              med_int theNbComp = 0,
-              med_type_champ theType = MED_REEL64,
-              const string& theValue = "");
-    
-    PMeshInfo myMeshInfo;
-    med_type_champ myType;
-    med_int myNbComp;
-    
-    TString myCompNames; 
-    string GetCompName(med_int theId) const;
-    void SetCompName(med_int theId, const string& theValue);
-
-    TString myUnitNames; 
-    string GetUnitName(med_int theId) const;
-    void SetUnitName(med_int theId, const string& theValue);
-  };
-
-
-//---------------------------------------------------------------
-  struct TTimeStampInfo{
-    TTimeStampInfo(const PFieldInfo& theFieldInfo, 
-                  med_entite_maillage theEntity,
-                  const TGeom& theGeom);
-
-    PFieldInfo myFieldInfo;
-    med_entite_maillage myEntity;
-    TGeom myGeom;
-
-    med_int myNbGauss, myNumDt, myNumOrd;
-    med_float myDt;
-
-    TString myUnitDt;
-    string GetUnitDt() const;
-    void SetUnitDt(const string& theValue);
-  };
-  
-
-  typedef valarray<med_float> TValue;
-  typedef map<med_geometrie_element,TValue> TMeshValue;
-//---------------------------------------------------------------
-  struct TTimeStampVal{
-    TTimeStampVal(const PTimeStampInfo& theTimeStampInfo);
-
-    PTimeStampInfo myTimeStampInfo;
-    TMeshValue myMeshValue;
-
-    TString myPflName;
-    string GetPflName() const;
-    void SetPflName(const string& theValue);
-  };
-
-};
-
-
-#endif
diff --git a/src/MEDWrapper/MED_Test.cxx b/src/MEDWrapper/MED_Test.cxx
deleted file mode 100644 (file)
index adc7477..0000000
+++ /dev/null
@@ -1,186 +0,0 @@
-//  VISU OBJECT : interactive object for VISU entities implementation
-//
-//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
-// 
-//  This library is free software; you can redistribute it and/or 
-//  modify it under the terms of the GNU Lesser General Public 
-//  License as published by the Free Software Foundation; either 
-//  version 2.1 of the License. 
-// 
-//  This library is distributed in the hope that it will be useful, 
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
-//  Lesser General Public License for more details. 
-// 
-//  You should have received a copy of the GNU Lesser General Public 
-//  License along with this library; if not, write to the Free Software 
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
-// 
-//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
-//
-//
-//  File:    VISUConvertor.cxx
-//  Author:  Alexey PETROV
-//  Module : VISU
-
-#include "MED_Structures.hxx"
-#include "MED_Wrapper.hxx"
-#include "MED_Utilities.hxx"
-
-using namespace std;
-
-#ifdef DEBUG
-static int MYDEBUG = 1;
-#else
-static int MYDEBUG = 0;
-#endif
-
-
-void ReadMed(const char* theFileName){
-  using namespace MED;
-  TWrapper aMed(theFileName);
-  string aFileName = theFileName;
-  aFileName += "-";
-  TWrapper aMedW(aFileName);
-
-  int aNbMeshes = aMed.GetNbMeshes();
-  MESSAGE("GetNbMeshes() = "<<aNbMeshes);
-
-  string aName;
-  for(int iMesh = 0; iMesh < aNbMeshes; iMesh++){
-    PMeshInfo aMeshInfo(new TMeshInfo());
-    PMeshInfo aNewMeshInfo(new TMeshInfo());
-    aMed.GetMeshInfo(iMesh+1,*aMeshInfo);
-    int aDim = aMeshInfo->myDim;
-    aName = aMeshInfo->GetName();
-    MESSAGE("GetMeshInfo - aName = '"<<aName<<"'; aDim = "<<aDim);
-    *aNewMeshInfo = *aMeshInfo;
-    aName[0] += 1;
-    aNewMeshInfo->SetName(aName);
-    aMedW.SetMeshInfo(*aNewMeshInfo);
-
-    TEntityInfo aEntityInfo = aMed.GetEntityInfo(*aMeshInfo);
-
-    med_int aNbFields = aMed.GetNbFields(); 
-    MESSAGE("GetNbFields() = "<<aNbFields);
-    for(int iField = 0; iField < aNbFields; iField++){
-      med_int aNbComp = aMed.GetNbComp(iField+1);
-      PFieldInfo aFieldInfo(new TFieldInfo(aMeshInfo,aNbComp));
-      aMed.GetFieldInfo(iField+1,*aFieldInfo);
-      MESSAGE("\taName = '"<<aFieldInfo->GetName()<<"'; aNbComp = "<<aNbComp<<"; ");
-      aMedW.SetFieldInfo(*aFieldInfo);
-      med_entite_maillage anEntity;
-      TGeom aTGeom;
-      med_int aNbTimeStamps = aMed.GetNbTimeStamps(*aFieldInfo,aEntityInfo,
-                                                  anEntity,aTGeom);
-      MESSAGE("GetNbTimeStamps = "<<aNbTimeStamps);
-      PTimeStampInfo aTimeStampInfo(new TTimeStampInfo(aFieldInfo,anEntity,aTGeom));
-      for(int iTimeStamp = 0; iTimeStamp < aNbTimeStamps; iTimeStamp++){
-       aMed.GetTimeStampInfo(iTimeStamp+1, *aTimeStampInfo);
-
-       TTimeStampVal aTimeStampVal(aTimeStampInfo);
-       aMed.GetTimeStampVal(aTimeStampVal);
-       aMedW.SetTimeStamp(aTimeStampVal);
-
-       TMeshValue& aMeshValue = aTimeStampVal.myMeshValue;
-       TMeshValue::iterator aMeshValueIter = aMeshValue.begin();
-       for(; aMeshValueIter != aMeshValue.end(); aMeshValueIter++){
-         med_geometrie_element aGeom = aMeshValueIter->first;
-         TValue aValue = aMeshValueIter->second;
-         MESSAGE("\t\taGeom = "<<aGeom<<"; aValue = "<<aValue.size()<<": ");
-         for(int i = 0, iEnd = aValue.size()/aNbComp; i < iEnd; i++){
-           for(int j = 0, ij = i*aNbComp; j < aNbComp; j++, ij++){
-             //MESSAGE(aValue[ij]<<",");
-           }
-           //MESSAGE(" ");
-         }
-         MESSAGE("\n");
-       }
-      }
-    }
-
-    int aNbFam = aMed.GetNbFamilies(*aMeshInfo);
-    MESSAGE("GetNbFamilies() = "<<aNbFam);
-    for(int iFam = 0; iFam < aNbFam; iFam++){
-      int aNbAttr = aMed.GetNbFamAttr(iFam+1,*aMeshInfo);
-      int aNbGroup = aMed.GetNbFamGroup(iFam+1,*aMeshInfo);
-      PFamilyInfo aFamilyInfo(new TFamilyInfo(aMeshInfo,aNbGroup,aNbAttr));
-      aMed.GetFamilyInfo(iFam+1,*aFamilyInfo);
-      aName = aFamilyInfo->GetName();
-      MESSAGE("\taName = '"<<aName<<"'; aNbAttr = "<<aNbAttr<<"; aNbGroup = "<<aNbGroup);
-      aName[0] += 1;
-      aFamilyInfo->SetName(aName);
-      aFamilyInfo->myMeshInfo = aNewMeshInfo;
-      aName = aFamilyInfo->GetName();
-      for(int iGroup = 0; iGroup < aNbGroup; iGroup++){
-       aName = aFamilyInfo->GetGroupName(iGroup);
-       MESSAGE("\t\taGroupName = '"<<aName<<"'");
-       aName[0] += 1;
-       aFamilyInfo->SetGroupName(iGroup,aName);
-      }
-
-      aMedW.SetFamilyInfo(*aFamilyInfo);
-    }
-
-    MESSAGE("GetEntityInfo - aNbEntities = "<<aEntityInfo.size());
-    TEntityInfo::iterator anEntityInfoIter = aEntityInfo.begin();
-    for(; anEntityInfoIter != aEntityInfo.end(); anEntityInfoIter++){
-      const med_entite_maillage& anEntity = anEntityInfoIter->first;
-      MESSAGE("\tanEntity = "<<anEntity);
-      if(anEntity == MED_NOEUD){
-       int aNbNodes = aMed.GetNbNodes(*aMeshInfo);
-       PNodeInfo aNodeInfo(new TNodeInfo(aMeshInfo,aNbNodes));
-       aMed.GetNodeInfo(*aNodeInfo);
-       MESSAGE("\tGetNodeInfo - aNbNodes = "<<aNbNodes<<": ");
-       TNodeCoord& aCoord = aNodeInfo->myCoord;
-       for(int iNode = 0; iNode < aNbNodes; iNode++){
-         for(int iDim = 0, anId = iNode*aDim; iDim < aDim; iDim++, anId++){
-           //MESSAGE(aCoord[anId]<<",");
-           aCoord[anId] += 1.0;
-         }
-         //MESSAGE(" ");
-       }
-       MESSAGE(endl);
-       aNodeInfo->myMeshInfo = aNewMeshInfo;
-       aMedW.SetNodeInfo(*aNodeInfo);
-       continue;
-      }
-      TGeom& aTGeom = anEntityInfoIter->second;
-      TGeom::iterator anTGeomIter = aTGeom.begin();
-      for(; anTGeomIter != aTGeom.end(); anTGeomIter++){
-       const med_geometrie_element& aGeom = anTGeomIter->first;
-       med_int& aNbElem = anTGeomIter->second;
-       MESSAGE("\t\taGeom = "<<aGeom<<"; aNbElem = "<<aNbElem<<": ");
-       PCellInfo aCellInfo(new TCellInfo(aMeshInfo,aNbElem,anEntity,aGeom));
-       aMed.GetCellInfo(*aCellInfo);
-       for(int iElem = 0; iElem < aCellInfo->myNbElem; iElem++){
-         int i = iElem*aCellInfo->myConnDim;
-         for(int iConn = 0; iConn < aCellInfo->myConnDim; iConn++, i++){
-           //MESSAGE(aCellInfo->myConn[i]<<",");
-         }
-         //MESSAGE(" ");
-       }
-       MESSAGE(endl);
-       aCellInfo->myMeshInfo = aNewMeshInfo;
-       aMedW.SetCellInfo(*aCellInfo);
-      }
-    }
-    
-  }
-  MESSAGE("OK");
-}
-
-
-int main(int argc, char** argv){ 
-  try{
-    if(argc > 1)
-      ReadMed(argv[1]);
-    return 0;
-  }catch(std::exception& exc){
-    MESSAGE("Follow exception was accured :\n"<<exc.what());
-  }catch(...){
-    MESSAGE("Unknown exception was accured in VISU_Convertor_impl");
-  } 
-  return 1;
-}
diff --git a/src/MEDWrapper/MED_Utilities.cxx b/src/MEDWrapper/MED_Utilities.cxx
deleted file mode 100644 (file)
index e09d642..0000000
+++ /dev/null
@@ -1,37 +0,0 @@
-//  Copyright (C) 2003  CEA/DEN, EDF R&D
-//
-//
-//
-//  File   : VISU_DatConvertor.cxx
-//  Author : Alexey PETROV
-//  Module : VISU
-
-#include "MED_Utilities.hxx"
-
-using namespace std;
-
-#ifdef _DEBUG_
-static int MYDEBUG = 1;
-#else
-static int MYDEBUG = 0;
-#endif
-
-
-int MED::PrefixPrinter::myCounter = 0;
-
-MED::PrefixPrinter::PrefixPrinter()
-{
-  myCounter++;
-}
-
-MED::PrefixPrinter::~PrefixPrinter()
-{
-  myCounter--;
-}
-
-string MED::PrefixPrinter::GetPrefix()
-{
-  if(myCounter)
-    return string(myCounter*2,' ');
-  return "";
-}
diff --git a/src/MEDWrapper/MED_Utilities.hxx b/src/MEDWrapper/MED_Utilities.hxx
deleted file mode 100644 (file)
index a7cf092..0000000
+++ /dev/null
@@ -1,52 +0,0 @@
-//  Copyright (C) 2003  CEA/DEN, EDF R&D
-//
-//
-//
-//  File   : VISU_DatConvertor.hxx
-//  Author : Alexey PETROV
-//  Module : VISU
-
-#ifndef MED_Utilities_HeaderFile
-#define MED_Utilities_HeaderFile
-
-#include <iostream>    
-#include <sstream>     
-#include <string>
-#include <stdexcept>
-
-
-namespace MED{
-  using namespace std;
-  class PrefixPrinter{
-    static int myCounter;
-  public:
-    PrefixPrinter();
-    ~PrefixPrinter();
-
-    static string GetPrefix();
-  };
-};
-
-
-#ifndef MESSAGE
-
-#define MESSAGE(msg) std::cout<<__FILE__<<"["<<__LINE__<<"]::"<<msg<<endl;
-
-#define BEGMSG(msg) std::cout<<MED::PrefixPrinter::GetPrefix()<<msg
-
-#define ADDMSG(msg) std::cout<<msg
-
-#endif
-
-
-#ifndef EXCEPTION
-
-#define EXCEPTION(TYPE, MSG) {\
-  std::ostringstream aStream;\
-  aStream<<__FILE__<<"["<<__LINE__<<"]::"<<MSG;\
-  throw TYPE(aStream.str());\
-}
-
-#endif
-
-#endif
diff --git a/src/MEDWrapper/MED_Wrapper.cxx b/src/MEDWrapper/MED_Wrapper.cxx
deleted file mode 100644 (file)
index d732fb0..0000000
+++ /dev/null
@@ -1,624 +0,0 @@
-//  Copyright (C) 2003  CEA/DEN, EDF R&D
-//
-//
-//
-//  File   : VISU_DatConvertor.cxx
-//  Author : Alexey PETROV
-//  Module : VISU
-
-#include "MED_Wrapper.hxx"
-#include "MED_Utilities.hxx"
-
-using namespace std;
-using namespace MED;
-
-#ifdef _DEBUG_
-static int MYDEBUG = 1;
-#else
-static int MYDEBUG = 0;
-#endif
-
-
-
-//---------------------------------------------------------------
-static med_geometrie_element NODEGEOM[1] = {MED_POINT1};
-
-static med_geometrie_element EDGEGEOM[MED_NBR_GEOMETRIE_ARETE] = {
-  MED_SEG2, MED_SEG3
-};
-
-static med_geometrie_element FACEGEOM[MED_NBR_GEOMETRIE_FACE] = {
-  MED_TRIA3, MED_QUAD4, MED_TRIA6, MED_QUAD8
-};
-
-static med_geometrie_element  CELLGEOM[MED_NBR_GEOMETRIE_MAILLE] = {
-  MED_POINT1, MED_SEG2, MED_SEG3, MED_TRIA3,
-  MED_QUAD4, MED_TRIA6, MED_QUAD8, MED_TETRA4,
-  MED_PYRA5, MED_PENTA6, MED_HEXA8, MED_TETRA10, 
-  MED_PYRA13, MED_PENTA15, MED_HEXA20
-};
-
-void GetEntity2Geom(med_entite_maillage theEntity, med_geometrie_element*& theVector, int* theEnd){
-  switch(theEntity){
-  case MED_MAILLE: theVector = CELLGEOM; *theEnd = MED_NBR_GEOMETRIE_MAILLE; break;
-  case MED_FACE: theVector = FACEGEOM; *theEnd = MED_NBR_GEOMETRIE_FACE; break;
-  case MED_ARETE: theVector = EDGEGEOM; *theEnd = MED_NBR_GEOMETRIE_ARETE; break;
-  case MED_NOEUD: theVector = NODEGEOM; *theEnd = 1; break;
-  default:
-    EXCEPTION(runtime_error,"GetEntity2Geom - theEntity == "<<theEntity<<" is uncorrect");
-  }
-}
-
-
-//---------------------------------------------------------------
-TFile::TFile(const std::string& theFileName): 
-  myFid(0), 
-  myCount(0),
-  myFileName(strdup(theFileName.c_str()))
-{}
-
-TFile::~TFile(){ 
-  free(myFileName);
-  Close();
-}
-
-
-void TFile::Open(med_mode_acces theMode){
-  if(myCount++ == 0){
-    myFid = MEDouvrir(myFileName,theMode);
-    if(myFid < 0)
-      EXCEPTION(runtime_error,"TFile - MEDouvrir('"<<myFileName<<"',"<<theMode<<")");
-  }
-}
-void TFile::Close(){ 
-  if(--myCount == 0) {
-    MEDfermer(myFid);
-  }
-}
-
-const med_idt& TFile::Id() const { 
-  if(myFid < 0)
-    EXCEPTION(runtime_error,"TFile - GetFid() < 0");
-  return myFid;
-}
-
-
-//---------------------------------------------------------------
-TWrapper::TWrapper(const std::string& theFileName): 
-  myFile(theFileName)
-{}
-
-
-med_int TWrapper::GetNbMeshes(){
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-
-  return MEDnMaa(myFile.Id());
-}
-
-
-void TWrapper::GetMeshInfo(med_int theMeshId, TMeshInfo& theInfo){
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-
-  med_err ret = MEDmaaInfo(myFile.Id(),
-                          theMeshId,
-                          &theInfo.myName[0],
-                          &theInfo.myDim);
-  if(ret < 0)
-    EXCEPTION(runtime_error,"GetMeshInfo - MEDmaaInfo(...)");
-}
-
-
-void TWrapper::SetMeshInfo(const TMeshInfo& theInfo){
-  med_err ret = -1;
-  try{
-    TFileWrapper aFileWrapper(myFile,MED_ECRI);
-    
-    TMeshInfo& anInfo = const_cast<TMeshInfo&>(theInfo);
-    ret = MEDmaaCr(myFile.Id(),
-                  &anInfo.myName[0],
-                  anInfo.myDim);
-  }catch(...){}
-  if(ret < 0){
-    TFileWrapper aFileWrapper(myFile,MED_REMP);
-    
-    TMeshInfo& anInfo = const_cast<TMeshInfo&>(theInfo);
-    ret = MEDmaaCr(myFile.Id(),
-                  &anInfo.myName[0],
-                  anInfo.myDim);
-  }
-  if(ret < 0)
-    EXCEPTION(runtime_error,"SetMeshInfo - MEDmaaCr(...)");
-}
-
-
-med_int TWrapper::GetNbFamilies(const TMeshInfo& theInfo){
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-
-  TMeshInfo& anInfo = const_cast<TMeshInfo&>(theInfo);
-  return MEDnFam(myFile.Id(),
-                &anInfo.myName[0],
-                0,
-                MED_FAMILLE);
-}
-
-
-med_int TWrapper::GetNbFamAttr(med_int theFamId, const TMeshInfo& theInfo){
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-
-  TMeshInfo& anInfo = const_cast<TMeshInfo&>(theInfo);
-  return MEDnFam(myFile.Id(),
-                &anInfo.myName[0],
-                theFamId,
-                MED_ATTR);
-}
-
-
-med_int TWrapper::GetNbFamGroup(med_int theFamId, const TMeshInfo& theInfo){
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-
-  TMeshInfo& anInfo = const_cast<TMeshInfo&>(theInfo);
-  return MEDnFam(myFile.Id(),
-                &anInfo.myName[0],
-                theFamId,
-                MED_GROUPE);
-}
-
-
-void TWrapper::GetFamilyInfo(med_int theFamId, TFamilyInfo& theInfo){
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-
-  TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
-
-  med_err ret = MEDfamInfo(myFile.Id(),
-                          &aMeshInfo.myName[0],
-                          theFamId,
-                          &theInfo.myName[0],
-                          &theInfo.myId,
-                          &theInfo.myAttrId[0],
-                          &theInfo.myAttrVal[0],
-                          &theInfo.myAttrDesc[0],
-                          &theInfo.myNbAttr,
-                          &theInfo.myGroupNames[0],
-                          &theInfo.myNbGroup);
-  if(ret < 0)
-    EXCEPTION(runtime_error,"GetFamilyInfo - MEDfamInfo(...)");
-}
-
-
-void TWrapper::SetFamilyInfo(const TFamilyInfo& theInfo){
-  TFileWrapper aFileWrapper(myFile,MED_ECRI);
-
-  TFamilyInfo& anInfo = const_cast<TFamilyInfo&>(theInfo);
-  TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
-
-  med_err ret = MEDfamCr(myFile.Id(),
-                        &aMeshInfo.myName[0],
-                        &anInfo.myName[0],
-                        anInfo.myId,
-                        &anInfo.myAttrId[0],
-                        &anInfo.myAttrVal[0],
-                        &anInfo.myAttrDesc[0],
-                        anInfo.myNbAttr,
-                        &anInfo.myGroupNames[0],
-                        anInfo.myNbGroup);
-  if(ret < 0)
-    EXCEPTION(runtime_error,"SetFamilyInfo - MEDfamCr(...)");
-}
-
-
-med_int TWrapper::GetNbNodes(const TMeshInfo& theMeshInfo){
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-
-  TMeshInfo& aMeshInfo = const_cast<TMeshInfo&>(theMeshInfo);
-
-  return MEDnEntMaa(myFile.Id(),
-                   &aMeshInfo.myName[0],
-                   MED_COOR,MED_NOEUD,
-                   med_geometrie_element(0),
-                   med_connectivite(0));
-}
-
-
-void TWrapper::GetNodeInfo(TNodeInfo& theInfo){
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-
-  TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
-
-  med_err ret = MEDnoeudsLire(myFile.Id(),
-                             &aMeshInfo.myName[0],
-                             aMeshInfo.myDim,
-                             &theInfo.myCoord[0],
-                             MED_FULL_INTERLACE,
-                             &theInfo.mySystem,
-                             &theInfo.myCoordNames[0],
-                             &theInfo.myCoordUnits[0],
-                             &theInfo.myElemNames[0],
-                             &theInfo.myIsElemNames,
-                             &theInfo.myElemNum[0],
-                             &theInfo.myIsElemNum,
-                             &theInfo.myFamNum[0],
-                             theInfo.myNbElem);
-  if(ret < 0)
-    EXCEPTION(runtime_error,"GetNodeInfo - MEDnoeudsLire(...)");
-}
-
-
-void TWrapper::SetNodeInfo(const TNodeInfo& theInfo)
-{
-  TFileWrapper aFileWrapper(myFile,MED_ECRI);
-
-  TNodeInfo& anInfo = const_cast<TNodeInfo&>(theInfo);
-  TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
-
-  med_err ret = MEDnoeudsEcr(myFile.Id(),
-                            &aMeshInfo.myName[0],
-                            aMeshInfo.myDim,
-                            &anInfo.myCoord[0],
-                            MED_FULL_INTERLACE,
-                            anInfo.mySystem,
-                            &anInfo.myCoordNames[0],
-                            &anInfo.myCoordUnits[0],
-                            &anInfo.myElemNames[0],
-                            anInfo.myIsElemNames,
-                            &anInfo.myElemNum[0],
-                            anInfo.myIsElemNum,
-                            &anInfo.myFamNum[0],
-                            anInfo.myNbElem,
-                            MED_REMP);
-  if(ret < 0)
-    EXCEPTION(runtime_error,"SetNodeInfo - MEDnoeudsEcr(...)");
-}
-
-
-TEntityInfo TWrapper::GetEntityInfo(const TMeshInfo& theMeshInfo){
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-
-  TEntityInfo anInfo;
-  if(med_int aNbElem = GetNbNodes(theMeshInfo)){
-    anInfo[MED_NOEUD][MED_POINT1] = aNbElem;
-    med_entite_maillage anEntityVector[3] = {MED_MAILLE, MED_FACE, MED_ARETE};
-    for(med_int iEntity = 0; iEntity < 3; iEntity++){
-      med_int iGeomEnd;
-      med_entite_maillage& anEntity = anEntityVector[iEntity];
-      med_geometrie_element* aGeomVector;
-      GetEntity2Geom(anEntity,aGeomVector,&iGeomEnd);
-      for(med_int iGeom = 0; iGeom < iGeomEnd; iGeom++) {
-       med_geometrie_element& aGeom = aGeomVector[iGeom];
-       if(med_int aNb = GetNbCells(theMeshInfo,anEntity,aGeom)){
-         anInfo[anEntity][aGeom] = aNb;
-       }
-      }
-    }
-  }
-  return anInfo;
-}
-
-
-med_int TWrapper::GetNbCells(const TMeshInfo& theMeshInfo, 
-                            med_entite_maillage theTEntity, 
-                            med_geometrie_element theTGeom, 
-                            med_connectivite theTConn)
-{
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-
-  TMeshInfo& aMeshInfo = const_cast<TMeshInfo&>(theMeshInfo);
-
-  return MEDnEntMaa(myFile.Id(),
-                   &aMeshInfo.myName[0],
-                   MED_CONN,
-                   theTEntity,
-                   theTGeom,
-                   theTConn); 
-}
-
-
-void TWrapper::GetCellInfo(TCellInfo& theInfo)
-{
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-
-  TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
-  med_int aNbElem = theInfo.myElemNum.size();
-
-  med_err ret = MEDelementsLire(myFile.Id(),
-                               &aMeshInfo.myName[0],
-                               aMeshInfo.myDim,
-                               &theInfo.myConn[0],
-                               MED_FULL_INTERLACE,
-                               &theInfo.myElemNames[0],
-                               &theInfo.myIsElemNames,
-                               &theInfo.myElemNum[0],
-                               &theInfo.myIsElemNum,
-                               &theInfo.myFamNum[0],
-                               aNbElem,
-                               theInfo.myTEntity,
-                               theInfo.myTGeom,
-                               theInfo.myTConn);
-  if(ret < 0)
-    EXCEPTION(runtime_error,"GetCellInfo - MEDelementsLire(...)");
-}
-
-
-void TWrapper::SetCellInfo(const TCellInfo& theInfo)
-{
-  TFileWrapper aFileWrapper(myFile,MED_ECRI);
-
-  TCellInfo& anInfo = const_cast<TCellInfo&>(theInfo);
-  TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
-  med_int aNbElem = anInfo.myElemNum.size();
-
-  med_err ret = MEDelementsEcr(myFile.Id(),
-                              &aMeshInfo.myName[0],
-                              aMeshInfo.myDim,
-                              &anInfo.myConn[0],
-                              MED_FULL_INTERLACE,
-                              &anInfo.myElemNames[0],
-                              anInfo.myIsElemNames,
-                              &anInfo.myElemNum[0],
-                              anInfo.myIsElemNum,
-                              &anInfo.myFamNum[0],
-                              anInfo.myNbElem,
-                              anInfo.myTEntity,
-                              anInfo.myTGeom,
-                              anInfo.myTConn,
-                              MED_REMP);
-
-  if(ret < 0)
-    EXCEPTION(runtime_error,"GetCellInfo - MEDelementsLire(...)");
-}
-
-
-med_int TWrapper::GetNbFields(){
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-
-  return MEDnChamp(myFile.Id(),0);
-}
-
-
-med_int TWrapper::GetNbComp(med_int theFieldId){
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-
-  return MEDnChamp(myFile.Id(),theFieldId);
-}
-
-
-void TWrapper::GetFieldInfo(med_int theFieldId, TFieldInfo& theInfo){
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-  
-  med_err ret = MEDchampInfo(myFile.Id(),
-                            theFieldId,
-                            &theInfo.myName[0],
-                            &theInfo.myType,
-                            &theInfo.myCompNames[0],
-                            &theInfo.myUnitNames[0],
-                            theInfo.myNbComp);
-  if(ret < 0)
-    EXCEPTION(runtime_error,"GetFieldInfo - MEDchampInfo(...)");
-}
-
-
-void TWrapper::SetFieldInfo(const TFieldInfo& theInfo)
-{
-  TFileWrapper aFileWrapper(myFile,MED_ECRI);
-  
-  TFieldInfo& anInfo = const_cast<TFieldInfo&>(theInfo);
-  med_err ret = MEDchampCr(myFile.Id(),
-                          &anInfo.myName[0],
-                          anInfo.myType,
-                          &anInfo.myCompNames[0],
-                          &anInfo.myUnitNames[0],
-                          anInfo.myNbComp);
-  if(ret < 0)
-    EXCEPTION(runtime_error,"SetFieldInfo - MEDchampEcr(...)");
-}
-
-
-med_int TWrapper::GetNbTimeStamps(const TFieldInfo& theInfo, 
-                                 const TEntityInfo& theEntityInfo,
-                                 med_entite_maillage& theEntity,
-                                 TGeom& theGeom)
-{
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-
-  if(theEntityInfo.empty()) 
-    EXCEPTION(runtime_error,"GetNbTimeStamps - There is no any Entity on the Mesh");
-
-  theGeom.clear();
-  med_int aNbTimeStamps = 0;
-  TFieldInfo& anInfo = const_cast<TFieldInfo&>(theInfo);
-  TEntityInfo::const_iterator anIter = theEntityInfo.begin();
-  for(; anIter != theEntityInfo.end(); anIter++){
-    const med_entite_maillage& anEntity = anIter->first;
-    const TGeom& aTGeom = anIter->second;
-    TGeom::const_iterator anGeomIter = aTGeom.begin();
-    for(; anGeomIter != aTGeom.end(); anGeomIter++){
-      const med_geometrie_element& aGeom = anGeomIter->first;
-      aNbTimeStamps = MEDnPasdetemps(myFile.Id(),&anInfo.myName[0],anEntity,aGeom);
-      if(aNbTimeStamps){
-       theEntity = anEntity;
-       theGeom[aGeom] = anGeomIter->second;
-      }
-    }
-    if(aNbTimeStamps) break;
-  }
-  return aNbTimeStamps;
-}
-
-
-void TWrapper::GetTimeStampInfo(med_int theTimeStampId, TTimeStampInfo& theInfo)
-{
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-  med_idt anId = myFile.Id();
-
-  TFieldInfo& aFieldInfo = *theInfo.myFieldInfo;
-  TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo;
-
-  med_entite_maillage anEntity = theInfo.myEntity;
-  TGeom& aTGeom = theInfo.myGeom;
-  if(aTGeom.empty())
-    EXCEPTION(runtime_error,"GetTimeStampInfo - There is no any cell");
-
-  TGeom::iterator anIter = aTGeom.begin();
-  med_geometrie_element aGeom = anIter->first;
-
-  med_err ret = MEDpasdetempsInfo(anId,
-                                 &aFieldInfo.myName[0],
-                                 anEntity,
-                                 aGeom,
-                                 theTimeStampId,
-                                 &aMeshInfo.myName[0],
-                                 &theInfo.myNbGauss,
-                                 &theInfo.myNumDt,
-                                 &theInfo.myUnitDt[0],
-                                 &theInfo.myDt,
-                                 &theInfo.myNumOrd);
-  if(ret < 0)
-    EXCEPTION(runtime_error,"GetTimeStampInfo - MEDpasdetempsInfo(...)");
-
-  static med_int MAX_NB_GAUSS_POINTS = 32;
-  if(theInfo.myNbGauss > MAX_NB_GAUSS_POINTS) 
-    theInfo.myNbGauss = 1;
-}
-
-void TWrapper::SetTimeStamp(const TTimeStampVal& theVal)
-{
-  TFileWrapper aFileWrapper(myFile,MED_ECRI);
-  
-  TTimeStampVal& aVal = const_cast<TTimeStampVal&>(theVal);
-  TTimeStampInfo& aTimeStampInfo = *aVal.myTimeStampInfo;
-  TFieldInfo& aFieldInfo = *aTimeStampInfo.myFieldInfo;
-  TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo;
-  TMeshValue& aMeshValue = aVal.myMeshValue;
-  
-  med_entite_maillage anEntity = aTimeStampInfo.myEntity;
-  TMeshValue::iterator anIter = aMeshValue.begin();
-  for(; anIter != aMeshValue.end(); anIter++){
-    const med_geometrie_element& aGeom = anIter->first;
-    TValue& aValue = aVal.myMeshValue[aGeom];
-    med_int iEnd = aValue.size();
-    med_int aNbVal = iEnd / aFieldInfo.myNbComp;
-    
-    med_err ret;
-    switch(aFieldInfo.myType){
-    case MED_REEL64: {
-      valarray<med_float>& anArray = aValue;
-
-      ret = MEDchampEcr(myFile.Id(),
-                       &aMeshInfo.myName[0],
-                       &aFieldInfo.myName[0],
-                       (unsigned char*)&anArray[0],
-                       MED_FULL_INTERLACE,
-                       aNbVal,
-                       aTimeStampInfo.myNbGauss,
-                       MED_ALL,
-                       &aVal.myPflName[0],
-                       MED_ECRI, 
-                       anEntity,
-                       aGeom,
-                       aTimeStampInfo.myNumDt,
-                       &aTimeStampInfo.myUnitDt[0],
-                       aTimeStampInfo.myDt,
-                       aTimeStampInfo.myNumOrd);
-      break;
-    }
-    case MED_INT32:
-    case MED_INT: {
-      valarray<med_int> anArray(iEnd);
-      for(med_int i = 0; i< iEnd; i++) anArray[i] = med_int(aValue[i]);
-
-      ret = MEDchampEcr(myFile.Id(),
-                       &aMeshInfo.myName[0],
-                       &aFieldInfo.myName[0],
-                       (unsigned char*)&anArray[0],
-                       MED_FULL_INTERLACE,
-                       aNbVal,
-                       aTimeStampInfo.myNbGauss,
-                       MED_ALL,
-                       &aVal.myPflName[0],
-                       MED_ECRI, 
-                       anEntity,
-                       aGeom,
-                       aTimeStampInfo.myNumDt,
-                       &aTimeStampInfo.myUnitDt[0],
-                       aTimeStampInfo.myDt,
-                       aTimeStampInfo.myNumOrd);
-      break;
-    }
-    default: 
-      EXCEPTION(runtime_error,"SetTimeStamp - Type of the field == "<<aFieldInfo.myType<<" is wrong");
-    }
-    if(ret < 0)
-      EXCEPTION(runtime_error,"SetTimeStamp - MEDchampEcr(...)");
-  }
-}
-
-void TWrapper::GetTimeStampVal(TTimeStampVal& theVal)
-{
-  TFileWrapper aFileWrapper(myFile,MED_LECT);
-  med_idt anId = myFile.Id();
-
-  TTimeStampInfo& aTimeStampInfo = *theVal.myTimeStampInfo;
-  TFieldInfo& aFieldInfo = *aTimeStampInfo.myFieldInfo;
-  TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo;
-  TMeshValue& aMeshValue = theVal.myMeshValue;
-
-  med_entite_maillage anEntity = aTimeStampInfo.myEntity;
-  TGeom& aTGeom = aTimeStampInfo.myGeom;
-  TGeom::iterator anIter = aTGeom.begin();
-  for(; anIter != aTGeom.end(); anIter++){
-    const med_geometrie_element& aGeom = anIter->first;
-    med_int aNbVal = MEDnVal(anId,&aFieldInfo.myName[0],anEntity,aGeom,
-                            aTimeStampInfo.myNumDt,aTimeStampInfo.myNumOrd);
-    if(aNbVal <= 0)
-      EXCEPTION(runtime_error,"GetTimeStampInfo - MEDnVal(...) - aNbVal == "<<aNbVal<<" <= 0");
-
-    TValue& aValue = theVal.myMeshValue[aGeom];
-    med_int iEnd = aNbVal * aFieldInfo.myNbComp;
-
-    if(iEnd != aValue.size())
-      EXCEPTION(runtime_error,"GetTimeStampInfo - iEnd == "<<iEnd<<" != aValue.size() == "<<aValue.size());
-
-    med_err ret;
-    switch(aFieldInfo.myType){
-    case MED_REEL64: {
-      valarray<med_float> anArray(iEnd);
-      ret = MEDchampLire(myFile.Id(),
-                        &aMeshInfo.myName[0],
-                        &aFieldInfo.myName[0],
-                        (unsigned char*)&anArray[0],
-                        MED_FULL_INTERLACE,
-                        MED_ALL,
-                        &theVal.myPflName[0],
-                        anEntity,
-                        aGeom,
-                        aTimeStampInfo.myNumDt,
-                        aTimeStampInfo.myNumOrd);
-      if(ret >= 0) 
-       for(med_int i = 0; i < iEnd; i++) aValue[i] = anArray[i];
-      break;
-    }
-    case MED_INT32:
-    case MED_INT: {
-      valarray<med_int> anArray(iEnd);
-      ret = MEDchampLire(myFile.Id(),
-                        &aMeshInfo.myName[0],
-                        &aFieldInfo.myName[0],
-                        (unsigned char*)&anArray[0],
-                        MED_FULL_INTERLACE,
-                        MED_ALL,
-                        &theVal.myPflName[0],
-                        anEntity,
-                        aGeom,
-                        aTimeStampInfo.myNumDt,
-                        aTimeStampInfo.myNumOrd);
-      if(ret >= 0) 
-       for(med_int i = 0; i < iEnd; i++) aValue[i] = anArray[i];
-      break;
-    }
-    default:
-      EXCEPTION(runtime_error,"GetValTimeStamp - Type of the field == "<<aFieldInfo.myType<<" is wrong");
-    }
-    if(ret < 0)
-      EXCEPTION(runtime_error,"GetValTimeStamp - MEDchampLire(...)");
-  }
-}
diff --git a/src/MEDWrapper/MED_Wrapper.hxx b/src/MEDWrapper/MED_Wrapper.hxx
deleted file mode 100644 (file)
index efb5c5e..0000000
+++ /dev/null
@@ -1,125 +0,0 @@
-//  Copyright (C) 2003  CEA/DEN, EDF R&D
-//
-//
-//
-//  File   : VISU_DatConvertor.hxx
-//  Author : Alexey PETROV
-//  Module : VISU
-
-#ifndef MED_Wrapper_HeaderFile
-#define MED_Wrapper_HeaderFile
-
-extern "C"{
-#include <med.h>
-}  
-#include "MED_Structures.hxx"
-
-
-namespace MED{
-//---------------------------------------------------------------
-  class TFile{
-    TFile();
-    TFile(const TFile&);
-  public:
-    TFile(const string& theFileName);
-    ~TFile();
-    
-    void Open(med_mode_acces theMode);
-    const med_idt& Id() const;
-    void Close();
-
-  protected:
-    char* myFileName;
-    med_idt myFid;
-    int myCount;
-  };
-
-
-//---------------------------------------------------------------
-  class TFileWrapper{
-    TFile& myFile;
-  public:
-    TFileWrapper(TFile& theFile, med_mode_acces theMode): 
-      myFile(theFile)
-    {
-      myFile.Open(theMode);
-    }
-
-    ~TFileWrapper(){
-      myFile.Close();
-    }
-  };
-
-
-//---------------------------------------------------------------
-  class TWrapper{
-    TWrapper();
-    TWrapper(const TWrapper&);
-    
-  public:
-    TWrapper(const string& theFileName);
-
-
-    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    med_int GetNbMeshes();
-    
-    void GetMeshInfo(med_int theMeshId, TMeshInfo&);
-    void SetMeshInfo(const TMeshInfo& theInfo);
-    
-
-    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    med_int GetNbFamilies(const TMeshInfo& theMeshInfo);
-    med_int GetNbFamAttr(med_int theFamId, const TMeshInfo& theInfo);
-    med_int GetNbFamGroup(med_int theFamId, const TMeshInfo& theInfo);
-    
-    void GetFamilyInfo(med_int theFamId, TFamilyInfo& theInfo);
-    void SetFamilyInfo(const TFamilyInfo& theInfo);
-
-
-    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    med_int GetNbNodes(const TMeshInfo& theMeshInfo);
-    
-    void GetNodeInfo(TNodeInfo&);
-    void SetNodeInfo(const TNodeInfo&);
-    
-
-    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    TEntityInfo GetEntityInfo(const TMeshInfo& theMeshInfo);
-    
-    med_int GetNbCells(const TMeshInfo& theMeshInfo, 
-                      med_entite_maillage, 
-                      med_geometrie_element, 
-                      med_connectivite theTConn = MED_NOD);
-    
-    void GetCellInfo(TCellInfo& theInfo);
-    void SetCellInfo(const TCellInfo& theInfo);
-    
-
-    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    med_int GetNbFields();
-    
-    med_int GetNbComp(med_int theFieldId);
-    
-    void GetFieldInfo(med_int theFieldId, TFieldInfo& theInfo);
-    void SetFieldInfo(const TFieldInfo& theInfo);
-
-
-    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    med_int GetNbTimeStamps(const TFieldInfo& theInfo, 
-                           const TEntityInfo& theEntityInfo,
-                           med_entite_maillage& theEntity,
-                           TGeom& theGeom);
-
-    void GetTimeStampInfo(med_int theTimeStampId, TTimeStampInfo&);
-
-    void GetTimeStampVal(TTimeStampVal& theTimeStampVal);
-
-    void SetTimeStamp(const TTimeStampVal& theTimeStampVal);
-
-  protected:
-    TFile myFile;
-  };
-
-};
-
-#endif
index 71cbd7cbd7523727d40ef73c6467cbc7ab5d0200..c6a625e10503ceeb48bb6d6dba5e62596245cc3c 100644 (file)
@@ -1,4 +1,4 @@
-#  VISU OBJECT : interactive object for VISU entities implementation
+#  
 #
 #  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 #  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
 #
 #
 #
-#  File   : Makefile.in
-#  Module : VISU
+#  File   : 
+#  Author : 
+#  Module : 
+#  $Header$
 
 top_srcdir=@top_srcdir@
 top_builddir=../..
@@ -32,20 +34,6 @@ VPATH=.:@srcdir@:@top_srcdir@/idl
 
 @COMMENCE@
 
-EXPORT_HEADERS = MED_Common.hxx MED_Utilities.hxx MEDA_Structures.hxx MEDA_Wrapper.hxx MEDA_Algorithm.hxx
+SUBDIRS = Base V2_1 V2_2 Factory
 
-# Libraries targets
-
-LIB = libMEDWrapper.la
-LIB_SRC = MED_Structures.cxx MED_Wrapper.cxx MED_Utilities.cxx \
-         MEDA_Structures.cxx MEDA_Wrapper.cxx MEDA_Algorithm.cxx 
-
-# Executables targets
-BIN = MED_Test MEDA_Test MEDA_Test1
-BIN_SRC = 
-
-CPPFLAGS+= $(BOOST_CPPFLAGS)  $(MED2_INCLUDES)
-
-LDFLAGS+= $(MED2_LIBS) $(HDF5_LIBS)
-
-@CONCLUDE@
+@MODULE@
diff --git a/src/MEDWrapper/V2_1/MED1cstring.cxx b/src/MEDWrapper/V2_1/MED1cstring.cxx
new file mode 100644 (file)
index 0000000..0b15952
--- /dev/null
@@ -0,0 +1,61 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+
+#include <stdlib.h>
+#include "med_misc.hxx"
+
+/*
+ * - Nom de la fonction : _MED1cstring
+ * - Description : convertit une chaine de caracteres FORTRAN
+ *                 en une nouvelle chaine de caracteres C
+ *                 dont la longueur est passee en parametre.
+ *                 Les caracteres completes sont des blancs
+ * - Parametres :
+ *     - chaine (IN)          : la chaine FORTRAN
+ *     - longueur_reelle (IN) : la longueur de la chaine FORTRAN
+ *     - longueur_fixee (IN)  : longueur de la chaine C a construire
+ * - Resultat : la nouvelle chaine C en cas de succes, NULL sinon
+ */
+
+namespace med_2_1{
+
+char *
+_MED1cstring(char *chaine,int longueur_reelle,int longueur_fixee)
+{
+  char *nouvelle;
+  int i;
+
+  if (longueur_reelle > longueur_fixee)
+    return NULL;
+
+  if ((nouvelle = (char *) malloc(sizeof(char)*(longueur_fixee+1))) == NULL)
+    return NULL;
+
+  for (i=0;i<longueur_reelle;i++)
+    *(nouvelle+i) = *(chaine+i);
+
+  for (i=longueur_reelle;i<longueur_fixee;i++)
+    *(nouvelle+i) = ' ';
+  
+  *(nouvelle+longueur_fixee) = '\0';
+
+  return nouvelle;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MED2cstring.cxx b/src/MEDWrapper/V2_1/MED2cstring.cxx
new file mode 100644 (file)
index 0000000..f7b94fd
--- /dev/null
@@ -0,0 +1,62 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include <stdlib.h>
+#include "med_misc.hxx"
+
+/*
+ * - Nom de la fonction _MED2cstring
+ * - Description : convertit une chaine de caracteres FORTRAN en 
+ *                 nouvelle chaine de caracteres C
+ * - Parametres :
+ *     - chaine (IN)   : la chaine FORTRAN
+ *     - longueur (IN) : longueur de la chaine
+ * - Resultat : la nouvelle chaine C en cas de succes, NULL sinon
+ */
+
+namespace med_2_1{
+
+char *
+_MED2cstring(char *chaine, int longueur)
+{
+  char *nouvelle;
+  char *temoin;
+  int long_reelle = longueur;
+  int i;
+
+  if ( longueur < 0 ) return NULL;
+
+  temoin = chaine+longueur-1;
+  while (*temoin == ' ' && (temoin != chaine) )
+    {
+      temoin --;
+      long_reelle--;
+    }
+  if ( *temoin == ' ') long_reelle = 0;
+      
+  if ((nouvelle = (char *) malloc(sizeof(char)*(long_reelle+1))) == NULL)
+    return NULL;
+
+  for (i=0;i<long_reelle+1;i++)
+    *(nouvelle+i) = *(chaine+i);
+  *(nouvelle+long_reelle) = '\0';
+
+  return nouvelle;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDGeometrieElement.cxx b/src/MEDWrapper/V2_1/MEDGeometrieElement.cxx
new file mode 100644 (file)
index 0000000..2d277fc
--- /dev/null
@@ -0,0 +1,63 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+namespace med_2_1{
+
+med_err 
+_MEDGeometrieElement(med_geometrie_element typ_geo[],med_entite_maillage typ_ent)
+{
+  int i;
+  med_geometrie_element typ_mai[MED_NBR_GEOMETRIE_MAILLE] = {MED_POINT1,MED_SEG2, 
+                                                        MED_SEG3,MED_TRIA3,
+                                                        MED_TRIA6,MED_QUAD4,
+                                                        MED_QUAD8,MED_TETRA4,
+                                                        MED_TETRA10,MED_HEXA8,
+                                                        MED_HEXA20,MED_PENTA6,
+                                                        MED_PENTA15,MED_PYRA5,
+                                                        MED_PYRA13};
+  med_geometrie_element typ_fac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6,
+                                                      MED_QUAD4,MED_QUAD8};
+  med_geometrie_element typ_are[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3};  
+
+  switch(typ_ent)
+    {
+    case MED_MAILLE :
+      for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
+       typ_geo[i] = typ_mai[i];
+      break;
+
+    case MED_FACE :
+      for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++)
+       typ_geo[i] = typ_fac[i];
+      break;
+      
+    case MED_ARETE :
+      for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++)
+       typ_geo[i] = typ_are[i];
+      break;
+
+    default :
+      return -1;
+    }
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MED_V2_1_Wrapper.cxx b/src/MEDWrapper/V2_1/MED_V2_1_Wrapper.cxx
new file mode 100644 (file)
index 0000000..fafc867
--- /dev/null
@@ -0,0 +1,931 @@
+//  
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : 
+//  Author : 
+//  Module : 
+//  $Header$
+
+#include "MED_V2_1_Wrapper.hxx"
+#include "MED_Utilities.hxx"
+
+#include "med.hxx"
+using namespace med_2_1;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+#else
+static int MYDEBUG = 0;
+#endif
+
+
+
+namespace MED{
+  namespace V2_1{
+
+    //---------------------------------------------------------------
+    class TFile{
+      TFile();
+      TFile(const TFile&);
+      
+    public:
+      TFile(const std::string& theFileName): 
+       myFid(-1), 
+       myCount(0),
+       myFileName(theFileName)
+      {}
+      
+      ~TFile(){ 
+       Close();
+      }
+      
+      void Open(EModeAcces theMode, TErr* theErr = NULL){
+       if(myCount++ == 0){
+         char* aFileName = const_cast<char*>(myFileName.c_str());
+         myFid = MEDouvrir(aFileName,med_mode_acces(theMode));
+       }
+       if(theErr){
+         *theErr = TErr(myFid);
+         INITMSG(MYDEBUG && myFid < 0,"TFile::Open - MED_MODE_ACCES = "<<theMode<<"; myFid = "<<myFid<<endl);
+       }else if(myFid < 0)
+         EXCEPTION(runtime_error,"TFile - MEDouvrir('"<<myFileName<<"',"<<theMode<<")");
+      }
+
+      const TIdt& Id() const { 
+       if(myFid < 0)
+         EXCEPTION(runtime_error,"TFile - GetFid() < 0");
+       return myFid;
+      }
+
+      void Close(){ 
+       if(--myCount == 0)
+         MEDfermer(myFid);
+      }
+
+    protected:
+      std::string myFileName;
+      TInt myCount;
+      TIdt myFid;
+    };
+
+
+    //---------------------------------------------------------------
+    class TFileWrapper{
+      PFile myFile;
+
+    public:
+      TFileWrapper(const PFile& theFile, EModeAcces theMode, TErr* theErr = NULL): 
+       myFile(theFile)
+      {
+       myFile->Open(theMode,theErr);
+      }
+      
+      ~TFileWrapper(){
+       myFile->Close();
+      }
+    };
+
+
+    //---------------------------------------------------------------
+    TVWrapper::TVWrapper(const std::string& theFileName): 
+      myFile(new TFile(theFileName))
+    {}
+    
+    
+    TInt TVWrapper::GetNbMeshes(TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+      
+      if(theErr && *theErr < 0)
+       return -1;
+      
+      return MEDnMaa(myFile->Id());
+    }
+    
+    
+    void TVWrapper::GetMeshInfo(TInt theMeshId, 
+                              MED::TMeshInfo& theInfo,
+                              TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+      
+      if(theErr && *theErr < 0)
+       return;
+      
+      TErr aRet = MEDmaaInfo(myFile->Id(),
+                            theMeshId,
+                            &theInfo.myName[0],
+                            &theInfo.myDim);
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"GetMeshInfo - MEDmaaInfo(...)");
+    }
+    
+    
+    void TVWrapper::SetMeshInfo(const MED::TMeshInfo& theInfo,
+                              EModeAcces theMode,
+                              TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,theMode,theErr);
+      
+      if(theErr && *theErr < 0)
+       return;
+      
+      MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
+      
+      TErr aRet = MEDmaaCr(myFile->Id(),
+                          &anInfo.myName[0],
+                          anInfo.myDim);
+      
+      INITMSG(MYDEBUG,"TVWrapper::SetMeshInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<endl);
+      
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"SetMeshInfo - MEDmaaCr(...)");
+    }
+    
+    
+    void TVWrapper::SetMeshInfo(const MED::TMeshInfo& theInfo,
+                              TErr* theErr)
+    {
+      TErr aRet;
+      SetMeshInfo(theInfo,eECRI,&aRet);
+      
+      if(aRet < 0)
+       SetMeshInfo(theInfo,eREMP,theErr);
+    }
+    
+    
+    TInt TVWrapper::GetNbFamilies(const MED::TMeshInfo& theInfo,
+                                TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+      
+      if(theErr && *theErr < 0)
+       return -1;
+      
+      MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
+      return MEDnFam(myFile->Id(),
+                    &anInfo.myName[0],
+                    0,
+                    MED_FAMILLE);
+    }
+    
+    
+    TInt TVWrapper::GetNbFamAttr(TInt theFamId, 
+                               const MED::TMeshInfo& theInfo,
+                               TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+      
+      if(theErr && *theErr < 0)
+       return -1;
+      
+      MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
+      return MEDnFam(myFile->Id(),
+                    &anInfo.myName[0],
+                    theFamId,
+                    MED_ATTR);
+    }
+    
+    
+    TInt TVWrapper::GetNbFamGroup(TInt theFamId, 
+                                const MED::TMeshInfo& theInfo,
+                                TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+      
+      if(theErr && *theErr < 0)
+       return -1;
+      
+      MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
+      return MEDnFam(myFile->Id(),
+                    &anInfo.myName[0],
+                    theFamId,
+                    MED_GROUPE);
+    }
+    
+    
+    void TVWrapper::GetFamilyInfo(TInt theFamId, 
+                                MED::TFamilyInfo& theInfo,
+                                TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+      
+      if(theErr && *theErr < 0)
+       return;
+      
+      MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
+      
+      TErr aRet = MEDfamInfo(myFile->Id(),
+                            &aMeshInfo.myName[0],
+                            theFamId,
+                            &theInfo.myName[0],
+                            &theInfo.myId,
+                            &theInfo.myAttrId[0],
+                            &theInfo.myAttrVal[0],
+                            &theInfo.myAttrDesc[0],
+                            &theInfo.myNbAttr,
+                            &theInfo.myGroupNames[0],
+                            &theInfo.myNbGroup);
+      
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"GetFamilyInfo - MEDfamInfo - "<<
+                 "&aMeshInfo.myName[0] = '"<<&aMeshInfo.myName[0]<<"'; "<<
+                 "theFamId = "<<theFamId<<"; "<<
+                 "&theInfo.myName[0] = '"<<&theInfo.myName[0]<<"'; "<<
+                 "theInfo.myId = "<<theInfo.myId);
+    }
+    
+    
+    void TVWrapper::SetFamilyInfo(const MED::TFamilyInfo& theInfo,
+                                EModeAcces theMode,
+                                TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,theMode,theErr);
+      
+      if(theErr && *theErr < 0)
+       return;
+      
+      MED::TFamilyInfo& anInfo = const_cast<MED::TFamilyInfo&>(theInfo);
+      MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
+      
+      TErr aRet = MEDfamCr(myFile->Id(),
+                          &aMeshInfo.myName[0],
+                          &anInfo.myName[0],
+                          anInfo.myId,
+                          &anInfo.myAttrId[0],
+                          &anInfo.myAttrVal[0],
+                          &anInfo.myAttrDesc[0],
+                          anInfo.myNbAttr,
+                          &anInfo.myGroupNames[0],
+                          anInfo.myNbGroup);
+      
+      INITMSG(MYDEBUG && aRet,"TVWrapper::SetFamilyInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<endl);
+      
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"SetFamilyInfo - MEDfamCr(...)");
+    }
+    
+    
+    void TVWrapper::SetFamilyInfo(const MED::TFamilyInfo& theInfo,
+                                TErr* theErr)
+    {
+      TErr aRet;
+      SetFamilyInfo(theInfo,eECRI,&aRet);
+      
+      if(aRet < 0)
+       SetFamilyInfo(theInfo,eREMP,theErr);
+    }
+    
+    
+    TInt TVWrapper::GetNbNodes(const MED::TMeshInfo& theMeshInfo,
+                             TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+      
+      if(theErr && *theErr < 0)
+       return -1;
+      
+      MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
+      
+      return MEDnEntMaa(myFile->Id(),
+                       &aMeshInfo.myName[0],
+                       MED_COOR,
+                       MED_NOEUD,
+                       med_geometrie_element(0),
+                       med_connectivite(0));
+    }
+    
+    
+    void TVWrapper::GetNodeInfo(MED::TNodeInfo& theInfo,
+                              TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+      
+      if(theErr && *theErr < 0)
+       return;
+      
+      MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
+
+      med_repere& aRepere = static_cast<med_repere>(theInfo.mySystem);
+      med_booleen& anIsElemNames = static_cast<med_booleen>(theInfo.myIsElemNames);
+      med_booleen& anIsElemNum = static_cast<med_booleen>(theInfo.myIsElemNum);
+
+      TErr aRet = MEDnoeudsLire(myFile->Id(),
+                               &aMeshInfo.myName[0],
+                               aMeshInfo.myDim,
+                               &theInfo.myCoord[0],
+                               MED_FULL_INTERLACE,
+                               &aRepere,
+                               &theInfo.myCoordNames[0],
+                               &theInfo.myCoordUnits[0],
+                               &theInfo.myElemNames[0],
+                               &anIsElemNames,
+                               &theInfo.myElemNum[0],
+                               &anIsElemNum,
+                               &theInfo.myFamNum[0],
+                               theInfo.myNbElem);
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"GetNodeInfo - MEDnoeudsLire(...)");
+    }
+    
+    
+    void TVWrapper::SetNodeInfo(const MED::TNodeInfo& theInfo,
+                              EModeAcces theMode,
+                              TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,theMode,theErr);
+      
+      if(theErr && *theErr < 0)
+       return;
+      
+      MED::TNodeInfo& anInfo = const_cast<MED::TNodeInfo&>(theInfo);
+      MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
+      
+      med_repere& aRepere = static_cast<med_repere>(theInfo.mySystem);
+      med_booleen& anIsElemNames = static_cast<med_booleen>(theInfo.myIsElemNames);
+      med_booleen& anIsElemNum = static_cast<med_booleen>(theInfo.myIsElemNum);
+
+      TErr aRet = MEDnoeudsEcr(myFile->Id(),
+                              &aMeshInfo.myName[0],
+                              aMeshInfo.myDim,
+                              &anInfo.myCoord[0],
+                              MED_FULL_INTERLACE,
+                              aRepere,
+                              &anInfo.myCoordNames[0],
+                              &anInfo.myCoordUnits[0],
+                              &anInfo.myElemNames[0],
+                              anIsElemNames,
+                              &anInfo.myElemNum[0],
+                              anIsElemNum,
+                              &anInfo.myFamNum[0],
+                              anInfo.myNbElem,
+                              MED_REMP);
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"SetNodeInfo - MEDnoeudsEcr(...)");
+    }
+    
+    
+    void TVWrapper::SetNodeInfo(const MED::TNodeInfo& theInfo,
+                              TErr* theErr)
+    {
+      TErr aRet;
+      SetNodeInfo(theInfo,eECRI,&aRet);
+      
+      if(aRet < 0)
+       SetNodeInfo(theInfo,eREMP,theErr);
+    }
+    
+    
+    TEntityInfo TVWrapper::GetEntityInfo(const MED::TMeshInfo& theMeshInfo,
+                                       EConnectivite theTConn,
+                                       TErr* theErr)
+    {
+      TEntityInfo anInfo;
+      
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+      
+      if(theErr && *theErr < 0)
+       return anInfo;
+      
+      if(TInt aNbElem = GetNbNodes(theMeshInfo)){
+       anInfo[eNOEUD][ePOINT1] = aNbElem;
+       const TEntity2GeomSet& anEntity2GeomSet = GetEntity2GeomSet();
+       TEntity2GeomSet::const_iterator anIter = anEntity2GeomSet.begin();
+       TEntity2GeomSet::const_iterator anIterEnd = anEntity2GeomSet.end();
+       for(; anIter != anIterEnd; anIter++){
+         const EEntiteMaillage& anEntity = anIter->first;
+         const TGeomSet& aGeomSet = anIter->second;
+         TGeomSet::const_iterator anIter2 = aGeomSet.begin();
+         TGeomSet::const_iterator anIterEnd2 = aGeomSet.end();
+         for(; anIter2 != anIterEnd2; anIter2++){
+           const EGeometrieElement& aGeom = *anIter2;
+           if(TInt aNb = GetNbCells(theMeshInfo,anEntity,aGeom,theTConn,theErr)){
+             anInfo[anEntity][aGeom] = aNb;
+           }
+         }
+       }
+      }
+      return anInfo;
+    }
+    
+    
+    TInt TVWrapper::GetNbCells(const MED::TMeshInfo& theMeshInfo, 
+                             EEntiteMaillage theTEntity, 
+                             EGeometrieElement theTGeom, 
+                             EConnectivite theTConn,
+                             TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+      
+      if(theErr && *theErr < 0)
+       return -1;
+      
+      MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
+      
+      med_entite_maillage& anEntity = static_cast<med_entite_maillage>(theTEntity);
+      med_geometrie_element& aGeom = static_cast<med_geometrie_element>(theTGeom);
+      med_connectivite& aConn = static_cast<med_connectivite>(theTConn);
+
+      return MEDnEntMaa(myFile->Id(),
+                       &aMeshInfo.myName[0],
+                       MED_CONN,
+                       anEntity,
+                       aGeom,
+                       aConn); 
+    }
+    
+    
+    void TVWrapper::GetCellInfo(MED::TCellInfo& theInfo,
+                              TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+
+      if(theErr && *theErr < 0)
+       return;
+      
+      MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
+      TInt aNbElem = theInfo.myElemNum.size();
+
+      med_booleen& anIsElemNames = static_cast<med_booleen>(theInfo.myIsElemNames);
+      med_booleen& anIsElemNum = static_cast<med_booleen>(theInfo.myIsElemNum);
+      med_entite_maillage& anEntity = static_cast<med_entite_maillage>(theInfo.myTEntity);
+      med_geometrie_element& aGeom = static_cast<med_geometrie_element>(theInfo.myTGeom);
+      med_connectivite& aConn = static_cast<med_connectivite>(theInfo.myTConn);
+
+      TErr aRet = MEDelementsLire(myFile->Id(),
+                                 &aMeshInfo.myName[0],
+                                 aMeshInfo.myDim,
+                                 &theInfo.myConn[0],
+                                 MED_FULL_INTERLACE,
+                                 &theInfo.myElemNames[0],
+                                 &anIsElemNames,
+                                 &theInfo.myElemNum[0],
+                                 &anIsElemNum,
+                                 &theInfo.myFamNum[0],
+                                 aNbElem,
+                                 anEntity,
+                                 aGeom,
+                                 aConn);
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"GetCellInfo - MEDelementsLire(...)");
+    }
+    
+    
+    void TVWrapper::SetCellInfo(const MED::TCellInfo& theInfo,
+                              EModeAcces theMode,
+                              TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,theMode,theErr);
+      
+      if(theErr && *theErr < 0)
+       return;
+
+      MED::TCellInfo& anInfo = const_cast<MED::TCellInfo&>(theInfo);
+      MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
+
+      med_booleen& anIsElemNames = static_cast<med_booleen>(theInfo.myIsElemNames);
+      med_booleen& anIsElemNum = static_cast<med_booleen>(theInfo.myIsElemNum);
+      med_entite_maillage& anEntity = static_cast<med_entite_maillage>(theInfo.myTEntity);
+      med_geometrie_element& aGeom = static_cast<med_geometrie_element>(theInfo.myTGeom);
+      med_connectivite& aConn = static_cast<med_connectivite>(theInfo.myTConn);
+
+      TErr aRet = MEDelementsEcr(myFile->Id(),
+                                &aMeshInfo.myName[0],
+                                aMeshInfo.myDim,
+                                &anInfo.myConn[0],
+                                MED_FULL_INTERLACE,
+                                &anInfo.myElemNames[0],
+                                anIsElemNames,
+                                &anInfo.myElemNum[0],
+                                anIsElemNum,
+                                &anInfo.myFamNum[0],
+                                anInfo.myNbElem,
+                                anEntity,
+                                aGeom,
+                                aConn,
+                                MED_REMP);
+      
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"GetCellInfo - MEDelementsLire(...)");
+    }
+    
+
+    void TVWrapper::SetCellInfo(const MED::TCellInfo& theInfo,
+                              TErr* theErr)
+    {
+      TErr aRet;
+      SetCellInfo(theInfo,eECRI,&aRet);
+      
+      if(aRet < 0)
+       SetCellInfo(theInfo,eREMP,theErr);
+    }
+    
+
+    TInt TVWrapper::GetNbFields(TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+      
+      if(theErr && *theErr < 0)
+       return -1;
+      
+      return MEDnChamp(myFile->Id(),0);
+    }
+    
+    
+    TInt TVWrapper::GetNbComp(TInt theFieldId,
+                            TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+      
+      if(theErr && *theErr < 0)
+       return -1;
+      
+      return MEDnChamp(myFile->Id(),theFieldId);
+    }
+    
+    
+    void TVWrapper::GetFieldInfo(TInt theFieldId, 
+                               MED::TFieldInfo& theInfo,
+                               TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+      
+      if(theErr && *theErr < 0)
+       return;
+      
+      med_type_champ& aType = static_cast<med_type_champ>(theInfo.myType);
+
+      TErr aRet = MEDchampInfo(myFile->Id(),
+                              theFieldId,
+                              &theInfo.myName[0],
+                              &aType,
+                              &theInfo.myCompNames[0],
+                              &theInfo.myUnitNames[0],
+                              theInfo.myNbComp);
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"GetFieldInfo - MEDchampInfo(...)");
+    }
+    
+    
+    void TVWrapper::SetFieldInfo(const MED::TFieldInfo& theInfo,
+                               EModeAcces theMode,
+                               TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,theMode,theErr);
+      
+      if(theErr && *theErr < 0)
+       return;
+      
+      MED::TFieldInfo& anInfo = const_cast<MED::TFieldInfo&>(theInfo);
+      
+      med_type_champ& aType = static_cast<med_type_champ>(theInfo.myType);
+      
+      TErr aRet = MEDchampCr(myFile->Id(),
+                            &anInfo.myName[0],
+                            aType,
+                            &anInfo.myCompNames[0],
+                            &anInfo.myUnitNames[0],
+                            anInfo.myNbComp);
+
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"SetFieldInfo - MEDchampCr(...)");
+    }
+    
+    
+    void TVWrapper::SetFieldInfo(const MED::TFieldInfo& theInfo,
+                               TErr* theErr)
+    {
+      try{
+
+       TErr aRet;
+       SetFieldInfo(theInfo,eECRI,&aRet);
+      
+       if(aRet < 0)
+         SetFieldInfo(theInfo,eREMP,theErr);
+
+      }catch(const std::exception& theExc){
+       EXCEPTION(runtime_error,"SetFieldInfo(...)"<<endl<<
+                 theExc.what());
+      }catch(...){
+       throw;
+      }
+    }
+    
+    
+    TInt TVWrapper::GetNbTimeStamps(const MED::TFieldInfo& theInfo, 
+                                  const MED::TEntityInfo& theEntityInfo,
+                                  EEntiteMaillage& theEntity,
+                                  TGeom& theGeom,
+                                  TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+      
+      if(theErr){
+       *theErr &= !theEntityInfo.empty();
+       if(!*theErr)
+         return -1;
+      }
+      
+      if(theEntityInfo.empty()) 
+       EXCEPTION(runtime_error,"GetNbTimeStamps - There is no any Entity on the Mesh");
+      
+      theGeom.clear();
+      TInt aNbTimeStamps = 0;
+      MED::TFieldInfo& anInfo = const_cast<MED::TFieldInfo&>(theInfo);
+      TEntityInfo::const_iterator anIter = theEntityInfo.begin();
+      for(; anIter != theEntityInfo.end(); anIter++){
+       const med_entite_maillage& anEntity = static_cast<const med_entite_maillage>(anIter->first);
+       const TGeom& aTGeom = anIter->second;
+       TGeom::const_iterator anGeomIter = aTGeom.begin();
+       for(; anGeomIter != aTGeom.end(); anGeomIter++){
+         const med_geometrie_element& aGeom = static_cast<const med_geometrie_element>(anGeomIter->first);
+         aNbTimeStamps = MEDnPasdetemps(myFile->Id(),&anInfo.myName[0],anEntity,aGeom);
+         if(aNbTimeStamps){
+           theEntity = EEntiteMaillage(anEntity);
+           theGeom[EGeometrieElement(aGeom)] = anGeomIter->second;
+         }
+       }
+       if(aNbTimeStamps) 
+         break;
+      }
+      return aNbTimeStamps;
+    }
+    
+    
+    void TVWrapper::GetTimeStampInfo(TInt theTimeStampId, 
+                                   MED::TTimeStampInfo& theInfo,
+                                   TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+      
+      TGeom& aTGeom = theInfo.myGeom;
+      
+      if(theErr){
+       *theErr &= !aTGeom.empty();
+       if(!*theErr)
+         return;
+      }
+      
+      if(aTGeom.empty())
+       EXCEPTION(runtime_error,"GetTimeStampInfo - There is no any cell");
+      
+      MED::TFieldInfo& aFieldInfo = *theInfo.myFieldInfo;
+      MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo;
+      
+      med_entite_maillage& anEntity = static_cast<med_entite_maillage>(theInfo.myEntity);
+      
+      TGeom::iterator anIter = aTGeom.begin();
+      med_geometrie_element& aGeom = static_cast<med_geometrie_element>(anIter->first);
+      
+      TErr aRet = MEDpasdetempsInfo(myFile->Id(),
+                                   &aFieldInfo.myName[0],
+                                   anEntity,
+                                   aGeom,
+                                   theTimeStampId,
+                                   &aMeshInfo.myName[0],
+                                   &theInfo.myNbGauss,
+                                   &theInfo.myNumDt,
+                                   &theInfo.myUnitDt[0],
+                                   &theInfo.myDt,
+                                   &theInfo.myNumOrd);
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"GetTimeStampInfo - MEDpasdetempsInfo(...)");
+      
+      static TInt MAX_NB_GAUSS_POINTS = 32;
+      if(theInfo.myNbGauss > MAX_NB_GAUSS_POINTS) 
+       theInfo.myNbGauss = 1;
+    }
+    
+
+    void TVWrapper::GetTimeStampVal(MED::TTimeStampVal& theVal,
+                                  TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECT,theErr);
+      
+      if(theErr && *theErr < 0)
+       return;
+      
+      TIdt anId = myFile->Id();
+      
+      MED::TTimeStampInfo& aTimeStampInfo = *theVal.myTimeStampInfo;
+      MED::TFieldInfo& aFieldInfo = *aTimeStampInfo.myFieldInfo;
+      MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo;
+      
+      med_entite_maillage& anEntity = static_cast<med_entite_maillage>(aTimeStampInfo.myEntity);
+      TGeom& aTGeom = aTimeStampInfo.myGeom;
+      TGeom::iterator anIter = aTGeom.begin();
+      for(; anIter != aTGeom.end(); anIter++){
+       med_geometrie_element& aGeom = static_cast<med_geometrie_element>(anIter->first);
+       TInt aNbVal = MEDnVal(anId,
+                             &aFieldInfo.myName[0],
+                             anEntity,
+                             aGeom,
+                             aTimeStampInfo.myNumDt,
+                             aTimeStampInfo.myNumOrd);
+       if(aNbVal <= 0){
+         if(theErr){
+           *theErr = -1;
+           return;
+         }
+         EXCEPTION(runtime_error,"GetTimeStampInfo - MEDnVal(...) - aNbVal == "<<aNbVal<<" <= 0");
+       }
+       
+       TValue& aValue = theVal.myMeshValue[EGeometrieElement(aGeom)];
+       TInt iEnd = aNbVal*aFieldInfo.myNbComp;
+       
+       if(iEnd != aValue.size()){
+         if(theErr){
+           *theErr = -1;
+           return;
+         }
+         EXCEPTION(runtime_error,"GetTimeStampInfo - iEnd == "<<iEnd<<" != aValue.size() == "<<aValue.size());
+       }
+       
+       TErr aRet;
+       switch(aFieldInfo.myType){
+       case eFLOAT64: {
+         std::vector<TFloat> anArray(iEnd);
+         aRet = MEDchampLire(anId,
+                             &aMeshInfo.myName[0],
+                             &aFieldInfo.myName[0],
+                             (unsigned char*)&anArray[0],
+                             MED_FULL_INTERLACE,
+                             MED_ALL,
+                             &theVal.myPflName[0],
+                             anEntity,
+                             aGeom,
+                             aTimeStampInfo.myNumDt,
+                             aTimeStampInfo.myNumOrd);
+         if(aRet >= 0) 
+           for(TInt i = 0; i < iEnd; i++) 
+             aValue[i] = anArray[i];
+         break;
+       }
+       default: {
+         std::vector<TInt> anArray(iEnd);
+         aRet = MEDchampLire(anId,
+                             &aMeshInfo.myName[0],
+                             &aFieldInfo.myName[0],
+                             (unsigned char*)&anArray[0],
+                             MED_FULL_INTERLACE,
+                             MED_ALL,
+                             &theVal.myPflName[0],
+                             anEntity,
+                             aGeom,
+                             aTimeStampInfo.myNumDt,
+                             aTimeStampInfo.myNumOrd);
+         if(aRet >= 0) 
+           for(med_int i = 0; i < iEnd; i++) 
+             aValue[i] = anArray[i];
+         break;
+       }}
+       if(aRet < 0){
+         if(theErr){
+           *theErr = aRet;
+           return;
+         }
+         EXCEPTION(runtime_error,"GetValTimeStamp - MEDchampLire(...)");
+       }
+      }
+    }
+    
+    
+    void TVWrapper::SetTimeStamp(const MED::TTimeStampVal& theVal,
+                               EModeAcces theMode,
+                               TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,theMode,theErr);
+      
+      if(theErr && *theErr < 0)
+       return;
+      
+      TErr aRet;
+      TIdt anId = myFile->Id();
+      
+      MED::TTimeStampVal& aVal = const_cast<MED::TTimeStampVal&>(theVal);
+      MED::TTimeStampInfo& aTimeStampInfo = *aVal.myTimeStampInfo;
+      MED::TFieldInfo& aFieldInfo = *aTimeStampInfo.myFieldInfo;
+      MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo;
+      MED::TMeshValue& aMeshValue = aVal.myMeshValue;
+      
+      med_entite_maillage& anEntity = static_cast<med_entite_maillage>(aTimeStampInfo.myEntity);
+      TMeshValue::iterator anIter = aMeshValue.begin();
+      for(; anIter != aMeshValue.end(); anIter++){
+       med_geometrie_element& aGeom = static_cast<med_geometrie_element>(anIter->first);
+       TValue& aValue = aVal.myMeshValue[EGeometrieElement(aGeom)];
+       med_int iEnd = aValue.size();
+       med_int aNbVal = iEnd / aFieldInfo.myNbComp;
+       
+       switch(aFieldInfo.myType){
+       case eFLOAT64: {
+         std::vector<TFloat>& anArray = aValue;
+         
+         aRet = MEDchampEcr(anId,
+                            &aMeshInfo.myName[0],
+                            &aFieldInfo.myName[0],
+                            (unsigned char*)&anArray[0],
+                            MED_FULL_INTERLACE,
+                            aNbVal,
+                            aTimeStampInfo.myNbGauss,
+                            MED_ALL,
+                            &aVal.myPflName[0],
+                            MED_ECRI, 
+                            anEntity,
+                            aGeom,
+                            aTimeStampInfo.myNumDt,
+                            &aTimeStampInfo.myUnitDt[0],
+                            aTimeStampInfo.myDt,
+                            aTimeStampInfo.myNumOrd);
+         break;
+       }
+       default: {
+         vector<TInt> anArray(iEnd);
+         for(TInt i = 0; i< iEnd; i++) anArray[i] = TInt(aValue[i]);
+         
+         aRet = MEDchampEcr(anId,
+                            &aMeshInfo.myName[0],
+                            &aFieldInfo.myName[0],
+                            (unsigned char*)&anArray[0],
+                            MED_FULL_INTERLACE,
+                            aNbVal,
+                            aTimeStampInfo.myNbGauss,
+                            MED_ALL,
+                            &aVal.myPflName[0],
+                            MED_ECRI, 
+                            anEntity,
+                            aGeom,
+                            aTimeStampInfo.myNumDt,
+                            &aTimeStampInfo.myUnitDt[0],
+                            aTimeStampInfo.myDt,
+                            aTimeStampInfo.myNumOrd);
+         break;
+       }}
+       
+       if(aRet < 0){
+         if(theErr){
+           *theErr = aRet;
+           break;
+         }
+         EXCEPTION(runtime_error,"SetTimeStamp - MEDchampEcr(...)");
+       }
+       
+      }
+      
+      INITMSG(MYDEBUG,"TVWrapper::SetMeshInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<endl);
+    }
+
+    
+    void TVWrapper::SetTimeStamp(const MED::TTimeStampVal& theVal,
+                               TErr* theErr)
+    {
+      TErr aRet;
+      SetTimeStamp(theVal,eECRI,&aRet);
+      
+      if(aRet < 0)
+       SetTimeStamp(theVal,eREMP,theErr);
+    }
+    
+  }
+}
diff --git a/src/MEDWrapper/V2_1/MED_V2_1_Wrapper.hxx b/src/MEDWrapper/V2_1/MED_V2_1_Wrapper.hxx
new file mode 100644 (file)
index 0000000..7314d38
--- /dev/null
@@ -0,0 +1,187 @@
+//  
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : 
+//  Author : 
+//  Module : 
+//  $Header$
+
+#ifndef MED_V2_1_Wrapper_HeaderFile
+#define MED_V2_1_Wrapper_HeaderFile
+
+#include "MED_TWrapper.hxx"
+
+namespace MED{
+  namespace V2_1{
+
+    const TInt PNOM = 8;
+
+    typedef MED::TTMeshInfo<PNOM,DESC,IDENT,NOM,LNOM> TVMeshInfo;
+
+    typedef MED::TTFamilyInfo<PNOM,DESC,IDENT,NOM,LNOM> TVFamilyInfo;
+
+    typedef MED::TTNodeInfo<PNOM,DESC,IDENT,NOM,LNOM> TVNodeInfo;
+
+    typedef MED::TTCellInfo<PNOM,DESC,IDENT,NOM,LNOM> TVCellInfo;
+
+    typedef MED::TTFieldInfo<PNOM,DESC,IDENT,NOM,LNOM> TVFieldInfo;
+
+    typedef MED::TTTimeStampInfo<PNOM,DESC,IDENT,NOM,LNOM> TVTimeStampInfo;
+
+    typedef MED::TTTimeStampVal<PNOM,DESC,IDENT,NOM,LNOM> TVTimeStampVal;
+
+    //---------------------------------------------------------------
+    class TFile;
+    typedef boost::shared_ptr<TFile> PFile;
+    
+    typedef enum {eLECT, eECRI, eREMP} EModeAcces; 
+
+    //---------------------------------------------------------------
+    class TVWrapper: public MED::TTWrapper<PNOM,DESC,IDENT,NOM,LNOM>{
+      TVWrapper();
+      TVWrapper(const TVWrapper&);
+      TVWrapper& operator=(const TVWrapper&);
+      
+    public:
+      TVWrapper(const std::string& theFileName);
+
+
+      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      virtual TInt GetNbMeshes(TErr* theErr = NULL);
+      
+      virtual void GetMeshInfo(TInt theMeshId, MED::TMeshInfo&,
+                              TErr* theErr = NULL);
+
+      virtual void SetMeshInfo(const MED::TMeshInfo& theInfo,
+                              TErr* theErr = NULL);
+      
+      void SetMeshInfo(const MED::TMeshInfo& theInfo,
+                      EModeAcces theMode,
+                      TErr* theErr = NULL);
+
+      
+      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      virtual TInt GetNbFamilies(const MED::TMeshInfo& theMeshInfo,
+                                TErr* theErr = NULL);
+      virtual TInt GetNbFamAttr(TInt theFamId, 
+                               const MED::TMeshInfo& theInfo,
+                               TErr* theErr = NULL);
+      virtual TInt GetNbFamGroup(TInt theFamId, 
+                                const MED::TMeshInfo& theInfo,
+                                TErr* theErr = NULL);
+      
+      virtual void GetFamilyInfo(TInt theFamId, 
+                                MED::TFamilyInfo& theInfo,
+                                TErr* theErr = NULL);
+
+      virtual void SetFamilyInfo(const MED::TFamilyInfo& theInfo,
+                                TErr* theErr = NULL);
+      
+      void SetFamilyInfo(const MED::TFamilyInfo& theInfo,
+                        EModeAcces theMode,
+                        TErr* theErr = NULL);
+
+      
+      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      virtual TInt GetNbNodes(const MED::TMeshInfo& theMeshInfo,
+                             TErr* theErr = NULL);
+      
+      virtual void GetNodeInfo(MED::TNodeInfo& theInfo,
+                              TErr* theErr = NULL);
+
+      virtual void SetNodeInfo(const MED::TNodeInfo& theInfo,
+                              TErr* theErr = NULL);
+      
+      void SetNodeInfo(const MED::TNodeInfo& theInfo,
+                      EModeAcces theMode,
+                      TErr* theErr = NULL);
+
+      
+      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      virtual TEntityInfo GetEntityInfo(const MED::TMeshInfo& theMeshInfo,
+                                       EConnectivite theTConn = eNOD,
+                                       TErr* theErr = NULL);
+      
+      virtual TInt GetNbCells(const MED::TMeshInfo& theMeshInfo, 
+                             EEntiteMaillage, 
+                             EGeometrieElement, 
+                             EConnectivite theTConn = eNOD,
+                             TErr* theErr = NULL);
+      
+      virtual void GetCellInfo(MED::TCellInfo& theInfo,
+                              TErr* theErr = NULL);
+
+      virtual void SetCellInfo(const MED::TCellInfo& theInfo,
+                              TErr* theErr = NULL);
+      
+      void SetCellInfo(const MED::TCellInfo& theInfo,
+                      EModeAcces theMode,
+                      TErr* theErr = NULL);
+
+      
+      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      virtual TInt GetNbFields(TErr* theErr = NULL);
+      
+      virtual TInt GetNbComp(TInt theFieldId,
+                            TErr* theErr = NULL);
+      
+      virtual void GetFieldInfo(TInt theFieldId, 
+                               MED::TFieldInfo& theInfo,
+                               TErr* theErr = NULL);
+
+      virtual void SetFieldInfo(const MED::TFieldInfo& theInfo,
+                               TErr* theErr = NULL);
+      
+      void SetFieldInfo(const MED::TFieldInfo& theInfo,
+                       EModeAcces theMode,
+                       TErr* theErr = NULL);
+
+      
+      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      virtual TInt GetNbTimeStamps(const MED::TFieldInfo& theInfo, 
+                                  const MED::TEntityInfo& theEntityInfo,
+                                  EEntiteMaillage& theEntity,
+                                  TGeom& theGeom,
+                                  TErr* theErr = NULL);
+      
+      virtual void GetTimeStampInfo(TInt theTimeStampId, 
+                                   MED::TTimeStampInfo& theInfo,
+                                   TErr* theErr = NULL);
+
+      virtual void GetTimeStampVal(MED::TTimeStampVal& theVal,
+                                  TErr* theErr = NULL);
+      
+      virtual void SetTimeStamp(const MED::TTimeStampVal& theTimeStampVal,
+                               TErr* theErr = NULL);
+      
+      void SetTimeStamp(const MED::TTimeStampVal& theTimeStampVal,
+                       EModeAcces theMode,
+                       TErr* theErr = NULL);
+
+    protected:
+      PFile myFile;
+    };
+  }
+}
+
+#endif
diff --git a/src/MEDWrapper/V2_1/MEDattrFermer.cxx b/src/MEDWrapper/V2_1/MEDattrFermer.cxx
new file mode 100644 (file)
index 0000000..6a7b708
--- /dev/null
@@ -0,0 +1,44 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDattrFermer
+ * - Description : fermeture de l'acces a l'attribut dont l'ID est passe en 
+ *                 parametre
+ * - Parametres :
+ *     - pid (IN)  : l'ID de l'objet HDF pere ou placer l'attribut
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDattrFermer(med_idt id)
+{
+  med_err ret;
+
+  if ((ret = H5Aclose(id)) < 0)
+    return -1;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDattrNumEcrire.cxx b/src/MEDWrapper/V2_1/MEDattrNumEcrire.cxx
new file mode 100644 (file)
index 0000000..51ae76e
--- /dev/null
@@ -0,0 +1,107 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDattrNumEcrire
+ * - Description : ecriture d'un attribut entier
+ * - Parametres :
+ *     - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut
+ *     - type (IN) : le type du champ {MED_REEL64,MED_INT}
+ *     - nom  (IN) : le nom de l'attribut
+ *     - val  (IN) : la valeur de l'attribut
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */
+
+namespace med_2_1{
+
+med_err 
+_MEDattrNumEcrire(med_idt pere,med_type_champ type,char *nom,unsigned char *val, 
+                 med_mode_acces mode)
+{
+  med_idt aid,attr;
+  med_err ret;
+  int type_hdf;
+
+  switch(type)
+    {
+    case MED_REEL64 :
+      /* 1) IA32 is LE but due to an (?HDF convertion BUG?) when using H5T_NATIVE_DOUBLE/MED_REEL64? under PCLINUX
+        the file read under SGI is incorrect
+        2) Compaq OSF/1 is LE, since we force SGI64,SUN4SOL2,HP to write double in LE even if they are BE, mips OSF/1 must be BE
+        REM  : Be careful of compatibility between MED files when changing this (med2.2)                    */
+#if defined(PCLINUX) || defined(OSF1)
+      type_hdf = H5T_IEEE_F64BE;
+#else 
+      type_hdf = H5T_IEEE_F64LE;
+#endif
+      break;
+      
+    case MED_INT :
+#if defined(IRIX64) || defined(OSF1)
+      type_hdf = H5T_NATIVE_LONG; 
+#elif defined(PCLINUX)
+      /* This explicit convertion avoid a core dump between in HDF&ASTER when reading on SGI
+        a file written under a PCLINUX system (in founction H5Tconvert),
+        we don't know yet if it is an HDF bug or an ASTER one */
+      /* The problem seems to be in convertion process between INT32LE->INT32BE ? */
+      type_hdf = H5T_STD_I32BE;
+      if ((H5Tconvert(H5T_NATIVE_INT,H5T_STD_I32BE,1,(void *)val,NULL,NULL)) < 0) 
+         return -1;
+#else
+      type_hdf = H5T_NATIVE_INT;
+#endif
+      break;
+
+    default :
+      return -1;
+    }
+
+  if ((aid = H5Screate(H5S_SCALAR)) < 0)
+    return -1;
+
+  if ( ((attr = H5Aopen_name(pere,nom)) > 0) && (mode != MED_REMP) )
+    return -1;
+  else
+    if ( attr < 0)
+      if ((attr = H5Acreate(pere,nom,type_hdf,aid,H5P_DEFAULT)) < 0) return -1;  
+
+  if ((ret = H5Awrite(attr,type_hdf,val)) < 0)
+    return -1;
+
+
+  if ((ret = H5Sclose(aid)) < 0)
+    return -1;
+  if ((ret = H5Aclose(attr)) < 0)
+    return -1;
+
+#if defined(PCLINUX)
+  /* This explicit convertion cancel the previous on which avoid a mysterious bug between HDF&ASTER when reading
+     a file written under a PCLINUX system, we don't know yet if it is an HDF bug or an ASTER one */  
+  if (type == MED_INT) 
+    if ((H5Tconvert(H5T_STD_I32BE,H5T_NATIVE_INT,1,(void *)val,NULL,NULL)) < 0) 
+      return -1;
+#endif
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDattrNumLire.cxx b/src/MEDWrapper/V2_1/MEDattrNumLire.cxx
new file mode 100644 (file)
index 0000000..12299c5
--- /dev/null
@@ -0,0 +1,77 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDattrNumLire
+ * - Description : lecture d'un attribut entier
+ * - Parametres :
+ *     - pere (IN)  : l'ID de l'objet HDF pere ou placer l'attribut
+ *     - type (IN)  : le type du champ {MED_REEL64,MED_INT}
+ *     - nom  (IN)  : le nom de l'attribut 
+ *     - val  (OUT) : la valeur de l'attribut
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDattrNumLire(med_idt pere,med_type_champ type,char *nom,unsigned char *val)
+{
+  med_idt attid;
+  med_err ret;
+  int type_hdf;
+
+  if ((attid = H5Aopen_name(pere,nom)) < 0)
+    return -1;
+
+  switch(type) 
+    {
+    case MED_REEL64 :
+#if defined(PCLINUX) || defined(OSF1)
+      type_hdf = H5T_IEEE_F64BE;
+#else 
+      type_hdf = H5T_IEEE_F64LE;
+#endif
+      break;
+      
+    case MED_INT :
+#if defined(IRIX64) || defined(OSF1)
+      type_hdf = H5T_NATIVE_LONG; 
+#else
+      type_hdf = H5T_NATIVE_INT;
+#endif
+      break;
+      
+    default :
+      return -1;
+    }
+
+  if ((ret = H5Aread(attid,type_hdf,val)) < 0)
+    return -1;
+
+  if ((ret = H5Aclose(attid)) < 0)
+    return -1;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDattrOuvrir.cxx b/src/MEDWrapper/V2_1/MEDattrOuvrir.cxx
new file mode 100644 (file)
index 0000000..bcf6be5
--- /dev/null
@@ -0,0 +1,45 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDattrOuvrir
+ * - Description : acces a l'attribut dont le nom est passe en parametre
+ * - Parametres :
+ *     - pid (IN)  : l'ID de l'objet HDF pere ou placer l'attribut
+ *     - nom  (IN)  : le nom de l'attribut 
+ * - Resultat : ID de l'attribut en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_idt 
+_MEDattrOuvrir(med_idt pid,char * nom)
+{
+   med_idt aid;
+
+   if ((aid = H5Aopen_name(pid,nom)) < 0)
+     return -1;
+
+   return aid;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDattrStringEcrire.cxx b/src/MEDWrapper/V2_1/MEDattrStringEcrire.cxx
new file mode 100644 (file)
index 0000000..1283368
--- /dev/null
@@ -0,0 +1,68 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDattrStringEcrire
+ * - Description : ecriture d'un attribut chaine de caracteres
+ * - Parametres :
+ *     - pere (IN)     : l'ID de l'objet HDF pere ou placer l'attribut
+ *     - nom  (IN)     : le nom de l'attribut 
+ *     - longueur (IN) : strlen(val)
+ *     - val  (IN)     : la valeur de l'attribut
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDattrStringEcrire(med_idt pere,char *nom,int longueur,char *val, med_mode_acces mode)
+{
+  med_idt aid,attr, datatype;
+  med_err ret;
+
+  if ((aid = H5Screate(H5S_SCALAR)) < 0)
+    return -1;
+  if((datatype = H5Tcopy(H5T_C_S1)) < 0)
+    return -1;
+  if((ret = H5Tset_size(datatype,longueur+1)) < 0)
+    return -1;
+
+  if ( ((attr = H5Aopen_name(pere,nom)) > 0)
+       && (mode != MED_REMP) )
+    return -1;
+  else
+    if ( attr < 0)
+      if ((attr = H5Acreate(pere,nom,datatype,aid,H5P_DEFAULT)) < 0) return -1;
+  
+  if ((ret = H5Awrite(attr, datatype, val)) < 0)
+    return -1;
+
+  if ((ret = H5Sclose(aid)) < 0)
+    return -1;
+  if ((ret = H5Tclose(datatype)) < 0)
+    return -1;
+  if ((ret = H5Aclose(attr)) < 0)
+    return -1;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDattrStringLire.cxx b/src/MEDWrapper/V2_1/MEDattrStringLire.cxx
new file mode 100644 (file)
index 0000000..764b9e2
--- /dev/null
@@ -0,0 +1,57 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDattrStringLire
+ * - Description : lecture d'un attribut chaine de caracteres
+ * - Parametres :
+ *     - pere (IN)     : l'ID de l'objet HDF pere ou placer l'attribut
+ *     - nom  (IN)     : le nom de l'attribut 
+ *     - longueur (IN) : strlen(val)
+ *     - val  (OUT)    : la valeur de l'attribut
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDattrStringLire(med_idt pere,char *nom,int longueur,char *val)
+{
+  med_idt attid,datatype;
+  med_err ret;
+
+  if ((datatype = H5Tcopy(H5T_C_S1)) < 0)
+    return -1;
+  if ((ret = H5Tset_size(datatype,longueur+1)) < 0)
+    return -1;
+  if ((attid = H5Aopen_name(pere,nom)) < 0)
+    return -1;
+  if ((ret = H5Aread(attid,datatype,val)) < 0)
+    return -1;
+  if ((ret = H5Tclose(datatype)) < 0)
+    return -1;
+  if ((ret = H5Aclose(attid)) < 0)
+    return -1;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDbodyFittedEcr.cxx b/src/MEDWrapper/V2_1/MEDbodyFittedEcr.cxx
new file mode 100644 (file)
index 0000000..c7d84f4
--- /dev/null
@@ -0,0 +1,142 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med_outils.hxx"
+#include "med.hxx"
+
+#if defined(IRIX64)
+#define MED_INTEGER MED_INT64
+#else
+#define MED_INTEGER MED_INT32
+#endif
+
+namespace med_2_1{
+
+med_err 
+MEDbodyFittedEcr(med_idt fid, char *maa, med_int mdim, med_float *coo, med_int *nbr, med_mode_switch mode_coo,
+                med_repere repere, char *nomcoo, char *unicoo, med_int *fam, med_int nnoeuds, med_mode_acces mode )
+{
+    /* ecriture des coordonnees */
+    med_idt   maaid, noeid, dataset;
+    med_size dimd[1];
+    char     chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+    med_int  type_rep_int;
+    int      d;
+    char     *ds;
+
+    /* On inhibe le gestionnaire d'erreur HDF */
+    _MEDmodeErreurVerrouiller();
+
+    /* Si le maillage n'existe pas => erreur */
+    strcpy(chemin, MED_MAA);
+    strcat(chemin, maa);
+    if ((maaid = _MEDdatagroupOuvrir(fid, chemin)) < 0) {
+        return(-1);
+    };
+
+    /* Si le Data Group "NOE" n'existe pas on le cree */
+    if ((noeid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE)) < 0) {
+        if ((noeid = _MEDdatagroupCreer(maaid, MED_NOM_NOE)) < 0) {
+            return(-1);
+        };
+    };
+
+    /* Creation du Data Set "BOF" */
+    dimd[0] = nnoeuds*mdim;
+    if (_MEDdatasetNumEcrire(noeid, MED_NOM_BOF, MED_REEL64, mode_coo, mdim, MED_ALL, MED_NOPF, 0, 0, dimd, (unsigned char*)coo, mode) < 0) {
+        return(-1);
+    };
+  
+    /* On re-ouvre le Data Set "BOF" pour y placer des attributs */
+    if ((dataset = _MEDdatasetOuvrir(noeid, MED_NOM_BOF)) < 0) {
+        return(-1);
+    };
+
+    /* Attribut NBR (nombre de noeuds) */
+    if (_MEDattrEntierEcrire(dataset, MED_NOM_NBR, &nnoeuds, mode) < 0) {
+        return(-1);
+    };
+
+    /* L'attribut "REP" */
+    type_rep_int = (med_int)repere;
+    if (_MEDattrEntierEcrire(dataset, MED_NOM_REP, &type_rep_int, mode) < 0) {
+        return(-1);
+    };
+
+    /* Attribut "NOM" */
+    if (_MEDattrStringEcrire(dataset, MED_NOM_NOM, mdim*MED_TAILLE_PNOM, nomcoo, mode) < 0) {
+        return(-1);
+    };
+
+    /* Attribut "UNI" */
+    if (_MEDattrStringEcrire(dataset, MED_NOM_UNI, mdim*MED_TAILLE_PNOM, unicoo, mode) < 0) {
+        return(-1);
+    };
+
+    if (_MEDdatasetFermer(dataset) < 0) return(-1);
+
+    dimd[0] = 1;
+    for (d=0; d<mdim; d++) {
+        switch (d) {
+            case 0 : {
+                ds = MED_NOM_IN1;
+                break;
+            };
+            case 1 : {
+                ds = MED_NOM_IN2;
+                break;
+            };
+            case 2 : {
+                ds = MED_NOM_IN3;
+                break;
+            };
+            default : {
+                return(-1);
+            };
+        };
+
+        /* Creation du Data Set "IN1", "IN2", "IN3" contenant la taille du bodyfitted sur cette dimension */
+        if (_MEDdatasetNumEcrire(noeid, ds, MED_INTEGER, mode_coo, MED_DIM1, MED_ALL, MED_NOPF, 0, 0, dimd, (unsigned char*)&nbr[d], mode) < 0) {
+            return(-1);
+        };
+
+        /* On re-ouvre ce Data Set pour y placer des attributs */
+        if ((dataset = _MEDdatasetOuvrir(noeid, ds)) < 0) {
+            return(-1);
+        };
+
+        /* Attribut NBR (nombre de noeuds dans l'une des dimensions) */
+        if (_MEDattrEntierEcrire(dataset, MED_NOM_NBR, &nbr[d], mode) < 0) {
+            return(-1);
+        };
+
+        if (_MEDdatasetFermer(dataset) < 0) return(-1);
+    };
+
+    /* Ecriture des numeros de familles */
+    if (MEDfamEcr(fid, maa, fam, nnoeuds, mode, MED_NOEUD, MED_POINT1) < 0) {
+        return(-1);
+    };
+
+    /* On ferme tout */
+    if (_MEDdatagroupFermer(noeid) < 0) return(-1);
+    if (_MEDdatagroupFermer(maaid) < 0) return(-1);
+    return(0);
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDbodyFittedLire.cxx b/src/MEDWrapper/V2_1/MEDbodyFittedLire.cxx
new file mode 100644 (file)
index 0000000..75d1a4a
--- /dev/null
@@ -0,0 +1,89 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med_outils.hxx"
+#include "med.hxx"
+
+namespace med_2_1{
+
+med_err 
+MEDbodyFittedLire(med_idt fid, char *maa, med_int mdim, med_float *coo, med_mode_switch mode_coo,
+                 med_repere *repere, char *nomcoo, char *unicoo, med_int *fam, med_int nnoeuds )
+{
+    med_idt maaid, noeid, dataset;
+    char    chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+    med_int type_rep_int;
+
+    /* On inhibe le gestionnaire d'erreur */
+    _MEDmodeErreurVerrouiller();
+
+    /* Si le maillage n'existe pas => erreur */
+    strcpy(chemin, MED_MAA);
+    strcat(chemin, maa);
+    maaid = _MEDdatagroupOuvrir(fid, chemin);
+    if (maaid < 0) return(-1);
+
+    /* Si le Data Group "NOE" n'existe pas => erreur */
+    noeid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE);
+    if (noeid < 0) return(-1);
+
+    /* Lecture du Data Set "BOF" */
+    if (_MEDdatasetNumLire(noeid, MED_NOM_BOF, MED_REEL64, mode_coo, mdim, MED_ALL, MED_NOPF, 0, 1, (unsigned char*)coo) < 0) {
+        return(-1);
+    };
+
+    /* On re-ouvre le Data Set "BOF" pour y lire des attributs */
+    dataset = _MEDdatasetOuvrir(noeid, MED_NOM_BOF);
+    if (dataset < 0) return(-1);
+
+    /* L'attribut "REP" */
+    if (_MEDattrEntierLire(dataset, MED_NOM_REP, &type_rep_int) < 0) {
+        return(-1);
+    } else {
+        *repere = (med_repere)type_rep_int;
+    };
+
+    /* Attribut "NOM" */
+    if (_MEDattrStringLire(dataset, MED_NOM_NOM, mdim*MED_TAILLE_PNOM, nomcoo) < 0) {
+        return(-1);
+    };
+
+    /* Attribut "UNI" */
+    if (_MEDattrStringLire(dataset, MED_NOM_UNI, mdim*MED_TAILLE_PNOM, unicoo) < 0) {
+        return(-1);
+    };
+
+    /* lecture des numeros de familles */
+    if (MEDfamLire(fid, maa, fam, nnoeuds, MED_NOEUD, MED_POINT1) < 0) {
+        return(-1);
+    };
+
+    /* On ferme tout */
+    if (_MEDdatasetFermer(dataset) < 0) {
+        return(-1);
+    };
+    if (_MEDdatagroupFermer(noeid) < 0) {
+        return(-1);
+    };
+    if (_MEDdatagroupFermer(maaid) < 0) {
+        return(-1);
+    };
+    return(0);
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDchampCr.cxx b/src/MEDWrapper/V2_1/MEDchampCr.cxx
new file mode 100644 (file)
index 0000000..13fe552
--- /dev/null
@@ -0,0 +1,83 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_err
+MEDchampCr(med_idt fid, char *champ, med_type_champ type, char *comp,
+          char *unit,med_int ncomp)
+{
+  med_err ret = 0;
+  med_idt root,gid;
+  char chemin[MED_TAILLE_CHA+1];
+  med_size dimd[1];
+  med_int _type = (med_int) type;
+  
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /* 
+   * Si le Data Group "/CHA/" n'existe pas, on le cree
+   */
+  strncpy(chemin,MED_CHA,MED_TAILLE_CHA-1);
+  chemin[MED_TAILLE_CHA-1] = '\0';
+  if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    if ((root = _MEDdatagroupCreer(fid,chemin)) < 0)
+      return -1;  
+
+  /* 
+   * Si le Data Group cha n'existe pas, on le cree
+   * Sinon => erreur
+   */
+  if ((gid = _MEDdatagroupOuvrir(root,champ)) >= 0)
+    return -1;
+  if ((gid = _MEDdatagroupCreer(root,champ)) < 0)
+    return -1;
+
+  /*
+   * Les infos sur les composants du champ
+   */
+  if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_NCO,&ncomp,MED_REMP)) < 0)
+    return -1;
+  if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_TYP,&_type,MED_REMP)) < 0)
+    return -1;
+  if ((ret = _MEDattrStringEcrire(gid,MED_NOM_NOM,MED_TAILLE_PNOM*ncomp,comp,MED_REMP)) < 0)
+    return -1;
+  if ((ret = _MEDattrStringEcrire(gid,MED_NOM_UNI,MED_TAILLE_PNOM*ncomp,unit,MED_REMP)) < 0)
+    return -1;
+
+  /*
+   * On ferme tout
+   */
+  if ((ret = _MEDdatagroupFermer(gid)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(root)) < 0)
+    return -1;
+  
+  return ret;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDchampEcr.cxx b/src/MEDWrapper/V2_1/MEDchampEcr.cxx
new file mode 100644 (file)
index 0000000..14f5090
--- /dev/null
@@ -0,0 +1,246 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+/*
+ * - Nom de la fonction : MEDchampEcr
+ * - Description : ecriture d'un Champ Résultat
+ * - Parametres :
+ *     - fid      (IN)  : ID du fichier HDF courant
+ *     - maa      (IN)  : le nom du maillage sur lequel s'applique le champ 
+ *     - cha      (IN)  : le nom du champ 
+ *     - val      (IN)  : valeurs du champ à stocker
+ *     - interlace(IN)  : entrelacement utilisé en mémoire {MED_FULL_INTERLACE,MED_NO_INTERLACE} 
+ *     - nbelem   (IN)  : nombre d'éléments (prend en compte le nbre 
+ *                         de points de Gauss (c'est demandé à l'utilisateur ds la doc) mais pas le nbre de composantes)
+ *     - ngauss   (IN)  : nbre de point de gauss utilisé (MED_NOPG si aucun)
+ *     - numco    (IN)  : n° de la composante à stocker (MED_ALL si toutes)
+ *     - profil   (IN)  : nom du profil utilisé (MED_NOPFL si inutilisé)
+ *     - mode     (IN)       : mode d'ecriture MED (MED_ECRI | MED_REMP)
+ *     - type_ent (IN)  : entité concerné par le champ {MED_NOEUD,MED_ARETE,MED_FACE,MED_MAILLE}
+ *     - type_geo (IN)  : type géométrique de l'entité concerné {MED_POINT,MED_SEG2 ......}
+ *     - numdt    (IN)  : n° du pas de temps (MED_NOPDT si aucun)
+ *     - dt_unit  (IN)  : chaine de taille MED_NOMP indiquant l'unité du champ
+ *     - dt       (IN)  : valeur du pas de temps 
+ *     - numo     (IN)  : n° d'ordre utilisé MED_NONOR si inutile
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+MEDchampEcr(med_idt fid, char *maa, char *cha,unsigned char *val,med_mode_switch interlace,med_int nbelem,med_int ngauss, 
+           med_int numco, char * profil, med_mode_acces mode, med_entite_maillage type_ent, 
+           med_geometrie_element type_geo, med_int numdt,char * dt_unit, med_float dt, med_int numo)
+{
+  med_err ret;
+  med_idt chid,datagroup1,datagroup2;
+  med_int ncomp, chtype, i, locnumdt,pfluse;
+  char pflname [MED_TAILLE_NOM+1];
+  char maillage[MED_TAILLE_NOM+1];
+  char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2],nomdatagroup2[2*MED_MAX_PARA+1];
+  char tmp1[MED_TAILLE_NOM_ENTITE+1];
+  med_size dimd[1],psize;
+  med_int   *pfltabtmp=0;
+  med_ssize *pfltab=0;
+  char chemin[MED_TAILLE_CHA+MED_TAILLE_NOM+1];
+  
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /* 
+   * Si le Data Group cha n'existe pas => erreur
+   */
+  strcpy(chemin,MED_CHA);
+  strcat(chemin,cha);
+  if ((chid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;
+
+  /* 
+   *  Creation du datagroup de niveau 1 <type_ent>[.<type_geo>] 
+   */
+  
+  if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0)
+    return -1;
+  if ((type_ent != MED_NOEUD))
+    {
+      if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0)
+       return -1;
+      strcat(nomdatagroup1,".");
+      strcat(nomdatagroup1,tmp1);
+    }
+  datagroup1 = 0;
+  if ( (datagroup1 = _MEDdatagroupOuvrir(chid,nomdatagroup1)) < 0) 
+    if ((datagroup1 = _MEDdatagroupCreer(chid,nomdatagroup1)) < 0)
+      return -1;
+  
+  /* Creation du datagroup de niveau 2 <numdt>.<numoo> */
+  if ( numdt == MED_NOPDT) locnumdt = MED_NOPDT; else locnumdt = numdt;
+  sprintf(nomdatagroup2,"%*li%*li",MED_MAX_PARA,(long ) locnumdt,MED_MAX_PARA,(long ) numo);
+
+  
+  /*Cree ou ouvre (en mode MED_REMP) le datagroup nomdatagroup2 */
+  datagroup2 = 0;   
+  if (((datagroup2 = _MEDdatagroupOuvrir(datagroup1,nomdatagroup2)) > 0)    
+      && (mode != MED_REMP))   
+    return -1;   
+  else   
+    if (datagroup2 < 0)
+      if ((datagroup2 = _MEDdatagroupCreer(datagroup1,nomdatagroup2)) < 0)   
+       return -1;   
+  
+  /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_NDT */
+  if ((ret = _MEDattrEntierEcrire(datagroup2,MED_NOM_NDT,&numdt,mode)) < 0)
+    return -1;
+  
+  /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_PDT */
+  if ((ret = _MEDattrFloatEcrire(datagroup2,MED_NOM_PDT,&dt,mode)) < 0)
+    return -1;
+    
+  /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_NOR */
+  if ((ret = _MEDattrEntierEcrire(datagroup2,MED_NOM_NOR,&numo,mode)) < 0)
+    return -1;
+  
+  /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_NBR */
+  if ((ret = _MEDattrEntierEcrire(datagroup2,MED_NOM_NBR,&nbelem,mode)) < 0)
+    return -1;
+
+  /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_MAA   */
+  /* rem : Aucune verification de l'existence du maillage */
+  strncpy(maillage,maa,MED_TAILLE_NOM);
+  maillage[MED_TAILLE_NOM]='\0';
+  if ((ret = _MEDattrStringEcrire(datagroup2,MED_NOM_MAI,MED_TAILLE_NOM,maillage,mode)) < 0)
+    return -1;
+  
+  /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_PFL   */ 
+  pfluse = 0;
+  if ( strlen(profil) == 0)   /* idem MED_NOPFL*/
+    strncpy(pflname,MED_NOPFLi,MED_TAILLE_NOM+1);
+  else {
+    strncpy(pflname,profil,MED_TAILLE_NOM);
+    pflname[MED_TAILLE_NOM]='\0';
+    pfluse = 1;
+  }
+  if ((ret = _MEDattrStringEcrire(datagroup2,MED_NOM_PFL,MED_TAILLE_NOM,pflname,mode)) < 0)
+    return -1; 
+
+  /*Cree ou ouvre (en mode MED_REMP) l'attribut  MED_NOM_UNI */ 
+  if ( strlen(dt_unit) == 0) {
+    if ((ret = _MEDattrStringEcrire(datagroup2,MED_NOM_UNI,MED_TAILLE_PNOM,"        ",mode)) < 0)
+      return -1;
+  } else
+    if ((ret = _MEDattrStringEcrire(datagroup2,MED_NOM_UNI,MED_TAILLE_PNOM,dt_unit,mode)) < 0)
+      return -1;
+  
+
+  /* Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_NGAU             */ 
+  /* Ecriture du nombre de pts de gauss propre au <type_ent>[.<type_geo>] */
+  /* On n'utilise pas ngauss=MED_NOPG mais ngauss=1 si aucun pt de gauss  */
+  if ((ret = _MEDattrEntierEcrire(datagroup2,MED_NOM_NGA,&ngauss,mode)) < 0)
+    return -1;
+
+  /*Lecture de l'attribut MED_NOM_NCO */
+  if ((ret = _MEDattrEntierLire(chid,MED_NOM_NCO,&ncomp)) < 0)
+    return -1;
+  /*Determination de la taille dimd[0] du dataset à stocker*/
+  dimd[0] = nbelem*ncomp;
+
+  /* Gestion des profils*/
+  if ( pfluse ) {
+   
+    if ( ( i = MEDnValProfil(fid,pflname) ) < 0 )
+      return -1;
+    else
+      psize = i;
+    
+    pfltabtmp = (med_int *)   malloc (sizeof(med_int)*psize);
+    pfltab    = (med_ssize *) malloc (sizeof(med_ssize)*psize);
+    if ((ret = MEDprofilLire(fid,pfltabtmp,pflname)) < 0)
+      return -1;
+    for (i=0;i<psize;i++)
+      pfltab[i] = (med_ssize) pfltabtmp[i];
+    
+  }
+  else
+    psize = MED_NOPF;
+  
+  
+  /*
+   * Ecriture du champ
+   */
+  if ((ret = _MEDattrEntierLire(chid,MED_NOM_TYP,&chtype)) < 0)
+    return -1;
+  switch(chtype)
+    {
+    case MED_REEL64 :
+      if ((ret =  _MEDdatasetNumEcrire(datagroup2,MED_NOM_CO,MED_REEL64,interlace,ncomp,numco,psize,pfltab,ngauss,dimd,val,
+                                      mode)) < 0)
+       return -1;
+      break;
+
+    case MED_INT32 :
+#if defined(IRIX64)||defined(OSF1) 
+     if ((ret =  _MEDdatasetNumEcrire(datagroup2,MED_NOM_CO,MED_INT64,interlace,ncomp,numco,psize,pfltab,ngauss,dimd,val,
+                                      mode)) < 0)
+       return -1;
+#else
+      if ((ret =  _MEDdatasetNumEcrire(datagroup2,MED_NOM_CO,MED_INT32,interlace,ncomp,numco,psize,pfltab,ngauss,dimd,val,
+                                      mode)) < 0)
+       return -1;
+#endif
+      break;
+
+    case MED_INT64 :
+#if defined(IRIX64)||defined(OSF1) 
+     if ((ret =  _MEDdatasetNumEcrire(datagroup2,MED_NOM_CO,MED_INT64,interlace,ncomp,numco,psize,pfltab,ngauss,dimd,val,
+                                      mode)) < 0)
+       return -1;
+#else
+     return -1;
+#endif
+     break;   
+
+    default :
+      return -1;
+    }
+
+  /*
+   * On ferme tout 
+   */
+  if ( pfluse ) { free(pfltab); free(pfltabtmp);}
+
+  if ((ret = _MEDdatagroupFermer(datagroup2)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(datagroup1)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(chid)) < 0)
+    return -1;
+  
+  return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDchampInfo.cxx b/src/MEDWrapper/V2_1/MEDchampInfo.cxx
new file mode 100644 (file)
index 0000000..6ff52b3
--- /dev/null
@@ -0,0 +1,76 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+namespace med_2_1{
+
+med_err 
+MEDchampInfo(med_idt fid,int indice,char *champ,
+            med_type_champ *type,char *comp,char *unit, 
+            med_int ncomp)
+{
+  med_err ret=0;
+  med_idt gid;
+  char chemin[MED_TAILLE_CHA+MED_TAILLE_NOM+1];
+  int num;
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * On recupere le nom du champ
+   */
+  num = indice - 1;
+  strcpy(chemin,MED_CHA);
+  if ((ret = _MEDobjetIdentifier(fid,chemin,num,champ)) < 0)
+    return -1;
+
+  /* 
+   * Si le Data Group cha n'existe pas => erreur
+   */
+  strcat(chemin,champ);
+  if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;
+
+
+  /*
+   * La liste des attributs
+   */
+  if ((ret = _MEDattrEntierLire(gid,MED_NOM_TYP,(med_int*) type)) < 0)
+    return -1;
+  if ((ret = _MEDattrStringLire(gid,MED_NOM_NOM,ncomp*MED_TAILLE_PNOM,
+                               comp)) < 0)
+    return -1;
+  if ((ret = _MEDattrStringLire(gid,MED_NOM_UNI,ncomp*MED_TAILLE_PNOM,
+                               unit)) < 0)
+    return -1;
+
+  /*
+   * On ferme tout
+   */
+  if ((ret = _MEDdatagroupFermer(gid)) < 0)
+    return -1; 
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDchampLire.cxx b/src/MEDWrapper/V2_1/MEDchampLire.cxx
new file mode 100644 (file)
index 0000000..ad21a68
--- /dev/null
@@ -0,0 +1,194 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+ /*La taille de val allouée par l'utilisateur doit prendre en compte le nbre de points de gauss et le nbre de composantes*/
+
+namespace med_2_1{
+
+med_err 
+MEDchampLire(med_idt fid,char *maa, char *cha, unsigned char *val,med_mode_switch interlace,med_int numco,
+            char *profil,med_entite_maillage type_ent, med_geometrie_element type_geo,
+            med_int numdt, med_int numo)
+     /* VERIFIER LA POSSIBILITE DE RELIRE L'UNITE DE PAS DE TEMPS (DS CHAMPINFO) */
+{
+  med_err ret;
+  med_idt chid, datagroup1, datagroup2;
+  med_int ncomp, chtype, ngauss, i, locnumdt, pfluse;
+  char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2],nomdatagroup2[2*MED_MAX_PARA+1];
+  char tmp1[MED_TAILLE_NOM_ENTITE+1], pfltmp[MED_TAILLE_NOM+1];
+  char chemin[MED_TAILLE_CHA+MED_TAILLE_NOM+1];
+  med_size   psize;
+  med_int   *pfltabtmp=0;
+  med_ssize *pfltab=0;
+  char maatmp[MED_TAILLE_NOM+1];
+  
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /* 
+   * Si le Data Group cha n'existe pas => erreur
+   */
+  strcpy(chemin,MED_CHA);
+  strcat(chemin,cha);
+  if ((chid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;
+
+ /* 
+   * Si le Data Group  de niveau 1 <type_ent>[.<type_geo>] n'existe pas => erreur
+   */
+  if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0)
+    return -1;
+  if ((type_ent != MED_NOEUD))
+    {
+      if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0)
+       return -1;
+      strcat(nomdatagroup1,".");
+      strcat(nomdatagroup1,tmp1);
+    }
+  datagroup1 = 0;
+  if ( (datagroup1 = _MEDdatagroupOuvrir(chid,nomdatagroup1)) < 0 )
+    return -1;
+
+  /*
+   * Si le Data Group de niveau 2 <numdtt>.<numoo> n'existe pas => erreur
+   */
+  if ( numdt == MED_NOPDT) locnumdt = MED_NOPDT; else locnumdt = numdt;
+  sprintf(nomdatagroup2,"%*li%*li",MED_MAX_PARA,(long ) locnumdt,MED_MAX_PARA,(long ) numo);
+  
+  datagroup2 = 0;   
+  if ( (datagroup2 = _MEDdatagroupOuvrir(datagroup1,nomdatagroup2)) < 0)    
+    return -1;   
+
+  /* Lecture du nbre de composantes du champ */
+
+  if ((ret = _MEDattrEntierLire(chid,MED_NOM_NCO,&ncomp)) < 0)
+    return -1;
+  
+  /* Gestion des profils*/
+
+  /*
+   * Lire le profil demandé
+   */
+
+  if ((ret = _MEDattrStringLire(datagroup2,MED_NOM_PFL,MED_TAILLE_NOM,pfltmp)) < 0)
+    return -1;
+  
+  if ( pfluse = (strcmp(pfltmp,MED_NOPFLi) && strcmp(pfltmp,"")) ) /* le test "" pour des raisons de compatibilité */
+    {
+      strcpy(profil,pfltmp);
+      if ( (i = MEDnValProfil(fid,profil)) < 0 )
+       return -1;
+      else
+       psize = i;
+
+      pfltabtmp = (med_int *)   malloc (sizeof(med_int)*psize);
+      pfltab = (med_ssize *) malloc (sizeof(med_ssize)*psize);
+      if ((ret = MEDprofilLire(fid,pfltabtmp,profil)) < 0)
+       return -1;
+      for (i=0;i<psize;i++)
+       pfltab[i] = (med_ssize) pfltabtmp[i];
+       
+    }
+  else {
+    psize = MED_NOPF;
+    strcpy(profil,MED_NOPFL);
+  }
+  
+  /*
+   * Lire le nom de maillage associé au champ
+   */
+  if ((ret = _MEDattrStringLire(datagroup2,MED_NOM_MAI,MED_TAILLE_NOM,maatmp)) < 0)
+    return -1;
+
+  if (strcmp(maa,maatmp)) 
+    return -1;
+  
+  /* Lit le nbre de points de Gauss  */ 
+  /* (attribut MED_NOM_NGAU) propre au <type_ent>[.<type_geo>] pour simplifier la relecture */
+  if ( (ret = _MEDattrEntierLire(datagroup2,MED_NOM_NGA,&ngauss)) < 0 )
+    return -1;
+
+  /*
+   * Lecture du champ
+   */
+
+  if ((ret = _MEDattrEntierLire(chid,MED_NOM_TYP,&chtype)) < 0)
+    return -1;
+
+  switch(chtype)
+    {
+    case MED_REEL64 :
+      if ((ret =  _MEDdatasetNumLire(datagroup2,MED_NOM_CO,MED_REEL64,
+                                    interlace,ncomp,numco,
+                                    psize,pfltab,ngauss,val))< 0)
+       return -1;
+      break;
+
+    case MED_INT32 :
+#if defined(IRIX64)||defined(OSF1) 
+     if ((ret =  _MEDdatasetNumLire(datagroup2,MED_NOM_CO,MED_INT64,
+                                    interlace,ncomp,numco,
+                                    psize,pfltab,ngauss,val))< 0)
+       return -1;
+#else
+     if ((ret =  _MEDdatasetNumLire(datagroup2,MED_NOM_CO,MED_INT32,
+                                    interlace,ncomp,numco,
+                                    psize, pfltab,ngauss,val))< 0)
+       return -1;
+#endif
+     break;
+
+    case MED_INT64 :
+#if defined(IRIX64)||defined(OSF1) 
+     if ((ret =  _MEDdatasetNumLire(datagroup2,MED_NOM_CO,MED_INT64,
+                                    interlace,ncomp,numco,
+                                    psize,pfltab,ngauss,val))< 0)
+       return -1;
+#else
+     return -1;
+#endif
+      break;      
+
+    default :
+      return -1;
+    }
+
+  /*
+   * On ferme tout 
+   */
+  if ( pfluse ) { free(pfltab); free(pfltabtmp);}
+
+  if ((ret = _MEDdatagroupFermer(datagroup2)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(datagroup1)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(chid)) < 0)
+    return -1;
+    
+  return 0;     
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDconnEcr.cxx b/src/MEDWrapper/V2_1/MEDconnEcr.cxx
new file mode 100644 (file)
index 0000000..a8395b5
--- /dev/null
@@ -0,0 +1,142 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+extern int mode_interlace; 
+
+namespace med_2_1{
+
+med_err 
+MEDconnEcr(med_idt fid,char *maa, med_int mdim, med_int *connectivite,med_mode_switch mode_switch,
+          med_int nbre,med_mode_acces mode,med_entite_maillage type_ent,
+          med_geometrie_element type_geo,med_connectivite type_conn)
+{
+  med_idt maaid, entid, geoid, dataset;
+  med_err ret;
+  med_size dimd[1];
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
+  char nom_geo[MED_TAILLE_NOM_ENTITE+1];
+  char nom_dataset[MED_TAILLE_NOM_ENTITE+1];
+  int dim, nnoe, ndes;
+  int nsup = 0;
+  int taille;
+  
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * Si le maillage n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * On met a jour le nom du Data Group representant
+   * le type des entites
+   */
+   if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
+     return -1;
+   /*
+    * Si le Data Group des entites n'existe pas on le cree
+    */
+   /*EF Gerer le mode */
+   if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
+     if ((entid = _MEDdatagroupCreer(maaid,nom_ent)) < 0)
+       return -1;
+
+   /*
+    * On cree s'il n'existe pas le Data Group du type geometrique
+    */
+   /*EF Gerer le mode */
+  if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
+     return -1;
+   if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
+     if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0)
+       return -1;
+
+   /*
+    * On regarde si le Data Set existe et on le cree sinon
+    */
+   if ((ret=_MEDparametresGeometrie(type_ent,type_geo,&dim,&nnoe,&ndes))<0)
+     return -1;
+   if (mdim == 2 || mdim == 3)
+     if (type_ent == MED_MAILLE && dim == 1)
+       nsup = 1;
+   if (mdim == 3)
+     if (type_ent == MED_MAILLE && dim == 2)
+       nsup = 1;
+   switch(type_conn)
+     {
+     case MED_NOD :
+       strcpy(nom_dataset,MED_NOM_NOD);
+       taille = nsup + nnoe;
+       break;
+
+     case MED_DESC :
+       strcpy(nom_dataset,MED_NOM_DES);
+       taille = nsup + ndes;
+       break;
+       
+     default :
+       return -1;
+     }
+   dimd[0] = nbre*taille;
+#if defined(IRIX64)||defined(OSF1)
+   if ((ret = _MEDdatasetNumEcrire(geoid,nom_dataset,MED_INT64,mode_switch,(med_size)taille,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
+                                   (unsigned char*) connectivite,mode)) < 0)
+     return -1;
+#else
+   if ((ret = _MEDdatasetNumEcrire(geoid,nom_dataset,MED_INT32,mode_switch,(med_size)taille,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
+                                   (unsigned char*) connectivite,mode)) < 0)
+     return -1;
+#endif
+
+  /*
+   * Attribut NBR (nombre de noeuds ou d'elements)
+   */
+   if ((dataset = _MEDdatasetOuvrir(geoid,nom_dataset)) < 0)
+     return -1;
+   if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&nbre,mode)) < 0)
+     return -1;
+
+   /*
+    * On ferme tout 
+    */
+   if ((ret = _MEDdatasetFermer(dataset)) < 0)
+     return -1;
+   if ((ret = _MEDdatagroupFermer(geoid)) < 0)
+     return -1;
+   if ((ret = _MEDdatagroupFermer(entid)) < 0)
+     return -1;
+   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+     return -1;
+
+  return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDconnLire.cxx b/src/MEDWrapper/V2_1/MEDconnLire.cxx
new file mode 100644 (file)
index 0000000..9e6c29f
--- /dev/null
@@ -0,0 +1,149 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+extern int mode_interlace; 
+
+namespace med_2_1{
+
+med_err 
+MEDconnLire(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch,
+           med_int * pfltabtmp, med_size psizetmp,
+           med_entite_maillage type_ent, med_geometrie_element type_geo,med_connectivite type_conn)
+{
+  med_idt maaid,entid,geoid;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
+  char nom_geo[MED_TAILLE_NOM_ENTITE+1];
+  char nom_dataset[MED_TAILLE_NOM_ENTITE+1];
+  med_ssize * pfltab;
+  med_size    psize;
+  int dim,nnoe,ndes;
+  int nsup = 0;
+  int taille;  
+  int i,j;
+  
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+  
+  /*
+   * Si le maillage n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;
+
+  /*
+   * On met a jour le nom du Data Group representant
+   * le type des entites
+   */
+   if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
+     return -1;
+   /*
+    * Si le Data Group des entites n'existe pas => erreur
+    */
+   if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
+     return -1;
+
+   /*
+    * si le Data Group du type geometrique n'existe pas => erreur
+    */
+   if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
+     return -1;
+   if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
+     return -1;
+
+   /*
+    * Si le Data Set de la connectivite n'existe pas => erreur
+    * Si oui => on le lit
+    */
+   if ((ret=_MEDparametresGeometrie(type_ent,type_geo,&dim,&nnoe,&ndes))<0)
+     return -1;
+   if (mdim == 2 || mdim == 3)
+     if (type_ent == MED_MAILLE && dim == 1)
+       nsup = 1;
+   if (mdim == 3)
+     if (type_ent == MED_MAILLE && dim == 2)
+       nsup = 1;
+
+
+   psize = psizetmp;
+   switch(type_conn)
+     {
+     case MED_NOD :
+       strcpy(nom_dataset,MED_NOM_NOD);
+       taille = nsup + nnoe;
+       break;
+
+     case MED_DESC :
+       strcpy(nom_dataset,MED_NOM_DES);
+       taille = nsup + ndes;
+       if ( psizetmp != MED_NOPF ) {  
+        psize = psizetmp;
+        pfltab = (med_ssize *) malloc (sizeof(med_ssize)*psize);
+        for (i=0;i<psizetmp;i++)
+          pfltab[i] = (med_ssize) (pfltabtmp[i]);
+       };
+       
+       break;
+       
+     default :
+       return -1;
+     }
+
+
+#if defined(IRIX64)||defined(OSF1)
+   if ((ret = _MEDdatasetNumLire(geoid,nom_dataset,MED_INT64,
+                                mode_switch,(med_size)taille,MED_ALL,
+                                psize,pfltab,MED_NOPG,
+                                (unsigned char*) connectivite)) < 0)
+     return -1;
+#else
+   if ((ret = _MEDdatasetNumLire(geoid,nom_dataset,MED_INT32,
+                                mode_switch,(med_size) taille,MED_ALL,
+                                psize,pfltab,MED_NOPG,
+                                (unsigned char*) connectivite)) < 0)
+     return -1;
+#endif 
+
+   /*
+    * On ferme tout 
+    */
+
+   if ( (psize != MED_NOPF) && (type_conn == MED_DESC) ) free(pfltab);
+  
+   if ((ret = _MEDdatagroupFermer(geoid)) < 0)
+     return -1;
+   if ((ret = _MEDdatagroupFermer(entid)) < 0)
+     return -1;
+   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+     return -1;
+
+   return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDcoordEcr.cxx b/src/MEDWrapper/V2_1/MEDcoordEcr.cxx
new file mode 100644 (file)
index 0000000..71d3706
--- /dev/null
@@ -0,0 +1,111 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med_outils.hxx"
+#include "med.hxx"
+
+#include <stdlib.h>
+#include <string.h>
+
+namespace med_2_1{
+
+med_err 
+MEDcoordEcr(med_idt fid, char *maa, med_int mdim, med_float *coo, 
+           med_mode_switch mode_coo,med_int n,
+           med_mode_acces mode, med_repere type_rep, char *nom, char *unit)
+{
+  med_idt maaid, noeid, dataset;
+  med_err ret;
+  med_size dimd[1];
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  med_int type_rep_int; 
+  /*
+   * On inhibe le gestionnaire d'erreur HDF
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * Si le maillage n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * Si le Data Group "NOE" n'existe pas
+   * on le cree
+   */
+  /* EF : A faire : gerer le mode MED_REMP*/
+  if ((noeid = _MEDdatagroupOuvrir(maaid,MED_NOM_NOE)) < 0)
+    if ((noeid = _MEDdatagroupCreer(maaid,MED_NOM_NOE)) < 0)
+      return -1;
+
+  /*
+   * Creation du Data Set "COO"
+   */
+  dimd[0] = n*mdim;
+  if ((ret = _MEDdatasetNumEcrire(noeid,MED_NOM_COO,MED_REEL64,mode_coo,mdim,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
+                                 (unsigned char*) coo,mode)) < 0)
+    return -1;
+  
+  /*
+   * On re-ouvre le Data Set "COO" pour y placer des attributs
+   */
+  if ((dataset = _MEDdatasetOuvrir(noeid,MED_NOM_COO)) < 0)
+    return -1;
+
+  /*
+   * Attribut NBR (nombre de noeuds)
+   */
+  if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n,mode)) < 0)
+    return -1;
+
+  /*
+   * L'attribut "REP"
+   */
+  type_rep_int = (med_int) type_rep; 
+  if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_REP,&type_rep_int,mode)) < 0)
+    return -1;
+
+  /*
+   * Attribut "NOM"
+   */
+  if ((ret = _MEDattrStringEcrire(dataset,MED_NOM_NOM,mdim*MED_TAILLE_PNOM,nom,mode)) < 0)
+    return -1;
+
+  /*
+   * Attribut "UNI"
+   */
+  if ((ret = _MEDattrStringEcrire(dataset,MED_NOM_UNI,mdim*MED_TAILLE_PNOM,unit,mode)) < 0)
+    return -1;
+
+  /*
+   * On ferme tout
+   */
+  if ((ret = _MEDdatasetFermer(dataset)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(noeid)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+    return -1;
+
+  return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDcoordLire.cxx b/src/MEDWrapper/V2_1/MEDcoordLire.cxx
new file mode 100644 (file)
index 0000000..1335f1a
--- /dev/null
@@ -0,0 +1,125 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med_outils.hxx"
+#include "med.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+extern int mode_interlace;
+
+namespace med_2_1{
+
+med_err 
+MEDcoordLire(med_idt fid, char *maa, med_int mdim, med_float *coo,
+            med_mode_switch mode_coo,med_int numco,
+            med_int * pfltabtmp, med_size psize, med_repere *type_rep, char *nom, char *unit)
+{
+  med_idt   maaid, noeid, dataset;
+  med_err   ret;
+  char      chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  int       i,j;
+  med_float *new_coo;
+  med_int   type_rep_int;
+  med_ssize * pfltab;
+
+  /*
+   * On inhibe le gestionnaire d'erreur
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * Si le maillage n'existe pas => erreur
+   * Sinon on recupere sa dimension au passage
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * Si le Data Group "NOE" n'existe pas => erreur
+   */
+  if ((noeid = _MEDdatagroupOuvrir(maaid,MED_NOM_NOE)) < 0)
+      return -1;
+
+  /*
+   * Convertion de med_int en med_ssize
+   */
+  if ( psize != MED_NOPF ) {  
+    pfltab = (med_ssize *) malloc (sizeof(med_ssize)*psize);
+    for (i=0;i<psize;i++)
+      pfltab[i] = (med_ssize) pfltabtmp[i];
+  }
+
+  /*
+   * Lecture du Data Set "COO"
+   */
+  if ((ret = _MEDdatasetNumLire(noeid,MED_NOM_COO,MED_REEL64,
+                               mode_coo,mdim,numco,
+                               psize,pfltab,MED_NOPG,
+                               (unsigned char*) coo)) < 0)
+    return -1;
+
+  
+
+  /*
+   * On re-ouvre le Data Set "COO" pour y lire des attributs
+   */
+  if ((dataset = _MEDdatasetOuvrir(noeid,MED_NOM_COO)) < 0)
+    return -1;
+
+  /*
+   * L'attribut "REP"
+   */
+  if ((ret = _MEDattrEntierLire(dataset,MED_NOM_REP,&type_rep_int)) < 0)
+    return -1;
+  else
+    *type_rep = (med_repere) type_rep_int;
+
+  /*
+   * Attribut "NOM"
+   */
+  if ((ret = _MEDattrStringLire(dataset,MED_NOM_NOM,mdim*MED_TAILLE_PNOM,
+                               nom)) < 0)
+    return -1;
+
+  /*
+   * Attribut "UNI"
+   */
+  if ((ret = _MEDattrStringLire(dataset,MED_NOM_UNI,mdim*MED_TAILLE_PNOM,
+                               unit)) < 0)
+    return -1;
+
+  /*
+   * On ferme tout
+   */
+  if ( psize != MED_NOPF ) free(pfltab); 
+  
+  if ((ret = _MEDdatasetFermer(dataset)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(noeid)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+    return -1;
+
+  return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDcstringFree.cxx b/src/MEDWrapper/V2_1/MEDcstringFree.cxx
new file mode 100644 (file)
index 0000000..aa15414
--- /dev/null
@@ -0,0 +1,42 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include <stdlib.h>
+#include "med_misc.hxx"
+
+/*
+ * - Nom de la fonction _MEDcstringFree
+ * - Description : libere la chaine de caracteres creee par
+ *                 les routines _MEDXcstring
+ * - Parametres :
+ *     - chaine (IN/OUT) : la chaine de caracteres a detruire
+ * - Resultat : 0 si succes, -1 sinon
+ */
+
+namespace med_2_1{
+
+med_err
+_MEDcstringFree(char *chaine)
+{
+
+  free(chaine);
+  return 0;
+
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDdatagroupCreer.cxx b/src/MEDWrapper/V2_1/MEDdatagroupCreer.cxx
new file mode 100644 (file)
index 0000000..4b91704
--- /dev/null
@@ -0,0 +1,45 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDdatagroupCreer
+ * - Description : creation et ouverture d'un Datagroup HDF
+ * - Parametres :
+ *     - pid     (IN)    : l'ID de l'objet pere
+ *     - nom     (IN)    : le nom de l'objet fils
+ * - Resultat : l'ID du fils en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_idt
+_MEDdatagroupCreer(med_idt pid, char *nom)
+{
+  med_idt id;
+
+  if ((id = H5Gcreate(pid,nom,0)) < 0)
+    return -1;
+
+  return id;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDdatagroupFermer.cxx b/src/MEDWrapper/V2_1/MEDdatagroupFermer.cxx
new file mode 100644 (file)
index 0000000..b48ea41
--- /dev/null
@@ -0,0 +1,44 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDdatagroupFermer
+ * - Description : fermeture d'un datagroup HDF
+ * - Parametres :
+ *     - id     (IN)     : l'ID du datagroup
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDdatagroupFermer(med_idt id)
+{
+  med_err ret;
+
+  if ((ret = H5Gclose(id)) < 0)
+    return -1;
+  else
+    return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDdatagroupOuvrir.cxx b/src/MEDWrapper/V2_1/MEDdatagroupOuvrir.cxx
new file mode 100644 (file)
index 0000000..89cdbe4
--- /dev/null
@@ -0,0 +1,45 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDdatagroupOuvrir
+ * - Description : ouverture d'un datagroup HDF
+ * - Parametres :
+ *     - pid     (IN)    : l'ID de l'objet pere
+ *     - nom     (IN)    : le nom de l'objet fils
+ * - Resultat : l'ID du fils en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_idt
+_MEDdatagroupOuvrir(med_idt pid, char *nom)
+{
+  med_idt id;
+
+  if ((id = H5Gopen(pid,nom)) < 0)
+    return -1;
+
+  return id;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDdatasetFermer.cxx b/src/MEDWrapper/V2_1/MEDdatasetFermer.cxx
new file mode 100644 (file)
index 0000000..7694e05
--- /dev/null
@@ -0,0 +1,43 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDdatasetFermer
+ * - Description : fermeture d'un objet HDF dataset
+ * - Parametres :
+ *     - id  (IN)     : l'ID de l'objet HDF dataset 
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err
+_MEDdatasetFermer(med_idt id)
+{
+  med_err ret;
+
+  if ((ret = H5Dclose(id)) < 0)
+    return -1;
+  
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDdatasetNumEcrire.cxx b/src/MEDWrapper/V2_1/MEDdatasetNumEcrire.cxx
new file mode 100644 (file)
index 0000000..85fb2a7
--- /dev/null
@@ -0,0 +1,373 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDdatasetNumEcrire
+ * - Description : ecriture d'un dataset tableau numerique
+ * - Parametres :
+ *     - pere (IN)      : l'ID de l'objet HDF pere ou placer l'attribut
+ *     - nom  (IN)      : le nom du dataset
+ *     - type (IN)      : type numerique MED { MED_REEL64 , MED_INT32 , MED_INT64 }
+ *     - interlace (IN) : Choix du type d'entrelacement utilisé par l'appelant { MED_FULL_INTERLACE(x1,y1,z1,x2,...)) , MED_NO_INTERLACE(x1,x2,y1,y2,z1,z2) }
+ *       - nbdim   (IN) : Dimension des éléments
+ *       - fixdim  (IN) : MED_ALL ou n° de la dimension a enregistrer
+ *     - psize     (IN) : Taille du profil à utiliser, MED_NOPF si pas de profil 
+ *                        (référence les élements, cette taille ne prend pas en compte le nombre de pts de gauss ni la dimension )  
+ *       - pfltab  (IN) : Tableau contenant les n° déléments à traiter (1....oo)
+ *       - pflmod  (IN) : PARAMETRE A AJOUTER : Indique comment lire les informations en mémoire { MED_COMPACT, MED_GLOBALE }. 
+ *       - ngauss  (IN) : Nombre de points de GAUSS par élément
+ *     - size (IN)     : Taille du tableau de valeurs
+ *                        (référence tous les élements, cette taille  prend en compte le nombre de pts de gauss et la dimension )  
+ *     - val  (IN)     : valeurs du tableau
+ *     - mode (IN)     : mode d'ecriture MED (MED_ECRI | MED_REMP)
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDdatasetNumEcrire(med_idt pere,char *nom, med_type_champ type,
+                    med_mode_switch interlace, med_size nbdim, med_size fixdim, 
+                    med_size psize, med_ssize * pfltab, med_int ngauss,
+                    med_size *size,  unsigned char *val, med_mode_acces mode)
+{
+  med_idt    dataset, dataspace = 0, memspace = 0;
+  med_ssize  start_mem[1],start_data[1],*pflmem,*pfldsk;
+  med_size   stride[1],count[1],pcount[1],pflsize[1];
+  med_err    ret;
+  int        i,j,index,type_hdf;
+  int        dim, firstdim, dimutil, lastdim ;
+  med_mode_profil pflmod;
+
+  /* Verify fixdim is between [0, nbdim] ( 0 is MED_ALL ) */
+  if ( ( fixdim < 0 ) || ( fixdim > nbdim ) ) 
+    return -1;
+
+  /* block pflmod to MED_COMPACT (until med2.2) */
+  pflmod = MED_COMPACT;
+
+  switch(type) 
+    {
+    case MED_REEL64 :
+      /* 1) IA32 is LE but due to an (?HDF convertion BUG?) when using H5T_NATIVE_DOUBLE/MED_REEL64? under PCLINUX
+        the file read under SGI is incorrect
+        2) Compaq OSF/1 is LE, since we force SGI64,SUN4SOL2,HP to write double in LE even if they are BE, mips OSF/1 must be BE
+        REM  : Be careful of compatibility between MED files when changing this (med2.2)                    */
+#if defined(PCLINUX) || defined(OSF1)
+      type_hdf = H5T_IEEE_F64BE;
+#else     
+      type_hdf = H5T_IEEE_F64LE;
+#endif
+      break;
+
+    case MED_INT32 :
+#if defined(PCLINUX)
+      type_hdf = H5T_STD_I32BE;
+      if ((H5Tconvert(H5T_NATIVE_INT,H5T_STD_I32BE,(hsize_t)*size,(void *)val,NULL,NULL)) < 0) 
+         return -1;
+#else
+      type_hdf = H5T_NATIVE_INT;
+#endif
+      break;
+    case MED_INT64 :
+      type_hdf = H5T_NATIVE_LONG;
+      break;
+
+    default :
+      return -1;
+    }
+
+
+  if ((dataset = H5Dopen(pere,nom)) < 0)
+    {
+      /* Whatever the size of the profil is we create a dataset with the size of the value array               */
+      /* Then if we used the MED_REMP mode we can append a new dimension to a previous one in the dataset      */
+      /* When we'll use the compression mode, the space used by unused values would be easily compressed       */
+  
+      if ((dataspace = H5Screate_simple(1,size,NULL)) < 0)
+       return -1;
+      if ((dataset = H5Dcreate(pere,nom,type_hdf,dataspace,
+                              H5P_DEFAULT)) < 0)
+       return -1;      
+    }
+  else
+    if (mode != MED_REMP)
+      {
+       H5Dclose(dataset);
+       return -1;
+      }
+    else
+      if ((dataspace = H5Dget_space(dataset)) <0)
+       return -1;
+
+
+  switch(interlace) 
+    {  /* switch Interlace */
+    case MED_FULL_INTERLACE :
+      
+      /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/
+      if ( fixdim != MED_ALL) 
+       { 
+         firstdim = fixdim-1;
+         lastdim  = fixdim;
+         dimutil  = 1;
+       } else  {
+         firstdim = 0;
+         lastdim  = nbdim;
+         dimutil  = nbdim; 
+       }
+
+      count [0] = (*size)/(nbdim);
+
+
+      if ( psize == MED_NOPF ) {  
+
+       /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
+       if ( (memspace = H5Screate_simple (1, size, NULL)) <0)
+         return -1;
+       
+       stride[0] = nbdim;  
+
+       for (dim=firstdim; dim < lastdim; dim++) {
+         
+         start_mem[0] = dim;
+         if ( (ret = H5Sselect_hyperslab (memspace, H5S_SELECT_SET, start_mem, stride, 
+                                          count, NULL)) <0)
+           return -1; 
+         
+         start_data[0] = dim*count[0];
+         if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL, 
+                                          count, NULL)) <0)
+           return -1; 
+         
+         if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,
+                             H5P_DEFAULT, val)) < 0)
+           return -1;
+       }
+       
+      } else { /* psize != MED_NOPF */
+       
+       pflsize [0] = psize*ngauss*nbdim;
+       pcount  [0] = psize*ngauss*dimutil;
+       pflmem      = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]);
+       pfldsk      = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]);
+       
+       switch(pflmod)
+         { /* switch pflmod pout FULL_INTERLACE*/
+         case MED_GLOBALE :
+
+           /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
+           if ( (memspace = H5Screate_simple (1, size, NULL)) <0)
+             return -1;
+
+           for (dim=firstdim; dim < lastdim; dim++) {
+             
+             for (i=0; i < psize; i++)              /* i balaye les élements du profil */
+               for (j=0; j < ngauss; j++) {         
+                 index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
+                 pflmem[index] = (pfltab[i]-1)*ngauss*nbdim + j*nbdim+dim;
+                 pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;             
+               }
+           }
+            
+           if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pflmem ) ) <0) 
+             return -1; 
+             
+           if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pfldsk ) ) <0) 
+             return -1; 
+           
+           break;
+           
+         case MED_COMPACT :
+
+           /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
+           /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
+           /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */ 
+
+           if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0)
+             return -1;
+           
+           for (dim=firstdim; dim < lastdim; dim++) {
+             
+             for (i=0; i < psize; i++)              /* i balaye les élements du profil */
+               for (j=0; j < ngauss; j++) {         
+                 index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
+                 pflmem[index] = i*ngauss*nbdim + j*nbdim+dim;
+                 pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;             
+               }
+           }
+           
+           if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pflmem ) ) <0) 
+             return -1; 
+           
+           if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pfldsk ) ) <0) 
+             return -1; 
+            
+           break;
+         
+         default :
+           return -1; 
+         }
+
+       if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
+         return -1;
+       
+       free(pflmem);
+       free(pfldsk);
+      }
+      
+      
+      break;
+      
+    case MED_NO_INTERLACE :
+
+      /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/
+
+      count[0] = (*size)/nbdim;
+
+      if ( psize == MED_NOPF ) {  
+       
+       if ( fixdim != MED_ALL) 
+         start_data[0] = (fixdim-1)*count[0];
+       else {
+         count[0] = *size;
+         start_data[0] =  0;
+       };
+       
+       if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL, 
+                                        count, NULL)) <0)
+         return -1; 
+       
+       if ((ret = H5Dwrite(dataset,type_hdf,dataspace,dataspace,
+                           H5P_DEFAULT, val)) < 0)
+         return -1;
+       
+      } else {
+
+       if ( fixdim != MED_ALL) 
+         { 
+           firstdim = fixdim-1;
+           lastdim  = fixdim;
+           dimutil  = 1;
+         } else        {
+           firstdim = 0;
+           lastdim  = nbdim;
+           dimutil  = nbdim; 
+         }
+       
+       pflsize [0] = psize*ngauss*nbdim;
+       pcount  [0] = psize*ngauss*dimutil; /* nom pas très coherent avec count !!! A revoir */ 
+       pfldsk     = (med_ssize *) malloc(sizeof(med_ssize)*pcount[0]);
+
+       switch(pflmod)
+         { /*switch plfmod pour NO_INTERLACE */
+         case MED_GLOBALE :
+           
+           for (dim=firstdim; dim < lastdim; dim++) {
+             
+             for (i=0; i < psize; i++)              /* i balaye le nbre d'élements du profil                */
+               for (j=0; j < ngauss; j++) { 
+                 index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
+                 pfldsk[index] = dim*count[0]+(pfltab[i]-1)*ngauss+j;      
+               }
+           }
+           
+           if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], (const hssize_t **) pfldsk ) ) <0) 
+             return -1;
+           
+           if ((ret = H5Dwrite(dataset,type_hdf,dataspace,dataspace,H5P_DEFAULT, val)) < 0)
+             return -1;
+           
+           break;
+           
+         case MED_COMPACT :
+           
+           /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
+           /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
+           /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */ 
+
+           if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0)
+             return -1;
+
+           pflmem     = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]);
+           
+           /* Le profil COMPACT est contigüe, mais il est possible que l'on selectionne uniquemenent une dimension*/
+           
+           for (dim=firstdim; dim < lastdim; dim++) {
+             
+             for (i=0; i < psize; i++)              /* i balaye le nbre d'élements du profil                */
+               for (j=0; j < ngauss; j++) {
+                 index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
+                 pflmem[index] = dim*(psize*ngauss) + (pfltab[i]-1)*ngauss+j;
+                 pfldsk[index] = dim*count[0]  + (pfltab[i]-1)*ngauss+j;           
+               }
+           }
+            
+           if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET,pcount[0], (const hssize_t **) pflmem ) ) <0) 
+             return -1; 
+             
+           if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], (const hssize_t **) pfldsk ) ) <0) 
+             return -1;
+          
+           if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
+             return -1;
+
+           free(pflmem);
+           
+           break;
+           
+         default :
+           return -1;      
+           
+         }
+   
+       free(pfldsk);
+       
+      };
+
+      break;
+      
+    default :
+      return -1;
+    }
+  
+  
+  if (memspace) 
+    if ((ret = H5Sclose(memspace)) < 0)
+      return -1;
+  
+  if ((ret = H5Sclose(dataspace)) < 0)
+    return -1;
+  
+  if ((ret = H5Dclose(dataset)) < 0)
+    return -1;      
+
+#if defined(PCLINUX)
+  if (type == MED_INT32)
+      if ((H5Tconvert(H5T_STD_I32BE,H5T_NATIVE_INT,(hsize_t)*size,(void *)val,NULL,NULL)) < 0) 
+         return -1;
+#endif 
+  
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDdatasetNumLire.cxx b/src/MEDWrapper/V2_1/MEDdatasetNumLire.cxx
new file mode 100644 (file)
index 0000000..8195e36
--- /dev/null
@@ -0,0 +1,349 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDdatasetNumLire
+ * - Description : lecture d'un dataset tableau numerique
+ * - Parametres :
+ *     - pere (IN)     : l'ID de l'objet HDF pere ou placer l'attribut
+ *     - nom  (IN)     : le nom du dataset
+ *     - type (IN)     : type numerique MED
+ *     - interlace (IN) : Choix du type d'entrelacement demandé par l'appelant { MED_FULL_INTERLACE(x1,y1,z1,x2,...)) , MED_NO_INTERLACE(x1,x2,y1,y2,z1,z2) }
+ *       - nbdim   (IN) : Dimension des éléments
+ *       - fixdim  (IN) : MED_ALL ou n° de la dimension a enregistrer à partir de 1..oo
+ *     - psize     (IN) : Taille du profil à utiliser, MED_NOPF si pas de profil
+ *       - pfltab  (IN) : Tableau contenant les n° déléments à traiter (1....oo)
+ *       - pflmod  (IN) : PARAMETRE A AJOUTER : Indique comment lire les informations en mémoire { MED_COMPACT, MED_GLOBALE }. 
+ *       - ngauss  (IN) : Nombre de points de GAUSS par élément
+ *     - val  (OUT)    : valeurs du tableau
+ * - Resultat : 0 en cas de succes, -1 sinon
+ *  Equivalent à l'ancienne routine si .....,MED_NO_INTERLACE,1,MED_ALL,MED_NOPF,0,1 (peu importe),....
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDdatasetNumLire(med_idt pere,char *nom,med_type_champ type,
+                  med_mode_switch interlace, med_size nbdim, med_size fixdim, 
+                  med_size psize, med_ssize * pfltab, med_int ngauss,
+                  unsigned char *val)
+{
+  med_idt    dataset, dataspace = 0, memspace = 0;
+  med_ssize  start_mem[1],start_data[1],*pflmem=0,*pfldsk=0;
+  med_size   stride[1],count[1],pcount[1],size[1],pflsize[1];
+  med_err    ret;
+  int        i,j,index,type_hdf;
+  hid_t      datatype;
+  size_t     typesize;
+  int        dim, firstdim, dimutil, lastdim;
+  med_mode_profil pflmod;
+
+  /* Verify fixdim is between [0, nbdim] ( 0 is MED_ALL ) */
+  if ( ( fixdim < 0 ) || ( fixdim > nbdim ) ) 
+    return -1;
+  /* block pflmod to MED_COMPACT (until med2.2) */
+  pflmod = MED_COMPACT;
+
+  switch(type)
+    {
+    case MED_REEL64 :
+      /* 1) IA32 is LE but due to an (?HDF convertion BUG?) when using H5T_NATIVE_DOUBLE/MED_REEL64? under PCLINUX
+        the file read under SGI is incorrect
+        2) Compaq OSF/1 is LE, since we force SGI64,SUN4SOL2,HP to write double in LE even if they are BE, mips OSF/1 must be BE
+        REM  : Be careful of compatibility between MED files when changing this (med2.2)                    */
+#if defined(PCLINUX) || defined(OSF1)
+      type_hdf = H5T_IEEE_F64BE;
+#else 
+      type_hdf = H5T_IEEE_F64LE;
+#endif
+      break;
+
+    case MED_INT32 :
+      type_hdf = H5T_NATIVE_INT;
+      break;
+
+    case MED_INT64 :
+      type_hdf = H5T_NATIVE_LONG;
+      break;
+
+    default :
+      return -1;
+    }
+
+  /* Ouverture du Dataset à lire */
+  if ((dataset = H5Dopen(pere,nom)) < 0)
+    return -1;
+
+  /* Interrogation de la taille du dataset */
+  if ( (datatype  = H5Dget_type(dataset )) < 0) return -1;
+  if ( (typesize  = H5Tget_size(datatype)) < 0) return -1;
+  size[0] = H5Dget_storage_size(dataset) / typesize; 
+  if ( H5Tclose(datatype) < 0) return -1;
+
+  /* Create dataspace */
+  if ((dataspace = H5Screate_simple(1,size,NULL)) < 0)
+    return -1;
+  
+  switch(interlace)
+    {
+    case MED_FULL_INTERLACE :
+
+      /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/
+      if ( fixdim != MED_ALL) 
+       { 
+         firstdim = fixdim-1;
+         lastdim  = fixdim;
+         dimutil  = 1;
+       } else  {
+         firstdim = 0;
+         lastdim = nbdim;
+         dimutil  = nbdim; 
+       }
+
+      count [0] = (*size)/(nbdim);
+      
+
+      /*rem: Pas de vérification de l'assertion (*size)=n*nbdim */
+      if ( psize == MED_NOPF ) {  
+
+      /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
+      if ( (memspace = H5Screate_simple (1, size, NULL)) <0)
+       return -1;
+
+       stride[0] = nbdim;  
+
+       for (dim=firstdim; dim < lastdim; dim++) {
+                 
+         start_mem[0] = dim;
+         if ( (ret = H5Sselect_hyperslab (memspace, H5S_SELECT_SET, start_mem, stride, 
+                                          count, NULL)) <0)
+           return -1; 
+         
+         start_data[0] = dim*count[0];
+         if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL, 
+                                          count, NULL)) <0)
+           return -1; 
+         
+         if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,
+                            H5P_DEFAULT, val)) < 0)
+           return -1;
+       }
+       
+      } else {
+
+       pflsize [0] = psize*ngauss*nbdim;
+       pcount  [0] = psize*ngauss*dimutil;
+       pflmem     = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]);
+       pfldsk     = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]);
+       
+       switch(pflmod)
+         { /* switch pflmod pour FULL_INTERLACE*/
+         case MED_GLOBALE :
+
+           /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
+           if ( (memspace = H5Screate_simple (1, size, NULL)) <0)
+             return -1;
+
+           for (dim=firstdim; dim < lastdim; dim++) {
+             
+             for (i=0; i < psize; i++)              /* i balaye les élements du profil */
+               for (j=0; j < ngauss; j++) {         
+                 index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
+                 pflmem[index] = (pfltab[i]-1)*ngauss*nbdim + j*nbdim+dim;
+                 pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;             
+               }
+           }
+           
+           if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], (const hssize_t **) pflmem ) ) <0) 
+             return -1; 
+           
+           if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pfldsk ) ) <0) 
+             return -1; 
+           
+           break;
+       
+         case MED_COMPACT :
+       
+           /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
+           /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
+           /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */ 
+           
+           if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0)
+             return -1;
+           
+           for (dim=firstdim; dim < lastdim; dim++) {
+             
+             for (i=0; i < psize; i++)              /* i balaye les élements du profil */
+               for (j=0; j < ngauss; j++) {         
+                 index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
+                 pflmem[index] = i*ngauss*nbdim + j*nbdim+dim;
+                 pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;             
+               }             
+           }
+           
+           if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], (const hssize_t **) pflmem ) ) <0) 
+             return -1; 
+           
+           if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pfldsk ) ) <0) 
+             return -1; 
+           
+           break;
+
+         default :
+           return -1; 
+         }
+       
+       if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
+         return -1;
+       
+       free(pflmem);
+       free(pfldsk);
+      }
+      
+      break;
+      
+    case MED_NO_INTERLACE :
+
+      /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/
+
+      count[0] = (*size)/nbdim;
+      
+      if ( psize == MED_NOPF ) {  
+       
+       if ( fixdim != MED_ALL) 
+         start_data[0] = (fixdim-1)*count[0];
+       else {
+         count[0] = *size;
+         start_data[0] =  0;
+       };
+       
+       if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL, 
+                                        count, NULL)) <0)
+         return -1; 
+       
+       if ((ret = H5Dread(dataset,type_hdf,dataspace,dataspace,
+                          H5P_DEFAULT, val)) < 0)
+         return -1;
+       
+      } else {
+
+       if ( fixdim != MED_ALL) 
+         { 
+           firstdim = fixdim-1;
+           lastdim  = fixdim;
+           dimutil  = 1;
+         } else        {
+           firstdim = 0;
+           lastdim  = nbdim;
+           dimutil  = nbdim; 
+         }
+
+       pflsize [0] = psize*ngauss*nbdim;       
+       pcount  [0] = psize*ngauss*dimutil; /* nom pas très coherent avec count !!! A revoir */ 
+       pfldsk      = (med_ssize *) malloc(sizeof(med_ssize)*pcount[0]);
+       
+       switch(pflmod)
+         { /*switch plfmod pour NO_INTERLACE */
+         case MED_GLOBALE :
+           
+           for (dim=firstdim; dim < lastdim; dim++) {
+             
+             for (i=0; i < psize; i++)              /* i balaye le nbre d'élements du profil                */
+               for (j=0; j < ngauss; j++) { 
+                 index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
+                 pfldsk[index] = dim*count[0]+(pfltab[i]-1)*ngauss+j;      
+               }
+           }
+           
+           if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], (const hssize_t **) pfldsk ) ) <0) 
+             return -1;
+           
+           if ((ret = H5Dread(dataset,type_hdf,dataspace,dataspace,H5P_DEFAULT, val)) < 0)
+             return -1;
+             
+           break;
+           
+         case MED_COMPACT :
+           
+           /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
+           /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
+           /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */ 
+
+           if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0)
+             return -1;
+
+           pflmem     = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]);
+           
+           /* Le profil COMPACT est contigüe, mais il est possible que l'on selectionne uniquemenent une dimension*/
+
+           for (dim=firstdim; dim < lastdim; dim++) {
+             
+             for (i=0; i < psize; i++)              /* i balaye le nbre d'élements du profil                */
+               for (j=0; j < ngauss; j++) {
+                 index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
+                 pflmem[index] = dim*(psize*ngauss) + (pfltab[i]-1)*ngauss+j;
+                 pfldsk[index] = dim*count[0]  + (pfltab[i]-1)*ngauss+j;           
+               }
+           }
+           
+           if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], (const hssize_t **) pflmem ) ) <0) 
+             return -1; 
+           
+           if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], (const hssize_t **) pfldsk ) ) <0) 
+             return -1;          
+           
+           if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
+             return -1;
+           
+           break;
+           
+         default :
+           return -1;      
+           
+         }
+       
+       free(pfldsk);
+       
+      };
+      
+      break;
+      
+    default :
+      return -1;
+    }
+  
+  
+
+  if (memspace) 
+    if ((ret = H5Sclose(memspace)) < 0)
+      return -1;
+
+  if ((ret = H5Sclose(dataspace)) < 0)
+    return -1;
+  
+  if ((ret = H5Dclose(dataset)) < 0)
+    return -1;      
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDdatasetOuvrir.cxx b/src/MEDWrapper/V2_1/MEDdatasetOuvrir.cxx
new file mode 100644 (file)
index 0000000..b3e852c
--- /dev/null
@@ -0,0 +1,44 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDdatasetOuvrir
+ * - Description : ouverture d'un objet HDF dataset
+ * - Parametres :
+ *     - pid  (IN)     : l'ID de l'objet HDF pere 
+ *     - nom  (IN)     : le nom du dataset
+ * - Resultat : ID du dataset en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_idt
+_MEDdatasetOuvrir(med_idt pid,char *nom)
+{
+  med_idt id;
+
+  if ((id = H5Dopen(pid,nom)) < 0)
+    return -1;
+
+  return id;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDdatasetStringEcrire.cxx b/src/MEDWrapper/V2_1/MEDdatasetStringEcrire.cxx
new file mode 100644 (file)
index 0000000..651f5a8
--- /dev/null
@@ -0,0 +1,87 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDdatasetStringEcrire
+ * - Description : ecriture d'un dataset tableau de caracteres
+ * - Parametres :
+ *     - pere (IN)     : l'ID de l'objet HDF pere ou placer l'attribut
+ *     - nom  (IN)     : le nom de l'attribut 
+ *     - dimd (IN)     : profil du tableau
+ *     - val  (IN)     : valeurs du tableau
+ *     - mode (IN)     : mode d'ecriture MED
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDdatasetStringEcrire(med_idt pere,char *nom,med_size *dimd,
+                       char *val, med_mode_acces mode)
+{
+  med_idt dataset;
+  med_idt datatype = 0;
+  med_idt dataspace = 0;
+  med_err ret;
+
+  if ((dataset = H5Dopen(pere,nom)) < 0)
+    {
+      if ((dataspace = H5Screate_simple(1,dimd,NULL)) < 0)
+       return -1;
+      if((datatype = H5Tcopy(H5T_C_S1)) < 0)
+       return -1;
+      if((ret = H5Tset_size(datatype,1)) < 0)
+       return -1;
+      if ((dataset = H5Dcreate(pere,nom,datatype,dataspace,
+                            H5P_DEFAULT)) < 0)
+       return -1;    
+    }
+  else
+    if (mode != MED_REMP)
+      {
+       H5Dclose(dataset);
+       return -1;
+      }
+    else
+      {
+      if ((dataspace = H5Screate_simple(1,dimd,NULL)) < 0)
+       return -1;
+      if((datatype = H5Tcopy(H5T_C_S1)) < 0)
+       return -1;
+      if((ret = H5Tset_size(datatype,1)) < 0)
+       return -1;
+      }
+  if ((ret = H5Dwrite(dataset,datatype,H5S_ALL,H5S_ALL,
+                     H5P_DEFAULT, val)) < 0)
+    return -1;
+  if (dataspace)
+    if((ret = H5Sclose(dataspace)) < 0)
+      return -1;
+  if (datatype)
+    if ((ret = H5Tclose(datatype)) < 0)
+      return -1;
+  if ((ret = H5Dclose(dataset)) < 0)
+    return -1;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDdatasetStringLire.cxx b/src/MEDWrapper/V2_1/MEDdatasetStringLire.cxx
new file mode 100644 (file)
index 0000000..017ccbf
--- /dev/null
@@ -0,0 +1,56 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDdatasetStringLire
+ * - Description : lecture d'un dataset tableau de caracteres
+ * - Parametres :
+ *     - pere (IN)     : l'ID de l'objet HDF pere ou placer l'attribut
+ *     - nom  (IN)     : le nom de l'attribut 
+ *     - val  (IN)     : valeurs du tableau
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDdatasetStringLire(med_idt pere,char *nom,char *val)
+{
+  med_idt dataset,datatype;
+  med_err ret;
+
+  if ((dataset = H5Dopen(pere,nom)) < 0)
+    return -1;
+  if ((datatype = H5Tcopy(H5T_C_S1)) < 0)
+    return -1;
+  if ((ret = H5Tset_size(datatype,1)) < 0)
+    return -1;
+  if ((ret = H5Dread(dataset,datatype,H5S_ALL,H5S_ALL,H5P_DEFAULT,val)) < 0)
+     return -1;
+  if ((ret = H5Tclose(datatype)) < 0)
+    return -1;
+  if ((ret = H5Dclose(dataset)) < 0)
+    return -1;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDdimLire.cxx b/src/MEDWrapper/V2_1/MEDdimLire.cxx
new file mode 100644 (file)
index 0000000..3ca50c6
--- /dev/null
@@ -0,0 +1,62 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+med_int
+MEDdimLire(med_idt fid, char *maillage)
+{
+  med_idt maaid;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  med_int dim;
+
+  /*
+   * On inhibe le gestionnaire d'erreur
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * On regarde si le groupe existe => erreur si non 
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maillage);  
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;
+
+  /*
+   * On va lire l'attribut dimension
+   */
+  if ((ret = _MEDattrEntierLire(maaid,MED_NOM_DIM,&dim)) < 0)
+    return -1;
+
+  /*
+   * Fermetures des objets HDF 
+   */
+  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+    return -1;
+
+  return dim;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDelementsEcr.cxx b/src/MEDWrapper/V2_1/MEDelementsEcr.cxx
new file mode 100644 (file)
index 0000000..e67b44d
--- /dev/null
@@ -0,0 +1,54 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+
+namespace med_2_1{
+
+med_err
+MEDelementsEcr(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch,
+              char *nom,med_booleen inom,med_int *num,med_booleen inum,
+              med_int *fam,med_int nele,med_entite_maillage typ_ent, 
+              med_geometrie_element typ_geo,med_connectivite typ_conn,
+              med_mode_acces mode)
+{
+  med_err ret;
+
+  /* Ecriture de la connectivite */
+  if ((ret = MEDconnEcr(fid,maa,mdim,connectivite,mode_switch,nele,mode,typ_ent,typ_geo,
+                       typ_conn)) < 0)
+    return -1;
+
+  /* Ecriture des noms */
+  if (inom == MED_VRAI)
+    if ((ret = MEDnomEcr(fid,maa,nom,nele,mode,typ_ent,typ_geo)) < 0)
+      return -1;
+
+  /* Ecriture des numeros */
+  if (inum == MED_VRAI)
+    if ((ret = MEDnumEcr(fid,maa,num,nele,mode,typ_ent,typ_geo)) < 0)
+      return -1;
+
+  /* Ecriture des numeros de familles */
+  if ((ret = MEDfamEcr(fid,maa,fam,nele,mode,typ_ent,typ_geo)) < 0)
+    return -1;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDelementsLire.cxx b/src/MEDWrapper/V2_1/MEDelementsLire.cxx
new file mode 100644 (file)
index 0000000..bdd8590
--- /dev/null
@@ -0,0 +1,55 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+
+namespace med_2_1{
+
+med_err
+MEDelementsLire(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch,
+              char *nom,med_booleen *inom,med_int *num,med_booleen *inum,
+              med_int *fam,med_int nele,med_entite_maillage typ_ent, 
+              med_geometrie_element typ_geo,med_connectivite typ_conn)
+{
+  med_err ret;
+
+  /* Lecure de la connectivite */
+  if ((ret = MEDconnLire(fid,maa,mdim,connectivite,mode_switch,0,MED_NOPF,
+                        typ_ent,typ_geo,typ_conn)) < 0)
+    return -1;
+
+  /* Lecture des noms */
+  if ((ret = MEDnomLire(fid,maa,nom,nele,typ_ent,typ_geo)) < 0)
+    *inom = MED_FAUX;
+  else
+    *inom = MED_VRAI;
+
+  /* Lecture des numeros */
+  if ((ret = MEDnumLire(fid,maa,num,nele,typ_ent,typ_geo)) < 0)
+    *inum = MED_FAUX;
+  else
+    *inum = MED_VRAI;
+
+  /* Lecture des numeros de familles */
+  if ((ret = MEDfamLire(fid,maa,fam,nele,typ_ent,typ_geo)) < 0)
+    return -1;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDequivCr.cxx b/src/MEDWrapper/V2_1/MEDequivCr.cxx
new file mode 100644 (file)
index 0000000..a5a3b81
--- /dev/null
@@ -0,0 +1,78 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_err 
+MEDequivCr(med_idt fid,char *maa, char *eq, char *desc)
+{
+  med_idt root,eqid;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+MED_TAILLE_NOM+1];
+  char tmp[MED_TAILLE_EQS+1];
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /* 
+   * Si le Data Group "EQS" n'existe pas, on le cree
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  strncpy(tmp,MED_EQS,MED_TAILLE_EQS-1);
+  tmp[MED_TAILLE_EQS-1] = '\0';
+  strcat(chemin,tmp);
+  if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    if ((root = _MEDdatagroupCreer(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * Si une equivalence du meme nom existe => erreur
+   * Sinon on la cree
+   */
+  if ((eqid = _MEDdatagroupOuvrir(root,eq)) >= 0)
+    return -1;
+  if ((eqid = _MEDdatagroupCreer(root,eq)) < 0)
+    return -1;
+
+  /*
+   * L'attribut "DES"
+   */
+  if ((ret = _MEDattrStringEcrire(eqid,MED_NOM_DES,MED_TAILLE_DESC,desc,MED_REMP)) < 0)
+    return -1;
+
+  /*
+   * On ferme tout 
+   */
+  if ((ret = _MEDdatagroupFermer(eqid)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(root)) < 0)
+    return -1;
+
+  return 0 ; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDequivEcr.cxx b/src/MEDWrapper/V2_1/MEDequivEcr.cxx
new file mode 100644 (file)
index 0000000..dfa3f72
--- /dev/null
@@ -0,0 +1,111 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+extern int mode_interlace; 
+
+namespace med_2_1{
+
+med_err 
+MEDequivEcr(med_idt fid, char *maa, char *eq, med_int *corr, med_int n, 
+           med_mode_acces mode, med_entite_maillage typ_ent, med_geometrie_element typ_geo)
+{
+  med_idt eqid, datagroup;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1]; 
+  char nomdatagroup[MED_TAILLE_NOM+1];
+  char tmp[MED_TAILLE_NOM_ENTITE+1];
+  med_size dimd[1];
+
+  if (typ_geo == MED_TETRA4 || typ_geo == MED_TETRA10 ||
+      typ_geo == MED_HEXA8  || typ_geo == MED_HEXA20  ||
+      typ_geo == MED_PENTA6 || typ_geo == MED_PENTA15 ||
+      typ_geo == MED_PYRA5  || typ_geo == MED_PYRA13)
+    return -1;
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /* 
+   * Si le Data Group de "eq" n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  strcat(chemin,MED_EQS);
+  strcat(chemin,eq);
+  if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;  
+
+  /*
+   * Ecriture de l'equivalence
+   */
+  if ((ret = _MEDnomEntite(nomdatagroup,typ_ent)) < 0)
+    return -1;
+  if ((typ_ent != MED_NOEUD))
+    {
+      if ((ret = _MEDnomGeometrie(tmp,typ_geo)) < 0)
+       return -1;
+      strcat(nomdatagroup,".");
+      strcat(nomdatagroup,tmp);
+    }
+  datagroup = 0;
+  if (((datagroup = _MEDdatagroupOuvrir(eqid,nomdatagroup)) > 0) && 
+      (mode != MED_REMP))
+    return -1;
+  else
+    if (datagroup > 0)
+      _MEDdatagroupFermer(datagroup);
+
+  /* EF : verifier que çà marche si le data groupe existe déjà */
+  if ((datagroup = _MEDdatagroupCreer(eqid,nomdatagroup)) < 0)
+    return -1;
+
+  if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n,mode)) < 0)
+    return -1;
+
+  dimd[0] = 2*n;
+
+#if defined(IRIX64)||defined(OSF1)
+  if ((ret =  _MEDdatasetNumEcrire(datagroup,MED_NOM_COR,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
+                               (unsigned char*) corr,mode)) < 0)
+    return -1;
+#else
+  if ((ret =  _MEDdatasetNumEcrire(datagroup,MED_NOM_COR,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
+                               (unsigned char*) corr,mode)) < 0)
+    return -1;
+#endif
+
+  /*
+   * On ferme tout 
+   */
+  if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(eqid)) < 0)
+    return -1;
+
+  return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDequivInfo.cxx b/src/MEDWrapper/V2_1/MEDequivInfo.cxx
new file mode 100644 (file)
index 0000000..e031dec
--- /dev/null
@@ -0,0 +1,73 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_err
+MEDequivInfo(int fid, char *maa, int ind, char *eq, char *des)
+{
+  med_idt eqid;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1];
+  int num;
+  int idx;
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * On recupere le nom de l'equivalence
+   */
+  num = ind - 1;
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  strcat(chemin,MED_EQS); 
+  if ((idx = _MEDobjetIdentifier(fid,chemin,num,eq)) < 0)
+    return -1;
+
+  /* 
+   * Si le Data Group eq n'existe pas => erreur
+   */
+  strcat(chemin,eq);
+  if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * L'attribut "DES"
+   */
+  if ((ret = _MEDattrStringLire(eqid,MED_NOM_DES,MED_TAILLE_DESC,des)) < 0)
+    return -1;
+
+  /*
+   * On ferme tout 
+   */
+  if ((ret = _MEDdatagroupFermer(eqid)) < 0)
+    return -1;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDequivLire.cxx b/src/MEDWrapper/V2_1/MEDequivLire.cxx
new file mode 100644 (file)
index 0000000..824e21c
--- /dev/null
@@ -0,0 +1,99 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+extern int mode_interlace; 
+
+namespace med_2_1{
+
+med_err 
+MEDequivLire(med_idt fid, char *maa, char *eq, med_int *corr, med_int n,
+            med_entite_maillage typ_ent,med_geometrie_element typ_geo)
+{
+  med_idt eqid, datagroup;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1]; 
+  char nomdatagroup[MED_TAILLE_NOM+1];
+  char tmp[MED_TAILLE_NOM_ENTITE+1];
+
+  if (typ_geo == MED_TETRA4 || typ_geo == MED_TETRA10 ||
+      typ_geo == MED_HEXA8  || typ_geo == MED_HEXA20  ||
+      typ_geo == MED_PENTA6 || typ_geo == MED_PENTA15 ||
+      typ_geo == MED_PYRA5  || typ_geo == MED_PYRA13)
+    return -1;
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /* 
+   * Si le Data Group de "eq" n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  strcat(chemin,MED_EQS);
+  strcat(chemin,eq);
+  if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;  
+
+  /*
+   * Lecture de l'equivalence
+   */
+  if ((ret = _MEDnomEntite(nomdatagroup,typ_ent)) < 0)
+    return -1;
+  if ((typ_ent != MED_NOEUD))
+    {
+      if ((ret = _MEDnomGeometrie(tmp,typ_geo)) < 0)
+       return -1;
+      strcat(nomdatagroup,".");
+      strcat(nomdatagroup,tmp);
+    }
+  if ((datagroup = _MEDdatagroupOuvrir(eqid,nomdatagroup)) < 0)
+    return -1;
+#if defined(IRIX64)||defined(OSF1)
+  if ((ret =  _MEDdatasetNumLire(datagroup,MED_NOM_COR,MED_INT64,
+                                MED_NO_INTERLACE,1,MED_ALL,
+                                MED_NOPF,0,MED_NOPG,
+                                (unsigned char *) corr)) < 0)
+    return -1;
+#else
+  if ((ret =  _MEDdatasetNumLire(datagroup,MED_NOM_COR,MED_INT32,
+                                MED_NO_INTERLACE,1,MED_ALL,
+                                MED_NOPF,0,MED_NOPG,
+                                (unsigned char *) corr)) < 0)
+    return -1;
+#endif
+
+  /*
+   * On ferme tout 
+   */
+  if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(eqid)) < 0)
+    return -1;
+
+  return 0;  
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfam2groA.cxx b/src/MEDWrapper/V2_1/MEDfam2groA.cxx
new file mode 100644 (file)
index 0000000..b964f81
--- /dev/null
@@ -0,0 +1,208 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "med.hxx"
+
+
+/***********************************************************************
+ * FONCTION MEDfam2groA
+ * 
+ * - DESCRIPTION : 1ere etape dans la conversion des familles de groupes
+ *      MED en goupes de noeuds et d'elements.
+ *      Calcul des tailles des tableaux a allouer pour stocker les
+ *      groupes que l'on veut creer.
+ *      Les parametres renvoyes sont :
+ *      1 - le nombre de groupes de noeuds a creer (ngn)
+ *      2 - le nombre de groupes d'elements (nge)
+ *      3 - le nombre total de noeuds composant l'ensemble des groupes
+ *          de noeuds (nindn)
+ *      4 - le nombre total d'elements composant l'ensemble des groupes
+ *          d'elements (ninde)
+ *      Ces parametres doivent permettre de creer les tables suivantes :
+ *      1 - une table de taille (nindn) contenant pour chaque groupe
+ *          de noeuds la liste des noeuds le composant. Cette table
+ *          sera indexee par une table de taille (ngn) qui contiendra
+ *          pour chaque noeud un numero d'indice. Une table de taille
+ *          (ngn) qui contiendra la liste des noms des differents
+ *          groupes de noeuds.
+ *      2 - idem pour les elements
+ *      Le remplissage de ces tables est realise par la fonction 
+ *      MEDfam2groB().
+ *
+ * - PARAMETRES :
+ *   NOM            .E/S. TYPE    .  DESCRIPTION
+ *   ------------------------------------------------------------------- 
+ *   nfam           .E  . med_int . nombre de familles
+ *   numfam         .E  . med_int*. table des numeros de familles
+ *   numfamnoe      .E  . med_int*. table des numeros de familles
+ *                  .   .         . des noeuds
+ *   nnoeuds        .E  . med_int . nombre de noeuds
+ *   numfamele      .E  . med_int*. table des numeros de familles
+ *                  .   .         . des elements
+ *   nelememts      .E  .         . nombre total d'elements
+ *   grofam         .E  . char*   . liste des groupes de familles
+ *   indfamgro      .E  . int*    . liste des indices des groupes
+ *                  .   .         . de familles dans grofam
+ *   ngn            .  S. med_int*. nombre de groupes de noeuds a
+ *                  .             . creer
+ *   nge            .  S. med_int*. nombre de groupes d'elements a
+ *                  .             . creer
+ *   nindn          .  S. med_int*. taille de la table
+ *                  .             . des groupes de noeuds a creer
+ *   ninde          .  S. med_int*. taille de la table
+ *                  .             . des groupes d'elements
+ *
+ * - RESULTAT : 0 si succes et -1 sinon
+ * 
+ ***********************************************************************/
+
+namespace med_2_1{
+
+med_err 
+MEDfam2groA (med_int nfam,med_int *numfam,med_int *numfamnoe, 
+            med_int nnoeuds,med_int *numfamele,med_int nelements, 
+            char *grofam,int *indfamgro, 
+            med_int *ngn,med_int *nge,med_int *nindn,med_int *ninde)
+{
+  int i,j,k;
+  char groupe[MED_TAILLE_LNOM];
+  char *nomgronoe,*nomgroele,*tmp;
+  med_int numc;
+  int nnoe = 0,nele = 0;
+  int flag = 0;
+
+  *ngn = 0;
+  *nge = 0;
+  *nindn = 0;
+  *ninde = 0;
+  
+  tmp = NULL;
+  nomgronoe = NULL;
+  nomgroele = NULL;
+
+  /* Pour chaque famille, on regarde s'il y a de nouveaux groupes
+     de noeuds ou d'elements a creer. Pour chaque nouveau groupe,
+     on compte le nombre de noeuds ou d'elements qui devront lui etre
+     rataches */
+  for (i=1;i<=nfam;i++)
+    if ((*(indfamgro+i)-*(indfamgro+i-1))/MED_TAILLE_LNOM > 0) 
+      {
+       /* on releve le numero de la famille courante */
+        numc = *(numfam+i-1);
+       nnoe = 0;
+       nele = 0;
+        /* si c'est une famille de noeuds, on compte le nombre de
+           noeuds qui y sont rattaches */
+        if (numc > 0)
+         for (j=0;j<nnoeuds;j++)
+           if (*(numfamnoe+j) == numc)
+             nnoe++;
+        /* si c'est une famille d'elements, on compte le nombre d'elements
+           qui y sont rattaches */
+       if (numc < 0)
+         for (j=0;j<nelements;j++)
+           if (*(numfamele+j) == numc)
+             nele++;     
+        /* on parcourt la liste des groupes de la famille et pour chaque
+           groupe :
+          1 - on met a jour les compteurs nindn et ninde ;
+           2 - on verifie s'il s'agit d'un groupe deja repertorie.
+               Si c'est le cas on ne fait rien, sinon on met a jour les
+               compteurs ngn ou nge */
+        for (j=0;j<(*(indfamgro+i)-*(indfamgro+i-1))/MED_TAILLE_LNOM;j++)
+         {
+           strncpy(groupe,grofam+*(indfamgro+i-1)+j*MED_TAILLE_LNOM,
+                   MED_TAILLE_LNOM);
+           if (numc > 0)
+             {
+                *nindn = *nindn+nnoe;
+               if (*ngn == 0)
+                 {
+                   *ngn = 1;
+                   if ((nomgronoe=(char*)malloc(sizeof(char)*MED_TAILLE_LNOM))
+                        == NULL)
+                     return -1;
+                   strncpy(nomgronoe,groupe,MED_TAILLE_LNOM);
+                 }
+               else
+                 { 
+                    flag = 0;
+                   for (k=0;k<(*ngn);k++)
+                     if (strncmp(groupe,nomgronoe+k*MED_TAILLE_LNOM,
+                                 MED_TAILLE_LNOM) == 0)
+                       flag = 1;
+                   if (flag == 0)
+                     { 
+                       *ngn = *ngn + 1;
+                       if ((tmp=(char*)malloc(sizeof(char)*
+                                              MED_TAILLE_LNOM**ngn)) == NULL)
+                         return -1;
+                       strncpy(tmp,nomgronoe,MED_TAILLE_LNOM*(*ngn-1));
+                       strncpy(tmp+MED_TAILLE_LNOM*(*ngn-1),groupe, 
+                               MED_TAILLE_LNOM);
+                       free(nomgronoe); 
+                       nomgronoe = tmp;
+                     }
+                 } 
+             } 
+           if (numc < 0)
+             {
+                *ninde = *ninde+nele;
+               if (*nge == 0)
+                 {
+                   *nge = 1;
+                   if ((nomgroele=(char *)malloc(sizeof(char)*
+                                                 MED_TAILLE_LNOM)) == NULL)
+                     return -1;
+                   strncpy(nomgroele,groupe,MED_TAILLE_LNOM);
+                 }
+               else
+                 { 
+                   flag = 0;
+                   for (k=0;k<(*nge);k++)
+                     if (strncmp(groupe,nomgroele+k*MED_TAILLE_LNOM, 
+                                 MED_TAILLE_LNOM) == 0)
+                       flag = 1;
+                   if (flag == 0)
+                     {
+                       *nge = *nge + 1;
+                       if ((tmp = (char*) malloc(sizeof(char)*MED_TAILLE_LNOM*
+                                                 *nge)) == NULL)
+                         return -1;
+                       strncpy(tmp,nomgroele,MED_TAILLE_LNOM*(*nge-1));
+                       strncpy(tmp+MED_TAILLE_LNOM*(*nge-1), groupe, 
+                               MED_TAILLE_LNOM);
+                       free(nomgroele);
+                       nomgroele = tmp;
+                     }
+                 }
+             } 
+         } 
+      }
+
+  /* nettoyage memoire */
+  free(nomgronoe);
+  free(nomgroele);
+  
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfam2groB.cxx b/src/MEDWrapper/V2_1/MEDfam2groB.cxx
new file mode 100644 (file)
index 0000000..3dbea60
--- /dev/null
@@ -0,0 +1,245 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "med.hxx"
+
+/***********************************************************************
+ * FONCTION MEDfam2groB
+ * 
+ * - DESCRIPTION : 2e etape dans la conversion des familles MED en 
+ *      groupes de noeuds et d'elements. Les tables allouees a partir
+ *      des parametres calcules par MEDfam2groA() sont passees en argument
+ *      a MEDfam2groB et remplies par cette derniere fonction.
+ *      Il s'agit de :
+ *      1 - la table des noms de groupes de noeuds, chaque nom ayant
+ *          une taille de MED_TAILLE_LNOM
+ *      2 - la table des noms des groupes d'elements
+ *      3 - la table des groupes de noeuds -i.e. pour chaque groupe
+ *          la liste des numeros des noeuds qui le composent
+ *      4 - la table d'indexation de la table des groupes de noeuds
+ *      5 - la table des groupes d'elements
+ *      6 - la table d'indexation de la table des groupes d'elements
+ *
+ * - PARAMETRES :
+ *   NOM            .E/S. TYPE    . DESCRIPTION
+ *   ------------------------------------------------------------------- 
+ *   nfam           .E  . med_int . nombre de familles
+ *   numfam         .E  . med_int*. table des numeros de familles
+ *   numfamnoe      .E  . med_int*. table des numeros de familles
+ *                  .   .         . des noeuds
+ *   nnoeuds        .E  . med_int . nombre de noeuds
+ *   numfamele      .E  . med_int*. table des numeros de familles
+ *                  .   .         . des elements
+ *   nelememts      .E  . med_int . nombre total d'elements
+ *   grofam         .E  . char*   . liste des groupes de familles
+ *   indfamgro      .E  . int*    . liste des indices des groupes
+ *                  .   .         . de familles dans indfamgro
+ *   numnoeuds      .E  . med_int*. numeros des noeuds
+ *   numele         .E  . med_int*. numeros des elements
+ *   ngn            .E  . med_int . nombre de groupes de noeuds
+ *   nge            .E  . med_int . nombre de groupes d'elements
+ *   nindn          .E  . med_int . nombre d'indices dans la table
+ *                  .             . des groupes de noeuds a creer
+ *   ninde          .E  . med_int . nombre d'indices dans la table
+ *                  .             . des groupes d'elements
+ *   nomgronoe      .  S. char*   . noms des groupes de noeuds
+ *   nomgroele      .  S. char*   . noms des groupes d'elements
+ *   indgronoe      .  S. int*    . indices des groupes de noeuds
+ *   indgroele      .  S. int*    . indices des groupes d'elements
+ *   tabgronoe      .  S. med_int*. table des groupes de noeuds
+ *   tabgroele      .  S. med_int*. table des groupes d'elements
+ *
+ * - RESULTAT : 0
+ * 
+ ***********************************************************************/
+
+namespace med_2_1{
+
+med_err 
+MEDfam2groB(med_int nfam,med_int *numfam,med_int *numfamnoe,
+           med_int nnoeuds,med_int *numfamele,med_int nelements, 
+           char *grofam,int *indfamgro,med_int *numnoeuds,
+           med_int *numele,med_int ngn,med_int nge,med_int nindn, 
+           med_int ninde,char *nomgronoe,char *nomgroele,
+           int *indgronoe,int *indgroele,
+           med_int *tabgronoe,med_int *tabgroele)
+{
+  int i,j,k;
+  char groupe[MED_TAILLE_LNOM];
+  med_int numc;
+  int nnoe = 0, nele = 0;
+  int flag = 0;
+  int nn = 0, ne = 0;
+  int pos, cpt;
+
+  /* initialisations */
+  for (i=0;i<=ngn;i++)
+    *(indgronoe+i) = 0;
+  for (i=0;i<=nge;i++)
+    *(indgroele+i) = 0;
+
+  /* 1ere passe : on passe en revue toutes les familles :
+     1 - on etablit dans (nomgronoe) et dans (nomgroele) les listes 
+     des noms de groupes de noeuds et d'elements
+     2 - on place dans les tables d'index (indgronoe) et (indgroele)
+     le nombre de noeuds ou d'elements que chaque groupe se verra 
+     attribuer */
+  for (i=1;i<=nfam;i++)
+      {
+        numc = *(numfam+i-1);
+       nnoe = 0;
+       nele = 0;
+        if (numc > 0)
+           for (j=0;j<nnoeuds;j++)
+             if (*(numfamnoe+j) == numc)
+               nnoe++;
+       if (numc < 0)
+         for (j=0;j<nelements;j++)
+           if (*(numfamele+j) == numc)
+             nele++;     
+        for (j=0;j<(*(indfamgro+i)-*(indfamgro+i-1))/MED_TAILLE_LNOM; j++)
+         {
+           strncpy(groupe, grofam+*(indfamgro+i-1)+j*MED_TAILLE_LNOM,
+                   MED_TAILLE_LNOM);
+           if (numc > 0)
+             {
+                if (nn == 0)
+                 {
+                   strncpy(nomgronoe,groupe,MED_TAILLE_LNOM);
+                   nn = 1;
+                    pos = 1;
+                 }
+               else
+                 {
+                   flag = 0;
+                   for (k=0; k<nn;k++)
+                     if (strncmp(groupe,nomgronoe+k*MED_TAILLE_LNOM,
+                                 MED_TAILLE_LNOM) == 0)
+                       {
+                         flag = 1;
+                         pos = k+1;
+                       }
+                   if (flag == 0)
+                     {
+                       strncpy(nomgronoe+nn*MED_TAILLE_LNOM,groupe, 
+                               MED_TAILLE_LNOM);
+                       pos = nn + 1;
+                       nn = nn + 1;
+                     }
+                 }
+               *(indgronoe+pos) = *(indgronoe+pos) + nnoe;
+             } 
+           if (numc < 0)
+             {
+                if (ne == 0)
+                 {
+                   strncpy(nomgroele,groupe,MED_TAILLE_LNOM);
+                   ne = 1;
+                   pos = 1;
+                 }
+               else
+                 {
+                   flag = 0;
+                   for (k=0; k<ne;k++)
+                     if (strncmp(groupe,nomgroele+k*MED_TAILLE_LNOM,
+                                 MED_TAILLE_LNOM) == 0)
+                       {
+                         flag = 1;
+                         pos = k + 1;
+                       }
+                   if (flag == 0)
+                     {
+                       strncpy(nomgroele+ne*MED_TAILLE_LNOM,groupe, 
+                               MED_TAILLE_LNOM);
+                       pos = ne + 1;
+                       ne = ne + 1;
+                     }
+                 }
+               *(indgroele+pos) = *(indgroele+pos) + nele;
+             }
+         } 
+      }
+  *(nomgronoe+ngn*MED_TAILLE_LNOM) = '\0';
+  *(nomgroele+nge*MED_TAILLE_LNOM) = '\0';
+
+  /* 2e passe : on construit les listes des index ainsi que les
+     les tables des groupes */
+  for (i=1;i<=ngn;i++)
+    {
+      cpt = 0;
+      *(indgronoe+i) = *(indgronoe+i-1) + *(indgronoe+i);
+      strncpy(groupe,nomgronoe+(i-1)*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
+      for (j=1;j<=nfam;j++)
+         {
+           numc = *(numfam+j-1);
+           if (numc > 0)
+             {
+               flag = 0;
+               for (k=0;k<(*(indfamgro+j)-*(indfamgro+j-1))/MED_TAILLE_LNOM;
+                    k++)
+                 if (! strncmp(groupe,
+                               grofam+*(indfamgro+j-1)+k*MED_TAILLE_LNOM,
+                               MED_TAILLE_LNOM))
+                   flag = 1;
+               if (flag == 1)
+                 for (k=0;k<nnoeuds;k++)
+                   if (*(numfamnoe+k) == numc)
+                     {
+                       *(tabgronoe+*(indgronoe+i-1)+cpt) = *(numnoeuds+k);
+                       cpt++;
+                     }
+             }
+         }
+    }        
+  
+  for (i=1;i<=nge;i++)
+    {
+      cpt = 0;
+      *(indgroele+i) = *(indgroele+i-1) + *(indgroele+i);  
+      strncpy(groupe,nomgroele+(i-1)*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
+      for (j=1;j<=nfam;j++)
+         {
+           numc = *(numfam+j-1);
+           if (numc < 0)
+             {
+               flag = 0;
+               for (k=0;k<(*(indfamgro+j)-*(indfamgro+j-1))/MED_TAILLE_LNOM;
+                    k++)
+                 if (! strncmp(groupe,
+                               grofam+*(indfamgro+j-1)+k*MED_TAILLE_LNOM,
+                               MED_TAILLE_LNOM))
+                   flag = 1;
+               if (flag == 1)
+                 for (k=0;k<nelements;k++)
+                   if (*(numfamele+k) == numc)
+                     {
+                       *(tabgroele+*(indgroele+i-1)+cpt) = *(numele+k);
+                       cpt++;
+                     }
+             }
+         }
+    }
+  
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfamCr.cxx b/src/MEDWrapper/V2_1/MEDfamCr.cxx
new file mode 100644 (file)
index 0000000..19faf22
--- /dev/null
@@ -0,0 +1,171 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_err 
+MEDfamCr(med_idt fid,char* maa,char *famille,med_int numero, 
+        med_int *attr_ident, med_int *attr_val, char *attr_desc, 
+        med_int n_attr,char *groupe, med_int n_groupe)
+{
+  med_idt root, datagroup, famid;
+  med_err ret;
+  med_size dimd[1];
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_FAS+MED_TAILLE_NOM+1];
+  char tmp[MED_TAILLE_FAS+1];
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /* 
+   * Si le Data Group FAS n'existe pas, on le cree
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  strncpy(tmp,MED_FAS,MED_TAILLE_FAS-1);
+  tmp[MED_TAILLE_FAS-1] = '\0';
+  strcat(chemin,tmp);
+  if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    if ((root = _MEDdatagroupCreer(fid,chemin)) < 0)
+      return -1;
+    
+  /*
+   * Si le Data Group de meme nom que famille existe => erreur
+   * Sinon on le cree
+   */
+  if ((famid = _MEDdatagroupOuvrir(root,famille)) >= 0)
+    return -1;
+  if ((famid = _MEDdatagroupCreer(root,famille)) < 0)
+    return -1;
+
+  /*
+   * L'attribut NUM
+   */
+  if ((ret = _MEDattrEntierEcrire(famid,MED_NOM_NUM,&numero,MED_REMP)) < 0)
+    return -1;
+
+  /*
+   * Le Data Group "GRO"
+   */
+  if (n_groupe > 0)
+    {
+      /*
+       * On cree le Data Group 
+       */
+      if ((datagroup = _MEDdatagroupCreer(famid,MED_NOM_GRO)) < 0)
+       return -1;
+
+      /*
+       * L'attribut "NBR"
+       */
+      if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n_groupe,MED_REMP)) < 0)
+       return -1;
+      
+      /* 
+       * Data Set des noms des groupes "NOM"
+       */
+      dimd[0] = n_groupe*MED_TAILLE_LNOM+1;
+      if ((ret = _MEDdatasetStringEcrire(datagroup,MED_NOM_NOM,dimd,groupe,
+                                     MED_REMP))<0)
+       return -1;
+
+      /* 
+       * On ferme le Data Group
+       */
+      if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
+       return -1;
+    }
+
+  /*
+   * Le Data Group "ATT"
+   */
+  
+  if (n_attr > 0)
+    {
+      if ((datagroup = _MEDdatagroupCreer(famid,MED_NOM_ATT)) < 0)
+       return -1;
+
+      /*
+       * L'attribut "NBR"
+       */
+      if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n_attr,MED_REMP)) < 0)
+       return -1;
+      
+      /*
+       * Le Data Set "IDE"
+       */
+      dimd[0] = n_attr;
+#if defined(IRIX64)||defined(OSF1)
+      if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_IDE,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
+                                  (unsigned char *)attr_ident,MED_REMP)) < 0)
+       return -1;    
+#else
+      if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_IDE,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
+                                  (unsigned char *)attr_ident,MED_REMP)) < 0)
+       return -1;      
+#endif
+
+      /*
+       * Le Data Set "VAL"
+       */
+      dimd[0] = n_attr;
+#if defined(IRIX64)||defined(OSF1)
+      if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_VAL,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
+                                  (unsigned char*)attr_val,MED_REMP)) < 0)
+       return -1;
+#else
+      if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_VAL,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
+                                  (unsigned char*)attr_val,MED_REMP)) < 0)
+       return -1;
+#endif
+
+      /*
+       * Le Data Set "DES"
+       */
+      dimd[0] = n_attr*MED_TAILLE_DESC+1;
+      if ((ret = _MEDdatasetStringEcrire(datagroup,MED_NOM_DES,dimd,attr_desc,
+                                     MED_REMP)) < 0)
+       return -1;
+
+      /* 
+       * On ferme le Data Group
+       */
+      if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
+       return -1;
+    }
+
+  /* 
+   * On ferme tout
+   */ 
+  if ((ret = _MEDdatagroupFermer(famid)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(root)) < 0)
+    return -1;
+
+  return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfamEcr.cxx b/src/MEDWrapper/V2_1/MEDfamEcr.cxx
new file mode 100644 (file)
index 0000000..e6beb4b
--- /dev/null
@@ -0,0 +1,123 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <stdlib.h>
+#include <string.h>
+
+namespace med_2_1{
+
+med_err 
+MEDfamEcr(med_idt fid,char *maa, med_int *fam, med_int n, med_mode_acces mode,
+         med_entite_maillage type_ent, med_geometrie_element type_geo)
+{
+  med_idt root, maaid, entid, geoid, dataset;
+  med_err ret;
+  med_size dimd[1];
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
+  char nom_geo[MED_TAILLE_NOM_ENTITE+1];
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * Si le maillage n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * On met a jour le nom du Data Group representant
+   * le type des entites
+   */
+   if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
+     return -1;
+
+   /*
+    * Si le Data Group des entites n'existe pas on le cree
+    */
+   if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
+     if ((entid = _MEDdatagroupCreer(maaid,nom_ent)) < 0)
+       return -1;
+
+   /*
+    * Pour les mailles, les faces et le aretes, on cree
+    * s'il n'existe pas le Data Group du type geometrique
+    */
+   if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE))
+     {
+       if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
+        return -1;
+
+       if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
+        if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0)
+          return -1;
+     }
+   else 
+     geoid = -1;
+
+   /*
+    * Creation du Data Set "FAM" 
+    */
+   if (geoid == -1)
+     root = entid;
+   else
+     root = geoid;
+   dimd[0] = n;
+#if defined(IRIX64) || defined(OSF1)
+   if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_FAM,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
+                               (unsigned char*)fam,mode)) < 0)
+     return -1;
+#else
+   if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_FAM,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
+                               (unsigned char*)fam,mode)) < 0)
+     return -1;
+#endif
+
+  /*
+   * Attribut NBR (nombre de noeuds)
+   */
+   if ((dataset = _MEDdatasetOuvrir(root,MED_NOM_FAM)) < 0)
+     return -1;
+   if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n,mode)) < 0)
+     return -1;
+
+   /*
+    * On ferme tout
+    */
+   if ((ret = _MEDdatasetFermer(dataset)) < 0)
+     return -1;
+   if (geoid != -1)
+     if ((ret = _MEDdatagroupFermer(geoid)) < 0)
+       return -1;
+   if ((ret = _MEDdatagroupFermer(entid)) < 0)
+     return -1;
+   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+     return -1; 
+
+  return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfamGridEcr.cxx b/src/MEDWrapper/V2_1/MEDfamGridEcr.cxx
new file mode 100644 (file)
index 0000000..be590c6
--- /dev/null
@@ -0,0 +1,58 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+
+namespace med_2_1{
+
+med_err 
+MEDfamGridEcr(med_idt fid, char *maa, med_int *fam, med_int n, med_mode_acces mode, med_entite_maillage type_ent) {
+    /* Ecrire des numeros de familles pour les grilles cartesiennes ou polaires :
+       - pour les noeuds
+       - pour les aretes
+       - pour les faces
+       - pour les mailles */
+
+    med_geometrie_element type_geo;
+
+    switch(type_ent) {
+        case MED_NOEUD : {
+            type_geo = MED_POINT1;
+            break;
+        };
+        case MED_ARETE : {
+            type_geo = MED_SEG2;
+            break;
+        };
+        case MED_FACE : {
+            type_geo = MED_QUAD4;
+            break;
+        };
+        case MED_MAILLE : {
+            type_geo = MED_HEXA8;
+            break;
+        };
+        default : {
+            return(-1);
+        };
+    };
+
+    return(MEDfamEcr(fid, maa, fam, n, mode, type_ent, type_geo));
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfamGridLire.cxx b/src/MEDWrapper/V2_1/MEDfamGridLire.cxx
new file mode 100644 (file)
index 0000000..2f89144
--- /dev/null
@@ -0,0 +1,58 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+
+namespace med_2_1{
+
+med_err 
+MEDfamGridLire(med_idt fid, char *maa, med_int *fam, med_int n, med_entite_maillage type_ent) {
+    /* lecture des numeros de familles pour les grilles cartesiennes ou polaires :
+       - pour les noeuds
+       - pour les aretes
+       - pour les faces
+       - pour les mailles */
+
+    med_geometrie_element type_geo;
+
+    switch(type_ent) {
+        case MED_NOEUD : {
+            type_geo = MED_POINT1;
+            break;
+        };
+        case MED_ARETE : {
+            type_geo = MED_SEG2;
+            break;
+        };
+        case MED_FACE : {
+            type_geo = MED_QUAD4;
+            break;
+        };
+        case MED_MAILLE : {
+            type_geo = MED_HEXA8;
+            break;
+        };
+        default : {
+            return(-1);
+        };
+    };
+
+    return(MEDfamLire(fid, maa, fam, n, type_ent, type_geo));
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfamInfo.cxx b/src/MEDWrapper/V2_1/MEDfamInfo.cxx
new file mode 100644 (file)
index 0000000..b4527b1
--- /dev/null
@@ -0,0 +1,160 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <stdlib.h>
+#include <string.h>
+
+namespace med_2_1{
+
+med_err 
+MEDfamInfo(med_idt fid,char *maa,int indice, char *famille, 
+          med_int *numero,
+          med_int *attr_ident, med_int *attr_val, char *attr_desc,
+          med_int *n_attr, char *groupe ,med_int *n_groupe)
+{
+  med_idt famid,datagroup;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_FAS+2*MED_TAILLE_NOM+1];
+  int num;
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * On recupere le nom de la famille
+   */
+  num = indice - 1;
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  strcat(chemin,MED_FAS); 
+  if ((ret = _MEDobjetIdentifier(fid,chemin,num,famille)) < 0)
+    return -1;
+
+  /* 
+   * Si le Data Group de la famille n'existe pas => erreur
+   */
+  strcat(chemin,famille);
+  if ((famid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;
+
+  /*
+   * L'attribut NUM
+   */
+  if ((ret = _MEDattrEntierLire(famid,MED_NOM_NUM,numero)) < 0)
+    return -1;
+
+  /*
+   * Le Data Group "GRO"
+   */
+  if ((datagroup = _MEDdatagroupOuvrir(famid,MED_NOM_GRO)) >= 0)
+    {
+      /*
+       * L'attribut "NBR"
+       */
+      if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,n_groupe)) < 0)
+       return -1;
+      
+      /* 
+       * Data Set des noms des groupes "NOM"
+       */
+      if ((ret = _MEDdatasetStringLire(datagroup,MED_NOM_NOM,groupe)) < 0)
+       return -1;
+
+      /* 
+       * On ferme le Data Group
+       */
+      if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
+       return -1;
+    }
+  else
+    *n_groupe = 0;
+
+  /*
+   * Le Data Group "ATT"
+   */
+  if ((datagroup = _MEDdatagroupOuvrir(famid,MED_NOM_ATT)) >= 0)
+    {
+      /*
+       * L'attribut "NBR"
+       */
+      if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,n_attr)) < 0)
+       return -1;
+      
+      /*
+       * Le Data Set "IDE"
+       */
+#if defined(IRIX64)||defined(OSF1)
+      if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_IDE,MED_INT64,
+                                   MED_NO_INTERLACE,1,MED_ALL,
+                                   MED_NOPF,0,MED_NOPG,
+                                   (unsigned char*) attr_ident)) < 0)
+       return -1;     
+#else
+      if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_IDE,MED_INT32,
+                                   MED_NO_INTERLACE,1,MED_ALL,
+                                   MED_NOPF,0,MED_NOPG,
+                                   (unsigned char*) attr_ident)) < 0)
+       return -1;     
+#endif
+
+      /*
+       * Le Data Set "VAL"
+       */
+#if defined(IRIX64)||defined(OSF1)
+      if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_VAL,MED_INT64,
+                                   MED_NO_INTERLACE,1,MED_ALL,
+                                   MED_NOPF,0,MED_NOPG,
+                                   (unsigned char *) attr_val)) < 0)
+       return -1;
+#else
+      if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_VAL,MED_INT32,
+                                   MED_NO_INTERLACE,1,MED_ALL,
+                                   MED_NOPF,0,MED_NOPG,
+                                   (unsigned char *) attr_val)) < 0)
+       return -1;
+#endif
+
+      /*
+       * Le Data Set "DES"
+       */
+      ret = _MEDdatasetStringLire(datagroup,MED_NOM_DES,attr_desc);
+
+      /* 
+       * On ferme le Data Group
+       */
+      if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
+       return -1;
+    }
+  else
+    *n_attr = 0;
+
+  /* 
+   * On ferme tout
+   */ 
+  if ((ret = _MEDdatagroupFermer(famid)) < 0)
+    return -1;
+
+  return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfamLire.cxx b/src/MEDWrapper/V2_1/MEDfamLire.cxx
new file mode 100644 (file)
index 0000000..501b98f
--- /dev/null
@@ -0,0 +1,112 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <stdlib.h>
+#include <string.h>
+
+namespace med_2_1{
+
+med_err 
+MEDfamLire(med_idt fid,char *maa, med_int *fam, med_int n, 
+          med_entite_maillage type_ent,med_geometrie_element type_geo)
+{
+  med_idt root,maaid, entid, geoid;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
+  char nom_geo[MED_TAILLE_NOM_ENTITE+1];
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * Si le maillage n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * On met a jour le nom du Data Group representant
+   * le type des entites
+   */
+   if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
+     return -1;
+
+   /*
+    * Si le Data Group des entites n'existe pas => erreur
+    */
+   if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
+     return -1;
+
+   /*
+    * Pour les mailles, les faces et le aretes, on cree
+    * si le Data Group du type geometrique => erreur
+    */
+   if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE))
+     {
+       if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
+        return -1;
+       if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
+        return -1;
+     }
+   else 
+     geoid = -1;
+
+   /*
+    * lecture du Data Set "FAM" 
+    */
+   if (geoid == -1)
+     root = entid;
+   else
+     root = geoid;
+#if defined(IRIX64)||defined(OSF1)
+   if ((ret = _MEDdatasetNumLire(root,MED_NOM_FAM,MED_INT64,
+                                MED_NO_INTERLACE,1,MED_ALL,
+                                MED_NOPF,0,MED_NOPG,
+                                (unsigned char *)fam)) < 0)
+     return -1;
+#else
+   if ((ret = _MEDdatasetNumLire(root,MED_NOM_FAM,MED_INT32,
+                                MED_NO_INTERLACE,1,MED_ALL,
+                                MED_NOPF,0,MED_NOPG,
+                                (unsigned char *)fam)) < 0)
+     return -1;
+#endif
+
+   /*
+    * On ferme tout
+    */
+   if (geoid != -1)
+     if ((ret = _MEDdatagroupFermer(geoid)) < 0)
+       return -1;
+   if ((ret = _MEDdatagroupFermer(entid)) < 0)
+     return -1;
+   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+     return -1; 
+
+  return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfamMaaCr.cxx b/src/MEDWrapper/V2_1/MEDfamMaaCr.cxx
new file mode 100644 (file)
index 0000000..f7dc6d2
--- /dev/null
@@ -0,0 +1,71 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <stdio.h>
+
+namespace med_2_1{
+
+med_err
+MEDfamMaaCr(med_idt fid,char *maa,
+           med_int *numfam,med_int *attide,
+           med_int *attval,char *attdes,int *indatt,char *gro,int *indgro,
+           med_int nfamilles)
+{
+  med_err ret;
+  med_int i;
+  med_int natt,ngro;
+  med_int numf;
+  char nomfam[MED_TAILLE_NOM+1];
+
+  /* La famille de numero 0 n'a aucun attribut, ni aucun groupe
+     Les familles de numero > 0 sont des familles de noeuds
+     Les familles de numero < 0 sont des familles d'elements */
+  for (i=0;i<nfamilles;i++)
+    {
+      numf = *(numfam+i);
+      if (numf == 0)
+       strcpy(nomfam,"FAMILLE_0");
+      if (numf > 0)
+       {
+         strcpy(nomfam,"FAMILLE_NOEUD_");
+         sprintf(nomfam,"%s%d",nomfam,numf);
+          nomfam[MED_TAILLE_NOM] = '\0';
+       }
+      if (numf < 0)
+       {
+         strcpy(nomfam,"FAMILLE_ELEMENT_");
+         sprintf(nomfam,"%s%d",nomfam,-numf);
+         nomfam[MED_TAILLE_NOM] = '\0';
+       }       
+      natt = *(indatt+i+1) - *(indatt+i);
+      ngro = (*(indgro+i+1) - *(indgro+i))/MED_TAILLE_LNOM;
+      if ((ret = MEDfamCr(fid,maa,nomfam,numf,
+                         attide+*(indatt+i),
+                         attval+*(indatt+i),
+                         attdes+*(indatt+i)*MED_TAILLE_DESC,natt,
+                         gro+*(indgro+i),ngro)) < 0)
+       return -1;
+    }
+    
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfamMaaInfo.cxx b/src/MEDWrapper/V2_1/MEDfamMaaInfo.cxx
new file mode 100644 (file)
index 0000000..9868abf
--- /dev/null
@@ -0,0 +1,52 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+
+#include "med.hxx"
+
+namespace med_2_1{
+
+med_err
+MEDfamMaaInfo(med_idt fid,char *maa,med_int *nfam,med_int *nattc,
+             med_int *ngroc)
+{
+  med_int ret;
+  med_int i;
+
+  /* Lecture du nombre de familles */
+  if ((*nfam = MEDnFam(fid,maa,0,(med_dim_famille)0)) < 0)
+    return -1;
+
+  /* Lecture des nombres cumules de groupes et d'attributs dans toutes
+     les familles du maillage */
+  *nattc = 0;
+  *ngroc = 0;
+  for (i=0;i<*nfam;i++)
+    {
+      if ((ret = MEDnFam(fid,maa,i+1,MED_ATTR)) < 0)
+       return -1;
+      *nattc += ret;
+      if ((ret = MEDnFam(fid,maa,i+1,MED_GROUPE)) < 0)
+       return -1;
+      *ngroc += ret;
+    }
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfamMaaLire.cxx b/src/MEDWrapper/V2_1/MEDfamMaaLire.cxx
new file mode 100644 (file)
index 0000000..ed3401a
--- /dev/null
@@ -0,0 +1,50 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+namespace med_2_1{
+
+med_err
+MEDfamMaaLire(med_idt fid,char *maa,med_int *numfam,med_int *attide,
+             med_int *attval,char *attdes,int *indatt,char *gro,int *indgro,
+             med_int nfamilles)
+{
+  med_err ret;
+  med_int natt,ngro;
+  med_int i;
+  char nom[MED_TAILLE_NOM+1];
+
+  *indatt = 0;
+  *indgro = 0;
+  for (i=0;i<nfamilles;i++)
+    {
+      if ((ret = MEDfamInfo(fid,maa,i+1,nom,numfam+i,attide+*(indatt+i),
+                           attval+*(indatt+i),
+                           attdes+*(indatt+i)*MED_TAILLE_DESC,
+                           &natt,gro+*(indgro+i),&ngro)) < 0)
+       return -1;
+      *(indatt+i+1) = *(indatt+i)+natt;
+      *(indgro+i+1) = *(indgro+i)+ngro*MED_TAILLE_LNOM;
+    }
+    
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfermer.cxx b/src/MEDWrapper/V2_1/MEDfermer.cxx
new file mode 100644 (file)
index 0000000..872ce4a
--- /dev/null
@@ -0,0 +1,41 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med_outils.hxx" 
+#include "med.hxx"
+
+namespace med_2_1{
+
+med_err 
+MEDfermer(med_idt fid)
+{
+  /*
+   * On inhibe le gestionnaire d'erreur
+   */
+   _MEDmodeErreurVerrouiller(); 
+
+  /*
+   * On ferme le fichier MED
+   */
+  if (_MEDfichierFermer(fid) < 0)
+    return -1;
+  else
+    return 0;
+}
+  
+}
diff --git a/src/MEDWrapper/V2_1/MEDfichDesEcr.cxx b/src/MEDWrapper/V2_1/MEDfichDesEcr.cxx
new file mode 100644 (file)
index 0000000..e335693
--- /dev/null
@@ -0,0 +1,69 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+
+namespace med_2_1{
+
+med_err 
+MEDfichDesEcr(med_idt fid, char *des, med_mode_acces mode)
+{ 
+  med_idt attr; 
+  med_idt root;
+  med_err ret;
+  char nom[] = MED_NOM_DESCRIPTEUR;
+  char chemin[MED_TAILLE_MAA+1];
+
+  /*
+   * On inhibe le gestionnaire d'erreur
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * On ouvre le Data Group racine
+   * s'il n'existe pas on le cree
+   */
+  strncpy(chemin,MED_MAA,MED_TAILLE_MAA-1);
+  chemin[MED_TAILLE_MAA-1] = '\0';
+  if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    if ((root = _MEDdatagroupCreer(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * On regarde si l'attribut existe
+   * Si oui on le met a jour en fonction
+   * du mode d'ouverture, sinon on le cree
+   */
+
+  if ((ret = _MEDattrStringEcrire(root,nom,MED_TAILLE_DESC,des,mode)) < 0)
+    return -1;
+
+  /*
+   * Fermetures 
+   */
+
+  if ((ret = _MEDdatagroupFermer(root)) < 0)
+    return -1;
+         
+  return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfichEntete.cxx b/src/MEDWrapper/V2_1/MEDfichEntete.cxx
new file mode 100644 (file)
index 0000000..b191d3a
--- /dev/null
@@ -0,0 +1,79 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+
+namespace med_2_1{
+
+med_err 
+MEDfichEntete(med_idt fid, med_fich_info quoi, char str[])
+{
+  med_idt atid, root;
+  med_err ret;
+  char locale[MED_TAILLE_DESC+1];
+  char chemin[MED_TAILLE_MAA+1];
+
+  switch (quoi)
+    {
+    case MED_HDF_VERSION : 
+      strcpy(str,HDF_VERSION_ACTUELLE);
+      break;
+
+    case MED_VERSION :
+      strcpy(str,MED_VERSION_ACTUELLE); 
+      break;
+
+    case MED_FICH_DES :
+      /*
+       * On inhibe le gestionnaire d'erreur HDF
+       */
+      _MEDmodeErreurVerrouiller();
+      
+      /*
+       * On ouvre le Data Group racine
+       */
+      strncpy(chemin,MED_MAA,strlen(MED_MAA)-1);
+      chemin[MED_TAILLE_MAA-1] = '\0';
+      if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+       return -1;
+
+      /*
+       * On regarde si l'attribut existe
+       * Si non => erreur
+       * Si oui => on le copie dans str
+       */
+      if ((ret = _MEDattrStringLire(root,MED_NOM_DESCRIPTEUR,
+                                   MED_TAILLE_DESC,locale)) < 0)
+       return -1;
+      strcpy(str,locale);
+      
+      if ((ret == _MEDdatagroupFermer(root)) < 0)
+       return -1;
+
+      break;
+      
+    default :
+      return -1;
+    }
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfichierCreer.cxx b/src/MEDWrapper/V2_1/MEDfichierCreer.cxx
new file mode 100644 (file)
index 0000000..dd72e8b
--- /dev/null
@@ -0,0 +1,71 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDfichierCreer
+ * - Description : creation d'un fichier HDF
+ * - Parametres :
+ *     - nom (IN) : le nom du fichier
+ * - Resultat : ID du fichier en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_idt
+_MEDfichierCreer(char *nom)
+{
+  med_idt fid,gid;
+  med_err ret;
+  med_int majeur = MED_NUM_MAJEUR;
+  med_int mineur = MED_NUM_MINEUR; 
+  med_int release = MED_NUM_RELEASE;
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  if ((fid = H5Fcreate(nom,H5F_ACC_TRUNC,
+                              H5P_DEFAULT,H5P_DEFAULT)) < 0)
+    return -1;
+
+  if ((gid = _MEDdatagroupCreer(fid,MED_NOM_INFOS)) < 0)
+    return -1;
+
+  /* Numero de versions de MED */
+  if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_MAJEUR,&majeur,MED_REMP)) < 0)
+    return -1;
+
+  if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_MINEUR,&mineur,MED_REMP)) < 0)
+    return -1;
+
+  if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_RELEASE,&release,MED_REMP)) < 0)
+    return -1;
+
+  /* On ferme tout */
+  if ((ret = _MEDdatagroupFermer(gid)) < 0)
+    return -1;
+
+  return fid;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfichierFermer.cxx b/src/MEDWrapper/V2_1/MEDfichierFermer.cxx
new file mode 100644 (file)
index 0000000..c0024e5
--- /dev/null
@@ -0,0 +1,43 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDfichierFermer
+ * - Description : fermeture d'un fichier HDF
+ * - Parametres :
+ *     - fid (IN) : ID du fichier
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDfichierFermer(med_idt fid)
+{
+  med_err ret;
+
+  if ((ret = H5Fclose(fid)) < 0)
+    return -1;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfichierOuvrir.cxx b/src/MEDWrapper/V2_1/MEDfichierOuvrir.cxx
new file mode 100644 (file)
index 0000000..593fbd6
--- /dev/null
@@ -0,0 +1,60 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDfichierOuvrir
+ * - Description : ouverture d'un fichier HDF en fonction du mode passe
+ *                 en parametre
+ * - Parametres :
+ *     - nom  (IN) : le nom du fichier
+ *     - mode (IN) : mode d'ouverture  
+ * - Resultat : ID du fichier en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_idt 
+_MEDfichierOuvrir(char *nom,med_mode_acces mode)
+{ 
+  med_idt fid;
+  int hdf_mode;
+
+  switch(mode)
+    {
+    case MED_ECRI :
+      hdf_mode = H5F_ACC_RDWR; 
+      break;
+
+    case MED_LECT :
+      hdf_mode = H5F_ACC_RDONLY;
+      break;
+
+    default :
+      return -1;
+    }  
+
+  if ((fid = H5Fopen(nom,hdf_mode,H5P_DEFAULT)) < 0)
+    return -1;
+
+  return fid;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDformatConforme.cxx b/src/MEDWrapper/V2_1/MEDformatConforme.cxx
new file mode 100644 (file)
index 0000000..d5ddea8
--- /dev/null
@@ -0,0 +1,40 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+namespace med_2_1{
+
+med_err
+MEDformatConforme(const char * nomfich)
+{
+
+  /*
+   * On inhibe le gestionnaire d'erreur
+   */
+  _MEDmodeErreurVerrouiller();
+
+
+  if  ( H5Fis_hdf5(nomfich) > 0 )
+        return 0;
+  else
+        return -1;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDfstring.cxx b/src/MEDWrapper/V2_1/MEDfstring.cxx
new file mode 100644 (file)
index 0000000..e1bc4fa
--- /dev/null
@@ -0,0 +1,47 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include <string.h>
+
+/*
+ *  Chaine C -> chaine FORTRAN completee par des blancs
+ */
+
+namespace med_2_1{
+
+med_err
+_MEDfstring(char *chaine, med_int longueur_fixee)
+{
+  int longueur_reelle, i;
+
+  if (longueur_fixee == 0 ) return 0;
+
+  longueur_reelle = strlen(chaine);
+  if (longueur_fixee < longueur_reelle)
+    return -1;
+
+  /* on supprime le caractere de fin de chaine C '\0'
+     et complete par des blancs */
+  for (i=longueur_reelle;i<longueur_fixee;i++)
+    *(chaine+i) = ' ';
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDgridCr.cxx b/src/MEDWrapper/V2_1/MEDgridCr.cxx
new file mode 100644 (file)
index 0000000..6e9ae94
--- /dev/null
@@ -0,0 +1,65 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+namespace med_2_1{
+
+med_err 
+MEDgridCr(med_idt fid, char *maillage, med_int dim, med_grid_type typ) 
+{
+    med_idt maaid, root;
+    char    chemin[MED_TAILLE_MAA+1];
+
+    /* On inhibe le gestionnaire d'erreur */
+    _MEDmodeErreurVerrouiller();
+
+    /* Si la racine n'existe pas on la cree */
+    strncpy(chemin, MED_MAA, strlen(MED_MAA)-1);
+    chemin[MED_TAILLE_MAA-1] = '\0';
+    if ((root = _MEDdatagroupOuvrir(fid, chemin)) < 0)
+        if ((root = _MEDdatagroupCreer(fid, chemin)) < 0)
+            return(-1);
+
+    /* si le maillage existe deja => erreur */
+    if (_MEDdatagroupOuvrir(root, maillage) > 0) {
+        return(-1);
+    };
+
+    /* Creation du Data Group */
+    maaid = _MEDdatagroupCreer(root, maillage);
+    if (maaid < 0) return(-1);
+
+    /* Creation de l'attribut dimension */
+    if (_MEDattrEntierEcrire(maaid, MED_NOM_DIM, &dim, MED_REMP) < 0) {
+        return(-1);
+    };
+
+    /* Creation de l'attribut grille */
+    if (_MEDattrEntierEcrire(maaid, MED_NOM_GRD, &typ, MED_REMP) < 0) {
+        return(-1);
+    };
+
+    /* Nettoyages divers */
+    if ( _MEDdatagroupFermer(maaid) < 0) return(-1);
+    if (_MEDdatagroupFermer(root)   < 0) return(-1);
+    return(0);
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDgridEcr.cxx b/src/MEDWrapper/V2_1/MEDgridEcr.cxx
new file mode 100644 (file)
index 0000000..3acc181
--- /dev/null
@@ -0,0 +1,109 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med_outils.hxx"
+#include "med.hxx"
+
+namespace med_2_1{
+
+med_err 
+MEDgridEcr(med_idt fid, char *maa, med_int mdim, med_float *coo, med_int nb, med_int dim, med_mode_switch mode_coo,
+          med_repere repere, char *nomcoo, char *unicoo, med_mode_acces mode )
+{
+    /* ecriture des indices */
+
+    med_idt  maaid, noeid, ds;
+    char     chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+    med_size dimd[1];
+    char     *dataset;
+    med_int  type_rep_int;
+
+    /* On inhibe le gestionnaire d'erreur HDF */
+    _MEDmodeErreurVerrouiller();
+
+    /* Si le maillage n'existe pas => erreur */
+    strcpy(chemin, MED_MAA);
+    strcat(chemin, maa);
+    maaid = _MEDdatagroupOuvrir(fid, chemin);
+    if (maaid < 0) return(-1);
+
+    /* Si le Data Group "NOE" n'existe pas on le cree */
+    if ((noeid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE)) < 0) {
+        if ((noeid = _MEDdatagroupCreer(maaid, MED_NOM_NOE)) < 0) {
+            return(-1);
+        };
+    };
+
+    switch (dim) {
+        case 0 : {
+            dataset = MED_NOM_IN1;
+            break;
+        };
+        case 1 : {
+            dataset = MED_NOM_IN2;
+            break;
+        };
+        case 2 : {
+            dataset = MED_NOM_IN3;
+            break;
+        };
+        default : {
+            return(-1);
+        };
+    };
+
+    /* Creation du Data Set "IN1" ou "IN2" ou "IN3" */
+    dimd[0] = nb;
+    if (_MEDdatasetNumEcrire(noeid, dataset, MED_REEL64, mode_coo, 1, MED_ALL, MED_NOPF, 0, 0, dimd, (unsigned char*)coo, mode) < 0) {
+        return(-1);
+    };
+
+    /* On re-ouvre le Data Set "IN1" ou "IN2" ou "IN3" pour y placer des attributs */
+    if ((ds = _MEDdatasetOuvrir(noeid, dataset)) < 0) {
+        return(-1);
+    };
+
+    /* Attribut NBR (nombre de noeuds) */
+    if (_MEDattrEntierEcrire(ds, MED_NOM_NBR, &nb, mode) < 0) {
+        return(-1);
+    };
+
+    /* L'attribut "REP" */
+    type_rep_int = (med_int)repere;
+    if (_MEDattrEntierEcrire(ds, MED_NOM_REP, &type_rep_int, mode) < 0) {
+        return(-1);
+    };
+
+    /* Attribut "NOM" */
+    if (_MEDattrStringEcrire(ds, MED_NOM_NOM, mdim*MED_TAILLE_PNOM, nomcoo, mode) < 0) {
+        return(-1);
+    };
+
+    /* Attribut "UNI" */
+    if (_MEDattrStringEcrire(ds, MED_NOM_UNI, mdim*MED_TAILLE_PNOM, unicoo, mode) < 0) {
+        return(-1);
+    };
+
+    /* On ferme tout */
+    if (_MEDdatasetFermer(ds)      < 0) return(-1);
+    if (_MEDdatagroupFermer(noeid) < 0) return(-1);
+    if (_MEDdatagroupFermer(maaid) < 0) return(-1);
+    return(0);
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDgridInfo.cxx b/src/MEDWrapper/V2_1/MEDgridInfo.cxx
new file mode 100644 (file)
index 0000000..43de1b2
--- /dev/null
@@ -0,0 +1,60 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_err 
+MEDgridInfo(med_idt fid, int indice, med_int *isAGrid, med_grid_type *typ) 
+{
+    int     numero;
+    med_idt maaid;
+    char    maillage[MED_TAILLE_NOM+1];
+    char    chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+
+    /* On inhibe le gestionnaire d'erreur */
+    _MEDmodeErreurVerrouiller();
+
+    /* On recupere le nom du groupe de rang "indice" */
+    numero = indice-1;
+    if (_MEDobjetIdentifier(fid, MED_MAA, numero, maillage) < 0) {
+        return(-1);
+    };
+
+    /* On va chercher l'attribut dimension */
+    strcpy(chemin, MED_MAA);
+    strcat(chemin, maillage);
+    maaid = _MEDdatagroupOuvrir(fid, chemin);
+    if (maaid < 0) return(-1);
+
+    if (_MEDattrEntierLire(maaid, MED_NOM_GRD, typ) < 0) {
+        *isAGrid = 0;
+    } else {
+        *isAGrid = 1;
+    };
+
+    if (_MEDdatagroupFermer(maaid) < 0) return(-1);
+    return(0);
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDgridLire.cxx b/src/MEDWrapper/V2_1/MEDgridLire.cxx
new file mode 100644 (file)
index 0000000..0322663
--- /dev/null
@@ -0,0 +1,85 @@
+#include "med_outils.hxx"
+#include "med.hxx"
+
+namespace med_2_1{
+
+med_err 
+MEDgridLire(med_idt fid, char *maa, med_int mdim, med_float *coo, med_int dim, med_mode_switch mode_coo,
+           med_repere *repere, char *nomcoo, char *unicoo )
+{
+    med_idt   maaid, noeid, ds;
+    char      chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+    char      *dataset;
+    med_int   type_rep_int;
+
+    /* On inhibe le gestionnaire d'erreur */
+    _MEDmodeErreurVerrouiller();
+
+    /* Si le maillage n'existe pas => erreur */
+    strcpy(chemin, MED_MAA);
+    strcat(chemin, maa);
+    maaid = _MEDdatagroupOuvrir(fid, chemin);
+    if (maaid < 0) return(-1);
+
+    /* Si le Data Group "NOE" n'existe pas => erreur */
+    noeid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE);
+    if (noeid < 0) return(-1);
+
+    switch (dim) {
+        case 0 : {
+            dataset = MED_NOM_IN1;
+            break;
+        };
+        case 1 : {
+            dataset = MED_NOM_IN2;
+            break;
+        };
+        case 2 : {
+            dataset = MED_NOM_IN3;
+            break;
+        };
+        default : {
+            return(-1);
+        };
+    };
+
+    /* Lecture du Data Set "IN1" ou "IN2" ou "IN3" */
+    if (_MEDdatasetNumLire(noeid, dataset, MED_REEL64, mode_coo, 1, MED_ALL, MED_NOPF, 0, 1, (unsigned char*)coo) < 0) {
+        return(-1);
+    };
+
+    /* On re-ouvre le Data Set precedant pour y lire des attributs */
+    ds = _MEDdatasetOuvrir(noeid, dataset);
+    if (ds < 0) return(-1);
+
+    /* L'attribut "REP" */
+    if (_MEDattrEntierLire(ds, MED_NOM_REP, &type_rep_int) < 0) {
+        return(-1);
+    } else {
+        *repere = (med_repere)type_rep_int;
+    };
+
+    /* Attribut "NOM" */
+    if (_MEDattrStringLire(ds, MED_NOM_NOM, mdim*MED_TAILLE_PNOM, nomcoo) < 0) {
+        return(-1);
+    };
+
+    /* Attribut "UNI" */
+    if (_MEDattrStringLire(ds, MED_NOM_UNI, mdim*MED_TAILLE_PNOM, unicoo) < 0) {
+        return(-1);
+    };
+
+    /* On ferme tout */
+    if (_MEDdatasetFermer(ds) < 0) {
+        return(-1);
+    };
+    if (_MEDdatagroupFermer(noeid) < 0) {
+        return(-1);
+    };
+    if (_MEDdatagroupFermer(maaid) < 0) {
+        return(-1);
+    };
+    return(0);
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDgro2famA.cxx b/src/MEDWrapper/V2_1/MEDgro2famA.cxx
new file mode 100644 (file)
index 0000000..5838900
--- /dev/null
@@ -0,0 +1,291 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "med.hxx"
+
+/***********************************************************************
+ * FONCTION MEDgro2famA
+ * 
+ * - DESCRIPTION : 1ere etape dans la conversion des groupes de noeuds
+ *      et d'elements en familles MED. 
+ *      Calcul des tailles des tableaux que l'on devra allouer pour
+ *      stocker les familles qui seront construites par MEDgro2famB().
+ *      Les parametres renvoyes sont :
+ *      1 - le nombre de familles MED a creer (nfamg)
+ *      2 - le nombre de noms groupes associes a l'ensemble des familles
+ *      MED (nindf)
+ *      Ces parametres doivent permettre a l'appelant de creer les tables
+ *      suivantes : 
+ *      1 - une table des noms des groupes propres a chaque famille,
+ *      de taille : nindf*MED_TAILLE_LNOM+1
+ *      2 - une table d'index donnant pour chaque famille son numero d'indice
+ *      dans la table des noms, de taille : nfamg+1
+ *      3 - une table destinee a contenir la liste des numeros de familles
+ *          a creer, de taille : nfamg
+ *
+ * - PARAMETRES :
+ *   NOM            .E/S. TYPE    .  DESCRIPTION
+ *   ------------------------------------------------------------------- 
+ *   nnoe           .E  . med_int . nombre de noeuds 
+ *   nele           .E  . med_int . nombre d'elements 
+ *   numnoe         .E  . med_int*. numeros des noeuds
+ *   numele         .E  . med_int*. numeros des elements
+ *   ngn            .E  . med_int . nombre de groupes de noeuds
+ *   nge            .E  . med_int . nombre de groupes d'elements
+ *   nindn          .E  . med_int . nombre d'indices dans la table
+ *                  .   .         . des groupes de noeuds
+ *   ninde          .E  . med_int . nombre d'indices dans la table
+ *                  .   .         . de groupes d'elements
+ *   indgronoe      .E  . int*    . table index de la table des groupes
+ *                  .   .         . de noeuds
+ *   indgroele      .E  . int*    . table index de la table des groupes
+ *                  .   .         . d'elements
+ *   tabgronoe      .E  . med_int*. table des groupes de noeuds
+ *   tabgroele      .E  . med_int*. table des groupes d'elements
+ *   nfamg          .  S. med_int*. nombre de familles MED a creer
+ *   nidnf          .  S. med_int*. nombre de noms groupes associes a 
+ *                  .   .         . l'ensemble des familles MED
+ *
+ * - RESULTAT : 0 si succes, -1 sinon
+ * 
+ ***********************************************************************/
+
+namespace med_2_1{
+
+med_err 
+MEDgro2famA (med_int nnoe,med_int nele,med_int *numnoe,med_int *numele,
+            med_int ngn,med_int nge,med_int nindn, 
+            med_int ninde,int *indgronoe,int *indgroele,med_int *tabgronoe, 
+            med_int *tabgroele,med_int *nfamg,med_int *nindf)
+{
+  int i,j,k;
+  int *famnoe,*famele,*tmp;
+  int *p;
+  int flag, num,exist;
+  int nfamn, nfame;
+  int fam01 = 0;
+  int fam02 = 0;
+
+  /* initialisations */
+  famnoe = NULL;
+  famele = NULL;
+
+  *nfamg = 0;
+  *nindf = 0;
+  nfamn = 0;
+  nfame = 0;
+
+  if ((ngn > 0) || (nge > 0))
+    {
+      /* pour chaque noeud :
+        1 - on dresse la liste des groupes de noeuds auquel il appartient
+        2 - en la comparant avec les listes pre-existantes, on
+         estime s'il est necessaire de creer une nouvelle famille de noeuds.
+        Si oui => on incremente le compteur local nfamn (nombre de familles
+                   de noeuds)
+                   on incremente le parametre nindf du nombre de groupes
+                   que devra compter cette famille de noeuds
+        Si non => on ne fait rien */
+      for (i=0;i<nnoe;i++)
+       {
+         if ((tmp = (int*) malloc(sizeof(int)*ngn)) == NULL)
+           return -1;
+         num = *(numnoe+i);
+         for (j=0;j<ngn;j++)
+           {
+             flag = 0;
+             /* on regarde si le noeud appartient au groupe */
+             for (k=0;k<*(indgronoe+j+1)-*(indgronoe+j);k++)
+               if (num == *(tabgronoe+*(indgronoe+j)+k))
+                 flag = 1;
+             /* on met le flag a jour dans tmp */
+             *(tmp+j) = flag;
+           }
+         /* on note la creation de la famille 0 */
+         if (fam01 == 0)
+           {
+             flag = 1;
+             for (j=0;j<ngn;j++)
+               if (*(tmp+j) == 1)
+                 flag = 0;
+             if (flag == 1)
+               fam01 = 1;
+           }
+         /* faut-il creer une nouvelle famille ? */
+         if (famnoe == NULL)
+           {
+             exist = 0;
+             if ((famnoe = (int *) malloc (sizeof(int)*ngn)) == NULL)
+               return -1;
+             for (j=0;j<ngn;j++)
+               {
+                 *(famnoe+j) = *(tmp+j);
+                 if (*(famnoe+j) == 1)
+                   *nindf = *nindf + 1;
+               }
+             nfamn = 1;
+           }
+         else
+           {
+             for (j=0;j<nfamn;j++)
+               {
+                 p = famnoe + ngn*j;
+                 for (k=0;k<ngn;k++)
+                   {
+                     if (*(p+k) != *(tmp+k))
+                       {
+                         exist = 0;
+                         break;
+                       }
+                     else
+                       exist = 1;
+                   }
+                 if (exist == 1)
+                   break;
+               }
+             if (exist == 0)
+               {
+                 nfamn = nfamn + 1;
+                 p = famnoe;
+                 if ((famnoe = (int*) malloc(sizeof(int)*ngn*nfamn)) == NULL)
+                   return -1;
+                 for (j=0;j<nfamn-1;j++)
+                   for (k=0;k<ngn;k++)
+                     *(famnoe+j*ngn+k) = *(p+j*ngn+k);
+                 free(p);
+                 p = famnoe+(nfamn-1)*ngn;
+                 for (j=0;j<ngn;j++)
+                   {
+                     *(p+j) = *(tmp+j);
+                     if (*(p+j) == 1)
+                       *nindf = *nindf + 1;
+                   }
+               }
+           }
+         free(tmp);
+       }
+      
+      /* pour chaque element : idem que pour les noeuds */
+      for (i=0;i<nele;i++)
+       {
+         if ((tmp = (int*) malloc(sizeof(int)*nge)) == NULL)
+           return -1;
+         num = *(numele+i);
+         for (j=0;j<nge;j++)
+           {
+             flag = 0;
+             /* on regarde si l'element appartient au groupe */
+             for (k=0;k<*(indgroele+j+1)-*(indgroele+j);k++)
+               if (num == *(tabgroele+*(indgroele+j)+k))
+                 flag = 1;
+             /* on met le flag a jour dans tmp */
+             *(tmp+j) = flag;
+           }
+         /* on note la creation de la famille 0 */
+         if (fam02 == 0)
+           {
+             flag = 1;
+             for (j=0;j<nge;j++)
+               if (*(tmp+j) == 1)
+                 flag = 0;
+             if (flag == 1)
+               fam02 = 1;
+           }
+         /* faut-il creer une nouvelle famille ? */
+         if (famele == NULL)
+           {
+             exist = 0;
+             if ((famele = (int *) malloc (sizeof(int)*nge)) == NULL)
+               return -1;
+             for (j=0;j<nge;j++)
+               {
+                 *(famele+j) = *(tmp+j);
+                 if (*(famele+j) == 1)
+                   *nindf = *nindf + 1;
+               }
+             nfame = 1;
+           }
+         else
+           {
+             for (j=0;j<nfame;j++)
+               {
+                 p = famele + nge*j;
+                 for (k=0;k<nge;k++)
+                   {
+                     if (*(p+k) != *(tmp+k))
+                       {
+                         exist = 0;
+                         break;
+                       }
+                     else
+                       exist = 1;
+                   }
+                 if (exist == 1)
+                   break;
+               }
+             if (exist == 0)
+               {
+                 nfame = nfame + 1;
+                 p = famele;
+                 if ((famele = (int*) malloc(sizeof(int)*nge*nfame)) == NULL)
+                   return -1;
+                 for (j=0;j<nfame-1;j++)
+                   for (k=0;k<nge;k++)
+                     *(famele+j*nge+k) = *(p+j*nge+k);
+                 free(p);
+                 p = famele+(nfame-1)*nge;
+                 for (j=0;j<nge;j++)
+                   {
+                     *(p+j) = *(tmp+j);
+                     if (*(p+j) == 1)
+                       *nindf = *nindf + 1;
+                   }
+               }
+           }
+         free(tmp);
+       }
+      
+      /* la famille 0 existe pour les noeuds et les elements, on 
+        ne la compte qu'une fois */
+      if (fam01 && fam02)
+       nfamn = nfamn - 1;
+      
+      /* le nombre de familles a creer est egal au nombre de familles
+        de noeuds + nombre de familles d'elements */
+      *nfamg = nfamn + nfame;
+      
+      
+      /* Nettoyage memoire */
+      free(famnoe);
+      free(famele);
+    }  
+  else
+    {
+      /* on a aucun groupes de noeuds ou d'elements */
+      *nfamg = 1; /* on a au moins la famille 0 */
+      *nindf = 0;
+    }
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDgro2famB.cxx b/src/MEDWrapper/V2_1/MEDgro2famB.cxx
new file mode 100644 (file)
index 0000000..a7263b9
--- /dev/null
@@ -0,0 +1,396 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "med.hxx"
+
+/***********************************************************************
+ * FONCTION MEDgro2famB
+ * 
+ * - DESCRIPTION : 2eme etape dans la conversion des groupes de noeuds
+ *      et d'elements en familles MED
+ *      Mise a jour des tables suivantes passees en parametres :
+ *      1 - les nouveaux numeros des familles a creer
+ *      2 - les nouveaux numeros des familles des elements
+ *      3 - les nouveaux numeros des familles des noeuds
+ *      4 - les noms des groupes composant ces familles
+ *      5 - les index de la table des groupes 
+ *
+ * - PARAMETRES :
+ *   NOM            .E/S. TYPE    .  DESCRIPTION
+ *   ------------------------------------------------------------------- 
+ *   nnoe           .E  . med_int . nombre de noeuds 
+ *   nele           .E  . med_int . nombre d'elements 
+ *   numnoe         .E  . med_int*. numeros des noeuds
+ *   numele         .E  . med_int*. numeros des elements
+ *   ngn            .E  . med_int . nombre de groupes de noeuds
+ *   nge            .E  . med_int . nombre de groupes d'elements
+ *   nindn          .E  . med_int . nombre d'indices dans la table
+ *                  .   .         . des groupes de noeuds
+ *   ninde          .E  . med_int . nombre d'indices dans la table
+ *                  .   .         . de groupes d'elements
+ *   nomgronoe      .E  . char*   . noms des groupes de noeuds
+ *   nomgroele      .E  . char*   . noms des groupes d'elements
+ *   indgronoe      .E  . int*    . table index de la table des groupes
+ *                  .   .         . de noeuds
+ *   indgroele      .E  . int*    . table index de la table des groupes
+ *                  .   .         . d'elements
+ *   tabgronoe      .E  . int*    . table des groupes de noeuds
+ *   tabgroele      .E  . int*    . table des groupes d'elements
+ *   nfamg          .E  . med_int . nombre de familles MED a creer
+ *   nidnf          .E  . med_int . nombre de noms groupes associes a 
+ *                  .   .         . l'ensemble des familles MED
+ *   newnumfam      .  S. med_int*. nouveaux numeros de familles
+ *   newnumfamele   .  S. med_int*. nouveaux numeros de familles des
+ *                  .   .         . elements
+ *   newnumfamnoe   .  S. med_int*. nouveaux numeros de familles des
+ *                  .   .         . noeuds
+ *   newindfamgro   .  S. int*    . table des index de la table des
+ *                  .   .         . noms de groupes associes aux familles
+ *   newfamgro      .   . char*   . table des noms des groupes des 
+ *                  .   .         . familles 
+ *
+ * - RESULTAT : 0
+ * 
+ ***********************************************************************/
+
+namespace med_2_1{
+
+med_err 
+MEDgro2famB (med_int nnoe,med_int nele,med_int *numnoe,med_int *numele,
+            med_int ngn,med_int nge,med_int nindn,
+            med_int ninde, char *nomgronoe,char *nomgroele, 
+            int *indgronoe,int *indgroele,med_int *tabgronoe, 
+            med_int *tabgroele,med_int nfamg,med_int nindf,
+            med_int *newnumfam,med_int *newnumfamele, 
+            med_int *newnumfamnoe,int *newindfamgro,
+            char *newfamgro)
+{
+  int i,j,k;
+
+  med_int *famnoe, *famele, *tmp;
+  med_int *p;
+  med_int num;
+  int flag,exist;
+  int nfamn, nfame;
+  int estfam0 = 1;
+  int newnumnoe, newnumele;
+  int tmp1;
+  int existfam0 = 0;
+  int ind = 0;
+
+  famnoe = NULL;
+  famele = NULL;
+
+  nfamn = 0;
+  nfame = 0;
+  newnumnoe = 0;
+  newnumele = 0;
+
+  *newindfamgro = 0;
+
+  if (nfamg > 1)
+    {
+      /* pour chaque noeud :
+        1 - on dresse la liste des groupes de noeuds auquel il appartient
+        2 - en la comparant avec les listes pre-existantes, on
+         estime s'il est necessaire de creer une nouvelle famille de noeuds.
+        Si oui => - on cree le numero de famille que l'on reporte 
+                     dans newnumfam
+                   - on reporte ce numero dans newnumnoe
+                   - on met a jour la table des noms des groupes des familles
+                     ainsi que sa table d'index  
+        Si non => on ne fait rien 
+         ATTENTION : pour la famille 0, on ne met a jour que les numeros */
+      for (i=0;i<nnoe;i++)
+       {
+         if ((tmp = (med_int*) malloc(sizeof(med_int)*ngn)) == NULL)
+           return -1;
+         num = *(numnoe+i);
+         for (j=0;j<ngn;j++)
+           {
+             flag = 0;
+             /* on regarde si le noeud appartient au groupe */
+             for (k=0;k<*(indgronoe+j+1)-*(indgronoe+j);k++)
+               if (num == *(tabgronoe+*(indgronoe+j)+k))
+                 flag = 1;
+             /* on met le flag a jour dans tmp */
+             *(tmp+j) = flag;
+           }
+         /* on regarde si le numero de famille est 0 */
+         estfam0 = 0;
+         flag = 1;
+         for (j=0;j<ngn;j++)
+           if (*(tmp+j) == 1)
+             flag = 0;
+         if (flag == 1)
+           {
+             estfam0 = 1;
+             *(newnumfamnoe+i) = 0;
+           }
+         if (flag == 1 && existfam0 == 0)
+           existfam0 = 1;
+         /* faut-il creer une nouvelle famille ? */
+         if (famnoe == NULL)
+           {
+             exist = 0;
+             if ((famnoe = (med_int *) malloc (sizeof(med_int)*ngn)) == NULL)
+               return -1;
+             /* on met a jour la table d'indices */
+             nfamn = 1;
+             *(newindfamgro+nfamn) = *(newindfamgro+nfamn-1);
+             for (j=0;j<ngn;j++)
+               {
+                 tmp1 = *(tmp+j);
+                 *(famnoe+j) = tmp1;
+                 if (tmp1 == 1)
+                   {
+                     strncpy(newfamgro+*(newindfamgro+nfamn),
+                             nomgronoe+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
+                     *(newindfamgro+nfamn) = *(newindfamgro+nfamn) + 
+                       MED_TAILLE_LNOM;
+                   }
+               }
+             if (estfam0 == 0)
+               {
+                 newnumnoe = 1;
+                 *newnumfamnoe = newnumnoe;
+                 *newnumfam = newnumnoe;
+               }
+             else
+               *newnumfam = 0;
+           }
+         else
+           {
+             for (j=0;j<nfamn;j++)
+               {
+                 p = famnoe + ngn*j;
+                 for (k=0;k<ngn;k++)
+                   {
+                     if (*(p+k) != *(tmp+k))
+                       {
+                         exist = 0;
+                         break;
+                       }
+                     else
+                       exist = 1;
+                   }
+                 if (exist == 1)
+                   {
+                     if (estfam0 == 0)
+                       *(newnumfamnoe+i) = *(newnumfam+j);
+                     break;
+                   }
+               }
+             if (exist == 0)
+               {
+                 nfamn = nfamn + 1;
+                 *(newindfamgro+nfamn) = *(newindfamgro+nfamn-1);
+                 p = famnoe;
+                 if ((famnoe = (med_int*) malloc(sizeof(med_int)*ngn*nfamn))
+                     == NULL)
+                   return -1;
+                 for (j=0;j<nfamn-1;j++)
+                   for (k=0;k<ngn;k++)
+                     *(famnoe+j*ngn+k) = *(p+j*ngn+k);
+                 free(p);
+                 p = famnoe+(nfamn-1)*ngn;
+                 for (j=0;j<ngn;j++)
+                   {
+                     tmp1 = *(tmp+j);
+                     *(p+j) = tmp1;
+                     if (tmp1 == 1)
+                       {
+                         strncpy(newfamgro+*(newindfamgro+nfamn), 
+                                 nomgronoe+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
+                     *(newindfamgro+nfamn) = *(newindfamgro + nfamn) 
+                       + MED_TAILLE_LNOM;
+                       }
+                   }
+                 if (estfam0 == 0)
+                   {
+                     newnumnoe = newnumnoe + 1;
+                     *(newnumfamnoe+i) = newnumnoe;
+                     *(newnumfam+nfamn-1) = newnumnoe;
+                   }
+                 else
+                   *(newnumfam+nfamn-1) = 0;
+               }
+           }
+         free(tmp);
+       }
+      
+      /* pour chaque element :
+        1 - on dresse la liste des groupes de noeuds auquel il appartient
+        2 - en la comparant avec les listes pre-existantes, on
+         estime s'il est necessaire de creer une nouvelle famille d'elements.
+        Si oui => - on cree le numero de famille que l'on reporte 
+                     dans newnumfam
+                   - on reporte ce numero dans newnumele
+                   - on met a jour la table des noms des groupes des familles
+                     ainsi que sa table d'index  
+        Si non => on ne fait rien 
+         ATTENTION : pour la famille 0, on ne met a jour que les numeros */
+      for (i=0;i<nele;i++)
+       {
+         if ((tmp = (med_int*) malloc(sizeof(med_int)*nge)) == NULL)
+           return -1;
+         num = *(numele+i);
+         for (j=0;j<nge;j++)
+           {
+             flag = 0;
+             /* on regarde si l'element appartient au groupe */
+             for (k=0;k<*(indgroele+j+1)-*(indgroele+j);k++)
+               if (num == *(tabgroele+*(indgroele+j)+k))
+                 flag = 1;
+             /* on met le flag a jour dans tmp */
+             *(tmp+j) = flag;
+           }
+         /* on regarde si le numero de famille est 0 */
+         estfam0 = 0;
+         flag = 1;
+         for (j=0;j<nge;j++)
+           if (*(tmp+j) == 1)
+             flag = 0;
+         if (flag == 1)
+           {
+             estfam0 = 1;
+             *(newnumfamele+i) = 0;
+           }
+         /* faut-il creer une nouvelle famille ? */
+         if (famele == NULL)
+           {
+             if (!(estfam0&&existfam0))
+               {
+                 exist = 0;
+                 if ((famele = (med_int *) malloc (sizeof(med_int)*nge))
+                     == NULL)
+                   return -1;
+                 nfame = 1;
+                 *(newindfamgro+nfamn+nfame) = *(newindfamgro+nfamn+nfame-1);
+                 for (j=0;j<nge;j++)
+                   {
+                     tmp1 = *(tmp+j);
+                     *(famele+j) = tmp1;
+                     if (tmp1 == 1)
+                       {
+                         strncpy(newfamgro+*(newindfamgro+nfamn+nfame),
+                                 nomgroele+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
+                         *(newindfamgro+nfamn+nfame) = *(newindfamgro+nfamn+nfame)
+                           + MED_TAILLE_LNOM;
+                       }
+                   }
+                 if (estfam0 == 0)
+                   {
+                     newnumele = -1;
+                     *(newnumfamele+i) = newnumele;
+                     *(newnumfam+nfamn+nfame-1) = newnumele;
+                   }
+                 else
+                   {
+                     newnumele = 0;
+                     *(newnumfam+nfamn+nfame-1) = newnumele;
+                     existfam0 = 1;
+                   }
+               }
+           }
+         else
+           {
+             for (j=0;j<nfame;j++)
+               {
+                 p = famele + nge*j;
+                 for (k=0;k<nge;k++)
+                   {
+                     if (*(p+k) != *(tmp+k))
+                       {
+                         exist = 0;
+                         break;
+                       }
+                     else
+                       exist = 1;
+                   }
+                 if (exist == 1)
+                   {
+                     if (estfam0 == 0)
+                       *(newnumfamele+i) = *(newnumfam+nfamn+j);
+                     break;
+                   }
+               }
+             if (exist == 0 && !(estfam0 && existfam0))
+               /* on cree une nouvelle famille */
+               {
+                 nfame = nfame + 1;
+                 *(newindfamgro+nfamn+nfame) = *(newindfamgro+nfamn+nfame-1);
+                 p = famele;
+                 if ((famele = (med_int*) malloc(sizeof(med_int)*nge*nfame))
+                     == NULL)
+                   return -1;
+                 for (j=0;j<nfame-1;j++)
+                   for (k=0;k<nge;k++)
+                     *(famele+j*nge+k) = *(p+j*nge+k);
+                 free(p);
+                 p = famele+(nfame-1)*nge;
+                 for (j=0;j<nge;j++)
+                   {
+                     tmp1 = *(tmp+j);
+                     *(p+j) = tmp1;
+                     if (tmp1 == 1)
+                       {
+                         strncpy((newfamgro+*(newindfamgro+nfamn+nfame)), 
+                                 nomgroele+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
+                         *(newindfamgro+nfamn+nfame) =
+                           *(newindfamgro+nfamn+nfame) + MED_TAILLE_LNOM;
+                       }
+                   }
+                 if (estfam0 == 0)
+                   {
+                     newnumele = newnumele - 1;
+                     *(newnumfamele+i) = newnumele;
+                     *(newnumfam+nfamn+nfame-1) = newnumele;
+                   }
+                 else
+                   if (existfam0 == 0)
+                     {
+                       *(newnumfam+nfamn+nfame-1) = 0;
+                       existfam0 =1;
+                     }
+               }
+           }
+         free(tmp);
+       }
+      
+      *(newfamgro+MED_TAILLE_LNOM*nindf) = '\0';
+
+      free(famnoe);
+      free(famele);
+    }
+  else
+    {
+      *newnumfam = 0;
+      for (i=0;i<nele;i++)
+       *(newnumfamele+i) = 0;
+      for (i=0;i<nnoe;i++)
+       *(newnumfamnoe+i) = 0;
+    }
+  
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDindiceInfo.cxx b/src/MEDWrapper/V2_1/MEDindiceInfo.cxx
new file mode 100644 (file)
index 0000000..4e88572
--- /dev/null
@@ -0,0 +1,48 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDindiceInfo
+ * - Description : en argument de H5Giterate, donne le nom
+ *                 de l'objet HDF (data set ou data group)
+ *                 contenu dans l'objet HDF passe en argument
+ * - Parametres :
+ *     - id      (IN)     : l'ID de l'objet HDF
+ *     - nom     (OUT)    : le nom recupere 
+ *     - donnees  (OUT)    : tampon
+ * - Resultat : 1 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDindiceInfo(med_idt id, const char *nom, void *donnees)
+{
+  if (donnees != NULL)
+    strcpy((char*)donnees,nom);
+  else 
+    return -1;
+
+  return 1;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDindiceNum.cxx b/src/MEDWrapper/V2_1/MEDindiceNum.cxx
new file mode 100644 (file)
index 0000000..bc757ed
--- /dev/null
@@ -0,0 +1,47 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDindiceNum
+ * - Description : en argument de H5Giterate, donne le nombre
+ *                 d'objets HDF (data set ou data group)
+ *                 contenu dans l'objet HDF passe en argument
+ * - Parametres :
+ *     - id      (IN)     : l'ID de l'objet HDF
+ *     - nom     (OUT)    : le nom du sous-objet
+ *     - donnees (OUT)    : tampon
+ * - Resultat : le nombre d'objets en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDindiceNum(med_idt id,const char *nom, void *donnees)
+{
+  int *compteur;
+  
+  compteur = (int *) donnees;
+  (*compteur)++;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDlFichDes.cxx b/src/MEDWrapper/V2_1/MEDlFichDes.cxx
new file mode 100644 (file)
index 0000000..7e63c91
--- /dev/null
@@ -0,0 +1,82 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+#include <string.h>
+
+namespace med_2_1{
+
+med_int
+MEDlFichDes(med_idt fid)
+{
+  med_idt attr, root;
+  med_err ret=0;
+  char des[MED_TAILLE_DESC+1];
+  med_int longueur=0;
+  char nom[MED_TAILLE_NOM+1];
+  char chemin[MED_TAILLE_MAA+1];
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * On ouvre le Data Group racine
+   */
+  strncpy(chemin,MED_MAA,MED_TAILLE_MAA-1);
+  chemin[MED_TAILLE_MAA-1] = '\0';
+  if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;
+
+  /*
+   * On regarde si l'attribut existe
+   * Si non => erreur
+   * Si oui => on retourne sa longueur
+   */
+  strcpy(nom,MED_NOM_DESCRIPTEUR);
+  if ((attr = _MEDattrOuvrir(root,nom)) < 0) {
+    _MEDdatagroupFermer(root);
+    longueur=0;
+    return 0;
+  }
+  if ((ret = _MEDattrFermer(attr)) < 0) {
+    _MEDdatagroupFermer(root);
+    return -1;
+  }
+  
+  if ((ret = _MEDattrStringLire(root,nom,MED_TAILLE_DESC,des)) < 0) {
+    _MEDdatagroupFermer(root);
+    return -1;
+  }
+  
+  longueur = strlen(des);
+
+  /*
+   * fermetures 
+   */
+  if ((ret == _MEDdatagroupFermer(root)) < 0)
+    return -1;
+
+  return longueur;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDmaaCr.cxx b/src/MEDWrapper/V2_1/MEDmaaCr.cxx
new file mode 100644 (file)
index 0000000..c4b50b7
--- /dev/null
@@ -0,0 +1,77 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_err 
+MEDmaaCr(med_idt fid, char *maillage, med_int dim)
+{
+  med_idt maaid, root;
+  char chemin[MED_TAILLE_MAA+1];
+  med_err ret;
+
+  /*
+   * On inhibe le gestionnaire d'erreur
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * Si la racine n'existe pas on la cree
+   */
+  strncpy(chemin,MED_MAA,strlen(MED_MAA)-1);
+  chemin[MED_TAILLE_MAA-1] = '\0';
+  if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    if ((root = _MEDdatagroupCreer(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * si le maillage existe deja => erreur
+   */
+  if ((maaid = _MEDdatagroupOuvrir(root,maillage)) > 0)
+    return -1;
+
+  /*
+   * Creation du Data Group
+   */
+  if ((maaid = _MEDdatagroupCreer(root,maillage)) < 0)
+    return -1;
+
+  /*
+   * Creation de l'attribut dimension
+   */
+  if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_DIM,&dim,MED_REMP)) < 0)
+    return -1;
+
+  /* 
+   * Nettoyages divers
+   */
+  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(root)) < 0)
+    return -1;
+
+  return 0;
+}
+  
+}
diff --git a/src/MEDWrapper/V2_1/MEDmaaInfo.cxx b/src/MEDWrapper/V2_1/MEDmaaInfo.cxx
new file mode 100644 (file)
index 0000000..e2b48a7
--- /dev/null
@@ -0,0 +1,62 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_err 
+MEDmaaInfo(med_idt fid, int indice, char *maillage, med_int *dim)
+{
+  int numero;
+  med_idt maaid;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+
+  /*
+   * On inhibe le gestionnaire d'erreur
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * On recupere le nom du groupe de rang "indice"
+   */ 
+  numero = indice-1;
+  if ((ret = _MEDobjetIdentifier(fid,MED_MAA,numero,maillage)) < 0)
+    return -1;
+
+  /*
+   * On va chercher l'attribut dimension 
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maillage);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;   
+  if ((ret = _MEDattrEntierLire(maaid,MED_NOM_DIM,dim)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+    return -1;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDmodeErreurVerrouiller.cxx b/src/MEDWrapper/V2_1/MEDmodeErreurVerrouiller.cxx
new file mode 100644 (file)
index 0000000..aa4eb08
--- /dev/null
@@ -0,0 +1,37 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDmodeErreurVerrouiller
+ * - Description : inhibe le mode erreur HDF5
+ * - Parametres : aucun
+ * - Resultat : aucun
+ */
+
+namespace med_2_1{
+
+void
+_MEDmodeErreurVerrouiller()
+{
+  H5Eset_auto(NULL,NULL);
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnChamp.cxx b/src/MEDWrapper/V2_1/MEDnChamp.cxx
new file mode 100644 (file)
index 0000000..55347ba
--- /dev/null
@@ -0,0 +1,87 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include <string.h>
+#include <stdlib.h>
+#include "med_outils.hxx"
+
+namespace med_2_1{
+
+med_int 
+MEDnChamp(med_idt fid, int indice)
+{
+  int n1;
+  med_int n2;
+  med_idt datagroup;
+  med_err ret;
+  char nomdatagroup[MED_TAILLE_NOM+1];
+  int num;
+  char chemin[MED_TAILLE_CHA+MED_TAILLE_NOM+1];
+
+  if (indice < 0)
+    return -1;
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 
+   */
+  _MEDmodeErreurVerrouiller();
+  
+  /* 
+   * Si le Data Group cha n'existe pas et indice == 0 => 0
+   * sinon erreur => erreur
+   */
+  strcpy(chemin,MED_CHA);
+
+  /*
+   * Si indice == 0 => nombre de champs
+   */
+  if (indice == 0)
+    {
+      n1 = 0;
+      _MEDnObjets(fid,chemin,&n1);
+      n2 = n1;
+    }
+
+  /*
+   * Si indice > 0 => nbre de composants
+   */
+  if (indice > 0)
+    {
+      /*
+       * On recupere le nom du champ 
+       */
+      num = indice-1;
+      if ((ret = _MEDobjetIdentifier(fid,chemin,num,nomdatagroup)) < 0)
+       return -1;
+      strcat(chemin,nomdatagroup);
+      /*
+       * On recupere le nombre de composants
+       */
+      if ((datagroup = _MEDdatagroupOuvrir(fid,chemin)) < 0) 
+       return -1;
+      if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NCO,&n2)) < 0)
+       return -1;
+      if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
+       return -1;
+    }
+
+  return n2;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnCorres.cxx b/src/MEDWrapper/V2_1/MEDnCorres.cxx
new file mode 100644 (file)
index 0000000..10b5830
--- /dev/null
@@ -0,0 +1,83 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_int 
+MEDnCorres(med_idt fid,char *maa,char *eq,med_entite_maillage typ_ent,
+          med_geometrie_element typ_geo)
+{
+  med_idt eqid, datagroup;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1]; 
+  char nomdatagroup[MED_TAILLE_NOM+1];
+  char tmp[MED_TAILLE_NOM_ENTITE+1];
+  med_int n;
+
+  if (typ_geo == MED_TETRA4 || typ_geo == MED_TETRA10 ||
+      typ_geo == MED_HEXA8  || typ_geo == MED_HEXA20  ||
+      typ_geo == MED_PENTA6 || typ_geo == MED_PENTA15 ||
+      typ_geo == MED_PYRA5  || typ_geo == MED_PYRA13)
+    return -1;
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+   _MEDmodeErreurVerrouiller();
+
+  /* 
+   * Si le Data Group de "eq" n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  strcat(chemin,MED_EQS);
+  strcat(chemin,eq);
+  if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;  
+  if ((ret = _MEDnomEntite(nomdatagroup,typ_ent)) < 0)
+    return -1;
+  if ((typ_ent != MED_NOEUD))
+    {
+      if ((ret = _MEDnomGeometrie(tmp,typ_geo)) < 0)
+       return -1;
+      strcat(nomdatagroup,".");
+      strcat(nomdatagroup,tmp);
+    }
+  if ((datagroup = _MEDdatagroupOuvrir(eqid,nomdatagroup)) < 0)
+    return 0;
+  if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,&n)) < 0)
+    return -1;
+
+  /*
+   * On ferme tout
+   */
+  if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(eqid)) < 0)
+    return -1;
+
+  return n;  
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnEntMaa.cxx b/src/MEDWrapper/V2_1/MEDnEntMaa.cxx
new file mode 100644 (file)
index 0000000..7f9cfbd
--- /dev/null
@@ -0,0 +1,111 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_int
+MEDnEntMaa(med_idt fid, char *maa, med_table quoi, med_entite_maillage type_ent, 
+          med_geometrie_element type_geo, med_connectivite type_conn)
+{
+  med_idt root, maaid, entid,geoid, dataset=0;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
+  char nom_geo[MED_TAILLE_NOM_ENTITE+1];
+  char nom_dataset[MED_TAILLE_NOM_ENTITE+1];
+  med_int res = 0;
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * Si le maillage n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;
+
+  /*
+   * On met a jour le nom du Data Group representant
+   * le type des entites
+   */
+  if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
+    return -1;
+
+   /*
+    * Si le Data Group des entites n'existe pas => res = 0
+    */
+  entid = _MEDdatagroupOuvrir(maaid,nom_ent);
+
+   /*
+    * Pour les mailles, les faces et le aretes
+    * si le Data Group du type geometrique n'existe pas => res = 0
+    */
+  if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE))
+    {
+      if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
+       return -1;
+      geoid = _MEDdatagroupOuvrir(entid,nom_geo);
+    }
+  else
+    geoid = -1;
+  
+   /*
+    * Ouverture du Data Set renvoye par _MEDnomDataset()
+    * S'il n'existe pas => erreur
+    * Sinon lecture de l'attribut NBR
+    */
+   if (geoid == -1)
+     root = entid;
+   else
+     root = geoid;
+   if ((ret = _MEDnomDataset(nom_dataset,quoi,type_conn)) < 0)
+     return -1;
+   dataset = _MEDdatasetOuvrir(root,nom_dataset);
+   if (dataset > 0)
+     if ((ret = _MEDattrEntierLire(dataset,MED_NOM_NBR,&res)) < 0)
+       return -1;
+
+   /*
+    * On ferme tout
+    */
+   if (dataset > 0)
+     if ((ret = _MEDdatasetFermer(dataset)) < 0)
+       return -1;
+   if (geoid > 0)
+     if ((ret = _MEDdatagroupFermer(geoid)) < 0)
+       return -1;
+   if (entid > 0)
+     if ((ret = _MEDdatagroupFermer(entid)) < 0)
+       return -1;
+   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+     return -1; 
+
+  return res;
+}
+     
+}
diff --git a/src/MEDWrapper/V2_1/MEDnEntites.cxx b/src/MEDWrapper/V2_1/MEDnEntites.cxx
new file mode 100644 (file)
index 0000000..b5b32c4
--- /dev/null
@@ -0,0 +1,69 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+
+namespace med_2_1{
+
+med_int
+MEDnEntites(med_idt fid,char *maa,med_entite_maillage typ_ent, 
+            med_connectivite typ_con)
+{
+  med_int total = 0;
+  int i;  
+  med_geometrie_element typ_mai[MED_NBR_GEOMETRIE_MAILLE] = {MED_POINT1,MED_SEG2, 
+                                                    MED_SEG3,MED_TRIA3,
+                                                    MED_TRIA6,MED_QUAD4,
+                                                    MED_QUAD8,MED_TETRA4,
+                                                    MED_TETRA10,MED_HEXA8,
+                                                    MED_HEXA20,MED_PENTA6,
+                                                    MED_PENTA15,MED_PYRA5,
+                                                    MED_PYRA13};
+  med_geometrie_element typ_fac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6,
+                                                    MED_QUAD4,MED_QUAD8};
+  med_geometrie_element typ_are[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3};  
+
+  switch (typ_ent)
+  {
+     case MED_MAILLE :
+        for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
+          total += MEDnEntMaa(fid,maa,MED_CONN,MED_MAILLE,typ_mai[i],typ_con);
+        break;
+
+     case MED_FACE :
+        for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++)
+          total += MEDnEntMaa(fid,maa,MED_CONN,MED_FACE,typ_fac[i],typ_con);
+        break;
+
+     case MED_ARETE :
+        for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++)
+          total += MEDnEntMaa(fid,maa,MED_CONN,MED_ARETE,typ_are[i],typ_con);
+        break;
+
+     case MED_NOEUD :
+       total = MEDnEntMaa(fid,maa,MED_COOR,MED_NOEUD,(med_geometrie_element)0,(med_connectivite)0);
+        break;
+
+     default :
+        total = -1;
+  }
+
+  return total;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnEquiv.cxx b/src/MEDWrapper/V2_1/MEDnEquiv.cxx
new file mode 100644 (file)
index 0000000..7c98481
--- /dev/null
@@ -0,0 +1,47 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_int 
+MEDnEquiv(med_idt fid, char *maa)
+{
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+MED_TAILLE_EQS+1];
+  int n;
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  strcat(chemin,MED_EQS);
+  n = 0;
+  _MEDnObjets(fid,chemin,&n);
+
+  return (med_int) n;  
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnFam.cxx b/src/MEDWrapper/V2_1/MEDnFam.cxx
new file mode 100644 (file)
index 0000000..3ac7579
--- /dev/null
@@ -0,0 +1,108 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_int 
+MEDnFam(med_idt fid,char *maa, int indice, med_dim_famille quoi)
+{
+  med_idt datagroup,famid;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_FAS+2*MED_TAILLE_NOM+1];
+  med_int n;
+  int n_tmp;
+  int num;
+  char famille[MED_TAILLE_NOM+1];
+
+
+  /* 
+   * On inhibe le gestionnaire d'erreur HDF 
+   */
+  _MEDmodeErreurVerrouiller();
+
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  strcat(chemin,MED_FAS);
+  if (indice == 0)
+    {
+      n_tmp = 0;
+      _MEDnObjets(fid,chemin,&n_tmp);
+      n = (med_int ) n_tmp;
+    }
+  else
+    {
+      /*
+       * On recupere le nom de la famille
+       */
+      num = indice - 1;
+      if ((ret = _MEDobjetIdentifier(fid,chemin,num,
+                           famille)) < 0)
+       return -1;
+      
+  /* 
+   * Si le Data Group de la famille n'existe pas => erreur
+   */
+      strcat(chemin,famille);
+      if ((famid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+       return -1;
+
+      switch (quoi)
+       {
+       case MED_GROUPE :
+         if ((datagroup = _MEDdatagroupOuvrir(famid,MED_NOM_GRO)) < 0)
+           n = 0;
+         else
+           {
+             if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,&n)) < 0)
+               return -1;
+             if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
+               return -1;
+           }
+         break;
+
+       case MED_ATTR :
+         if ((datagroup = _MEDdatagroupOuvrir(famid,MED_NOM_ATT)) < 0)
+           n = 0;
+         else
+           {
+             if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,&n)) < 0)
+               return -1;
+             if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
+               return -1;
+           }
+         break;
+
+       default :
+         return -1;
+       }
+
+      if ((ret = _MEDdatagroupFermer(famid)) < 0)
+        return -1;
+
+    }
+
+  return (med_int) n;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnGrid.cxx b/src/MEDWrapper/V2_1/MEDnGrid.cxx
new file mode 100644 (file)
index 0000000..607888c
--- /dev/null
@@ -0,0 +1,114 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+namespace med_2_1{
+
+med_int 
+MEDnGrid(med_idt fid, char *maa, med_grid n) 
+{
+    med_idt maaid, entid, geoid, dataset;
+    char    chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+    char    nom_ent[MED_TAILLE_NOM_ENTITE+1];
+    char    *nom_dataset;
+    med_int  res = (-1);
+
+    /* On inhibe le gestionnaire d'erreur HDF 5 */
+    _MEDmodeErreurVerrouiller();
+
+    /* Si le maillage n'existe pas => erreur */
+    strcpy(chemin, MED_MAA);
+    strcat(chemin, maa);
+    maaid = _MEDdatagroupOuvrir(fid, chemin);
+    if (maaid < 0) return(-1);
+
+    switch (n) {
+        case MED_FAM_NOEUD : {
+            nom_dataset = MED_NOM_FAM;
+            if (_MEDnomEntite(nom_ent, MED_NOEUD) < 0) return(-1);
+            entid = _MEDdatagroupOuvrir(maaid, nom_ent);
+            break;
+        };
+        case MED_FAM_ARETE : {
+            nom_dataset = MED_NOM_FAM;
+            if (_MEDnomEntite(nom_ent, MED_ARETE) < 0) return(-1);
+            geoid = _MEDdatagroupOuvrir(maaid, nom_ent);
+            if (geoid < 0) return(-1);
+            if (_MEDnomGeometrie(nom_ent, MED_SEG2) < 0) return(-1);
+            entid = _MEDdatagroupOuvrir(geoid, nom_ent);
+            break;
+        };
+        case MED_FAM_FACE : {
+            nom_dataset = MED_NOM_FAM;
+            if (_MEDnomEntite(nom_ent, MED_FACE) < 0) return(-1);
+            geoid = _MEDdatagroupOuvrir(maaid, nom_ent);
+            if (geoid < 0) return(-1);
+            if (_MEDnomGeometrie(nom_ent, MED_QUAD4) < 0) return(-1);
+            entid = _MEDdatagroupOuvrir(geoid, nom_ent);
+            break;
+        };
+        case MED_FAM_MAILLE : {
+            nom_dataset = MED_NOM_FAM;
+            if (_MEDnomEntite(nom_ent, MED_MAILLE) < 0) return(-1);
+            geoid = _MEDdatagroupOuvrir(maaid, nom_ent);
+            if (geoid < 0) return(-1);
+            if (_MEDnomGeometrie(nom_ent, MED_HEXA8) < 0) return(-1);
+            entid = _MEDdatagroupOuvrir(geoid, nom_ent);
+            break;
+        };
+        case MED_GRID_NOEUD : {
+            nom_dataset = MED_NOM_BOF;
+            entid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE);
+            break;
+        };
+        case MED_GRID_D1 : {
+            nom_dataset = MED_NOM_IN1;
+            entid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE);
+            break;
+        };
+        case MED_GRID_D2 : {
+            nom_dataset = MED_NOM_IN2;
+            entid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE);
+            break;
+        };
+        case MED_GRID_D3 : {
+            nom_dataset = MED_NOM_IN3;
+            entid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE);
+            break;
+        };
+        default : {
+            return(-1);
+        };
+    };
+
+    if (entid < 0) return(-1);
+    dataset = _MEDdatasetOuvrir(entid, nom_dataset);
+    if (dataset < 0) return(-1);
+    if (_MEDattrEntierLire(dataset, MED_NOM_NBR, &res) < 0) return(-1);
+
+    /* On ferme tout */
+    if (_MEDdatasetFermer(dataset) < 0) return(-1);
+    if (_MEDdatagroupFermer(entid) < 0) return(-1);
+    if (_MEDdatagroupFermer(maaid) < 0) return(-1);
+
+    return(res);
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnMaa.cxx b/src/MEDWrapper/V2_1/MEDnMaa.cxx
new file mode 100644 (file)
index 0000000..a7a8124
--- /dev/null
@@ -0,0 +1,39 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+
+namespace med_2_1{
+
+med_int 
+MEDnMaa(med_idt fid)
+{
+  int n;
+
+  _MEDmodeErreurVerrouiller();
+  
+  n = 0;
+  _MEDnObjets(fid,MED_MAA,&n);
+
+  return (med_int) n;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnObjets.cxx b/src/MEDWrapper/V2_1/MEDnObjets.cxx
new file mode 100644 (file)
index 0000000..6720f95
--- /dev/null
@@ -0,0 +1,46 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDnObjets
+ * - Description : indique le nombre d'objets HDF contenu dans le
+ *                 datagroup passe en argument
+ * - Parametres :
+ *     - fid     (IN)     : l'ID du fichier HDF
+ *     - chemin  (IN)     : chemin d'acces au datagroup
+ *     - n       (OUT)    : le nombre recherche
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDnObjets(med_idt fid,char *chemin,int *n)
+{
+  int idx;
+
+  if ((idx  = H5Giterate(fid,chemin,NULL,_MEDindiceNum,(void *)n)) < 0)
+    return -1;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnPasdetemps.cxx b/src/MEDWrapper/V2_1/MEDnPasdetemps.cxx
new file mode 100644 (file)
index 0000000..6cad0ba
--- /dev/null
@@ -0,0 +1,73 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+/*
+ * Nombre de Couple (PDT,NOR) pour le champ <cha>
+ */
+
+namespace med_2_1{
+
+med_int 
+MEDnPasdetemps(med_idt fid,char *cha,med_entite_maillage type_ent, 
+              med_geometrie_element type_geo)
+
+{
+  med_err ret;
+  int n1;
+  char nomdatagroup1[MED_TAILLE_NOM+1];
+  char tmp1         [MED_TAILLE_NOM_ENTITE+1];
+  char chemin       [MED_TAILLE_CHA+(MED_TAILLE_NOM+1)+MED_TAILLE_NOM+1];
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+  
+  /* 
+   * Creation du chemin d'accès aux différents (PDT,NOR) pour les différents <type_ent>[.<type_geo>]
+   */
+  strcpy(chemin,MED_CHA);
+  strcat(chemin,cha);
+  strcat(chemin,"/");
+  if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0)
+    return -1;
+  if ((type_ent != MED_NOEUD))
+    {
+      if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0)
+       return -1;
+      strcat(nomdatagroup1,".");
+      strcat(nomdatagroup1,tmp1);
+    }
+  strcat(chemin,nomdatagroup1);
+
+  n1 =0;
+  _MEDnObjets(fid,chemin,&n1);
+      
+  return (med_int) n1;
+
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnProfil.cxx b/src/MEDWrapper/V2_1/MEDnProfil.cxx
new file mode 100644 (file)
index 0000000..5dcb648
--- /dev/null
@@ -0,0 +1,38 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+namespace med_2_1{
+
+med_int 
+MEDnProfil(med_idt fid)
+{
+  int n;
+  med_err ret;
+
+  _MEDmodeErreurVerrouiller();
+
+  n = 0;
+  _MEDnObjets(fid,MED_PROFILS,&n);
+
+  return (med_int) n;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnVal.cxx b/src/MEDWrapper/V2_1/MEDnVal.cxx
new file mode 100644 (file)
index 0000000..010c826
--- /dev/null
@@ -0,0 +1,83 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include <string.h>
+#include <stdlib.h>
+#include "med_outils.hxx"
+
+namespace med_2_1{
+
+med_int 
+MEDnVal(med_idt fid, char *champ, med_entite_maillage type_ent, 
+       med_geometrie_element type_geo,med_int numdt, med_int numo)
+{
+  med_int n;
+  med_idt datagroup;
+  med_err ret;
+  char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2],nomdatagroup2[2*MED_MAX_PARA+1];
+  char tmp1   [MED_TAILLE_NOM_ENTITE+1];
+  char chemin [MED_TAILLE_CHA+(MED_TAILLE_NOM+1)+(2*MED_TAILLE_NOM_ENTITE+2)+(2*MED_MAX_PARA)+1+100];
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * On cree le chemin d'accès
+   */
+  strcpy(chemin,MED_CHA);
+  strcat(chemin,champ);
+  strcat(chemin,"/");
+
+  /* On cree le nom du datagroup de niveau 1 */
+  if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0)
+    return -1;
+  if ((type_ent != MED_NOEUD))
+    {
+      if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0)
+       return -1;
+      strcat(nomdatagroup1,".");
+      strcat(nomdatagroup1,tmp1);
+    }
+  strcat(chemin,nomdatagroup1);
+  strcat(chemin,"/");
+
+  /* Creation du datagroup de niveau 2 <numdt>.<numoo> */
+  sprintf(nomdatagroup2,"%*li%*li",MED_MAX_PARA,(long ) numdt,MED_MAX_PARA,(long ) numo);
+  strcat(chemin,nomdatagroup2);
+ /*
+   * Acces au champ
+  */
+  if ((datagroup = _MEDdatagroupOuvrir(fid,chemin)) < 0) 
+    return 0;
+  if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,&n)) < 0)
+    return -1;
+
+  /*
+   * fermetures 
+   */
+  if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
+    return -1;
+  return n;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnValProfil.cxx b/src/MEDWrapper/V2_1/MEDnValProfil.cxx
new file mode 100644 (file)
index 0000000..7c14cf2
--- /dev/null
@@ -0,0 +1,60 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_int 
+MEDnValProfil(med_idt fid, char *nom)
+{
+  med_int n = 0;
+  med_idt pid;
+  char chemin[MED_TAILLE_PROFILS+MED_TAILLE_NOM+1]; 
+  med_err ret;
+  
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /* 
+   * ouverture du groupe /PROFILS/"nom"
+   */  
+  strcpy(chemin,MED_PROFILS);
+  strcat(chemin,nom); 
+  if ((pid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;
+
+  if ((ret = _MEDattrEntierLire(pid,MED_NOM_N,&n)) < 0)
+    return ret;
+
+  /*
+   * On ferme tout
+   */
+  if ((ret = _MEDdatagroupFermer(pid)) < 0)
+    return -1; 
+
+  return n;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnbnoisEcr.cxx b/src/MEDWrapper/V2_1/MEDnbnoisEcr.cxx
new file mode 100644 (file)
index 0000000..3c287ce
--- /dev/null
@@ -0,0 +1,62 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_err 
+MEDnbnoisEcr(med_idt fid, char *nom_maillage,med_int n)
+{
+  med_idt maaid;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  med_err ret;
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * Si le maillage n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,nom_maillage);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * Creation de l'attribut "Nombre de Noeuds Isoles"
+   */
+  if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_NNI,&n,MED_REMP)) < 0)
+    return -1;
+
+  /* 
+   * Fermetures des objets
+   */
+  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+    return -1;
+
+  return 0;
+}
+  
+}
diff --git a/src/MEDWrapper/V2_1/MEDnbnoisLire.cxx b/src/MEDWrapper/V2_1/MEDnbnoisLire.cxx
new file mode 100644 (file)
index 0000000..363d66f
--- /dev/null
@@ -0,0 +1,63 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_int
+MEDnbnoisLire(med_idt fid,char *nom_maillage)
+{
+  med_idt maaid;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  med_int n;
+
+  /*
+   * On inhibe le gestionnaire d'erreur
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * On regarde si le maillage existe => erreur si non 
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,nom_maillage);  
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;
+
+  /*
+   * On va lire l'attribut "NNI"
+   */
+  if ((ret = _MEDattrEntierLire(maaid,MED_NOM_NNI,&n)) < 0)
+    return -1;
+
+  /*
+   * Fermetures des objets HDF 
+   */
+  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+    return -1;
+
+  return n;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnbnomaEcr.cxx b/src/MEDWrapper/V2_1/MEDnbnomaEcr.cxx
new file mode 100644 (file)
index 0000000..2d63525
--- /dev/null
@@ -0,0 +1,62 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_err
+MEDnbnomaEcr(med_idt fid, char *nom_maillage,med_int n)
+{
+  med_idt maaid;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  med_err ret;
+
+  /*
+   * On inhibe le gestionnaire d'erreur
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * Si le maillage n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,nom_maillage);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * Creation de l'attribut "Nombre de Noeuds Max par maille"
+   */
+  if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_NNM,&n,MED_REMP)) < 0)
+    return -1;
+
+  /* 
+   * Nettoyages divers
+   */
+  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+    return -1;
+
+  return 0;
+}
+  
+}
diff --git a/src/MEDWrapper/V2_1/MEDnbnomaLire.cxx b/src/MEDWrapper/V2_1/MEDnbnomaLire.cxx
new file mode 100644 (file)
index 0000000..b018a0a
--- /dev/null
@@ -0,0 +1,63 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_int
+MEDnbnomaLire(med_idt fid,char *nom_maillage)
+{
+  med_idt maaid;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  med_int n;
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * On regarde si le maillage existe => erreur si non 
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,nom_maillage);  
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;
+
+  /*
+   * On va lire l'attribut "NNM"
+   */
+  if ((ret = _MEDattrEntierLire(maaid,MED_NOM_NNM,&n)) < 0)
+    return -1;
+
+  /*
+   * Fermetures des objets HDF 
+   */
+  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+    return -1;
+
+  return n;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnbnosoEcr.cxx b/src/MEDWrapper/V2_1/MEDnbnosoEcr.cxx
new file mode 100644 (file)
index 0000000..453ebe2
--- /dev/null
@@ -0,0 +1,62 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_err 
+MEDnbnosoEcr(med_idt fid, char *nom_maillage,med_int n)
+{
+  med_idt maaid;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  med_err ret;
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * Si le maillage n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,nom_maillage);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * Creation de l'attribut "Nombre de Noeuds Sommets"
+   */
+  if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_NNS,&n,MED_REMP)) < 0)
+    return -1;
+
+  /* 
+   * Fermetures
+   */
+  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+    return -1;
+
+  return 0;
+}
+  
+}
diff --git a/src/MEDWrapper/V2_1/MEDnbnosoLire.cxx b/src/MEDWrapper/V2_1/MEDnbnosoLire.cxx
new file mode 100644 (file)
index 0000000..7a1b672
--- /dev/null
@@ -0,0 +1,63 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med_outils.hxx"
+#include "med.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_int
+MEDnbnosoLire(med_idt fid,char *nom_maillage)
+{
+  med_idt maaid;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  med_int n;
+
+  /*
+   * On inhibe le gestionnaire d'erreur
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * On regarde si le maillage existe => erreur si non 
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,nom_maillage);  
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;
+
+  /*
+   * On va lire l'attribut "NNS"
+   */
+  if ((ret = _MEDattrEntierLire(maaid,MED_NOM_NNS,&n)) < 0)
+    return -1;
+
+  /*
+   * Fermetures des objets HDF 
+   */
+  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+    return -1;
+
+  return n;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnoeudsEcr.cxx b/src/MEDWrapper/V2_1/MEDnoeudsEcr.cxx
new file mode 100644 (file)
index 0000000..808d258
--- /dev/null
@@ -0,0 +1,55 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+
+namespace med_2_1{
+
+med_err
+MEDnoeudsEcr(med_idt fid,char *maa,med_int mdim,med_float *coord,
+            med_mode_switch mode_coo,
+            med_repere repere,char *nomcoo, char *unicoo,char *nom,
+            med_booleen inom,med_int *num,med_booleen inum,med_int *fam,
+            med_int nnoeuds,med_mode_acces mode)
+{
+  med_err ret;
+
+  /* ecriture des coordonnees */
+  if ((ret = MEDcoordEcr(fid,maa,mdim,coord,mode_coo,
+                        nnoeuds,mode,repere,nomcoo,
+                        unicoo)) < 0)
+    return -1;
+
+  /* ecriture des noms (facultatifs) */
+  if (inom == MED_VRAI)
+    if ((ret = MEDnomEcr(fid,maa,nom,nnoeuds,mode,MED_NOEUD,MED_POINT1)) < 0)
+      return -1;
+
+  /* ecriture des numeros (facultatifs) */
+  if (inum == MED_VRAI)
+    if ((ret = MEDnumEcr(fid,maa,num,nnoeuds,mode,MED_NOEUD,MED_POINT1)) < 0)
+      return -1;
+
+  /* ecriture des numeros de familles */
+  if ((ret = MEDfamEcr(fid,maa,fam,nnoeuds,mode,MED_NOEUD,MED_POINT1)) < 0)
+    return -1;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnoeudsLire.cxx b/src/MEDWrapper/V2_1/MEDnoeudsLire.cxx
new file mode 100644 (file)
index 0000000..68014ba
--- /dev/null
@@ -0,0 +1,57 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+
+#include "med.hxx"
+
+namespace med_2_1{
+
+med_err
+MEDnoeudsLire(med_idt fid,char *maa,med_int mdim, med_float *coord,
+             med_mode_switch mode_coo,
+             med_repere *repere,char *nomcoo, char *unicoo,char *nom,
+             med_booleen *inom,med_int *num,med_booleen *inum,med_int *fam,
+             med_int nnoeuds)
+{
+  med_err ret;
+
+  /* lecture des coordonnees */
+  if ((ret = MEDcoordLire(fid,maa,mdim,coord,mode_coo,MED_ALL,0,MED_NOPF,repere,nomcoo,
+                         unicoo)) < 0)
+    return -1;
+
+  /* lecture des noms (facultatifs) */
+  if ((ret = MEDnomLire(fid,maa,nom,nnoeuds,MED_NOEUD,MED_POINT1)) < 0)
+    *inom = MED_FAUX;
+  else
+    *inom = MED_VRAI;
+
+  /* lecture des numeros (facultatifs) */
+  if ((ret = MEDnumLire(fid,maa,num,nnoeuds,MED_NOEUD,MED_POINT1)) < 0)
+    *inum = MED_FAUX;
+  else
+    *inum = MED_VRAI;  
+
+  /* lecture des numeros de familles */
+  if ((ret = MEDfamLire(fid,maa,fam,nnoeuds,MED_NOEUD,MED_POINT1)) < 0)
+    return -1;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnomDataset.cxx b/src/MEDWrapper/V2_1/MEDnomDataset.cxx
new file mode 100644 (file)
index 0000000..fe72b24
--- /dev/null
@@ -0,0 +1,79 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDnomDataset
+ * - Description : fournit un nom de dataset
+ * - Parametres :
+ *     - nom_dataset (OUT) : le nom du data set
+ *     - quoi (IN)         : le type de table MED
+ *     - type_conn (IN)    : le type de connectivite
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDnomDataset(char *nom_dataset,med_table quoi,med_connectivite type_conn)
+{
+  switch(quoi)
+    {
+    case MED_COOR :
+      strcpy(nom_dataset,MED_NOM_COO);
+      break;
+
+    case MED_CONN :
+      switch(type_conn)
+       {
+       case MED_NOD :
+         strcpy(nom_dataset,MED_NOM_NOD);
+         break;
+
+       case MED_DESC :
+         strcpy(nom_dataset,MED_NOM_DES);
+         break;
+
+       default :
+         return -1;
+       }
+      break;
+
+    case MED_NOM :
+      strcpy(nom_dataset,MED_NOM_NOM);
+      break;
+
+    case MED_NUM :
+      strcpy(nom_dataset,MED_NOM_NUM);
+      break;
+
+    case MED_FAM :
+      strcpy(nom_dataset,MED_NOM_FAM);
+      break;
+
+    default :
+      return -1;
+    }
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnomEcr.cxx b/src/MEDWrapper/V2_1/MEDnomEcr.cxx
new file mode 100644 (file)
index 0000000..a71cf47
--- /dev/null
@@ -0,0 +1,116 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <stdlib.h>
+#include <string.h>
+
+namespace med_2_1{
+
+med_err 
+MEDnomEcr(med_idt fid,char *maa, char *nom, med_int n, med_mode_acces mode,
+         med_entite_maillage type_ent,med_geometrie_element type_geo)
+{
+  med_idt root, maaid, entid, geoid, dataset;
+  med_err ret;
+  med_size dimd[1];
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
+  char nom_geo[MED_TAILLE_NOM_ENTITE+1];
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * Si le maillage n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * On met a jour le nom du Data Group representant
+   * le type des entites
+   */
+   if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
+     return -1;
+
+   /*
+    * Si le Data Group des entites n'existe pas on le cree
+    */
+   if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
+     if ((entid = _MEDdatagroupCreer(maaid,nom_ent)) < 0)
+       return -1;
+
+   /*
+    * Pour les mailles, les faces et le aretes, on cree
+    * s'il n'existe pas le Data Group du type geometrique
+    */
+   if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE))
+     {
+       if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
+        return -1;
+
+       if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
+        if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0)
+          return -1;
+     }
+   else
+     geoid = -1;
+
+   /*
+    * Creation du Data Set "NOM" 
+    */
+   if (geoid == -1)
+     root = entid;
+   else
+     root = geoid;
+   dimd[0] = n*MED_TAILLE_PNOM+1;
+   if ((ret = _MEDdatasetStringEcrire(root,MED_NOM_NOM,dimd,nom,mode)) < 0)
+     return -1;
+
+  /*
+   * Attribut NBR (nombre de noeuds)
+   */
+   if ((dataset = _MEDdatasetOuvrir(root,MED_NOM_NOM)) < 0)
+     return -1;
+   if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n,mode)) < 0)
+     return -1;
+
+   /*
+    * On ferme tout
+    */
+   if ((ret = _MEDdatasetFermer(dataset)) < 0)
+     return -1;
+   if (geoid > 0)
+     if ((ret = _MEDdatagroupFermer(geoid)) < 0)
+       return -1;
+   if ((ret = _MEDdatagroupFermer(entid)) < 0)
+     return -1;
+   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+     return -1;
+
+  return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnomEntite.cxx b/src/MEDWrapper/V2_1/MEDnomEntite.cxx
new file mode 100644 (file)
index 0000000..b5b4350
--- /dev/null
@@ -0,0 +1,60 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDnomEntite
+ * - Description : fournit le nom associe a un type d'entite MED
+ * - Parametres :
+ *     - nom_ent (OUT) : le nom de l'entite
+ *     - type_ent (IN) : le type de l'entite
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDnomEntite(char *nom_ent,med_entite_maillage type_ent)
+{
+   switch(type_ent)
+     {
+     case MED_NOEUD :
+       strcpy(nom_ent,MED_NOM_NOE);
+       break;
+
+     case MED_MAILLE :
+       strcpy(nom_ent,MED_NOM_MAI);
+       break;
+
+     case MED_FACE :
+       strcpy(nom_ent,MED_NOM_FAC);
+       break;
+
+     case MED_ARETE :
+       strcpy(nom_ent,MED_NOM_ARE);
+       break;
+
+     default :
+       return -1;
+     }
+   return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnomGeometrie.cxx b/src/MEDWrapper/V2_1/MEDnomGeometrie.cxx
new file mode 100644 (file)
index 0000000..3cbc6bb
--- /dev/null
@@ -0,0 +1,106 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDnomGeometrie
+ * - Description : fournit le nom de l'element geometrique associe
+ *                 au type geometrique MED
+ * - Parametres :
+ *     - nom_geo (OUT) : le nom de l'element
+ *     - type_geo (IN) : le type de l'element
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDnomGeometrie(char *nom_geo,med_geometrie_element type_geo)
+{
+   switch (type_geo)
+     {
+     case MED_POINT1 :
+       strcpy(nom_geo,MED_NOM_PO1);
+       break;
+       
+     case MED_SEG2 :
+       strcpy(nom_geo,MED_NOM_SE2);
+       break;
+          
+     case MED_SEG3 :
+       strcpy(nom_geo,MED_NOM_SE3);
+       break;
+          
+     case MED_TRIA3 :
+       strcpy(nom_geo,MED_NOM_TR3);
+       break;
+          
+     case MED_TRIA6 :
+       strcpy(nom_geo,MED_NOM_TR6);
+       break;
+          
+     case MED_QUAD4 :
+       strcpy(nom_geo,MED_NOM_QU4);
+       break;
+       
+     case MED_QUAD8 :
+       strcpy(nom_geo,MED_NOM_QU8);
+       break;
+       
+     case MED_TETRA4 :
+       strcpy(nom_geo,MED_NOM_TE4);
+       break;
+       
+     case MED_TETRA10 :
+       strcpy(nom_geo,MED_NOM_T10);
+       break;
+       
+     case MED_HEXA8 :
+       strcpy(nom_geo,MED_NOM_HE8);
+       break;
+       
+     case MED_HEXA20 :
+       strcpy(nom_geo,MED_NOM_H20);
+       break;
+       
+     case MED_PENTA6 :
+       strcpy(nom_geo,MED_NOM_PE6);
+       break;
+       
+     case MED_PENTA15 :
+       strcpy(nom_geo,MED_NOM_P15);
+       break;
+       
+     case MED_PYRA5 :
+       strcpy(nom_geo,MED_NOM_PY5);
+       break;
+       
+     case MED_PYRA13 :
+       strcpy(nom_geo,MED_NOM_P13);
+       break;
+
+     default :
+       return -1;
+        }
+   
+   return 0;
+} 
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnomLire.cxx b/src/MEDWrapper/V2_1/MEDnomLire.cxx
new file mode 100644 (file)
index 0000000..4ec85b3
--- /dev/null
@@ -0,0 +1,101 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <stdlib.h>
+#include <string.h>
+
+namespace med_2_1{
+
+med_err
+MEDnomLire(med_idt fid,char *maa, char *nom, med_int n, 
+          med_entite_maillage type_ent,med_geometrie_element type_geo)
+{
+  med_idt root, maaid, entid, geoid;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
+  char nom_geo[MED_TAILLE_NOM_ENTITE+1];
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * Si le maillage n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * On met a jour le nom du Data Group representant
+   * le type des entites
+   */
+   if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
+     return -1;
+
+   /*
+    * Si le Data Group des entites n'existe pas => erreur
+    */
+   if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
+     return -1;
+
+   /*
+    * Pour les mailles, les faces et le aretes,
+    * on ouvre le Data Group du type geometrique
+    */
+   if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE))
+     {
+       if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
+        return -1;
+       if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
+          return -1;
+     }
+   else
+     geoid = -1;
+
+   /*
+    * lecture du Data Set "NOM" 
+    */
+   if (geoid == -1)
+     root = entid;
+   else
+     root = geoid;
+   if ((ret = _MEDdatasetStringLire(root,MED_NOM_NOM,nom)) < 0)
+     return -1;
+
+   /*
+    * On ferme tout
+    */
+   if (geoid > 0)
+     if ((ret = _MEDdatagroupFermer(geoid)) < 0)
+       return -1;
+   if ((ret = _MEDdatagroupFermer(entid)) < 0)
+     return -1;
+   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+     return -1;
+
+  return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnumEcr.cxx b/src/MEDWrapper/V2_1/MEDnumEcr.cxx
new file mode 100644 (file)
index 0000000..d72b6ce
--- /dev/null
@@ -0,0 +1,123 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <stdlib.h>
+#include <string.h>
+
+namespace med_2_1{
+
+med_err 
+MEDnumEcr(med_idt fid,char *maa, med_int *num, med_int n, med_mode_acces mode,
+         med_entite_maillage type_ent,med_geometrie_element type_geo)
+{
+  med_idt root, maaid, entid, geoid, dataset;
+  med_err ret;
+  med_size dimd[1];
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
+  char nom_geo[MED_TAILLE_NOM_ENTITE+1];
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller(); 
+
+  /*
+   * Si le maillage n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * On met a jour le nom du Data Group representant
+   * le type des entites
+   */
+   if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
+     return -1;
+
+   /*
+    * Si le Data Group des entites n'existe pas on le cree
+    */
+   if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
+     if ((root = _MEDdatagroupCreer(maaid,nom_ent)) < 0)
+       return -1;
+
+   /*
+    * Pour les mailles, les faces et le aretes, on cree
+    * s'il n'existe pas le Data Group du type geometrique
+    */
+   if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE))
+     {
+       if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
+        return -1;
+
+       if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
+        if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0)
+          return -1;
+     }
+   else 
+     geoid = -1;
+
+   /*
+    * Creation du Data Set "NUM" 
+    */
+   if (geoid == -1)
+     root = entid;
+   else
+     root = geoid;
+   dimd[0] = n;
+#if defined(IRIX64)||defined(OSF1)
+   if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_NUM,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
+                               (unsigned char*) num,mode)) < 0)
+     return -1;
+#else
+   if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_NUM,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
+                               (unsigned char*) num,mode)) < 0)
+     return -1;
+#endif
+
+  /*
+   * Attribut NBR (nombre de noeuds)
+   */
+   if ((dataset = _MEDdatasetOuvrir(root,MED_NOM_NUM)) < 0)
+     return -1;
+   if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n,mode)) < 0)
+     return -1;
+
+   /*
+    * On ferme tout
+    */
+   if ((ret = _MEDdatasetFermer(dataset)) < 0)
+     return -1;
+   if (geoid != -1)
+     if ((ret = _MEDdatagroupFermer(geoid)) < 0)
+       return -1;
+   if ((ret = _MEDdatagroupFermer(entid)) < 0)
+     return -1;
+   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+     return -1; 
+
+  return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDnumLire.cxx b/src/MEDWrapper/V2_1/MEDnumLire.cxx
new file mode 100644 (file)
index 0000000..9389640
--- /dev/null
@@ -0,0 +1,112 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <stdlib.h>
+#include <string.h>
+
+namespace med_2_1{
+
+med_err 
+MEDnumLire(med_idt fid,char *maa, med_int *num, med_int n, 
+          med_entite_maillage type_ent,med_geometrie_element type_geo)
+{
+  med_idt root,maaid,entid,geoid;
+  med_err ret;
+  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
+  char nom_geo[MED_TAILLE_NOM_ENTITE+1];
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller(); 
+
+  /*
+   * Si le maillage n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * On met a jour le nom du Data Group representant
+   * le type des entites
+   */
+   if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
+     return -1;
+
+   /*
+    * Si le Data Group des entites n'existe pas => erreur
+    */
+   if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
+     return -1;
+
+   /*
+    * Pour les mailles, les faces et le aretes, 
+    * si le Data Group du type geometrique => erreur
+    */
+   if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE))
+     {
+       if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
+        return -1;
+       if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
+        return -1;
+     }
+   else 
+     geoid = -1;
+
+   /*
+    * lecture du Data Set "NUM" 
+    */
+   if (geoid == -1)
+     root = entid;
+   else
+     root = geoid;
+#if defined(IRIX64)||defined(OSF1)
+   if ((ret = _MEDdatasetNumLire(root,MED_NOM_NUM,MED_INT64,
+                                MED_NO_INTERLACE,1,MED_ALL,
+                                MED_NOPF,0,MED_NOPG,
+                                (unsigned char*) num)) < 0)
+     return -1;
+#else
+   if ((ret = _MEDdatasetNumLire(root,MED_NOM_NUM,MED_INT32,
+                                MED_NO_INTERLACE,1,MED_ALL,
+                                MED_NOPF,0,MED_NOPG,
+                                (unsigned char*) num)) < 0)
+     return -1;
+#endif
+
+   /*
+    * On ferme tout
+    */
+   if (geoid != -1)
+     if ((ret = _MEDdatagroupFermer(geoid)) < 0)
+       return -1;
+   if ((ret = _MEDdatagroupFermer(entid)) < 0)
+     return -1;
+   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+     return -1;
+
+  return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDobjetIdentifer.cxx b/src/MEDWrapper/V2_1/MEDobjetIdentifer.cxx
new file mode 100644 (file)
index 0000000..14361be
--- /dev/null
@@ -0,0 +1,49 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDobjetIdentifier
+ * - Description : retrouve le nom de l'objet de rang "indice" 
+ *                 se trouvant dans le datagroup "chemin"
+ * - Parametres :
+ *     - fid     (IN)     : l'ID du fichier ou se trouve le datagroup
+ *     - chemin  (IN)     : chemin d'acces au datagroup
+ *     - indice  (IN)     : indice de l'objet du datagroup dont on veut
+ *                          le nom
+ *     - nom     (OUT)    : le nom 
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */ 
+
+namespace med_2_1{
+
+med_err 
+_MEDobjetIdentifier(med_idt fid,char *chemin,int indice,void *nom)
+{
+  int idx;
+
+  if ((idx = H5Giterate(fid,chemin,&indice,_MEDindiceInfo,
+                       nom)) < 0)
+    return -1;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDouvrir.cxx b/src/MEDWrapper/V2_1/MEDouvrir.cxx
new file mode 100644 (file)
index 0000000..0d259de
--- /dev/null
@@ -0,0 +1,76 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx" 
+
+#ifdef PPRO_NT
+#define F_OK 0
+#else
+#include <unistd.h>
+#endif
+
+namespace med_2_1{
+
+med_idt
+MEDouvrir(char *nom, med_mode_acces mode_acces)
+{
+  med_idt fid; 
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * On ouvre le fichier MED sous HDF
+   */
+  switch(mode_acces)
+    {
+    case MED_LECT :
+      if (access(nom,F_OK))
+       return -1;
+      else 
+       if ((fid = _MEDfichierOuvrir(nom,mode_acces)) < 0)
+         return -1;
+      break;
+
+    case MED_ECRI :
+      if (access(nom,F_OK))
+       {
+         if ((fid = _MEDfichierCreer(nom)) < 0)
+           return -1;
+       }
+      else
+       if ((fid = _MEDfichierOuvrir(nom,mode_acces)) < 0)
+         return -1;
+      break;
+
+    case MED_REMP :
+      if ((fid = _MEDfichierCreer(nom)) < 0)
+       return -1;
+      break;
+
+    default :
+      return -1;
+    }
+
+  return fid;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDparametresGeometrie.cxx b/src/MEDWrapper/V2_1/MEDparametresGeometrie.cxx
new file mode 100644 (file)
index 0000000..02a722f
--- /dev/null
@@ -0,0 +1,164 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/*
+ * - Nom de la fonction : _MEDparametresGeometrie
+ * - Description : fournit les parametres geometriques des differents
+ *                 entites et elements MED
+ * - Parametres :
+ *     - typ_ent (IN)  : type d'entite de l'element
+ *     - type_geo (IN) : le type geometrique de l'element
+ *     - dim (OUT)     : dimension de l'element
+ *     - nnoe (OUT)    : nombre de noeuds composant l'element (connectivite 
+ *                       nodale)
+ *     - ndes (OUT)    : nombre de composants dans l'elements (connectivite
+ *                       descendante)
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */
+
+namespace med_2_1{
+
+med_err 
+_MEDparametresGeometrie(med_entite_maillage type_ent,
+                       med_geometrie_element type_geo, int *dim, 
+                       int *nnoe,int *ndes)
+{
+  *nnoe = type_geo % 100;
+  *dim = type_geo / 100;
+
+  switch(type_ent)
+    {
+    case MED_MAILLE :
+      switch (type_geo)
+       {
+       case MED_POINT1 :
+         *ndes = 0;
+         break;
+         
+       case MED_SEG2 :
+         *ndes = 2;
+         break;
+         
+       case MED_SEG3 :
+         *ndes = 3;
+         break;
+         
+       case MED_TRIA3 :
+         *ndes = 3;
+         break;
+         
+       case MED_TRIA6 :
+         *ndes = 3;
+         break;
+         
+       case MED_QUAD4 :
+         *ndes = 4;
+         break;
+         
+       case MED_QUAD8 :
+         *ndes = 4;
+         break;
+         
+       case MED_TETRA4 :
+         *ndes = 4;
+         break;
+         
+       case MED_TETRA10 :
+         *ndes = 4;
+         break;
+         
+       case MED_HEXA8 :
+         *ndes = 6;
+         break;
+         
+       case MED_HEXA20 :
+         *ndes = 6;
+         break;
+         
+       case MED_PENTA6 :
+         *ndes = 5;
+         break;
+         
+       case MED_PENTA15 :
+         *ndes = 5;
+         break;
+         
+       case MED_PYRA5 :
+         *ndes = 5;
+         break;
+         
+       case MED_PYRA13 :
+         *ndes = 5;
+         break;
+         
+       default :
+         return -1;
+       }
+      break;
+      
+    case MED_FACE :
+      switch(type_geo)
+       {
+       case MED_TRIA3 :
+         *ndes = 3;
+         break;
+         
+       case MED_TRIA6 :
+         *ndes = 3;
+         break;
+         
+       case MED_QUAD4 :
+         *ndes = 4;
+         break;
+         
+       case MED_QUAD8 :
+         *ndes = 4;
+         break;
+         
+       default :
+         return -1;
+       }
+      break;
+      
+    case MED_ARETE :
+      switch(type_geo)
+       {
+       case MED_SEG2 :
+         *ndes = 2;
+         break;
+         
+       case MED_SEG3 :
+         *ndes = 3;
+         break;
+         
+       default :
+         return -1;
+       }
+      break;
+      
+    default :
+      return -1;
+    }
+  
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDpasdetempsInfo.cxx b/src/MEDWrapper/V2_1/MEDpasdetempsInfo.cxx
new file mode 100644 (file)
index 0000000..e95f601
--- /dev/null
@@ -0,0 +1,100 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+/* Le nom de cette fonction n'est pas très bien choisie */
+
+namespace med_2_1{
+
+med_err 
+MEDpasdetempsInfo(med_idt fid,char *champ
+                 ,med_entite_maillage type_ent, med_geometrie_element type_geo,
+                 int indice, char *maa, med_int * ngauss, med_int * numdt, char * dt_unit, med_float * dt, 
+                 med_int * numo)
+{
+
+  med_err ret=0;
+  med_int gauss_size;
+  med_idt gid;
+  char chemin[(MED_TAILLE_CHA+MED_TAILLE_NOM+1)+(2*MED_TAILLE_NOM_ENTITE+2)+2*MED_MAX_PARA+1];
+  int num;
+  char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2],nomdatagroup2[2*MED_MAX_PARA+1];
+  char tmp1         [MED_TAILLE_NOM_ENTITE+1];
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * On recupere le nom du datagroup <numdtt>.<numoo>
+   */
+  strcpy(chemin,MED_CHA);
+  strcat(chemin,champ);
+  strcat(chemin,"/");
+
+  if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0)
+    return -1;
+  if ((type_ent != MED_NOEUD))
+    {
+      if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0)
+       return -1;
+      strcat(nomdatagroup1,".");
+      strcat(nomdatagroup1,tmp1);
+    }
+  strcat(chemin,nomdatagroup1);
+  strcat(chemin,"/");
+
+  num = indice - 1;
+  if ((ret = _MEDobjetIdentifier(fid,chemin,num,nomdatagroup2)) < 0)
+    return -1;
+  strcat(chemin,nomdatagroup2);
+  if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;
+
+  /*
+   * La liste des attributs
+   */
+ if ((ret = _MEDattrStringLire(gid,MED_NOM_MAI,MED_TAILLE_NOM,maa)) < 0)
+    return -1;
+  
+ if ((ret = _MEDattrEntierLire(gid,MED_NOM_NDT,(med_int*) numdt)) < 0)
+   return -1;
+
+ if ((ret = _MEDattrFloatLire(gid,MED_NOM_PDT,(med_float*) dt)) < 0)
+   return -1;
+
+ if ((ret = _MEDattrStringLire(gid,MED_NOM_UNI,MED_TAILLE_PNOM,dt_unit)) < 0)
+   return -1;
+ if ((ret = _MEDattrEntierLire(gid,MED_NOM_NOR,(med_int*) numo)) < 0)
+   return -1;
+
+ if ( (ret = _MEDattrEntierLire(gid,MED_NOM_NGA,ngauss)) < 0 )
+   return -1;
+
+
+ if ((ret = _MEDdatagroupFermer(gid)) < 0)
+   return -1;
+  return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDprofilEcr.cxx b/src/MEDWrapper/V2_1/MEDprofilEcr.cxx
new file mode 100644 (file)
index 0000000..b2d1e97
--- /dev/null
@@ -0,0 +1,89 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_err
+MEDprofilEcr(med_idt fid,med_int *pflval,med_int n,char *nom)
+{
+  med_idt root, pid, did;
+  med_size dimd[1];
+  med_err ret;
+  char chemin[MED_TAILLE_PROFILS+1];
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /* 
+   * Si le groupe "PROFILS" n'existe pas, on le cree
+   */
+  strncpy(chemin,MED_PROFILS,MED_TAILLE_PROFILS-1);
+  chemin[MED_TAILLE_PROFILS-1] = '\0';
+  if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    if ((root = _MEDdatagroupCreer(fid,chemin)) < 0)
+      return -1;
+
+  /* 
+   * Si le groupe "nom" n'existe pas, on le cree
+   * Sinon => erreur
+   */
+  if ((pid = _MEDdatagroupOuvrir(root,nom)) >= 0)
+    return -1;
+  if ((pid = _MEDdatagroupCreer(root,nom)) < 0)
+    return -1;
+
+  /*
+   * On stocke "n" sous forme d'attribut
+   */
+  if ((ret = _MEDattrEntierEcrire(pid,MED_NOM_N,&n,MED_REMP)) < 0)
+    return -1;
+
+  /*
+   * On stocke le profil dans un dataset
+   */
+  dimd[0] = n;
+#if defined(IRIX64)||defined(OSF1)
+  if ((ret =  _MEDdatasetNumEcrire(pid,MED_NOM_PFL,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
+                               (unsigned char*) pflval,MED_REMP)) < 0)
+    return -1;
+#else
+  if ((ret =  _MEDdatasetNumEcrire(pid,MED_NOM_PFL,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
+                               (unsigned char*) pflval,MED_REMP)) < 0)
+    return -1;
+#endif
+
+  /*
+   * On ferme tout
+   */
+  if ((ret = _MEDdatagroupFermer(pid)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(root)) < 0)
+    return -1;
+
+  return 0; 
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDprofilInfo.cxx b/src/MEDWrapper/V2_1/MEDprofilInfo.cxx
new file mode 100644 (file)
index 0000000..77f2968
--- /dev/null
@@ -0,0 +1,62 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_err 
+MEDprofilInfo(med_idt fid, int indice, char *profil, med_int *n)
+{
+  int numero;
+  med_idt proid;
+  med_err ret;
+  char chemin[MED_TAILLE_PROFILS+MED_TAILLE_NOM+1];
+
+  /*
+   * On inhibe le gestionnaire d'erreur
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * On recupere le nom du groupe de rang "indice"
+   */ 
+  numero = indice-1;
+  if ((ret = _MEDobjetIdentifier(fid,MED_PROFILS,numero,profil)) < 0)
+    return -1;
+
+  /*
+   * On va chercher l'attribut taille du profil 
+   */
+  strcpy(chemin,MED_PROFILS);
+  strcat(chemin,profil);
+  if ((proid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;   
+  if ((ret = _MEDattrEntierLire(proid,MED_NOM_N,n)) < 0)
+    return -1;
+  if ((ret = _MEDdatagroupFermer(proid)) < 0)
+    return -1;
+
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDprofilLire.cxx b/src/MEDWrapper/V2_1/MEDprofilLire.cxx
new file mode 100644 (file)
index 0000000..7621f82
--- /dev/null
@@ -0,0 +1,73 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+namespace med_2_1{
+
+med_err 
+MEDprofilLire(med_idt fid,med_int *pflval, char *nom)
+{
+  med_err ret = 0;
+  med_idt pid,did;
+  char chemin[MED_TAILLE_PROFILS+MED_TAILLE_NOM+1]; 
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF 5
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /* 
+   * ouverture du groupe /PROFILS/"nom"
+   */  
+  strcpy(chemin,MED_PROFILS);
+  strcat(chemin,nom); 
+  if ((pid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+    return -1;
+
+  /*
+   * Lecture du profil
+   */
+#if defined(IRIX64)||defined(OSF1)
+  if ((ret =  _MEDdatasetNumLire(pid,MED_NOM_PFL,MED_INT64,
+                                MED_NO_INTERLACE,1,MED_ALL,
+                                MED_NOPF,0,MED_NOPG,
+                                (unsigned char *) pflval)) < 0)
+    return -1;
+#else
+  if ((ret =  _MEDdatasetNumLire(pid,MED_NOM_PFL,MED_INT32,
+                                MED_NO_INTERLACE,1,MED_ALL,
+                                MED_NOPF,0,MED_NOPG,
+                                (unsigned char *) pflval)) < 0)
+    return -1;
+#endif
+
+  /*
+   * On ferme tout
+   */
+  if ((ret = _MEDdatagroupFermer(pid)) < 0)
+    return -1; 
+
+  return ret;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDunvCr.cxx b/src/MEDWrapper/V2_1/MEDunvCr.cxx
new file mode 100644 (file)
index 0000000..a1bcd98
--- /dev/null
@@ -0,0 +1,102 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+#include <stdio.h>
+#include <time.h>
+
+#ifdef PPRO_NT
+// Windows Header Files:
+#include <windows.h>
+#include <Lmcons.h>
+#include <sys/timeb.h>
+#else
+#include <sys/time.h>
+#endif
+
+namespace med_2_1{
+
+med_err 
+MEDunvCr(med_idt fid, char *maa)
+{
+  med_idt maaid;
+  char chemin [MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  char nomu   [MED_TAILLE_LNOM+1];    
+  time_t  temps;
+#ifdef PPRO_NT
+  struct timeb   tp;
+  char   lpBuffer [UNLEN+1];
+  long   nSize   = UNLEN+1;
+#else
+  struct timeval tp;
+#endif 
+  med_err ret;
+
+  /*
+   * On inhibe le gestionnaire d'erreur
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * Si le maillage n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * Creation/Ecriture de l'attribut nom universel 
+   */
+  
+#ifdef PPRO_NT
+  if ( GetUserName(lpBuffer,&nSize) == 0 ) return -1;
+  if ( nSize > MED_TAILLE_NOM ) nSize = MED_TAILLE_NOM;
+  strncpy(nomu,lpBuffer,nSize);
+  strcat(nomu," ");
+  temps=time(&temps);
+  strcat(nomu,ctime(&temps));
+  ftime(&tp);
+  nSize = strlen(nomu)-1;
+  if ( sprintf(&nomu[nSize]," %hu",tp.millitm) < 0 ) return -1;
+#else
+  if (cuserid(nomu) == (void*) NULL) return -1;
+  strcat(nomu," ");
+  temps=time(&temps);
+  strcat(nomu,ctime(&temps));
+  if ( gettimeofday(&tp,NULL) < 0 ) return -1;
+  if ( sprintf(&nomu[strlen(nomu)-1]," %li",tp.tv_usec) < 0 ) return -1;
+#endif
+  if ((ret = _MEDattrStringEcrire(maaid,MED_NOM_UNV,MED_TAILLE_LNOM,nomu,MED_REMP)) < 0) 
+    return -1;
+
+  /* 
+   * Nettoyages divers
+   */
+  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+    return -1;
+  return 0;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDunvLire.cxx b/src/MEDWrapper/V2_1/MEDunvLire.cxx
new file mode 100644 (file)
index 0000000..f6ddc5f
--- /dev/null
@@ -0,0 +1,66 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+
+#include <stdio.h>
+#include <time.h>
+
+namespace med_2_1{
+
+med_err 
+MEDunvLire(med_idt fid, char *maa,char *nomu)
+{
+  med_idt maaid;
+  char chemin [MED_TAILLE_MAA+MED_TAILLE_NOM+1];
+  med_err ret;
+
+  /*
+   * On inhibe le gestionnaire d'erreur
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * Si le maillage n'existe pas => erreur
+   */
+  strcpy(chemin,MED_MAA);
+  strcat(chemin,maa);
+  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+      return -1;
+
+  /*
+   * Creation/Ecriture de l'attribut nom universel 
+   */
+  if ((ret = _MEDattrStringLire(maaid,MED_NOM_UNV,MED_TAILLE_LNOM,
+                              nomu )) < 0)
+    return -1;
+
+  /* 
+   * Nettoyages divers
+   */
+  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
+    return -1;
+  return 0;
+}
+  
+}
diff --git a/src/MEDWrapper/V2_1/MEDversionConforme.cxx b/src/MEDWrapper/V2_1/MEDversionConforme.cxx
new file mode 100644 (file)
index 0000000..764a9a8
--- /dev/null
@@ -0,0 +1,68 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+namespace med_2_1{
+
+med_err
+MEDversionConforme(const char *nom) {
+  med_int majeur, mineur;
+  med_idt fid, gid;
+  med_err ret;
+
+  /*
+   * On inhibe le gestionnaire d'erreur HDF
+   */
+  _MEDmodeErreurVerrouiller();
+
+  /*
+   * On ouvre le fichier MED en mode MED_LECT
+   */     
+  if ((fid = _MEDfichierOuvrir((char *)nom,MED_LECT)) < 0)
+    return -1;
+  
+  /*
+   * Lecture du numero de version 
+   */
+  if ((gid = _MEDdatagroupOuvrir(fid,MED_NOM_INFOS)) < 0) 
+    return -1;
+  
+  if ((ret = _MEDattrEntierLire(gid,MED_NOM_MAJEUR,&majeur)) < 0)
+    return -1;
+  
+  if ((ret = _MEDattrEntierLire(gid,MED_NOM_MINEUR,&mineur)) < 0)
+    return -1;                                                 
+  
+  /* 
+   * On ferme tout 
+   */
+  if ((ret = _MEDdatagroupFermer(gid)) < 0)
+    return -1;
+  
+  if ((ret = _MEDfichierFermer(fid)) < 0)
+    return -1;
+  
+  if ((majeur == MED_NUM_MAJEUR) && (mineur == MED_NUM_MINEUR))
+    return 0;
+  else
+    return -1;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDversionDonner.cxx b/src/MEDWrapper/V2_1/MEDversionDonner.cxx
new file mode 100644 (file)
index 0000000..33a5772
--- /dev/null
@@ -0,0 +1,31 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+namespace med_2_1{
+
+void
+MEDversionDonner(med_int *majeur, med_int *mineur, med_int *release) {
+  *majeur = MED_NUM_MAJEUR;
+  *mineur = MED_NUM_MINEUR;
+  *release = MED_NUM_RELEASE;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/MEDversionLire.cxx b/src/MEDWrapper/V2_1/MEDversionLire.cxx
new file mode 100644 (file)
index 0000000..b358d83
--- /dev/null
@@ -0,0 +1,55 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*  
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#include "med.hxx"
+#include "med_outils.hxx"
+
+namespace med_2_1{
+
+med_err 
+MEDversionLire(med_idt fid, med_int *majeur, med_int *mineur, med_int *release) 
+{
+  med_err ret = 0;
+  med_idt gid;  
+
+  /* On ouvre le group ou se trouvent les infos */
+  if ((gid = _MEDdatagroupOuvrir(fid,MED_NOM_INFOS)) < 0) {
+    *majeur = 2;
+    *mineur = -1;
+    *release = -1;
+    ret = 0;
+  }
+  else {
+    if ((ret = _MEDattrEntierLire(gid,MED_NOM_MAJEUR,majeur)) < 0)
+      return -1;
+
+    if ((ret = _MEDattrEntierLire(gid,MED_NOM_MINEUR,mineur)) < 0)
+      return -1;
+
+    if ((ret = _MEDattrEntierLire(gid,MED_NOM_RELEASE,release)) < 0)
+      return -1;
+
+    /* On ferme tout */
+    if ((ret = _MEDdatagroupFermer(gid)) < 0)
+      return -1;
+  }                                                    
+
+  return ret;
+}
+
+}
diff --git a/src/MEDWrapper/V2_1/Makefile.in b/src/MEDWrapper/V2_1/Makefile.in
new file mode 100644 (file)
index 0000000..3293939
--- /dev/null
@@ -0,0 +1,166 @@
+#  
+#
+#  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+#  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+# 
+#  This library is free software; you can redistribute it and/or 
+#  modify it under the terms of the GNU Lesser General Public 
+#  License as published by the Free Software Foundation; either 
+#  version 2.1 of the License. 
+# 
+#  This library is distributed in the hope that it will be useful, 
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+#  Lesser General Public License for more details. 
+# 
+#  You should have received a copy of the GNU Lesser General Public 
+#  License along with this library; if not, write to the Free Software 
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+# 
+#  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+#
+#
+#
+#  File   : 
+#  Author : 
+#  Module : 
+#  $Header$
+
+top_srcdir=@top_srcdir@
+top_builddir=../../..
+srcdir=@srcdir@
+VPATH=.:@srcdir@:@top_srcdir@/idl
+
+
+@COMMENCE@
+
+LIB_SRC_TOOLS_HDFI= \
+MEDattrFermer.cxx \
+MEDattrNumEcrire.cxx \
+MEDattrNumLire.cxx \
+MEDattrOuvrir.cxx \
+MEDattrStringEcrire.cxx \
+MEDattrStringLire.cxx \
+MEDdatagroupCreer.cxx \
+MEDdatagroupFermer.cxx \
+MEDdatagroupOuvrir.cxx \
+MEDdatasetFermer.cxx \
+MEDdatasetNumEcrire.cxx \
+MEDdatasetNumLire.cxx \
+MEDdatasetOuvrir.cxx \
+MEDdatasetStringEcrire.cxx \
+MEDdatasetStringLire.cxx \
+MEDfichierCreer.cxx \
+MEDfichierFermer.cxx \
+MEDfichierOuvrir.cxx \
+MEDindiceInfo.cxx \
+MEDindiceNum.cxx \
+MEDmodeErreurVerrouiller.cxx \
+MEDnObjets.cxx \
+MEDobjetIdentifer.cxx 
+
+LIB_SRC_TOOLS_MISC= \
+MED1cstring.cxx             MEDnomDataset.cxx \
+MED2cstring.cxx             MEDnomEntite.cxx \
+MEDGeometrieElement.cxx     MEDnomGeometrie.cxx \
+MEDcstringFree.cxx          MEDparametresGeometrie.cxx \
+MEDfstring.cxx
+
+LIB_SRC_API_CI= \
+MEDchampCr.cxx \
+MEDchampEcr.cxx \
+MEDchampInfo.cxx \
+MEDchampLire.cxx \
+MEDconnEcr.cxx \
+MEDconnLire.cxx \
+MEDcoordEcr.cxx \
+MEDcoordLire.cxx \
+MEDdimLire.cxx \
+MEDelementsEcr.cxx \
+MEDelementsLire.cxx \
+MEDequivCr.cxx \
+MEDequivEcr.cxx \
+MEDequivInfo.cxx \
+MEDequivLire.cxx \
+MEDfam2groA.cxx \
+MEDfam2groB.cxx \
+MEDfamCr.cxx \
+MEDfamEcr.cxx \
+MEDfamInfo.cxx \
+MEDfamLire.cxx \
+MEDfamMaaCr.cxx \
+MEDfamMaaInfo.cxx \
+MEDfamMaaLire.cxx \
+MEDfermer.cxx \
+MEDfichDesEcr.cxx \
+MEDfichEntete.cxx \
+MEDgro2famA.cxx \
+MEDgro2famB.cxx \
+MEDlFichDes.cxx \
+MEDmaaCr.cxx \
+MEDmaaInfo.cxx \
+MEDnChamp.cxx \
+MEDnCorres.cxx \
+MEDnEntMaa.cxx \
+MEDnEntites.cxx \
+MEDnEquiv.cxx \
+MEDnFam.cxx \
+MEDnMaa.cxx \
+MEDnPasdetemps.cxx \
+MEDnProfil.cxx \
+MEDnVal.cxx \
+MEDnValProfil.cxx \
+MEDnbnoisEcr.cxx \
+MEDnbnoisLire.cxx \
+MEDnbnomaEcr.cxx \
+MEDnbnomaLire.cxx \
+MEDnbnosoEcr.cxx \
+MEDnbnosoLire.cxx \
+MEDnoeudsEcr.cxx \
+MEDnoeudsLire.cxx \
+MEDnomEcr.cxx \
+MEDnomLire.cxx \
+MEDnumEcr.cxx \
+MEDnumLire.cxx \
+MEDouvrir.cxx \
+MEDpasdetempsInfo.cxx \
+MEDprofilEcr.cxx \
+MEDprofilLire.cxx \
+MEDprofilInfo.cxx \
+MEDunvCr.cxx \
+MEDunvLire.cxx \
+MEDformatConforme.cxx \
+MEDversionConforme.cxx \
+MEDversionDonner.cxx \
+MEDversionLire.cxx \
+MEDbodyFittedEcr.cxx \
+MEDbodyFittedLire.cxx \
+MEDfamGridEcr.cxx \
+MEDfamGridLire.cxx \
+MEDgridCr.cxx \
+MEDgridEcr.cxx \
+MEDgridInfo.cxx \
+MEDgridLire.cxx \
+MEDnGrid.cxx
+
+# Libraries targets
+
+LIB = libMEDWrapper_V2_1.la
+LIB_SRC = \
+       $(LIB_SRC_TOOLS_HDFI) \
+       $(LIB_SRC_TOOLS_MISC) \
+       $(LIB_SRC_API_CI) \
+       MED_V2_1_Wrapper.cxx
+
+EXPORT_HEADERS = \
+       MED_V2_1_Wrapper.hxx
+
+# Executables targets
+BIN = mdump_V2_1 test1_V2_1
+BIN_SRC = 
+
+CPPFLAGS+= $(BOOST_CPPFLAGS) $(HDF5_INCLUDES) -DPCLINUX
+
+LDFLAGS+= $(HDF5_LIBS) -lMEDWrapperBase
+
+@CONCLUDE@
diff --git a/src/MEDWrapper/V2_1/mdump_V2_1.cxx b/src/MEDWrapper/V2_1/mdump_V2_1.cxx
new file mode 100644 (file)
index 0000000..6c959fd
--- /dev/null
@@ -0,0 +1,1626 @@
+/******************************************************************************
+ * - Nom du fichier : mdump.c
+ *
+ * - Description : utilitaire de dump pour fichier MED V2.1
+ *
+ *****************************************************************************/
+#define NBR_MAILLE_EQU 7
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "med.hxx"
+using namespace med_2_1;
+
+/*******************************************************************
+ *  DUMP D'UN FICHIER MED STRUCTURE EN GRILLE :                    *
+ *  NOEUDS, ELEMENTS, FAMILLES, EQUIVALENCES, CHAMPS DE RESULTATS  *
+ *******************************************************************/
+
+int grid_cartesian_or_polar(med_idt fid, int numero, med_mode_switch mode_coo) {
+    med_int mdim, nnoe, nfam, i, j;
+    char nommaa[MED_TAILLE_NOM+1];
+    char nom_universel[MED_TAILLE_LNOM+1];
+    med_float *coo;
+    med_int *fam;
+    char nomcoo[3*MED_TAILLE_PNOM+1];
+    char unicoo[3*MED_TAILLE_PNOM+1];
+    med_repere rep;
+    char str[MED_TAILLE_PNOM+1];
+
+    fprintf(stdout,"\n(****************************)\n");
+    fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n");
+    fprintf(stdout,"(****************************)\n");
+
+    /* lecture du nom et de la dimension de la grille */
+    if (MEDmaaInfo(fid, numero, nommaa, &mdim) < 0) {
+        fprintf(stderr, ">> ERREUR : lecture du nom de la grille\n");
+        return(EXIT_FAILURE);
+    };
+    fprintf(stdout, "- Nom de la grille : <<%s>>\n", nommaa);
+    fprintf(stdout, "- Dimension de la grille : %d\n", mdim);
+
+    /* lecture du nom universel (presence optionnelle) */
+    if (MEDunvLire(fid, nommaa, nom_universel) > 0) {
+        fprintf(stdout, "- Nom universel de la grille : %s \n", nom_universel);
+    } else {
+        fprintf(stdout, "- Pas de nom universel \n");
+    };
+
+    /* nombre de familles */
+    nfam = MEDnFam(fid, nommaa, 0, (med_dim_famille)0);
+    if (nfam < 0) {
+        fprintf(stderr, ">> ERREUR : lecture du nombre de familles\n");
+        return(EXIT_FAILURE);
+    };
+    fprintf(stdout, "- Nombre de familles : %d \n", nfam);
+
+    fprintf(stdout, "\n- Lecture des indices : \n");
+    for (i=0; i<mdim; i++) {
+        fprintf(stdout, "-- Lecture de l'indice : %d\n", i);
+        nnoe = MEDnGrid(fid, nommaa, (med_grid)i);
+        fprintf(stdout, "-- nombre d'indice : %d\n", nnoe);
+        coo  = (med_float*)malloc(sizeof(med_float)*nnoe);
+
+        if (MEDgridLire(fid, nommaa, mdim, coo, i, mode_coo, &rep, nomcoo, unicoo) < 0) {
+            fprintf(stderr, ">> ERREUR : lecture des indices \n");
+            return(EXIT_FAILURE);
+        };
+
+        fprintf(stdout, "- Type de repere des coordonnees : %d \n", rep);
+
+        fprintf(stdout, "- Nom des coordonnees : \n");
+        for (j=0; j<mdim; j++) {
+            strncpy(str, nomcoo+j*MED_TAILLE_PNOM, MED_TAILLE_PNOM);
+            str[MED_TAILLE_PNOM] = '\0';
+            fprintf(stdout, " %s ", str);
+        };
+
+        fprintf(stdout, "\n- Unites des coordonnees : \n");
+        for (j=0; j<mdim; j++) {
+            strncpy(str, unicoo+j*MED_TAILLE_PNOM, MED_TAILLE_PNOM);
+            str[MED_TAILLE_PNOM] = '\0';
+            fprintf(stdout, " %s ", str);
+        };
+
+        fprintf(stdout, "\n-- Coordonnees des indices : \n");
+        for (j=0; j<nnoe; j++) {
+            fprintf(stdout, "   %f ", *(coo+j));
+        };
+
+        fprintf(stdout, "\n\n");
+        free(coo);
+    };
+
+    nfam = MEDnGrid(fid, nommaa, (med_grid)-2);
+    fprintf(stdout, "- Nombre de noeud pour les familles : %d\n", nfam);
+    if (nfam > 0) {
+        fam = (med_int*)malloc(sizeof(med_int)*nfam);
+        if (MEDfamGridLire(fid, nommaa, fam, nfam,MED_NOEUD) < 0) {
+            fprintf(stderr, ">> ERREUR : lecture des familles\n");
+            return(EXIT_FAILURE);
+        };
+
+        fprintf(stdout, "\n- Numeros des familles des noeuds :\n");
+        for (i=0; i<nfam; i++) {
+            fprintf(stdout, " %d ", *(fam+i));
+        };
+        fprintf(stdout, "\n");
+        free(fam);
+    };
+
+    return(0);
+}
+
+int grid_body_fitted(med_idt fid, int numero, med_mode_switch mode_coo) {
+    med_int mdim, nnoe, nfam, i;
+    char nommaa[MED_TAILLE_NOM+1];
+    char nom_universel[MED_TAILLE_LNOM+1];
+    char str[MED_TAILLE_PNOM+1];
+    char nomcoo[3*MED_TAILLE_PNOM+1];
+    char unicoo[3*MED_TAILLE_PNOM+1];
+    med_float *coo;
+    med_int *fam;
+    med_repere rep;
+
+    fprintf(stdout,"\n(****************************)\n");
+    fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n");
+    fprintf(stdout,"(****************************)\n");
+
+    /* lecture du nom et de la dimension du maillage */
+    if (MEDmaaInfo(fid, numero, nommaa, &mdim) < 0) {
+        fprintf(stderr, ">> ERREUR : lecture du nom du maillage body fitted\n");
+        return(EXIT_FAILURE);
+    };
+    fprintf(stdout, "- Nom du maillage body fitted : <<%s>>\n", nommaa);
+    fprintf(stdout, "- Dimension du maillage body fitted : %d\n", mdim);
+
+    /* lecture du nom universel (presence optionnelle) */
+    if (MEDunvLire(fid, nommaa, nom_universel) > 0) {
+        fprintf(stdout, "- Nom universel du maillage body fitted : %s \n", nom_universel);
+    } else {
+        fprintf(stdout, "- Pas de nom universel \n");
+    };
+
+    /* Combien de noeuds ? */
+    /*    nnoe = MEDnGrid(fid, nommaa, -1);*/
+    nnoe = MEDnGrid(fid, nommaa, MED_GRID_NOEUD);
+    if (nnoe < 0) {
+        fprintf(stderr, ">> ERREUR : lecture du nombre de noeuds (via MEDnGrid) \n");
+        return(EXIT_FAILURE);
+    };
+    fprintf(stdout, "- Nombre de noeuds : %d \n", nnoe);
+
+    /* Combien de noeuds dans la dimension 1 ? */
+    i = MEDnGrid(fid, nommaa, (med_grid)0);
+    if (i < 0) {
+        fprintf(stderr, ">> ERREUR : lecture du nombre de noeuds (via MEDnGrid) dans la dimension 1 \n");
+        return(EXIT_FAILURE);
+    };
+    fprintf(stdout, "- Nombre de noeuds dans la dimension 1 : %d \n", i);
+
+    /* Combien de noeuds dans la dimension 2 ? */
+    i = MEDnGrid(fid, nommaa, (med_grid)1);
+    if (i < 0) {
+        fprintf(stderr, ">> ERREUR : lecture du nombre de noeuds (via MEDnGrid) dans la dimension 2 \n");
+        return(EXIT_FAILURE);
+    };
+    fprintf(stdout, "- Nombre de noeuds dans la dimension 2 : %d \n", i);
+
+    /* nombre de familles */
+    nfam = MEDnFam(fid, nommaa, 0,(med_dim_famille)0);
+    if (nfam < 0) {
+        fprintf(stderr, ">> ERREUR : lecture du nombre de familles \n");
+        return(EXIT_FAILURE);
+    };
+    fprintf(stdout, "- Nombre de familles : %d \n", nfam);
+
+    coo = (med_float*)malloc(sizeof(med_float)*nnoe*mdim);
+    fam = (med_int*)malloc(sizeof(med_int)*nnoe);
+
+    if (MEDbodyFittedLire(fid, nommaa, mdim, coo, mode_coo, &rep, nomcoo, unicoo, fam, nnoe) < 0) {
+        fprintf(stderr, ">> ERREUR : lecture des noeuds \n");
+        return(EXIT_FAILURE);
+    };
+
+    fprintf(stdout, "- Type de repere des coordonnees : %d \n", rep);
+
+    fprintf(stdout, "- Nom des coordonnees : \n");
+    for (i=0; i<mdim; i++) {
+        strncpy(str, nomcoo+i*MED_TAILLE_PNOM, MED_TAILLE_PNOM);
+        str[MED_TAILLE_PNOM] = '\0';
+        fprintf(stdout, " %s ", str);
+    };
+
+    fprintf(stdout, "\n- Unites des coordonnees : \n");
+    for (i=0; i<mdim; i++) {
+        strncpy(str, unicoo+i*MED_TAILLE_PNOM, MED_TAILLE_PNOM);
+        str[MED_TAILLE_PNOM] = '\0';
+        fprintf(stdout, " %s ", str);
+    };
+
+    fprintf(stdout, "\n- Coordonnees des noeuds : \n");
+    for (i=0; i<nnoe*mdim; i++) {
+        fprintf(stdout, " %f ", *(coo+i));
+    };
+
+    fprintf(stdout, "\n- Numeros des familles des noeuds : \n");
+    for (i=0; i<nnoe; i++) {
+        fprintf(stdout, " %d ", *(fam+i));
+    };
+    fprintf(stdout, "\n");
+
+    if (nnoe) {
+        free(coo);
+        free(fam);
+    };
+    return(0);
+}
+
+int grid(med_idt fid, int numero, med_grid_type theType, med_mode_switch mode_coo) {
+    switch (theType) {
+        case MED_CARTESIAN : {
+            fprintf(stdout, "- Type de la grille : MED_CARTESIAN\n");
+            return(grid_cartesian_or_polar(fid, numero, mode_coo));
+        };
+        case MED_POLAR : {
+            fprintf(stdout, "- Type de la grille : MED_POLAR\n");
+            return(grid_cartesian_or_polar(fid, numero, mode_coo));
+        };
+        case MED_BODY_FITTED : {
+            fprintf(stdout, "- Type de la grille : MED_BODY_FITTED\n");
+            return(grid_body_fitted(fid, numero, mode_coo));
+        };
+        default : {
+            fprintf(stderr, ">> ERREUR : type de maillage inconnu\n");
+            return(EXIT_FAILURE);
+        };
+    };
+}
+
+/******************************************************************************
+ * DUMP D'UN FICHIER MED  : NOEUDS,
+ * ELEMENTS, FAMILLES, EQUIVALENCES, CHAMPS DE RESULTATS
+ *****************************************************************************/
+
+int main (int argc, char **argv)
+{
+  med_err ret = 0;
+  med_idt fid;
+  int i,j,k,l,kp;
+  int numero;
+  char message[200];
+  /* nombre d'objets MED */
+  char nom_universel[MED_TAILLE_LNOM+1];
+  med_int long_fichier_en_tete; 
+  char *fichier_en_tete;
+  char version_hdf[10];
+  char version_med[10];
+  med_int nmaa,mdim,nnoe;
+  med_int nmai[MED_NBR_GEOMETRIE_MAILLE],nfac[MED_NBR_GEOMETRIE_FACE];
+  med_int nare[MED_NBR_GEOMETRIE_ARETE];
+  /* nom du maillage */
+  char nommaa[MED_TAILLE_NOM+1];
+  /* noeuds */
+  med_float *coo;
+  char nomcoo[3*MED_TAILLE_PNOM+1];
+  char unicoo[3*MED_TAILLE_PNOM+1];
+  char *nomnoe;
+  med_int *numnoe;
+  med_int *nufano; 
+  med_repere rep;
+  med_booleen inonoe,inunoe;
+  med_mode_switch mode_coo;
+  char str[MED_TAILLE_PNOM+1];
+  /* elements */
+  med_int nsup;
+  med_int edim;
+  med_int taille;
+  med_int *connectivite;
+  char *nomele;
+  med_int *numele;
+  med_int *nufael;
+  med_booleen inoele, inuele;
+  med_connectivite typ_con;
+  med_geometrie_element typgeo;
+  med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE] = {MED_POINT1,MED_SEG2, 
+                                                  MED_SEG3,MED_TRIA3,
+                                                  MED_TRIA6,MED_QUAD4,
+                                                  MED_QUAD8,MED_TETRA4,
+                                                  MED_TETRA10,MED_HEXA8,
+                                                  MED_HEXA20,MED_PENTA6,
+                                                  MED_PENTA15,MED_PYRA5,
+                                                  MED_PYRA13};
+  med_int desmai[MED_NBR_GEOMETRIE_MAILLE] = {0,2,3,3,3,4,4,4,4,6,6,5,5,5,5};
+  med_int nmailles[MED_NBR_GEOMETRIE_MAILLE];
+  char nommai[MED_NBR_GEOMETRIE_MAILLE] [MED_TAILLE_NOM+1] = {"MED_POINT1",
+                                                         "MED_SEG2", 
+                                                         "MED_SEG3",
+                                                         "MED_TRIA3",
+                                                         "MED_TRIA6",
+                                                         "MED_QUAD4",
+                                                         "MED_QUAD8",
+                                                         "MED_TETRA4",
+                                                         "MED_TETRA10",
+                                                         "MED_HEXA8",
+                                                         "MED_HEXA20",
+                                                         "MED_PENTA6",
+                                                         "MED_PENTA15",
+                                                         "MED_PYRA5",
+                                                         "MED_PYRA13"};
+  med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6,
+                                                MED_QUAD4,MED_QUAD8};
+  med_int desfac[MED_NBR_GEOMETRIE_FACE] = {3,3,4,4};
+  med_int nfaces[MED_NBR_GEOMETRIE_FACE];
+  char nomfac[MED_NBR_GEOMETRIE_FACE][MED_TAILLE_NOM+1] = {"MED_TRIA3","MED_TRIA6",
+                                                      "MED_QUAD4","MED_QUAD8"};
+  med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3};
+  med_int desare[MED_NBR_GEOMETRIE_ARETE] = {2,3};
+  med_int naretes[MED_NBR_GEOMETRIE_ARETE];
+  char nomare[MED_NBR_GEOMETRIE_ARETE] [MED_TAILLE_NOM+1] = {"MED_SEG2","MED_SEG3"};
+  /* familles */
+  med_int nfam;
+  med_int natt,ngro;
+  char *attdes,*gro;
+  med_int *attval,*attide;
+  char nomfam[MED_TAILLE_NOM+1];
+  med_int numfam;
+  char str1[MED_TAILLE_DESC+1];
+  char str2[MED_TAILLE_LNOM+1];
+  /* equivalences */
+  med_int nequ,ncor;
+  med_int *cor;
+  char equ[MED_TAILLE_NOM+1];
+  char des[MED_TAILLE_DESC+1];
+  /* champs de resultats */
+  char *comp;
+  char *unit;
+  char nomcha[MED_TAILLE_NOM+1];
+  char maillage_champ[MED_TAILLE_NOM+1];
+  med_int ncomp;
+  med_float *valr;
+  med_int *vale;
+  med_type_champ typcha;
+  med_int ncha;
+  med_int nval;
+  int reponse;
+  int lecture_en_tete_seulement = 0;
+  med_int npdt;
+  med_int ngauss,numdt,numo;
+  med_float dt;
+  char dtunit[MED_TAILLE_PNOM+1];
+  char pflnom[MED_TAILLE_NOM+1];
+  med_int pflsize;
+  med_int *pflval;
+  med_int isGrid;
+  med_grid_type theType;
+
+  /****************************************************************************
+  *                  TEST DU NOMBRE D'ARGUMENTS                               *
+  *                  argument 1 = nom du fichier MED                          *
+  ****************************************************************************/
+  if (argc != 2 && argc != 5)
+    {
+      fprintf(stderr,">> ERREUR : nombre de parametres incorrects \n");
+      exit(EXIT_FAILURE);
+    }
+
+  /****************************************************************************
+  *                      OUVERTURE DU FICHIER EN LECTURE                      *
+  ****************************************************************************/
+  fid = MEDouvrir(argv[1],MED_LECT);
+  if (fid < 0)
+    {
+      fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",argv[1]);
+      exit(EXIT_FAILURE);
+    }
+
+
+  /****************************************************************************
+  *                     QUESTIONS PRELIMINAIRES                               *
+  *    1. Mode d'affichage des coordonnees (entrelace ou non) ?               *
+  *    2. Connectivite des elements (nodale ou descendante)                   *
+  ****************************************************************************/
+  fprintf(stdout,"\n >>>>>> DUMP DU FICHIER %s >>>>>>\n",argv[1]);
+
+  /* en-tete du fichier (presence optionnelle) */
+  long_fichier_en_tete = MEDlFichDes(fid);
+  if (long_fichier_en_tete > 0)
+    {
+      fichier_en_tete = (char *) malloc(sizeof(char)*(long_fichier_en_tete+1));
+      ret = MEDfichEntete(fid,MED_FICH_DES,fichier_en_tete);
+      if (ret < 0)
+       {
+         fprintf(stderr,">> ERREUR : lecture de l'en-tete du fichier \n");
+         exit(EXIT_FAILURE);
+       }      
+      fprintf(stdout,"- En-tete du fichier : %s \n",fichier_en_tete);
+      free(fichier_en_tete);
+    }
+  /* versions hdf et med */
+  ret = MEDfichEntete(fid,MED_HDF_VERSION,version_hdf);
+  if (ret < 0)
+    {
+      fprintf(stderr,">> ERREUR : lecture du numero de version de HDF \n");
+      exit(EXIT_FAILURE);
+    }      
+  ret = MEDfichEntete(fid,MED_VERSION,version_med);
+  if (ret < 0)
+    {
+      fprintf(stderr,">> ERREUR : lecture du numero de version de MED \n");
+      exit(EXIT_FAILURE);
+    }     
+  fprintf(stdout,"- Version de HDF utilisee : %s \n",version_hdf);
+  fprintf(stdout,"- Version de MED utilisee : %s \n",version_med);
+
+  if (argc == 2)
+    {
+      fprintf(stdout,"(*****************)\n");
+      fprintf(stdout,"(* PARAMETRAGE : *)\n");
+      fprintf(stdout,"(*****************)\n");
+      fprintf(stdout,"- Mode d'affichage des coordonnées des noeuds ? \n");
+      fprintf(stdout,"  1. Mode entrelacé : taper 1 \n"); 
+      fprintf(stdout,"  2. Mode non entrelacé : taper 2 \n");
+      reponse = 0;
+      do
+       {
+         fprintf(stdout,"  Reponse : ");
+         scanf("%d",&reponse);
+       }
+      while (reponse != 1 && reponse != 2);
+      if (reponse == 1)
+       mode_coo = MED_FULL_INTERLACE;
+      else
+       mode_coo = MED_NO_INTERLACE;
+      
+      fprintf(stdout,"- Connectivité des éléments ? \n");
+      fprintf(stdout,"  1. Nodale : taper 1 \n"); 
+      fprintf(stdout,"  2. Descendante : taper 2 \n");
+      reponse = 0;
+      do
+       {
+         fprintf(stdout,"  Reponse : ");
+         scanf("%d",&reponse);
+       }
+      while (reponse != 1 && reponse != 2);
+      if (reponse == 1)
+       typ_con = MED_NOD;
+      else
+       typ_con = MED_DESC;
+    }
+  else
+      {
+       if (! strcmp(argv[3],"NODALE"))
+         typ_con = MED_NOD;
+       if (! strcmp(argv[3],"DESCENDANTE"))    
+         typ_con = MED_DESC;
+       
+       if (!strcmp(argv[4],"NO_INTERLACE"))
+         mode_coo = MED_NO_INTERLACE;
+       if (!strcmp(argv[4],"FULL_INTERLACE"))
+         mode_coo = MED_FULL_INTERLACE;
+        if (! strcmp(argv[4],"LECTURE_EN_TETE_SEULEMENT"))
+         lecture_en_tete_seulement = 1;
+
+      }
+
+  /****************************************************************************
+  *                      QUEL MAILLAGE LIRE                                   *
+  ****************************************************************************/
+  nmaa = MEDnMaa(fid);
+  if (nmaa < 0)
+    {
+      fprintf(stderr,">> ERREUR : lecture du nombre de maillages \n");
+      exit(EXIT_FAILURE);
+    }
+  
+  /* Quel maillage lire ? */
+  if (argc == 2)
+    {
+      fprintf(stdout,"- Il y a %d maillages dans ce fichier \n",nmaa);
+      fprintf(stdout,"  Lequel voulez-vous lire (1|2|3|...|n) ?\n");
+      do
+       {
+         fprintf(stdout,"  Reponse : ");
+         scanf("%d",&numero);
+       }
+      while (numero > nmaa || numero <= 0);
+    }
+  else
+    {
+      numero = atoi(argv[2]);
+      if (numero > nmaa || numero  <= 0)
+       {
+         fprintf(stderr,">> ERREUR : il y a %d maillages dans ce fichier  \n",
+                 nmaa);
+         exit(EXIT_FAILURE);
+       }
+    }
+
+/*****************************************************************************
+ *       QUELLE SORTE DE MAILLAGE : GRILLE OU PAS                            *
+ *****************************************************************************/
+
+    fprintf(stdout,"\n(**************************************************)\n");
+    fprintf(stdout,"(* MAILLAGE STRUCTURE (GRILLE) OU NON STRUCTURE : *)\n");
+    fprintf(stdout,"(**************************************************)\n");
+
+    /* lecture de la sorte de maillage : structure ou pas */
+    ret = MEDgridInfo(fid, numero, &isGrid, &theType);
+    if (ret < 0) {
+        fprintf(stderr, ">> ERREUR : lecture de la sorte de maillage (structure ou pas)\n");
+        exit(EXIT_FAILURE);
+    };
+    fprintf(stdout, "- Sorte de maillage : %s\n", isGrid? "structure (grille)": "non structure");
+    if (isGrid) {
+        ret = grid(fid, numero, theType, mode_coo);
+        if (ret == 0) {
+            ret = MEDfermer(fid);
+            if (ret == 0) {
+                fprintf(stdout, "\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n", argv[1]);
+            } else {
+                fprintf(stderr, ">> ERREUR : erreur a la fermeture du fichier %s\n", argv[1]);
+            };
+        };
+        if (ret == 0) {
+            return(0);
+        } else {
+            exit(EXIT_FAILURE);
+        };
+    };
+
+  /****************************************************************************
+  *                       NOMBRES D'OBJETS MED                                *
+  ****************************************************************************/
+  fprintf(stdout,"\n(****************************)\n");
+  fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n");
+  fprintf(stdout,"(****************************)\n");
+
+  /* lecture du nom et de la dimension du maillage */
+  ret = MEDmaaInfo(fid,numero,nommaa,&mdim);
+  if (ret < 0)
+    {
+      fprintf(stderr,">> ERREUR : lecture du nom du maillage \n");
+      exit(EXIT_FAILURE);
+    }
+  fprintf(stdout,"- Nom du maillage : <<%s>>\n",nommaa);
+  fprintf(stdout,"- Dimension du maillage : %d\n",mdim);
+
+  /* lecture du nom universel (presence optionnelle) */
+ ret = MEDunvLire(fid,nommaa,nom_universel);
+ if (ret > 0)
+   fprintf(stdout,"- Nom universel du maillage : %s \n",nom_universel);
+ else
+   fprintf(stdout,"- Pas de nom universel \n");
+  
+      
+  /* Combien de noeuds ? */
+  nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,(med_geometrie_element)0,(med_connectivite)0);
+  if (nnoe < 0)
+    {
+      fprintf(stderr,">> ERREUR : lecture du nombre de noeuds (via MEDnEntMaa) \n");
+      exit(EXIT_FAILURE);
+    }
+  fprintf(stdout,"- Nombre de noeuds : %d \n",nnoe);
+
+  /* Combien de mailles, faces ou aretes ? */
+  for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
+    {
+      nmailles[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,typmai[i],
+                              typ_con);
+      if (nmailles[i] < 0)
+       {
+         fprintf(stderr,">> ERREUR : lecture du nombre de mailles \n");
+         exit(EXIT_FAILURE);
+       }
+      fprintf (stdout,"- Nombre de mailles de type %s : %d \n",nommai[i],nmailles[i]);
+    }
+
+  for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++)
+    {
+      nfaces[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_FACE,typfac[i],
+                            typ_con);
+      if (nfaces[i] < 0)
+       {
+         fprintf(stderr,">> ERREUR : lecture du nombre de faces \n");
+         exit(EXIT_FAILURE);
+       }
+      fprintf (stdout,"- Nombre de faces de type %s : %d \n",nomfac[i],nfaces[i]);
+    }    
+
+  for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++)
+    {
+      naretes[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_ARETE,typare[i],
+                             typ_con); 
+      if (naretes[i] < 0)
+       {
+         fprintf(stderr,">> ERREUR : lecture du nombre d'aretes \n");
+         exit(EXIT_FAILURE);
+       }
+      fprintf (stdout,"- Nombre d'aretes de type %s : %d \n",nomare[i],naretes[i]);
+    }
+
+  /* nombre de familles */
+  nfam = MEDnFam(fid,nommaa,0,(med_dim_famille)0);
+  if (nfam < 0)
+    {
+      fprintf(stderr,">> ERREUR : lecture du nombre de familles \n");
+      exit(EXIT_FAILURE);
+    }  
+  fprintf(stdout,"- Nombre de familles : %d \n",nfam);
+
+  /* combien d'equivalences dans le fichier */
+  nequ = MEDnEquiv(fid,nommaa);
+  if (nequ < 0)
+    {
+      fprintf(stderr,">> ERREUR : lecture du nombre d'equivalences \n");
+      exit(EXIT_FAILURE);
+    }  
+    fprintf(stdout,"- Nombre d'equivalences : %d \n",nequ);
+
+  /* combien de champs dans le fichier */
+  ncha = MEDnChamp(fid,0);
+  if (ncha < 0)
+    {
+      fprintf(stderr,">> ERREUR : lecture du nombre de champs \n");
+      exit(EXIT_FAILURE);
+    }  
+  fprintf(stdout,"- Nombre de champs : %d \n",ncha);
+
+  /* Doit-on s'arreter ? */
+  if (lecture_en_tete_seulement)
+    {
+      ret = MEDfermer(fid);
+      if (ret == 0)
+       {
+         fprintf(stdout,"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1]);
+         return 0;
+       }
+      else
+       {
+         fprintf(stderr,">> ERREUR : fermeture du fichier %s  \n",argv[1]);
+         exit(EXIT_FAILURE);
+       }
+    }
+
+  /****************************************************************************
+  *                       LECTURE DES NOEUDS                                  *
+  ****************************************************************************/
+  fprintf(stdout,"\n(************************)\n");
+  fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n");
+  fprintf(stdout,"(************************)\n");
+
+  /* Allocations memoires */
+  /* table des coordonnees 
+     profil : (dimension * nombre de noeuds ) */
+  coo = (med_float*) malloc(sizeof(med_float)*nnoe*mdim);
+  /* table  des numeros, des numeros de familles des noeuds
+     profil : (nombre de noeuds) */
+  numnoe = (med_int*) malloc(sizeof(med_int)*nnoe);
+  nufano = (med_int*) malloc(sizeof(med_int)*nnoe);
+  /* table des noms des noeuds 
+     profil : (nnoe*MED_TAILLE_PNOM+1) */
+  nomnoe = (char*) malloc(MED_TAILLE_PNOM*nnoe+1);
+
+  /* lecture des noeuds : 
+     - coordonnees
+     - noms (optionnel dans un fichier MED) 
+     - numeros (optionnel dans un fichier MED) 
+     - numeros des familles */
+  ret = MEDnoeudsLire(fid,nommaa,mdim,coo,mode_coo,&rep,
+                     nomcoo,unicoo,nomnoe,&inonoe,numnoe,&inunoe,
+                     nufano,nnoe);
+  if (ret < 0)
+    strcpy(message,">> ERREUR : lecture des noeuds \n");
+
+  /* affichage des resultats */
+  if (ret == 0)
+    { 
+      fprintf(stdout,"- Type de repere des coordonnees : %d \n",rep);
+      fprintf(stdout,"- Nom des coordonnees : \n");
+      for (i=0;i<mdim;i++)
+       {
+         strncpy(str,nomcoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
+          str[MED_TAILLE_PNOM] = '\0';
+          fprintf(stdout," %s ",str);
+       }
+      fprintf(stdout,"\n- Unites des coordonnees : \n");
+      for (i=0;i<mdim;i++)
+       {
+         strncpy(str,unicoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
+          str[MED_TAILLE_PNOM] = '\0';
+          fprintf(stdout," %s ",str);
+       }     
+      fprintf(stdout,"\n- Coordonnees des noeuds : \n");
+      for (i=0;i<nnoe*mdim;i++)
+       fprintf(stdout," %f ",*(coo+i));
+      if (inonoe)
+       {
+         fprintf(stdout,"\n- Noms des noeuds : \n");
+         for (i=0;i<nnoe;i++)
+           {
+             strncpy(str,nomnoe+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
+              str[MED_TAILLE_PNOM] = '\0';
+             fprintf(stdout," %s ",str);
+           }
+       }
+      if (inunoe)
+       {
+         fprintf(stdout,"\n- Numeros des noeuds : \n");
+         for (i=0;i<nnoe;i++)
+             fprintf(stdout," %d ",*(numnoe+i));
+       }
+      fprintf(stdout,"\n- Numeros des familles des noeuds : \n");
+      for (i=0;i<nnoe;i++)
+       fprintf(stdout," %d ",*(nufano+i));
+      fprintf(stdout,"\n");
+    }
+
+  /* liberation memoire */
+  free(coo);
+  free(nomnoe);
+  free(numnoe);
+  free(nufano);
+
+  /****************************************************************************
+  *                       LECTURE DES ELEMENTS                                *
+  ****************************************************************************/
+  fprintf(stdout,"\n(**************************)\n");
+  fprintf(stdout,"(* ELEMENTS DU MAILLAGE : *)\n");
+  fprintf(stdout,"(**************************)");
+  /* Lecture des connectivites, noms, numeros des mailles */
+  if (ret == 0)
+    for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
+      {
+       if (nmailles[i] > 0 && ret == 0)
+         {
+           /* dimension de la maille */
+           edim = typmai[i] / 100;
+           nsup = 0;
+           if (mdim  == 2 || mdim == 3)
+             if (edim == 1)
+               nsup = 1;
+           if (mdim == 3)
+             if (edim == 2)
+               nsup = 1;
+           switch(typ_con)
+             {
+             case MED_NOD :
+               taille = nsup+typmai[i]%100;
+               break;
+               
+             case MED_DESC :
+               taille = nsup+desmai[i];
+               break;
+               
+             default :
+               ret = -1;
+             }
+           
+           /* allocation memoire */
+           connectivite = (med_int*)malloc(sizeof(med_int)*
+                                           taille*nmailles[i]);
+           nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*
+                                  nmailles[i]+1);
+           numele = (med_int*)malloc(sizeof(med_int)*
+                                     nmailles[i]);
+           nufael = (med_int*)malloc(sizeof(med_int)*
+                                     nmailles[i]);
+           
+           /* lecture des données */
+           ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
+                                 nomele,&inoele,numele,&inuele,nufael,
+                                 nmailles[i],MED_MAILLE,typmai[i],
+                                 typ_con);
+           if (ret < 0)
+             strcpy(message,">> ERREUR : lecture des mailles \n");
+           
+           /* affichage des resultats */
+           if (ret == 0)
+             {
+               fprintf(stdout,"\n\n- Mailles de type %s : ", nommai[i]);
+               fprintf(stdout,"\n  - Connectivité : \n");
+               for (j=0;j<nmailles[i]*taille;j++)
+                 fprintf(stdout," %d ",*(connectivite+j));
+               if (inoele)
+                 {
+                   fprintf(stdout,"\n  - Noms : \n");
+                   for (j=0;j<nmailles[i];j++)
+                     {
+                       fprintf(stdout," %d ",*(connectivite+j));
+                       strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
+                       str[MED_TAILLE_PNOM] = '\0';
+                       fprintf(stdout," %s ",str);
+                     }
+                 }
+               if (inuele)
+                 {
+                   fprintf(stdout,"\n  - Numeros :\n");
+                   for (j=0;j<nmailles[i];j++)
+                     fprintf(stdout," %d ",*(numele+j));
+                 }
+               fprintf(stdout,"\n  - Numéros de familles : \n");
+               for (j=0;j<nmailles[i];j++)
+                 fprintf(stdout," %d ",*(nufael+j));
+             }
+               
+           /* liberation memoire */
+           free(connectivite);
+           free(nomele);
+           free(numele);
+           free(nufael);
+         }
+      }
+
+  if (ret == 0)
+    for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++)
+      {
+       if (nfaces[i] > 0 && ret == 0)
+         {
+           /* dimension de la face */
+           edim = typfac[i] / 100;
+           nsup = 0;
+           if (mdim  == 2 || mdim == 3)
+             if (edim == 1)
+               nsup = 1;
+           if (mdim == 3)
+             if (edim == 2)
+               nsup = 1;
+           switch(typ_con)
+             {
+             case MED_NOD :
+               taille = nsup+typfac[i]%100;
+               break;
+               
+             case MED_DESC :
+               taille = nsup+desfac[i];
+               break;
+               
+             default :
+               ret = -1;
+             }
+           
+           /* allocation memoire */
+           connectivite = (med_int*)malloc(sizeof(med_int)*
+                                           taille*nfaces[i]);
+           nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*
+                                  nfaces[i]+1);
+           numele = (med_int*)malloc(sizeof(med_int)*
+                                     nfaces[i]);
+           nufael = (med_int*)malloc(sizeof(med_int)*
+                                     nfaces[i]);
+           
+           /* lecture des données */
+           ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
+                                 nomele,&inoele,numele,&inuele,nufael,
+                                 nfaces[i],MED_FACE,typfac[i],
+                                 typ_con);
+           if (ret < 0)
+             strcpy(message,">> ERREUR : lecture des faces \n");
+           
+           /* affichage des resultats */
+           if (ret == 0)
+             {
+               fprintf(stdout,"\n- Faces de type %s : ", nomfac[i]);
+               fprintf(stdout,"\n  - Connectivité : \n");
+               for (j=0;j<nfaces[i]*taille;j++)
+                 fprintf(stdout," %d ",*(connectivite+j));
+               if (inoele)
+                 {
+                   fprintf(stdout,"\n  - Noms : \n");
+                   for (j=0;j<nfaces[i];j++)
+                     {
+                       fprintf(stdout," %d ",*(connectivite+j));
+                       strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
+                       str[MED_TAILLE_PNOM] = '\0';
+                       fprintf(stdout," %s ",str);
+                     }
+                 }
+               if (inuele)
+                 {
+                   fprintf(stdout,"\n  - Numeros :\n");
+                   for (j=0;j<nfaces[i];j++)
+                     fprintf(stdout," %d ",*(numele+j));
+                 }
+               fprintf(stdout,"\n  - Numéros de familles : \n");
+               for (j=0;j<nfaces[i];j++)
+                 fprintf(stdout," %d ",*(nufael+j));
+             }
+               
+           /* liberation memoire */
+           free(connectivite);
+           free(nomele);
+           free(numele);
+           free(nufael);
+         }
+    }    
+
+  if (ret == 0)
+    for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++)
+      {
+       if (naretes[i] > 0 && ret == 0)
+         {
+           /* dimension de l'arete  */
+           edim = typare[i] / 100;
+           nsup = 0;
+           if (mdim  == 2 || mdim == 3)
+             if (edim == 1)
+               nsup = 1;
+           if (mdim == 3)
+             if (edim == 2)
+               nsup = 1;
+           switch(typ_con)
+             {
+             case MED_NOD :
+               taille = nsup+typare[i]%100;
+               break;
+               
+             case MED_DESC :
+               taille = nsup+desare[i];
+               break;
+               
+             default :
+               ret = -1;
+             }
+           
+           /* allocation memoire */
+           connectivite = (med_int*)malloc(sizeof(med_int)*
+                                           taille*naretes[i]);
+           nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*
+                                  naretes[i]+1);
+           numele = (med_int*)malloc(sizeof(med_int)*
+                                     naretes[i]);
+           nufael = (med_int*)malloc(sizeof(med_int)*
+                                     naretes[i]);
+           
+           /* lecture des données */
+           ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
+                                 nomele,&inoele,numele,&inuele,nufael,
+                                 naretes[i],MED_ARETE,typare[i],
+                                 typ_con);
+           if (ret < 0)
+             strcpy(message,">> ERREUR : lecture des aretes \n");
+           
+           /* affichage des resultats */
+           if (ret == 0)
+             {
+               fprintf(stdout,"\n- Aretes de type %d : ", nomare[i]);
+               fprintf(stdout,"\n  - Connectivité : \n");
+               for (j=0;j<naretes[i]*taille;j++)
+                 fprintf(stdout," %d ",*(connectivite+j));
+               if (inoele)
+                 {
+                   fprintf(stdout,"\n  - Noms : \n");
+                   for (j=0;j<naretes[i];j++)
+                     {
+                       fprintf(stdout," %d ",*(connectivite+j));
+                       strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
+                       str[MED_TAILLE_PNOM] = '\0';
+                       fprintf(stdout," %s ",str);
+                     }
+                 }
+               if (inuele)
+                 {
+                   fprintf(stdout,"\n  - Numeros :\n");
+                   for (j=0;j<naretes[i];j++)
+                     fprintf(stdout," %d ",*(numele+j));
+                 }
+               fprintf(stdout,"\n  - Numéros de familles : \n");
+               for (j=0;j<naretes[i];j++)
+                 fprintf(stdout," %d ",*(nufael+j));
+             }
+               
+           /* liberation memoire */
+           free(connectivite);
+           free(nomele);
+           free(numele);
+           free(nufael);
+         }
+      }
+  
+  /****************************************************************************
+  *                       LECTURE DES FAMILLES                                *
+  ****************************************************************************/
+  printf("\n(*************************)\n");
+  printf("(* FAMILLES DU MAILLAGE : *)\n");
+  printf("(*************************)\n");
+  if (ret == 0)
+    for (i=0;i<nfam;i++)
+      {
+       
+       /* nombre de groupes */
+       ngro = MEDnFam(fid,nommaa,i+1,MED_GROUPE);
+       if (ngro < 0)  
+         {
+           ret = -1;
+           strcpy(message,
+                  ">> ERREUR : lecture du nombre de groupes d'une famille \n");
+         }
+       
+       /* nombre d'attributs */
+       if (ret == 0)
+         {
+           natt = MEDnFam(fid,nommaa,i+1,MED_ATTR);
+           if (natt < 0)
+             {
+               ret = -1;
+               strcpy(message,
+                  ">> ERREUR : lecture du nombre d'attributs d'une famille\n");
+             }
+         }
+
+       if (ret == 0)
+         fprintf(stdout,"- Famille %d a %d attributs et %d groupes \n",i+1,natt,ngro); 
+
+       /* nom,numero,attributs,groupes */
+       if (ret == 0)
+         {
+           attide = (med_int*) malloc(sizeof(med_int)*natt);
+           attval = (med_int*) malloc(sizeof(med_int)*natt);       
+           attdes = (char *) malloc(MED_TAILLE_DESC*natt+1);
+           gro = (char*) malloc(MED_TAILLE_LNOM*ngro+1);
+           ret = MEDfamInfo(fid,nommaa,i+1,nomfam,&numfam,attide,attval,
+                            attdes,&natt,gro,&ngro);
+           fprintf(stdout,"  - Famille de nom %s et de numero %d : \n",nomfam,numfam);
+           fprintf(stdout,"  - Attributs : \n");
+           for (j=0;j<natt;j++)
+             {
+               strncpy(str1,attdes+j*MED_TAILLE_DESC,MED_TAILLE_DESC);
+               str1[MED_TAILLE_DESC] = '\0';
+               fprintf(stdout,"   ide = %d - val = %d - des = %s\n",*(attide+j),
+                      *(attval+j),str1);
+             }
+            free(attide);
+           free(attval);
+            free(attdes);
+            fprintf(stdout,"  - Groupes :\n");
+           for (j=0;j<ngro;j++)
+             {
+               strncpy(str2,gro+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
+               str2[MED_TAILLE_LNOM] = '\0';
+               fprintf(stdout,"   gro = %s\n",str2);
+             }
+            free(gro);
+         }
+      }
+
+  /****************************************************************************
+  *                       LECTURE DES EQUIVALENCES                            *
+  ****************************************************************************/
+  fprintf(stdout,"\n(******************************)\n");
+  fprintf(stdout,"(* EQUIVALENCES DU MAILLAGE : *)\n");
+  fprintf(stdout,"(******************************)\n");
+
+  /* lecture de toutes les equivalences associes a nommaa */
+  if (ret == 0)
+    for (i = 0;i<nequ;i++)
+      {
+       fprintf(stdout,"- Equivalence numero : %d ",i+1);
+
+       /* lecture des infos sur l'equivalence */
+       ret = MEDequivInfo(fid,nommaa,i+1,equ,des);
+        if (ret == 0)
+         {
+           fprintf(stdout,"\n  - Nom de l'equivalence: %s \n",equ);
+            fprintf(stdout,"\n  - Description de l'equivalence : %s \n",des);
+         }
+       else
+         strcpy(message,">> ERREUR : lecture informations sur equivalence\n");
+
+       /* lecture des correspondances sur les differents types d'entites */
+       if (ret == 0)
+         {
+           /* les noeuds */
+           if ((ncor = MEDnCorres(fid,nommaa,equ,MED_NOEUD,(med_geometrie_element)0)) < 0)
+             {
+               ret = -1;
+               strcpy(message,">> ERREUR : lecture nombre de correspondances\n");
+             }
+           else
+             fprintf(stdout,"\n  - Il y a %d correspondances sur les noeuds \n",ncor);
+           if (ncor > 0)
+             {
+               cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
+                ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_NOEUD,(med_geometrie_element)0);
+               if (ret == 0)
+                 for (j=0;j<ncor;j++)
+                   fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",j+1,*(cor+2*j),
+                          *(cor+2*j+1));
+               else
+                  strcpy(message,">> ERREUR : lecture des correspondances\n");
+                free(cor);
+             }
+           
+           /* sur les mailles : on ne prend pas en compte les mailles 3D */
+           if (ret ==0)
+             for (j=0;j<NBR_MAILLE_EQU;j++)
+               {
+                 if ((ncor = MEDnCorres(fid,nommaa,equ,MED_MAILLE,typmai[j])) < 0)
+                   {
+                     ret = -1;
+                      strcpy(message,
+                             ">> ERREUR : lecture informations sur nombre de correspondances \n");
+                   }
+                 else
+                   fprintf(stdout,"\n  - Il y a %d correspondances sur les mailles %s \n",ncor,
+                          nommai[j]);
+                 if (ncor > 0)
+                   {
+                     cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
+                     ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_MAILLE,
+                                        typmai[j]);
+                     if (ret == 0)
+                       for (k=0;k<ncor;k++)
+                         fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
+                                *(cor+2*k+1));
+                     else
+                        strcpy(message,">> ERREUR : correspondances\n");
+                     free(cor);
+                   }
+               }
+
+           /* sur les faces */
+           if (ret == 0)
+             for (j=0;j<MED_NBR_GEOMETRIE_FACE;j++)
+               {
+                 if ((ncor = MEDnCorres(fid,nommaa,equ,MED_FACE,typfac[j])) < 0)
+                   {
+                     ret = -1;
+                     strcpy(message,">> ERREUR : informations sur correspondances \n");
+                   }
+                 else
+                   fprintf(stdout,"\n  - Il y a %d correspondances sur les faces %s\n",ncor,
+                          nomfac[j]);
+                 if (ncor > 0)
+                   {
+                     cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
+                     ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_FACE,
+                                        typfac[j]);
+                     if (ret < 0)
+                       strcpy(message,"ERREUR : lecture des equivalences \n");
+                     else
+                       for (k=0;k<ncor;k++)
+                         fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
+                                *(cor+2*k+1));
+                     free(cor);
+                   }
+               }
+           
+           /*  sur les aretes */
+           for (j=0;j<MED_NBR_GEOMETRIE_ARETE;j++)
+             {
+               if ((ncor = MEDnCorres(fid,nommaa,equ,MED_ARETE,typare[j])) < 0)
+                 {
+                   ret = -1;
+                   strcpy(message,">> ERREUR : nombre de correspondances \n");
+                 }
+               else
+                 fprintf(stdout,"\n  - Il y a %d correspondances sur les aretes %s \n",
+                        ncor,nomare[j]);
+               if (ncor > 0)
+                 {
+                   cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
+                   ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_ARETE,
+                                      typare[j]);
+                   if (ret < 0)
+                     strcpy(message,">> ERREUR : equivalences \n");
+                   else
+                     for (k=0;k<ncor;k++)
+                       fprintf(stdout,"\n  Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
+                              *(cor+2*k+1));
+                   free(cor);
+                 }
+             }
+         }                         
+      }
+
+  /****************************************************************************
+  *                       LECTURE DES CHAMPS                                  *
+  ****************************************************************************/
+  fprintf(stdout,"\n(************************)\n");
+  fprintf(stdout,"(* CHAMPS DU MAILLAGE : *)\n");
+  fprintf(stdout,"(************************)\n");
+
+  if (ret == 0)
+    for (i=0;i<ncha;i++)
+      {
+       fprintf(stdout,"- Champ numero : %d \n",i+1);
+       
+       /* combien de composantes */
+       if ((ncomp = MEDnChamp(fid,i+1)) < 0)
+         {
+           ret = -1;
+           strcpy(message,">> ERREUR : nombre de composants d'un champ\n");
+         }
+       
+       /* allocation memoire de comp et unit*/
+        if (ret == 0)
+         {
+           comp = (char*) malloc(ncomp*MED_TAILLE_PNOM+1);
+           unit = (char*) malloc(ncomp*MED_TAILLE_PNOM+1);
+         }
+
+       /* infos sur les champs */
+       if (ret == 0)
+         ret = MEDchampInfo(fid,i+1,nomcha,&typcha,comp,unit,ncomp);
+       if (ret < 0)
+         strcpy(message,">> ERREUR : information sur les champs \n");
+
+       if (ret == 0) {
+         fprintf(stdout,"  - Nom du champ : %s de type %d\n",nomcha,typcha);
+         fprintf(stdout,"  - Nom des composantes : %s\n",comp);
+         fprintf(stdout,"  - Unites des composantes : %s \n",unit);
+         free(comp);
+         free(unit);   
+       }
+            
+             
+       if (ret == 0)  /* Valeurs sur les noeuds */
+         {
+           /* Combien de pas de temps ? */
+           npdt = MEDnPasdetemps(fid,nomcha,MED_NOEUD,(med_geometrie_element)0);
+           if (npdt < 0)
+             ret = -1;
+           if (ret == -1)
+             strcpy(message,">> ERREUR : la lecture du nombe de pas de temps");
+           else
+             fprintf(stdout,"\n  - Il y a %d pas de temps sur les noeuds \n",npdt);
+
+           /* Lecture des valeurs pour tous les pas de temps */
+           if (ret == 0)
+             for (j=0;j<npdt;j++)
+               {
+                 /* Informations sur les pas de temps */
+                 if (ret == 0)
+                   ret = MEDpasdetempsInfo(fid,nomcha,MED_NOEUD,(med_geometrie_element)0,
+                                           j+1, maillage_champ, &ngauss, &numdt,  dtunit, &dt, &numo);
+
+                 if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
+                   fprintf(stdout,"\n  -> \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n",
+                           numdt,dt,numo,ngauss);
+                 else
+                   strcpy(message,">> ERREUR : information sur les pas de temps \n");
+                 
+                 /* Combien de valeurs a lire ? */
+                 if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
+                   {
+                     if ((nval = MEDnVal(fid,nomcha,MED_NOEUD,(med_geometrie_element)0,numdt,numo)) < 0)
+                       {
+                         ret = -1;
+                         strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n");
+                       }
+                     else
+                       fprintf(stdout,"\n  - Il y a %d valeurs sur les noeuds \n",nval);
+                   }
+
+                 if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
+                   {
+                     if (typcha == MED_REEL64)
+                       {
+                         valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval);
+                         ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL,
+                                            pflnom,MED_NOEUD,(med_geometrie_element)0,numdt,numo);
+                                            
+                         if (ret < 0)
+                           strcpy(message,">> ERREUR : lecture des champs \n");
+                         else
+                           for (k=0;k<nval*ncomp;k++)
+                             fprintf(stdout," %f ",*(valr+k));
+                         free(valr);
+                       }
+                     else
+                       {
+                         vale = (med_int*) malloc(sizeof(med_int)*ncomp*nval);
+                         ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)vale,mode_coo,MED_ALL,
+                                            pflnom,MED_NOEUD,(med_geometrie_element)0,numdt,numo);
+                         if (ret < 0)
+                           strcpy(message,">> ERREUR : lecture des champs \n");
+                         else
+                           for (k=0;k<nval*ncomp;k++)
+                             fprintf(stdout," %d ",*(vale+k));
+                         free(vale);
+                       }
+
+                     /* Lecture d'un profil eventuel */
+                     if (strcmp(pflnom,MED_NOPFL) == 0 )
+                       fprintf(stdout,"\n \t- Pas de profil\n");
+                     else 
+                       {
+                         if ( (pflsize = MEDnValProfil(fid,pflnom)) <0)
+                           {
+                             ret = -1;
+                             strcpy(message,">> ERREUR : lecture de la taille du profil \n");
+                           }
+                         else 
+                           {
+                             fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize);
+                             pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
+                             
+                             if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0)
+                               strcpy(message,">> ERREUR : lecture du profil \n");
+                             else
+                               for (l=0;l<pflsize;l++)
+                                 fprintf(stdout,"\t%i\n",*(pflval+l));
+                             
+                             free(pflval);
+                           }
+                       }
+                   }                             
+               }
+         }
+
+
+       if (ret == 0)  /* Valeurs sur les mailles */
+         {
+           for (k=0;k<MED_NBR_GEOMETRIE_MAILLE;k++)
+             {
+               typgeo = typmai[k];
+
+               /* Combien de pas de temps ? */
+               npdt = MEDnPasdetemps(fid,nomcha,MED_MAILLE,typgeo);
+               if (npdt < 0)
+                 ret = -1;
+               if (ret == -1)
+                 strcpy(message,">> ERREUR : la lecture du nombe de pas de temps");
+               else
+                 fprintf(stdout,"\n  - Il y a %d pas de temps sur les mailles de type %d \n",npdt,typgeo);
+
+               /* Lecture des valeurs pour tous les pas de temps */
+               if (ret == 0)
+                 for (j=0;j<npdt;j++)
+                   {
+                     /* Informations sur les pas de temps */
+                     if (ret == 0)
+                       ret = MEDpasdetempsInfo(fid,nomcha,MED_MAILLE,typgeo,
+                                               j+1, maillage_champ, &ngauss, &numdt,  dtunit, &dt, &numo);
+
+                     if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
+                       fprintf(stdout,"\n  -> \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n",
+                               numdt,dt,numo,ngauss);
+                     else
+                       strcpy(message,">> ERREUR : information sur les pas de temps \n");
+
+                     /* Combien de valeurs a lire ? */
+                     if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
+                       {
+                         if ((nval = MEDnVal(fid,nomcha,MED_MAILLE,typgeo,numdt,numo)) < 0)
+                           {
+                             ret = -1;
+                             strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n");
+                           }
+                         else
+                           fprintf(stdout,"\n  - Il y a %d valeurs sur les noeuds \n",nval);
+                       }
+
+                     if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
+                       {
+                         if (typcha == MED_REEL64)
+                           {
+                             valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval);
+                             ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL,
+                                                pflnom,MED_MAILLE,typgeo,numdt,numo);
+                             if (ret < 0)
+                               strcpy(message,">> ERREUR : lecture des champs \n");
+                             else
+                               for (kp=0;kp<nval*ncomp;kp++)
+                                 fprintf(stdout," %f ",*(valr+kp));
+                             free(valr);
+                           }
+                         else
+                           {
+                             vale = (med_int*) malloc(sizeof(med_int)*ncomp*nval);
+                             ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)vale,mode_coo,MED_ALL,
+                                                pflnom,MED_MAILLE,typgeo,numdt,numo);
+                             if (ret < 0)
+                               strcpy(message,">> ERREUR : lecture des champs \n");
+                             else
+                               for (kp=0;kp<nval*ncomp;kp++)
+                                 fprintf(stdout," %d ",*(vale+kp));
+                             free(vale);
+                           }
+                         
+                         /* Lecture d'un profil eventuel */
+                         if (strcmp(pflnom,MED_NOPFL) == 0 )
+                           fprintf(stdout,"\n \t- Pas de profil\n");
+                         else 
+                           {
+                             if ( (pflsize = MEDnValProfil(fid,pflnom)) <0)
+                               {
+                                 ret = -1;
+                                 strcpy(message,">> ERREUR : lecture de la taille du profil \n");
+                               }
+                             else 
+                               {
+                                 fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize);
+                                 pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
+                                 
+                                 if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0)
+                                   strcpy(message,">> ERREUR : lecture du profil \n");
+                                 else
+                                   for (l=0;l<pflsize;l++)
+                                     fprintf(stdout,"\t%i\n",*(pflval+l));
+                                 
+                                 free(pflval);
+                               }
+                           }
+                       }                                 
+                   }
+             }
+         }    
+      
+
+       if (ret == 0)  /* Valeurs sur les faces */
+         {
+           for (k=0;k<MED_NBR_GEOMETRIE_FACE;k++)
+             {
+               typgeo = typfac[k];
+
+               /* Combien de pas de temps ? */
+               npdt = MEDnPasdetemps(fid,nomcha,MED_FACE,typgeo);
+               if (npdt < 0)
+                 ret = -1;
+               if (ret == -1)
+                 strcpy(message,">> ERREUR : la lecture du nombe de pas de temps");
+               else
+                 fprintf(stdout,"\n  - Il y a %d pas de temps sur les faces de type %d \n",npdt,typgeo);
+
+               /* Lecture des valeurs pour tous les pas de temps */
+               if (ret == 0)
+                 for (j=0;j<npdt;j++)
+                   {
+                     /* Informations sur les pas de temps */
+                     if (ret == 0)
+                       ret = MEDpasdetempsInfo(fid,nomcha,MED_FACE,typgeo,
+                                               j+1, maillage_champ, &ngauss, &numdt,  dtunit, &dt, &numo);
+
+                     if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
+                       fprintf(stdout,"\n  -> \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n",
+                               numdt,dt,numo,ngauss);
+                     else
+                       strcpy(message,">> ERREUR : information sur les pas de temps \n");
+
+                     /* Combien de valeurs a lire ? */
+                     if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
+                       {
+                         if ((nval = MEDnVal(fid,nomcha,MED_FACE,typgeo,numdt,numo)) < 0)
+                           {
+                             ret = -1;
+                             strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n");
+                           }
+                         else
+                           fprintf(stdout,"\n  - Il y a %d valeurs sur les noeuds \n",nval);
+                       }
+
+                     if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
+                       {
+                         if (typcha == MED_REEL64)
+                           {
+                             valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval);
+                             ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL,
+                                                pflnom,MED_FACE,typgeo,numdt,numo);
+                             if (ret < 0)
+                               strcpy(message,">> ERREUR : lecture des champs \n");
+                             else
+                               for (kp=0;kp<nval*ncomp;kp++)
+                                 fprintf(stdout," %f ",*(valr+kp));
+                             free(valr);
+                           }
+                         else
+                           {
+                             vale = (med_int*) malloc(sizeof(med_int)*ncomp*nval);
+                             ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)vale,mode_coo,MED_ALL,
+                                                pflnom,MED_FACE,typgeo,numdt,numo);
+                             if (ret < 0)
+                               strcpy(message,">> ERREUR : lecture des champs \n");
+                             else
+                               for (kp=0;kp<nval*ncomp;kp++)
+                                 fprintf(stdout," %d ",*(vale+kp));
+                             free(vale);
+                           }
+                         
+                         /* Lecture d'un profil eventuel */
+                         if (strcmp(pflnom,MED_NOPFL) == 0 )
+                           fprintf(stdout,"\n \t- Pas de profil\n");
+                         else 
+                           {
+                             if ( (pflsize = MEDnValProfil(fid,pflnom)) <0)
+                               {
+                                 ret = -1;
+                                 strcpy(message,">> ERREUR : lecture de la taille du profil \n");
+                               }
+                             else 
+                               {
+                                 fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize);
+                                 pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
+                                 
+                                 if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0)
+                                   strcpy(message,">> ERREUR : lecture du profil \n");
+                                 else
+                                   for (l=0;l<pflsize;l++)
+                                     fprintf(stdout,"\t%i\n",*(pflval+l));
+                                 
+                                 free(pflval);
+                               }
+                           }
+                       }                                 
+                   }
+             }
+         }    
+
+
+       if (ret == 0)  /* Valeurs sur les aretes */
+         {
+           for (k=0;k<MED_NBR_GEOMETRIE_ARETE;k++)
+             {
+               typgeo = typare[k];
+
+               /* Combien de pas de temps ? */
+               npdt = MEDnPasdetemps(fid,nomcha,MED_ARETE,typgeo);
+               if (npdt < 0)
+                 ret = -1;
+               if (ret == -1)
+                 strcpy(message,">> ERREUR : la lecture du nombe de pas de temps");
+               else
+                 fprintf(stdout,"\n  - Il y a %d pas de temps sur les aretes de type %d \n",npdt,typgeo);
+
+               /* Lecture des valeurs pour tous les pas de temps */
+               if (ret == 0)
+                 for (j=0;j<npdt;j++)
+                   {
+                     /* Informations sur les pas de temps */
+                     if (ret == 0)
+                       ret = MEDpasdetempsInfo(fid,nomcha,MED_ARETE,typgeo,
+                                               j+1, maillage_champ, &ngauss, &numdt,  dtunit, &dt, &numo);
+
+                     if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
+                       fprintf(stdout,"\n  -> \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n",
+                               numdt,dt,numo,ngauss);
+                     else
+                       strcpy(message,">> ERREUR : information sur les pas de temps \n");
+
+                     /* Combien de valeurs a lire ? */
+                     if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
+                       {
+                         if ((nval = MEDnVal(fid,nomcha,MED_ARETE,typgeo,numdt,numo)) < 0)
+                           {
+                             ret = -1;
+                             strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n");
+                           }
+                         else
+                           fprintf(stdout,"\n  - Il y a %d valeurs sur les noeuds \n",nval);
+                       }
+
+                     if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
+                       {
+                         if (typcha == MED_REEL64)
+                           {
+                             valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval);
+                             ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL,
+                                                pflnom,MED_ARETE,typgeo,numdt,numo);
+                             if (ret < 0)
+                               strcpy(message,">> ERREUR : lecture des champs \n");
+                             else
+                               for (kp=0;kp<nval*ncomp;kp++)
+                                 fprintf(stdout," %f ",*(valr+kp));
+                             free(valr);
+                           }
+                         else
+                           {
+                             vale = (med_int*) malloc(sizeof(med_int)*ncomp*nval);
+                             ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)vale,mode_coo,MED_ALL,
+                                                pflnom,MED_ARETE,typgeo,numdt,numo);
+                             if (ret < 0)
+                               strcpy(message,">> ERREUR : lecture des champs \n");
+                             else
+                               for (kp=0;kp<nval*ncomp;kp++)
+                                 fprintf(stdout," %d ",*(vale+kp));
+                             free(vale);
+                           }
+                         
+                         /* Lecture d'un profil eventuel */
+                         if (strcmp(pflnom,MED_NOPFL) == 0 )
+                           fprintf(stdout,"\n \t- Pas de profil\n");
+                         else 
+                           {
+                             if ( (pflsize = MEDnValProfil(fid,pflnom)) <0)
+                               {
+                                 ret = -1;
+                                 strcpy(message,">> ERREUR : lecture de la taille du profil \n");
+                               }
+                             else 
+                               {
+                                 fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize);
+                                 pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
+                                 
+                                 if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0)
+                                   strcpy(message,">> ERREUR : lecture du profil \n");
+                                 else
+                                   for (l=0;l<pflsize;l++)
+                                     fprintf(stdout,"\t%i\n",*(pflval+l));
+                                 
+                                 free(pflval);
+                               }
+                           }
+                       }                                 
+                   }
+             }
+         }    
+
+      }
+
+  if (ret < 0)
+    fprintf(stderr,"%s\n",message);
+
+  /****************************************************************************
+  *                      FERMETURE DU FICHIER                                 *
+  ****************************************************************************/
+  ret = MEDfermer(fid);
+  
+  if (ret == 0)
+    fprintf(stdout,"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1]);
+  else
+   fprintf(stderr,">> ERREUR : erreur a la fermeture du fichier %s\n",argv[1]);
+
+  return 0;
+}
diff --git a/src/MEDWrapper/V2_1/med.hxx b/src/MEDWrapper/V2_1/med.hxx
new file mode 100644 (file)
index 0000000..2fe174f
--- /dev/null
@@ -0,0 +1,164 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2003  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#ifndef MED_H
+#define MED_H
+
+extern "C"{
+#include <hdf5.h>
+}
+
+namespace med_2_1{
+
+#define MED_NULL       (void *) NULL
+#define MED_MAX_PARA        20
+
+#define MED_TAILLE_DESC 200
+#define MED_TAILLE_IDENT  8
+#define MED_TAILLE_NOM   32
+#define MED_TAILLE_LNOM  80    
+#define MED_TAILLE_PNOM   8 
+
+/* Integration des developpements OCC */
+typedef enum {MED_CARTESIAN, MED_POLAR, MED_BODY_FITTED} med_grid_type;
+
+typedef enum {MED_GRID_D1=0, MED_GRID_D2=1, MED_GRID_D3=2,
+              MED_GRID_NOEUD=3,
+              MED_FAM_NOEUD=4, MED_FAM_ARETE=5, MED_FAM_FACE=6, MED_FAM_MAILLE=7 } med_grid;
+
+/* Fin de l'integration*/
+
+typedef enum {MED_FULL_INTERLACE,
+             MED_NO_INTERLACE}  med_mode_switch; 
+
+typedef enum {MED_GLOBALE,
+             MED_COMPACT }  med_mode_profil; 
+
+typedef enum {MED_LECT,MED_ECRI,MED_REMP} med_mode_acces; 
+
+typedef enum {MED_MAILLE, MED_FACE, MED_ARETE, MED_NOEUD} med_entite_maillage; 
+
+typedef enum {MED_COOR, MED_CONN, MED_NOM, MED_NUM, MED_FAM} med_table;
+
+typedef enum {MED_REEL64=6, MED_INT32=24,MED_INT64=26, MED_INT} med_type_champ;
+
+#define MED_NBR_GEOMETRIE_MAILLE 15
+#define MED_NBR_GEOMETRIE_FACE 4
+#define MED_NBR_GEOMETRIE_ARETE 2
+typedef enum {MED_POINT1=1, MED_SEG2=102, MED_SEG3=103, MED_TRIA3=203,
+             MED_QUAD4=204, MED_TRIA6=206,MED_QUAD8=208, MED_TETRA4=304,
+             MED_PYRA5=305, MED_PENTA6=306, MED_HEXA8=308, MED_TETRA10=310, 
+             MED_PYRA13=313, MED_PENTA15=315, MED_HEXA20=320}
+med_geometrie_element;
+
+typedef enum {MED_NOD, MED_DESC} med_connectivite ; 
+
+typedef enum {MED_CART, MED_CYL, MED_SPHER} med_repere; 
+
+typedef enum {MED_FAUX, MED_VRAI} med_booleen ; 
+
+typedef enum {MED_GROUPE, MED_ATTR, MED_FAMILLE} med_dim_famille; 
+
+typedef enum {MED_COMP, MED_DTYPE} med_dim_champ; 
+
+typedef enum {MED_HDF_VERSION, MED_VERSION, MED_FICH_DES} med_fich_info; 
+
+#define MED_NOPG   1                   /* -> pas de point de Gauss                    */
+#define MED_NOPFL  ""                  /* -> pas de profils utilisateur               */
+#define MED_NOPFLi "                                "  /* Variable Interne                      */
+#define MED_NOPF   0                   /* -> pas de profils pour _MEDdataseNnumEcrire */
+#define MED_NOPDT -1                   /* rem: pas de pas de temps negatifs           */
+#define MED_NONOR -1                   /* rem: pas de n°ordre negatif                 */
+#define MED_DIM1   1                   /* PAS */
+#define MED_ALL    0
+
+#if defined(SUN4SOL2) || defined(PCLINUX) || defined(OSF1_32) || defined(IRIX64_32) || defined(RS6000)
+/* interface C/FORTRAN */
+/* this true only with g77 and gcc : we must change it to use directly NOMF_... and INT32 or INT64 -
+ it will be more simple to understand and to use ! */
+#define NOMF_POST_UNDERSCORE 
+
+/* correspondance des types avec HDF 5 */
+typedef hsize_t        med_size;
+typedef hssize_t       med_ssize;
+typedef hid_t          med_idt;
+typedef herr_t         med_err;
+
+/* types elementaires */
+typedef int            med_int;
+typedef double         med_float;
+#endif
+
+#if defined(HP9000)
+/* correspondance des types avec HDF 5 */
+typedef hsize_t        med_size;
+typedef hssize_t       med_ssize;
+typedef hid_t          med_idt;
+typedef herr_t         med_err;
+
+/* types elementaires */
+typedef int            med_int;
+typedef double         med_float;
+#endif
+
+#if defined(IRIX64) || defined(OSF1)
+#define NOMF_POST_UNDERSCORE
+
+/* correspondance des types avec HDF 5 */
+typedef hsize_t        med_size;
+typedef hssize_t       med_ssize;
+typedef hid_t          med_idt;
+typedef herr_t         med_err;
+
+/* types elementaires */
+typedef long           med_int;
+typedef double         med_float;
+#endif
+
+
+#if defined(PPRO_NT) 
+/* correspondance des types avec HDF 5 */
+typedef hsize_t        med_size;
+typedef hssize_t       med_ssize;
+typedef hid_t          med_idt;
+typedef herr_t         med_err;
+
+/* types elementaires */
+typedef int           med_int;
+typedef double         med_float;
+#endif
+
+
+#if defined(NOMF_PRE_UNDERSCORE) && defined(NOMF_POST_UNDERSCORE)
+#   define NOMF(x)     _##x##_
+#endif
+#if defined(NOMF_PRE_UNDERSCORE) && !defined(NOMF_POST_UNDERSCORE)
+#   define NOMF(x)     _##x
+#endif
+#if !defined(NOMF_PRE_UNDERSCORE) && defined(NOMF_POST_UNDERSCORE)
+#   define NOMF(x)     x##_
+#endif
+#if !defined(NOMF_PRE_UNDERSCORE) && !defined(NOMF_POST_UNDERSCORE)
+#   define NOMF(x)     x
+#endif
+
+}
+
+#include "med_proto.hxx"
+
+#endif  /* MED_H */
diff --git a/src/MEDWrapper/V2_1/med_hdfi.hxx b/src/MEDWrapper/V2_1/med_hdfi.hxx
new file mode 100644 (file)
index 0000000..670ff63
--- /dev/null
@@ -0,0 +1,120 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#ifndef MED_HDFI_H
+#define MED_HDFI_H
+#include "med.hxx"
+
+/* FONCTIONS INTERFACE MED/HDF */
+namespace med_2_1{
+
+/* Gestion des fichiers HDF */
+extern
+med_idt _MEDfichierCreer(char *nom);
+
+extern
+med_idt _MEDfichierOuvrir(char *nom,med_mode_acces mode);
+
+extern
+med_err _MEDfichierFermer(med_idt fid);
+
+
+/* Gestion des datagroups HDF */
+extern 
+med_idt _MEDdatagroupCreer(med_idt pid, char *nom);
+
+extern 
+med_idt _MEDdatagroupOuvrir(med_idt pid, char *nom);
+
+extern
+med_err _MEDdatagroupFermer(med_idt id);
+
+
+/* Gestion des datasets HDF */
+
+extern 
+med_idt _MEDdatasetOuvrir(med_idt pid,char *nom);
+
+extern
+med_err _MEDdatasetFermer(med_idt id);
+
+extern
+med_err _MEDdatasetNumEcrire (med_idt pere,char *nom, med_type_champ type,
+                            med_mode_switch interlace, med_size nbdim, med_size fixdim, 
+                            med_size psize, med_ssize * profil, med_int ngauss,
+                             med_size *size,  unsigned char *val, med_mode_acces mode);
+
+
+extern
+med_err _MEDdatasetNumLire(med_idt pere,char *nom,med_type_champ type,
+                          med_mode_switch interlace, med_size nbdim, med_size fixdim, 
+                          med_size psize, med_ssize * pfltab, med_int ngauss,
+                          unsigned char *val);
+
+extern
+med_err _MEDdatasetStringEcrire(med_idt pere,char *nom,med_size *dimd,
+                               char *val, med_mode_acces mode);
+
+extern
+med_err _MEDdatasetStringLire(med_idt pere,char *nom,char *val);
+
+/* Gestion des attributs HDF */
+extern 
+med_idt _MEDattrOuvrir(med_idt pid,char * nom);
+
+extern
+med_err _MEDattrFermer(med_idt id);
+
+extern
+med_err _MEDattrNumEcrire(med_idt pere,med_type_champ type,char *nom,unsigned char *val,med_mode_acces mode);
+
+#define _MEDattrEntierEcrire(w,x,y,z)  _MEDattrNumEcrire(w,MED_INT   ,x,(unsigned char *) y,z)
+#define _MEDattrFloatEcrire(w,x,y,z)   _MEDattrNumEcrire(w,MED_REEL64,x,(unsigned char *) y,z)
+
+extern
+med_err _MEDattrNumLire(med_idt pere,med_type_champ type,char *nom,unsigned char *val);
+
+#define _MEDattrEntierLire(x,y,z) _MEDattrNumLire(x,MED_INT   ,y,(unsigned char*)z)
+#define _MEDattrFloatLire(x,y,z)  _MEDattrNumLire(x,MED_REEL64,y,(unsigned char*)z)
+
+extern
+med_err _MEDattrStringEcrire(med_idt pere,char *nom,int longueur,char *val,med_mode_acces mode);
+
+extern
+med_err _MEDattrStringLire(med_idt pere,char *nom,int longueur,char *val);
+
+
+/* Divers */
+extern
+med_err _MEDindiceInfo(med_idt id, const char *nom, void *donnees);
+
+extern
+med_err _MEDindiceNum(med_idt id,const char *nom, void *donnees);
+
+extern  
+med_err _MEDobjetIdentifier(med_idt fid,char *chemin,int indice,void *nom);
+
+extern 
+med_err _MEDnObjets(med_idt fid,char *chemin,int *n);
+
+extern 
+void _MEDmodeErreurVerrouiller(); 
+
+}
+
+#endif /* MED_HDFI_H */
diff --git a/src/MEDWrapper/V2_1/med_misc.hxx b/src/MEDWrapper/V2_1/med_misc.hxx
new file mode 100644 (file)
index 0000000..9e9676e
--- /dev/null
@@ -0,0 +1,62 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#ifndef MED_MISC_H
+#define MED_MISC_H
+#include "med.hxx"
+
+
+/* CHAINES DE CARACTERES FORTRAN => C */
+namespace med_2_1{
+
+extern
+char *_MED1cstring(char *chaine,int longueur_reelle,int longueur_fixee);
+
+extern
+char *_MED2cstring(char *chaine, int longueur);
+
+extern
+med_err _MEDcstringFree(char *chaine);
+
+extern
+med_err _MEDfstring(char *chaine, med_int longueur_fixee);
+
+/* Noms associes aux objets MED */
+extern
+med_err _MEDnomEntite(char *nom_ent,med_entite_maillage type_ent);
+
+extern
+med_err _MEDnomGeometrie(char *nom_geo,med_geometrie_element type_geo);
+
+extern
+med_err _MEDparametresGeometrie(med_entite_maillage type_ent, 
+                              med_geometrie_element type_geo, int *dim, int *nnoe,
+                              int *ndes);
+extern
+med_err _MEDnomDataset(char *nom_dataset,med_table quoi,
+                      med_connectivite type_conn);
+
+/* Geometrie des objets MED */
+extern 
+med_err _MEDGeometrieElement(med_geometrie_element typ_geo[],
+                            med_entite_maillage typ_ent);
+
+}
+
+#endif /* MED_MISC_H */
+
diff --git a/src/MEDWrapper/V2_1/med_outils.hxx b/src/MEDWrapper/V2_1/med_outils.hxx
new file mode 100644 (file)
index 0000000..b897a62
--- /dev/null
@@ -0,0 +1,127 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2003  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#ifndef MED_OUTILS_H
+#define MED_OUTILS_H
+#include "med.hxx"
+
+#define MED_NOM_MAJEUR "MAJ"
+#define MED_NOM_MINEUR "MIN"
+#define MED_NOM_RELEASE "REL"
+
+#define MED_NUM_MAJEUR 2
+#define MED_NUM_MINEUR 1
+#define MED_NUM_RELEASE 6
+
+#define MED_NOM_INFOS "INFOS_GENERALES"
+
+#define MED_NOM_DESCRIPTEUR "descripteur de fichier"
+#define MED_VERSION_ACTUELLE "2.1.6"
+#define HDF_VERSION_ACTUELLE "5-1.4.4"
+
+/* Noms des data sets ou attributs correspondant a des entites MED */
+#define MED_TAILLE_NOM_ENTITE 3
+#define MED_NOM_NUM "NUM"
+#define MED_NOM_NBR "NBR"
+#define MED_NOM_NOM "NOM"
+#define MED_NOM_UNV "UNV"
+#define MED_NOM_NNS "NNS"
+#define MED_NOM_NNM "NNM"
+#define MED_NOM_NNI "NNI"
+#define MED_NOM_GRO "GRO"
+#define MED_NOM_ATT "ATT"
+#define MED_NOM_NCO "NCO"
+#define MED_NOM_DIM "DIM"
+#define MED_NOM_FAM "FAM"
+#define MED_NOM_IDE "IDE"
+#define MED_NOM_VAL "VAL"
+#define MED_NOM_DES "DES"
+#define MED_NOM_COR "COR"
+#define MED_NOM_DIM "DIM"
+#define MED_NOM_NOE "NOE"
+#define MED_NOM_COO "COO"
+#define MED_NOM_REP "REP"
+#define MED_NOM_UNI "UNI"
+#define MED_NOM_NOD "NOD"
+#define MED_NOM_TYP "TYP"
+#define MED_NOM_CO "CO"
+#define MED_NOM_NCW "NCW"
+#define MED_NOM_TYW "TYW"
+#define MED_NOM_MAI "MAI"
+#define MED_NOM_FAC "FAC"
+#define MED_NOM_ARE "ARE"
+#define MED_NOM_PO1 "PO1"
+#define MED_NOM_SE2 "SE2"
+#define MED_NOM_SE3 "SE3"
+#define MED_NOM_TR3 "TR3"
+#define MED_NOM_TR6 "TR6"
+#define MED_NOM_QU4 "QU4"
+#define MED_NOM_QU8 "QU8"
+#define MED_NOM_TE4 "TE4"
+#define MED_NOM_T10 "T10"
+#define MED_NOM_HE8 "HE8"
+#define MED_NOM_H20 "H20"
+#define MED_NOM_PE6 "PE6"
+#define MED_NOM_P15 "P15"
+#define MED_NOM_PY5 "PY5"
+#define MED_NOM_P13 "P13"  
+
+#define MED_NOM_GEO "GEO"
+#define MED_NOM_GAU "GAU"
+#define MED_NOM_NGA "NGA"
+#define MED_NOM_N   "N"
+#define MED_NOM_PFL "PFL"
+#define MED_NOM_NDT "NDT"
+#define MED_NOM_PDT "PDT"
+#define MED_NOM_NOR "NOR"
+
+/* Integration des developpements OCC */
+#define MED_NOM_GRD "GRD"
+#define MED_NOM_BOF "BOF"
+#define MED_NOM_IN1 "IN1"
+#define MED_NOM_IN2 "IN2"
+#define MED_NOM_IN3 "IN3"
+
+/* Nom du DATA GROUP CONTENANT TOUS LES MAILLAGES DU FICHIER HDF */
+#define MED_MAA "/ENS_MAA/"
+#define MED_TAILLE_MAA 9
+
+/* Nom du data group ou ranger les champs solution */
+#define MED_CHA "/CHA/"
+#define MED_TAILLE_CHA 5
+
+/* Nom du data group ou ranger les familles */
+#define MED_FAS "/FAS/"
+#define MED_TAILLE_FAS 5
+
+/* Nom du data group ou ranger les equivalences */
+#define MED_EQS "/EQS/"
+#define MED_TAILLE_EQS 5
+
+/* Nom du data groupe contenant les profils */
+#define MED_PROFILS "/PROFILS/"
+#define MED_TAILLE_PROFILS 9 
+
+/*Pour eviter le bug solaris*/
+#include <malloc.h>
+
+/* Interface des routines du composant tools */
+#include "med_misc.hxx"
+#include "med_hdfi.hxx"
+#include "med_utils.hxx"
+#endif /* MED_OUTILS_H */
diff --git a/src/MEDWrapper/V2_1/med_proto.hxx b/src/MEDWrapper/V2_1/med_proto.hxx
new file mode 100644 (file)
index 0000000..1847b56
--- /dev/null
@@ -0,0 +1,276 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+#ifndef MED_PROTO_H
+#define MED_PROTO_H
+
+/* Interface de l'API MED */
+namespace med_2_1{
+/* Fichier */
+extern med_idt
+MEDouvrir(char *nom, med_mode_acces mode_acces);
+extern med_err 
+MEDfermer(med_idt fid); 
+extern med_int
+MEDlFichDes(med_idt fid);
+extern med_err 
+MEDfichEntete(med_idt fid, med_fich_info quoi, char str[]); 
+extern med_err 
+MEDfichDesEcr(med_idt fid, char *des, med_mode_acces mode); 
+extern med_err
+MEDunvCr(med_idt fid, char *maa);
+extern med_err
+MEDunvLire(med_idt fid, char *maa,char *nomu);
+extern med_err
+MEDformatConforme(const char * nomfich);
+extern med_err
+MEDversionConforme(const char *nom);
+extern void
+MEDversionDonner(med_int *majeur, med_int *mineur, med_int *release);
+extern med_err 
+MEDversionLire(med_idt fid, med_int *majeur, med_int *mineur, med_int *release);
+
+
+
+/* Maillage */
+extern med_err 
+MEDmaaCr(med_idt fid, char *maillage, med_int dim);
+extern med_int
+MEDdimLire(med_idt fid, char *maillage); 
+extern med_err 
+MEDmaaInfo(med_idt fid, int indice, char *maillage, med_int *dim); 
+extern med_int 
+MEDnMaa(med_idt fid);
+extern med_err 
+MEDnbnosoEcr(med_idt fid, char *nom_maillage,med_int n);
+extern med_int
+MEDnbnosoLire(med_idt fid,char *nom_maillage);
+extern med_err 
+MEDnbnoisEcr(med_idt fid, char *nom_maillage,med_int n);
+extern med_int
+MEDnbnoisLire(med_idt fid,char *nom_maillage);
+extern med_err
+MEDnbnomaEcr(med_idt fid, char *nom_maillage,med_int n);
+extern med_int
+MEDnbnomaLire(med_idt fid,char *nom_maillage);
+
+/* EntMaillage */
+extern med_err 
+MEDconnEcr(med_idt fid,char *maa, med_int mdim, med_int *connectivite,med_mode_switch mode_switch,
+          med_int nbre,med_mode_acces mode,med_entite_maillage type_ent,
+          med_geometrie_element type_geo,med_connectivite type_conn);
+
+extern med_err 
+MEDconnLire(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch,
+           med_int * pfltab, med_size psize,
+           med_entite_maillage type_ent, med_geometrie_element type_geo,med_connectivite type_conn);
+extern med_err 
+MEDnomEcr(med_idt fid,char *maa, char *nom, med_int n, med_mode_acces mode,
+         med_entite_maillage type_ent,med_geometrie_element type_geo); 
+extern med_err 
+MEDnomLire(med_idt fid,char *maa, char *nom, med_int n, 
+          med_entite_maillage type_ent,med_geometrie_element type_geo); 
+extern med_err 
+MEDnumLire(med_idt fid,char *maa, med_int *num, med_int n, 
+          med_entite_maillage type_ent,med_geometrie_element type_geo); 
+extern med_err 
+MEDnumEcr(med_idt fid,char *maa, med_int *num, med_int n, med_mode_acces mode,
+         med_entite_maillage type_ent,med_geometrie_element type_geo);
+extern med_err 
+MEDcoordEcr(med_idt fid, char *maa, med_int mdim, med_float *coo, 
+           med_mode_switch mode_coo,med_int n,
+           med_mode_acces mode, med_repere type_rep, char *nom, char *unit);
+extern med_err 
+MEDcoordLire(med_idt fid, char *maa, med_int mdim, med_float *coo,
+            med_mode_switch mode_coo,med_int numco,
+            med_int * pfltab, med_size psize, med_repere *type_rep, char *nom, char *unit);
+
+extern med_int
+MEDnEntMaa(med_idt fid, char *maa, med_table quoi, med_entite_maillage type_ent, 
+          med_geometrie_element type_geo, med_connectivite type_conn); 
+
+
+/* Resultat */
+extern med_err MEDchampCr(med_idt fid, char *champ, med_type_champ type, char *comp,
+                  char *unit,med_int ncomp);
+
+extern med_err 
+MEDchampEcr(med_idt fid, char *maa, char *cha,unsigned char *val,med_mode_switch interlace,med_int nbelem,med_int ngauss, 
+           med_int numco, char * profil, med_mode_acces mode, med_entite_maillage type_ent, 
+           med_geometrie_element type_geo, med_int numdt,char * dt_unit, med_float dt, med_int numo);
+
+extern med_err 
+MEDchampLire(med_idt fid,char *maa, char *cha, unsigned char *val,med_mode_switch interlace,med_int numco,
+            char *profil,med_entite_maillage type_ent, med_geometrie_element type_geo,
+            med_int numdt, med_int numo);
+extern med_err
+MEDchampInfo(med_idt fid,int indice,char *champ,
+                    med_type_champ *type,char *comp,char *unit, 
+                    med_int ncomp);
+
+extern med_int 
+MEDnChamp(med_idt fid, int indice); 
+
+extern med_int
+MEDnVal(med_idt fid, char *champ, med_entite_maillage typ_ent, 
+       med_geometrie_element typ_geo,med_int numdt, med_int numo);
+
+
+/* Famille  */
+extern med_err 
+MEDfamEcr(med_idt fid,char *maa, med_int *fam, med_int n, med_mode_acces mode,
+         med_entite_maillage type_ent, med_geometrie_element type_geo); 
+extern med_err 
+MEDfamLire(med_idt fid,char *maa, med_int *fam, med_int n, 
+          med_entite_maillage type_ent,med_geometrie_element type_geo);
+extern med_err 
+MEDfamCr(med_idt fid,char* maa,char *famille,med_int numero, 
+        med_int *attr_ident, med_int *attr_val,char *attr_desc,med_int n_attr,
+        char *groupe , med_int n_groupe);
+extern med_int 
+MEDnFam(med_idt fid,char *maa, int indice, med_dim_famille quoi);
+extern med_err 
+MEDfamInfo(med_idt fid,char *maa,int indice, char *famille, 
+          med_int *numero,
+          med_int *attr_ident, med_int *attr_val, char *attr_desc,
+          med_int *n_attr,char *groupe ,med_int *n_groupe); 
+/* Equivalence    */
+extern med_err 
+MEDequivCr(med_idt fid,char *maa, char *eq, char *desc); 
+extern med_err 
+MEDequivLire(med_idt fid, char *maa, char *eq, med_int *corr, med_int n,
+            med_entite_maillage typ_ent,med_geometrie_element typ_geo); 
+extern med_err 
+MEDequivEcr(med_idt fid, char *maa, char *eq, med_int *corr, med_int n, 
+           med_mode_acces mode, med_entite_maillage typ_ent, med_geometrie_element typ_geo); 
+extern med_err 
+MEDequivInfo(med_idt fid, char *maa, int ind, char *eq, char *des);
+extern med_int 
+MEDnEquiv(med_idt fid, char *maa);
+extern med_int 
+MEDnCorres(med_idt fid,char *maa,char *eq,med_entite_maillage typ_ent,
+          med_geometrie_element typ_geo); 
+
+
+/* Routines de niveau intermediaire */
+extern med_int
+MEDnEntites(med_idt fid,char *maa,med_entite_maillage typ_ent, 
+            med_connectivite typ_con);
+
+extern med_err
+MEDnoeudsLire(med_idt fid,char *maa,med_int mdim, med_float *coord,
+             med_mode_switch mode_coo,
+             med_repere *repere,char *nomcoo, char *unicoo,char *nom,
+             med_booleen *inom,med_int *num,med_booleen *inum,med_int *fam,
+             med_int nnoeuds);
+
+extern med_err
+MEDnoeudsEcr(med_idt fid,char *maa,med_int mdim,med_float *coord,
+            med_mode_switch mode_coo,
+            med_repere repere,char *nomcoo, char *unicoo,char *nom,
+            med_booleen inom,med_int *num,med_booleen inum,med_int *fam,
+            med_int nnoeuds,med_mode_acces mode);
+extern med_err
+MEDelementsEcr(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch,
+              char *nom,med_booleen inom,med_int *num,med_booleen inum,
+              med_int *fam,med_int nele,med_entite_maillage typ_ent, 
+              med_geometrie_element typ_geo,med_connectivite typ_conn,med_mode_acces mode);
+extern med_err
+MEDelementsLire(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch,
+              char *nom,med_booleen *inom,med_int *num,med_booleen *inum,
+              med_int *fam,med_int nele,med_entite_maillage typ_ent, 
+              med_geometrie_element typ_geo,med_connectivite typ_conn);
+
+/* Routines de haut niveau    */
+
+/*(? On enlève le reste ?)*/
+
+extern med_err
+MEDfamMaaInfo(med_idt fid,char *maa,med_int *nfam,med_int *nattc,
+             med_int *ngroc);
+
+extern med_err
+MEDfamMaaLire(med_idt fid,char *maa,
+             med_int *numfam,med_int *attide,
+             med_int *attval,char *attdes,int *indatt,char *gro,int *indgro,
+             med_int nfamilles);
+
+extern med_err
+MEDfamMaaCr(med_idt fid,char *maa,
+           med_int *numfam,med_int *attide,
+           med_int *attval,char *attdes,int *indatt,char *gro,int *indgro,
+           med_int nfamilles);
+
+/* Routines concernant les profils */
+
+extern med_err 
+MEDprofilInfo(med_idt fid, int indice, char *profil, med_int *n); 
+
+extern med_int 
+MEDnProfil(med_idt fid);
+
+extern med_err 
+MEDprofilEcr(med_idt fid,med_int *pflval,med_int n,char *nom);
+
+extern med_int 
+MEDnValProfil(med_idt fid, char *nom);
+
+extern med_err 
+MEDprofilLire(med_idt fid, med_int *pflval, char *nom);
+
+/* Routines concernant les pas de temps/ numéros d'ordre */
+
+extern med_int
+MEDnPasdetemps(med_idt fid,char *cha,med_entite_maillage type_ent, 
+              med_geometrie_element type_geo);
+
+extern med_err 
+MEDpasdetempsInfo(med_idt fid,char *champ
+                 ,med_entite_maillage type_ent, med_geometrie_element type_geo,
+                 int indice, char *maa, med_int * ngauss, med_int * numdt, char * dt_unit, med_float * dt, 
+                 med_int * numo);
+
+/* Grilles */
+
+med_int MEDnGrid(med_idt fid, char *maa, med_grid n);
+med_err MEDgridCr(med_idt fid, char *maillage, med_int dim, med_grid_type typ);
+med_err MEDgridInfo(med_idt fid, int indice, med_int *isAGrid, med_grid_type *typ);
+med_err MEDgridEcr(
+        med_idt fid, char *maa, med_int mdim, med_float *coo, med_int nb, med_int dim, med_mode_switch mode_coo,
+        med_repere repere, char *nomcoo, char *unicoo, med_mode_acces mode );
+med_err MEDgridLire(
+        med_idt fid, char *maa, med_int mdim, med_float *coo, med_int dim, med_mode_switch mode_coo,
+        med_repere *repere, char *nomcoo, char *unicoo );
+med_err MEDfamGridEcr(med_idt fid, char *maa, med_int *fam, med_int n, med_mode_acces mode, med_entite_maillage type_ent);
+med_err MEDfamGridLire(med_idt fid, char *maa, med_int *fam, med_int n, med_entite_maillage type_ent);
+med_err MEDbodyFittedEcr(
+        med_idt fid, char *maa, med_int mdim, med_float *coo, med_int *nbr, med_mode_switch mode_coo,
+        med_repere repere, char *nomcoo, char *unicoo, med_int *fam, med_int nnoeuds, med_mode_acces mode );
+med_err MEDbodyFittedLire(
+        med_idt fid, char *maa, med_int mdim, med_float *coo, med_mode_switch mode_coo,
+        med_repere *repere, char *nomcoo, char *unicoo, med_int *fam, med_int nnoeuds );
+}
+
+#endif /* MED_PROTO_H */
+
+
+
+
diff --git a/src/MEDWrapper/V2_1/med_utils.hxx b/src/MEDWrapper/V2_1/med_utils.hxx
new file mode 100644 (file)
index 0000000..0c16d65
--- /dev/null
@@ -0,0 +1,261 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+# ifndef __UTILITES_H__
+# define __UTILITES_H__
+
+
+/* pour indiquer le statut des arguments des fonctions. */
+
+#ifdef _IN
+#error _IN already defined
+#endif
+#define _IN
+
+#ifdef _OUT
+#error _OUT already defined
+#endif
+#define _OUT
+
+#ifdef _INOUT
+#error _INOUT already defined
+#endif
+#define _INOUT
+
+#ifdef _UNUSED
+#error _UNUSED already defined
+#endif
+#define _UNUSED
+
+
+
+
+
+
+
+/* --- Pour afficher le nom du fichier source courant et le numero de la ligne courante --- */
+/* --- sur la stderr.                                                                   --- */
+
+# define ICI                   {\
+                                       fflush(stdout);\
+                                       fprintf(stderr, "%s [%d] : " , __FILE__ , __LINE__ ) ;\
+                                       fflush(stderr) ;\
+                               }
+
+
+
+
+
+
+
+/* --- Pour afficher la date et l'heure de la compilation du fichier source courant,    --- */
+/* --- sur la stdout.                                                                   --- */
+
+# ifdef INFOS_COMPILATION
+# error INFOS_COMPILATION already defined
+# endif
+# define INFOS_COMPILATION     {\
+                                       fflush(stderr);\
+                                       fprintf(stdout, "%s [%d] : " , __FILE__ , __LINE__ ) ;\
+                                       fprintf(stdout,"Compilation le %s" , __DATE__);\
+                                       fprintf(stdout," a %s" , __TIME__ );\
+                                       fprintf(stdout,"\n\n\n" );\
+                                       fflush(stdout) ;\
+                               }
+
+
+
+
+
+
+
+/* --- Pour attendre "secondes" secondes et afficher un message sur la stderr indiquant --- */
+/* --- cette attente volontaire.                                                        --- */
+
+# ifdef ATTENTE
+# error ATTENTE already defined
+# endif
+# define ATTENTE(secondes)     {\
+                                       ICI ;\
+                                       fprintf( stderr, "ATTENTE de %d secondes" , secondes);\
+                                       fflush(stderr) ;\
+                                       sleep(secondes) ;\
+                                       fprintf( stderr, "\n" );\
+                                       fflush(stderr) ;\
+                               }
+
+
+
+
+
+
+
+/* ----------    Les macros suivantes ne doivent pas deja exister !              ---------- */
+
+# ifdef EXECUTION
+# error EXECUTION already defined
+# endif
+# ifdef INTERRUPTION
+# error INTERRUPTION already defined
+# endif
+# ifdef ISCRUTE
+# error ISCRUTE already defined
+# endif
+# ifdef RSCRUTE
+# error RSCRUTE already defined
+# endif
+# ifdef SSCRUTE
+# error SSCRUTE already defined
+# endif
+# ifdef CSCRUTE
+# error CSCRUTE already defined
+# endif
+# ifdef XSCRUTE
+# error XSCRUTE already defined
+# endif
+# ifdef MESSAGE
+# error MESSAGE already defined
+# endif
+
+
+
+
+
+# ifdef _DEBOG_
+
+
+/* --- Pour tracer sur la stderr l'execution d"une instruction.                         --- */
+
+# define EXECUTION(instruction)        {\
+                                       ICI ;\
+                                       fprintf( stderr,"INSTRUCTION %s" , #instruction ) ;\
+                                       fflush(stderr);\
+                                       instruction ;\
+                                       fflush(stdout);\
+                                       fprintf( stderr," FRANCHIE\n" ) ;\
+                                       fflush(stderr);\
+                               }
+
+
+
+
+
+
+
+/* --- Pour afficher un message d'interruption volontaire et retourner le code retour   --- */
+/* --- "code"                                                                           --- */
+
+# define INTERRUPTION(code)    {\
+                                       ICI ;\
+                                       fprintf( stderr," INTERRUPTION code = %d",code) ;\
+                                       fprintf(stderr,"\n") ;\
+                                       exit(code) ;\
+                               }
+
+
+
+
+
+
+
+/* --- Pour conditionner la poursuite du traitement par la validite de la condition     --- */
+/* --- "condiiton".                                                                     --- */
+
+# ifndef ASSERT
+# define ASSERT(condition)     if( !(condition) ){\
+                                       ICI ;\
+                                       fprintf(stderr,"condition %s VIOLEE\n",#condition);\
+                                       INTERRUPTION(17);\
+                               }
+# endif                /* # ifndef ASSERT */
+
+
+
+
+
+
+
+/* --- Pour afficher sur la stderr la valeur d'une variable precedee de son nom.        --- */
+
+# define ISCRUTE(entier)       {\
+                                       ICI ;\
+                                       fprintf(stderr,"%s = %d\n",#entier,entier) ;\
+                                       fflush(stderr) ;\
+                               }
+# define RSCRUTE(reel)         {\
+                                       ICI ;\
+                                       fprintf(stderr,"%s = %f\n",#reel,reel) ;\
+                                       fflush(stderr) ;\
+                               }
+# define XSCRUTE(pointeur)             {\
+                                       ICI ;\
+                                       fprintf(stderr,"%s = %x\n",#pointeur,pointeur) ;\
+                                       fflush(stderr) ;\
+                               }
+# define CSCRUTE(car)          {\
+                                       ICI ;\
+                                       fprintf(stderr,"%s = %c\n",#car,car) ;\
+                                       fflush(stderr) ;\
+                               }
+# define SSCRUTE(chaine)       {\
+                                       ICI ;\
+                                       fprintf(stderr,"%s = \"%s\"\n",#chaine,chaine) ;\
+                                       fflush(stderr) ;\
+                               }
+# define MESSAGE(chaine)       {\
+                                       ICI ;\
+                                       fprintf(stderr,"%s\n",chaine) ;\
+                                       fflush(stderr) ;\
+                               }
+# define FIN(nom)              {\
+                                       ICI ;\
+                                       fprintf( stderr , "} FIN %s\n\n\n" , nom ) ;\
+                                       fflush(stderr) ;\
+                               }
+# define DEBUT(nom)            {\
+                                       fprintf( stderr , "\n\n\n") ;\
+                                       ICI ;\
+                                       fprintf( stderr , "{ DEBUT %s\n" , nom ) ;\
+                                       fflush(stderr) ;\
+                               }
+
+
+# else         /* # ifdef _DEBOG_ */
+
+
+
+# define EXECUTION(instruction) instruction
+# define INTERRUPTION(code)
+
+# ifndef ASSERT
+# define ASSERT(condition)
+# endif
+
+# define ISCRUTE(entier)
+# define RSCRUTE(reel)
+# define CSCRUTE(car)
+# define SSCRUTE(chaine)
+# define MESSAGE(chaine)
+# define DEBUT(nom)
+# define FIN(nom)
+
+# endif                /* # ifdef _DEBOG_ */
+
+
+# endif                /* # ifndef __UTILITES_H__ */
diff --git a/src/MEDWrapper/V2_1/test1_V2_1.cxx b/src/MEDWrapper/V2_1/test1_V2_1.cxx
new file mode 100644 (file)
index 0000000..20746cb
--- /dev/null
@@ -0,0 +1,72 @@
+/*************************************************************************
+* COPYRIGHT (C) 1999 - 2002  EDF R&D
+* THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+* IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
+* AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
+* EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+*
+* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+*
+* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+*
+*************************************************************************/
+
+/******************************************************************************
+ * - Nom du fichier : test1.c
+ *
+ * - Description : tests des routines d'ouverture/fermeture des
+ *                 fichiers MED 
+ *
+ *****************************************************************************/
+
+#include "med.hxx"
+using namespace med_2_1;
+
+/******************************************************************************
+ * OUVERTURE/FERMETURE DE FICHIERS :
+ *
+ * Description :
+ *    - ouverture du fichier en mode ecriture avec remplacement
+ *    - ecriture d'une description du fichier (optionnel)
+ *    - fermeture du fichier
+ *    - ouverture du fichier en mode de lecture
+ *    - fermeture du fichier
+ *****************************************************************************/
+
+int main (int argc, char **argv)
+{
+  med_err ret = 0;
+  med_idt fid;
+  char des[MED_TAILLE_DESC+1]="Ceci est un courte description du mon fichier test1.med";
+
+  fid = MEDouvrir("test1.med",MED_REMP);
+  if (fid < 0)
+    ret = -1;
+  printf("%d\n",ret);
+
+  if (ret == 0)
+    ret = MEDfichDesEcr(fid,des, MED_REMP);
+  printf("%d\n",ret);
+
+  ret = MEDfermer(fid);
+  printf("%d\n",ret);
+
+  fid = MEDouvrir("test1.med",MED_LECT);
+  if (fid < 0)
+    ret = -1;
+  printf("%d\n",ret);
+
+  ret = MEDfermer(fid);
+  printf("%d\n",ret);
+  
+  return 0;
+}
+
+
+
+
diff --git a/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx b/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx
new file mode 100644 (file)
index 0000000..2405e77
--- /dev/null
@@ -0,0 +1,945 @@
+//  
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : 
+//  Author : 
+//  Module : 
+//  $Header$
+
+#include "MED_V2_2_Wrapper.hxx"
+#include "MED_Utilities.hxx"
+
+extern "C"{
+#include <med.h>
+}
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+#else
+static int MYDEBUG = 0;
+#endif
+
+
+
+namespace MED{
+  namespace V2_2{
+
+    //---------------------------------------------------------------
+    class TFile{
+      TFile();
+      TFile(const TFile&);
+      
+    public:
+      TFile(const std::string& theFileName): 
+       myFid(0), 
+       myCount(0),
+       myFileName(theFileName)
+      {}
+      
+      ~TFile(){ 
+       Close();
+      }
+      
+      void Open(EModeAcces theMode, TErr* theErr = NULL){
+       if(myCount++ == 0){
+         char* aFileName = const_cast<char*>(myFileName.c_str());
+         myFid = MEDouvrir(aFileName,med_mode_acces(theMode));
+       }
+       if(theErr)
+         *theErr = TErr(myFid > 0);
+       else if(myFid < 0)
+         EXCEPTION(runtime_error,"TFile - MEDouvrir('"<<myFileName<<"',"<<theMode<<")");
+      }
+
+      const TIdt& Id() const { 
+       if(myFid < 0)
+         EXCEPTION(runtime_error,"TFile - GetFid() < 0");
+       return myFid;
+      }
+
+      void Close(){ 
+       if(--myCount == 0)
+         MEDfermer(myFid);
+      }
+
+    protected:
+      std::string myFileName;
+      TInt myCount;
+      TIdt myFid;
+    };
+
+
+    //---------------------------------------------------------------
+    class TFileWrapper{
+      PFile myFile;
+
+    public:
+      TFileWrapper(const PFile& theFile, EModeAcces theMode, TErr* theErr = NULL): 
+       myFile(theFile)
+      {
+       myFile->Open(theMode,theErr);
+      }
+      
+      ~TFileWrapper(){
+       myFile->Close();
+      }
+    };
+
+
+    //---------------------------------------------------------------
+    TVWrapper::TVWrapper(const std::string& theFileName): 
+      myFile(new TFile(theFileName))
+    {
+    }
+    
+    
+    TInt TVWrapper::GetNbMeshes(TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+      
+      if(theErr && !*theErr)
+       return -1;
+      
+      return MEDnMaa(myFile->Id());
+    }
+    
+    
+    void TVWrapper::GetMeshInfo(TInt theMeshId, 
+                              MED::TMeshInfo& theInfo,
+                              TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+      
+      if(theErr && !*theErr)
+       return;
+      
+      med_maillage& aType = static_cast<med_maillage>(theInfo.myType);
+
+      TErr aRet = MEDmaaInfo(myFile->Id(),
+                            theMeshId,
+                            &theInfo.myName[0],
+                            &theInfo.myDim,
+                            &aType,
+                            &theInfo.myDesc[0]);
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"GetMeshInfo - MEDmaaInfo(...)");
+    }
+    
+    
+    void TVWrapper::SetMeshInfo(const MED::TMeshInfo& theInfo,
+                              EModeAcces theMode,
+                              TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,theMode,theErr);
+      
+      if(theErr && !*theErr)
+       return;
+      
+      MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
+      
+      med_maillage& aType = static_cast<med_maillage>(theInfo.myType);
+
+      TErr aRet = MEDmaaCr(myFile->Id(),
+                          &anInfo.myName[0],
+                          anInfo.myDim,
+                          aType,
+                          &anInfo.myDesc[0]);
+      if(aRet == 0){
+       aRet = MEDunvCr(myFile->Id(),
+                       &anInfo.myName[0]);
+      }
+      
+      INITMSG(MYDEBUG,"TVWrapper::SetMeshInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<endl);
+      
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"SetMeshInfo - MEDmaaCr(...)");
+    }
+    
+    
+    void TVWrapper::SetMeshInfo(const MED::TMeshInfo& theInfo,
+                              TErr* theErr)
+    {
+      TErr aRet;
+      SetMeshInfo(theInfo,eLECTURE_ECRITURE,&aRet);
+      
+      if(aRet < 0)
+       SetMeshInfo(theInfo,eLECTURE_AJOUT,&aRet);
+
+      if(aRet < 0)
+       SetMeshInfo(theInfo,eCREATION,theErr);
+    }
+    
+    
+    TInt TVWrapper::GetNbFamilies(const MED::TMeshInfo& theInfo,
+                                TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+      
+      if(theErr && !*theErr)
+       return -1;
+      
+      MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
+      return MEDnFam(myFile->Id(),
+                    &anInfo.myName[0]);
+    }
+    
+    
+    TInt TVWrapper::GetNbFamAttr(TInt theFamId, 
+                               const MED::TMeshInfo& theInfo,
+                               TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+      
+      if(theErr && !*theErr)
+       return -1;
+      
+      MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
+      return MEDnAttribut(myFile->Id(),
+                         &anInfo.myName[0],
+                         theFamId);
+    }
+    
+    
+    TInt TVWrapper::GetNbFamGroup(TInt theFamId, 
+                                const MED::TMeshInfo& theInfo,
+                                TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+      
+      if(theErr && !*theErr)
+       return -1;
+      
+      MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
+      return MEDnGroupe(myFile->Id(),
+                       &anInfo.myName[0],
+                       theFamId);
+    }
+    
+    
+    void TVWrapper::GetFamilyInfo(TInt theFamId, 
+                                MED::TFamilyInfo& theInfo,
+                                TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+      
+      if(theErr && !*theErr)
+       return;
+      
+      MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
+      
+      TErr aRet = MEDfamInfo(myFile->Id(),
+                            &aMeshInfo.myName[0],
+                            theFamId,
+                            &theInfo.myName[0],
+                            &theInfo.myId,
+                            &theInfo.myAttrId[0],
+                            &theInfo.myAttrVal[0],
+                            &theInfo.myAttrDesc[0],
+                            &theInfo.myNbAttr,
+                            &theInfo.myGroupNames[0],
+                            &theInfo.myNbGroup);
+      
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"GetFamilyInfo - MEDfamInfo(...) - "<<
+                 " aMeshInfo.myName = '"<<&aMeshInfo.myName[0]<<
+                 "'; theFamId = "<<theFamId<<
+                 "; theInfo.myNbGroup = "<<theInfo.myNbGroup<<
+                 "; theInfo.myNbAttr = "<<theInfo.myNbAttr);
+
+      INITMSG(MYDEBUG,"GetFamilyInfo - MEDfamInfo(...) - "<<
+             " aMeshInfo.myName = '"<<&aMeshInfo.myName[0]<<
+             "'; theFamId = "<<theFamId<<
+             "; theInfo.myNbGroup = "<<theInfo.myNbGroup<<
+             "; theInfo.myNbAttr = "<<theInfo.myNbAttr);
+    }
+    
+    
+    void TVWrapper::SetFamilyInfo(const MED::TFamilyInfo& theInfo,
+                                EModeAcces theMode,
+                                TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,theMode,theErr);
+      
+      if(theErr && !*theErr)
+       return;
+      
+      MED::TFamilyInfo& anInfo = const_cast<MED::TFamilyInfo&>(theInfo);
+      MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
+      
+      TErr aRet = MEDfamCr(myFile->Id(),
+                          &aMeshInfo.myName[0],
+                          &anInfo.myName[0],
+                          anInfo.myId,
+                          &anInfo.myAttrId[0],
+                          &anInfo.myAttrVal[0],
+                          &anInfo.myAttrDesc[0],
+                          anInfo.myNbAttr,
+                          &anInfo.myGroupNames[0],
+                          anInfo.myNbGroup);
+      
+      INITMSG(MYDEBUG,"TVWrapper::GetFamilyInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<endl);
+      
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"SetFamilyInfo - MEDfamCr(...)");
+    }
+    
+    
+    void TVWrapper::SetFamilyInfo(const MED::TFamilyInfo& theInfo,
+                                TErr* theErr)
+    {
+      TErr aRet;
+      SetFamilyInfo(theInfo,eLECTURE_ECRITURE,&aRet);
+      
+      if(aRet < 0)
+       SetFamilyInfo(theInfo,eLECTURE_AJOUT,theErr);
+    }
+    
+    
+    TInt TVWrapper::GetNbNodes(const MED::TMeshInfo& theMeshInfo,
+                             TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+      
+      if(theErr && !*theErr)
+       return -1;
+      
+      MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
+      
+      return MEDnEntMaa(myFile->Id(),
+                       &aMeshInfo.myName[0],
+                       MED_COOR,
+                       MED_NOEUD,
+                       med_geometrie_element(0),
+                       med_connectivite(0));
+    }
+    
+    
+    void TVWrapper::GetNodeInfo(MED::TNodeInfo& theInfo,
+                              TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+      
+      if(theErr && !*theErr)
+       return;
+      
+      MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
+
+      med_repere& aRepere = static_cast<med_repere>(theInfo.mySystem);
+      med_booleen& anIsElemNames = static_cast<med_booleen>(theInfo.myIsElemNames);
+      med_booleen& anIsElemNum = static_cast<med_booleen>(theInfo.myIsElemNum);
+
+      TErr aRet = MEDnoeudsLire(myFile->Id(),
+                               &aMeshInfo.myName[0],
+                               aMeshInfo.myDim,
+                               &theInfo.myCoord[0],
+                               MED_FULL_INTERLACE,
+                               &aRepere,
+                               &theInfo.myCoordNames[0],
+                               &theInfo.myCoordUnits[0],
+                               &theInfo.myElemNames[0],
+                               &anIsElemNames,
+                               &theInfo.myElemNum[0],
+                               &anIsElemNum,
+                               &theInfo.myFamNum[0],
+                               theInfo.myNbElem);
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"GetNodeInfo - MEDnoeudsLire(...)");
+    }
+    
+    
+    void TVWrapper::SetNodeInfo(const MED::TNodeInfo& theInfo,
+                              EModeAcces theMode,
+                              TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,theMode,theErr);
+      
+      if(theErr && !*theErr)
+       return;
+      
+      MED::TNodeInfo& anInfo = const_cast<MED::TNodeInfo&>(theInfo);
+      MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
+      
+      med_repere& aRepere = static_cast<med_repere>(theInfo.mySystem);
+      med_booleen& anIsElemNames = static_cast<med_booleen>(theInfo.myIsElemNames);
+      med_booleen& anIsElemNum = static_cast<med_booleen>(theInfo.myIsElemNum);
+
+      TErr aRet = MEDnoeudsEcr(myFile->Id(),
+                              &aMeshInfo.myName[0],
+                              aMeshInfo.myDim,
+                              &anInfo.myCoord[0],
+                              MED_FULL_INTERLACE,
+                              aRepere,
+                              &anInfo.myCoordNames[0],
+                              &anInfo.myCoordUnits[0],
+                              &anInfo.myElemNames[0],
+                              anIsElemNames,
+                              &anInfo.myElemNum[0],
+                              anIsElemNum,
+                              &anInfo.myFamNum[0],
+                              anInfo.myNbElem);
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"SetNodeInfo - MEDnoeudsEcr(...)");
+    }
+    
+    
+    void TVWrapper::SetNodeInfo(const MED::TNodeInfo& theInfo,
+                              TErr* theErr)
+    {
+      TErr aRet;
+      SetNodeInfo(theInfo,eLECTURE_ECRITURE,&aRet);
+      
+      if(aRet < 0)
+       SetNodeInfo(theInfo,eLECTURE_AJOUT,theErr);
+    }
+    
+    
+    TEntityInfo TVWrapper::GetEntityInfo(const MED::TMeshInfo& theMeshInfo,
+                                       EConnectivite theTConn,
+                                       TErr* theErr)
+    {
+      TEntityInfo anInfo;
+      
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+      
+      if(theErr && !*theErr)
+       return anInfo;
+      
+      if(TInt aNbElem = GetNbNodes(theMeshInfo)){
+       anInfo[eNOEUD][ePOINT1] = aNbElem;
+       const TEntity2GeomSet& anEntity2GeomSet = GetEntity2GeomSet();
+       TEntity2GeomSet::const_iterator anIter = anEntity2GeomSet.begin();
+       TEntity2GeomSet::const_iterator anIterEnd = anEntity2GeomSet.end();
+       for(; anIter != anIterEnd; anIter++){
+         const EEntiteMaillage& anEntity = anIter->first;
+         const TGeomSet& aGeomSet = anIter->second;
+         TGeomSet::const_iterator anIter2 = aGeomSet.begin();
+         TGeomSet::const_iterator anIterEnd2 = aGeomSet.end();
+         for(; anIter2 != anIterEnd2; anIter2++){
+           const EGeometrieElement& aGeom = *anIter2;
+           if(TInt aNb = GetNbCells(theMeshInfo,anEntity,aGeom,theTConn,theErr)){
+             anInfo[anEntity][aGeom] = aNb;
+           }
+         }
+       }
+      }
+      return anInfo;
+    }
+    
+    
+    TInt TVWrapper::GetNbCells(const MED::TMeshInfo& theMeshInfo, 
+                             EEntiteMaillage theTEntity, 
+                             EGeometrieElement theTGeom, 
+                             EConnectivite theTConn,
+                             TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+      
+      if(theErr && !*theErr)
+       return -1;
+      
+      MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
+      
+      med_entite_maillage& anEntity = static_cast<med_entite_maillage>(theTEntity);
+      med_geometrie_element& aGeom = static_cast<med_geometrie_element>(theTGeom);
+      med_connectivite& aConn = static_cast<med_connectivite>(theTConn);
+
+      return MEDnEntMaa(myFile->Id(),
+                       &aMeshInfo.myName[0],
+                       MED_CONN,
+                       anEntity,
+                       aGeom,
+                       aConn); 
+    }
+    
+    
+    void TVWrapper::GetCellInfo(MED::TCellInfo& theInfo,
+                              TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+
+      if(theErr && !*theErr)
+       return;
+      
+      MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
+      TInt aNbElem = theInfo.myElemNum.size();
+
+      med_booleen& anIsElemNames = static_cast<med_booleen>(theInfo.myIsElemNames);
+      med_booleen& anIsElemNum = static_cast<med_booleen>(theInfo.myIsElemNum);
+      med_entite_maillage& anEntity = static_cast<med_entite_maillage>(theInfo.myTEntity);
+      med_geometrie_element& aGeom = static_cast<med_geometrie_element>(theInfo.myTGeom);
+      med_connectivite& aConn = static_cast<med_connectivite>(theInfo.myTConn);
+
+      TErr aRet = MEDelementsLire(myFile->Id(),
+                                 &aMeshInfo.myName[0],
+                                 aMeshInfo.myDim,
+                                 &theInfo.myConn[0],
+                                 MED_FULL_INTERLACE,
+                                 &theInfo.myElemNames[0],
+                                 &anIsElemNames,
+                                 &theInfo.myElemNum[0],
+                                 &anIsElemNum,
+                                 &theInfo.myFamNum[0],
+                                 aNbElem,
+                                 anEntity,
+                                 aGeom,
+                                 aConn);
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"GetCellInfo - MEDelementsLire(...)");
+    }
+    
+    
+    void TVWrapper::SetCellInfo(const MED::TCellInfo& theInfo,
+                              EModeAcces theMode,
+                              TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,theMode,theErr);
+      
+      if(theErr && !*theErr)
+       return;
+
+      MED::TCellInfo& anInfo = const_cast<MED::TCellInfo&>(theInfo);
+      MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
+
+      med_booleen& anIsElemNames = static_cast<med_booleen>(theInfo.myIsElemNames);
+      med_booleen& anIsElemNum = static_cast<med_booleen>(theInfo.myIsElemNum);
+      med_entite_maillage& anEntity = static_cast<med_entite_maillage>(theInfo.myTEntity);
+      med_geometrie_element& aGeom = static_cast<med_geometrie_element>(theInfo.myTGeom);
+      med_connectivite& aConn = static_cast<med_connectivite>(theInfo.myTConn);
+
+      TErr aRet = MEDelementsEcr(myFile->Id(),
+                                &aMeshInfo.myName[0],
+                                aMeshInfo.myDim,
+                                &anInfo.myConn[0],
+                                MED_FULL_INTERLACE,
+                                &anInfo.myElemNames[0],
+                                anIsElemNames,
+                                &anInfo.myElemNum[0],
+                                anIsElemNum,
+                                &anInfo.myFamNum[0],
+                                anInfo.myNbElem,
+                                anEntity,
+                                aGeom,
+                                aConn);
+      
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"GetCellInfo - MEDelementsLire(...)");
+    }
+    
+
+    void TVWrapper::SetCellInfo(const MED::TCellInfo& theInfo,
+                              TErr* theErr)
+    {
+      SetCellInfo(theInfo,eLECTURE_ECRITURE,theErr);
+    }
+    
+
+    TInt TVWrapper::GetNbFields(TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+      
+      if(theErr && !*theErr)
+       return -1;
+      
+      return MEDnChamp(myFile->Id(),0);
+    }
+    
+    
+    TInt TVWrapper::GetNbComp(TInt theFieldId,
+                            TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+      
+      if(theErr && !*theErr)
+       return -1;
+      
+      return MEDnChamp(myFile->Id(),theFieldId);
+    }
+    
+    
+    void TVWrapper::GetFieldInfo(TInt theFieldId, 
+                               MED::TFieldInfo& theInfo,
+                               TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+      
+      if(theErr && !*theErr)
+       return;
+      
+      med_type_champ& aType = static_cast<med_type_champ>(theInfo.myType);
+
+      TErr aRet = MEDchampInfo(myFile->Id(),
+                              theFieldId,
+                              &theInfo.myName[0],
+                              &aType,
+                              &theInfo.myCompNames[0],
+                              &theInfo.myUnitNames[0],
+                              theInfo.myNbComp);
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"GetFieldInfo - MEDchampInfo(...)");
+    }
+    
+    
+    void TVWrapper::SetFieldInfo(const MED::TFieldInfo& theInfo,
+                               EModeAcces theMode,
+                               TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,theMode,theErr);
+      
+      if(theErr && !*theErr)
+       return;
+      
+      MED::TFieldInfo& anInfo = const_cast<MED::TFieldInfo&>(theInfo);
+      
+      med_type_champ& aType = static_cast<med_type_champ>(theInfo.myType);
+      
+      TErr aRet = MEDchampCr(myFile->Id(),
+                            &anInfo.myName[0],
+                            aType,
+                            &anInfo.myCompNames[0],
+                            &anInfo.myUnitNames[0],
+                            anInfo.myNbComp);
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"SetFieldInfo - MEDchampEcr(...)");
+    }
+    
+    
+    void TVWrapper::SetFieldInfo(const MED::TFieldInfo& theInfo,
+                               TErr* theErr)
+    {
+      TErr aRet;
+      SetFieldInfo(theInfo,eLECTURE_ECRITURE,&aRet);
+      
+      if(aRet < 0)
+       SetFieldInfo(theInfo,eLECTURE_AJOUT,theErr);
+    }
+    
+    
+    TInt TVWrapper::GetNbTimeStamps(const MED::TFieldInfo& theInfo, 
+                                  const MED::TEntityInfo& theEntityInfo,
+                                  EEntiteMaillage& theEntity,
+                                  TGeom& theGeom,
+                                  TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+      
+      if(theErr){
+       *theErr &= !theEntityInfo.empty();
+       if(!*theErr)
+         return -1;
+      }
+      
+      if(theEntityInfo.empty()) 
+       EXCEPTION(runtime_error,"GetNbTimeStamps - There is no any Entity on the Mesh");
+      
+      theGeom.clear();
+      TInt aNbTimeStamps = 0;
+      MED::TFieldInfo& anInfo = const_cast<MED::TFieldInfo&>(theInfo);
+      TEntityInfo::const_iterator anIter = theEntityInfo.begin();
+      for(; anIter != theEntityInfo.end(); anIter++){
+       const med_entite_maillage& anEntity = static_cast<const med_entite_maillage>(anIter->first);
+       const TGeom& aTGeom = anIter->second;
+       TGeom::const_iterator anGeomIter = aTGeom.begin();
+       for(; anGeomIter != aTGeom.end(); anGeomIter++){
+         const med_geometrie_element& aGeom = static_cast<const med_geometrie_element>(anGeomIter->first);
+         aNbTimeStamps = MEDnPasdetemps(myFile->Id(),&anInfo.myName[0],anEntity,aGeom);
+         if(aNbTimeStamps){
+           theEntity = EEntiteMaillage(anEntity);
+           theGeom[EGeometrieElement(aGeom)] = anGeomIter->second;
+         }
+       }
+       if(aNbTimeStamps) 
+         break;
+      }
+      return aNbTimeStamps;
+    }
+    
+    
+    void TVWrapper::GetTimeStampInfo(TInt theTimeStampId, 
+                                   MED::TTimeStampInfo& theInfo,
+                                   TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+      
+      TGeom& aTGeom = theInfo.myGeom;
+      
+      if(theErr){
+       *theErr &= !aTGeom.empty();
+       if(!*theErr)
+         return;
+      }
+      
+      if(aTGeom.empty())
+       EXCEPTION(runtime_error,"GetTimeStampInfo - There is no any cell");
+      
+      MED::TFieldInfo& aFieldInfo = *theInfo.myFieldInfo;
+      MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo;
+      
+      med_entite_maillage& anEntity = static_cast<med_entite_maillage>(theInfo.myEntity);
+      
+      TGeom::iterator anIter = aTGeom.begin();
+      med_geometrie_element& aGeom = static_cast<med_geometrie_element>(anIter->first);
+
+      med_booleen& anIsLocal = static_cast<med_booleen>(aFieldInfo.myIsLocal);
+      
+      TErr aRet = MEDpasdetempsInfo(myFile->Id(),
+                                   &aFieldInfo.myName[0],
+                                   anEntity,
+                                   aGeom,
+                                   theTimeStampId,
+                                   &theInfo.myNbGauss,
+                                   &theInfo.myNumDt,
+                                   &theInfo.myNumOrd,
+                                   &theInfo.myUnitDt[0],
+                                   &theInfo.myDt,
+                                   &aMeshInfo.myName[0],
+                                   &anIsLocal,
+                                   &aFieldInfo.myNbRef);
+      if(theErr) 
+       *theErr = aRet;
+      else if(aRet < 0)
+       EXCEPTION(runtime_error,"GetTimeStampInfo - MEDpasdetempsInfo(...)");
+      
+      static TInt MAX_NB_GAUSS_POINTS = 32;
+      if(theInfo.myNbGauss > MAX_NB_GAUSS_POINTS) 
+       theInfo.myNbGauss = 1;
+    }
+    
+
+    void TVWrapper::GetTimeStampVal(MED::TTimeStampVal& theVal,
+                                  TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,eLECTURE,theErr);
+      
+      if(theErr && !*theErr)
+       return;
+      
+      TIdt anId = myFile->Id();
+      
+      MED::TTimeStampInfo& aTimeStampInfo = *theVal.myTimeStampInfo;
+      MED::TFieldInfo& aFieldInfo = *aTimeStampInfo.myFieldInfo;
+      MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo;
+      
+      med_entite_maillage& anEntity = static_cast<med_entite_maillage>(aTimeStampInfo.myEntity);
+      med_mode_profil& aPflMode = static_cast<med_mode_profil>(theVal.myPflMode);
+      TGeom& aTGeom = aTimeStampInfo.myGeom;
+      TGeom::iterator anIter = aTGeom.begin();
+      for(; anIter != aTGeom.end(); anIter++){
+       med_geometrie_element& aGeom = static_cast<med_geometrie_element>(anIter->first);
+       TInt aNbVal = MEDnVal(anId,
+                             &aFieldInfo.myName[0],
+                             anEntity,
+                             aGeom,
+                             aTimeStampInfo.myNumDt,
+                             aTimeStampInfo.myNumOrd,
+                             &aMeshInfo.myName[0],
+                             aPflMode);
+       if(aNbVal <= 0){
+         if(theErr){
+           *theErr = MED_FAUX;
+           return;
+         }
+         EXCEPTION(runtime_error,"GetTimeStampInfo - MEDnVal(...) - aNbVal == "<<aNbVal<<" <= 0");
+       }
+       
+       TValue& aValue = theVal.myMeshValue[EGeometrieElement(aGeom)];
+       TInt iEnd = aNbVal*aFieldInfo.myNbComp;
+       
+       if(iEnd != aValue.size()){
+         if(theErr){
+           *theErr = MED_FAUX;
+           return;
+         }
+         EXCEPTION(runtime_error,"GetTimeStampInfo - iEnd == "<<iEnd<<" != aValue.size() == "<<aValue.size());
+       }
+       
+       TErr aRet;
+       switch(aFieldInfo.myType){
+       case eFLOAT64: {
+         std::vector<TFloat> anArray(iEnd);
+         aRet = MEDchampLire(anId,
+                             &aMeshInfo.myName[0],
+                             &aFieldInfo.myName[0],
+                             (unsigned char*)&anArray[0],
+                             MED_FULL_INTERLACE,
+                             MED_ALL,
+                             &aTimeStampInfo.myGaussName[0],
+                             &theVal.myPflName[0],
+                             aPflMode,
+                             anEntity,
+                             aGeom,
+                             aTimeStampInfo.myNumDt,
+                             aTimeStampInfo.myNumOrd);
+         if(aRet >= 0) 
+           for(TInt i = 0; i < iEnd; i++) 
+             aValue[i] = anArray[i];
+         break;
+       }
+       default: {
+         std::vector<TInt> anArray(iEnd);
+         aRet = MEDchampLire(anId,
+                             &aMeshInfo.myName[0],
+                             &aFieldInfo.myName[0],
+                             (unsigned char*)&anArray[0],
+                             MED_FULL_INTERLACE,
+                             MED_ALL,
+                             &aTimeStampInfo.myGaussName[0],
+                             &theVal.myPflName[0],
+                             aPflMode,
+                             anEntity,
+                             aGeom,
+                             aTimeStampInfo.myNumDt,
+                             aTimeStampInfo.myNumOrd);
+         if(aRet >= 0) 
+           for(med_int i = 0; i < iEnd; i++) 
+             aValue[i] = anArray[i];
+         break;
+       }}
+       if(aRet < 0){
+         if(theErr){
+           *theErr = MED_FAUX;
+           return;
+         }
+         EXCEPTION(runtime_error,"GetValTimeStamp - MEDchampLire(...)");
+       }
+      }
+    }
+    
+    
+    void TVWrapper::SetTimeStamp(const MED::TTimeStampVal& theVal,
+                                EModeAcces theMode,
+                                TErr* theErr)
+    {
+      TFileWrapper aFileWrapper(myFile,theMode,theErr);
+      
+      if(theErr && !*theErr)
+       return;
+      
+      TErr aRet;
+      TIdt anId = myFile->Id();
+      
+      MED::TTimeStampVal& aVal = const_cast<MED::TTimeStampVal&>(theVal);
+      MED::TTimeStampInfo& aTimeStampInfo = *aVal.myTimeStampInfo;
+      MED::TFieldInfo& aFieldInfo = *aTimeStampInfo.myFieldInfo;
+      MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo;
+      MED::TMeshValue& aMeshValue = aVal.myMeshValue;
+      
+      med_entite_maillage& anEntity = static_cast<med_entite_maillage>(aTimeStampInfo.myEntity);
+      med_mode_profil& aPflMode = static_cast<med_mode_profil>(theVal.myPflMode);
+      TMeshValue::iterator anIter = aMeshValue.begin();
+      for(; anIter != aMeshValue.end(); anIter++){
+       med_geometrie_element& aGeom = static_cast<med_geometrie_element>(anIter->first);
+       TValue& aValue = aVal.myMeshValue[EGeometrieElement(aGeom)];
+       med_int iEnd = aValue.size();
+       med_int aNbVal = iEnd / aFieldInfo.myNbComp;
+       
+       switch(aFieldInfo.myType){
+       case eFLOAT64: {
+         std::vector<TFloat>& anArray = aValue;
+         
+         aRet = MEDchampEcr(anId,
+                            &aMeshInfo.myName[0],
+                            &aFieldInfo.myName[0],
+                            (unsigned char*)&anArray[0],
+                            MED_FULL_INTERLACE,
+                            aNbVal,
+                            &aTimeStampInfo.myGaussName[0],
+                            MED_ALL,
+                            &aVal.myPflName[0],
+                            aPflMode,
+                            anEntity,
+                            aGeom,
+                            aTimeStampInfo.myNumDt,
+                            &aTimeStampInfo.myUnitDt[0],
+                            aTimeStampInfo.myDt,
+                            aTimeStampInfo.myNumOrd);
+         break;
+       }
+       default: {
+         vector<TInt> anArray(iEnd);
+         for(TInt i = 0; i< iEnd; i++) anArray[i] = TInt(aValue[i]);
+         
+         aRet = MEDchampEcr(anId,
+                            &aMeshInfo.myName[0],
+                            &aFieldInfo.myName[0],
+                            (unsigned char*)&anArray[0],
+                            MED_FULL_INTERLACE,
+                            aNbVal,
+                            &aTimeStampInfo.myGaussName[0],
+                            MED_ALL,
+                            &aVal.myPflName[0],
+                            aPflMode,
+                            anEntity,
+                            aGeom,
+                            aTimeStampInfo.myNumDt,
+                            &aTimeStampInfo.myUnitDt[0],
+                            aTimeStampInfo.myDt,
+                            aTimeStampInfo.myNumOrd);
+         break;
+       }}
+       
+       if(aRet < 0){
+         if(theErr){
+           *theErr = MED_FAUX;
+           break;
+         }
+         EXCEPTION(runtime_error,"SetTimeStamp - MEDchampEcr(...)");
+       }
+       
+      }
+      
+      INITMSG(MYDEBUG,"TVWrapper::SetMeshInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<endl);
+    }
+
+    
+    void TVWrapper::SetTimeStamp(const MED::TTimeStampVal& theVal,
+                               TErr* theErr)
+    {
+      TErr aRet;
+      SetTimeStamp(theVal,eLECTURE_ECRITURE,&aRet);
+      
+      if(aRet < 0)
+       SetTimeStamp(theVal,eLECTURE_AJOUT,theErr);
+    }
+    
+  }
+}
diff --git a/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.hxx b/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.hxx
new file mode 100644 (file)
index 0000000..0d60ca7
--- /dev/null
@@ -0,0 +1,189 @@
+//  
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : 
+//  Author : 
+//  Module : 
+//  $Header$
+
+#ifndef MED_V2_2_Wrapper_HeaderFile
+#define MED_V2_2_Wrapper_HeaderFile
+
+#include "MED_Structures.hxx"
+#include "MED_TWrapper.hxx"
+
+namespace MED{
+  namespace V2_2{
+
+    const TInt PNOM = 16;
+
+    typedef MED::TTMeshInfo<PNOM,DESC,IDENT,NOM,LNOM> TVMeshInfo;
+
+    typedef MED::TTFamilyInfo<PNOM,DESC,IDENT,NOM,LNOM> TVFamilyInfo;
+
+    typedef MED::TTNodeInfo<PNOM,DESC,IDENT,NOM,LNOM> TVNodeInfo;
+
+    typedef MED::TTCellInfo<PNOM,DESC,IDENT,NOM,LNOM> TVCellInfo;
+
+    typedef MED::TTFieldInfo<PNOM,DESC,IDENT,NOM,LNOM> TVFieldInfo;
+
+    typedef MED::TTTimeStampInfo<PNOM,DESC,IDENT,NOM,LNOM> TVTimeStampInfo;
+
+    typedef MED::TTTimeStampVal<PNOM,DESC,IDENT,NOM,LNOM> TVTimeStampVal;
+
+    //---------------------------------------------------------------
+    class TFile;
+    typedef boost::shared_ptr<TFile> PFile;
+    
+    typedef enum {eLECTURE, eLECTURE_ECRITURE, eLECTURE_AJOUT, eCREATION} EModeAcces; 
+
+    //---------------------------------------------------------------
+    class TVWrapper: public MED::TTWrapper<PNOM,DESC,IDENT,NOM,LNOM>{
+      TVWrapper();
+      TVWrapper(const TVWrapper&);
+      TVWrapper& operator=(const TVWrapper&);
+      
+    public:
+      TVWrapper(const std::string& theFileName);
+
+      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      virtual TInt GetNbMeshes(TErr* theErr = NULL);
+      
+      virtual void GetMeshInfo(TInt theMeshId, MED::TMeshInfo&,
+                              TErr* theErr = NULL);
+
+      virtual void SetMeshInfo(const MED::TMeshInfo& theInfo,
+                              TErr* theErr = NULL);
+      
+      void SetMeshInfo(const MED::TMeshInfo& theInfo,
+                      EModeAcces theMode,
+                      TErr* theErr = NULL);
+
+      
+      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      virtual TInt GetNbFamilies(const MED::TMeshInfo& theMeshInfo,
+                                TErr* theErr = NULL);
+
+      virtual TInt GetNbFamAttr(TInt theFamId, 
+                               const MED::TMeshInfo& theInfo,
+                               TErr* theErr = NULL);
+
+      virtual TInt GetNbFamGroup(TInt theFamId, 
+                                const MED::TMeshInfo& theInfo,
+                                TErr* theErr = NULL);
+      
+      virtual void GetFamilyInfo(TInt theFamId, 
+                                MED::TFamilyInfo& theInfo,
+                                TErr* theErr = NULL);
+
+      virtual void SetFamilyInfo(const MED::TFamilyInfo& theInfo,
+                                TErr* theErr = NULL);
+      
+      void SetFamilyInfo(const MED::TFamilyInfo& theInfo,
+                        EModeAcces theMode,
+                        TErr* theErr = NULL);
+
+      
+      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      virtual TInt GetNbNodes(const MED::TMeshInfo& theMeshInfo,
+                             TErr* theErr = NULL);
+      
+      virtual void GetNodeInfo(MED::TNodeInfo& theInfo,
+                              TErr* theErr = NULL);
+
+      virtual void SetNodeInfo(const MED::TNodeInfo& theInfo,
+                              TErr* theErr = NULL);
+      
+      void SetNodeInfo(const MED::TNodeInfo& theInfo,
+                      EModeAcces theMode,
+                      TErr* theErr = NULL);
+
+      
+      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      virtual TEntityInfo GetEntityInfo(const MED::TMeshInfo& theMeshInfo,
+                                       EConnectivite theTConn = eNOD,
+                                       TErr* theErr = NULL);
+      
+      virtual TInt GetNbCells(const MED::TMeshInfo& theMeshInfo, 
+                             EEntiteMaillage, 
+                             EGeometrieElement, 
+                             EConnectivite theTConn = eNOD,
+                             TErr* theErr = NULL);
+      
+      virtual void GetCellInfo(MED::TCellInfo& theInfo,
+                              TErr* theErr = NULL);
+
+      virtual void SetCellInfo(const MED::TCellInfo& theInfo,
+                              TErr* theErr = NULL);
+      
+      void SetCellInfo(const MED::TCellInfo& theInfo,
+                      EModeAcces theMode,
+                      TErr* theErr = NULL);
+
+      
+      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      virtual TInt GetNbFields(TErr* theErr = NULL);
+      
+      virtual TInt GetNbComp(TInt theFieldId,
+                            TErr* theErr = NULL);
+      
+      virtual void GetFieldInfo(TInt theFieldId, 
+                               MED::TFieldInfo& theInfo,
+                               TErr* theErr = NULL);
+
+      virtual void SetFieldInfo(const MED::TFieldInfo& theInfo,
+                               TErr* theErr = NULL);
+      
+      void SetFieldInfo(const MED::TFieldInfo& theInfo,
+                       EModeAcces theMode,
+                       TErr* theErr = NULL);
+
+      
+      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      virtual TInt GetNbTimeStamps(const MED::TFieldInfo& theInfo, 
+                                  const MED::TEntityInfo& theEntityInfo,
+                                  EEntiteMaillage& theEntity,
+                                  TGeom& theGeom,
+                                  TErr* theErr = NULL);
+      
+      virtual void GetTimeStampInfo(TInt theTimeStampId, 
+                                   MED::TTimeStampInfo& theInfo,
+                                   TErr* theErr = NULL);
+
+      virtual void GetTimeStampVal(MED::TTimeStampVal& theVal,
+                                  TErr* theErr = NULL);
+      
+      virtual void SetTimeStamp(const MED::TTimeStampVal& theTimeStampVal,
+                               TErr* theErr = NULL);
+      
+      void SetTimeStamp(const MED::TTimeStampVal& theTimeStampVal,
+                       EModeAcces theMode,
+                       TErr* theErr = NULL);
+
+    protected:
+      PFile myFile;
+    };
+  }
+}
+
+#endif
diff --git a/src/MEDWrapper/V2_2/Makefile.in b/src/MEDWrapper/V2_2/Makefile.in
new file mode 100644 (file)
index 0000000..a1cf82e
--- /dev/null
@@ -0,0 +1,54 @@
+#  
+#
+#  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+#  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+# 
+#  This library is free software; you can redistribute it and/or 
+#  modify it under the terms of the GNU Lesser General Public 
+#  License as published by the Free Software Foundation; either 
+#  version 2.1 of the License. 
+# 
+#  This library is distributed in the hope that it will be useful, 
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+#  Lesser General Public License for more details. 
+# 
+#  You should have received a copy of the GNU Lesser General Public 
+#  License along with this library; if not, write to the Free Software 
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+# 
+#  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+#
+#
+#
+#  File   : 
+#  Author : 
+#  Module : 
+#  $Header$
+
+top_srcdir=@top_srcdir@
+top_builddir=../../..
+srcdir=@srcdir@
+VPATH=.:@srcdir@:@top_srcdir@/idl
+
+
+@COMMENCE@
+
+# Libraries targets
+
+LIB = libMEDWrapper_V2_2.la
+LIB_SRC = \
+       MED_V2_2_Wrapper.cxx
+
+EXPORT_HEADERS = \
+       MED_V2_2_Wrapper.hxx
+
+# Executables targets
+BIN =
+BIN_SRC = 
+
+CPPFLAGS+= $(BOOST_CPPFLAGS) $(MED2_INCLUDES)
+
+LDFLAGS+= $(MED2_LIBS) $(HDF5_LIBS) -lMEDWrapperBase
+
+@CONCLUDE@
index 44d642b86fe0f7dba6b0f832051b6979f0080b2f..5d6d5bf514785a3bee222e2b144228d58c57b68a 100644 (file)
                 throw SALOME::SALOME_Exception(ExDescription); \
               }
 
-#include <iostream>
+#include <ostream.h>
+
 //Dump the CORBA exception type.
-static std::ostream& operator<<(std::ostream& os, const CORBA::Exception& e)
+inline std::ostream& operator<<(std::ostream& os, const CORBA::Exception& e)
 {
   CORBA::Any tmp;
   tmp<<= e;
@@ -63,4 +64,5 @@ static std::ostream& operator<<(std::ostream& os, const CORBA::Exception& e)
   
   return os;
 }
+
 #endif