0021803: EDF 2351 : Available versions of MED in TUI function ExportMED aren't consistent with GUI behavior

CMakeLists.txt

@@ -296,7 +296,7 @@ INCLUDE(CMakePackageConfigHelpers)
 # They all have to be INSTALL'd with the option "EXPORT ${PROJECT_NAME}TargetGroup"
 SET(_${PROJECT_NAME}_exposed_targets 
   SMESHControls MeshDriver MeshDriverDAT MeshDriverGMF MeshDriverMED
-  MeshDriverSTL MeshDriverUNV MEDWrapperBase MEDWrapper MEDWrapper_V2_2
+  MeshDriverSTL MeshDriverUNV MEDWrapper
   SMDS SMESHimpl SMESHEngine SMESHClient SMESHDS
   SMESHUtils StdMeshers StdMeshersEngine MeshJobManagerEngine
   SPADDERPluginTesterEngine SalomeIDLSMESH SalomeIDLSPADDER

SalomeSMESHConfig.cmake.in

@@ -138,9 +138,7 @@ SET(SMESH_MeshDriverGMF MeshDriverGMF)
 SET(SMESH_MeshDriverMED MeshDriverMED)
 SET(SMESH_MeshDriverSTL MeshDriverSTL)
 SET(SMESH_MeshDriverUNV MeshDriverUNV)
-SET(SMESH_MEDWrapperBase MEDWrapperBase)
 SET(SMESH_MEDWrapper MEDWrapper)
-SET(SMESH_MEDWrapper_V2_2 MEDWrapper_V2_2)
 IF(SALOME_SMESH_ENABLE_MEFISTO)
   SET(SMESH_MEFISTO2D MEFISTO2D)
 ENDIF(SALOME_SMESH_ENABLE_MEFISTO)

idl/SMESH_Gen.idl

@@ -411,10 +411,20 @@ module SMESH
      */
     long GetObjectId(in Object theObject);
 
+    /*!
+     * \brief Get version of MED format being used.
+     */
+    string GetMEDFileVersion();
+
     /*!
      * \brief Get MED version of the file by its name.
      */
-    boolean GetMEDVersion(in string theFileName, out MED_VERSION theVersion);
+    string GetMEDVersion(in string theFileName);
+
+    /*!
+     * \brief Check compatibility of file with MED format being used.
+     */
+    boolean CheckCompatibility(in string theFileName);
 
     /*!
      * \brief Get names of meshes defined in file with the specified name.

idl/SMESH_Mesh.idl

@@ -235,15 +235,6 @@ module SMESH
     DRS_FAIL            // general failure (exception etc.)
   };
 
-  /*!
-   * Enumeration for ExportToMED*()
-   */
-  enum MED_VERSION
-  {
-    MED_V2_1,
-    MED_V2_2
-  };
-
   /*! 
    * \brief A structure containing information about MED file
    */
@@ -623,13 +614,12 @@ module SMESH
     boolean HasDuplicatedGroupNamesMED();
 
     /*!
-     * Export Mesh to a MED Format file
+     * Export a Mesh to MED file.
      * @params
-     * - file : name of the MED file
+     * - fileName : name of the MED file
      * - auto_groups : boolean parameter for creating/not creating
      *                 the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
      *                 the typical use is auto_groups=false.
-     * - version : defines the version of format of MED file, that will be created
      * - overwrite : boolean parameter for overwriting/not overwriting the file, if it exists
      * - autoDimension : if @c true, a space dimension of a MED mesh can be either
      *         - 1D if all mesh nodes lie on OX coordinate axis, or
@@ -637,18 +627,16 @@ module SMESH
      *         - 3D in the rest cases.
      *         If @a autoDimension is @c false, the space dimension is always 3.
      */
-    void ExportToMEDX( in string      file, 
+    void ExportMED( in string      fileName, 
-                       in boolean     auto_groups, 
+		    in boolean     auto_groups, 
-                       in MED_VERSION version, 
+		    in boolean     overwrite,
-                       in boolean     overwrite,
+		    in boolean     autoDimension) raises (SALOME::SALOME_Exception);
-                       in boolean     autoDimension) raises (SALOME::SALOME_Exception);
 
     /*!
      * Export a [part of] Mesh into a MED file
      * @params
      * - meshPart : a part of mesh to store
-     * - file : name of the MED file
+     * - fileName : name of the MED file
-     * - version : define the version of format of MED file, that will be created
      * - overwrite : boolean parameter for overwriting/not overwriting the file, if it exists
      * - autoDimension : if @c True, a space dimension for export is defined by mesh 
      *                 configuration; for example a planar mesh lying on XOY plane
@@ -663,31 +651,13 @@ module SMESH
      *         - 's' stands for _solids_ field.
      */
     void ExportPartToMED( in SMESH_IDSource     meshPart,
-                          in string             file,
+                          in string             fileName,
                           in boolean            auto_groups,
-                          in MED_VERSION        version,
                           in boolean            overwrite,
                           in boolean            autoDimension,
                           in GEOM::ListOfFields fields,
                           in string             geomAssocFields ) raises (SALOME::SALOME_Exception);
 
-    /*!
-     * Export Mesh to a MED Format file
-     * Works, just the same as ExportToMEDX, with overwrite parameter equal to true.
-     * The method is kept in order to support old functionality
-     */
-    void ExportToMED( in string file, in boolean auto_groups, in MED_VERSION theVersion )
-      raises (SALOME::SALOME_Exception);
-
-    /*!
-     * Export Mesh to MED_V2_1 MED format
-     * Works, just the same as ExportToMEDX with MED_VERSION parameter equal to MED_V2_1
-     * and overwrite parameter equal to true
-     * The method is kept in order to support old functionality
-     */
-    void ExportMED( in string file, in boolean auto_groups )
-      raises (SALOME::SALOME_Exception);
-
     /*!
      * Export Mesh to SAUV formatted file
      * Write a temporary med file and use med2sauv
@@ -695,11 +665,6 @@ module SMESH
     void ExportSAUV( in string file, in boolean auto_groups )
       raises (SALOME::SALOME_Exception);
 
-    /*!
-     * Return string representation of a MED file version comprising nbDigits
-     */
-    string GetVersionString(in MED_VERSION version, in short nbDigits);
-
     /*!
      * Export Mesh to different Formats
      * (UNV supported version is I-DEAS 10)

src/DriverMED/CMakeLists.txt

@@ -25,8 +25,7 @@ INCLUDE_DIRECTORIES(
   ${CAS_INCLUDE_DIRS}
   ${VTK_INCLUDE_DIRS}
   ${Boost_INCLUDE_DIRS}
-  ${PROJECT_SOURCE_DIR}/src/MEDWrapper/Base
+  ${PROJECT_SOURCE_DIR}/src/MEDWrapper
-  ${PROJECT_SOURCE_DIR}/src/MEDWrapper/Factory
   ${PROJECT_SOURCE_DIR}/src/Driver
   ${PROJECT_SOURCE_DIR}/src/SMDS
   ${PROJECT_SOURCE_DIR}/src/SMESHUtils
@@ -45,8 +44,6 @@ SET(_link_LIBRARIES
   ${Boost_LIBRARIES}
   MeshDriver
   MEDWrapper
-  MEDWrapperBase
-  MEDWrapper_V2_2
 )
 
 SET(_link_LIBRARIES_bin

src/DriverMED/DriverMED_Family.cxx

@@ -383,11 +383,7 @@ DriverMED_Family::GetFamilyInfo(const MED::PWrapper& theWrapper,
   }
   string aValue = aStr.str();
   // PAL19785,0019867 - med forbids whitespace to be the last char in the name
-  int maxSize;
+  int maxSize = MED::GetNOMLength();
-  //if ( theWrapper->GetVersion() == MED::eV2_1 )
-  //  maxSize = MED::GetNOMLength<MED::eV2_1>();
-  //else
-    maxSize = MED::GetNOMLength<MED::eV2_2>();
   int lastCharPos = min( maxSize, (int) aValue.size() ) - 1;
   while ( isspace( aValue[ lastCharPos ] ))
     aValue.resize( lastCharPos-- );

src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx

@@ -110,7 +110,7 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
 #endif
     myFamilies.clear();
     if(MYDEBUG) MESSAGE("Perform - myFile : "<<myFile);
-    PWrapper aMed = CrWrapper(myFile,true);
+    PWrapper aMed = CrWrapperR(myFile);
 
     aResult = DRS_EMPTY;
     TInt aNbMeshes = aMed->GetNbMeshes();
@@ -1022,7 +1022,7 @@ list<string> DriverMED_R_SMESHDS_Mesh::GetMeshNames(Status& theStatus)
   try {
     if(MYDEBUG) MESSAGE("GetMeshNames - myFile : " << myFile);
     theStatus = DRS_OK;
-    PWrapper aMed = CrWrapper(myFile);
+    PWrapper aMed = CrWrapperR(myFile);
 
     if (TInt aNbMeshes = aMed->GetNbMeshes()) {
       for (int iMesh = 0; iMesh < aNbMeshes; iMesh++) {

src/DriverMED/DriverMED_W_Field.cxx

@@ -254,7 +254,7 @@ Driver_Mesh::Status DriverMED_W_Field::Perform()
   if ( !myMesh )
     return addMessage("Supporting mesh not set", /*isFatal=*/true );
 
-  MED::PWrapper medFile = MED::CrWrapper( myFile, MED::eV2_2 );
+  MED::PWrapper medFile = MED::CrWrapperW( myFile );
   MED::PMeshInfo meshInfo;
   if ( myMeshId > 0 )
   {

src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx

@@ -52,7 +52,6 @@ using namespace MED;
 
 
 DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
-  myMedVersion(MED::eV2_2),
   myAllSubMeshes (false),
   myDoGroupOfNodes (false),
   myDoGroupOfEdges (false),
@@ -65,36 +64,11 @@ DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
   myDoAllInGroups(false)
 {}
 
-void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName, 
-                                       MED::EVersion      theId)
-{
-  Driver_SMESHDS_Mesh::SetFile(theFileName);
-  myMedVersion = theId;
-}
-
 void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName)
 {
   Driver_SMESHDS_Mesh::SetFile(theFileName);
 }
 
-string DriverMED_W_SMESHDS_Mesh::GetVersionString(const MED::EVersion theVersion, int theNbDigits)
-{
-  TInt majeur, mineur, release;
-  majeur =  mineur = release = 0;
-//   if ( theVersion == eV2_1 )
-//     MED::GetVersionRelease<eV2_1>(majeur, mineur, release);
-//   else
-    MED::GetVersionRelease<eV2_2>(majeur, mineur, release);
-  ostringstream name;
-  if ( theNbDigits > 0 )
-    name << majeur;
-  if ( theNbDigits > 1 )
-    name << "." << mineur;
-  if ( theNbDigits > 2 )
-    name << "." << release;
-  return name.str();
-}
-
 void DriverMED_W_SMESHDS_Mesh::AddGroup(SMESHDS_GroupBase* theGroup)
 {
   myGroups.push_back(theGroup);
@@ -457,7 +431,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
       }
     }
 
-    MED::PWrapper myMed = CrWrapper(myFile,myMedVersion);
+    MED::PWrapper myMed = CrWrapperW(myFile);
     PMeshInfo aMeshInfo = myMed->CrMeshInfo(aMeshDimension,aSpaceDimension,aMeshName);
     //MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
     myMed->SetMeshInfo(aMeshInfo);

src/DriverMED/DriverMED_W_SMESHDS_Mesh.h

@@ -47,12 +47,9 @@ class MESHDRIVERMED_EXPORT DriverMED_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
 
   DriverMED_W_SMESHDS_Mesh();
 
-  virtual void SetFile(const std::string& theFileName);
+  void SetFile(const std::string& theFileName);
-  void SetFile(const std::string& theFileName, MED::EVersion theId);
   void SetAutoDimension(bool toFindOutDimension) { myAutoDimension = toFindOutDimension; }
 
-  static std::string GetVersionString(const MED::EVersion theVersion, int theNbDigits=2);
-
   void AddGroupOfNodes();
   void AddGroupOfEdges();
   void AddGroupOfFaces();
@@ -77,7 +74,6 @@ class MESHDRIVERMED_EXPORT DriverMED_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
 
  private:
 
-  MED::EVersion myMedVersion;
   std::list<SMESHDS_GroupBase*> myGroups;
   bool myAllSubMeshes;
   std::vector<SMESHDS_SubMesh*> mySubMeshes;

src/MEDWrapper/Base/CMakeLists.txt

@@ -1,78 +0,0 @@
-# Copyright (C) 2012-2016  CEA/DEN, EDF R&D, OPEN CASCADE
-#
-# 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
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
-# --- options ---
-# additional include directories
-INCLUDE_DIRECTORIES(
-  ${HDF5_INCLUDE_DIRS}
-  ${Boost_INCLUDE_DIRS}
-  ${KERNEL_INCLUDE_DIRS}
-  ${MEDFILE_INCLUDE_DIRS}
-)
-
-# additional preprocessor / compiler flags
-ADD_DEFINITIONS(
-  ${HDF5_DEFINITIONS}
-  ${BOOST_DEFINITIONS}
-)
-
-SET(_link_LIBRARIES
-  ${Boost_LIBRARIES}
-)
-
-# --- headers ---
-
-# header files / no moc processing
-SET(MEDWrapperBase_HEADERS
-  MED_Common.hxx
-  MED_Vector.hxx
-  MED_SharedPtr.hxx
-  MED_SliceArray.hxx
-  MED_Wrapper.hxx
-  MED_TWrapper.hxx
-  MED_Structures.hxx
-  MED_TStructures.hxx
-  MED_Algorithm.hxx
-  MED_GaussUtils.hxx
-  MED_CoordUtils.hxx
-  MED_Utilities.hxx
-  MED_GaussDef.hxx
-  MED_WrapperBase.hxx
-)
-
-# --- sources ---
-
-# sources / static
-SET(MEDWrapperBase_SOURCES
-  MED_Structures.cxx
-  MED_Wrapper.cxx
-  MED_Algorithm.cxx
-  MED_GaussUtils.cxx
-  MED_CoordUtils.cxx
-  MED_Utilities.cxx
-  MED_GaussDef.cxx
-)
-
-# --- rules ---
- 
-ADD_LIBRARY(MEDWrapperBase ${MEDWrapperBase_SOURCES})
-TARGET_LINK_LIBRARIES(MEDWrapperBase ${_link_LIBRARIES})
-INSTALL(TARGETS MEDWrapperBase EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
-
-INSTALL(FILES ${MEDWrapperBase_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})

src/MEDWrapper/Base/MED_Structures.cxx

@@ -1,865 +0,0 @@
-// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
-//
-// Copyright (C) 2003-2007  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, 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
-//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
-//  File   : MED_Structure.cxx
-//  Author : Eugeny NIKOLAEV
-//
-#include "MED_Structures.hxx"
-#include "MED_Utilities.hxx"
-
-#include <cstring>
-
-using namespace MED;
-
-namespace MED
-{
-  TInt
-  GetNbNodes(EGeometrieElement typmai)
-  {
-    return typmai%100;
-  }
-
-  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);
-  }
-
-  void 
-  SetString(TInt theId, 
-            TInt theStep, 
-            TString& theString, 
-            const std::string& theValue)
-  {
-    TInt aSize = std::min(TInt(theValue.size()+1),theStep);
-    char* aPos = &theString[theId*theStep];
-    strncpy(aPos,theValue.c_str(),aSize);
-  }
-
-  void 
-  SetString(TInt theId, 
-            TInt theStep, 
-            TString& theString, 
-            const TString& theValue)
-  {
-    TInt aSize = std::min(TInt(theValue.size()+1),theStep);
-    char* aPos = &theString[theId*theStep];
-    const char* aValue = &theValue[0];
-    strncpy(aPos,aValue,aSize);
-  }
-
-  TInt
-  GetDimGaussCoord(EGeometrieElement theGeom)
-  {
-    return theGeom/100;
-  }
-
-  TInt
-  GetNbRefCoord(EGeometrieElement theGeom)
-  {
-    return (theGeom%100);
-  }
-
-  //---------------------------------------------------------------
-  PFloatTimeStampValue
-  CastToFloatTimeStampValue(const PTimeStampValueBase& theTimeStampValue)
-  {
-    return theTimeStampValue;
-  }
-
-  PIntTimeStampValue
-  CastToIntTimeStampValue(const PTimeStampValueBase& theTimeStampValue)
-  {
-    return theTimeStampValue;
-  }
-}
-
-//---------------------------------------------------------------
-TInt
-TFamilyInfo
-::GetAttrId(TInt theId) const 
-{
-  return myAttrId[theId];
-}
-
-TInt
-TFamilyInfo
-::GetAttrVal(TInt theId) const 
-{
-  return myAttrVal[theId];
-}
-
-void
-TFamilyInfo
-::SetAttrId(TInt theId,TInt theVal) 
-{
-  myAttrId[theId] = theVal;
-}
-
-void
-TFamilyInfo
-::SetAttrVal(TInt theId,TInt theVal) 
-{
-  myAttrVal[theId] = theVal;
-}
-
-//---------------------------------------------------------------
-TInt
-TElemInfo
-::GetFamNum(TInt theId) const 
-{
-  return (*myFamNum)[theId];
-}
-
-void
-TElemInfo
-::SetFamNum(TInt theId, TInt theVal) 
-{
-  (*myFamNum)[theId] = theVal;
-  myIsFamNum = eVRAI;
-}
-
-TInt
-TElemInfo
-::GetElemNum(TInt theId) const 
-{
-  return (*myElemNum)[theId];
-}
-
-void
-TElemInfo
-::SetElemNum(TInt theId, TInt theVal) 
-{
-  (*myElemNum)[theId] = theVal;
-}
-
-//---------------------------------------------------------------
-TCCoordSlice 
-TNodeInfo
-::GetCoordSlice(TInt theId) const
-{
-  TInt aDim = myMeshInfo->GetSpaceDim();
-  if(GetModeSwitch() == eFULL_INTERLACE)
-    return TCCoordSlice(*myCoord, std::slice(theId*aDim, aDim, 1));
-  else
-    return TCCoordSlice(*myCoord, std::slice(theId, aDim, aDim));
-}
-
-TCoordSlice 
-TNodeInfo
-::GetCoordSlice(TInt theId)
-{
-  TInt aDim = myMeshInfo->GetSpaceDim();
-  if(GetModeSwitch() == eFULL_INTERLACE)
-    return TCoordSlice(*myCoord, std::slice(theId*aDim,aDim,1));
-  else
-    return TCoordSlice(*myCoord, std::slice(theId,aDim,aDim));
-}
-
-//---------------------------------------------------------------
-TCConnSlice 
-TCellInfo
-::GetConnSlice(TInt theElemId) const
-{
-  if(GetModeSwitch() == eFULL_INTERLACE)
-    return TCConnSlice(*myConn, std::slice(GetConnDim()*theElemId, GetNbNodes(myGeom), 1));
-  else
-    return TCConnSlice(*myConn, std::slice(theElemId, GetNbNodes(myGeom), GetConnDim()));
-}
-
-TConnSlice 
-TCellInfo
-::GetConnSlice(TInt theElemId)
-{
-  if(GetModeSwitch() == eFULL_INTERLACE)
-    return TConnSlice(*myConn, std::slice(GetConnDim()*theElemId, GetNbNodes(myGeom), 1));
-  else
-    return TConnSlice(*myConn, std::slice(theElemId, GetNbNodes(myGeom), GetConnDim()));
-}
-
-
-//---------------------------------------------------------------
-TInt
-TPolygoneInfo
-::GetNbConn(TInt theElemId) const 
-{
-  return (*myIndex)[theElemId + 1] - (*myIndex)[theElemId];
-}
-
-TCConnSlice 
-TPolygoneInfo
-::GetConnSlice(TInt theElemId) const
-{
-  return TCConnSlice(*myConn, std::slice((*myIndex)[theElemId] - 1, GetNbConn(theElemId), 1));
-}
-
-TConnSlice 
-TPolygoneInfo
-::GetConnSlice(TInt theElemId)
-{
-  return TConnSlice(*myConn, std::slice((*myIndex)[theElemId] - 1, GetNbConn(theElemId), 1));
-}
-
-
-//---------------------------------------------------------------
-TInt 
-TPolyedreInfo
-::GetNbFaces(TInt theElemId) const 
-{
-  return (*myIndex)[theElemId+1] - (*myIndex)[theElemId];
-}
-
-TInt 
-TPolyedreInfo
-::GetNbNodes(TInt theElemId) const 
-{
-  TInt aNbNodes = 0;
-  TInt aNbFaces = GetNbFaces(theElemId);
-  TInt aStartFaceId = (*myIndex)[theElemId] - 1;
-  for(TInt aFaceId = 0; aFaceId < aNbFaces; aFaceId++, aStartFaceId++){
-    TInt aCurrentId = (*myFaces)[aStartFaceId];
-    TInt aDiff = (*myFaces)[aStartFaceId + 1] - aCurrentId;
-    aNbNodes += aDiff;
-  }
-  return aNbNodes;
-}
-
-TCConnSliceArr 
-TPolyedreInfo
-::GetConnSliceArr(TInt theElemId) const
-{
-  TInt aNbFaces = GetNbFaces(theElemId);
-  TCConnSliceArr aConnSliceArr(aNbFaces);
-  TInt aStartFaceId = (*myIndex)[theElemId] - 1;
-  for(TInt aFaceId = 0; aFaceId < aNbFaces; aFaceId++, aStartFaceId++){
-    TInt aCurrentId = (*myFaces)[aStartFaceId];
-    TInt aDiff = (*myFaces)[aStartFaceId + 1] - aCurrentId;
-    aConnSliceArr[aFaceId] =
-      TCConnSlice(*myConn, std::slice(aCurrentId - 1, aDiff, 1));
-  }
-  return aConnSliceArr;
-}
-
-TConnSliceArr 
-TPolyedreInfo
-::GetConnSliceArr(TInt theElemId)
-{
-  TInt aNbFaces = GetNbFaces(theElemId);
-  TConnSliceArr aConnSliceArr(aNbFaces);
-  TInt aStartFaceId = (*myIndex)[theElemId] - 1;
-  for(TInt aFaceId = 0; aFaceId < aNbFaces; aFaceId++, aStartFaceId++){
-    TInt aCurrentId = (*myFaces)[aStartFaceId];
-    TInt aDiff = (*myFaces)[aStartFaceId + 1] - aCurrentId;
-    aConnSliceArr[aFaceId] =
-      TConnSlice(*myConn, std::slice(aCurrentId - 1, aDiff, 1));
-  }
-  return aConnSliceArr;
-}
-
-
-//---------------------------------------------------------------
-TMeshValueBase
-::TMeshValueBase():
-  myNbElem(0),
-  myNbComp(0),
-  myNbGauss(0),
-  myStep(0)
-{}
-
-void
-TMeshValueBase
-::Allocate(TInt theNbElem,
-           TInt theNbGauss,
-           TInt theNbComp,
-           EModeSwitch theMode)
-{
-  myModeSwitch = theMode;
-  
-  myNbElem = theNbElem;
-  myNbGauss = theNbGauss;
-  myNbComp = theNbComp;
-  
-  myStep = theNbComp*theNbGauss;
-}
-
-size_t
-TMeshValueBase
-::GetSize() const
-{
-  return myNbElem * myStep;
-}
-    
-size_t
-TMeshValueBase
-::GetNbVal() const
-{
-  return myNbElem * myNbGauss;
-}
-
-size_t
-TMeshValueBase
-::GetNbGauss() const
-{
-  return myNbGauss;
-}
-
-size_t
-TMeshValueBase
-::GetStep() const
-{
-  return myStep;
-}
-
-
-//---------------------------------------------------------------
-TInt
-TProfileInfo
-::GetElemNum(TInt theId) const 
-{
-  return (*myElemNum)[theId];
-}
-
-void
-TProfileInfo
-::SetElemNum(TInt theId,TInt theVal) 
-{
-  (*myElemNum)[theId] = theVal;
-}
-
-//---------------------------------------------------------------
-bool
-TGaussInfo::TLess
-::operator()(const TKey& theLeft, const TKey& theRight) const
-{
-  EGeometrieElement aLGeom = boost::get<0>(theLeft);
-  EGeometrieElement aRGeom = boost::get<0>(theRight);
-  if(aLGeom != aRGeom)
-    return aLGeom < aRGeom;
-
-  const std::string& aLStr = boost::get<1>(theLeft);
-  const std::string& aRStr = boost::get<1>(theRight);
-  return aLStr < aRStr;
-}
-
-bool
-TGaussInfo::TLess
-::operator()(const TGaussInfo& theLeft, const TGaussInfo& theRight) const
-{
-  if(!&theLeft)
-    return true;
-
-  if(!&theRight)
-    return false;
-
-  if(theLeft.myGeom != theRight.myGeom)
-    return theLeft.myGeom < theRight.myGeom;
-
-  if(theLeft.myRefCoord != theRight.myRefCoord)
-    return theLeft.myRefCoord < theRight.myRefCoord;
-
-  return theLeft.myGaussCoord < theRight.myGaussCoord;
-}
-
-TCCoordSlice 
-TGaussInfo
-::GetRefCoordSlice(TInt theId) const
-{
-  if(GetModeSwitch() == eFULL_INTERLACE)
-    return TCCoordSlice(myRefCoord,std::slice(theId*GetDim(),GetDim(),1));
-  else
-    return TCCoordSlice(myRefCoord,std::slice(theId,GetDim(),GetDim()));
-}
-
-TCoordSlice 
-TGaussInfo
-::GetRefCoordSlice(TInt theId)
-{
-  if(GetModeSwitch() == eFULL_INTERLACE)
-    return TCoordSlice(myRefCoord,std::slice(theId*GetDim(),GetDim(),1));
-  else
-    return TCoordSlice(myRefCoord,std::slice(theId,GetDim(),GetDim()));
-}
-
-TCCoordSlice 
-TGaussInfo
-::GetGaussCoordSlice(TInt theId) const
-{
-  if(GetModeSwitch() == eFULL_INTERLACE)
-    return TCCoordSlice(myGaussCoord,std::slice(theId*GetDim(),GetDim(),1));
-  else
-    return TCCoordSlice(myGaussCoord,std::slice(theId,GetDim(),GetDim()));
-}
-
-TCoordSlice 
-TGaussInfo
-::GetGaussCoordSlice(TInt theId)
-{
-  if(GetModeSwitch() == eFULL_INTERLACE)
-    return TCoordSlice(myGaussCoord,std::slice(theId*GetDim(),GetNbGauss(),1));
-  else
-    return TCoordSlice(myGaussCoord,std::slice(theId,GetNbGauss(),GetDim()));
-}
-
-
-//---------------------------------------------------------------
-TInt
-TTimeStampInfo
-::GetNbGauss(EGeometrieElement theGeom) const
-{
-  TGeom2NbGauss::const_iterator anIter = myGeom2NbGauss.find(theGeom);
-  if(anIter == myGeom2NbGauss.end())
-    return 1;//EXCEPTION(runtime_error,"TTimeStampInfo::GetNbGauss - myGeom2NbGauss.find(theGeom) fails");
-
-  return anIter->second;
-}
-
-
-//---------------------------------------------------------------
-// TGrilleInfo structure methods
-//---------------------------------------------------------------
-const EGrilleType&
-TGrilleInfo
-::GetGrilleType() const
-{
-  return myGrilleType;
-}
-
-EGrilleType
-TGrilleInfo
-::GetGrilleType()
-{
-  return myGrilleType;
-}
-
-void
-TGrilleInfo
-::SetGrilleType(EGrilleType theGrilleType)
-{
-  myGrilleType = theGrilleType;
-}
-
-const
-TIndexes&
-TGrilleInfo
-::GetMapOfIndexes() const
-{
-  return myIndixes;
-}
-
-TIndexes&
-TGrilleInfo
-::GetMapOfIndexes()
-{
-  return myIndixes;
-}
-
-const
-TFloatVector&
-TGrilleInfo
-::GetIndexes(TInt theAxisNumber) const
-{
-  TIndexes::const_iterator aIter=myIndixes.find(theAxisNumber);
-  if(aIter==myIndixes.end())
-    EXCEPTION(std::runtime_error, "const TGrilleInfo::GetIndexes - myIndixes.find(theAxisNumber); fails");
-  return aIter->second;
-}
-
-TFloatVector&
-TGrilleInfo
-::GetIndexes(TInt theAxisNumber)
-{
-  TIndexes::iterator aIter=myIndixes.find(theAxisNumber);
-  if(aIter==myIndixes.end())
-    EXCEPTION(std::runtime_error, "TGrilleInfo::GetIndexes - myIndixes.find(theAxisNumber="<<theAxisNumber<<"); fails");
-  return aIter->second;
-}
-
-TInt
-TGrilleInfo
-::GetNbIndexes(TInt theAxisNumber)
-{
-  const TFloatVector& aVector=GetIndexes(theAxisNumber);
-  return aVector.size();
-}
-
-TInt
-TGrilleInfo
-::GetNbNodes()
-{
-  TInt nbNodes=0;
-  TInt aDim = myMeshInfo->GetDim();
-  for(int i=0;i<aDim;i++)
-    if(nbNodes == 0)
-      nbNodes = this->GetGrilleStructure()[i];
-    else
-      nbNodes = nbNodes*this->GetGrilleStructure()[i];
- 
-  return nbNodes;
-}
-
-TInt
-TGrilleInfo
-::GetNbCells()
-{
-  TInt nbCells=0;
-  TInt aDim = myMeshInfo->GetDim();
-  for(int i=0;i<aDim;i++)
-    if(nbCells == 0)
-      nbCells = this->GetGrilleStructure()[i]-1;
-    else
-      nbCells = nbCells*(this->GetGrilleStructure()[i]-1);
-  return nbCells;
-}
-
-TInt
-TGrilleInfo
-::GetNbSubCells()
-{
-  TInt nb=0;
-  TInt aDim = myMeshInfo->GetDim();
-  switch (aDim) {
-  case 3:
-    nb =
-      (myGrilleStructure[0]  ) * (myGrilleStructure[1]-1) * (myGrilleStructure[2]-1) +
-      (myGrilleStructure[0]-1) * (myGrilleStructure[1]  ) * (myGrilleStructure[2]-1) +
-      (myGrilleStructure[0]-1) * (myGrilleStructure[1]-1) * (myGrilleStructure[2]  );
-    break;
-  case 2:
-    nb =
-      (myGrilleStructure[0]  ) * (myGrilleStructure[1]-1) +
-      (myGrilleStructure[0]-1) * (myGrilleStructure[1]  );
-    break;
-  }
-  return nb;
-}
-
-EGeometrieElement
-TGrilleInfo
-::GetGeom()
-{
-  TInt aDim = myMeshInfo->GetDim();
-  switch(aDim){
-  case 1:
-    return eSEG2;
-  case 2:
-    return eQUAD4;
-  case 3:
-    return eHEXA8;
-  default:
-    return eNONE;
-  }
-}
-
-EGeometrieElement
-TGrilleInfo
-::GetSubGeom()
-{
-  TInt aDim = myMeshInfo->GetDim();
-  switch(aDim){
-  case 2:
-    return eSEG2;
-  case 3:
-    return eQUAD4;
-  }
-  return eNONE;
-}
-
-EEntiteMaillage
-TGrilleInfo
-::GetEntity()
-{
-  return eMAILLE;
-}
-
-EEntiteMaillage
-TGrilleInfo
-::GetSubEntity()
-{
-  TInt aDim = myMeshInfo->GetDim();
-  switch(aDim){
-  case 2:
-    return eARETE;
-  case 3:
-    return eFACE;
-  }
-  return EEntiteMaillage(-1);
-}
-
-const
-TIntVector&
-TGrilleInfo
-::GetGrilleStructure() const
-{
-  return myGrilleStructure;
-}
-
-TIntVector
-TGrilleInfo
-::GetGrilleStructure()
-{
-  return myGrilleStructure;
-}
-
-void
-TGrilleInfo
-::SetGrilleStructure(TInt theAxis,TInt theNb)
-{
-  if(theAxis >= 0 && theAxis <=2 && theNb >= 0)
-  myGrilleStructure[theAxis]=theNb;
-}
-
-const
-TNodeCoord&
-TGrilleInfo
-::GetNodeCoord() const
-{
-  return myCoord;
-}
-
-TNodeCoord&
-TGrilleInfo
-::GetNodeCoord()
-{
-  return myCoord;
-}
-
-TNodeCoord
-TGrilleInfo
-::GetCoord(TInt theId)
-{
-  TNodeCoord aCoord;
-  TInt aDim       = myMeshInfo->GetDim();
-  TInt aNbNodes   = this->GetNbNodes();
-  aCoord.resize(aDim);
-  
-  if(theId >= aNbNodes)
-    EXCEPTION(std::runtime_error, "TGrilleInfo::GetCoord - theId out of range");
-
-  if(myGrilleType == eGRILLE_STANDARD){
-    switch(aDim){
-    case 3:
-      aCoord[2] = myCoord[aDim*theId+2];
-    case 2:
-      aCoord[1] = myCoord[aDim*theId+1];
-    case 1:{
-      aCoord[0] = myCoord[aDim*theId];
-      break;
-    }
-    }
-  } else {
-
-    TFloatVector aVecX  = this->GetIndexes(0);
-    TInt nbIndxX        = this->GetNbIndexes(0);
-    
-    switch(aDim){
-    case 1:{
-      aCoord[0] = aVecX[theId];
-      break;
-    }
-    case 2:{
-      TFloatVector aVecY = this->GetIndexes(1);
-      TInt i,j,k;
-      i = j = k = 0;
-      i = theId % nbIndxX;
-      j = theId / nbIndxX;
-      if(myGrilleType == eGRILLE_CARTESIENNE){
-        aCoord[0] = aVecX[i];
-        aCoord[1] = aVecY[j];
-      } else { // eGRILLE_POLAIRE (cylindrical)
-        aCoord[0] = aVecX[i] * cos(aVecY[j]);
-        aCoord[1] = aVecX[i] * sin(aVecY[j]);
-      }
-      break;
-    }
-    case 3:{
-      TFloatVector aVecY = this->GetIndexes(1);
-      TInt nbIndxY       = this->GetNbIndexes(1);
-      TFloatVector aVecZ = this->GetIndexes(2);
-      TInt i,j,k;
-      i = j = k = 0;
-      
-      i = theId % nbIndxX;
-      j = (theId / nbIndxX) % nbIndxY;
-      k = theId / (nbIndxX*nbIndxY);
-
-      if(myGrilleType == eGRILLE_CARTESIENNE){
-        aCoord[0] = aVecX[i];
-        aCoord[1] = aVecY[j];
-        aCoord[2] = aVecZ[k];
-      } else { // eGRILLE_POLAIRE (cylindrical)
-        aCoord[0] = aVecX[i] * cos(aVecY[j]);
-        aCoord[1] = aVecX[i] * sin(aVecY[j]);
-        aCoord[2] = aVecZ[k];
-      }
-      
-      break;
-    }
-    }
-  }
-
-  return aCoord;
-}
-
-TIntVector
-TGrilleInfo
-::GetConn(TInt theId, const bool isSub)
-{
-  TIntVector anIndexes;
-  TInt aDim = myMeshInfo->GetDim();
-
-  TInt idx;
-  TInt iMin, jMin, kMin, iMax, jMax, kMax;
-  TInt loc[3];
-
-  loc[0] = loc[1] = loc[2] = 0;
-  iMin = iMax = jMin = jMax = kMin = kMax = 0;
-
-  switch(aDim) {
-  case 3:
-    {
-      TInt nbX = this->GetGrilleStructure()[0];
-      TInt nbY = this->GetGrilleStructure()[1];
-      TInt nbZ = this->GetGrilleStructure()[2];
-      TInt d01 = nbX*nbY, dX = 1, dY = 1, dZ = 1;
-      if ( isSub )
-      {
-        if ( theId < nbX * (nbY-1) * (nbZ-1))
-        { // face is normal to X axis
-          dX = 0;
-        }
-        else if ( theId < nbX * (nbY-1) * (nbZ-1) + (nbX-1) * nbY * (nbZ-1))
-        {  // face is normal to Y axis
-          theId -= nbX * (nbY-1) * (nbZ-1);
-          dY = 0;
-        }
-        else
-        {
-          theId -= nbX * (nbY-1) * (nbZ-1) + (nbX-1) * nbY * (nbZ-1);
-          dZ = 0;
-        }
-      }
-      //else
-      {
-        iMin = theId % (nbX - dX);
-        jMin = (theId / (nbX - dX)) % (nbY - dY);
-        kMin = theId / ((nbX - dX) * (nbY - dY));
-        iMax = iMin+dX;
-        jMax = jMin+dY;
-        kMax = kMin+dZ;
-      }
-      for (loc[2]=kMin; loc[2]<=kMax; loc[2]++)
-        for (loc[1]=jMin; loc[1]<=jMax; loc[1]++)
-          for (loc[0]=iMin; loc[0]<=iMax; loc[0]++)
-          {
-            idx = loc[0] + loc[1]*nbX + loc[2]*d01;
-            anIndexes.push_back(idx);
-          }
-      break;
-    }
-  case 2:
-    {
-      TInt nbX = this->GetGrilleStructure()[0];
-      TInt nbY = this->GetGrilleStructure()[1];
-      TInt dX = 1, dY = 1;
-      if ( isSub )
-      {
-        if ( theId < nbX * (nbY-1))
-        { // edge is normal to X axis
-          dX = 0;
-        }
-        else
-        {
-          theId -= nbX * (nbY-1);
-          dY = 0;
-        }
-      }
-      iMin = theId % (nbX-dX);
-      jMin = theId / (nbX-dX);
-      iMax = iMin+dX;
-      jMax = jMin+dY;
-      for (loc[1]=jMin; loc[1]<=jMax; loc[1]++)
-        for (loc[0]=iMin; loc[0]<=iMax; loc[0]++)
-        {
-          idx = loc[0] + loc[1]*nbX;
-          anIndexes.push_back(idx);
-        }
-      break;
-    }
-  case 1:
-    {
-      iMin = theId;
-      for (loc[0]=iMin; loc[0]<=iMin+1; loc[0]++)
-      {
-        idx = loc[0];
-        anIndexes.push_back(idx);
-      }
-      break;
-    }
-  }
-
-  return anIndexes;
-}
-
-TInt
-TGrilleInfo
-::GetFamNumNode(TInt theId) const 
-{
-  return myFamNumNode[theId];
-}
-
-void
-TGrilleInfo
-::SetFamNumNode(TInt theId,TInt theVal) 
-{
-  myFamNumNode[theId] = theVal;
-}
-
-TInt
-TGrilleInfo
-::GetFamNum(TInt theId) const 
-{
-  return myFamNum[theId];
-}
-
-void
-TGrilleInfo
-::SetFamNum(TInt theId,TInt theVal) 
-{
-  myFamNum[theId] = theVal;
-}
-
-TInt
-TGrilleInfo
-::GetFamSubNum(TInt theId) const 
-{
-  return myFamSubNum[theId];
-}
-
-void
-TGrilleInfo
-::SetFamSubNum(TInt theId,TInt theVal) 
-{
-  myFamSubNum[theId] = theVal;
-}

src/MEDWrapper/Base/MED_TWrapper.hxx

@@ -1,578 +0,0 @@
-// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
-//
-// Copyright (C) 2003-2007  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, 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
-//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
-#ifndef MED_TWrapper_HeaderFile
-#define MED_TWrapper_HeaderFile
-
-#include "MED_TStructures.hxx"
-#include "MED_Wrapper.hxx"
-
-namespace MED
-{
-
-  template<EVersion eVersion>
-  class TTWrapper: public TWrapper
-  {
-  public:
-    //----------------------------------------------------------------------------
-    //! Gets version of the MED library used for the MED file
-    virtual 
-    EVersion
-    GetVersion()
-    {
-      return eVersion;
-    }
-    
-    //----------------------------------------------------------------------------
-    virtual 
-    PMeshInfo
-    CrMeshInfo(TInt theDim = 0, TInt theSpaceDim = 0,
-               const std::string& theValue = "",
-               EMaillage theType = eNON_STRUCTURE,
-               const std::string& theDesc = "")
-    {
-      return PMeshInfo(new TTMeshInfo<eVersion>
-                       (theDim,
-                        theSpaceDim,
-                        theValue,
-                        theType,
-                        theDesc));
-    }
-
-    virtual 
-    PMeshInfo
-    CrMeshInfo(const PMeshInfo& theInfo)
-    {
-      return PMeshInfo(new TTMeshInfo<eVersion>(theInfo));
-    }
-    
-
-    //----------------------------------------------------------------------------
-    virtual
-    PFamilyInfo
-    CrFamilyInfo(const PMeshInfo& theMeshInfo,
-                 TInt theNbGroup = 0, 
-                 TInt theNbAttr = 0,
-                 TInt theId = 0,
-                 const std::string& theValue = "")
-    {
-      return PFamilyInfo(new TTFamilyInfo<eVersion>
-                         (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<eVersion>
-                         (theMeshInfo,
-                          theValue,
-                          theId,
-                          theGroupNames,
-                          theAttrDescs,
-                          theAttrIds,
-                          theAttrVals));
-    }
-
-    virtual
-    PFamilyInfo
-    CrFamilyInfo(const PMeshInfo& theMeshInfo,
-                 const PFamilyInfo& theInfo)
-    {
-      return PFamilyInfo(new TTFamilyInfo<eVersion>
-                         (theMeshInfo,
-                          theInfo));
-    }
-
-    //----------------------------------------------------------------------------
-    virtual
-    PElemInfo
-    CrElemInfo(const PMeshInfo& theMeshInfo, 
-               TInt theNbElem,
-               EBooleen theIsElemNum = eVRAI,
-               EBooleen theIsElemNames = eVRAI)
-    {
-      return PElemInfo(new TTElemInfo<eVersion>
-                       (theMeshInfo,
-                        theNbElem,
-                        theIsElemNum,
-                        theIsElemNames));
-    }
-
-    virtual
-    PElemInfo
-    CrElemInfo(const PMeshInfo& theMeshInfo, 
-               TInt theNbElem,
-               const TIntVector& theFamNum,
-               const TIntVector& aElemNum,
-               const TStringVector& aElemNames)
-    {
-      return PElemInfo(new TTElemInfo<eVersion>
-                       (theMeshInfo,
-                        theNbElem,
-                        theFamNum,
-                        aElemNum,
-                        aElemNames));
-    }
-
-    //----------------------------------------------------------------------------
-    virtual
-    PNodeInfo
-    CrNodeInfo(const PMeshInfo& theMeshInfo, 
-               TInt theNbElem,
-               EModeSwitch theMode = eFULL_INTERLACE,
-               ERepere theSystem = eCART, 
-               EBooleen theIsElemNum = eVRAI,
-               EBooleen theIsElemNames = eVRAI)
-    {
-      return PNodeInfo(new TTNodeInfo<eVersion>
-                       (theMeshInfo,
-                        theNbElem,
-                        theMode,
-                        theSystem,
-                        theIsElemNum,
-                        theIsElemNames));
-    }
-
-    virtual 
-    PNodeInfo
-    CrNodeInfo(const PMeshInfo& theMeshInfo, 
-               const TFloatVector& theNodeCoords,
-               EModeSwitch theMode = eFULL_INTERLACE,
-               ERepere theSystem = eCART, 
-               const TStringVector& theCoordNames = TStringVector(),
-               const TStringVector& theCoordUnits = TStringVector(),
-               const TIntVector& theFamilyNums = TIntVector(),
-               const TIntVector& theElemNums = TIntVector(),
-               const TStringVector& theElemNames = TStringVector())
-    {
-      return PNodeInfo(new TTNodeInfo<eVersion>
-                       (theMeshInfo,
-                        theNodeCoords,
-                        theMode,
-                        theSystem,
-                        theCoordNames,
-                        theCoordUnits,
-                        theFamilyNums,
-                        theElemNums,
-                        theElemNames));
-    }
-
-    virtual 
-    PNodeInfo
-    CrNodeInfo(const PMeshInfo& theMeshInfo,
-               const PNodeInfo& theInfo)
-    {
-      return PNodeInfo(new TTNodeInfo<eVersion>
-                       (theMeshInfo,
-                        theInfo));
-    }
-    
-    //----------------------------------------------------------------------------
-    virtual
-    PPolygoneInfo
-    CrPolygoneInfo(const PMeshInfo& theMeshInfo, 
-                   EEntiteMaillage theEntity, 
-                   EGeometrieElement theGeom,
-                   TInt theNbElem,
-                   TInt theConnSize,
-                   EConnectivite theConnMode = eNOD,
-                   EBooleen theIsElemNum = eVRAI,
-                   EBooleen theIsElemNames = eVRAI)
-    {
-      return PPolygoneInfo(new TTPolygoneInfo<eVersion>
-                           (theMeshInfo,
-                            theEntity,
-                            theGeom,
-                            theNbElem,
-                            theConnSize,
-                            theConnMode,
-                            theIsElemNum,
-                            theIsElemNames));
-    }
-
-    virtual
-    PPolygoneInfo
-    CrPolygoneInfo(const PMeshInfo& theMeshInfo, 
-                   EEntiteMaillage theEntity, 
-                   EGeometrieElement theGeom,
-                   const TIntVector& theIndexes,
-                   const TIntVector& theConnectivities,
-                   EConnectivite theConnMode = eNOD,
-                   const TIntVector& theFamilyNums = TIntVector(),
-                   const TIntVector& theElemNums = TIntVector(),
-                   const TStringVector& theElemNames = TStringVector())
-    {
-      return PPolygoneInfo(new TTPolygoneInfo<eVersion>
-                           (theMeshInfo,
-                            theEntity,
-                            theGeom,
-                            theIndexes,
-                            theConnectivities,
-                            theConnMode,
-                            theFamilyNums,
-                            theElemNums,
-                            theElemNames));
-    }
-
-    virtual
-    PPolygoneInfo
-    CrPolygoneInfo(const PMeshInfo& theMeshInfo,
-                   const PPolygoneInfo& theInfo)
-    {
-      return PPolygoneInfo(new TTPolygoneInfo<eVersion>
-                           (theMeshInfo,
-                            theInfo));
-    }
-    
-    //----------------------------------------------------------------------------
-    virtual
-    PPolyedreInfo
-    CrPolyedreInfo(const PMeshInfo& theMeshInfo, 
-                   EEntiteMaillage theEntity, 
-                   EGeometrieElement theGeom,
-                   TInt theNbElem,
-                   TInt theNbFaces,
-                   TInt theConnSize,
-                   EConnectivite theConnMode = eNOD,
-                   EBooleen theIsElemNum = eVRAI,
-                   EBooleen theIsElemNames = eVRAI)
-    {
-      return PPolyedreInfo(new TTPolyedreInfo<eVersion>
-                           (theMeshInfo,
-                            theEntity,
-                            theGeom,
-                            theNbElem,
-                            theNbFaces,
-                            theConnSize,
-                            theConnMode,
-                            theIsElemNum,
-                            theIsElemNames));
-    }
-
-    virtual
-    PPolyedreInfo
-    CrPolyedreInfo(const PMeshInfo& theMeshInfo, 
-                   EEntiteMaillage theEntity, 
-                   EGeometrieElement theGeom,
-                   const TIntVector& theIndexes,
-                   const TIntVector& theFaces,
-                   const TIntVector& theConnectivities,
-                   EConnectivite theConnMode = eNOD,
-                   const TIntVector& theFamilyNums = TIntVector(),
-                   const TIntVector& theElemNums = TIntVector(),
-                   const TStringVector& theElemNames = TStringVector())
-    {
-      return PPolyedreInfo(new TTPolyedreInfo<eVersion>
-                           (theMeshInfo,
-                            theEntity,
-                            theGeom,
-                            theIndexes,
-                            theFaces,
-                            theConnectivities,
-                            theConnMode,
-                            theFamilyNums,
-                            theElemNums,
-                            theElemNames));
-    }
-
-    virtual
-    PPolyedreInfo
-    CrPolyedreInfo(const PMeshInfo& theMeshInfo,
-                   const PPolyedreInfo& theInfo)
-    {
-      return PPolyedreInfo(new TTPolyedreInfo<eVersion>
-                           (theMeshInfo,
-                            theInfo));
-    }
-
-    //----------------------------------------------------------------------------
-    virtual
-    PCellInfo
-    CrCellInfo(const PMeshInfo& theMeshInfo, 
-               EEntiteMaillage theEntity, 
-               EGeometrieElement theGeom,
-               TInt theNbElem,
-               EConnectivite theConnMode = eNOD,
-               EBooleen theIsElemNum = eVRAI,
-               EBooleen theIsElemNames = eVRAI,
-               EModeSwitch theMode = eFULL_INTERLACE)
-    {
-      return PCellInfo(new TTCellInfo<eVersion>
-                       (theMeshInfo,
-                        theEntity,
-                        theGeom,
-                        theNbElem,
-                        theConnMode,
-                        theIsElemNum,
-                        theIsElemNames,
-                        theMode));
-    }
-
-    virtual
-    PCellInfo
-    CrCellInfo(const PMeshInfo& theMeshInfo, 
-               EEntiteMaillage theEntity, 
-               EGeometrieElement theGeom,
-               const TIntVector& theConnectivities,
-               EConnectivite theConnMode = eNOD,
-               const TIntVector& theFamilyNums = TIntVector(),
-               const TIntVector& theElemNums = TIntVector(),
-               const TStringVector& theElemNames = TStringVector(),
-               EModeSwitch theMode = eFULL_INTERLACE)
-    {
-      return PCellInfo(new TTCellInfo<eVersion>
-                       (theMeshInfo,
-                        theEntity,
-                        theGeom,
-                        theConnectivities,
-                        theConnMode,
-                        theFamilyNums,
-                        theElemNums,
-                        theElemNames,
-                        theMode));
-    }
-
-    virtual
-    PCellInfo
-    CrCellInfo(const PMeshInfo& theMeshInfo,
-               const PCellInfo& theInfo)
-    {
-      return PCellInfo(new TTCellInfo<eVersion>
-                       (theMeshInfo,
-                        theInfo));
-    }
-    
-    //----------------------------------------------------------------------------
-    //! Creates a MEDWrapper MED Balls representation
-    virtual PBallInfo CrBallInfo(const PMeshInfo& theMeshInfo, 
-                                 TInt             theNbBalls,
-                                 EBooleen         theIsElemNum = eVRAI)
-    {
-      return PBallInfo( new TTBallInfo<eVersion>( theMeshInfo, theNbBalls, theIsElemNum ));
-    }
-
-    //! Creates a MEDWrapper MED Balls representation
-    virtual PBallInfo CrBallInfo(const PMeshInfo&  theMeshInfo, 
-                                 const TIntVector& theNodes,
-                                 TFloatVector&     theDiameters,
-                                 const TIntVector& theFamilyNums = TIntVector(),
-                                 const TIntVector& theElemNums = TIntVector())
-    {
-      return PBallInfo( new TTBallInfo<eVersion>( theMeshInfo, theNodes, theDiameters,
-                                                  theFamilyNums, theElemNums));
-    }
-
-    //! A copy-constructor for the MEDWrapper MED Balls representation
-    virtual PBallInfo CrBallInfo(const PMeshInfo& theMeshInfo,
-                                 const PBallInfo& theInfo)
-    {
-      return PBallInfo( new TTBallInfo<eVersion>( 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<eVersion>
-                        (theMeshInfo,
-                         theNbComp,
-                         theType,
-                         theValue,
-                         theIsLocal,
-                         theNbRef));
-    }
-
-    virtual
-    PFieldInfo
-    CrFieldInfo(const PMeshInfo& theMeshInfo,
-                const PFieldInfo& theInfo)
-    {
-      return PFieldInfo(new TTFieldInfo<eVersion>
-                        (theMeshInfo,
-                         theInfo));
-    }
-    
-
-    //----------------------------------------------------------------------------
-    virtual
-    PTimeStampInfo
-    CrTimeStampInfo(const PFieldInfo& theFieldInfo, 
-                    EEntiteMaillage theEntity,
-                    const TGeom2Size& theGeom2Size,
-                    const TGeom2NbGauss& theGeom2NbGauss = TGeom2NbGauss(),
-                    TInt theNumDt = 0,
-                    TInt theNumOrd = 0,
-                    TFloat theDt = 0,
-                    const std::string& theUnitDt = "",
-                    const TGeom2Gauss& theGeom2Gauss = TGeom2Gauss())
-    {
-      return PTimeStampInfo(new TTTimeStampInfo<eVersion>
-                            (theFieldInfo,
-                             theEntity,
-                             theGeom2Size,
-                             theGeom2NbGauss,
-                             theNumDt,
-                             theNumOrd,
-                             theDt,
-                             theUnitDt,
-                             theGeom2Gauss));
-    }
-
-    virtual
-    PTimeStampInfo
-    CrTimeStampInfo(const PFieldInfo& theFieldInfo,
-                    const PTimeStampInfo& theInfo)
-    {
-      return PTimeStampInfo(new TTTimeStampInfo<eVersion>
-                            (theFieldInfo,
-                             theInfo));
-    }
-
-
-    //----------------------------------------------------------------------------
-    virtual
-    PGaussInfo
-    CrGaussInfo(const TGaussInfo::TInfo& theInfo,
-                EModeSwitch theMode = eFULL_INTERLACE)
-    {
-      return PGaussInfo(new TTGaussInfo<eVersion>
-                        (theInfo,
-                         theMode));
-    }
-    
-
-    //----------------------------------------------------------------------------
-    virtual
-    PProfileInfo
-    CrProfileInfo(const TProfileInfo::TInfo& theInfo,
-                  EModeProfil theMode = eCOMPACT)
-    {
-      return PProfileInfo(new TTProfileInfo<eVersion>
-                           (theInfo,
-                            theMode));
-    }
-    
-
-    //----------------------------------------------------------------------------
-    virtual
-    PTimeStampValueBase
-    CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
-                     ETypeChamp theTypeChamp,
-                     const TGeom2Profile& theGeom2Profile = TGeom2Profile(),
-                     EModeSwitch theMode = eFULL_INTERLACE)
-    {
-      if(theTypeChamp == eFLOAT64)
-        return PTimeStampValueBase(new TTTimeStampValue<eVersion, TFloatMeshValue>
-                                   (theTimeStampInfo,
-                                    theTypeChamp,
-                                    theGeom2Profile,
-                                    theMode));
-      return PTimeStampValueBase(new TTTimeStampValue<eVersion, TIntMeshValue>
-                                 (theTimeStampInfo,
-                                  theTypeChamp,
-                                  theGeom2Profile,
-                                  theMode));
-    }
-
-    virtual
-    PTimeStampValueBase
-    CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
-                     const PTimeStampValueBase& theInfo,
-                     ETypeChamp theTypeChamp)
-    {
-      if(theTypeChamp == eFLOAT64)
-        return PTimeStampValueBase(new TTTimeStampValue<eVersion, TFloatMeshValue>
-                                   (theTimeStampInfo,
-                                    theInfo,
-                                    theTypeChamp));
-      return PTimeStampValueBase(new TTTimeStampValue<eVersion, TIntMeshValue>
-                                 (theTimeStampInfo,
-                                  theInfo,
-                                  theTypeChamp));
-    }
-    
-    //----------------------------------------------------------------------------
-    virtual
-    PGrilleInfo
-    CrGrilleInfo(const PMeshInfo& theMeshInfo,
-                 const PGrilleInfo& theInfo)
-    {
-      return PGrilleInfo(new TTGrilleInfo<eVersion>
-                            (theMeshInfo,
-                             theInfo));
-    }
-    virtual
-    PGrilleInfo
-    CrGrilleInfo(const PMeshInfo& theMeshInfo,
-                 const EGrilleType& type)
-    {
-      return PGrilleInfo(new TTGrilleInfo<eVersion>
-                            (theMeshInfo,
-                             type));
-    }
-
-    virtual
-    PGrilleInfo
-    CrGrilleInfo(const PMeshInfo& theMeshInfo,
-                 const EGrilleType& type,
-                 const TInt& nbNodes)
-    {
-      return PGrilleInfo(new TTGrilleInfo<eVersion>
-                            (theMeshInfo,
-                             type,
-                             nbNodes));
-    }
-
-    virtual
-    PGrilleInfo
-    CrGrilleInfo(const PMeshInfo& theMeshInfo,
-                 const EGrilleType& type,
-                 const MED::TIntVector& nbNodeVec)
-    {
-      return PGrilleInfo(new TTGrilleInfo<eVersion>
-                            (theMeshInfo,
-                             type,
-                             nbNodeVec));
-    }
-    //----------------------------------------------------------------------------
-  };
-
-}
-
-
-#endif

src/MEDWrapper/Base/MED_Utilities.cxx

@@ -1,113 +0,0 @@
-// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
-//
-// Copyright (C) 2003-2007  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, 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
-//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
-#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--;
-    if(myCounter < 0)
-      EXCEPTION(runtime_error,"PrefixPrinter::~PrefixPrinter() - myCounter("<<myCounter<<") < 0");
-  }
-}
-
-string MED::PrefixPrinter::GetPrefix()
-{
-  if(myCounter){
-    if(myCounter < 0)
-      EXCEPTION(runtime_error,"PrefixPrinter::~PrefixPrinter() - myCounter("<<myCounter<<") < 0");
-    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(eTRIA7);
-  aGeomFACESet.insert(eQUAD8);
-  aGeomFACESet.insert(eQUAD9);
-  aGeomFACESet.insert(ePOLYGONE);
-  aGeomFACESet.insert(ePOLYGON2);
-
-  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(eOCTA12);
-  aGeomMAILLESet.insert(eTETRA10);
-  aGeomMAILLESet.insert(ePYRA13);
-  aGeomMAILLESet.insert(ePENTA15);
-  aGeomMAILLESet.insert(eHEXA20);
-  aGeomMAILLESet.insert(eHEXA27);
-  aGeomMAILLESet.insert(ePOLYEDRE);
-
-  /* This combination allows reading nb of models of structure elements */
-  Entity2GeomSet[eSTRUCT_ELEMENT].insert(eAllGeoType); 
-
-  return true;
-}
-
-static bool anIsInited = InitEntity2GeomSet();
-
-const MED::TEntity2GeomSet& MED::GetEntity2GeomSet()
-{
-  return Entity2GeomSet;
-}
-
-

src/MEDWrapper/Base/MED_Wrapper.cxx

@@ -1,707 +0,0 @@
-// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
-//
-// Copyright (C) 2003-2007  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, 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
-//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
-//  File   : MED_Wrapper.cxx
-//  Author : Alexey PETROV
-//
-#include "MED_Wrapper.hxx"
-#include "MED_Utilities.hxx"
- 
-#include <boost/version.hpp>
-
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-static int MYVALUEDEBUG = 0;
-#else
-// static int MYDEBUG = 0;
-// static int MYVALUEDEBUG = 0;
-#endif
-
-namespace MED
-{
-  TLockProxy
-  ::TLockProxy(TWrapper* theWrapper):
-    myWrapper(theWrapper)
-  {
-#if BOOST_VERSION >= 103500
-    myWrapper->myMutex.lock();
-#else
-    boost::detail::thread::lock_ops<TWrapper::TMutex>::lock(myWrapper->myMutex);
-#endif
-    INITMSG(MYDEBUG,"TLockProxy() - this -"<<this<<"; myWrapper = "<<myWrapper<<std::endl);
-  }
-  
-  TLockProxy
-  ::~TLockProxy()
-  {
-    INITMSG(MYDEBUG,"~TLockProxy() - this -"<<this<<"; myWrapper = "<<myWrapper<<std::endl);
-#if BOOST_VERSION >= 103500
-    myWrapper->myMutex.unlock();
-#else
-    boost::detail::thread::lock_ops<TWrapper::TMutex>::unlock(myWrapper->myMutex);
-#endif
-  }
-  
-  TWrapper*
-  TLockProxy
-  ::operator-> () const // never throws
-  {
-    return myWrapper;
-  }
-
-  //----------------------------------------------------------------------------
-  TWrapper::~TWrapper()
-  {
-  }
-
-  //----------------------------------------------------------------------------
-  PMeshInfo
-  TWrapper
-  ::GetPMeshInfo(TInt theId,
-                 TErr* theErr)
-  {
-    PMeshInfo anInfo = CrMeshInfo();
-    GetMeshInfo(theId,*anInfo,theErr);
-    return anInfo;
-  }
-
-
-  //----------------------------------------------------------------------------
-  PFamilyInfo 
-  TWrapper
-  ::GetPFamilyInfo(const PMeshInfo& theMeshInfo, 
-                   TInt theId,
-                   TErr* theErr)
-  {
-    // must be reimplemented in connection with mesh type eSTRUCTURE
-    //     if(theMeshInfo->GetType() != eNON_STRUCTURE)
-    //       return PFamilyInfo();
-    
-    TInt aNbAttr = GetNbFamAttr(theId,*theMeshInfo);
-    TInt aNbGroup = GetNbFamGroup(theId,*theMeshInfo);
-    PFamilyInfo anInfo = CrFamilyInfo(theMeshInfo,aNbGroup,aNbAttr);
-    GetFamilyInfo(theId,*anInfo,theErr);
-
-#ifdef _DEBUG_
-    std::string aName = anInfo->GetName();
-    INITMSG(MYDEBUG,"GetPFamilyInfo - aFamilyName = '"<<aName<<
-            "'; andId = "<<anInfo->GetId()<<
-            "; aNbAttr = "<<aNbAttr<<
-            "; aNbGroup = "<<aNbGroup<<"\n");
-    for(TInt iGroup = 0; iGroup < aNbGroup; iGroup++){
-      aName = anInfo->GetGroupName(iGroup);
-      INITMSG(MYDEBUG,"aGroupName = '"<<aName<<"'\n");
-    }
-#endif
-    
-    return anInfo;
-  }
-
-
-  //----------------------------------------------------------------------------
-  PNodeInfo
-  TWrapper
-  ::GetPNodeInfo(const PMeshInfo& theMeshInfo,
-                 TErr* theErr)
-  {
-    TInt aNbElems = GetNbNodes(*theMeshInfo);
-    if(aNbElems == 0){
-      return PNodeInfo();
-    }
-
-    PNodeInfo anInfo = CrNodeInfo(theMeshInfo,aNbElems);
-    GetNodeInfo(*anInfo,theErr);
-
-#ifdef _DEBUG_
-    TInt aDim = theMeshInfo->myDim;
-    TInt aNbElem = anInfo->GetNbElem();
-    INITMSG(MYDEBUG,"GetPNodeInfo: ");
-    {
-      INITMSG(MYDEBUG,"aCoords: "<<aNbElem<<": ");
-      TNodeCoord& aCoord = anInfo->myCoord;
-      for(TInt iElem = 0; iElem < aNbElem; iElem++){
-        for(TInt iDim = 0, anId = iElem*aDim; iDim < aDim; iDim++, anId++){
-          ADDMSG(MYVALUEDEBUG,aCoord[anId]<<",");
-        }
-        ADDMSG(MYVALUEDEBUG," ");
-      }
-      ADDMSG(MYDEBUG, std::endl);
-      
-      BEGMSG(MYVALUEDEBUG, "GetFamNum: ");
-      for(TInt iElem = 0; iElem < aNbElem; iElem++){
-        ADDMSG(MYVALUEDEBUG,anInfo->GetFamNum(iElem)<<", ");
-      }
-      ADDMSG(MYVALUEDEBUG, std::endl);
-      
-      if(anInfo->IsElemNum()){
-        BEGMSG(MYVALUEDEBUG,"GetElemNum: ");
-        for(TInt iElem = 0; iElem < aNbElem; iElem++){
-          ADDMSG(MYVALUEDEBUG,anInfo->GetElemNum(iElem)<<", ");
-        }
-        ADDMSG(MYVALUEDEBUG, std::endl);
-      }
-    }
-    ADDMSG(MYDEBUG, std::endl);
-#endif
-    
-    return anInfo;
-  }
-
-  //----------------------------------------------------------------------------
-  PPolygoneInfo
-  TWrapper
-  ::GetPPolygoneInfo(const PMeshInfo& theMeshInfo,
-                     EEntiteMaillage theEntity, 
-                     EGeometrieElement theGeom, 
-                     EConnectivite theConnMode)
-  {
-    if(theMeshInfo->GetType() != eNON_STRUCTURE)
-      return PPolygoneInfo();
-
-    TInt aNbElem = GetNbPolygones(theMeshInfo,theEntity,theGeom,theConnMode);
-    TInt aConnSize = GetPolygoneConnSize(theMeshInfo,theEntity,theGeom,theConnMode);
-    PPolygoneInfo anInfo = CrPolygoneInfo(theMeshInfo,theEntity,theGeom,aNbElem,aConnSize,theConnMode);
-    GetPolygoneInfo(anInfo);
-
-#ifdef _DEBUG_
-    INITMSG(MYDEBUG,"GetPPolygoneInfo"<<
-            " - theGeom = "<<theGeom<<
-            "; aNbElem = "<<aNbElem<<": ");
-    for(TInt iElem = 1; iElem < aNbElem; iElem++){
-      TCConnSlice aConnSlice = anInfo->GetConnSlice(iElem);
-      TInt aConnDim = aConnSlice.size();
-      for(TInt iConn = 0; iConn < aConnDim; iConn++){
-        ADDMSG(MYVALUEDEBUG,aConnSlice[iConn]<<",");
-      }
-      ADDMSG(MYDEBUG," ");
-    }
-    ADDMSG(MYDEBUG, std::endl);
-#endif
-
-    return anInfo;
-  }
-  
-  //----------------------------------------------------------------------------
-  PPolyedreInfo
-  TWrapper
-  ::GetPPolyedreInfo(const PMeshInfo& theMeshInfo,
-                     EEntiteMaillage theEntity, 
-                     EGeometrieElement theGeom, 
-                     EConnectivite theConnMode)
-  {
-    if(theMeshInfo->GetType() != eNON_STRUCTURE)
-      return PPolyedreInfo();
-    TInt aNbElem  = GetNbPolyedres(theMeshInfo,theEntity,theGeom,theConnMode);
-    TInt aNbFaces, aConnSize;
-    GetPolyedreConnSize(theMeshInfo,aNbFaces,aConnSize,theConnMode);
-    PPolyedreInfo anInfo = CrPolyedreInfo(theMeshInfo,theEntity,theGeom,aNbElem,aNbFaces,aConnSize,theConnMode);
-    GetPolyedreInfo(anInfo);
-
-#ifdef _DEBUG_
-    INITMSG(MYDEBUG,"GetPPolyedreInfo"<<
-            " - theGeom = "<<theGeom<<
-            "; aNbElem = "<<aNbElem<<": ");
-    for(TInt iElem = 0; iElem < aNbElem; iElem++){
-      TCConnSliceArr aConnSliceArr = anInfo->GetConnSliceArr(iElem);
-      TInt aNbFaces = aConnSliceArr.size();
-      ADDMSG(MYDEBUG,"{");
-      for(TInt iFace = 0; iFace < aNbFaces; iFace++){
-        TCConnSlice aConnSlice = aConnSliceArr[iFace];
-        TInt aNbConn = aConnSlice.size();
-        ADDMSG(MYDEBUG,"[");
-        for(TInt iConn = 0; iConn < aNbConn; iConn++){
-          ADDMSG(MYVALUEDEBUG,aConnSlice[iConn]<<",");
-        }
-        ADDMSG(MYDEBUG,"] ");
-      }
-      ADDMSG(MYDEBUG,"} ");
-    }
-    ADDMSG(MYDEBUG, std::endl);
-#endif
-
-    return anInfo;
-  }
-  
-  //----------------------------------------------------------------------------
-  PElemInfo 
-  TWrapper
-  ::GetPElemInfo(const PMeshInfo& theMeshInfo,
-                 EEntiteMaillage theEntity, 
-                 EGeometrieElement theGeom, 
-                 EConnectivite theConnMode,
-                 TErr* theErr)
-  {
-    EMaillage aType = theMeshInfo->GetType();
-    if(aType == eNON_STRUCTURE){
-      switch(theGeom){
-      case ePOINT1:
-        if(theEntity == eNOEUD)
-          return GetPNodeInfo(theMeshInfo,theErr);
-        return GetPCellInfo(theMeshInfo,theEntity,theGeom,theConnMode,theErr);
-        break;
-      case ePOLYGONE:
-        return GetPPolygoneInfo(theMeshInfo,theEntity,theGeom,theConnMode);
-        break;
-      case ePOLYEDRE:
-        return GetPPolyedreInfo(theMeshInfo,theEntity,theGeom,theConnMode);
-        break;
-      default:
-        return GetPCellInfo(theMeshInfo,theEntity,theGeom,theConnMode,theErr);
-      }
-    } else {
-      PGrilleInfo aGrille = GetPGrilleInfo(theMeshInfo);
-
-      TInt nbElems;
-      EBooleen theIsElemNum = eFAUX;
-      // nodes
-      switch(theGeom){
-      case ePOINT1:
-        nbElems = aGrille->GetNbNodes();
-        theIsElemNum = eVRAI;
-        break;
-      case eSEG2:
-      case eQUAD4:
-      case eHEXA8:
-        nbElems = aGrille->GetNbCells();
-        break;
-      default:
-        nbElems = 0;
-      }
-      
-      TIntVector aFamNum;
-      TIntVector aElemNum;
-      TStringVector aElemNames;
-      
-      PElemInfo aElemInfo;
-
-      if(theGeom == ePOINT1){
-        aElemInfo = CrElemInfo(theMeshInfo,
-                               nbElems,
-                               theIsElemNum);
-        MED::TElemInfo &aTElemInfo = *aElemInfo;
-
-        // must be reimplemente in connection with mesh type eSTRUCTURE
-//      GetNumeration(aTElemInfo,
-//                    nbElems,
-//                    theEntity,
-//                    theGeom,
-//                    theErr);
-        
-        GetFamilies(aTElemInfo,
-                    nbElems,
-                    theEntity,
-                    theGeom,
-                    theErr);
-        
-        // must be reimplemente in connection with mesh type eSTRUCTURE
-//      GetNames(aTElemInfo,
-//               nbElems,
-//               theEntity,
-//               theGeom,
-//               theErr);
-      } else {
-        aElemInfo = CrElemInfo(theMeshInfo,
-                               nbElems,
-                               aFamNum,
-                               aElemNum,
-                               aElemNames);
-      }
-      
-      return aElemInfo;
-    }
-    return PElemInfo();
-  }
-
-
-  //----------------------------------------------------------------------------
-  PCellInfo 
-  TWrapper
-  ::GetPCellInfo(const PMeshInfo& theMeshInfo,
-                 EEntiteMaillage theEntity, 
-                 EGeometrieElement theGeom, 
-                 EConnectivite theConnMode,
-                 TErr* theErr)
-  {
-    if(theMeshInfo->GetType() != eNON_STRUCTURE)
-      return PCellInfo();
-    TInt aNbElem = GetNbCells(theMeshInfo,theEntity,theGeom,theConnMode);
-    PCellInfo anInfo = CrCellInfo(theMeshInfo,theEntity,theGeom,aNbElem,theConnMode);
-    GetCellInfo(anInfo,theErr);
-
-#ifdef _DEBUG_
-    TInt aConnDim = anInfo->GetConnDim();
-    INITMSG(MYDEBUG,"GetPCellInfo - theEntity = "<<theEntity<<"; theGeom = "<<theGeom<<"; aConnDim: "<<aConnDim<<"\n");
-    BEGMSG(MYDEBUG,"GetPCellInfo - aNbElem: "<<aNbElem<<": ");
-    for(TInt iElem = 0; iElem < aNbElem; iElem++){
-      TCConnSlice aConnSlice = anInfo->GetConnSlice(iElem);
-      for(TInt iConn = 0; iConn < aConnDim; iConn++){
-        ADDMSG(MYVALUEDEBUG,aConnSlice[iConn]<<",");
-      }
-      ADDMSG(MYVALUEDEBUG," ");
-    }
-    ADDMSG(MYDEBUG, std::endl);
-
-    BEGMSG(MYVALUEDEBUG,"GetPCellInfo - GetFamNum: ");
-    for(TInt iElem = 0; iElem < aNbElem; iElem++){
-      ADDMSG(MYVALUEDEBUG,anInfo->GetFamNum(iElem)<<", ");
-    }
-    ADDMSG(MYVALUEDEBUG, std::endl);
-
-    if(anInfo->IsElemNum()){
-      BEGMSG(MYVALUEDEBUG,"GetPCellInfo - GetElemNum: ");
-      for(TInt iElem = 0; iElem < aNbElem; iElem++){
-        ADDMSG(MYVALUEDEBUG,anInfo->GetElemNum(iElem)<<", ");
-      }
-      ADDMSG(MYVALUEDEBUG, std::endl);
-    }
-    ADDMSG(MYDEBUG, std::endl);
-#endif
-    
-    return anInfo;
-  }
-
-  //----------------------------------------------------------------------------
-  //! Read a MEDWrapped representation of MED Balls from the MED file
-  PBallInfo
-  TWrapper
-  ::GetPBallInfo(const PMeshInfo& theMeshInfo)
-  {
-    TInt nbBalls = GetNbBalls(theMeshInfo);
-    if ( nbBalls < 1 ) return PBallInfo();
-
-    PBallInfo anInfo = CrBallInfo( theMeshInfo, nbBalls );
-    GetBallInfo(anInfo);
-
-    return anInfo;
-  }
-  //----------------------------------------------------------------------------
-  PFieldInfo
-  TWrapper
-  ::GetPFieldInfo(const PMeshInfo& theMeshInfo, 
-                  TInt theId,
-                  TErr* theErr)
-  {
-    TInt aNbComp = GetNbComp(theId);
-    PFieldInfo anInfo = CrFieldInfo(theMeshInfo,aNbComp);
-    GetFieldInfo(theId,*anInfo,theErr);
-
-#ifdef _DEBUG_
-    INITMSG(MYDEBUG,
-            "GetPFieldInfo "<<
-            "- aName = '"<<anInfo->GetName()<<"'"<<
-            "; aType = "<<anInfo->GetType()<<
-            "; aNbComp = "<<aNbComp<<
-            std::endl);
-#endif
-    
-    return anInfo;
-  }
-
-
-  //----------------------------------------------------------------------------
-  PTimeStampInfo
-  TWrapper
-  ::GetPTimeStampInfo(const PFieldInfo& theFieldInfo,
-                      EEntiteMaillage theEntity,
-                      const TGeom2Size& theGeom2Size,
-                      TInt theId,
-                      TErr* theErr)
-  {
-    PTimeStampInfo anInfo = CrTimeStampInfo(theFieldInfo,theEntity,theGeom2Size);
-    GetTimeStampInfo(theId,*anInfo,theErr);
-
-#ifdef _DEBUG_
-    INITMSG(MYDEBUG,"GetPTimeStampInfo - anEntity = "<<anInfo->GetEntity()<<"\n");
-    TGeom2NbGauss& aGeom2NbGauss = anInfo->myGeom2NbGauss;
-    TGeom2NbGauss::const_iterator anIter = aGeom2NbGauss.begin();
-    for(; anIter != aGeom2NbGauss.end(); anIter++){
-      const EGeometrieElement& aGeom = anIter->first;
-      INITMSG(MYDEBUG,"aGeom = "<<aGeom<<" - "<<aGeom2NbGauss[aGeom]<<";\n");
-    }
-#endif
-
-    return anInfo;
-  }
-
-
-  //----------------------------------------------------------------------------
-  PProfileInfo
-  TWrapper
-  ::GetPProfileInfo(TInt theId,
-                    EModeProfil theMode,
-                    TErr* theErr)
-  {
-    TProfileInfo::TInfo aPreInfo = GetProfilePreInfo(theId);
-    PProfileInfo anInfo = CrProfileInfo(aPreInfo,theMode);
-    GetProfileInfo(theId,*anInfo,theErr);
-
-    return anInfo;
-  }
-
-
-  //----------------------------------------------------------------------------
-  PTimeStampValueBase
-  TWrapper
-  ::CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
-                     const TGeom2Profile& theGeom2Profile,
-                     EModeSwitch theMode)
-  {
-    PFieldInfo aFieldInfo = theTimeStampInfo->GetFieldInfo();
-    return CrTimeStampValue(theTimeStampInfo,
-                            aFieldInfo->GetType(),
-                            theGeom2Profile,
-                            theMode);
-  }
-
-  //----------------------------------------------------------------------------
-  PTimeStampValueBase
-  TWrapper
-  ::CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
-                     const PTimeStampValueBase& theInfo)
-  {
-    PFieldInfo aFieldInfo = theTimeStampInfo->GetFieldInfo();
-    return CrTimeStampValue(theTimeStampInfo,
-                            theInfo,
-                            aFieldInfo->GetType());
-  }
-
-  //----------------------------------------------------------------------------
-  template<class TimeStampValueType>
-  void
-  Print(SharedPtr<TimeStampValueType> theTimeStampValue)
-  {
-    INITMSG(MYDEBUG,"Print - TimeStampValue\n");
-    typename TimeStampValueType::TTGeom2Value& aGeom2Value = theTimeStampValue->myGeom2Value;
-    typename TimeStampValueType::TTGeom2Value::const_iterator anIter = aGeom2Value.begin();
-    for(; anIter != aGeom2Value.end(); anIter++){
-      const EGeometrieElement& aGeom = anIter->first;
-      const typename TimeStampValueType::TTMeshValue& aMeshValue = anIter->second;
-      TInt aNbElem = aMeshValue.myNbElem;
-      TInt aNbGauss = aMeshValue.myNbGauss;
-      TInt aNbComp = aMeshValue.myNbComp;
-      INITMSG(MYDEBUG,"aGeom = "<<aGeom<<" - "<<aNbElem<<": ");
-      for(TInt iElem = 0; iElem < aNbElem; iElem++){
-        typename TimeStampValueType::TTMeshValue::TCValueSliceArr aValueSliceArr = aMeshValue.GetGaussValueSliceArr(iElem);
-        ADDMSG(MYVALUEDEBUG,"{");
-        for(TInt iGauss = 0; iGauss < aNbGauss; iGauss++){
-          const typename TimeStampValueType::TTMeshValue::TCValueSlice& aValueSlice = aValueSliceArr[iGauss];
-          for(TInt iComp = 0; iComp < aNbComp; iComp++){
-            ADDMSG(MYVALUEDEBUG,aValueSlice[iComp]<<" ");
-          }
-          ADDMSG(MYVALUEDEBUG,"| ");
-        }
-        ADDMSG(MYVALUEDEBUG,"} ");
-      }
-      ADDMSG(MYDEBUG,"\n");
-    }
-  }
-
-  //----------------------------------------------------------------------------
-  PTimeStampValueBase 
-  TWrapper
-  ::GetPTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
-                       const TMKey2Profile& theMKey2Profile,
-                       const TKey2Gauss& theKey2Gauss,
-                       TErr* theErr)
-  {
-    PFieldInfo aFieldInfo = theTimeStampInfo->GetFieldInfo();
-    PTimeStampValueBase anInfo = CrTimeStampValue(theTimeStampInfo,
-                                                  aFieldInfo->GetType());
-    GetTimeStampValue(anInfo, 
-                      theMKey2Profile, 
-                      theKey2Gauss,
-                      theErr);
-#ifdef _DEBUG_
-    if(aFieldInfo->GetType() == eFLOAT64)
-      Print<TFloatTimeStampValue>(anInfo);
-    else
-      Print<TIntTimeStampValue>(anInfo);
-#endif
-    return anInfo;
-  }
-
-  //----------------------------------------------------------------------------
-  void 
-  TWrapper
-  ::GetTimeStampVal(const PTimeStampVal& theVal,
-                    const TMKey2Profile& theMKey2Profile,
-                    const TKey2Gauss& theKey2Gauss,
-                    TErr* theErr)
-  {
-    PTimeStampInfo aTimeStampInfo = theVal->GetTimeStampInfo();
-    PFieldInfo aFieldInfo = aTimeStampInfo->GetFieldInfo();
-    if(aFieldInfo->GetType() == eFLOAT64)
-      GetTimeStampValue(theVal,
-                        theMKey2Profile,
-                        theKey2Gauss,
-                        theErr);
-    else{
-      PTimeStampValueBase aVal = CrTimeStampValue(aTimeStampInfo,
-                                                  theVal,
-                                                  eINT);
-      GetTimeStampValue(aVal,
-                        theMKey2Profile,
-                        theKey2Gauss,
-                        theErr);
-      CopyTimeStampValueBase(aVal, theVal);
-    }
-  }
-
-  //----------------------------------------------------------------------------
-  void
-  TWrapper
-  ::SetTimeStamp(const PTimeStampVal& theVal,
-                 TErr* theErr)
-  {
-    PTimeStampInfo aTimeStampInfo = theVal->GetTimeStampInfo();
-    PFieldInfo aFieldInfo = aTimeStampInfo->GetFieldInfo();
-    if(aFieldInfo->GetType() == eFLOAT64)
-      SetTimeStampValue(theVal, theErr);
-    else{
-      PTimeStampValueBase aVal = CrTimeStampValue(aTimeStampInfo,
-                                                  eINT,
-                                                  theVal->GetGeom2Profile(),
-                                                  theVal->GetModeSwitch());
-      CopyTimeStampValueBase(theVal, aVal);
-      SetTimeStampValue(aVal, theErr);
-    }
-  }
-
-  //----------------------------------------------------------------------------
-  PTimeStampVal
-  TWrapper
-  ::CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
-                   const TGeom2Profile& theGeom2Profile,
-                   EModeSwitch theMode)
-  {
-    return CrTimeStampValue(theTimeStampInfo,
-                            eFLOAT64,
-                            theGeom2Profile,
-                            theMode);
-  }
-
-  //----------------------------------------------------------------------------
-  PTimeStampVal
-  TWrapper
-  ::CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
-                   const PTimeStampVal& theInfo)
-  {
-    return CrTimeStampValue(theTimeStampInfo,
-                            theInfo,
-                            eFLOAT64);
-  }
-
-  //----------------------------------------------------------------------------
-  PTimeStampVal 
-  TWrapper
-  ::GetPTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
-                     const TMKey2Profile& theMKey2Profile,
-                     const TKey2Gauss& theKey2Gauss,
-                     TErr* theErr)
-  {
-    PTimeStampVal anInfo = CrTimeStampVal(theTimeStampInfo);
-    GetTimeStampVal(anInfo, 
-                    theMKey2Profile, 
-                    theKey2Gauss,
-                    theErr);
-    return anInfo;
-  }
-
-  //----------------------------------------------------------------------------
-  PGrilleInfo
-  TWrapper
-  ::GetPGrilleInfo(const PMeshInfo& theMeshInfo)
-  {
-    if(theMeshInfo->GetType() != eSTRUCTURE)
-      return PGrilleInfo();
-
-    EGrilleType type;
-    GetGrilleType(*theMeshInfo,type);
-    PGrilleInfo anInfo;
-    if(type == eGRILLE_STANDARD){
-      const TInt nnoeuds = GetNbNodes(*theMeshInfo);
-      anInfo = CrGrilleInfo(theMeshInfo,type,nnoeuds);
-    }
-    else {
-      TIntVector aVec;
-      aVec.resize(theMeshInfo->GetDim());
-      for(int aAxe=0;aAxe<theMeshInfo->GetDim();aAxe++){
-        ETable aATable = eCOOR_IND1;
-        switch(aAxe){
-        case 0:
-          aATable = eCOOR_IND1;
-          break;
-        case 1:
-          aATable = eCOOR_IND2;
-          break;
-        case 2:
-          aATable = eCOOR_IND3;
-          break;
-        }
-        aVec[aAxe] = GetNbNodes(*theMeshInfo,aATable);
-      }
-      anInfo = CrGrilleInfo(theMeshInfo,type,aVec);
-    }
-
-    GetGrilleInfo(anInfo);
-    anInfo->SetGrilleType(type);
-
-#ifdef _DEBUG_
-    INITMSG(MYDEBUG,"GetPGrilleInfo: ");
-    {
-      TInt aNbElem = anInfo->GetNbNodes();
-      BEGMSG(MYVALUEDEBUG,"GetFamNumNode: ");
-      for(TInt iElem = 0; iElem < aNbElem; iElem++){
-        ADDMSG(MYVALUEDEBUG,anInfo->GetFamNumNode(iElem)<<", ");
-      }
-      TInt aNbCells = anInfo->GetNbCells();
-      BEGMSG(MYVALUEDEBUG,"GetFamNum: ");
-      for(TInt iElem = 0; iElem < aNbCells; iElem++){
-        ADDMSG(MYVALUEDEBUG,anInfo->GetFamNum(iElem)<<", ");
-      }
-      ADDMSG(MYVALUEDEBUG, std::endl);
-      BEGMSG(MYVALUEDEBUG,"GetCoordName: ");
-      for(TInt iElem = 0; iElem < theMeshInfo->GetDim(); iElem++){
-        ADDMSG(MYVALUEDEBUG,anInfo->GetCoordName(iElem)<<", ");
-      }
-      ADDMSG(MYVALUEDEBUG, std::endl);
-      BEGMSG(MYVALUEDEBUG,"GetCoordUnit: ");
-      for(TInt iElem = 0; iElem < theMeshInfo->GetDim(); iElem++){
-        ADDMSG(MYVALUEDEBUG,anInfo->GetCoordUnit(iElem)<<", ");
-      }
-      ADDMSG(MYVALUEDEBUG, std::endl);
-      
-    }
-#endif
-    
-    return anInfo;
-  }
-  
-  //----------------------------------------------------------------------------
-  PGrilleInfo
-  TWrapper
-  ::GetPGrilleInfo(const PMeshInfo& theMeshInfo,
-                   const PGrilleInfo& theInfo)
-  {
-    PGrilleInfo anInfo = CrGrilleInfo(theMeshInfo,theInfo);
-    return anInfo;
-  }  
-}

src/MEDWrapper/CMakeLists.txt

@@ -17,6 +17,70 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
-ADD_SUBDIRECTORY(Base)
+# --- options ---
-ADD_SUBDIRECTORY(V2_2)
+# additional include directories
-ADD_SUBDIRECTORY(Factory)
+INCLUDE_DIRECTORIES(
+  ${Boost_INCLUDE_DIRS}
+  ${HDF5_INCLUDE_DIRS}
+  ${MEDFILE_INCLUDE_DIRS}
+  ${KERNEL_INCLUDE_DIRS}
+)
+
+# additional preprocessor / compiler flags
+ADD_DEFINITIONS(
+  ${BOOST_DEFINITIONS}
+  ${HDF5_DEFINITIONS}
+)
+
+SET(_link_LIBRARIES
+  ${Boost_LIBRARIES}
+  ${HDF5_LIBS}
+  ${MEDFILE_C_LIBRARIES}
+)
+
+# --- headers ---
+
+# header files / no moc processing
+SET(MEDWrapper_HEADERS
+  MED_Algorithm.hxx
+  MED_Common.hxx
+  MED_CoordUtils.hxx
+  MED_Factory.hxx
+  MED_GaussDef.hxx
+  MED_GaussUtils.hxx
+  MED_SharedPtr.hxx
+  MED_SliceArray.hxx
+  MED_Structures.hxx
+  MED_TStructures.hxx
+  MED_Utilities.hxx
+  MED_Vector.hxx
+  MED_Wrapper.hxx
+  MED_WrapperDef.hxx
+)
+
+# --- sources ---
+
+# sources / static
+SET(MEDWrapper_SOURCES
+  MED_Algorithm.cxx
+  MED_Common.cxx
+  MED_CoordUtils.cxx
+  MED_Factory.cxx
+  MED_GaussDef.cxx
+  MED_GaussUtils.cxx
+  MED_Structures.cxx
+  MED_Utilities.cxx
+  MED_Wrapper.cxx
+)
+
+# --- rules ---
+
+ADD_LIBRARY(MEDWrapper ${MEDWrapper_SOURCES})
+TARGET_LINK_LIBRARIES(MEDWrapper ${_link_LIBRARIES})
+INSTALL(TARGETS MEDWrapper EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
+
+ADD_EXECUTABLE(mprint_version mprint_version.cxx)
+TARGET_LINK_LIBRARIES(mprint_version ${MEDFILE_C_LIBRARIES})
+INSTALL(TARGETS mprint_version EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_BINS})
+
+INSTALL(FILES ${MEDWrapper_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})

src/MEDWrapper/Factory/CMakeLists.txt

@@ -1,73 +0,0 @@
-# Copyright (C) 2012-2016  CEA/DEN, EDF R&D, OPEN CASCADE
-#
-# 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
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
-# --- options ---
-# additional include directories
-INCLUDE_DIRECTORIES(
-  ${HDF5_INCLUDE_DIRS}
-  ${Boost_INCLUDE_DIRS}
-  ${MEDFILE_INCLUDE_DIRS}
-  ${KERNEL_INCLUDE_DIRS}
-  ${CMAKE_CURRENT_SOURCE_DIR}/../Base
-  ${CMAKE_CURRENT_SOURCE_DIR}/../V2_2
-)
-
-# additional preprocessor / compiler flags
-ADD_DEFINITIONS(
-  ${HDF5_DEFINITIONS}
-  ${BOOST_DEFINITIONS}
-)
-
-SET(_link_LIBRARIES
-  MEDWrapperBase
-  MEDWrapper_V2_2
-  ${Boost_LIBRARIES}
-  ${MEDFILE_C_LIBRARIES}
-)
-
-# --- headers ---
-
-# header files / no moc processing
-SET(MEDWrapper_HEADERS
-  MED_Factory.hxx
-  MED_WrapperFactory.hxx
-)
-
-# --- sources ---
-
-# sources / static
-SET(MEDWrapper_SOURCES
-  MED_Factory.cxx
-)
-
-# --- rules ---
-
-ADD_LIBRARY(MEDWrapper ${MEDWrapper_SOURCES})
-TARGET_LINK_LIBRARIES(MEDWrapper ${_link_LIBRARIES} ${MED_medloader} )
-INSTALL(TARGETS MEDWrapper EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
-
-ADD_EXECUTABLE(mprint_version mprint_version.cxx)
-TARGET_LINK_LIBRARIES(mprint_version ${_link_LIBRARIES} MEDWrapper)
-
-ADD_EXECUTABLE(MED_Test MED_Test.cxx)
-TARGET_LINK_LIBRARIES(MED_Test ${_link_LIBRARIES} MEDWrapper)
-
-INSTALL(TARGETS mprint_version MED_Test EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_BINS})
-
-INSTALL(FILES ${MEDWrapper_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})

src/MEDWrapper/Factory/MED_Factory.cxx

@@ -1,167 +0,0 @@
-// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
-//
-// Copyright (C) 2003-2007  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, 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
-//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
-
-#include "MED_Factory.hxx"
-#include "MED_Utilities.hxx"
-#include "MED_V2_2_Wrapper.hxx"
-
-#include <stdio.h>
-#include <errno.h>
-#include <sstream>
-
-#include <med.h>
-extern "C"
-{
-#ifndef WIN32
-  #include <unistd.h>
-#endif
-}
-
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-#else
-static int MYDEBUG = 0;
-#endif
-
-namespace MED
-{
-  
-  EVersion GetVersionId(const std::string& theFileName,
-                        bool theDoPreCheckInSeparateProcess)
-  {
-    INITMSG(MYDEBUG,"GetVersionId - theFileName = '"<<theFileName<<"'"<<std::endl);
-    EVersion aVersion = eVUnknown;    
-
-#ifndef WIN32
-    if (access(theFileName.c_str(),F_OK))
-      return aVersion;
-    if ( theDoPreCheckInSeparateProcess ) {
-      // First check, is it possible to deal with the file
-      std::ostringstream aStr;
-      // File name is in quotes for the case of space(s) inside it (PAL13009)
-      aStr<<"bash -c \""<<getenv("SMESH_ROOT_DIR")<<"/bin/salome/mprint_version \'"<<theFileName<<"\'\"";
-      if(!MYDEBUG)
-        aStr<<" 2>&1 > /dev/null";
-
-      std::string aCommand = aStr.str();
-      int aStatus = system(aCommand.c_str());
-
-      BEGMSG( MYDEBUG,"aCommand = '" << aCommand << "'; aStatus = " << aStatus
-             << "; errno = " << errno << " = " << strerror( errno ) << std::endl );
-      if ( aStatus != 0 && errno != EAGAIN && errno != ENOMEM ) // "Cannot allocate memory" is OK
-        return aVersion;
-    }
-#endif
-    // check compatibility of hdf and med versions
-    med_bool hdfok, medok;
-    MEDfileCompatibility(theFileName.c_str(), &hdfok, &medok);
-    if ((!hdfok) /*|| (!medok)*/) // med-2.1 is KO since med-3.0.0
-      return aVersion;
-
-    // Next, try to open the file trough the MED API
-    const char* aFileName = theFileName.c_str();
-    med_idt aFid = MEDfileOpen(aFileName,MED_ACC_RDONLY);
-
-    MSG(MYDEBUG,"GetVersionId - theFileName = '"<<theFileName<<"'; aFid = "<<aFid<<std::endl);
-    if(aFid >= 0){
-      med_int aMajor, aMinor, aRelease;
-      med_err aRet = MEDfileNumVersionRd(aFid,&aMajor,&aMinor,&aRelease);
-      INITMSG(MYDEBUG,"GetVersionId - theFileName = '"<<theFileName<<"'; aRet = "<<aRet<<std::endl);
-      if(aRet >= 0){
-        if(aMajor == 2 && aMinor == 1)
-          aVersion = eV2_1;
-        else
-          aVersion = eV2_2;
-      }
-      else {
-        // VSR: simulate med 2.3.6 behavior, med file version is assumed to 2.1
-        aVersion = eV2_1;
-      }
-    }
-    MEDfileClose(aFid);
-
-    BEGMSG(MYDEBUG,"GetVersionId - theFileName = '"<<theFileName<<"'; aVersion = "<<aVersion<<std::endl);
-    return aVersion;
-  }
-
-  bool getMEDVersion( const std::string& fname, int& major, int& minor, int& release )
-  {
-    med_idt f = MEDfileOpen(fname.c_str(), MED_ACC_RDONLY );
-    if( f<0 )
-      return false;
-
-    med_int aMajor, aMinor, aRelease;
-    med_err aRet = MEDfileNumVersionRd( f, &aMajor, &aMinor, &aRelease );
-    major = aMajor;
-    minor = aMinor;
-    release = aRelease;
-    MEDfileClose( f );
-    if( aRet<0 ) {
-      // VSR: simulate med 2.3.6 behavior, med file version is assumed to 2.1
-      major = 2; minor = release = -1;
-      //return false;
-    }
-    return true;
-  }
-
-  PWrapper CrWrapper(const std::string& theFileName,
-                     bool theDoPreCheckInSeparateProcess)
-  {
-    PWrapper aWrapper;
-    EVersion aVersion = GetVersionId(theFileName,theDoPreCheckInSeparateProcess);
-    switch(aVersion){
-    case eV2_2:
-      aWrapper.reset(new MED::V2_2::TVWrapper(theFileName));
-      break;
-    case eV2_1:
-      EXCEPTION(std::runtime_error,"Cannot open file '"<<theFileName<<"'. Med version 2.1 is not supported any more.");
-      //aWrapper.reset(new MED::V2_1::TVWrapper(theFileName));
-      break;
-    default:
-      EXCEPTION(std::runtime_error,"MED::CrWrapper - theFileName = '"<<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:
-      EXCEPTION(std::runtime_error,"Cannot open file '"<<theFileName<<"'. Med version 2.1 is not supported any more.");
-      //aWrapper.reset(new MED::V2_1::TVWrapper(theFileName));
-      break;
-    default:
-      aWrapper.reset(new MED::V2_2::TVWrapper(theFileName));
-    }
-    return aWrapper;
-  }
-
-}

src/MEDWrapper/Factory/MED_Test.cxx

@@ -1,347 +0,0 @@
-// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
-//
-// Copyright (C) 2003-2007  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, 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
-//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
-#include "MED_Utilities.hxx"
-#include "MED_Algorithm.hxx"
-#include "MED_GaussUtils.hxx"
-#include "MED_Factory.hxx"
-
-#ifdef _DEBUG_
-static int MYDEBUG = 1;
-#else
-// static int MYDEBUG = 0;
-#endif
-
-static int MYWRITEDEBUG = 1;
-
-using namespace MED;
-
-#undef _DEBUG_
-
-void CheckMed(const std::string& theFileName)
-{
-  MSG(MYDEBUG,"CheckMed - theFileName = '"<<theFileName<<"'");
-  {
-    //TErr anErr;
-    PWrapper aMed = CrWrapper(theFileName);
-
-    TKey2Gauss aKey2Gauss = GetKey2Gauss(aMed);
-    TMKey2Profile aMKey2Profile = GetMKey2Profile(aMed);
-    INITMSG(MYDEBUG,"aMed->GetNbProfiles() = "<<aMed->GetNbProfiles()<<std::endl);
-
-    TInt aNbMeshes = aMed->GetNbMeshes();
-    BEGMSG(MYDEBUG,"GetNbMeshes() = "<<aNbMeshes<<std::endl);
-    for(TInt iMesh = 1; iMesh <= aNbMeshes; iMesh++){
-      
-      PMeshInfo aMeshInfo = aMed->GetPMeshInfo(iMesh);
-      INITMSG(MYDEBUG,"aMeshInfo->GetName() = '"<<aMeshInfo->GetName()<<"'"<<std::endl);
-
-      TEntityInfo aEntityInfo = aMed->GetEntityInfo(aMeshInfo);
-      
-      TEntity2TGeom2ElemInfo anEntity2TGeom2ElemInfo = 
-        GetEntity2TGeom2ElemInfo(aMed,aMeshInfo,aEntityInfo);
-
-      TFieldInfo2TimeStampInfoSet aFieldInfo2TimeStampInfoSet = 
-        GetFieldInfo2TimeStampInfoSet(aMed,aMeshInfo,aEntityInfo);
-      
-      TEntite2TFieldInfo2TimeStampInfoSet anEntite2TFieldInfo2TimeStampInfoSet = 
-        GetEntite2TFieldInfo2TimeStampInfoSet(aFieldInfo2TimeStampInfoSet);
-
-      TEntite2TFieldInfo2TimeStampInfoSet::const_iterator anEntite2TFieldInfo2TimeStampInfoSetIter = 
-        anEntite2TFieldInfo2TimeStampInfoSet.begin();
-      for(; anEntite2TFieldInfo2TimeStampInfoSetIter != anEntite2TFieldInfo2TimeStampInfoSet.end(); anEntite2TFieldInfo2TimeStampInfoSetIter++){
-        const TFieldInfo2TimeStampInfoSet& aFieldInfo2TimeStampInfoSet = anEntite2TFieldInfo2TimeStampInfoSetIter->second;
-        TFieldInfo2TimeStampInfoSet::const_iterator aFieldInfo2TimeStampInfoSetIter = aFieldInfo2TimeStampInfoSet.begin();
-        for(; aFieldInfo2TimeStampInfoSetIter != aFieldInfo2TimeStampInfoSet.end(); aFieldInfo2TimeStampInfoSetIter++){
-          PFieldInfo aFieldInfo = aFieldInfo2TimeStampInfoSetIter->first;
-          INITMSG(MYDEBUG,
-                  "GetPFieldInfo "<<
-                  "- aName = '"<<aFieldInfo->GetName()<<"'"<<
-                  "; aType = "<<aFieldInfo->GetType()<<
-                  "; aNbComp = "<<aFieldInfo->GetNbComp()<<
-                  std::endl);
-          const TTimeStampInfoSet& aTimeStampInfoSet = aFieldInfo2TimeStampInfoSetIter->second;
-          TTimeStampInfoSet::const_iterator aTimeStampInfoSettIter = aTimeStampInfoSet.begin();
-          for(; aTimeStampInfoSettIter != aTimeStampInfoSet.end(); aTimeStampInfoSettIter++){
-            PTimeStampInfo aTimeStampInfo = *aTimeStampInfoSettIter;
-            INITMSG(MYDEBUG,
-                    "GetPTimeStampInfo "<<
-                    "- anEntity = "<<aTimeStampInfo->GetEntity()<<
-                    "; aNumDt = "<<aTimeStampInfo->GetNumDt()<<
-                    std::endl);
-            PTimeStampValueBase aTimeStampValue = 
-              aMed->GetPTimeStampValue(aTimeStampInfo,
-                                       aMKey2Profile,
-                                       aKey2Gauss);
-          }
-        }
-      }
-
-      continue;
-
-      TFamilyInfoSet aFamilyInfoSet = GetFamilyInfoSet(aMed,aMeshInfo);
-      
-      TEntity2FamilySet aEntity2FamilySet = 
-        GetEntity2FamilySet(aMed,anEntity2TGeom2ElemInfo,aFamilyInfoSet);
-      
-      TGroupInfo aGroupInfo = GetGroupInfo(aFamilyInfoSet);
-      
-      PNodeInfo aNodeInfo = aMed->GetPNodeInfo(aMeshInfo);
-      TEntity2TGeom2ElemInfo::const_iterator anIter = anEntity2TGeom2ElemInfo.begin();
-      for(; anIter != anEntity2TGeom2ElemInfo.end(); anIter++){
-        const EEntiteMaillage& anEntity = anIter->first;
-        if(anEntity != eNOEUD){
-          const TGeom2ElemInfo& aGeom2ElemInfo = anIter->second;
-          TKey2Gauss::const_iterator anIter2 = aKey2Gauss.begin();
-          for(; anIter2 != aKey2Gauss.end(); anIter2++){
-            const TGaussInfo::TKey& aKey = anIter2->first;
-            EGeometrieElement aGeom = boost::get<0>(aKey);
-            TGeom2ElemInfo::const_iterator anIter3 = aGeom2ElemInfo.find(aGeom);
-            if(anIter3 != aGeom2ElemInfo.end()){
-              if(PCellInfo aCellInfo = anIter3->second){
-                PGaussInfo aGaussInfo = anIter2->second;
-                TGaussCoord aGaussCoord;
-                GetGaussCoord3D(aGaussInfo,aCellInfo,aNodeInfo,aGaussCoord);
-              }
-            }
-          }
-        }
-      }
-      
-    }
-  }
-  MSG(MYDEBUG,"OK");
-}
-
-
-void CopyMed(const PWrapper& theMed, 
-             const PWrapper& theMed2, 
-             int theIncr)
-{
-  TKey2Gauss aKey2Gauss = GetKey2Gauss(theMed);
-  TMKey2Profile aMKey2Profile = GetMKey2Profile(theMed);
-
-  TInt aNbMeshes = theMed->GetNbMeshes();
-  MSG(MYDEBUG,"aNbMeshes = "<<aNbMeshes);
-  std::string aName;
-  for(TInt iMesh = 0; iMesh < aNbMeshes; iMesh++){
-    PMeshInfo aMeshInfo = theMed->GetPMeshInfo(iMesh+1);
-#ifdef _DEBUG_
-    TInt aDim = aMeshInfo->myDim;
-    aName = aMeshInfo->GetName();
-    INITMSG(MYDEBUG,"GetMeshInfo - aName = '"<<aName<<"'; aDim = "<<aDim<<"\n");
-#endif
-    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);
-#ifdef _DEBUG_
-      TInt aNbComp = aFieldInfo->GetNbComp();
-      INITMSG(MYDEBUG,"aName = '"<<aFieldInfo->GetName()<<"'; aNbComp = "<<aNbComp<<";\n");
-#endif
-      PFieldInfo aFieldInfo2 = theMed->CrFieldInfo(aMeshInfo2,aFieldInfo);
-
-      if(MYWRITEDEBUG){
-        aName = aFieldInfo->GetName();
-        aName[0] += theIncr;
-        aFieldInfo2->SetName(aName);
-        theMed2->SetFieldInfo(aFieldInfo2);
-      }
-
-      EEntiteMaillage anEntity;
-      TGeom2Size aGeom2Size;
-      TInt aNbTimeStamps = 
-        theMed->GetNbTimeStamps(aFieldInfo,aEntityInfo,anEntity,aGeom2Size);
-      {
-        INITMSG(MYDEBUG,"GetNbTimeStamps = "<<aNbTimeStamps<<std::endl);
-        for(TInt iTimeStamp = 0; iTimeStamp < aNbTimeStamps; iTimeStamp++){
-          PTimeStampInfo aTimeStampInfo = 
-          theMed->GetPTimeStampInfo(aFieldInfo,anEntity,aGeom2Size,iTimeStamp+1);
-#ifdef _DEBUG_
-          TInt aNumDt = aTimeStampInfo->GetNumDt();
-          INITMSG(MYDEBUG,"aNumDt = "<<aNumDt<<"\n");
-#endif
-          
-          PTimeStampInfo aTimeStampInfo2 = 
-            theMed->CrTimeStampInfo(aFieldInfo2,aTimeStampInfo);
-          
-          PTimeStampValueBase aTimeStampValue = 
-            theMed->GetPTimeStampValue(aTimeStampInfo,
-                                       aMKey2Profile,
-                                       aKey2Gauss);
-          
-          PTimeStampValueBase aTimeStampValue2 = 
-            theMed->CrTimeStampValue(aTimeStampInfo2,
-                                     aTimeStampValue);
-          
-          if(MYWRITEDEBUG) theMed2->SetTimeStamp(aTimeStampValue2);
-        }
-      }
-    }
-
-    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();
-#ifdef _DEBUG_
-      TInt aNbAttr = aFamilyInfo->GetNbAttr();
-#endif
-      TInt anId = aFamilyInfo->GetId();
-      if(anId == 0)
-        continue;
-
-      aName = aFamilyInfo->GetName();
-#ifdef _DEBUG_
-      INITMSG(MYDEBUG,"aName = '"<<aName<<"'; anId = "<<anId<<
-              "; aNbAttr = "<<aNbAttr<<"; aNbGroup = "<<aNbGroup<<"\n");
-#endif
-      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)<<std::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);
-        PNodeInfo aNodeInfo2 = theMed->CrNodeInfo(aMeshInfo2,aNodeInfo);
-        if(MYWRITEDEBUG) theMed2->SetNodeInfo(aNodeInfo2);
-        continue;
-      }
-      TGeom2Size& aGeom2Size = anEntityInfoIter->second;
-      TGeom2Size::iterator aGeomIter = aGeom2Size.begin();
-      for(; aGeomIter != aGeom2Size.end(); aGeomIter++){
-        const EGeometrieElement& aGeom = aGeomIter->first;
-#ifdef _DEBUG_
-        const TInt& aNbElem = aGeomIter->second;
-        INITMSG(MYDEBUG,"aGeom = "<<aGeom<<"; aNbElem = "<<aNbElem<<": ");
-#endif
-        switch(aGeom){
-        case ePOLYGONE: {
-          PPolygoneInfo aPolygoneInfo = theMed->GetPPolygoneInfo(aMeshInfo,anEntity,aGeom);
-          PPolygoneInfo aPolygoneInfo2 = theMed->CrPolygoneInfo(aMeshInfo2,aPolygoneInfo);
-          if(MYWRITEDEBUG) theMed2->SetPolygoneInfo(aPolygoneInfo2);
-          break;
-        }
-        case ePOLYEDRE: {
-          PPolyedreInfo aPolyedreInfo = theMed->GetPPolyedreInfo(aMeshInfo,anEntity,aGeom);
-          PPolyedreInfo aPolyedreInfo2 = theMed->CrPolyedreInfo(aMeshInfo2,aPolyedreInfo);
-          if(MYWRITEDEBUG) theMed2->SetPolyedreInfo(aPolyedreInfo2);
-          break;
-        }
-        default:
-          PCellInfo aCellInfo = theMed->GetPCellInfo(aMeshInfo,anEntity,aGeom);
-          PCellInfo aCellInfo2 = theMed2->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<<"', theVersion = "<<theVersion);
-
-  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_2,
-             int theNbCopy = 1)
-{
-  MSG(MYDEBUG,"theFileName = '"<<theFileName<<"'; "<<
-      "theFileName2 = '"<<theFileName2<<"'; "<<
-      "theVersion = "<<theVersion<<"; "<<
-      "theNbCopy = "<<theNbCopy);
-
-  CopyMed(theFileName,theFileName2,theVersion,theNbCopy);
-}
-
-#ifdef WIN32
-#pragma warning(disable:4101) // exc unreferenced ... ??
-#endif
-
-int main(int argc, char** argv){ 
-#ifndef _DEBUG_
-  try{
-#endif
-    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;
-#ifndef _DEBUG_
-  }catch(std::exception& exc){
-    MSG(MYDEBUG,"Follow exception was accured :\n"<<exc.what());
-  }catch(...){
-    MSG(MYDEBUG,"Unknown exception was accured");
-  } 
-#endif 
-  return 1;
-}

src/MEDWrapper/MED_Algorithm.cxx

@@ -19,24 +19,24 @@
 //
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
+
 #include "MED_Algorithm.hxx"
 #include "MED_Wrapper.hxx"
-
 #include "MED_Utilities.hxx"
- 
+
 #ifdef _DEBUG_
 static int MYDEBUG = 0;
 static int MYVALUEDEBUG = 0;
 #else
-// static int MYDEBUG = 0;
+static int MYDEBUG = 0;
-// static int MYVALUEDEBUG = 0;
+static int MYVALUEDEBUG = 0;
 #endif
 
 namespace MED
 {
   //---------------------------------------------------------------
-  TEntity2TGeom2ElemInfo 
+  TEntity2TGeom2ElemInfo
-  GetEntity2TGeom2ElemInfo(const PWrapper& theWrapper, 
+  GetEntity2TGeom2ElemInfo(const PWrapper& theWrapper,
                            const PMeshInfo& theMeshInfo,
                            const MED::TEntityInfo& theEntityInfo)
   {
@@ -64,8 +64,7 @@ namespace MED
     ADDMSG(MYDEBUG,"\n");
     return anEntity2TGeom2ElemInfo;
   }
-  
+
-  
   //---------------------------------------------------------------
   TFamilyInfoSet
   GetFamilyInfoSet(const PWrapper& theWrapper,
@@ -85,7 +84,6 @@ namespace MED
     return aFamilyInfoSet;
   }
 
-
   //---------------------------------------------------------------
   TGroupInfo
   GetGroupInfo(const TFamilyInfoSet& theFamilyInfoSet)
@@ -98,7 +96,7 @@ namespace MED
       TInt aNbGroup = aFamilyInfo->GetNbGroup();
       for(TInt iGroup = 0; iGroup < aNbGroup; iGroup++){
         aGroup[aFamilyInfo->GetGroupName(iGroup)].insert(aFamilyInfo);
-      } 
+      }
     }
 
 #ifdef _DEBUG_
@@ -121,10 +119,9 @@ namespace MED
     return aGroup;
   }
 
-
   //---------------------------------------------------------------
-  TFieldInfo2TimeStampInfoSet 
+  TFieldInfo2TimeStampInfoSet
-  GetFieldInfo2TimeStampInfoSet(const PWrapper& theWrapper, 
+  GetFieldInfo2TimeStampInfoSet(const PWrapper& theWrapper,
                                 const PMeshInfo& theMeshInfo,
                                 const MED::TEntityInfo& theEntityInfo)
   {
@@ -141,7 +138,7 @@ namespace MED
       TInt aNbTimeStamps = theWrapper->GetNbTimeStamps(aFieldInfo,theEntityInfo,anEntity,aGeom2Size);
       ADDMSG(MYDEBUG,"anEntity = "<<anEntity<<"; GetNbTimeStamps = "<<aNbTimeStamps<<"\n");
       for(TInt iTimeStamp = 1; iTimeStamp <= aNbTimeStamps; iTimeStamp++){
-        PTimeStampInfo aTimeStamp = 
+        PTimeStampInfo aTimeStamp =
           theWrapper->GetPTimeStampInfo(aFieldInfo,anEntity,aGeom2Size,iTimeStamp);
         aFieldInfo2TimeStampInfoSet[aFieldInfo].insert(aTimeStamp);
         INITMSG(MYDEBUG,
@@ -152,10 +149,9 @@ namespace MED
     ADDMSG(MYDEBUG,"\n");
     return aFieldInfo2TimeStampInfoSet;
   }
-  
 
   //---------------------------------------------------------------
-  TEntite2TFieldInfo2TimeStampInfoSet 
+  TEntite2TFieldInfo2TimeStampInfoSet
   GetEntite2TFieldInfo2TimeStampInfoSet(const TFieldInfo2TimeStampInfoSet& theFieldInfo2TimeStampInfoSet)
   {
     TEntite2TFieldInfo2TimeStampInfoSet anEntite2TFieldInfo2TimeStampInfoSet;
@@ -163,14 +159,13 @@ namespace MED
     for(; anIter != theFieldInfo2TimeStampInfoSet.end(); anIter++){
       const TTimeStampInfoSet& aTimeStampInfoSet = anIter->second;
       //const PFieldInfo& aFieldInfo = anIter->first;
-      if(aTimeStampInfoSet.empty()) 
+      if(aTimeStampInfoSet.empty())
         continue;
       const PTimeStampInfo& aTimeStampInfo = *aTimeStampInfoSet.begin();
       anEntite2TFieldInfo2TimeStampInfoSet[ConvertEntity(aTimeStampInfo->GetEntity())].insert(*anIter);
     }
     return anEntite2TFieldInfo2TimeStampInfoSet;
   }
-  
 
   //---------------------------------------------------------------
   bool
@@ -181,16 +176,15 @@ namespace MED
     return aLeftInfo->GetId() < aRightInfo->GetId();
   }
 
-
   //---------------------------------------------------------------
-  TEntity2FamilySet 
+  TEntity2FamilySet
-  GetEntity2FamilySet(const PWrapper& theWrapper, 
+  GetEntity2FamilySet(const PWrapper& theWrapper,
                       const TEntity2TGeom2ElemInfo& theEntity2TGeom2ElemInfo,
                       const TFamilyInfoSet& theFamilyInfoSet)
   {
     MSG(MYDEBUG,"GetFamiliesByEntity(...)");
     TEntity2FamilySet anEntity2FamilySet;
-    
+
     typedef std::map<TInt,PFamilyInfo> TId2Family;
     TId2Family anId2Family;
     TFamilyInfoSet::const_iterator anIter = theFamilyInfoSet.begin();
@@ -198,12 +192,12 @@ namespace MED
       const PFamilyInfo& aFamilyInfo = *anIter;
       anId2Family.insert(TId2Family::value_type(aFamilyInfo->GetId(),aFamilyInfo));
     }
-    
+
     if(!anId2Family.empty()){
       typedef std::map<TInt,TInt> TFamilyID2Size;
       typedef std::map<EEntiteMaillage,TFamilyID2Size> TEntity2FamilyID;
       TEntity2FamilyID anEntity2FamilyID;
-      
+
       if(!theEntity2TGeom2ElemInfo.empty()){
         TEntity2TGeom2ElemInfo::const_iterator anIter = theEntity2TGeom2ElemInfo.begin();
         for(; anIter != theEntity2TGeom2ElemInfo.end(); anIter++){
@@ -221,7 +215,7 @@ namespace MED
           }
         }
       }
-      
+
       if(!anEntity2FamilyID.empty()){
         TEntity2FamilyID::const_iterator anIter = anEntity2FamilyID.begin();
         for(; anIter != anEntity2FamilyID.end(); anIter++){
@@ -243,15 +237,14 @@ namespace MED
           }
         }
       }
-    }    
+    }
     ADDMSG(MYDEBUG,"\n");
     return anEntity2FamilySet;
   }
-  
 
   //---------------------------------------------------------------
   TKey2Gauss
-  GetKey2Gauss(const PWrapper& theWrapper, 
+  GetKey2Gauss(const PWrapper& theWrapper,
                TErr* theErr,
                EModeSwitch theMode)
   {
@@ -278,10 +271,9 @@ namespace MED
     return aKey2Gauss;
   }
 
-
   //---------------------------------------------------------------
   PProfileInfo
-  GetProfileInfo(const PWrapper& theWrapper, 
+  GetProfileInfo(const PWrapper& theWrapper,
                  const std::string& theProfileName,
                  TErr* theErr,
                  EModeProfil theMode)
@@ -296,11 +288,10 @@ namespace MED
     }
     return anInfo;
   }
-  
 
   //---------------------------------------------------------------
   TMKey2Profile
-  GetMKey2Profile(const PWrapper& theWrapper, 
+  GetMKey2Profile(const PWrapper& theWrapper,
                   TErr* theErr,
                   EModeProfil theMode)
   {
@@ -312,7 +303,7 @@ namespace MED
       PProfileInfo anInfo = theWrapper->GetPProfileInfo(anId,theMode,theErr);
       const std::string& aName = boost::get<0>(aPreInfo);
       aKey2Profile[aName] = anInfo;
-      
+
 #ifdef _DEBUG_
       INITMSG(MYDEBUG,
               "- aName = '"<<aName<<"'"<<
@@ -324,14 +315,16 @@ namespace MED
       }
       ADDMSG(MYVALUEDEBUG, std::endl);
 #endif
-      
+
     }
     return TMKey2Profile(theMode,aKey2Profile);
   }
 
   //---------------------------------------------------------------
   EEntiteMaillage
-  GetEntityByFamilyId(PGrilleInfo& theInfo,TInt theId){
+  GetEntityByFamilyId(PGrilleInfo& theInfo,
+                      TInt theId)
+  {
     TElemNum::iterator aNodeFamIter = (theInfo->myFamNumNode).begin();
     for(;aNodeFamIter != (theInfo->myFamNumNode).end(); aNodeFamIter++){
       if(theId == *aNodeFamIter)
@@ -346,8 +339,10 @@ namespace MED
     return EEntiteMaillage(-1);
   }
 
+  //---------------------------------------------------------------
   TFamilyID2NbCells
-  GetFamilyID2NbCells(PGrilleInfo& theInfo){
+  GetFamilyID2NbCells(PGrilleInfo& theInfo)
+  {
     TFamilyID2NbCells aFamily2NbCells;
     TInt aNbNodes = theInfo->myFamNumNode.size();
     TInt aNbCells = theInfo->myFamNum.size();
@@ -358,17 +353,21 @@ namespace MED
     return aFamily2NbCells;
   }
 
-  EEntiteMaillage ConvertEntity(const EEntiteMaillage& aEntity){
+  //---------------------------------------------------------------
+  EEntiteMaillage
+  ConvertEntity(const EEntiteMaillage& aEntity)
+  {
     switch( aEntity ){
-      
     case eNOEUD_ELEMENT:
-    case eMAILLE: return eMAILLE; //eNOEUD_ELEMENT it is eMAILLE
+    case eMAILLE:
-      
+      return eMAILLE; // eNOEUD_ELEMENT is eMAILLE
     case eFACE:
     case eARETE:
-    case eNOEUD: return aEntity; break;
+    case eNOEUD:
-    default: return EEntiteMaillage(-1);
+      return aEntity;
-      
+    default:
+      break;
     }
+    return EEntiteMaillage(-1);
   }
 }

src/MEDWrapper/MED_Algorithm.hxx

@@ -19,116 +19,107 @@
 //
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
+
 #ifndef MED_Algorithm_HeaderFile
 #define MED_Algorithm_HeaderFile
 
-#include "MED_WrapperBase.hxx"
+#include "MED_WrapperDef.hxx"
 #include "MED_Structures.hxx"
 
+#include <boost/tuple/tuple.hpp>
+
 #include <set>
+#include <string>
 
 namespace MED
 {
   //---------------------------------------------------------------
   typedef std::map<EGeometrieElement,PElemInfo> TGeom2ElemInfo;
   typedef std::map<EEntiteMaillage,TGeom2ElemInfo> TEntity2TGeom2ElemInfo;
+  typedef std::set<PFamilyInfo> TFamilyInfoSet;
+  typedef std::map<std::string,TFamilyInfoSet> TGroupInfo;
+  typedef boost::tuple<PFamilyInfo,TInt> TFamilyTSize;
+  typedef std::set<TFamilyTSize> TFamilyTSizeSet;
+  typedef std::map<EEntiteMaillage,TFamilyTSizeSet> TEntity2FamilySet;
+  typedef std::set<PTimeStampInfo> TTimeStampInfoSet;
+  typedef std::map<PFieldInfo,TTimeStampInfoSet> TFieldInfo2TimeStampInfoSet;
+  typedef std::map<EEntiteMaillage,TFieldInfo2TimeStampInfoSet> TEntite2TFieldInfo2TimeStampInfoSet;
+  typedef std::map<TGaussInfo::TKey,PGaussInfo,TGaussInfo::TLess> TKey2Gauss;
+  typedef std::map<TProfileInfo::TKey,PProfileInfo> TKey2Profile;
+  typedef boost::tuple<EModeProfil,TKey2Profile> TMKey2Profile;
+  typedef std::map<TInt,TInt> TFamilyID2NbCells;
 
+  //---------------------------------------------------------------
   //! Get set of TElemInfo by its geometrical type and corresponding MED ENTITY
   MEDWRAPPER_EXPORT
   TEntity2TGeom2ElemInfo
-  GetEntity2TGeom2ElemInfo(const PWrapper& theWrapper, 
+  GetEntity2TGeom2ElemInfo(const PWrapper& theWrapper,
                            const PMeshInfo& theMeshInfo,
                            const MED::TEntityInfo& theEntityInfo);
 
-
   //---------------------------------------------------------------
-  typedef std::set<PFamilyInfo> TFamilyInfoSet;
-
   //! Read set of MED FAMILIES for defined MED file
   MEDWRAPPER_EXPORT
   TFamilyInfoSet
-  GetFamilyInfoSet(const PWrapper& theWrapper, 
+  GetFamilyInfoSet(const PWrapper& theWrapper,
                    const PMeshInfo& theMeshInfo);
-  
 
   //---------------------------------------------------------------
-  typedef boost::tuple<PFamilyInfo,TInt> TFamilyTSize;
+  //! Compare two MED FAMILIES
-
+  MEDWRAPPER_EXPORT
   bool
   operator<(const TFamilyTSize& theLeft, const TFamilyTSize& theRight);
-  typedef std::set<TFamilyTSize> TFamilyTSizeSet;
-
 
   //---------------------------------------------------------------
-  typedef std::map<EEntiteMaillage,TFamilyTSizeSet> TEntity2FamilySet;
-  
   //! Split set of MED FAMILIES by corresponding MED ENTITY
   MEDWRAPPER_EXPORT
   TEntity2FamilySet
-  GetEntity2FamilySet(const PWrapper& theWrapper, 
+  GetEntity2FamilySet(const PWrapper& theWrapper,
                       const TEntity2TGeom2ElemInfo& theEntity2TGeom2ElemInfo,
                       const TFamilyInfoSet& theFamilyInfoSet);
-  
 
   //---------------------------------------------------------------
-  typedef std::map<std::string,TFamilyInfoSet> TGroupInfo;
-  
   //! Split the input set of MED FAMILIES by corresponding MED GROUPS
   MEDWRAPPER_EXPORT
   TGroupInfo
   GetGroupInfo(const TFamilyInfoSet& theFamilyInfoSet);
-  
-  
-  //---------------------------------------------------------------
-  typedef std::set<PTimeStampInfo> TTimeStampInfoSet;
-  typedef std::map<PFieldInfo,TTimeStampInfoSet> TFieldInfo2TimeStampInfoSet;
 
+  //---------------------------------------------------------------
   //! Read set of MED TIMESTAMPS groupped by corresponding MED FIELDS
   MEDWRAPPER_EXPORT
   TFieldInfo2TimeStampInfoSet
-  GetFieldInfo2TimeStampInfoSet(const PWrapper& theWrapper, 
+  GetFieldInfo2TimeStampInfoSet(const PWrapper& theWrapper,
                                 const PMeshInfo& theMeshInfo,
                                 const MED::TEntityInfo& theEntityInfo);
-  
 
   //---------------------------------------------------------------
-  typedef std::map<EEntiteMaillage,TFieldInfo2TimeStampInfoSet> TEntite2TFieldInfo2TimeStampInfoSet;
-
   //! Split the input set of MED TIMESTAMPS by corresponding MED FIELDS and MED ENTITIES
   MEDWRAPPER_EXPORT
   TEntite2TFieldInfo2TimeStampInfoSet
   GetEntite2TFieldInfo2TimeStampInfoSet(const TFieldInfo2TimeStampInfoSet& theFieldInfo2TimeStampInfoSet);
 
-
   //---------------------------------------------------------------
-  typedef std::map<TGaussInfo::TKey,PGaussInfo,TGaussInfo::TLess> TKey2Gauss;
-
   //! Read set of MED GAUSS
   MEDWRAPPER_EXPORT
   TKey2Gauss
-  GetKey2Gauss(const PWrapper& theWrapper, 
+  GetKey2Gauss(const PWrapper& theWrapper,
                TErr* theErr = NULL,
                EModeSwitch theMode = eFULL_INTERLACE);
 
-
   //---------------------------------------------------------------
   //! Get MED PROFILE by its name
   MEDWRAPPER_EXPORT
   PProfileInfo
-  GetProfileInfo(const PWrapper& theWrapper, 
+  GetProfileInfo(const PWrapper& theWrapper,
                  const std::string& theProfileName,
                  TErr* theErr = NULL,
                  EModeProfil theMode = eCOMPACT);
 
-
   //---------------------------------------------------------------
-  typedef std::map<TProfileInfo::TKey,PProfileInfo> TKey2Profile;
-  typedef boost::tuple<EModeProfil,TKey2Profile> TMKey2Profile;
-
   //! Read set of MED PROFILES
   MEDWRAPPER_EXPORT
   TMKey2Profile
-  GetMKey2Profile(const PWrapper& theWrapper, 
+  GetMKey2Profile(const PWrapper& theWrapper,
                   TErr* theErr = NULL,
                   EModeProfil theMode = eCOMPACT);
 
@@ -139,18 +130,17 @@ namespace MED
   GetEntityByFamilyId(PGrilleInfo& theInfo,
                       TInt theId);
 
-  typedef std::map<TInt,TInt> TFamilyID2NbCells;
+  //---------------------------------------------------------------
-  
   //! Get Number of cells for theId family, for Grille
   MEDWRAPPER_EXPORT
   TFamilyID2NbCells
   GetFamilyID2NbCells(PGrilleInfo& theInfo);
 
+  //---------------------------------------------------------------
   //! Convert eNOEUD_ELEMENT to eMAILLE
   MEDWRAPPER_EXPORT
   EEntiteMaillage
   ConvertEntity(const EEntiteMaillage& aEntity);
-
 }
 
-#endif
+#endif // MED_Algorithm_HeaderFile

src/MEDWrapper/MED_Common.cxx

@@ -0,0 +1,121 @@
+// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  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, 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
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "MED_Common.hxx"
+#include <med.h>
+
+namespace MED
+{
+  TInt
+  GetDESCLength()
+  {
+    return 200;
+  }
+
+  TInt
+  GetIDENTLength()
+  {
+    return 8;
+  }
+
+  TInt
+  GetNOMLength()
+  {
+    return 64;
+  }
+
+  TInt
+  GetLNOMLength()
+  {
+    return 80;
+  }
+
+  TInt
+  GetPNOMLength()
+  {
+    return 16;
+  }
+
+  void
+  GetVersionRelease(TInt& major, TInt& minor, TInt& release)
+  {
+    major   = MED_MAJOR_NUM;
+    minor   = MED_MINOR_NUM;
+    release = MED_RELEASE_NUM;
+  }
+
+  TInt
+  GetNbConn(EGeometrieElement typmai,
+            EEntiteMaillage typent,
+            TInt mdim)
+  {
+    return typmai % 100;
+  }
+
+  TInt
+  GetNbNodes(EGeometrieElement typmai)
+  {
+    return typmai % 100;
+  }
+
+  const MED::TEntity2GeomSet& GetEntity2GeomSet()
+  {
+    static MED::TEntity2GeomSet Entity2GeomSet;
+
+    if ( Entity2GeomSet.empty() ) {
+      TGeomSet& aGeomARETESet = Entity2GeomSet[MED::eARETE];
+      aGeomARETESet.insert(MED::eSEG2);
+      aGeomARETESet.insert(MED::eSEG3);
+
+      TGeomSet& aGeomFACESet = Entity2GeomSet[MED::eFACE];
+      aGeomFACESet.insert(MED::eTRIA3);
+      aGeomFACESet.insert(MED::eQUAD4);
+      aGeomFACESet.insert(MED::eTRIA6);
+      aGeomFACESet.insert(MED::eTRIA7);
+      aGeomFACESet.insert(MED::eQUAD8);
+      aGeomFACESet.insert(MED::eQUAD9);
+      aGeomFACESet.insert(MED::ePOLYGONE);
+      aGeomFACESet.insert(MED::ePOLYGON2);
+
+      TGeomSet& aGeomMAILLESet = Entity2GeomSet[MED::eMAILLE];
+      aGeomMAILLESet.insert(MED::ePOINT1);
+      aGeomMAILLESet.insert(aGeomARETESet.begin(), aGeomARETESet.end());
+      aGeomMAILLESet.insert(aGeomFACESet.begin(), aGeomFACESet.end());
+      aGeomMAILLESet.insert(MED::eTETRA4);
+      aGeomMAILLESet.insert(MED::ePYRA5);
+      aGeomMAILLESet.insert(MED::ePENTA6);
+      aGeomMAILLESet.insert(MED::eHEXA8);
+      aGeomMAILLESet.insert(MED::eOCTA12);
+      aGeomMAILLESet.insert(MED::eTETRA10);
+      aGeomMAILLESet.insert(MED::ePYRA13);
+      aGeomMAILLESet.insert(MED::ePENTA15);
+      aGeomMAILLESet.insert(MED::eHEXA20);
+      aGeomMAILLESet.insert(MED::eHEXA27);
+      aGeomMAILLESet.insert(MED::ePOLYEDRE);
+
+      /* This combination allows reading nb of models of structure elements */
+      Entity2GeomSet[MED::eSTRUCT_ELEMENT].insert(MED::eAllGeoType);
+    }
+
+    return Entity2GeomSet;
+  }
+}

src/MEDWrapper/MED_Common.hxx

@@ -23,7 +23,9 @@
 #ifndef MED_Common_HeaderFile
 #define MED_Common_HeaderFile
 
-#include "MED_WrapperBase.hxx"
+#include "MED_WrapperDef.hxx"
+#include "MED_Vector.hxx"
+#include "MED_SharedPtr.hxx"
 
 #include <string>
 #include <set>
@@ -31,114 +33,65 @@
 
 #include <hdf5.h>
 
-#include <boost/tuple/tuple.hpp>
-
-#include "SALOMEconfig.h"
-
-#include "MED_Vector.hxx"
-#include "MED_SharedPtr.hxx"
-#include "MED_SliceArray.hxx"
-
 #ifdef WIN32
 #pragma warning(disable:4099)
 #endif
 
-namespace MED{
+namespace MED
-
+{
-  enum EVersion {eVUnknown = -1, eV2_1, eV2_2};
+  typedef enum {eFAUX, eVRAI} EBooleen;
-  
-  typedef enum {eFAUX, eVRAI} EBooleen ; 
   typedef double TFloat;
 #if defined(HAVE_F77INT64)
   typedef long TInt;
 #else
   typedef int TInt;
-#endif 
+#endif
   typedef hid_t TIdt;
   typedef herr_t TErr;
 
   typedef enum {eFULL_INTERLACE, eNO_INTERLACE} EModeSwitch;
 
-  typedef enum {eFLOAT64=6, eINT=24, eLONG=26 } ETypeChamp;
+  typedef enum {eFLOAT64=6, eINT=24, eLONG=26} ETypeChamp;
 
   typedef enum {eNON_STRUCTURE, eSTRUCTURE} EMaillage;
 
-  typedef enum {eCART, eCYL, eSPHER} ERepere; 
+  typedef enum {eCART, eCYL, eSPHER} ERepere;
 
-  typedef enum {eNOD, eDESC} EConnectivite ; 
+  typedef enum {eNOD, eDESC} EConnectivite;
 
   typedef enum {ePOINT1=1, eSEG2=102, eSEG3=103, eTRIA3=203,
-                eQUAD4=204, eTRIA6=206, eTRIA7=207, eQUAD8=208, eQUAD9=209,eTETRA4=304,
+                eQUAD4=204, eTRIA6=206, eTRIA7=207, eQUAD8=208, eQUAD9=209, eTETRA4=304,
-                ePYRA5=305, ePENTA6=306, eHEXA8=308, eOCTA12=312, eTETRA10=310, 
+                ePYRA5=305, ePENTA6=306, eHEXA8=308, eOCTA12=312, eTETRA10=310,
                 ePYRA13=313, ePENTA15=315, eHEXA20=320, eHEXA27=327,
-                ePOLYGONE=400, ePOLYGON2=420, ePOLYEDRE=500, eNONE=0, 
+                ePOLYGONE=400, ePOLYGON2=420, ePOLYEDRE=500, eNONE=0,
-                eBALL=1101 /*no such a type in med.h, it's just a trick*/,
+                eBALL=1101, // no such a type in med.h, it's just a trick
-                eAllGeoType=-1 } EGeometrieElement;
+                eAllGeoType=-1} EGeometrieElement;
 
-  typedef enum {eMAILLE, eFACE, eARETE, eNOEUD, eNOEUD_ELEMENT, eSTRUCT_ELEMENT} EEntiteMaillage; 
+  typedef enum {eMAILLE, eFACE, eARETE, eNOEUD, eNOEUD_ELEMENT, eSTRUCT_ELEMENT} EEntiteMaillage;
 
-  typedef enum {eNO_PFLMOD, eGLOBAL, eCOMPACT}  EModeProfil; 
+  typedef enum {eNO_PFLMOD, eGLOBAL, eCOMPACT} EModeProfil;
 
   typedef enum {eGRILLE_CARTESIENNE, eGRILLE_POLAIRE, eGRILLE_STANDARD} EGrilleType;
 
   typedef enum {eCOOR, eCONN, eNOM, eNUM, eFAM, eCOOR_IND1, eCOOR_IND2, eCOOR_IND3} ETable;
 
+  typedef TVector<TInt> TIntVector;
   typedef TVector<TFloat> TFloatVector;
   typedef TVector<std::string> TStringVector;
-  typedef TVector<TInt> TIntVector;
   typedef std::set<std::string> TStringSet;
-  
+
   typedef std::map<EGeometrieElement,TInt> TGeom2Size;
   typedef std::map<EEntiteMaillage,TGeom2Size> TEntityInfo;
 
   typedef std::set<EGeometrieElement> TGeomSet;
   typedef std::map<EEntiteMaillage,TGeomSet> TEntity2GeomSet;
 
-  MEDWRAPPER_EXPORT 
-  const TEntity2GeomSet& 
-  GetEntity2GeomSet();
-
-  template<EVersion>
-  TInt MEDWRAPPER_EXPORT
-  GetDESCLength();
-  
-  template<EVersion>
-  TInt MEDWRAPPER_EXPORT
-  GetIDENTLength();
-  
-  template<EVersion>
-  TInt MEDWRAPPER_EXPORT
-  GetNOMLength();
-  
-  template<EVersion>
-  TInt MEDWRAPPER_EXPORT
-  GetLNOMLength();
-  
-  template<EVersion>
-  TInt MEDWRAPPER_EXPORT
-  GetPNOMLength();
-  
-  template<EVersion>
-  void MEDWRAPPER_EXPORT
-  GetVersionRelease(TInt& majeur, TInt& mineur, TInt& release);
-  
-  template<EVersion>
-  MEDWRAPPER_EXPORT
-  TInt
-  GetNbConn(EGeometrieElement typmai,
-            EEntiteMaillage typent,
-            TInt mdim);
-  
-  MEDWRAPPER_EXPORT
-  TInt 
-  GetNbNodes(EGeometrieElement typmai);
-
   struct TNameInfo;
   typedef SharedPtr<TNameInfo> PNameInfo;
-  
+
   struct TMeshInfo;
   typedef SharedPtr<TMeshInfo> PMeshInfo;
-  
+
   struct TFamilyInfo;
   typedef SharedPtr<TFamilyInfo> PFamilyInfo;
 
@@ -168,10 +121,10 @@ namespace MED{
 
   struct TProfileInfo;
   typedef SharedPtr<TProfileInfo> PProfileInfo;
-  
+
   struct TGaussInfo;
   typedef SharedPtr<TGaussInfo> PGaussInfo;
-  
+
   class TGrilleInfo;
   typedef SharedPtr<TGrilleInfo> PGrilleInfo;
 
@@ -180,7 +133,42 @@ namespace MED{
 
   struct TWrapper;
   typedef SharedPtr<TWrapper> PWrapper;
+
+  MEDWRAPPER_EXPORT
+  TInt
+  GetDESCLength();
+
+  MEDWRAPPER_EXPORT
+  TInt
+  GetIDENTLength();
+
+  MEDWRAPPER_EXPORT
+  TInt
+  GetNOMLength();
+
+  MEDWRAPPER_EXPORT
+  TInt
+  GetLNOMLength();
+
+  MEDWRAPPER_EXPORT
+  TInt
+  GetPNOMLength();
+
+  MEDWRAPPER_EXPORT
+  void
+  GetVersionRelease(TInt&, TInt&, TInt&);
+
+  MEDWRAPPER_EXPORT
+  TInt
+  GetNbConn(EGeometrieElement, EEntiteMaillage, TInt);
+
+  MEDWRAPPER_EXPORT
+  TInt
+  GetNbNodes(EGeometrieElement typmai);
+
+  MEDWRAPPER_EXPORT
+  const TEntity2GeomSet&
+  GetEntity2GeomSet();
 }
 
-
+#endif // MED_Common_HeaderFile
-#endif

src/MEDWrapper/MED_CoordUtils.cxx

@@ -19,68 +19,67 @@
 //
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
+
 #include "MED_CoordUtils.hxx"
 #include "MED_Utilities.hxx"
- 
+
 namespace MED
 {
-
   enum ECoordName{eX, eY, eZ, eNone};
 
   template<ECoordName TCoordId>
-  TFloat 
+  TFloat
   GetCoord(const TCCoordSlice& theCoordSlice)
   {
     return theCoordSlice[TCoordId];
   }
 
   template<>
-  TFloat 
+  TFloat
   GetCoord<eNone>(const TCCoordSlice& theCoordSlice)
   {
     return 0.0;
   }
-  
+
   TGetCoord
   aXYZGetCoord[3] = {
-    &GetCoord<eX>, 
+    &GetCoord<eX>,
-    &GetCoord<eY>, 
+    &GetCoord<eY>,
     &GetCoord<eZ>
   };
-  
+
   TGetCoord
   aXYGetCoord[3] = {
-    &GetCoord<eX>, 
+    &GetCoord<eX>,
-    &GetCoord<eY>, 
+    &GetCoord<eY>,
     &GetCoord<eNone>
   };
-  
+
   TGetCoord
   aYZGetCoord[3] = {
     &GetCoord<eNone>,
-    &GetCoord<eX>, 
+    &GetCoord<eX>,
     &GetCoord<eY>
   };
-  
+
-  TGetCoord 
+  TGetCoord
   aXZGetCoord[3] = {
-    &GetCoord<eX>, 
+    &GetCoord<eX>,
     &GetCoord<eNone>,
     &GetCoord<eY>
   };
-  
+
-  
+  TGetCoord
-  TGetCoord 
   aXGetCoord[3] = {
-    &GetCoord<eX>, 
+    &GetCoord<eX>,
     &GetCoord<eNone>,
     &GetCoord<eNone>
   };
-  
+
   TGetCoord
   aYGetCoord[3] = {
     &GetCoord<eNone>,
-    &GetCoord<eX>, 
+    &GetCoord<eX>,
     &GetCoord<eNone>
   };
 
@@ -91,22 +90,20 @@ namespace MED
     &GetCoord<eX>
   };
 
-  
   //---------------------------------------------------------------
   TCoordHelper
   ::TCoordHelper(TGetCoord* theGetCoord):
     myGetCoord(theGetCoord)
   {}
 
-  TFloat 
+  TFloat
   TCoordHelper
-  ::GetCoord(TCCoordSlice& theCoordSlice, 
+  ::GetCoord(TCCoordSlice& theCoordSlice,
              TInt theCoordId)
   {
     return (*myGetCoord[theCoordId])(theCoordSlice);
   }
 
-
   //---------------------------------------------------------------
   PCoordHelper
   GetCoordHelper(PNodeInfo theNodeInfo)

src/MEDWrapper/MED_CoordUtils.hxx

@@ -19,38 +19,35 @@
 //
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
+
 #ifndef MED_CoordUtils_HeaderFile
 #define MED_CoordUtils_HeaderFile
 
-#include "MED_WrapperBase.hxx"
+#include "MED_WrapperDef.hxx"
-
 #include "MED_Structures.hxx"
 
 namespace MED
 {
   typedef TFloat (*TGetCoord)(const TCCoordSlice& theCoordSlice);
 
-
   //---------------------------------------------------------------
   class MEDWRAPPER_EXPORT TCoordHelper
   {
     TGetCoord* myGetCoord;
-    
+
   public:
     TCoordHelper(TGetCoord* theGetCoord);
 
-    TFloat 
+    TFloat
-    GetCoord(TCCoordSlice& theCoordSlice, 
+    GetCoord(TCCoordSlice& theCoordSlice,
              TInt theCoordId);
   };
   typedef SharedPtr<TCoordHelper> PCoordHelper;
 
-
   //---------------------------------------------------------------
-  MEDWRAPPER_EXPORT 
+  MEDWRAPPER_EXPORT
   PCoordHelper
   GetCoordHelper(PNodeInfo theNodeInfo);
-
 }
 
-#endif
+#endif // MED_CoordUtils_HeaderFile

src/MEDWrapper/MED_Factory.cxx

@@ -0,0 +1,120 @@
+// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  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, 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
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "MED_Factory.hxx"
+#include "MED_Utilities.hxx"
+#include "MED_Wrapper.hxx"
+
+#include <stdio.h>
+#include <errno.h>
+#include <sstream>
+
+#include <med.h>
+extern "C"
+{
+#ifndef WIN32
+  #include <unistd.h>
+#endif
+}
+
+namespace MED
+{
+  bool exists(const std::string& fileName)
+  {
+#ifdef WIN32
+    return (GetFileAttributes(xmlPath.c_str()) != INVALID_FILE_ATTRIBUTES);
+#else
+    return (access(fileName.c_str(), F_OK) == 0);
+#endif
+  }
+
+  bool CheckCompatibility(const std::string& fileName)
+  {
+    bool ok = false;
+    // check that file is accessible
+    if ( exists(fileName) ) {
+      // check HDF5 && MED compatibility
+      med_bool hdfok, medok;
+      MEDfileCompatibility(fileName.c_str(), &hdfok, &medok);
+      if ( hdfok && medok ) {
+        med_idt aFid = MEDfileOpen(fileName.c_str(), MED_ACC_RDONLY);
+        if (aFid >= 0) {
+          med_int major, minor, release;
+          med_err ret = MEDfileNumVersionRd(aFid, &major, &minor, &release);
+          if (ret >= 0) {
+            int version = 100*major + minor;
+            if (version >= 202)
+              ok = true;
+          }
+        }
+        MEDfileClose(aFid);
+      }
+    }
+    return ok;
+  }
+
+  bool GetMEDVersion(const std::string& fileName, int& major, int& minor, int& release)
+  {
+    bool ok = false;
+    major = minor = release = 0;
+    med_idt aFid = MEDfileOpen(fileName.c_str(), MED_ACC_RDONLY);
+    if (aFid >= 0) {
+      med_int _major, _minor, _release;
+      med_err ret = MEDfileNumVersionRd(aFid, &_major, &_minor, &_release);
+      if (ret == 0) {
+        major = _major;
+        minor = _minor;
+        release = _release;
+        ok = true;
+      }
+      MEDfileClose(aFid);
+    }
+    return ok;
+  }
+
+  std::string GetMEDVersion(const std::string& fileName)
+  {
+    std::string version;
+    int major, minor, release;
+    if (GetMEDVersion(fileName, major, minor, release)) {
+      std::ostringstream os;
+      os << major << "." << minor << "." << release;
+      version = os.str();
+    }
+    return version;
+  }
+
+  PWrapper CrWrapperR(const std::string& fileName)
+  {
+    if (!CheckCompatibility(fileName)) {
+      EXCEPTION(std::runtime_error, "Cannot open file '"<<fileName<<"'.");
+    }
+    return new MED::TWrapper(fileName);
+  }
+
+  PWrapper CrWrapperW(const std::string& fileName)
+  {
+    if (!CheckCompatibility(fileName))
+      remove(fileName.c_str());
+    return new MED::TWrapper(fileName);
+  }
+}

src/MEDWrapper/MED_Factory.hxx

@@ -23,27 +23,27 @@
 #ifndef MED_Factory_HeaderFile
 #define MED_Factory_HeaderFile
 
-#include "MED_WrapperFactory.hxx"
+#include "MED_WrapperDef.hxx"
 #include "MED_Wrapper.hxx"
 
+#include <string>
+
 namespace MED
 {
-  MEDWRAPPER_FACTORY_EXPORT
+  MEDWRAPPER_EXPORT
-  EVersion  
+  std::string GetMEDVersion( const std::string& );
-  GetVersionId(const std::string& theFileName,
-               bool theDoPreCheckInSeparateProcess = false);
 
-  MEDWRAPPER_FACTORY_EXPORT
+  MEDWRAPPER_EXPORT
-    bool getMEDVersion( const std::string&, int&, int&, int& );
+  bool GetMEDVersion( const std::string&, int&, int&, int& );
-  
-  MEDWRAPPER_FACTORY_EXPORT
-  PWrapper 
-  CrWrapper(const std::string& theFileName,
-            bool theDoPreCheckInSeparateProcess = false);
 
-  MEDWRAPPER_FACTORY_EXPORT
+  MEDWRAPPER_EXPORT
-  PWrapper 
+  bool CheckCompatibility( const std::string& );
-  CrWrapper(const std::string& theFileName, EVersion theId);
+
+  MEDWRAPPER_EXPORT
+  PWrapper CrWrapperR( const std::string& );
+
+  MEDWRAPPER_EXPORT
+  PWrapper CrWrapperW( const std::string& );
 }
 
-#endif
+#endif // MED_Factory_HeaderFile

src/MEDWrapper/MED_GaussDef.cxx

@@ -16,34 +16,30 @@
 //
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
-// File   : MED_GaussDef.hxx
+
-// Author : Edward AGAPOV (eap)
-//
 #include "MED_GaussDef.hxx"
 #include "MED_Utilities.hxx"
 #include "MED_GaussUtils.hxx"
 
 namespace MED
 {
-  using namespace std;
-  using namespace MED;
   //---------------------------------------------------------------
 
   void TGaussDef::add(const double x, const double weight)
   {
     if ( dim() != 1 )
-      EXCEPTION( logic_error,"dim() != 1");
+      EXCEPTION( std::logic_error,"dim() != 1");
     if ( myWeights.capacity() == myWeights.size() )
-      EXCEPTION( logic_error,"Extra gauss point");
+      EXCEPTION( std::logic_error,"Extra gauss point");
     myCoords.push_back( x );
     myWeights.push_back( weight );
   }
   void TGaussDef::add(const double x, const double y, const double weight)
   {
     if ( dim() != 2 )
-      EXCEPTION( logic_error,"dim() != 2");
+      EXCEPTION( std::logic_error,"dim() != 2");
     if ( myWeights.capacity() == myWeights.size() )
-      EXCEPTION( logic_error,"Extra gauss point");
+      EXCEPTION( std::logic_error,"Extra gauss point");
     myCoords.push_back( x );
     myCoords.push_back( y );
     myWeights.push_back( weight );
@@ -51,9 +47,9 @@ namespace MED
   void TGaussDef::add(const double x, const double y, const double z, const double weight)
   {
     if ( dim() != 3 )
-      EXCEPTION( logic_error,"dim() != 3");
+      EXCEPTION( std::logic_error,"dim() != 3");
     if ( myWeights.capacity() == myWeights.size() )
-      EXCEPTION( logic_error,"Extra gauss point");
+      EXCEPTION( std::logic_error,"Extra gauss point");
     myCoords.push_back( x );
     myCoords.push_back( y );
     myCoords.push_back( z );
@@ -66,7 +62,6 @@ namespace MED
                         aShapeFun.myRefCoord.end() );
   }
 
-
   //---------------------------------------------------------------
   /*!
    * \brief Fill definition of gauss points family
@@ -99,7 +94,7 @@ namespace MED
         const double P1 = 1./1.8;
         const double P2 = 1./1.125;
         add( -a,  P1 );
-        add(  0,  P2 ); 
+        add(  0,  P2 );
         add(  a,  P1 ); break;
       }
       case 4: {
@@ -107,11 +102,11 @@ namespace MED
         const double P1 = 0.652145154862546, P2 = 0.347854845137454 ;
         add(  a,  P1 );
         add( -a,  P1 );
-        add(  b,  P2 ); 
+        add(  b,  P2 );
         add( -b,  P2 ); break;
       }
       default:
-        EXCEPTION( logic_error,"Invalid nb of gauss points for SEG"<<nbGauss);
+        EXCEPTION( std::logic_error,"Invalid nb of gauss points for SEG"<<nbGauss);
       }
       break;
 
@@ -139,11 +134,11 @@ namespace MED
         case 6: { // FPG6
           const double P1 = 0.11169079483905, P2 = 0.0549758718227661;
           const double a  = 0.445948490915965, b = 0.091576213509771;
-          add(     b,     b, P2 ); 
+          add(     b,     b, P2 );
           add( 1-2*b,     b, P2 );
           add(     b, 1-2*b, P2 );
           add(     a, 1-2*a, P1 );
-          add(     a,     a, P1 ); 
+          add(     a,     a, P1 );
           add( 1-2*a,     a, P1 ); break;
         }
         case 7: { // FPG7
@@ -151,11 +146,11 @@ namespace MED
           const double B  = 0.101286507323456;
           const double P1 = 0.066197076394253;
           const double P2 = 0.062969590272413;
-          add(  1/3.,  1/3., 9/80. ); 
+          add(  1/3.,  1/3., 9/80. );
-          add(     A,     A, P1 ); 
+          add(     A,     A, P1 );
           add( 1-2*A,     A, P1 );
           add(     A, 1-2*A, P1 );
-          add(     B,     B, P2 ); 
+          add(     B,     B, P2 );
           add( 1-2*B,     B, P2 );
           add(     B, 1-2*B, P2 ); break;
         }
@@ -167,10 +162,10 @@ namespace MED
           const double P1 = 0.025422453185103;
           const double P2 = 0.058393137863189;
           const double P3 = 0.041425537809187;
-          add(     A,     A, P1 ); 
+          add(     A,     A, P1 );
           add( 1-2*A,     A, P1 );
           add(     A, 1-2*A, P1 );
-          add(     B,     B, P2 ); 
+          add(     B,     B, P2 );
           add( 1-2*B,     B, P2 );
           add(     B, 1-2*B, P2 );
           add(     C,     D, P3 );
@@ -181,7 +176,7 @@ namespace MED
           add(     D, 1-C-D, P3 ); break;
         }
         default:
-          EXCEPTION( logic_error,"Invalid nb of gauss points for TRIA, variant 1: "
+          EXCEPTION( std::logic_error,"Invalid nb of gauss points for TRIA, variant 1: "
                      <<nbGauss);
         }
       }
@@ -200,15 +195,15 @@ namespace MED
         case 6: {
           const double P1 = 0.11169079483905, P2 = 0.0549758718227661;
           const double A  = 0.445948490915965, B = 0.091576213509771;
-          add( 2*B-1, 1-4*B, 4*P2 ); 
+          add( 2*B-1, 1-4*B, 4*P2 );
           add( 2*B-1, 2*B-1, 4*P2 );
           add( 1-4*B, 2*B-1, 4*P2 );
           add( 1-4*A, 2*A-1, 4*P1 );
-          add( 2*A-1, 1-4*A, 4*P1 ); 
+          add( 2*A-1, 1-4*A, 4*P1 );
           add( 2*A-1, 2*A-1, 4*P1 ); break;
         }
         default:
-          EXCEPTION( logic_error,"Invalid nb of gauss points for TRIA, variant 2: "
+          EXCEPTION( std::logic_error,"Invalid nb of gauss points for TRIA, variant 2: "
                      <<nbGauss);
         }
       }
@@ -223,7 +218,7 @@ namespace MED
           add( 0.2 , 0.6 ,  25/96 ); break;
         }
         default:
-          EXCEPTION( logic_error,"Invalid nb of gauss points for TRIA, variant 3: "
+          EXCEPTION( std::logic_error,"Invalid nb of gauss points for TRIA, variant 3: "
                      <<nbGauss);
         }
       }
@@ -258,7 +253,7 @@ namespace MED
           add( 0., 0.,  64/81. ); break;
         }
         default:
-          EXCEPTION( logic_error,"Invalid nb of gauss points for QUAD, variant 1: "
+          EXCEPTION( std::logic_error,"Invalid nb of gauss points for QUAD, variant 1: "
                      <<nbGauss);
         }
       }
@@ -286,7 +281,7 @@ namespace MED
           add( 0., 0.,  64/81. ); break;
         }
         default:
-          EXCEPTION( logic_error,"Invalid nb of gauss points for QUAD, variant 1: "
+          EXCEPTION( std::logic_error,"Invalid nb of gauss points for QUAD, variant 1: "
                      <<nbGauss);
         }
       }
@@ -315,7 +310,7 @@ namespace MED
           add(  a,  a,  c12  ); break;
         }
         default:
-          EXCEPTION( logic_error,"Invalid nb of gauss points for QUAD, variant 3: "
+          EXCEPTION( std::logic_error,"Invalid nb of gauss points for QUAD, variant 3: "
                      <<nbGauss);
         }
       }
@@ -365,7 +360,7 @@ namespace MED
         break;
       }
       default:
-        EXCEPTION( logic_error,"Invalid nb of gauss points for TETRA: "<<nbGauss);
+        EXCEPTION( std::logic_error,"Invalid nb of gauss points for TETRA: "<<nbGauss);
       }
       break;
 
@@ -399,12 +394,12 @@ namespace MED
         add( 0., 0.,  h3,  p3 ); break;
       }
       case 27: { // FPG27
-        const double a1  = 0.788073483; 
+        const double a1  = 0.788073483;
-        const double b6  = 0.499369002; 
+        const double b6  = 0.499369002;
-        const double b1  = 0.848418011; 
+        const double b1  = 0.848418011;
-        const double c8  = 0.478508449; 
+        const double c8  = 0.478508449;
-        const double c1  = 0.652816472; 
+        const double c1  = 0.652816472;
-        const double d12 = 0.032303742; 
+        const double d12 = 0.032303742;
         const double d1  = 1.106412899;
         double z = 1/2., fz = b1/2*(1 - z);
         add(  0.,  0.,   z,  a1 ); // 1
@@ -444,7 +439,7 @@ namespace MED
         break;
       }
       default:
-        EXCEPTION( logic_error,"Invalid nb of gauss points for PYRA: "<<nbGauss);
+        EXCEPTION( std::logic_error,"Invalid nb of gauss points for PYRA: "<<nbGauss);
       }
       break;
     case ePENTA6:
@@ -502,7 +497,7 @@ namespace MED
         break;
       }
       default:
-        EXCEPTION( logic_error,"Invalid nb of gauss points for PENTA: " <<nbGauss);
+        EXCEPTION( std::logic_error,"Invalid nb of gauss points for PENTA: " <<nbGauss);
       }
       break;
 
@@ -556,15 +551,15 @@ namespace MED
         break;
       }
       default:
-        EXCEPTION( logic_error,"Invalid nb of gauss points for PENTA: " <<nbGauss);
+        EXCEPTION( std::logic_error,"Invalid nb of gauss points for PENTA: " <<nbGauss);
       }
       break;
 
     default:
-      EXCEPTION( logic_error,"unexpected EGeometrieElement: "<< geom);
+      EXCEPTION( std::logic_error,"unexpected EGeometrieElement: "<< geom);
     }
 
     if ( myWeights.capacity() != myWeights.size() )
-      EXCEPTION( logic_error,"Not all gauss points defined");
+      EXCEPTION( std::logic_error,"Not all gauss points defined");
   }
 }

src/MEDWrapper/MED_GaussDef.hxx

@@ -16,21 +16,19 @@
 //
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
-// File   : MED_GaussDef.hxx
+
-// Author : Edward AGAPOV (eap)
-//
 #ifndef MED_GaussDef_HeaderFile
 #define MED_GaussDef_HeaderFile
 
-#include "MED_WrapperBase.hxx"
+#include "MED_WrapperDef.hxx"
 
-//#include "MED_GaussUtils.hxx" <<<---- avoid dependence on boost
 #include <vector>
 
 namespace MED
 {
   class TShapeFun;
   typedef std::vector<double> TDoubleVector;
+
   /*!
    * \brief Description of family of integration points
    */
@@ -46,9 +44,9 @@ namespace MED
      *  \param geomType - element geometry (EGeometrieElement or med_geometrie_element)
      *  \param nbPoints - nb gauss point
      *  \param variant - [1-3] to choose the variant of definition
-     * 
+     *
      * Throws in case of invalid parameters
-     * variant == 1 refers to "Fonctions de forme et points d'integration 
+     * variant == 1 refers to "Fonctions de forme et points d'integration
      *              des elements finis" v7.4 by J. PELLET, X. DESROCHES, 15/09/05
      * variant == 2 refers to the same doc v6.4 by J.P. LEFEBVRE, X. DESROCHES, 03/07/03
      * variant == 3 refers to the same doc v6.4, second variant for 2D elements
@@ -66,4 +64,4 @@ namespace MED
   };
 }
 
-#endif
+#endif // MED_GaussDef_HeaderFile

src/MEDWrapper/MED_GaussUtils.cxx

@@ -19,19 +19,18 @@
 //
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
+
 #include "MED_GaussUtils.hxx"
 #include "MED_Utilities.hxx"
- 
+
 #ifdef _DEBUG_
 static int MYDEBUG = 0;
 static int MYVALUEDEBUG = 0;
 #else
-// static int MYDEBUG = 0;
+static int MYDEBUG = 0;
-// static int MYVALUEDEBUG = 0;
+static int MYVALUEDEBUG = 0;
 #endif
 
-//#define _DEBUG_REF_COORDS_
-
 namespace MED
 {
   //---------------------------------------------------------------
@@ -63,28 +62,27 @@ namespace MED
     myGaussCoord.resize(theNbElem*myGaussStep);
   }
 
-
   TInt
   TGaussCoord
   ::GetNbElem() const
-  { 
+  {
-    return myNbElem; 
+    return myNbElem;
   }
-  
+
   TInt
   TGaussCoord
   ::GetNbGauss() const
-  { 
+  {
-    return myNbGauss; 
+    return myNbGauss;
   }
-  
+
   TInt
   TGaussCoord
   ::GetDim() const
-  { 
+  {
-    return myDim; 
+    return myDim;
   }
-  
+
   unsigned char*
   TGaussCoord
   ::GetValuePtr()
@@ -92,8 +90,7 @@ namespace MED
     return (unsigned char*)&(myGaussCoord[0]);
   }
 
-
+  TCCoordSliceArr
-  TCCoordSliceArr 
   TGaussCoord
   ::GetCoordSliceArr(TInt theElemId) const
   {
@@ -115,8 +112,7 @@ namespace MED
     return aCoordSliceArr;
   }
 
-
+  TCoordSliceArr
-  TCoordSliceArr 
   TGaussCoord
   ::GetCoordSliceArr(TInt theElemId)
   {
@@ -138,10 +134,9 @@ namespace MED
     return aCoordSliceArr;
   }
 
-
   //---------------------------------------------------------------
   inline
-  bool 
+  bool
   IsEqual(TFloat theLeft, TFloat theRight)
   {
     static TFloat EPS = 1.0E-3;
@@ -150,7 +145,6 @@ namespace MED
     return true;
   }
 
-
   //---------------------------------------------------------------
   class TShapeFun::TFun
   {
@@ -167,7 +161,7 @@ namespace MED
       myNbRef = theNbRef;
     }
 
-    TCFloatVecSlice 
+    TCFloatVecSlice
     GetFunSlice(TInt theGaussId) const
     {
       return TCFloatVecSlice(myFun,std::slice(theGaussId*myNbRef,myNbRef,1));
@@ -188,7 +182,7 @@ namespace MED
     myNbRef(theNbRef)
   {}
 
-  TCCoordSlice 
+  TCCoordSlice
   TShapeFun::GetCoord(TInt theRefId) const
   {
     return TCCoordSlice(myRefCoord,std::slice(theRefId*myDim,myDim,1));
@@ -200,7 +194,7 @@ namespace MED
     return TCoordSlice(myRefCoord,std::slice(theRefId*myDim,myDim,1));
   }
 
-  void 
+  void
   TShapeFun::GetFun(const TCCoordSliceArr& theRef,
                     const TCCoordSliceArr& theGauss,
                     TFun& theFun) const
@@ -210,7 +204,7 @@ namespace MED
     theFun.Init(aNbGauss,aNbRef);
   }
 
-  bool 
+  bool
   TShapeFun::IsSatisfy(const TCCoordSliceArr& theRefCoord) const
   {
     TInt aNbRef = theRefCoord.size();
@@ -302,7 +296,7 @@ namespace MED
           TCFloatVecSlice aFunSlice = aFun.GetFunSlice(aGaussId);
 
           for(TInt aConnId = 0; aConnId < aConnDim; aConnId++){
-            TInt aNodeId = aConnSlice[aConnId] - 1;      
+            TInt aNodeId = aConnSlice[aConnId] - 1;
             TCCoordSlice aNodeCoordSlice = theNodeInfo.GetCoordSlice(aNodeId);
 
             for(TInt aDimId = 0; aDimId < aDim; aDimId++){
@@ -345,7 +339,6 @@ namespace MED
     return false;
   }
 
-
   //---------------------------------------------------------------
   TSeg2a::TSeg2a():TShapeFun(1,2)
   {
@@ -376,7 +369,6 @@ namespace MED
     }
   }
 
-
   //---------------------------------------------------------------
   TSeg3a::TSeg3a():TShapeFun(1,3)
   {
@@ -409,8 +401,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TTria3a::TTria3a():
     TShapeFun(2,3)
@@ -444,8 +434,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TTria6a::TTria6a():TShapeFun(2,6)
   {
@@ -486,8 +474,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TTria3b::TTria3b():
     TShapeFun(2,3)
@@ -521,8 +507,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TTria6b::TTria6b():
     TShapeFun(2,6)
@@ -564,8 +548,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TQuad4a::TQuad4a():
     TShapeFun(2,4)
@@ -601,8 +583,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TQuad8a::TQuad8a():
     TShapeFun(2,8)
@@ -648,8 +628,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TQuad9a::TQuad9a():
     TShapeFun(2,9)
@@ -699,8 +677,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TQuad4b::TQuad4b():
     TShapeFun(2,4)
@@ -736,8 +712,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TQuad8b::TQuad8b():
     TShapeFun(2,8)
@@ -788,8 +762,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TQuad9b::TQuad9b():
     TShapeFun(2,9)
@@ -839,8 +811,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TTetra4a::TTetra4a():
     TShapeFun(3,4)
@@ -876,8 +846,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TTetra10a::TTetra10a():
     TShapeFun(3,10)
@@ -929,11 +897,8 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
 
-
   TTetra4b::TTetra4b():
     TShapeFun(3,4)
   {
@@ -968,8 +933,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TTetra10b::TTetra10b():
     TShapeFun(3,10)
@@ -1021,8 +984,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   THexa8a::THexa8a():
     TShapeFun(3,8)
@@ -1067,7 +1028,6 @@ namespace MED
     }
   }
 
-
   //---------------------------------------------------------------
   THexa20a::THexa20a(TInt theDim, TInt theNbRef):
     TShapeFun(theDim,theNbRef)
@@ -1145,8 +1105,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   THexa27a::THexa27a():
     THexa20a(3,27)
@@ -1209,8 +1167,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   THexa8b::THexa8b():
     TShapeFun(3,8)
@@ -1255,8 +1211,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   THexa20b::THexa20b(TInt theDim, TInt theNbRef):
     TShapeFun(theDim,theNbRef)
@@ -1334,8 +1288,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TPenta6a::TPenta6a():
     TShapeFun(3,6)
@@ -1376,8 +1328,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TPenta6b::TPenta6b():
     TShapeFun(3,6)
@@ -1418,8 +1368,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TPenta15a::TPenta15a():
     TShapeFun(3,15)
@@ -1482,8 +1430,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TPenta15b::TPenta15b():
     TShapeFun(3,15)
@@ -1546,8 +1492,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TPyra5a::TPyra5a():
     TShapeFun(3,5)
@@ -1592,8 +1536,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TPyra5b::TPyra5b():
     TShapeFun(3,5)
@@ -1601,7 +1543,7 @@ namespace MED
     TInt aNbRef = myRefCoord.size();
     for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
       TCoordSlice aCoord = GetCoord(aRefId);
-      switch(aRefId){        
+      switch(aRefId){
       case  0: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
       case  3: aCoord[0] =  0.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
       case  2: aCoord[0] = -1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
@@ -1617,7 +1559,7 @@ namespace MED
                    TFun& theFun) const
   {
     GetFun(theRef,theGauss,theFun);
-    
+
     TInt aNbGauss = theGauss.size();
     for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
       const TCCoordSlice& aCoord = theGauss[aGaussId];
@@ -1637,8 +1579,6 @@ namespace MED
       aSlice[4] = aCoord[2];
     }
   }
-  
-
 
   //---------------------------------------------------------------
   TPyra13a::TPyra13a():
@@ -1709,8 +1649,6 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   TPyra13b::TPyra13b():
     TShapeFun(3,13)
@@ -1780,11 +1718,9 @@ namespace MED
     }
   }
 
-
-
   //---------------------------------------------------------------
   bool
-  GetGaussCoord3D(const TGaussInfo& theGaussInfo, 
+  GetGaussCoord3D(const TGaussInfo& theGaussInfo,
                   const TCellInfo& theCellInfo,
                   const TNodeInfo& theNodeInfo,
                   TGaussCoord& theGaussCoord,
@@ -1966,7 +1902,7 @@ namespace MED
 
         break;
       }
-      default: 
+      default:
         INITMSG(MYDEBUG,"eNONE"<<std::endl);
         return false;
       }
@@ -2015,7 +1951,7 @@ namespace MED
         TCoordSlice& aGaussCoordSlice = aCoordSliceArr[aGaussId];
 
         for(TInt aConnId = 0; aConnId < aConnDim; aConnId++){
-          TInt aNodeId = aConnSlice[aConnId] - 1;      
+          TInt aNodeId = aConnSlice[aConnId] - 1;
           TCCoordSlice aNodeCoordSlice = theNodeInfo.GetCoordSlice(aNodeId);
 
           for(TInt aDimId = 0; aDimId < aDim; aDimId++){
@@ -2048,7 +1984,6 @@ namespace MED
     return true;
   }
 
-
   //---------------------------------------------------------------
   bool
   GetBaryCenter(const TPolygoneInfo& thePolygoneInfo,
@@ -2090,7 +2025,7 @@ namespace MED
         TCoordSlice& aGaussCoordSlice = aCoordSliceArr[aGaussId];
 
         for(TInt aConnId = 0; aConnId < aNbConn; aConnId++){
-          TInt aNodeId = aConnSlice[aConnId] - 1;      
+          TInt aNodeId = aConnSlice[aConnId] - 1;
           TCCoordSlice aNodeCoordSlice = theNodeInfo.GetCoordSlice(aNodeId);
 
           for(TInt aDimId = 0; aDimId < aDim; aDimId++){
@@ -2107,7 +2042,6 @@ namespace MED
     return true;
   }
 
-
   //---------------------------------------------------------------
   bool
   GetBaryCenter(const TPolyedreInfo& thePolyedreInfo,
@@ -2153,7 +2087,7 @@ namespace MED
           TCConnSlice aConnSlice = aConnSliceArr[aFaceId];
           TInt aNbConn = aConnSlice.size();
           for(TInt aConnId = 0; aConnId < aNbConn; aConnId++){
-            TInt aNodeId = aConnSlice[aConnId] - 1;      
+            TInt aNodeId = aConnSlice[aConnId] - 1;
             TCCoordSlice aNodeCoordSlice = theNodeInfo.GetCoordSlice(aNodeId);
 
             for(TInt aDimId = 0; aDimId < aDim; aDimId++){

src/MEDWrapper/MED_GaussUtils.hxx

@@ -19,11 +19,11 @@
 //
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
+
 #ifndef MED_GaussUtils_HeaderFile
 #define MED_GaussUtils_HeaderFile
 
-#include "MED_WrapperBase.hxx"
+#include "MED_WrapperDef.hxx"
-
 #include "MED_Structures.hxx"
 
 namespace MED
@@ -34,7 +34,7 @@ namespace MED
 
   //! Define a helper class to handle Gauss Points coordinates
   class MEDWRAPPER_EXPORT TGaussCoord:
-    virtual TModeSwitchInfo 
+    virtual TModeSwitchInfo
   {
     TInt myNbElem;
     TInt myNbGauss;
@@ -45,7 +45,7 @@ namespace MED
     TNodeCoord myGaussCoord;
 
   public:
-    
+
     TGaussCoord();
 
     //! To init the class
@@ -72,27 +72,25 @@ namespace MED
     GetCoordSliceArr(TInt theElemId) const;
 
     //! Get slice of the coordinate that corresponds to defined cell
-    TCoordSliceArr 
+    TCoordSliceArr
     GetCoordSliceArr(TInt theElemId);
   };
   typedef SharedPtr<TGaussCoord> PGaussCoord;
 
-
   //---------------------------------------------------------------
   //! To calculate Gauss Points coordinates
-  MEDWRAPPER_EXPORT 
+  MEDWRAPPER_EXPORT
   bool
-  GetGaussCoord3D(const TGaussInfo& theGaussInfo, 
+  GetGaussCoord3D(const TGaussInfo& theGaussInfo,
                   const TCellInfo& theCellInfo,
                   const TNodeInfo& theNodeInfo,
                   TGaussCoord& theGaussCoord,
                   const TElemNum& theElemNum = TElemNum(),
                   EModeSwitch theMode = eFULL_INTERLACE);
 
-
   //---------------------------------------------------------------
   //! To calculate Gauss Points coordinates for defined TCellInfo as its bary center
-  MEDWRAPPER_EXPORT 
+  MEDWRAPPER_EXPORT
   bool
   GetBaryCenter(const TCellInfo& theCellInfo,
                 const TNodeInfo& theNodeInfo,
@@ -101,7 +99,7 @@ namespace MED
                 EModeSwitch theMode = eFULL_INTERLACE);
 
   //! To calculate Gauss Points coordinates for defined TPolygoneInfo as its bary center
-  MEDWRAPPER_EXPORT 
+  MEDWRAPPER_EXPORT
   bool
   GetBaryCenter(const TPolygoneInfo& thePolygoneInfo,
                 const TNodeInfo& theNodeInfo,
@@ -110,7 +108,7 @@ namespace MED
                 EModeSwitch theMode = eFULL_INTERLACE);
 
   //! To calculate Gauss Points coordinates for defined TPolyedreInfo as its bary center
-  MEDWRAPPER_EXPORT 
+  MEDWRAPPER_EXPORT
   bool
   GetBaryCenter(const TPolyedreInfo& thePolyedreInfo,
                 const TNodeInfo& theNodeInfo,
@@ -124,7 +122,7 @@ namespace MED
   struct MEDWRAPPER_EXPORT TShapeFun
   {
     class TFun;
-    
+
     TFloatVector myRefCoord;
     TInt myDim;
     TInt myNbRef;
@@ -140,7 +138,7 @@ namespace MED
     void GetFun(const TCCoordSliceArr& theRef,
                 const TCCoordSliceArr& theGauss,
                 TFun& theFun) const;
-    virtual 
+    virtual
     void InitFun(const TCCoordSliceArr& theRef,
                  const TCCoordSliceArr& theGauss,
                  TFun& theFun) const = 0;
@@ -359,7 +357,6 @@ namespace MED
                          TFun& theFun) const;
   };
   //---------------------------------------------------------------
-
 }
 
-#endif
+#endif // MED_GaussUtils_HeaderFile

src/MEDWrapper/MED_SharedPtr.hxx

@@ -19,6 +19,7 @@
 //
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
+
 #ifndef MED_SharedPtr_HeaderFile
 #define MED_SharedPtr_HeaderFile
 
@@ -26,11 +27,10 @@
 
 namespace MED
 {
-
   //! To extend the boost::shared_ptr to support such features automatic dynamic cast
   /*!
     All entities of the MEDWrapper package are handled as pointer.
-    This class was introduced to provide correct and flexible memory management 
+    This class was introduced to provide correct and flexible memory management
     for all of the MEDWrapper objects.
   */
   template<class T> class SharedPtr: public boost::shared_ptr<T>
@@ -41,8 +41,8 @@ namespace MED
 
     //! Construct the class by any type of a pointer
     template<class Y>
-    explicit SharedPtr(Y * p): 
+    explicit SharedPtr(Y * p):
-      boost::shared_ptr<T>(p) 
+      boost::shared_ptr<T>(p)
     {}
 
     //! Construct the class by any specialisation of the class
@@ -53,7 +53,7 @@ namespace MED
 
     //! Copy-constructor
     template<class Y>
-    SharedPtr& 
+    SharedPtr&
     operator=(SharedPtr<Y> const & r)
     {
       SharedPtr<T>(r).swap(*this);
@@ -61,35 +61,33 @@ namespace MED
     }
 
     //! Introduce a flexible way to reset the wrapped pointer
-    template<class Y> 
+    template<class Y>
-    SharedPtr& 
+    SharedPtr&
     operator()(Y * p) // Y must be complete
     {
       return operator=<Y>(SharedPtr<Y>(p));
     }
 
     //! Introduce a flexible way to reset the wrapped pointer
-    template<class Y> 
+    template<class Y>
-    SharedPtr& 
+    SharedPtr&
     operator()(SharedPtr<Y> const & r) // Y must be complete
     {
       return operator=<Y>(SharedPtr<Y>(r));
     }
 
     //! To provide a flexible way to use reference to the wrapped pointer (const version)
-    operator const T& () const 
+    operator const T& () const
-    { 
+    {
       return *(this->get());
     }
 
     //! To provide a flexible way to use reference to the wrapped pointer
-    operator T& () 
+    operator T& ()
-    { 
+    {
       return *(this->get());
     }
   };
-
 }
 
-
+#endif // MED_SharedPtr_HeaderFile
-#endif

src/MEDWrapper/MED_SliceArray.hxx

@@ -19,10 +19,11 @@
 //
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
+
 #ifndef MED_SliceArray_HeaderFile
 #define MED_SliceArray_HeaderFile
 
-#ifdef WIN32 // for correctly compiling "valarray" in modules, which includes this file
+#ifdef WIN32 // for correct compiling of "valarray" in modules, which include this file
   #undef max
   #undef min
 #endif
@@ -38,12 +39,12 @@ namespace MED
 {
   //---------------------------------------------------------------
   //! This class intends to provide a uniform way to handle multidimensional data (const version)
-  /*! 
+  /*!
     It just contains a pointer to real sequence and implement proper calculation of its indexes.
     This class deals with constant pointer to the sources data and provides const method to
     read them (data).
    */
-  template<class TValueType> 
+  template<class TValueType>
   class TCSlice
   {
     const TValueType* myCValuePtr; //!< Reference to source multidimensional data
@@ -69,7 +70,7 @@ namespace MED
     {
       return mySlice.start() + theId*mySlice.stride();
     }
-    
+
     size_t
     get_id(size_t theId) const
     {
@@ -78,7 +79,7 @@ namespace MED
 #endif
       return calculate_id(theId);
     }
-    
+
     size_t
     get_id_at(size_t theId) const
     {
@@ -92,38 +93,38 @@ namespace MED
     //! Construct the class from bare pointer
     TCSlice(const value_type* theValuePtr,
             size_t theSourceSize,
-            const std::slice& theSlice): 
+            const std::slice& theSlice):
       myCValuePtr(theValuePtr),
       mySourceSize(theSourceSize),
       mySlice(theSlice)
     {}
-    
+
     //! Construct the class from corresponding container
     TCSlice(const TVector<value_type>& theContainer,
-            const std::slice& theSlice): 
+            const std::slice& theSlice):
       myCValuePtr(&theContainer[0]),
       mySourceSize(theContainer.size()),
       mySlice(theSlice)
     {}
-    
+
     //! Default constructor (dangerous)
     TCSlice():
       myCValuePtr(NULL)
     {}
 
     //! Get element by its number (const version)
-    const value_type& 
+    const value_type&
     operator[](size_t theId) const
     {
       return *(myCValuePtr + get_id(theId));
     }
-    
+
-    const value_type& 
+    const value_type&
     at(size_t theId) const
     {
       return *(myCValuePtr + get_id_at(theId));
     }
-    
+
     //! Get range of the order numbers
     size_t
     size() const
@@ -131,15 +132,14 @@ namespace MED
       return mySlice.size();
     }
   };
-  
 
   //---------------------------------------------------------------
   //! This class extends TCSlice functionality for non-constant case
-  template<class TValueType> 
+  template<class TValueType>
   class TSlice: public TCSlice<TValueType>
   {
     TValueType* myValuePtr;
-    
+
   public:
     typedef TValueType value_type;
     typedef TCSlice<TValueType> TSupperClass;
@@ -147,39 +147,38 @@ namespace MED
     //! Construct the class from bare pointer
     TSlice(value_type* theValuePtr,
            size_t theSourceSize,
-           const std::slice& theSlice): 
+           const std::slice& theSlice):
       TSupperClass(theValuePtr, theSourceSize, theSlice),
       myValuePtr(theValuePtr)
     {}
-    
+
     //! Construct the class from corresponding container
     TSlice(TVector<value_type>& theContainer,
-           const std::slice& theSlice): 
+           const std::slice& theSlice):
       TSupperClass(theContainer, theSlice),
       myValuePtr(&theContainer[0])
     {}
-    
+
     //! Default constructor (dangerous)
     TSlice():
       myValuePtr(NULL)
     {}
 
     //! Get element by its number
-    value_type& 
+    value_type&
     operator[](size_t theId)
     {
       return *(myValuePtr + this->get_id(theId));
     }
 
-    value_type& 
+    value_type&
     at(size_t theId)
     {
       return *(myValuePtr + this->get_id_at(theId));
     }
   };
-
 }
 
 #undef MED_TCSLICE_CHECK_RANGE
 
-#endif
+#endif // MED_SliceArray_HeaderFile

src/MEDWrapper/MED_Structures.cxx

@@ -0,0 +1,849 @@
+// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  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, 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
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "MED_Structures.hxx"
+#include "MED_Utilities.hxx"
+
+#include <cstring>
+
+namespace MED
+{
+  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);
+  }
+
+  void
+  SetString(TInt theId,
+            TInt theStep,
+            TString& theString,
+            const std::string& theValue)
+  {
+    TInt aSize = std::min(TInt(theValue.size()+1),theStep);
+    char* aPos = &theString[theId*theStep];
+    strncpy(aPos,theValue.c_str(),aSize);
+  }
+
+  void
+  SetString(TInt theId,
+            TInt theStep,
+            TString& theString,
+            const TString& theValue)
+  {
+    TInt aSize = std::min(TInt(theValue.size()+1),theStep);
+    char* aPos = &theString[theId*theStep];
+    const char* aValue = &theValue[0];
+    strncpy(aPos,aValue,aSize);
+  }
+
+  TInt
+  GetDimGaussCoord(EGeometrieElement theGeom)
+  {
+    return theGeom/100;
+  }
+
+  TInt
+  GetNbRefCoord(EGeometrieElement theGeom)
+  {
+    return (theGeom%100);
+  }
+
+  //---------------------------------------------------------------
+  PFloatTimeStampValue
+  CastToFloatTimeStampValue(const PTimeStampValueBase& theTimeStampValue)
+  {
+    return theTimeStampValue;
+  }
+
+  PIntTimeStampValue
+  CastToIntTimeStampValue(const PTimeStampValueBase& theTimeStampValue)
+  {
+    return theTimeStampValue;
+  }
+
+  //---------------------------------------------------------------
+  TInt
+  TFamilyInfo
+  ::GetAttrId(TInt theId) const
+  {
+    return myAttrId[theId];
+  }
+
+  TInt
+  TFamilyInfo
+  ::GetAttrVal(TInt theId) const
+  {
+    return myAttrVal[theId];
+  }
+
+  void
+  TFamilyInfo
+  ::SetAttrId(TInt theId,TInt theVal)
+  {
+    myAttrId[theId] = theVal;
+  }
+
+  void
+  TFamilyInfo
+  ::SetAttrVal(TInt theId,TInt theVal)
+  {
+    myAttrVal[theId] = theVal;
+  }
+
+  //---------------------------------------------------------------
+  TInt
+  TElemInfo
+  ::GetFamNum(TInt theId) const
+  {
+    return (*myFamNum)[theId];
+  }
+
+  void
+  TElemInfo
+  ::SetFamNum(TInt theId, TInt theVal)
+  {
+    (*myFamNum)[theId] = theVal;
+    myIsFamNum = eVRAI;
+  }
+
+  TInt
+  TElemInfo
+  ::GetElemNum(TInt theId) const
+  {
+    return (*myElemNum)[theId];
+  }
+
+  void
+  TElemInfo
+  ::SetElemNum(TInt theId, TInt theVal)
+  {
+    (*myElemNum)[theId] = theVal;
+  }
+
+  //---------------------------------------------------------------
+  TCCoordSlice
+  TNodeInfo
+  ::GetCoordSlice(TInt theId) const
+  {
+    TInt aDim = myMeshInfo->GetSpaceDim();
+    if(GetModeSwitch() == eFULL_INTERLACE)
+      return TCCoordSlice(*myCoord, std::slice(theId*aDim, aDim, 1));
+    else
+      return TCCoordSlice(*myCoord, std::slice(theId, aDim, aDim));
+  }
+
+  TCoordSlice
+  TNodeInfo
+  ::GetCoordSlice(TInt theId)
+  {
+    TInt aDim = myMeshInfo->GetSpaceDim();
+    if(GetModeSwitch() == eFULL_INTERLACE)
+      return TCoordSlice(*myCoord, std::slice(theId*aDim,aDim,1));
+    else
+      return TCoordSlice(*myCoord, std::slice(theId,aDim,aDim));
+  }
+
+  //---------------------------------------------------------------
+  TCConnSlice
+  TCellInfo
+  ::GetConnSlice(TInt theElemId) const
+  {
+    if(GetModeSwitch() == eFULL_INTERLACE)
+      return TCConnSlice(*myConn, std::slice(GetConnDim()*theElemId, GetNbNodes(myGeom), 1));
+    else
+      return TCConnSlice(*myConn, std::slice(theElemId, GetNbNodes(myGeom), GetConnDim()));
+  }
+
+  TConnSlice
+  TCellInfo
+  ::GetConnSlice(TInt theElemId)
+  {
+    if(GetModeSwitch() == eFULL_INTERLACE)
+      return TConnSlice(*myConn, std::slice(GetConnDim()*theElemId, GetNbNodes(myGeom), 1));
+    else
+      return TConnSlice(*myConn, std::slice(theElemId, GetNbNodes(myGeom), GetConnDim()));
+  }
+
+  //---------------------------------------------------------------
+  TInt
+  TPolygoneInfo
+  ::GetNbConn(TInt theElemId) const
+  {
+    return (*myIndex)[theElemId + 1] - (*myIndex)[theElemId];
+  }
+
+  TCConnSlice
+  TPolygoneInfo
+  ::GetConnSlice(TInt theElemId) const
+  {
+    return TCConnSlice(*myConn, std::slice((*myIndex)[theElemId] - 1, GetNbConn(theElemId), 1));
+  }
+
+  TConnSlice
+  TPolygoneInfo
+  ::GetConnSlice(TInt theElemId)
+  {
+    return TConnSlice(*myConn, std::slice((*myIndex)[theElemId] - 1, GetNbConn(theElemId), 1));
+  }
+
+  //---------------------------------------------------------------
+  TInt
+  TPolyedreInfo
+  ::GetNbFaces(TInt theElemId) const
+  {
+    return (*myIndex)[theElemId+1] - (*myIndex)[theElemId];
+  }
+
+  TInt
+  TPolyedreInfo
+  ::GetNbNodes(TInt theElemId) const
+  {
+    TInt aNbNodes = 0;
+    TInt aNbFaces = GetNbFaces(theElemId);
+    TInt aStartFaceId = (*myIndex)[theElemId] - 1;
+    for(TInt aFaceId = 0; aFaceId < aNbFaces; aFaceId++, aStartFaceId++){
+      TInt aCurrentId = (*myFaces)[aStartFaceId];
+      TInt aDiff = (*myFaces)[aStartFaceId + 1] - aCurrentId;
+      aNbNodes += aDiff;
+    }
+    return aNbNodes;
+  }
+
+  TCConnSliceArr
+  TPolyedreInfo
+  ::GetConnSliceArr(TInt theElemId) const
+  {
+    TInt aNbFaces = GetNbFaces(theElemId);
+    TCConnSliceArr aConnSliceArr(aNbFaces);
+    TInt aStartFaceId = (*myIndex)[theElemId] - 1;
+    for(TInt aFaceId = 0; aFaceId < aNbFaces; aFaceId++, aStartFaceId++){
+      TInt aCurrentId = (*myFaces)[aStartFaceId];
+      TInt aDiff = (*myFaces)[aStartFaceId + 1] - aCurrentId;
+      aConnSliceArr[aFaceId] =
+        TCConnSlice(*myConn, std::slice(aCurrentId - 1, aDiff, 1));
+    }
+    return aConnSliceArr;
+  }
+
+  TConnSliceArr
+  TPolyedreInfo
+  ::GetConnSliceArr(TInt theElemId)
+  {
+    TInt aNbFaces = GetNbFaces(theElemId);
+    TConnSliceArr aConnSliceArr(aNbFaces);
+    TInt aStartFaceId = (*myIndex)[theElemId] - 1;
+    for(TInt aFaceId = 0; aFaceId < aNbFaces; aFaceId++, aStartFaceId++){
+      TInt aCurrentId = (*myFaces)[aStartFaceId];
+      TInt aDiff = (*myFaces)[aStartFaceId + 1] - aCurrentId;
+      aConnSliceArr[aFaceId] =
+        TConnSlice(*myConn, std::slice(aCurrentId - 1, aDiff, 1));
+    }
+    return aConnSliceArr;
+  }
+
+  //---------------------------------------------------------------
+  TMeshValueBase
+  ::TMeshValueBase():
+    myNbElem(0),
+    myNbComp(0),
+    myNbGauss(0),
+    myStep(0)
+  {}
+
+  void
+  TMeshValueBase
+  ::Allocate(TInt theNbElem,
+             TInt theNbGauss,
+             TInt theNbComp,
+             EModeSwitch theMode)
+  {
+    myModeSwitch = theMode;
+
+    myNbElem = theNbElem;
+    myNbGauss = theNbGauss;
+    myNbComp = theNbComp;
+
+    myStep = theNbComp*theNbGauss;
+  }
+
+  size_t
+  TMeshValueBase
+  ::GetSize() const
+  {
+    return myNbElem * myStep;
+  }
+
+  size_t
+  TMeshValueBase
+  ::GetNbVal() const
+  {
+    return myNbElem * myNbGauss;
+  }
+
+  size_t
+  TMeshValueBase
+  ::GetNbGauss() const
+  {
+    return myNbGauss;
+  }
+
+  size_t
+  TMeshValueBase
+  ::GetStep() const
+  {
+    return myStep;
+  }
+
+  //---------------------------------------------------------------
+  TInt
+  TProfileInfo
+  ::GetElemNum(TInt theId) const
+  {
+    return (*myElemNum)[theId];
+  }
+
+  void
+  TProfileInfo
+  ::SetElemNum(TInt theId,TInt theVal)
+  {
+    (*myElemNum)[theId] = theVal;
+  }
+
+  //---------------------------------------------------------------
+  bool
+  TGaussInfo::TLess
+  ::operator()(const TKey& theLeft, const TKey& theRight) const
+  {
+    EGeometrieElement aLGeom = boost::get<0>(theLeft);
+    EGeometrieElement aRGeom = boost::get<0>(theRight);
+    if(aLGeom != aRGeom)
+      return aLGeom < aRGeom;
+
+    const std::string& aLStr = boost::get<1>(theLeft);
+    const std::string& aRStr = boost::get<1>(theRight);
+    return aLStr < aRStr;
+  }
+
+  bool
+  TGaussInfo::TLess
+  ::operator()(const TGaussInfo& theLeft, const TGaussInfo& theRight) const
+  {
+    if(!&theLeft)
+      return true;
+
+    if(!&theRight)
+      return false;
+
+    if(theLeft.myGeom != theRight.myGeom)
+      return theLeft.myGeom < theRight.myGeom;
+
+    if(theLeft.myRefCoord != theRight.myRefCoord)
+      return theLeft.myRefCoord < theRight.myRefCoord;
+
+    return theLeft.myGaussCoord < theRight.myGaussCoord;
+  }
+
+  TCCoordSlice
+  TGaussInfo
+  ::GetRefCoordSlice(TInt theId) const
+  {
+    if(GetModeSwitch() == eFULL_INTERLACE)
+      return TCCoordSlice(myRefCoord,std::slice(theId*GetDim(),GetDim(),1));
+    else
+      return TCCoordSlice(myRefCoord,std::slice(theId,GetDim(),GetDim()));
+  }
+
+  TCoordSlice
+  TGaussInfo
+  ::GetRefCoordSlice(TInt theId)
+  {
+    if(GetModeSwitch() == eFULL_INTERLACE)
+      return TCoordSlice(myRefCoord,std::slice(theId*GetDim(),GetDim(),1));
+    else
+      return TCoordSlice(myRefCoord,std::slice(theId,GetDim(),GetDim()));
+  }
+
+  TCCoordSlice
+  TGaussInfo
+  ::GetGaussCoordSlice(TInt theId) const
+  {
+    if(GetModeSwitch() == eFULL_INTERLACE)
+      return TCCoordSlice(myGaussCoord,std::slice(theId*GetDim(),GetDim(),1));
+    else
+      return TCCoordSlice(myGaussCoord,std::slice(theId,GetDim(),GetDim()));
+  }
+
+  TCoordSlice
+  TGaussInfo
+  ::GetGaussCoordSlice(TInt theId)
+  {
+    if(GetModeSwitch() == eFULL_INTERLACE)
+      return TCoordSlice(myGaussCoord,std::slice(theId*GetDim(),GetNbGauss(),1));
+    else
+      return TCoordSlice(myGaussCoord,std::slice(theId,GetNbGauss(),GetDim()));
+  }
+
+  //---------------------------------------------------------------
+  TInt
+  TTimeStampInfo
+  ::GetNbGauss(EGeometrieElement theGeom) const
+  {
+    TGeom2NbGauss::const_iterator anIter = myGeom2NbGauss.find(theGeom);
+    if(anIter == myGeom2NbGauss.end())
+      return 1;//EXCEPTION(runtime_error,"TTimeStampInfo::GetNbGauss - myGeom2NbGauss.find(theGeom) fails");
+
+    return anIter->second;
+  }
+
+  //---------------------------------------------------------------
+  // TGrilleInfo structure methods
+  //---------------------------------------------------------------
+  const EGrilleType&
+  TGrilleInfo
+  ::GetGrilleType() const
+  {
+    return myGrilleType;
+  }
+
+  EGrilleType
+  TGrilleInfo
+  ::GetGrilleType()
+  {
+    return myGrilleType;
+  }
+
+  void
+  TGrilleInfo
+  ::SetGrilleType(EGrilleType theGrilleType)
+  {
+    myGrilleType = theGrilleType;
+  }
+
+  const
+  TIndexes&
+  TGrilleInfo
+  ::GetMapOfIndexes() const
+  {
+    return myIndixes;
+  }
+
+  TIndexes&
+  TGrilleInfo
+  ::GetMapOfIndexes()
+  {
+    return myIndixes;
+  }
+
+  const
+  TFloatVector&
+  TGrilleInfo
+  ::GetIndexes(TInt theAxisNumber) const
+  {
+    TIndexes::const_iterator aIter=myIndixes.find(theAxisNumber);
+    if(aIter==myIndixes.end())
+      EXCEPTION(std::runtime_error, "const TGrilleInfo::GetIndexes - myIndixes.find(theAxisNumber); fails");
+    return aIter->second;
+  }
+
+  TFloatVector&
+  TGrilleInfo
+  ::GetIndexes(TInt theAxisNumber)
+  {
+    TIndexes::iterator aIter=myIndixes.find(theAxisNumber);
+    if(aIter==myIndixes.end())
+      EXCEPTION(std::runtime_error, "TGrilleInfo::GetIndexes - myIndixes.find(theAxisNumber="<<theAxisNumber<<"); fails");
+    return aIter->second;
+  }
+
+  TInt
+  TGrilleInfo
+  ::GetNbIndexes(TInt theAxisNumber)
+  {
+    const TFloatVector& aVector=GetIndexes(theAxisNumber);
+    return aVector.size();
+  }
+
+  TInt
+  TGrilleInfo
+  ::GetNbNodes()
+  {
+    TInt nbNodes=0;
+    TInt aDim = myMeshInfo->GetDim();
+    for(int i=0;i<aDim;i++)
+      if(nbNodes == 0)
+        nbNodes = this->GetGrilleStructure()[i];
+      else
+        nbNodes = nbNodes*this->GetGrilleStructure()[i];
+
+    return nbNodes;
+  }
+
+  TInt
+  TGrilleInfo
+  ::GetNbCells()
+  {
+    TInt nbCells=0;
+    TInt aDim = myMeshInfo->GetDim();
+    for(int i=0;i<aDim;i++)
+      if(nbCells == 0)
+        nbCells = this->GetGrilleStructure()[i]-1;
+      else
+        nbCells = nbCells*(this->GetGrilleStructure()[i]-1);
+    return nbCells;
+  }
+
+  TInt
+  TGrilleInfo
+  ::GetNbSubCells()
+  {
+    TInt nb=0;
+    TInt aDim = myMeshInfo->GetDim();
+    switch (aDim) {
+    case 3:
+      nb =
+        (myGrilleStructure[0]  ) * (myGrilleStructure[1]-1) * (myGrilleStructure[2]-1) +
+        (myGrilleStructure[0]-1) * (myGrilleStructure[1]  ) * (myGrilleStructure[2]-1) +
+        (myGrilleStructure[0]-1) * (myGrilleStructure[1]-1) * (myGrilleStructure[2]  );
+      break;
+    case 2:
+      nb =
+        (myGrilleStructure[0]  ) * (myGrilleStructure[1]-1) +
+        (myGrilleStructure[0]-1) * (myGrilleStructure[1]  );
+      break;
+    }
+    return nb;
+  }
+
+  EGeometrieElement
+  TGrilleInfo
+  ::GetGeom()
+  {
+    TInt aDim = myMeshInfo->GetDim();
+    switch(aDim){
+    case 1:
+      return eSEG2;
+    case 2:
+      return eQUAD4;
+    case 3:
+      return eHEXA8;
+    default:
+      return eNONE;
+    }
+  }
+
+  EGeometrieElement
+  TGrilleInfo
+  ::GetSubGeom()
+  {
+    TInt aDim = myMeshInfo->GetDim();
+    switch(aDim){
+    case 2:
+      return eSEG2;
+    case 3:
+      return eQUAD4;
+    }
+    return eNONE;
+  }
+
+  EEntiteMaillage
+  TGrilleInfo
+  ::GetEntity()
+  {
+    return eMAILLE;
+  }
+
+  EEntiteMaillage
+  TGrilleInfo
+  ::GetSubEntity()
+  {
+    TInt aDim = myMeshInfo->GetDim();
+    switch(aDim){
+    case 2:
+      return eARETE;
+    case 3:
+      return eFACE;
+    }
+    return EEntiteMaillage(-1);
+  }
+
+  const
+  TIntVector&
+  TGrilleInfo
+  ::GetGrilleStructure() const
+  {
+    return myGrilleStructure;
+  }
+
+  TIntVector
+  TGrilleInfo
+  ::GetGrilleStructure()
+  {
+    return myGrilleStructure;
+  }
+
+  void
+  TGrilleInfo
+  ::SetGrilleStructure(TInt theAxis,TInt theNb)
+  {
+    if(theAxis >= 0 && theAxis <=2 && theNb >= 0)
+      myGrilleStructure[theAxis]=theNb;
+  }
+
+  const
+  TNodeCoord&
+  TGrilleInfo
+  ::GetNodeCoord() const
+  {
+    return myCoord;
+  }
+
+  TNodeCoord&
+  TGrilleInfo
+  ::GetNodeCoord()
+  {
+    return myCoord;
+  }
+
+  TNodeCoord
+  TGrilleInfo
+  ::GetCoord(TInt theId)
+  {
+    TNodeCoord aCoord;
+    TInt aDim       = myMeshInfo->GetDim();
+    TInt aNbNodes   = this->GetNbNodes();
+    aCoord.resize(aDim);
+
+    if(theId >= aNbNodes)
+      EXCEPTION(std::runtime_error, "TGrilleInfo::GetCoord - theId out of range");
+
+    if(myGrilleType == eGRILLE_STANDARD){
+      switch(aDim){
+      case 3:
+        aCoord[2] = myCoord[aDim*theId+2];
+      case 2:
+        aCoord[1] = myCoord[aDim*theId+1];
+      case 1:{
+        aCoord[0] = myCoord[aDim*theId];
+        break;
+      }
+      }
+    } else {
+
+      TFloatVector aVecX  = this->GetIndexes(0);
+      TInt nbIndxX        = this->GetNbIndexes(0);
+
+      switch(aDim){
+      case 1:{
+        aCoord[0] = aVecX[theId];
+        break;
+      }
+      case 2:{
+        TFloatVector aVecY = this->GetIndexes(1);
+        TInt i,j,k;
+        i = j = k = 0;
+        i = theId % nbIndxX;
+        j = theId / nbIndxX;
+        if(myGrilleType == eGRILLE_CARTESIENNE){
+          aCoord[0] = aVecX[i];
+          aCoord[1] = aVecY[j];
+        } else { // eGRILLE_POLAIRE (cylindrical)
+          aCoord[0] = aVecX[i] * cos(aVecY[j]);
+          aCoord[1] = aVecX[i] * sin(aVecY[j]);
+        }
+        break;
+      }
+      case 3:{
+        TFloatVector aVecY = this->GetIndexes(1);
+        TInt nbIndxY       = this->GetNbIndexes(1);
+        TFloatVector aVecZ = this->GetIndexes(2);
+        TInt i,j,k;
+        i = j = k = 0;
+
+        i = theId % nbIndxX;
+        j = (theId / nbIndxX) % nbIndxY;
+        k = theId / (nbIndxX*nbIndxY);
+
+        if(myGrilleType == eGRILLE_CARTESIENNE){
+          aCoord[0] = aVecX[i];
+          aCoord[1] = aVecY[j];
+          aCoord[2] = aVecZ[k];
+        } else { // eGRILLE_POLAIRE (cylindrical)
+          aCoord[0] = aVecX[i] * cos(aVecY[j]);
+          aCoord[1] = aVecX[i] * sin(aVecY[j]);
+          aCoord[2] = aVecZ[k];
+        }
+
+        break;
+      }
+      }
+    }
+
+    return aCoord;
+  }
+
+  TIntVector
+  TGrilleInfo
+  ::GetConn(TInt theId, const bool isSub)
+  {
+    TIntVector anIndexes;
+    TInt aDim = myMeshInfo->GetDim();
+
+    TInt idx;
+    TInt iMin, jMin, kMin, iMax, jMax, kMax;
+    TInt loc[3];
+
+    loc[0] = loc[1] = loc[2] = 0;
+    iMin = iMax = jMin = jMax = kMin = kMax = 0;
+
+    switch(aDim) {
+    case 3:
+      {
+        TInt nbX = this->GetGrilleStructure()[0];
+        TInt nbY = this->GetGrilleStructure()[1];
+        TInt nbZ = this->GetGrilleStructure()[2];
+        TInt d01 = nbX*nbY, dX = 1, dY = 1, dZ = 1;
+        if ( isSub )
+          {
+            if ( theId < nbX * (nbY-1) * (nbZ-1))
+              { // face is normal to X axis
+                dX = 0;
+              }
+            else if ( theId < nbX * (nbY-1) * (nbZ-1) + (nbX-1) * nbY * (nbZ-1))
+              {  // face is normal to Y axis
+                theId -= nbX * (nbY-1) * (nbZ-1);
+                dY = 0;
+              }
+            else
+              {
+                theId -= nbX * (nbY-1) * (nbZ-1) + (nbX-1) * nbY * (nbZ-1);
+                dZ = 0;
+              }
+          }
+        //else
+        {
+          iMin = theId % (nbX - dX);
+          jMin = (theId / (nbX - dX)) % (nbY - dY);
+          kMin = theId / ((nbX - dX) * (nbY - dY));
+          iMax = iMin+dX;
+          jMax = jMin+dY;
+          kMax = kMin+dZ;
+        }
+        for (loc[2]=kMin; loc[2]<=kMax; loc[2]++)
+          for (loc[1]=jMin; loc[1]<=jMax; loc[1]++)
+            for (loc[0]=iMin; loc[0]<=iMax; loc[0]++)
+              {
+                idx = loc[0] + loc[1]*nbX + loc[2]*d01;
+                anIndexes.push_back(idx);
+              }
+        break;
+      }
+    case 2:
+      {
+        TInt nbX = this->GetGrilleStructure()[0];
+        TInt nbY = this->GetGrilleStructure()[1];
+        TInt dX = 1, dY = 1;
+        if ( isSub )
+          {
+            if ( theId < nbX * (nbY-1))
+              { // edge is normal to X axis
+                dX = 0;
+              }
+            else
+              {
+                theId -= nbX * (nbY-1);
+                dY = 0;
+              }
+          }
+        iMin = theId % (nbX-dX);
+        jMin = theId / (nbX-dX);
+        iMax = iMin+dX;
+        jMax = jMin+dY;
+        for (loc[1]=jMin; loc[1]<=jMax; loc[1]++)
+          for (loc[0]=iMin; loc[0]<=iMax; loc[0]++)
+            {
+              idx = loc[0] + loc[1]*nbX;
+              anIndexes.push_back(idx);
+            }
+        break;
+      }
+    case 1:
+      {
+        iMin = theId;
+        for (loc[0]=iMin; loc[0]<=iMin+1; loc[0]++)
+          {
+            idx = loc[0];
+            anIndexes.push_back(idx);
+          }
+        break;
+      }
+    }
+
+    return anIndexes;
+  }
+
+  TInt
+  TGrilleInfo
+  ::GetFamNumNode(TInt theId) const
+  {
+    return myFamNumNode[theId];
+  }
+
+  void
+  TGrilleInfo
+  ::SetFamNumNode(TInt theId,TInt theVal)
+  {
+    myFamNumNode[theId] = theVal;
+  }
+
+  TInt
+  TGrilleInfo
+  ::GetFamNum(TInt theId) const
+  {
+    return myFamNum[theId];
+  }
+
+  void
+  TGrilleInfo
+  ::SetFamNum(TInt theId,TInt theVal)
+  {
+    myFamNum[theId] = theVal;
+  }
+
+  TInt
+  TGrilleInfo
+  ::GetFamSubNum(TInt theId) const
+  {
+    return myFamSubNum[theId];
+  }
+
+  void
+  TGrilleInfo
+  ::SetFamSubNum(TInt theId,TInt theVal)
+  {
+    myFamSubNum[theId] = theVal;
+  }
+}

src/MEDWrapper/MED_Structures.hxx

@@ -23,8 +23,12 @@
 #ifndef MED_Structures_HeaderFile
 #define MED_Structures_HeaderFile
 
+#include "MED_WrapperDef.hxx"
 #include "MED_Common.hxx"
 #include "MED_Utilities.hxx"
+#include "MED_SliceArray.hxx"
+
+#include <boost/tuple/tuple.hpp>
 
 #ifdef WIN32
 #pragma warning(disable:4251)
@@ -32,40 +36,44 @@
 
 namespace MED
 {
-
   //---------------------------------------------------------------
   //! Defines a type for managing sequence of strings
-  typedef TVector<char> TString; 
+  typedef TVector<char> TString;
   typedef SharedPtr<TString> PString;
 
+  //---------------------------------------------------------------
   //! Extract a substring from the sequence of the strings
   MEDWRAPPER_EXPORT
-  std::string 
+  std::string
-  GetString(TInt theId, TInt theStep, 
+  GetString(TInt theId,
+            TInt theStep,
             const TString& theString);
-  
-  //! Set a substring in the sequence of the strings
-  MEDWRAPPER_EXPORT 
-  void
-  SetString(TInt theId, TInt theStep, 
-                 TString& theString, 
-                 const std::string& theValue);
 
+  //---------------------------------------------------------------
   //! Set a substring in the sequence of the strings
   MEDWRAPPER_EXPORT
   void
-  SetString(TInt theId, TInt theStep, 
+  SetString(TInt theId,
-                 TString& theString, 
+            TInt theStep,
-                 const TString& theValue);
+            TString& theString,
+            const std::string& theValue);
+
+  //---------------------------------------------------------------
+  //! Set a substring in the sequence of the strings
+  MEDWRAPPER_EXPORT
+  void
+  SetString(TInt theId,
+            TInt theStep,
+            TString& theString,
+            const TString& theValue);
 
   //---------------------------------------------------------------
   //! Define a parent class for all MEDWrapper classes
   struct MEDWRAPPER_EXPORT TBase
   {
-    virtual ~TBase() {} 
+    virtual ~TBase() {}
   };
 
-
   //---------------------------------------------------------------
   //! Define a parent class for all named MED entities
   struct MEDWRAPPER_EXPORT TNameInfo: virtual TBase
@@ -76,11 +84,10 @@ namespace MED
     virtual void SetName(const TString& theValue) = 0; //!< Set a new name
   };
 
-
   //---------------------------------------------------------------
   //! Define a parent class for all MED entities that contains a sequence of numbers
   /*!
-    It defines through corresponding enumeration (EModeSwitch) how the sequence 
+    It defines through corresponding enumeration (EModeSwitch) how the sequence
     should be interpreted in C or Fortran mode (eFULL_INTERLACE or eNON_INTERLACE).
   */
   struct MEDWRAPPER_EXPORT TModeSwitchInfo: virtual TBase
@@ -95,67 +102,62 @@ namespace MED
       myModeSwitch(theModeSwitch)
     {}
 
-    EModeSwitch myModeSwitch; //!< Keeps the 
+    EModeSwitch myModeSwitch; //!< Keeps the interlace mode
-    EModeSwitch GetModeSwitch() const { return myModeSwitch;}
+    EModeSwitch GetModeSwitch() const { return myModeSwitch; }
   };
 
-
   //---------------------------------------------------------------
   //! Define a base class which represents MED Mesh entity
   struct MEDWRAPPER_EXPORT TMeshInfo: virtual TNameInfo
   {
     TInt myDim; //!< Dimension of the mesh (0, 1, 2 or 3)
-    TInt GetDim() const { return myDim;} //!< Gets dimension of the mesh
+    TInt GetDim() const { return myDim; } //!< Gets dimension of the mesh
 
     TInt mySpaceDim;
     TInt GetSpaceDim() const { return mySpaceDim; }
 
     EMaillage myType; //!< Type of the mesh
-    EMaillage GetType() const { return myType;} //!< Gets type of the mesh
+    EMaillage GetType() const { return myType; } //!< Gets type of the mesh
 
     TString myDesc; //!< Description of the mesh
     virtual std::string GetDesc() const = 0; //!< Get description for the mesh
     virtual void SetDesc(const std::string& theValue) = 0; //!< Sets description for the mesh
-
-    
   };
-  
 
   //---------------------------------------------------------------
-  typedef TVector<TInt> TIntVector;
   typedef TSlice<TInt> TIntVecSlice;
   typedef TCSlice<TInt> TCIntVecSlice;
-
   typedef TIntVector TFamAttr;
 
+  //---------------------------------------------------------------
   //! Define a base class which represents MED Family entity
   struct MEDWRAPPER_EXPORT TFamilyInfo: virtual TNameInfo
   {
     PMeshInfo myMeshInfo; //!< A reference to correspondig MED Mesh
     //! Get a reference to corresponding MED Mesh
-    const PMeshInfo& GetMeshInfo() const { return myMeshInfo;} 
+    const PMeshInfo& GetMeshInfo() const { return myMeshInfo; }
 
     TInt myId; //!< An unique index of the MED FAMILY
-    TInt GetId() const { return myId;} //!< Gets number of the MED FAMILY
+    TInt GetId() const { return myId; } //!< Gets number of the MED FAMILY
-    void SetId(TInt theId) { myId = theId;} //! Define number of the MED FAMILY
+    void SetId(TInt theId) { myId = theId; } //! Define number of the MED FAMILY
 
     TInt myNbGroup; //!< Defines number MED Groups connected to
     //! Gets number of MED GROUPS the MED FAMILY is bound to
-    TInt GetNbGroup() const { return myNbGroup;} 
+    TInt GetNbGroup() const { return myNbGroup; }
 
     //! Contains sequence of the names for the MED Groups connected to
-    TString myGroupNames; 
+    TString myGroupNames;
     //! Gets name of a bound MED GROUP by its number
     virtual std::string GetGroupName(TInt theId) const = 0;
     //! Sets name of the defined MED GROUP by its number
     virtual void SetGroupName(TInt theId, const std::string& theValue) = 0;
 
-    TInt myNbAttr; //!< Defines number of the MED Family attributes 
+    TInt myNbAttr; //!< Defines number of the MED Family attributes
     //! Gets number of attached attributes for the MED FAMILY
-    TInt GetNbAttr() const { return myNbAttr;} 
+    TInt GetNbAttr() const { return myNbAttr; }
 
     //! Defines sequence of the indexes of the MED Family attributes
-    TFamAttr myAttrId; 
+    TFamAttr myAttrId;
     //! Get MED FAMILY attribute by its number
     TInt GetAttrId(TInt theId) const;
     //! Set MED FAMILY attribute by its number
@@ -176,38 +178,37 @@ namespace MED
     virtual void SetAttrDesc(TInt theId, const std::string& theValue) = 0;
   };
 
-
   //---------------------------------------------------------------
   typedef TIntVector TElemNum;
   typedef SharedPtr<TElemNum> PElemNum;
-  
+
+  //---------------------------------------------------------------
   //! Define a parent class for all MED entities that describes mesh entites such as nodes and cells.
   struct MEDWRAPPER_EXPORT TElemInfo: virtual TBase
   {
     PMeshInfo myMeshInfo; //!< A reference to correspondig MED Mesh
     //! Get a reference to corresponding MED Mesh
-    const PMeshInfo& GetMeshInfo() const { return myMeshInfo;}
+    const PMeshInfo& GetMeshInfo() const { return myMeshInfo; }
 
     TInt myNbElem; //<! Number of corresponding mesh entities
-    TInt GetNbElem() const { return myNbElem;} //! Get number of mesh elements
+    TInt GetNbElem() const { return myNbElem; } //! Get number of mesh elements
-    
+
     //! Defines sequence MED Family indexes for corresponding mesh entites
-    PElemNum myFamNum; 
+    PElemNum myFamNum;
     //! Get number of a MED FAMILY by order number of the mesh element
     TInt GetFamNum(TInt theId) const;
-    //! Set number of a MED FAMILY for the mesh element with the  order number
+    //! Set number of a MED FAMILY for the mesh element with the order number
     void SetFamNum(TInt theId, TInt theVal);
 
     //! Defines if the mesh elements are indexed
     EBooleen myIsElemNum;
     //! Let know if the mesh elements are indexed
-    EBooleen IsElemNum() const { return myIsElemNum;}
+    EBooleen IsElemNum() const { return myIsElemNum; }
-    
+
     //! Defines if the mesh elements family are indexed
     EBooleen myIsFamNum;
     //! Let know if the mesh elements family are indexed
-    EBooleen IsFamNum() const { return myIsFamNum;}
+    EBooleen IsFamNum() const { return myIsFamNum; }
-    
 
     //! Contains sequence of the indexes for the mesh elements
     PElemNum myElemNum;
@@ -219,7 +220,7 @@ namespace MED
     //! Defines if the mesh elements are named
     EBooleen myIsElemNames;
     //! Let know if the mesh elements havew names
-    EBooleen IsElemNames() const { return myIsElemNames;}
+    EBooleen IsElemNames() const { return myIsElemNames; }
 
     //! Contains sequence of the names for the mesh elements
     PString myElemNames;
@@ -229,22 +230,19 @@ namespace MED
     virtual void SetElemName(TInt theId, const std::string& theValue) = 0;
   };
 
-
   //---------------------------------------------------------------
-  typedef TVector<TFloat> TFloatVector;
   typedef TSlice<TFloat> TFloatVecSlice;
   typedef TCSlice<TFloat> TCFloatVecSlice;
-
   typedef TFloatVector TNodeCoord;
   typedef SharedPtr<TNodeCoord> PNodeCoord;
-
   typedef TFloatVecSlice TCoordSlice;
   typedef TCFloatVecSlice TCCoordSlice;
 
+  //---------------------------------------------------------------
   //! Define a base class which represents MED Nodes entity
-  struct MEDWRAPPER_EXPORT TNodeInfo: 
+  struct MEDWRAPPER_EXPORT TNodeInfo:
     virtual TElemInfo,
-    virtual TModeSwitchInfo 
+    virtual TModeSwitchInfo
   {
     PNodeCoord myCoord; //!< Contains all nodal coordinates
 
@@ -255,9 +253,9 @@ namespace MED
 
     ERepere mySystem; //!< Defines, which coordinate system is used
     //! Get which coordinate system is used for the node describing
-    ERepere GetSystem() const { return mySystem;}
+    ERepere GetSystem() const { return mySystem; }
     //! Set coordinate system to be used for the node describing
-    void SetSystem(ERepere theSystem) { mySystem = theSystem;}
+    void SetSystem(ERepere theSystem) { mySystem = theSystem; }
 
     TString myCoordNames; //!< Contains names for the coordinate dimensions
     //! Get name of the coordinate dimension by its order number
@@ -272,27 +270,27 @@ namespace MED
     virtual void SetCoordUnit(TInt theId, const std::string& theValue) = 0;
   };
 
-
   //---------------------------------------------------------------
   typedef TIntVecSlice TConnSlice;
   typedef TCIntVecSlice TCConnSlice;
 
+  //---------------------------------------------------------------
   //! Define a base class which represents MED Cells entity
-  struct MEDWRAPPER_EXPORT TCellInfo: 
+  struct MEDWRAPPER_EXPORT TCellInfo:
     virtual TElemInfo,
-    virtual TModeSwitchInfo 
+    virtual TModeSwitchInfo
   {
     EEntiteMaillage myEntity; //!< Defines the MED Entity where the mesh cells belongs to
     //! Find out what MED ENTITY the cells belong to
-    EEntiteMaillage GetEntity() const { return myEntity;}
+    EEntiteMaillage GetEntity() const { return myEntity; }
 
     EGeometrieElement myGeom; //!< Defines the MED Geometric type of the instance
     //! Find out what MED geometrical type the cells belong to
-    EGeometrieElement GetGeom() const { return myGeom;}
+    EGeometrieElement GetGeom() const { return myGeom; }
 
     EConnectivite myConnMode; //!< Defines connectivity mode
-    //! Find out in what connectivity the cells are written
+    //! Find out in what connectivity the cells are writen
-    EConnectivite GetConnMode() const { return myConnMode;}
+    EConnectivite GetConnMode() const { return myConnMode; }
 
     virtual TInt GetConnDim() const = 0; //!< Gives step in the connectivity sequence
 
@@ -306,23 +304,23 @@ namespace MED
 
   //---------------------------------------------------------------
   //! Define a base class which represents MED Polygon entity
-  struct MEDWRAPPER_EXPORT TPolygoneInfo: 
+  struct MEDWRAPPER_EXPORT TPolygoneInfo:
     virtual TElemInfo
   {
     //! Defines the MED Entity where the polygons belongs to
     EEntiteMaillage myEntity; // MED_FACE|MED_MAILLE
     //! Find out what MED ENTITY the MED Polygons belong to
-    EEntiteMaillage GetEntity() const { return myEntity;}
+    EEntiteMaillage GetEntity() const { return myEntity; }
 
     //! Defines the MED Geometric type of the instance
     EGeometrieElement myGeom; // ePOLYGONE
     //! Find out what MED geometrical type the MED Polygons belong to
-    EGeometrieElement GetGeom() const { return ePOLYGONE;}
+    EGeometrieElement GetGeom() const { return ePOLYGONE; }
 
     //! Defines connectivity mode
     EConnectivite myConnMode; // eNOD|eDESC(eDESC not used)
-    //! Find out in what connectivity the cells are written
+    //! Find out in what connectivity the cells are writen
-    EConnectivite GetConnMode() const { return myConnMode;}
+    EConnectivite GetConnMode() const { return myConnMode; }
 
     PElemNum myConn; //!< Table de connectivities
     PElemNum myIndex; //!< Table de indexes
@@ -338,12 +336,12 @@ namespace MED
 
   //---------------------------------------------------------------
   //! Define a class representing MED_BALL structure element.
-  //
+  /*!
-  //  This could be a generic class for any structure element
+    This could be a generic class for any structure element
-  //  holding any number of contant and variable attributes
+    holding any number of contant and variable attributes
-  //  but it's too hard to implement
+    but it's too hard to implement
-  //
+  */
-  struct MEDWRAPPER_EXPORT TBallInfo: 
+  struct MEDWRAPPER_EXPORT TBallInfo:
     virtual TCellInfo
   {
     TFloatVector myDiameters;
@@ -353,24 +351,25 @@ namespace MED
   typedef TVector<TCConnSlice> TCConnSliceArr;
   typedef TVector<TConnSlice> TConnSliceArr;
 
+  //---------------------------------------------------------------
   //! Define a base class which represents MED Polyedre entity
-  struct MEDWRAPPER_EXPORT TPolyedreInfo: 
+  struct MEDWRAPPER_EXPORT TPolyedreInfo:
     virtual TElemInfo
   {
     //! Defines the MED Entity where the polyedres belongs to
     EEntiteMaillage myEntity; // MED_FACE|MED_MAILLE
     //! Find out what MED ENTITY the MED Polyedres belong to
-    EEntiteMaillage GetEntity() const { return myEntity;}
+    EEntiteMaillage GetEntity() const { return myEntity; }
 
     //! Defines the MED Geometric type of the instance
     EGeometrieElement myGeom; // ePOLYEDRE
     //! Find out what MED geometrical type the MED Polyedres belong to
-    EGeometrieElement GetGeom() const { return ePOLYEDRE;}
+    EGeometrieElement GetGeom() const { return ePOLYEDRE; }
 
     //! Defines connectivity mode
     EConnectivite myConnMode; // eNOD|eDESC(eDESC not used)
-    //! Find out in what connectivity the cells are written
+    //! Find out in what connectivity the cells are writen
-    EConnectivite GetConnMode() const { return myConnMode;}
+    EConnectivite GetConnMode() const { return myConnMode; }
 
     PElemNum myConn; //!< Table de connectivities
     PElemNum myFaces; //!< Table de faces indexes
@@ -389,28 +388,28 @@ namespace MED
 
   //---------------------------------------------------------------
   //! Define a base class which represents MED Field entity
-  struct MEDWRAPPER_EXPORT TFieldInfo: 
+  struct MEDWRAPPER_EXPORT TFieldInfo:
     virtual TNameInfo
   {
     PMeshInfo myMeshInfo; //!< A reference to corresponding MED Mesh
     //! Get a reference to corresponding MED Mesh
-    const PMeshInfo& GetMeshInfo() const { return myMeshInfo;}
+    const PMeshInfo& GetMeshInfo() const { return myMeshInfo; }
 
     ETypeChamp myType; //!< Defines type of MED Field
     //! Find out what type of MED FIELD is used
-    ETypeChamp GetType() const { return myType;}
+    ETypeChamp GetType() const { return myType; }
 
     TInt myNbComp; //!< Defines number of components stored in the field
     //! Get number of components for MED FIELD
-    TInt GetNbComp() const { return myNbComp;}
+    TInt GetNbComp() const { return myNbComp; }
 
     EBooleen myIsLocal; //!< Defines if the MED Field is local
     //! Find out if MED FIELD is local or not
-    EBooleen GetIsLocal() const { return myIsLocal;}
+    EBooleen GetIsLocal() const { return myIsLocal; }
 
     TInt myNbRef; //!< Defines number of references of the field
     //! Find out number of references for the MED FIELD
-    TInt GetNbRef() const { return myNbRef;}
+    TInt GetNbRef() const { return myNbRef; }
 
     TString myCompNames; //!< Contains names for each of MED Field components
     //! Get name of the component by its order number
@@ -423,27 +422,28 @@ namespace MED
     virtual std::string GetUnitName(TInt theId) const = 0;
     //! Set unit for the component by its order number
     virtual void SetUnitName(TInt theId, const std::string& theValue) = 0;
-
   };
 
-
   //---------------------------------------------------------------
   //! Get dimension of the Gauss coordinates for the defined type of mesh cell
   MEDWRAPPER_EXPORT
   TInt
   GetDimGaussCoord(EGeometrieElement theGeom);
 
+  //---------------------------------------------------------------
   //! Get number of referenced nodes for the defined type of mesh cell
   MEDWRAPPER_EXPORT
   TInt
   GetNbRefCoord(EGeometrieElement theGeom);
 
+  //---------------------------------------------------------------
   typedef TFloatVector TWeight;
 
+  //---------------------------------------------------------------
   //! The class represents MED Gauss entity
-  struct MEDWRAPPER_EXPORT TGaussInfo: 
+  struct MEDWRAPPER_EXPORT TGaussInfo:
     virtual TNameInfo,
-    virtual TModeSwitchInfo 
+    virtual TModeSwitchInfo
   {
     typedef boost::tuple<EGeometrieElement,std::string> TKey;
     typedef boost::tuple<TKey,TInt> TInfo;
@@ -457,12 +457,12 @@ namespace MED
     };
 
     //! Defines, which geometrical type the MED Gauss entity belongs to
-    EGeometrieElement myGeom; 
+    EGeometrieElement myGeom;
     //! Find out what MED geometrical type the MED GAUSS entity belong to
-    EGeometrieElement GetGeom() const { return myGeom;}
+    EGeometrieElement GetGeom() const { return myGeom; }
 
     //! Contains coordinates for the refereced nodes
-    TNodeCoord myRefCoord; 
+    TNodeCoord myRefCoord;
 
     //! Gives coordinates for the referenced node by its number
     TCCoordSlice GetRefCoordSlice(TInt theId) const;
@@ -481,54 +481,54 @@ namespace MED
     TWeight myWeight;
 
     //! Gives number of the referenced nodes
-    TInt GetNbRef() const { return GetNbRefCoord(GetGeom());}
+    TInt GetNbRef() const { return GetNbRefCoord(GetGeom()); }
 
     //! Gives dimension of the referenced nodes
-    TInt GetDim() const { return GetDimGaussCoord(GetGeom());}
+    TInt GetDim() const { return GetDimGaussCoord(GetGeom()); }
 
     //! Gives number of the Gauss Points
-    TInt GetNbGauss() const { return (TInt)(myGaussCoord.size()/GetDim());}
+    TInt GetNbGauss() const { return (TInt)(myGaussCoord.size() / GetDim()); }
   };
 
-
   //---------------------------------------------------------------
   typedef std::map<EGeometrieElement,PGaussInfo> TGeom2Gauss;
   typedef std::map<EGeometrieElement,TInt> TGeom2NbGauss;
 
+  //---------------------------------------------------------------
   //! Define a base class which represents MED TimeStamp
-  struct MEDWRAPPER_EXPORT TTimeStampInfo: 
+  struct MEDWRAPPER_EXPORT TTimeStampInfo:
     virtual TBase
   {
     PFieldInfo myFieldInfo; //!< A reference to correspondig MED Field
     //! Get a reference to corresponding MED Field
-    const PFieldInfo& GetFieldInfo() const { return myFieldInfo;}
+    const PFieldInfo& GetFieldInfo() const { return myFieldInfo; }
 
     //! Defines the MED Entity where the MED TimeStamp belongs to
     EEntiteMaillage myEntity;
     //! Find out to what MED Entity the MED TimeStamp belong to
-    EEntiteMaillage GetEntity() const { return myEntity;}
+    EEntiteMaillage GetEntity() const { return myEntity; }
 
     //! Keeps map of number of cells per geometric type where the MED TimeStamp belongs to
     TGeom2Size myGeom2Size;
     //! Get map of number of cells per geometric type where the MED TimeStamp belongs to
-    const TGeom2Size& GetGeom2Size() const { return myGeom2Size;}
+    const TGeom2Size& GetGeom2Size() const { return myGeom2Size; }
 
     TGeom2NbGauss myGeom2NbGauss; //!< Keeps number of the Gauss Points for the MED TimeStamp
     TInt GetNbGauss(EGeometrieElement theGeom) const; //!< Gives number of the Gauss Points for the MED TimeStamp
 
     TInt myNumDt; //!< Keeps number in time for the MED TimeStamp
-    TInt GetNumDt() const { return myNumDt;} //!< Defines number in time for the MED TimeStamp
+    TInt GetNumDt() const { return myNumDt; } //!< Defines number in time for the MED TimeStamp
 
     TInt myNumOrd; //!< Keeps number for the MED TimeStamp
-    TInt GetNumOrd() const { return myNumOrd;} //!< Defines number for the MED TimeStamp
+    TInt GetNumOrd() const { return myNumOrd; } //!< Defines number for the MED TimeStamp
 
     TFloat myDt; //!< Keeps time for the MED TimeStamp
-    TFloat GetDt() const { return myDt;} //!< Defines time for the MED TimeStamp
+    TFloat GetDt() const { return myDt; } //!< Defines time for the MED TimeStamp
 
     //! Keeps map of MED Gauss entityes per geometric type
     TGeom2Gauss myGeom2Gauss;
     //! Gets a map of MED Gauss entityes per geometric type
-    const TGeom2Gauss& GetGeom2Gauss() const { return myGeom2Gauss;}
+    const TGeom2Gauss& GetGeom2Gauss() const { return myGeom2Gauss; }
 
     TString myUnitDt; //!< Defines unit for the time for the MED TimeStamp
     //! Get unit of time for the MED TimeStamp
@@ -536,11 +536,10 @@ namespace MED
     //! Set unit of time for the MED TimeStamp
     virtual void SetUnitDt(const std::string& theValue) = 0;
   };
-  
 
   //---------------------------------------------------------------
   //! The class represents MED Profile entity
-  struct MEDWRAPPER_EXPORT TProfileInfo: 
+  struct MEDWRAPPER_EXPORT TProfileInfo:
     virtual TNameInfo
   {
     typedef std::string TKey;
@@ -548,9 +547,9 @@ namespace MED
 
     EModeProfil myMode; //!< Keeps mode for the MED Profile
     //! Find out what mode of MED Profile is used
-    EModeProfil GetMode() const { return myMode;}
+    EModeProfil GetMode() const { return myMode; }
     //! Set mode for the MED Profile
-    void SetMode(EModeProfil theMode) { myMode = theMode;}
+    void SetMode(EModeProfil theMode) { myMode = theMode; }
 
     PElemNum myElemNum; //!< Keeps sequence of cell by its number which belong to the profile
     //! Get number of mesh elelemts by its order number
@@ -559,17 +558,16 @@ namespace MED
     void SetElemNum(TInt theId, TInt theVal);
 
     //! Find out if the MED Profile defined
-    bool IsPresent() const { return GetName() != "";}
+    bool IsPresent() const { return GetName() != ""; }
 
     //! Find out size of the MED Profile
-    TInt GetSize() const { return (TInt)myElemNum->size();}
+    TInt GetSize() const { return (TInt)myElemNum->size(); }
   };
 
-
   //---------------------------------------------------------------
   //! The class is a helper one. It provide safe and flexible way to get access to values for a MED TimeStamp
   struct MEDWRAPPER_EXPORT TMeshValueBase:
-    virtual TModeSwitchInfo 
+    virtual TModeSwitchInfo
   {
     TInt myNbElem;
     TInt myNbComp;
@@ -588,19 +586,19 @@ namespace MED
     //! Returns size of the value container
     size_t
     GetSize() const;
-    
+
     //! Returns MED interpetation of the value size
     size_t
     GetNbVal() const;
-    
+
     //! Returns number of Gauss Points bounded with the value
     size_t
     GetNbGauss() const;
-    
+
     //! Returns step inside of the data array
     size_t
     GetStep() const;
-    
+
     //! Returns bare pointer on the internal value representation
     virtual
     unsigned char*
@@ -611,17 +609,17 @@ namespace MED
   //! The class is a helper one. It provide safe and flexible way to get access to values for a MED TimeStamp
   template<class TValueType>
   struct TTMeshValue:
-    virtual TMeshValueBase 
+    virtual TMeshValueBase
   {
     typedef TValueType TValue;
     typedef typename TValueType::value_type TElement;
 
     typedef TSlice<TElement> TValueSlice;
     typedef TCSlice<TElement> TCValueSlice;
-    
+
     typedef TVector<TCValueSlice> TCValueSliceArr;
     typedef TVector<TValueSlice> TValueSliceArr;
-    
+
     TValue myValue;
 
     //! Initialize the class
@@ -682,7 +680,7 @@ namespace MED
     }
 
     //! Iteration through Gauss Points by their components
-    TValueSliceArr 
+    TValueSliceArr
     GetGaussValueSliceArr(TInt theElemId)
     {
       TValueSliceArr aValueSliceArr(myNbGauss);
@@ -726,7 +724,7 @@ namespace MED
     }
 
     //! Iteration through components by corresponding Gauss Points
-    TValueSliceArr 
+    TValueSliceArr
     GetCompValueSliceArr(TInt theElemId)
     {
       if(GetModeSwitch() == eFULL_INTERLACE){
@@ -750,18 +748,19 @@ namespace MED
     }
   };
 
+  //---------------------------------------------------------------
   typedef TTMeshValue<TFloatVector> TFloatMeshValue;
   typedef TTMeshValue<TIntVector> TIntMeshValue;
 
   //---------------------------------------------------------------
-  // Backward compatibility  declarations
+  // Backward compatibility declarations
   typedef TFloatVector TValue;
   typedef TSlice<TFloat> TValueSlice;
   typedef TCSlice<TFloat> TCValueSlice;
-  
+
   typedef TVector<TCValueSlice> TCValueSliceArr;
   typedef TVector<TValueSlice> TValueSliceArr;
-    
+
   typedef TFloatMeshValue TMeshValue;
   typedef std::map<EGeometrieElement,TMeshValue> TGeom2Value;
 
@@ -769,61 +768,61 @@ namespace MED
   typedef std::map<EGeometrieElement,PProfileInfo> TGeom2Profile;
   typedef std::set<EGeometrieElement> TGeom;
 
+  //---------------------------------------------------------------
   //! The class is a base class for MED TimeStamp values holder
-  struct MEDWRAPPER_EXPORT TTimeStampValueBase: 
+  struct MEDWRAPPER_EXPORT TTimeStampValueBase:
-    virtual TModeSwitchInfo 
+    virtual TModeSwitchInfo
   {
     //! A reference to correspondig MED TimeStamp
     PTimeStampInfo myTimeStampInfo;
     //!< Get a reference to correspondig MED TimeStamp
-    const PTimeStampInfo& GetTimeStampInfo() const { return myTimeStampInfo;}
+    const PTimeStampInfo& GetTimeStampInfo() const { return myTimeStampInfo; }
 
     //! Keeps set of MED EGeometrieElement which contains values for the timestamp
     TGeomSet myGeomSet;
-    const TGeomSet& GetGeomSet() const { return myGeomSet;}
+    const TGeomSet& GetGeomSet() const { return myGeomSet; }
 
     //! Keeps map of MED Profiles per geometric type
     TGeom2Profile myGeom2Profile;
     //! Gets a map of MED Profiles per geometric type
-    const TGeom2Profile& GetGeom2Profile() const { return myGeom2Profile;}
+    const TGeom2Profile& GetGeom2Profile() const { return myGeom2Profile; }
 
     //! Gets type of the champ
-    virtual 
+    virtual
     ETypeChamp
     GetTypeChamp() const = 0;
 
     //! Allocates values for the given geometry
-    virtual 
+    virtual
     void
     AllocateValue(EGeometrieElement theGeom,
                   TInt theNbElem,
                   TInt theNbGauss,
                   TInt theNbComp,
                   EModeSwitch theMode = eFULL_INTERLACE) = 0;
-    
+
-    virtual 
+    virtual
     size_t
     GetValueSize(EGeometrieElement theGeom) const = 0;
-    
+
-    virtual 
+    virtual
     size_t
     GetNbVal(EGeometrieElement theGeom) const = 0;
-    
+
-    virtual 
+    virtual
     size_t
     GetNbGauss(EGeometrieElement theGeom) const = 0;
 
-    virtual 
+    virtual
     unsigned char*
     GetValuePtr(EGeometrieElement theGeom) = 0;
   };
 
-
   //---------------------------------------------------------------
   //! The class implements a container for MED TimeStamp values
   template<class TMeshValueType>
-  struct TTimeStampValue: 
+  struct TTimeStampValue:
-    virtual TTimeStampValueBase 
+    virtual TTimeStampValueBase
   {
     typedef TMeshValueType TTMeshValue;
     typedef SharedPtr<TMeshValueType> PTMeshValue;
@@ -833,7 +832,7 @@ namespace MED
     ETypeChamp myTypeChamp; //<! Keeps type of the champ
 
     //! Gets type of the champ
-    virtual 
+    virtual
     ETypeChamp
     GetTypeChamp() const
     {
@@ -843,14 +842,14 @@ namespace MED
     //! Keeps map of MED TimeStamp values per geometric type (const version)
     TTGeom2Value myGeom2Value;
 
-    const TTGeom2Value& 
+    const TTGeom2Value&
     GetGeom2Value() const
     {
       return myGeom2Value;
     }
 
     //! Gets MED TimeStamp values for the given geometric type (const version)
-    const PTMeshValue& 
+    const PTMeshValue&
     GetMeshValuePtr(EGeometrieElement theGeom) const
     {
       typename TTGeom2Value::const_iterator anIter = myGeom2Value.find(theGeom);
@@ -860,7 +859,7 @@ namespace MED
     }
 
     //! Gets MED TimeStamp values for the given geometric type
-    PTMeshValue& 
+    PTMeshValue&
     GetMeshValuePtr(EGeometrieElement theGeom)
     {
       myGeomSet.insert(theGeom);
@@ -872,21 +871,20 @@ namespace MED
     }
 
     //! Gets MED TimeStamp values for the given geometric type (const version)
-    const TTMeshValue& 
+    const TTMeshValue&
     GetMeshValue(EGeometrieElement theGeom) const
     {
       return *(this->GetMeshValuePtr(theGeom));
     }
 
     //! Gets MED TimeStamp values for the given geometric type
-    TTMeshValue& 
+    TTMeshValue&
     GetMeshValue(EGeometrieElement theGeom)
     {
       return *(this->GetMeshValuePtr(theGeom));
     }
   };
 
-
   //---------------------------------------------------------------
   typedef TTimeStampValue<TFloatMeshValue> TFloatTimeStampValue;
   typedef SharedPtr<TFloatTimeStampValue> PFloatTimeStampValue;
@@ -896,11 +894,10 @@ namespace MED
 
   typedef TTimeStampValue<TIntMeshValue> TIntTimeStampValue;
   typedef SharedPtr<TIntTimeStampValue> PIntTimeStampValue;
-  
+
   PIntTimeStampValue MEDWRAPPER_EXPORT
   CastToIntTimeStampValue(const PTimeStampValueBase& theTimeStampValue);
 
-
   //---------------------------------------------------------------
   template<class TMeshValueTypeFrom, class TMeshValueTypeTo>
   void
@@ -917,8 +914,8 @@ namespace MED
       const EGeometrieElement& aGeom = anIter->first;
       const typename TimeStampValueTypeFrom::TTMeshValue& aMeshValue = *anIter->second;
       typename TimeStampValueTypeTo::TTMeshValue& aMeshValue2 = theTimeStampValueTo->GetMeshValue(aGeom);
-      aMeshValue2.Allocate(aMeshValue.myNbElem, 
+      aMeshValue2.Allocate(aMeshValue.myNbElem,
-                           aMeshValue.myNbGauss, 
+                           aMeshValue.myNbGauss,
                            aMeshValue.myNbComp,
                            aMeshValue.myModeSwitch);
       const typename TimeStampValueTypeFrom::TTMeshValue::TValue& aValue = aMeshValue.myValue;
@@ -929,6 +926,7 @@ namespace MED
     }
   }
 
+  //---------------------------------------------------------------
   template<class TMeshValueType>
   void
   CopyTimeStampValue(SharedPtr<TTimeStampValue<TMeshValueType> > theTimeStampValueFrom,
@@ -948,7 +946,7 @@ namespace MED
   //---------------------------------------------------------------
   inline
   void
-  CopyTimeStampValueBase(const PTimeStampValueBase& theValueFrom, 
+  CopyTimeStampValueBase(const PTimeStampValueBase& theValueFrom,
                          const PTimeStampValueBase& theValueTo)
   {
     if(theValueFrom->GetTypeChamp() == theValueTo->GetTypeChamp()){
@@ -964,23 +962,22 @@ namespace MED
     }
   }
 
-
   //---------------------------------------------------------------
-  // Backward compatibility  declarations
+  // Backward compatibility declarations
   typedef TFloatTimeStampValue TTimeStampVal;
   typedef PFloatTimeStampValue PTimeStampVal;
 
   //---------------------------------------------------------------
   typedef std::map<TInt,TFloatVector> TIndexes;
   typedef std::map<TInt,TString> TNames;
-  
+
+  //---------------------------------------------------------------
   //! Define a base class which represents MED Grille (structured mesh)
   struct MEDWRAPPER_EXPORT TGrilleInfo:
     virtual TModeSwitchInfo
   {
-
     PMeshInfo myMeshInfo;
-    const PMeshInfo& GetMeshInfo() const { return myMeshInfo;} 
+    const PMeshInfo& GetMeshInfo() const { return myMeshInfo; }
 
     TNodeCoord myCoord; //!< Contains all nodal coordinates, now used only for eGRILLE_STANDARD
     //! Gives coordinates for mesh nodes (const version)
@@ -999,8 +996,6 @@ namespace MED
     //!Sets grille type
     void SetGrilleType(EGrilleType theGrilleType);
 
-
-    
     TString myCoordNames; //!< Contains names for the coordinate dimensions
     //! Get name of the coordinate dimension by its order number
     virtual std::string GetCoordName(TInt theId) const = 0 ;
@@ -1013,7 +1008,6 @@ namespace MED
     //! Set name of unit for the coordinate dimension by its order number
     virtual void SetCoordUnit(TInt theId, const std::string& theValue) = 0;
 
-
     //! Map of index of axes and Table of indexes for certain axe, now used for eGRILLE_CARTESIENNE and eGRILLE_POLAIRE
     TIndexes myIndixes;
     //!Gets a map of Tables (const version)
@@ -1026,7 +1020,7 @@ namespace MED
     TFloatVector& GetIndexes(TInt theAxisNumber);
     //!Gets a number of indices per axe
     TInt GetNbIndexes(TInt theAxisNumber);
-    
+
     TInt GetNbNodes();//! Return count of all points
     TInt GetNbCells();//! Return count of all cells
     TInt GetNbSubCells();//! Return count of all entities of <mesh dimension-1>
@@ -1045,37 +1039,34 @@ namespace MED
     TIntVector GetGrilleStructure();
     //!Sets the grille structure of theAxis axe to theNb.
     void SetGrilleStructure(TInt theAxis,TInt theNb);
-    
+
     /*!
      *Defines sequence MED Family indexes for corresponding mesh entites
      */
-    TElemNum myFamNum; 
+    TElemNum myFamNum;
     //! Get number of a MED FAMILY by order number of the mesh element
     TInt GetFamNum(TInt theId) const;
-    //! Set number of a MED FAMILY for the mesh element with the  order number
+    //! Set number of a MED FAMILY for the mesh element with the order number
     void SetFamNum(TInt theId, TInt theVal);
-    
+
     /*!
      *Defines sequence MED Family indexes for sub entites
      */
-    TElemNum myFamSubNum; 
+    TElemNum myFamSubNum;
     //! Get number of a MED FAMILY by order number of sub element
     TInt GetFamSubNum(TInt theId) const;
     //! Set number of a MED FAMILY for theId-th sub element
     void SetFamSubNum(TInt theId, TInt theVal);
-    
+
     /*!
      *Defines sequence MED Family indexes for corresponding mesh nodes
      */
     TElemNum myFamNumNode;
     //! Get number of a MED FAMILY by order number of the mesh node
     TInt GetFamNumNode(TInt theId) const;
-    //! Set number of a MED FAMILY for the mesh node with the  order number
+    //! Set number of a MED FAMILY for the mesh node with the order number
     void SetFamNumNode(TInt theId, TInt theVal);
-
   };
-
-
 }
 
-#endif
+#endif // MED_Structures_HeaderFile

src/MEDWrapper/MED_TStructures.hxx

@@ -19,6 +19,7 @@
 //
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
+
 #ifndef MED_TStructures_HeaderFile
 #define MED_TStructures_HeaderFile
 
@@ -91,12 +92,11 @@ namespace MED
   };
   
   //---------------------------------------------------------------
-  template<EVersion eVersion>
   struct TTNameInfo: virtual TNameInfo
   {
     TTNameInfo(const std::string& theValue)
     {
-      myName.resize(GetNOMLength<eVersion>()+1);
+      myName.resize(GetNOMLength()+1);
       SetName(theValue);
     }
 
@@ -104,32 +104,30 @@ namespace MED
     std::string
     GetName() const 
     { 
-      return GetString(0, GetNOMLength<eVersion>(), myName);
+      return GetString(0, GetNOMLength(), myName);
     }
 
     virtual
     void
     SetName(const std::string& theValue)
     {
-      SetString(0, GetNOMLength<eVersion>(), myName, theValue);
+      SetString(0, GetNOMLength(), myName, theValue);
     }
 
     virtual
     void
     SetName(const TString& theValue)
     {
-      SetString(0, GetNOMLength<eVersion>(), myName, theValue);
+      SetString(0, GetNOMLength(), myName, theValue);
     }
   };
 
-
   //---------------------------------------------------------------
-  template<EVersion eVersion>
   struct TTMeshInfo: 
     virtual TMeshInfo, 
-    virtual TTNameInfo<eVersion>
+    virtual TTNameInfo
   {
-    typedef TTNameInfo<eVersion> TNameInfoBase;
+    typedef TTNameInfo TNameInfoBase;
 
     TTMeshInfo(const PMeshInfo& theInfo):
       TNameInfoBase(theInfo->GetName())
@@ -138,7 +136,7 @@ namespace MED
       mySpaceDim = theInfo->GetSpaceDim();
       myType = theInfo->GetType();
       
-      myDesc.resize(GetDESCLength<eVersion>()+1);
+      myDesc.resize(GetDESCLength()+1);
       SetDesc(theInfo->GetDesc());
     }
 
@@ -152,7 +150,7 @@ namespace MED
       mySpaceDim = theSpaceDim;
       myType = theType;
       
-      myDesc.resize(GetDESCLength<eVersion>()+1);
+      myDesc.resize(GetDESCLength()+1);
       SetDesc(theDesc);
     }
 
@@ -160,25 +158,23 @@ namespace MED
     std::string
     GetDesc() const 
     { 
-      return GetString(0, GetDESCLength<eVersion>(), myDesc);
+      return GetString(0, GetDESCLength(), myDesc);
     }
 
     virtual
     void
     SetDesc(const std::string& theValue)
     {
-      SetString(0, GetDESCLength<eVersion>(), myDesc, theValue);
+      SetString(0, GetDESCLength(), myDesc, theValue);
     }
   };
 
-
   //---------------------------------------------------------------
-  template<EVersion eVersion>
   struct TTFamilyInfo: 
     virtual TFamilyInfo, 
-    virtual TTNameInfo<eVersion>
+    virtual TTNameInfo
   {
-    typedef TTNameInfo<eVersion> TNameInfoBase;
+    typedef TTNameInfo TNameInfoBase;
 
     TTFamilyInfo(const PMeshInfo& theMeshInfo, const PFamilyInfo& theInfo):
       TNameInfoBase(theInfo->GetName())
@@ -188,7 +184,7 @@ namespace MED
       myId = theInfo->GetId();
 
       myNbGroup = theInfo->GetNbGroup();
-      myGroupNames.resize(myNbGroup*GetLNOMLength<eVersion>()+1);
+      myGroupNames.resize(myNbGroup*GetLNOMLength()+1);
       if(myNbGroup){
         for(TInt anId = 0; anId < myNbGroup; anId++){
           SetGroupName(anId,theInfo->GetGroupName(anId));
@@ -198,7 +194,7 @@ namespace MED
       myNbAttr = theInfo->GetNbAttr();
       myAttrId.resize(myNbAttr);
       myAttrVal.resize(myNbAttr);
-      myAttrDesc.resize(myNbAttr*GetDESCLength<eVersion>()+1);
+      myAttrDesc.resize(myNbAttr*GetDESCLength()+1);
       if(myNbAttr){
         for(TInt anId = 0; anId < myNbAttr; anId++){
           SetAttrDesc(anId,theInfo->GetAttrDesc(anId));
@@ -220,12 +216,12 @@ namespace MED
       myId = theId;
 
       myNbGroup = theNbGroup;
-      myGroupNames.resize(theNbGroup*GetLNOMLength<eVersion>()+1);
+      myGroupNames.resize(theNbGroup*GetLNOMLength()+1);
 
       myNbAttr = theNbAttr;
       myAttrId.resize(theNbAttr);
       myAttrVal.resize(theNbAttr);
-      myAttrDesc.resize(theNbAttr*GetDESCLength<eVersion>()+1);
+      myAttrDesc.resize(theNbAttr*GetDESCLength()+1);
     }
 
     TTFamilyInfo(const PMeshInfo& theMeshInfo,
@@ -242,7 +238,7 @@ namespace MED
       myId = theId;
 
       myNbGroup = (TInt)theGroupNames.size();
-      myGroupNames.resize(myNbGroup*GetLNOMLength<eVersion>()+1);
+      myGroupNames.resize(myNbGroup*GetLNOMLength()+1);
       if(myNbGroup){
         TStringSet::const_iterator anIter = theGroupNames.begin();
         for(TInt anId = 0; anIter != theGroupNames.end(); anIter++, anId++){
@@ -254,7 +250,7 @@ namespace MED
       myNbAttr = (TInt)theAttrDescs.size();
       myAttrId.resize(myNbAttr);
       myAttrVal.resize(myNbAttr);
-      myAttrDesc.resize(myNbAttr*GetDESCLength<eVersion>()+1);
+      myAttrDesc.resize(myNbAttr*GetDESCLength()+1);
       if(myNbAttr){
         for(TInt anId = 0, anEnd = (TInt)theAttrDescs.size(); anId < anEnd; anId++){
           SetAttrDesc(anId,theAttrDescs[anId]);
@@ -268,34 +264,32 @@ namespace MED
     std::string
     GetGroupName(TInt theId) const 
     { 
-      return GetString(theId, GetLNOMLength<eVersion>(), myGroupNames);
+      return GetString(theId, GetLNOMLength(), myGroupNames);
     }
 
     virtual
     void
     SetGroupName(TInt theId, const std::string& theValue)
     {
-      SetString(theId, GetLNOMLength<eVersion>(), myGroupNames, theValue);
+      SetString(theId, GetLNOMLength(), myGroupNames, theValue);
     }
 
     virtual
     std::string
     GetAttrDesc(TInt theId) const 
     { 
-      return GetString(theId, GetDESCLength<eVersion>(), myAttrDesc);
+      return GetString(theId, GetDESCLength(), myAttrDesc);
     }
 
     virtual
     void
     SetAttrDesc(TInt theId, const std::string& theValue)
     {
-      SetString(theId, GetDESCLength<eVersion>(), myAttrDesc, theValue);
+      SetString(theId, GetDESCLength(), myAttrDesc, theValue);
     }
   };
 
-
   //---------------------------------------------------------------
-  template<EVersion eVersion>
   struct TTElemInfo: virtual TElemInfo
   {
     TTElemInfo(const PMeshInfo& theMeshInfo, const PElemInfo& theInfo)
@@ -314,7 +308,7 @@ namespace MED
 
       myIsElemNames = theInfo->IsElemNames();
       if(theInfo->IsElemNames())
-        myElemNames.reset(new TString(myNbElem*GetPNOMLength<eVersion>() + 1));
+        myElemNames.reset(new TString(myNbElem*GetPNOMLength() + 1));
       else
         myElemNames.reset(new TString());
 
@@ -354,7 +348,7 @@ namespace MED
 
       myIsElemNames = theIsElemNames;
       if(theIsElemNames)
-        myElemNames.reset(new TString(theNbElem*GetPNOMLength<eVersion>() + 1));
+        myElemNames.reset(new TString(theNbElem*GetPNOMLength() + 1));
       else
         myElemNames.reset(new TString());
    }
@@ -379,7 +373,7 @@ namespace MED
       
       myIsElemNames = theElemNames.size()? eVRAI: eFAUX;
       if(myIsElemNames)
-        myElemNames.reset(new TString(theNbElem*GetPNOMLength<eVersion>() + 1));
+        myElemNames.reset(new TString(theNbElem*GetPNOMLength() + 1));
       else
         myElemNames.reset(new TString());
      
@@ -404,25 +398,23 @@ namespace MED
     std::string
     GetElemName(TInt theId) const 
     { 
-      return GetString(theId,GetPNOMLength<eVersion>(), *myElemNames);
+      return GetString(theId,GetPNOMLength(), *myElemNames);
     }
 
     virtual
     void
     SetElemName(TInt theId, const std::string& theValue)
     {
-      SetString(theId,GetPNOMLength<eVersion>(), *myElemNames, theValue);
+      SetString(theId,GetPNOMLength(), *myElemNames, theValue);
     }
   };
 
-
   //---------------------------------------------------------------
-  template<EVersion eVersion>
   struct TTNodeInfo: 
     virtual TNodeInfo, 
-    virtual TTElemInfo<eVersion>
+    virtual TTElemInfo
   {
-    typedef TTElemInfo<eVersion> TElemInfoBase;
+    typedef TTElemInfo TElemInfoBase;
 
     TTNodeInfo(const PMeshInfo& theMeshInfo, const PNodeInfo& theInfo):
       TNodeInfo(theInfo),
@@ -436,11 +428,11 @@ namespace MED
       
       TInt aSpaceDim = theMeshInfo->GetSpaceDim();
 
-      myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+      myCoordNames.resize(aSpaceDim*GetPNOMLength()+1);
       for(TInt anId = 0; anId < aSpaceDim; anId++)
         SetCoordName(anId,theInfo->GetCoordName(anId));
       
-      myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+      myCoordUnits.resize(aSpaceDim*GetPNOMLength()+1);
       for(TInt anId = 0; anId < aSpaceDim; anId++)
         SetCoordUnit(anId,theInfo->GetCoordUnit(anId));
     }
@@ -461,9 +453,9 @@ namespace MED
 
       myCoord.reset(new TNodeCoord(theNbElem * theMeshInfo->mySpaceDim));
 
-      myCoordUnits.resize(theMeshInfo->mySpaceDim*GetPNOMLength<eVersion>()+1);
+      myCoordUnits.resize(theMeshInfo->mySpaceDim*GetPNOMLength()+1);
 
-      myCoordNames.resize(theMeshInfo->mySpaceDim*GetPNOMLength<eVersion>()+1);
+      myCoordNames.resize(theMeshInfo->mySpaceDim*GetPNOMLength()+1);
     }
 
     
@@ -489,12 +481,12 @@ namespace MED
       
       TInt aSpaceDim = theMeshInfo->GetSpaceDim();
 
-      myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+      myCoordNames.resize(aSpaceDim*GetPNOMLength()+1);
       if(!theCoordNames.empty())
         for(TInt anId = 0; anId < aSpaceDim; anId++)
           SetCoordName(anId,theCoordNames[anId]);
       
-      myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>() + 1);
+      myCoordUnits.resize(aSpaceDim*GetPNOMLength() + 1);
       if(!theCoordUnits.empty())
         for(TInt anId = 0; anId < aSpaceDim; anId++)
           SetCoordUnit(anId, theCoordUnits[anId]);
@@ -504,38 +496,37 @@ namespace MED
     std::string
     GetCoordName(TInt theId) const 
     { 
-      return GetString(theId,GetPNOMLength<eVersion>(),myCoordNames);
+      return GetString(theId,GetPNOMLength(),myCoordNames);
     }
 
     virtual
     void
     SetCoordName(TInt theId, const std::string& theValue)
     {
-      SetString(theId,GetPNOMLength<eVersion>(),myCoordNames,theValue);
+      SetString(theId,GetPNOMLength(),myCoordNames,theValue);
     }
 
     virtual
     std::string 
     GetCoordUnit(TInt theId) const 
     { 
-      return GetString(theId,GetPNOMLength<eVersion>(),myCoordUnits);
+      return GetString(theId,GetPNOMLength(),myCoordUnits);
     }
 
     virtual
     void
     SetCoordUnit(TInt theId, const std::string& theValue)
     {
-      SetString(theId,GetPNOMLength<eVersion>(),myCoordUnits,theValue);
+      SetString(theId,GetPNOMLength(),myCoordUnits,theValue);
     }
   };
 
   //---------------------------------------------------------------
-  template<EVersion eVersion>
   struct TTPolygoneInfo: 
     virtual TPolygoneInfo, 
-    virtual TTElemInfo<eVersion>
+    virtual TTElemInfo
   {
-    typedef TTElemInfo<eVersion> TElemInfoBase;
+    typedef TTElemInfo TElemInfoBase;
 
     TTPolygoneInfo(const PMeshInfo& theMeshInfo, const PPolygoneInfo& theInfo):
       TElemInfoBase(theMeshInfo,theInfo)
@@ -597,12 +588,11 @@ namespace MED
   };
   
   //---------------------------------------------------------------
-  template<EVersion eVersion>
   struct TTPolyedreInfo: 
     virtual TPolyedreInfo, 
-    virtual TTElemInfo<eVersion>
+    virtual TTElemInfo
   {
-    typedef TTElemInfo<eVersion> TElemInfoBase;
+    typedef TTElemInfo TElemInfoBase;
 
     TTPolyedreInfo(const PMeshInfo& theMeshInfo, const PPolyedreInfo& theInfo):
       TElemInfoBase(theMeshInfo,theInfo)
@@ -669,12 +659,11 @@ namespace MED
   };
 
   //---------------------------------------------------------------
-  template<EVersion eVersion>
   struct TTCellInfo: 
     virtual TCellInfo, 
-    virtual TTElemInfo<eVersion>
+    virtual TTElemInfo
   {
-    typedef TTElemInfo<eVersion> TElemInfoBase;
+    typedef TTElemInfo TElemInfoBase;
 
     TTCellInfo(const PMeshInfo& theMeshInfo, const PCellInfo& theInfo):
       TElemInfoBase(theMeshInfo,theInfo)
@@ -684,7 +673,7 @@ namespace MED
       myConnMode  = theInfo->GetConnMode();
       
       TInt aConnDim = GetNbNodes(myGeom);
-      TInt aNbConn = GetNbConn<eVersion>(myGeom, myEntity, myMeshInfo->myDim);
+      TInt aNbConn = GetNbConn(myGeom, myEntity, myMeshInfo->myDim);
       myConn.reset(new TElemNum(myNbElem * aNbConn));
       for(TInt anElemId = 0; anElemId < myNbElem; anElemId++){
         TConnSlice aConnSlice = GetConnSlice(anElemId);
@@ -713,7 +702,7 @@ namespace MED
       myGeom = theGeom;
 
       myConnMode = theConnMode;
-      TInt aNbConn = GetNbConn<eVersion>(theGeom, myEntity, theMeshInfo->myDim);
+      TInt aNbConn = GetNbConn(theGeom, myEntity, theMeshInfo->myDim);
       myConn.reset(new TElemNum(theNbElem * aNbConn));
     }
     
@@ -738,7 +727,7 @@ namespace MED
 
       myConnMode = theConnMode;
       TInt aConnDim = GetNbNodes(myGeom);
-      TInt aNbConn = GetNbConn<eVersion>(myGeom, myEntity, myMeshInfo->myDim);
+      TInt aNbConn = GetNbConn(myGeom, myEntity, myMeshInfo->myDim);
       myConn.reset(new TElemNum(myNbElem * aNbConn));
       for(TInt anElemId = 0; anElemId < myNbElem; anElemId++){
         TConnSlice aConnSlice = GetConnSlice(anElemId);
@@ -752,18 +741,17 @@ namespace MED
     TInt
     GetConnDim() const 
     { 
-      return GetNbConn<eVersion>(myGeom, myEntity, myMeshInfo->myDim);
+      return GetNbConn(myGeom, myEntity, myMeshInfo->myDim);
     }
 
   };
 
   //---------------------------------------------------------------
-  template<EVersion eVersion>
   struct TTBallInfo: 
     virtual TBallInfo,
-    virtual TTCellInfo<eVersion>
+    virtual TTCellInfo
   {
-    typedef TTCellInfo<eVersion> TCellInfoBase;
+    typedef TTCellInfo TCellInfoBase;
 
     TTBallInfo(const PMeshInfo& theMeshInfo, const PBallInfo& theInfo):
       TCellInfoBase::TElemInfoBase(theMeshInfo, theInfo),
@@ -816,12 +804,11 @@ namespace MED
   };
 
   //---------------------------------------------------------------
-  template<EVersion eVersion>
   struct TTFieldInfo: 
     virtual TFieldInfo, 
-    virtual TTNameInfo<eVersion>
+    virtual TTNameInfo
   {
-    typedef TTNameInfo<eVersion> TNameInfoBase;
+    typedef TTNameInfo TNameInfoBase;
 
     TTFieldInfo(const PMeshInfo& theMeshInfo, const PFieldInfo& theInfo):
       TNameInfoBase(theInfo->GetName())
@@ -829,12 +816,12 @@ namespace MED
       myMeshInfo = theMeshInfo;
 
       myNbComp = theInfo->GetNbComp();
-      myCompNames.resize(myNbComp*GetPNOMLength<eVersion>()+1);
+      myCompNames.resize(myNbComp*GetPNOMLength()+1);
       for(TInt anId = 0; anId < myNbComp; anId++){
         SetCompName(anId,theInfo->GetCompName(anId));
       }
 
-      myUnitNames.resize(myNbComp*GetPNOMLength<eVersion>()+1);
+      myUnitNames.resize(myNbComp*GetPNOMLength()+1);
       for(TInt anId = 0; anId < myNbComp; anId++){
         SetUnitName(anId,theInfo->GetUnitName(anId));
       }
@@ -856,8 +843,8 @@ namespace MED
       myMeshInfo = theMeshInfo;
 
       myNbComp = theNbComp;
-      myCompNames.resize(theNbComp*GetPNOMLength<eVersion>()+1);
+      myCompNames.resize(theNbComp*GetPNOMLength()+1);
-      myUnitNames.resize(theNbComp*GetPNOMLength<eVersion>()+1);
+      myUnitNames.resize(theNbComp*GetPNOMLength()+1);
 
       myType = theType;
 
@@ -869,39 +856,37 @@ namespace MED
     std::string
     GetCompName(TInt theId) const 
     { 
-      return GetString(theId,GetPNOMLength<eVersion>(),myCompNames);
+      return GetString(theId,GetPNOMLength(),myCompNames);
     }
 
     virtual
     void
     SetCompName(TInt theId, const std::string& theValue)
     {
-      SetString(theId,GetPNOMLength<eVersion>(),myCompNames,theValue);
+      SetString(theId,GetPNOMLength(),myCompNames,theValue);
     }
 
     virtual
     std::string 
     GetUnitName(TInt theId) const 
     { 
-      return GetString(theId,GetPNOMLength<eVersion>(),myUnitNames);
+      return GetString(theId,GetPNOMLength(),myUnitNames);
     }
 
     virtual
     void
     SetUnitName(TInt theId, const std::string& theValue)
     {
-      SetString(theId,GetPNOMLength<eVersion>(),myUnitNames,theValue);
+      SetString(theId,GetPNOMLength(),myUnitNames,theValue);
     }
   };
 
-
   //---------------------------------------------------------------
-  template<EVersion eVersion>
   struct TTGaussInfo: 
     virtual TGaussInfo,
-    virtual TTNameInfo<eVersion>
+    virtual TTNameInfo
   {
-    typedef TTNameInfo<eVersion> TNameInfoBase;
+    typedef TTNameInfo TNameInfoBase;
 
     TTGaussInfo(const TGaussInfo::TInfo& theInfo,
                 EModeSwitch theMode):
@@ -919,9 +904,7 @@ namespace MED
     }
   };
 
-
   //---------------------------------------------------------------
-  template<EVersion eVersion>
   struct TTTimeStampInfo: virtual TTimeStampInfo
   {
     TTTimeStampInfo(const PFieldInfo& theFieldInfo, const PTimeStampInfo& theInfo)
@@ -935,7 +918,7 @@ namespace MED
       myNumOrd = theInfo->GetNumOrd();
       myDt = theInfo->GetDt();
 
-      myUnitDt.resize(GetPNOMLength<eVersion>()+1);
+      myUnitDt.resize(GetPNOMLength()+1);
       SetUnitDt(theInfo->GetUnitDt());
 
       myGeom2NbGauss = theInfo->myGeom2NbGauss;
@@ -961,7 +944,7 @@ namespace MED
       myNumOrd = theNumDt;
       myDt = theDt;
 
-      myUnitDt.resize(GetPNOMLength<eVersion>()+1);
+      myUnitDt.resize(GetPNOMLength()+1);
       SetUnitDt(theUnitDt);
 
       myGeom2NbGauss = theGeom2NbGauss;
@@ -972,25 +955,23 @@ namespace MED
     std::string
     GetUnitDt() const
     { 
-      return GetString(0,GetPNOMLength<eVersion>(),myUnitDt);
+      return GetString(0,GetPNOMLength(),myUnitDt);
     }
 
     virtual
     void
     SetUnitDt(const std::string& theValue)
     {
-      SetString(0,GetPNOMLength<eVersion>(),myUnitDt,theValue);
+      SetString(0,GetPNOMLength(),myUnitDt,theValue);
     }
   };
 
-
   //---------------------------------------------------------------
-  template<EVersion eVersion>
   struct TTProfileInfo: 
     virtual TProfileInfo,
-    virtual TTNameInfo<eVersion>
+    virtual TTNameInfo
   {
-    typedef TTNameInfo<eVersion> TNameInfoBase;
+    typedef TTNameInfo TNameInfoBase;
 
     TTProfileInfo(const TProfileInfo::TInfo& theInfo,
                   EModeProfil theMode):
@@ -1002,9 +983,8 @@ namespace MED
     }
   };
 
-
   //---------------------------------------------------------------
-  template<EVersion eVersion, class TMeshValueType>
+  template<class TMeshValueType>
   struct TTTimeStampValue: virtual TTimeStampValue<TMeshValueType>
   {
     TTTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
@@ -1097,7 +1077,6 @@ namespace MED
   };
 
   //---------------------------------------------------------------
-  template<EVersion eVersion>
   struct TTGrilleInfo:
     virtual TGrilleInfo
   {
@@ -1134,11 +1113,11 @@ namespace MED
       TInt aSpaceDim = theMeshInfo->GetSpaceDim();
       if(type == eGRILLE_STANDARD){
         myCoord.resize(aSpaceDim*nnoeuds);
-        myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+        myCoordNames.resize(aSpaceDim*GetPNOMLength()+1);
-        myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+        myCoordUnits.resize(aSpaceDim*GetPNOMLength()+1);
       } else { //if(type == eGRILLE_CARTESIENNE){
-        myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
+        myCoordNames.resize(aSpaceDim*GetPNOMLength()+aSpaceDim);
-        myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
+        myCoordUnits.resize(aSpaceDim*GetPNOMLength()+aSpaceDim);
       }
       myGrilleStructure.resize(aSpaceDim);
       myFamNumNode.resize(nnoeuds);
@@ -1150,11 +1129,11 @@ namespace MED
       myMeshInfo        = theMeshInfo;
       TInt aSpaceDim = theMeshInfo->GetSpaceDim();
       if(type == eGRILLE_STANDARD){
-        myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+        myCoordNames.resize(aSpaceDim*GetPNOMLength()+1);
-        myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+        myCoordUnits.resize(aSpaceDim*GetPNOMLength()+1);
       } else {// if(type == eGRILLE_CARTESIENNE){
-        myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
+        myCoordNames.resize(aSpaceDim*GetPNOMLength()+aSpaceDim);
-        myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
+        myCoordUnits.resize(aSpaceDim*GetPNOMLength()+aSpaceDim);
       }
       myGrilleStructure.resize(aSpaceDim);
     }
@@ -1167,11 +1146,11 @@ namespace MED
 
       TInt aSpaceDim = theMeshInfo->GetSpaceDim();
       if(type == eGRILLE_STANDARD){
-        myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+        myCoordNames.resize(aSpaceDim*GetPNOMLength()+1);
-        myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+        myCoordUnits.resize(aSpaceDim*GetPNOMLength()+1);
       } else {// if(type == eGRILLE_CARTESIENNE){
-        myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
+        myCoordNames.resize(aSpaceDim*GetPNOMLength()+aSpaceDim);
-        myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
+        myCoordUnits.resize(aSpaceDim*GetPNOMLength()+aSpaceDim);
       }
 
       if(type != eGRILLE_STANDARD)
@@ -1185,31 +1164,30 @@ namespace MED
     std::string
     GetCoordName(TInt theId) const 
     { 
-      return GetString(theId,GetPNOMLength<eVersion>(),myCoordNames);
+      return GetString(theId,GetPNOMLength(),myCoordNames);
     }
 
     virtual
     void
     SetCoordName(TInt theId, const std::string& theValue)
     {
-      SetString(theId,GetPNOMLength<eVersion>(),myCoordNames,theValue);
+      SetString(theId,GetPNOMLength(),myCoordNames,theValue);
     }
 
     virtual
     std::string 
     GetCoordUnit(TInt theId) const 
     { 
-      return GetString(theId,GetPNOMLength<eVersion>(),myCoordUnits);
+      return GetString(theId,GetPNOMLength(),myCoordUnits);
     }
 
     virtual
     void
     SetCoordUnit(TInt theId, const std::string& theValue)
     {
-      SetString(theId,GetPNOMLength<eVersion>(),myCoordUnits,theValue);
+      SetString(theId,GetPNOMLength(),myCoordUnits,theValue);
     }
-
   };
 }
 
-#endif
+#endif // MED_TStructures_HeaderFile

src/MEDWrapper/MED_Utilities.cxx

@@ -19,28 +19,41 @@
 //
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
-//  File   : MED_WrapperFactory.hxx
-//  Author : Alexander A. BORODIN
-//
-#ifndef _MED_WrapperFactory_HXX_
-#define _MED_WrapperFactory_HXX_
 
-#ifdef WIN32
+#include "MED_Utilities.hxx"
- #if defined MEDWRAPPER_FACTORY_EXPORTS || defined MEDWrapper_EXPORTS
+#include "MED_Common.hxx"
-  #if defined WIN32
+
-   #define MEDWRAPPER_FACTORY_EXPORT __declspec( dllexport )
+#ifdef _DEBUG_
-  #else
+static int MYDEBUG = 0;
-   #define MEDWRAPPER_FACTORY_EXPORT
-  #endif
- #else
-  #if defined WIN32
-   #define MEDWRAPPER_FACTORY_EXPORT __declspec( dllimport )
-  #else
-   #define MEDWRAPPER_FACTORY_EXPORT
-  #endif
- #endif
 #else
- #define MEDWRAPPER_FACTORY_EXPORT
+static int MYDEBUG = 0;
 #endif
 
-#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--;
+    if(myCounter < 0)
+      EXCEPTION(std::runtime_error,"PrefixPrinter::~PrefixPrinter() - myCounter("<<myCounter<<") < 0");
+  }
+}
+
+std::string MED::PrefixPrinter::GetPrefix()
+{
+  if(myCounter){
+    if(myCounter < 0)
+      EXCEPTION(std::runtime_error,"PrefixPrinter::~PrefixPrinter() - myCounter("<<myCounter<<") < 0");
+    return std::string(myCounter*2,' ');
+  }
+  return "";
+}

src/MEDWrapper/MED_Utilities.hxx

@@ -19,18 +19,18 @@
 //
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
+
 #ifndef MED_Utilities_HeaderFile
 #define MED_Utilities_HeaderFile
 
-#include "MED_WrapperBase.hxx"
+#include "MED_WrapperDef.hxx"
 
-#include <iostream>     
+#include <iostream>
-#include <sstream>      
+#include <sstream>
 #include <string>
 #include <string.h>
 #include <stdexcept>
 
-
 namespace MED
 {
   class MEDWRAPPER_EXPORT PrefixPrinter
@@ -51,14 +51,13 @@ namespace MED
   #define INITMSGA(deb,lev,msg) MED::PrefixPrinter aPrefixPrinter_##lev(deb); BEGMSG(deb,msg)
   #define INITMSG(deb,msg) INITMSGA(deb,,msg)
   #define ADDMSG(deb,msg) if(deb) std::cout<<msg
-#else
+#else // _DEBUG_
   #define MSG(deb,msg)
   #define BEGMSG(deb,msg)
   #define INITMSGA(deb,lev,msg)
   #define INITMSG(deb,msg)
   #define ADDMSG(deb,msg)
-#endif
+#endif // _DEBUG_
-
 
 #ifndef EXCEPTION
 
@@ -68,6 +67,6 @@ namespace MED
   throw TYPE(aStream.str().c_str());\
 }
 
-#endif
+#endif // EXCEPTION
 
-#endif
+#endif // MED_Utilities_HeaderFile

src/MEDWrapper/MED_Vector.hxx

@@ -19,6 +19,7 @@
 //
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
+
 #ifndef MED_Vector_HeaderFile
 #define MED_Vector_HeaderFile
 
@@ -31,8 +32,7 @@
 
 namespace MED
 {
-
+  //! Main purpose to introduce the class was to customize operator []
-  //! Main purpose to introduce the class was to customize operator [] 
   template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
   class TVector : public std::vector<_Tp, _Alloc>
   {
@@ -68,15 +68,15 @@ namespace MED
 
   public:
     explicit
-    TVector(const allocator_type& __a = allocator_type()): 
+    TVector(const allocator_type& __a = allocator_type()):
-      superclass(__a) 
+      superclass(__a)
     {}
-    
+
     TVector(size_type __n, const value_type& __val,
             const allocator_type& __a = allocator_type()):
       superclass(__n, __val, __a)
     {}
-    
+
     explicit
     TVector(size_type __n):
       superclass(__n)
@@ -144,9 +144,8 @@ namespace MED
       return get_value(__n);
     }
   };
-
 }
 
 #undef MED_TVECTOR_CHECK_RANGE
 
-#endif
+#endif // MED_Vector_HeaderFile

src/MEDWrapper/MED_WrapperDef.hxx

@@ -19,28 +19,18 @@
 //
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
-//  File   : MED_WrapperBase.hxx
+
-//  Author : Alexander A. BORODIN
+#ifndef MED_WrapperDef_HeaderFile
-//
+#define MED_WrapperDef_HeaderFile
-#ifndef _MED_WrapperBase_HXX_
-#define _MED_WrapperBase_HXX_
 
 #ifdef WIN32
- #if defined MEDWRAPPER_BASE_EXPORTS || defined MEDWrapperBase_EXPORTS
+#  if defined(MEDWRAPPER_EXPORTS) || defined(MEDWrapper_EXPORTS)
-  #if defined WIN32
+#    define MEDWRAPPER_EXPORT __declspec( dllexport )
-   #define MEDWRAPPER_EXPORT __declspec( dllexport )
+#  else
-  #else
+#    define MEDWRAPPER_EXPORT __declspec( dllimport )
-   #define MEDWRAPPER_EXPORT
+#  endif // WIN32
-  #endif
- #else
-  #if defined WIN32
-   #define MEDWRAPPER_EXPORT __declspec( dllimport )
-  #else
-   #define MEDWRAPPER_EXPORT
-  #endif
- #endif
 #else
- #define MEDWRAPPER_EXPORT
+#  define MEDWRAPPER_EXPORT
 #endif
 
-#endif
+#endif // MED_WrapperDef_HeaderFile

src/MEDWrapper/V2_2/CMakeLists.txt

@@ -1,63 +0,0 @@
-# Copyright (C) 2012-2016  CEA/DEN, EDF R&D, OPEN CASCADE
-#
-# 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
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
-# --- options ---
-# additional include directories
-INCLUDE_DIRECTORIES(
-  ${MEDFILE_INCLUDE_DIRS}
-  ${HDF5_INCLUDE_DIRS}
-  ${Boost_INCLUDE_DIRS}
-  ${KERNEL_INCLUDE_DIRS}
-  ${CMAKE_CURRENT_SOURCE_DIR}/../Base
-)
-
-# additional preprocessor / compiler flags
-ADD_DEFINITIONS(
-  ${HDF5_DEFINITIONS}
-  ${BOOST_DEFINITIONS}
-)
-
-SET(_link_LIBRARIES
-  ${HDF5_LIBS}
-  ${MEDFILE_C_LIBRARIES}
-  ${Boost_LIBRARIES}
-  MEDWrapperBase
-)
-
-# --- headers ---
-
-# header files / no moc processing
-SET(MEDWrapper_V2_2_HEADERS
-  MED_V2_2_Wrapper.hxx
-)
-
-# --- sources ---
-
-# sources / static
-SET(MEDWrapper_V2_2_SOURCES
-  MED_V2_2_Wrapper.cxx
-)
-
-# --- rules ---
-
-ADD_LIBRARY(MEDWrapper_V2_2 ${MEDWrapper_V2_2_SOURCES})
-TARGET_LINK_LIBRARIES(MEDWrapper_V2_2 ${_link_LIBRARIES})
-INSTALL(TARGETS MEDWrapper_V2_2 EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
-
-INSTALL(FILES ${MEDWrapper_V2_2_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})

src/MEDWrapper/V2_2/MED_V2_2_Wrapper.hxx

@@ -1,489 +0,0 @@
-// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
-//
-// Copyright (C) 2003-2007  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, 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
-//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
-#ifndef MED_V2_2_Wrapper_HeaderFile
-#define MED_V2_2_Wrapper_HeaderFile
-
-#ifdef WIN32
- #if defined MEDWRAPPER_V2_2_EXPORTS || defined MEDWrapper_V2_2_EXPORTS
-  #if defined WIN32
-   #define MED_V22_WRAPPER_EXPORT __declspec( dllexport )
-  #else
-   #define MED_V22_WRAPPER_EXPORT
-  #endif
- #else
-  #if defined WIN32
-   #define MED_V22_WRAPPER_EXPORT __declspec( dllimport )
-  #else
-   #define MED_V22_WRAPPER_EXPORT
-  #endif
- #endif
-#else
- #define MED_V22_WRAPPER_EXPORT
-#endif
-
-#include "MED_Structures.hxx"
-#include "MED_TWrapper.hxx"
-
-namespace MED
-{
-  template<>
-  TInt MED_V22_WRAPPER_EXPORT
-  GetDESCLength<eV2_2>();
-  
-  template<>
-  TInt MED_V22_WRAPPER_EXPORT
-  GetIDENTLength<eV2_2>();
-  
-  template<>
-  TInt MED_V22_WRAPPER_EXPORT
-  GetNOMLength<eV2_2>();
-  
-  template<>
-  TInt MED_V22_WRAPPER_EXPORT
-  GetLNOMLength<eV2_2>();
-  
-  template<>
-  TInt MED_V22_WRAPPER_EXPORT
-  GetPNOMLength<eV2_2>();
-
-  template<>
-  void MED_V22_WRAPPER_EXPORT
-  GetVersionRelease<eV2_2>(TInt& majeur, TInt& mineur, TInt& release);
-
-  template<>
-  TInt MED_V22_WRAPPER_EXPORT
-  GetNbConn<eV2_2>(EGeometrieElement typmai,
-                   EEntiteMaillage typent,
-                   TInt mdim);
-
-  namespace V2_2
-  {
-    //----------------------------------------------------------------------------
-    class TFile;
-    typedef boost::shared_ptr<TFile> PFile;
-    
-    typedef enum {eLECTURE, eLECTURE_ECRITURE, eLECTURE_AJOUT, eCREATION} EModeAcces; 
-
-    //----------------------------------------------------------------------------
-    class MED_V22_WRAPPER_EXPORT TVWrapper: public MED::TTWrapper<eV2_2>
-    {
-      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
-      void
-      GetNames(TElemInfo& theInfo,
-               TInt nb,
-               EEntiteMaillage theEntity, 
-               EGeometrieElement theGeom,
-               TErr* theErr = NULL);
-
-      virtual
-      void
-      GetNumeration(TElemInfo& theInfo,
-                    TInt nb,
-                    EEntiteMaillage theEntity, 
-                    EGeometrieElement theGeom,
-                    TErr* theErr = NULL);
-
-      virtual
-      void
-      GetFamilies(TElemInfo& theInfo,
-                  TInt nb,
-                  EEntiteMaillage theEntity, 
-                  EGeometrieElement theGeom,
-                  TErr* theErr = NULL);
-
-      virtual
-      void
-      SetNames(const TElemInfo& theInfo,
-               EEntiteMaillage theEntity, 
-               EGeometrieElement theGeom,
-               TErr* theErr = NULL);
-
-      void
-      SetNames(const TElemInfo& theInfo,
-               EModeAcces theMode,
-               EEntiteMaillage theEntity, 
-               EGeometrieElement theGeom,
-               TErr* theErr = NULL);
-      
-      virtual
-      void
-      SetNumeration(const TElemInfo& theInfo,
-                    EEntiteMaillage theEntity, 
-                    EGeometrieElement theGeom,
-                    TErr* theErr = NULL);
-      void
-      SetNumeration(const TElemInfo& theInfo,
-                    EModeAcces theMode,
-                    EEntiteMaillage theEntity, 
-                    EGeometrieElement theGeom,
-                    TErr* theErr = NULL);
-      
-      virtual
-      void
-      SetFamilies(const TElemInfo& theInfo,
-                  EEntiteMaillage theEntity, 
-                  EGeometrieElement theGeom,
-                  TErr* theErr = NULL);
-      void
-      SetFamilies(const TElemInfo& theInfo,
-                  EModeAcces theMode,
-                  EEntiteMaillage theEntity, 
-                  EGeometrieElement theGeom,
-                  TErr* theErr = NULL);
-
-      //----------------------------------------------------------------------------
-      virtual
-      TInt
-      GetNbNodes(const MED::TMeshInfo& theMeshInfo,
-                 TErr* theErr = NULL)
-      {
-        return GetNbNodes(theMeshInfo,eCOOR,theErr);
-      }
-
-      TInt
-      GetNbNodes(const MED::TMeshInfo& theMeshInfo,
-                 ETable theTable,
-                 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
-      void
-      GetPolygoneInfo(TPolygoneInfo& theInfo,
-                      TErr* theErr = NULL);
-
-      virtual 
-      void
-      SetPolygoneInfo(const TPolygoneInfo& theInfo,
-                                   TErr* theErr = NULL);
-      
-      void
-      SetPolygoneInfo(const MED::TPolygoneInfo& theInfo,
-                      EModeAcces theMode,
-                      TErr* theErr = NULL);
-
-      virtual 
-      TInt
-      GetNbPolygones(const TMeshInfo& theMeshInfo,
-                   EEntiteMaillage theEntity,
-                   EGeometrieElement theGeom,
-                   EConnectivite theConnMode = eNOD,
-                   TErr* theErr = NULL);
-      
-      virtual 
-      TInt
-      GetPolygoneConnSize(const TMeshInfo& theMeshInfo,
-                        EEntiteMaillage theEntity,
-                        EGeometrieElement theGeom,
-                        EConnectivite theConnMode = eNOD,
-                        TErr* theErr = NULL);
-
-      //----------------------------------------------------------------------------
-      virtual 
-      void
-      GetPolyedreInfo(TPolyedreInfo& theInfo,
-                      TErr* theErr = NULL);
-      
-      virtual
-      void
-      SetPolyedreInfo(const TPolyedreInfo& theInfo,
-                      TErr* theErr = NULL);
-      
-      void
-      SetPolyedreInfo(const MED::TPolyedreInfo& theInfo,
-                      EModeAcces theMode,
-                      TErr* theErr = NULL);
-      
-      virtual
-      TInt
-      GetNbPolyedres(const TMeshInfo& theMeshInfo,
-                     EEntiteMaillage,
-                     EGeometrieElement,
-                     EConnectivite,
-                     TErr* theErr = NULL);
-      
-      virtual 
-      void
-      GetPolyedreConnSize(const TMeshInfo& theMeshInfo,
-                          TInt& theNbFaces,
-                          TInt& theConnSize,
-                          EConnectivite theConnMode = eNOD,
-                          TErr* theErr = NULL);
-      
-      //----------------------------------------------------------------------------
-      virtual
-      TEntityInfo
-      GetEntityInfo(const MED::TMeshInfo& theMeshInfo,
-                    EConnectivite theConnMode = eNOD,
-                    TErr* theErr = NULL);
-      
-      virtual 
-      TInt
-      GetNbCells(const MED::TMeshInfo& theMeshInfo, 
-                 EEntiteMaillage, 
-                 EGeometrieElement, 
-                 EConnectivite theConnMode = 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);
-      
-      //----------------------------------------------------------------------------
-      //! Read geom type of MED_BALL structural element
-      EGeometrieElement GetBallGeom(const TMeshInfo& theMeshInfo);
-      
-      //! Read number of balls in the Mesh
-      virtual TInt GetNbBalls(const TMeshInfo& theMeshInfo);
-
-      //! Read a MEDWrapped representation of MED_BALL from the MED file
-      virtual void GetBallInfo(TBallInfo& theInfo, TErr* theErr = NULL);
-
-      //! Write a MEDWrapped representation of MED_BALL to the MED file
-      virtual void  SetBallInfo(const TBallInfo& theInfo, TErr* theErr);
-
-      //! Write a MEDWrapped representation of MED_BALL to the MED file
-      void  SetBallInfo(const TBallInfo& theInfo, EModeAcces theMode, TErr* theErr);
-
-      //----------------------------------------------------------------------------
-      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
-      GetNbGauss(TErr* theErr = NULL);
-
-      virtual 
-      TGaussInfo::TInfo
-      GetGaussPreInfo(TInt theId, 
-                      TErr* theErr = NULL);
-
-      virtual 
-      void
-      GetGaussInfo(TInt theId, 
-                   TGaussInfo& theInfo,
-                   TErr* theErr = NULL);
-
-      //----------------------------------------------------------------------------
-      virtual 
-      TInt
-      GetNbProfiles(TErr* theErr = NULL);
-
-      virtual 
-      TProfileInfo::TInfo
-      GetProfilePreInfo(TInt theId, 
-                        TErr* theErr = NULL);
-      
-      virtual 
-      void
-      GetProfileInfo(TInt theId, 
-                     TProfileInfo& theInfo,
-                     TErr* theErr = NULL);
-
-      virtual
-      void
-      SetProfileInfo(const TProfileInfo& theInfo,
-                     TErr*               theErr = NULL);
-
-      void
-      SetProfileInfo(const TProfileInfo& theInfo,
-                     EModeAcces          theMode,
-                     TErr*               theErr = NULL);
-
-      //----------------------------------------------------------------------------
-      virtual 
-      TInt
-      GetNbTimeStamps(const MED::TFieldInfo& theInfo, 
-                      const MED::TEntityInfo& theEntityInfo,
-                      EEntiteMaillage& theEntity,
-                      TGeom2Size& theGeom2Size,
-                      TErr* theErr = NULL);
-      
-      virtual 
-      void
-      GetTimeStampInfo(TInt theTimeStampId, 
-                       MED::TTimeStampInfo& theInfo,
-                       TErr* theErr = NULL);
-      
-      virtual
-      void
-      GetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
-                        const TMKey2Profile& theMKey2Profile,
-                        const TKey2Gauss& theKey2Gauss,
-                        TErr* theErr = NULL);
-      
-      virtual
-      void
-      SetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
-                        TErr* theErr = NULL);
-      
-      void 
-      SetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
-                        EModeAcces theMode,
-                        TErr* theErr = NULL);
-      
-
-      //----------------------------------------------------------------------------
-      virtual
-      void
-      GetGrilleInfo(TGrilleInfo& theGrilleInfo,
-                    TErr* theErr = NULL);
-      
-      virtual
-      void
-      SetGrilleInfo(const MED::TGrilleInfo& theGrilleInfo,
-                    TErr* theErr = NULL);
-
-      void
-      SetGrilleInfo(const MED::TGrilleInfo& theGrilleInfo,
-                    EModeAcces theMode,
-                    TErr* theErr = NULL);
-
-      virtual
-      void
-      GetGrilleType(const MED::TMeshInfo& theMeshInfo,
-                    EGrilleType& type,
-                    TErr* theErr = NULL);
-
-      void
-      GetGrilleStruct(const MED::TMeshInfo& theMeshInfo,
-                      TIntVector& theStruct,
-                      TErr* theErr = NULL);
-
-    protected:
-      PFile myFile;
-    };
-  }
-}
-
-#endif

src/MEDWrapper/mprint_version.cxx

@@ -27,18 +27,22 @@
 
 int main (int argc, char **argv)
 {
-  med_idt aFid = MEDfileOpen(argv[1],MED_ACC_RDONLY);
+  if ( argc < 2 )
-  if(aFid < 0)
+    return -1;
-    exit(1);
 
-  med_int aMajor, aMinor, aRelease;
+  med_idt fid = MEDfileOpen(argv[1], MED_ACC_RDONLY);
-  med_err aRet = MEDfileNumVersionRd(aFid,&aMajor,&aMinor,&aRelease);
+  if (fid < 0)
-  MEDfileClose(aFid);
+    return 1;
-  if(aRet < 0) {
+
-    // VSR: simulate med 2.3.6 behavior, med file version is assumed to 2.1
+  med_int major, minor, release;
-    aMajor=2;
+  med_err aRet = MEDfileNumVersionRd(fid, &major, &minor, &release);
-    aMinor=aRelease=-1;
+  MEDfileClose(fid);
+  if (aRet < 0) {
+    // VSR: simulate med 2.3.6 behavior, med file version is assumed to be 2.1 or older
+    major = 2;
+    minor = release = -1;
   }
 
-  printf("%d.%d.%d\n",aMajor,aMinor,aRelease);
+  printf("%d.%d.%d\n", major, minor, release);
+  return 0;
 }

src/SMESH/CMakeLists.txt

@@ -27,7 +27,7 @@ INCLUDE_DIRECTORIES(
   ${Boost_INCLUDE_DIRS}
   ${HDF5_INCLUDE_DIRS}
   ${PROJECT_SOURCE_DIR}/src/Controls
-  ${PROJECT_SOURCE_DIR}/src/MEDWrapper/Base
+  ${PROJECT_SOURCE_DIR}/src/MEDWrapper
   ${PROJECT_SOURCE_DIR}/src/Driver
   ${PROJECT_SOURCE_DIR}/src/DriverDAT
   ${PROJECT_SOURCE_DIR}/src/DriverMED

src/SMESH/SMESH_Mesh.cxx

@@ -1376,7 +1376,6 @@ bool SMESH_Mesh::HasDuplicatedGroupNamesMED()
  *  \param [in] theAutoGroups - boolean parameter for creating/not creating
  *              the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
  *              the typical use is auto_groups=false.
- *  \param [in] theVersion - defines the version of format of MED file, that will be created
  *  \param [in] meshPart - mesh data to export
  *  \param [in] theAutoDimension - if \c true, a space dimension of a MED mesh can be either
      *         - 1D if all mesh nodes lie on OX coordinate axis, or
@@ -1392,7 +1391,6 @@ bool SMESH_Mesh::HasDuplicatedGroupNamesMED()
 void SMESH_Mesh::ExportMED(const char *        file, 
                            const char*         theMeshName, 
                            bool                theAutoGroups,
-                           int                 theVersion,
                            const SMESHDS_Mesh* meshPart,
                            bool                theAutoDimension,
                            bool                theAddODOnVertices,
@@ -1402,7 +1400,7 @@ void SMESH_Mesh::ExportMED(const char *        file,
   SMESH_TRY;
 
   DriverMED_W_SMESHDS_Mesh myWriter;
-  myWriter.SetFile         ( file, MED::EVersion(theVersion) );
+  myWriter.SetFile         ( file );
   myWriter.SetMesh         ( meshPart ? (SMESHDS_Mesh*) meshPart : _myMeshDS   );
   myWriter.SetAutoDimension( theAutoDimension );
   myWriter.AddODOnVertices ( theAddODOnVertices );
@@ -1478,7 +1476,7 @@ void SMESH_Mesh::ExportSAUV(const char *file,
   cmd += "from medutilities import my_remove ; my_remove(r'" + medfilename + "')";
   cmd += "\"";
   system(cmd.c_str());
-  ExportMED(medfilename.c_str(), theMeshName, theAutoGroups, /*theVersion=*/1,
+  ExportMED(medfilename.c_str(), theMeshName, theAutoGroups,
             /*meshPart=*/NULL, /*theAutoDimension=*/false, /*theAddODOnVertices=*/false,
             /*theAllElemsToGroup=*/true ); // theAllElemsToGroup is for PAL0023413
 #ifdef WIN32

src/SMESH/SMESH_Mesh.hxx

@@ -249,7 +249,6 @@ class SMESH_EXPORT SMESH_Mesh
   void ExportMED(const char *        theFile, 
                  const char*         theMeshName = NULL, 
                  bool                theAutoGroups = true, 
-                 int                 theVersion = 0,
                  const SMESHDS_Mesh* theMeshPart = 0,
                  bool                theAutoDimension = false,
                  bool                theAddODOnVertices = false,

src/SMESHClient/CMakeLists.txt

@@ -71,8 +71,6 @@ SET(_link_LIBRARIES
   SMESHDS
   SMESHControls
   MEDWrapper
-  MEDWrapperBase
-  MEDWrapper_V2_2
 )
 
 # --- headers ---

src/SMESHGUI/CMakeLists.txt

@@ -42,7 +42,7 @@ INCLUDE_DIRECTORIES(
   ${PROJECT_SOURCE_DIR}/src/SMESHUtils
   ${PROJECT_SOURCE_DIR}/src/Controls
   ${PROJECT_SOURCE_DIR}/src/SMESHClient
-  ${PROJECT_SOURCE_DIR}/src/MEDWrapper/Base
+  ${PROJECT_SOURCE_DIR}/src/MEDWrapper
   ${PROJECT_BINARY_DIR}
   ${PROJECT_BINARY_DIR}/idl
 )

src/SMESHGUI/SMESHGUI.cxx

@@ -238,8 +238,8 @@ namespace
     }
     else if ( theCommandID == SMESHOp::OpImportSAUV ||
               theCommandID == SMESHOp::OpPopupImportSAUV ) {
-      filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
+      filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
-      filter.append( QObject::tr( "All files (*)" ) );
+      filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
     }
     else if ( theCommandID == SMESHOp::OpImportGMF ||
               theCommandID == SMESHOp::OpPopupImportGMF ) {
@@ -650,8 +650,7 @@ namespace
 
     // Get parameters of export operation
 
-    QString            aFilename;
+    QString aFilename;
-    SMESH::MED_VERSION aFormat = SMESH::MED_V2_2;
     // Init the parameters with the default values
     bool aIsASCII_STL   = true;
     bool toCreateGroups = false;
@@ -728,27 +727,14 @@ namespace
     }
     else if ( isMED || isSAUV ) // Export to MED or SAUV
     {
-      QMap<QString, SMESH::MED_VERSION> aFilterMap;
+      QStringList filters;
-      //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
       if ( isMED ) {
-        QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
+        filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
-        //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
-        aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
       }
       else { // isSAUV
-        aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
+        filters << QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)";
-        aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
-        aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
       }
 
-      QStringList filters;
-      QString aDefaultFilter;
-      QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
-      for ( ; it != aFilterMap.end(); ++it ) {
-        filters.push_back( it.key() );
-        if (it.value() == SMESH::MED_V2_2)
-          aDefaultFilter = it.key();
-      }
       QStringList checkBoxes;
       checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
 
@@ -761,7 +747,6 @@ namespace
         new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
       fd->setWindowTitle( aTitle );
       fd->setNameFilters( filters );
-      fd->selectNameFilter( aDefaultFilter );
       fd->SetChecked( toCreateGroups, 0 );
       fd->SetChecked( toFindOutDim,   1 );
       if ( !anInitialPath.isEmpty() )
@@ -789,34 +774,13 @@ namespace
           aFilename = QString::null;
           break;
         }
-        aFormat = aFilterMap[fd->selectedNameFilter()];
         toOverwrite = fv->isOverwrite();
         is_ok = true;
         if ( !aFilename.isEmpty() ) {
-          // med-2.1 does not support poly elements
-          if ( aFormat==SMESH::MED_V2_1 )
-            for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
-              SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
-              SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
-              if ( nbElems[ SMESH::Entity_Polygon   ] + nbElems[ SMESH::Entity_Quad_Polygon   ] +
-                   nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
-              {
-                int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
-                                                    QObject::tr("SMESH_WRN_WARNING"),
-                                                    QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
-                                                    QObject::tr("SMESH_BUT_YES"),
-                                                    QObject::tr("SMESH_BUT_NO"), 0, 1);
-                if (aRet != 0) {
-                  is_ok = false;
-                  break;
-                }
-              }
-            }
           if( !toOverwrite ) {
             // can't append to an existing using other format
-            SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
+            bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckCompatibility( aFilename.toUtf8().constData() );
-            bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
+            if ( !isVersionOk ) {
-            if( !isVersionOk || aVersion != aFormat ) {
               int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
                                                   QObject::tr("SMESH_WRN_WARNING"),
                                                   QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
@@ -901,11 +865,11 @@ namespace
             const QString&            geoAssFields = aFieldList[ aMeshIndex ].second;
             const bool                   hasFields = ( fields.length() || !geoAssFields.isEmpty() );
             if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
-              aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
+              aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups,
-                                       aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
+                                    toOverwrite && aMeshIndex == 0, toFindOutDim );
             else
               aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
-                                          aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
+                                          toOverwrite && aMeshIndex == 0, toFindOutDim,
                                           fields, geoAssFields.toLatin1().data() );
           }
         }

src/SMESHGUI/SMESHGUI_FileInfoDlg.cxx

@@ -23,8 +23,6 @@
 //
 #include "SMESHGUI_FileInfoDlg.h"
 
-#include "MED_Common.hxx"
-
 #include <QGridLayout>
 #include <QLabel>
 #include <QLineEdit>

src/SMESHGUI/SMESH_msg_en.ts

@@ -11,6 +11,10 @@
         <source>MED_FILES_FILTER</source>
         <translation>MED files</translation>
     </message>
+    <message>
+        <source>SAUV_FILES_FILTER</source>
+        <translation>SAUV files</translation>
+    </message>
     <message>
         <source>IDEAS_FILES_FILTER</source>
         <translation>IDEAS files</translation>
@@ -23,10 +27,6 @@
         <source>TEXT_FILES_FILTER</source>
         <translation>TXT files</translation>
     </message>
-    <message>
-        <source>MED_VX_FILES_FILTER</source>
-        <translation>MED %1 files</translation>
-    </message>
     <message>
         <source>STL_FILES_FILTER</source>
         <translation>STL files</translation>
@@ -1764,13 +1764,6 @@ Do you want to continue?</translation>
         <source>SMESH_EXPORT_ONLY_GPOUP</source>
         <translation>You are going to export the group without its mesh.
 Do you want to continue?</translation>
-    </message>
-    <message>
-        <source>SMESH_EXPORT_MED_V2_1</source>
-        <translation>During export mesh with name - &quot;%1&quot; to MED 2.1
-polygons and polyhedrons elements will be missed
-For correct export use MED 2.2
-Are you sure want to export to MED 2.1?</translation>
     </message>
     <message>
         <source>SMESH_EXPORT_MED_VERSION_COLLISION</source>

src/SMESHGUI/SMESH_msg_fr.ts

@@ -11,6 +11,10 @@
         <source>MED_FILES_FILTER</source>
         <translation>Fichiers MED</translation>
     </message>
+    <message>
+        <source>SAUV_FILES_FILTER</source>
+        <translation>Fichiers SAUV</translation>
+    </message>
     <message>
         <source>IDEAS_FILES_FILTER</source>
         <translation>Fichiers IDEAS</translation>
@@ -23,10 +27,6 @@
         <source>TEXT_FILES_FILTER</source>
         <translation>Fichiers TXT</translation>
     </message>
-    <message>
-        <source>MED_VX_FILES_FILTER</source>
-        <translation>Fichiers MED %1</translation>
-    </message>
     <message>
         <source>STL_FILES_FILTER</source>
         <translation>Fichiers STL</translation>
@@ -1748,13 +1748,6 @@ Voulez-vous continuer ?</translation>
         <source>SMESH_EXPORT_ONLY_GPOUP</source>
         <translation>Vous allez export le groupe sans son maillage.
 Voulez-vous continuer ?</translation>
-    </message>
-    <message>
-        <source>SMESH_EXPORT_MED_V2_1</source>
-        <translation>Les éléments polygonaux et polyèdriques seront omis 
-dans le cas d&apos;exportation du maillage &quot;%1&quot; à MED 2.1
-Utilisez MED 2.2 pour l&apos;exportation correcte.
-Voulez-vous effectuer l&apos;exportation à MED 2.1 ?</translation>
     </message>
     <message>
         <source>SMESH_EXPORT_MED_VERSION_COLLISION</source>

src/SMESHGUI/SMESH_msg_ja.ts

@@ -11,6 +11,10 @@
       <source>MED_FILES_FILTER</source>
       <translation>MEDファイル</translation>
     </message>
+    <message>
+        <source>SAUV_FILES_FILTER</source>
+        <translation>SAUVファイル</translation>
+    </message>
     <message>
       <source>IDEAS_FILES_FILTER</source>
       <translation>IDEAS ファイル</translation>
@@ -23,10 +27,6 @@
       <source>TEXT_FILES_FILTER</source>
       <translation>TXT ファイル</translation>
     </message>
-    <message>
-      <source>MED_VX_FILES_FILTER</source>
-      <translation>ファイル MED %1</translation>
-    </message>
     <message>
       <source>STL_FILES_FILTER</source>
       <translation>STL ファイル</translation>
@@ -1731,10 +1731,6 @@
       <source>SMESH_EXPORT_ONLY_GPOUP</source>
       <translation>そのメッシュなしでグループのエクスポートをしようとしています。続行しますか？</translation>
     </message>
-    <message>
-      <source>SMESH_EXPORT_MED_V2_1</source>
-      <translation>多角形、多面体要素は正しいエクスポート用 MED 2.1 MED 2.2 にメッシュ '%' のエクスポートの場合省略されます。MED 2.1 をエクスポートしますか。</translation>
-    </message>
     <message>
       <source>SMESH_EXPORT_MED_VERSION_COLLISION</source>
       <translation>ファイル「%1」MED バージョンは知られていないか、選択したバージョンと一致しません。ファイルを上書きしますか。</translation>

src/SMESH_I/CMakeLists.txt

@@ -31,8 +31,7 @@ INCLUDE_DIRECTORIES(
   ${PROJECT_SOURCE_DIR}/src/Controls
   ${PROJECT_SOURCE_DIR}/src/SMDS
   ${PROJECT_SOURCE_DIR}/src/SMESHDS
-  ${PROJECT_SOURCE_DIR}/src/MEDWrapper/Base
+  ${PROJECT_SOURCE_DIR}/src/MEDWrapper
-  ${PROJECT_SOURCE_DIR}/src/MEDWrapper/Factory
   ${PROJECT_SOURCE_DIR}/src/Driver
   ${PROJECT_SOURCE_DIR}/src/DriverMED
   ${PROJECT_SOURCE_DIR}/src/DriverCGNS
@@ -116,7 +115,7 @@ SET(SMESHEngine_HEADERS
 SET(SMESHEngine_SOURCES
   SMESH_Gen_i.cxx
   SMESH_Gen_i_1.cxx
-  SMESH_DumpPython.cxx
+  SMESH_PythonDump.cxx
   SMESH_Mesh_i.cxx
   SMESH_subMesh_i.cxx
   SMESH_MeshEditor_i.cxx

src/SMESH_I/SMESH_2smeshpy.cxx

@@ -440,6 +440,18 @@ namespace {
       }
     }
   }
+
+  bool _FilterArg( const _AString& theArg  )
+  {
+    static std::list<_AString> filteredArgs;
+    static bool initialized = false;
+    if ( !initialized ) {
+      initialized = true;
+      filteredArgs.push_back( "SMESH.MED_V2_1" );
+      filteredArgs.push_back( "SMESH.MED_V2_2" );
+    }  
+    return std::find( filteredArgs.begin(), filteredArgs.end(), theArg ) != filteredArgs.end();
+  }
 }
 
 //================================================================================
@@ -1971,16 +1983,26 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
   // ----------------------------------------------------------------------
   else if ( theCommand->MethodStartsFrom( "Export" ))
   {
-    if ( method == "ExportToMED" ||  // ExportToMED()  --> ExportMED()
+    if ( method == "ExportToMED"  || // ExportToMED()  --> ExportMED()
-         method == "ExportToMEDX" )  // ExportToMEDX() --> ExportMED()
+         method == "ExportToMEDX" || // ExportToMEDX() --> ExportMED()
+         method == "ExportMED" )
     {
       theCommand->SetMethod( "ExportMED" );
-      if ( theCommand->GetNbArgs() == 5 )
+      // filter out deprecated version parameter
+      vector< _AString > args;
+      for ( int i = 1; i <= theCommand->GetNbArgs(); i++ ) {
+        if ( !_FilterArg( theCommand->GetArg( i ) ) )
+          args.push_back( theCommand->GetArg( i ) );
+      }
+      theCommand->RemoveArgs();
+      for ( uint i = 0; i < args.size(); i++ )
+        theCommand->SetArg( i+1, args[i] );
+      if ( theCommand->GetNbArgs() == 4 )
       {
         // ExportToMEDX(...,autoDimension) -> ExportToMEDX(...,meshPart=None,autoDimension)
-        _AString autoDimension = theCommand->GetArg( 5 );
+        _AString autoDimension = theCommand->GetArg( 4 );
-        theCommand->SetArg( 5, "None" );
+        theCommand->SetArg( 4, "None" );
-        theCommand->SetArg( 6, autoDimension );
+        theCommand->SetArg( 5, autoDimension );
       }
     }
     else if ( method == "ExportCGNS" )
@@ -2006,6 +2028,15 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
       TCollection_AsciiString newMethod = method;
       newMethod.Remove( /*where=*/7, /*howmany=*/6 );
       theCommand->SetMethod( newMethod );
+      // filter out deprecated version parameter
+      vector< _AString > args;
+      for ( int i = 1; i <= theCommand->GetNbArgs(); i++ ) {
+        if ( !_FilterArg( theCommand->GetArg( i ) ) )
+          args.push_back( theCommand->GetArg( i ) );
+      }
+      theCommand->RemoveArgs();
+      for ( uint i = 0; i < args.size(); i++ )
+        theCommand->SetArg( i+1, args[i] );
       // make the 1st arg be the last one (or last but three for ExportMED())
       _pyID partID = theCommand->GetArg( 1 );
       int nbArgs = theCommand->GetNbArgs() - 3 * (newMethod == "ExportMED");

src/SMESH_I/SMESH_Gen_i.cxx

@@ -131,6 +131,7 @@
 
 #include <map>
 #include <fstream>
+#include <sstream>
 #include <cstdio>
 #include <cstdlib>
 
@@ -2943,6 +2944,22 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
   return newMesh._retn();
 }
 
+//================================================================================
+/*!
+ * \brief Get version of MED format being used.
+ */
+//================================================================================
+
+char* SMESH_Gen_i::GetMEDFileVersion()
+{
+  MED::TInt majeur, mineur, release;
+  majeur =  mineur = release = 0;
+  MED::GetVersionRelease(majeur, mineur, release);
+  std::ostringstream version;
+  version << majeur << "." << mineur << "." << release;
+  return CORBA::string_dup( version.str().c_str() );
+}
+
 //================================================================================
 /*!
  *  SMESH_Gen_i::GetMEDVersion
@@ -2950,17 +2967,22 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
  *  Get MED version of the file by its name
  */
 //================================================================================
-CORBA::Boolean SMESH_Gen_i::GetMEDVersion(const char* theFileName,
+char* SMESH_Gen_i::GetMEDVersion(const char* theFileName)
-                                          SMESH::MED_VERSION& theVersion)
 {
-  theVersion = SMESH::MED_V2_1;
+  std::string version = MED::GetMEDVersion( theFileName );
-  MED::EVersion aVersion = MED::GetVersionId( theFileName );
+  return CORBA::string_dup( version.c_str() );
-  switch( aVersion ) {
+}
-    case MED::eV2_1     : theVersion = SMESH::MED_V2_1; return true;
+
-    case MED::eV2_2     : theVersion = SMESH::MED_V2_2; return true;
+//================================================================================
-    case MED::eVUnknown : return false;
+/*!
-  }
+ *  SMESH_Gen_i::CheckCompatibility
-  return false;
+ *
+ *  Check compatibility of file with MED format being used.
+ */
+//================================================================================
+CORBA::Boolean SMESH_Gen_i::CheckCompatibility(const char* theFileName)
+{
+  return MED::CheckCompatibility( theFileName );
 }
 
 //================================================================================
@@ -2973,7 +2995,7 @@ CORBA::Boolean SMESH_Gen_i::GetMEDVersion(const char* theFileName,
 SMESH::string_array* SMESH_Gen_i::GetMeshNames(const char* theFileName)
 {
   SMESH::string_array_var aResult = new SMESH::string_array();
-  MED::PWrapper aMed = MED::CrWrapper( theFileName );
+  MED::PWrapper aMed = MED::CrWrapperR( theFileName );
   MED::TErr anErr;
   MED::TInt aNbMeshes = aMed->GetNbMeshes( &anErr );
   if( anErr >= 0 ) {

src/SMESH_I/SMESH_Gen_i.hxx

@@ -383,9 +383,14 @@ public:
                                               CORBA::Double                 mergeTolerance)
     throw ( SALOME::SALOME_Exception );
 
+  // Get version of MED format being used.
+  char* GetMEDFileVersion();
+
   // Get MED version of the file by its name
-  CORBA::Boolean GetMEDVersion(const char* theFileName,
+  char* GetMEDVersion(const char* theFileName);
-                               SMESH::MED_VERSION& theVersion);
+
+  // Check compatibility of file with MED format being used.
+  CORBA::Boolean CheckCompatibility(const char* theFileName);
 
   // Get names of meshes defined in file with the specified name
   SMESH::string_array* GetMeshNames(const char* theFileName);

src/SMESH_I/SMESH_Mesh_i.cxx

@@ -402,8 +402,8 @@ SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName )
   CreateGroupServants();
 
   int major, minor, release;
-  if( !MED::getMEDVersion( theFileName, major, minor, release ) )
+  major = minor = release = 0;
-    major = minor = release = -1;
+  MED::GetMEDVersion(theFileName, major, minor, release);
   _medFileInfo           = new SMESH::MedFileInfo();
   _medFileInfo->fileName = theFileName;
   _medFileInfo->fileSize = 0;
@@ -443,19 +443,6 @@ SMESH::DriverMED_ReadStatus SMESH_Mesh_i::ImportCGNSFile( const char*  theFileNa
   return ConvertDriverMEDReadStatus(status);
 }
 
-//================================================================================
-/*!
- * \brief Return string representation of a MED file version comprising nbDigits
- */
-//================================================================================
-
-char* SMESH_Mesh_i::GetVersionString(SMESH::MED_VERSION version, CORBA::Short nbDigits)
-{
-  string ver = DriverMED_W_SMESHDS_Mesh::GetVersionString(MED::EVersion(version),
-                                                          nbDigits);
-  return CORBA::string_dup( ver.c_str() );
-}
-
 //=============================================================================
 /*!
  *  ImportUNVFile
@@ -2973,15 +2960,14 @@ string SMESH_Mesh_i::prepareMeshNameAndGroups(const char*    file,
 
 //================================================================================
 /*!
- * \brief Export to med file
+ * \brief Export to MED file
  */
 //================================================================================
 
-void SMESH_Mesh_i::ExportToMEDX (const char*        file,
+void SMESH_Mesh_i::ExportMED(const char*        file,
-                                 CORBA::Boolean     auto_groups,
+                             CORBA::Boolean     auto_groups,
-                                 SMESH::MED_VERSION theVersion,
+                             CORBA::Boolean     overwrite,
-                                 CORBA::Boolean     overwrite,
+                             CORBA::Boolean     autoDimension)
-                                 CORBA::Boolean     autoDimension)
   throw(SALOME::SALOME_Exception)
 {
   SMESH_TRY;
@@ -2989,43 +2975,16 @@ void SMESH_Mesh_i::ExportToMEDX (const char*        file,
     _preMeshInfo->FullLoadFromFile();
 
   string aMeshName = prepareMeshNameAndGroups(file, overwrite);
-  _impl->ExportMED( file, aMeshName.c_str(), auto_groups, theVersion, 0, autoDimension );
+  _impl->ExportMED( file, aMeshName.c_str(), auto_groups, 0, autoDimension );
 
-  TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportToMEDX( r'"
+  TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportMED( r'"
                 << file << "', " << auto_groups << ", "
-                << theVersion << ", " << overwrite << ", "
+                << overwrite << ", "
                 << autoDimension << " )";
 
   SMESH_CATCH( SMESH::throwCorbaException );
 }
 
-//================================================================================
-/*!
- * \brief Export a mesh to a med file
- */
-//================================================================================
-
-void SMESH_Mesh_i::ExportToMED (const char*        file,
-                                CORBA::Boolean     auto_groups,
-                                SMESH::MED_VERSION theVersion)
-  throw(SALOME::SALOME_Exception)
-{
-  ExportToMEDX(file,auto_groups,theVersion,true);
-}
-
-//================================================================================
-/*!
- * \brief Export a mesh to a med file
- */
-//================================================================================
-
-void SMESH_Mesh_i::ExportMED (const char* file,
-                              CORBA::Boolean auto_groups)
-  throw(SALOME::SALOME_Exception)
-{
-  ExportToMEDX(file,auto_groups,SMESH::MED_V2_2,true);
-}
-
 //================================================================================
 /*!
  * \brief Export a mesh to a SAUV file
@@ -3131,7 +3090,6 @@ void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii)
 void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
                                    const char*               file,
                                    CORBA::Boolean            auto_groups,
-                                   SMESH::MED_VERSION        version,
                                    CORBA::Boolean            overwrite,
                                    CORBA::Boolean            autoDimension,
                                    const GEOM::ListOfFields& fields,
@@ -3185,7 +3143,7 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
   {
     aMeshName = prepareMeshNameAndGroups(file, overwrite);
     _impl->ExportMED( file, aMeshName.c_str(), auto_groups,
-                      version, 0, autoDimension, /*addODOnVertices=*/have0dField);
+                      0, autoDimension, /*addODOnVertices=*/have0dField);
     meshDS = _impl->GetMeshDS();
   }
   else
@@ -3203,7 +3161,7 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
 
     SMESH_MeshPartDS* partDS = new SMESH_MeshPartDS( meshPart );
     _impl->ExportMED( file, aMeshName.c_str(), auto_groups,
-                      version, partDS, autoDimension, /*addODOnVertices=*/have0dField);
+                      partDS, autoDimension, /*addODOnVertices=*/have0dField);
     meshDS = tmpDSDeleter._obj = partDS;
   }
 
@@ -3229,7 +3187,7 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
   }
   TPythonDump() << _this() << ".ExportPartToMED( "
                 << meshPart << ", r'" << file << "', "
-                << auto_groups << ", " << version << ", " << overwrite << ", "
+                << auto_groups << ", " << overwrite << ", "
                 << autoDimension << ", " << goList
                 << ", '" << ( geomAssocFields ? geomAssocFields : "" ) << "'" << " )";
 

src/SMESH_I/SMESH_Mesh_i.hxx

@@ -225,21 +225,11 @@ public:
    *  Consider maximum group name length stored in MED file.
    */
   CORBA::Boolean HasDuplicatedGroupNamesMED();
-  /*!
-   * Return string representation of a MED file version comprising nbDigits
-   */
-  char* GetVersionString(SMESH::MED_VERSION version, CORBA::Short nbDigits);
 
-  void ExportToMEDX( const char*        file,
+  void ExportMED( const char*        file,
-                     CORBA::Boolean     auto_groups,
+                  CORBA::Boolean     auto_groups,
-                     SMESH::MED_VERSION version,
+                  CORBA::Boolean     overwrite,
-                     CORBA::Boolean     overwrite,
+                  CORBA::Boolean     autoDimension = true) throw (SALOME::SALOME_Exception);
-                     CORBA::Boolean     autoDimension=true) throw (SALOME::SALOME_Exception);
-  void ExportToMED ( const char*        file,
-                     CORBA::Boolean     auto_groups,
-                     SMESH::MED_VERSION version ) throw (SALOME::SALOME_Exception);
-  void ExportMED   ( const char*        file,
-                     CORBA::Boolean     auto_groups ) throw (SALOME::SALOME_Exception);
 
   void ExportSAUV( const char* file, CORBA::Boolean auto_groups ) throw (SALOME::SALOME_Exception);
 
@@ -256,7 +246,6 @@ public:
   void ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
                        const char*               file,
                        CORBA::Boolean            auto_groups,
-                       SMESH::MED_VERSION        version,
                        CORBA::Boolean            overwrite,
                        CORBA::Boolean            autoDim,
                        const GEOM::ListOfFields& fields,
@@ -316,7 +305,7 @@ public:
   CORBA::Long NbPolygons()
     throw (SALOME::SALOME_Exception);
 
-  CORBA::Long NbPolygonsOfOrder(SMESH::ElementOrder order=SMESH::ORDER_ANY)
+  CORBA::Long NbPolygonsOfOrder(SMESH::ElementOrder order = SMESH::ORDER_ANY)
     throw (SALOME::SALOME_Exception);
 
   CORBA::Long NbVolumes()

src/SMESH_I/SMESH_PreMeshInfo.cxx

@@ -460,10 +460,7 @@ bool SMESH_PreMeshInfo::readMeshInfo()
 {
   _isInfoOk = true;
 
-  MED::PWrapper aMed = MED::CrWrapper(_medFileName,true);
+  MED::PWrapper aMed = MED::CrWrapperR(_medFileName);
-  // if ( aMed->GetVersion() != MED::eV2_2 )
-  //   return false;
-
   MED::PMeshInfo medMeshInfo = aMed->CrMeshInfo(3,3,SMESH_Comment( _meshID ));
 
   // read nb nodes
@@ -516,7 +513,7 @@ void SMESH_PreMeshInfo::readGroupInfo()
 
   map< int, vector< SMESH_PreMeshInfo* > > famId2grInfo;
 
-  MED::PWrapper aMed = MED::CrWrapper(_medFileName,false);
+  MED::PWrapper aMed = MED::CrWrapperR(_medFileName);
   MED::PMeshInfo medMeshInfo = aMed->CrMeshInfo(3,3,SMESH_Comment( _meshID ));
 
   // read families to fill in famId2grInfo

src/SMESH_I/SMESH_PythonDump.cxx

@@ -468,7 +468,6 @@ namespace SMESH
     return *this;
   }
 
-
   TPythonDump& TPythonDump:: operator<<(SMESH_Gen_i* theArg)
   {
     myStream << SMESHGenName(); return *this;
@@ -484,17 +483,6 @@ namespace SMESH
     myStream << theStr; return *this;
   }
 
-
-  TPythonDump& TPythonDump::operator<<(SMESH::MED_VERSION theVersion)
-  {
-    switch (theVersion) {
-    case SMESH::MED_V2_1: myStream << "SMESH.MED_V2_1"; break;
-    case SMESH::MED_V2_2: myStream << "SMESH.MED_V2_2"; break;
-    default: myStream << theVersion;
-    }
-    return *this;
-  }
-
   TPythonDump& TPythonDump::operator<<(const SMESH::AxisStruct & theAxis)
   {
     *this << "SMESH.AxisStruct( "

src/SMESH_I/SMESH_PythonDump.hxx

@@ -200,9 +200,6 @@ namespace SMESH
     TPythonDump&
     operator<<(SMESH_MeshEditor_i* theArg);
 
-    TPythonDump&
-    operator<<(SMESH::MED_VERSION theArg);
-
     TPythonDump&
     operator<<(const SMESH::AxisStruct & theAxis);
 

src/SMESH_SWIG/smeshBuilder.py

@@ -84,6 +84,10 @@ import salome
 from salome.geom import geomBuilder
 
 import SMESH # This is necessary for back compatibility
+import omniORB                                   # back compatibility
+SMESH.MED_V2_1 = omniORB.EnumItem("MED_V2_1", 0) # back compatibility
+SMESH.MED_V2_2 = omniORB.EnumItem("MED_V2_2", 1) # back compatibility
+
 from   SMESH import *
 from   salome.smesh.smesh_algorithm import Mesh_Algorithm
 
@@ -1839,13 +1843,10 @@ class Mesh(metaclass=MeshMeta):
 
     ## Export the mesh in a file in MED format
     ## allowing to overwrite the file if it exists or add the exported data to its contents
-    #  @param f is the file name
+    #  @param fileName is the file name
     #  @param auto_groups boolean parameter for creating/not creating
     #  the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
     #  the typical use is auto_groups=False.
-    #  @param version MED format version (MED_V2_1 or MED_V2_2,
-    #                 the latter meaning any current version). The parameter is
-    #                 obsolete since MED_V2_1 is no longer supported.
     #  @param overwrite boolean parameter for overwriting/not overwriting the file
     #  @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh
     #  @param autoDimension if @c True (default), a space dimension of a MED mesh can be either
@@ -1861,17 +1862,33 @@ class Mesh(metaclass=MeshMeta):
     #         - 'f' stands for "_faces _" field;
     #         - 's' stands for "_solids _" field.
     #  @ingroup l2_impexp
-    def ExportMED(self, f, auto_groups=0, version=MED_V2_2,
+    def ExportMED(self, *args, **kwargs):
-                  overwrite=1, meshPart=None, autoDimension=True, fields=[], geomAssocFields=''):
+        # process positional arguments
+        args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
+        fileName        = args[0]
+        auto_groups     = args[1] if len(args) > 1 else False
+        overwrite       = args[2] if len(args) > 2 else True
+        meshPart        = args[3] if len(args) > 3 else None
+        autoDimension   = args[4] if len(args) > 4 else True
+        fields          = args[5] if len(args) > 5 else []
+        geomAssocFields = args[6] if len(args) > 6 else ''
+        # process keywords arguments
+        auto_groups     = kwargs.get("auto_groups", auto_groups)
+        overwrite       = kwargs.get("overwrite", overwrite)
+        meshPart        = kwargs.get("meshPart", meshPart)
+        autoDimension   = kwargs.get("autoDimension", autoDimension)
+        fields          = kwargs.get("fields", fields)
+        geomAssocFields = kwargs.get("geomAssocFields", geomAssocFields)
+        # invoke engine's function
         if meshPart or fields or geomAssocFields:
             unRegister = genObjUnRegister()
             if isinstance( meshPart, list ):
                 meshPart = self.GetIDSource( meshPart, SMESH.ALL )
                 unRegister.set( meshPart )
-            self.mesh.ExportPartToMED( meshPart, f, auto_groups, version, overwrite, autoDimension,
+            self.mesh.ExportPartToMED( meshPart, fileName, auto_groups, overwrite, autoDimension,
                                        fields, geomAssocFields)
         else:
-            self.mesh.ExportToMEDX(f, auto_groups, version, overwrite, autoDimension)
+            self.mesh.ExportMED(fileName, auto_groups, overwrite, autoDimension)
 
     ## Export the mesh in a file in SAUV format
     #  @param f is the file name
@@ -1961,10 +1978,7 @@ class Mesh(metaclass=MeshMeta):
     ## Deprecated, used only for compatibility! Please, use ExportMED() method instead.
     #  Export the mesh in a file in MED format
     #  allowing to overwrite the file if it exists or add the exported data to its contents
-    #  @param f the file name
+    #  @param fileName the file name
-    #  @param version MED format version (MED_V2_1 or MED_V2_2,
-    #                 the latter meaning any current version). The parameter is
-    #                 obsolete since MED_V2_1 is no longer supported.
     #  @param opt boolean parameter for creating/not creating
     #         the groups Group_On_All_Nodes, Group_On_All_Faces, ...
     #  @param overwrite boolean parameter for overwriting/not overwriting the file
@@ -1974,8 +1988,49 @@ class Mesh(metaclass=MeshMeta):
     #         - 3D in the rest cases.<br>
     #         If @a autoDimension is @c False, the space dimension is always 3.
     #  @ingroup l2_impexp
-    def ExportToMED(self, f, version=MED_V2_2, opt=0, overwrite=1, autoDimension=True):
+    def ExportToMED(self, *args, **kwargs):
-        self.mesh.ExportToMEDX(f, opt, version, overwrite, autoDimension)
+        print("WARNING: ExportToMED() is deprecated, use ExportMED() instead")
+        # process positional arguments
+        args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
+        fileName      = args[0]
+        auto_groups   = args[1] if len(args) > 1 else False
+        overwrite     = args[2] if len(args) > 2 else True
+        autoDimension = args[3] if len(args) > 3 else True
+        # process keywords arguments
+        auto_groups   = kwargs.get("opt", auto_groups)         # old keyword name
+        auto_groups   = kwargs.get("auto_groups", auto_groups) # new keyword name
+        overwrite     = kwargs.get("overwrite", overwrite)
+        autoDimension = kwargs.get("autoDimension", autoDimension)
+        # invoke engine's function
+        self.mesh.ExportMED(fileName, auto_groups, overwrite, autoDimension)
+
+    ## Deprecated, used only for compatibility! Please, use ExportMED() method instead.
+    #  Export the mesh in a file in MED format
+    #  allowing to overwrite the file if it exists or add the exported data to its contents
+    #  @param fileName the file name
+    #  @param opt boolean parameter for creating/not creating
+    #         the groups Group_On_All_Nodes, Group_On_All_Faces, ...
+    #  @param overwrite boolean parameter for overwriting/not overwriting the file
+    #  @param autoDimension if @c True (default), a space dimension of a MED mesh can be either
+    #         - 1D if all mesh nodes lie on OX coordinate axis, or
+    #         - 2D if all mesh nodes lie on XOY coordinate plane, or
+    #         - 3D in the rest cases.<br>
+    #         If @a autoDimension is @c False, the space dimension is always 3.
+    #  @ingroup l2_impexp
+    def ExportToMEDX(self, *args, **kwargs):
+        print("WARNING: ExportToMEDX() is deprecated, use ExportMED() instead")
+        # process positional arguments
+        args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
+        fileName      = args[0]
+        auto_groups   = args[1] if len(args) > 1 else False
+        overwrite     = args[2] if len(args) > 2 else True
+        autoDimension = args[3] if len(args) > 3 else True
+        # process keywords arguments
+        auto_groups   = kwargs.get("auto_groups", auto_groups)
+        overwrite     = kwargs.get("overwrite", overwrite)
+        autoDimension = kwargs.get("autoDimension", autoDimension)
+        # invoke engine's function
+        self.mesh.ExportMED(fileName, auto_groups, overwrite, autoDimension)
 
     # Operations with groups:
     # ----------------------
@@ -5121,7 +5176,25 @@ class meshProxy(SMESH._objref_SMESH_Mesh):
     def CreateDimGroup(self,*args): # 2 args added: nbCommonNodes, underlyingOnly
         if len( args ) == 3:
             args += SMESH.ALL_NODES, True
-        return SMESH._objref_SMESH_Mesh.CreateDimGroup( self, *args )
+        return SMESH._objref_SMESH_Mesh.CreateDimGroup(self, *args)
+    def ExportToMEDX(self, *args): # function removed
+        print("WARNING: ExportToMEDX() is deprecated, use ExportMED() instead")
+        args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
+        SMESH._objref_SMESH_Mesh.ExportMED(self, *args)
+    def ExportToMED(self, *args): # function removed
+        print("WARNING: ExportToMED() is deprecated, use ExportMED() instead")
+        args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
+        while len(args) < 4:  # !!!! nb of parameters for ExportToMED IDL's method
+            args.append(True)
+        SMESH._objref_SMESH_Mesh.ExportMED(self, *args)
+    def ExportPartToMED(self, *args): # 'version' parameter removed
+        args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
+        SMESH._objref_SMESH_Mesh.ExportPartToMED(self, *args)
+    def ExportMED(self, *args): # signature of method changed
+        args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
+        while len(args) < 4:  # !!!! nb of parameters for ExportToMED IDL's method
+            args.append(True)
+        SMESH._objref_SMESH_Mesh.ExportMED(self, *args)
     pass
 omniORB.registerObjref(SMESH._objref_SMESH_Mesh._NP_RepositoryId, meshProxy)
 

src/Tools/ZCracksPlug/casTests/genereCube.py

@@ -109,7 +109,7 @@ def cube3D(L, N, outFile):
     aFilter_1.SetMesh(Maillage_1.GetMesh())
     FACE_temp = Maillage_1.GroupOnFilter( SMESH.FACE, noms[cont], aFilter_1 )
  
-  Maillage_1.ExportMED( outFile, 0, SMESH.MED_V2_2, 1, None ,1)
+  Maillage_1.ExportMED(outFile)
 
   #if salome.sg.hasDesktop():
     #salome.sg.updateObjBrowser(True)
@@ -191,7 +191,7 @@ def cube2D(L, N, outFile):
     aFilter_1.SetMesh(Maillage_1.GetMesh())
     EDGE_temp = Maillage_1.GroupOnFilter( SMESH.EDGE, noms[cont], aFilter_1 )
  
-  Maillage_1.ExportMED( outFile, 0, SMESH.MED_V2_2, 1, None ,1)
+  Maillage_1.ExportMED(outFile)
 
   #if salome.sg.hasDesktop():
     #salome.sg.updateObjBrowser(True)

src/Tools/ZCracksPlug/ellipse.py

@@ -189,10 +189,10 @@ def generate(data_demi_grand_axe, data_centre, data_normale,
   Maillage=uF.meshCrack(FACE_FISSURE, minSize, maxSize, chordal, dim)
 
   try:
-    Maillage.ExportMED( outFile, 0, SMESH.MED_V2_2, 1, None ,1)
+    Maillage.ExportMED(outFile)
     smesh.SetName(Maillage.GetMesh(), 'MAILLAGE_FISSURE')
   except:
-    print('ExportToMEDX() failed. Invalid file name?')
+    print('ExportMED() failed. Invalid file name?')
 
 
   ## Set names of Mesh objects

src/Tools/ZCracksPlug/genereCrack.py

@@ -228,7 +228,7 @@ def generateCustom(crack, outFile):
   else:
     Group_1 = Maillage_1.CreateEmptyGroup( SMESH.NODE, 'crack' )
     nbAdd = Group_1.AddFrom( Maillage_1.GetMesh() )
-    Maillage_1.ExportMED( outFile, 0, SMESH.MED_V2_2, 1, None ,1)
+    Maillage_1.ExportMED(outFile)
   return(True)
 
 

src/Tools/ZCracksPlug/rectangle.py

@@ -216,10 +216,10 @@ def generate(data_longueur,data_largeur,data_centre,
   Maillage=uF.meshCrack(FACE_FISSURE, minSize, maxSize, chordal, dim)
 
   try:
-    Maillage.ExportMED( outFile, 0, SMESH.MED_V2_2, 1, None ,1)
+    Maillage.ExportMED(outFile)
     smesh.SetName(Maillage.GetMesh(), 'MAILLAGE_FISSURE')
   except:
-    print('ExportToMEDX() failed. Invalid file name?')
+    print('ExportMED() failed. Invalid file name?')
 
 
   if salome.sg.hasDesktop():

src/Tools/ZCracksPlug/sphere.py

@@ -57,10 +57,10 @@ def generate(data_rayon,data_centre,outFile):
   Maillage=uF.meshCrack(FACE_FISSURE, minSize, maxSize, chordal, dim=3)
 
   try:
-    Maillage.ExportMED( outFile, 0, SMESH.MED_V2_2, 1, None ,1)
+    Maillage.ExportMED(outFile)
     smesh.SetName(Maillage.GetMesh(), 'MAILLAGE_FISSURE')
   except:
-    print('ExportToMEDX() failed. Invalid file name?')
+    print('ExportMED() failed. Invalid file name?')
 
 
   ## Set names of Mesh objects

src/Tools/ZCracksPlug/utilityFunctions.py

@@ -233,7 +233,7 @@ def extendElsets(meshFile, outFile=None):
     if len(front)==0: crackOnly=False
 
   if crackOnly:
-    mesh.ExportMED(outFile, 0, SMESH.MED_V2_2, 1, None ,1)
+    mesh.ExportMED(outFile)
     return('crack')
 
   # Propagates color using elem connectivity
@@ -304,7 +304,7 @@ def extendElsets(meshFile, outFile=None):
       mesh.MakeGroupByIds('Extended_side%d' %n ,SMESH.EDGE,grElemList[2][n])
 
   if outFile==None: outFile=meshFile
-  mesh.ExportMED(outFile, 0, SMESH.MED_V2_2, 1, None ,1)
+  mesh.ExportMED(outFile)
   return(True)
 
 

src/Tools/blocFissure/exemple2.py

@@ -56,7 +56,7 @@ Quadrangle_2D = boite.Quadrangle(algo=smeshBuilder.QUADRANGLE)
 Hexa_3D = boite.Hexahedron(algo=smeshBuilder.Hexa)
 isDone = boite.Compute()
 smesh.SetName(boite, 'boite')
-boite.ExportMED( r'boite.med', 0, SMESH.MED_V2_2, 1 )
+boite.ExportMED(r'boite.med')
 
 ## set object names
 smesh.SetName(boite.GetMesh(), 'boite')

src/Tools/blocFissure/gmu/construitFissureGenerale.py

@@ -328,7 +328,7 @@ def construitFissureGenerale(maillagesSains,
   fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
 
   logging.info("export maillage fini")
-  maillageComplet.ExportMED( fichierMaillageFissure, 0, SMESH.MED_V2_2, 1 )
+  maillageComplet.ExportMED(fichierMaillageFissure)
   putName(maillageComplet, nomFicFissure)
   logging.info("fichier maillage fissure %s", fichierMaillageFissure)
 

src/Tools/blocFissure/gmu/creeZoneDefautDansObjetSain.py

@@ -57,7 +57,7 @@ def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure,
   [origShapes, verticesShapes, dmoyen] = \
     creeZoneDefautMaillage(maillagesSains, shapeDefaut, tailleDefaut, nomZones, coordsNoeudsFissure)
 
-  maillageSain.ExportMED( fichierMaillageSain, 0, SMESH.MED_V2_2, 1 )
+  maillageSain.ExportMED(fichierMaillageSain)
   logging.debug("fichier maillage sain %s", fichierMaillageSain)
   [maillageSain, internalBoundary, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges] = \
     peauInterne(fichierMaillageSain, shapeDefaut, nomZones)

src/Tools/blocFissure/gmu/insereFissureElliptique.py

@@ -189,7 +189,7 @@ def insereFissureElliptique(geometriesSaines, maillagesSains,
 
   if step == 18:
     return None
-  maillageComplet.ExportMED( fichierMaillageFissure, 0, SMESH.MED_V2_2, 1 )
+  maillageComplet.ExportMED(fichierMaillageFissure)
   putName(maillageComplet, nomFicFissure)
   logging.info("fichier maillage fissure : %s", fichierMaillageFissure)
 

src/Tools/blocFissure/gmu/insereFissureGenerale.py

@@ -1373,7 +1373,7 @@ def insereFissureGenerale(maillagesSains,
   fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
 
   logging.info("export maillage fini")
-  maillageComplet.ExportMED( fichierMaillageFissure, 0, SMESH.MED_V2_2, 1 )
+  maillageComplet.ExportMED(fichierMaillageFissure)
   putName(maillageComplet, nomFicFissure)
   logging.info("fichier maillage fissure %s", fichierMaillageFissure)
 

src/Tools/blocFissure/gmu/insereFissureLongue.py

@@ -649,7 +649,7 @@ def insereFissureLongue(geometriesSaines, maillagesSains,
   #isDone = maillageComplet.ReorientObject( grps[0] )
   fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
 
-  maillageComplet.ExportMED( fichierMaillageFissure, 0, SMESH.MED_V2_2, 1 )
+  maillageComplet.ExportMED(fichierMaillageFissure)
   putName(maillageComplet, nomFicFissure)
   logging.info("fichier maillage fissure %s", fichierMaillageFissure)
 

src/Tools/blocFissure/materielCasTests/cubeAngle.py

@@ -63,7 +63,7 @@ Quadrangle_2D = Mesh_1.Quadrangle(algo=smeshBuilder.QUADRANGLE)
 Hexa_3D = Mesh_1.Hexahedron(algo=smeshBuilder.Hexa)
 isDone = Mesh_1.Compute()
 smesh.SetName(Mesh_1, 'Mesh_1')
-Mesh_1.ExportMED(  os.path.join(gmu.pathBloc, "materielCasTests/CubeAngle.med"), 0, SMESH.MED_V2_2, 1 )
+Mesh_1.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests/CubeAngle.med"))
 
 ## set object names
 smesh.SetName(Mesh_1.GetMesh(), 'Mesh_1')

src/Tools/blocFissure/materielCasTests/cubeFin.py

@@ -122,7 +122,7 @@ smesh.SetName(ENCASTR_1, 'ENCASTR')
 smesh.SetName(cubeFin_1.GetMesh(), 'cubeFin')
 smesh.SetName(Nb_Segments_1, 'Nb. Segments_1')
 
-cubeFin_1.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests/cubeFin.med"), 0, SMESH.MED_V2_2, 1 )
+cubeFin_1.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests/cubeFin.med"))
 
 if salome.sg.hasDesktop():
   salome.sg.updateObjBrowser()

src/Tools/blocFissure/materielCasTests/decoupeCylindre.py

@@ -144,7 +144,7 @@ Nb_Segments_3 = Regular_1D_2.NumberOfSegments(6,[],[  ])
 Nb_Segments_3.SetDistrType( 0 )
 isDone = CylindreSain_1.Compute()
 smesh.SetName(CylindreSain_1, 'CylindreSain')
-CylindreSain_1.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests//CylindreSain.med"), 0, SMESH.MED_V2_2, 1 )
+CylindreSain_1.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests//CylindreSain.med"))
 SubMesh_1 = Regular_1D_1.GetSubMesh()
 SubMesh_2 = Regular_1D_2.GetSubMesh()
 

src/Tools/blocFissure/materielCasTests/disque_perce.py

@@ -70,7 +70,7 @@ status = Disque_1.AddHypothesis(Nb_Segments_2,Compound_4)
 Quadrangle_2D = Disque_1.Quadrangle(algo=smeshBuilder.QUADRANGLE)
 isDone = Disque_1.Compute()
 smesh.SetName(Disque_1, 'Disque')
-Disque_1.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests/disque.med"), 0, SMESH.MED_V2_2, 1 )
+Disque_1.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests/disque.med"))
 SubMesh_1 = Regular_1D_1.GetSubMesh()
 SubMesh_2 = Regular_1D_2.GetSubMesh()
 

src/Tools/blocFissure/materielCasTests/eprouvetteCourbe.py

@@ -87,7 +87,7 @@ Nb_Segments_3 = Regular_1D_2.NumberOfSegments(25)
 Nb_Segments_3.SetDistrType( 0 )
 isDone = EprouvetteCourbe_1.Compute()
 smesh.SetName(EprouvetteCourbe_1, 'EprouvetteCourbe')
-EprouvetteCourbe_1.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests/EprouvetteCourbe.med"), 0, SMESH.MED_V2_2, 1 )
+EprouvetteCourbe_1.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests/EprouvetteCourbe.med"))
 SubMesh_1 = Regular_1D_1.GetSubMesh()
 SubMesh_2 = Regular_1D_2.GetSubMesh()
 

src/Tools/blocFissure/materielCasTests/eprouvetteDroite.py

@@ -121,7 +121,7 @@ Nb_Segments_3 = Regular_1D_2.NumberOfSegments(10,[],[  ])
 Nb_Segments_3.SetDistrType( 0 )
 isDone = eprouvetteDroite_1.Compute()
 smesh.SetName(eprouvetteDroite_1, 'eprouvetteDroite')
-eprouvetteDroite_1.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests/eprouvetteDroite.med"), 0, SMESH.MED_V2_2, 1 )
+eprouvetteDroite_1.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests/eprouvetteDroite.med"))
 SubMesh_1 = Regular_1D_1.GetSubMesh()
 SubMesh_2 = Regular_1D_2.GetSubMesh()
 

src/Tools/blocFissure/materielCasTests/fissureGauche.py

@@ -116,7 +116,7 @@ Nb_Segments_3 = Regular_1D_2.NumberOfSegments(5,[],[  ])
 Nb_Segments_3.SetDistrType( 0 )
 isDone = objetSain_1.Compute()
 smesh.SetName(objetSain_1, 'objetSain')
-objetSain_1.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests/faceGaucheSain.med"), 0, SMESH.MED_V2_2, 1 )
+objetSain_1.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests/faceGaucheSain.med"))
 SubMesh_1 = Regular_1D_1.GetSubMesh()
 SubMesh_2 = Regular_1D_2.GetSubMesh()
 

src/Tools/blocFissure/materielCasTests/fissureGauche2.py

@@ -84,7 +84,7 @@ Quadrangle_2D = Mesh_1.Quadrangle(algo=smeshBuilder.QUADRANGLE)
 Hexa_3D = Mesh_1.Hexahedron(algo=smeshBuilder.Hexa)
 isDone = Mesh_1.Compute()
 smesh.SetName(Mesh_1, 'Mesh_1')
-Mesh_1.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests/boiteSaine.med"), 0, SMESH.MED_V2_2, 1 )
+Mesh_1.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests/boiteSaine.med"))
 
 ## set object names
 smesh.SetName(Mesh_1.GetMesh(), 'Mesh_1')

src/Tools/blocFissure/materielCasTests/vis.py

@@ -192,7 +192,7 @@ visHex80 = smesh.CopyMesh( coupe_vis_1, 'visHex80', 1, 0)
 [ tige_2, section_2, tige_haute_2, rond_2, tete_2, section_tete_2, conge_2, appui_2, p_imp_2, tige_rotated, tige_top, section_rotated, section_top, tige_haute_rotated, tige_haute_top, rond_rotated, rond_top, tete_rotated, tete_top, section_tete_rotated, section_tete_top, conge_rotated, conge_top, appui_rotated, appui_top, p_imp_rotated, p_imp_top ] = visHex80.GetGroups()
 Sub_mesh_1 = Regular_1D_1.GetSubMesh()
 Sub_mesh_2 = Regular_1D_2.GetSubMesh()
-visHex80.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests/visSain.med"), 0, SMESH.MED_V2_2, 1 )
+visHex80.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests/visSain.med"))
  
 
 ## Set names of Mesh objects

src/Tools/padder/spadderpy/gui/plugindialog.py

@@ -211,7 +211,7 @@ class PluginDialog(QDialog):
         name. This returns the filename.
         '''
         filename=str("/tmp/padder_inputfile_"+meshName+".med")
-        meshObject.ExportToMEDX( filename, 0, SMESH.MED_V2_2, 1, 1 )
+        meshObject.ExportMED(filename, False, True, True)
         return filename
 
     def clear(self):