Salome HOME
CoTech decision: move MEDWrapper from MED to SMESH
authoreap <eap@opencascade.com>
Mon, 24 Jun 2013 10:06:18 +0000 (10:06 +0000)
committereap <eap@opencascade.com>
Mon, 24 Jun 2013 10:06:18 +0000 (10:06 +0000)
+ MEDWrapper \

44 files changed:
src/DriverMED/DriverMED.hxx [new file with mode: 0644]
src/DriverMED/DriverMED_Family.h
src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx
src/DriverMED/DriverMED_R_SMESHDS_Mesh.h
src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
src/DriverMED/DriverMED_W_SMESHDS_Mesh.h
src/DriverMED/Makefile.am
src/MEDWrapper/Base/CMakeLists.txt [new file with mode: 0644]
src/MEDWrapper/Base/MED_Algorithm.cxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_Algorithm.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_Common.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_CoordUtils.cxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_CoordUtils.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_GaussDef.cxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_GaussDef.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_GaussUtils.cxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_GaussUtils.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_SharedPtr.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_SliceArray.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_Structures.cxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_Structures.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_TStructures.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_TWrapper.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_Utilities.cxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_Utilities.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_Vector.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_Wrapper.cxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_Wrapper.hxx [new file with mode: 0644]
src/MEDWrapper/Base/MED_WrapperBase.hxx [new file with mode: 0755]
src/MEDWrapper/Base/Makefile.am [new file with mode: 0644]
src/MEDWrapper/CMakeLists.txt [new file with mode: 0644]
src/MEDWrapper/Factory/CMakeLists.txt [new file with mode: 0644]
src/MEDWrapper/Factory/MED_Factory.cxx [new file with mode: 0644]
src/MEDWrapper/Factory/MED_Factory.hxx [new file with mode: 0644]
src/MEDWrapper/Factory/MED_Test.cxx [new file with mode: 0644]
src/MEDWrapper/Factory/MED_WrapperFactory.hxx [new file with mode: 0755]
src/MEDWrapper/Factory/Makefile.am [new file with mode: 0644]
src/MEDWrapper/Factory/mprint_version.cxx [new file with mode: 0644]
src/MEDWrapper/Makefile.am [new file with mode: 0644]
src/MEDWrapper/V2_2/CMakeLists.txt [new file with mode: 0644]
src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx [new file with mode: 0644]
src/MEDWrapper/V2_2/MED_V2_2_Wrapper.hxx [new file with mode: 0644]
src/MEDWrapper/V2_2/Makefile.am [new file with mode: 0644]
src/Makefile.am

diff --git a/src/DriverMED/DriverMED.hxx b/src/DriverMED/DriverMED.hxx
new file mode 100644 (file)
index 0000000..c2bee4b
--- /dev/null
@@ -0,0 +1,28 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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
+//
+
+// Declarations needed for usage of DriverMED
+
+#include <boost/shared_ptr.hpp>
+
+class DriverMED_Family;
+typedef boost::shared_ptr<DriverMED_Family> DriverMED_FamilyPtr;
index 1cd35e27194c7ee6b4c761872425b28234bd837e..c64c17f7c402e4ea82dba33fbe04b2ee8570f60c 100644 (file)
 //  File   : DriverMED_Family.hxx
 //  Author : Julia DOROVSKIKH
 //  Module : SMESH
-//  $Header$
 //
 #ifndef _INCLUDE_DRIVERMED_FAMILY
 #define _INCLUDE_DRIVERMED_FAMILY
 
 #include "SMESH_DriverMED.hxx"
+#include "DriverMED.hxx"
 
 #include "SMDS_Mesh.hxx"
 #include "SMESHDS_GroupBase.hxx"
@@ -49,8 +49,6 @@
 #define REST_BALL_FAMILY    -5
 #define FIRST_ELEM_FAMILY   -6
 
-class DriverMED_Family;
-typedef boost::shared_ptr<DriverMED_Family> DriverMED_FamilyPtr;
 typedef std::list<DriverMED_FamilyPtr     > DriverMED_FamilyPtrList;
 typedef std::map<int,SMESHDS_SubMesh*     > SMESHDS_SubMeshPtrMap;
 typedef std::list<SMESHDS_GroupBase*      > SMESHDS_GroupBasePtrList;
index cd6243d16065e9be9b8c600aa27cd1cd2b915030..b4ca1a08fb6a2458c4e475bb17b92d7f8efb0bad 100644 (file)
@@ -52,6 +52,26 @@ static int MYDEBUG = 0;
 using namespace MED;
 using namespace std;
 
+typedef std::map<int, DriverMED_FamilyPtr> TID2FamilyMap;
+
+namespace DriverMED
+{
+  bool buildMeshGrille(const MED::PWrapper&  theWrapper,
+                       const MED::PMeshInfo& theMeshInfo,
+                       SMESHDS_Mesh*         theMesh,
+                       const TID2FamilyMap&  myFamilies);
+  /*!
+   * \brief Ensure aFamily has a required ID
+    * \param aFamily - a family to check
+    * \param anID - an ID aFamily should have
+    * \param myFamilies - a map of the family ID to the Family
+    * \retval bool  - true if successful
+   */
+  bool checkFamilyID(DriverMED_FamilyPtr & aFamily,
+                     int                   anID,
+                     const TID2FamilyMap&  myFamilies);
+}
+
 void
 DriverMED_R_SMESHDS_Mesh
 ::SetMeshName(string theMeshName)
@@ -135,7 +155,7 @@ DriverMED_R_SMESHDS_Mesh
         }
 
         if (aMeshInfo->GetType() == MED::eSTRUCTURE){
-          /*bool aRes = */buildMeshGrille(aMed,aMeshInfo);
+          /*bool aRes = */DriverMED::buildMeshGrille(aMed,aMeshInfo,myMesh,myFamilies);
           continue;
         }
 
@@ -169,7 +189,7 @@ DriverMED_R_SMESHDS_Mesh
 
           // Save reference to this node from its family
           TInt aFamNum = aNodeInfo->GetFamNum(iElem);
-          if ( checkFamilyID ( aFamily, aFamNum ))
+          if ( DriverMED::checkFamilyID ( aFamily, aFamNum, myFamilies ))
           {
             aFamily->AddElement(aNode);
             aFamily->SetType(SMDSAbs_Node);
@@ -257,7 +277,7 @@ DriverMED_R_SMESHDS_Mesh
 
                 // Save reference to this element from its family
                 TInt aFamNum = aBallInfo->GetFamNum(iBall);
-                if ( checkFamilyID ( aFamily, aFamNum ))
+                if ( DriverMED::checkFamilyID ( aFamily, aFamNum, myFamilies ))
                 {
                   aFamily->AddElement(anElement);
                   aFamily->SetType( SMDSAbs_Ball );
@@ -329,7 +349,7 @@ DriverMED_R_SMESHDS_Mesh
                     if(aResult < DRS_WARN_RENUMBER)
                       aResult = DRS_WARN_RENUMBER;
                   }
-                  if ( checkFamilyID ( aFamily, aFamNum ))
+                  if ( DriverMED::checkFamilyID ( aFamily, aFamNum, myFamilies ))
                   {
                     // Save reference to this element from its family
                     aFamily->AddElement(anElement);
@@ -409,7 +429,7 @@ DriverMED_R_SMESHDS_Mesh
                     if (aResult < DRS_WARN_RENUMBER)
                       aResult = DRS_WARN_RENUMBER;
                   }
-                  if ( checkFamilyID ( aFamily, aFamNum )) {
+                  if ( DriverMED::checkFamilyID ( aFamily, aFamNum, myFamilies )) {
                     // Save reference to this element from its family
                     aFamily->AddElement(anElement);
                     aFamily->SetType(anElement->GetType());
@@ -920,7 +940,7 @@ DriverMED_R_SMESHDS_Mesh
                     if (aResult < DRS_WARN_RENUMBER)
                       aResult = DRS_WARN_RENUMBER;
                   }
-                  if ( checkFamilyID ( aFamily, aFamNum )) {
+                  if ( DriverMED::checkFamilyID ( aFamily, aFamNum, myFamilies )) {
                     // Save reference to this element from its family
                     myFamilies[aFamNum]->AddElement(anElement);
                     myFamilies[aFamNum]->SetType(anElement->GetType());
@@ -1127,7 +1147,9 @@ void DriverMED_R_SMESHDS_Mesh::CreateAllSubMeshes ()
  * \param anID - an ID aFamily should have
  * \retval bool  - true if successful
  */
-bool DriverMED_R_SMESHDS_Mesh::checkFamilyID(DriverMED_FamilyPtr & aFamily, int anID) const
+bool DriverMED::checkFamilyID(DriverMED_FamilyPtr & aFamily,
+                              int                   anID,
+                              const TID2FamilyMap&  myFamilies)
 {
   if ( !aFamily || aFamily->GetId() != anID ) {
     map<int, DriverMED_FamilyPtr>::const_iterator i_fam = myFamilies.find(anID);
@@ -1138,14 +1160,18 @@ bool DriverMED_R_SMESHDS_Mesh::checkFamilyID(DriverMED_FamilyPtr & aFamily, int
   return ( aFamily->GetId() == anID );
 }
 
-
-/*! \brief Reading the structured mesh and convert to non structured (by filling of smesh structure for non structured mesh)
+/*!
+ * \brief Reading the structured mesh and convert to non structured
+ *        (by filling of smesh structure for non structured mesh)
  * \param theWrapper  - PWrapper const pointer
  * \param theMeshInfo - PMeshInfo const pointer
+ * \param myFamilies  - a map of the family ID to the Family
  * \return TRUE, if successfully. Else FALSE
  */
-bool DriverMED_R_SMESHDS_Mesh::buildMeshGrille(const MED::PWrapper& theWrapper,
-                                               const MED::PMeshInfo& theMeshInfo)
+bool DriverMED::buildMeshGrille(const MED::PWrapper&  theWrapper,
+                                const MED::PMeshInfo& theMeshInfo,
+                                SMESHDS_Mesh*         myMesh,
+                                const TID2FamilyMap&  myFamilies)
 {
   bool res = true;
 
@@ -1167,7 +1193,7 @@ bool DriverMED_R_SMESHDS_Mesh::buildMeshGrille(const MED::PWrapper& theWrapper,
 
     if((aGrilleInfo->myFamNumNode).size() > 0){
       TInt aFamNum = aGrilleInfo->GetFamNumNode(iNode);
-      if ( checkFamilyID ( aFamily, aFamNum ))
+      if ( DriverMED::checkFamilyID ( aFamily, aFamNum, myFamilies ))
         {
           aFamily->AddElement(aNode);
           aFamily->SetType(SMDSAbs_Node);
@@ -1224,7 +1250,7 @@ bool DriverMED_R_SMESHDS_Mesh::buildMeshGrille(const MED::PWrapper& theWrapper,
     }
     if((aGrilleInfo->myFamNum).size() > 0){
       TInt aFamNum = aGrilleInfo->GetFamNum(iCell);
-      if ( checkFamilyID ( aFamily, aFamNum )){
+      if ( DriverMED::checkFamilyID ( aFamily, aFamNum, myFamilies )){
         aFamily->AddElement(anElement);
         aFamily->SetType(anElement->GetType());
       }
index 5e4459a3234467bed5d718d7630ad31feb0e9800..71d38ef78db0c4abb4e14acbf5f38db99f746941 100644 (file)
 
 #include "SMESH_DriverMED.hxx"
 
+#include "DriverMED.hxx"
 #include "Driver_SMESHDS_Mesh.h"
-#include "DriverMED_Family.h"
+#include "SMDSAbs_ElementType.hxx"
 
 #include <list>
+#include <map>
 
 class SMESHDS_Mesh;
 class SMESHDS_Group;
@@ -53,18 +55,6 @@ class MESHDRIVERMED_EXPORT DriverMED_R_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
   std::list<std::string> GetMeshNames(Status& theStatus);
   void SetMeshName(std::string theMeshName);
 
- private:
-  /*!
-   * \brief Ensure aFamily has required ID
-    * \param aFamily - a family to check
-    * \param anID - an ID aFamily should have
-    * \retval bool  - true if successful
-   */
-  bool checkFamilyID(DriverMED_FamilyPtr & aFamily, int anID) const;
-
-  bool buildMeshGrille(const MED::PWrapper& theWrapper,
-                       const MED::PMeshInfo& theMeshInfo);
-
  private:
   std::string myMeshName;
   std::map<int, DriverMED_FamilyPtr> myFamilies;
index 9289fb2364a8262a68f12f69973e455ee1974a9c..aa89eea404c9a50914a106380de14ce2ef040a54 100644 (file)
 //  File   : DriverMED_W_SMESHDS_Mesh.cxx
 //  Module : SMESH
 //
-#include <sstream>
 
 #include "DriverMED_W_SMESHDS_Mesh.h"
-#include "DriverMED_Family.h"
 
-#include "SMESHDS_Mesh.hxx"
+#include "DriverMED_Family.h"
+#include "MED_Factory.hxx"
+#include "MED_Utilities.hxx"
 #include "SMDS_MeshElement.hxx"
 #include "SMDS_MeshNode.hxx"
 #include "SMDS_PolyhedralVolumeOfNodes.hxx"
+#include "SMESHDS_Mesh.hxx"
 
-#include "utilities.h"
+#include <utilities.h>
 
-#include "MED_Utilities.hxx"
 
 #define _EDF_NODE_IDS_
 //#define _ELEMENTS_BY_DIM_
@@ -46,6 +46,7 @@ using namespace MED;
 
 
 DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
+  myMedVersion(MED::eV2_2),
   myAllSubMeshes (false),
   myDoGroupOfNodes (false),
   myDoGroupOfEdges (false),
@@ -57,15 +58,15 @@ DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
 {}
 
 void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName, 
-                                       MED::EVersion theId)
+                                       MED::EVersion      theId)
 {
-  myMed = CrWrapper(theFileName,theId);
   Driver_SMESHDS_Mesh::SetFile(theFileName);
+  myMedVersion = theId;
 }
 
 void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName)
 {
-  return SetFile(theFileName,MED::eV2_2);
+  Driver_SMESHDS_Mesh::SetFile(theFileName);
 }
 
 string DriverMED_W_SMESHDS_Mesh::GetVersionString(const MED::EVersion theVersion, int theNbDigits)
@@ -393,6 +394,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
     if ( myMesh->NbVolumes() > 0 )
       aMeshDimension = 3;
     
+    MED::PWrapper myMed = CrWrapper(myFile,myMedVersion);
     PMeshInfo aMeshInfo = myMed->CrMeshInfo(aMeshDimension,aSpaceDimension,aMeshName);
     MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
     myMed->SetMeshInfo(aMeshInfo);
index 95daf9fa6827aff7042fd515d3a23007a6a7a672..30d1f475fe006667a83d8fdf73621b1cd6648581 100644 (file)
@@ -30,7 +30,7 @@
 #include "SMESH_DriverMED.hxx"
 
 #include "Driver_SMESHDS_Mesh.h"
-#include "MED_Factory.hxx"
+#include "MED_Common.hxx"
 
 #include <string>
 #include <list>
@@ -72,7 +72,7 @@ class MESHDRIVERMED_EXPORT DriverMED_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
 
  private:
 
-  MED::PWrapper myMed;
+  MED::EVersion myMedVersion;
   std::list<SMESHDS_GroupBase*> myGroups;
   bool myAllSubMeshes;
   std::map<int,SMESHDS_SubMesh*> mySubMeshes;
@@ -85,6 +85,4 @@ class MESHDRIVERMED_EXPORT DriverMED_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
   bool myAutoDimension;
 };
 
-
 #endif
-
index 13ac7d4515efecd0971dcb8c1501b53ffaeb9eef..dc58802a1976835dce4f204d41a129d02e1c78ac 100644 (file)
@@ -26,6 +26,7 @@ include $(top_srcdir)/adm_local/unix/make_common_starter.am
 
 # header files 
 salomeinclude_HEADERS = \
+       DriverMED.hxx \
        DriverMED_R_SMESHDS_Mesh.h \
        DriverMED_W_SMESHDS_Mesh.h \
        DriverMED_Family.h \
@@ -47,12 +48,13 @@ dist_MED_Test_SOURCES = \
 
 # additionnal information to compil and link file
 libMeshDriverMED_la_CPPFLAGS = \
-       $(MED_CXXFLAGS) \
        @HDF5_INCLUDES@ \
        $(KERNEL_CXXFLAGS) \
        $(CAS_CPPFLAGS) \
         $(VTK_INCLUDES) \
        $(BOOST_CPPFLAGS) \
+       -I$(srcdir)/../MEDWrapper/Base \
+       -I$(srcdir)/../MEDWrapper/Factory \
        -I$(srcdir)/../Driver \
        -I$(srcdir)/../SMDS \
        -I$(srcdir)/../SMESHUtils \
@@ -61,7 +63,9 @@ libMeshDriverMED_la_CPPFLAGS = \
 libMeshDriverMED_la_LDFLAGS  = \
        $(BOOST_LIBS) \
        ../Driver/libMeshDriver.la \
-       $(MED_LDFLAGS) -lMEDWrapper -lMEDWrapperBase -lMEDWrapper_V2_2
+       ../MEDWrapper/Factory/libMEDWrapper.la \
+       ../MEDWrapper/Base/libMEDWrapperBase.la \
+       ../MEDWrapper/V2_2/libMEDWrapper_V2_2.la \
        $(BOOST_LIB_SYSTEM) 
 
 MED_Test_CPPFLAGS = \
@@ -77,8 +81,7 @@ MED_Test_LDADD = \
        -lOpUtil \
        -lSALOMELocalTrace \
        -lSALOMEBasics \
-       $(MED_LDFLAGS) \
-       -lMEDWrapper \
-       -lMEDWrapperBase \
-       -lMEDWrapper_V2_2
+       ../MEDWrapper/Factory/libMEDWrapper.la \
+       ../MEDWrapper/Base/libMEDWrapperBase.la \
+       ../MEDWrapper/V2_2/libMEDWrapper_V2_2.la \
        $(BOOST_LIB_SYSTEM) 
diff --git a/src/MEDWrapper/Base/CMakeLists.txt b/src/MEDWrapper/Base/CMakeLists.txt
new file mode 100644 (file)
index 0000000..2d7fe40
--- /dev/null
@@ -0,0 +1,47 @@
+# Copyright (C) 2012-2013  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# 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_DIRECTORIES(
+  ${HDF5_INCLUDE_DIRS}
+  ${BOOST_INCLUDE_DIRS}
+)
+
+IF(MED_ENABLE_KERNEL)
+  INCLUDE_DIRECTORIES(${KERNEL_ROOT_DIR}/include/salome)
+ELSE(MED_ENABLE_KERNEL)
+  INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR}/adm_local_without_kernel)
+ENDIF(MED_ENABLE_KERNEL)
+
+SET(MEDWrapperBase_SOURCES
+  MED_Structures.cxx
+  MED_Wrapper.cxx
+  MED_Algorithm.cxx
+  MED_GaussUtils.cxx
+  MED_CoordUtils.cxx
+  MED_Utilities.cxx
+  MED_GaussDef.cxx
+  )
+
+ADD_LIBRARY(MEDWrapperBase SHARED ${MEDWrapperBase_SOURCES})
+SET_TARGET_PROPERTIES(MEDWrapperBase PROPERTIES COMPILE_FLAGS "-D${MACHINE} ${HDF5_DEFINITIONS} ${BOOST_DEFINITIONS} ${PLATFORM_DEFINITIONS}")
+TARGET_LINK_LIBRARIES(MEDWrapperBase ${BOOST_LIB_THREAD} ${BOOST_LIB_DATE_TIME})
+INSTALL(TARGETS MEDWrapperBase DESTINATION ${MED_salomelib_LIBS})
+
+FILE(GLOB MEDWrapperBase_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
+INSTALL(FILES ${MEDWrapperBase_HEADERS_HXX} DESTINATION ${MED_salomeinclude_HEADERS})
diff --git a/src/MEDWrapper/Base/MED_Algorithm.cxx b/src/MEDWrapper/Base/MED_Algorithm.cxx
new file mode 100644 (file)
index 0000000..afe4ab7
--- /dev/null
@@ -0,0 +1,375 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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_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 MYVALUEDEBUG = 0;
+#endif
+
+namespace MED
+{
+  //---------------------------------------------------------------
+  TEntity2TGeom2ElemInfo 
+  GetEntity2TGeom2ElemInfo(const PWrapper& theWrapper, 
+                           const PMeshInfo& theMeshInfo,
+                           const MED::TEntityInfo& theEntityInfo)
+  {
+    MSG(MYDEBUG,"GetElemsByEntity(...)");
+    TEntity2TGeom2ElemInfo anEntity2TGeom2ElemInfo;
+    MED::TEntityInfo::const_iterator anIter = theEntityInfo.begin();
+    PElemInfo anElemInfo;
+    TErr anErr;
+    for(; anIter != theEntityInfo.end(); anIter++){
+      const EEntiteMaillage& anEntity = anIter->first;
+      const TGeom2Size& aGeom2Size = anIter->second;
+      TGeom2ElemInfo& aGeom2ElemInfo = anEntity2TGeom2ElemInfo[anEntity];
+
+      if(anEntity == eNOEUD){
+        aGeom2ElemInfo[ePOINT1] = theWrapper->GetPElemInfo(theMeshInfo);
+        continue;
+      }
+
+      TGeom2Size::const_iterator anIter2 = aGeom2Size.begin();
+      for(; anIter2 != aGeom2Size.end(); anIter2++){
+        const EGeometrieElement& aGeom = anIter2->first;
+        aGeom2ElemInfo[aGeom] = theWrapper->GetPElemInfo(theMeshInfo,anEntity,aGeom,MED::eNOD,&anErr);
+      }
+    }
+    ADDMSG(MYDEBUG,"\n");
+    return anEntity2TGeom2ElemInfo;
+  }
+  
+  
+  //---------------------------------------------------------------
+  TFamilyInfoSet
+  GetFamilyInfoSet(const PWrapper& theWrapper,
+                   const PMeshInfo& theMeshInfo)
+  {
+    MSG(MYDEBUG,"GetFamilies(...)");
+    TErr anErr;
+    TFamilyInfoSet aFamilyInfoSet;
+    TInt aNbFam = theWrapper->GetNbFamilies(*theMeshInfo);
+    INITMSG(MYDEBUG,"GetNbFamilies() = "<<aNbFam<<"\n");
+    for(TInt iFam = 1; iFam <= aNbFam; iFam++){
+      PFamilyInfo aFamilyInfo = theWrapper->GetPFamilyInfo(theMeshInfo,iFam,&anErr);
+      if(anErr >= 0)
+        aFamilyInfoSet.insert(aFamilyInfo);
+    }
+    ADDMSG(MYDEBUG,"\n");
+    return aFamilyInfoSet;
+  }
+
+
+  //---------------------------------------------------------------
+  TGroupInfo
+  GetGroupInfo(const TFamilyInfoSet& theFamilyInfoSet)
+  {
+    MSG(MYDEBUG,"GetFamiliesByGroup(...)");
+    TGroupInfo aGroup;
+    TFamilyInfoSet::const_iterator anIter = theFamilyInfoSet.begin();
+    for(; anIter != theFamilyInfoSet.end(); anIter++){
+      const PFamilyInfo& aFamilyInfo = *anIter;
+      TInt aNbGroup = aFamilyInfo->GetNbGroup();
+      for(TInt iGroup = 0; iGroup < aNbGroup; iGroup++){
+        aGroup[aFamilyInfo->GetGroupName(iGroup)].insert(aFamilyInfo);
+      } 
+    }
+
+#ifdef _DEBUG_
+    if(MYDEBUG){
+      TGroupInfo::const_iterator anIter = aGroup.begin();
+      for(; anIter != aGroup.end(); anIter++){
+        const std::string& aName = anIter->first;
+        INITMSG(MYDEBUG,"aGroupName = '"<<aName<<"'\n");
+        const TFamilyInfoSet& aFamilyInfoSet = anIter->second;
+        TFamilyInfoSet::const_iterator anFamIter = aFamilyInfoSet.begin();
+        for(; anFamIter != aFamilyInfoSet.end(); anFamIter++){
+          const PFamilyInfo& aFamilyInfo = *anFamIter;
+          INITMSG(MYDEBUG,"aFamilyName = '"<<aFamilyInfo->GetName()<<"'\n");
+        }
+      }
+      ADDMSG(MYDEBUG,"\n");
+    }
+#endif
+
+    return aGroup;
+  }
+
+
+  //---------------------------------------------------------------
+  TFieldInfo2TimeStampInfoSet 
+  GetFieldInfo2TimeStampInfoSet(const PWrapper& theWrapper, 
+                                const PMeshInfo& theMeshInfo,
+                                const MED::TEntityInfo& theEntityInfo)
+  {
+    MSG(MYDEBUG,"GetFieldsByEntity(...)");
+    TFieldInfo2TimeStampInfoSet aFieldInfo2TimeStampInfoSet;
+    TInt aNbFields = theWrapper->GetNbFields();
+    INITMSG(MYDEBUG,"GetNbFields() = "<<aNbFields<<"\n");
+    for(TInt iField = 1; iField <= aNbFields; iField++){
+      PFieldInfo aFieldInfo = theWrapper->GetPFieldInfo(theMeshInfo,iField);
+      INITMSG(MYDEBUG,"aFieldName = '"<<aFieldInfo->GetName()<<
+              "'; aNbComp = "<<aFieldInfo->GetNbComp()<<"; ");
+      TGeom2Size aGeom2Size;
+      EEntiteMaillage anEntity = EEntiteMaillage(-1);
+      TInt aNbTimeStamps = theWrapper->GetNbTimeStamps(aFieldInfo,theEntityInfo,anEntity,aGeom2Size);
+      ADDMSG(MYDEBUG,"anEntity = "<<anEntity<<"; GetNbTimeStamps = "<<aNbTimeStamps<<"\n");
+      for(TInt iTimeStamp = 1; iTimeStamp <= aNbTimeStamps; iTimeStamp++){
+        PTimeStampInfo aTimeStamp = 
+          theWrapper->GetPTimeStampInfo(aFieldInfo,anEntity,aGeom2Size,iTimeStamp);
+        aFieldInfo2TimeStampInfoSet[aFieldInfo].insert(aTimeStamp);
+        INITMSG(MYDEBUG,
+                "aDt = "<<aTimeStamp->GetDt()<<
+                ", Unit = \'"<<aTimeStamp->GetUnitDt()<<"\n");
+      }
+    }
+    ADDMSG(MYDEBUG,"\n");
+    return aFieldInfo2TimeStampInfoSet;
+  }
+  
+
+  //---------------------------------------------------------------
+  TEntite2TFieldInfo2TimeStampInfoSet 
+  GetEntite2TFieldInfo2TimeStampInfoSet(const TFieldInfo2TimeStampInfoSet& theFieldInfo2TimeStampInfoSet)
+  {
+    TEntite2TFieldInfo2TimeStampInfoSet anEntite2TFieldInfo2TimeStampInfoSet;
+    TFieldInfo2TimeStampInfoSet::const_iterator anIter = theFieldInfo2TimeStampInfoSet.begin();
+    for(; anIter != theFieldInfo2TimeStampInfoSet.end(); anIter++){
+      const TTimeStampInfoSet& aTimeStampInfoSet = anIter->second;
+      //const PFieldInfo& aFieldInfo = anIter->first;
+      if(aTimeStampInfoSet.empty()) 
+        continue;
+      const PTimeStampInfo& aTimeStampInfo = *aTimeStampInfoSet.begin();
+      anEntite2TFieldInfo2TimeStampInfoSet[ConvertEntity(aTimeStampInfo->GetEntity())].insert(*anIter);
+    }
+    return anEntite2TFieldInfo2TimeStampInfoSet;
+  }
+  
+
+  //---------------------------------------------------------------
+  bool
+  operator<(const TFamilyTSize& theLeft, const TFamilyTSize& theRight)
+  {
+    const MED::PFamilyInfo& aLeftInfo = boost::get<0>(theLeft);
+    const MED::PFamilyInfo& aRightInfo = boost::get<0>(theRight);
+    return aLeftInfo->GetId() < aRightInfo->GetId();
+  }
+
+
+  //---------------------------------------------------------------
+  TEntity2FamilySet 
+  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();
+    for(; anIter != theFamilyInfoSet.end(); anIter++){
+      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++){
+          const EEntiteMaillage& anEntity = anIter->first;
+          TFamilyID2Size& aFamilyID2Size = anEntity2FamilyID[anEntity];
+          const TGeom2ElemInfo& aGeom2ElemInfo = anIter->second;
+          TGeom2ElemInfo::const_iterator aGeom2ElemInfoIter = aGeom2ElemInfo.begin();
+          for(; aGeom2ElemInfoIter != aGeom2ElemInfo.end(); aGeom2ElemInfoIter++){
+            const PElemInfo& aElemInfo = aGeom2ElemInfoIter->second;
+            if(TInt aNbElem = aElemInfo->GetNbElem()){
+              for(TInt i = 0; i < aNbElem; i++){
+                aFamilyID2Size[aElemInfo->GetFamNum(i)] += 1;
+              }
+            }
+          }
+        }
+      }
+      
+      if(!anEntity2FamilyID.empty()){
+        TEntity2FamilyID::const_iterator anIter = anEntity2FamilyID.begin();
+        for(; anIter != anEntity2FamilyID.end(); anIter++){
+          const EEntiteMaillage& anEntity = anIter->first;
+          INITMSG(MYDEBUG,"anEntity = "<<anEntity<<":\n");
+          const TFamilyID2Size& aFamilyID2Size = anIter->second;
+          TFamilyID2Size::const_iterator anIter2 = aFamilyID2Size.begin();
+          for(; anIter2 != aFamilyID2Size.end(); anIter2++){
+            TInt anId = anIter2->first;
+            TInt aSize = anIter2->second;
+            TId2Family::const_iterator anIter3 = anId2Family.find(anId);
+            if(anIter3 != anId2Family.end()){
+              const PFamilyInfo& aFamilyInfo = anIter3->second;
+              anEntity2FamilySet[anEntity].insert(TFamilyTSize(aFamilyInfo,aSize));
+              INITMSG(MYDEBUG,
+                      "aFamilyName = '"<<aFamilyInfo->GetName()<<
+                      "' anId = "<<aFamilyInfo->GetId()<<"\n");
+            }
+          }
+        }
+      }
+    }    
+    ADDMSG(MYDEBUG,"\n");
+    return anEntity2FamilySet;
+  }
+  
+
+  //---------------------------------------------------------------
+  TKey2Gauss
+  GetKey2Gauss(const PWrapper& theWrapper, 
+               TErr* theErr,
+               EModeSwitch theMode)
+  {
+    INITMSG(MYDEBUG,"GetKey2Gauss - theMode = "<<theMode<<std::endl);
+    TKey2Gauss aKey2Gauss;
+    TInt aNbGauss = theWrapper->GetNbGauss(theErr);
+    for(TInt anId = 1; anId <= aNbGauss; anId++){
+      TGaussInfo::TInfo aPreInfo = theWrapper->GetGaussPreInfo(anId);
+      PGaussInfo anInfo = theWrapper->CrGaussInfo(aPreInfo,theMode);
+      theWrapper->GetGaussInfo(anId,anInfo,theErr);
+      TGaussInfo::TKey aKey = boost::get<0>(aPreInfo);
+      aKey2Gauss[aKey] = anInfo;
+
+#ifdef _DEBUG_
+      const EGeometrieElement& aGeom = boost::get<0>(aKey);
+      const std::string& aName = boost::get<1>(aKey);
+      INITMSG(MYDEBUG,
+              "- aGeom = "<<aGeom<<
+              "; aName = '"<<aName<<"'"<<
+              std::endl);
+#endif
+
+    }
+    return aKey2Gauss;
+  }
+
+
+  //---------------------------------------------------------------
+  PProfileInfo
+  GetProfileInfo(const PWrapper& theWrapper, 
+                 const std::string& theProfileName,
+                 TErr* theErr,
+                 EModeProfil theMode)
+  {
+    PProfileInfo anInfo;
+    TInt aNbProfiles = theWrapper->GetNbProfiles(theErr);
+    for(TInt anId = 1; anId <= aNbProfiles; anId++){
+      TProfileInfo::TInfo aPreInfo = theWrapper->GetProfilePreInfo(anId);
+      const std::string& aName = boost::get<0>(aPreInfo);
+      if(aName == theProfileName)
+        return theWrapper->GetPProfileInfo(anId,theMode,theErr);
+    }
+    return anInfo;
+  }
+  
+
+  //---------------------------------------------------------------
+  TMKey2Profile
+  GetMKey2Profile(const PWrapper& theWrapper, 
+                  TErr* theErr,
+                  EModeProfil theMode)
+  {
+    INITMSG(MYDEBUG,"GetMKey2Profile - theMode = "<<theMode<<std::endl);
+    TKey2Profile aKey2Profile;
+    TInt aNbProfiles = theWrapper->GetNbProfiles(theErr);
+    for(TInt anId = 1; anId <= aNbProfiles; anId++){
+      TProfileInfo::TInfo aPreInfo = theWrapper->GetProfilePreInfo(anId);
+      PProfileInfo anInfo = theWrapper->GetPProfileInfo(anId,theMode,theErr);
+      const std::string& aName = boost::get<0>(aPreInfo);
+      aKey2Profile[aName] = anInfo;
+      
+#ifdef _DEBUG_
+      INITMSG(MYDEBUG,
+              "- aName = '"<<aName<<"'"<<
+              " : "<<
+              std::endl);
+      TInt aNbElem = anInfo->GetSize();
+      for(TInt iElem = 0; iElem < aNbElem; iElem++){
+        ADDMSG(MYVALUEDEBUG,anInfo->GetElemNum(iElem)<<", ");
+      }
+      ADDMSG(MYVALUEDEBUG, std::endl);
+#endif
+      
+    }
+    return TMKey2Profile(theMode,aKey2Profile);
+  }
+
+  //---------------------------------------------------------------
+  EEntiteMaillage
+  GetEntityByFamilyId(PGrilleInfo& theInfo,TInt theId){
+    TElemNum::iterator aNodeFamIter = (theInfo->myFamNumNode).begin();
+    for(;aNodeFamIter != (theInfo->myFamNumNode).end(); aNodeFamIter++){
+      if(theId == *aNodeFamIter)
+        return eNOEUD;
+    }
+    TElemNum::iterator aCellFamIter = (theInfo->myFamNum).begin();
+    for(;aCellFamIter != (theInfo->myFamNum).end(); aCellFamIter++){
+      if(theId == *aCellFamIter)
+        return eMAILLE;
+    }
+    EXCEPTION(std::runtime_error, "GetEntityByFamilyId - fails");
+    return EEntiteMaillage(-1);
+  }
+
+  TFamilyID2NbCells
+  GetFamilyID2NbCells(PGrilleInfo& theInfo){
+    TFamilyID2NbCells aFamily2NbCells;
+    TInt aNbNodes = theInfo->myFamNumNode.size();
+    TInt aNbCells = theInfo->myFamNum.size();
+    for(TInt i=0; i<aNbNodes; i++) aFamily2NbCells[theInfo->GetFamNumNode(i)] = 0;
+    for(TInt i=0; i<aNbCells; i++) aFamily2NbCells[theInfo->GetFamNum(i)] = 0;
+    for(TInt i=0; i<aNbNodes; i++) aFamily2NbCells[theInfo->GetFamNumNode(i)] += 1;
+    for(TInt i=0; i<aNbCells; i++) aFamily2NbCells[theInfo->GetFamNum(i)] += 1;
+    return aFamily2NbCells;
+  }
+
+  EEntiteMaillage ConvertEntity(const EEntiteMaillage& aEntity){
+    switch( aEntity ){
+      
+    case eNOEUD_ELEMENT:
+    case eMAILLE: return eMAILLE; //eNOEUD_ELEMENT it is eMAILLE
+      
+    case eFACE:
+    case eARETE:
+    case eNOEUD: return aEntity; break;
+    default: return EEntiteMaillage(-1);
+      
+    }
+  }
+}
diff --git a/src/MEDWrapper/Base/MED_Algorithm.hxx b/src/MEDWrapper/Base/MED_Algorithm.hxx
new file mode 100644 (file)
index 0000000..ee7ac37
--- /dev/null
@@ -0,0 +1,157 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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_Algorithm_HeaderFile
+#define MED_Algorithm_HeaderFile
+
+#include "MED_WrapperBase.hxx"
+#include "MED_Structures.hxx"
+
+#include <set>
+
+namespace MED
+{
+  //---------------------------------------------------------------
+  typedef std::map<EGeometrieElement,PElemInfo> TGeom2ElemInfo;
+  typedef std::map<EEntiteMaillage,TGeom2ElemInfo> TEntity2TGeom2ElemInfo;
+
+  //! Get set of TElemInfo by its geometrical type and corresponding MED ENTITY
+  MEDWRAPPER_EXPORT
+  TEntity2TGeom2ElemInfo
+  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, 
+                   const PMeshInfo& theMeshInfo);
+  
+
+  //---------------------------------------------------------------
+  typedef boost::tuple<PFamilyInfo,TInt> TFamilyTSize;
+
+  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, 
+                      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, 
+                                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, 
+               TErr* theErr = NULL,
+               EModeSwitch theMode = eFULL_INTERLACE);
+
+
+  //---------------------------------------------------------------
+  //! Get MED PROFILE by its name
+  MEDWRAPPER_EXPORT
+  PProfileInfo
+  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, 
+                  TErr* theErr = NULL,
+                  EModeProfil theMode = eCOMPACT);
+
+  //---------------------------------------------------------------
+  //! Get Entity for Grille by family id.
+  MEDWRAPPER_EXPORT
+  EEntiteMaillage
+  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
diff --git a/src/MEDWrapper/Base/MED_Common.hxx b/src/MEDWrapper/Base/MED_Common.hxx
new file mode 100644 (file)
index 0000000..4715f6c
--- /dev/null
@@ -0,0 +1,186 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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_Common_HeaderFile
+#define MED_Common_HeaderFile
+
+#include "MED_WrapperBase.hxx"
+
+#include <string>
+#include <set>
+#include <map>
+
+#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{
+
+  enum EVersion {eVUnknown = -1, eV2_1, eV2_2};
+  
+  typedef enum {eFAUX, eVRAI} EBooleen ; 
+  typedef double TFloat;
+#if defined(HAVE_F77INT64)
+  typedef long TInt;
+#else
+  typedef int TInt;
+#endif 
+  typedef hid_t TIdt;
+  typedef herr_t TErr;
+
+  typedef enum {eFULL_INTERLACE, eNO_INTERLACE} EModeSwitch;
+
+  typedef enum {eFLOAT64=6, eINT=26} ETypeChamp;
+
+  typedef enum {eNON_STRUCTURE, eSTRUCTURE} EMaillage;
+
+  typedef enum {eCART, eCYL, eSPHER} ERepere; 
+
+  typedef enum {eNOD, eDESC} EConnectivite ; 
+
+  typedef enum {ePOINT1=1, eSEG2=102, eSEG3=103, eTRIA3=203,
+                eQUAD4=204, eTRIA6=206, eTRIA7=207, eQUAD8=208, eQUAD9=209,eTETRA4=304,
+                ePYRA5=305, ePENTA6=306, eHEXA8=308, eOCTA12=312, eTETRA10=310, 
+                ePYRA13=313, ePENTA15=315, eHEXA20=320, eHEXA27=327,
+                ePOLYGONE=400, ePOLYEDRE=500, eNONE=0, 
+                eBALL=1101 /*no such a type in med.h, it's just a trick*/,
+                eAllGeoType=-1 } EGeometrieElement;
+
+  typedef enum {eMAILLE, eFACE, eARETE, eNOEUD, eNOEUD_ELEMENT, eSTRUCT_ELEMENT} EEntiteMaillage; 
+
+  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<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;
+
+  struct TElemInfo;
+  typedef SharedPtr<TElemInfo> PElemInfo;
+
+  struct TNodeInfo;
+  typedef SharedPtr<TNodeInfo> PNodeInfo;
+
+  struct TPolygoneInfo;
+  typedef SharedPtr<TPolygoneInfo> PPolygoneInfo;
+
+  struct TPolyedreInfo;
+  typedef SharedPtr<TPolyedreInfo> PPolyedreInfo;
+
+  struct TCellInfo;
+  typedef SharedPtr<TCellInfo> PCellInfo;
+
+  struct TBallInfo;
+  typedef SharedPtr<TBallInfo> PBallInfo;
+
+  struct TFieldInfo;
+  typedef SharedPtr<TFieldInfo> PFieldInfo;
+
+  struct TTimeStampInfo;
+  typedef SharedPtr<TTimeStampInfo> PTimeStampInfo;
+
+  struct TProfileInfo;
+  typedef SharedPtr<TProfileInfo> PProfileInfo;
+  
+  struct TGaussInfo;
+  typedef SharedPtr<TGaussInfo> PGaussInfo;
+  
+  class TGrilleInfo;
+  typedef SharedPtr<TGrilleInfo> PGrilleInfo;
+
+  struct TTimeStampValueBase;
+  typedef SharedPtr<TTimeStampValueBase> PTimeStampValueBase;
+
+  struct TWrapper;
+  typedef SharedPtr<TWrapper> PWrapper;
+}
+
+
+#endif
diff --git a/src/MEDWrapper/Base/MED_CoordUtils.cxx b/src/MEDWrapper/Base/MED_CoordUtils.cxx
new file mode 100644 (file)
index 0000000..21f9162
--- /dev/null
@@ -0,0 +1,160 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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_CoordUtils.hxx"
+#include "MED_Utilities.hxx"
+namespace MED
+{
+
+  enum ECoordName{eX, eY, eZ, eNone};
+
+  template<ECoordName TCoordId>
+  TFloat 
+  GetCoord(const TCCoordSlice& theCoordSlice)
+  {
+    return theCoordSlice[TCoordId];
+  }
+
+  template<>
+  TFloat 
+  GetCoord<eNone>(const TCCoordSlice& theCoordSlice)
+  {
+    return 0.0;
+  }
+  
+  TGetCoord
+  aXYZGetCoord[3] = {
+    &GetCoord<eX>, 
+    &GetCoord<eY>, 
+    &GetCoord<eZ>
+  };
+  
+  TGetCoord
+  aXYGetCoord[3] = {
+    &GetCoord<eX>, 
+    &GetCoord<eY>, 
+    &GetCoord<eNone>
+  };
+  
+  TGetCoord
+  aYZGetCoord[3] = {
+    &GetCoord<eNone>,
+    &GetCoord<eX>, 
+    &GetCoord<eY>
+  };
+  
+  TGetCoord 
+  aXZGetCoord[3] = {
+    &GetCoord<eX>, 
+    &GetCoord<eNone>,
+    &GetCoord<eY>
+  };
+  
+  
+  TGetCoord 
+  aXGetCoord[3] = {
+    &GetCoord<eX>, 
+    &GetCoord<eNone>,
+    &GetCoord<eNone>
+  };
+  
+  TGetCoord
+  aYGetCoord[3] = {
+    &GetCoord<eNone>,
+    &GetCoord<eX>, 
+    &GetCoord<eNone>
+  };
+
+  TGetCoord
+  aZGetCoord[3] = {
+    &GetCoord<eNone>,
+    &GetCoord<eNone>,
+    &GetCoord<eX>
+  };
+
+  
+  //---------------------------------------------------------------
+  TCoordHelper
+  ::TCoordHelper(TGetCoord* theGetCoord):
+    myGetCoord(theGetCoord)
+  {}
+
+  TFloat 
+  TCoordHelper
+  ::GetCoord(TCCoordSlice& theCoordSlice, 
+             TInt theCoordId)
+  {
+    return (*myGetCoord[theCoordId])(theCoordSlice);
+  }
+
+
+  //---------------------------------------------------------------
+  PCoordHelper
+  GetCoordHelper(PNodeInfo theNodeInfo)
+  {
+    PCoordHelper aCoordHelper;
+    {
+      PMeshInfo aMeshInfo = theNodeInfo->GetMeshInfo();
+      TInt aMeshDimension = aMeshInfo->GetDim();
+      bool anIsDimPresent[3] = {false, false, false};
+      for(int iDim = 0; iDim < aMeshDimension; iDim++){
+        // PAL16857(SMESH not conform to the MED convention) ->
+        // 1D - always along X
+        // 2D - always in XOY plane
+        anIsDimPresent[iDim] = iDim < aMeshDimension;
+//      std::string aName = theNodeInfo->GetCoordName(iDim);
+//         if ( aName.size() > 1 ) // PAL12148, aName has size 8 or 16
+//           aName = aName.substr(0,1);
+//      if(aName == "x" || aName == "X")
+//        anIsDimPresent[eX] = true;
+//      else if(aName == "y" || aName == "Y")
+//        anIsDimPresent[eY] = true;
+//      else if(aName == "z" || aName == "Z")
+//        anIsDimPresent[eZ] = true;
+      }
+
+      switch(aMeshDimension){
+      case 3:
+        aCoordHelper.reset(new TCoordHelper(aXYZGetCoord));
+        break;
+      case 2:
+        if(anIsDimPresent[eY] && anIsDimPresent[eZ])
+          aCoordHelper.reset(new TCoordHelper(aYZGetCoord));
+        else if(anIsDimPresent[eX] && anIsDimPresent[eZ])
+          aCoordHelper.reset(new TCoordHelper(aXZGetCoord));
+        else
+          aCoordHelper.reset(new TCoordHelper(aXYGetCoord));
+        break;
+      case 1:
+        if(anIsDimPresent[eY])
+          aCoordHelper.reset(new TCoordHelper(aYGetCoord));
+        else if(anIsDimPresent[eZ])
+          aCoordHelper.reset(new TCoordHelper(aZGetCoord));
+        else
+          aCoordHelper.reset(new TCoordHelper(aXGetCoord));
+        break;
+      }
+    }
+    return aCoordHelper;
+  }
+}
diff --git a/src/MEDWrapper/Base/MED_CoordUtils.hxx b/src/MEDWrapper/Base/MED_CoordUtils.hxx
new file mode 100644 (file)
index 0000000..17b09d7
--- /dev/null
@@ -0,0 +1,57 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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_CoordUtils_HeaderFile
+#define MED_CoordUtils_HeaderFile
+
+#include "MED_WrapperBase.hxx"
+
+#include "MED_Structures.hxx"
+
+namespace MED
+{
+  typedef TFloat (*TGetCoord)(const TCCoordSlice& theCoordSlice);
+
+
+  //---------------------------------------------------------------
+  class MEDWRAPPER_EXPORT TCoordHelper
+  {
+    TGetCoord* myGetCoord;
+    
+  public:
+    TCoordHelper(TGetCoord* theGetCoord);
+
+    TFloat 
+    GetCoord(TCCoordSlice& theCoordSlice, 
+             TInt theCoordId);
+  };
+  typedef SharedPtr<TCoordHelper> PCoordHelper;
+
+
+  //---------------------------------------------------------------
+  MEDWRAPPER_EXPORT 
+  PCoordHelper
+  GetCoordHelper(PNodeInfo theNodeInfo);
+
+}
+
+#endif
diff --git a/src/MEDWrapper/Base/MED_GaussDef.cxx b/src/MEDWrapper/Base/MED_GaussDef.cxx
new file mode 100644 (file)
index 0000000..f89042e
--- /dev/null
@@ -0,0 +1,570 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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_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");
+    if ( myWeights.capacity() == myWeights.size() )
+      EXCEPTION( 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");
+    if ( myWeights.capacity() == myWeights.size() )
+      EXCEPTION( logic_error,"Extra gauss point");
+    myCoords.push_back( x );
+    myCoords.push_back( y );
+    myWeights.push_back( weight );
+  }
+  void TGaussDef::add(const double x, const double y, const double z, const double weight)
+  {
+    if ( dim() != 3 )
+      EXCEPTION( logic_error,"dim() != 3");
+    if ( myWeights.capacity() == myWeights.size() )
+      EXCEPTION( logic_error,"Extra gauss point");
+    myCoords.push_back( x );
+    myCoords.push_back( y );
+    myCoords.push_back( z );
+    myWeights.push_back( weight );
+  }
+  void TGaussDef::setRefCoords(const TShapeFun& aShapeFun)
+  {
+    myRefCoords.reserve( aShapeFun.myRefCoord.size() );
+    myRefCoords.assign( aShapeFun.myRefCoord.begin(),
+                        aShapeFun.myRefCoord.end() );
+  }
+
+
+  //---------------------------------------------------------------
+  /*!
+   * \brief Fill definition of gauss points family
+   */
+  //---------------------------------------------------------------
+
+  TGaussDef::TGaussDef(const int geom, const int nbGauss, const int variant)
+  {
+    myType = geom;
+    myCoords .reserve( nbGauss * dim() );
+    myWeights.reserve( nbGauss );
+
+    switch ( geom ) {
+
+    case eSEG2:
+    case eSEG3:
+      if (geom == eSEG2) setRefCoords( TSeg2a() );
+      else               setRefCoords( TSeg3a() );
+      switch ( nbGauss ) {
+      case 1: {
+        add( 0.0, 2.0 ); break;
+      }
+      case 2: {
+        const double a = 0.577350269189626;
+        add(  a,  1.0 );
+        add( -a,  1.0 ); break;
+      }
+      case 3: {
+        const double a = 0.774596669241;
+        const double P1 = 1./1.8;
+        const double P2 = 1./1.125;
+        add( -a,  P1 );
+        add(  0,  P2 ); 
+        add(  a,  P1 ); break;
+      }
+      case 4: {
+        const double a  = 0.339981043584856, b  = 0.861136311594053;
+        const double P1 = 0.652145154862546, P2 = 0.347854845137454 ;
+        add(  a,  P1 );
+        add( -a,  P1 );
+        add(  b,  P2 ); 
+        add( -b,  P2 ); break;
+      }
+      default:
+        EXCEPTION( logic_error,"Invalid nb of gauss points for SEG"<<nbGauss);
+      }
+      break;
+
+    case eTRIA3:
+    case eTRIA6:
+      if ( variant == 1 ) {
+        if (geom == eTRIA3) setRefCoords( TTria3b() );
+        else                setRefCoords( TTria6b() );
+        switch ( nbGauss ) {
+        case 1: { // FPG1
+          add( 1/3., 1/3., 1/2. ); break;
+        }
+        case 3: { // FPG3
+          // what about COT3 ???
+          add( 1/6., 1/6., 1/6. );
+          add( 2/3., 1/6., 1/6. );
+          add( 1/6., 2/3., 1/6. ); break;
+        }
+        case 4: { // FPG4
+          add( 1/5., 1/5.,  25/(24*4.) );
+          add( 3/5., 1/5.,  25/(24*4.) );
+          add( 1/5., 3/5.,  25/(24*4.) );
+          add( 1/3., 1/3., -27/(24*4.) ); break;
+        }
+        case 6: { // FPG6
+          const double P1 = 0.11169079483905, P2 = 0.0549758718227661;
+          const double a  = 0.445948490915965, b = 0.091576213509771;
+          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( 1-2*a,     a, P1 ); break;
+        }
+        case 7: { // FPG7
+          const double A  = 0.470142064105115;
+          const double B  = 0.101286507323456;
+          const double P1 = 0.066197076394253;
+          const double P2 = 0.062969590272413;
+          add(  1/3.,  1/3., 9/80. ); 
+          add(     A,     A, P1 ); 
+          add( 1-2*A,     A, P1 );
+          add(     A, 1-2*A, P1 );
+          add(     B,     B, P2 ); 
+          add( 1-2*B,     B, P2 );
+          add(     B, 1-2*B, P2 ); break;
+        }
+        case 12: { // FPG12
+          const double A  = 0.063089014491502;
+          const double B  = 0.249286745170910;
+          const double C  = 0.310352451033785;
+          const double D  = 0.053145049844816;
+          const double P1 = 0.025422453185103;
+          const double P2 = 0.058393137863189;
+          const double P3 = 0.041425537809187;
+          add(     A,     A, P1 ); 
+          add( 1-2*A,     A, P1 );
+          add(     A, 1-2*A, P1 );
+          add(     B,     B, P2 ); 
+          add( 1-2*B,     B, P2 );
+          add(     B, 1-2*B, P2 );
+          add(     C,     D, P3 );
+          add(     D,     C, P3 );
+          add( 1-C-D,     C, P3 );
+          add( 1-C-D,     D, P3 );
+          add(     C, 1-C-D, P3 );
+          add(     D, 1-C-D, P3 ); break;
+        }
+        default:
+          EXCEPTION( logic_error,"Invalid nb of gauss points for TRIA, variant 1: "
+                     <<nbGauss);
+        }
+      }
+      else if ( variant == 2 ) {
+        if (geom == eTRIA3) setRefCoords( TTria3a() );
+        else                setRefCoords( TTria6a() );
+        switch ( nbGauss ) {
+        case 1: {
+          add( -1/3., -1/3., 2. ); break;
+        }
+        case 3: {
+          add( -2/3.,  1/3., 2/3. );
+          add( -2/3., -2/3., 2/3. );
+          add(  1/3., -2/3., 2/3. ); break;
+        }
+        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, 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, 2*A-1, 4*P1 ); break;
+        }
+        default:
+          EXCEPTION( logic_error,"Invalid nb of gauss points for TRIA, variant 2: "
+                     <<nbGauss);
+        }
+      }
+      else if ( variant == 3 ) {
+        if (geom == eTRIA3) setRefCoords( TTria3b() );
+        else                setRefCoords( TTria6b() );
+        switch ( nbGauss ) {
+        case 4: {
+          add( 1/3., 1/3., -27/96 );
+          add( 0.2 , 0.2 ,  25/96 );
+          add( 0.6 , 0.2 ,  25/96 );
+          add( 0.2 , 0.6 ,  25/96 ); break;
+        }
+        default:
+          EXCEPTION( logic_error,"Invalid nb of gauss points for TRIA, variant 3: "
+                     <<nbGauss);
+        }
+      }
+      break;
+
+    case eQUAD4:
+    case eQUAD8:
+      if ( variant == 1 ) {
+        if (geom == eQUAD4) setRefCoords( TQuad4b() );
+        else                setRefCoords( TQuad8b() );
+        switch ( nbGauss ) {
+        case 1: { // FPG1
+          add(  0,  0,  4 ); break;
+        }
+        case 4: { // FPG4
+          const double a = 1/sqrt(3.);
+          add( -a, -a,  1 );
+          add(  a, -a,  1 );
+          add(  a,  a,  1 );
+          add( -a,  a,  1 ); break;
+        }
+        case 9: { // FPG9
+          const double a = 0.774596669241483;
+          add( -a, -a,  25/81. );
+          add(  a, -a,  25/81. );
+          add(  a,  a,  25/81. );
+          add( -a,  a,  25/81. );
+          add( 0., -a,  40/81. );
+          add(  a, 0.,  40/81. );
+          add( 0.,  a,  40/81. );
+          add( -a, 0.,  40/81. );
+          add( 0., 0.,  64/81. ); break;
+        }
+        default:
+          EXCEPTION( logic_error,"Invalid nb of gauss points for QUAD, variant 1: "
+                     <<nbGauss);
+        }
+      }
+      else if ( variant == 2 ) {
+        if (geom == eQUAD4) setRefCoords( TQuad4a() );
+        else                setRefCoords( TQuad8a() );
+        switch ( nbGauss ) {
+        case 4: {
+          const double a = 1/sqrt(3.);
+          add( -a,  a,  1 );
+          add( -a, -a,  1 );
+          add(  a, -a,  1 );
+          add(  a,  a,  1 ); break;
+        }
+        case 9: {
+          const double a = 0.774596669241483;
+          add( -a,  a,  25/81. );
+          add( -a, -a,  25/81. );
+          add(  a, -a,  25/81. );
+          add(  a,  a,  25/81. );
+          add( -a, 0.,  40/81. );
+          add( 0., -a,  40/81. );
+          add(  a, 0.,  40/81. );
+          add( 0.,  a,  40/81. );
+          add( 0., 0.,  64/81. ); break;
+        }
+        default:
+          EXCEPTION( logic_error,"Invalid nb of gauss points for QUAD, variant 1: "
+                     <<nbGauss);
+        }
+      }
+      else if ( variant == 3 ) {
+        if (geom == eQUAD4) setRefCoords( TQuad4b() );
+        else                setRefCoords( TQuad8b() );
+        switch ( nbGauss ) {
+        case 4: {
+          const double a = 3/sqrt(3.);
+          add( -a, -a,  1 );
+          add( -a,  a,  1 );
+          add(  a, -a,  1 );
+          add(  a,  a,  1 ); break;
+        }
+        case 9: {
+          const double a = sqrt(3/5.), c1 = 5/9., c2 = 8/9.;
+          const double c12 = c1*c2, c22 = c2*c2, c1c2 = c1*c2;
+          add( -a, -a,  c12  );
+          add( -a, 0.,  c1c2 );
+          add( -a,  a,  c12  );
+          add( 0., -a,  c1c2 );
+          add( 0., 0.,  c22  );
+          add( 0.,  a,  c1c2 );
+          add(  a, -a,  c12  );
+          add(  a, 0.,  c1c2 );
+          add(  a,  a,  c12  ); break;
+        }
+        default:
+          EXCEPTION( logic_error,"Invalid nb of gauss points for QUAD, variant 3: "
+                     <<nbGauss);
+        }
+      }
+      break;
+
+    case eTETRA4:
+    case eTETRA10:
+      if (geom == eTETRA4) setRefCoords( TTetra4a() );
+      else                 setRefCoords( TTetra10a() );
+      switch ( nbGauss ) {
+      case 4: { // FPG4
+        const double a = (5 - sqrt(5.))/20., b = (5 + 3*sqrt(5.))/20.;
+        add(  a,  a,  a,  1/24. );
+        add(  a,  a,  b,  1/24. );
+        add(  a,  b,  a,  1/24. );
+        add(  b,  a,  a,  1/24. ); break;
+      }
+      case 5: { // FPG5
+        const double a = 0.25, b = 1/6., c = 0.5;
+        add(  a,  a,  a, -2/15. );
+        add(  b,  b,  b,  3/40. );
+        add(  b,  b,  c,  3/40. );
+        add(  b,  c,  b,  3/40. );
+        add(  c,  b,  b,  3/40. ); break;
+      }
+      case 15: { // FPG15
+        const double a = 0.25;
+        const double b1 = (7 + sqrt(15.))/34., c1 = (13 + 3*sqrt(15.))/34., d = (5 - sqrt(15.))/20.;
+        const double b2 = (7 - sqrt(15.))/34., c2 = (13 - 3*sqrt(15.))/34., e = (5 + sqrt(15.))/20.;
+        const double P1 = (2665 - 14*sqrt(15.))/226800.;
+        const double P2 = (2665 + 14*sqrt(15.))/226800.;
+        add(  a,  a,  a,  8/405.);//_____
+        add( b1, b1, b1,  P1    );
+        add( b1, b1, c1,  P1    );
+        add( b1, c1, b1,  P1    );
+        add( c1, b1, b1,  P1    );//_____
+        add( b2, b2, b2,  P2    );
+        add( b2, b2, c2,  P2    );
+        add( b2, c2, b2,  P2    );
+        add( c2, b2, b2,  P2    );//_____
+        add(  d,  d,  e,  5/567.);
+        add(  d,  e,  d,  5/567.);
+        add(  e,  d,  d,  5/567.);
+        add(  d,  e,  e,  5/567.);
+        add(  e,  d,  e,  5/567.);
+        add(  e,  e,  d,  5/567.);
+        break;
+      }
+      default:
+        EXCEPTION( logic_error,"Invalid nb of gauss points for TETRA: "<<nbGauss);
+      }
+      break;
+
+    case ePYRA5:
+    case ePYRA13:
+      if (geom == ePYRA5) setRefCoords( TPyra5a() );
+      else                setRefCoords( TPyra13a() );
+      switch ( nbGauss ) {
+      case 5: { // FPG5
+        const double h1 = 0.1531754163448146;
+        const double h2 = 0.6372983346207416;
+        add(  .5,  0.,  h1,  2/15. );
+        add(  0.,  .5,  h1,  2/15. );
+        add( -.5,  0.,  h1,  2/15. );
+        add(  0., -.5,  h1,  2/15. );
+        add(  0.,  0.,  h2,  2/15. ); break;
+      }
+      case 6: { // FPG6
+        const double p1 = 0.1024890634400000 ;
+        const double p2 = 0.1100000000000000 ;
+        const double p3 = 0.1467104129066667 ;
+        const double a  = 0.5702963741068025 ;
+        const double h1 = 0.1666666666666666 ;
+        const double h2 = 0.08063183038464675;
+        const double h3 = 0.6098484849057127 ;
+        add(  a, 0.,  h1,  p1 );
+        add( 0.,  a,  h1,  p1 );
+        add( -a, 0.,  h1,  p1 );
+        add( 0., -a,  h1,  p1 );
+        add( 0., 0.,  h2,  p2 );
+        add( 0., 0.,  h3,  p3 ); break;
+      }
+      case 27: { // FPG27
+        const double a1  = 0.788073483; 
+        const double b6  = 0.499369002; 
+        const double b1  = 0.848418011; 
+        const double c8  = 0.478508449; 
+        const double c1  = 0.652816472; 
+        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
+        add(  fz,  fz,   z,  b6 ); // 2
+        add( -fz,  fz,   z,  b6 ); // 3
+        add( -fz, -fz,   z,  b6 ); // 4
+        add(  fz, -fz,   z,  b6 ); // 5
+        z = (1 - b1)/2.;
+        add(  0.,  0.,   z,  b6 ); // 6
+        z = (1 + b1)/2.;
+        add(  0.,  0.,   z,  b6 ); // 7
+        z = (1 - c1)/2.; fz = c1*(1 - z);
+        add(  fz,  0.,   z,  c8 ); // 8
+        add(  0.,  fz,   z,  c8 ); // 9
+        add( -fz,  0.,   z,  c8 ); // 10
+        add(  0., -fz,   z,  c8 ); // 11
+        z = (1 + c1)/2.; fz = c1*(1 - z);
+        add(  fz,  0.,   z,  c8 ); // 12
+        add(  0.,  fz,   z,  c8 ); // 13
+        add( -fz,  0.,   z,  c8 ); // 14
+        add(  0., -fz,   z,  c8 ); // 15
+        z = (1 - d1)/2., fz = d1/2*(1 - z);
+        add(  fz,  fz,   z,  d12); // 16
+        add( -fz,  fz,   z,  d12); // 17
+        add( -fz, -fz,   z,  d12); // 18
+        add(  fz, -fz,   z,  d12); // 19
+        z = 1/2.; fz = d1*(1 - z);
+        add(  fz,  0.,   z,  d12); // 20
+        add(  0.,  fz,   z,  d12); // 21
+        add( -fz,  0.,   z,  d12); // 22
+        add(  0., -fz,   z,  d12); // 23
+        z = (1 + d1)/2., fz = d1/2*(1 - z);
+        add(  fz,  fz,   z,  d12); // 24
+        add( -fz,  fz,   z,  d12); // 25
+        add( -fz, -fz,   z,  d12); // 26
+        add(  fz, -fz,   z,  d12); // 27
+        break;
+      }
+      default:
+        EXCEPTION( logic_error,"Invalid nb of gauss points for PYRA: "<<nbGauss);
+      }
+      break;
+    case ePENTA6:
+    case ePENTA15:
+      if (geom == ePENTA6) setRefCoords( TPenta6a() );
+      else                 setRefCoords( TPenta15a() );
+      switch ( nbGauss ) {
+      case 6: { // FPG6
+        const double a = sqrt(3.)/3.;
+        add( -a, .5, .5,  1/6. );
+        add( -a, 0., .5,  1/6. );
+        add( -a, .5, 0.,  1/6. );
+        add(  a, .5, .5,  1/6. );
+        add(  a, 0., .5,  1/6. );
+        add(  a, .5, 0.,  1/6. ); break;
+      }
+      case 8: { // FPG8
+        const double a = 0.577350269189626;
+        add( -a, 1/3., 1/3., -27/96. );
+        add( -a,  0.6,  0.2,  25/96. );
+        add( -a,  0.2,  0.6,  25/96. );
+        add( -a,  0.2,  0.2,  25/96. );
+        add( +a, 1/3., 1/3., -27/96. );
+        add( +a,  0.6,  0.2,  25/96. );
+        add( +a,  0.2,  0.6,  25/96. );
+        add( +a,  0.2,  0.2,  25/96. ); break;
+      }
+      case 21: { // FPG21
+        const double d = sqrt(3/5.), c1 = 5/9., c2 = 8/9.; // d <=> alfa
+        const double a = (6 + sqrt(15.))/21.;
+        const double b = (6 - sqrt(15.))/21.;
+        const double P1 = (155 + sqrt(15.))/2400.;
+        const double P2 = (155 - sqrt(15.))/2400.;  //___
+        add( -d,  1/3.,  1/3., c1*9/80. );//___
+        add( -d,     a,     a, c1*P1    );
+        add( -d, 1-2*a,     a, c1*P1    );
+        add( -d,     a, 1-2*a, c1*P1    );//___
+        add( -d,     b,     b, c1*P2    );
+        add( -d, 1-2*b,     b, c1*P2    );
+        add( -d,     b, 1-2*b, c1*P2    );//___
+        add( 0.,  1/3.,  1/3., c2*9/80. );//___
+        add( 0.,     a,     a, c2*P1    );
+        add( 0., 1-2*a,     a, c2*P1    );
+        add( 0.,     a, 1-2*a, c2*P1    );//___
+        add( 0.,     b,     b, c2*P2    );
+        add( 0., 1-2*b,     b, c2*P2    );
+        add( 0.,     b, 1-2*b, c2*P2    );//___
+        add(  d,  1/3.,  1/3., c1*9/80. );//___
+        add(  d,     a,     a, c1*P1    );
+        add(  d, 1-2*a,     a, c1*P1    );
+        add(  d,     a, 1-2*a, c1*P1    );//___
+        add(  d,     b,     b, c1*P2    );
+        add(  d, 1-2*b,     b, c1*P2    );
+        add(  d,     b, 1-2*b, c1*P2    );//___
+        break;
+      }
+      default:
+        EXCEPTION( logic_error,"Invalid nb of gauss points for PENTA: " <<nbGauss);
+      }
+      break;
+
+    case eHEXA8:
+    case eHEXA20:
+      if (geom == eHEXA8) setRefCoords( THexa8a() );
+      else                setRefCoords( THexa20a() );
+      switch ( nbGauss ) {
+      case 8: { // FPG8
+        const double a = sqrt(3.)/3.;
+        add( -a, -a, -a,  1. );
+        add( -a, -a,  a,  1. );
+        add( -a,  a, -a,  1. );
+        add( -a,  a,  a,  1. );
+        add(  a, -a, -a,  1. );
+        add(  a, -a,  a,  1. );
+        add(  a,  a, -a,  1. );
+        add(  a,  a,  a,  1. ); break;
+      }
+      case 27: { // FPG27
+        const double a = sqrt(3/5.), c1 = 5/9., c2 = 8/9.;
+        const double c12 = c1*c1, c13 = c1*c1*c1;
+        const double c22 = c2*c2, c23 = c2*c2*c2;
+        add( -a, -a, -a,   c13  ); // 1
+        add( -a, -a, 0., c12*c2 ); // 2
+        add( -a, -a,  a,   c13  ); // 3
+        add( -a, 0., -a, c12*c2 ); // 4
+        add( -a, 0., 0., c1*c22 ); // 5
+        add( -a, 0.,  a, c12*c2 ); // 6
+        add( -a,  a, -a,   c13  ); // 7
+        add( -a,  a, 0., c12*c2 ); // 8
+        add( -a,  a,  a,   c13  ); // 9
+        add( 0., -a, -a, c12*c2 ); // 10
+        add( 0., -a, 0., c1*c22 ); // 11
+        add( 0., -a,  a, c12*c2 ); // 12
+        add( 0., 0., -a, c1*c22 ); // 13
+        add( 0., 0., 0.,   c23  ); // 14
+        add( 0., 0.,  a, c1*c22 ); // 15
+        add( 0.,  a, -a, c12*c2 ); // 16
+        add( 0.,  a, 0., c1*c22 ); // 17
+        add( 0.,  a,  a, c12*c2 ); // 18
+        add(  a, -a, -a,   c13  ); // 19
+        add(  a, -a, 0., c12*c2 ); // 20
+        add(  a, -a,  a,   c13  ); // 21
+        add(  a, 0., -a, c12*c2 ); // 22
+        add(  a, 0., 0., c1*c22 ); // 23
+        add(  a, 0.,  a, c12*c2 ); // 24
+        add(  a,  a, -a,   c13  ); // 25
+        add(  a,  a, 0., c12*c2 ); // 26
+        add(  a,  a,  a,   c13  ); // 27
+        break;
+      }
+      default:
+        EXCEPTION( logic_error,"Invalid nb of gauss points for PENTA: " <<nbGauss);
+      }
+      break;
+
+    default:
+      EXCEPTION( logic_error,"unexpected EGeometrieElement: "<< geom);
+    }
+
+    if ( myWeights.capacity() != myWeights.size() )
+      EXCEPTION( logic_error,"Not all gauss points defined");
+  }
+}
diff --git a/src/MEDWrapper/Base/MED_GaussDef.hxx b/src/MEDWrapper/Base/MED_GaussDef.hxx
new file mode 100644 (file)
index 0000000..ae12c9a
--- /dev/null
@@ -0,0 +1,69 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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_GaussDef.hxx
+// Author : Edward AGAPOV (eap)
+//
+#ifndef MED_GaussDef_HeaderFile
+#define MED_GaussDef_HeaderFile
+
+#include "MED_WrapperBase.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
+   */
+  struct TGaussDef
+  {
+    int           myType;      //!< element geometry (EGeometrieElement or med_geometrie_element)
+    TDoubleVector myRefCoords; //!< description of reference points
+    TDoubleVector myCoords;    //!< coordinates of Gauss points
+    TDoubleVector myWeights;   //!< weights, len(weights)==<nb of gauss points>
+
+    /*!
+     * \brief Creates definition of gauss points family
+     *  \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 
+     *              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
+     */
+    MEDWRAPPER_EXPORT TGaussDef(const int geomType, const int nbPoints, const int variant=1);
+
+    MEDWRAPPER_EXPORT int dim() const { return myType/100; }
+    MEDWRAPPER_EXPORT int nbPoints() const { return myWeights.capacity(); }
+
+  private:
+    void add(const double x, const double weight);
+    void add(const double x, const double y, const double weight);
+    void add(const double x, const double y, const double z, const double weight);
+    void setRefCoords(const TShapeFun& aShapeFun);
+  };
+}
+
+#endif
diff --git a/src/MEDWrapper/Base/MED_GaussUtils.cxx b/src/MEDWrapper/Base/MED_GaussUtils.cxx
new file mode 100644 (file)
index 0000000..9ae82df
--- /dev/null
@@ -0,0 +1,2173 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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_GaussUtils.hxx"
+#include "MED_Utilities.hxx"
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+static int MYVALUEDEBUG = 0;
+#else
+// static int MYDEBUG = 0;
+// static int MYVALUEDEBUG = 0;
+#endif
+
+//#define _DEBUG_REF_COORDS_
+
+namespace MED
+{
+  //---------------------------------------------------------------
+  TGaussCoord
+  ::TGaussCoord():
+    TModeSwitchInfo(eFULL_INTERLACE),
+    myNbElem(0),
+    myNbGauss(0),
+    myDim(0),
+    myGaussStep(0)
+  {
+  }
+
+  void
+  TGaussCoord
+  ::Init(TInt theNbElem,
+         TInt theNbGauss,
+         TInt theDim,
+         EModeSwitch theMode)
+  {
+    myModeSwitch = theMode;
+
+    myNbElem = theNbElem;
+    myNbGauss = theNbGauss;
+    myDim = theDim;
+
+    myGaussStep = myNbGauss*myDim;
+
+    myGaussCoord.resize(theNbElem*myGaussStep);
+  }
+
+
+  TInt
+  TGaussCoord
+  ::GetNbElem() const
+  { 
+    return myNbElem; 
+  }
+  
+  TInt
+  TGaussCoord
+  ::GetNbGauss() const
+  { 
+    return myNbGauss; 
+  }
+  
+  TInt
+  TGaussCoord
+  ::GetDim() const
+  { 
+    return myDim; 
+  }
+  
+  unsigned char*
+  TGaussCoord
+  ::GetValuePtr()
+  {
+    return (unsigned char*)&(myGaussCoord[0]);
+  }
+
+
+  TCCoordSliceArr 
+  TGaussCoord
+  ::GetCoordSliceArr(TInt theElemId) const
+  {
+    TCCoordSliceArr aCoordSliceArr(myNbGauss);
+    if(GetModeSwitch() == eFULL_INTERLACE){
+      TInt anId = theElemId*myGaussStep;
+      for(TInt anGaussId = 0; anGaussId < myNbGauss; anGaussId++){
+        aCoordSliceArr[anGaussId] =
+          TCCoordSlice(myGaussCoord,std::slice(anId,myDim,1));
+        anId += myDim;
+      }
+    }
+    else{
+      for(TInt anGaussId = 0; anGaussId < myNbGauss; anGaussId++){
+        aCoordSliceArr[anGaussId] =
+          TCCoordSlice(myGaussCoord,std::slice(theElemId,myDim,myGaussStep));
+      }
+    }
+    return aCoordSliceArr;
+  }
+
+
+  TCoordSliceArr 
+  TGaussCoord
+  ::GetCoordSliceArr(TInt theElemId)
+  {
+    TCoordSliceArr aCoordSliceArr(myNbGauss);
+    if(GetModeSwitch() == eFULL_INTERLACE){
+      TInt anId = theElemId*myGaussStep;
+      for(TInt anGaussId = 0; anGaussId < myNbGauss; anGaussId++){
+        aCoordSliceArr[anGaussId] =
+          TCoordSlice(myGaussCoord,std::slice(anId,myDim,1));
+        anId += myDim;
+      }
+    }
+    else{
+      for(TInt anGaussId = 0; anGaussId < myNbGauss; anGaussId++){
+        aCoordSliceArr[anGaussId] =
+          TCoordSlice(myGaussCoord,std::slice(theElemId,myDim,myGaussStep));
+      }
+    }
+    return aCoordSliceArr;
+  }
+
+
+  //---------------------------------------------------------------
+  inline
+  bool 
+  IsEqual(TFloat theLeft, TFloat theRight)
+  {
+    static TFloat EPS = 1.0E-3;
+    if(fabs(theLeft) + fabs(theRight) > EPS)
+      return fabs(theLeft-theRight)/(fabs(theLeft)+fabs(theRight)) < EPS;
+    return true;
+  }
+
+
+  //---------------------------------------------------------------
+  class TShapeFun::TFun
+  {
+    TFloatVector myFun;
+    TInt myNbRef;
+
+  public:
+
+    void
+    Init(TInt theNbGauss,
+         TInt theNbRef)
+    {
+      myFun.resize(theNbGauss*theNbRef);
+      myNbRef = theNbRef;
+    }
+
+    TCFloatVecSlice 
+    GetFunSlice(TInt theGaussId) const
+    {
+      return TCFloatVecSlice(myFun,std::slice(theGaussId*myNbRef,myNbRef,1));
+    }
+
+    TFloatVecSlice
+    GetFunSlice(TInt theGaussId)
+    {
+      return TFloatVecSlice(myFun,std::slice(theGaussId*myNbRef,myNbRef,1));
+    }
+  };
+
+  //---------------------------------------------------------------
+
+  TShapeFun::TShapeFun(TInt theDim, TInt theNbRef):
+    myRefCoord(theNbRef*theDim),
+    myDim(theDim),
+    myNbRef(theNbRef)
+  {}
+
+  TCCoordSlice 
+  TShapeFun::GetCoord(TInt theRefId) const
+  {
+    return TCCoordSlice(myRefCoord,std::slice(theRefId*myDim,myDim,1));
+  }
+
+  TCoordSlice
+  TShapeFun::GetCoord(TInt theRefId)
+  {
+    return TCoordSlice(myRefCoord,std::slice(theRefId*myDim,myDim,1));
+  }
+
+  void 
+  TShapeFun::GetFun(const TCCoordSliceArr& theRef,
+                    const TCCoordSliceArr& theGauss,
+                    TFun& theFun) const
+  {
+    TInt aNbRef = theRef.size();
+    TInt aNbGauss = theGauss.size();
+    theFun.Init(aNbGauss,aNbRef);
+  }
+
+  bool 
+  TShapeFun::IsSatisfy(const TCCoordSliceArr& theRefCoord) const
+  {
+    TInt aNbRef = theRefCoord.size();
+    TInt aNbRef2 = GetNbRef();
+    INITMSG(MYDEBUG,"TShapeFun::IsSatisfy "<<
+            "- aNbRef("<<aNbRef<<")"<<
+            "; aNbRef2("<<aNbRef2<<")\n");
+    bool anIsSatisfy = (aNbRef == aNbRef2);
+    if(anIsSatisfy){
+      for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+        const TCCoordSlice& aCoord2 = theRefCoord[aRefId];
+        TCCoordSlice aCoord = GetCoord(aRefId);
+        TInt aDim = aCoord.size();
+        bool anIsEqual = false;
+        for(TInt anId = 0; anId < aDim; anId++){
+          anIsEqual = IsEqual(aCoord[anId],aCoord2[anId]);
+          if(!anIsEqual){
+            anIsSatisfy = false;
+            break;
+          }
+        }
+        if(!anIsEqual){
+#ifdef _DEBUG_
+          TCCoordSlice aCoord = GetCoord(aRefId);
+          INITMSG(MYDEBUG,aRefId + 1<<": aCoord = {");
+          TInt aDim = aCoord.size();
+          for(TInt anId = 0; anId < aDim; anId++)
+            ADDMSG(MYDEBUG,"\t"<<aCoord[anId]);
+          const TCCoordSlice& aCoord2 = theRefCoord[aRefId];
+          ADDMSG(MYDEBUG,"}\t!=\taCoord2 = {");
+          for(TInt anId = 0; anId < aDim; anId++)
+            ADDMSG(MYDEBUG,"\t"<<aCoord2[anId]);
+          ADDMSG(MYDEBUG,"}\n");
+#endif
+#ifndef _DEBUG_
+          BEGMSG(MYDEBUG,"anIsSatisfy = "<<anIsSatisfy<<"\n");
+          return anIsSatisfy;
+#endif
+        }
+      }
+    }
+
+    BEGMSG(MYDEBUG,"anIsSatisfy = "<<anIsSatisfy<<"\n");
+    return anIsSatisfy;
+  }
+
+  bool
+  TShapeFun::Eval(const TCellInfo&       theCellInfo,
+                  const TNodeInfo&       theNodeInfo,
+                  const TElemNum&        theElemNum,
+                  const TCCoordSliceArr& theRef,
+                  const TCCoordSliceArr& theGauss,
+                  TGaussCoord&           theGaussCoord,
+                  EModeSwitch            theMode)
+  {
+    INITMSG(MYDEBUG,"TShapeFun::Eval"<<std::endl);
+
+    if(IsSatisfy(theRef)){
+      const PMeshInfo& aMeshInfo = theCellInfo.GetMeshInfo();
+      TInt aDim = aMeshInfo->GetDim();
+      TInt aNbGauss = theGauss.size();
+
+      bool anIsSubMesh = !theElemNum.empty();
+      TInt aNbElem;
+      if(anIsSubMesh)
+        aNbElem = theElemNum.size();
+      else
+        aNbElem = theCellInfo.GetNbElem();
+
+      theGaussCoord.Init(aNbElem,aNbGauss,aDim,theMode);
+
+      TFun aFun;
+      InitFun(theRef,theGauss,aFun);
+      TInt aConnDim = theCellInfo.GetConnDim();
+
+      INITMSG(MYDEBUG,"aDim = "<<aDim<<
+              "; aNbGauss = "<<aNbGauss<<
+              "; aNbElem = "<<aNbElem<<
+              "; aNbNodes = "<<theNodeInfo.GetNbElem()<<
+              std::endl);
+
+      for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
+        TInt aCellId = anIsSubMesh? theElemNum[anElemId]-1: anElemId;
+        TCConnSlice aConnSlice = theCellInfo.GetConnSlice(aCellId);
+        TCoordSliceArr aCoordSliceArr = theGaussCoord.GetCoordSliceArr(anElemId);
+
+        for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+          TCoordSlice& aGaussCoordSlice = aCoordSliceArr[aGaussId];
+          TCFloatVecSlice aFunSlice = aFun.GetFunSlice(aGaussId);
+
+          for(TInt aConnId = 0; aConnId < aConnDim; aConnId++){
+            TInt aNodeId = aConnSlice[aConnId] - 1;      
+            TCCoordSlice aNodeCoordSlice = theNodeInfo.GetCoordSlice(aNodeId);
+
+            for(TInt aDimId = 0; aDimId < aDim; aDimId++){
+              aGaussCoordSlice[aDimId] += aNodeCoordSlice[aDimId]*aFunSlice[aConnId];
+            }
+          }
+        }
+      }
+
+#ifdef _DEBUG_
+      {
+        INITMSG(MYVALUEDEBUG,"theGauss: ");
+        for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+          TCCoordSlice aCoordSlice = theGauss[aGaussId];
+          ADDMSG(MYVALUEDEBUG,"{");
+          for(TInt aDimId = 0; aDimId < aDim; aDimId++){
+            ADDMSG(MYVALUEDEBUG,aCoordSlice[aDimId]<<" ");
+          }
+          ADDMSG(MYVALUEDEBUG,"} ");
+        }
+        ADDMSG(MYVALUEDEBUG,std::endl);
+      }
+      for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
+        TCCoordSliceArr aCoordSliceArr = theGaussCoord.GetCoordSliceArr(anElemId);
+        INITMSG(MYVALUEDEBUG,"");
+        for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+          TCCoordSlice aCoordSlice = aCoordSliceArr[aGaussId];
+          ADDMSG(MYVALUEDEBUG,"{");
+          for(TInt aDimId = 0; aDimId < aDim; aDimId++){
+            ADDMSG(MYVALUEDEBUG,aCoordSlice[aDimId]<<" ");
+          }
+          ADDMSG(MYVALUEDEBUG,"} ");
+        }
+        ADDMSG(MYVALUEDEBUG,std::endl);
+      }
+#endif
+      return true;
+    }
+
+    return false;
+  }
+
+
+  //---------------------------------------------------------------
+  TSeg2a::TSeg2a():TShapeFun(1,2)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0; break;
+      case  1: aCoord[0] =  1.0; break;
+      }
+    }
+  }
+
+  void
+  TSeg2a::InitFun(const TCCoordSliceArr& theRef,
+                  const TCCoordSliceArr& theGauss,
+                  TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.5*(1.0 - aCoord[0]);
+      aSlice[1] = 0.5*(1.0 + aCoord[0]);
+    }
+  }
+
+
+  //---------------------------------------------------------------
+  TSeg3a::TSeg3a():TShapeFun(1,3)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0; break;
+      case  1: aCoord[0] =  1.0; break;
+      case  2: aCoord[0] =  0.0; break;
+      }
+    }
+  }
+
+  void
+  TSeg3a::InitFun(const TCCoordSliceArr& theRef,
+                  const TCCoordSliceArr& theGauss,
+                  TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.5*(1.0 - aCoord[0])*aCoord[0];
+      aSlice[1] = 0.5*(1.0 + aCoord[0])*aCoord[0];
+      aSlice[2] = (1.0 + aCoord[0])*(1.0 - aCoord[0]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TTria3a::TTria3a():
+    TShapeFun(2,3)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0;  aCoord[1] =  1.0; break;
+      case  1: aCoord[0] = -1.0;  aCoord[1] = -1.0; break;
+      case  2: aCoord[0] =  1.0;  aCoord[1] = -1.0; break;
+      }
+    }
+  }
+
+  void
+  TTria3a::InitFun(const TCCoordSliceArr& theRef,
+                   const TCCoordSliceArr& theGauss,
+                   TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.5*(1.0 + aCoord[1]);
+      aSlice[1] = -0.5*(aCoord[0] + aCoord[1]);
+      aSlice[2] = 0.5*(1.0 + aCoord[0]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TTria6a::TTria6a():TShapeFun(2,6)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0;  aCoord[1] =  1.0; break;
+      case  1: aCoord[0] = -1.0;  aCoord[1] = -1.0; break;
+      case  2: aCoord[0] =  1.0;  aCoord[1] = -1.0; break;
+
+      case  3: aCoord[0] = -1.0;  aCoord[1] =  1.0; break;
+      case  4: aCoord[0] =  0.0;  aCoord[1] = -1.0; break;
+      case  5: aCoord[0] =  0.0;  aCoord[1] =  0.0; break;
+      }
+    }
+  }
+
+  void
+  TTria6a::InitFun(const TCCoordSliceArr& theRef,
+                   const TCCoordSliceArr& theGauss,
+                   TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.5*(1.0 + aCoord[1])*aCoord[1];
+      aSlice[1] = 0.5*(aCoord[0] + aCoord[1])*(aCoord[0] + aCoord[1] + 1);
+      aSlice[2] = 0.5*(1.0 + aCoord[0])*aCoord[0];
+
+      aSlice[3] = -1.0*(1.0 + aCoord[1])*(aCoord[0] + aCoord[1]);
+      aSlice[4] = -1.0*(1.0 + aCoord[0])*(aCoord[0] + aCoord[1]);
+      aSlice[5] = (1.0 + aCoord[1])*(1.0 + aCoord[1]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TTria3b::TTria3b():
+    TShapeFun(2,3)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] =  0.0;  aCoord[1] =  0.0; break;
+      case  1: aCoord[0] =  1.0;  aCoord[1] =  0.0; break;
+      case  2: aCoord[0] =  0.0;  aCoord[1] =  1.0; break;
+      }
+    }
+  }
+
+  void
+  TTria3b::InitFun(const TCCoordSliceArr& theRef,
+                   const TCCoordSliceArr& theGauss,
+                   TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 1.0 - aCoord[0] - aCoord[1];
+      aSlice[1] = aCoord[0];
+      aSlice[2] = aCoord[1];
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TTria6b::TTria6b():
+    TShapeFun(2,6)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] =  0.0;  aCoord[1] =  0.0; break;
+      case  1: aCoord[0] =  1.0;  aCoord[1] =  0.0; break;
+      case  2: aCoord[0] =  0.0;  aCoord[1] =  1.0; break;
+
+      case  3: aCoord[0] =  0.5;  aCoord[1] =  0.0; break;
+      case  4: aCoord[0] =  0.5;  aCoord[1] =  0.5; break;
+      case  5: aCoord[0] =  0.0;  aCoord[1] =  0.5; break;
+      }
+    }
+  }
+
+  void
+  TTria6b::InitFun(const TCCoordSliceArr& theRef,
+                   const TCCoordSliceArr& theGauss,
+                   TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = (1.0 - aCoord[0] - aCoord[1])*(1.0 - 2.0*aCoord[0] - 2.0*aCoord[1]);
+      aSlice[1] = aCoord[0]*(2.0*aCoord[0] - 1.0);
+      aSlice[2] = aCoord[1]*(2.0*aCoord[1] - 1.0);
+
+      aSlice[3] = 4.0*aCoord[0]*(1.0 - aCoord[0] - aCoord[1]);
+      aSlice[4] = 4.0*aCoord[0]*aCoord[1];
+      aSlice[5] = 4.0*aCoord[1]*(1.0 - aCoord[0] - aCoord[1]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TQuad4a::TQuad4a():
+    TShapeFun(2,4)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0;  aCoord[1] =  1.0; break;
+      case  1: aCoord[0] = -1.0;  aCoord[1] = -1.0; break;
+      case  2: aCoord[0] =  1.0;  aCoord[1] = -1.0; break;
+      case  3: aCoord[0] =  1.0;  aCoord[1] =  1.0; break;
+      }
+    }
+  }
+
+  void
+  TQuad4a::InitFun(const TCCoordSliceArr& theRef,
+                   const TCCoordSliceArr& theGauss,
+                   TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.25*(1.0 + aCoord[1])*(1.0 - aCoord[0]);
+      aSlice[1] = 0.25*(1.0 - aCoord[1])*(1.0 - aCoord[0]);
+      aSlice[2] = 0.25*(1.0 - aCoord[1])*(1.0 + aCoord[0]);
+      aSlice[3] = 0.25*(1.0 + aCoord[0])*(1.0 + aCoord[1]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TQuad8a::TQuad8a():
+    TShapeFun(2,8)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0;  aCoord[1] =  1.0; break;
+      case  1: aCoord[0] = -1.0;  aCoord[1] = -1.0; break;
+      case  2: aCoord[0] =  1.0;  aCoord[1] = -1.0; break;
+      case  3: aCoord[0] =  1.0;  aCoord[1] =  1.0; break;
+
+      case  4: aCoord[0] = -1.0;  aCoord[1] =  0.0; break;
+      case  5: aCoord[0] =  0.0;  aCoord[1] = -1.0; break;
+      case  6: aCoord[0] =  1.0;  aCoord[1] =  0.0; break;
+      case  7: aCoord[0] =  0.0;  aCoord[1] =  1.0; break;
+      }
+    }
+  }
+
+  void
+  TQuad8a::InitFun(const TCCoordSliceArr& theRef,
+                   const TCCoordSliceArr& theGauss,
+                   TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.25*(1.0 + aCoord[1])*(1.0 - aCoord[0])*(aCoord[1] - aCoord[0] - 1.0);
+      aSlice[1] = 0.25*(1.0 - aCoord[1])*(1.0 - aCoord[0])*(-aCoord[1] - aCoord[0] - 1.0);
+      aSlice[2] = 0.25*(1.0 - aCoord[1])*(1.0 + aCoord[0])*(-aCoord[1] + aCoord[0] - 1.0);
+      aSlice[3] = 0.25*(1.0 + aCoord[1])*(1.0 + aCoord[0])*(aCoord[1] + aCoord[0] - 1.0);
+
+      aSlice[4] = 0.5*(1.0 - aCoord[0])*(1.0 - aCoord[1])*(1.0 + aCoord[1]);
+      aSlice[5] = 0.5*(1.0 - aCoord[1])*(1.0 - aCoord[0])*(1.0 + aCoord[0]);
+      aSlice[6] = 0.5*(1.0 + aCoord[0])*(1.0 - aCoord[1])*(1.0 + aCoord[1]);
+      aSlice[7] = 0.5*(1.0 + aCoord[1])*(1.0 - aCoord[0])*(1.0 + aCoord[0]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TQuad9a::TQuad9a():
+    TShapeFun(2,9)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0;  aCoord[1] =  1.0; break;
+      case  1: aCoord[0] = -1.0;  aCoord[1] = -1.0; break;
+      case  2: aCoord[0] =  1.0;  aCoord[1] = -1.0; break;
+      case  3: aCoord[0] =  1.0;  aCoord[1] =  1.0; break;
+
+      case  4: aCoord[0] = -1.0;  aCoord[1] =  0.0; break;
+      case  5: aCoord[0] =  0.0;  aCoord[1] = -1.0; break;
+      case  6: aCoord[0] =  1.0;  aCoord[1] =  0.0; break;
+      case  7: aCoord[0] =  0.0;  aCoord[1] =  1.0; break;
+
+      case  8: aCoord[0] =  0.0;  aCoord[1] =  0.0; break;
+      }
+    }
+  }
+
+  void
+  TQuad9a::InitFun(const TCCoordSliceArr& theRef,
+                   const TCCoordSliceArr& theGauss,
+                   TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.25*aCoord[0]*aCoord[1]*(aCoord[0] + 1.0)*(aCoord[1] - 1.0);
+      aSlice[1] = 0.25*aCoord[0]*aCoord[1]*(aCoord[0] + 1.0)*(aCoord[1] + 1.0);
+      aSlice[2] = 0.25*aCoord[0]*aCoord[1]*(aCoord[0] - 1.0)*(aCoord[1] + 1.0);
+      aSlice[3] = 0.25*aCoord[0]*aCoord[1]*(aCoord[0] - 1.0)*(aCoord[1] - 1.0);
+
+      aSlice[4] = 0.5*aCoord[0]*(aCoord[0] + 1.0)*(1.0 - aCoord[1]*aCoord[1]);
+      aSlice[5] = 0.5*(1.0 - aCoord[0]*aCoord[0])*aCoord[1]*(aCoord[1] + 1.0);
+      aSlice[6] = 0.5*aCoord[0]*(aCoord[0] - 1.0)*(1.0 - aCoord[1]*aCoord[1]);
+      aSlice[7] = 0.5*(1.0 - aCoord[0]*aCoord[0])*aCoord[1]*(aCoord[1] - 1.0);
+
+      aSlice[8] = (1.0 - aCoord[0]*aCoord[0])*(1.0 - aCoord[1]*aCoord[1]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TQuad4b::TQuad4b():
+    TShapeFun(2,4)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0;  aCoord[1] = -1.0; break;
+      case  1: aCoord[0] =  1.0;  aCoord[1] = -1.0; break;
+      case  2: aCoord[0] =  1.0;  aCoord[1] =  1.0; break;
+      case  3: aCoord[0] = -1.0;  aCoord[1] =  1.0; break;
+      }
+    }
+  }
+
+  void
+  TQuad4b::InitFun(const TCCoordSliceArr& theRef,
+                   const TCCoordSliceArr& theGauss,
+                   TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.25*(1.0 - aCoord[0])*(1.0 - aCoord[1]);
+      aSlice[1] = 0.25*(1.0 + aCoord[0])*(1.0 - aCoord[1]);
+      aSlice[2] = 0.25*(1.0 + aCoord[0])*(1.0 + aCoord[1]);
+      aSlice[3] = 0.25*(1.0 - aCoord[0])*(1.0 + aCoord[1]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TQuad8b::TQuad8b():
+    TShapeFun(2,8)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0;  aCoord[1] = -1.0; break;
+      case  1: aCoord[0] =  1.0;  aCoord[1] = -1.0; break;
+      case  2: aCoord[0] =  1.0;  aCoord[1] =  1.0; break;
+      case  3: aCoord[0] = -1.0;  aCoord[1] =  1.0; break;
+
+      case  4: aCoord[0] =  0.0;  aCoord[1] = -1.0; break;
+      case  5: aCoord[0] =  1.0;  aCoord[1] =  0.0; break;
+      case  6: aCoord[0] =  0.0;  aCoord[1] =  1.0; break;
+      case  7: aCoord[0] = -1.0;  aCoord[1] =  0.0; break;
+      }
+    }
+  }
+
+  void
+  TQuad8b::InitFun(const TCCoordSliceArr& theRef,
+                   const TCCoordSliceArr& theGauss,
+                   TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.25*(1.0 - aCoord[0])*(1.0 - aCoord[1])*(-1.0 - aCoord[0] - aCoord[1]);
+      aSlice[1] = 0.25*(1.0 + aCoord[0])*(1.0 - aCoord[1])*(-1.0 + aCoord[0] - aCoord[1]);
+      aSlice[2] = 0.25*(1.0 + aCoord[0])*(1.0 + aCoord[1])*(-1.0 + aCoord[0] + aCoord[1]);
+      aSlice[3] = 0.25*(1.0 - aCoord[0])*(1.0 + aCoord[1])*(-1.0 - aCoord[0] + aCoord[1]);
+
+      aSlice[4] = 0.5*(1.0 - aCoord[0]*aCoord[0])*(1.0 - aCoord[1]);
+      aSlice[5] = 0.5*(1.0 - aCoord[1]*aCoord[1])*(1.0 + aCoord[0]);
+      aSlice[6] = 0.5*(1.0 - aCoord[0]*aCoord[0])*(1.0 + aCoord[1]);
+      aSlice[7] = 0.5*(1.0 - aCoord[1]*aCoord[1])*(1.0 - aCoord[0]);
+
+      //aSlice[4] = 0.5*(1.0 - aCoord[0])*(1.0 - aCoord[0])*(1.0 - aCoord[1]);
+      //aSlice[5] = 0.5*(1.0 + aCoord[0])*(1.0 - aCoord[1])*(1.0 - aCoord[1]);
+      //aSlice[6] = 0.5*(1.0 - aCoord[0])*(1.0 - aCoord[0])*(1.0 + aCoord[1]);
+      //aSlice[7] = 0.5*(1.0 - aCoord[0])*(1.0 - aCoord[1])*(1.0 - aCoord[1]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TQuad9b::TQuad9b():
+    TShapeFun(2,9)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0;  aCoord[1] = -1.0; break;
+      case  1: aCoord[0] =  1.0;  aCoord[1] = -1.0; break;
+      case  2: aCoord[0] =  1.0;  aCoord[1] =  1.0; break;
+      case  3: aCoord[0] = -1.0;  aCoord[1] =  1.0; break;
+
+      case  4: aCoord[0] =  0.0;  aCoord[1] = -1.0; break;
+      case  5: aCoord[0] =  1.0;  aCoord[1] =  0.0; break;
+      case  6: aCoord[0] =  0.0;  aCoord[1] =  1.0; break;
+      case  7: aCoord[0] = -1.0;  aCoord[1] =  0.0; break;
+
+      case  8: aCoord[0] =  0.0;  aCoord[1] =  0.0; break;
+      }
+    }
+  }
+
+  void
+  TQuad9b::InitFun(const TCCoordSliceArr& theRef,
+                   const TCCoordSliceArr& theGauss,
+                   TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.25*aCoord[0]*aCoord[1]*(aCoord[0] - 1.0)*(aCoord[1] - 1.0);
+      aSlice[1] = 0.25*aCoord[0]*aCoord[1]*(aCoord[0] + 1.0)*(aCoord[1] - 1.0);
+      aSlice[2] = 0.25*aCoord[0]*aCoord[1]*(aCoord[0] + 1.0)*(aCoord[1] + 1.0);
+      aSlice[3] = 0.25*aCoord[0]*aCoord[1]*(aCoord[0] - 1.0)*(aCoord[1] + 1.0);
+
+      aSlice[4] = 0.5*(1.0 - aCoord[0]*aCoord[0])*aCoord[1]*(aCoord[1] - 1.0);
+      aSlice[5] = 0.5*aCoord[0]*(aCoord[0] + 1.0)*(1.0 - aCoord[1]*aCoord[1]);
+      aSlice[6] = 0.5*(1.0 - aCoord[0]*aCoord[0])*aCoord[1]*(aCoord[1] + 1.0);
+      aSlice[7] = 0.5*aCoord[0]*(aCoord[0] - 1.0)*(1.0 - aCoord[1]*aCoord[1]);
+
+      aSlice[8] = (1.0 - aCoord[0]*aCoord[0])*(1.0 - aCoord[1]*aCoord[1]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TTetra4a::TTetra4a():
+    TShapeFun(3,4)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] =  0.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case  1: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      case  2: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      case  3: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      }
+    }
+  }
+
+  void
+  TTetra4a::InitFun(const TCCoordSliceArr& theRef,
+                    const TCCoordSliceArr& theGauss,
+                    TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = aCoord[1];
+      aSlice[1] = aCoord[2];
+      aSlice[2] = 1.0 - aCoord[0] - aCoord[1] - aCoord[2];
+      aSlice[3] = aCoord[0];
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TTetra10a::TTetra10a():
+    TShapeFun(3,10)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] =  0.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case  1: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      case  2: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      case  3: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+
+      case  4: aCoord[0] =  0.0;  aCoord[1] =  0.5;  aCoord[2] =  0.5; break;
+      case  5: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  0.5; break;
+      case  6: aCoord[0] =  0.0;  aCoord[1] =  0.5;  aCoord[2] =  0.0; break;
+
+      case  7: aCoord[0] =  0.5;  aCoord[1] =  0.5;  aCoord[2] =  0.0; break;
+      case  8: aCoord[0] =  0.5;  aCoord[1] =  0.0;  aCoord[2] =  0.5; break;
+      case  9: aCoord[0] =  0.5;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      }
+    }
+  }
+
+  void
+  TTetra10a::InitFun(const TCCoordSliceArr& theRef,
+                     const TCCoordSliceArr& theGauss,
+                     TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = aCoord[1]*(2.0*aCoord[1] - 1.0);
+      aSlice[1] = aCoord[2]*(2.0*aCoord[2] - 1.0);
+      aSlice[2] = (1.0 - aCoord[0] - aCoord[1] - aCoord[2])*(1.0 - 2.0*aCoord[0] - 2.0*aCoord[1] - 2.0*aCoord[2]);
+      aSlice[3] = aCoord[0]*(2.0*aCoord[0] - 1.0);
+
+      aSlice[4] = 4.0*aCoord[1]*aCoord[2];
+      aSlice[5] = 4.0*aCoord[2]*(1.0 - aCoord[0] - aCoord[1] - aCoord[2]);
+      aSlice[6] = 4.0*aCoord[1]*(1.0 - aCoord[0] - aCoord[1] - aCoord[2]);
+
+      aSlice[7] = 4.0*aCoord[0]*aCoord[1];
+      aSlice[8] = 4.0*aCoord[0]*aCoord[2];
+      aSlice[9] = 4.0*aCoord[0]*(1.0 - aCoord[0] - aCoord[1] - aCoord[2]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+
+
+  TTetra4b::TTetra4b():
+    TShapeFun(3,4)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] =  0.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case  2: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      case  1: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      case  3: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      }
+    }
+  }
+
+  void
+  TTetra4b::InitFun(const TCCoordSliceArr& theRef,
+                    const TCCoordSliceArr& theGauss,
+                    TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = aCoord[1];
+      aSlice[2] = aCoord[2];
+      aSlice[1] = 1.0 - aCoord[0] - aCoord[1] - aCoord[2];
+      aSlice[3] = aCoord[0];
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TTetra10b::TTetra10b():
+    TShapeFun(3,10)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] =  0.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case  2: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      case  1: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      case  3: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+
+      case  6: aCoord[0] =  0.0;  aCoord[1] =  0.5;  aCoord[2] =  0.5; break;
+      case  5: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  0.5; break;
+      case  4: aCoord[0] =  0.0;  aCoord[1] =  0.5;  aCoord[2] =  0.0; break;
+
+      case  7: aCoord[0] =  0.5;  aCoord[1] =  0.5;  aCoord[2] =  0.0; break;
+      case  9: aCoord[0] =  0.5;  aCoord[1] =  0.0;  aCoord[2] =  0.5; break;
+      case  8: aCoord[0] =  0.5;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      }
+    }
+  }
+
+  void
+  TTetra10b::InitFun(const TCCoordSliceArr& theRef,
+                     const TCCoordSliceArr& theGauss,
+                     TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = aCoord[1]*(2.0*aCoord[1] - 1.0);
+      aSlice[2] = aCoord[2]*(2.0*aCoord[2] - 1.0);
+      aSlice[1] = (1.0 - aCoord[0] - aCoord[1] - aCoord[2])*(1.0 - 2.0*aCoord[0] - 2.0*aCoord[1] - 2.0*aCoord[2]);
+      aSlice[3] = aCoord[0]*(2.0*aCoord[0] - 1.0);
+
+      aSlice[6] = 4.0*aCoord[1]*aCoord[2];
+      aSlice[5] = 4.0*aCoord[2]*(1.0 - aCoord[0] - aCoord[1] - aCoord[2]);
+      aSlice[4] = 4.0*aCoord[1]*(1.0 - aCoord[0] - aCoord[1] - aCoord[2]);
+
+      aSlice[7] = 4.0*aCoord[0]*aCoord[1];
+      aSlice[9] = 4.0*aCoord[0]*aCoord[2];
+      aSlice[8] = 4.0*aCoord[0]*(1.0 - aCoord[0] - aCoord[1] - aCoord[2]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  THexa8a::THexa8a():
+    TShapeFun(3,8)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0;  aCoord[1] = -1.0;  aCoord[2] = -1.0; break;
+      case  1: aCoord[0] =  1.0;  aCoord[1] = -1.0;  aCoord[2] = -1.0; break;
+      case  2: aCoord[0] =  1.0;  aCoord[1] =  1.0;  aCoord[2] = -1.0; break;
+      case  3: aCoord[0] = -1.0;  aCoord[1] =  1.0;  aCoord[2] = -1.0; break;
+      case  4: aCoord[0] = -1.0;  aCoord[1] = -1.0;  aCoord[2] =  1.0; break;
+      case  5: aCoord[0] =  1.0;  aCoord[1] = -1.0;  aCoord[2] =  1.0; break;
+      case  6: aCoord[0] =  1.0;  aCoord[1] =  1.0;  aCoord[2] =  1.0; break;
+      case  7: aCoord[0] = -1.0;  aCoord[1] =  1.0;  aCoord[2] =  1.0; break;
+      }
+    }
+  }
+
+  void
+  THexa8a::InitFun(const TCCoordSliceArr& theRef,
+                   const TCCoordSliceArr& theGauss,
+                   TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.125*(1.0 - aCoord[0])*(1.0 - aCoord[1])*(1.0 - aCoord[2]);
+      aSlice[1] = 0.125*(1.0 + aCoord[0])*(1.0 - aCoord[1])*(1.0 - aCoord[2]);
+      aSlice[2] = 0.125*(1.0 + aCoord[0])*(1.0 + aCoord[1])*(1.0 - aCoord[2]);
+      aSlice[3] = 0.125*(1.0 - aCoord[0])*(1.0 + aCoord[1])*(1.0 - aCoord[2]);
+
+      aSlice[4] = 0.125*(1.0 - aCoord[0])*(1.0 - aCoord[1])*(1.0 + aCoord[2]);
+      aSlice[5] = 0.125*(1.0 + aCoord[0])*(1.0 - aCoord[1])*(1.0 + aCoord[2]);
+      aSlice[6] = 0.125*(1.0 + aCoord[0])*(1.0 + aCoord[1])*(1.0 + aCoord[2]);
+      aSlice[7] = 0.125*(1.0 - aCoord[0])*(1.0 + aCoord[1])*(1.0 + aCoord[2]);
+    }
+  }
+
+
+  //---------------------------------------------------------------
+  THexa20a::THexa20a(TInt theDim, TInt theNbRef):
+    TShapeFun(theDim,theNbRef)
+  {
+    TInt aNbRef = myRefCoord.size();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0;  aCoord[1] = -1.0;  aCoord[2] = -1.0; break;
+      case  1: aCoord[0] =  1.0;  aCoord[1] = -1.0;  aCoord[2] = -1.0; break;
+      case  2: aCoord[0] =  1.0;  aCoord[1] =  1.0;  aCoord[2] = -1.0; break;
+      case  3: aCoord[0] = -1.0;  aCoord[1] =  1.0;  aCoord[2] = -1.0; break;
+      case  4: aCoord[0] = -1.0;  aCoord[1] = -1.0;  aCoord[2] =  1.0; break;
+      case  5: aCoord[0] =  1.0;  aCoord[1] = -1.0;  aCoord[2] =  1.0; break;
+      case  6: aCoord[0] =  1.0;  aCoord[1] =  1.0;  aCoord[2] =  1.0; break;
+      case  7: aCoord[0] = -1.0;  aCoord[1] =  1.0;  aCoord[2] =  1.0; break;
+
+      case  8: aCoord[0] =  0.0;  aCoord[1] = -1.0;  aCoord[2] = -1.0; break;
+      case  9: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] = -1.0; break;
+      case 10: aCoord[0] =  0.0;  aCoord[1] =  1.0;  aCoord[2] = -1.0; break;
+      case 11: aCoord[0] = -1.0;  aCoord[1] =  0.0;  aCoord[2] = -1.0; break;
+      case 12: aCoord[0] = -1.0;  aCoord[1] = -1.0;  aCoord[2] =  0.0; break;
+      case 13: aCoord[0] =  1.0;  aCoord[1] = -1.0;  aCoord[2] =  0.0; break;
+      case 14: aCoord[0] =  1.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case 15: aCoord[0] = -1.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case 16: aCoord[0] =  0.0;  aCoord[1] = -1.0;  aCoord[2] =  1.0; break;
+      case 17: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      case 18: aCoord[0] =  0.0;  aCoord[1] =  1.0;  aCoord[2] =  1.0; break;
+      case 19: aCoord[0] = -1.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      }
+    }
+  }
+
+  void
+  THexa20a::InitFun(const TCCoordSliceArr& theRef,
+                    const TCCoordSliceArr& theGauss,
+                    TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.125*(1.0 - aCoord[0])*(1.0 - aCoord[1])*(1.0 - aCoord[2])*
+        (-2.0 - aCoord[0] - aCoord[1] - aCoord[2]);
+      aSlice[1] = 0.125*(1.0 + aCoord[0])*(1.0 - aCoord[1])*(1.0 - aCoord[2])*
+        (-2.0 + aCoord[0] - aCoord[1] - aCoord[2]);
+      aSlice[2] = 0.125*(1.0 + aCoord[0])*(1.0 + aCoord[1])*(1.0 - aCoord[2])*
+        (-2.0 + aCoord[0] + aCoord[1] - aCoord[2]);
+      aSlice[3] = 0.125*(1.0 - aCoord[0])*(1.0 + aCoord[1])*(1.0 - aCoord[2])*
+        (-2.0 - aCoord[0] + aCoord[1] - aCoord[2]);
+      aSlice[4] = 0.125*(1.0 - aCoord[0])*(1.0 - aCoord[1])*(1.0 + aCoord[2])*
+        (-2.0 - aCoord[0] - aCoord[1] + aCoord[2]);
+      aSlice[5] = 0.125*(1.0 + aCoord[0])*(1.0 - aCoord[1])*(1.0 + aCoord[2])*
+        (-2.0 + aCoord[0] - aCoord[1] + aCoord[2]);
+      aSlice[6] = 0.125*(1.0 + aCoord[0])*(1.0 + aCoord[1])*(1.0 + aCoord[2])*
+        (-2.0 + aCoord[0] + aCoord[1] + aCoord[2]);
+      aSlice[7] = 0.125*(1.0 - aCoord[0])*(1.0 + aCoord[1])*(1.0 + aCoord[2])*
+        (-2.0 - aCoord[0] + aCoord[1] + aCoord[2]);
+
+      aSlice[8] = 0.25*(1.0 - aCoord[0]*aCoord[0])*(1.0 - aCoord[1])*(1.0 - aCoord[2]);
+      aSlice[9] = 0.25*(1.0 - aCoord[1]*aCoord[1])*(1.0 + aCoord[0])*(1.0 - aCoord[2]);
+      aSlice[10] = 0.25*(1.0 - aCoord[0]*aCoord[0])*(1.0 + aCoord[1])*(1.0 - aCoord[2]);
+      aSlice[11] = 0.25*(1.0 - aCoord[1]*aCoord[1])*(1.0 - aCoord[0])*(1.0 - aCoord[2]);
+      aSlice[12] = 0.25*(1.0 - aCoord[2]*aCoord[2])*(1.0 - aCoord[0])*(1.0 - aCoord[1]);
+      aSlice[13] = 0.25*(1.0 - aCoord[2]*aCoord[2])*(1.0 + aCoord[0])*(1.0 - aCoord[1]);
+      aSlice[14] = 0.25*(1.0 - aCoord[2]*aCoord[2])*(1.0 + aCoord[0])*(1.0 + aCoord[1]);
+      aSlice[15] = 0.25*(1.0 - aCoord[2]*aCoord[2])*(1.0 - aCoord[0])*(1.0 + aCoord[1]);
+      aSlice[16] = 0.25*(1.0 - aCoord[0]*aCoord[0])*(1.0 - aCoord[1])*(1.0 + aCoord[2]);
+      aSlice[17] = 0.25*(1.0 - aCoord[1]*aCoord[1])*(1.0 + aCoord[0])*(1.0 + aCoord[2]);
+      aSlice[18] = 0.25*(1.0 - aCoord[0]*aCoord[0])*(1.0 + aCoord[1])*(1.0 + aCoord[2]);
+      aSlice[19] = 0.25*(1.0 - aCoord[1]*aCoord[1])*(1.0 - aCoord[0])*(1.0 + aCoord[2]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  THexa27a::THexa27a():
+    THexa20a(3,27)
+  {
+    TInt aNbRef = myRefCoord.size();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case 20: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] = -1.0; break;
+      case 21: aCoord[0] =  0.0;  aCoord[1] = -1.0;  aCoord[2] =  0.0; break;
+      case 22: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      case 23: aCoord[0] =  0.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case 24: aCoord[0] = -1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      case 25: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      case 26: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      }
+    }
+  }
+
+  void
+  THexa27a::InitFun(const TCCoordSliceArr& theRef,
+                    const TCCoordSliceArr& theGauss,
+                    TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.125*aCoord[0]*(aCoord[0] - 1.0)*aCoord[1]*(aCoord[1] - 1.0)*aCoord[2]*(aCoord[2] - 1.0);
+      aSlice[1] = 0.125*aCoord[0]*(aCoord[0] + 1.0)*aCoord[1]*(aCoord[1] - 1.0)*aCoord[2]*(aCoord[2] - 1.0);
+      aSlice[2] = 0.125*aCoord[0]*(aCoord[0] + 1.0)*aCoord[1]*(aCoord[1] + 1.0)*aCoord[2]*(aCoord[2] - 1.0);
+      aSlice[3] = 0.125*aCoord[0]*(aCoord[0] - 1.0)*aCoord[1]*(aCoord[1] + 1.0)*aCoord[2]*(aCoord[2] - 1.0);
+      aSlice[4] = 0.125*aCoord[0]*(aCoord[0] + 1.0)*aCoord[1]*(aCoord[1] - 1.0)*aCoord[2]*(aCoord[2] + 1.0);
+      aSlice[5] = 0.125*aCoord[0]*(aCoord[0] + 1.0)*aCoord[1]*(aCoord[1] - 1.0)*aCoord[2]*(aCoord[2] + 1.0);
+      aSlice[6] = 0.125*aCoord[0]*(aCoord[0] + 1.0)*aCoord[1]*(aCoord[1] + 1.0)*aCoord[2]*(aCoord[2] + 1.0);
+      aSlice[7] = 0.125*aCoord[0]*(aCoord[0] - 1.0)*aCoord[1]*(aCoord[1] + 1.0)*aCoord[2]*(aCoord[2] + 1.0);
+
+      aSlice[8] = 0.25*(1.0 - aCoord[0]*aCoord[0])*aCoord[1]*(aCoord[1] - 1.0)*aCoord[2]*(aCoord[2] - 1.0);
+      aSlice[9] = 0.25*aCoord[0]*(aCoord[0] + 1.0)*(1.0 - aCoord[1]*aCoord[1])*aCoord[2]*(aCoord[2] - 1.0);
+      aSlice[10]= 0.25*aCoord[0]*(aCoord[0] + 1.0)*(1.0 - aCoord[1]*aCoord[1])*aCoord[2]*(aCoord[2] - 1.0);
+      aSlice[11]= 0.25*aCoord[0]*(aCoord[0] - 1.0)*(1.0 - aCoord[1]*aCoord[1])*aCoord[2]*(aCoord[2] - 1.0);
+      aSlice[12]= 0.25*aCoord[0]*(aCoord[0] - 1.0)*aCoord[1]*(aCoord[1] - 1.0)*(1.0 - aCoord[2]*aCoord[2]);
+      aSlice[13]= 0.25*aCoord[0]*(aCoord[0] + 1.0)*aCoord[1]*(aCoord[1] - 1.0)*(1.0 - aCoord[2]*aCoord[2]);
+      aSlice[14]= 0.25*aCoord[0]*(aCoord[0] + 1.0)*aCoord[1]*(aCoord[1] + 1.0)*(1.0 - aCoord[2]*aCoord[2]);
+      aSlice[15]= 0.25*aCoord[0]*(aCoord[0] - 1.0)*aCoord[1]*(aCoord[1] + 1.0)*(1.0 - aCoord[2]*aCoord[2]);
+      aSlice[16]= 0.25*(1.0 - aCoord[0]*aCoord[0])*aCoord[1]*(aCoord[1] - 1.0)*aCoord[2]*(aCoord[2] + 1.0);
+      aSlice[17]= 0.25*aCoord[0]*(aCoord[0] + 1.0)*(1.0 - aCoord[1]*aCoord[1])*aCoord[2]*(aCoord[2] + 1.0);
+      aSlice[18]= 0.25*(1.0 - aCoord[0]*aCoord[0])*aCoord[1]*(aCoord[1] + 1.0)*aCoord[2]*(aCoord[2] + 1.0);
+      aSlice[19]= 0.25*aCoord[0]*(aCoord[0] - 1.0)*(1.0 - aCoord[1]*aCoord[1])*aCoord[2]*(aCoord[2] + 1.0);
+      aSlice[20]= 0.25*(1.0 - aCoord[0]*aCoord[0])*(1.0 - aCoord[1]*aCoord[1])*aCoord[2]*(aCoord[2] - 1.0);
+      aSlice[21]= 0.25*(1.0 - aCoord[0]*aCoord[0])*aCoord[1]*(aCoord[1] - 1.0)*(1.0 - aCoord[2]*aCoord[2]);
+      aSlice[22]= 0.25*aCoord[0]*(aCoord[0] + 1.0)*(1.0 - aCoord[1]*aCoord[1])*(1.0 - aCoord[2]*aCoord[2]);
+      aSlice[23]= 0.25*(1.0 - aCoord[0]*aCoord[0])*aCoord[1]*(aCoord[1] + 1.0)*(1.0 - aCoord[2]*aCoord[2]);
+      aSlice[24]= 0.25*aCoord[0]*(aCoord[0] - 1.0)*(1.0 - aCoord[1]*aCoord[1])*(1.0 - aCoord[2]*aCoord[2]);
+      aSlice[25]= 0.25*(1.0 - aCoord[0]*aCoord[0])*(1.0 - aCoord[1]*aCoord[1])*aCoord[2]*(aCoord[2] + 1.0);
+      aSlice[26]= 0.25*(1.0 - aCoord[0]*aCoord[0])*(1.0 - aCoord[1]*aCoord[1])*(1.0 - aCoord[1]*aCoord[1]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  THexa8b::THexa8b():
+    TShapeFun(3,8)
+  {
+    TInt aNbRef = GetNbRef();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0;  aCoord[1] = -1.0;  aCoord[2] = -1.0; break;
+      case  3: aCoord[0] =  1.0;  aCoord[1] = -1.0;  aCoord[2] = -1.0; break;
+      case  2: aCoord[0] =  1.0;  aCoord[1] =  1.0;  aCoord[2] = -1.0; break;
+      case  1: aCoord[0] = -1.0;  aCoord[1] =  1.0;  aCoord[2] = -1.0; break;
+      case  4: aCoord[0] = -1.0;  aCoord[1] = -1.0;  aCoord[2] =  1.0; break;
+      case  7: aCoord[0] =  1.0;  aCoord[1] = -1.0;  aCoord[2] =  1.0; break;
+      case  6: aCoord[0] =  1.0;  aCoord[1] =  1.0;  aCoord[2] =  1.0; break;
+      case  5: aCoord[0] = -1.0;  aCoord[1] =  1.0;  aCoord[2] =  1.0; break;
+      }
+    }
+  }
+
+  void
+  THexa8b::InitFun(const TCCoordSliceArr& theRef,
+                   const TCCoordSliceArr& theGauss,
+                   TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.125*(1.0 - aCoord[0])*(1.0 - aCoord[1])*(1.0 - aCoord[2]);
+      aSlice[3] = 0.125*(1.0 + aCoord[0])*(1.0 - aCoord[1])*(1.0 - aCoord[2]);
+      aSlice[2] = 0.125*(1.0 + aCoord[0])*(1.0 + aCoord[1])*(1.0 - aCoord[2]);
+      aSlice[1] = 0.125*(1.0 - aCoord[0])*(1.0 + aCoord[1])*(1.0 - aCoord[2]);
+
+      aSlice[4] = 0.125*(1.0 - aCoord[0])*(1.0 - aCoord[1])*(1.0 + aCoord[2]);
+      aSlice[7] = 0.125*(1.0 + aCoord[0])*(1.0 - aCoord[1])*(1.0 + aCoord[2]);
+      aSlice[6] = 0.125*(1.0 + aCoord[0])*(1.0 + aCoord[1])*(1.0 + aCoord[2]);
+      aSlice[5] = 0.125*(1.0 - aCoord[0])*(1.0 + aCoord[1])*(1.0 + aCoord[2]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  THexa20b::THexa20b(TInt theDim, TInt theNbRef):
+    TShapeFun(theDim,theNbRef)
+  {
+    TInt aNbRef = myRefCoord.size();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0;  aCoord[1] = -1.0;  aCoord[2] = -1.0; break;
+      case  3: aCoord[0] =  1.0;  aCoord[1] = -1.0;  aCoord[2] = -1.0; break;
+      case  2: aCoord[0] =  1.0;  aCoord[1] =  1.0;  aCoord[2] = -1.0; break;
+      case  1: aCoord[0] = -1.0;  aCoord[1] =  1.0;  aCoord[2] = -1.0; break;
+      case  4: aCoord[0] = -1.0;  aCoord[1] = -1.0;  aCoord[2] =  1.0; break;
+      case  7: aCoord[0] =  1.0;  aCoord[1] = -1.0;  aCoord[2] =  1.0; break;
+      case  6: aCoord[0] =  1.0;  aCoord[1] =  1.0;  aCoord[2] =  1.0; break;
+      case  5: aCoord[0] = -1.0;  aCoord[1] =  1.0;  aCoord[2] =  1.0; break;
+
+      case 11: aCoord[0] =  0.0;  aCoord[1] = -1.0;  aCoord[2] = -1.0; break;
+      case 10: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] = -1.0; break;
+      case  9: aCoord[0] =  0.0;  aCoord[1] =  1.0;  aCoord[2] = -1.0; break;
+      case  8: aCoord[0] = -1.0;  aCoord[1] =  0.0;  aCoord[2] = -1.0; break;
+      case 16: aCoord[0] = -1.0;  aCoord[1] = -1.0;  aCoord[2] =  0.0; break;
+      case 19: aCoord[0] =  1.0;  aCoord[1] = -1.0;  aCoord[2] =  0.0; break;
+      case 18: aCoord[0] =  1.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case 17: aCoord[0] = -1.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case 15: aCoord[0] =  0.0;  aCoord[1] = -1.0;  aCoord[2] =  1.0; break;
+      case 14: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      case 13: aCoord[0] =  0.0;  aCoord[1] =  1.0;  aCoord[2] =  1.0; break;
+      case 12: aCoord[0] = -1.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      }
+    }
+  }
+
+  void
+  THexa20b::InitFun(const TCCoordSliceArr& theRef,
+                    const TCCoordSliceArr& theGauss,
+                    TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.125*(1.0 - aCoord[0])*(1.0 - aCoord[1])*(1.0 - aCoord[2])*
+        (-2.0 - aCoord[0] - aCoord[1] - aCoord[2]);
+      aSlice[3] = 0.125*(1.0 + aCoord[0])*(1.0 - aCoord[1])*(1.0 - aCoord[2])*
+        (-2.0 + aCoord[0] - aCoord[1] - aCoord[2]);
+      aSlice[2] = 0.125*(1.0 + aCoord[0])*(1.0 + aCoord[1])*(1.0 - aCoord[2])*
+        (-2.0 + aCoord[0] + aCoord[1] - aCoord[2]);
+      aSlice[1] = 0.125*(1.0 - aCoord[0])*(1.0 + aCoord[1])*(1.0 - aCoord[2])*
+        (-2.0 - aCoord[0] + aCoord[1] - aCoord[2]);
+      aSlice[4] = 0.125*(1.0 - aCoord[0])*(1.0 - aCoord[1])*(1.0 + aCoord[2])*
+        (-2.0 - aCoord[0] - aCoord[1] + aCoord[2]);
+      aSlice[7] = 0.125*(1.0 + aCoord[0])*(1.0 - aCoord[1])*(1.0 + aCoord[2])*
+        (-2.0 + aCoord[0] - aCoord[1] + aCoord[2]);
+      aSlice[6] = 0.125*(1.0 + aCoord[0])*(1.0 + aCoord[1])*(1.0 + aCoord[2])*
+        (-2.0 + aCoord[0] + aCoord[1] + aCoord[2]);
+      aSlice[5] = 0.125*(1.0 - aCoord[0])*(1.0 + aCoord[1])*(1.0 + aCoord[2])*
+        (-2.0 - aCoord[0] + aCoord[1] + aCoord[2]);
+
+      aSlice[11] = 0.25*(1.0 - aCoord[0]*aCoord[0])*(1.0 - aCoord[1])*(1.0 - aCoord[2]);
+      aSlice[10] = 0.25*(1.0 - aCoord[1]*aCoord[1])*(1.0 + aCoord[0])*(1.0 - aCoord[2]);
+      aSlice[9] = 0.25*(1.0 - aCoord[0]*aCoord[0])*(1.0 + aCoord[1])*(1.0 - aCoord[2]);
+      aSlice[8] = 0.25*(1.0 - aCoord[1]*aCoord[1])*(1.0 - aCoord[0])*(1.0 - aCoord[2]);
+      aSlice[16] = 0.25*(1.0 - aCoord[2]*aCoord[2])*(1.0 - aCoord[0])*(1.0 - aCoord[1]);
+      aSlice[19] = 0.25*(1.0 - aCoord[2]*aCoord[2])*(1.0 + aCoord[0])*(1.0 - aCoord[1]);
+      aSlice[18] = 0.25*(1.0 - aCoord[2]*aCoord[2])*(1.0 + aCoord[0])*(1.0 + aCoord[1]);
+      aSlice[17] = 0.25*(1.0 - aCoord[2]*aCoord[2])*(1.0 - aCoord[0])*(1.0 + aCoord[1]);
+      aSlice[15] = 0.25*(1.0 - aCoord[0]*aCoord[0])*(1.0 - aCoord[1])*(1.0 + aCoord[2]);
+      aSlice[14] = 0.25*(1.0 - aCoord[1]*aCoord[1])*(1.0 + aCoord[0])*(1.0 + aCoord[2]);
+      aSlice[13] = 0.25*(1.0 - aCoord[0]*aCoord[0])*(1.0 + aCoord[1])*(1.0 + aCoord[2]);
+      aSlice[12] = 0.25*(1.0 - aCoord[1]*aCoord[1])*(1.0 - aCoord[0])*(1.0 + aCoord[2]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TPenta6a::TPenta6a():
+    TShapeFun(3,6)
+  {
+    TInt aNbRef = myRefCoord.size();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case  1: aCoord[0] = -1.0;  aCoord[1] = -0.0;  aCoord[2] =  1.0; break;
+      case  2: aCoord[0] = -1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      case  3: aCoord[0] =  1.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case  4: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      case  5: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      }
+    }
+  }
+
+  void
+  TPenta6a::InitFun(const TCCoordSliceArr& theRef,
+                    const TCCoordSliceArr& theGauss,
+                    TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.5*aCoord[1]*(1.0 - aCoord[0]);
+      aSlice[1] = 0.5*aCoord[2]*(1.0 - aCoord[0]);
+      aSlice[2] = 0.5*(1.0 - aCoord[1] - aCoord[2])*(1.0 - aCoord[0]);
+
+      aSlice[3] = 0.5*aCoord[1]*(aCoord[0] + 1.0);
+      aSlice[4] = 0.5*aCoord[2]*(aCoord[0] + 1.0);
+      aSlice[5] = 0.5*(1.0 - aCoord[1] - aCoord[2])*(1.0 + aCoord[0]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TPenta6b::TPenta6b():
+    TShapeFun(3,6)
+  {
+    TInt aNbRef = myRefCoord.size();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case  2: aCoord[0] = -1.0;  aCoord[1] = -0.0;  aCoord[2] =  1.0; break;
+      case  1: aCoord[0] = -1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      case  3: aCoord[0] =  1.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case  5: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      case  4: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      }
+    }
+  }
+
+  void
+  TPenta6b::InitFun(const TCCoordSliceArr& theRef,
+                    const TCCoordSliceArr& theGauss,
+                    TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.5*aCoord[1]*(1.0 - aCoord[0]);
+      aSlice[2] = 0.5*aCoord[2]*(1.0 - aCoord[0]);
+      aSlice[1] = 0.5*(1.0 - aCoord[1] - aCoord[2])*(1.0 - aCoord[0]);
+
+      aSlice[3] = 0.5*aCoord[1]*(aCoord[0] + 1.0);
+      aSlice[5] = 0.5*aCoord[2]*(aCoord[0] + 1.0);
+      aSlice[4] = 0.5*(1.0 - aCoord[1] - aCoord[2])*(1.0 + aCoord[0]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TPenta15a::TPenta15a():
+    TShapeFun(3,15)
+  {
+    TInt aNbRef = myRefCoord.size();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case  1: aCoord[0] = -1.0;  aCoord[1] = -0.0;  aCoord[2] =  1.0; break;
+      case  2: aCoord[0] = -1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      case  3: aCoord[0] =  1.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case  4: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      case  5: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+
+      case  6: aCoord[0] = -1.0;  aCoord[1] =  0.5;  aCoord[2] =  0.5; break;
+      case  7: aCoord[0] = -1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.5; break;
+      case  8: aCoord[0] = -1.0;  aCoord[1] =  0.5;  aCoord[2] =  0.0; break;
+      case  9: aCoord[0] =  0.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case 10: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      case 11: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      case 12: aCoord[0] =  1.0;  aCoord[1] =  0.5;  aCoord[2] =  0.5; break;
+      case 13: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.5; break;
+      case 14: aCoord[0] =  1.0;  aCoord[1] =  0.5;  aCoord[2] =  0.0; break;
+      }
+    }
+  }
+
+  void
+  TPenta15a::InitFun(const TCCoordSliceArr& theRef,
+                     const TCCoordSliceArr& theGauss,
+                     TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.5*aCoord[1]*(1.0 - aCoord[0])*(2.0*aCoord[1] - 2.0 - aCoord[0]);
+      aSlice[1] = 0.5*aCoord[2]*(1.0 - aCoord[0])*(2.0*aCoord[2] - 2.0 - aCoord[0]);
+      aSlice[2] = 0.5*(aCoord[0] - 1.0)*(1.0 - aCoord[1] - aCoord[2])*(aCoord[0] + 2.0*aCoord[1] + 2.0*aCoord[2]);
+
+      aSlice[3] = 0.5*aCoord[1]*(1.0 + aCoord[0])*(2.0*aCoord[1] - 2.0 + aCoord[0]);
+      aSlice[4] = 0.5*aCoord[2]*(1.0 + aCoord[0])*(2.0*aCoord[2] - 2.0 + aCoord[0]);
+      aSlice[5] = 0.5*(-aCoord[0] - 1.0)*(1.0 - aCoord[1] - aCoord[2])*(-aCoord[0] + 2.0*aCoord[1] + 2.0*aCoord[2]);
+
+      aSlice[6] = 2.0*aCoord[1]*aCoord[2]*(1.0 - aCoord[0]);
+      aSlice[7] = 2.0*aCoord[2]*(1.0 - aCoord[1] - aCoord[2])*(1.0 - aCoord[0]);
+      aSlice[8] = 2.0*aCoord[1]*(1.0 - aCoord[1] - aCoord[2])*(1.0 - aCoord[0]);
+
+      aSlice[9] = aCoord[1]*(1.0 - aCoord[0]*aCoord[0]);
+      aSlice[10] = aCoord[2]*(1.0 - aCoord[0]*aCoord[0]);
+      aSlice[11] = (1.0 - aCoord[1] - aCoord[2])*(1.0 - aCoord[0]*aCoord[0]);
+
+      aSlice[12] = 2.0*aCoord[1]*aCoord[2]*(1.0 + aCoord[0]);
+      aSlice[13] = 2.0*aCoord[2]*(1.0 - aCoord[1] - aCoord[2])*(1.0 + aCoord[0]);
+      aSlice[14] = 2.0*aCoord[1]*(1.0 - aCoord[1] - aCoord[2])*(1.0 + aCoord[0]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TPenta15b::TPenta15b():
+    TShapeFun(3,15)
+  {
+    TInt aNbRef = myRefCoord.size();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] = -1.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case  2: aCoord[0] = -1.0;  aCoord[1] = -0.0;  aCoord[2] =  1.0; break;
+      case  1: aCoord[0] = -1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      case  3: aCoord[0] =  1.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case  5: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      case  4: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+
+      case  8: aCoord[0] = -1.0;  aCoord[1] =  0.5;  aCoord[2] =  0.5; break;
+      case  7: aCoord[0] = -1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.5; break;
+      case  6: aCoord[0] = -1.0;  aCoord[1] =  0.5;  aCoord[2] =  0.0; break;
+      case 12: aCoord[0] =  0.0;  aCoord[1] =  1.0;  aCoord[2] =  0.0; break;
+      case 14: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      case 13: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      case 11: aCoord[0] =  1.0;  aCoord[1] =  0.5;  aCoord[2] =  0.5; break;
+      case 10: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.5; break;
+      case  9: aCoord[0] =  1.0;  aCoord[1] =  0.5;  aCoord[2] =  0.0; break;
+      }
+    }
+  }
+
+  void
+  TPenta15b::InitFun(const TCCoordSliceArr& theRef,
+                     const TCCoordSliceArr& theGauss,
+                     TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.5*aCoord[1]*(1.0 - aCoord[0])*(2.0*aCoord[1] - 2.0 - aCoord[0]);
+      aSlice[2] = 0.5*aCoord[2]*(1.0 - aCoord[0])*(2.0*aCoord[2] - 2.0 - aCoord[0]);
+      aSlice[1] = 0.5*(aCoord[0] - 1.0)*(1.0 - aCoord[1] - aCoord[2])*(aCoord[0] + 2.0*aCoord[1] + 2.0*aCoord[2]);
+
+      aSlice[3] = 0.5*aCoord[1]*(1.0 + aCoord[0])*(2.0*aCoord[1] - 2.0 + aCoord[0]);
+      aSlice[5] = 0.5*aCoord[2]*(1.0 + aCoord[0])*(2.0*aCoord[2] - 2.0 + aCoord[0]);
+      aSlice[4] = 0.5*(-aCoord[0] - 1.0)*(1.0 - aCoord[1] - aCoord[2])*(-aCoord[0] + 2.0*aCoord[1] + 2.0*aCoord[2]);
+
+      aSlice[8] = 2.0*aCoord[1]*aCoord[2]*(1.0 - aCoord[0]);
+      aSlice[7] = 2.0*aCoord[2]*(1.0 - aCoord[1] - aCoord[2])*(1.0 - aCoord[0]);
+      aSlice[6] = 2.0*aCoord[1]*(1.0 - aCoord[1] - aCoord[2])*(1.0 - aCoord[0]);
+
+      aSlice[12] = aCoord[1]*(1.0 - aCoord[0]*aCoord[0]);
+      aSlice[14] = aCoord[2]*(1.0 - aCoord[0]*aCoord[0]);
+      aSlice[13] = (1.0 - aCoord[1] - aCoord[2])*(1.0 - aCoord[0]*aCoord[0]);
+
+      aSlice[11] = 2.0*aCoord[1]*aCoord[2]*(1.0 + aCoord[0]);
+      aSlice[10] = 2.0*aCoord[2]*(1.0 - aCoord[1] - aCoord[2])*(1.0 + aCoord[0]);
+      aSlice[9]  = 2.0*aCoord[1]*(1.0 - aCoord[1] - aCoord[2])*(1.0 + aCoord[0]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TPyra5a::TPyra5a():
+    TShapeFun(3,5)
+  {
+    TInt aNbRef = myRefCoord.size();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      case  1: 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;
+      case  3: aCoord[0] =  0.0;  aCoord[1] = -1.0;  aCoord[2] =  0.0; break;
+      case  4: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      }
+    }
+  }
+
+  void
+  TPyra5a::InitFun(const TCCoordSliceArr& theRef,
+                   const TCCoordSliceArr& theGauss,
+                   TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+      // APO & RNV:
+      // Fix for 0019920: EDF 788 VISU: Bad localisation of gauss points for pyramids
+      // Seems shape function for ePYRA5 elements is:
+      // w0 = 0.25*(-X + Y - 1.0)*(-X - Y - 1.0)*(1.0 - Z);
+      // w1 = 0.25*(-X - Y - 1.0)*(+X - Y - 1.0)*(1.0 - Z);
+      // w2 = 0.25*(+X + Y - 1.0)*(+X - Y - 1.0)*(1.0 - Z);
+      // w3 = 0.25*(+X + Y - 1.0)*(-X + Y - 1.0)*(1.0 - Z);
+      // w4 = +Z;
+      aSlice[0] = 0.25*(-aCoord[0] + aCoord[1] - 1.0)*(-aCoord[0] - aCoord[1] - 1.0)*(1.0 - aCoord[2]);
+      aSlice[1] = 0.25*(-aCoord[0] - aCoord[1] - 1.0)*(+aCoord[0] - aCoord[1] - 1.0)*(1.0 - aCoord[2]);
+      aSlice[2] = 0.25*(+aCoord[0] + aCoord[1] - 1.0)*(+aCoord[0] - aCoord[1] - 1.0)*(1.0 - aCoord[2]);
+      aSlice[3] = 0.25*(+aCoord[0] + aCoord[1] - 1.0)*(-aCoord[0] + aCoord[1] - 1.0)*(1.0 - aCoord[2]);
+      aSlice[4] = aCoord[2];
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TPyra5b::TPyra5b():
+    TShapeFun(3,5)
+  {
+    TInt aNbRef = myRefCoord.size();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(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;
+      case  1: aCoord[0] =  0.0;  aCoord[1] = -1.0;  aCoord[2] =  0.0; break;
+      case  4: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+      }
+    }
+  }
+
+  void
+  TPyra5b::InitFun(const TCCoordSliceArr& theRef,
+                   const TCCoordSliceArr& theGauss,
+                   TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+    
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+      // APO & RNV:
+      // Fix for 0019920: EDF 788 VISU: Bad localisation of gauss points for pyramids
+      // Seems shape function for ePYRA5 elements is:
+      // w0 = 0.25*(-X + Y - 1.0)*(-X - Y - 1.0)*(1.0 - Z);
+      // w1 = 0.25*(-X - Y - 1.0)*(+X - Y - 1.0)*(1.0 - Z);
+      // w2 = 0.25*(+X + Y - 1.0)*(+X - Y - 1.0)*(1.0 - Z);
+      // w3 = 0.25*(+X + Y - 1.0)*(-X + Y - 1.0)*(1.0 - Z);
+      // w4 = +Z;
+      aSlice[0] = 0.25*(-aCoord[0] + aCoord[1] - 1.0)*(-aCoord[0] - aCoord[1] - 1.0)*(1.0 - aCoord[2]);
+      aSlice[3] = 0.25*(-aCoord[0] - aCoord[1] - 1.0)*(+aCoord[0] - aCoord[1] - 1.0)*(1.0 - aCoord[2]);
+      aSlice[2] = 0.25*(+aCoord[0] + aCoord[1] - 1.0)*(+aCoord[0] - aCoord[1] - 1.0)*(1.0 - aCoord[2]);
+      aSlice[1] = 0.25*(+aCoord[0] + aCoord[1] - 1.0)*(-aCoord[0] + aCoord[1] - 1.0)*(1.0 - aCoord[2]);
+      aSlice[4] = aCoord[2];
+    }
+  }
+  
+
+
+  //---------------------------------------------------------------
+  TPyra13a::TPyra13a():
+    TShapeFun(3,13)
+  {
+    TInt aNbRef = myRefCoord.size();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(aRefId);
+      switch(aRefId){
+      case  0: aCoord[0] =  1.0;  aCoord[1] =  0.0;  aCoord[2] =  0.0; break;
+      case  1: 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;
+      case  3: aCoord[0] =  0.0;  aCoord[1] = -1.0;  aCoord[2] =  0.0; break;
+      case  4: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+
+      case  5: aCoord[0] =  0.5;  aCoord[1] =  0.5;  aCoord[2] =  0.0; break;
+      case  6: aCoord[0] = -0.5;  aCoord[1] =  0.5;  aCoord[2] =  0.0; break;
+      case  7: aCoord[0] = -0.5;  aCoord[1] = -0.5;  aCoord[2] =  0.0; break;
+      case  8: aCoord[0] =  0.5;  aCoord[1] = -0.5;  aCoord[2] =  0.0; break;
+      case  9: aCoord[0] =  0.5;  aCoord[1] =  0.0;  aCoord[2] =  0.5; break;
+      case 10: aCoord[0] =  0.0;  aCoord[1] =  0.5;  aCoord[2] =  0.5; break;
+      case 11: aCoord[0] = -0.5;  aCoord[1] =  0.0;  aCoord[2] =  0.5; break;
+      case 12: aCoord[0] =  0.0;  aCoord[1] = -0.5;  aCoord[2] =  0.5; break;
+      }
+    }
+  }
+
+  void
+  TPyra13a::InitFun(const TCCoordSliceArr& theRef,
+                    const TCCoordSliceArr& theGauss,
+                    TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.5*(-aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*(-aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*
+        (aCoord[0] - 0.5)/(1.0 - aCoord[2]);
+      aSlice[1] = 0.5*(-aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*(+aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*
+        (aCoord[1] - 0.5)/(1.0 - aCoord[2]);
+      aSlice[2] = 0.5*(+aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*(+aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*
+        (-aCoord[0] - 0.5)/(1.0 - aCoord[2]);
+      aSlice[3] = 0.5*(+aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*(-aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*
+        (-aCoord[1] - 0.5)/(1.0 - aCoord[2]);
+
+      aSlice[4] = 2.0*aCoord[2]*(aCoord[2] - 0.5);
+
+      aSlice[5] = 0.5*(-aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*(-aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*
+        (aCoord[0] - aCoord[1] + aCoord[2] - 1.0)/(1.0 - aCoord[2]);
+      aSlice[6] = 0.5*(-aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*(aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*
+        (aCoord[0] + aCoord[1] + aCoord[2] - 1.0)/(1.0 - aCoord[2]);
+      aSlice[7] = 0.5*(aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*(aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*
+        (-aCoord[0] + aCoord[1] + aCoord[2] - 1.0)/(1.0 - aCoord[2]);
+      aSlice[8] = 0.5*(aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*(-aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*
+        (-aCoord[0] - aCoord[1] + aCoord[2] - 1.0)/(1.0 - aCoord[2]);
+
+      aSlice[9] = 0.5*aCoord[2]*(-aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*(-aCoord[0] - aCoord[1] + aCoord[2] - 1.0)/
+        (1.0 - aCoord[2]);
+      aSlice[10] = 0.5*aCoord[2]*(-aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*(aCoord[0] - aCoord[1] + aCoord[2] - 1.0)/
+        (1.0 - aCoord[2]);
+      aSlice[11] = 0.5*aCoord[2]*(aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*(aCoord[0] + aCoord[1] + aCoord[2] - 1.0)/
+        (1.0 - aCoord[2]);
+      aSlice[12] = 0.5*aCoord[2]*(aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*(-aCoord[0] + aCoord[1] + aCoord[2] - 1.0)/
+        (1.0 - aCoord[2]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  TPyra13b::TPyra13b():
+    TShapeFun(3,13)
+  {
+    TInt aNbRef = myRefCoord.size();
+    for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+      TCoordSlice aCoord = GetCoord(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;
+      case  1: aCoord[0] =  0.0;  aCoord[1] = -1.0;  aCoord[2] =  0.0; break;
+      case  4: aCoord[0] =  0.0;  aCoord[1] =  0.0;  aCoord[2] =  1.0; break;
+
+      case  8: aCoord[0] =  0.5;  aCoord[1] =  0.5;  aCoord[2] =  0.0; break;
+      case  7: aCoord[0] = -0.5;  aCoord[1] =  0.5;  aCoord[2] =  0.0; break;
+      case  6: aCoord[0] = -0.5;  aCoord[1] = -0.5;  aCoord[2] =  0.0; break;
+      case  5: aCoord[0] =  0.5;  aCoord[1] = -0.5;  aCoord[2] =  0.0; break;
+      case  9: aCoord[0] =  0.5;  aCoord[1] =  0.0;  aCoord[2] =  0.5; break;
+      case 12: aCoord[0] =  0.0;  aCoord[1] =  0.5;  aCoord[2] =  0.5; break;
+      case 11: aCoord[0] = -0.5;  aCoord[1] =  0.0;  aCoord[2] =  0.5; break;
+      case 10: aCoord[0] =  0.0;  aCoord[1] = -0.5;  aCoord[2] =  0.5; break;
+      }
+    }
+  }
+
+  void
+  TPyra13b::InitFun(const TCCoordSliceArr& theRef,
+                    const TCCoordSliceArr& theGauss,
+                    TFun& theFun) const
+  {
+    GetFun(theRef,theGauss,theFun);
+
+    TInt aNbGauss = theGauss.size();
+    for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+      const TCCoordSlice& aCoord = theGauss[aGaussId];
+      TFloatVecSlice aSlice = theFun.GetFunSlice(aGaussId);
+
+      aSlice[0] = 0.5*(-aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*(-aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*
+        (aCoord[0] - 0.5)/(1.0 - aCoord[2]);
+      aSlice[3] = 0.5*(-aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*(+aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*
+        (aCoord[1] - 0.5)/(1.0 - aCoord[2]);
+      aSlice[2] = 0.5*(+aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*(+aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*
+        (-aCoord[0] - 0.5)/(1.0 - aCoord[2]);
+      aSlice[1] = 0.5*(+aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*(-aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*
+        (-aCoord[1] - 0.5)/(1.0 - aCoord[2]);
+
+      aSlice[4] = 2.0*aCoord[2]*(aCoord[2] - 0.5);
+
+      aSlice[8] = 0.5*(-aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*(-aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*
+        (aCoord[0] - aCoord[1] + aCoord[2] - 1.0)/(1.0 - aCoord[2]);
+      aSlice[7] = 0.5*(-aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*(aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*
+        (aCoord[0] + aCoord[1] + aCoord[2] - 1.0)/(1.0 - aCoord[2]);
+      aSlice[6] = 0.5*(aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*(aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*
+        (-aCoord[0] + aCoord[1] + aCoord[2] - 1.0)/(1.0 - aCoord[2]);
+      aSlice[5] = 0.5*(aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*(-aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*
+        (-aCoord[0] - aCoord[1] + aCoord[2] - 1.0)/(1.0 - aCoord[2]);
+
+      aSlice[9] = 0.5*aCoord[2]*(-aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*(-aCoord[0] - aCoord[1] + aCoord[2] - 1.0)/
+        (1.0 - aCoord[2]);
+      aSlice[12] = 0.5*aCoord[2]*(-aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*(aCoord[0] - aCoord[1] + aCoord[2] - 1.0)/
+        (1.0 - aCoord[2]);
+      aSlice[11] = 0.5*aCoord[2]*(aCoord[0] - aCoord[1] + aCoord[2] - 1.0)*(aCoord[0] + aCoord[1] + aCoord[2] - 1.0)/
+        (1.0 - aCoord[2]);
+      aSlice[10] = 0.5*aCoord[2]*(aCoord[0] + aCoord[1] + aCoord[2] - 1.0)*(-aCoord[0] + aCoord[1] + aCoord[2] - 1.0)/
+        (1.0 - aCoord[2]);
+    }
+  }
+
+
+
+  //---------------------------------------------------------------
+  bool
+  GetGaussCoord3D(const TGaussInfo& theGaussInfo, 
+                  const TCellInfo& theCellInfo,
+                  const TNodeInfo& theNodeInfo,
+                  TGaussCoord& theGaussCoord,
+                  const TElemNum& theElemNum,
+                  EModeSwitch theMode)
+  {
+    INITMSG(MYDEBUG,"GetGaussCoord3D\n");
+
+    if(theGaussInfo.myGeom == theCellInfo.myGeom){
+      EGeometrieElement aGeom = theGaussInfo.myGeom;
+
+      TInt aNbRef = theGaussInfo.GetNbRef();
+      TCCoordSliceArr aRefSlice(aNbRef);
+      for(TInt anId = 0; anId < aNbRef; anId++)
+        aRefSlice[anId] = theGaussInfo.GetRefCoordSlice(anId);
+
+      TInt aNbGauss = theGaussInfo.GetNbGauss();
+      TCCoordSliceArr aGaussSlice(aNbGauss);
+      for(TInt anId = 0; anId < aNbGauss; anId++)
+        aGaussSlice[anId] = theGaussInfo.GetGaussCoordSlice(anId);
+
+      switch(aGeom){
+      case eSEG2: {
+        INITMSG(MYDEBUG,"eSEG2"<<std::endl);
+
+        if(TSeg2a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        break;
+      }
+      case eSEG3: {
+        INITMSG(MYDEBUG,"eSEG3"<<std::endl);
+
+        if(TSeg3a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        break;
+      }
+      case eTRIA3: {
+        INITMSG(MYDEBUG,"eTRIA3"<<std::endl);
+
+        if(TTria3a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        if(TTria3b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        break;
+      }
+      case eTRIA6: {
+        INITMSG(MYDEBUG,"eTRIA6"<<std::endl);
+
+        if(TTria6a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        if(TTria6b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        break;
+      }
+      case eQUAD4: {
+        INITMSG(MYDEBUG,"eQUAD4"<<std::endl);
+
+        if(TQuad4a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        if(TQuad4b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        break;
+      }
+      case eQUAD8: {
+        INITMSG(MYDEBUG,"eQUAD8"<<std::endl);
+
+        if(TQuad8a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        if(TQuad8b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        break;
+      }
+      case eQUAD9: {
+        INITMSG(MYDEBUG,"eQUAD9"<<std::endl);
+
+        if(TQuad9a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        if(TQuad9b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        break;
+      }
+      case eTETRA4: {
+        INITMSG(MYDEBUG,"eTETRA4"<<std::endl);
+
+        if(TTetra4a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        if(TTetra4b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        break;
+      }
+      case ePYRA5: {
+        INITMSG(MYDEBUG,"ePYRA5"<<std::endl);
+
+        if(TPyra5a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        if(TPyra5b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        break;
+      }
+      case ePENTA6: {
+        INITMSG(MYDEBUG,"ePENTA6"<<std::endl);
+
+        if(TPenta6a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        if(TPenta6b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        break;
+      }
+      case eHEXA8: {
+        INITMSG(MYDEBUG,"eHEXA8"<<std::endl);
+
+        if(THexa8a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        if(THexa8b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        break;
+      }
+      case eTETRA10: {
+        INITMSG(MYDEBUG,"eTETRA10"<<std::endl);
+
+        if(TTetra10a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        if(TTetra10b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        break;
+      }
+      case ePYRA13: {
+        INITMSG(MYDEBUG,"ePYRA13"<<std::endl);
+
+        if(TPyra13a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        if(TPyra13b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        break;
+      }
+      case ePENTA15: {
+        INITMSG(MYDEBUG,"ePENTA15"<<std::endl);
+
+        if(TPenta15a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        if(TPenta15b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        break;
+      }
+      case eHEXA20: {
+        INITMSG(MYDEBUG,"eHEXA20"<<std::endl);
+
+        if(THexa20a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        if(THexa20b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
+          return true;
+
+        break;
+      }
+      default: 
+        INITMSG(MYDEBUG,"eNONE"<<std::endl);
+        return false;
+      }
+    }
+
+    return false;
+  }
+
+  //---------------------------------------------------------------
+  bool
+  GetBaryCenter(const TCellInfo& theCellInfo,
+                const TNodeInfo& theNodeInfo,
+                TGaussCoord& theGaussCoord,
+                const TElemNum& theElemNum,
+                EModeSwitch theMode)
+  {
+    INITMSG(MYDEBUG,"GetBaryCenter\n");
+    const PMeshInfo& aMeshInfo = theCellInfo.GetMeshInfo();
+    TInt aDim = aMeshInfo->GetDim();
+    static TInt aNbGauss = 1;
+
+    bool anIsSubMesh = !theElemNum.empty();
+    TInt aNbElem;
+    if(anIsSubMesh)
+      aNbElem = theElemNum.size();
+    else
+      aNbElem = theCellInfo.GetNbElem();
+
+    theGaussCoord.Init(aNbElem,aNbGauss,aDim,theMode);
+
+    TInt aConnDim = theCellInfo.GetConnDim();
+
+    INITMSGA(MYDEBUG,0,
+             "- aDim = "<<aDim<<
+             "; aNbGauss = "<<aNbGauss<<
+             "; aNbElem = "<<aNbElem<<
+             "; aNbNodes = "<<theNodeInfo.GetNbElem()<<
+             std::endl);
+
+    for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
+      TInt aCellId = anIsSubMesh? theElemNum[anElemId]-1: anElemId;
+      TCConnSlice aConnSlice = theCellInfo.GetConnSlice(aCellId);
+      TCoordSliceArr aCoordSliceArr = theGaussCoord.GetCoordSliceArr(anElemId);
+
+      for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+        TCoordSlice& aGaussCoordSlice = aCoordSliceArr[aGaussId];
+
+        for(TInt aConnId = 0; aConnId < aConnDim; aConnId++){
+          TInt aNodeId = aConnSlice[aConnId] - 1;      
+          TCCoordSlice aNodeCoordSlice = theNodeInfo.GetCoordSlice(aNodeId);
+
+          for(TInt aDimId = 0; aDimId < aDim; aDimId++){
+            aGaussCoordSlice[aDimId] += aNodeCoordSlice[aDimId];
+          }
+        }
+
+        for(TInt aDimId = 0; aDimId < aDim; aDimId++){
+          aGaussCoordSlice[aDimId] /= aConnDim;
+        }
+      }
+    }
+
+#ifdef _DEBUG_
+    for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
+      TCoordSliceArr aCoordSliceArr = theGaussCoord.GetCoordSliceArr(anElemId);
+      INITMSG(MYVALUEDEBUG,"");
+      for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+        TCoordSlice& aCoordSlice = aCoordSliceArr[aGaussId];
+        ADDMSG(MYVALUEDEBUG,"{");
+        for(TInt aDimId = 0; aDimId < aDim; aDimId++){
+          ADDMSG(MYVALUEDEBUG,aCoordSlice[aDimId]<<" ");
+        }
+        ADDMSG(MYVALUEDEBUG,"} ");
+      }
+      ADDMSG(MYVALUEDEBUG,std::endl);
+    }
+#endif
+
+    return true;
+  }
+
+
+  //---------------------------------------------------------------
+  bool
+  GetBaryCenter(const TPolygoneInfo& thePolygoneInfo,
+                const TNodeInfo& theNodeInfo,
+                TGaussCoord& theGaussCoord,
+                const TElemNum& theElemNum,
+                EModeSwitch theMode)
+  {
+    INITMSG(MYDEBUG,"GetBaryCenter\n");
+    const PMeshInfo& aMeshInfo = thePolygoneInfo.GetMeshInfo();
+    TInt aDim = aMeshInfo->GetDim();
+    static TInt aNbGauss = 1;
+
+    bool anIsSubMesh = !theElemNum.empty();
+    TInt aNbElem;
+    if(anIsSubMesh)
+      aNbElem = theElemNum.size();
+    else
+      aNbElem = thePolygoneInfo.GetNbElem();
+
+    theGaussCoord.Init(aNbElem,aNbGauss,aDim,theMode);
+
+    INITMSGA(MYDEBUG,0,
+             "- aDim = "<<aDim<<
+             "; aNbGauss = "<<aNbGauss<<
+             "; aNbElem = "<<aNbElem<<
+             "; aNbNodes = "<<theNodeInfo.GetNbElem()<<
+             std::endl);
+
+    for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
+      TInt aCellId = anIsSubMesh? theElemNum[anElemId]-1: anElemId;
+
+      TCoordSliceArr aCoordSliceArr = theGaussCoord.GetCoordSliceArr(anElemId);
+      TCConnSlice aConnSlice = thePolygoneInfo.GetConnSlice(aCellId);
+      TInt aNbConn = thePolygoneInfo.GetNbConn(aCellId);
+      TInt aNbNodes = thePolygoneInfo.GetNbConn(aCellId);
+
+      for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+        TCoordSlice& aGaussCoordSlice = aCoordSliceArr[aGaussId];
+
+        for(TInt aConnId = 0; aConnId < aNbConn; aConnId++){
+          TInt aNodeId = aConnSlice[aConnId] - 1;      
+          TCCoordSlice aNodeCoordSlice = theNodeInfo.GetCoordSlice(aNodeId);
+
+          for(TInt aDimId = 0; aDimId < aDim; aDimId++){
+            aGaussCoordSlice[aDimId] += aNodeCoordSlice[aDimId];
+          }
+        }
+
+        for(TInt aDimId = 0; aDimId < aDim; aDimId++){
+          aGaussCoordSlice[aDimId] /= aNbNodes;
+        }
+      }
+    }
+
+    return true;
+  }
+
+
+  //---------------------------------------------------------------
+  bool
+  GetBaryCenter(const TPolyedreInfo& thePolyedreInfo,
+                const TNodeInfo& theNodeInfo,
+                TGaussCoord& theGaussCoord,
+                const TElemNum& theElemNum,
+                EModeSwitch theMode)
+  {
+    INITMSG(MYDEBUG,"GetBaryCenter\n");
+    const PMeshInfo& aMeshInfo = thePolyedreInfo.GetMeshInfo();
+    TInt aDim = aMeshInfo->GetDim();
+    static TInt aNbGauss = 1;
+
+    bool anIsSubMesh = !theElemNum.empty();
+    TInt aNbElem;
+    if(anIsSubMesh)
+      aNbElem = theElemNum.size();
+    else
+      aNbElem = thePolyedreInfo.GetNbElem();
+
+    theGaussCoord.Init(aNbElem,aNbGauss,aDim,theMode);
+
+    INITMSGA(MYDEBUG,0,
+             "- aDim = "<<aDim<<
+             "; aNbGauss = "<<aNbGauss<<
+             "; aNbElem = "<<aNbElem<<
+             "; aNbNodes = "<<theNodeInfo.GetNbElem()<<
+             std::endl);
+
+    for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
+      TInt aCellId = anIsSubMesh? theElemNum[anElemId]-1: anElemId;
+
+      TCoordSliceArr aCoordSliceArr = theGaussCoord.GetCoordSliceArr(anElemId);
+      TCConnSliceArr aConnSliceArr = thePolyedreInfo.GetConnSliceArr(aCellId);
+      TInt aNbFaces = aConnSliceArr.size();
+
+      TInt aNbNodes = thePolyedreInfo.GetNbNodes(aCellId);
+
+      for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+        TCoordSlice& aGaussCoordSlice = aCoordSliceArr[aGaussId];
+
+        for(TInt aFaceId = 0; aFaceId < aNbFaces; aFaceId++){
+          TCConnSlice aConnSlice = aConnSliceArr[aFaceId];
+          TInt aNbConn = aConnSlice.size();
+          for(TInt aConnId = 0; aConnId < aNbConn; aConnId++){
+            TInt aNodeId = aConnSlice[aConnId] - 1;      
+            TCCoordSlice aNodeCoordSlice = theNodeInfo.GetCoordSlice(aNodeId);
+
+            for(TInt aDimId = 0; aDimId < aDim; aDimId++){
+              aGaussCoordSlice[aDimId] += aNodeCoordSlice[aDimId];
+            }
+          }
+        }
+        for(TInt aDimId = 0; aDimId < aDim; aDimId++){
+          aGaussCoordSlice[aDimId] /= aNbNodes;
+        }
+      }
+    }
+
+    return true;
+  }
+}
diff --git a/src/MEDWrapper/Base/MED_GaussUtils.hxx b/src/MEDWrapper/Base/MED_GaussUtils.hxx
new file mode 100644 (file)
index 0000000..ffea1a8
--- /dev/null
@@ -0,0 +1,366 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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_GaussUtils_HeaderFile
+#define MED_GaussUtils_HeaderFile
+
+#include "MED_WrapperBase.hxx"
+
+#include "MED_Structures.hxx"
+
+namespace MED
+{
+  //---------------------------------------------------------------
+  typedef TVector<TCCoordSlice> TCCoordSliceArr;
+  typedef TVector<TCoordSlice> TCoordSliceArr;
+
+  //! Define a helper class to handle Gauss Points coordinates
+  class MEDWRAPPER_EXPORT TGaussCoord:
+    virtual TModeSwitchInfo 
+  {
+    TInt myNbElem;
+    TInt myNbGauss;
+    TInt myDim;
+
+    TInt myGaussStep;
+
+    TNodeCoord myGaussCoord;
+
+  public:
+    
+    TGaussCoord();
+
+    //! To init the class
+    void
+    Init(TInt theNbElem,
+         TInt theNbGauss,
+         TInt theDim,
+         EModeSwitch theMode = eFULL_INTERLACE);
+
+    TInt
+    GetNbElem() const;
+
+    TInt
+    GetNbGauss() const;
+
+    TInt
+    GetDim() const;
+
+    unsigned char*
+    GetValuePtr();
+
+    //! Get slice of the coordinate that corresponds to defined cell (const version)
+    TCCoordSliceArr
+    GetCoordSliceArr(TInt theElemId) const;
+
+    //! Get slice of the coordinate that corresponds to defined cell
+    TCoordSliceArr 
+    GetCoordSliceArr(TInt theElemId);
+  };
+  typedef SharedPtr<TGaussCoord> PGaussCoord;
+
+
+  //---------------------------------------------------------------
+  //! To calculate Gauss Points coordinates
+  MEDWRAPPER_EXPORT 
+  bool
+  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 
+  bool
+  GetBaryCenter(const TCellInfo& theCellInfo,
+                const TNodeInfo& theNodeInfo,
+                TGaussCoord& theGaussCoord,
+                const TElemNum& theElemNum = TElemNum(),
+                EModeSwitch theMode = eFULL_INTERLACE);
+
+  //! To calculate Gauss Points coordinates for defined TPolygoneInfo as its bary center
+  MEDWRAPPER_EXPORT 
+  bool
+  GetBaryCenter(const TPolygoneInfo& thePolygoneInfo,
+                const TNodeInfo& theNodeInfo,
+                TGaussCoord& theGaussCoord,
+                const TElemNum& theElemNum = TElemNum(),
+                EModeSwitch theMode = eFULL_INTERLACE);
+
+  //! To calculate Gauss Points coordinates for defined TPolyedreInfo as its bary center
+  MEDWRAPPER_EXPORT 
+  bool
+  GetBaryCenter(const TPolyedreInfo& thePolyedreInfo,
+                const TNodeInfo& theNodeInfo,
+                TGaussCoord& theGaussCoord,
+                const TElemNum& theElemNum = TElemNum(),
+                EModeSwitch theMode = eFULL_INTERLACE);
+
+  //---------------------------------------------------------------
+  //! Shape function definitions
+  //---------------------------------------------------------------
+  struct MEDWRAPPER_EXPORT TShapeFun
+  {
+    class TFun;
+    
+    TFloatVector myRefCoord;
+    TInt myDim;
+    TInt myNbRef;
+
+    TShapeFun(TInt theDim = 0, TInt theNbRef = 0);
+
+    TInt GetNbRef() const { return myNbRef; }
+
+    TCCoordSlice GetCoord(TInt theRefId) const;
+
+    TCoordSlice GetCoord(TInt theRefId);
+
+    void GetFun(const TCCoordSliceArr& theRef,
+                const TCCoordSliceArr& theGauss,
+                TFun& theFun) const;
+    virtual 
+    void InitFun(const TCCoordSliceArr& theRef,
+                 const TCCoordSliceArr& theGauss,
+                 TFun& theFun) const = 0;
+    virtual
+    bool IsSatisfy(const TCCoordSliceArr& theRefCoord) const;
+
+    bool Eval(const TCellInfo&       theCellInfo,
+              const TNodeInfo&       theNodeInfo,
+              const TElemNum&        theElemNum,
+              const TCCoordSliceArr& theRef,
+              const TCCoordSliceArr& theGauss,
+              TGaussCoord&           theGaussCoord,
+              EModeSwitch            theMode);
+  };
+  //---------------------------------------------------------------
+  struct TSeg2a: TShapeFun {
+    TSeg2a();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TSeg3a: TShapeFun {
+    TSeg3a();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TTria3a: TShapeFun {
+    TTria3a();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TTria6a: TShapeFun {
+    TTria6a();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TTria3b: TShapeFun {
+    TTria3b();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TTria6b: TShapeFun {
+    TTria6b();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TQuad4a: TShapeFun {
+    TQuad4a();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TQuad8a: TShapeFun {
+    TQuad8a();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TQuad9a: TShapeFun {
+    TQuad9a();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TQuad4b: TShapeFun {
+    TQuad4b();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TQuad8b: TShapeFun {
+    TQuad8b();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TQuad9b: TShapeFun {
+    TQuad9b();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TTetra4a: TShapeFun {
+    TTetra4a();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TTetra10a: TShapeFun {
+    TTetra10a();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TTetra4b: TShapeFun {
+    TTetra4b();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TTetra10b: TShapeFun {
+    TTetra10b();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct THexa8a: TShapeFun {
+    THexa8a();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct THexa20a: TShapeFun {
+    THexa20a(TInt theDim = 3, TInt theNbRef = 20);
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct THexa27a: THexa20a {
+    THexa27a();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct THexa8b: TShapeFun {
+    THexa8b();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct THexa20b: TShapeFun {
+    THexa20b(TInt theDim = 3, TInt theNbRef = 20);
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TPenta6a: TShapeFun {
+    TPenta6a();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TPenta6b: TShapeFun {
+    TPenta6b();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TPenta15a: TShapeFun {
+    TPenta15a();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TPenta15b: TShapeFun {
+    TPenta15b();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TPyra5a: TShapeFun {
+    TPyra5a();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TPyra5b: TShapeFun {
+    TPyra5b();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TPyra13a: TShapeFun {
+    TPyra13a();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+  struct TPyra13b: TShapeFun {
+    TPyra13b();
+    virtual void InitFun(const TCCoordSliceArr& theRef,
+                         const TCCoordSliceArr& theGauss,
+                         TFun& theFun) const;
+  };
+  //---------------------------------------------------------------
+
+}
+
+#endif
diff --git a/src/MEDWrapper/Base/MED_SharedPtr.hxx b/src/MEDWrapper/Base/MED_SharedPtr.hxx
new file mode 100644 (file)
index 0000000..d0f4746
--- /dev/null
@@ -0,0 +1,96 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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_SharedPtr_HeaderFile
+#define MED_SharedPtr_HeaderFile
+
+#include <boost/shared_ptr.hpp>
+
+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 
+    for all of the MEDWrapper objects.
+  */
+  template<class T> class SharedPtr: public boost::shared_ptr<T>
+  {
+  public:
+    //! Default constructor
+    SharedPtr() {}
+
+    //! Construct the class by any type of a pointer
+    template<class Y>
+    explicit SharedPtr(Y * p): 
+      boost::shared_ptr<T>(p) 
+    {}
+
+    //! Construct the class by any specialisation of the class
+    template<class Y>
+    SharedPtr(SharedPtr<Y> const & r):
+      boost::shared_ptr<T>(r,boost::detail::dynamic_cast_tag())
+    {}
+
+    //! Copy-constructor
+    template<class Y>
+    SharedPtr& 
+    operator=(SharedPtr<Y> const & r)
+    {
+      boost::shared_ptr<T>(r,boost::detail::dynamic_cast_tag()).swap(*this);
+      return *this;
+    }
+
+    //! Introduce a flexible way to reset the wrapped pointer
+    template<class Y> 
+    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> 
+    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 
+    { 
+      return *(this->get());
+    }
+
+    //! To provide a flexible way to use reference to the wrapped pointer
+    operator T& () 
+    { 
+      return *(this->get());
+    }
+  };
+
+}
+
+
+#endif
diff --git a/src/MEDWrapper/Base/MED_SliceArray.hxx b/src/MEDWrapper/Base/MED_SliceArray.hxx
new file mode 100644 (file)
index 0000000..c41951c
--- /dev/null
@@ -0,0 +1,186 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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_SliceArray_HeaderFile
+#define MED_SliceArray_HeaderFile
+
+#ifdef WIN32 // for correctly compiling "valarray" in modules, which are includes this file
+  #undef max
+  #undef min
+#endif
+
+#include <valarray>
+#include <stdexcept>
+
+//#if defined(_DEBUG_)
+#  define MED_TCSLICE_CHECK_RANGE
+//#endif
+
+namespace MED
+{
+  //---------------------------------------------------------------
+  //! This class intends to provide an uniform way to handle multy-dimention data (const version)
+  /*! 
+    It just contains pointer to real sequence and implement proper calcultion of its indexes.
+    This class deal with constant pointer to the sources data and provide const method to
+    read the them (data).
+   */
+  template<class TValueType> 
+  class TCSlice
+  {
+    const TValueType* myCValuePtr; //!< Reference to source multy-dimension data
+    size_t mySourceSize; //!< Size of the source multy-dimension data
+    std::slice mySlice; //!< Defines algorithm of index calculation
+
+  protected:
+    void
+    check_id(size_t theId) const
+    {
+      long int anId = -1;
+      if(theId < mySlice.size()){
+        anId = mySlice.start() + theId*mySlice.stride();
+        if(anId < (long int)mySourceSize)
+          return;
+      }
+      throw std::out_of_range("TCSlice::check_id");
+    }
+
+    //! Calculate internal index to get proper element from the source multy-dimension data
+    size_t
+    calculate_id(size_t theId) const
+    {
+      return mySlice.start() + theId*mySlice.stride();
+    }
+    
+    size_t
+    get_id(size_t theId) const
+    {
+#ifdef MED_TCSLICE_CHECK_RANGE
+      check_id(theId);
+#endif
+      return calculate_id(theId);
+    }
+    
+    size_t
+    get_id_at(size_t theId) const
+    {
+      check_id(theId);
+      return calculate_id(theId);
+    }
+
+  public:
+    typedef TValueType value_type;
+
+    //! Construct the class from bare pointer
+    TCSlice(const value_type* theValuePtr,
+            size_t theSourceSize,
+            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): 
+      myCValuePtr(&theContainer[0]),
+      mySourceSize(theContainer.size()),
+      mySlice(theSlice)
+    {}
+    
+    //! Default constructor (dangerous)
+    TCSlice():
+      myCValuePtr(NULL)
+    {}
+
+    //! Get element by its number (const version)
+    const value_type& 
+    operator[](size_t theId) const
+    {
+      return *(myCValuePtr + get_id(theId));
+    }
+    
+    const value_type& 
+    at(size_t theId) const
+    {
+      return *(myCValuePtr + get_id_at(theId));
+    }
+    
+    //! Get range of the order numbers
+    size_t
+    size() const
+    {
+      return mySlice.size();
+    }
+  };
+  
+
+  //---------------------------------------------------------------
+  //! This class extend TCSlice functionality for non-constant case
+  template<class TValueType> 
+  class TSlice: public TCSlice<TValueType>
+  {
+    TValueType* myValuePtr;
+    
+  public:
+    typedef TValueType value_type;
+    typedef TCSlice<TValueType> TSupperClass;
+
+    //! Construct the class from bare pointer
+    TSlice(value_type* theValuePtr,
+           size_t theSourceSize,
+           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): 
+      TSupperClass(theContainer, theSlice),
+      myValuePtr(&theContainer[0])
+    {}
+    
+    //! Default constructor (dangerous)
+    TSlice():
+      myValuePtr(NULL)
+    {}
+
+    //! Get element by its number
+    value_type& 
+    operator[](size_t theId)
+    {
+      return *(myValuePtr + this->get_id(theId));
+    }
+
+    value_type& 
+    at(size_t theId)
+    {
+      return *(myValuePtr + this->get_id_at(theId));
+    }
+  };
+
+}
+
+#undef MED_TCSLICE_CHECK_RANGE
+
+#endif
diff --git a/src/MEDWrapper/Base/MED_Structures.cxx b/src/MEDWrapper/Base/MED_Structures.cxx
new file mode 100644 (file)
index 0000000..e9059ad
--- /dev/null
@@ -0,0 +1,865 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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;
+}
diff --git a/src/MEDWrapper/Base/MED_Structures.hxx b/src/MEDWrapper/Base/MED_Structures.hxx
new file mode 100644 (file)
index 0000000..bcd361a
--- /dev/null
@@ -0,0 +1,1081 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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_Structures_HeaderFile
+#define MED_Structures_HeaderFile
+
+#include "MED_Common.hxx"
+#include "MED_Utilities.hxx"
+
+#ifdef WIN32
+#pragma warning(disable:4251)
+#endif
+
+namespace MED
+{
+
+  //---------------------------------------------------------------
+  //! Defines a type for managing sequence of strings
+  typedef TVector<char> TString; 
+  typedef SharedPtr<TString> PString;
+
+  //! Extract a substring from the sequence of the strings
+  MEDWRAPPER_EXPORT
+  std::string 
+  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, 
+                 TString& theString, 
+                 const TString& theValue);
+
+  //---------------------------------------------------------------
+  //! Define a parent class for all MEDWrapper classes
+  struct MEDWRAPPER_EXPORT TBase
+  {
+    virtual ~TBase() {} 
+  };
+
+
+  //---------------------------------------------------------------
+  //! Define a parent class for all named MED entities
+  struct MEDWRAPPER_EXPORT TNameInfo: virtual TBase
+  {
+    TString myName; //!< Keeps its name
+    virtual std::string GetName() const = 0; //!< Gets its name
+    virtual void SetName(const std::string& theValue) = 0; //!< Set a new name
+    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 
+    should be interpreted in C or Fortran mode (eFULL_INTERLACE or eNON_INTERLACE).
+  */
+  struct MEDWRAPPER_EXPORT TModeSwitchInfo: virtual TBase
+  {
+    //! To construct instance of the class by default
+    TModeSwitchInfo():
+      myModeSwitch(eFULL_INTERLACE)
+    {}
+
+    //! To construct instance of the class
+    TModeSwitchInfo(EModeSwitch theModeSwitch):
+      myModeSwitch(theModeSwitch)
+    {}
+
+    EModeSwitch myModeSwitch; //!< Keeps the 
+    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 mySpaceDim;
+    TInt GetSpaceDim() const { return mySpaceDim; }
+
+    EMaillage myType; //!< 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;} 
+
+    TInt myId; //!< An unique index 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
+
+    TInt myNbGroup; //!< Defines number MED Groups connected to
+    //! Gets number of MED GROUPS the MED FAMILY is bound to
+    TInt GetNbGroup() const { return myNbGroup;} 
+
+    //! Contains sequence of the names for the MED Groups connected to
+    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 
+    //! Gets number of attached attributes for the MED FAMILY
+    TInt GetNbAttr() const { return myNbAttr;} 
+
+    //! Defines sequence of the indexes of the MED Family attributes
+    TFamAttr myAttrId; 
+    //! Get MED FAMILY attribute by its number
+    TInt GetAttrId(TInt theId) const;
+    //! Set MED FAMILY attribute by its number
+    void SetAttrId(TInt theId, TInt theVal);
+
+    //! Defines sequence of the values of the MED Family attributes
+    TFamAttr myAttrVal;
+    //! Get MED FAMILY attribute by its number
+    TInt GetAttrVal(TInt theId) const;
+    //! Set MED FAMILY attribute by its number
+    void SetAttrVal(TInt theId, TInt theVal);
+
+    //! Defines sequence of the names of the MED Family attributes
+    TString myAttrDesc;
+    //! Get value of the MED FAMILY attribute by its number
+    virtual std::string GetAttrDesc(TInt theId) const = 0;
+    //! Set value of the MED FAMILY attribute by its number
+    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;}
+
+    TInt myNbElem; //<! Number of corresponding mesh entities
+    TInt GetNbElem() const { return myNbElem;} //! Get number of mesh elements
+    
+    //! Defines sequence MED Family indexes for corresponding mesh entites
+    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
+    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;}
+    
+    //! Defines if the mesh elements family are indexed
+    EBooleen myIsFamNum;
+    //! Let know if the mesh elements family are indexed
+    EBooleen IsFamNum() const { return myIsFamNum;}
+    
+
+    //! Contains sequence of the indexes for the mesh elements
+    PElemNum myElemNum;
+    //! Get a reference number of the mesh element by its order number
+    TInt GetElemNum(TInt theId) const;
+    //! Set a reference number for the mesh element by its order number
+    void SetElemNum(TInt theId, TInt theVal);
+
+    //! Defines if the mesh elements are named
+    EBooleen myIsElemNames;
+    //! Let know if the mesh elements havew names
+    EBooleen IsElemNames() const { return myIsElemNames;}
+
+    //! Contains sequence of the names for the mesh elements
+    PString myElemNames;
+    //! Get name of the mesh element by its order number
+    virtual std::string GetElemName(TInt theId) const = 0;
+    //! Set name of the mesh element by its order number
+    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: 
+    virtual TElemInfo,
+    virtual TModeSwitchInfo 
+  {
+    PNodeCoord myCoord; //!< Contains all nodal coordinates
+
+    //! Gives coordinates for mesh node by its number (const version)
+    TCCoordSlice GetCoordSlice(TInt theId) const;
+    //! Gives coordinates for mesh node by its number
+    TCoordSlice GetCoordSlice(TInt theId);
+
+    ERepere mySystem; //!< Defines, which coordinate system is used
+    //! Get which coordinate system is used for the node describing
+    ERepere GetSystem() const { return mySystem;}
+    //! Set coordinate system to be used for the node describing
+    void SetSystem(ERepere theSystem) { mySystem = theSystem;}
+
+    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;
+    //! Set name of the coordinate dimension by its order number
+    virtual void SetCoordName(TInt theId, const std::string& theValue) = 0;
+
+    TString myCoordUnits; //!< Contains units for the coordinate dimensions
+    //! Get name of unit for the coordinate dimension by its order number
+    virtual std::string GetCoordUnit(TInt theId) const = 0;
+    //! Set name of unit for the coordinate dimension by its order number
+    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: 
+    virtual TElemInfo,
+    virtual TModeSwitchInfo 
+  {
+    EEntiteMaillage myEntity; //!< Defines the MED Entity where the mesh cells belongs to
+    //! Let known what MED ENTITY the cells belong to
+    EEntiteMaillage GetEntity() const { return myEntity;}
+
+    EGeometrieElement myGeom; //!< Defines the MED Geometric type of the instance
+    //! Let known what MED geometrical type the cells belong to
+    EGeometrieElement GetGeom() const { return myGeom;}
+
+    EConnectivite myConnMode; //!< Defines connectivity mode
+    //! Let known in what connectivity the cells are writen
+    EConnectivite GetConnMode() const { return myConnMode;}
+
+    virtual TInt GetConnDim() const = 0; //!< Gives step in the connectivity sequence
+
+    PElemNum myConn; //!< Defines sequence which describe connectivity for each of mesh cell
+
+    //! Gives connectivities for mesh cell by its number (const version)
+    TCConnSlice GetConnSlice(TInt theElemId) const;
+    //! Gives connectivities for mesh cell by its number
+    TConnSlice GetConnSlice(TInt theElemId);
+  };
+
+  //---------------------------------------------------------------
+  //! Define a base class which represents MED Polygon entity
+  struct MEDWRAPPER_EXPORT TPolygoneInfo: 
+    virtual TElemInfo
+  {
+    //! Defines the MED Entity where the polygons belongs to
+    EEntiteMaillage myEntity; // MED_FACE|MED_MAILLE
+    //! Let known what MED ENTITY the MED Polygons belong to
+    EEntiteMaillage GetEntity() const { return myEntity;}
+
+    //! Defines the MED Geometric type of the instance
+    EGeometrieElement myGeom; // ePOLYGONE
+    //! Let known what MED geometrical type the MED Polygons belong to
+    EGeometrieElement GetGeom() const { return ePOLYGONE;}
+
+    //! Defines connectivity mode
+    EConnectivite myConnMode; // eNOD|eDESC(eDESC not used)
+    //! Let known in what connectivity the cells are writen
+    EConnectivite GetConnMode() const { return myConnMode;}
+
+    PElemNum myConn; //!< Table de connectivities
+    PElemNum myIndex; //!< Table de indexes
+
+    //! Gives number of the connectivities for the defined polygon
+    TInt GetNbConn(TInt theElemId) const;
+
+    //! Gives connectivities for polygon by its number (const version)
+    TCConnSlice GetConnSlice(TInt theElemId) const;
+    //! Gives connectivities for polygon by its number
+    TConnSlice GetConnSlice(TInt theElemId);
+  };
+
+  //---------------------------------------------------------------
+  //! Define a class representing MED_BALL structure element.
+  //
+  //  This could be a generic class for any structure element
+  //  holding any number of contant and variable attributes
+  //  but it's too hard to implement
+  //
+  struct MEDWRAPPER_EXPORT TBallInfo: 
+    virtual TCellInfo
+  {
+    TFloatVector myDiameters;
+  };
+
+  //---------------------------------------------------------------
+  typedef TVector<TCConnSlice> TCConnSliceArr;
+  typedef TVector<TConnSlice> TConnSliceArr;
+
+  //! Define a base class which represents MED Polyedre entity
+  struct MEDWRAPPER_EXPORT TPolyedreInfo: 
+    virtual TElemInfo
+  {
+    //! Defines the MED Entity where the polyedres belongs to
+    EEntiteMaillage myEntity; // MED_FACE|MED_MAILLE
+    //! Let known what MED ENTITY the MED Polyedres belong to
+    EEntiteMaillage GetEntity() const { return myEntity;}
+
+    //! Defines the MED Geometric type of the instance
+    EGeometrieElement myGeom; // ePOLYEDRE
+    //! Let known what MED geometrical type the MED Polyedres belong to
+    EGeometrieElement GetGeom() const { return ePOLYEDRE;}
+
+    //! Defines connectivity mode
+    EConnectivite myConnMode; // eNOD|eDESC(eDESC not used)
+    //! Let known in what connectivity the cells are writen
+    EConnectivite GetConnMode() const { return myConnMode;}
+
+    PElemNum myConn; //!< Table de connectivities
+    PElemNum myFaces; //!< Table de faces indexes
+    PElemNum myIndex; //!< Table de indexes
+
+    //! Gives number of the faces for the defined polyedre (const version)
+    TInt GetNbFaces(TInt theElemId) const;
+    //! Gives number of the nodes for the defined polyedre
+    TInt GetNbNodes(TInt theElemId) const;
+
+    //! Gives sequence of the face connectivities for polyedre by its number (const version)
+    TCConnSliceArr GetConnSliceArr(TInt theElemId) const;
+    //! Gives sequence of the face connectivities for polyedre by its number
+    TConnSliceArr GetConnSliceArr(TInt theElemId);
+  };
+
+  //---------------------------------------------------------------
+  //! Define a base class which represents MED Field entity
+  struct MEDWRAPPER_EXPORT TFieldInfo: 
+    virtual TNameInfo
+  {
+    PMeshInfo myMeshInfo; //!< A reference to correspondig MED Mesh
+    //! Get a reference to corresponding MED Mesh
+    const PMeshInfo& GetMeshInfo() const { return myMeshInfo;}
+
+    ETypeChamp myType; //!< Defines type of the MED Field
+    //! Let known what type of the MED FIELD is used
+    ETypeChamp GetType() const { return myType;}
+
+    TInt myNbComp; //!< Defines number of components stored in the field
+    //! Get number of components for the MED FIELD
+    TInt GetNbComp() const { return myNbComp;}
+
+    EBooleen myIsLocal; //!< Defines if the MED Field is local
+    //! Let known is the MED FIELD is local or not
+    EBooleen GetIsLocal() const { return myIsLocal;}
+
+    TInt myNbRef; //!< Defines number of refereces of the field
+    //! Let known number of references for the MED FIELD
+    TInt GetNbRef() const { return myNbRef;}
+
+    TString myCompNames; //!< Contains names for each of MED Field components
+    //! Get name of the component by its order number
+    virtual std::string GetCompName(TInt theId) const = 0;
+    //! Set name for the component by its order number
+    virtual void SetCompName(TInt theId, const std::string& theValue) = 0;
+
+    TString myUnitNames; //!< Contains units for each of MED Field components
+    //! Get unit of the component by its order number
+    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: 
+    virtual TNameInfo,
+    virtual TModeSwitchInfo 
+  {
+    typedef boost::tuple<EGeometrieElement,std::string> TKey;
+    typedef boost::tuple<TKey,TInt> TInfo;
+    struct MEDWRAPPER_EXPORT TLess
+    {
+      bool
+      operator()(const TKey& theLeft, const TKey& theRight) const;
+
+      bool
+      operator()(const TGaussInfo& theLeft, const TGaussInfo& theRight) const;
+    };
+
+    //! Defines, which geometrical type the MED Gauss entity belongs to
+    EGeometrieElement myGeom; 
+    //! Let known what MED geometrical type the MED GAUSS entity belong to
+    EGeometrieElement GetGeom() const { return myGeom;}
+
+    //! Contains coordinates for the refereced nodes
+    TNodeCoord myRefCoord; 
+
+    //! Gives coordinates for the referenced node by its number
+    TCCoordSlice GetRefCoordSlice(TInt theId) const;
+    //! Gives coordinates for the referenced node by its number
+    TCoordSlice GetRefCoordSlice(TInt theId);
+
+    //! Contains coordinates for the Gauss points
+    TNodeCoord myGaussCoord;
+
+    //! Gives coordinates for the Gauss points by its number
+    TCCoordSlice GetGaussCoordSlice(TInt theId) const;
+    //! Gives coordinates for the Gauss points by its number
+    TCoordSlice GetGaussCoordSlice(TInt theId);
+
+    //! Contains wheights for the Gauss points
+    TWeight myWeight;
+
+    //! Gives number of the referenced nodes
+    TInt GetNbRef() const { return GetNbRefCoord(GetGeom());}
+
+    //! Gives dimension of the referenced nodes
+    TInt GetDim() const { return GetDimGaussCoord(GetGeom());}
+
+    //! Gives number of the Gauss Points
+    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: 
+    virtual TBase
+  {
+    PFieldInfo myFieldInfo; //!< A reference to correspondig MED Field
+    //! Get a reference to corresponding MED Field
+    const PFieldInfo& GetFieldInfo() const { return myFieldInfo;}
+
+    //! Defines the MED Entity where the MED TimeStamp belongs to
+    EEntiteMaillage myEntity;
+    //! Let known to what MED Entity the MED TimeStamp belong to
+    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;}
+
+    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 myNumOrd; //!< Keeps 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
+
+    //! 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;}
+
+    TString myUnitDt; //!< Defines unit for the time for the MED TimeStamp
+    //! Get unit of time for the MED TimeStamp
+    virtual std::string GetUnitDt() const = 0;
+    //! 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: 
+    virtual TNameInfo
+  {
+    typedef std::string TKey;
+    typedef boost::tuple<TKey,TInt> TInfo;
+
+    EModeProfil myMode; //!< Keeps mode for the MED Profile
+    //! Let known what mode of MED Profile is used
+    EModeProfil GetMode() const { return myMode;}
+    //! Set mode for the MED Profile
+    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
+    TInt GetElemNum(TInt theId) const;
+    //! Set number of mesh elelemts by its order number
+    void SetElemNum(TInt theId, TInt theVal);
+
+    //! Let known is the MED Profile defined
+    bool IsPresent() const { return GetName() != "";}
+
+    //! Let known size of the MED Profile
+    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 
+  {
+    TInt myNbElem;
+    TInt myNbComp;
+    TInt myNbGauss;
+    TInt myStep;
+
+    TMeshValueBase();
+
+    //! Initialize the class
+    void
+    Allocate(TInt theNbElem,
+             TInt theNbGauss,
+             TInt theNbComp,
+             EModeSwitch theMode = eFULL_INTERLACE);
+
+    //! 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*
+    GetValuePtr() = 0;
+  };
+
+  //---------------------------------------------------------------
+  //! 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 
+  {
+    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
+    void
+    Allocate(TInt theNbElem,
+             TInt theNbGauss,
+             TInt theNbComp,
+             EModeSwitch theMode = eFULL_INTERLACE)
+    {
+      TMeshValueBase::Allocate(theNbElem, theNbGauss, theNbComp, theMode);
+      myValue.resize(theNbElem * this->GetStep());
+    }
+
+    //! Returns bare pointer on the internal value representation
+    virtual
+    unsigned char*
+    GetValuePtr()
+    {
+      return (unsigned char*)&myValue[0];
+    }
+
+    //! Returns bare pointer on the internal value representation
+    virtual
+    TElement*
+    GetPointer()
+    {
+      return &myValue[0];
+    }
+
+    //! Returns bare pointer on the internal value representation
+    virtual
+    const TElement*
+    GetPointer() const
+    {
+      return &myValue[0];
+    }
+
+    //! Iteration through Gauss Points by their components
+    TCValueSliceArr
+    GetGaussValueSliceArr(TInt theElemId) const
+    {
+      TCValueSliceArr aValueSliceArr(myNbGauss);
+      if(GetModeSwitch() == eFULL_INTERLACE){
+        TInt anId = theElemId * myStep;
+        for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
+          aValueSliceArr[aGaussId] =
+            TCValueSlice(myValue, std::slice(anId, myNbComp, 1));
+          anId += myNbComp;
+        }
+      }
+      else{
+        for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
+          aValueSliceArr[aGaussId] =
+            TCValueSlice(myValue, std::slice(theElemId, myNbComp, myStep));
+        }
+      }
+      return aValueSliceArr;
+    }
+
+    //! Iteration through Gauss Points by their components
+    TValueSliceArr 
+    GetGaussValueSliceArr(TInt theElemId)
+    {
+      TValueSliceArr aValueSliceArr(myNbGauss);
+      if(GetModeSwitch() == eFULL_INTERLACE){
+        TInt anId = theElemId*myStep;
+        for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
+          aValueSliceArr[aGaussId] =
+            TValueSlice(myValue, std::slice(anId, myNbComp, 1));
+          anId += myNbComp;
+        }
+      }
+      else{
+        for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
+          aValueSliceArr[aGaussId] =
+            TValueSlice(myValue, std::slice(theElemId, myNbComp, myStep));
+        }
+      }
+      return aValueSliceArr;
+    }
+
+    //! Iteration through components by corresponding Gauss Points
+    TCValueSliceArr
+    GetCompValueSliceArr(TInt theElemId) const
+    {
+      TCValueSliceArr aValueSliceArr(myNbComp);
+      if(GetModeSwitch() == eFULL_INTERLACE){
+        TInt anId = theElemId*myStep;
+        for(TInt aCompId = 0; aCompId < myNbComp; aCompId++){
+          aValueSliceArr[aCompId] =
+            TCValueSlice(myValue, std::slice(anId, myNbGauss, myNbComp));
+          anId += 1;
+        }
+      }
+      else{
+        for(TInt aCompId = 0; aCompId < myNbComp; aCompId++){
+          aValueSliceArr[aCompId] =
+            TCValueSlice(myValue, std::slice(theElemId, myNbGauss, myStep));
+        }
+      }
+      return aValueSliceArr;
+    }
+
+    //! Iteration through components by corresponding Gauss Points
+    TValueSliceArr 
+    GetCompValueSliceArr(TInt theElemId)
+    {
+      if(GetModeSwitch() == eFULL_INTERLACE){
+        TValueSliceArr aValueSliceArr(myNbComp);
+        TInt anId = theElemId*myStep;
+        for(TInt aCompId = 0; aCompId < myNbComp; aCompId++){
+          aValueSliceArr[aCompId] =
+            TValueSlice(myValue, std::slice(anId, myNbGauss, myNbComp));
+          anId += 1;
+        }
+        return aValueSliceArr;
+      }
+      else{
+        TValueSliceArr aValueSliceArr(myNbGauss);
+        for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
+          aValueSliceArr[aGaussId] =
+            TValueSlice(myValue,std::slice(theElemId, myNbComp, myStep));
+        }
+        return aValueSliceArr;
+      }
+    }
+  };
+
+  typedef TTMeshValue<TFloatVector> TFloatMeshValue;
+  typedef TTMeshValue<TIntVector> TIntMeshValue;
+
+  //---------------------------------------------------------------
+  // 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;
+
+  //---------------------------------------------------------------
+  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: 
+    virtual TModeSwitchInfo 
+  {
+    //! A reference to correspondig MED TimeStamp
+    PTimeStampInfo myTimeStampInfo;
+    //!< Get a reference to correspondig MED TimeStamp
+    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;}
+
+    //! 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;}
+
+    //! Gets type of the champ
+    virtual 
+    ETypeChamp
+    GetTypeChamp() const = 0;
+
+    //! Allocates values for the given geometry
+    virtual 
+    void
+    AllocateValue(EGeometrieElement theGeom,
+                  TInt theNbElem,
+                  TInt theNbGauss,
+                  TInt theNbComp,
+                  EModeSwitch theMode = eFULL_INTERLACE) = 0;
+    
+    virtual 
+    size_t
+    GetValueSize(EGeometrieElement theGeom) const = 0;
+    
+    virtual 
+    size_t
+    GetNbVal(EGeometrieElement theGeom) const = 0;
+    
+    virtual 
+    size_t
+    GetNbGauss(EGeometrieElement theGeom) const = 0;
+
+    virtual 
+    unsigned char*
+    GetValuePtr(EGeometrieElement theGeom) = 0;
+  };
+
+
+  //---------------------------------------------------------------
+  //! The class implements a container for MED TimeStamp values
+  template<class TMeshValueType>
+  struct TTimeStampValue: 
+    virtual TTimeStampValueBase 
+  {
+    typedef TMeshValueType TTMeshValue;
+    typedef SharedPtr<TMeshValueType> PTMeshValue;
+    typedef typename TMeshValueType::TElement TElement;
+    typedef std::map<EGeometrieElement, PTMeshValue> TTGeom2Value;
+
+    ETypeChamp myTypeChamp; //<! Keeps type of the champ
+
+    //! Gets type of the champ
+    virtual 
+    ETypeChamp
+    GetTypeChamp() const
+    {
+      return myTypeChamp;
+    }
+
+    //! Keeps map of MED TimeStamp values per geometric type (const version)
+    TTGeom2Value myGeom2Value;
+
+    const TTGeom2Value& 
+    GetGeom2Value() const
+    {
+      return myGeom2Value;
+    }
+
+    //! Gets MED TimeStamp values for the given geometric type (const version)
+    const PTMeshValue& 
+    GetMeshValuePtr(EGeometrieElement theGeom) const
+    {
+      typename TTGeom2Value::const_iterator anIter = myGeom2Value.find(theGeom);
+      if(anIter == myGeom2Value.end())
+        EXCEPTION(std::runtime_error,"TTimeStampValue::GetMeshValuePtr - myGeom2Value.find(theGeom) fails");
+      return anIter->second;
+    }
+
+    //! Gets MED TimeStamp values for the given geometric type
+    PTMeshValue& 
+    GetMeshValuePtr(EGeometrieElement theGeom)
+    {
+      myGeomSet.insert(theGeom);
+      if(myGeom2Value.find(theGeom) == myGeom2Value.end()){
+        myGeom2Value[theGeom] = PTMeshValue(new TTMeshValue());
+        return myGeom2Value[theGeom];
+      }
+      return myGeom2Value[theGeom];
+    }
+
+    //! Gets MED TimeStamp values for the given geometric type (const version)
+    const TTMeshValue& 
+    GetMeshValue(EGeometrieElement theGeom) const
+    {
+      return *(this->GetMeshValuePtr(theGeom));
+    }
+
+    //! Gets MED TimeStamp values for the given geometric type
+    TTMeshValue& 
+    GetMeshValue(EGeometrieElement theGeom)
+    {
+      return *(this->GetMeshValuePtr(theGeom));
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  typedef TTimeStampValue<TFloatMeshValue> TFloatTimeStampValue;
+  typedef SharedPtr<TFloatTimeStampValue> PFloatTimeStampValue;
+
+  PFloatTimeStampValue MEDWRAPPER_EXPORT
+  CastToFloatTimeStampValue(const PTimeStampValueBase& theTimeStampValue);
+
+  typedef TTimeStampValue<TIntMeshValue> TIntTimeStampValue;
+  typedef SharedPtr<TIntTimeStampValue> PIntTimeStampValue;
+  
+  PIntTimeStampValue MEDWRAPPER_EXPORT
+  CastToIntTimeStampValue(const PTimeStampValueBase& theTimeStampValue);
+
+
+  //---------------------------------------------------------------
+  template<class TMeshValueTypeFrom, class TMeshValueTypeTo>
+  void
+  CopyTimeStampValue(SharedPtr<TTimeStampValue<TMeshValueTypeFrom> > theTimeStampValueFrom,
+                     SharedPtr<TTimeStampValue<TMeshValueTypeTo> > theTimeStampValueTo)
+  {
+    typedef TTimeStampValue<TMeshValueTypeFrom> TimeStampValueTypeFrom;
+    typedef TTimeStampValue<TMeshValueTypeTo> TimeStampValueTypeTo;
+    typedef typename TMeshValueTypeTo::TElement TElementTo;
+
+    typename TimeStampValueTypeFrom::TTGeom2Value& aGeom2Value = theTimeStampValueFrom->myGeom2Value;
+    typename TimeStampValueTypeFrom::TTGeom2Value::const_iterator anIter = aGeom2Value.begin();
+    for(; anIter != aGeom2Value.end(); anIter++){
+      const EGeometrieElement& aGeom = anIter->first;
+      const typename TimeStampValueTypeFrom::TTMeshValue& aMeshValue = *anIter->second;
+      typename TimeStampValueTypeTo::TTMeshValue& aMeshValue2 = theTimeStampValueTo->GetMeshValue(aGeom);
+      aMeshValue2.Allocate(aMeshValue.myNbElem, 
+                           aMeshValue.myNbGauss, 
+                           aMeshValue.myNbComp,
+                           aMeshValue.myModeSwitch);
+      const typename TimeStampValueTypeFrom::TTMeshValue::TValue& aValue = aMeshValue.myValue;
+      typename TimeStampValueTypeTo::TTMeshValue::TValue& aValue2 = aMeshValue2.myValue;
+      TInt aSize = aValue.size();
+      for(TInt anId = 0; anId < aSize; anId++)
+        aValue2[anId] = TElementTo(aValue[anId]);
+    }
+  }
+
+  template<class TMeshValueType>
+  void
+  CopyTimeStampValue(SharedPtr<TTimeStampValue<TMeshValueType> > theTimeStampValueFrom,
+                     SharedPtr<TTimeStampValue<TMeshValueType> > theTimeStampValueTo)
+  {
+    typedef TTimeStampValue<TMeshValueType> TimeStampValueType;
+    typename TimeStampValueType::TTGeom2Value& aGeom2Value = theTimeStampValueFrom->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;
+      typename TimeStampValueType::TTMeshValue& aMeshValue2 = theTimeStampValueTo->GetMeshValue(aGeom);
+      aMeshValue2 = aMeshValue;
+    }
+  }
+
+  //---------------------------------------------------------------
+  inline
+  void
+  CopyTimeStampValueBase(const PTimeStampValueBase& theValueFrom, 
+                         const PTimeStampValueBase& theValueTo)
+  {
+    if(theValueFrom->GetTypeChamp() == theValueTo->GetTypeChamp()){
+      if(theValueFrom->GetTypeChamp() == eFLOAT64)
+        CopyTimeStampValue<TFloatMeshValue>(theValueFrom, theValueTo);
+      else if(theValueFrom->GetTypeChamp() == eINT)
+        CopyTimeStampValue<TIntMeshValue>(theValueFrom, theValueTo);
+    }else{
+      if(theValueFrom->GetTypeChamp() == eFLOAT64 && theValueTo->GetTypeChamp() == eINT)
+        CopyTimeStampValue<TFloatMeshValue, TIntMeshValue>(theValueFrom, theValueTo);
+      else if(theValueFrom->GetTypeChamp() == eINT && theValueTo->GetTypeChamp() == eFLOAT64)
+        CopyTimeStampValue<TIntMeshValue, TFloatMeshValue>(theValueFrom, theValueTo);
+    }
+  }
+
+
+  //---------------------------------------------------------------
+  // 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;} 
+
+    TNodeCoord myCoord; //!< Contains all nodal coordinates, now used only for eGRILLE_STANDARD
+    //! Gives coordinates for mesh nodes (const version)
+    const TNodeCoord& GetNodeCoord() const;
+    TNodeCoord& GetNodeCoord();
+    //! Gives coordinates for mesh node by its number, array index from 0
+    TNodeCoord GetCoord(TInt theId);
+    //! Gives ids of nodes for mesh cell or sub-cell by its number, array index from 0
+    TIntVector GetConn(TInt theId, const bool isSub=false);
+
+    EGrilleType myGrilleType; //!< Defines grille type (eGRILLE_CARTESIENNE,eGRILLE_POLAIRE,eGRILLE_STANDARD)
+    //!Gets grille type (const version)
+    const EGrilleType& GetGrilleType() const;
+    //!Gets grille type
+    EGrilleType GetGrilleType();
+    //!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 ;
+    //! Set name of the coordinate dimension by its order number
+    virtual void SetCoordName(TInt theId, const std::string& theValue) = 0;
+
+    TString myCoordUnits; //!< Contains units for the coordinate dimensions
+    //! Get name of unit for the coordinate dimension by its order number
+    virtual std::string GetCoordUnit(TInt theId) const = 0;
+    //! 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)
+    const TIndexes& GetMapOfIndexes() const ;
+    //!Gets a map of Tables
+    TIndexes& GetMapOfIndexes();
+    //!Gets a Table of indexes for certain axe(const version)
+    const TFloatVector& GetIndexes(TInt theAxisNumber) const;
+    //!Gets a Table of indexes for certain axe
+    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>
+    EGeometrieElement GetGeom();//! Return geometry of cells (calculated from mesh dimension)
+    EGeometrieElement GetSubGeom();//! Return geometry of subcells (calculated from mesh dimension)
+    EEntiteMaillage GetEntity();//! Return entity (eMAILLE)
+    EEntiteMaillage GetSubEntity();//! Return sub entity
+
+    /*!
+     *Vector of grille structure (Example: {3,4,5}, 3 nodes in X axe, 4 nodes in Y axe, ...)
+     */
+    TIntVector myGrilleStructure;
+    //!Gets grille structure(const version)
+    const TIntVector& GetGrilleStructure() const;
+    //!Gets grille structure
+    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; 
+    //! 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
+    void SetFamNum(TInt theId, TInt theVal);
+    
+    /*!
+     *Defines sequence MED Family indexes for sub entites
+     */
+    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
+    void SetFamNumNode(TInt theId, TInt theVal);
+
+  };
+
+
+}
+
+#endif
diff --git a/src/MEDWrapper/Base/MED_TStructures.hxx b/src/MEDWrapper/Base/MED_TStructures.hxx
new file mode 100644 (file)
index 0000000..dfbca90
--- /dev/null
@@ -0,0 +1,1216 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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_TStructures_HeaderFile
+#define MED_TStructures_HeaderFile
+
+#include "MED_Structures.hxx"
+
+#ifdef WIN32
+#pragma warning(disable:4250)
+#endif
+
+namespace MED
+{
+  //---------------------------------------------------------------
+  //! To provide a common way to handle values of MEDWrapper types as native MED types
+  template<class TValue, class TRepresentation>
+  struct TValueHolder
+  {
+    TValue& myValue;
+    TRepresentation myRepresentation;
+
+    TValueHolder(TValue& theValue):
+      myValue(theValue),
+      myRepresentation(TRepresentation(theValue))
+    {}
+
+    ~TValueHolder()
+    {
+      myValue = TValue(myRepresentation);
+    }
+
+    TRepresentation*
+    operator& ()
+    {
+      return &myRepresentation;
+    }
+
+    operator TRepresentation () const
+    {
+      return myRepresentation;
+    }  
+
+    const TValue&
+    operator() () const
+    {
+      return myValue;
+    }  
+  };
+  
+  //! To customize TValueHolder common template definition for TVector
+  template<class TVal, class TRepresentation>
+  struct TValueHolder<TVector<TVal>, TRepresentation>
+  {
+    typedef TVector<TVal> TValue;
+    TValue& myValue;
+    TRepresentation* myRepresentation;
+
+    TValueHolder(TValue& theValue):
+      myValue(theValue)
+    {
+      if(theValue.empty())
+        myRepresentation = (TRepresentation*)NULL;
+      else
+        myRepresentation = (TRepresentation*)&theValue[0];
+    }
+
+    TRepresentation*
+    operator& ()
+    {
+      return myRepresentation;
+    }
+  };
+  
+  //---------------------------------------------------------------
+  template<EVersion eVersion>
+  struct TTNameInfo: virtual TNameInfo
+  {
+    TTNameInfo(const std::string& theValue)
+    {
+      myName.resize(GetNOMLength<eVersion>()+1);
+      SetName(theValue);
+    }
+
+    virtual
+    std::string
+    GetName() const 
+    { 
+      return GetString(0, GetNOMLength<eVersion>(), myName);
+    }
+
+    virtual
+    void
+    SetName(const std::string& theValue)
+    {
+      SetString(0, GetNOMLength<eVersion>(), myName, theValue);
+    }
+
+    virtual
+    void
+    SetName(const TString& theValue)
+    {
+      SetString(0, GetNOMLength<eVersion>(), myName, theValue);
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  template<EVersion eVersion>
+  struct TTMeshInfo: 
+    virtual TMeshInfo, 
+    virtual TTNameInfo<eVersion>
+  {
+    typedef TTNameInfo<eVersion> TNameInfoBase;
+
+    TTMeshInfo(const PMeshInfo& theInfo):
+      TNameInfoBase(theInfo->GetName())
+    {
+      myDim = theInfo->GetDim();
+      mySpaceDim = theInfo->GetSpaceDim();
+      myType = theInfo->GetType();
+      
+      myDesc.resize(GetDESCLength<eVersion>()+1);
+      SetDesc(theInfo->GetDesc());
+    }
+
+    TTMeshInfo(TInt theDim, TInt theSpaceDim,
+               const std::string& theValue,
+               EMaillage theType,
+               const std::string& theDesc):
+      TNameInfoBase(theValue)
+    {
+      myDim = theDim;
+      mySpaceDim = theSpaceDim;
+      myType = theType;
+      
+      myDesc.resize(GetDESCLength<eVersion>()+1);
+      SetDesc(theDesc);
+    }
+
+    virtual 
+    std::string
+    GetDesc() const 
+    { 
+      return GetString(0, GetDESCLength<eVersion>(), myDesc);
+    }
+
+    virtual
+    void
+    SetDesc(const std::string& theValue)
+    {
+      SetString(0, GetDESCLength<eVersion>(), myDesc, theValue);
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  template<EVersion eVersion>
+  struct TTFamilyInfo: 
+    virtual TFamilyInfo, 
+    virtual TTNameInfo<eVersion>
+  {
+    typedef TTNameInfo<eVersion> TNameInfoBase;
+
+    TTFamilyInfo(const PMeshInfo& theMeshInfo, const PFamilyInfo& theInfo):
+      TNameInfoBase(theInfo->GetName())
+    {
+      myMeshInfo = theMeshInfo;
+
+      myId = theInfo->GetId();
+
+      myNbGroup = theInfo->GetNbGroup();
+      myGroupNames.resize(myNbGroup*GetLNOMLength<eVersion>()+1);
+      if(myNbGroup){
+        for(TInt anId = 0; anId < myNbGroup; anId++){
+          SetGroupName(anId,theInfo->GetGroupName(anId));
+        }
+      }
+
+      myNbAttr = theInfo->GetNbAttr();
+      myAttrId.resize(myNbAttr);
+      myAttrVal.resize(myNbAttr);
+      myAttrDesc.resize(myNbAttr*GetDESCLength<eVersion>()+1);
+      if(myNbAttr){
+        for(TInt anId = 0; anId < myNbAttr; anId++){
+          SetAttrDesc(anId,theInfo->GetAttrDesc(anId));
+          myAttrVal[anId] = theInfo->GetAttrVal(anId);
+          myAttrId[anId] = theInfo->GetAttrId(anId);
+        }
+      }
+    }
+
+    TTFamilyInfo(const PMeshInfo& theMeshInfo,
+                 TInt theNbGroup, 
+                 TInt theNbAttr,
+                 TInt theId,
+                 const std::string& theValue):
+      TNameInfoBase(theValue)
+    {
+      myMeshInfo = theMeshInfo;
+
+      myId = theId;
+
+      myNbGroup = theNbGroup;
+      myGroupNames.resize(theNbGroup*GetLNOMLength<eVersion>()+1);
+
+      myNbAttr = theNbAttr;
+      myAttrId.resize(theNbAttr);
+      myAttrVal.resize(theNbAttr);
+      myAttrDesc.resize(theNbAttr*GetDESCLength<eVersion>()+1);
+    }
+
+    TTFamilyInfo(const PMeshInfo& theMeshInfo,
+                 const std::string& theValue,
+                 TInt theId,
+                 const TStringSet& theGroupNames, 
+                 const TStringVector& theAttrDescs, 
+                 const TIntVector& theAttrIds, 
+                 const TIntVector& theAttrVals):
+      TNameInfoBase(theValue)
+    {
+      myMeshInfo = theMeshInfo;
+
+      myId = theId;
+
+      myNbGroup = (TInt)theGroupNames.size();
+      myGroupNames.resize(myNbGroup*GetLNOMLength<eVersion>()+1);
+      if(myNbGroup){
+        TStringSet::const_iterator anIter = theGroupNames.begin();
+        for(TInt anId = 0; anIter != theGroupNames.end(); anIter++, anId++){
+          const std::string& aVal = *anIter;
+          SetGroupName(anId,aVal);
+        }
+      }
+
+      myNbAttr = (TInt)theAttrDescs.size();
+      myAttrId.resize(myNbAttr);
+      myAttrVal.resize(myNbAttr);
+      myAttrDesc.resize(myNbAttr*GetDESCLength<eVersion>()+1);
+      if(myNbAttr){
+        for(TInt anId = 0, anEnd = (TInt)theAttrDescs.size(); anId < anEnd; anId++){
+          SetAttrDesc(anId,theAttrDescs[anId]);
+          myAttrVal[anId] = theAttrVals[anId];
+          myAttrId[anId] = theAttrIds[anId];
+        }
+      }
+    }
+
+    virtual
+    std::string
+    GetGroupName(TInt theId) const 
+    { 
+      return GetString(theId, GetLNOMLength<eVersion>(), myGroupNames);
+    }
+
+    virtual
+    void
+    SetGroupName(TInt theId, const std::string& theValue)
+    {
+      SetString(theId, GetLNOMLength<eVersion>(), myGroupNames, theValue);
+    }
+
+    virtual
+    std::string
+    GetAttrDesc(TInt theId) const 
+    { 
+      return GetString(theId, GetDESCLength<eVersion>(), myAttrDesc);
+    }
+
+    virtual
+    void
+    SetAttrDesc(TInt theId, const std::string& theValue)
+    {
+      SetString(theId, GetDESCLength<eVersion>(), myAttrDesc, theValue);
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  template<EVersion eVersion>
+  struct TTElemInfo: virtual TElemInfo
+  {
+    TTElemInfo(const PMeshInfo& theMeshInfo, const PElemInfo& theInfo)
+    {
+      myMeshInfo = theMeshInfo;
+      
+      myNbElem = theInfo->GetNbElem();
+      myFamNum.reset(new TElemNum(myNbElem));
+      myIsFamNum = eFAUX; // is set to eVRAI in SetFamNum()
+
+      myIsElemNum = theInfo->IsElemNum();
+      if(theInfo->IsElemNum())
+        myElemNum.reset(new TElemNum(myNbElem));
+      else
+        myElemNum.reset(new TElemNum());
+
+      myIsElemNames = theInfo->IsElemNames();
+      if(theInfo->IsElemNames())
+        myElemNames.reset(new TString(myNbElem*GetPNOMLength<eVersion>() + 1));
+      else
+        myElemNames.reset(new TString());
+
+      if(theInfo->GetNbElem()){
+        for(TInt anId = 0; anId < myNbElem; anId++){
+          SetFamNum(anId, theInfo->GetFamNum(anId));
+        }
+        if(theInfo->IsElemNum() == eVRAI){
+          for(TInt anId = 0; anId < myNbElem; anId++){
+            SetElemNum(anId, theInfo->GetElemNum(anId));
+          }
+        }
+        if(theInfo->IsElemNames() == eVRAI){
+          for(TInt anId = 0; anId < myNbElem; anId++){
+            SetElemName(anId,theInfo->GetElemName(anId));
+          }
+        }
+      }
+    }
+
+    TTElemInfo(const PMeshInfo& theMeshInfo, 
+               TInt theNbElem,
+               EBooleen theIsElemNum,
+               EBooleen theIsElemNames)
+    {
+      myMeshInfo = theMeshInfo;
+
+      myNbElem = theNbElem;
+      myFamNum.reset(new TElemNum(theNbElem));
+      myIsFamNum = eFAUX; // is set to eVRAI in SetFamNum()
+
+      myIsElemNum = theIsElemNum;
+      if(theIsElemNum)
+        myElemNum.reset(new TElemNum(theNbElem));
+      else
+        myElemNum.reset(new TElemNum());
+
+      myIsElemNames = theIsElemNames;
+      if(theIsElemNames)
+        myElemNames.reset(new TString(theNbElem*GetPNOMLength<eVersion>() + 1));
+      else
+        myElemNames.reset(new TString());
+   }
+    
+    TTElemInfo(const PMeshInfo& theMeshInfo, 
+               TInt theNbElem,
+               const TIntVector& theFamilyNums,
+               const TIntVector& theElemNums,
+               const TStringVector& theElemNames)
+    {
+      myMeshInfo = theMeshInfo;
+      
+      myNbElem = theNbElem;
+      myFamNum.reset(new TElemNum(theNbElem));
+      myIsFamNum = eFAUX; // is set to eVRAI in SetFamNum()
+      
+      myIsElemNum = theElemNums.size()? eVRAI: eFAUX;
+      if(myIsElemNum)
+        myElemNum.reset(new TElemNum(theNbElem));
+      else
+        myElemNum.reset(new TElemNum());
+      
+      myIsElemNames = theElemNames.size()? eVRAI: eFAUX;
+      if(myIsElemNames)
+        myElemNames.reset(new TString(theNbElem*GetPNOMLength<eVersion>() + 1));
+      else
+        myElemNames.reset(new TString());
+     
+      if(theNbElem){
+
+        if(theFamilyNums.size())
+          *myFamNum = theFamilyNums;
+
+        if(myIsElemNum)
+          *myElemNum = theElemNums;
+
+        if(myIsElemNames){
+          for(TInt anId = 0; anId < theNbElem; anId++){
+            const std::string& aVal = theElemNames[anId];
+            SetElemName(anId,aVal);
+          }
+        }
+      }
+    }
+
+    virtual
+    std::string
+    GetElemName(TInt theId) const 
+    { 
+      return GetString(theId,GetPNOMLength<eVersion>(), *myElemNames);
+    }
+
+    virtual
+    void
+    SetElemName(TInt theId, const std::string& theValue)
+    {
+      SetString(theId,GetPNOMLength<eVersion>(), *myElemNames, theValue);
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  template<EVersion eVersion>
+  struct TTNodeInfo: 
+    virtual TNodeInfo, 
+    virtual TTElemInfo<eVersion>
+  {
+    typedef TTElemInfo<eVersion> TElemInfoBase;
+
+    TTNodeInfo(const PMeshInfo& theMeshInfo, const PNodeInfo& theInfo):
+      TNodeInfo(theInfo),
+      TElemInfoBase(theMeshInfo, theInfo)
+    {
+      myModeSwitch = theInfo->GetModeSwitch();
+      
+      mySystem = theInfo->GetSystem();
+      
+      myCoord.reset(new TNodeCoord(*theInfo->myCoord));
+      
+      TInt aSpaceDim = theMeshInfo->GetSpaceDim();
+
+      myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+      for(TInt anId = 0; anId < aSpaceDim; anId++)
+        SetCoordName(anId,theInfo->GetCoordName(anId));
+      
+      myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+      for(TInt anId = 0; anId < aSpaceDim; anId++)
+        SetCoordUnit(anId,theInfo->GetCoordUnit(anId));
+    }
+
+    TTNodeInfo(const PMeshInfo& theMeshInfo, 
+               TInt theNbElem,
+               EModeSwitch theMode,
+               ERepere theSystem, 
+               EBooleen theIsElemNum,
+               EBooleen theIsElemNames):
+      TModeSwitchInfo(theMode),
+      TElemInfoBase(theMeshInfo,
+                    theNbElem,
+                    theIsElemNum,
+                    theIsElemNames)
+    {
+      mySystem = theSystem;
+
+      myCoord.reset(new TNodeCoord(theNbElem * theMeshInfo->mySpaceDim));
+
+      myCoordUnits.resize(theMeshInfo->mySpaceDim*GetPNOMLength<eVersion>()+1);
+
+      myCoordNames.resize(theMeshInfo->mySpaceDim*GetPNOMLength<eVersion>()+1);
+    }
+
+    
+    TTNodeInfo(const PMeshInfo& theMeshInfo, 
+               const TFloatVector& theNodeCoords,
+               EModeSwitch theMode,
+               ERepere theSystem, 
+               const TStringVector& theCoordNames,
+               const TStringVector& theCoordUnits,
+               const TIntVector& theFamilyNums,
+               const TIntVector& theElemNums,
+               const TStringVector& theElemNames):
+      TModeSwitchInfo(theMode),
+      TElemInfoBase(theMeshInfo,
+                    (TInt)theNodeCoords.size()/theMeshInfo->GetDim(),
+                    theFamilyNums,
+                    theElemNums,
+                    theElemNames)
+    {
+      mySystem = theSystem;
+
+      myCoord.reset(new TNodeCoord(theNodeCoords));
+      
+      TInt aSpaceDim = theMeshInfo->GetSpaceDim();
+
+      myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+      if(!theCoordNames.empty())
+        for(TInt anId = 0; anId < aSpaceDim; anId++)
+          SetCoordName(anId,theCoordNames[anId]);
+      
+      myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>() + 1);
+      if(!theCoordUnits.empty())
+        for(TInt anId = 0; anId < aSpaceDim; anId++)
+          SetCoordUnit(anId, theCoordUnits[anId]);
+    }
+
+    virtual
+    std::string
+    GetCoordName(TInt theId) const 
+    { 
+      return GetString(theId,GetPNOMLength<eVersion>(),myCoordNames);
+    }
+
+    virtual
+    void
+    SetCoordName(TInt theId, const std::string& theValue)
+    {
+      SetString(theId,GetPNOMLength<eVersion>(),myCoordNames,theValue);
+    }
+
+    virtual
+    std::string 
+    GetCoordUnit(TInt theId) const 
+    { 
+      return GetString(theId,GetPNOMLength<eVersion>(),myCoordUnits);
+    }
+
+    virtual
+    void
+    SetCoordUnit(TInt theId, const std::string& theValue)
+    {
+      SetString(theId,GetPNOMLength<eVersion>(),myCoordUnits,theValue);
+    }
+  };
+
+  //---------------------------------------------------------------
+  template<EVersion eVersion>
+  struct TTPolygoneInfo: 
+    virtual TPolygoneInfo, 
+    virtual TTElemInfo<eVersion>
+  {
+    typedef TTElemInfo<eVersion> TElemInfoBase;
+
+    TTPolygoneInfo(const PMeshInfo& theMeshInfo, const PPolygoneInfo& theInfo):
+      TElemInfoBase(theMeshInfo,theInfo)
+    {
+      myEntity = theInfo->GetEntity();
+      myGeom = theInfo->GetGeom();
+
+      myIndex.reset(new TElemNum(*theInfo->myIndex));
+      myConn.reset(new TElemNum(*theInfo->myConn));
+
+      myConnMode = theInfo->GetConnMode();
+    }
+
+    TTPolygoneInfo(const PMeshInfo& theMeshInfo, 
+                   EEntiteMaillage theEntity, 
+                   EGeometrieElement theGeom,
+                   TInt theNbElem,
+                   TInt theConnSize,
+                   EConnectivite theConnMode,
+                   EBooleen theIsElemNum,
+                   EBooleen theIsElemNames):
+      TElemInfoBase(theMeshInfo,
+                    theNbElem,
+                    theIsElemNum,
+                    theIsElemNames)
+    {
+      myEntity = theEntity;
+      myGeom = theGeom;
+
+      myIndex.reset(new TElemNum(theNbElem + 1));
+      myConn.reset(new TElemNum(theConnSize));
+
+      myConnMode = theConnMode;
+    }
+    
+    TTPolygoneInfo(const PMeshInfo& theMeshInfo, 
+                   EEntiteMaillage theEntity, 
+                   EGeometrieElement theGeom,
+                   const TIntVector& theIndexes,
+                   const TIntVector& theConnectivities,
+                   EConnectivite theConnMode,
+                   const TIntVector& theFamilyNums,
+                   const TIntVector& theElemNums,
+                   const TStringVector& theElemNames):
+      TElemInfoBase(theMeshInfo,
+                    (TInt)theIndexes.size() - 1,
+                    theFamilyNums,
+                    theElemNums,
+                    theElemNames)
+    {
+      myEntity = theEntity;
+      myGeom = theGeom;
+
+      myIndex.reset(new TElemNum(theIndexes));
+      myConn.reset(new TElemNum(theConnectivities));
+
+      myConnMode = theConnMode;
+    }
+  };
+  
+  //---------------------------------------------------------------
+  template<EVersion eVersion>
+  struct TTPolyedreInfo: 
+    virtual TPolyedreInfo, 
+    virtual TTElemInfo<eVersion>
+  {
+    typedef TTElemInfo<eVersion> TElemInfoBase;
+
+    TTPolyedreInfo(const PMeshInfo& theMeshInfo, const PPolyedreInfo& theInfo):
+      TElemInfoBase(theMeshInfo,theInfo)
+    {
+      myEntity = theInfo->GetEntity();
+      myGeom = theInfo->GetGeom();
+
+      myIndex.reset(new TElemNum(*theInfo->myIndex));
+      myFaces.reset(new TElemNum(*theInfo->myFaces));
+      myConn.reset(new TElemNum(*theInfo->myConn));
+
+      myConnMode = theInfo->GetConnMode();
+    }
+
+    TTPolyedreInfo(const PMeshInfo& theMeshInfo, 
+                   EEntiteMaillage theEntity, 
+                   EGeometrieElement theGeom,
+                   TInt theNbElem,
+                   TInt theNbFaces,
+                   TInt theConnSize,
+                   EConnectivite theConnMode,
+                   EBooleen theIsElemNum,
+                   EBooleen theIsElemNames):
+      TElemInfoBase(theMeshInfo,
+                    theNbElem,
+                    theIsElemNum,
+                    theIsElemNames)
+    {
+      myEntity = theEntity;
+      myGeom = theGeom;
+
+      myIndex.reset(new TElemNum(theNbElem + 1));
+      myFaces.reset(new TElemNum(theNbFaces));
+      myConn.reset(new TElemNum(theConnSize));
+
+      myConnMode = theConnMode;
+    }
+    
+    TTPolyedreInfo(const PMeshInfo& theMeshInfo, 
+                   EEntiteMaillage theEntity, 
+                   EGeometrieElement theGeom,
+                   const TIntVector& theIndexes,
+                   const TIntVector& theFaces,
+                   const TIntVector& theConnectivities,
+                   EConnectivite theConnMode,
+                   const TIntVector& theFamilyNums,
+                   const TIntVector& theElemNums,
+                   const TStringVector& theElemNames):
+      TElemInfoBase(theMeshInfo,
+                    (TInt)theIndexes.size()-1,
+                    theFamilyNums,
+                    theElemNums,
+                    theElemNames)
+    {
+      myEntity = theEntity;
+      myGeom = theGeom;
+
+      myIndex.reset(new TElemNum(theIndexes));
+      myFaces.reset(new TElemNum(theFaces));
+      myConn.reset(new TElemNum(theConnectivities));
+
+      myConnMode = theConnMode;
+    }
+  };
+
+  //---------------------------------------------------------------
+  template<EVersion eVersion>
+  struct TTCellInfo: 
+    virtual TCellInfo, 
+    virtual TTElemInfo<eVersion>
+  {
+    typedef TTElemInfo<eVersion> TElemInfoBase;
+
+    TTCellInfo(const PMeshInfo& theMeshInfo, const PCellInfo& theInfo):
+      TElemInfoBase(theMeshInfo,theInfo)
+    {
+      myEntity = theInfo->GetEntity();
+      myGeom = theInfo->GetGeom();
+      myConnMode  = theInfo->GetConnMode();
+      
+      TInt aConnDim = GetNbNodes(myGeom);
+      TInt aNbConn = GetNbConn<eVersion>(myGeom, myEntity, myMeshInfo->myDim);
+      myConn.reset(new TElemNum(myNbElem * aNbConn));
+      for(TInt anElemId = 0; anElemId < myNbElem; anElemId++){
+        TConnSlice aConnSlice = GetConnSlice(anElemId);
+        TCConnSlice aConnSlice2 = theInfo->GetConnSlice(anElemId);
+        for(TInt anConnId = 0; anConnId < aConnDim; anConnId++){
+          aConnSlice[anConnId] = aConnSlice2[anConnId];
+        }
+      }
+    }
+
+    TTCellInfo(const PMeshInfo& theMeshInfo, 
+               EEntiteMaillage theEntity, 
+               EGeometrieElement theGeom,
+               TInt theNbElem,
+               EConnectivite theConnMode,
+               EBooleen theIsElemNum,
+               EBooleen theIsElemNames,
+               EModeSwitch theMode):
+      TModeSwitchInfo(theMode),
+      TElemInfoBase(theMeshInfo,
+                    theNbElem,
+                    theIsElemNum,
+                    theIsElemNames)
+    {
+      myEntity = theEntity;
+      myGeom = theGeom;
+
+      myConnMode = theConnMode;
+      TInt aNbConn = GetNbConn<eVersion>(theGeom, myEntity, theMeshInfo->myDim);
+      myConn.reset(new TElemNum(theNbElem * aNbConn));
+    }
+    
+    TTCellInfo(const PMeshInfo& theMeshInfo, 
+               EEntiteMaillage theEntity, 
+               EGeometrieElement theGeom,
+               const TIntVector& theConnectivities,
+               EConnectivite theConnMode,
+               const TIntVector& theFamilyNums,
+               const TIntVector& theElemNums,
+               const TStringVector& theElemNames,
+               EModeSwitch theMode):
+      TModeSwitchInfo(theMode),
+      TElemInfoBase(theMeshInfo,
+                    (TInt)theConnectivities.size() / GetNbNodes(theGeom),
+                    theFamilyNums,
+                    theElemNums,
+                    theElemNames)
+    {
+      myEntity = theEntity;
+      myGeom = theGeom;
+
+      myConnMode = theConnMode;
+      TInt aConnDim = GetNbNodes(myGeom);
+      TInt aNbConn = GetNbConn<eVersion>(myGeom, myEntity, myMeshInfo->myDim);
+      myConn.reset(new TElemNum(myNbElem * aNbConn));
+      for(TInt anElemId = 0; anElemId < myNbElem; anElemId++){
+        TConnSlice aConnSlice = GetConnSlice(anElemId);
+        for(TInt anConnId = 0; anConnId < aConnDim; anConnId++){
+          aConnSlice[anConnId] = theConnectivities[anElemId*aConnDim + anConnId];
+        }
+      }
+    }
+
+    virtual 
+    TInt
+    GetConnDim() const 
+    { 
+      return GetNbConn<eVersion>(myGeom, myEntity, myMeshInfo->myDim);
+    }
+
+  };
+
+  //---------------------------------------------------------------
+  template<EVersion eVersion>
+  struct TTBallInfo: 
+    virtual TBallInfo,
+    virtual TTCellInfo<eVersion>
+  {
+    typedef TTCellInfo<eVersion> TCellInfoBase;
+
+    TTBallInfo(const PMeshInfo& theMeshInfo, const PBallInfo& theInfo):
+      TCellInfoBase::TElemInfoBase(theMeshInfo, theInfo),
+      TCellInfoBase(theMeshInfo,theInfo)
+    {
+      myDiameters = theInfo->myDiameters;
+    }
+
+    TTBallInfo(const PMeshInfo& theMeshInfo,
+               TInt             theNbElem,
+               EBooleen         theIsElemNum ):
+      TCellInfoBase::TElemInfoBase(theMeshInfo,
+                                   theNbElem,
+                                   theIsElemNum,
+                                   /*theIsElemNames=*/eFAUX),
+      TCellInfoBase(theMeshInfo,
+                    eSTRUCT_ELEMENT,
+                    eBALL,
+                    theNbElem,
+                    /*EConnectivite=*/eNOD,
+                    theIsElemNum,
+                    /*theIsElemNames=*/eFAUX,
+                    eFULL_INTERLACE)
+    {
+      myDiameters.resize( theNbElem );
+    }
+
+    TTBallInfo(const PMeshInfo&  theMeshInfo, 
+               const TIntVector& theNodes,
+               TFloatVector&     theDiameters,
+               const TIntVector& theFamilyNums,
+               const TIntVector& theElemNums):
+      TCellInfoBase::TElemInfoBase(theMeshInfo,
+                                   (TInt)std::max(theNodes.size(),theDiameters.size() ),
+                                   theFamilyNums,
+                                   theElemNums,
+                                   TStringVector()),
+      TCellInfoBase(theMeshInfo,
+                    eSTRUCT_ELEMENT,
+                    eBALL,
+                    theNodes,
+                    /*EConnectivite=*/eNOD,
+                    theFamilyNums,
+                    theElemNums,
+                    TStringVector(),
+                    eFULL_INTERLACE)
+    {
+      myDiameters.swap( theDiameters );
+    }
+  };
+
+  //---------------------------------------------------------------
+  template<EVersion eVersion>
+  struct TTFieldInfo: 
+    virtual TFieldInfo, 
+    virtual TTNameInfo<eVersion>
+  {
+    typedef TTNameInfo<eVersion> TNameInfoBase;
+
+    TTFieldInfo(const PMeshInfo& theMeshInfo, const PFieldInfo& theInfo):
+      TNameInfoBase(theInfo->GetName())
+    {
+      myMeshInfo = theMeshInfo;
+
+      myNbComp = theInfo->GetNbComp();
+      myCompNames.resize(myNbComp*GetPNOMLength<eVersion>()+1);
+      for(TInt anId = 0; anId < myNbComp; anId++){
+        SetCompName(anId,theInfo->GetCompName(anId));
+      }
+
+      myUnitNames.resize(myNbComp*GetPNOMLength<eVersion>()+1);
+      for(TInt anId = 0; anId < myNbComp; anId++){
+        SetUnitName(anId,theInfo->GetUnitName(anId));
+      }
+
+      myType = theInfo->GetType();
+
+      myIsLocal = theInfo->GetIsLocal();
+      myNbRef = theInfo->GetNbRef();
+    }
+
+    TTFieldInfo(const PMeshInfo& theMeshInfo, 
+                TInt theNbComp,
+                ETypeChamp theType,
+                const std::string& theValue,
+                EBooleen theIsLocal,
+                TInt theNbRef):
+      TNameInfoBase(theValue)
+    {
+      myMeshInfo = theMeshInfo;
+
+      myNbComp = theNbComp;
+      myCompNames.resize(theNbComp*GetPNOMLength<eVersion>()+1);
+      myUnitNames.resize(theNbComp*GetPNOMLength<eVersion>()+1);
+
+      myType = theType;
+
+      myIsLocal = theIsLocal;
+      myNbRef = theNbRef;
+    }
+    
+    virtual 
+    std::string
+    GetCompName(TInt theId) const 
+    { 
+      return GetString(theId,GetPNOMLength<eVersion>(),myCompNames);
+    }
+
+    virtual
+    void
+    SetCompName(TInt theId, const std::string& theValue)
+    {
+      SetString(theId,GetPNOMLength<eVersion>(),myCompNames,theValue);
+    }
+
+    virtual
+    std::string 
+    GetUnitName(TInt theId) const 
+    { 
+      return GetString(theId,GetPNOMLength<eVersion>(),myUnitNames);
+    }
+
+    virtual
+    void
+    SetUnitName(TInt theId, const std::string& theValue)
+    {
+      SetString(theId,GetPNOMLength<eVersion>(),myUnitNames,theValue);
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  template<EVersion eVersion>
+  struct TTGaussInfo: 
+    virtual TGaussInfo,
+    virtual TTNameInfo<eVersion>
+  {
+    typedef TTNameInfo<eVersion> TNameInfoBase;
+
+    TTGaussInfo(const TGaussInfo::TInfo& theInfo,
+                EModeSwitch theMode):
+      TModeSwitchInfo(theMode),
+      TNameInfoBase(boost::get<1>(boost::get<0>(theInfo)))
+    {
+      const TGaussInfo::TKey& aKey = boost::get<0>(theInfo);
+
+      myGeom = boost::get<0>(aKey);
+      myRefCoord.resize(GetNbRef()*GetDim());
+
+      TInt aNbGauss = boost::get<1>(theInfo);
+      myGaussCoord.resize(aNbGauss*GetDim());
+      myWeight.resize(aNbGauss);
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  template<EVersion eVersion>
+  struct TTTimeStampInfo: virtual TTimeStampInfo
+  {
+    TTTimeStampInfo(const PFieldInfo& theFieldInfo, const PTimeStampInfo& theInfo)
+    {
+      myFieldInfo = theFieldInfo;
+
+      myEntity = theInfo->GetEntity();
+      myGeom2Size = theInfo->GetGeom2Size();
+
+      myNumDt = theInfo->GetNumDt();
+      myNumOrd = theInfo->GetNumOrd();
+      myDt = theInfo->GetDt();
+
+      myUnitDt.resize(GetPNOMLength<eVersion>()+1);
+      SetUnitDt(theInfo->GetUnitDt());
+
+      myGeom2NbGauss = theInfo->myGeom2NbGauss;
+      myGeom2Gauss = theInfo->GetGeom2Gauss();
+    }
+
+    TTTimeStampInfo(const PFieldInfo& theFieldInfo, 
+                    EEntiteMaillage theEntity,
+                    const TGeom2Size& theGeom2Size,
+                    const TGeom2NbGauss& theGeom2NbGauss,
+                    TInt theNumDt,
+                    TInt theNumOrd,
+                    TFloat theDt,
+                    const std::string& theUnitDt,
+                    const TGeom2Gauss& theGeom2Gauss)
+    {
+      myFieldInfo = theFieldInfo;
+
+      myEntity = theEntity;
+      myGeom2Size = theGeom2Size;
+
+      myNumDt = theNumDt;
+      myNumOrd = theNumDt;
+      myDt = theDt;
+
+      myUnitDt.resize(GetPNOMLength<eVersion>()+1);
+      SetUnitDt(theUnitDt);
+
+      myGeom2NbGauss = theGeom2NbGauss;
+      myGeom2Gauss = theGeom2Gauss;
+    }
+
+    virtual 
+    std::string
+    GetUnitDt() const
+    { 
+      return GetString(0,GetPNOMLength<eVersion>(),myUnitDt);
+    }
+
+    virtual
+    void
+    SetUnitDt(const std::string& theValue)
+    {
+      SetString(0,GetPNOMLength<eVersion>(),myUnitDt,theValue);
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  template<EVersion eVersion>
+  struct TTProfileInfo: 
+    virtual TProfileInfo,
+    virtual TTNameInfo<eVersion>
+  {
+    typedef TTNameInfo<eVersion> TNameInfoBase;
+
+    TTProfileInfo(const TProfileInfo::TInfo& theInfo,
+                  EModeProfil theMode):
+      TNameInfoBase(boost::get<0>(theInfo))
+    {
+      TInt aSize = boost::get<1>(theInfo);
+      myElemNum.reset(new TElemNum(aSize));
+      myMode = aSize > 0? theMode: eNO_PFLMOD;
+    }
+  };
+
+
+  //---------------------------------------------------------------
+  template<EVersion eVersion, class TMeshValueType>
+  struct TTTimeStampValue: virtual TTimeStampValue<TMeshValueType>
+  {
+    TTTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
+                     const PTimeStampValueBase& theInfo,
+                     ETypeChamp theTypeChamp)
+    {
+      typedef TTimeStampValue<TMeshValueType> TCompatible;
+      if(TCompatible* aCompatible = dynamic_cast<TCompatible*>(theInfo.get())){
+        this->myTimeStampInfo = theTimeStampInfo;
+        this->myTypeChamp = theTypeChamp;
+        this->myGeom2Profile = aCompatible->GetGeom2Profile();
+        this->myGeom2Value = aCompatible->myGeom2Value;
+        this->myGeomSet = aCompatible->GetGeomSet();
+      }else
+        EXCEPTION(std::runtime_error,"TTTimeStampValue::TTTimeStampValue - use incompatible arguments!");
+    }
+
+    TTTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
+                     ETypeChamp theTypeChamp,
+                     const TGeom2Profile& theGeom2Profile,
+                     EModeSwitch theMode):
+      TModeSwitchInfo(theMode)
+    {
+      this->myTimeStampInfo = theTimeStampInfo;
+
+      this->myTypeChamp = theTypeChamp;
+
+      this->myGeom2Profile = theGeom2Profile;
+
+      TInt aNbComp = theTimeStampInfo->myFieldInfo->myNbComp;
+
+      const TGeom2Size& aGeom2Size = theTimeStampInfo->GetGeom2Size();
+      TGeom2Size::const_iterator anIter = aGeom2Size.begin();
+      for(; anIter != aGeom2Size.end(); anIter++){
+        const EGeometrieElement& aGeom = anIter->first;
+        TInt aNbElem = anIter->second;
+
+        MED::PProfileInfo aProfileInfo;
+        MED::TGeom2Profile::const_iterator anIter = theGeom2Profile.find(aGeom);
+        if(anIter != theGeom2Profile.end())
+          aProfileInfo = anIter->second;
+
+        if(aProfileInfo && aProfileInfo->IsPresent())
+          aNbElem = aProfileInfo->GetSize();
+
+        TInt aNbGauss = theTimeStampInfo->GetNbGauss(aGeom);
+        
+        this->GetMeshValue(aGeom).Allocate(aNbElem,aNbGauss,aNbComp);
+      }
+    }
+
+    virtual 
+    size_t
+    GetValueSize(EGeometrieElement theGeom) const
+    {
+      return this->GetMeshValue(theGeom).GetSize();
+    }
+
+    virtual 
+    size_t
+    GetNbVal(EGeometrieElement theGeom) const
+    {
+      return this->GetMeshValue(theGeom).GetNbVal();
+    }
+
+    virtual 
+    size_t
+    GetNbGauss(EGeometrieElement theGeom) const
+    {
+      return this->GetMeshValue(theGeom).GetNbGauss();
+    }
+
+    virtual 
+    void
+    AllocateValue(EGeometrieElement theGeom,
+                  TInt theNbElem,
+                  TInt theNbGauss,
+                  TInt theNbComp,
+                  EModeSwitch theMode = eFULL_INTERLACE)
+    {
+      this->GetMeshValue(theGeom).Allocate(theNbElem,theNbGauss,theNbComp,theMode);
+    }
+    
+    virtual 
+    unsigned char*
+    GetValuePtr(EGeometrieElement theGeom)
+    {
+      return this->GetMeshValue(theGeom).GetValuePtr();
+    }
+  };
+
+  //---------------------------------------------------------------
+  template<EVersion eVersion>
+  struct TTGrilleInfo:
+    virtual TGrilleInfo
+  {
+    TTGrilleInfo(const PMeshInfo& theMeshInfo,
+                 const PGrilleInfo& theInfo)
+    {
+      myMeshInfo        = theMeshInfo;
+
+      myCoord           = theInfo->GetNodeCoord();
+      
+      myGrilleType      = theInfo->GetGrilleType();
+
+      myCoordNames      = theInfo->myCoordNames;
+
+      myCoordUnits      = theInfo->myCoordUnits;
+
+      myIndixes         = theInfo->GetMapOfIndexes();
+
+      myGrilleStructure = theInfo->GetGrilleStructure();
+
+      myGrilleType      = theInfo->GetGrilleType();
+
+      myFamNumNode.resize(theInfo->GetNbNodes());
+      myFamNumNode      = theInfo->myFamNumNode;
+
+      myFamNum      = theInfo->myFamNum;
+    }
+
+    TTGrilleInfo(const PMeshInfo& theMeshInfo,
+                 const EGrilleType& type,
+                 const TInt nnoeuds)
+    {
+      myMeshInfo        = theMeshInfo;
+      TInt aSpaceDim = theMeshInfo->GetSpaceDim();
+      if(type == eGRILLE_STANDARD){
+        myCoord.resize(aSpaceDim*nnoeuds);
+        myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+        myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+      } else { //if(type == eGRILLE_CARTESIENNE){
+        myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
+        myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
+      }
+      myGrilleStructure.resize(aSpaceDim);
+      myFamNumNode.resize(nnoeuds);
+    }
+
+    TTGrilleInfo(const PMeshInfo& theMeshInfo,
+                 const EGrilleType& type)
+    {
+      myMeshInfo        = theMeshInfo;
+      TInt aSpaceDim = theMeshInfo->GetSpaceDim();
+      if(type == eGRILLE_STANDARD){
+        myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+        myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+      } else {// if(type == eGRILLE_CARTESIENNE){
+        myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
+        myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
+      }
+      myGrilleStructure.resize(aSpaceDim);
+    }
+
+    TTGrilleInfo(const PMeshInfo& theMeshInfo,
+                 const EGrilleType& type,
+                 const MED::TIntVector& nbNodeVec)
+    {
+      myMeshInfo        = theMeshInfo;
+
+      TInt aSpaceDim = theMeshInfo->GetSpaceDim();
+      if(type == eGRILLE_STANDARD){
+        myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+        myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
+      } else {// if(type == eGRILLE_CARTESIENNE){
+        myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
+        myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
+      }
+
+      if(type != eGRILLE_STANDARD)
+        for(unsigned int aAxe=0;aAxe<nbNodeVec.size();aAxe++){
+          myIndixes[aAxe].resize(nbNodeVec[aAxe]);
+        }
+      myGrilleStructure.resize(aSpaceDim);
+    }
+
+    virtual
+    std::string
+    GetCoordName(TInt theId) const 
+    { 
+      return GetString(theId,GetPNOMLength<eVersion>(),myCoordNames);
+    }
+
+    virtual
+    void
+    SetCoordName(TInt theId, const std::string& theValue)
+    {
+      SetString(theId,GetPNOMLength<eVersion>(),myCoordNames,theValue);
+    }
+
+    virtual
+    std::string 
+    GetCoordUnit(TInt theId) const 
+    { 
+      return GetString(theId,GetPNOMLength<eVersion>(),myCoordUnits);
+    }
+
+    virtual
+    void
+    SetCoordUnit(TInt theId, const std::string& theValue)
+    {
+      SetString(theId,GetPNOMLength<eVersion>(),myCoordUnits,theValue);
+    }
+
+  };
+}
+
+#endif
diff --git a/src/MEDWrapper/Base/MED_TWrapper.hxx b/src/MEDWrapper/Base/MED_TWrapper.hxx
new file mode 100644 (file)
index 0000000..4acda13
--- /dev/null
@@ -0,0 +1,578 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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
diff --git a/src/MEDWrapper/Base/MED_Utilities.cxx b/src/MEDWrapper/Base/MED_Utilities.cxx
new file mode 100644 (file)
index 0000000..49cd74a
--- /dev/null
@@ -0,0 +1,113 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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);
+
+  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;
+}
+
+
diff --git a/src/MEDWrapper/Base/MED_Utilities.hxx b/src/MEDWrapper/Base/MED_Utilities.hxx
new file mode 100644 (file)
index 0000000..39e7cf8
--- /dev/null
@@ -0,0 +1,74 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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_Utilities_HeaderFile
+#define MED_Utilities_HeaderFile
+
+#include "MED_WrapperBase.hxx"
+
+#include <iostream>     
+#include <sstream>      
+#include <string>
+#include <string.h>
+#include <stdexcept>
+
+
+namespace MED
+{
+  class MEDWRAPPER_EXPORT PrefixPrinter
+  {
+    static int myCounter;
+    bool myIsActive;
+  public:
+    PrefixPrinter(bool theIsActive = true);
+    ~PrefixPrinter();
+
+    static std::string GetPrefix();
+  };
+}
+
+#ifdef _DEBUG_
+  #define MSG(deb,msg) if(deb) std::cout<<MED::PrefixPrinter::GetPrefix()<<msg<<" ("<<__FILE__<<" ["<<__LINE__<<"])\n"
+  #define BEGMSG(deb,msg) if(deb) std::cout<<MED::PrefixPrinter::GetPrefix()<<msg
+  #define 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
+  #define MSG(deb,msg)
+  #define BEGMSG(deb,msg)
+  #define INITMSGA(deb,lev,msg)
+  #define INITMSG(deb,msg)
+  #define ADDMSG(deb,msg)
+#endif
+
+
+#ifndef EXCEPTION
+
+#define EXCEPTION(TYPE, MSG) {\
+  std::ostringstream aStream;\
+  aStream<<__FILE__<<"["<<__LINE__<<"]::"<<MSG;\
+  throw TYPE(aStream.str().c_str());\
+}
+
+#endif
+
+#endif
diff --git a/src/MEDWrapper/Base/MED_Vector.hxx b/src/MEDWrapper/Base/MED_Vector.hxx
new file mode 100644 (file)
index 0000000..94e894f
--- /dev/null
@@ -0,0 +1,153 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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_Vector_HeaderFile
+#define MED_Vector_HeaderFile
+
+#include <vector>
+#include <stdexcept>
+
+//#if defined(_DEBUG_)
+#  define MED_TVECTOR_CHECK_RANGE
+//#endif
+
+namespace MED
+{
+
+  //! 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>
+  {
+  public:
+    typedef size_t size_type;
+
+    typedef std::vector<_Tp, _Alloc> superclass;
+    typedef typename superclass::allocator_type allocator_type;
+
+    typedef _Tp value_type;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+
+  protected:
+    void
+    check_range(size_type __n) const
+    {
+      if (__n >= this->size())
+        throw std::out_of_range("TVector [] access out of range");
+    }
+
+    const_reference
+    get_value(size_type __n) const
+    {
+      return superclass::operator[](__n);
+    }
+
+    reference
+    get_value(size_type __n)
+    {
+      return superclass::operator[](__n);
+    }
+
+  public:
+    explicit
+    TVector(const allocator_type& __a = allocator_type()): 
+      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)
+    {}
+
+    TVector(const TVector& __x):
+      superclass(__x)
+    {}
+
+    template<typename _InputIterator>
+    TVector(_InputIterator __first, _InputIterator __last,
+            const allocator_type& __a = allocator_type()):
+      superclass(__first, __last, __a)
+    {}
+
+    template<typename _Yp, typename _Al>
+    TVector(TVector<_Yp, _Al> __y):
+      superclass(__y.begin(), __y.end())
+    {}
+
+    TVector&
+    operator=(const TVector& __x)
+    {
+      superclass::operator=(__x);
+      return *this;
+    }
+
+    template<typename _Yp, typename _Al>
+    TVector&
+    operator=(TVector<_Yp, _Al> __y)
+    {
+      this->assign(__y.begin(), __y.end());
+      return *this;
+    }
+
+    reference
+    operator[](size_type __n)
+    {
+#if defined(MED_TVECTOR_CHECK_RANGE)
+      check_range(__n);
+#endif
+      return get_value(__n);
+    }
+
+    const_reference
+    operator[](size_type __n) const
+    {
+#if defined(MED_TVECTOR_CHECK_RANGE)
+      check_range(__n);
+#endif
+      return get_value(__n);
+    }
+
+    reference
+    at(size_type __n)
+    {
+      check_range(__n);
+      return get_value(__n);
+    }
+
+    const_reference
+    at(size_type __n) const
+    {
+      check_range(__n);
+      return get_value(__n);
+    }
+  };
+
+}
+
+#undef MED_TVECTOR_CHECK_RANGE
+
+#endif
diff --git a/src/MEDWrapper/Base/MED_Wrapper.cxx b/src/MEDWrapper/Base/MED_Wrapper.cxx
new file mode 100644 (file)
index 0000000..d04c284
--- /dev/null
@@ -0,0 +1,707 @@
+// Copyright (C) 2007-2013  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.
+//
+// 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,