#17845 [EDF] Modifications of Automatic meshing

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

diff --git a/src/SMESH_SWIG/StdMeshersBuilder.py b/src/SMESH_SWIG/StdMeshersBuilder.py
index efa9d0c15bbf29919a080a681f2ee0f2e863da63..0c4241384f6e5686b267ef4555091d4acf37c994 100644 (file)
--- a/src/SMESH_SWIG/StdMeshersBuilder.py
+++ b/src/SMESH_SWIG/StdMeshersBuilder.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2019  CEA/DEN, EDF R&D, OPEN CASCADE

 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public


@@ -107,7 +107,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
     of smeshBuilder.Mesh class    
     """
 
     of smeshBuilder.Mesh class    
     """
 

-    docHelper  = "Creates segment 1D algorithm for edges"
+    docHelper  = "Create segment 1D algorithm for edges"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -131,7 +131,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
         Parameters:
             l : for the length of segments that cut an edge
             UseExisting : if == true - searches for an  existing hypothesis created with
         Parameters:
             l : for the length of segments that cut an edge
             UseExisting : if == true - searches for an  existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

             p : precision, used for calculation of the number of segments.
                 The precision should be a positive, meaningful value within the range [0,1].
                 In general, the number of segments is calculated with the formula:
             p : precision, used for calculation of the number of segments.
                 The precision should be a positive, meaningful value within the range [0,1].
                 In general, the number of segments is calculated with the formula:


@@ -161,7 +161,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
             length : is optional maximal allowed length of segment, if it is omitted
                 the preestimated length is used that depends on geometry size
             UseExisting : if ==true - searches for an existing hypothesis created with
             length : is optional maximal allowed length of segment, if it is omitted
                 the preestimated length is used that depends on geometry size
             UseExisting : if ==true - searches for an existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         
         Returns:
             an instance of StdMeshers_MaxLength hypothesis
         
         Returns:
             an instance of StdMeshers_MaxLength hypothesis


@@ -169,15 +169,16 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
     
 
         hyp = self.Hypothesis("MaxLength", [length], UseExisting=UseExisting)
     
 
         hyp = self.Hypothesis("MaxLength", [length], UseExisting=UseExisting)

-        if length > 0.0:
+        if isinstance(length,str) or length > 0:

             # set given length
             hyp.SetLength(length)
         if not UseExisting:
             # set preestimated length
             # set given length
             hyp.SetLength(length)
         if not UseExisting:
             # set preestimated length

+            import SMESH

             gen = self.mesh.smeshpyD
             initHyp = gen.GetHypothesisParameterValues("MaxLength", "libStdMeshersEngine.so",
                                                        self.mesh.GetMesh(), self.mesh.GetShape(),
             gen = self.mesh.smeshpyD
             initHyp = gen.GetHypothesisParameterValues("MaxLength", "libStdMeshersEngine.so",
                                                        self.mesh.GetMesh(), self.mesh.GetShape(),

-                                                       False) # <- byMesh
+                                                       SMESH.HypInitParams( 1, 1.0, False ))

             preHyp = initHyp._narrow(StdMeshers.StdMeshers_MaxLength)
             if preHyp:
                 hyp.SetPreestimatedLength( preHyp.GetPreestimatedLength() )
             preHyp = initHyp._narrow(StdMeshers.StdMeshers_MaxLength)
             if preHyp:
                 hyp.SetPreestimatedLength( preHyp.GetPreestimatedLength() )


@@ -252,7 +253,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
             maxSize: defines the maximal allowed segment length
             deflection: defines the maximal allowed distance from a segment to an edge
             UseExisting: if ==true - searches for an existing hypothesis created with
             maxSize: defines the maximal allowed segment length
             deflection: defines the maximal allowed distance from a segment to an edge
             UseExisting: if ==true - searches for an existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

 
         Returns:
             an instance of StdMeshers_Adaptive1D hypothesis
 
         Returns:
             an instance of StdMeshers_Adaptive1D hypothesis


@@ -280,7 +281,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
             reversedEdges: is a list of edges to mesh using reversed orientation.
                 A list item can also be a tuple (edge, 1st_vertex_of_edge)
             UseExisting: if ==true - searches for an existing hypothesis created with
             reversedEdges: is a list of edges to mesh using reversed orientation.
                 A list item can also be a tuple (edge, 1st_vertex_of_edge)
             UseExisting: if ==true - searches for an existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

 
         Returns:
                 an instance of StdMeshers_Arithmetic1D hypothesis
 
         Returns:
                 an instance of StdMeshers_Arithmetic1D hypothesis


@@ -314,7 +315,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
                 reversedEdges: is a list of edges to mesh using reversed orientation.
                     A list item can also be a tuple (edge, 1st_vertex_of_edge)
                 UseExisting: if ==true - searches for an existing hypothesis created with
                 reversedEdges: is a list of edges to mesh using reversed orientation.
                     A list item can also be a tuple (edge, 1st_vertex_of_edge)
                 UseExisting: if ==true - searches for an existing hypothesis created with

-                    the same parameters, else (default) - creates a new one
+                    the same parameters, else (default) - Create a new one

 
             Returns:
                 an instance of StdMeshers_Geometric1D hypothesis
 
             Returns:
                 an instance of StdMeshers_Geometric1D hypothesis


@@ -349,7 +350,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
             reversedEdges: is a list of edges to mesh using reversed orientation.
                 A list item can also be a tuple (edge, 1st_vertex_of_edge)
             UseExisting: if ==true - searches for an existing hypothesis created with
             reversedEdges: is a list of edges to mesh using reversed orientation.
                 A list item can also be a tuple (edge, 1st_vertex_of_edge)
             UseExisting: if ==true - searches for an existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

 
         Returns:
                 an instance of StdMeshers_FixedPoints1D hypothesis
 
         Returns:
                 an instance of StdMeshers_FixedPoints1D hypothesis


@@ -381,7 +382,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
             reversedEdges: is a list of edges to mesh using reversed orientation.
                 A list item can also be a tuple (edge, 1st_vertex_of_edge)
             UseExisting: if ==true - searches for an existing hypothesis created with
             reversedEdges: is a list of edges to mesh using reversed orientation.
                 A list item can also be a tuple (edge, 1st_vertex_of_edge)
             UseExisting: if ==true - searches for an existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

 
         Returns:
             an instance of StdMeshers_StartEndLength hypothesis
 
         Returns:
             an instance of StdMeshers_StartEndLength hypothesis


@@ -458,7 +459,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
         hyp.SetFineness( fineness )
         return hyp
 
         hyp.SetFineness( fineness )
         return hyp
 

-    def LengthNearVertex(self, length, vertex=0, UseExisting=0):
+    def LengthNearVertex(self, length, vertex=-1, UseExisting=0):

         """
         Defines "SegmentLengthAroundVertex" hypothesis
 
         """
         Defines "SegmentLengthAroundVertex" hypothesis
 


@@ -468,7 +469,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
                 Any other integer value means that the hypothesis will be set on the
                 whole 1D shape, where Mesh_Segment algorithm is assigned.
             UseExisting: if ==true - searches for an  existing hypothesis created with
                 Any other integer value means that the hypothesis will be set on the
                 whole 1D shape, where Mesh_Segment algorithm is assigned.
             UseExisting: if ==true - searches for an  existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         
         import types
         """
         
         import types


@@ -545,7 +546,7 @@ class StdMeshersBuilder_CompositeSegment(StdMeshersBuilder_Segment):
         of smeshBuilder.Mesh class
     """
 
         of smeshBuilder.Mesh class
     """
 

-    docHelper  = "Creates segment 1D algorithm for edges"
+    docHelper  = "Create segment 1D algorithm for edges"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -579,7 +580,7 @@ class StdMeshersBuilder_Segment_Python(Mesh_Algorithm):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates segment 1D algorithm for edges"
+    docHelper  = "Create segment 1D algorithm for edges"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -605,7 +606,7 @@ class StdMeshersBuilder_Segment_Python(Mesh_Algorithm):
             n: for the number of segments that cut an edge
             func: for the python function that calculates the length of all segments
             UseExisting: if ==true - searches for the existing hypothesis created with
             n: for the number of segments that cut an edge
             func: for the python function that calculates the length of all segments
             UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         
         compFun = lambda hyp, args: False
         """
         
         compFun = lambda hyp, args: False


@@ -637,7 +638,7 @@ class StdMeshersBuilder_Triangle_MEFISTO(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates triangle 2D algorithm for faces"
+    docHelper  = "Create triangle 2D algorithm for faces"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -662,7 +663,7 @@ class StdMeshersBuilder_Triangle_MEFISTO(Mesh_Algorithm):
         Parameters:
             area: for the maximum area of each triangle
             UseExisting: if ==true - searches for an  existing hypothesis created with the
         Parameters:
             area: for the maximum area of each triangle
             UseExisting: if ==true - searches for an  existing hypothesis created with the

-                same parameters, else (default) - creates a new one
+                same parameters, else (default) - Create a new one

         """
         
         from salome.smesh.smeshBuilder import IsEqual
         """
         
         from salome.smesh.smeshBuilder import IsEqual


@@ -703,7 +704,7 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates quadrangle 2D algorithm for faces"
+    docHelper  = "Create quadrangle 2D algorithm for faces"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -726,7 +727,7 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
         pass
 
     def QuadrangleParameters(self, quadType=StdMeshers.QUAD_STANDARD, triangleVertex=0,
         pass
 
     def QuadrangleParameters(self, quadType=StdMeshers.QUAD_STANDARD, triangleVertex=0,

-                             enfVertices=[],enfPoints=[],UseExisting=0):
+                             enfVertices=[],enfPoints=[],corners=[],UseExisting=0):

         """
         Defines "QuadrangleParameters" hypothesis
             quadType defines the algorithm of transition between differently descretized
         """
         Defines "QuadrangleParameters" hypothesis
             quadType defines the algorithm of transition between differently descretized


@@ -762,8 +763,15 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
                 or triples of values ([[x1,y1,z1], [x2,y2,z2], ...]).
                 In the case if the defined QuadrangleParameters() refer to a sole face,
                 all given points must lie on this face, else the mesher fails.
                 or triples of values ([[x1,y1,z1], [x2,y2,z2], ...]).
                 In the case if the defined QuadrangleParameters() refer to a sole face,
                 all given points must lie on this face, else the mesher fails.

+            corners: list of vertices that should be used as quadrangle corners.
+                The parameter can be useful for faces with more than four vertices,
+                since in some cases Quadrangle Mapping algorithm chooses corner vertices
+                differently than it is desired.
+                A hypothesis can be global and define corners for all CAD faces that
+                require it, but be sure that each specified vertex is a corner in all
+                faces the hypothesis will be applied to.

             UseExisting: if *True* - searches for the existing hypothesis created with
             UseExisting: if *True* - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         
 
         """
         
 


@@ -774,6 +782,7 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
         if isinstance( enfVertices, int ) and not enfPoints and not UseExisting:
             # a call of old syntax, before inserting enfVertices and enfPoints before UseExisting
             UseExisting, enfVertices = enfVertices, []
         if isinstance( enfVertices, int ) and not enfPoints and not UseExisting:
             # a call of old syntax, before inserting enfVertices and enfPoints before UseExisting
             UseExisting, enfVertices = enfVertices, []

+

         pStructs, xyz = [], []
         for p in enfPoints:
             if isinstance( p, SMESH.PointStruct ):
         pStructs, xyz = [], []
         for p in enfPoints:
             if isinstance( p, SMESH.PointStruct ):


@@ -791,6 +800,10 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
             self.params = self.Hypothesis("QuadrangleParams", [quadType,vertexID,entries,xyz],
                                           UseExisting = UseExisting, CompareMethod=compFun)
             pass
             self.params = self.Hypothesis("QuadrangleParams", [quadType,vertexID,entries,xyz],
                                           UseExisting = UseExisting, CompareMethod=compFun)
             pass

+
+        if corners and isinstance( corners[0], GEOM._objref_GEOM_Object ):
+            corners = [ self.mesh.geompyD.GetSubShapeID( self.mesh.geom, v ) for v in corners ]
+

         if self.params.GetQuadType() != quadType:
             self.params.SetQuadType(quadType)
         if vertexID > 0:
         if self.params.GetQuadType() != quadType:
             self.params.SetQuadType(quadType)
         if vertexID > 0:


@@ -799,6 +812,7 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
         for v in enfVertices:
             AssureGeomPublished( self.mesh, v )
         self.params.SetEnforcedNodes( enfVertices, pStructs )
         for v in enfVertices:
             AssureGeomPublished( self.mesh, v )
         self.params.SetEnforcedNodes( enfVertices, pStructs )

+        self.params.SetCorners( corners )

         return self.params
 
     def QuadranglePreference(self, reversed=False, UseExisting=0):
         return self.params
 
     def QuadranglePreference(self, reversed=False, UseExisting=0):


@@ -810,7 +824,7 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
         Parameters:
             reversed: if True, transition area is located along the coarser meshed sides.
         UseExisting: if ==true - searches for the existing hypothesis created with
         Parameters:
             reversed: if True, transition area is located along the coarser meshed sides.
         UseExisting: if ==true - searches for the existing hypothesis created with

-            the same parameters, else (default) - creates a new one
+            the same parameters, else (default) - Create a new one

         """
         
         if reversed:
         """
         
         if reversed:


@@ -824,7 +838,7 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
 
         Parameters:
             UseExisting: if ==true - searches for the existing hypothesis created with
 
         Parameters:
             UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
     
         return self.QuadrangleParameters(QUAD_TRIANGLE_PREF,UseExisting=UseExisting)
         """
     
         return self.QuadrangleParameters(QUAD_TRIANGLE_PREF,UseExisting=UseExisting)


@@ -839,7 +853,7 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
 
         Parameters:
             UseExisting: if ==true - searches for the existing hypothesis created with
 
         Parameters:
             UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         
         return self.QuadrangleParameters(QUAD_REDUCED,UseExisting=UseExisting)
         """
         
         return self.QuadrangleParameters(QUAD_REDUCED,UseExisting=UseExisting)


@@ -854,7 +868,7 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
                 Vertex can be either a GEOM_Object or a vertex ID within the
                 shape to mesh
              UseExisting: if ==true - searches for the existing hypothesis created with
                 Vertex can be either a GEOM_Object or a vertex ID within the
                 shape to mesh
              UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         
         return self.QuadrangleParameters(QUAD_STANDARD,vertex,UseExisting)
         """
         
         return self.QuadrangleParameters(QUAD_STANDARD,vertex,UseExisting)


@@ -881,7 +895,7 @@ class StdMeshersBuilder_Hexahedron(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates hexahedron 3D algorithm for volumes"
+    docHelper  = "Create hexahedron 3D algorithm for volumes"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -921,7 +935,7 @@ class StdMeshersBuilder_Projection1D(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates projection 1D algorithm for edges"
+    docHelper  = "Create projection 1D algorithm for edges"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -950,7 +964,7 @@ class StdMeshersBuilder_Projection1D(Mesh_Algorithm):
             srcV: a vertex of *edge* to associate with *tgtV* (optional)
             tgtV: a vertex of *the edge* to which the algorithm is assigned, to associate with *srcV* (optional)
             UseExisting: if ==true - searches for the existing hypothesis created with
             srcV: a vertex of *edge* to associate with *tgtV* (optional)
             tgtV: a vertex of *the edge* to which the algorithm is assigned, to associate with *srcV* (optional)
             UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         from salome.smesh.smeshBuilder import AssureGeomPublished, Mesh
         AssureGeomPublished( self.mesh, edge )
         """
         from salome.smesh.smeshBuilder import AssureGeomPublished, Mesh
         AssureGeomPublished( self.mesh, edge )


@@ -989,7 +1003,7 @@ class StdMeshersBuilder_Projection2D(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates projection 2D algorithm for faces"
+    docHelper  = "Create projection 2D algorithm for faces"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1061,7 +1075,7 @@ class StdMeshersBuilder_Projection1D2D(StdMeshersBuilder_Projection2D):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates projection 1D-2D algorithm for faces"
+    docHelper  = "Create projection 1D-2D algorithm for faces"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1095,7 +1109,7 @@ class StdMeshersBuilder_Projection3D(Mesh_Algorithm):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates projection 3D algorithm for volumes"
+    docHelper  = "Create projection 3D algorithm for volumes"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1128,7 +1142,7 @@ class StdMeshersBuilder_Projection3D(Mesh_Algorithm):
             srcV2: a vertex of *solid* to associate with *tgtV1* (optional)
             tgtV2: a vertex of *the solid* to which the algorithm is assigned,to associate with *srcV2* (optional)
             UseExisting: if ==true - searches for the existing hypothesis created with
             srcV2: a vertex of *solid* to associate with *tgtV1* (optional)
             tgtV2: a vertex of *the solid* to which the algorithm is assigned,to associate with *srcV2* (optional)
             UseExisting: if ==true - searches for the existing hypothesis created with

-                    the same parameters, else (default) - creates a new one
+                    the same parameters, else (default) - Create a new one

 
         Note: 
             association vertices must belong to one edge of a solid
 
         Note: 
             association vertices must belong to one edge of a solid


@@ -1169,7 +1183,7 @@ class StdMeshersBuilder_Prism3D(Mesh_Algorithm):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates prism 3D algorithm for volumes"
+    docHelper  = "Create prism 3D algorithm for volumes"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1245,7 +1259,7 @@ class StdMeshersBuilder_Prism3D(Mesh_Algorithm):
         Parameters:
             n: number of layers
             UseExisting: if ==true - searches for the existing hypothesis created with
         Parameters:
             n: number of layers
             UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         if self.algoType != "RadialPrism_3D":
             print("Prism_3D algorithm doesn't support any hypothesis")
         """
         if self.algoType != "RadialPrism_3D":
             print("Prism_3D algorithm doesn't support any hypothesis")


@@ -1381,7 +1395,7 @@ class StdMeshersBuilder_RadialPrism3D(StdMeshersBuilder_Prism3D):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates Raial Prism 3D algorithm for volumes"
+    docHelper  = "Create Raial Prism 3D algorithm for volumes"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1453,7 +1467,7 @@ class StdMeshersBuilder_RadialAlgorithm(Mesh_Algorithm):
         Parameters:
             n: number of layers
             UseExisting: if ==true - searches for the existing hypothesis created with
         Parameters:
             n: number of layers
             UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         if self.distribHyp:
             self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp )
         """
         if self.distribHyp:
             self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp )


@@ -1563,7 +1577,7 @@ class StdMeshersBuilder_RadialQuadrangle1D2D(StdMeshersBuilder_RadialAlgorithm):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates quadrangle 1D-2D algorithm for faces having a shape of disk or a disk segment"
+    docHelper  = "Create quadrangle 1D-2D algorithm for faces having a shape of disk or a disk segment"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1599,7 +1613,7 @@ class StdMeshersBuilder_QuadMA_1D2D(StdMeshersBuilder_RadialAlgorithm):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates quadrangle 1D-2D algorithm for faces"
+    docHelper  = "Create quadrangle 1D-2D algorithm for faces"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1637,7 +1651,7 @@ class StdMeshersBuilder_PolygonPerFace(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates polygon 2D algorithm for faces"
+    docHelper  = "Create polygon 2D algorithm for faces"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1677,7 +1691,7 @@ class StdMeshersBuilder_UseExistingElements_1D(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates 1D algorithm for edges with reusing of existing mesh elements"
+    docHelper  = "Create 1D algorithm for edges with reusing of existing mesh elements"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1704,7 +1718,7 @@ class StdMeshersBuilder_UseExistingElements_1D(Mesh_Algorithm):
             toCopyMesh: if True, the whole mesh *groups* belong to is imported
             toCopyGroups: if True, all groups of the mesh *groups* belong to are imported
             UseExisting: if ==true - searches for the existing hypothesis created with
             toCopyMesh: if True, the whole mesh *groups* belong to is imported
             toCopyGroups: if True, all groups of the mesh *groups* belong to are imported
             UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         for group in groups:
             from salome.smesh.smeshBuilder import AssureGeomPublished
         """
         for group in groups:
             from salome.smesh.smeshBuilder import AssureGeomPublished


@@ -1739,7 +1753,7 @@ class StdMeshersBuilder_UseExistingElements_1D2D(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates 1D-2D algorithm for faces with reusing of existing mesh elements"
+    docHelper  = "Create 1D-2D algorithm for faces with reusing of existing mesh elements"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1766,7 +1780,7 @@ class StdMeshersBuilder_UseExistingElements_1D2D(Mesh_Algorithm):
             toCopyMesh: if True, the whole mesh *groups* belong to is imported
             toCopyGroups: if True, all groups of the mesh *groups* belong to are imported
             UseExisting: if ==true - searches for the existing hypothesis created with
             toCopyMesh: if True, the whole mesh *groups* belong to is imported
             toCopyGroups: if True, all groups of the mesh *groups* belong to are imported
             UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         import SMESH
         compFun = lambda hyp, args: ( hyp.GetSourceFaces() == args[0] and \
         """
         import SMESH
         compFun = lambda hyp, args: ( hyp.GetSourceFaces() == args[0] and \


@@ -1802,7 +1816,7 @@ class StdMeshersBuilder_Cartesian_3D(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates Body Fitting 3D algorithm for volumes"
+    docHelper  = "Create Body Fitting 3D algorithm for volumes"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1959,7 +1973,7 @@ class StdMeshersBuilder_UseExisting_1D(Mesh_Algorithm):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates 1D algorithm allowing batch meshing of edges"
+    docHelper  = "Create 1D algorithm allowing batch meshing of edges"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1994,7 +2008,7 @@ class StdMeshersBuilder_UseExisting_2D(Mesh_Algorithm):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates 2D algorithm allowing batch meshing of faces"
+    docHelper  = "Create 2D algorithm allowing batch meshing of faces"

     """
     doc string of the method
     """
     """
     doc string of the method
     """