22361: EDF SMESH: Quadrangle (mapping) algorithm: faces with more than 4 edges

[modules/smesh.git] / src / SMESH_SWIG / StdMeshersBuilder.py

diff --git a/src/SMESH_SWIG/StdMeshersBuilder.py b/src/SMESH_SWIG/StdMeshersBuilder.py
index bf79aeb0372cc69fd6cc5891678f3db6867a97d3..2163fed5a3e2c37d02e5e9a64899352bb97a049b 100644 (file)
--- a/src/SMESH_SWIG/StdMeshersBuilder.py
+++ b/src/SMESH_SWIG/StdMeshersBuilder.py
@@ -22,10 +22,6 @@
 # Python API for the standard meshing plug-in module.
 
 from salome.smesh.smesh_algorithm import Mesh_Algorithm
-from salome.smesh.smeshBuilder import AssureGeomPublished, IsEqual, ParseParameters
-from salome.smesh.smeshBuilder import GetName, TreatHypoStatus
-from salome.smesh.smeshBuilder import Mesh
-
 import StdMeshers
 
 #----------------------------
@@ -56,19 +52,19 @@ for e in StdMeshers.QuadType._items: exec('%s = StdMeshers.%s'%(e,e))
 
 ## Defines segment 1D algorithm for edges discretization.
 #
-#  It can be created by calling smesh.Mesh.Segment(geom=0)
+#  It can be created by calling smeshBuilder.Mesh.Segment(geom=0)
 #
 #  @ingroup l3_algos_basic
 class StdMeshersBuilder_Segment(Mesh_Algorithm):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "Segment"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = REGULAR
     ## flag pointing either this algorithm should be used by default in dynamic method
-    #  of smesh.Mesh class
+    #  of smeshBuilder.Mesh class
     #  @internal
     isDefault  = True
     ## doc string of the method
@@ -100,6 +96,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
     #  @return an instance of StdMeshers_LocalLength hypothesis
     #  @ingroup l3_hypos_1dhyps
     def LocalLength(self, l, UseExisting=0, p=1e-07):
+        from salome.smesh.smeshBuilder import IsEqual
         comFun=lambda hyp, args: IsEqual(hyp.GetLength(), args[0]) and IsEqual(hyp.GetPrecision(), args[1])
         hyp = self.Hypothesis("LocalLength", [l,p], UseExisting=UseExisting, CompareMethod=comFun)
         hyp.SetLength(l)
@@ -171,6 +168,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
                     if not args[1] or hyp.GetObjectEntry() == args[2]:
                         return True
             else:
+                from salome.smesh.smeshBuilder import IsEqual
                 if hyp.GetReversedEdges() == args[2]:
                     if not args[2] or hyp.GetObjectEntry() == args[3]:
                         if hyp.GetDistrType() == 1:
@@ -178,6 +176,29 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
                                 return True
         return False
 
+    ## Defines "Adaptive" hypothesis to cut an edge into segments keeping segment size
+    #  within the given range and considering (1) deflection of segments from the edge
+    #  and (2) distance from segments to closest edges and faces to have segment length
+    #  not longer than two times shortest distances to edges and faces.
+    #  @param minSize defines the minimal allowed segment length
+    #  @param maxSize defines the maximal allowed segment length
+    #  @param deflection defines the maximal allowed distance from a segment to an edge
+    #  @param UseExisting if ==true - searches for an existing hypothesis created with
+    #                     the same parameters, else (default) - creates a new one
+    #  @return an instance of StdMeshers_Adaptive1D hypothesis
+    #  @ingroup l3_hypos_1dhyps
+    def Adaptive(self, minSize, maxSize, deflection, UseExisting=False):
+        from salome.smesh.smeshBuilder import IsEqual
+        compFun = lambda hyp, args: ( IsEqual(hyp.GetMinSize(), args[0]) and \
+                                      IsEqual(hyp.GetMaxSize(), args[1]) and \
+                                      IsEqual(hyp.GetDeflection(), args[2]))
+        hyp = self.Hypothesis("Adaptive1D", [minSize, maxSize, deflection],
+                              UseExisting=UseExisting, CompareMethod=compFun)
+        hyp.SetMinSize(minSize)
+        hyp.SetMaxSize(maxSize)
+        hyp.SetDeflection(deflection)
+        return hyp
+
     ## Defines "Arithmetic1D" hypothesis to cut an edge in several segments with increasing arithmetic length
     #  @param start defines the length of the first segment
     #  @param end   defines the length of the last  segment
@@ -192,6 +213,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
             reversedEdges, UseExisting = [], reversedEdges
         reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
         entry = self.MainShapeEntry()
+        from salome.smesh.smeshBuilder import IsEqual
         compFun = lambda hyp, args: ( IsEqual(hyp.GetLength(1), args[0]) and \
                                       IsEqual(hyp.GetLength(0), args[1]) and \
                                       hyp.GetReversedEdges() == args[2]  and \
@@ -248,6 +270,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
             reversedEdges, UseExisting = [], reversedEdges
         reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
         entry = self.MainShapeEntry()
+        from salome.smesh.smeshBuilder import IsEqual
         compFun = lambda hyp, args: ( IsEqual(hyp.GetLength(1), args[0]) and \
                                       IsEqual(hyp.GetLength(0), args[1]) and \
                                       hyp.GetReversedEdges() == args[2]  and \
@@ -266,6 +289,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
     #                     the same parameters, else (default) - create a new one
     #  @ingroup l3_hypos_1dhyps
     def Deflection1D(self, d, UseExisting=0):
+        from salome.smesh.smeshBuilder import IsEqual
         compFun = lambda hyp, args: IsEqual(hyp.GetDeflection(), args[0])
         hyp = self.Hypothesis("Deflection1D", [d], UseExisting=UseExisting, CompareMethod=compFun)
         hyp.SetDeflection(d)
@@ -283,6 +307,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
     #                     same parameters, else (default) - create a new one
     #  @ingroup l3_hypos_1dhyps
     def AutomaticLength(self, fineness=0, UseExisting=0):
+        from salome.smesh.smeshBuilder import IsEqual
         compFun = lambda hyp, args: IsEqual(hyp.GetFineness(), args[0])
         hyp = self.Hypothesis("AutomaticLength",[fineness],UseExisting=UseExisting,
                               CompareMethod=compFun)
@@ -303,7 +328,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
         if type(vertex) is types.IntType:
             if vertex == 0 or vertex == 1:
                 from salome.geom import geomBuilder
-                vertex = self.mesh.geompyD.ExtractShapes(self.geom, geomBuilder.ShapeType["VERTEX"],True)[vertex]
+                vertex = self.mesh.geompyD.ExtractShapes(self.geom, geomBuilder.geomBuilder.ShapeType["VERTEX"],True)[vertex]
                 self.geom = vertex
                 pass
             pass
@@ -313,6 +338,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
         # 0D algorithm
         if self.geom is None:
             raise RuntimeError, "Attemp to create SegmentAroundVertex_0D algoritm on None shape"
+        from salome.smesh.smeshBuilder import AssureGeomPublished, GetName, TreatHypoStatus
         AssureGeomPublished( self.mesh, self.geom )
         name = GetName(self.geom)
 
@@ -323,6 +349,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
         status = self.mesh.mesh.AddHypothesis(self.geom, algo)
         TreatHypoStatus(status, "SegmentAroundVertex_0D", name, True)
         #
+        from salome.smesh.smeshBuilder import IsEqual
         comFun = lambda hyp, args: IsEqual(hyp.GetLength(), args[0])
         hyp = self.Hypothesis("SegmentLengthAroundVertex", [length], UseExisting=UseExisting,
                               CompareMethod=comFun)
@@ -346,19 +373,19 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
 
 ## Segment 1D algorithm for discretization of a set of adjacent edges as one edge.
 #
-#  It is created by calling smesh.Mesh.Segment(smesh.COMPOSITE,geom=0)
+#  It is created by calling smeshBuilder.Mesh.Segment(smeshBuilder.COMPOSITE,geom=0)
 #
 #  @ingroup l3_algos_basic
 class StdMeshersBuilder_CompositeSegment(StdMeshersBuilder_Segment):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "Segment"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = COMPOSITE
     ## flag pointing either this algorithm should be used by default in dynamic method
-    #  of smesh.Mesh class
+    #  of smeshBuilder.Mesh class
     #  @internal
     isDefault  = False
     ## doc string of the method
@@ -377,15 +404,15 @@ class StdMeshersBuilder_CompositeSegment(StdMeshersBuilder_Segment):
 
 ## Defines a segment 1D algorithm for discretization of edges with Python function
 #
-#  It is created by calling smesh.Mesh.Segment(smesh.PYTHON,geom=0)
+#  It is created by calling smeshBuilder.Mesh.Segment(smeshBuilder.PYTHON,geom=0)
 #
 #  @ingroup l3_algos_basic
 class StdMeshersBuilder_Segment_Python(Mesh_Algorithm):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "Segment"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = PYTHON
     ## doc string of the method
@@ -422,19 +449,19 @@ class StdMeshersBuilder_Segment_Python(Mesh_Algorithm):
 
 ## Triangle MEFISTO 2D algorithm
 #
-#  It is created by calling smesh.Mesh.Triangle(smesh.MEFISTO,geom=0)
+#  It is created by calling smeshBuilder.Mesh.Triangle(smeshBuilder.MEFISTO,geom=0)
 #
 #  @ingroup l3_algos_basic
 class StdMeshersBuilder_Triangle_MEFISTO(Mesh_Algorithm):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "Triangle"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = MEFISTO
     ## flag pointing either this algorithm should be used by default in dynamic method
-    #  of smesh.Mesh class
+    #  of smeshBuilder.Mesh class
     #  @internal
     isDefault  = True
     ## doc string of the method
@@ -457,6 +484,7 @@ class StdMeshersBuilder_Triangle_MEFISTO(Mesh_Algorithm):
     #
     #  @ingroup l3_hypos_2dhyps
     def MaxElementArea(self, area, UseExisting=0):
+        from salome.smesh.smeshBuilder import IsEqual
         comparator = lambda hyp, args: IsEqual(hyp.GetMaxElementArea(), args[0])
         hyp = self.Hypothesis("MaxElementArea", [area], UseExisting=UseExisting,
                               CompareMethod=comparator)
@@ -475,19 +503,19 @@ class StdMeshersBuilder_Triangle_MEFISTO(Mesh_Algorithm):
 
 ## Defines a quadrangle 2D algorithm
 # 
-#  It is created by calling smesh.Mesh.Quadrangle(geom=0)
+#  It is created by calling smeshBuilder.Mesh.Quadrangle(geom=0)
 #
 #  @ingroup l3_algos_basic
 class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "Quadrangle"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = QUADRANGLE
     ## flag pointing either this algorithm should be used by default in dynamic method
-    #  of smesh.Mesh class
+    #  of smeshBuilder.Mesh class
     #  @internal
     isDefault  = True
     ## doc string of the method
@@ -594,19 +622,19 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
 
 ## Defines a hexahedron 3D algorithm
 # 
-#  It is created by calling smesh.Mesh.Hexahedron(geom=0)
+#  It is created by calling smeshBuilder.Mesh.Hexahedron(geom=0)
 #
 #  @ingroup l3_algos_basic
 class StdMeshersBuilder_Hexahedron(Mesh_Algorithm):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "Hexahedron"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = Hexa
     ## flag pointing either this algorithm should be used by default in dynamic method
-    #  of smesh.Mesh class
+    #  of smeshBuilder.Mesh class
     #  @internal
     isDefault  = True
     ## doc string of the method
@@ -626,19 +654,19 @@ class StdMeshersBuilder_Hexahedron(Mesh_Algorithm):
 
 ## Defines a projection 1D algorithm
 #  
-#  It is created by calling smesh.Mesh.Projection1D(geom=0)
+#  It is created by calling smeshBuilder.Mesh.Projection1D(geom=0)
 #
 #  @ingroup l3_algos_proj
 class StdMeshersBuilder_Projection1D(Mesh_Algorithm):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "Projection1D"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = "Projection_1D"
     ## flag pointing either this algorithm should be used by default in dynamic method
-    #  of smesh.Mesh class
+    #  of smeshBuilder.Mesh class
     #  @internal
     isDefault  = True
     ## doc string of the method
@@ -665,6 +693,7 @@ class StdMeshersBuilder_Projection1D(Mesh_Algorithm):
     #  @param UseExisting if ==true - searches for the existing hypothesis created with
     #                     the same parameters, else (default) - creates a new one
     def SourceEdge(self, edge, mesh=None, srcV=None, tgtV=None, UseExisting=0):
+        from salome.smesh.smeshBuilder import AssureGeomPublished
         AssureGeomPublished( self.mesh, edge )
         AssureGeomPublished( self.mesh, srcV )
         AssureGeomPublished( self.mesh, tgtV )
@@ -683,19 +712,19 @@ class StdMeshersBuilder_Projection1D(Mesh_Algorithm):
 
 ## Defines a projection 2D algorithm
 #  
-#  It is created by calling smesh.Mesh.Projection2D(geom=0)
+#  It is created by calling smeshBuilder.Mesh.Projection2D(geom=0)
 #
 #  @ingroup l3_algos_proj
 class StdMeshersBuilder_Projection2D(Mesh_Algorithm):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "Projection2D"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = "Projection_2D"
     ## flag pointing either this algorithm should be used by default in dynamic method
-    #  of smesh.Mesh class
+    #  of smeshBuilder.Mesh class
     #  @internal
     isDefault  = True
     ## doc string of the method
@@ -732,6 +761,7 @@ class StdMeshersBuilder_Projection2D(Mesh_Algorithm):
         if isinstance(mesh, Mesh):
             mesh = mesh.GetMesh()
         for geom in [ face, srcV1, tgtV1, srcV2, tgtV2 ]:
+            from salome.smesh.smeshBuilder import AssureGeomPublished
             AssureGeomPublished( self.mesh, geom )
         hyp = self.Hypothesis("ProjectionSource2D", [face,mesh,srcV1,tgtV1,srcV2,tgtV2],
                               UseExisting=0)
@@ -746,15 +776,15 @@ class StdMeshersBuilder_Projection2D(Mesh_Algorithm):
 
 ## Defines a projection 1D-2D algorithm
 #  
-#  It is created by calling smesh.Mesh.Projection1D2D(geom=0)
+#  It is created by calling smeshBuilder.Mesh.Projection1D2D(geom=0)
 #
 #  @ingroup l3_algos_proj
 class StdMeshersBuilder_Projection1D2D(StdMeshersBuilder_Projection2D):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "Projection1D2D"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = "Projection_1D2D"
     ## doc string of the method
@@ -773,15 +803,15 @@ class StdMeshersBuilder_Projection1D2D(StdMeshersBuilder_Projection2D):
 
 ## Defines a projection 3D algorithm
 # 
-#  It is created by calling smesh.Mesh.Projection3D(geom=0)
+#  It is created by calling smeshBuilder.Mesh.Projection3D(geom=0)
 #
 #  @ingroup l3_algos_proj
 class StdMeshersBuilder_Projection3D(Mesh_Algorithm):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "Projection3D"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = "Projection_3D"
     ## doc string of the method
@@ -815,6 +845,7 @@ class StdMeshersBuilder_Projection3D(Mesh_Algorithm):
     def SourceShape3D(self, solid, mesh=0, srcV1=0, tgtV1=0,
                       srcV2=0, tgtV2=0, UseExisting=0):
         for geom in [ solid, srcV1, tgtV1, srcV2, tgtV2 ]:
+            from salome.smesh.smeshBuilder import AssureGeomPublished
             AssureGeomPublished( self.mesh, geom )
         hyp = self.Hypothesis("ProjectionSource3D",
                               [solid,mesh,srcV1,tgtV1,srcV2,tgtV2],
@@ -836,15 +867,15 @@ class StdMeshersBuilder_Projection3D(Mesh_Algorithm):
 ## Defines a Prism 3D algorithm, which is either "Extrusion 3D" or "Radial Prism"
 #  depending on geometry
 # 
-#  It is created by calling smesh.Mesh.Prism(geom=0)
+#  It is created by calling smeshBuilder.Mesh.Prism(geom=0)
 #
 #  @ingroup l3_algos_3dextr
 class StdMeshersBuilder_Prism3D(Mesh_Algorithm):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "Prism"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = "Prism_3D"
     ## doc string of the method
@@ -861,9 +892,9 @@ class StdMeshersBuilder_Prism3D(Mesh_Algorithm):
         shape = geom
         if not shape:
             shape = mesh.geom
-        from geompy import SubShapeAll, ShapeType
-        nbSolids = len( SubShapeAll( shape, ShapeType["SOLID"] ))
-        nbShells = len( SubShapeAll( shape, ShapeType["SHELL"] ))
+        from salome.geom import geomBuilder
+        nbSolids = len( geomBuilder.geom.SubShapeAll( shape, geomBuilder.geomBuilder.ShapeType["SOLID"] ))
+        nbShells = len( geomBuilder.geom.SubShapeAll( shape, geomBuilder.geomBuilder.ShapeType["SHELL"] ))
         if nbSolids == 0 or nbSolids == nbShells:
             self.Create(mesh, geom, "Prism_3D")
             pass
@@ -910,6 +941,7 @@ class StdMeshersBuilder_Prism3D(Mesh_Algorithm):
             print "Prism_3D algorith doesn't support any hyposesis"
             return None
         self.mesh.RemoveHypothesis( self.distribHyp, self.geom )
+        from salome.smesh.smeshBuilder import IsEqual
         compFun = lambda hyp, args: IsEqual(hyp.GetNumberOfLayers(), args[0])
         self.nbLayers = self.Hypothesis("NumberOfLayers", [n], UseExisting=UseExisting,
                                         CompareMethod=compFun)
@@ -988,15 +1020,15 @@ class StdMeshersBuilder_Prism3D(Mesh_Algorithm):
 ## Defines a Prism 3D algorithm, which is either "Extrusion 3D" or "Radial Prism"
 #  depending on geometry
 # 
-#  It is created by calling smesh.Mesh.Prism(geom=0)
+#  It is created by calling smeshBuilder.Mesh.Prism(geom=0)
 #
 #  @ingroup l3_algos_3dextr
 class StdMeshersBuilder_RadialPrism3D(StdMeshersBuilder_Prism3D):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "Prism"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = "RadialPrism_3D"
     ## doc string of the method
@@ -1020,15 +1052,15 @@ class StdMeshersBuilder_RadialPrism3D(StdMeshersBuilder_Prism3D):
 
 ## Defines a Radial Quadrangle 1D-2D algorithm
 # 
-#  It is created by calling smesh.Mesh.Quadrangle(smesh.RADIAL_QUAD,geom=0)
+#  It is created by calling smeshBuilder.Mesh.Quadrangle(smeshBuilder.RADIAL_QUAD,geom=0)
 #
 #  @ingroup l2_algos_radialq
 class StdMeshersBuilder_RadialQuadrangle1D2D(Mesh_Algorithm):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "Quadrangle"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = RADIAL_QUAD
     ## doc string of the method
@@ -1076,6 +1108,7 @@ class StdMeshersBuilder_RadialQuadrangle1D2D(Mesh_Algorithm):
     def NumberOfLayers(self, n, UseExisting=0):
         if self.distribHyp:
             self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp )
+        from salome.smesh.smeshBuilder import IsEqual
         compFun = lambda hyp, args: IsEqual(hyp.GetNumberOfLayers(), args[0])
         self.nbLayers = self.Hypothesis("NumberOfLayers2D", [n], UseExisting=UseExisting,
                                         CompareMethod=compFun)
@@ -1135,19 +1168,19 @@ class StdMeshersBuilder_RadialQuadrangle1D2D(Mesh_Algorithm):
 
 ## Defines a Use Existing Elements 1D algorithm
 #
-#  It is created by calling smesh.Mesh.UseExisting1DElements(geom=0)
+#  It is created by calling smeshBuilder.Mesh.UseExisting1DElements(geom=0)
 #
 #  @ingroup l3_algos_basic
 class StdMeshersBuilder_UseExistingElements_1D(Mesh_Algorithm):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "UseExisting1DElements"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = "Import_1D"
     ## flag pointing either this algorithm should be used by default in dynamic method
-    #  of smesh.Mesh class
+    #  of smeshBuilder.Mesh class
     #  @internal
     isDefault  = True
     ## doc string of the method
@@ -1171,6 +1204,7 @@ class StdMeshersBuilder_UseExistingElements_1D(Mesh_Algorithm):
     #                     the same parameters, else (default) - creates a new one
     def SourceEdges(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
         for group in groups:
+            from salome.smesh.smeshBuilder import AssureGeomPublished
             AssureGeomPublished( self.mesh, group )
         compFun = lambda hyp, args: ( hyp.GetSourceEdges() == args[0] and \
                                       hyp.GetCopySourceMesh() == args[1], args[2] )
@@ -1184,19 +1218,19 @@ class StdMeshersBuilder_UseExistingElements_1D(Mesh_Algorithm):
 
 ## Defines a Use Existing Elements 1D-2D algorithm
 #
-#  It is created by calling smesh.Mesh.UseExisting2DElements(geom=0)
+#  It is created by calling smeshBuilder.Mesh.UseExisting2DElements(geom=0)
 #
 #  @ingroup l3_algos_basic
 class StdMeshersBuilder_UseExistingElements_1D2D(Mesh_Algorithm):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "UseExisting2DElements"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = "Import_1D2D"
     ## flag pointing either this algorithm should be used by default in dynamic method
-    #  of smesh.Mesh class
+    #  of smeshBuilder.Mesh class
     #  @internal
     isDefault  = True
     ## doc string of the method
@@ -1220,6 +1254,7 @@ class StdMeshersBuilder_UseExistingElements_1D2D(Mesh_Algorithm):
     #                     the same parameters, else (default) - creates a new one
     def SourceFaces(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
         for group in groups:
+            from salome.smesh.smeshBuilder import AssureGeomPublished
             AssureGeomPublished( self.mesh, group )
         compFun = lambda hyp, args: ( hyp.GetSourceFaces() == args[0] and \
                                       hyp.GetCopySourceMesh() == args[1], args[2] )
@@ -1233,19 +1268,19 @@ class StdMeshersBuilder_UseExistingElements_1D2D(Mesh_Algorithm):
 
 ## Defines a Body Fitting 3D algorithm
 #
-#  It is created by calling smesh.Mesh.BodyFitted(geom=0)
+#  It is created by calling smeshBuilder.Mesh.BodyFitted(geom=0)
 #
 #  @ingroup l3_algos_basic
 class StdMeshersBuilder_Cartesian_3D(Mesh_Algorithm):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "BodyFitted"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = "Cartesian_3D"
     ## flag pointing either this algorithm should be used by default in dynamic method
-    #  of smesh.Mesh class
+    #  of smeshBuilder.Mesh class
     #  @internal
     isDefault  = True
     ## doc string of the method
@@ -1307,15 +1342,15 @@ class StdMeshersBuilder_Cartesian_3D(Mesh_Algorithm):
 ## Defines a stub 1D algorithm, which enables "manual" creation of nodes and
 #  segments usable by 2D algoritms
 #
-#  It is created by calling smesh.Mesh.UseExistingSegments(geom=0)
+#  It is created by calling smeshBuilder.Mesh.UseExistingSegments(geom=0)
 #
 #  @ingroup l3_algos_basic
 class StdMeshersBuilder_UseExisting_1D(Mesh_Algorithm):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "UseExistingSegments"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = "UseExisting_1D"
     ## doc string of the method
@@ -1335,15 +1370,15 @@ class StdMeshersBuilder_UseExisting_1D(Mesh_Algorithm):
 ## Defines a stub 2D algorithm, which enables "manual" creation of nodes and
 #  faces usable by 3D algoritms
 #
-#  It is created by calling smesh.Mesh.UseExistingFaces(geom=0)
+#  It is created by calling smeshBuilder.Mesh.UseExistingFaces(geom=0)
 #
 #  @ingroup l3_algos_basic
 class StdMeshersBuilder_UseExisting_2D(Mesh_Algorithm):
 
-    ## name of the dynamic method in smesh.Mesh class
+    ## name of the dynamic method in smeshBuilder.Mesh class
     #  @internal
     meshMethod = "UseExistingFaces"
-    ## type of algorithm used with helper function in smesh.Mesh class
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
     #  @internal
     algoType   = "UseExisting_2D"
     ## doc string of the method