Salome HOME
Merge from V6_main 06/03/2013
[modules/smesh.git] / src / DriverGMF / DriverGMF_Read.cxx
index e3fc5d76bd1d60e737cd22e8628a3c3b1172bb4a..0d70c8d5aeea181d2218c555e43e0a7036cf33b0 100644 (file)
@@ -29,6 +29,7 @@
 #include "SMESHDS_Group.hxx"
 #include "SMESHDS_Mesh.hxx"
 #include "SMESH_Comment.hxx"
+#include "SMESH_TypeDefs.hxx"
 
 #include <Basics_Utils.hxx>
 
@@ -69,9 +70,11 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
   if ( !meshID )
   {
     if ( DriverGMF::isExtensionCorrect( myFile ))
-      return addMessage( SMESH_Comment("Can't open for reading ") << myFile, /*fatal=*/true );
+      return addMessage( SMESH_Comment("Can't open for reading ") << myFile,
+                         /*fatal=*/true );
     else
-      return addMessage( SMESH_Comment("Not '.mesh' or '.meshb' extension of file ") << myFile, /*fatal=*/true );
+      return addMessage( SMESH_Comment("Not '.mesh' or '.meshb' extension of file ") << myFile,
+                         /*fatal=*/true );
   }
   DriverGMF::MeshCloser aMeshCloser( meshID ); // An object closing GMF mesh at destruction
 
@@ -109,34 +112,33 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
 
   int iN[28]; // 28 - nb nodes in HEX27 (+ 1 for safety :)
 
-  /* Read extra vertices for quadratic edges */
-  std::vector<int> quadNodesAtEdges;
-  int nbQuadEdges = 0;
-  if ( (nbQuadEdges = GmfStatKwd(meshID, GmfExtraVerticesAtEdges)) )
-  {
-    quadNodesAtEdges.reserve( nbQuadEdges );
-    GmfGotoKwd(meshID, GmfExtraVerticesAtEdges);
-    for ( int i = 1; i <= nbQuadEdges; ++i )
-    {
-      GmfGetLin(meshID, GmfExtraVerticesAtEdges, &iN[0], &iN[1], &iN[2]);
-      quadNodesAtEdges.push_back(iN[2]);
-    }
-  }
-
   /* Read edges */
   const int edgeIDShift = myMesh->GetMeshInfo().NbElements();
   if ( int nbEdges = GmfStatKwd(meshID, GmfEdges))
   {
-    const bool readQuadNodes = ( nbQuadEdges == nbEdges );
+    // read extra vertices for quadratic edges
+    std::vector<int> quadNodesAtEdges( nbEdges + 1, -1 );
+    if ( int nbQuadEdges = GmfStatKwd(meshID, GmfExtraVerticesAtEdges))
+    {
+      GmfGotoKwd(meshID, GmfExtraVerticesAtEdges);
+      for ( int i = 1; i <= nbQuadEdges; ++i )
+      {
+        GmfGetLin(meshID, GmfExtraVerticesAtEdges, &iN[0], &iN[1], &iN[2]);
+        if ( iN[1] >= 1 )
+          quadNodesAtEdges[ iN[0] ] = iN[2];
+      }
+    }
+    // create edges
     GmfGotoKwd(meshID, GmfEdges);
     for ( int i = 1; i <= nbEdges; ++i )
     {
       GmfGetLin(meshID, GmfEdges, &iN[0], &iN[1], &ref);
-      if ( readQuadNodes )
+      const int midN = quadNodesAtEdges[ i ];
+      if ( midN > 0 )
       {
-        const int midN = quadNodesAtEdges[i-1];
         if ( !myMesh->AddEdgeWithID( iN[0], iN[1], midN, edgeIDShift + i ))
-          status = storeBadNodeIds( "GmfEdges + GmfExtraVerticesAtEdges",i, 3, iN[0],iN[1],midN);
+          status = storeBadNodeIds( "GmfEdges + GmfExtraVerticesAtEdges",i,
+                                    3, iN[0], iN[1], midN);
       }
       else
       {
@@ -145,47 +147,40 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
       }
     }
   }
-  // the vector of extra vertices at edges won't be used anymore so it is cleared
-  quadNodesAtEdges.clear();
-
-  /* Read extra vertices for quadratic triangles */
-  std::vector< std::vector<int> > quadNodesAtTriangles;
-  int nbQuadTria = 0;
-  if ( (nbQuadTria = GmfStatKwd(meshID, GmfExtraVerticesAtTriangles)) )
-  {
-    GmfGotoKwd(meshID, GmfExtraVerticesAtTriangles);
-    quadNodesAtTriangles.reserve( nbQuadTria );
-    std::vector<int> nodes(4);
-    for ( int i = 1; i <= nbQuadTria; ++i )
-    {
-      GmfGetLin(meshID, GmfExtraVerticesAtTriangles,
-                &iN[0], &iN[1], &iN[2], &iN[3], &iN[4],
-                &iN[5]); // iN[5] - preview TRIA7
-      nodes.clear();
-      nodes.push_back(iN[2]);
-      nodes.push_back(iN[3]);
-      nodes.push_back(iN[4]);
-      nodes.push_back(iN[5]);
-      nodes.resize( iN[1] );
-
-      quadNodesAtTriangles.push_back(nodes);
-    }
-  }
 
   /* Read triangles */
   const int triaIDShift = myMesh->GetMeshInfo().NbElements();
   if ( int nbTria = GmfStatKwd(meshID, GmfTriangles))
   {
-    const bool readQuadNodes = (nbQuadTria == nbTria);
+    // read extra vertices for quadratic triangles
+    std::vector< std::vector<int> > quadNodesAtTriangles( nbTria + 1 );
+    if ( int nbQuadTria = GmfStatKwd(meshID, GmfExtraVerticesAtTriangles ))
+    {
+      GmfGotoKwd( meshID, GmfExtraVerticesAtTriangles );
+      for ( int i = 1; i <= nbQuadTria; ++i )
+      {
+        GmfGetLin(meshID, GmfExtraVerticesAtTriangles,
+                  &iN[0], &iN[1], &iN[2], &iN[3], &iN[4],
+                  &iN[5]); // iN[5] - preview TRIA7
+        if ( iN[0] <= nbTria )
+        {
+          std::vector<int>& nodes = quadNodesAtTriangles[ iN[0] ];
+          nodes.insert( nodes.end(), & iN[2], & iN[5+1] );
+          nodes.resize( iN[1] );
+        }
+      }
+    }
+    // create triangles
     GmfGotoKwd(meshID, GmfTriangles);
     for ( int i = 1; i <= nbTria; ++i )
     {
       GmfGetLin(meshID, GmfTriangles, &iN[0], &iN[1], &iN[2], &ref);
-      if ( readQuadNodes )
+      std::vector<int>& midN = quadNodesAtTriangles[ i ];
+      if ( midN.size() >= 3 )
       {
-        const std::vector<int>& midN = quadNodesAtTriangles[ i-1 ];
-        if ( !myMesh->AddFaceWithID( iN[0],iN[1],iN[2], midN[0],midN[1],midN[2],  triaIDShift + i ))
-          status = storeBadNodeIds( "GmfTriangles + GmfExtraVerticesAtTriangles",i, 6, 
+        if ( !myMesh->AddFaceWithID( iN[0],iN[1],iN[2], midN[0],midN[1],midN[2],
+                                     triaIDShift + i ))
+          status = storeBadNodeIds( "GmfTriangles + GmfExtraVerticesAtTriangles",i, 6,
                                     iN[0],iN[1],iN[2], midN[0],midN[1],midN[2] );
       }
       else
@@ -193,127 +188,108 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
         if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], triaIDShift + i ))
           status = storeBadNodeIds( "GmfTriangles",i, 3, iN[0], iN[1], iN[2] );
       }
+      if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
     }
   }
-  // the vector of extra vertices at triangles won't be used anymore so it is cleared
-  quadNodesAtTriangles.clear();
 
-  /* Read extra vertices for quadratic quadrangles */
-  std::vector< std::vector<int> > quadNodesAtQuadrilaterals;
-  int nbQuadQuad = 0;
-  if ( (nbQuadQuad = GmfStatKwd(meshID, GmfExtraVerticesAtQuadrilaterals)) )
-  {
-    GmfGotoKwd(meshID, GmfExtraVerticesAtQuadrilaterals);
-    quadNodesAtQuadrilaterals.reserve( nbQuadQuad );
-    std::vector<int> nodes( 5 );
-    for ( int i = 1; i <= nbQuadQuad; ++i )
-    {
-      GmfGetLin(meshID, GmfExtraVerticesAtQuadrilaterals,
-                &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &iN[6]);
-      nodes.clear();
-      nodes.push_back(iN[2]);
-      nodes.push_back(iN[3]);
-      nodes.push_back(iN[4]);
-      nodes.push_back(iN[5]);
-      nodes.push_back(iN[6]);
-      nodes.resize( iN[1] );
-
-      quadNodesAtQuadrilaterals.push_back(nodes);
-    }
-  }
-
- /* Read quadrangles */
+  /* Read quadrangles */
   const int quadIDShift = myMesh->GetMeshInfo().NbElements();
   if ( int nbQuad = GmfStatKwd(meshID, GmfQuadrilaterals))
   {
-    const bool readQuadNodes = (nbQuadQuad == nbQuad);
+    // read extra vertices for quadratic quadrangles
+    std::vector< std::vector<int> > quadNodesAtQuadrilaterals( nbQuad + 1 );
+    if ( int nbQuadQuad = GmfStatKwd( meshID, GmfExtraVerticesAtQuadrilaterals ))
+    {
+      GmfGotoKwd(meshID, GmfExtraVerticesAtQuadrilaterals);
+      for ( int i = 1; i <= nbQuadQuad; ++i )
+      {
+        GmfGetLin(meshID, GmfExtraVerticesAtQuadrilaterals,
+                  &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &iN[6]);
+        if ( iN[0] <= nbQuad )
+        {
+          std::vector<int>& nodes = quadNodesAtQuadrilaterals[ iN[0] ];
+          nodes.insert( nodes.end(), & iN[2], & iN[6+1] );
+          nodes.resize( iN[1] );
+        }
+      }
+    }
+    // create quadrangles
     GmfGotoKwd(meshID, GmfQuadrilaterals);
     for ( int i = 1; i <= nbQuad; ++i )
     {
       GmfGetLin(meshID, GmfQuadrilaterals, &iN[0], &iN[1], &iN[2], &iN[3], &ref);
-      if ( readQuadNodes )
+      std::vector<int>& midN = quadNodesAtQuadrilaterals[ i ];
+      if ( midN.size() == 8-4 ) // QUAD8
       {
-        const std::vector<int>& midN = quadNodesAtQuadrilaterals[ i-1 ];
-        if ( midN.size() == 4 )
-        {
-          if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3],
-                                       midN[0], midN[1], midN[2], midN[3],
-                                       quadIDShift + i ))
-            status = storeBadNodeIds( "GmfQuadrilaterals + GmfExtraVerticesAtQuadrilaterals",i, 8,
-                                      iN[0], iN[1],iN[2], iN[3],
-                                      midN[0], midN[1], midN[2], midN[3]);
-        }
-        else
-        {
-          if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3],
-                                       midN[0], midN[1], midN[2], midN[3], midN[4],
-                                       quadIDShift + i ))
-            status = storeBadNodeIds( "GmfQuadrilaterals + GmfExtraVerticesAtQuadrilaterals",i, 9,
-                                      iN[0], iN[1],iN[2], iN[3],
-                                      midN[0], midN[1], midN[2], midN[3], midN[4]);
-        }
+        if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3],
+                                     midN[0], midN[1], midN[2], midN[3],
+                                     quadIDShift + i ))
+          status = storeBadNodeIds( "GmfQuadrilaterals + GmfExtraVerticesAtQuadrilaterals",i, 8,
+                                    iN[0], iN[1],iN[2], iN[3],
+                                    midN[0], midN[1], midN[2], midN[3]);
       }
-      else
+      else if ( midN.size() > 8-4 ) // QUAD9
+      {
+        if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3],
+                                     midN[0], midN[1], midN[2], midN[3], midN[4],
+                                     quadIDShift + i ))
+          status = storeBadNodeIds( "GmfQuadrilaterals + GmfExtraVerticesAtQuadrilaterals",i, 9,
+                                    iN[0], iN[1],iN[2], iN[3],
+                                    midN[0], midN[1], midN[2], midN[3], midN[4]);
+      }
+      else // QUAD4
       {
         if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3], quadIDShift + i ))
           status = storeBadNodeIds( "GmfQuadrilaterals",i, 4, iN[0], iN[1],iN[2], iN[3] );
       }
+      if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
     }
   }
-  // the vector of extra vertices at quadrilaterals won't be used anymore so it is cleared
-  quadNodesAtQuadrilaterals.clear();
 
-  /* Read extra vertices for quadratic tetrahedra */
-  std::vector< std::vector<int> > quadNodesAtTetrahedra;
-  int nbQuadTetra = 0;
-  if ( (nbQuadTetra = GmfStatKwd(meshID, GmfExtraVerticesAtTetrahedra)) )
-  {
-    GmfGotoKwd(meshID, GmfExtraVerticesAtTetrahedra);
-    quadNodesAtTetrahedra.reserve( nbQuadTetra );
-    std::vector<int> nodes( 6 );
-    for ( int i = 1; i <= nbQuadTetra; ++i )
-    {
-      GmfGetLin(meshID, GmfExtraVerticesAtTetrahedra,
-                &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &iN[6], &iN[7]);
-      nodes.clear();
-      nodes.push_back(iN[2]);
-      nodes.push_back(iN[3]);
-      nodes.push_back(iN[4]);
-      nodes.push_back(iN[5]);
-      nodes.push_back(iN[6]);
-      nodes.push_back(iN[7]);
-      nodes.resize( iN[1] );
-
-      quadNodesAtTetrahedra.push_back(nodes);
-    }
-  }
   /* Read terahedra */
   const int tetIDShift = myMesh->GetMeshInfo().NbElements();
-  if ( int nbTet = GmfStatKwd(meshID, GmfTetrahedra))
+  if ( int nbTet = GmfStatKwd( meshID, GmfTetrahedra ))
   {
-    const bool readQuadNodes = (nbQuadTetra == nbTet);
+    // read extra vertices for quadratic tetrahedra
+    std::vector< std::vector<int> > quadNodesAtTetrahedra( nbTet + 1 );
+    if ( int nbQuadTetra = GmfStatKwd( meshID, GmfExtraVerticesAtTetrahedra ))
+    {
+      GmfGotoKwd(meshID, GmfExtraVerticesAtTetrahedra);
+      for ( int i = 1; i <= nbQuadTetra; ++i )
+      {
+        GmfGetLin(meshID, GmfExtraVerticesAtTetrahedra,
+                  &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &iN[6], &iN[7]);
+        if ( iN[0] <= nbTet )
+        {
+          std::vector<int>& nodes = quadNodesAtTetrahedra[ iN[0] ];
+          nodes.insert( nodes.end(), & iN[2], & iN[7+1] );
+          nodes.resize( iN[1] );
+        }
+      }
+    }
+    // create tetrahedra
     GmfGotoKwd(meshID, GmfTetrahedra);
     for ( int i = 1; i <= nbTet; ++i )
     {
       GmfGetLin(meshID, GmfTetrahedra, &iN[0], &iN[1], &iN[2], &iN[3], &ref);
-      if ( readQuadNodes )
+      std::vector<int>& midN = quadNodesAtTetrahedra[ i ];  
+      if ( midN.size() >= 10-4 ) // TETRA10
       {
-        const std::vector<int>& midN = quadNodesAtTetrahedra[ i-1 ];  
         if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], 
-                                       midN[2], midN[1], midN[0], midN[3], midN[5], midN[4], tetIDShift + i ))
-          status = storeBadNodeIds( "GmfTetrahedra + GmfExtraVerticesAtTetrahedra",i, 10, iN[0], iN[2], iN[1], iN[3], 
-                                                                midN[2], midN[1], midN[0], midN[3], midN[5], midN[4] );
+                                       midN[2], midN[1], midN[0], midN[3], midN[5], midN[4],
+                                       tetIDShift + i ))
+          status = storeBadNodeIds( "GmfTetrahedra + GmfExtraVerticesAtTetrahedra",i, 10,
+                                    iN[0], iN[2], iN[1], iN[3], 
+                                    midN[2], midN[1], midN[0], midN[3], midN[5], midN[4] );
       }
-      else
+      else // TETRA4
       {
-        if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], tetIDShift + i ) )
+        if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], tetIDShift + i ))
           status = storeBadNodeIds( "GmfTetrahedra" ,i, 4, iN[0], iN[2], iN[1], iN[3] );
       }
+      if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
     }
   }
-  // the vector of extra vertices at tetrahedra won't be used anymore so it is cleared
-  quadNodesAtTetrahedra.clear();
 
   /* Read pyramids */
   const int pyrIDShift = myMesh->GetMeshInfo().NbElements();
@@ -328,92 +304,58 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
     }
   }
 
-  /* Read extra vertices for quadratic hexahedra */
-  std::vector< std::vector<int> > quadNodesAtHexahedra;
-  int nbQuadHexa = 0;
-  if ( (nbQuadHexa = GmfStatKwd(meshID, GmfExtraVerticesAtHexahedra)) )
-  {
-    GmfGotoKwd(meshID, GmfExtraVerticesAtHexahedra);
-    quadNodesAtHexahedra.reserve( nbQuadHexa );
-    std::vector<int> nodes( 19 );
-    for ( int i = 1; i <= nbQuadHexa; ++i )
-    {
-      GmfGetLin(meshID, GmfExtraVerticesAtHexahedra, &iN[0], &iN[1],    // Hexa Id, Nb of extra vertices
-                                                     &iN[2], &iN[3], &iN[4], &iN[5],
-                                                     &iN[6], &iN[7], &iN[8], &iN[9],
-                                                     &iN[10], &iN[11], &iN[12], &iN[13], // HEXA20
-                                                     &iN[14], 
-                                                     &iN[15], &iN[16], &iN[17], &iN[18], 
-                                                     &iN[19],
-                                                     &iN[20]);                          // HEXA27
-      nodes.clear();
-      nodes.push_back(iN[2]);
-      nodes.push_back(iN[3]);
-      nodes.push_back(iN[4]);
-      nodes.push_back(iN[5]);
-      nodes.push_back(iN[6]);
-      nodes.push_back(iN[7]);
-      nodes.push_back(iN[8]);
-      nodes.push_back(iN[9]);
-      nodes.push_back(iN[10]);
-      nodes.push_back(iN[11]);
-      nodes.push_back(iN[12]);
-      nodes.push_back(iN[13]);     
-      nodes.push_back(iN[14]);
-      nodes.push_back(iN[15]);
-      nodes.push_back(iN[16]);
-      nodes.push_back(iN[17]);
-      nodes.push_back(iN[18]);
-      nodes.push_back(iN[19]);
-      nodes.push_back(iN[20]);
-      nodes.resize( iN[1] );
-
-      quadNodesAtHexahedra.push_back(nodes);
-    }
-  }
-  
   /* Read hexahedra */
   const int hexIDShift = myMesh->GetMeshInfo().NbElements();
   if ( int nbHex = GmfStatKwd(meshID, GmfHexahedra))
   {
-    const bool readQuadNodes = (nbQuadHexa == nbHex);
+    // read extra vertices for quadratic hexahedra
+    std::vector< std::vector<int> > quadNodesAtHexahedra( nbHex + 1 );
+    if ( int nbQuadHexa = GmfStatKwd( meshID, GmfExtraVerticesAtHexahedra ))
+    {
+      GmfGotoKwd(meshID, GmfExtraVerticesAtHexahedra);
+      for ( int i = 1; i <= nbQuadHexa; ++i )
+      {
+        GmfGetLin(meshID, GmfExtraVerticesAtHexahedra, &iN[0], &iN[1], // Hexa Id, Nb extra vertices
+                  &iN[2], &iN[3], &iN[4], &iN[5],
+                  &iN[6], &iN[7], &iN[8], &iN[9],
+                  &iN[10], &iN[11], &iN[12], &iN[13], // HEXA20
+                  &iN[14],
+                  &iN[15], &iN[16], &iN[17], &iN[18], 
+                  &iN[19],
+                  &iN[20]);                          // HEXA27
+        if ( iN[0] <= nbHex )
+        {
+          std::vector<int>& nodes = quadNodesAtHexahedra[ iN[0] ];
+          nodes.insert( nodes.end(), & iN[2], & iN[20+1] );
+          nodes.resize( iN[1] );
+        }
+      }
+    }
+    // create hexhedra
     GmfGotoKwd(meshID, GmfHexahedra);
     for ( int i = 1; i <= nbHex; ++i )
     {
       GmfGetLin(meshID, GmfHexahedra, &iN[0], &iN[1], &iN[2], &iN[3],
-                                      &iN[4], &iN[5], &iN[6], &iN[7],&ref);
-      if ( readQuadNodes )
+                &iN[4], &iN[5], &iN[6], &iN[7], &ref);
+      std::vector<int>& midN = quadNodesAtHexahedra[ i ];
+      if ( midN.size() == 20-8 ) // HEXA20
       {
-        const std::vector<int>& midN = quadNodesAtHexahedra[ i-1 ];  
-        if ( midN.size() == 12 )  // HEXA20
-        {
-          if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
-                                         iN[4], iN[7], iN[6], iN[5],
-                                         midN[3], midN[2], midN[1], midN[0],
-                                         midN[7], midN[6], midN[5], midN[4],
-                                         midN[8], midN[11], midN[10], midN[9],
-                                         tetIDShift + i ))
-            status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 20, 
-                                       iN[0], iN[3], iN[2], iN[1],
+        if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
                                        iN[4], iN[7], iN[6], iN[5],
                                        midN[3], midN[2], midN[1], midN[0],
                                        midN[7], midN[6], midN[5], midN[4],
-                                       midN[8], midN[11], midN[10], midN[9]);
-        }
-        else                      // HEXA27
-        {
-           if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
-                                          iN[4], iN[7], iN[6], iN[5],
-                                          midN[3], midN[2], midN[1], midN[0],
-                                          midN[7], midN[6], midN[5], midN[4],
-                                          midN[8], midN[11], midN[10], midN[9],
-                                          midN[12],
-                                          midN[16], midN[15], midN[14], midN[13],
-                                          midN[17],
-                                          midN[18],                                                        
-                                          tetIDShift + i ))
-            status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 27, 
-                                       iN[0], iN[3], iN[2], iN[1],
+                                       midN[8], midN[11], midN[10], midN[9],
+                                       hexIDShift + i ))
+          status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 20, 
+                                    iN[0], iN[3], iN[2], iN[1],
+                                    iN[4], iN[7], iN[6], iN[5],
+                                    midN[3], midN[2], midN[1], midN[0],
+                                    midN[7], midN[6], midN[5], midN[4],
+                                    midN[8], midN[11], midN[10], midN[9]);
+      }
+      else if ( midN.size() >= 27-8 ) // HEXA27
+      {
+        if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
                                        iN[4], iN[7], iN[6], iN[5],
                                        midN[3], midN[2], midN[1], midN[0],
                                        midN[7], midN[6], midN[5], midN[4],
@@ -421,20 +363,29 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
                                        midN[12],
                                        midN[16], midN[15], midN[14], midN[13],
                                        midN[17],
-                                       midN[18]);
-        }
+                                       midN[18],
+                                       hexIDShift + i ))
+          status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 27, 
+                                    iN[0], iN[3], iN[2], iN[1],
+                                    iN[4], iN[7], iN[6], iN[5],
+                                    midN[3], midN[2], midN[1], midN[0],
+                                    midN[7], midN[6], midN[5], midN[4],
+                                    midN[8], midN[11], midN[10], midN[9],
+                                    midN[12],
+                                    midN[16], midN[15], midN[14], midN[13],
+                                    midN[17],
+                                    midN[18]);
       }
-      else
+      else // HEXA8
       {
         if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
                                        iN[4], iN[7], iN[6], iN[5], hexIDShift + i ) )
           status = storeBadNodeIds( "GmfHexahedra" ,i, 8, iN[0], iN[3], iN[2], iN[1],
-                                                          iN[4], iN[7], iN[6], iN[5] );
+                                    iN[4], iN[7], iN[6], iN[5] );
       }
+      if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
     }
   }
-  // the vector of extra vertices at tetrahedra won't be used anymore so it is cleared
-  quadNodesAtHexahedra.clear();
 
   /* Read prism */
   const int prismIDShift = myMesh->GetMeshInfo().NbElements();
@@ -443,8 +394,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
     GmfGotoKwd(meshID, GmfPrisms);
     for ( int i = 1; i <= nbPrism; ++i )
     {
-      GmfGetLin(meshID, GmfPrisms,
-                &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &ref);
+      GmfGetLin(meshID, GmfPrisms, &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &ref);
       if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], iN[5], iN[4], prismIDShift + i))
         status = storeBadNodeIds( "GmfPrisms",i,
                                   6, iN[0], iN[1],iN[2], iN[3], iN[4], iN[5] );