Salome HOME
0022098: EDF 2036 SMESH: Create groups from none conected parts of a mesh
[modules/smesh.git] / src / StdMeshers / StdMeshers_Penta_3D.cxx
index ec275531750d4ec12d681aad088e52810c4fd6bf..3db3f2dd9e9a53ce62d9d9aece172c3c958a6957 100644 (file)
@@ -1,29 +1,29 @@
-//  SMESH StdMeshers_Penta_3D implementaion of SMESH idl descriptions
+// Copyright (C) 2007-2013  CEA/DEN, EDF R&D, OPEN CASCADE
 //
-//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
-// 
-//  This library is free software; you can redistribute it and/or 
-//  modify it under the terms of the GNU Lesser General Public 
-//  License as published by the Free Software Foundation; either 
-//  version 2.1 of the License. 
-// 
-//  This library is distributed in the hope that it will be useful, 
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
-//  Lesser General Public License for more details. 
-// 
-//  You should have received a copy of the GNU Lesser General Public 
-//  License along with this library; if not, write to the Free Software 
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
-// 
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+// 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
 //
+
+//  SMESH StdMeshers_Penta_3D implementaion of SMESH idl descriptions
 //  File   : StdMeshers_Penta_3D.cxx
 //  Module : SMESH
-
+//
 #include "StdMeshers_Penta_3D.hxx"
 
 #include "utilities.h"
 #include "SMDS_VolumeOfNodes.hxx"
 #include "SMDS_VolumeTool.hxx"
 #include "SMESHDS_SubMesh.hxx"
+#include "SMESH_Comment.hxx"
 #include "SMESH_Mesh.hxx"
+#include "SMESH_MeshAlgos.hxx"
+#include "SMESH_MesherHelper.hxx"
 #include "SMESH_subMesh.hxx"
-#include "SMESH_MeshEditor.hxx"
+#include "SMESH_subMeshEventListener.hxx"
 
 #include <BRep_Tool.hxx>
-#include <TopAbs_ShapeEnum.hxx>
 #include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
 #include <TopTools_IndexedMapOfShape.hxx>
-#include <TopTools_IndexedMapOfShape.hxx>
 #include <TopTools_ListIteratorOfListOfShape.hxx>
 #include <TopTools_ListOfShape.hxx>
+#include <TopTools_SequenceOfShape.hxx>
+#include <TopTools_MapOfShape.hxx>
 #include <TopoDS.hxx>
 #include <TopoDS_Edge.hxx>
 #include <TopoDS_Shell.hxx>
 #include <TopoDS_Vertex.hxx>
 #include <gp_Pnt.hxx>
-#include <BRepTools.hxx>
-#include <BRepTools_WireExplorer.hxx>
-#include <TopTools_MapOfShape.hxx>
 
 #include <stdio.h>
 #include <algorithm>
@@ -63,12 +64,14 @@ using namespace std;
 typedef map < int, int, less<int> >::iterator   \
   StdMeshers_IteratorOfDataMapOfIntegerInteger;
 
+enum { NB_WALL_FACES = 4 };
+
 //=======================================================================
 //function : StdMeshers_Penta_3D
 //purpose  : 
 //=======================================================================
 StdMeshers_Penta_3D::StdMeshers_Penta_3D()
-: myErrorStatus(1)
+  : myErrorStatus(SMESH_ComputeError::New())
 {
   myTol3D=0.1;
   myWallNodesMaps.resize( SMESH_Block::NbFaces() );
@@ -83,8 +86,6 @@ StdMeshers_Penta_3D::StdMeshers_Penta_3D()
 
 StdMeshers_Penta_3D::~StdMeshers_Penta_3D()
 {
-  if ( myTool )
-    delete myTool;
 }
 
 //=======================================================================
@@ -92,55 +93,51 @@ StdMeshers_Penta_3D::~StdMeshers_Penta_3D()
 //purpose  : 
 //=======================================================================
 bool StdMeshers_Penta_3D::Compute(SMESH_Mesh& aMesh, 
-                                 const TopoDS_Shape& aShape)
+                                  const TopoDS_Shape& aShape)
 {
   MESSAGE("StdMeshers_Penta_3D::Compute()");
   //
-  myErrorStatus=0;
-  //
   bool bOK=false;
   //
   myShape=aShape;
   SetMesh(aMesh);
   //
   CheckData();
-  if (myErrorStatus){
+  if (!myErrorStatus->IsOK()) {
     return bOK;
   }
 
-  myTool = new SMESH_MesherHelper(aMesh);
-  myCreateQuadratic = myTool->IsQuadraticSubMesh(aShape);
-
   //
   MakeBlock();
-  if (myErrorStatus){
-    delete myTool; myTool = 0;
+  if (!myErrorStatus->IsOK()) {
     return bOK;
   }
   //
   ClearMeshOnFxy1();
-  if (myErrorStatus) {
-    delete myTool; myTool = 0;
+  if (!myErrorStatus->IsOK()) {
     return bOK;
   }
+
+  // now unnecessary faces removed, we can load medium nodes
+  SMESH_MesherHelper helper(aMesh);
+  myTool = &helper;
+  myCreateQuadratic = myTool->IsQuadraticSubMesh(aShape);
+
   //
   MakeNodes();
-  if (myErrorStatus){
-    delete myTool; myTool = 0;
+  if (!myErrorStatus->IsOK()) {
     return bOK;
   }
   //
   MakeConnectingMap();
   //
   MakeMeshOnFxy1();
-  if (myErrorStatus) {
-    delete myTool; myTool = 0;
+  if (!myErrorStatus->IsOK()) {
     return bOK;
   }
   //
   MakeVolumeMesh();
   //
-  delete myTool; myTool = 0;
   return !bOK;
 }
 
@@ -150,8 +147,6 @@ bool StdMeshers_Penta_3D::Compute(SMESH_Mesh& aMesh,
 //=======================================================================
 void StdMeshers_Penta_3D::MakeNodes()
 {
-  myErrorStatus=0;
-  //
   const int aNbSIDs=9;
   int i, j, k, ij, iNbN, aNodeID, aSize, iErr;
   double aX, aY, aZ;
@@ -241,7 +236,7 @@ void StdMeshers_Penta_3D::MakeNodes()
       //
       if ( SMESH_Block::IsEdgeID (aSID)) {
         const SMDS_EdgePosition* epos =
-          static_cast<const SMDS_EdgePosition*>(aNode->GetPosition().get());
+          static_cast<const SMDS_EdgePosition*>(aNode->GetPosition());
         myBlock.ComputeParameters( epos->GetUParameter(), aS, aCoords );
       }
       else {
@@ -255,7 +250,7 @@ void StdMeshers_Penta_3D::MakeNodes()
       if (iErr) {
         MESSAGE("StdMeshers_Penta_3D::MakeNodes()," <<
                 "SMESHBlock: ComputeParameters operation failed");
-        myErrorStatus=101; // SMESHBlock: ComputeParameters operation failed
+        myErrorStatus=myBlock.GetError();
         return;
       }
       aTNode.SetNormCoord(aCoords);
@@ -264,97 +259,35 @@ void StdMeshers_Penta_3D::MakeNodes()
       ++j;
     }
   }
-  /*
-  //DEB
-  {
-    int iShapeSupportID, iBaseNodeID;
-    //
-    //printf("\n\n*** Base Face\n");
-    i=0;
-    for (j=0; j<myJSize; ++j) {
-      ij=i*myJSize+j;
-      const StdMeshers_TNode& aTNode=myTNodes[ij];
-      iShapeSupportID=aTNode.ShapeSupportID();
-      iBaseNodeID=aTNode.BaseNodeID();
-      const gp_XYZ& aXYZ=aTNode.NormCoord();
-      printf("*** j:%d bID#%d iSS:%d { %lf %lf %lf }\n",
-            j,  iBaseNodeID, iShapeSupportID, aXYZ.X(),  aXYZ.Y(), aXYZ.Z());
-    }
-  }
-  */
-  //DEB
-  //return; //zz
-  //
-  // 3. Finding of Z-layers
-//   vector<double> aZL(myISize);
-//   vector<double>::iterator aItZL1, aItZL2 ;
-//   //
-//   const TopoDS_Shape& aE00z=myBlock.Shape(SMESH_Block::ID_E00z);
-//   SMDS_NodeIteratorPtr aItaE00z =
-//     pMesh->GetSubMeshContaining(aE00z)->GetSubMeshDS()->GetNodes();
-//   //
-//   aZL[0]=0.;
-//   i=1;
-//   while (aItaE00z->more()) {
-//     const SMDS_MeshNode* aNode=aItaE00z->next();
-//     const SMDS_EdgePosition* epos =
-//       static_cast<const SMDS_EdgePosition*>(aNode->GetPosition().get());
-//     myBlock.ComputeParameters( epos->GetUParameter(), aE00z, aCoords );
-//     iErr=myBlock.ErrorStatus();
-//     if (iErr) {
-//       MESSAGE("StdMeshers_Penta_3D::MakeNodes()," <<
-//               "SMESHBlock: ComputeParameters operation failed");
-//       myErrorStatus=101; // SMESHBlock: ComputeParameters operation failed
-//       return;
-//     }
-//     aZL[i]=aCoords.Z();
-//     ++i;
-//   }
-//   aZL[i]=1.;
-//   //
-//   aItZL1=aZL.begin();
-//   aItZL2=aZL.end();
-//   //
-//   // Sorting the layers
-//   sort(aItZL1, aItZL2);
-  //DEB
-  /*
-  printf("** \n\n Layers begin\n");
-  for(i=0, aItZL=aItZL1; aItZL!=aItZL2; ++aItZL, ++i) {
-    printf(" #%d : %lf\n", i, *aItZL);
-  } 
-  printf("** Layers end\n");
-  */
-  //DEB
-  //
-  //
 
   // 3.1 Fill maps of wall nodes
-  SMESH_Block::TShapeID wallFaceID[4] = {
+  SMESH_Block::TShapeID wallFaceID[ NB_WALL_FACES ] = {
     SMESH_Block::ID_Fx0z, SMESH_Block::ID_Fx1z,
     SMESH_Block::ID_F0yz, SMESH_Block::ID_F1yz
-    };
-  SMESH_Block::TShapeID baseEdgeID[4] = {
+  };
+  SMESH_Block::TShapeID baseEdgeID[ NB_WALL_FACES ] = {
     SMESH_Block::ID_Ex00, SMESH_Block::ID_Ex10,
     SMESH_Block::ID_E0y0, SMESH_Block::ID_E1y0
-    };
-  for ( i = 0; i < 4; ++i ) {
+  };
+  for ( i = 0; i < NB_WALL_FACES ; ++i ) {
     int fIndex = SMESH_Block::ShapeIndex( wallFaceID[ i ]);
     bool ok = LoadIJNodes (myWallNodesMaps[ fIndex ],
                            TopoDS::Face( myBlock.Shape( wallFaceID[ i ] )),
                            TopoDS::Edge( myBlock.Shape( baseEdgeID[ i ] )),
                            pMesh->GetMeshDS());
     if ( !ok ) {
-      myErrorStatus = i + 1;
-      MESSAGE(" Cant LoadIJNodes() from a wall face " << myErrorStatus );
+      myErrorStatus->myName = COMPERR_BAD_INPUT_MESH;
+      myErrorStatus->myComment = SMESH_Comment() <<
+        "Can't find regular quadrangle mesh on a side face #" <<
+        pMesh->GetMeshDS()->ShapeToIndex( myBlock.Shape( wallFaceID[ i ]));
       return;
     }
   }
 
   // 3.2 find node columns for vertical edges and edge IDs
-  vector<const SMDS_MeshNode*> * verticEdgeNodes[ 4 ];
-  SMESH_Block::TShapeID          verticEdgeID   [ 4 ];
-  for ( i = 0; i < 4; ++i ) { // 4 first base nodes are nodes on vertices
+  vector<const SMDS_MeshNode*> * verticEdgeNodes[ NB_WALL_FACES ];
+  SMESH_Block::TShapeID          verticEdgeID   [ NB_WALL_FACES ];
+  for ( i = 0; i < NB_WALL_FACES ; ++i ) { // 4 first base nodes are nodes on vertices
     // edge ID
     SMESH_Block::TShapeID eID, vID = aSIDs[ i ];
     ShapeSupportID(false, vID, eID);
@@ -362,7 +295,7 @@ void StdMeshers_Penta_3D::MakeNodes()
     // column nodes
     StdMeshers_TNode& aTNode = myTNodes[ i ];
     verticEdgeNodes[ i ] = 0;
-    for ( j = 0; j < 4; ++j ) { // loop on 4 wall faces
+    for ( j = 0; j < NB_WALL_FACES ; ++j ) { // loop on 4 wall faces
       int fIndex = SMESH_Block::ShapeIndex( wallFaceID[ j ]);
       StdMeshers_IJNodeMap & ijNodes= myWallNodesMaps[ fIndex ];
       if ( ijNodes.begin()->second[0] == aTNode.Node() )
@@ -416,20 +349,20 @@ void StdMeshers_Penta_3D::MakeNodes()
   N = itn->next();
   gp_XY UV111 = myTool->GetNodeUV(TopFace,N);
 
-  for (j=0; j<myJSize; ++j) {
+  for (j=0; j<myJSize; ++j) { // loop on all nodes of the base face (ID_Fxy0)
     // base node info
     const StdMeshers_TNode& aBN = myTNodes[j];
     aBNSSID = (SMESH_Block::TShapeID)aBN.ShapeSupportID();
     iBNID = aBN.BaseNodeID();
     const gp_XYZ& aBNXYZ = aBN.NormCoord();
-    bool createNode = ( aBNSSID == SMESH_Block::ID_Fxy0 );
+    bool createNode = ( aBNSSID == SMESH_Block::ID_Fxy0 ); // if base node is inside a bottom face
     //
     // set XYZ on horizontal edges and get node columns of faces:
     // 2 columns for each face, between which a base node is located
     vector<const SMDS_MeshNode*>* nColumns[8];
-    double ratio[4]; // base node position between columns [0.-1.]
+    double ratio[ NB_WALL_FACES ]; // base node position between columns [0.-1.]
     if ( createNode ) {
-      for ( k = 0; k < 4; ++k ) {
+      for ( k = 0; k < NB_WALL_FACES ; ++k ) {
         ratio[ k ] = SetHorizEdgeXYZ (aBNXYZ, wallFaceID[ k ],
                                       nColumns[k*2], nColumns[k*2+1]);
       }
@@ -441,27 +374,31 @@ void StdMeshers_Penta_3D::MakeNodes()
     myShapeXYZ[ SMESH_Block::ID_Fxy1 ].SetCoord( 0., 0., 0. );
     //
     // first create or find a top node, then the rest ones in a column
-    for (i=myISize-1; i>0; --i) {
+    for (i=myISize-1; i>0; --i) // vertical loop, from top to bottom
+    {
       bIsUpperLayer = (i==(myISize-1));
       gp_XY UV_Ex01, UV_Ex11, UV_E0y1, UV_E1y1;
-      if ( createNode ) {
+      if ( createNode ) // a base node is inside a top face
+      {
         // set XYZ on vertical edges and faces
-        for ( k = 0; k < 4; ++k ) {
+        for ( k = 0; k < NB_WALL_FACES ; ++k ) {
+          // XYZ on a vertical edge 
           const SMDS_MeshNode* n = (*verticEdgeNodes[ k ]) [ i ];
           myShapeXYZ[ verticEdgeID[ k ] ].SetCoord( n->X(), n->Y(), n->Z() );
-          //
+          // XYZ on a face (part 1 from one column)
           n = (*nColumns[k*2]) [ i ];
+          gp_XYZ xyz( n->X(), n->Y(), n->Z() );
+          myShapeXYZ[ wallFaceID[ k ]] = ( 1. - ratio[ k ]) * xyz;
           gp_XY tmp1;
-          if( i==myISize-1 ) {
+          if( bIsUpperLayer ) {
             tmp1 = myTool->GetNodeUV(TopFace,n);
             tmp1 = ( 1. - ratio[ k ]) * tmp1;
           }
-          gp_XYZ xyz( n->X(), n->Y(), n->Z() );
-          myShapeXYZ[ wallFaceID[ k ]] = ( 1. - ratio[ k ]) * xyz;
+          // XYZ on a face (part 2 from other column)
           n = (*nColumns[k*2+1]) [ i ];
           xyz.SetCoord( n->X(), n->Y(), n->Z() );
           myShapeXYZ[ wallFaceID[ k ]] += ratio[ k ] * xyz;
-          if( i==myISize-1 ) {
+          if( bIsUpperLayer ) {
             gp_XY tmp2 = myTool->GetNodeUV(TopFace,n);
             tmp1 +=  ratio[ k ] * tmp2;
             if( k==0 )
@@ -487,9 +424,9 @@ void StdMeshers_Penta_3D::MakeNodes()
       //
       //   suporting shape ID
       ShapeSupportID(bIsUpperLayer, aBNSSID, aSSID);
-      if (myErrorStatus) {
+      if (!myErrorStatus->IsOK()) {
         MESSAGE("StdMeshers_Penta_3D::MakeNodes() ");
-       return;
+        return;
       }
       //
       aTN.SetShapeSupportID(aSSID);
@@ -497,13 +434,13 @@ void StdMeshers_Penta_3D::MakeNodes()
       aTN.SetBaseNodeID(iBNID);
       //
       if (aSSID!=SMESH_Block::ID_NONE){
-       // try to find the node
-       const TopoDS_Shape& aS=myBlock.Shape((int)aSSID);
-       FindNodeOnShape(aS, aCoords, i, aTN);
+        // try to find the node
+        const TopoDS_Shape& aS=myBlock.Shape((int)aSSID);
+        FindNodeOnShape(aS, aCoords, i, aTN);
       }
       else{
-       // create node and get it id
-       CreateNode (bIsUpperLayer, aCoords, aTN);
+        // create node and get its id
+        CreateNode (bIsUpperLayer, aCoords, aTN);
         //
         if ( bIsUpperLayer ) {
           const SMDS_MeshNode* n = aTN.Node();
@@ -534,41 +471,14 @@ void StdMeshers_Penta_3D::MakeNodes()
           meshDS->SetNodeOnFace((SMDS_MeshNode*)n, topfaceID, aP.X(), aP.Y());
         }
       }
-      if (myErrorStatus) {
+      if (!myErrorStatus->IsOK()) {
         MESSAGE("StdMeshers_Penta_3D::MakeNodes() ");
-       return;
+        return;
       }
       //
       myTNodes[ij]=aTN;
     }
   }
-  //DEB
-  /*
-  {
-    int iSSID, iBNID, aID;
-    //
-    for (i=0; i<myISize; ++i) {
-      printf(" Layer# %d\n", i);
-      for (j=0; j<myJSize; ++j) {
-       ij=i*myJSize+j; 
-       const StdMeshers_TNode& aTN=myTNodes[ij];
-       //const StdMeshers_TNode& aTN=aTNodes[ij];
-       const gp_XYZ& aXYZ=aTN.NormCoord();
-       iSSID=aTN.ShapeSupportID();
-       iBNID=aTN.BaseNodeID();
-       //
-       const SMDS_MeshNode* aNode=aTN.Node();
-       aID=aNode->GetID(); 
-       aX=aNode->X();
-       aY=aNode->Y();
-       aZ=aNode->Z();
-       printf("*** j:%d BNID#%d iSSID:%d ID:%d { %lf %lf %lf },  { %lf %lf %lf }\n",
-              j,  iBNID, iSSID, aID, aXYZ.X(),  aXYZ.Y(), aXYZ.Z(), aX, aY, aZ);
-      }
-    }
-  }
-  */
-  //DEB t
 }
 
 
@@ -578,12 +488,10 @@ void StdMeshers_Penta_3D::MakeNodes()
 //=======================================================================
 
 void StdMeshers_Penta_3D::FindNodeOnShape(const TopoDS_Shape& aS,
-                                         const gp_XYZ&       aParams,
+                                          const gp_XYZ&       aParams,
                                           const int           z,
-                                         StdMeshers_TNode&   aTN)
+                                          StdMeshers_TNode&   aTN)
 {
-  myErrorStatus=0;
-  //
   double aX, aY, aZ, aD, aTol2, minD;
   gp_Pnt aP1, aP2;
   //
@@ -662,12 +570,15 @@ double StdMeshers_Penta_3D::SetHorizEdgeXYZ(const gp_XYZ&                  aBase
                                             vector<const SMDS_MeshNode*>*& aCol2)
 {
   // find base and top edges of the face
+  enum { BASE = 0, TOP };
   vector< int > edgeVec; // 0-base, 1-top
   SMESH_Block::GetFaceEdgesIDs( aFaceID, edgeVec );
   //
-  int coord = SMESH_Block::GetCoordIndOnEdge( edgeVec[ 0 ] );
+  int coord = SMESH_Block::GetCoordIndOnEdge( edgeVec[ BASE ] );
+  bool isForward = myBlock.IsForwadEdge( edgeVec[ BASE ] );
+
   double param = aBaseNodeParams.Coord( coord );
-  if ( !myBlock.IsForwadEdge( edgeVec[ 0 ] ))
+  if ( !isForward)
     param = 1. - param;
   //
   // look for columns around param
@@ -686,19 +597,34 @@ double StdMeshers_Penta_3D::SetHorizEdgeXYZ(const gp_XYZ&                  aBase
   aCol1 = & par_nVec_1->second;
   aCol2 = & par_nVec_2->second;
 
-  // base edge
-  const SMDS_MeshNode* n1 = aCol1->front();
-  const SMDS_MeshNode* n2 = aCol2->front();
-  gp_XYZ xyz1( n1->X(), n1->Y(), n1->Z() ), xyz2( n2->X(), n2->Y(), n2->Z() );
-  myShapeXYZ[ edgeVec[ 0 ] ] = ( 1. - r ) * xyz1 + r * xyz2;
-
   // top edge
-  n1 = aCol1->back();
-  n2 = aCol2->back();
-  xyz1.SetCoord( n1->X(), n1->Y(), n1->Z() );
-  xyz2.SetCoord( n2->X(), n2->Y(), n2->Z() );
-  myShapeXYZ[ edgeVec[ 1 ] ] = ( 1. - r ) * xyz1 + r * xyz2;
+  if (1) {
+    // this variant is better for cases with curved edges and
+    // different nodes distribution on top and base edges
+    const SMDS_MeshNode* n1 = aCol1->back();
+    const SMDS_MeshNode* n2 = aCol2->back();
+    gp_XYZ xyz1( n1->X(), n1->Y(), n1->Z() );
+    gp_XYZ xyz2( n2->X(), n2->Y(), n2->Z() );
+    myShapeXYZ[ edgeVec[ 1 ] ] = ( 1. - r ) * xyz1 + r * xyz2;
+  }
+  else {
+    // this variant is better for other cases
+    //   SMESH_MesherHelper helper( *GetMesh() );
+    //   const TopoDS_Edge & edge = TopoDS::Edge( myBlock.Shape( edgeVec[ TOP ]));
+    //   double u1 = helper.GetNodeU( edge, n1 );
+    //   double u2 = helper.GetNodeU( edge, n2 );
+    //   double u = ( 1. - r ) * u1 + r * u2;
+    //   gp_XYZ topNodeParams;
+    //   myBlock.Block().EdgeParameters( edgeVec[ TOP ], u, topNodeParams );
+    //   myBlock.Block().EdgePoint( edgeVec[ TOP ],
+    //                              topNodeParams,
+    //                              myShapeXYZ[ edgeVec[ TOP ]]);
+  }
 
+  // base edge
+  myBlock.Block().EdgePoint( edgeVec[ BASE ],
+                             aBaseNodeParams,
+                             myShapeXYZ[ edgeVec[ BASE ]]);
   return r;
 }
 
@@ -709,8 +635,6 @@ double StdMeshers_Penta_3D::SetHorizEdgeXYZ(const gp_XYZ&                  aBase
 //=======================================================================
 void StdMeshers_Penta_3D::MakeVolumeMesh()
 {
-  myErrorStatus=0;
-  //
   int i, j, ij, ik, i1, i2, aSSID; 
   //
   SMESH_Mesh*   pMesh = GetMesh();
@@ -726,8 +650,8 @@ void StdMeshers_Penta_3D::MakeVolumeMesh()
       const StdMeshers_TNode& aTN = myTNodes[ij];
       aSSID=aTN.ShapeSupportID();
       if (aSSID==SMESH_Block::ID_NONE) {
-       SMDS_MeshNode* aNode = (SMDS_MeshNode*)aTN.Node();
-       meshDS->SetNodeInVolume(aNode, shapeID);
+        SMDS_MeshNode* aNode = (SMDS_MeshNode*)aTN.Node();
+        meshDS->SetNodeInVolume(aNode, shapeID);
       }
     }
   }
@@ -753,22 +677,16 @@ void StdMeshers_Penta_3D::MakeVolumeMesh()
     if ( aN.size() < nbFaceNodes * 2 )
       aN.resize( nbFaceNodes * 2 );
     //
-    k=0;
-    aItNodes=pE0->nodesIterator();
-    while (aItNodes->more()) {
-      //const SMDS_MeshElement* pNode = aItNodes->next();
-      const SMDS_MeshNode* pNode =
-        static_cast<const SMDS_MeshNode*> (aItNodes->next());
-      if(myTool->IsMedium(pNode))
-        continue;
+    for ( k=0; k<nbFaceNodes; ++k ) {
+      const SMDS_MeshNode* pNode = pE0->GetNode(k);
+//       if(myTool->IsMedium(pNode))
+//         continue;
       aID0 = pNode->GetID();
       aJ[k] = GetIndexOnLayer(aID0);
-      if (myErrorStatus) {
+      if (!myErrorStatus->IsOK()) {
         MESSAGE("StdMeshers_Penta_3D::MakeVolumeMesh");
-       return;
+        return;
       }
-      //
-      ++k;
     }
     //
     bool forward = true;
@@ -776,15 +694,15 @@ void StdMeshers_Penta_3D::MakeVolumeMesh()
       i1=i;
       i2=i+1;
       for(j=0; j<nbFaceNodes; ++j) {
-       ij = i1*myJSize+aJ[j];
-       const StdMeshers_TNode& aTN1 = myTNodes[ij];
-       const SMDS_MeshNode* aN1 = aTN1.Node();
-       aN[j]=aN1;
-       //
-       ij=i2*myJSize+aJ[j];
-       const StdMeshers_TNode& aTN2 = myTNodes[ij];
-       const SMDS_MeshNode* aN2 = aTN2.Node();
-       aN[j+nbFaceNodes] = aN2;
+        ij = i1*myJSize+aJ[j];
+        const StdMeshers_TNode& aTN1 = myTNodes[ij];
+        const SMDS_MeshNode* aN1 = aTN1.Node();
+        aN[j]=aN1;
+        //
+        ij=i2*myJSize+aJ[j];
+        const StdMeshers_TNode& aTN2 = myTNodes[ij];
+        const SMDS_MeshNode* aN2 = aTN2.Node();
+        aN[j+nbFaceNodes] = aN2;
       }
       // check if volume orientation will be ok
       if ( i == 0 ) {
@@ -850,8 +768,6 @@ void StdMeshers_Penta_3D::MakeVolumeMesh()
 //=======================================================================
 void StdMeshers_Penta_3D::MakeMeshOnFxy1()
 {
-  myErrorStatus=0;
-  //
   int aID0, aJ, aLevel, ij, aNbNodes, k;
   //
   SMDS_NodeIteratorPtr itn;
@@ -866,6 +782,7 @@ void StdMeshers_Penta_3D::MakeMeshOnFxy1()
   SMESH_Mesh* pMesh = GetMesh();
   SMESHDS_Mesh * meshDS = pMesh->GetMeshDS();
   //
+  SMESH_subMesh *aSubMesh1 = pMesh->GetSubMeshContaining(aFxy1);
   SMESH_subMesh *aSubMesh0 = pMesh->GetSubMeshContaining(aFxy0);
   SMESHDS_SubMesh *aSM0 = aSubMesh0->GetSubMeshDS();
   //
@@ -874,7 +791,7 @@ void StdMeshers_Penta_3D::MakeMeshOnFxy1()
   itn = aSM0->GetNodes();
   aNbNodes = aSM0->NbNodes();
   //printf("** aNbNodes=%d\n", aNbNodes);
-
+  myTool->SetSubShape( aFxy1 ); // to set medium nodes to aFxy1
   //
   // set elements on aFxy1
   vector<const SMDS_MeshNode*> aNodes1;
@@ -889,25 +806,21 @@ void StdMeshers_Penta_3D::MakeMeshOnFxy1()
     aNbNodes = pE0->NbNodes();
     if(myCreateQuadratic)
       aNbNodes = aNbNodes/2;
-//     if (aNbNodes!=3) {
-//       continue;
-//     }
     if ( aNodes1.size() < aNbNodes )
       aNodes1.resize( aNbNodes );
     //
     k = aNbNodes-1; // reverse a face
     aItNodes = pE0->nodesIterator();
     while (aItNodes->more()) {
-      //const SMDS_MeshElement* pNode = aItNodes->next();
       const SMDS_MeshNode* pNode =
         static_cast<const SMDS_MeshNode*> (aItNodes->next());
       if(myTool->IsMedium(pNode))
         continue;
       aID0 = pNode->GetID();
       aJ = GetIndexOnLayer(aID0);
-      if (myErrorStatus) {
+      if (!myErrorStatus->IsOK()) {
         MESSAGE("StdMeshers_Penta_3D::MakeMeshOnFxy1() ");
-       return;
+        return;
       }
       //
       ij = aLevel*myJSize + aJ;
@@ -919,11 +832,9 @@ void StdMeshers_Penta_3D::MakeMeshOnFxy1()
     SMDS_MeshFace * face = 0;
     switch ( aNbNodes ) {
     case 3:
-      //face = meshDS->AddFace(aNodes1[0], aNodes1[1], aNodes1[2]);
       face = myTool->AddFace(aNodes1[0], aNodes1[1], aNodes1[2]);
       break;
     case 4:
-      //face = meshDS->AddFace(aNodes1[0], aNodes1[1], aNodes1[2], aNodes1[3]);
       face = myTool->AddFace(aNodes1[0], aNodes1[1], aNodes1[2], aNodes1[3]);
       break;
     default:
@@ -931,6 +842,18 @@ void StdMeshers_Penta_3D::MakeMeshOnFxy1()
     }
     meshDS->SetMeshElementOnShape(face, aFxy1);
   }
+  myTool->SetSubShape( myShape );
+
+  // update compute state of top face submesh
+  aSubMesh1->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
+
+  // assure that mesh on the top face will be cleaned when it is cleaned
+  // on the bottom face
+  SMESH_subMesh* volSM = pMesh->GetSubMesh( myTool->GetSubShape() );
+  volSM->SetEventListener( new SMESH_subMeshEventListener(true, // deletable by SMESH_subMesh
+                                                          "StdMeshers_Penta_3D"),
+                           SMESH_subMeshEventListenerData::MakeData( aSubMesh1 ),
+                           aSubMesh0 ); // translate CLEAN event of aSubMesh0 to aSubMesh1
 }
 
 //=======================================================================
@@ -939,8 +862,6 @@ void StdMeshers_Penta_3D::MakeMeshOnFxy1()
 //=======================================================================
 void StdMeshers_Penta_3D::ClearMeshOnFxy1()
 {
-  myErrorStatus=0;
-  //
   SMESH_subMesh* aSubMesh;
   SMESH_Mesh* pMesh=GetMesh();
   //
@@ -956,14 +877,13 @@ void StdMeshers_Penta_3D::ClearMeshOnFxy1()
 //=======================================================================
 int StdMeshers_Penta_3D::GetIndexOnLayer(const int aID)
 {
-  myErrorStatus=0;
-  //
   int j=-1;
   StdMeshers_IteratorOfDataMapOfIntegerInteger aMapIt;
   //
   aMapIt=myConnectingMap.find(aID);
   if (aMapIt==myConnectingMap.end()) {
-    myErrorStatus=200;
+    myErrorStatus->myName    = 200;
+    myErrorStatus->myComment = "Internal error of StdMeshers_Penta_3D";
     return j;
   }
   j=(*aMapIt).second;
@@ -990,12 +910,9 @@ void StdMeshers_Penta_3D::MakeConnectingMap()
 //purpose  : 
 //=======================================================================
 void StdMeshers_Penta_3D::CreateNode(const bool bIsUpperLayer,
-                                    const gp_XYZ& aParams,
-                                    StdMeshers_TNode& aTN)
+                                     const gp_XYZ& aParams,
+                                     StdMeshers_TNode& aTN)
 {
-  myErrorStatus=0;
-  //
-  // int iErr;
   double aX, aY, aZ;
   //
   gp_Pnt aP;
@@ -1003,15 +920,15 @@ void StdMeshers_Penta_3D::CreateNode(const bool bIsUpperLayer,
   SMDS_MeshNode* pNode=NULL; 
   aTN.SetNode(pNode);  
   //
-//   if (bIsUpperLayer) {
-//     // point on face Fxy1
-//     const TopoDS_Shape& aS=myBlock.Shape(SMESH_Block::ID_Fxy1);
-//     myBlock.Point(aParams, aS, aP);
-//   }
-//   else {
-//     // point inside solid
-//     myBlock.Point(aParams, aP);
-//   }
+  //   if (bIsUpperLayer) {
+  //     // point on face Fxy1
+  //     const TopoDS_Shape& aS=myBlock.Shape(SMESH_Block::ID_Fxy1);
+  //     myBlock.Point(aParams, aS, aP);
+  //   }
+  //   else {
+  //     // point inside solid
+  //     myBlock.Point(aParams, aP);
+  //   }
   if (bIsUpperLayer) {
     double u = aParams.X(), v = aParams.Y();
     double u1 = ( 1. - u ), v1 = ( 1. - v );
@@ -1029,11 +946,11 @@ void StdMeshers_Penta_3D::CreateNode(const bool bIsUpperLayer,
     SMESH_Block::ShellPoint( aParams, myShapeXYZ, aP.ChangeCoord() );
   }
   //
-//   iErr=myBlock.ErrorStatus();
-//   if (iErr) {
-//     myErrorStatus=12; // can not find the node point;
-//     return;
-//   }
+  //   iErr=myBlock.ErrorStatus();
+  //   if (iErr) {
+  //     myErrorStatus=12; // can not find the node point;
+  //     return;
+  //   }
   //
   aX=aP.X(); aY=aP.Y(); aZ=aP.Z(); 
   //
@@ -1041,7 +958,7 @@ void StdMeshers_Penta_3D::CreateNode(const bool bIsUpperLayer,
   SMESHDS_Mesh* pMeshDS = pMesh->GetMeshDS();
   //
   pNode = pMeshDS->AddNode(aX, aY, aZ);
-  
+
   aTN.SetNode(pNode);
 }
 
@@ -1050,43 +967,42 @@ void StdMeshers_Penta_3D::CreateNode(const bool bIsUpperLayer,
 //purpose  : 
 //=======================================================================
 void StdMeshers_Penta_3D::ShapeSupportID(const bool bIsUpperLayer,
-                                        const SMESH_Block::TShapeID aBNSSID,
-                                        SMESH_Block::TShapeID& aSSID)
+                                         const SMESH_Block::TShapeID aBNSSID,
+                                         SMESH_Block::TShapeID& aSSID)
 {
-  myErrorStatus=0;
-  //
   switch (aBNSSID) {
-    case SMESH_Block::ID_V000:
-      aSSID=(bIsUpperLayer) ?  SMESH_Block::ID_V001 : SMESH_Block::ID_E00z;
-      break;
-    case SMESH_Block::ID_V100:
-      aSSID=(bIsUpperLayer) ?  SMESH_Block::ID_V101 : SMESH_Block::ID_E10z;
-      break; 
-    case SMESH_Block::ID_V110:
-      aSSID=(bIsUpperLayer) ?  SMESH_Block::ID_V111 : SMESH_Block::ID_E11z;
-      break;
-    case SMESH_Block::ID_V010:
-      aSSID=(bIsUpperLayer) ?  SMESH_Block::ID_V011 : SMESH_Block::ID_E01z;
-      break;
-    case SMESH_Block::ID_Ex00:
-      aSSID=(bIsUpperLayer) ?  SMESH_Block::ID_Ex01 : SMESH_Block::ID_Fx0z;
-      break;
-    case SMESH_Block::ID_Ex10:
-      aSSID=(bIsUpperLayer) ?  SMESH_Block::ID_Ex11 : SMESH_Block::ID_Fx1z;
-      break; 
-    case SMESH_Block::ID_E0y0:
-      aSSID=(bIsUpperLayer) ?  SMESH_Block::ID_E0y1 : SMESH_Block::ID_F0yz;
-      break; 
-    case SMESH_Block::ID_E1y0:
-      aSSID=(bIsUpperLayer) ?  SMESH_Block::ID_E1y1 : SMESH_Block::ID_F1yz;
-      break; 
-    case SMESH_Block::ID_Fxy0:
-      aSSID=SMESH_Block::ID_NONE;//(bIsUpperLayer) ?  Shape_ID_Fxy1 : Shape_ID_NONE;
-      break;   
-    default:
-      aSSID=SMESH_Block::ID_NONE;
-      myErrorStatus=10; // Can not find supporting shape ID
-      break;
+  case SMESH_Block::ID_V000:
+    aSSID=(bIsUpperLayer) ?  SMESH_Block::ID_V001 : SMESH_Block::ID_E00z;
+    break;
+  case SMESH_Block::ID_V100:
+    aSSID=(bIsUpperLayer) ?  SMESH_Block::ID_V101 : SMESH_Block::ID_E10z;
+    break; 
+  case SMESH_Block::ID_V110:
+    aSSID=(bIsUpperLayer) ?  SMESH_Block::ID_V111 : SMESH_Block::ID_E11z;
+    break;
+  case SMESH_Block::ID_V010:
+    aSSID=(bIsUpperLayer) ?  SMESH_Block::ID_V011 : SMESH_Block::ID_E01z;
+    break;
+  case SMESH_Block::ID_Ex00:
+    aSSID=(bIsUpperLayer) ?  SMESH_Block::ID_Ex01 : SMESH_Block::ID_Fx0z;
+    break;
+  case SMESH_Block::ID_Ex10:
+    aSSID=(bIsUpperLayer) ?  SMESH_Block::ID_Ex11 : SMESH_Block::ID_Fx1z;
+    break; 
+  case SMESH_Block::ID_E0y0:
+    aSSID=(bIsUpperLayer) ?  SMESH_Block::ID_E0y1 : SMESH_Block::ID_F0yz;
+    break; 
+  case SMESH_Block::ID_E1y0:
+    aSSID=(bIsUpperLayer) ?  SMESH_Block::ID_E1y1 : SMESH_Block::ID_F1yz;
+    break; 
+  case SMESH_Block::ID_Fxy0:
+    aSSID=SMESH_Block::ID_NONE;//(bIsUpperLayer) ?  Shape_ID_Fxy1 : Shape_ID_NONE;
+    break;   
+  default:
+    aSSID=SMESH_Block::ID_NONE;
+    myErrorStatus->myName=10; // Can not find supporting shape ID
+    myErrorStatus->myComment = "Internal error of StdMeshers_Penta_3D";
+    break;
   }
   return;
 }
@@ -1096,8 +1012,6 @@ void StdMeshers_Penta_3D::ShapeSupportID(const bool bIsUpperLayer,
 //=======================================================================
 void StdMeshers_Penta_3D::MakeBlock()
 {
-  myErrorStatus=0;
-  //
   bool bFound;
   int i, j, iNbEV, iNbE, iErr, iCnt, iNbNodes, iNbF;
   //
@@ -1125,25 +1039,25 @@ void StdMeshers_Penta_3D::MakeBlock()
       const SMDS_MeshElement * pElement = itf->next();
       aElementType = pElement->GetType();
       if (aElementType==SMDSAbs_Face) {
-       iNbNodes = pElement->NbNodes();
-       if ( iNbNodes==3 || (myCreateQuadratic && iNbNodes==6) ) {
-         aFTr = aF;
-         ++iCnt;
-         if (iCnt>1) {
-           // \begin{E.A.}
-           // The current algorithm fails if there is more that one
-           // face wich contains triangles ...
-           // In that case, replace return by break to try another
-           // method (coded in "if (iCnt != 1) { ... }")
-           //
+        iNbNodes = pElement->NbNodes();
+        if ( iNbNodes==3 || (pElement->IsQuadratic() && iNbNodes==6) ) {
+          aFTr = aF;
+          ++iCnt;
+          if (iCnt>1) {
+            // \begin{E.A.}
+            // The current algorithm fails if there is more that one
+            // face wich contains triangles ...
+            // In that case, replace return by break to try another
+            // method (coded in "if (iCnt != 1) { ... }")
+            //
             // MESSAGE("StdMeshers_Penta_3D::MakeBlock() ");
-           // myErrorStatus=5; // more than one face has triangulation
-           // return;
-           break;
-           // \end{E.A.}
-         }
-         break; // next face
-       }
+            // myErrorStatus=5; // more than one face has triangulation
+            // return;
+            break;
+            // \end{E.A.}
+          }
+          break; // next face
+        }
       }
     }
   }
@@ -1212,89 +1126,90 @@ void StdMeshers_Penta_3D::MakeBlock()
       int has_only_quad_f6 = 1;
       //
       for (i=1; i<=iNbF; ++i) {
-       int ok = 1;
-       const TopoDS_Shape& aF = aM(i);
-       SMESH_subMesh *aSubMesh = pMesh->GetSubMeshContaining(aF);
-       SMESHDS_SubMesh *aSM = aSubMesh->GetSubMeshDS();
-       SMDS_ElemIteratorPtr itf = aSM->GetElements();
-       while(itf->more()) {
-         const SMDS_MeshElement * pElement = itf->next();
-         aElementType = pElement->GetType();
-         if (aElementType==SMDSAbs_Face) {
-           iNbNodes = pElement->NbNodes();
-           if ( iNbNodes!=4 ) {
-             ok = 0;
-             break ;
-           }
-         }
-       }
-       if (i==1) has_only_quad_f1 = ok ;
-       if (i==2) has_only_quad_f2 = ok ;
-       if (i==3) has_only_quad_f3 = ok ;
-       if (i==4) has_only_quad_f4 = ok ;
-       if (i==5) has_only_quad_f5 = ok ;
-       if (i==6) has_only_quad_f6 = ok ;
+        int ok = 1;
+        const TopoDS_Shape& aF = aM(i);
+        SMESH_subMesh *aSubMesh = pMesh->GetSubMeshContaining(aF);
+        SMESHDS_SubMesh *aSM = aSubMesh->GetSubMeshDS();
+        SMDS_ElemIteratorPtr itf = aSM->GetElements();
+        while(itf->more()) {
+          const SMDS_MeshElement * pElement = itf->next();
+          aElementType = pElement->GetType();
+          if (aElementType==SMDSAbs_Face) {
+            iNbNodes = pElement->NbNodes();
+            if ( iNbNodes!=4 ) {
+              ok = 0;
+              break ;
+            }
+          }
+        }
+        if (i==1) has_only_quad_f1 = ok ;
+        if (i==2) has_only_quad_f2 = ok ;
+        if (i==3) has_only_quad_f3 = ok ;
+        if (i==4) has_only_quad_f4 = ok ;
+        if (i==5) has_only_quad_f5 = ok ;
+        if (i==6) has_only_quad_f6 = ok ;
       }
       //
       TopTools_IndexedMapOfShape aE;
       TopExp::MapShapes(myShape, TopAbs_EDGE, aE);
       int iNbE = aE.Extent();
       if (iNbE == 12) {
-       //
-       int nb_e01 = pMesh->GetSubMeshContaining(aE(1))->GetSubMeshDS()->NbElements();
-       int nb_e02 = pMesh->GetSubMeshContaining(aE(2))->GetSubMeshDS()->NbElements();
-       int nb_e03 = pMesh->GetSubMeshContaining(aE(3))->GetSubMeshDS()->NbElements();
-       int nb_e04 = pMesh->GetSubMeshContaining(aE(4))->GetSubMeshDS()->NbElements();
-       int nb_e05 = pMesh->GetSubMeshContaining(aE(5))->GetSubMeshDS()->NbElements();
-       int nb_e06 = pMesh->GetSubMeshContaining(aE(6))->GetSubMeshDS()->NbElements();
-       int nb_e07 = pMesh->GetSubMeshContaining(aE(7))->GetSubMeshDS()->NbElements();
-       int nb_e08 = pMesh->GetSubMeshContaining(aE(8))->GetSubMeshDS()->NbElements();
-       int nb_e09 = pMesh->GetSubMeshContaining(aE(9))->GetSubMeshDS()->NbElements();
-       int nb_e10 = pMesh->GetSubMeshContaining(aE(10))->GetSubMeshDS()->NbElements();
-       int nb_e11 = pMesh->GetSubMeshContaining(aE(11))->GetSubMeshDS()->NbElements();
-       int nb_e12 = pMesh->GetSubMeshContaining(aE(12))->GetSubMeshDS()->NbElements();
-       //
-       int nb_ok = 0 ;
-       //
-       if ( (nb_e01==nb_e03) && (nb_e03==nb_e05) && (nb_e05==nb_e07) ) {
-         if ( has_only_quad_f1 && has_only_quad_f2 && has_only_quad_f3 && has_only_quad_f4 ) {
-           if ( (nb_e09==nb_e10) && (nb_e08==nb_e06) && (nb_e11==nb_e12) && (nb_e04==nb_e02) ) {
-             if (nb_f5==nb_f6) {
-               nb_ok += 1;
-               aFTr = aM(5);
-             }
-           }
-         }
-       }
-       if ( (nb_e02==nb_e04) && (nb_e04==nb_e06) && (nb_e06==nb_e08) ) {
-         if ( has_only_quad_f1 && has_only_quad_f2 && has_only_quad_f5 && has_only_quad_f6 ) {
-           if ( (nb_e01==nb_e03) && (nb_e10==nb_e12) && (nb_e05==nb_e07) && (nb_e09==nb_e11) ) {
-             if (nb_f3==nb_f4) {
-               nb_ok += 1;
-               aFTr = aM(3);
-             }
-           }
-         }
-       }
-       if ( (nb_e09==nb_e10) && (nb_e10==nb_e11) && (nb_e11==nb_e12) ) {
-         if ( has_only_quad_f3 && has_only_quad_f4 && has_only_quad_f5 && has_only_quad_f6 ) {
-           if ( (nb_e01==nb_e05) && (nb_e02==nb_e06) && (nb_e03==nb_e07) && (nb_e04==nb_e08) ) {
-             if (nb_f1==nb_f2) {
-               nb_ok += 1;
-               aFTr = aM(1);
-             }
-           }
-         }
-       }
-       //
-       if ( nb_ok == 1 ) {
-         isOK = 1;
-       }
-       //
+        //
+        int nb_e01 = pMesh->GetSubMeshContaining(aE(1))->GetSubMeshDS()->NbElements();
+        int nb_e02 = pMesh->GetSubMeshContaining(aE(2))->GetSubMeshDS()->NbElements();
+        int nb_e03 = pMesh->GetSubMeshContaining(aE(3))->GetSubMeshDS()->NbElements();
+        int nb_e04 = pMesh->GetSubMeshContaining(aE(4))->GetSubMeshDS()->NbElements();
+        int nb_e05 = pMesh->GetSubMeshContaining(aE(5))->GetSubMeshDS()->NbElements();
+        int nb_e06 = pMesh->GetSubMeshContaining(aE(6))->GetSubMeshDS()->NbElements();
+        int nb_e07 = pMesh->GetSubMeshContaining(aE(7))->GetSubMeshDS()->NbElements();
+        int nb_e08 = pMesh->GetSubMeshContaining(aE(8))->GetSubMeshDS()->NbElements();
+        int nb_e09 = pMesh->GetSubMeshContaining(aE(9))->GetSubMeshDS()->NbElements();
+        int nb_e10 = pMesh->GetSubMeshContaining(aE(10))->GetSubMeshDS()->NbElements();
+        int nb_e11 = pMesh->GetSubMeshContaining(aE(11))->GetSubMeshDS()->NbElements();
+        int nb_e12 = pMesh->GetSubMeshContaining(aE(12))->GetSubMeshDS()->NbElements();
+        //
+        int nb_ok = 0 ;
+        //
+        if ( (nb_e01==nb_e03) && (nb_e03==nb_e05) && (nb_e05==nb_e07) ) {
+          if ( has_only_quad_f1 && has_only_quad_f2 && has_only_quad_f3 && has_only_quad_f4 ) {
+            if ( (nb_e09==nb_e10) && (nb_e08==nb_e06) && (nb_e11==nb_e12) && (nb_e04==nb_e02) ) {
+              if (nb_f5==nb_f6) {
+                nb_ok += 1;
+                aFTr = aM(5);
+              }
+            }
+          }
+        }
+        if ( (nb_e02==nb_e04) && (nb_e04==nb_e06) && (nb_e06==nb_e08) ) {
+          if ( has_only_quad_f1 && has_only_quad_f2 && has_only_quad_f5 && has_only_quad_f6 ) {
+            if ( (nb_e01==nb_e03) && (nb_e10==nb_e12) && (nb_e05==nb_e07) && (nb_e09==nb_e11) ) {
+              if (nb_f3==nb_f4) {
+                nb_ok += 1;
+                aFTr = aM(3);
+              }
+            }
+          }
+        }
+        if ( (nb_e09==nb_e10) && (nb_e10==nb_e11) && (nb_e11==nb_e12) ) {
+          if ( has_only_quad_f3 && has_only_quad_f4 && has_only_quad_f5 && has_only_quad_f6 ) {
+            if ( (nb_e01==nb_e05) && (nb_e02==nb_e06) && (nb_e03==nb_e07) && (nb_e04==nb_e08) ) {
+              if (nb_f1==nb_f2) {
+                nb_ok += 1;
+                aFTr = aM(1);
+              }
+            }
+          }
+        }
+        //
+        if ( nb_ok == 1 ) {
+          isOK = 1;
+        }
+        //
       }
     }
     if (!isOK) {
-      myErrorStatus=5; // more than one face has triangulation
+      myErrorStatus->myName=5; // more than one face has triangulation
+      myErrorStatus->myComment="Incorrect input mesh";
       return;
     }
   }
@@ -1307,9 +1222,11 @@ void StdMeshers_Penta_3D::MakeBlock()
   //
   // 1.1 Base vertex V000
   iNbE = aME.Extent();
-  if (iNbE!=4){
+  if (iNbE!= NB_WALL_FACES ){
     MESSAGE("StdMeshers_Penta_3D::MakeBlock() ");
-    myErrorStatus=7; // too few edges are in base face aFTr 
+    myErrorStatus->myName=7; // too few edges are in base face aFTr
+    myErrorStatus->myComment=SMESH_Comment("Not a quadrilateral face #")
+      <<pMesh->GetMeshDS()->ShapeToIndex( aFTr )<<": "<<iNbE<<" edges" ;
     return;
   }
   const TopoDS_Edge& aE1=TopoDS::Edge(aME(1));
@@ -1324,7 +1241,9 @@ void StdMeshers_Penta_3D::MakeBlock()
   iNbEV=aMEV.Extent();
   if (iNbEV!=3){
     MESSAGE("StdMeshers_Penta_3D::MakeBlock() ");
-    myErrorStatus=7; // too few edges meet in base vertex 
+    myErrorStatus->myName=7; // too few edges meet in base vertex 
+    myErrorStatus->myComment=SMESH_Comment("3 edges must share vertex #")
+      <<pMesh->GetMeshDS()->ShapeToIndex( aV000 )<<" but there are "<<iNbEV<<" edges";
     return;
   }
   //
@@ -1338,18 +1257,20 @@ void StdMeshers_Penta_3D::MakeBlock()
       const TopoDS_Edge& aE=TopoDS::Edge(aEx);
       TopExp::Vertices(aE, aV[0], aV[1]);
       for (i=0; i<2; ++i) {
-       if (!aV[i].IsSame(aV000)) {
-         aV001=aV[i];
-         bFound=!bFound;
-         break;
-       }
+        if (!aV[i].IsSame(aV000)) {
+          aV001=aV[i];
+          bFound=!bFound;
+          break;
+        }
       }
     }
   }
   //
   if (!bFound) {
     MESSAGE("StdMeshers_Penta_3D::MakeBlock() ");
-    myErrorStatus=8; // can not find reper V001 
+    myErrorStatus->myName=8; // can not find reper V001
+    myErrorStatus->myComment=SMESH_Comment("Can't find opposite vertex for vertex #")
+      <<pMesh->GetMeshDS()->ShapeToIndex( aV000 );
     return;
   }
   //DEB
@@ -1366,7 +1287,8 @@ void StdMeshers_Penta_3D::MakeBlock()
   iNbE=aME.Extent();
   if (iNbE!=1) {
     MESSAGE("StdMeshers_Penta_3D::MakeBlock() ");
-    myErrorStatus=9; // number of shells in source shape !=1 
+    myErrorStatus->myName=9; // number of shells in source shape !=1
+    myErrorStatus->myComment=SMESH_Comment("Unexpected nb of shells ")<<iNbE;
     return;
   }
   //
@@ -1376,7 +1298,7 @@ void StdMeshers_Penta_3D::MakeBlock()
   iErr = myBlock.ErrorStatus();
   if (iErr) {
     MESSAGE("StdMeshers_Penta_3D::MakeBlock() ");
-    myErrorStatus=100; // SMESHBlock: Load operation failed
+    myErrorStatus=myBlock.GetError(); // SMESHBlock: Load operation failed
     return;
   }
 }
@@ -1386,8 +1308,6 @@ void StdMeshers_Penta_3D::MakeBlock()
 //=======================================================================
 void StdMeshers_Penta_3D::CheckData()
 {
-  myErrorStatus=0;
-  //
   int i, iNb;
   int iNbEx[]={8, 12, 6};
   //
@@ -1399,14 +1319,16 @@ void StdMeshers_Penta_3D::CheckData()
   //
   if (myShape.IsNull()){
     MESSAGE("StdMeshers_Penta_3D::CheckData() ");
-    myErrorStatus=2; // null shape
+    myErrorStatus->myName=2; // null shape
+    myErrorStatus->myComment="Null shape";
     return;
   }
   //
   aST=myShape.ShapeType();
   if (!(aST==TopAbs_SOLID || aST==TopAbs_SHELL)) {
     MESSAGE("StdMeshers_Penta_3D::CheckData() ");
-    myErrorStatus=3; // not compatible type of shape
+    myErrorStatus->myName=3; // not compatible type of shape
+    myErrorStatus->myComment=SMESH_Comment("Wrong shape type (TopAbs_ShapeEnum) ")<<aST;
     return;
   }
   //
@@ -1416,7 +1338,8 @@ void StdMeshers_Penta_3D::CheckData()
     iNb=aM.Extent();
     if (iNb!=iNbEx[i]){
       MESSAGE("StdMeshers_Penta_3D::CheckData() ");
-      myErrorStatus=4; // number of subshape is not compatible
+      myErrorStatus->myName=4; // number of sub-shape is not compatible
+      myErrorStatus->myComment="Wrong number of sub-shapes of a block";
       return;
     }
   }
@@ -1448,7 +1371,7 @@ bool StdMeshers_Penta_3D::LoadIJNodes(StdMeshers_IJNodeMap & theIJNodes,
   TopExp_Explorer exp( theFace, TopAbs_EDGE );
   int nbEdges = 0;
   for ( ; exp.More(); exp.Next() ) {
-    if ( ++nbEdges > 4 ) {
+    if ( ++nbEdges > NB_WALL_FACES ) {
       return false; // more than 4 edges in theFace
     }
     TopoDS_Edge e = TopoDS::Edge( exp.Current() );
@@ -1467,7 +1390,7 @@ bool StdMeshers_Penta_3D::LoadIJNodes(StdMeshers_IJNodeMap & theIJNodes,
     else
       e2 = e;
   }
-  if ( nbEdges < 4 ) {
+  if ( nbEdges < NB_WALL_FACES ) {
     return false; // less than 4 edges in theFace
   }
 
@@ -1482,7 +1405,7 @@ bool StdMeshers_Penta_3D::LoadIJNodes(StdMeshers_IJNodeMap & theIJNodes,
   SMESHDS_SubMesh* smVft = theMesh->MeshElements( vft );
   if (!smFace || !smb || !smt || !sm1 || !sm2 || !smVfb || !smVlb || !smVft ) {
     MESSAGE( "NULL submesh " <<smFace<<" "<<smb<<" "<<smt<<" "<<
-            sm1<<" "<<sm2<<" "<<smVfb<<" "<<smVlb<<" "<<smVft);
+             sm1<<" "<<sm2<<" "<<smVfb<<" "<<smVlb<<" "<<smVft);
     return false;
   }
   if ( smb->NbNodes() != smt->NbNodes() || sm1->NbNodes() != sm2->NbNodes() ) {
@@ -1503,13 +1426,13 @@ bool StdMeshers_Penta_3D::LoadIJNodes(StdMeshers_IJNodeMap & theIJNodes,
       int nf = sm1->NbNodes()*smb->NbNodes() - n3*n4;
       if( nf != smFace->NbNodes() ) {
         MESSAGE( "Wrong nb face nodes: " <<
-                sm1->NbNodes()<<" "<<smb->NbNodes()<<" "<<smFace->NbNodes());
+                 sm1->NbNodes()<<" "<<smb->NbNodes()<<" "<<smFace->NbNodes());
         return false;
       }
     }
     else {
       MESSAGE( "Wrong nb face nodes: " <<
-              sm1->NbNodes()<<" "<<smb->NbNodes()<<" "<<smFace->NbNodes());
+               sm1->NbNodes()<<" "<<smb->NbNodes()<<" "<<smFace->NbNodes());
       return false;
     }
   }
@@ -1544,7 +1467,7 @@ bool StdMeshers_Penta_3D::LoadIJNodes(StdMeshers_IJNodeMap & theIJNodes,
     if(myTool->IsMedium(node))
       continue;
     const SMDS_EdgePosition* pos =
-      dynamic_cast<const SMDS_EdgePosition*>( node->GetPosition().get() );
+      dynamic_cast<const SMDS_EdgePosition*>( node->GetPosition() );
     if ( !pos ) {
       return false;
     }
@@ -1567,7 +1490,7 @@ bool StdMeshers_Penta_3D::LoadIJNodes(StdMeshers_IJNodeMap & theIJNodes,
     if(myTool->IsMedium(node))
       continue;
     const SMDS_EdgePosition* pos =
-      dynamic_cast<const SMDS_EdgePosition*>( node->GetPosition().get() );
+      dynamic_cast<const SMDS_EdgePosition*>( node->GetPosition() );
     if ( !pos ) {
       return false;
     }
@@ -1585,12 +1508,12 @@ bool StdMeshers_Penta_3D::LoadIJNodes(StdMeshers_IJNodeMap & theIJNodes,
   // try to load the rest nodes
 
   // get all faces from theFace
-  map<int,const SMDS_MeshElement*> allFaces, foundFaces;
+  TIDSortedElemSet allFaces, foundFaces;
   SMDS_ElemIteratorPtr eIt = smFace->GetElements();
   while ( eIt->more() ) {
     const SMDS_MeshElement* e = eIt->next();
     if ( e->GetType() == SMDSAbs_Face )
-      allFaces.insert( make_pair(e->GetID(),e) );
+      allFaces.insert( e );
   }
   // Starting from 2 neighbour nodes on theBaseEdge, look for a face
   // the nodes belong to, and between the nodes of the found face,
@@ -1611,7 +1534,7 @@ bool StdMeshers_Penta_3D::LoadIJNodes(StdMeshers_IJNodeMap & theIJNodes,
     const SMDS_MeshElement* face = 0;
     do {
       // look for a face by 2 nodes
-      face = SMESH_MeshEditor::FindFaceInSet( n1, n2, allFaces, foundFaces );
+      face = SMESH_MeshAlgos::FindFaceInSet( n1, n2, allFaces, foundFaces );
       if ( face ) {
         int nbFaceNodes = face->NbNodes();
         if ( (!myCreateQuadratic && nbFaceNodes>4) ||
@@ -1637,14 +1560,14 @@ bool StdMeshers_Penta_3D::LoadIJNodes(StdMeshers_IJNodeMap & theIJNodes,
             return false;
           }
           par_nVec_2->second[ row ] = node;
-          foundFaces.insert( make_pair(face->GetID(),face) );
+          foundFaces.insert( face );
           n2 = node;
           if ( nbFaceNodes==4 || (myCreateQuadratic && nbFaceNodes==8) ) {
             n1 = par_nVec_1->second[ row ];
           }
         }
         else if ( (nbFaceNodes==3 || (myCreateQuadratic && nbFaceNodes==6) )  &&
-                 n3 == par_nVec_1->second[ row ] ) {
+                  n3 == par_nVec_1->second[ row ] ) {
           n1 = n3;
         }
         else {
@@ -1713,6 +1636,28 @@ int StdMeshers_SMESHBlock::ErrorStatus() const
   return myErrorStatus;
 }
 
+//================================================================================
+/*!
+ * \brief Return problem description
+ */
+//================================================================================
+
+SMESH_ComputeErrorPtr StdMeshers_SMESHBlock::GetError() const
+{
+  SMESH_ComputeErrorPtr err = SMESH_ComputeError::New();
+  string & text = err->myComment;
+  switch ( myErrorStatus ) {
+  case 2:
+  case 3: text = "Internal error of StdMeshers_Penta_3D"; break; 
+  case 4: text = "Can't compute normalized parameters of a point inside a block"; break;
+  case 5: text = "Can't compute coordinates by normalized parameters inside a block"; break;
+  case 6: text = "Can't detect block sub-shapes. Not a block?"; break;
+  }
+  if (!text.empty())
+    err->myName = myErrorStatus;
+  return err;
+}
+
 //=======================================================================
 //function : Load
 //purpose  : 
@@ -1729,8 +1674,8 @@ void StdMeshers_SMESHBlock::Load(const TopoDS_Shell& theShell)
 //purpose  : 
 //=======================================================================
 void StdMeshers_SMESHBlock::Load(const TopoDS_Shell& theShell,
-                                const TopoDS_Vertex& theV000,
-                                const TopoDS_Vertex& theV001)
+                                 const TopoDS_Vertex& theV000,
+                                 const TopoDS_Vertex& theV001)
 {
   myErrorStatus=0;
   //
@@ -1741,7 +1686,7 @@ void StdMeshers_SMESHBlock::Load(const TopoDS_Shell& theShell,
   myShapeIDMap.Clear();  
   bOk = myTBlock.LoadBlockShapes(myShell, theV000, theV001, myShapeIDMap);
   if (!bOk) {
-    myErrorStatus=2;
+    myErrorStatus=6;
     return;
   }
 }
@@ -1751,7 +1696,7 @@ void StdMeshers_SMESHBlock::Load(const TopoDS_Shell& theShell,
 //purpose  : 
 //=======================================================================
 void StdMeshers_SMESHBlock::ComputeParameters(const gp_Pnt& thePnt, 
-                                             gp_XYZ& theXYZ)
+                                              gp_XYZ& theXYZ)
 {
   ComputeParameters(thePnt, myShell, theXYZ);
 }
@@ -1761,7 +1706,7 @@ void StdMeshers_SMESHBlock::ComputeParameters(const gp_Pnt& thePnt,
 //purpose  : 
 //=======================================================================
 void StdMeshers_SMESHBlock::ComputeParameters(const gp_Pnt& thePnt,
-                                             const TopoDS_Shape& theShape,
+                                              const TopoDS_Shape& theShape,
                                               gp_XYZ& theXYZ)
 {
   myErrorStatus=0;
@@ -1799,7 +1744,7 @@ void StdMeshers_SMESHBlock::ComputeParameters(const double& theU,
     return;
   }
   if ( SMESH_Block::IsEdgeID( aID ))
-      bOk = myTBlock.EdgeParameters( aID, theU, theXYZ );
+    bOk = myTBlock.EdgeParameters( aID, theU, theXYZ );
   if (!bOk) {
     myErrorStatus=4; // problems with computation Parameters 
     return;
@@ -1810,8 +1755,7 @@ void StdMeshers_SMESHBlock::ComputeParameters(const double& theU,
 //function : Point
 //purpose  : 
 //=======================================================================
- void StdMeshers_SMESHBlock::Point(const gp_XYZ& theParams,
-                                  gp_Pnt& aP3D)
+void StdMeshers_SMESHBlock::Point(const gp_XYZ& theParams, gp_Pnt& aP3D)
 {
   TopoDS_Shape aS;
   //
@@ -1822,9 +1766,9 @@ void StdMeshers_SMESHBlock::ComputeParameters(const double& theU,
 //function : Point
 //purpose  : 
 //=======================================================================
- void StdMeshers_SMESHBlock::Point(const gp_XYZ& theParams,
-                                  const TopoDS_Shape& theShape,
-                                  gp_Pnt& aP3D)
+void StdMeshers_SMESHBlock::Point(const gp_XYZ& theParams,
+                                  const TopoDS_Shape& theShape,
+                                  gp_Pnt& aP3D)
 {
   myErrorStatus = 0;
   //
@@ -1855,7 +1799,7 @@ void StdMeshers_SMESHBlock::ComputeParameters(const double& theU,
     }
   }
   if (!bOk) {
-    myErrorStatus=4; // problems with point computation 
+    myErrorStatus=5; // problems with point computation 
     return;
   }
   aP3D.SetXYZ(aXYZ);
@@ -1910,3 +1854,112 @@ const TopoDS_Shape& StdMeshers_SMESHBlock::Shape(const int theID)
 }
 
 
+//=======================================================================
+//function : Evaluate
+//purpose  : 
+//=======================================================================
+bool StdMeshers_Penta_3D::Evaluate(SMESH_Mesh& aMesh, 
+                                   const TopoDS_Shape& aShape,
+                                   MapShapeNbElems& aResMap)
+{
+  MESSAGE("StdMeshers_Penta_3D::Evaluate()");
+
+  // find face contains only triangles
+  vector < SMESH_subMesh * >meshFaces;
+  TopTools_SequenceOfShape aFaces;
+  int NumBase = 0, i = 0;
+  for (TopExp_Explorer exp(aShape, TopAbs_FACE); exp.More(); exp.Next()) {
+    i++;
+    aFaces.Append(exp.Current());
+    SMESH_subMesh *aSubMesh = aMesh.GetSubMesh(exp.Current());
+    meshFaces.push_back(aSubMesh);
+    MapShapeNbElemsItr anIt = aResMap.find(meshFaces[i]);
+    if( anIt == aResMap.end() ) {
+      NumBase = 0;
+      break;
+    }
+    std::vector<int> aVec = (*anIt).second;
+    int nbtri = Max(aVec[SMDSEntity_Triangle],aVec[SMDSEntity_Quad_Triangle]);
+    int nbqua = Max(aVec[SMDSEntity_Quadrangle],aVec[SMDSEntity_Quad_Quadrangle]);
+    if( nbtri>0 && nbqua==0 ) {
+      NumBase = i;
+    }
+  }
+
+  if(NumBase==0) {
+    std::vector<int> aResVec(SMDSEntity_Last);
+    for(int i=SMDSEntity_Node; i<SMDSEntity_Last; i++) aResVec[i] = 0;
+    SMESH_subMesh * sm = aMesh.GetSubMesh(aShape);
+    aResMap.insert(std::make_pair(sm,aResVec));
+    myErrorStatus->myName    = COMPERR_ALGO_FAILED;
+    myErrorStatus->myComment = "Submesh can not be evaluated";
+    return false;
+  }
+
+  // find number of 1d elems for base face
+  int nb1d = 0;
+  TopTools_MapOfShape Edges1;
+  for (TopExp_Explorer exp(aFaces.Value(NumBase), TopAbs_EDGE); exp.More(); exp.Next()) {
+    Edges1.Add(exp.Current());
+    SMESH_subMesh *sm = aMesh.GetSubMesh(exp.Current());
+    if( sm ) {
+      MapShapeNbElemsItr anIt = aResMap.find(sm);
+      if( anIt == aResMap.end() ) continue;
+      std::vector<int> aVec = (*anIt).second;
+      nb1d += Max(aVec[SMDSEntity_Edge],aVec[SMDSEntity_Quad_Edge]);
+    }
+  }
+  // find face opposite to base face
+  int OppNum = 0;
+  for(i=1; i<=6; i++) {
+    if(i==NumBase) continue;
+    bool IsOpposite = true;
+    for(TopExp_Explorer exp(aFaces.Value(i), TopAbs_EDGE); exp.More(); exp.Next()) {
+      if( Edges1.Contains(exp.Current()) ) {
+        IsOpposite = false;
+        break;
+      }
+    }
+    if(IsOpposite) {
+      OppNum = i;
+      break;
+    }
+  }
+  // find number of 2d elems on side faces
+  int nb2d = 0;
+  for(i=1; i<=6; i++) {
+    if( i==OppNum || i==NumBase ) continue;
+    MapShapeNbElemsItr anIt = aResMap.find( meshFaces[i-1] );
+    if( anIt == aResMap.end() ) continue;
+    std::vector<int> aVec = (*anIt).second;
+    nb2d += Max(aVec[SMDSEntity_Quadrangle],aVec[SMDSEntity_Quad_Quadrangle]);
+  }
+
+  MapShapeNbElemsItr anIt = aResMap.find( meshFaces[NumBase-1] );
+  std::vector<int> aVec = (*anIt).second;
+  int nb2d_face0 = Max(aVec[SMDSEntity_Quadrangle],aVec[SMDSEntity_Quad_Quadrangle]);
+  int nb0d_face0 = aVec[SMDSEntity_Node];
+
+  anIt = aResMap.find( meshFaces[OppNum-1] );
+  for(i=SMDSEntity_Node; i<SMDSEntity_Last; i++)
+    (*anIt).second[i] = aVec[i];
+
+  SMESH_MesherHelper aTool (aMesh);
+  bool _quadraticMesh = aTool.IsQuadraticSubMesh(aShape);
+
+  std::vector<int> aResVec(SMDSEntity_Last);
+  for(int i=SMDSEntity_Node; i<SMDSEntity_Last; i++) aResVec[i] = 0;
+  if(_quadraticMesh) {
+    aResVec[SMDSEntity_Quad_Penta] = nb2d_face0 * ( nb2d/nb1d );
+    aResVec[SMDSEntity_Node] = nb0d_face0 * ( 2*nb2d/nb1d - 1 );
+  }
+  else {
+    aResVec[SMDSEntity_Node] = nb0d_face0 * ( nb2d/nb1d - 1 );
+    aResVec[SMDSEntity_Penta] = nb2d_face0 * ( nb2d/nb1d );
+  }
+  SMESH_subMesh * sm = aMesh.GetSubMesh(aShape);
+  aResMap.insert(std::make_pair(sm,aResVec));
+
+  return true;
+}
+