]> SALOME platform Git repositories - plugins/blsurfplugin.git/commitdiff
Salome HOME
Add remesher gpusph_v2
authoreap <eap@opencascade.com>
Fri, 22 Dec 2017 12:02:38 +0000 (15:02 +0300)
committereap <eap@opencascade.com>
Fri, 22 Dec 2017 12:02:38 +0000 (15:02 +0300)
15 files changed:
resources/BLSURFPlugin.xml
src/BLSURFPlugin/BLSURFPluginBuilder.py
src/BLSURFPlugin/BLSURFPlugin_BLSURF.cxx
src/BLSURFPlugin/BLSURFPlugin_BLSURF.hxx
src/BLSURFPlugin/BLSURFPlugin_BLSURF_i.cxx
src/BLSURFPlugin/BLSURFPlugin_BLSURF_i.hxx
src/BLSURFPlugin/BLSURFPlugin_Hypothesis.cxx
src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx
src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx
src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.hxx
src/BLSURFPlugin/BLSURFPlugin_i.cxx
src/GUI/BLSURFPluginGUI.cxx
src/GUI/BLSURFPluginGUI_HypothesisCreator.cxx
src/GUI/BLSURFPluginGUI_HypothesisCreator.h
src/GUI/BLSURFPlugin_images.ts

index d4360377c4c89f502b10d6ff84150ad9e67bc4b0..7ba53d018c049ce0000c46673c1c61e810b2c9dd 100644 (file)
@@ -31,6 +31,7 @@
                server-lib="BLSURFEngine"
                gui-lib="BLSURFPluginGUI">
   <hypotheses>
+
     <hypothesis type="MG-CADSurf Parameters"
                label-id="MG-CADSurf Parameters"
                icon-id="mesh_hypo_BLSURF.png"
       </python-wrap>
     </hypothesis>
 
+    <hypothesis type="MG-CADSurf Parameters_NOGEOM"
+               label-id="MG-CADSurf Parameters"
+               icon-id="mesh_hypo_BLSURF.png"
+               dim="2">
+      <python-wrap>
+        <accumulative-methods>
+          SetOptionValue,
+          SetPreCADOptionValue,
+          UnsetOption,
+          UnsetPreCADOption,
+          AddOption,
+          AddPreCADOption,
+          SetSizeMap,
+          SetConstantSizeMap,
+          UnsetSizeMap,
+          SetAttractor,
+          UnsetAttractor,
+          SetAttractorGeom,
+          UnsetAttractorGeom,
+          SetEnforcedVertex,
+          SetEnforcedVertexNamed,
+          SetEnforcedVertexGeom,
+          SetEnforcedVertexWithGroup,
+          SetEnforcedVertexNamedWithGroup,
+          SetEnforcedVertexGeomWithGroup,
+          UnsetEnforcedVertex,
+          UnsetEnforcedVertexGeom,
+          UnsetEnforcedVertices,
+          AddEnforcedVertex,
+          AddEnforcedVertexNamed,
+          AddEnforcedVertexGeom,
+          AddEnforcedVertexWithGroup,
+          AddEnforcedVertexNamedWithGroup,
+          AddEnforcedVertexGeomWithGroup,
+          RemoveEnforcedVertex,
+          RemoveEnforcedVertexGeom,
+          RemoveEnforcedVertices,
+          AddPreCadFacesPeriodicity
+        </accumulative-methods>
+      </python-wrap>
+    </hypothesis>
+
   </hypotheses>
   <algorithms>
 
       </python-wrap>
     </algorithm>
 
+    <algorithm type="MG-CADSurf_NOGEOM"
+               label-id="MG-CADSurf"
+               icon-id="mesh_algo_BLSURF.png"
+               opt-hypos="MG-CADSurf Parameters_NOGEOM"
+               output="TRIA,QUAD"
+               need-geom="never"
+               dim="2">
+      <python-wrap>
+        <algo>MG-CADSurf_NOGEOM=Triangle(algo=smeshBuilder.MG_CADSurf)</algo>
+        <hypo>MG-CADSurf Parameters_NOGEOM=Parameters()</hypo>
+      </python-wrap>
+    </algorithm>
+
   </algorithms>
 </meshers-group>
 
index 369a94f6df154d996c67cd742cd29ce18f122704..8fcb6e959f06c583b2db517920f118b91b07c6ee 100644 (file)
@@ -87,7 +87,11 @@ class BLSURF_Algorithm(Mesh_Algorithm):
     Mesh_Algorithm.__init__(self)
     if noBLSURFPlugin:
       print "Warning: BLSURFPlugin module unavailable"
-    self.Create(mesh, geom, BLSURF, LIBRARY)
+    if mesh.GetMesh().HasShapeToMesh():
+      self.Create(mesh, geom, self.algoType, LIBRARY)
+    else:
+      self.Create(mesh, geom, self.algoType+"_NOGEOM", LIBRARY)
+      mesh.smeshpyD.SetName( self.algo, self.algoType )
     self.params=None
     self.geompyD = mesh.geompyD
     #self.SetPhysicalMesh() - PAL19680
@@ -643,8 +647,13 @@ class BLSURF_Algorithm(Mesh_Algorithm):
   #  @return hypothesis object
   def Parameters(self):
     if not self.params:
-      self.params = self.Hypothesis("MG-CADSurf Parameters", [],
-                                    LIBRARY, UseExisting=0)
+      hypType = "MG-CADSurf Parameters"
+      hasGeom = self.mesh.GetMesh().HasShapeToMesh()
+      if hasGeom:
+        self.params = self.Hypothesis(hypType, [], LIBRARY, UseExisting=0)
+      else:
+        self.params = self.Hypothesis(hypType + "_NOGEOM", [], LIBRARY, UseExisting=0)
+        self.mesh.smeshpyD.SetName( self.params, hypType )
       pass
     return self.params
 
index 5a2acd99018fe3ac079d88605e39e58977ac171d..71c5b07fb65fef98838e4bdce030ac5225da5b4a 100644 (file)
@@ -226,6 +226,7 @@ TopTools_IndexedMapOfShape FacesWithEnforcedVertices;
 std::map< int, BLSURFPlugin_Hypothesis::TEnfVertexCoordsList > FaceId2EnforcedVertexCoords;
 std::map< BLSURFPlugin_Hypothesis::TEnfVertexCoords, BLSURFPlugin_Hypothesis::TEnfVertexCoords > EnfVertexCoords2ProjVertex;
 std::map< BLSURFPlugin_Hypothesis::TEnfVertexCoords, BLSURFPlugin_Hypothesis::TEnfVertexList > EnfVertexCoords2EnfVertexList;
+SMESH_MesherHelper* theHelper;
 
 bool HasSizeMapOnFace=false;
 bool HasSizeMapOnEdge=false;
@@ -238,18 +239,22 @@ bool HasSizeMapOnVertex=false;
  */
 //=============================================================================
 
-BLSURFPlugin_BLSURF::BLSURFPlugin_BLSURF(int hypId, int studyId,
-                                               SMESH_Gen* gen)
+BLSURFPlugin_BLSURF::BLSURFPlugin_BLSURF(int        hypId,
+                                         int        studyId,
+                                         SMESH_Gen* gen,
+                                         bool       theHasGEOM)
   : SMESH_2D_Algo(hypId, studyId, gen)
 {
-  _name = "MG-CADSurf";//"BLSURF";
+  _name = theHasGEOM ? "MG-CADSurf" : "MG-CADSurf_NOGEOM";//"BLSURF";
   _shapeType = (1 << TopAbs_FACE); // 1 bit /shape type
-  _compatibleHypothesis.push_back(BLSURFPlugin_Hypothesis::GetHypType());
-  _compatibleHypothesis.push_back(StdMeshers_ViscousLayers2D::GetHypType());
+  _compatibleHypothesis.push_back(BLSURFPlugin_Hypothesis::GetHypType(theHasGEOM));
+  if ( theHasGEOM )
+    _compatibleHypothesis.push_back(StdMeshers_ViscousLayers2D::GetHypType());
   _requireDiscreteBoundary = false;
   _onlyUnaryInput = false;
   _hypothesis = NULL;
   _supportSubmeshes = true;
+  _requireShape = theHasGEOM;
 
   smeshGen_i = SMESH_Gen_i::GetSMESHGen();
   CORBA::Object_var anObject = smeshGen_i->GetNS()->Resolve("/myStudyManager");
@@ -332,7 +337,8 @@ bool BLSURFPlugin_BLSURF::CheckHypothesis
   {
     theHyp = *itl;
     string hypName = theHyp->GetName();
-    if ( hypName == BLSURFPlugin_Hypothesis::GetHypType() )
+    if ( hypName == BLSURFPlugin_Hypothesis::GetHypType(true) ||
+         hypName == BLSURFPlugin_Hypothesis::GetHypType(false) )
     {
       _hypothesis = static_cast<const BLSURFPlugin_Hypothesis*> (theHyp);
       ASSERT(_hypothesis);
@@ -402,34 +408,85 @@ typedef struct {
         gp_XY uv;
         gp_XYZ xyz;
 } projectionPoint;
+
 /////////////////////////////////////////////////////////
-projectionPoint getProjectionPoint(const TopoDS_Face& face, const gp_Pnt& point)
+
+projectionPoint getProjectionPoint(const TopoDS_Face& theFace, const gp_Pnt& thePoint)
 {
   projectionPoint myPoint;
-  Handle(Geom_Surface) surface = BRep_Tool::Surface(face);
-  GeomAPI_ProjectPointOnSurf projector( point, surface );
-  if ( !projector.IsDone() || projector.NbPoints()==0 )
-    throw "getProjectionPoint: Can't project";
-
-  Quantity_Parameter u,v;
-  projector.LowerDistanceParameters(u,v);
-  myPoint.uv = gp_XY(u,v);
-  gp_Pnt aPnt = projector.NearestPoint();
-  myPoint.xyz = gp_XYZ(aPnt.X(),aPnt.Y(),aPnt.Z());
-  //return gp_XY(u,v);
-  return myPoint;
-}
-/////////////////////////////////////////////////////////
 
-/////////////////////////////////////////////////////////
-double getT(const TopoDS_Edge& edge, const gp_Pnt& point)
-{
-  Standard_Real f,l;
-  Handle(Geom_Curve) curve = BRep_Tool::Curve(edge, f,l);
-  GeomAPI_ProjectPointOnCurve projector( point, curve);
-  if ( projector.NbPoints() == 0 )
-    throw;
-  return projector.LowerDistanceParameter();
+  if ( theFace.IsNull() )
+  {
+    TopoDS_Shape foundFace, myShape = theHelper->GetSubShape();
+    TopTools_MapOfShape checkedFaces;
+    std::map< double, std::pair< TopoDS_Face, gp_Pnt2d > > dist2face;
+
+    for ( TopExp_Explorer exp ( myShape, TopAbs_FACE ); exp.More(); exp.Next())
+    {
+      const TopoDS_Face& face = TopoDS::Face( exp.Current() );
+      if ( !checkedFaces.Add( face )) continue;
+
+      // check distance to face
+      Handle(ShapeAnalysis_Surface) surface = theHelper->GetSurface( face );
+      gp_Pnt2d uv = surface->ValueOfUV( thePoint, Precision::Confusion());
+      double distance = surface->Gap();
+      if ( distance > Precision::Confusion() )
+      {
+        // the face is far, store for future analysis
+        dist2face.insert( std::make_pair( distance, std::make_pair( face, uv )));
+      }
+      else
+      {
+        // check location on the face
+        BRepClass_FaceClassifier FC( face, uv, Precision::Confusion());
+        if ( FC.State() == TopAbs_IN )
+        {
+          foundFace   = face;
+          myPoint.uv  = uv.XY();
+          myPoint.xyz = surface->Value( uv ).XYZ();
+          break;
+        }
+      }
+    }
+    if ( foundFace.IsNull() )
+    {
+      // find the closest face
+      std::map< double, std::pair< TopoDS_Face, gp_Pnt2d > >::iterator d2f = dist2face.begin();
+      for ( ; d2f != dist2face.end(); ++d2f )
+      {
+        const TopoDS_Face& face = d2f->second.first;
+        const gp_Pnt2d &     uv = d2f->second.second;
+        BRepClass_FaceClassifier FC( face, uv, Precision::Confusion());
+        if ( FC.State() == TopAbs_IN )
+        {
+          foundFace   = face;
+          myPoint.uv  = uv.XY();
+          myPoint.xyz = theHelper->GetSurface( face )->Value( uv ).XYZ();
+          break;
+        }
+      }
+    }
+    // set the resultShape
+    if ( foundFace.IsNull() )
+      throw SMESH_ComputeError(COMPERR_BAD_PARMETERS,
+                               "getProjectionPoint: can't find a face by a vertex");
+  }
+  else
+  {
+    Handle(Geom_Surface) surface = BRep_Tool::Surface( theFace );
+    GeomAPI_ProjectPointOnSurf projector( thePoint, surface );
+    if ( !projector.IsDone() || projector.NbPoints()==0 )
+      throw SMESH_ComputeError(COMPERR_BAD_PARMETERS,
+                               "getProjectionPoint: can't project a vertex to a face");
+
+    Quantity_Parameter u,v;
+    projector.LowerDistanceParameters(u,v);
+    myPoint.uv = gp_XY(u,v);
+    gp_Pnt aPnt = projector.NearestPoint();
+    myPoint.xyz = gp_XYZ(aPnt.X(),aPnt.Y(),aPnt.Z());
+  }
+
+  return myPoint;
 }
 
 /////////////////////////////////////////////////////////
@@ -510,112 +567,7 @@ void _createEnforcedVertexOnFace(TopoDS_Face faceShape, gp_Pnt aPnt, BLSURFPlugi
     }
   }
 }
-
-/*!
- * \brief Find geom faces supporting given points
- */
-TopoDS_Shape BLSURFPlugin_BLSURF::
-findFaces( const BLSURFPlugin_Hypothesis::TEnfVertexList& enfVertexList )
-{
-  // get points from enfVertexList
-  vector< gp_Pnt > points;
-  BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator enfVertexListIt = enfVertexList.begin();
-  for( ; enfVertexListIt != enfVertexList.end() ; ++enfVertexListIt )
-  {
-    BLSURFPlugin_Hypothesis::TEnfVertex * enfVertex = *enfVertexListIt;
-    if ( enfVertex->coords.size() >= 3 )
-    {
-      points.push_back( gp_Pnt( enfVertex->coords[0], enfVertex->coords[1], enfVertex->coords[2]));
-    }
-    else
-    {
-      TopoDS_Shape GeomShape = entryToShape( enfVertex->geomEntry );
-      if ( !GeomShape.IsNull() )
-      {
-        if ( GeomShape.ShapeType() == TopAbs_VERTEX )
-          points.push_back( BRep_Tool::Pnt( TopoDS::Vertex( GeomShape )));
-
-        else if ( GeomShape.ShapeType() == TopAbs_COMPOUND)
-          for (TopoDS_Iterator it (GeomShape); it.More(); it.Next())
-           if ( it.Value().ShapeType() == TopAbs_VERTEX )
-             points.push_back( BRep_Tool::Pnt( TopoDS::Vertex( it.Value() )));
-      }
-    }
-  }
-
-  TopoDS_Shape resultShape, myShape = myHelper->GetSubShape();
-  TopoDS_Compound compound;
-
-  for ( size_t i = 0; i <= points.size(); ++i )
-  {
-    TopoDS_Face foundFace;
-    TopTools_MapOfShape checkedFaces;
-    std::map< double, std::pair< TopoDS_Face, gp_Pnt2d > > dist2face;
-
-    for ( TopExp_Explorer exp ( myShape, TopAbs_FACE ); exp.More(); exp.Next())
-    {
-      const TopoDS_Face& face = TopoDS::Face( exp.Current() );
-      if ( !checkedFaces.Add( face )) continue;
-
-      // check distance to face
-      Handle(ShapeAnalysis_Surface) surface = myHelper->GetSurface( face );
-      gp_Pnt2d uv = surface->ValueOfUV( points[i], Precision::Confusion());
-      double distance = surface->Gap();
-      if ( distance > Precision::Confusion() )
-      {
-        // the face is far, store for future analysis
-        dist2face.insert( std::make_pair( distance, std::make_pair( face, uv )));
-      }
-      else
-      {
-        // check location on the face
-        BRepClass_FaceClassifier FC( face, uv, Precision::Confusion());
-        if ( FC.State() == TopAbs_IN )
-        {
-          foundFace = face;
-          break;
-        }
-      }
-    }
-    if ( foundFace.IsNull() )
-    {
-      // find the closest face
-      std::map< double, std::pair< TopoDS_Face, gp_Pnt2d > >::iterator d2f = dist2face.begin();
-      for ( ; d2f != dist2face.end(); ++d2f )
-      {
-        const TopoDS_Face& face = d2f->second.first;
-        const gp_Pnt2d &     uv = d2f->second.second;
-        BRepClass_FaceClassifier FC( face, uv, Precision::Confusion());
-        if ( FC.State() == TopAbs_IN )
-        {
-          foundFace = face;
-          break;
-        }
-      }
-    }
-    // set the resultShape
-    if ( !foundFace.IsNull() )
-    {
-      if ( resultShape.IsNull() )
-      {
-        resultShape = foundFace;
-      }
-      else
-      {
-        BRep_Builder builder;
-        if ( compound.IsNull() )
-        {
-          builder.MakeCompound( compound );
-          resultShape = compound;
-        }
-        builder.Add( compound, foundFace );
-      }
-    }
-  } // loop on points
-
-  return resultShape;
-}
-
+  
 /////////////////////////////////////////////////////////
 void BLSURFPlugin_BLSURF::createEnforcedVertexOnFace(TopoDS_Shape faceShape, BLSURFPlugin_Hypothesis::TEnfVertexList enfVertexList)
 {
@@ -874,11 +826,25 @@ void BLSURFPlugin_BLSURF::createPreCadEdgesPeriodicity(TopoDS_Shape theGeomShape
 
 void BLSURFPlugin_BLSURF::SetParameters(const BLSURFPlugin_Hypothesis* hyp,
                                         cadsurf_session_t *            css,
-                                        const TopoDS_Shape&            theGeomShape
-                                        )
+                                        const TopoDS_Shape&            theGeomShape)
 {
   // rnc : Bug 1457
   // Clear map so that it is not stored in the algorithm with old enforced vertices in it
+  FacesWithSizeMap.Clear();
+  FaceId2SizeMap.clear();
+  EdgesWithSizeMap.Clear();
+  EdgeId2SizeMap.clear();
+  VerticesWithSizeMap.Clear();
+  VertexId2SizeMap.clear();
+  FaceId2PythonSmp.clear();
+  EdgeId2PythonSmp.clear();
+  VertexId2PythonSmp.clear();
+  FaceId2AttractorCoords.clear();
+  FaceId2ClassAttractor.clear();
+  FaceIndex2ClassAttractor.clear();
+  FacesWithEnforcedVertices.Clear();
+  FaceId2EnforcedVertexCoords.clear();
+  EnfVertexCoords2ProjVertex.clear();
   EnfVertexCoords2EnfVertexList.clear();
 
   double diagonal               = SMESH_Mesh::GetShapeDiagonalSize( theGeomShape );
@@ -1296,12 +1262,11 @@ void BLSURFPlugin_BLSURF::SetParameters(const BLSURFPlugin_Hypothesis* hyp,
         GeomShape = entryToShape(enfIt->first);
         if ( GeomShape.IsNull() )
         {
-          GeomShape = findFaces( enfIt->second );
-          if ( GeomShape.IsNull() )
-            continue;
+          createEnforcedVertexOnFace( GeomShape, enfIt->second );
         }
         // Group Management
-        if ( GeomShape.ShapeType() == TopAbs_COMPOUND){
+        else if ( GeomShape.ShapeType() == TopAbs_COMPOUND)
+        {
           for (TopoDS_Iterator it (GeomShape); it.More(); it.Next()){
             if (it.Value().ShapeType() == TopAbs_FACE){
               HasSizeMapOnFace = true;
@@ -1309,7 +1274,8 @@ void BLSURFPlugin_BLSURF::SetParameters(const BLSURFPlugin_Hypothesis* hyp,
             }
           }
         }
-        if ( GeomShape.ShapeType() == TopAbs_FACE){
+        else if ( GeomShape.ShapeType() == TopAbs_FACE)
+        {
           HasSizeMapOnFace = true;
           createEnforcedVertexOnFace(GeomShape, enfIt->second);
         }
@@ -1411,17 +1377,17 @@ namespace
   /*!
    * \brief Class correctly terminating usage of MG-CADSurf library at destruction
    */
-  class BLSURF_Cleaner
+  struct BLSURF_Cleaner
   {
-    context_t *       _ctx;
+    context_t *        _ctx;
     cadsurf_session_t* _css;
-    cad_t *           _cad;
-    dcad_t *          _dcad;
-  public:
-    BLSURF_Cleaner(context_t *       ctx,
-                   cadsurf_session_t* css,
-                   cad_t *           cad,
-                   dcad_t *          dcad)
+    cad_t *            _cad;
+    dcad_t *           _dcad;
+
+    BLSURF_Cleaner(context_t *        ctx,
+                   cadsurf_session_t* css=0,
+                   cad_t *            cad=0,
+                   dcad_t *           dcad=0)
       : _ctx ( ctx  ),
         _css ( css  ),
         _cad ( cad  ),
@@ -1757,8 +1723,8 @@ status_t interrupt_cb(integer *interrupt_status, void *user_data);
  */
 //=============================================================================
 
-bool BLSURFPlugin_BLSURF::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape) {
-
+bool BLSURFPlugin_BLSURF::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
+{
   // Fix problem with locales
   Kernel_Utils::Localizer aLocalizer;
 
@@ -1828,7 +1794,7 @@ bool BLSURFPlugin_BLSURF::compute(SMESH_Mesh&         aMesh,
 
   SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
   SMESH_MesherHelper helper( aMesh ), helperWithShape( aMesh );
-  myHelper = & helperWithShape;
+  myHelper = theHelper = & helperWithShape;
   // do not call helper.IsQuadraticSubMesh() because sub-meshes
   // may be cleaned and helper.myTLinkNodeMap gets invalid in such a case
   bool haveQuadraticSubMesh = helperWithShape.IsQuadraticSubMesh( aShape );
@@ -1864,15 +1830,6 @@ bool BLSURFPlugin_BLSURF::compute(SMESH_Mesh&         aMesh,
   cad_t *c     = cad_new(ctx);
   dcad_t *dcad = dcad_new(c);
 
-  FacesWithSizeMap.Clear();
-  FaceId2SizeMap.clear();
-  FaceId2ClassAttractor.clear();
-  FaceIndex2ClassAttractor.clear();
-  EdgesWithSizeMap.Clear();
-  EdgeId2SizeMap.clear();
-  VerticesWithSizeMap.Clear();
-  VertexId2SizeMap.clear();
-
   /* Now fill the CAD object with data from your CAD
    * environement. This is the most complex part of a successfull
    * integration.
@@ -2849,6 +2806,166 @@ bool BLSURFPlugin_BLSURF::compute(SMESH_Mesh&         aMesh,
   return ( status == STATUS_OK && !quadraticSubMeshAndViscousLayer );
 }
 
+//================================================================================
+/*!
+ * \brief Compute a mesh basing on discrete CAD description
+ */
+//================================================================================
+
+bool BLSURFPlugin_BLSURF::Compute(SMESH_Mesh & aMesh, SMESH_MesherHelper* aHelper)
+{
+  if ( aMesh.NbFaces() == 0 )
+    return error( COMPERR_BAD_INPUT_MESH, "2D elements are missing" );
+
+  context_t *ctx = context_new();
+  if (!ctx) return error("Pb in context_new()");
+
+  BLSURF_Cleaner cleaner( ctx );
+
+  message_cb_user_data mcud;
+  mcud._error     = & this->SMESH_Algo::_comment;
+  mcud._progress  = & this->SMESH_Algo::_progress;
+  mcud._verbosity =
+    _hypothesis ? _hypothesis->GetVerbosity() : BLSURFPlugin_Hypothesis::GetDefaultVerbosity();
+  meshgems_status_t ret = context_set_message_callback(ctx, message_cb, &mcud);
+  if (ret != STATUS_OK) return error("Pb. in context_set_message_callback() ");
+
+  cadsurf_session_t * css = cadsurf_session_new(ctx);
+  if(!css) return error( "Pb. in cadsurf_session_new() " );
+  cleaner._css = css;
+
+
+  // Fill an input mesh
+
+  mesh_t * msh = meshgems_mesh_new_in_memory( ctx );
+  if ( !msh ) return error("Pb. in meshgems_mesh_new_in_memory()"); 
+
+  // mark nodes used by 2D elements
+  SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
+  SMDS_NodeIteratorPtr nodeIt = meshDS->nodesIterator();
+  while ( nodeIt->more() )
+  {
+    const SMDS_MeshNode* n = nodeIt->next();
+    n->setIsMarked( n->NbInverseElements( SMDSAbs_Face ));
+  }
+  meshgems_mesh_set_vertex_count( msh, meshDS->NbNodes() );
+
+  // set node coordinates
+  if ( meshDS->NbNodes() != meshDS->MaxNodeID() )
+  {
+    meshDS->compactMesh();
+  }
+  SMESH_TNodeXYZ nXYZ;
+  nodeIt = meshDS->nodesIterator();
+  meshgems_integer i;
+  for ( i = 1; nodeIt->more(); ++i )
+  {
+    nXYZ.Set( nodeIt->next() );
+    meshgems_mesh_set_vertex_coordinates( msh, i, nXYZ._xyz );
+  }
+
+  // set nodes of faces
+  meshgems_mesh_set_triangle_count  ( msh, meshDS->GetMeshInfo().NbTriangles() );
+  meshgems_mesh_set_quadrangle_count( msh, meshDS->GetMeshInfo().NbQuadrangles() );
+  meshgems_integer nodeIDs[4];
+  meshgems_integer iT = 1, iQ = 1;
+  SMDS_FaceIteratorPtr faceIt = meshDS->facesIterator();
+  while ( faceIt->more() )
+  {
+    const SMDS_MeshElement* face = faceIt->next();
+    meshgems_integer nbNodes = face->NbCornerNodes();
+    if ( nbNodes > 4 || face->IsPoly() ) continue;
+
+    for ( i = 0; i < nbNodes; ++i )
+      nodeIDs[i] = face->GetNode( i )->GetID();
+    if ( nbNodes == 3 )
+      meshgems_mesh_set_triangle_vertices  ( msh, iT++, nodeIDs );
+    else
+      meshgems_mesh_set_quadrangle_vertices( msh, iQ++, nodeIDs );
+  }
+
+  ret = cadsurf_set_mesh(css, msh);
+  if ( ret != STATUS_OK ) return error("Pb in cadsurf_set_mesh()");
+
+
+  // Compute the mesh
+
+  SetParameters(_hypothesis, css, aMesh.GetShapeToMesh() );
+
+  ret = cadsurf_compute_mesh(css);
+  if ( ret != STATUS_OK ) return false;
+
+  mesh_t *omsh = 0;
+  cadsurf_get_mesh(css, &omsh);
+  if ( !omsh ) return error( "Pb. in cadsurf_get_mesh()" );
+
+
+  // Update SALOME mesh
+
+  // remove quadrangles and triangles
+  for ( faceIt = meshDS->facesIterator(); faceIt->more();  )
+  {
+    const SMDS_MeshElement* face = faceIt->next();
+    if ( !face->IsPoly() )
+      meshDS->RemoveFreeElement( face, /*sm=*/0, /*fromGroups=*/true );
+  }
+  // remove edges that bound the just removed faces
+  for ( SMDS_EdgeIteratorPtr edgeIt = meshDS->edgesIterator(); edgeIt->more(); )
+  {
+    const SMDS_MeshElement* edge = edgeIt->next();
+    const SMDS_MeshNode* n0 = edge->GetNode(0);
+    const SMDS_MeshNode* n1 = edge->GetNode(1);
+    if ( n0->isMarked() &&
+         n1->isMarked() &&
+         n0->NbInverseElements( SMDSAbs_Volume ) == 0 &&
+         n1->NbInverseElements( SMDSAbs_Volume ) == 0 )
+      meshDS->RemoveFreeElement( edge, /*sm=*/0, /*fromGroups=*/true );
+  }
+  // remove nodes that just became free
+  for ( nodeIt = meshDS->nodesIterator(); nodeIt->more(); )
+  {
+    const SMDS_MeshNode* n = nodeIt->next();
+    if ( n->isMarked() && n->NbInverseElements() == 0 )
+      meshDS->RemoveFreeNode( n, /*sm=*/0, /*fromGroups=*/true );
+  }
+
+  // add nodes
+  meshgems_integer nbvtx = 0, nodeID;
+  meshgems_mesh_get_vertex_count( omsh, &nbvtx );
+  meshgems_real xyz[3];
+  for ( i = 1; i <= nbvtx; ++i )
+  {
+    meshgems_mesh_get_vertex_coordinates( omsh, i, xyz );
+    SMDS_MeshNode* n = meshDS->AddNode( xyz[0], xyz[1], xyz[2] );
+    nodeID = n->GetID();
+    meshgems_mesh_set_vertex_tag( omsh, i, &nodeID ); // save mapping of IDs in MG and SALOME meshes
+  }
+
+  // add triangles
+  meshgems_integer nbtri = 0;
+  meshgems_mesh_get_triangle_count( omsh, &nbtri );
+  const SMDS_MeshNode* nodes[3];
+  for ( i = 1; i <= nbtri; ++i )
+  {
+    meshgems_mesh_get_triangle_vertices( omsh, i, nodeIDs );
+    for ( int j = 0; j < 3; ++j )
+    {
+      meshgems_mesh_get_vertex_tag( omsh, nodeIDs[j], &nodeID );
+      nodes[j] = meshDS->FindNode( nodeID );
+    }
+    meshDS->AddFace( nodes[0], nodes[1], nodes[2] );
+  }
+
+  cadsurf_regain_mesh(css, omsh);
+
+  // as we don't assign the new triangles to a shape (the pseudo-shape),
+  // we mark the shape as always computed to avoid the error messages
+  // that no elements assigned to the shape
+  aMesh.GetSubMesh( aHelper->GetSubShape() )->SetIsAlwaysComputed( true );
+
+  return true;
+}
+
 //================================================================================
 /*!
  * \brief Terminates computation
@@ -2866,7 +2983,10 @@ void BLSURFPlugin_BLSURF::CancelCompute()
  */
 //=============================================================================
 
-void BLSURFPlugin_BLSURF::Set_NodeOnEdge(SMESHDS_Mesh* meshDS, const SMDS_MeshNode* node, const TopoDS_Shape& ed) {
+void BLSURFPlugin_BLSURF::Set_NodeOnEdge(SMESHDS_Mesh*        meshDS,
+                                         const SMDS_MeshNode* node,
+                                         const TopoDS_Shape&  ed)
+{
   const TopoDS_Edge edge = TopoDS::Edge(ed);
 
   gp_Pnt pnt(node->X(), node->Y(), node->Z());
index 5f162cf23a678f122afde197844cf773c9c04cf1..60c5e29cbe805857aaf72bbccaf0789110033f0b 100644 (file)
@@ -75,7 +75,7 @@ class TopoDS_Shape;
 
 class BLSURFPlugin_BLSURF: public SMESH_2D_Algo {
   public:
-    BLSURFPlugin_BLSURF(int hypId, int studyId, SMESH_Gen* gen);
+    BLSURFPlugin_BLSURF(int hypId, int studyId, SMESH_Gen* gen, bool theHasGEOM);
 
     virtual ~BLSURFPlugin_BLSURF();
 
@@ -86,6 +86,7 @@ class BLSURFPlugin_BLSURF: public SMESH_2D_Algo {
     void SetParameters(const BLSURFPlugin_Hypothesis* hyp, cadsurf_session_t *css, const TopoDS_Shape& shape);
 
     virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
+    virtual bool Compute(SMESH_Mesh & aMesh, SMESH_MesherHelper* aHelper);
 
     virtual void CancelCompute();
     bool computeCanceled() { return _compute_canceled; }
@@ -148,7 +149,6 @@ class BLSURFPlugin_BLSURF: public SMESH_2D_Algo {
     TopoDS_Shape entryToShape(std::string entry);
     void addCoordsFromVertices(const std::vector<std::string> &theVerticesEntries, std::vector<double> &theVerticesCoords);
     void addCoordsFromVertex(BLSURFPlugin_Hypothesis::TEntry theVertexEntry, std::vector<double> &theVerticesCoords);
-    TopoDS_Shape findFaces( const BLSURFPlugin_Hypothesis::TEnfVertexList& enfVertexList );
     void createEnforcedVertexOnFace(TopoDS_Shape FaceShape, BLSURFPlugin_Hypothesis::TEnfVertexList enfVertexList);
     void createPreCadFacesPeriodicity(TopoDS_Shape theGeomShape, const BLSURFPlugin_Hypothesis::TPreCadPeriodicity &preCadPeriodicity);
     void createPreCadEdgesPeriodicity(TopoDS_Shape theGeomShape, const BLSURFPlugin_Hypothesis::TPreCadPeriodicity &preCadPeriodicity);
index 249470aa5620f979bf0fe20f5827e74e3fdf3da9..947bf7187134092eadc0703aedf663ac93966b58 100644 (file)
 
 BLSURFPlugin_BLSURF_i::BLSURFPlugin_BLSURF_i( PortableServer::POA_ptr thePOA,
                                               int                     theStudyId,
-                                              ::SMESH_Gen*            theGenImpl )
+                                              ::SMESH_Gen*            theGenImpl,
+                                              bool                    theHasGEOM )
      : SALOME::GenericObj_i( thePOA ), 
        SMESH_Hypothesis_i( thePOA ), 
        SMESH_Algo_i( thePOA ),
        SMESH_2D_Algo_i( thePOA )
 {
-  MESSAGE( "BLSURFPlugin_BLSURF_i::BLSURFPlugin_BLSURF_i" );
   myBaseImpl = new ::BLSURFPlugin_BLSURF( theGenImpl->GetANewId(),
                                           theStudyId,
-                                          theGenImpl );
+                                          theGenImpl,
+                                          theHasGEOM);
 }
 
 //=============================================================================
@@ -60,7 +61,6 @@ BLSURFPlugin_BLSURF_i::BLSURFPlugin_BLSURF_i( PortableServer::POA_ptr thePOA,
 
 BLSURFPlugin_BLSURF_i::~BLSURFPlugin_BLSURF_i()
 {
-  MESSAGE( "BLSURFPlugin_BLSURF_i::~BLSURFPlugin_BLSURF_i" );
 }
 
 //=============================================================================
@@ -73,6 +73,5 @@ BLSURFPlugin_BLSURF_i::~BLSURFPlugin_BLSURF_i()
 
 ::BLSURFPlugin_BLSURF* BLSURFPlugin_BLSURF_i::GetImpl()
 {
-  MESSAGE( "BLSURFPlugin_BLSURF_i::GetImpl" );
   return ( ::BLSURFPlugin_BLSURF* )myBaseImpl;
 }
index 15a0a5fb9333ca687b8cf92bc39542b59a892abd..1b3b30db1c50f913c83926aaa7b4857445612d43 100644 (file)
@@ -42,7 +42,8 @@ public:
   // Constructor
   BLSURFPlugin_BLSURF_i( PortableServer::POA_ptr thePOA,
                          int                     theStudyId,
-                         ::SMESH_Gen*            theGenImpl );
+                         ::SMESH_Gen*            theGenImpl,
+                         bool                    theHasGEOM);
   // Destructor
   virtual ~BLSURFPlugin_BLSURF_i();
  
index 4048437af099027795a3c30e5f8b1c06efe32a24..6790461b07dc37b911f0b4f2766d45d463ec8d57 100644 (file)
@@ -49,7 +49,7 @@ namespace
 }
 
 //=============================================================================
-BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen * gen) :
+BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen * gen, bool hasgeom) :
   SMESH_Hypothesis(hypId, studyId, gen), 
   _physicalMesh(GetDefaultPhysicalMesh()),
   _geometricMesh(GetDefaultGeometricMesh()),
@@ -99,7 +99,7 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, int studyId, SMESH_G
   _preCadEdgesPeriodicityVector(GetDefaultPreCadEdgesPeriodicityVector()),
   _GMFFileName(GetDefaultGMFFile())
 {
-  _name = GetHypType();
+  _name = GetHypType(hasgeom);
   _param_algo_dim = 2;
   
 //   _GMFFileMode = false; // GMF ascii mode
@@ -115,6 +115,7 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, int studyId, SMESH_G
                                             // "optimise_tiny_edges",                      // default = 0
                                             // "remove_duplicate_cad_faces",               // default = 1
                                             "tiny_edge_avoid_surface_intersections",    // default = 1
+                                            "debug",                                    // default = 0 
                                             // "tiny_edge_respect_geometry",               // default = 0
                                             "" // mark of end
       };
@@ -139,7 +140,6 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, int studyId, SMESH_G
                                             "merge_edges",                              // default =  = 1
                                             "remove_duplicate_cad_faces",               // default = 1
                                             // "create_tag_on_collision",                  // default = 1
-                                            "debug",                                    // default = 0 
                                             "process_3d_topology",                      // default = 1
                                             // "remove_tiny_edges",                        // default = 0
                                             // remove_tiny_uv_edges option is not documented
@@ -167,7 +167,7 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, int studyId, SMESH_G
     _option2value[boolOptionNames[i++]].clear();
   }
   i = 0;
-  while (preCADboolOptionNames[i][0])
+  while (preCADboolOptionNames[i][0] && hasgeom)
   {
     _boolOptions.insert( preCADboolOptionNames[i] );
     _preCADoption2value[preCADboolOptionNames[i++]].clear();
@@ -177,7 +177,7 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, int studyId, SMESH_G
     _option2value[intOptionNames[i++]].clear();
   
   i = 0;
-  while (preCADintOptionNames[i][0])
+  while (preCADintOptionNames[i][0] && hasgeom)
     _preCADoption2value[preCADintOptionNames[i++]].clear();
 
   i = 0;
@@ -186,7 +186,7 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, int studyId, SMESH_G
     _option2value[doubleOptionNames[i++]].clear();
   }
   i = 0;
-  while (preCADdoubleOptionNames[i][0]) {
+  while (preCADdoubleOptionNames[i][0] && hasgeom) {
     _preCADdoubleOptions.insert(preCADdoubleOptionNames[i]);
     _preCADoption2value[preCADdoubleOptionNames[i++]].clear();
   }
@@ -196,7 +196,7 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, int studyId, SMESH_G
     _option2value[charOptionNames[i++]].clear();
   }
   i = 0;
-  while (preCADcharOptionNames[i][0]) {
+  while (preCADcharOptionNames[i][0] && hasgeom) {
     _preCADcharOptions.insert(preCADcharOptionNames[i]);
     _preCADoption2value[preCADcharOptionNames[i++]].clear();
   }
@@ -209,17 +209,20 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, int studyId, SMESH_G
   _defaultOptionValues["rectify_jacobian"                       ] = "yes";
   _defaultOptionValues["respect_geometry"                       ] = "yes";
   _defaultOptionValues["tiny_edge_avoid_surface_intersections"  ] = "yes";
-  _defaultOptionValues["process_3d_topology"                    ] = "no";
-  _defaultOptionValues["remove_tiny_uv_edges"                   ] = "no";
-  _defaultOptionValues["closed_geometry"                        ] = "no";
   _defaultOptionValues["debug"                                  ] = "no";
-  _defaultOptionValues["discard_input_topology"                 ] = "no";
-  _defaultOptionValues["merge_edges"                            ] = "no";
-  _defaultOptionValues["periodic_tolerance"                     ] = "1e-5*D";
-  _defaultOptionValues["remove_duplicate_cad_faces"             ] = "no";
-  _defaultOptionValues["required_entities"                      ] = "respect";
-  _defaultOptionValues["sewing_tolerance"                       ] = "5e-4*D";
-  _defaultOptionValues["tags"                                   ] = "respect";
+  if ( hasgeom )
+  {
+    _defaultOptionValues["closed_geometry"                        ] = "no";
+    _defaultOptionValues["discard_input_topology"                 ] = "no";
+    _defaultOptionValues["merge_edges"                            ] = "no";
+    _defaultOptionValues["periodic_tolerance"                     ] = "1e-5*D";
+    _defaultOptionValues["process_3d_topology"                    ] = "no";
+    _defaultOptionValues["remove_duplicate_cad_faces"             ] = "no";
+    _defaultOptionValues["remove_tiny_uv_edges"                   ] = "no";
+    _defaultOptionValues["required_entities"                      ] = "respect";
+    _defaultOptionValues["sewing_tolerance"                       ] = "5e-4*D";
+    _defaultOptionValues["tags"                                   ] = "respect";
+  }
 
 #ifdef _DEBUG_
   // check validity of option names of _defaultOptionValues
@@ -228,7 +231,7 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, int studyId, SMESH_G
     ASSERT( _option2value.count( n2v->first ) || _preCADoption2value.count( n2v->first ));
   ASSERT( _option2value.size() + _preCADoption2value.size() == _defaultOptionValues.size() );
 #endif
-      
+
   _sizeMap.clear();
   _attractors.clear();
   _faceEntryEnfVertexListMap.clear();
@@ -802,7 +805,7 @@ void BLSURFPlugin_Hypothesis::SetPreCADDiscardInput(bool theVal)
 // Return true if any PreCAD option is activated
 bool BLSURFPlugin_Hypothesis::HasPreCADOptions(const BLSURFPlugin_Hypothesis* hyp)
 {
-  if ( !hyp )
+  if ( !hyp || hyp->_name == GetHypType(/*hasgeom=*/false))
   {
     return false;
   }
index bcf1e84024035119c24e7c1fa40057ef8a86d49b..2f5299b477399ca10ef2f442e0e6214c2e6ccb64 100644 (file)
@@ -43,7 +43,7 @@
 class BLSURFPlugin_Hypothesis: public SMESH_Hypothesis
 {
 public:
-  BLSURFPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen * gen);
+  BLSURFPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen * gen, bool hasgeom);
 
   enum Topology {
     FromCAD,
@@ -64,8 +64,9 @@ public:
     GeometricalLocalSize
   };
 
-  static const char* GetHypType() { return "MG-CADSurf Parameters"; }
-  
+  static const char* GetHypType(bool hasgeom)
+  { return hasgeom ? "MG-CADSurf Parameters" : "MG-CADSurf Parameters_NOGEOM"; }
+
   TopoDS_Shape entryToShape(std::string entry);
 
   void SetPhysicalMesh(PhysicalMesh thePhysicalMesh);
index 16a34586f56aaca1e2147e44ee1b06d1701e0be7..395ef2e8e660ae8d4575117dcfe60ed1e61e2c04 100644 (file)
@@ -46,11 +46,16 @@ using namespace std;
  *  Constructor
  */
 //=============================================================================
-BLSURFPlugin_Hypothesis_i::BLSURFPlugin_Hypothesis_i(PortableServer::POA_ptr thePOA, int theStudyId,
-    ::SMESH_Gen* theGenImpl) :
-  SALOME::GenericObj_i(thePOA), SMESH_Hypothesis_i(thePOA) {
-  MESSAGE( "BLSURFPlugin_Hypothesis_i::BLSURFPlugin_Hypothesis_i" );
-  myBaseImpl = new ::BLSURFPlugin_Hypothesis(theGenImpl->GetANewId(), theStudyId, theGenImpl);
+BLSURFPlugin_Hypothesis_i::BLSURFPlugin_Hypothesis_i(PortableServer::POA_ptr thePOA,
+                                                     int                     theStudyId,
+                                                     ::SMESH_Gen*            theGenImpl,
+                                                     bool                    theHasGEOM) :
+  SALOME::GenericObj_i(thePOA), SMESH_Hypothesis_i(thePOA)
+{
+  myBaseImpl = new ::BLSURFPlugin_Hypothesis(theGenImpl->GetANewId(),
+                                             theStudyId,
+                                             theGenImpl,
+                                             theHasGEOM);
 }
 
 //=============================================================================
@@ -60,8 +65,8 @@ BLSURFPlugin_Hypothesis_i::BLSURFPlugin_Hypothesis_i(PortableServer::POA_ptr the
  *  Destructor
  */
 //=============================================================================
-BLSURFPlugin_Hypothesis_i::~BLSURFPlugin_Hypothesis_i() {
-  MESSAGE( "BLSURFPlugin_Hypothesis_i::~BLSURFPlugin_Hypothesis_i" );
+BLSURFPlugin_Hypothesis_i::~BLSURFPlugin_Hypothesis_i()
+{
 }
 
 //=============================================================================
@@ -74,8 +79,8 @@ BLSURFPlugin_Hypothesis_i::~BLSURFPlugin_Hypothesis_i() {
  */
 
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetPhysicalMesh(CORBA::Long theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetPhysicalMesh");
+void BLSURFPlugin_Hypothesis_i::SetPhysicalMesh(CORBA::Long theValue)
+{
   ASSERT(myBaseImpl);
   this->GetImpl()->SetPhysicalMesh((::BLSURFPlugin_Hypothesis::PhysicalMesh) theValue);
   SMESH::TPythonDump() << _this() << ".SetPhysicalMesh( " << theValue << " )";
@@ -88,8 +93,8 @@ void BLSURFPlugin_Hypothesis_i::SetPhysicalMesh(CORBA::Long theValue) {
  *  Get PhysicalMesh
  */
 //=============================================================================
-CORBA::Long BLSURFPlugin_Hypothesis_i::GetPhysicalMesh() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetPhysicalMesh");
+CORBA::Long BLSURFPlugin_Hypothesis_i::GetPhysicalMesh()
+{
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetPhysicalMesh();
 }
@@ -102,8 +107,8 @@ CORBA::Long BLSURFPlugin_Hypothesis_i::GetPhysicalMesh() {
  */
 
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetGeometricMesh(CORBA::Long theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetGeometricMesh");
+void BLSURFPlugin_Hypothesis_i::SetGeometricMesh(CORBA::Long theValue)
+{
   ASSERT(myBaseImpl);
   this->GetImpl()->SetGeometricMesh((::BLSURFPlugin_Hypothesis::GeometricMesh) theValue);
   SMESH::TPythonDump() << _this() << ".SetGeometricMesh( " << theValue << " )";
@@ -116,8 +121,8 @@ void BLSURFPlugin_Hypothesis_i::SetGeometricMesh(CORBA::Long theValue) {
  *  Get GeometricMesh
  */
 //=============================================================================
-CORBA::Long BLSURFPlugin_Hypothesis_i::GetGeometricMesh() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetGeometricMesh");
+CORBA::Long BLSURFPlugin_Hypothesis_i::GetGeometricMesh()
+{
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetGeometricMesh();
 }
@@ -129,8 +134,8 @@ CORBA::Long BLSURFPlugin_Hypothesis_i::GetGeometricMesh() {
  *  Set PhySize
  */
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetPhySize(CORBA::Double theValue) {
-//   MESSAGE("BLSURFPlugin_Hypothesis_i::SetPhySize");
+void BLSURFPlugin_Hypothesis_i::SetPhySize(CORBA::Double theValue)
+{
   ASSERT(myBaseImpl);
   this->GetImpl()->SetPhySize(theValue, false);
   SMESH::TPythonDump() << _this() << ".SetPhySize( " << theValue << " )";
@@ -143,8 +148,8 @@ void BLSURFPlugin_Hypothesis_i::SetPhySize(CORBA::Double theValue) {
  *  Set Relative PhySize
  */
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetPhySizeRel(CORBA::Double theValue) {
-//   MESSAGE("BLSURFPlugin_Hypothesis_i::SetPhySizeRel");
+void BLSURFPlugin_Hypothesis_i::SetPhySizeRel(CORBA::Double theValue)
+{
   ASSERT(myBaseImpl);
   this->GetImpl()->SetPhySize(theValue, true);
   SMESH::TPythonDump() << _this() << ".SetPhySizeRel( " << theValue << " )";
@@ -157,8 +162,8 @@ void BLSURFPlugin_Hypothesis_i::SetPhySizeRel(CORBA::Double theValue) {
  *  Get PhySize
  */
 //=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetPhySize() {
-//   MESSAGE("BLSURFPlugin_Hypothesis_i::GetPhySize");
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetPhySize()
+{
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetPhySize();
 }
@@ -170,15 +175,15 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetPhySize() {
  *  Returns True if PhySize is relative
  */
 //=============================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsPhySizeRel() {
-//   MESSAGE("BLSURFPlugin_Hypothesis_i::IsPhySizeRel");
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsPhySizeRel()
+{
   ASSERT(myBaseImpl);
   return this->GetImpl()->IsPhySizeRel();
 }
 
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetMinSize(CORBA::Double theMinSize) {
-  ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetMinSize(CORBA::Double theMinSize)
+{
   if (IsMinSizeRel() || GetMinSize() != theMinSize ) {
     this->GetImpl()->SetMinSize(theMinSize, false);
     SMESH::TPythonDump() << _this() << ".SetMinSize( " << theMinSize << " )";
@@ -186,8 +191,8 @@ void BLSURFPlugin_Hypothesis_i::SetMinSize(CORBA::Double theMinSize) {
 }
 
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetMinSizeRel(CORBA::Double theMinSize) {
-  ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetMinSizeRel(CORBA::Double theMinSize)
+{
   if ( !IsMinSizeRel() || (GetMinSize() != theMinSize) ) {
     this->GetImpl()->SetMinSize(theMinSize, true);
     SMESH::TPythonDump() << _this() << ".SetMinSizeRel( " << theMinSize << " )";
@@ -195,21 +200,20 @@ void BLSURFPlugin_Hypothesis_i::SetMinSizeRel(CORBA::Double theMinSize) {
 }
 
 //=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetMinSize() {
-  ASSERT(myBaseImpl);
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetMinSize()
+{
   return this->GetImpl()->GetMinSize();
 }
 
 //=============================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsMinSizeRel() {
-//   MESSAGE("BLSURFPlugin_Hypothesis_i::IsMinSizeRel");
-  ASSERT(myBaseImpl);
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsMinSizeRel()
+{
   return this->GetImpl()->IsMinSizeRel();
 }
 
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetMaxSize(CORBA::Double theMaxSize) {
-  ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetMaxSize(CORBA::Double theMaxSize)
+{
   if (IsMaxSizeRel() || GetMaxSize() != theMaxSize) {
     this->GetImpl()->SetMaxSize(theMaxSize, false);
     SMESH::TPythonDump() << _this() << ".SetMaxSize( " << theMaxSize << " )";
@@ -217,8 +221,8 @@ void BLSURFPlugin_Hypothesis_i::SetMaxSize(CORBA::Double theMaxSize) {
 }
 
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetMaxSizeRel(CORBA::Double theMaxSize) {
-  ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetMaxSizeRel(CORBA::Double theMaxSize)
+{
   if ( !IsMaxSizeRel() || (GetMaxSize() != theMaxSize) ) {
     this->GetImpl()->SetMaxSize(theMaxSize, true);
     SMESH::TPythonDump() << _this() << ".SetMaxSizeRel( " << theMaxSize << " )";
@@ -226,15 +230,14 @@ void BLSURFPlugin_Hypothesis_i::SetMaxSizeRel(CORBA::Double theMaxSize) {
 }
 
 //=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetMaxSize() {
-  ASSERT(myBaseImpl);
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetMaxSize()
+{
   return this->GetImpl()->GetMaxSize();
 }
 
 //=============================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsMaxSizeRel() {
-//   MESSAGE("BLSURFPlugin_Hypothesis_i::IsMaxSizeRel");
-  ASSERT(myBaseImpl);
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsMaxSizeRel()
+{
   return this->GetImpl()->IsMaxSizeRel();
 }
 
@@ -246,9 +249,8 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsMaxSizeRel() {
  *  Set true or false
  */
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetUseGradation(CORBA::Boolean theValue) {
-  MESSAGE("BLSURFPlugin_Hypothesis_i::SetUseGradation");
-  ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetUseGradation(CORBA::Boolean theValue)
+{
   if ( GetImpl()->GetUseGradation() != bool( theValue ))
   {
     this->GetImpl()->SetUseGradation(theValue);
@@ -264,9 +266,8 @@ void BLSURFPlugin_Hypothesis_i::SetUseGradation(CORBA::Boolean theValue) {
  *  Get true or false
  */
 //=============================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseGradation() {
-  MESSAGE("BLSURFPlugin_Hypothesis_i::GetUseGradation");
-  ASSERT(myBaseImpl);
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseGradation()
+{
   return this->GetImpl()->GetUseGradation();
 }
 
@@ -277,9 +278,8 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseGradation() {
  *  Set Gradation
  */
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetGradation(CORBA::Double theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetGradation");
-  ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetGradation(CORBA::Double theValue)
+{
   this->GetImpl()->SetGradation(theValue);
 
   if ( theValue < 0 )
@@ -295,9 +295,8 @@ void BLSURFPlugin_Hypothesis_i::SetGradation(CORBA::Double theValue) {
  *  Get Gradation
  */
 //=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetGradation() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetGradation");
-  ASSERT(myBaseImpl);
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetGradation()
+{
   return this->GetImpl()->GetGradation();
 }
 
@@ -308,9 +307,8 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetGradation() {
  *  Set true or false
  */
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetUseVolumeGradation(CORBA::Boolean theValue) {
-  MESSAGE("BLSURFPlugin_Hypothesis_i::SetUseVolumeGradation");
-  ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetUseVolumeGradation(CORBA::Boolean theValue)
+{
   if ( GetImpl()->GetUseVolumeGradation() != bool( theValue ))
   {
     this->GetImpl()->SetUseVolumeGradation(theValue);
@@ -326,9 +324,8 @@ void BLSURFPlugin_Hypothesis_i::SetUseVolumeGradation(CORBA::Boolean theValue) {
  *  Get true or false
  */
 //=============================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseVolumeGradation() {
-  MESSAGE("BLSURFPlugin_Hypothesis_i::GetUseVolumeGradation");
-  ASSERT(myBaseImpl);
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseVolumeGradation()
+{
   return this->GetImpl()->GetUseVolumeGradation();
 }
 
@@ -339,9 +336,8 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseVolumeGradation() {
  *  Set VolumeGradation
  */
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetVolumeGradation(CORBA::Double theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetVolumeGradation");
-  ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetVolumeGradation(CORBA::Double theValue)
+{
   this->GetImpl()->SetVolumeGradation(theValue);
   if ( theValue < 0 )
     SetUseVolumeGradation( false );
@@ -356,9 +352,8 @@ void BLSURFPlugin_Hypothesis_i::SetVolumeGradation(CORBA::Double theValue) {
  *  Get VolumeGradation
  */
 //=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetVolumeGradation() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetVolumeGradation");
-  ASSERT(myBaseImpl);
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetVolumeGradation()
+{
   return this->GetImpl()->GetVolumeGradation();
 }
 
@@ -369,9 +364,8 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetVolumeGradation() {
  *  Set true or false
  */
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetQuadAllowed(CORBA::Boolean theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetQuadAllowed");
-  ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetQuadAllowed(CORBA::Boolean theValue)
+{
   this->GetImpl()->SetQuadAllowed(theValue);
   std::string theValueStr = theValue ? "True" : "False";
   SMESH::TPythonDump() << _this() << ".SetQuadAllowed( " << theValueStr.c_str() << " )";
@@ -384,9 +378,8 @@ void BLSURFPlugin_Hypothesis_i::SetQuadAllowed(CORBA::Boolean theValue) {
  *  Get true or false
  */
 //=============================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetQuadAllowed() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetQuadAllowed");
-  ASSERT(myBaseImpl);
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetQuadAllowed()
+{
   return this->GetImpl()->GetQuadAllowed();
 }
 
@@ -397,9 +390,8 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetQuadAllowed() {
  *  Set AngleMesh
  */
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetAngleMesh(CORBA::Double theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetAngleMesh");
-  ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetAngleMesh(CORBA::Double theValue)
+{
   this->GetImpl()->SetAngleMesh(theValue);
   SMESH::TPythonDump() << _this() << ".SetAngleMesh( " << theValue << " )";
 }
@@ -411,9 +403,8 @@ void BLSURFPlugin_Hypothesis_i::SetAngleMesh(CORBA::Double theValue) {
  *  Get AngleMesh
  */
 //=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetAngleMesh() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetAngleMesh");
-  ASSERT(myBaseImpl);
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetAngleMesh()
+{
   return this->GetImpl()->GetAngleMesh();
 }
 
@@ -424,9 +415,8 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetAngleMesh() {
  *  Set Chordal Error
  */
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetChordalError(CORBA::Double theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetChordalError");
-  ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetChordalError(CORBA::Double theValue)
+{
   this->GetImpl()->SetChordalError(theValue);
   SMESH::TPythonDump() << _this() << ".SetChordalError( " << theValue << " )";
 }
@@ -438,9 +428,8 @@ void BLSURFPlugin_Hypothesis_i::SetChordalError(CORBA::Double theValue) {
  *  Get Chordal Error
  */
 //=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetChordalError() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetChordalError");
-  ASSERT(myBaseImpl);
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetChordalError()
+{
   return this->GetImpl()->GetChordalError();
 }
 
@@ -451,9 +440,8 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetChordalError() {
  *  Set true or false
  */
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetAnisotropic(CORBA::Boolean theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetAnisotropic");
-  ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetAnisotropic(CORBA::Boolean theValue)
+{
   this->GetImpl()->SetAnisotropic(theValue);
   std::string theValueStr = theValue ? "True" : "False";
   SMESH::TPythonDump() << _this() << ".SetAnisotropic( " << theValueStr.c_str() << " )";
@@ -466,9 +454,8 @@ void BLSURFPlugin_Hypothesis_i::SetAnisotropic(CORBA::Boolean theValue) {
  *  Get true or false
  */
 //=============================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetAnisotropic() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetAnisotropic");
-  ASSERT(myBaseImpl);
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetAnisotropic()
+{
   return this->GetImpl()->GetAnisotropic();
 }
 
@@ -479,9 +466,8 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetAnisotropic() {
  *  Set Anisotropic Ratio
  */
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetAnisotropicRatio(CORBA::Double theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetAnisotropicRatio");
-  ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetAnisotropicRatio(CORBA::Double theValue)
+{
   this->GetImpl()->SetAnisotropicRatio(theValue);
   SMESH::TPythonDump() << _this() << ".SetAnisotropicRatio( " << theValue << " )";
 }
@@ -493,9 +479,8 @@ void BLSURFPlugin_Hypothesis_i::SetAnisotropicRatio(CORBA::Double theValue) {
  *  Get Anisotropic Ratio
  */
 //=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetAnisotropicRatio() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetAnisotropicRatio");
-  ASSERT(myBaseImpl);
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetAnisotropicRatio()
+{
   return this->GetImpl()->GetAnisotropicRatio();
 }
 
@@ -508,7 +493,6 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetAnisotropicRatio() {
  */
 //=============================================================================
 void BLSURFPlugin_Hypothesis_i::SetRemoveTinyEdges(CORBA::Boolean theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetRemoveTinyEdges");
   ASSERT(myBaseImpl);
   this->GetImpl()->SetRemoveTinyEdges(theValue);
   std::string theValueStr = theValue ? "True" : "False";
@@ -523,7 +507,6 @@ void BLSURFPlugin_Hypothesis_i::SetRemoveTinyEdges(CORBA::Boolean theValue) {
  */
 //=============================================================================
 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetRemoveTinyEdges() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetRemoveTinyEdges");
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetRemoveTinyEdges();
 }
@@ -536,7 +519,6 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetRemoveTinyEdges() {
  */
 //=============================================================================
 void BLSURFPlugin_Hypothesis_i::SetTinyEdgeLength(CORBA::Double theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetTinyEdgeLength");
   ASSERT(myBaseImpl);
   this->GetImpl()->SetTinyEdgeLength(theValue);
   SMESH::TPythonDump() << _this() << ".SetTinyEdgeLength( " << theValue << " )";
@@ -550,7 +532,6 @@ void BLSURFPlugin_Hypothesis_i::SetTinyEdgeLength(CORBA::Double theValue) {
  */
 //=============================================================================
 CORBA::Double BLSURFPlugin_Hypothesis_i::GetTinyEdgeLength() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetTinyEdgeLength");
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetTinyEdgeLength();
 }
@@ -563,7 +544,6 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetTinyEdgeLength() {
  */
 //=============================================================================
 void BLSURFPlugin_Hypothesis_i::SetOptimiseTinyEdges(CORBA::Boolean theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetOptimiseTinyEdges");
   ASSERT(myBaseImpl);
   this->GetImpl()->SetOptimiseTinyEdges(theValue);
   std::string theValueStr = theValue ? "True" : "False";
@@ -578,7 +558,6 @@ void BLSURFPlugin_Hypothesis_i::SetOptimiseTinyEdges(CORBA::Boolean theValue) {
  */
 //=============================================================================
 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetOptimiseTinyEdges() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetOptimiseTinyEdges");
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetOptimiseTinyEdges();
 }
@@ -591,7 +570,6 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetOptimiseTinyEdges() {
  */
 //=============================================================================
 void BLSURFPlugin_Hypothesis_i::SetTinyEdgeOptimisationLength(CORBA::Double theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetTinyEdgeOptimisationLength");
   ASSERT(myBaseImpl);
   this->GetImpl()->SetTinyEdgeOptimisationLength(theValue);
   SMESH::TPythonDump() << _this() << ".SetTinyEdgeOptimisationLength( " << theValue << " )";
@@ -605,7 +583,6 @@ void BLSURFPlugin_Hypothesis_i::SetTinyEdgeOptimisationLength(CORBA::Double theV
  */
 //=============================================================================
 CORBA::Double BLSURFPlugin_Hypothesis_i::GetTinyEdgeOptimisationLength() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetTinyEdgeOptimisationLength");
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetTinyEdgeOptimisationLength();
 }
@@ -618,7 +595,6 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetTinyEdgeOptimisationLength() {
  */
 //=============================================================================
 void BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersection(CORBA::Boolean theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersection");
   ASSERT(myBaseImpl);
   this->GetImpl()->SetCorrectSurfaceIntersection(theValue);
   std::string theValueStr = theValue ? "True" : "False";
@@ -633,7 +609,6 @@ void BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersection(CORBA::Boolean the
  */
 //=============================================================================
 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersection() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersection");
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetCorrectSurfaceIntersection();
 }
@@ -646,7 +621,6 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersection() {
  */
 //=============================================================================
 void BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersectionMaxCost(CORBA::Double theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersectionMaxCost");
   ASSERT(myBaseImpl);
   this->GetImpl()->SetCorrectSurfaceIntersectionMaxCost(theValue);
   SMESH::TPythonDump() << _this() << ".SetCorrectSurfaceIntersectionMaxCost( " << theValue << " )";
@@ -660,7 +634,6 @@ void BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersectionMaxCost(CORBA::Doub
  */
 //=============================================================================
 CORBA::Double BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersectionMaxCost() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersectionMaxCost");
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetCorrectSurfaceIntersectionMaxCost();
 }
@@ -673,7 +646,6 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersectionMaxCost()
  */
 //=============================================================================
 void BLSURFPlugin_Hypothesis_i::SetBadElementRemoval(CORBA::Boolean theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetBadElementRemoval");
   ASSERT(myBaseImpl);
   this->GetImpl()->SetBadElementRemoval(theValue);
   std::string theValueStr = theValue ? "True" : "False";
@@ -688,7 +660,6 @@ void BLSURFPlugin_Hypothesis_i::SetBadElementRemoval(CORBA::Boolean theValue) {
  */
 //=============================================================================
 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetBadElementRemoval() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetBadElementRemoval");
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetBadElementRemoval();
 }
@@ -701,7 +672,6 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetBadElementRemoval() {
  */
 //=============================================================================
 void BLSURFPlugin_Hypothesis_i::SetBadElementAspectRatio(CORBA::Double theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetBadElementAspectRatio");
   ASSERT(myBaseImpl);
   this->GetImpl()->SetBadElementAspectRatio(theValue);
   SMESH::TPythonDump() << _this() << ".SetBadElementAspectRatio( " << theValue << " )";
@@ -715,7 +685,6 @@ void BLSURFPlugin_Hypothesis_i::SetBadElementAspectRatio(CORBA::Double theValue)
  */
 //=============================================================================
 CORBA::Double BLSURFPlugin_Hypothesis_i::GetBadElementAspectRatio() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetBadElementAspectRatio");
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetBadElementAspectRatio();
 }
@@ -728,7 +697,6 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetBadElementAspectRatio() {
  */
 //=============================================================================
 void BLSURFPlugin_Hypothesis_i::SetOptimizeMesh(CORBA::Boolean theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetOptimizeMesh");
   ASSERT(myBaseImpl);
   this->GetImpl()->SetOptimizeMesh(theValue);
   std::string theValueStr = theValue ? "True" : "False";
@@ -743,7 +711,6 @@ void BLSURFPlugin_Hypothesis_i::SetOptimizeMesh(CORBA::Boolean theValue) {
  */
 //=============================================================================
 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetOptimizeMesh() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetOptimizeMesh");
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetOptimizeMesh();
 }
@@ -756,7 +723,6 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetOptimizeMesh() {
  */
 //=============================================================================
 void BLSURFPlugin_Hypothesis_i::SetQuadraticMesh(CORBA::Boolean theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetQuadraticMesh");
   ASSERT(myBaseImpl);
   this->GetImpl()->SetQuadraticMesh(theValue);
   std::string theValueStr = theValue ? "True" : "False";
@@ -771,7 +737,6 @@ void BLSURFPlugin_Hypothesis_i::SetQuadraticMesh(CORBA::Boolean theValue) {
  */
 //=============================================================================
 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetQuadraticMesh() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetQuadraticMesh");
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetQuadraticMesh();
 }
@@ -788,7 +753,6 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetQuadraticMesh() {
 
 //=============================================================================
 void BLSURFPlugin_Hypothesis_i::SetTopology(CORBA::Long theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetTopology");
   ASSERT(myBaseImpl);
   this->GetImpl()->SetTopology((::BLSURFPlugin_Hypothesis::Topology) theValue);
   SMESH::TPythonDump() << _this() << ".SetTopology( " << theValue << " )";
@@ -802,7 +766,6 @@ void BLSURFPlugin_Hypothesis_i::SetTopology(CORBA::Long theValue) {
  */
 //=============================================================================
 CORBA::Long BLSURFPlugin_Hypothesis_i::GetTopology() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetTopology");
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetTopology();
 }
@@ -1112,7 +1075,6 @@ BLSURFPlugin::THyperPatchList* BLSURFPlugin_Hypothesis_i::GetHyperPatches()
  */
 //=============================================================================
 void BLSURFPlugin_Hypothesis_i::SetPreCADMergeEdges(CORBA::Boolean theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetPreCADMergeEdges");
   ASSERT(myBaseImpl);
   this->GetImpl()->SetPreCADMergeEdges(theValue);
   std::string theValueStr = theValue ? "True" : "False";
@@ -1127,7 +1089,6 @@ void BLSURFPlugin_Hypothesis_i::SetPreCADMergeEdges(CORBA::Boolean theValue) {
  */
 //=============================================================================
 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADMergeEdges() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCADMergeEdges");
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetPreCADMergeEdges();
 }
@@ -1140,7 +1101,6 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADMergeEdges() {
  */
 //=============================================================================
 void BLSURFPlugin_Hypothesis_i::SetPreCADRemoveDuplicateCADFaces(CORBA::Boolean theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetPreCADRemoveDuplicateCADFaces");
   ASSERT(myBaseImpl);
   this->GetImpl()->SetPreCADRemoveDuplicateCADFaces(theValue);
   std::string theValueStr = theValue ? "True" : "False";
@@ -1155,7 +1115,6 @@ void BLSURFPlugin_Hypothesis_i::SetPreCADRemoveDuplicateCADFaces(CORBA::Boolean
  */
 //=============================================================================
 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADRemoveDuplicateCADFaces() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCADRemoveDuplicateCADFaces");
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetPreCADRemoveDuplicateCADFaces();
 }
@@ -1168,7 +1127,6 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADRemoveDuplicateCADFaces() {
  */
 //=============================================================================
 void BLSURFPlugin_Hypothesis_i::SetPreCADProcess3DTopology(CORBA::Boolean theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetPreCADProcess3DTopology");
   ASSERT(myBaseImpl);
   this->GetImpl()->SetPreCADProcess3DTopology(theValue);
   std::string theValueStr = theValue ? "True" : "False";
@@ -1183,7 +1141,6 @@ void BLSURFPlugin_Hypothesis_i::SetPreCADProcess3DTopology(CORBA::Boolean theVal
  */
 //=============================================================================
 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADProcess3DTopology() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCADProcess3DTopology");
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetPreCADProcess3DTopology();
 }
@@ -1196,7 +1153,6 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADProcess3DTopology() {
  */
 //=============================================================================
 void BLSURFPlugin_Hypothesis_i::SetPreCADDiscardInput(CORBA::Boolean theValue) {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::SetPreCADDiscardInput");
   ASSERT(myBaseImpl);
   this->GetImpl()->SetPreCADDiscardInput(theValue);
   std::string theValueStr = theValue ? "True" : "False";
@@ -1211,7 +1167,6 @@ void BLSURFPlugin_Hypothesis_i::SetPreCADDiscardInput(CORBA::Boolean theValue) {
  */
 //=============================================================================
 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADDiscardInput() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCADDiscardInput");
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetPreCADDiscardInput();
 }
@@ -1521,7 +1476,7 @@ BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetAdvancedOptionValues()
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis_i::SetOptionValues(const BLSURFPlugin::string_array& options)
-    throw (SALOME::SALOME_Exception) {
+  throw (SALOME::SALOME_Exception) {
   ASSERT(myBaseImpl);
   for (CORBA::ULong i = 0; i < options.length(); ++i) {
     string name_value_type = options[i].in();
@@ -1549,7 +1504,7 @@ void BLSURFPlugin_Hypothesis_i::SetOptionValues(const BLSURFPlugin::string_array
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis_i::SetPreCADOptionValues(const BLSURFPlugin::string_array& options)
-    throw (SALOME::SALOME_Exception) {
+  throw (SALOME::SALOME_Exception) {
   ASSERT(myBaseImpl);
   for ( CORBA::ULong i = 0; i < options.length(); ++i) {
     string name_value_type = options[i].in();
@@ -1677,9 +1632,8 @@ char* BLSURFPlugin_Hypothesis_i::GetPreCADOption(const char* optionName)
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis_i::SetSizeMapEntry(const char* entry, const char* sizeMap)
-    throw (SALOME::SALOME_Exception) {
+  throw (SALOME::SALOME_Exception) {
   ASSERT(myBaseImpl);
-  MESSAGE("ENGINE : SETSIZEMAP START ENTRY : " << entry);
   if ( !entry || !entry[0] )
     THROW_SALOME_CORBA_EXCEPTION( "SetSizeMapEntry(): empty geom entry", SALOME::BAD_PARAM );
   bool valueChanged = false;
@@ -1697,7 +1651,6 @@ void BLSURFPlugin_Hypothesis_i::SetSizeMapEntry(const char* entry, const char* s
   } catch (SALOME_Exception& ex) {
     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
   }
-  MESSAGE("ENGINE : SETSIZEMAP END ENTRY : " << entry);
   if (valueChanged)
     SMESH::TPythonDump() << _this() << ".SetSizeMap(" << entry << ", '" << sizeMap << "' )";
 }
@@ -1707,7 +1660,6 @@ void BLSURFPlugin_Hypothesis_i::SetSizeMapEntry(const char* entry, const char* s
 void BLSURFPlugin_Hypothesis_i::SetConstantSizeMapEntry(const char* entry, GEOM::shape_type shapeType, CORBA::Double sizeMap)
   throw (SALOME::SALOME_Exception) {
   ASSERT(myBaseImpl);
-  MESSAGE("ENGINE : SETSIZEMAP START ENTRY : " << entry);
   bool valueChanged = false;
   std::ostringstream sizeMapFunction;
   switch (shapeType) {
@@ -1730,7 +1682,6 @@ void BLSURFPlugin_Hypothesis_i::SetConstantSizeMapEntry(const char* entry, GEOM:
   } catch (SALOME_Exception& ex) {
     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
   }
-  MESSAGE("ENGINE : SETSIZEMAP END ENTRY : " << entry);
   if (valueChanged)
     SMESH::TPythonDump() << _this() << ".SetConstantSizeMap(" << entry << ", '" << sizeMap << "' )";
 }
@@ -1738,9 +1689,8 @@ void BLSURFPlugin_Hypothesis_i::SetConstantSizeMapEntry(const char* entry, GEOM:
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis_i::SetAttractorEntry(const char* entry, const char* attractor)
-    throw (SALOME::SALOME_Exception) {
+  throw (SALOME::SALOME_Exception) {
   ASSERT(myBaseImpl);
-  MESSAGE("ENGINE : SETATTRACTOR START ENTRY : " << entry);
   bool valueChanged = false;
   try {
     valueChanged = ( this->GetImpl()->GetAttractorEntry(entry) != attractor );
@@ -1760,7 +1710,6 @@ void BLSURFPlugin_Hypothesis_i::SetAttractorEntry(const char* entry, const char*
   } catch (SALOME_Exception& ex) {
     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
   }
-  MESSAGE("ENGINE : SETATTRACTOR END ENTRY : " << entry);
   if (valueChanged)
     SMESH::TPythonDump() << _this() << ".SetAttractor(" << entry << ", '" << attractor << "' )";
 }
@@ -1771,7 +1720,6 @@ void BLSURFPlugin_Hypothesis_i::SetClassAttractorEntry(const char* entry, const
   throw (SALOME::SALOME_Exception)
 {
   ASSERT(myBaseImpl);
-  MESSAGE("ENGINE : SETATTRACTOR START ENTRY : " << entry);
   //bool valueChanged = false;
   try {
     this->GetImpl()->SetClassAttractorEntry(entry, att_entry, StartSize, EndSize, ActionRadius, ConstantRadius);
@@ -1786,7 +1734,6 @@ void BLSURFPlugin_Hypothesis_i::SetClassAttractorEntry(const char* entry, const
   } catch (SALOME_Exception& ex) {
     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
   }
-  MESSAGE("ENGINE : SETATTRACTOR END ENTRY : " << entry);
   //if ( valueChanged )
   SMESH::TPythonDump() << _this() << ".SetAttractorGeom( "
                        << entry << ", " << att_entry << ", "<<StartSize<<", "<<EndSize<<", "<<ActionRadius<<", "<<ConstantRadius<<" )";
@@ -1922,7 +1869,6 @@ BLSURFPlugin::TAttParamsMap* BLSURFPlugin_Hypothesis_i::GetAttractorParams()
     double startSize, endSize, infDist, constDist;
     if ( !atIt->second->Empty() ) {
       attEntry = atIt->second->GetAttractorEntry();
-      MESSAGE("GetAttractorParams : attEntry ="<<attEntry)
       std::vector<double> params = atIt->second->GetParameters();
       startSize = params[0];
       endSize = params[1];
@@ -1935,8 +1881,6 @@ BLSURFPlugin::TAttParamsMap* BLSURFPlugin_Hypothesis_i::GetAttractorParams()
     result[i].endSize = endSize;
     result[i].infDist = infDist;
     result[i].constDist = constDist;
-    MESSAGE("GetAttractorParams : result[i].attEntry ="<<result[i].attEntry)
-    MESSAGE("GetAttractorParams : result[i].faceEntry ="<<result[i].faceEntry)
   }
   return result._retn();
 }
@@ -1944,7 +1888,7 @@ BLSURFPlugin::TAttParamsMap* BLSURFPlugin_Hypothesis_i::GetAttractorParams()
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis_i::SetSizeMapEntries(const BLSURFPlugin::string_array& sizeMaps)
-    throw (SALOME::SALOME_Exception) {
+  throw (SALOME::SALOME_Exception) {
   ASSERT(myBaseImpl);
   for ( CORBA::ULong i = 0; i < sizeMaps.length(); ++i) {
     string entry_sizemap = sizeMaps[i].in();
@@ -1976,8 +1920,6 @@ void BLSURFPlugin_Hypothesis_i::SetSizeMap(const GEOM::GEOM_Object_ptr GeomObj,
   ASSERT(myBaseImpl);
   string entry;
   entry = GeomObj->GetStudyEntry();
-  MESSAGE("IDL : GetName : " << GeomObj->GetName());
-  MESSAGE("IDL : SETSIZEMAP ( "<< entry << " , " << sizeMap << ")");
   SetSizeMapEntry(entry.c_str(), sizeMap);
 }
 
@@ -1989,8 +1931,6 @@ void BLSURFPlugin_Hypothesis_i::SetConstantSizeMap(const GEOM::GEOM_Object_ptr G
   GEOM::shape_type shapeType = GeomObj->GetShapeType();
   if (shapeType == GEOM::COMPOUND)
     shapeType = GeomObj->GetMaxShapeType();
-  MESSAGE("IDL : GetName : " << GeomObj->GetName());
-  MESSAGE("IDL : SETSIZEMAP ( "<< entry << " , " << sizeMap << ")");
   SetConstantSizeMapEntry(entry.c_str(), shapeType, sizeMap);
 }
 
@@ -1999,8 +1939,6 @@ void BLSURFPlugin_Hypothesis_i::UnsetSizeMap(const GEOM::GEOM_Object_ptr GeomObj
   ASSERT(myBaseImpl);
   string entry;
   entry = GeomObj->GetStudyEntry();
-  MESSAGE("IDL : GetName : " << GeomObj->GetName());
-  MESSAGE("IDL : UNSETSIZEMAP ( "<< entry << ")");
   UnsetEntry(entry.c_str());
   SMESH::TPythonDump() << _this() << ".UnsetSizeMap( " << entry.c_str() << " )";
 }
@@ -2009,8 +1947,6 @@ void BLSURFPlugin_Hypothesis_i::SetAttractor(GEOM::GEOM_Object_ptr GeomObj, cons
   ASSERT(myBaseImpl);
   string entry;
   entry = GeomObj->GetStudyEntry();
-  MESSAGE("IDL : GetName : " << GeomObj->GetName());
-  MESSAGE("IDL : SETATTRACTOR ( "<< entry << " , " << attractor << ")");
   SetAttractorEntry(entry.c_str(), attractor);
 }
 
@@ -2018,8 +1954,6 @@ void BLSURFPlugin_Hypothesis_i::UnsetAttractor(GEOM::GEOM_Object_ptr GeomObj) {
   ASSERT(myBaseImpl);
   string entry;
   entry = GeomObj->GetStudyEntry();
-  MESSAGE("IDL : GetName : " << GeomObj->GetName());
-  MESSAGE("IDL : UNSETATTRACTOR ( "<< entry << ")");
   UnsetEntry(entry.c_str());
   SMESH::TPythonDump() << _this() << ".UnsetAttractor( " << entry.c_str() << " )";
 }
@@ -2065,8 +1999,6 @@ void BLSURFPlugin_Hypothesis_i::SetAttractorGeom(GEOM::GEOM_Object_ptr theFace,
   
   TopoDS_Face FaceShape = TopoDS::Face(SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theFace ));
   TopoDS_Shape AttractorShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theAttractor );
-  MESSAGE("IDL : GetName : " << theFace->GetName());
-  MESSAGE("IDL : SETATTRACTOR () ");//<< entry << " , " << att_entry << ")");
   SetClassAttractorEntry( theFaceEntry.c_str(), theAttEntry.c_str(), StartSize, EndSize, ActionRadius, ConstantRadius);
 }
 
@@ -2092,8 +2024,6 @@ void BLSURFPlugin_Hypothesis_i::UnsetAttractorGeom(GEOM::GEOM_Object_ptr theFace
        !theAttrEntry.in() || !theAttrEntry.in()[0] )
     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
   
-  MESSAGE("IDL : GetName : " << theFace->GetName());
-  MESSAGE("IDL : UNSETATTRACTOR ( "<< theFaceEntry << ")");
   GetImpl()->ClearEntry( theFaceEntry.in(), theAttrEntry.in() );
   SMESH::TPythonDump() << _this() << ".UnsetAttractorGeom( "
                        << theFace << ", " << theAttractor << " )";
@@ -2109,30 +2039,30 @@ void BLSURFPlugin_Hypothesis_i::UnsetAttractorEntry(const char* faceEntry,
 
 
 /*
- void BLSURFPlugin_Hypothesis_i::SetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap)
- {}
 void BLSURFPlugin_Hypothesis_i::SetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap)
 {}
 
- void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj)
- {}
 void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj)
 {}
 
- void BLSURFPlugin_Hypothesis_i::SetCustomSizeMapEntry(const char* entry,const char* sizeMap )  throw (SALOME::SALOME_Exception)
- {}
 void BLSURFPlugin_Hypothesis_i::SetCustomSizeMapEntry(const char* entry,const char* sizeMap )  throw (SALOME::SALOME_Exception)
 {}
 
- char* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntry(const char* entry)  throw (SALOME::SALOME_Exception)
- {}
 char* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntry(const char* entry)  throw (SALOME::SALOME_Exception)
 {}
 
- void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMapEntry(const char* entry)
- {
- ASSERT(myBaseImpl);
- this->GetImpl()->UnsetCustomSizeMap(entry);
- SMESH::TPythonDump() << _this() << ".UnsetCustomSizeMap( " << entry << " )";
- }
 void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMapEntry(const char* entry)
 {
 ASSERT(myBaseImpl);
 this->GetImpl()->UnsetCustomSizeMap(entry);
 SMESH::TPythonDump() << _this() << ".UnsetCustomSizeMap( " << entry << " )";
 }
 
 
- BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntries()
- {}
 BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntries()
 {}
 
- */
+*/
 
 // ///////////////////////
 // // ENFORCED VERTICES //
@@ -2145,28 +2075,24 @@ void BLSURFPlugin_Hypothesis_i::UnsetAttractorEntry(const char* faceEntry,
  *
  */
 BLSURFPlugin::TFaceEntryEnfVertexListMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVerticesByFace() {
-  MESSAGE("IDL: GetAllEnforcedVerticesByFace()");
   ASSERT(myBaseImpl);
 
   BLSURFPlugin::TFaceEntryEnfVertexListMap_var resultMap = new BLSURFPlugin::TFaceEntryEnfVertexListMap();
 
   const ::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexListMap faceEntryEnfVertexListMap =
-      this->GetImpl()->_GetAllEnforcedVerticesByFace();
+    this->GetImpl()->_GetAllEnforcedVerticesByFace();
   resultMap->length(faceEntryEnfVertexListMap.size());
-  MESSAGE("Face entry to Enforced Vertex map size is " << resultMap->length());
 
   ::BLSURFPlugin_Hypothesis::TEnfVertexList _enfVertexList;
   ::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexListMap::const_iterator it_entry = faceEntryEnfVertexListMap.begin();
   for (int i = 0; it_entry != faceEntryEnfVertexListMap.end(); ++it_entry, ++i) {
     BLSURFPlugin::TFaceEntryEnfVertexListMapElement_var mapElement =
-        new BLSURFPlugin::TFaceEntryEnfVertexListMapElement();
+      new BLSURFPlugin::TFaceEntryEnfVertexListMapElement();
     mapElement->faceEntry = CORBA::string_dup(it_entry->first.c_str());
-    MESSAGE("Face Entry: " << mapElement->faceEntry);
 
     _enfVertexList = it_entry->second;
     BLSURFPlugin::TEnfVertexList_var enfVertexList = new BLSURFPlugin::TEnfVertexList();
     enfVertexList->length(_enfVertexList.size());
-    MESSAGE("Number of enf vertex: " << enfVertexList->length());
 
     ::BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator it_enfVertex = _enfVertexList.begin();
     ::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex;
@@ -2203,10 +2129,9 @@ BLSURFPlugin::TFaceEntryEnfVertexListMap* BLSURFPlugin_Hypothesis_i::GetAllEnfor
       msg << "Enforced vertex: \n"
           << "Name: " << enfVertex->name << "\n";
       if (coords->length())
-          msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
+        msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
       msg << "Geom entry: " << enfVertex->geomEntry << "\n"
           << "Group Name: " << enfVertex->grpName;
-      MESSAGE(msg.str());
 
       enfVertexList[j] = enfVertex;
     }
@@ -2224,17 +2149,14 @@ BLSURFPlugin::TFaceEntryEnfVertexListMap* BLSURFPlugin_Hypothesis_i::GetAllEnfor
  *
  */
 BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVertices() {
-  MESSAGE("IDL: GetAllEnforcedVertices()");
   ASSERT(myBaseImpl);
   BLSURFPlugin::TEnfVertexList_var resultMap = new BLSURFPlugin::TEnfVertexList();
   const ::BLSURFPlugin_Hypothesis::TEnfVertexList enfVertexList = this->GetImpl()->_GetAllEnforcedVertices();
   resultMap->length(enfVertexList.size());
-  MESSAGE("Enforced Vertex map size is " << resultMap->length());
 
   ::BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator evlIt = enfVertexList.begin();
   ::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex;
   for (int i = 0; evlIt != enfVertexList.end(); ++evlIt, ++i) {
-    MESSAGE("Enforced Vertex #" << i);
     currentEnfVertex = (*evlIt);
     BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex();
     // Name
@@ -2261,10 +2183,9 @@ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVertices(
     msg << "Enforced vertex: \n"
         << "Name: " << enfVertex->name << "\n";
     if (coords->length())
-        msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
+      msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
     msg << "Geom entry: " << enfVertex->geomEntry << "\n"
         << "Group Name: " << enfVertex->grpName;
-    MESSAGE(msg.str());
 
     resultMap[i] = enfVertex;
   }
@@ -2279,26 +2200,22 @@ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVertices(
  *
  */
 BLSURFPlugin::TFaceEntryCoordsListMap* BLSURFPlugin_Hypothesis_i::GetAllCoordsByFace() {
-  MESSAGE("IDL: GetAllCoordsByFace()");
   ASSERT(myBaseImpl);
 
   BLSURFPlugin::TFaceEntryCoordsListMap_var resultMap = new BLSURFPlugin::TFaceEntryCoordsListMap();
 
   const ::BLSURFPlugin_Hypothesis::TFaceEntryCoordsListMap entryCoordsListMap = this->GetImpl()->_GetAllCoordsByFace();
   resultMap->length(entryCoordsListMap.size());
-  MESSAGE("Enforced Vertex map size is " << resultMap->length());
 
   ::BLSURFPlugin_Hypothesis::TEnfVertexCoordsList _coordsList;
   ::BLSURFPlugin_Hypothesis::TFaceEntryCoordsListMap::const_iterator it_entry = entryCoordsListMap.begin();
   for (int i = 0; it_entry != entryCoordsListMap.end(); ++it_entry, ++i) {
     BLSURFPlugin::TFaceEntryCoordsListMapElement_var mapElement = new BLSURFPlugin::TFaceEntryCoordsListMapElement();
     mapElement->faceEntry = CORBA::string_dup(it_entry->first.c_str());
-    MESSAGE("Face Entry: " << mapElement->faceEntry);
 
     _coordsList = it_entry->second;
     BLSURFPlugin::TEnfVertexCoordsList_var coordsList = new BLSURFPlugin::TEnfVertexCoordsList();
     coordsList->length(_coordsList.size());
-    MESSAGE("Number of coords: " << coordsList->length());
 
     ::BLSURFPlugin_Hypothesis::TEnfVertexCoordsList::const_iterator it_coords = _coordsList.begin();
     for (int j = 0; it_coords != _coordsList.end(); ++it_coords, ++j) {
@@ -2307,7 +2224,6 @@ BLSURFPlugin::TFaceEntryCoordsListMap* BLSURFPlugin_Hypothesis_i::GetAllCoordsBy
       for (CORBA::ULong i=0;i<coords->length();i++)
         coords[i] = (*it_coords)[i];
       coordsList[j] = coords;
-      MESSAGE("Coords #" << j << ": " << coords[0] << ", " << coords[1] << ", " << coords[2]);
     }
     mapElement->coordsList = coordsList;
 
@@ -2322,19 +2238,16 @@ BLSURFPlugin::TFaceEntryCoordsListMap* BLSURFPlugin_Hypothesis_i::GetAllCoordsBy
  * They are the coords of the "manual" enforced vertices.
  */
 BLSURFPlugin::TCoordsEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVerticesByCoords() {
-  MESSAGE("IDL: GetAllEnforcedVerticesByCoords()");
   ASSERT(myBaseImpl);
 
   BLSURFPlugin::TCoordsEnfVertexMap_var resultMap = new BLSURFPlugin::TCoordsEnfVertexMap();
   const ::BLSURFPlugin_Hypothesis::TCoordsEnfVertexMap coordsEnfVertexMap =
-      this->GetImpl()->_GetAllEnforcedVerticesByCoords();
+    this->GetImpl()->_GetAllEnforcedVerticesByCoords();
   resultMap->length(coordsEnfVertexMap.size());
-  MESSAGE("Enforced Vertex map size is " << resultMap->length());
 
   ::BLSURFPlugin_Hypothesis::TCoordsEnfVertexMap::const_iterator it_coords = coordsEnfVertexMap.begin();
   ::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex;
   for (int i = 0; it_coords != coordsEnfVertexMap.end(); ++it_coords, ++i) {
-    MESSAGE("Enforced Vertex #" << i);
     currentEnfVertex = (it_coords->second);
     BLSURFPlugin::TCoordsEnfVertexElement_var mapElement = new BLSURFPlugin::TCoordsEnfVertexElement();
     BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords();
@@ -2342,7 +2255,6 @@ BLSURFPlugin::TCoordsEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVert
     for (CORBA::ULong ind=0;ind<coords->length();ind++)
       coords[ind] = it_coords->first[ind];
     mapElement->coords = coords;
-    MESSAGE("Coords: " << mapElement->coords[0] << ", " << mapElement->coords[1] << ", " << mapElement->coords[2]);
 
     BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex();
     // Name
@@ -2370,10 +2282,9 @@ BLSURFPlugin::TCoordsEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVert
     msg << "Enforced vertex: \n"
         << "Name: " << enfVertex->name << "\n";
     if (coords->length())
-        msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
+      msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
     msg << "Geom entry: " << enfVertex->geomEntry << "\n"
         << "Group Name: " << enfVertex->grpName;
-    MESSAGE(msg.str());
 
     resultMap[i] = mapElement;
   }
@@ -2387,34 +2298,29 @@ BLSURFPlugin::TCoordsEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVert
  *
  */
 BLSURFPlugin::TFaceEntryEnfVertexEntryListMap* BLSURFPlugin_Hypothesis_i::GetAllEnfVertexEntriesByFace() {
-  MESSAGE("IDL: GetAllEnfVertexEntriesByFace()");
   ASSERT(myBaseImpl);
 
   BLSURFPlugin::TFaceEntryEnfVertexEntryListMap_var resultMap = new BLSURFPlugin::TFaceEntryEnfVertexEntryListMap();
 
   const ::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexEntryListMap entryEnfVertexEntryListMap =
-      this->GetImpl()->_GetAllEnfVertexEntriesByFace();
+    this->GetImpl()->_GetAllEnfVertexEntriesByFace();
   resultMap->length(entryEnfVertexEntryListMap.size());
-  MESSAGE("Enforced Vertex map size is " << resultMap->length());
 
   ::BLSURFPlugin_Hypothesis::TEntryList _enfVertexEntryList;
   ::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexEntryListMap::const_iterator it_entry =
       entryEnfVertexEntryListMap.begin();
   for (int i = 0; it_entry != entryEnfVertexEntryListMap.end(); ++it_entry, ++i) {
     BLSURFPlugin::TFaceEntryEnfVertexEntryListMapElement_var mapElement =
-        new BLSURFPlugin::TFaceEntryEnfVertexEntryListMapElement();
+      new BLSURFPlugin::TFaceEntryEnfVertexEntryListMapElement();
     mapElement->faceEntry = CORBA::string_dup(it_entry->first.c_str());
-    MESSAGE("Face Entry: " << mapElement->faceEntry);
 
     _enfVertexEntryList = it_entry->second;
     BLSURFPlugin::TEntryList_var enfVertexEntryList = new BLSURFPlugin::TEntryList();
     enfVertexEntryList->length(_enfVertexEntryList.size());
-    MESSAGE("Number of enf vertex entries: " << enfVertexEntryList->length());
 
     ::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it_enfVertexEntry = _enfVertexEntryList.begin();
     for (int j = 0; it_enfVertexEntry != _enfVertexEntryList.end(); ++it_enfVertexEntry, ++j) {
       enfVertexEntryList[j] = CORBA::string_dup((*it_enfVertexEntry).c_str());
-      MESSAGE("Enf Vertex Entry #" << j << ": " << enfVertexEntryList[j]);
     }
     mapElement->enfVertexEntryList = enfVertexEntryList;
 
@@ -2429,23 +2335,19 @@ BLSURFPlugin::TFaceEntryEnfVertexEntryListMap* BLSURFPlugin_Hypothesis_i::GetAll
  * They are the geom entries of the enforced vertices defined with geom shape (vertex, compound, group).
  */
 BLSURFPlugin::TEnfVertexEntryEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVerticesByEnfVertexEntry() {
-  MESSAGE("IDL: GetAllEnforcedVerticesByEnfVertexEntry()");
   ASSERT(myBaseImpl);
 
   BLSURFPlugin::TEnfVertexEntryEnfVertexMap_var resultMap = new BLSURFPlugin::TEnfVertexEntryEnfVertexMap();
   const ::BLSURFPlugin_Hypothesis::TEnfVertexEntryEnfVertexMap enfVertexEntryEnfVertexMap =
-      this->GetImpl()->_GetAllEnforcedVerticesByEnfVertexEntry();
+    this->GetImpl()->_GetAllEnforcedVerticesByEnfVertexEntry();
   resultMap->length(enfVertexEntryEnfVertexMap.size());
-  MESSAGE("Enforced Vertex map size is " << resultMap->length());
 
   ::BLSURFPlugin_Hypothesis::TEnfVertexEntryEnfVertexMap::const_iterator it_enfVertexEntry = enfVertexEntryEnfVertexMap.begin();
   ::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex;
   for (int i = 0; it_enfVertexEntry != enfVertexEntryEnfVertexMap.end(); ++it_enfVertexEntry, ++i) {
-    MESSAGE("Enforced Vertex #" << i);
     currentEnfVertex = it_enfVertexEntry->second;
     BLSURFPlugin::TEnfVertexEntryEnfVertexElement_var mapElement = new BLSURFPlugin::TEnfVertexEntryEnfVertexElement();
     mapElement->enfVertexEntry = CORBA::string_dup(it_enfVertexEntry->first.c_str());;
-    MESSAGE("Enf Vertex Entry #" << i << ": " << mapElement->enfVertexEntry);
 
     BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex();
     // Name
@@ -2472,10 +2374,9 @@ BLSURFPlugin::TEnfVertexEntryEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnfo
     msg << "Enforced vertex: \n"
         << "Name: " << enfVertex->name << "\n";
     if (coords->length())
-        msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
+      msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
     msg << "Geom entry: " << enfVertex->geomEntry << "\n"
         << "Group Name: " << enfVertex->grpName;
-    MESSAGE(msg.str());
 
     mapElement->enfVertex = enfVertex;
     resultMap[i] = mapElement;
@@ -2496,11 +2397,10 @@ void BLSURFPlugin_Hypothesis_i::ClearAllEnforcedVertices() {
  * Set/get/unset an enforced vertex on face - OBSOLETE
  */
 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y,
-    CORBA::Double z) throw (SALOME::SALOME_Exception) {
+                                                  CORBA::Double z) throw (SALOME::SALOME_Exception) {
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theFace shape type is not FACE or COMPOUND");
     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
   }
 
@@ -2521,8 +2421,6 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertex(GEOM::GEOM_Object_ptr theFace,
   }
   if (theFaceEntry.empty())
     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
-  MESSAGE("IDL : GetName : " << theFace->GetName());
-  MESSAGE("IDL : SetEnforcedVertex( "<< theFaceEntry << ", " << x << ", " << y << ", " << z << ")");
   try {
     return SetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z);
   } catch (SALOME_Exception& ex) {
@@ -2534,11 +2432,10 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertex(GEOM::GEOM_Object_ptr theFace,
  * Set/get/unset an enforced vertex with name on face
  */
 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamed(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y,
-    CORBA::Double z, const char* theVertexName) throw (SALOME::SALOME_Exception) {
+                                                       CORBA::Double z, const char* theVertexName) throw (SALOME::SALOME_Exception) {
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theFace shape type is not FACE or COMPOUND");
     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
   }
 
@@ -2560,8 +2457,6 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamed(GEOM::GEOM_Object_ptr the
   if (theFaceEntry.empty())
     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
   
-  MESSAGE("IDL : GetName : " << theFace->GetName());
-  MESSAGE("IDL : SetEnforcedVertexNamed( "<< theFaceEntry << ", " << x << ", " << y << ", " << z << ", " << theVertexName << ")");
   try {
     return SetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z, theVertexName);
   } catch (SALOME_Exception& ex) {
@@ -2573,16 +2468,14 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamed(GEOM::GEOM_Object_ptr the
  * Set/get/unset an enforced vertex with geom object on face
  */
 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex)
-    throw (SALOME::SALOME_Exception) {
+  throw (SALOME::SALOME_Exception) {
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theFace shape type is not FACE or COMPOUND");
     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
   }
 
   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theVertex shape type is not VERTEX or COMPOUND");
     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
   }
 
@@ -2629,9 +2522,6 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theF
     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
 
   string theVertexName = theVertex->GetName();
-  MESSAGE("IDL : theFace->GetName : " << theFace->GetName());
-  MESSAGE("IDL : theVertex->GetName : " << theVertexName);
-  MESSAGE("IDL : SetEnforcedVertexGeom( "<< theFaceEntry << ", " << theVertexEntry<< ")");
   try {
     return SetEnforcedVertexEntry(theFaceEntry.c_str(), 0, 0, 0, theVertexName.c_str(), theVertexEntry.c_str());
   } catch (SALOME_Exception& ex) {
@@ -2643,12 +2533,11 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theF
  * Set an enforced vertex with group name on face
  */
 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
 throw (SALOME::SALOME_Exception)
 {
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theFace shape type is not FACE or COMPOUND");
     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
   }
 
@@ -2669,8 +2558,6 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr
   }
   if (theFaceEntry.empty())
     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
-  MESSAGE("IDL : GetName : " << theFace->GetName());
-  MESSAGE("IDL : SetEnforcedVertexWithGroup( "<< theFaceEntry << ", " << x << ", " << y << ", " << z << ", " << theGroupName << ")");
   try {
     return SetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z, "", "", theGroupName);
   } catch (SALOME_Exception& ex) {
@@ -2683,12 +2570,11 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr
  */
 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamedWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z, 
                                                                 const char* theVertexName, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
 throw (SALOME::SALOME_Exception)
 {
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theFace shape type is not FACE or COMPOUND");
     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
   }
 
@@ -2709,8 +2595,6 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamedWithGroup(GEOM::GEOM_Objec
   }
   if (theFaceEntry.empty())
     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
-  MESSAGE("IDL : GetName : " << theFace->GetName());
-  MESSAGE("IDL : SetEnforcedVertexNamedWithGroup( "<< theFaceEntry << ", " << x << ", " << y << ", " << z << ", " << theVertexName << ", " << theGroupName << ")");
   try {
     return SetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z, theVertexName, "", theGroupName);
   } catch (SALOME_Exception& ex) {
@@ -2722,17 +2606,15 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamedWithGroup(GEOM::GEOM_Objec
  * Set an enforced vertex with geom entry and group name on face
  */
 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
 throw (SALOME::SALOME_Exception)
 {
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theFace shape type is not FACE or COMPOUND");
     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
   }
 
   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theVertex shape type is not VERTEX or COMPOUND");
     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
   }
 
@@ -2770,9 +2652,6 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object
     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
 
   string theVertexName = theVertex->GetName();
-  MESSAGE("IDL : theFace->GetName : " << theFace->GetName());
-  MESSAGE("IDL : theVertex->GetName : " << theVertexName);
-  MESSAGE("IDL : SetEnforcedVertexGeomWithGroup( "<< theFaceEntry << ", " << theVertexEntry<< ", " << theGroupName<< ")");
   try {
     return SetEnforcedVertexEntry(theFaceEntry.c_str(), 0, 0, 0, theVertexName.c_str(), theVertexEntry.c_str(), theGroupName);
   } catch (SALOME_Exception& ex) {
@@ -2789,7 +2668,6 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object
 //  ASSERT(myBaseImpl);
 
 //  if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
-//    MESSAGE("theFace shape type is not FACE or COMPOUND");
 //    THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
 //  }
 
@@ -2811,8 +2689,6 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object
 //  if (theFaceEntry.empty())
 //    THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
 
-//  MESSAGE("IDL : GetName : " << theFace->GetName());
-//  MESSAGE("IDL : GetInternalEnforcedVertexEntry ( "<< theFaceEntry << ")");
 //  try {
 //    return GetInternalEnforcedVertexEntry(theFaceEntry.c_str());
 //  } catch (SALOME_Exception& ex) {
@@ -2824,11 +2700,10 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object
  * Get the list of all enforced vertices
  */
 BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVertices(GEOM::GEOM_Object_ptr theFace)
-    throw (SALOME::SALOME_Exception) {
+  throw (SALOME::SALOME_Exception) {
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theFace shape type is not FACE or COMPOUND");
     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
   }
 
@@ -2850,8 +2725,6 @@ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVertices(GEO
   if (theFaceEntry.empty())
     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
 
-  MESSAGE("IDL : GetName : " << theFace->GetName());
-  MESSAGE("IDL : GetEnforcedVerticesEntry ( "<< theFaceEntry << ")");
   try {
     return GetEnforcedVerticesEntry(theFaceEntry.c_str());
   } catch (SALOME_Exception& ex) {
@@ -2860,11 +2733,10 @@ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVertices(GEO
 }
 
 bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y,
-    CORBA::Double z) throw (SALOME::SALOME_Exception) {
+                                                    CORBA::Double z) throw (SALOME::SALOME_Exception) {
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theFace shape type is not FACE or COMPOUND");
     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
   }
 
@@ -2885,8 +2757,6 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertex(GEOM::GEOM_Object_ptr theFac
   }
   if (theFaceEntry.empty())
     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
-  MESSAGE("IDL : GetName : " << theFace->GetName());
-  MESSAGE("IDL : UnsetEnforcedVertex ( "<< theFaceEntry << ", " << x << ", " << y << ", " << z << ")");
 
   try {
     return UnsetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z);
@@ -2896,15 +2766,13 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertex(GEOM::GEOM_Object_ptr theFac
 }
 
 bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex)
-    throw (SALOME::SALOME_Exception) {
+  throw (SALOME::SALOME_Exception) {
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theFace shape type is not FACE or COMPOUND");
     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
   }
   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theVertex shape type is not VERTEX or COMPOUND");
     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
   }
 
@@ -2950,7 +2818,6 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexGeom(GEOM::GEOM_Object_ptr th
   if (theVertexEntry.empty())
     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
   
-  MESSAGE("IDL : UnsetEnforcedVertexGeom ( "<< theFaceEntry << ", " << theVertexEntry << ")");
 
   try {
     return UnsetEnforcedVertexEntry(theFaceEntry.c_str(), 0, 0, 0, theVertexEntry.c_str());
@@ -2963,7 +2830,6 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertices(GEOM::GEOM_Object_ptr theF
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theFace shape type is not FACE or COMPOUND");
     THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
   }
 
@@ -2985,8 +2851,6 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertices(GEOM::GEOM_Object_ptr theF
   if (theFaceEntry.empty())
     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
   
-  MESSAGE("IDL : GetName : " << theFace->GetName());
-  MESSAGE("IDL : UnsetEnforcedVertices ( "<< theFaceEntry << ")");
 
   try {
     return UnsetEnforcedVerticesEntry(theFaceEntry.c_str());
@@ -3025,10 +2889,9 @@ bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexNamed(CORBA::Double x, CORBA::D
  * Set/get/unset an enforced vertex with geom object on face
  */
 bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
-    throw (SALOME::SALOME_Exception)
+  throw (SALOME::SALOME_Exception)
 {
   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theVertex shape type is not VERTEX or COMPOUND");
     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
   }
   string theVertexEntry = theVertex->GetStudyEntry();
@@ -3062,7 +2925,7 @@ bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexGeom(GEOM::GEOM_Object_ptr theV
  * Set an enforced vertex with group name on face
  */
 bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
 throw (SALOME::SALOME_Exception)
 {
   ASSERT(myBaseImpl);
 
@@ -3078,7 +2941,7 @@ bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexWithGroup(CORBA::Double x, CORB
  */
 bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexNamedWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, 
                                                                 const char* theVertexName, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
 throw (SALOME::SALOME_Exception)
 {
   ASSERT(myBaseImpl);
 
@@ -3093,10 +2956,9 @@ bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexNamedWithGroup(CORBA::Double x,
  * Set an enforced vertex with geom entry and group name on face
  */
 bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theVertex, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
 throw (SALOME::SALOME_Exception)
 {
   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theVertex shape type is not VERTEX or COMPOUND");
     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
   }
 
@@ -3137,10 +2999,9 @@ bool BLSURFPlugin_Hypothesis_i::RemoveEnforcedVertex(CORBA::Double x, CORBA::Dou
 }
 
 bool BLSURFPlugin_Hypothesis_i::RemoveEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
-    throw (SALOME::SALOME_Exception)
+  throw (SALOME::SALOME_Exception)
 {
   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theVertex shape type is not VERTEX or COMPOUND");
     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
   }
   std::string theVertexEntry = theVertex->GetStudyEntry();
@@ -3258,13 +3119,12 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexEntry(const char* theFaceEntry,
 }
 
 BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVerticesEntry(const char* entry)
-    throw (SALOME::SALOME_Exception)
+  throw (SALOME::SALOME_Exception)
 {
   try {
     BLSURFPlugin::TEnfVertexList_var vertexList = new BLSURFPlugin::TEnfVertexList();
     ::BLSURFPlugin_Hypothesis::TEnfVertexList _vList = this->GetImpl()->GetEnfVertexList(entry);
     vertexList->length(_vList.size());
-    MESSAGE("Number of enforced vertices: " << vertexList->length());
     ::BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator evlIt = _vList.begin();
     for (int i = 0; evlIt != _vList.end(); ++evlIt, ++i) {
       ::BLSURFPlugin_Hypothesis::TEnfVertex *_enfVertex = (*evlIt);
@@ -3293,7 +3153,6 @@ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVerticesEntr
 
       vertexList[i] = enfVertex;
     }
-    MESSAGE("ENGINE : GetEnforcedVerticesEntry END ENTRY : " << entry);
     return vertexList._retn();
   } catch (const std::invalid_argument& ex) {
     SALOME::ExceptionStruct ExDescription;
@@ -3318,7 +3177,7 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexEntry(const char* theFaceEntr
 
     if (string(theVertexEntry).empty())
       SMESH::TPythonDump() << "isDone = " << _this() << ".RemoveEnforcedVertex(" << x << ", " << y << ", " << z
-          << ")";
+                           << ")";
     else
       SMESH::TPythonDump() << "isDone = " << _this() << ".RemoveEnforcedVertexGeom(" << theVertexEntry << ")";
 
@@ -3329,7 +3188,6 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexEntry(const char* theFaceEntr
     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
   }
 
-  MESSAGE("ENGINE : UnsetEnforcedVertexEntry END ENTRY : " << theFaceEntry);
   return res;
 }
 bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVerticesEntry(const char* theFaceEntry) throw (SALOME::SALOME_Exception)
@@ -3406,125 +3264,115 @@ char* BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFacesGroup()
 /*
  * Enable internal enforced vertices on specific face if requested by user
  *
-void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices)
+ void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices)
  throw (SALOME::SALOME_Exception)
-{
-  MESSAGE("BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexForFace");
-  try {
-    SetInternalEnforcedVertexWithGroup(theFace, toEnforceInternalVertices);
-  } catch (SALOME_Exception& ex) {
-    THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
-  }
-}
+ {
+ try {
+ SetInternalEnforcedVertexWithGroup(theFace, toEnforceInternalVertices);
+ } catch (SALOME_Exception& ex) {
+ THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
+ }
+ }
 
-void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName)
+ void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName)
  throw (SALOME::SALOME_Exception)
-{
-  MESSAGE("BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexForFaceWithGroup");
-
-  if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
-    MESSAGE("theFace shape type is not FACE or COMPOUND");
-    THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
-  }
-
-  string theFaceEntry = theFace->GetStudyEntry();
-
-  if (theFaceEntry.empty()) {
-    GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine();
-    SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen();
-    string aName;
-    if (theFace->GetShapeType() == GEOM::FACE)
-      aName = "Face_";
-    if (theFace->GetShapeType() == GEOM::COMPOUND)
-      aName = "Compound_";
-    aName += theFace->GetEntry();
-    SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str());
-    if (!theSFace->_is_nil())
-      theFaceEntry = theSFace->GetID();
-  }
-  if (theFaceEntry.empty())
-    THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
-
-  MESSAGE("IDL : GetName : " << theFace->GetName());
-  MESSAGE("IDL : GetInternalEnforcedVertexEntry ( "<< theFaceEntry << ")");
-  try {
-    SetInternalEnforcedVertexEntry(theFaceEntry.c_str(), toEnforceInternalVertices, theGroupName);
-  } catch (SALOME_Exception& ex) {
-    THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
-  }
-}
+ {
 
-void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexEntry(const char* theFaceEntry, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName)
-    throw (SALOME::SALOME_Exception)
-{
-  MESSAGE("BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexForFaceEntry");
-  ASSERT(myBaseImpl);
-  try {
-    this->GetImpl()->SetInternalEnforcedVertex(theFaceEntry, toEnforceInternalVertices, theGroupName);
-    std::string theValueStr = toEnforceInternalVertices ? "True" : "False";
-    if (string(theGroupName).empty())
-      SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertex( " << theFaceEntry << ", " << theValueStr.c_str() << " )";
-    else
-      SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertexWithGroup( " << theFaceEntry << ", " << theValueStr.c_str() << ", \"" << theGroupName << "\" )";
-  } catch (const std::exception& ex) {
-    std::cout << "Exception: " << ex.what() << std::endl;
-    THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
-  }
-}
+ if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
+ THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
+ }
 
-*/
+ string theFaceEntry = theFace->GetStudyEntry();
+
+ if (theFaceEntry.empty()) {
+ GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine();
+ SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen();
+ string aName;
+ if (theFace->GetShapeType() == GEOM::FACE)
+ aName = "Face_";
+ if (theFace->GetShapeType() == GEOM::COMPOUND)
+ aName = "Compound_";
+ aName += theFace->GetEntry();
+ SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str());
+ if (!theSFace->_is_nil())
+ theFaceEntry = theSFace->GetID();
+ }
+ if (theFaceEntry.empty())
+ THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
 
-/* TODO GROUPS
- char* BLSURFPlugin_Hypothesis_i::GetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z)
- throw (SALOME::SALOME_Exception)
- {
- ASSERT(myBaseImpl);
- MESSAGE("ENGINE : GetEnforcedVertexGroupName START ");
  try {
- return CORBA::string_dup( this->GetImpl()->GetEnforcedVertexGroupName(x, y, z).c_str());
- }
- catch (const std::invalid_argument& ex) {
- SALOME::ExceptionStruct ExDescription;
- ExDescription.text = ex.what();
- ExDescription.type = SALOME::BAD_PARAM;
- ExDescription.sourceFile = "BLSURFPlugin_Hypothesis_i::GetEnforcedVertexGroupName(entry)";
- ExDescription.lineNumber = 1146;
- throw SALOME::SALOME_Exception(ExDescription);
- }
- catch (SALOME_Exception& ex) {
+ SetInternalEnforcedVertexEntry(theFaceEntry.c_str(), toEnforceInternalVertices, theGroupName);
+ } catch (SALOME_Exception& ex) {
  THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
  }
- MESSAGE("ENGINE : GetEnforcedVertexGroupName END ");
- return 0;
  }
 
-
- void BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* groupName)
+ void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexEntry(const char* theFaceEntry, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName)
  throw (SALOME::SALOME_Exception)
  {
  ASSERT(myBaseImpl);
- MESSAGE("ENGINE : SetEnforcedVertexGroupName START ");
  try {
- this->GetImpl()->SetEnforcedVertexGroupName(x, y, z, groupName);
- }
- catch (const std::invalid_argument& ex) {
- SALOME::ExceptionStruct ExDescription;
- ExDescription.text = ex.what();
- ExDescription.type = SALOME::BAD_PARAM;
- ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetEnforcedVertexGroupName(x,y,z)";
- ExDescription.lineNumber = 1170;
- throw SALOME::SALOME_Exception(ExDescription);
- }
- catch (SALOME_Exception& ex) {
+ this->GetImpl()->SetInternalEnforcedVertex(theFaceEntry, toEnforceInternalVertices, theGroupName);
+ std::string theValueStr = toEnforceInternalVertices ? "True" : "False";
+ if (string(theGroupName).empty())
+ SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertex( " << theFaceEntry << ", " << theValueStr.c_str() << " )";
+ else
+ SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertexWithGroup( " << theFaceEntry << ", " << theValueStr.c_str() << ", \"" << theGroupName << "\" )";
+ } catch (const std::exception& ex) {
+ std::cout << "Exception: " << ex.what() << std::endl;
  THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
  }
+ }
 
- SMESH::TPythonDump() << _this() << ".SetEnforcedVertexGroupName("
- << x << ", " << y << ", " << z << ", '" << groupName << "' )";
+*/
 
- MESSAGE("ENGINE : SetEnforcedVertexGroupName END ");
- }
- */
+/* TODO GROUPS
+   char* BLSURFPlugin_Hypothesis_i::GetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z)
+   throw (SALOME::SALOME_Exception)
+   {
+   ASSERT(myBaseImpl);
+   try {
+   return CORBA::string_dup( this->GetImpl()->GetEnforcedVertexGroupName(x, y, z).c_str());
+   }
+   catch (const std::invalid_argument& ex) {
+   SALOME::ExceptionStruct ExDescription;
+   ExDescription.text = ex.what();
+   ExDescription.type = SALOME::BAD_PARAM;
+   ExDescription.sourceFile = "BLSURFPlugin_Hypothesis_i::GetEnforcedVertexGroupName(entry)";
+   ExDescription.lineNumber = 1146;
+   throw SALOME::SALOME_Exception(ExDescription);
+   }
+   catch (SALOME_Exception& ex) {
+   THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
+   }
+   return 0;
+   }
+
+
+   void BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* groupName)
+   throw (SALOME::SALOME_Exception)
+   {
+   ASSERT(myBaseImpl);
+   try {
+   this->GetImpl()->SetEnforcedVertexGroupName(x, y, z, groupName);
+   }
+   catch (const std::invalid_argument& ex) {
+   SALOME::ExceptionStruct ExDescription;
+   ExDescription.text = ex.what();
+   ExDescription.type = SALOME::BAD_PARAM;
+   ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetEnforcedVertexGroupName(x,y,z)";
+   ExDescription.lineNumber = 1170;
+   throw SALOME::SALOME_Exception(ExDescription);
+   }
+   catch (SALOME_Exception& ex) {
+   THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
+   }
+
+   SMESH::TPythonDump() << _this() << ".SetEnforcedVertexGroupName("
+   << x << ", " << y << ", " << z << ", '" << groupName << "' )";
+
+   }
+*/
 ///////////////////////
 
 ///////////////////////
@@ -3534,7 +3382,6 @@ void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexEntry(const char* theFa
 
 std::string BLSURFPlugin_Hypothesis_i::ShapeTypeToString(GEOM::shape_type theShapeType)
 {
-//enum shape_type { COMPOUND, COMPSOLID, SOLID, SHELL, FACE, WIRE, EDGE, VERTEX, SHAPE /*, __max_shape_type=0xffffffff */ };
   std::map<GEOM::shape_type, std::string> MapShapeTypeToString;
   MapShapeTypeToString[GEOM::COMPOUND] = std::string("COMPOUND");
   MapShapeTypeToString[GEOM::COMPSOLID] = std::string("COMPSOLID");
@@ -3555,18 +3402,17 @@ void BLSURFPlugin_Hypothesis_i::CheckShapeTypes(GEOM::GEOM_Object_ptr shape, std
   bool ok = false;
   std::stringstream typesTxt;
   for (std::size_t i=0; i<theShapeTypes.size(); i++)
-    {
-      GEOM::shape_type theShapeType = theShapeTypes[i];
-      if (shape->GetShapeType() == theShapeType)
-        ok = true;
-      typesTxt << ShapeTypeToString(theShapeType);
-      if (i < theShapeTypes.size()-1 )
-        typesTxt << ", ";
-    }
+  {
+    GEOM::shape_type theShapeType = theShapeTypes[i];
+    if (shape->GetShapeType() == theShapeType)
+      ok = true;
+    typesTxt << ShapeTypeToString(theShapeType);
+    if (i < theShapeTypes.size()-1 )
+      typesTxt << ", ";
+  }
   if (!ok){
     std::stringstream msg;
-    msg << "shape shape type is not in" << typesTxt.str();
-    MESSAGE(msg.str());
+    msg << "shape type is not in" << typesTxt.str();
     THROW_SALOME_CORBA_EXCEPTION(msg.str().c_str(), SALOME::BAD_PARAM);
   }
 }
@@ -3577,7 +3423,6 @@ void BLSURFPlugin_Hypothesis_i::CheckShapeType(GEOM::GEOM_Object_ptr shape, GEOM
   if (shape->GetShapeType() != theShapeType) {
     std::stringstream msg;
     msg << "shape shape type is not " << ShapeTypeToString(theShapeType);
-    MESSAGE(msg.str());
     THROW_SALOME_CORBA_EXCEPTION(msg.str().c_str(), SALOME::BAD_PARAM);
   }
 }
@@ -3611,26 +3456,26 @@ std::string BLSURFPlugin_Hypothesis_i::FormatVerticesEntries(vector<string> &the
   std::stringstream listEntriesTxt;
 
   if (!theSourceVerticesEntries.empty())
+  {
+    listEntriesTxt << ", [" ;
+    size_t i =0;
+    for (std::vector<std::string>::const_iterator it = theSourceVerticesEntries.begin(); it != theSourceVerticesEntries.end(); it++, i++)
     {
-      listEntriesTxt << ", [" ;
-      size_t i =0;
-      for (std::vector<std::string>::const_iterator it = theSourceVerticesEntries.begin(); it != theSourceVerticesEntries.end(); it++, i++)
-        {
-          if (i>0)
-            listEntriesTxt << ", ";
-          listEntriesTxt << *it;
-        }
+      if (i>0)
+        listEntriesTxt << ", ";
+      listEntriesTxt << *it;
+    }
 
-      listEntriesTxt << "], [" ;
-      i =0;
-      for (std::vector<std::string>::const_iterator it = theTargetVerticesEntries.begin(); it != theTargetVerticesEntries.end(); it++, i++)
-        {
-          if (i>0)
-            listEntriesTxt << ", ";
-          listEntriesTxt << *it;
-        }
-      listEntriesTxt << "]" ;
+    listEntriesTxt << "], [" ;
+    i =0;
+    for (std::vector<std::string>::const_iterator it = theTargetVerticesEntries.begin(); it != theTargetVerticesEntries.end(); it++, i++)
+    {
+      if (i>0)
+        listEntriesTxt << ", ";
+      listEntriesTxt << *it;
     }
+    listEntriesTxt << "]" ;
+  }
   return listEntriesTxt.str();
 }
 
@@ -3645,66 +3490,61 @@ void BLSURFPlugin_Hypothesis_i::ClearPreCadPeriodicityVectors() {
 
 BLSURFPlugin::TPeriodicityList* BLSURFPlugin_Hypothesis_i::GetPreCadFacesPeriodicityVector()
 {
-  MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCadFacesPeriodicityVector");
   const ::BLSURFPlugin_Hypothesis::TPreCadPeriodicityVector preCadPeriodicityVector =
-      this->GetImpl()->_GetPreCadFacesPeriodicityVector();
+    this->GetImpl()->_GetPreCadFacesPeriodicityVector();
 
   BLSURFPlugin::TPeriodicityList_var periodicityList = PreCadVectorToSequence(preCadPeriodicityVector);
 
-  MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCadFacesPeriodicityVector end");
   return periodicityList._retn();
 }
 
 BLSURFPlugin::TPeriodicityList* BLSURFPlugin_Hypothesis_i::GetPreCadEdgesPeriodicityVector()
 {
-  MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCadEdgesPeriodicityVector");
   const ::BLSURFPlugin_Hypothesis::TPreCadPeriodicityVector preCadPeriodicityVector =
-      this->GetImpl()->_GetPreCadEdgesPeriodicityVector();
+    this->GetImpl()->_GetPreCadEdgesPeriodicityVector();
 
   BLSURFPlugin::TPeriodicityList_var periodicityList = PreCadVectorToSequence(preCadPeriodicityVector);
 
-  MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCadEdgesPeriodicityVector end");
   return periodicityList._retn();
 }
 
 // convert a vector preCadPeriodicityVector into TPeriodicityList Corba sequence
 BLSURFPlugin::TPeriodicityList* BLSURFPlugin_Hypothesis_i::PreCadVectorToSequence(const ::BLSURFPlugin_Hypothesis::TPreCadPeriodicityVector& preCadPeriodicityVector)
 {
-  MESSAGE("BLSURFPlugin_Hypothesis_i::PreCadVectorToSequence");
   BLSURFPlugin::TPeriodicityList_var periodicityList = new BLSURFPlugin::TPeriodicityList();
 
-    periodicityList->length(preCadPeriodicityVector.size());
+  periodicityList->length(preCadPeriodicityVector.size());
 
-    for (size_t i = 0; i<preCadPeriodicityVector.size(); i++)
-      {
-        ::BLSURFPlugin_Hypothesis::TPreCadPeriodicity preCadPeriodicityVector_i = preCadPeriodicityVector[i];
+  for (size_t i = 0; i<preCadPeriodicityVector.size(); i++)
+  {
+    ::BLSURFPlugin_Hypothesis::TPreCadPeriodicity preCadPeriodicityVector_i = preCadPeriodicityVector[i];
 
-        BLSURFPlugin::TPreCadPeriodicity_var myPreCadPeriodicity = new BLSURFPlugin::TPreCadPeriodicity();
-        myPreCadPeriodicity->shape1Entry = CORBA::string_dup(preCadPeriodicityVector_i.shape1Entry.c_str());
-        myPreCadPeriodicity->shape2Entry = CORBA::string_dup(preCadPeriodicityVector_i.shape2Entry.c_str());
+    BLSURFPlugin::TPreCadPeriodicity_var myPreCadPeriodicity = new BLSURFPlugin::TPreCadPeriodicity();
+    myPreCadPeriodicity->shape1Entry = CORBA::string_dup(preCadPeriodicityVector_i.shape1Entry.c_str());
+    myPreCadPeriodicity->shape2Entry = CORBA::string_dup(preCadPeriodicityVector_i.shape2Entry.c_str());
 
-        BLSURFPlugin::TEntryList_var sourceVertices = new BLSURFPlugin::TEntryList();
-        if (! preCadPeriodicityVector_i.theSourceVerticesEntries.empty())
-          {
-            sourceVertices->length(preCadPeriodicityVector_i.theSourceVerticesEntries.size());
-            for (size_t j=0; j<preCadPeriodicityVector_i.theSourceVerticesEntries.size(); j++)
-              sourceVertices[j]=CORBA::string_dup(preCadPeriodicityVector_i.theSourceVerticesEntries[j].c_str());
-          }
+    BLSURFPlugin::TEntryList_var sourceVertices = new BLSURFPlugin::TEntryList();
+    if (! preCadPeriodicityVector_i.theSourceVerticesEntries.empty())
+    {
+      sourceVertices->length(preCadPeriodicityVector_i.theSourceVerticesEntries.size());
+      for (size_t j=0; j<preCadPeriodicityVector_i.theSourceVerticesEntries.size(); j++)
+        sourceVertices[j]=CORBA::string_dup(preCadPeriodicityVector_i.theSourceVerticesEntries[j].c_str());
+    }
 
-        myPreCadPeriodicity->theSourceVerticesEntries = sourceVertices;
+    myPreCadPeriodicity->theSourceVerticesEntries = sourceVertices;
 
-        BLSURFPlugin::TEntryList_var targetVertices = new BLSURFPlugin::TEntryList();
-        if (! preCadPeriodicityVector_i.theTargetVerticesEntries.empty())
-           {
-            targetVertices->length(preCadPeriodicityVector_i.theTargetVerticesEntries.size());
-             for (size_t j=0; j<preCadPeriodicityVector_i.theTargetVerticesEntries.size(); j++)
-               targetVertices[j]=CORBA::string_dup(preCadPeriodicityVector_i.theTargetVerticesEntries[j].c_str());
-           }
+    BLSURFPlugin::TEntryList_var targetVertices = new BLSURFPlugin::TEntryList();
+    if (! preCadPeriodicityVector_i.theTargetVerticesEntries.empty())
+    {
+      targetVertices->length(preCadPeriodicityVector_i.theTargetVerticesEntries.size());
+      for (size_t j=0; j<preCadPeriodicityVector_i.theTargetVerticesEntries.size(); j++)
+        targetVertices[j]=CORBA::string_dup(preCadPeriodicityVector_i.theTargetVerticesEntries[j].c_str());
+    }
 
-        myPreCadPeriodicity->theTargetVerticesEntries = targetVertices;
+    myPreCadPeriodicity->theTargetVerticesEntries = targetVertices;
 
-        periodicityList[i] = myPreCadPeriodicity;
-      }
+    periodicityList[i] = myPreCadPeriodicity;
+  }
 
 
   return periodicityList._retn();
@@ -3712,7 +3552,7 @@ BLSURFPlugin::TPeriodicityList* BLSURFPlugin_Hypothesis_i::PreCadVectorToSequenc
 
 
 void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicity(GEOM::GEOM_Object_ptr theFace1, GEOM::GEOM_Object_ptr theFace2)
-throw (SALOME::SALOME_Exception)
+  throw (SALOME::SALOME_Exception)
 {
   ASSERT(myBaseImpl);
   const GEOM::ListOfGO theSourceVertices;
@@ -3722,11 +3562,10 @@ throw (SALOME::SALOME_Exception)
 
 
 void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityWithVertices(GEOM::GEOM_Object_ptr theFace1, GEOM::GEOM_Object_ptr theFace2,
-    const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices)
-throw (SALOME::SALOME_Exception)
+                                                                      const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices)
+  throw (SALOME::SALOME_Exception)
 {
   ASSERT(myBaseImpl);
-  MESSAGE("BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityWithVertices");
 
   size_t theLength = theSourceVertices.length();
   if (theLength != theTargetVertices.length())
@@ -3750,27 +3589,24 @@ throw (SALOME::SALOME_Exception)
   GEOM::GEOM_Object_ptr theVtx_i;
   string theEntry_i;
   for (size_t ind = 0; ind < theLength; ind++) {
-      theVtx_i = theSourceVertices[ind];
-      theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix3);
-      theSourceVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
+    theVtx_i = theSourceVertices[ind];
+    theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix3);
+    theSourceVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
   }
 
   string prefix4 = "Target_vertex_";
   BLSURFPlugin::TEntryList_var theTargetVerticesEntries = new BLSURFPlugin::TEntryList();
   theTargetVerticesEntries->length(theLength);
   for (size_t ind = 0; ind < theLength; ind++) {
-      theVtx_i = theTargetVertices[ind];
-      theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix4);
-      theTargetVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
+    theVtx_i = theTargetVertices[ind];
+    theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix4);
+    theTargetVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
   }
 
   string theFace2Name = theFace2->GetName();
-  MESSAGE("IDL : theFace1->GetName : " << theFace1->GetName());
-  MESSAGE("IDL : theFace2->GetName : " << theFace2->GetName());
-  MESSAGE("IDL : AddPreCadFacesPeriodicity( "<< theFace1Entry << ", " << theFace2Entry <<  ")");
   try {
-      AddPreCadFacesPeriodicityEntry(theFace1Entry.c_str(), theFace2Entry.c_str(),
-          theSourceVerticesEntries, theTargetVerticesEntries);
+    AddPreCadFacesPeriodicityEntry(theFace1Entry.c_str(), theFace2Entry.c_str(),
+                                   theSourceVerticesEntries, theTargetVerticesEntries);
   } catch (SALOME_Exception& ex) {
     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
   }
@@ -3778,8 +3614,8 @@ throw (SALOME::SALOME_Exception)
 
 
 void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityEntry(const char* theFace1Entry, const char* theFace2Entry,
-    const BLSURFPlugin::TEntryList& theSourceVerticesEntriesCorba, const BLSURFPlugin::TEntryList& theTargetVerticesEntriesCorba)
-    throw (SALOME::SALOME_Exception)
+                                                               const BLSURFPlugin::TEntryList& theSourceVerticesEntriesCorba, const BLSURFPlugin::TEntryList& theTargetVerticesEntriesCorba)
+  throw (SALOME::SALOME_Exception)
 {
 
   ASSERT(myBaseImpl);
@@ -3787,31 +3623,29 @@ void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityEntry(const char* theFa
   // Convert BLSURFPlugin::TEntryList to vector<string>
   vector<string> theSourceVerticesEntries, theTargetVerticesEntries;
   for (size_t ind = 0; ind < theSourceVerticesEntriesCorba.length(); ind++) {
-      theSourceVerticesEntries.push_back(theSourceVerticesEntriesCorba[ind].in());
-      theTargetVerticesEntries.push_back(theTargetVerticesEntriesCorba[ind].in());
+    theSourceVerticesEntries.push_back(theSourceVerticesEntriesCorba[ind].in());
+    theTargetVerticesEntries.push_back(theTargetVerticesEntriesCorba[ind].in());
   }
 
   string listEntriesTxt = FormatVerticesEntries(theSourceVerticesEntries, theTargetVerticesEntries);
 
-  MESSAGE("IDL : AddPreCadFacesPeriodicityEntry(" << theFace1Entry << ", " << theFace2Entry << listEntriesTxt.c_str() << ")");
 
   this->GetImpl()->AddPreCadFacesPeriodicity(theFace1Entry, theFace2Entry,
-      theSourceVerticesEntries, theTargetVerticesEntries);
+                                             theSourceVerticesEntries, theTargetVerticesEntries);
 
   SMESH::TPythonDump pd;
   if (!theSourceVerticesEntries.empty())
-    {
-      pd << _this() << ".AddPreCadFacesPeriodicityWithVertices(" << theFace1Entry << ", " << theFace2Entry;
-      pd << listEntriesTxt.c_str();
-      pd << ")";
-    }
+  {
+    pd << _this() << ".AddPreCadFacesPeriodicityWithVertices(" << theFace1Entry << ", " << theFace2Entry;
+    pd << listEntriesTxt.c_str();
+    pd << ")";
+  }
   else
     pd << _this() << ".AddPreCadFacesPeriodicity(" << theFace1Entry << ", " << theFace2Entry << ")";
-  MESSAGE("IDL : AddPreCadFacesPeriodicityEntry END");
 }
 
 void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicity(GEOM::GEOM_Object_ptr theEdge1, GEOM::GEOM_Object_ptr theEdge2)
-      throw (SALOME::SALOME_Exception)
+  throw (SALOME::SALOME_Exception)
 {
   ASSERT(myBaseImpl);
   const GEOM::ListOfGO theSourceVertices;
@@ -3820,10 +3654,9 @@ void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicity(GEOM::GEOM_Object_ptr
 }
 
 void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityWithVertices(GEOM::GEOM_Object_ptr theEdge1, GEOM::GEOM_Object_ptr theEdge2,
-    const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices)
-      throw (SALOME::SALOME_Exception)
+                                                                      const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices)
+  throw (SALOME::SALOME_Exception)
 {
-  MESSAGE("BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityWithVertices");
   ASSERT(myBaseImpl);
 
   size_t theLength = theSourceVertices.length();
@@ -3848,27 +3681,24 @@ void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityWithVertices(GEOM::GEOM
   GEOM::GEOM_Object_ptr theVtx_i;
   string theEntry_i;
   for (size_t ind = 0; ind < theLength; ind++) {
-      theVtx_i = theSourceVertices[ind];
-      theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix3);
-      theSourceVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
+    theVtx_i = theSourceVertices[ind];
+    theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix3);
+    theSourceVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
   }
 
   string prefix4 = "Target_vertex_";
   BLSURFPlugin::TEntryList_var theTargetVerticesEntries = new BLSURFPlugin::TEntryList();
   theTargetVerticesEntries->length(theLength);
   for (size_t ind = 0; ind < theLength; ind++) {
-      theVtx_i = theTargetVertices[ind];
-      theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix4);
-      theTargetVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
+    theVtx_i = theTargetVertices[ind];
+    theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix4);
+    theTargetVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
   }
 
   string theEdge2Name = theEdge2->GetName();
-  MESSAGE("IDL : theEdge1->GetName : " << theEdge1->GetName());
-  MESSAGE("IDL : theEdge2->GetName : " << theEdge2->GetName());
-  MESSAGE("IDL : AddPreCadEdgesPeriodicity( "<< theEdge1Entry << ", " << theEdge2Entry << ")");
   try {
-      AddPreCadEdgesPeriodicityEntry(theEdge1Entry.c_str(), theEdge2Entry.c_str(),
-          theSourceVerticesEntries, theTargetVerticesEntries);
+    AddPreCadEdgesPeriodicityEntry(theEdge1Entry.c_str(), theEdge2Entry.c_str(),
+                                   theSourceVerticesEntries, theTargetVerticesEntries);
   } catch (SALOME_Exception& ex) {
     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
   }
@@ -3876,8 +3706,8 @@ void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityWithVertices(GEOM::GEOM
 
 
 void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityEntry(const char* theEdge1Entry, const char* theEdge2Entry,
-    const BLSURFPlugin::TEntryList& theSourceVerticesEntriesCorba, const BLSURFPlugin::TEntryList& theTargetVerticesEntriesCorba)
-    throw (SALOME::SALOME_Exception)
+                                                               const BLSURFPlugin::TEntryList& theSourceVerticesEntriesCorba, const BLSURFPlugin::TEntryList& theTargetVerticesEntriesCorba)
+  throw (SALOME::SALOME_Exception)
 {
 
   ASSERT(myBaseImpl);
@@ -3885,27 +3715,25 @@ void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityEntry(const char* theEd
   // Convert BLSURFPlugin::TEntryList to vector<string>
   vector<string> theSourceVerticesEntries, theTargetVerticesEntries;
   for (size_t ind = 0; ind < theSourceVerticesEntriesCorba.length(); ind++) {
-      theSourceVerticesEntries.push_back(theSourceVerticesEntriesCorba[ind].in());
-      theTargetVerticesEntries.push_back(theTargetVerticesEntriesCorba[ind].in());
+    theSourceVerticesEntries.push_back(theSourceVerticesEntriesCorba[ind].in());
+    theTargetVerticesEntries.push_back(theTargetVerticesEntriesCorba[ind].in());
   }
 
   string listEntriesTxt = FormatVerticesEntries(theSourceVerticesEntries, theTargetVerticesEntries);
 
-  MESSAGE("IDL : AddPreCadEdgesPeriodicityEntry(" << theEdge1Entry << ", " << theEdge2Entry << listEntriesTxt.c_str() << ")");
   this->GetImpl()->AddPreCadEdgesPeriodicity(theEdge1Entry, theEdge2Entry,
-      theSourceVerticesEntries, theTargetVerticesEntries);
+                                             theSourceVerticesEntries, theTargetVerticesEntries);
 
   SMESH::TPythonDump pd;
   if (!theSourceVerticesEntries.empty())
-    {
-      pd << _this() << ".AddPreCadEdgesPeriodicityWithVertices(" << theEdge1Entry << ", " << theEdge2Entry;
-      pd << listEntriesTxt.c_str();
-      pd << ")";
-    }
+  {
+    pd << _this() << ".AddPreCadEdgesPeriodicityWithVertices(" << theEdge1Entry << ", " << theEdge2Entry;
+    pd << listEntriesTxt.c_str();
+    pd << ")";
+  }
   else
     pd << _this() << ".AddPreCadEdgesPeriodicity(" << theEdge1Entry << ", " << theEdge2Entry << ")";
 
-  MESSAGE("IDL : AddPreCadEdgesPeriodicityEntry END");
 }
 
 
@@ -3920,11 +3748,10 @@ void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityEntry(const char* theEd
 // void BLSURFPlugin_Hypothesis_i::SetGMFFile(const char* theFileName, CORBA::Boolean isBinary) {
 void BLSURFPlugin_Hypothesis_i::SetGMFFile(const char* theFileName) {
   ASSERT(myBaseImpl);
-  MESSAGE("IDL : SetGMFFile(" << theFileName << ")");
   bool valueChanged/*, modeChanged*/ = false;
   try {
     valueChanged = (this->GetImpl()->GetGMFFile() != theFileName);
-//     modeChanged = (this->GetImpl()->GetGMFFileMode() != isBinary);
+    //     modeChanged = (this->GetImpl()->GetGMFFileMode() != isBinary);
     if (valueChanged)// or (!valueChanged && modeChanged))
       this->GetImpl()->SetGMFFile(theFileName);// ,isBinary);
   } catch (const std::exception& ex) {
@@ -3932,7 +3759,6 @@ void BLSURFPlugin_Hypothesis_i::SetGMFFile(const char* theFileName) {
   }
   if (valueChanged)// or (!valueChanged && modeChanged))
     SMESH::TPythonDump() << _this() << ".SetGMFFile(\"" << theFileName << "\")"; //", " << isBinary << ")";
-  MESSAGE("IDL : SetGMFFile END ");
 }
 
 //================================================================================
@@ -3945,7 +3771,6 @@ void BLSURFPlugin_Hypothesis_i::SetGMFFile(const char* theFileName) {
 //================================================================================  
 char* BLSURFPlugin_Hypothesis_i::GetGMFFile() {
   ASSERT(myBaseImpl);
-//   MESSAGE("IDL : GetGMFFile()");
   return CORBA::string_dup(this->GetImpl()->GetGMFFile().c_str());
 }
 
@@ -3959,7 +3784,6 @@ char* BLSURFPlugin_Hypothesis_i::GetGMFFile() {
 // //================================================================================  
 // CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetGMFFileMode() {
 //   ASSERT(myBaseImpl);
-//   MESSAGE("IDL : GetGMFFileMode()");
 //   return this->GetImpl()->GetGMFFileMode();
 // }
 
@@ -3971,7 +3795,6 @@ char* BLSURFPlugin_Hypothesis_i::GetGMFFile() {
  */
 //=============================================================================
 ::BLSURFPlugin_Hypothesis* BLSURFPlugin_Hypothesis_i::GetImpl() {
-  // MESSAGE("BLSURFPlugin_Hypothesis_i::GetImpl");
   return (::BLSURFPlugin_Hypothesis*) myBaseImpl;
 }
 
@@ -4035,7 +3858,7 @@ void BLSURFPlugin_Hypothesis_i::SetDecimesh(CORBA::Boolean theValue) {
 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetDecimesh() {
   std::string theValueStr = this->GetOptionValue("respect_geometry");
   if (theValueStr.empty() || theValueStr == "respect")
-      return true;
+    return true;
   return false;
 }
 void BLSURFPlugin_Hypothesis_i::SetPreCADRemoveNanoEdges(CORBA::Boolean theValue) {
@@ -4045,7 +3868,7 @@ void BLSURFPlugin_Hypothesis_i::SetPreCADRemoveNanoEdges(CORBA::Boolean theValue
 CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADRemoveNanoEdges() {
   std::string theValueStr = this->GetPreCADOption("remove_tiny_edges");
   if (theValueStr == "1")
-      return true;
+    return true;
   return false;
 }
 void BLSURFPlugin_Hypothesis_i::SetPreCADEpsNano(CORBA::Double theValue) {
index 50b68061646d9ca8a28f7d3442469db58752c8e2..d711253a26e25d75eda4bbfb519e5469f1f1dc7a 100644 (file)
@@ -37,11 +37,16 @@ class GEOM_Object;
 
 // BLSURFPlugin parameters hypothesis
 
-class BLSURFPlugin_Hypothesis_i: public virtual POA_BLSURFPlugin::BLSURFPlugin_Hypothesis,
-    public virtual SMESH_Hypothesis_i {
+class BLSURFPlugin_Hypothesis_i:
+  public virtual POA_BLSURFPlugin::BLSURFPlugin_Hypothesis,
+  public virtual SMESH_Hypothesis_i
+{
 public:
   // Constructor
-  BLSURFPlugin_Hypothesis_i(PortableServer::POA_ptr thePOA, int theStudyId, ::SMESH_Gen* theGenImpl);
+  BLSURFPlugin_Hypothesis_i(PortableServer::POA_ptr thePOA,
+                            int                     theStudyId,
+                            ::SMESH_Gen*            theGenImpl,
+                            bool                    theHasGEOM);
   // Destructor
   virtual ~BLSURFPlugin_Hypothesis_i();
 
index f357ebdc421e5ee3d1a1ba1feddc06cc37ce8dca..9cefe5c4cb0a3ea9d40bb31486ca3c44e6255c90 100644 (file)
 #include "BLSURFPlugin_BLSURF_i.hxx"
 #include "BLSURFPlugin_Hypothesis_i.hxx"
 
-template <class T> class BLSURFPlugin_Creator_i:public HypothesisCreator_i<T>
+template <class T, bool NOGEOM>
+class BLSURFPlugin_Creator_i : public GenericHypothesisCreator_i
 {
+  // Create a hypothesis
+  virtual SMESH_Hypothesis_i* Create(PortableServer::POA_ptr thePOA,
+                                     int                     theStudyId,
+                                     ::SMESH_Gen*            theGenImpl)
+  {
+    return new T (thePOA, theStudyId, theGenImpl, !NOGEOM);
+  }
+
   // as we have 'module BLSURFPlugin' in BLSURFPlugin_Algorithm.idl
   virtual std::string GetModuleName() { return "BLSURFPlugin"; }
 };
@@ -54,19 +63,20 @@ extern "C"
   BLSURFPLUGIN_EXPORT
   GenericHypothesisCreator_i* GetHypothesisCreator (const char* aHypName)
   {
-    MESSAGE("GetHypothesisCreator " << aHypName);
-
     GenericHypothesisCreator_i* aCreator = 0;
 
     // Algorithms
     if (strcmp(aHypName, "BLSURF") == 0 ||
         strcmp(aHypName, "MG-CADSurf") == 0 )
-      aCreator = new BLSURFPlugin_Creator_i<BLSURFPlugin_BLSURF_i>;
+      aCreator = new BLSURFPlugin_Creator_i<BLSURFPlugin_BLSURF_i,false>;
+    else if (strcmp(aHypName, "MG-CADSurf_NOGEOM") == 0 )
+      aCreator = new BLSURFPlugin_Creator_i<BLSURFPlugin_BLSURF_i,true>;
     // Hypotheses
     else if (strcmp(aHypName, "BLSURF_Parameters") == 0 ||
              strcmp(aHypName, "MG-CADSurf Parameters") == 0 )
-      aCreator = new BLSURFPlugin_Creator_i<BLSURFPlugin_Hypothesis_i>;
-    else ;
+      aCreator = new BLSURFPlugin_Creator_i<BLSURFPlugin_Hypothesis_i,false>;
+    else if (strcmp(aHypName, "MG-CADSurf Parameters_NOGEOM") == 0 )
+      aCreator = new BLSURFPlugin_Creator_i<BLSURFPlugin_Hypothesis_i,true>;
 
     return aCreator;
   }
index d2152d5eb05d6dc6f5dae71defd911452196735a..67a6bd832804d5e559e46a515dd024b88120680a 100755 (executable)
@@ -43,8 +43,9 @@ extern "C"
   SMESHGUI_GenericHypothesisCreator* GetHypothesisCreator( const QString& aHypType )
   {
     SMESHGUI_GenericHypothesisCreator* aCreator = NULL;
-    if( aHypType=="BLSURF_Parameters" ||
-        aHypType=="MG-CADSurf Parameters")
+    if ( aHypType == "BLSURF_Parameters" ||
+         aHypType == "MG-CADSurf Parameters" ||
+         aHypType == "MG-CADSurf Parameters_NOGEOM")
       aCreator =  new BLSURFPluginGUI_HypothesisCreator( aHypType );
     return aCreator;
   }
index 30d0cac0a31b58a88276aaa7004b9370f02e2a96..94ba8e72e4b64316a58756f2d7c43f6726156ab9 100644 (file)
@@ -26,6 +26,7 @@
 //
 #include "BLSURFPluginGUI_HypothesisCreator.h"
 #include "BLSURFPluginGUI_Dlg.h"
+#include "BLSURFPlugin_Hypothesis.hxx"
 
 #include <GeometryGUI.h>
 
@@ -668,6 +669,9 @@ QFrame* BLSURFPluginGUI_HypothesisCreator::buildFrame()
   if( isCreation() )
     myName = new QLineEdit( myStdGroup );
   myStdWidget = new BLSURFPluginGUI_StdWidget(myStdGroup);
+  if ( !hasGeom() ) {
+    myStdWidget->myPhysicalMesh->removeItem( PhysicalLocalSize );
+  }
   
   int row = 0;
   if( isCreation() ) {
@@ -694,7 +698,7 @@ QFrame* BLSURFPluginGUI_HypothesisCreator::buildFrame()
 
   // Size Maps parameters
 
-  mySmpGroup = new QWidget();
+  mySmpGroup = new QWidget( dlg() );
 
   //Layout
   QGridLayout* anSmpLayout = new QGridLayout(mySmpGroup);
@@ -825,7 +829,7 @@ QFrame* BLSURFPluginGUI_HypothesisCreator::buildFrame()
   smpTab->setCurrentIndex( SMP_STD_TAB ); 
 
   // Enforced vertices parameters
-  myEnfGroup = new QWidget();
+  myEnfGroup = new QWidget( dlg() );
   QGridLayout* anEnfLayout = new QGridLayout(myEnfGroup);
 
   myEnforcedTreeWidget = new QTreeWidget(myEnfGroup);
@@ -918,7 +922,7 @@ QFrame* BLSURFPluginGUI_HypothesisCreator::buildFrame()
 
   // ---
   // Periodicity parameters
-  myPeriodicityGroup = new QWidget();
+  myPeriodicityGroup = new QWidget( dlg() );
   aPeriodicityLayout1 = new QGridLayout(myPeriodicityGroup);
 
   myPeriodicitySplitter = new QSplitter(myPeriodicityGroup);
@@ -1143,14 +1147,24 @@ QFrame* BLSURFPluginGUI_HypothesisCreator::buildFrame()
   hpLayout->addWidget( hpRemBtn,              2, 3, 1, 2 );
   hpLayout->addWidget( myHyPatchFaceSelector, 3, 1, 1, 4 );
 
+
+
   // ---
   myTabWidget->insertTab( STD_TAB, myStdGroup, tr( "SMESH_ARGUMENTS" ) );
   myTabWidget->insertTab( ADV_TAB, myAdvGroup, tr( "BLSURF_ADV_ARGS" ) );
-  myTabWidget->insertTab( SMP_TAB, mySmpGroup, tr( "LOCAL_SIZE" ) );
-  myTabWidget->insertTab( ENF_TAB, myEnfGroup, tr( "BLSURF_ENF_VER" ) );
-  myTabWidget->insertTab( PERIODICITY_TAB, myPeriodicityGroup, tr( "BLSURF_PERIODICITY" ) );
-  myTabWidget->insertTab( HYPERPATCH_TAB, hpGroup, tr( "BLSURF_HYPERPATCH_TAB" ));
-
+  if ( hasGeom() ) {
+    myTabWidget->insertTab( SMP_TAB, mySmpGroup, tr( "LOCAL_SIZE" ) );
+    myTabWidget->insertTab( ENF_TAB, myEnfGroup, tr( "BLSURF_ENF_VER" ) );
+    myTabWidget->insertTab( PERIODICITY_TAB, myPeriodicityGroup, tr( "BLSURF_PERIODICITY" ) );
+    myTabWidget->insertTab( HYPERPATCH_TAB, hpGroup, tr( "BLSURF_HYPERPATCH_TAB" ));
+  }
+  else
+  {
+    mySmpGroup->hide();
+    myEnfGroup->hide();
+    myPeriodicityGroup->hide();
+    hpGroup->hide();
+  }
   myTabWidget->setCurrentIndex( STD_TAB );
 
   connect( myAdvWidget->addBtn, SIGNAL( clicked() ),           this, SLOT( onAddOption() ) );
@@ -3387,6 +3401,11 @@ void BLSURFPluginGUI_HypothesisCreator::onHyPatchRemove()
   }
 }
 
+bool BLSURFPluginGUI_HypothesisCreator::hasGeom() const
+{
+  return hypType() == BLSURFPlugin_Hypothesis::GetHypType(true);
+}
+
 QString BLSURFPluginGUI_HypothesisCreator::caption() const
 {
   return tr( "BLSURF_TITLE" );
index 91c959ab4346a6ec6c2aec3f051864f0aad4b2a6..4c5a952cdc4b7738bb0769ccb37948830e11fcc4 100644 (file)
@@ -257,7 +257,6 @@ private:
   bool                sizeMapValidationFromEntry(QString,bool displayError = true);
   GeomSelectionTools* getGeomSelectionTool() const;
   GEOM::GEOM_Gen_var  getGeomEngine();
-  //void                insertElementType( TopAbs_ShapeEnum );
   bool                insertElement( GEOM::GEOM_Object_var, bool modify = false );
   bool                insertAttractor(GEOM::GEOM_Object_var, GEOM::GEOM_Object_var, bool modify = false);
   int                 findRowFromEntry(QString entry);
@@ -266,6 +265,7 @@ private:
   void                avoidSimultaneousSelection(ListOfWidgets &myCustomWidgets) const;
   void                AddPreCadSequenceToVector(BlsurfHypothesisData& h_data, BLSURFPlugin::TPeriodicityList_var preCadFacePeriodicityVector, bool onFace) const;
   void                addHyPatchToTable(const QString& tags);
+  bool                hasGeom() const;
 
 private:
   
index db5c9a54aca3ee2fe82f816e165db06fd58e7a20..730d2a27c2eca3f59124f2e4d8d37831394d7184 100644 (file)
             <source>ICON_SMESH_TREE_HYPO_MG-CADSurf Parameters</source>
             <translation>mesh_tree_hypo_BLSURF.png</translation>
         </message>
+        <message>
+            <source>ICON_SMESH_TREE_ALGO_MG-CADSurf_NOGEOM</source>
+            <translation>mesh_tree_algo_BLSURF.png</translation>
+        </message>
+        <message>
+            <source>ICON_SMESH_TREE_HYPO_MG-CADSurf Parameters_NOGEOM</source>
+            <translation>mesh_tree_hypo_BLSURF.png</translation>
+        </message>
     </context>
 </TS>