Improve SMESH python documentation.

doc/salome/gui/SMESH/input/modules.rst

@@ -0,0 +1,967 @@
+.. _modules_page:
+
+#######
+Modules
+#######
+
+********************************
+Auxiliary methods and structures
+********************************
+
+Functions:
+
+:meth:`def ParseParameters <smeshBuilder.ParseParameters>`
+
+:meth:`def ParseAngles <smeshBuilder.ParseAngles>`
+
+:meth:`def __initPointStruct <smeshBuilder.__initPointStruct>`
+
+:meth:`def __initAxisStruct <smeshBuilder.__initAxisStruct>`
+
+:meth:`def IsEqual <smeshBuilder.IsEqual>`
+
+:meth:`def GetName <smeshBuilder.GetName>`
+
+:meth:`def TreatHypoStatus <smeshBuilder.TreatHypoStatus>`
+
+:meth:`def AssureGeomPublished <smeshBuilder.AssureGeomPublished>`
+
+:meth:`def FirstVertexOnCurve <smeshBuilder.FirstVertexOnCurve>`
+
+:meth:`def DumpPython <smeshBuilder.smeshBuilder.DumpPython>`
+
+:meth:`def SetDumpPythonHistorical <smeshBuilder.smeshBuilder.SetDumpPythonHistorical>`
+
+:meth:`def init_smesh <smeshBuilder.smeshBuilder.init_smesh>`
+
+:meth:`def EnumToLong <smeshBuilder.smeshBuilder.EnumToLong>`
+
+:meth:`def ColorToString <smeshBuilder.smeshBuilder.ColorToString>`
+
+:meth:`def GetPointStruct <smeshBuilder.smeshBuilder.GetPointStruct>`
+
+:meth:`def GetDirStruct <smeshBuilder.smeshBuilder.GetDirStruct>`
+
+:meth:`def MakeDirStruct <smeshBuilder.smeshBuilder.MakeDirStruct>`
+
+:meth:`def GetAxisStruct <smeshBuilder.smeshBuilder.GetAxisStruct>`
+
+:meth:`def SetName <smeshBuilder.smeshBuilder.SetName>`
+
+:meth:`def SetEmbeddedMode <smeshBuilder.smeshBuilder.SetEmbeddedMode>`
+
+:meth:`def IsEmbeddedMode <smeshBuilder.smeshBuilder.IsEmbeddedMode>`
+
+:meth:`def SetCurrentStudy <smeshBuilder.smeshBuilder.SetCurrentStudy>`
+
+:meth:`def GetCurrentStudy <smeshBuilder.smeshBuilder.GetCurrentStudy>`
+
+:meth:`def GetSubShapesId <smeshBuilder.smeshBuilder.GetSubShapesId>`
+
+:meth:`def SetBoundaryBoxSegmentation <smeshBuilder.smeshBuilder.SetBoundaryBoxSegmentation>`
+
+:meth:`def GetSubShapeName <smeshBuilder.Mesh.GetSubShapeName>`
+
+:meth:`def GetLog <smeshBuilder.Mesh.GetLog>`
+
+:meth:`def ClearLog <smeshBuilder.Mesh.ClearLog>`
+
+:meth:`def GetId <smeshBuilder.Mesh.GetId>`
+
+:meth:`def GetStudyId <smeshBuilder.Mesh.GetStudyId>`
+
+:meth:`def GetIDSource <smeshBuilder.Mesh.GetIDSource>`
+
+
+
+***************
+Creating Meshes
+***************
+
+Functions:
+
+:meth:`def Concatenate <smeshBuilder.smeshBuilder.Concatenate>`
+
+:meth:`def CopyMesh <smeshBuilder.smeshBuilder.CopyMesh>`
+
+Importing and exporting meshes
+##############################
+
+Functions:
+
+:meth:`def CreateMeshesFromUNV <smeshBuilder.smeshBuilder.CreateMeshesFromUNV>`
+
+:meth:`def CreateMeshesFromMED <smeshBuilder.smeshBuilder.CreateMeshesFromMED>`
+
+:meth:`def CreateMeshesFromSAUV <smeshBuilder.smeshBuilder.CreateMeshesFromSAUV>`
+
+:meth:`def CreateMeshesFromSTL <smeshBuilder.smeshBuilder.CreateMeshesFromSTL>`
+
+:meth:`def CreateMeshesFromCGNS <smeshBuilder.smeshBuilder.CreateMeshesFromCGNS>`
+
+:meth:`def CreateMeshesFromGMF <smeshBuilder.smeshBuilder.CreateMeshesFromGMF>`
+
+:meth:`def ExportMED <smeshBuilder.Mesh.ExportMED>`
+
+:meth:`def ExportSAUV <smeshBuilder.Mesh.ExportSAUV>`
+
+:meth:`def ExportDAT <smeshBuilder.Mesh.ExportDAT>`
+
+:meth:`def ExportUNV <smeshBuilder.Mesh.ExportUNV>`
+
+:meth:`def ExportSTL <smeshBuilder.Mesh.ExportSTL>`
+
+:meth:`def ExportCGNS <smeshBuilder.Mesh.ExportCGNS>`
+
+:meth:`def ExportGMF <smeshBuilder.Mesh.ExportGMF>`
+
+:meth:`def ExportToMED <smeshBuilder.Mesh.ExportToMED>`
+
+
+Constructing meshes
+###################
+
+Functions:
+
+:meth:`def Mesh <smeshBuilder.smeshBuilder.Mesh>`
+
+:meth:`def __init__ <smeshBuilder.Mesh.__init__>`
+
+:meth:`def SetMesh <smeshBuilder.Mesh.SetMesh>`
+
+:meth:`def GetMesh <smeshBuilder.Mesh.GetMesh>`
+
+:meth:`def SetName <smeshBuilder.Mesh.SetName>`
+
+:meth:`def GetShape <smeshBuilder.Mesh.GetShape>`
+
+:meth:`def SetShape <smeshBuilder.Mesh.SetShape>`
+
+:meth:`def IsReadyToCompute <smeshBuilder.Mesh.IsReadyToCompute>`
+
+:meth:`def GetAlgoState <smeshBuilder.Mesh.GetAlgoState>`
+
+:meth:`def Evaluate <smeshBuilder.Mesh.Evaluate>`
+
+:meth:`def Compute <smeshBuilder.Mesh.Compute>`
+
+:meth:`def GetComputeErrors <smeshBuilder.Mesh.GetComputeErrors>`
+
+:meth:`def GetFailedShapes <smeshBuilder.Mesh.GetFailedShapes>`
+
+:meth:`def GetMeshOrder <smeshBuilder.Mesh.GetMeshOrder>`
+
+:meth:`def SetMeshOrder <smeshBuilder.Mesh.SetMeshOrder>`
+
+:meth:`def Clear <smeshBuilder.Mesh.Clear>`
+
+
+Defining Algorithms
+###################
+
+Basic meshing algorithms
+========================
+
+Data Structures:
+
+:class:`class StdMeshersBuilder_Segment <StdMeshersBuilder.StdMeshersBuilder_Segment>`
+
+:class:`class StdMeshersBuilder_Segment_Python <StdMeshersBuilder.StdMeshersBuilder_Segment_Python>`
+
+:class:`class StdMeshersBuilder_Triangle_MEFISTO <StdMeshersBuilder.StdMeshersBuilder_Triangle_MEFISTO>`
+
+:class:`class StdMeshersBuilder_Quadrangle <StdMeshersBuilder.StdMeshersBuilder_Quadrangle>`
+
+:class:`class StdMeshersBuilder_Hexahedron <StdMeshersBuilder.StdMeshersBuilder_Hexahedron>`
+
+:class:`class StdMeshersBuilder_UseExistingElements_1D <StdMeshersBuilder.StdMeshersBuilder_UseExistingElements_1D>`
+
+:class:`class StdMeshersBuilder_UseExistingElements_1D2D <StdMeshersBuilder.StdMeshersBuilder_UseExistingElements_1D2D>`
+
+:class:`class StdMeshersBuilder_Cartesian_3D <StdMeshersBuilder.StdMeshersBuilder_Cartesian_3D>`
+
+:class:`class StdMeshersBuilder_UseExisting_1D <StdMeshersBuilder.StdMeshersBuilder_UseExisting_1D>`
+
+:class:`class StdMeshersBuilder_UseExisting_2D <StdMeshersBuilder.StdMeshersBuilder_UseExisting_2D>`
+
+Functions:
+
+:meth:`def AutomaticTetrahedralization <smeshBuilder.Mesh.AutomaticTetrahedralization>`
+
+:meth:`def AutomaticHexahedralization <smeshBuilder.Mesh.AutomaticHexahedralization>`
+
+
+
+
+Projection algorithms
+=====================
+
+Data Structures:
+
+:class:`class StdMeshersBuilder_Projection1D <StdMeshersBuilder.StdMeshersBuilder_Projection1D>`
+
+:class:`class StdMeshersBuilder_Projection2D <StdMeshersBuilder.StdMeshersBuilder_Projection2D>`
+
+:class:`class StdMeshersBuilder_Projection1D2D <StdMeshersBuilder.StdMeshersBuilder_Projection1D2D>`
+
+:class:`class StdMeshersBuilder_Projection3D <StdMeshersBuilder.StdMeshersBuilder_Projection3D>`
+
+
+Segments around vertex
+======================
+
+Functions:
+
+:meth:`def LengthNearVertex <StdMeshersBuilder.StdMeshersBuilder_Segment.LengthNearVertex>`
+
+3D extrusion meshing algorithms
+===============================
+
+Data Structures:
+
+:class:`class StdMeshersBuilder_Prism3D <StdMeshersBuilder.StdMeshersBuilder_Prism3D>`
+
+:class:`class StdMeshersBuilder_RadialPrism3D <StdMeshersBuilder.StdMeshersBuilder_RadialPrism3D>`
+
+
+Mesh_Algorithm
+==============
+
+:class:`class Mesh_Algorithm <smesh_algorithm.Mesh_Algorithm>`
+
+
+Defining hypotheses
+###################
+
+1D Meshing Hypotheses
+=====================
+
+Functions:
+
+:meth:`def ReversedEdgeIndices <smesh_algorithm.Mesh_Algorithm.ReversedEdgeIndices>`
+
+:meth:`def LocalLength <StdMeshersBuilder.StdMeshersBuilder_Segment.LocalLength>`
+
+:meth:`def MaxSize <StdMeshersBuilder.StdMeshersBuilder_Segment.MaxSize>`
+
+:meth:`def NumberOfSegments <StdMeshersBuilder.StdMeshersBuilder_Segment.NumberOfSegments>`
+
+:meth:`def Adaptive <StdMeshersBuilder.StdMeshersBuilder_Segment.Adaptive>`
+
+:meth:`def Arithmetic1D <StdMeshersBuilder.StdMeshersBuilder_Segment.Arithmetic1D>`
+
+:meth:`def GeometricProgression <StdMeshersBuilder.StdMeshersBuilder_Segment.GeometricProgression>`
+
+:meth:`def FixedPoints1D <StdMeshersBuilder.StdMeshersBuilder_Segment.FixedPoints1D>`
+
+:meth:`def StartEndLength <StdMeshersBuilder.StdMeshersBuilder_Segment.StartEndLength>`
+
+:meth:`def Deflection1D <StdMeshersBuilder.StdMeshersBuilder_Segment.Deflection1D>`
+
+:meth:`def AutomaticLength <StdMeshersBuilder.StdMeshersBuilder_Segment.AutomaticLength>`
+
+:meth:`def PythonSplit1D <StdMeshersBuilder.StdMeshersBuilder_Segment_Python.PythonSplit1D>`
+
+
+2D Meshing Hypotheses
+=====================
+
+Functions:
+
+:meth:`def MaxElementArea <StdMeshersBuilder.StdMeshersBuilder_Triangle_MEFISTO.MaxElementArea>`
+
+:meth:`def LengthFromEdges <StdMeshersBuilder.StdMeshersBuilder_Triangle_MEFISTO.LengthFromEdges>`
+
+
+Quadrangle Hypotheses
+=====================
+
+Functions:
+
+:meth:`def QuadrangleParameters <StdMeshersBuilder.StdMeshersBuilder_Quadrangle.QuadrangleParameters>`
+
+:meth:`def QuadranglePreference <StdMeshersBuilder.StdMeshersBuilder_Quadrangle.QuadranglePreference>`
+
+:meth:`def TrianglePreference <StdMeshersBuilder.StdMeshersBuilder_Quadrangle.TrianglePreference>`
+
+:meth:`def Reduced <StdMeshersBuilder.StdMeshersBuilder_Quadrangle.Reduced>`
+
+:meth:`def TriangleVertex <StdMeshersBuilder.StdMeshersBuilder_Quadrangle.TriangleVertex>`
+
+
+
+Additional Hypotheses
+=====================
+
+Functions:
+
+:meth:`def ViscousLayers <smesh_algorithm.Mesh_Algorithm.ViscousLayers>`
+
+:meth:`def ViscousLayers2D <smesh_algorithm.Mesh_Algorithm.ViscousLayers2D>`
+
+:meth:`def Propagation <StdMeshersBuilder.StdMeshersBuilder_Segment.Propagation>`
+
+:meth:`def PropagationOfDistribution <StdMeshersBuilder.StdMeshersBuilder_Segment.PropagationOfDistribution>`
+
+:meth:`def QuadraticMesh <StdMeshersBuilder.StdMeshersBuilder_Segment.QuadraticMesh>`
+
+
+Constructing sub-meshes
+#######################
+
+Functions:
+
+:meth:`def GetSubMesh <smeshBuilder.Mesh.GetSubMesh>`
+
+:meth:`def ClearSubMesh <smeshBuilder.Mesh.ClearSubMesh>`
+
+:meth:`def Compute <smeshBuilder.Mesh.Compute>`
+
+
+
+Editing meshes
+##############
+
+Functions:
+
+:meth:`def AddHypothesis <smeshBuilder.Mesh.AddHypothesis>`
+
+:meth:`def IsUsedHypothesis <smeshBuilder.Mesh.IsUsedHypothesis>`
+
+:meth:`def RemoveHypothesis <smeshBuilder.Mesh.RemoveHypothesis>`
+
+:meth:`def GetHypothesisList <smeshBuilder.Mesh.GetHypothesisList>`
+
+:meth:`def RemoveGlobalHypotheses <smeshBuilder.Mesh.RemoveGlobalHypotheses>`
+
+
+****************
+Mesh Information
+****************
+
+Functions:
+
+:meth:`def GetMeshInfo <smeshBuilder.smeshBuilder.GetMeshInfo>`
+
+:meth:`def GetGeometryByMeshElement <smeshBuilder.Mesh.GetGeometryByMeshElement>`
+
+:meth:`def MeshDimension <smeshBuilder.Mesh.MeshDimension>`
+
+:meth:`def GetMeshInfo <smeshBuilder.Mesh.GetMeshInfo>`
+
+:meth:`def NbNodes <smeshBuilder.Mesh.NbNodes>`
+
+:meth:`def NbElements <smeshBuilder.Mesh.NbElements>`
+
+:meth:`def Nb0DElements <smeshBuilder.Mesh.Nb0DElements>`
+
+:meth:`def NbBalls <smeshBuilder.Mesh.NbBalls>`
+
+:meth:`def NbEdges <smeshBuilder.Mesh.NbEdges>`
+
+:meth:`def NbEdgesOfOrder <smeshBuilder.Mesh.NbEdgesOfOrder>`
+
+:meth:`def NbFaces <smeshBuilder.Mesh.NbFaces>`
+
+:meth:`def NbFacesOfOrder <smeshBuilder.Mesh.NbFacesOfOrder>`
+
+:meth:`def NbTriangles <smeshBuilder.Mesh.NbTriangles>`
+
+:meth:`def NbTrianglesOfOrder <smeshBuilder.Mesh.NbTrianglesOfOrder>`
+
+:meth:`def NbBiQuadTriangles <smeshBuilder.Mesh.NbBiQuadTriangles>`
+
+:meth:`def NbQuadrangles <smeshBuilder.Mesh.NbQuadrangles>`
+
+:meth:`def NbQuadranglesOfOrder <smeshBuilder.Mesh.NbQuadranglesOfOrder>`
+
+:meth:`def NbBiQuadQuadrangles <smeshBuilder.Mesh.NbBiQuadQuadrangles>`
+
+:meth:`def NbPolygons <smeshBuilder.Mesh.NbPolygons>`
+
+:meth:`def NbVolumes <smeshBuilder.Mesh.NbVolumes>`
+
+:meth:`def NbVolumesOfOrder <smeshBuilder.Mesh.NbVolumesOfOrder>`
+
+:meth:`def NbTetras <smeshBuilder.Mesh.NbTetras>`
+
+:meth:`def NbTetrasOfOrder <smeshBuilder.Mesh.NbTetrasOfOrder>`
+
+:meth:`def NbHexas <smeshBuilder.Mesh.NbHexas>`
+
+:meth:`def NbHexasOfOrder <smeshBuilder.Mesh.NbHexasOfOrder>`
+
+:meth:`def NbTriQuadraticHexas <smeshBuilder.Mesh.NbTriQuadraticHexas>`
+
+:meth:`def NbPyramids <smeshBuilder.Mesh.NbPyramids>`
+
+:meth:`def NbPyramidsOfOrder <smeshBuilder.Mesh.NbPyramidsOfOrder>`
+
+:meth:`def NbPrisms <smeshBuilder.Mesh.NbPrisms>`
+
+:meth:`def NbPrismsOfOrder <smeshBuilder.Mesh.NbPrismsOfOrder>`
+
+:meth:`def NbHexagonalPrisms <smeshBuilder.Mesh.NbHexagonalPrisms>`
+
+:meth:`def NbPolyhedrons <smeshBuilder.Mesh.NbPolyhedrons>`
+
+:meth:`def NbSubMesh <smeshBuilder.Mesh.NbSubMesh>`
+
+:meth:`def GetElementsId <smeshBuilder.Mesh.GetElementsId>`
+
+:meth:`def GetElementsByType <smeshBuilder.Mesh.GetElementsByType>`
+
+:meth:`def GetNodesId <smeshBuilder.Mesh.GetNodesId>`
+
+:meth:`def GetElementType <smeshBuilder.Mesh.GetElementType>`
+
+:meth:`def GetElementGeomType <smeshBuilder.Mesh.GetElementGeomType>`
+
+:meth:`def GetElementShape <smeshBuilder.Mesh.GetElementShape>`
+
+:meth:`def GetSubMeshElementsId <smeshBuilder.Mesh.GetSubMeshElementsId>`
+
+:meth:`def GetSubMeshNodesId <smeshBuilder.Mesh.GetSubMeshNodesId>`
+
+:meth:`def GetSubMeshElementType <smeshBuilder.Mesh.GetSubMeshElementType>`
+
+:meth:`def Dump <smeshBuilder.Mesh.Dump>`
+
+:meth:`def GetNodeXYZ <smeshBuilder.Mesh.GetNodeXYZ>`
+
+:meth:`def GetNodeInverseElements <smeshBuilder.Mesh.GetNodeInverseElements>`
+
+:meth:`def GetNodePosition <smeshBuilder.Mesh.GetNodePosition>`
+
+:meth:`def GetElementPosition <smeshBuilder.Mesh.GetElementPosition>`
+
+:meth:`def GetShapeID <smeshBuilder.Mesh.GetShapeID>`
+
+:meth:`def GetShapeIDForElem <smeshBuilder.Mesh.GetShapeIDForElem>`
+
+:meth:`def GetElemNbNodes <smeshBuilder.Mesh.GetElemNbNodes>`
+
+:meth:`def GetElemNode <smeshBuilder.Mesh.GetElemNode>`
+
+:meth:`def GetElemNodes <smeshBuilder.Mesh.GetElemNodes>`
+
+:meth:`def IsMediumNode <smeshBuilder.Mesh.IsMediumNode>`
+
+:meth:`def IsMediumNodeOfAnyElem <smeshBuilder.Mesh.IsMediumNodeOfAnyElem>`
+
+:meth:`def ElemNbEdges <smeshBuilder.Mesh.ElemNbEdges>`
+
+:meth:`def ElemNbFaces <smeshBuilder.Mesh.ElemNbFaces>`
+
+:meth:`def GetElemFaceNodes <smeshBuilder.Mesh.GetElemFaceNodes>`
+
+:meth:`def GetFaceNormal <smeshBuilder.Mesh.GetFaceNormal>`
+
+:meth:`def FindElementByNodes <smeshBuilder.Mesh.FindElementByNodes>`
+
+:meth:`def GetElementsByNodes <smeshBuilder.Mesh.GetElementsByNodes>`
+
+:meth:`def IsPoly <smeshBuilder.Mesh.IsPoly>`
+
+:meth:`def IsQuadratic <smeshBuilder.Mesh.IsQuadratic>`
+
+:meth:`def GetBallDiameter <smeshBuilder.Mesh.GetBallDiameter>`
+
+:meth:`def BaryCenter <smeshBuilder.Mesh.BaryCenter>`
+
+:meth:`def FindNodeClosestTo <smeshBuilder.Mesh.FindNodeClosestTo>`
+
+:meth:`def FindElementsByPoint <smeshBuilder.Mesh.FindElementsByPoint>`
+
+:meth:`def GetPointState <smeshBuilder.Mesh.GetPointState>`
+
+
+******************************
+Quality controls and Filtering
+******************************
+
+Functions:
+
+:meth:`def GetEmptyCriterion <smeshBuilder.smeshBuilder.GetEmptyCriterion>`
+
+:meth:`def GetCriterion <smeshBuilder.smeshBuilder.GetCriterion>`
+
+:meth:`def GetFilter <smeshBuilder.smeshBuilder.GetFilter>`
+
+:meth:`def GetFilterFromCriteria <smeshBuilder.smeshBuilder.GetFilterFromCriteria>`
+
+:meth:`def GetFunctor <smeshBuilder.smeshBuilder.GetFunctor>`
+
+:meth:`def GetIdsFromFilter <smeshBuilder.Mesh.GetIdsFromFilter>`
+
+:meth:`def IsManifold <smeshBuilder.Mesh.IsManifold>`
+
+:meth:`def IsCoherentOrientation2D <smeshBuilder.Mesh.IsCoherentOrientation2D>`
+
+
+
+*****************
+Grouping elements
+*****************
+
+Functions:
+
+:meth:`def SetAutoColor <smeshBuilder.Mesh.SetAutoColor>`
+
+:meth:`def GetAutoColor <smeshBuilder.Mesh.GetAutoColor>`
+
+:meth:`def HasDuplicatedGroupNamesMED <smeshBuilder.Mesh.HasDuplicatedGroupNamesMED>`
+
+
+Creating groups
+###############
+
+Functions:
+
+:meth:`def CreateEmptyGroup <smeshBuilder.Mesh.CreateEmptyGroup>`
+
+:meth:`def Group <smeshBuilder.Mesh.Group>`
+
+:meth:`def GroupOnGeom <smeshBuilder.Mesh.GroupOnGeom>`
+
+:meth:`def GroupOnFilter <smeshBuilder.Mesh.GroupOnFilter>`
+
+:meth:`def MakeGroupByIds <smeshBuilder.Mesh.MakeGroupByIds>`
+
+:meth:`def MakeGroup <smeshBuilder.Mesh.MakeGroup>`
+
+:meth:`def MakeGroupByCriterion <smeshBuilder.Mesh.MakeGroupByCriterion>`
+
+:meth:`def MakeGroupByCriteria <smeshBuilder.Mesh.MakeGroupByCriteria>`
+
+:meth:`def MakeGroupByFilter <smeshBuilder.Mesh.MakeGroupByFilter>`
+
+:meth:`def GetGroups <smeshBuilder.Mesh.GetGroups>`
+
+:meth:`def NbGroups <smeshBuilder.Mesh.NbGroups>`
+
+:meth:`def GetGroupNames <smeshBuilder.Mesh.GetGroupNames>`
+
+:meth:`def GetGroupByName <smeshBuilder.Mesh.GetGroupByName>`
+
+
+Using operations on groups
+##########################
+
+Functions:
+
+:meth:`def UnionGroups <smeshBuilder.Mesh.UnionGroups>`
+
+:meth:`def UnionListOfGroups <smeshBuilder.Mesh.UnionListOfGroups>`
+
+:meth:`def IntersectGroups <smeshBuilder.Mesh.IntersectGroups>`
+
+:meth:`def IntersectListOfGroups <smeshBuilder.Mesh.IntersectListOfGroups>`
+
+:meth:`def CutGroups <smeshBuilder.Mesh.CutGroups>`
+
+:meth:`def CutListOfGroups <smeshBuilder.Mesh.CutListOfGroups>`
+
+:meth:`def CreateDimGroup <smeshBuilder.Mesh.CreateDimGroup>`
+
+:meth:`def ConvertToStandalone <smeshBuilder.Mesh.ConvertToStandalone>`
+
+
+Deleting groups
+###############
+
+Functions:
+
+:meth:`def RemoveGroup <smeshBuilder.Mesh.RemoveGroup>`
+
+:meth:`def RemoveGroupWithContents <smeshBuilder.Mesh.RemoveGroupWithContents>`
+
+
+****************
+Modifying meshes
+****************
+
+Functions:
+
+:meth:`def GetPattern <smeshBuilder.smeshBuilder.GetPattern>`
+
+:meth:`def GetMeshEditor <smeshBuilder.Mesh.GetMeshEditor>`
+
+
+Adding nodes and elements
+#########################
+
+Functions:
+
+:meth:`def AddNode <smeshBuilder.Mesh.AddNode>`
+
+:meth:`def Add0DElement <smeshBuilder.Mesh.Add0DElement>`
+
+:meth:`def Add0DElementsToAllNodes <smeshBuilder.Mesh.Add0DElementsToAllNodes>`
+
+:meth:`def AddBall <smeshBuilder.Mesh.AddBall>`
+
+:meth:`def AddEdge <smeshBuilder.Mesh.AddEdge>`
+
+:meth:`def AddFace <smeshBuilder.Mesh.AddFace>`
+
+:meth:`def AddPolygonalFace <smeshBuilder.Mesh.AddPolygonalFace>`
+
+:meth:`def AddQuadPolygonalFace <smeshBuilder.Mesh.AddQuadPolygonalFace>`
+
+:meth:`def AddVolume <smeshBuilder.Mesh.AddVolume>`
+
+:meth:`def AddPolyhedralVolume <smeshBuilder.Mesh.AddPolyhedralVolume>`
+
+:meth:`def AddPolyhedralVolumeByFaces <smeshBuilder.Mesh.AddPolyhedralVolumeByFaces>`
+
+:meth:`def SetNodeOnVertex <smeshBuilder.Mesh.SetNodeOnVertex>`
+
+:meth:`def SetNodeOnEdge <smeshBuilder.Mesh.SetNodeOnEdge>`
+
+:meth:`def SetNodeOnFace <smeshBuilder.Mesh.SetNodeOnFace>`
+
+:meth:`def SetNodeInVolume <smeshBuilder.Mesh.SetNodeInVolume>`
+
+:meth:`def SetMeshElementOnShape <smeshBuilder.Mesh.SetMeshElementOnShape>`
+
+:meth:`def Make2DMeshFrom3D <smeshBuilder.Mesh.Make2DMeshFrom3D>`
+
+:meth:`def MakeBoundaryMesh <smeshBuilder.Mesh.MakeBoundaryMesh>`
+
+:meth:`def MakeBoundaryElements <smeshBuilder.Mesh.MakeBoundaryElements>`
+
+:meth:`def GetLastCreatedNodes <smeshBuilder.Mesh.GetLastCreatedNodes>`
+
+:meth:`def GetLastCreatedElems <smeshBuilder.Mesh.GetLastCreatedElems>`
+
+:meth:`def ClearLastCreated <smeshBuilder.Mesh.ClearLastCreated>`
+
+
+Removing nodes and elements
+###########################
+
+Functions:
+
+:meth:`def RemoveElements <smeshBuilder.Mesh.RemoveElements>`
+
+:meth:`def RemoveNodes <smeshBuilder.Mesh.RemoveNodes>`
+
+:meth:`def RemoveOrphanNodes <smeshBuilder.Mesh.RemoveOrphanNodes>`
+
+
+Modifying nodes and elements
+############################
+
+functions:
+
+:meth:`def MoveNode <smeshBuilder.Mesh.MoveNode>`
+
+:meth:`def MoveClosestNodeToPoint <smeshBuilder.Mesh.MoveClosestNodeToPoint>`
+
+:meth:`def MeshToPassThroughAPoint <smeshBuilder.Mesh.MeshToPassThroughAPoint>`
+
+:meth:`def ChangeElemNodes <smeshBuilder.Mesh.ChangeElemNodes>`
+
+
+Renumbering nodes and elements
+##############################
+
+Functions:
+
+:meth:`def RenumberNodes <smeshBuilder.Mesh.RenumberNodes>`
+
+:meth:`def RenumberElements <smeshBuilder.Mesh.RenumberElements>`
+
+
+Transforming meshes (Translation, Rotation, Symmetry, Sewing, Merging)
+######################################################################
+
+Functions:
+
+:meth:`def Mirror <smeshBuilder.Mesh.Mirror>`
+
+:meth:`def MirrorMakeMesh <smeshBuilder.Mesh.MirrorMakeMesh>`
+
+:meth:`def MirrorObject <smeshBuilder.Mesh.MirrorObject>`
+
+:meth:`def MirrorObjectMakeMesh <smeshBuilder.Mesh.MirrorObjectMakeMesh>`
+
+:meth:`def Translate <smeshBuilder.Mesh.Translate>`
+
+:meth:`def TranslateMakeMesh <smeshBuilder.Mesh.TranslateMakeMesh>`
+
+:meth:`def TranslateObject <smeshBuilder.Mesh.TranslateObject>`
+
+:meth:`def TranslateObjectMakeMesh <smeshBuilder.Mesh.TranslateObjectMakeMesh>`
+
+:meth:`def Rotate <smeshBuilder.Mesh.Rotate>`
+
+:meth:`def RotateMakeMesh <smeshBuilder.Mesh.RotateMakeMesh>`
+
+:meth:`def RotateObject <smeshBuilder.Mesh.RotateObject>`
+
+:meth:`def RotateObjectMakeMesh <smeshBuilder.Mesh.RotateObjectMakeMesh>`
+
+:meth:`def FindCoincidentNodes <smeshBuilder.Mesh.FindCoincidentNodes>`
+
+:meth:`def FindCoincidentNodesOnPart <smeshBuilder.Mesh.FindCoincidentNodesOnPart>`
+
+:meth:`def MergeNodes <smeshBuilder.Mesh.MergeNodes>`
+
+:meth:`def FindEqualElements <smeshBuilder.Mesh.FindEqualElements>`
+
+:meth:`def MergeElements <smeshBuilder.Mesh.MergeElements>`
+
+:meth:`def MergeEqualElements <smeshBuilder.Mesh.MergeEqualElements>`
+
+:meth:`def FindFreeBorders <smeshBuilder.Mesh.FindFreeBorders>`
+
+:meth:`def FillHole <smeshBuilder.Mesh.FillHole>`
+
+:meth:`def FindCoincidentFreeBorders <smeshBuilder.Mesh.FindCoincidentFreeBorders>`
+
+:meth:`def SewCoincidentFreeBorders <smeshBuilder.Mesh.SewCoincidentFreeBorders>`
+
+:meth:`def SewFreeBorders <smeshBuilder.Mesh.SewFreeBorders>`
+
+:meth:`def SewConformFreeBorders <smeshBuilder.Mesh.SewConformFreeBorders>`
+
+:meth:`def SewBorderToSide <smeshBuilder.Mesh.SewBorderToSide>`
+
+:meth:`def SewSideElements <smeshBuilder.Mesh.SewSideElements>`
+
+
+
+Uniting triangles
+#################
+
+Functions:
+
+:meth:`def DeleteDiag <smeshBuilder.Mesh.DeleteDiag>`
+
+:meth:`def TriToQuad <smeshBuilder.Mesh.TriToQuad>`
+
+:meth:`def TriToQuadObject <smeshBuilder.Mesh.TriToQuadObject>`
+
+
+
+Cutting elements
+################
+
+Functions:
+
+:meth:`def InverseDiag <smeshBuilder.Mesh.InverseDiag>`
+
+:meth:`def QuadToTri <smeshBuilder.Mesh.QuadToTri>`
+
+:meth:`def QuadToTriObject <smeshBuilder.Mesh.QuadToTriObject>`
+
+:meth:`def QuadTo4Tri <smeshBuilder.Mesh.QuadTo4Tri>`
+
+:meth:`def SplitQuad <smeshBuilder.Mesh.SplitQuad>`
+
+:meth:`def SplitQuadObject <smeshBuilder.Mesh.SplitQuadObject>`
+
+:meth:`def BestSplit <smeshBuilder.Mesh.BestSplit>`
+
+:meth:`def SplitVolumesIntoTetra <smeshBuilder.Mesh.SplitVolumesIntoTetra>`
+
+:meth:`def SplitBiQuadraticIntoLinear <smeshBuilder.Mesh.SplitBiQuadraticIntoLinear>`
+
+:meth:`def SplitHexahedraIntoPrisms <smeshBuilder.Mesh.SplitHexahedraIntoPrisms>`
+
+:meth:`def SplitQuadsNearTriangularFacets <smeshBuilder.Mesh.SplitQuadsNearTriangularFacets>`
+
+:meth:`def SplitHexaToTetras <smeshBuilder.Mesh.SplitHexaToTetras>`
+
+:meth:`def SplitHexaToPrisms <smeshBuilder.Mesh.SplitHexaToPrisms>`
+
+
+
+Changing orientation of elements
+################################
+
+Functions:
+
+:meth:`def Reorient <smeshBuilder.Mesh.Reorient>`
+
+:meth:`def ReorientObject <smeshBuilder.Mesh.ReorientObject>`
+
+:meth:`def Reorient2D <smeshBuilder.Mesh.Reorient2D>`
+
+:meth:`def Reorient2DBy3D <smeshBuilder.Mesh.Reorient2DBy3D>`
+
+
+
+Smoothing
+#########
+
+Functions:
+
+:meth:`def Smooth <smeshBuilder.Mesh.Smooth>`
+
+:meth:`def SmoothObject <smeshBuilder.Mesh.SmoothObject>`
+
+:meth:`def SmoothParametric <smeshBuilder.Mesh.SmoothParametric>`
+
+:meth:`def SmoothParametricObject <smeshBuilder.Mesh.SmoothParametricObject>`
+
+
+
+Extrusion and Revolution
+########################
+
+Functions:
+
+:meth:`def RotationSweepObjects <smeshBuilder.Mesh.RotationSweepObjects>`
+
+:meth:`def RotationSweep <smeshBuilder.Mesh.RotationSweep>`
+
+:meth:`def RotationSweepObject <smeshBuilder.Mesh.RotationSweepObject>`
+
+:meth:`def RotationSweepObject1D <smeshBuilder.Mesh.RotationSweepObject1D>`
+
+:meth:`def RotationSweepObject2D <smeshBuilder.Mesh.RotationSweepObject2D>`
+
+:meth:`def ExtrusionSweepObjects <smeshBuilder.Mesh.ExtrusionSweepObjects>`
+
+:meth:`def ExtrusionSweep <smeshBuilder.Mesh.ExtrusionSweep>`
+
+:meth:`def ExtrusionByNormal <smeshBuilder.Mesh.ExtrusionByNormal>`
+
+:meth:`def ExtrusionSweepObject <smeshBuilder.Mesh.ExtrusionSweepObject>`
+
+:meth:`def ExtrusionSweepObject1D <smeshBuilder.Mesh.ExtrusionSweepObject1D>`
+
+:meth:`def ExtrusionSweepObject2D <smeshBuilder.Mesh.ExtrusionSweepObject2D>`
+
+:meth:`def AdvancedExtrusion <smeshBuilder.Mesh.AdvancedExtrusion>`
+
+:meth:`def ExtrusionAlongPathObjects <smeshBuilder.Mesh.ExtrusionAlongPathObjects>`
+
+:meth:`def ExtrusionAlongPathX <smeshBuilder.Mesh.ExtrusionAlongPathX>`
+
+:meth:`def ExtrusionAlongPath <smeshBuilder.Mesh.ExtrusionAlongPath>`
+
+:meth:`def ExtrusionAlongPathObject <smeshBuilder.Mesh.ExtrusionAlongPathObject>`
+
+:meth:`def ExtrusionAlongPathObject1D <smeshBuilder.Mesh.ExtrusionAlongPathObject1D>`
+
+:meth:`def ExtrusionAlongPathObject2D <smeshBuilder.Mesh.ExtrusionAlongPathObject2D>`
+
+
+
+Convert to/from Quadratic Mesh
+##############################
+
+Functions:
+
+:meth:`def ConvertToQuadratic <smeshBuilder.Mesh.ConvertToQuadratic>`
+
+:meth:`def ConvertFromQuadratic <smeshBuilder.Mesh.ConvertFromQuadratic>`
+
+
+
+Duplication of nodes and elements (to emulate cracks)
+#####################################################
+
+Functions:
+
+:meth:`def DoubleElements <smeshBuilder.Mesh.DoubleElements>`
+
+:meth:`def DoubleNodes <smeshBuilder.Mesh.DoubleNodes>`
+
+:meth:`def DoubleNode <smeshBuilder.Mesh.DoubleNode>`
+
+:meth:`def DoubleNodeGroup <smeshBuilder.Mesh.DoubleNodeGroup>`
+
+:meth:`def DoubleNodeGroups <smeshBuilder.Mesh.DoubleNodeGroups>`
+
+:meth:`def DoubleNodeElem <smeshBuilder.Mesh.DoubleNodeElem>`
+
+:meth:`def DoubleNodeElemInRegion <smeshBuilder.Mesh.DoubleNodeElemInRegion>`
+
+:meth:`def DoubleNodeElemGroup <smeshBuilder.Mesh.DoubleNodeElemGroup>`
+
+:meth:`def DoubleNodeElemGroupInRegion <smeshBuilder.Mesh.DoubleNodeElemGroupInRegion>`
+
+:meth:`def DoubleNodeElemGroups <smeshBuilder.Mesh.DoubleNodeElemGroups>`
+
+:meth:`def DoubleNodeElemGroupsInRegion <smeshBuilder.Mesh.DoubleNodeElemGroupsInRegion>`
+
+:meth:`def AffectedElemGroupsInRegion <smeshBuilder.Mesh.AffectedElemGroupsInRegion>`
+
+:meth:`def DoubleNodesOnGroupBoundaries <smeshBuilder.Mesh.DoubleNodesOnGroupBoundaries>`
+
+:meth:`def CreateFlatElementsOnFacesGroups <smeshBuilder.Mesh.CreateFlatElementsOnFacesGroups>`
+
+
+
+************
+Measurements
+************
+
+Functions:
+
+
+:meth:`def MinDistance <smeshBuilder.smeshBuilder.MinDistance>`
+
+:meth:`def GetMinDistance <smeshBuilder.smeshBuilder.GetMinDistance>`
+
+:meth:`def BoundingBox <smeshBuilder.smeshBuilder.BoundingBox>`
+
+:meth:`def GetBoundingBox <smeshBuilder.smeshBuilder.GetBoundingBox>`
+
+:meth:`def GetLength <smeshBuilder.smeshBuilder.GetLength>`
+
+:meth:`def GetArea <smeshBuilder.smeshBuilder.GetArea>`
+
+:meth:`def GetVolume <smeshBuilder.smeshBuilder.GetVolume>`
+
+:meth:`def GetFreeBorders <smeshBuilder.Mesh.GetFreeBorders>`
+
+:meth:`def MinDistance <smeshBuilder.Mesh.MinDistance>`
+
+:meth:`def GetMinDistance <smeshBuilder.Mesh.GetMinDistance>`
+
+:meth:`def BoundingBox <smeshBuilder.Mesh.BoundingBox>`
+
+:meth:`def GetBoundingBox <smeshBuilder.Mesh.GetBoundingBox>`
+
+:meth:`def GetFunctor <smeshBuilder.Mesh.GetFunctor>`
+
+:meth:`def FunctorValue <smeshBuilder.Mesh.FunctorValue>`
+
+:meth:`def GetLength <smeshBuilder.Mesh.GetLength>`
+
+:meth:`def GetArea <smeshBuilder.Mesh.GetArea>`
+
+:meth:`def GetVolume <smeshBuilder.Mesh.GetVolume>`
+
+:meth:`def GetMaxElementLength <smeshBuilder.Mesh.GetMaxElementLength>`
+
+:meth:`def GetAspectRatio <smeshBuilder.Mesh.GetAspectRatio>`
+
+:meth:`def GetWarping <smeshBuilder.Mesh.GetWarping>`
+
+:meth:`def GetMinimumAngle <smeshBuilder.Mesh.GetMinimumAngle>`
+
+:meth:`def GetTaper <smeshBuilder.Mesh.GetTaper>`
+
+:meth:`def GetSkew <smeshBuilder.Mesh.GetSkew>`
+
+:meth:`def GetMinMax <smeshBuilder.Mesh.GetMinMax>`
+
+
+*******************************
+Accessing SMESH object in study
+*******************************
+
+Data Structures:
+
+:class:`SMeshStudyTools <smeshstudytools.SMeshStudyTools>`
+
+
+
+

doc/salome/gui/SMESH/input/smeshpy_interface.rst

@@ -9,9 +9,9 @@ be used for easy mesh creation and edition.
 
 Documentation of SALOME %Mesh module Python API is available in two forms:
 
-- `Structured documentation <smeshpy_doc/modules.html>`_, where all methods and classes are grouped by their functionality.
+- :ref:`Structured documentation <modules_page>`, where all methods and classes are grouped by their functionality.
 
-- `Linear documentation <smeshpy_doc/namespaces.html>`_ grouped only by classes, declared in the :ref:`smeshBuilder` and :ref:`StdMeshersBuilder` Python packages.
+- :ref:`Linear documentation <genindex>` grouped only by classes, declared in the :mod:`smeshBuilder` and :mod:`StdMeshersBuilder` Python packages.
 
 With SALOME 7.2, the Python interface for Mesh has been slightly modified to offer new functionality.
 
@@ -19,45 +19,45 @@ You may have to modify your scripts generated with SALOME 6 or older versions.
 
 Please see :ref:`smesh_migration_page`.
 
-Class :ref:`smeshBuilder.smeshBuilder` provides an interface to create and handle
+Class :class:`smeshBuilder.smeshBuilder` provides an interface to create and handle
 meshes. It can be used to create an empty mesh or to import mesh from the data file.
 
 As soon as a mesh is created, it is possible to manage it via its own
-methods, described in class :ref:`smeshBuilder.Mesh` documentation.
+methods, described in class :class:`smeshBuilder.Mesh` documentation.
 
-Class :ref:`smeshstudytools.SMeshStudyTools` provides several methods to manipulate mesh objects in Salome study. 
+Class :class:`smeshstudytools.SMeshStudyTools` provides several methods to manipulate mesh objects in Salome study. 
 
 A usual workflow to generate a mesh on geometry is following:
 
-#. Create an instance of :ref:`smeshBuilder.smeshBuilder`:
+#. Create an instance of :class:`smeshBuilder.smeshBuilder`:
 	.. code-block:: python
 		:linenos:
 
 		from salome.smesh import smeshBuilder
 		smesh = smeshBuilder.New( salome.myStudy )
 
-#. Create a :ref:`smeshBuilder.Mesh` object:
+#. Create a :class:`smeshBuilder.Mesh` object:
 
 	.. code-block:: python
 		:linenos:
 
-		mesh = :ref:`smeshBuilder.smeshBuilder.Mesh`smesh.Mesh( geometry )
+		mesh = smesh.Mesh( geometry )
 
 #. Create and assign :ref:`basic_meshing_algos_page` by calling corresponding methods of the mesh. If a sub-shape is provided as an argument, a :ref:`constructing_submeshes_page` is implicitly created on this sub-shape:
 	.. code-block:: python
 		:linenos:
 
-		regular1D = :ref:`smeshBuilder.Mesh.Segment` 
+		regular1D = smeshBuilder.Mesh.Segment()
-		mefisto   = :ref:`smeshBuilder.Mesh.Triangle` ( smeshBuilder.MEFISTO )
+		mefisto   = smeshBuilder.Mesh.Triangle( smeshBuilder.MEFISTO )
 		# use other triangle algorithm on a face -- a sub-mesh appears in the mesh
-		netgen    = :ref:`smeshBuilder.Mesh.Triangle` ( smeshBuilder.NETGEN_1D2D, face )
+		netgen    = smeshBuilder.Mesh.Triangle( smeshBuilder.NETGEN_1D2D, face )
 
 #. Create and assign :ref:`about_hypo_page` by calling corresponding methods of algorithms:
 	.. code-block:: python
 		:linenos:
 
-		segLen10 = :ref:`StdMeshersBuilder.StdMeshersBuilder_Segment.LocalLength`( 10. )
+		segLen10 = StdMeshersBuilder.StdMeshersBuilder_Segment.LocalLength( 10. )
-		maxArea  = :ref:`StdMeshersBuilder.StdMeshersBuilder_Segment.LocalLength`( 100. )
+		maxArea  = StdMeshersBuilder.StdMeshersBuilder_Segment.LocalLength( 100. )
 		netgen.SetMaxSize( 20. )
 		netgen.SetFineness( smeshBuilder.VeryCoarse )
   
@@ -65,7 +65,7 @@ A usual workflow to generate a mesh on geometry is following:
 	.. code-block:: python
 		:linenos:
 
-		:ref:`Mesh.Compute`()
+		Mesh.Compute()
 
 An easiest way to start with Python scripting is to do something in
 GUI and then to get a corresponding Python script via 

src/SMESH_SWIG/smesh_algorithm.py

@@ -25,51 +25,63 @@ import salome
 from salome.geom import geomBuilder
 import SMESH, StdMeshers
 
-## The base class to define meshing algorithms
-#
-#  @note This class should not be used directly, it is supposed to be sub-classed
-#  for implementing Python API for specific meshing algorithms
-#
-#  For each meshing algorithm, a python class inheriting from class %Mesh_Algorithm
-#  should be defined. This descendant class should have two attributes defining the way
-#  it is created by class Mesh (see e.g. class @ref StdMeshersBuilder.StdMeshersBuilder_Segment "StdMeshersBuilder_Segment"
-#  in StdMeshersBuilder package):
-#  - @c meshMethod attribute defines name of method of class smesh.Mesh by calling which the
-#    python class of algorithm is created; this method is dynamically added to the smesh.Mesh class
-#    in runtime. For example, if in @c class MyPlugin_Algorithm this attribute is defined as
-#    @code
-#    meshMethod = "MyAlgorithm"
-#    @endcode
-#    then an instance of @c MyPlugin_Algorithm can be created by the direct invocation of the function
-#    of smesh.Mesh class:
-#    @code
-#    my_algo = mesh.MyAlgorithm()
-#    @endcode
-#  - @c algoType defines type of algorithm and is used mostly to discriminate
-#    algorithms that are created by the same method of class smesh.Mesh. For example, if this attribute
-#    is specified in @c MyPlugin_Algorithm class as
-#    @code
-#    algoType = "MyPLUGIN"
-#    @endcode
-#    then it's creation code can be:
-#    @code
-#    my_algo = mesh.MyAlgorithm(algo="MyPLUGIN")
-#    @endcode
-#  @ingroup l2_algorithms
 class Mesh_Algorithm:
+    """
+    The base class to define meshing algorithms
+
+    Note:
+    	This class should not be used directly, it is supposed to be sub-classed
+    for implementing Python API for specific meshing algorithms
+
+    For each meshing algorithm, a python class inheriting from class %Mesh_Algorithm
+    should be defined. This descendant class should have two attributes defining the way
+    it is created by class Mesh (see e.g. class :ref:`StdMeshersBuilder.StdMeshersBuilder_Segment`
+    in StdMeshersBuilder package):
+
+    	- :code:`meshMethod` attribute defines name of method of class smesh.Mesh by calling which the
+    		python class of algorithm is created; this method is dynamically added to the smesh.Mesh class
+    		in runtime. For example, if in :code:`class MyPlugin_Algorithm` this attribute is defined as
+    		::
+
+    			meshMethod = "MyAlgorithm"
+
+    		then an instance of :code:`MyPlugin_Algorithm` can be created by the direct invocation of the function
+    		of smesh.Mesh class:
+    		::
+    
+    			my_algo = mesh.MyAlgorithm()
+    
+    	- :code:`algoType` defines type of algorithm and is used mostly to discriminate
+    		algorithms that are created by the same method of class smesh.Mesh. For example, if this attribute
+    		is specified in :code:`MyPlugin_Algorithm` class as
+    		::
+    
+    			algoType = "MyPLUGIN"
+
+    		then it's creation code can be:
+    		::
+
+    			my_algo = mesh.MyAlgorithm(algo="MyPLUGIN")
+    """
+    
     
-    ## Private constructor
     def __init__(self):
+	"""
+	Private constuctor
+	"""
         self.mesh = None
         self.geom = None
         self.subm = None
         self.algo = None
         pass
 
-    ## Finds a hypothesis in the study by its type name and parameters.
-    #  Finds only the hypotheses created in smeshpyD engine.
-    #  @return SMESH.SMESH_Hypothesis
     def FindHypothesis (self, hypname, args, CompareMethod, smeshpyD):
+	"""
+	Finds a hypothesis in the study by its type name and parameters.
+	Finds only the hypotheses created in smeshpyD engine.
+	Returns: 
+		SMESH.SMESH_Hypothesis
+	"""
         study = smeshpyD.GetCurrentStudy()
         if not study: return None
         #to do: find component by smeshpyD object, not by its data type
@@ -110,10 +122,14 @@ class Mesh_Algorithm:
             pass
         return None
 
-    ## Finds the algorithm in the study by its type name.
-    #  Finds only the algorithms, which have been created in smeshpyD engine.
-    #  @return SMESH.SMESH_Algo
     def FindAlgorithm (self, algoname, smeshpyD):
+	"""
+	Finds the algorithm in the study by its type name.
+	Finds only the algorithms, which have been created in smeshpyD engine.
+
+	Returns:
+		SMESH.SMESH_Algo
+	"""
         study = smeshpyD.GetCurrentStudy()
         if not study: return None
         #to do: find component by smeshpyD object, not by its data type
@@ -151,37 +167,51 @@ class Mesh_Algorithm:
             pass
         return None
 
-    ## If the algorithm is global, returns 0; \n
-    #  else returns the submesh associated to this algorithm.
     def GetSubMesh(self):
+	"""
+	If the algorithm is global, returns 0; 
+	else returns the submesh associated to this algorithm.
+	"""
         return self.subm
 
-    ## Returns the wrapped mesher.
     def GetAlgorithm(self):
+	"""
+	Returns the wrapped mesher.
+	"""
         return self.algo
 
-    ## Gets the list of hypothesis that can be used with this algorithm
     def GetCompatibleHypothesis(self):
+	"""
+	Gets the list of hypothesis that can be used with this algorithm
+	"""
         mylist = []
         if self.algo:
             mylist = self.algo.GetCompatibleHypothesis()
         return mylist
 
-    ## Gets the name of the algorithm
     def GetName(self):
+	"""
+	Gets the name of the algorithm
+	"""
         from salome.smesh.smeshBuilder import GetName
         return GetName(self.algo)
 
-    ## Sets the name to the algorithm
     def SetName(self, name):
+	"""
+	Sets the name to the algorithm
+	"""
         self.mesh.smeshpyD.SetName(self.algo, name)
 
-    ## Gets the id of the algorithm
     def GetId(self):
+	"""
+	Gets the id of the algorithm
+	"""
         return self.algo.GetId()
 
-    ## Private method.
     def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"):
+	"""
+	Private method.
+	"""
         if geom is None and mesh.mesh.HasShapeToMesh():
             raise RuntimeError, "Attempt to create " + hypo + " algorithm on None shape"
         algo = self.FindAlgorithm(hypo, mesh.smeshpyD)
@@ -191,8 +221,10 @@ class Mesh_Algorithm:
         self.Assign(algo, mesh, geom)
         return self.algo
 
-    ## Private method
     def Assign(self, algo, mesh, geom):
+	"""
+	Private method
+	"""
         from salome.smesh.smeshBuilder import AssureGeomPublished, TreatHypoStatus, GetName
         if geom is None and mesh.mesh.HasShapeToMesh():
             raise RuntimeError, "Attempt to create " + algo + " algorithm on None shape"
@@ -214,9 +246,11 @@ class Mesh_Algorithm:
     def CompareEqualHyp (self, hyp, args):
         return True
 
-    ## Private method
     def Hypothesis (self, hyp, args=[], so="libStdMeshersEngine.so",
                     UseExisting=0, CompareMethod="", toAdd=True):
+	"""
+	Private method
+	"""
         from salome.smesh.smeshBuilder import TreatHypoStatus, GetName
         hypo = None
         if UseExisting:
@@ -250,40 +284,47 @@ class Mesh_Algorithm:
             TreatHypoStatus( status, GetName(hypo), geomName, 0, self.mesh )
         return hypo
 
-    ## Returns entry of the shape to mesh in the study
     def MainShapeEntry(self):
+	"""
+	Returns entry of the shape to mesh in the study
+	"""
         if not self.mesh or not self.mesh.GetMesh(): return ""
         if not self.mesh.GetMesh().HasShapeToMesh(): return ""
         shape = self.mesh.GetShape()
         return shape.GetStudyEntry()
 
-    ## Defines "ViscousLayers" hypothesis to give parameters of layers of prisms to build
-    #  near mesh boundary. This hypothesis can be used by several 3D algorithms:
-    #  NETGEN 3D, MG-Tetra, Hexahedron(i,j,k)
-    #  @param thickness total thickness of layers of prisms
-    #  @param numberOfLayers number of layers of prisms
-    #  @param stretchFactor factor (>1.0) of growth of layer thickness towards inside of mesh
-    #  @param faces list of geometrical faces (or their ids).
-    #         Viscous layers are either generated on these faces or not, depending on
-    #         the value of \a isFacesToIgnore parameter.
-    #  @param isFacesToIgnore if \c True, the Viscous layers are not generated on the
-    #         faces specified by the previous parameter (\a faces).
-    #  @param extrMethod extrusion method defines how position of new nodes are found during
-    #         prism construction and how creation of distorted and intersecting prisms is
-    #         prevented. Possible values are:
-    #       - StdMeshers.SURF_OFFSET_SMOOTH (default) method extrudes nodes along normal
-    #         to underlying geometrical surface. Smoothing of internal surface of
-    #         element layers can be used to avoid creation of invalid prisms.
-    #       - StdMeshers.FACE_OFFSET method extrudes nodes along average normal of
-    #         surrounding mesh faces till intersection with a neighbor mesh face
-    #         translated along its own normal by the layers thickness. Thickness
-    #         of layers can be limited to avoid creation of invalid prisms.
-    #       - StdMeshers.NODE_OFFSET method extrudes nodes along average normal of
-    #         surrounding mesh faces by the layers thickness. Thickness of
-    #         layers can be limited to avoid creation of invalid prisms.
-    #  @ingroup l3_hypos_additi
     def ViscousLayers(self, thickness, numberOfLayers, stretchFactor,
                       faces=[], isFacesToIgnore=True, extrMethod=StdMeshers.SURF_OFFSET_SMOOTH ):
+	"""
+	Defines "ViscousLayers" hypothesis to give parameters of layers of prisms to build
+	near mesh boundary. This hypothesis can be used by several 3D algorithms:
+	NETGEN 3D, MG-Tetra, Hexahedron(i,j,k)
+
+	Parameters:
+		thickness: total thickness of layers of prisms
+		numberOfLayers: number of layers of prisms
+		stretchFactor: factor (>1.0) of growth of layer thickness towards inside of mesh
+		faces: list of geometrical faces (or their ids).
+			Viscous layers are either generated on these faces or not, depending on
+			the value of **isFacesToIgnore** parameter.
+		isFacesToIgnore: if *True*, the Viscous layers are not generated on the
+			faces specified by the previous parameter (**faces**).
+		extrMethod: extrusion method defines how position of new nodes are found during
+			prism construction and how creation of distorted and intersecting prisms is
+			prevented. Possible values are:
+
+			- StdMeshers.SURF_OFFSET_SMOOTH (default) method extrudes nodes along normal
+				to underlying geometrical surface. Smoothing of internal surface of
+				element layers can be used to avoid creation of invalid prisms.
+			- StdMeshers.FACE_OFFSET method extrudes nodes along average normal of
+				surrounding mesh faces till intersection with a neighbor mesh face
+				translated along its own normal by the layers thickness. Thickness
+				of layers can be limited to avoid creation of invalid prisms.
+			- StdMeshers.NODE_OFFSET method extrudes nodes along average normal of
+				surrounding mesh faces by the layers thickness. Thickness of
+				layers can be limited to avoid creation of invalid prisms.
+	"""
+        
         if not isinstance(self.algo, SMESH._objref_SMESH_3D_Algo):
             raise TypeError, "ViscousLayers are supported by 3D algorithms only"
         if not "ViscousLayers" in self.GetCompatibleHypothesis():
@@ -308,20 +349,24 @@ class Mesh_Algorithm:
         self.mesh.AddHypothesis( hyp, self.geom )
         return hyp
 
-    ## Defines "ViscousLayers2D" hypothesis to give parameters of layers of quadrilateral
-    #  elements to build near mesh boundary. This hypothesis can be used by several 2D algorithms:
-    #  NETGEN 2D, NETGEN 1D-2D, Quadrangle (mapping), MEFISTO, MG-CADSurf
-    #  @param thickness total thickness of layers of quadrilaterals
-    #  @param numberOfLayers number of layers
-    #  @param stretchFactor factor (>1.0) of growth of layer thickness towards inside of mesh
-    #  @param edges list of geometrical edges (or their ids).
-    #         Viscous layers are either generated on these edges or not, depending on
-    #         the value of \a isEdgesToIgnore parameter.
-    #  @param isEdgesToIgnore if \c True, the Viscous layers are not generated on the
-    #         edges specified by the previous parameter (\a edges).
-    #  @ingroup l3_hypos_additi
     def ViscousLayers2D(self, thickness, numberOfLayers, stretchFactor,
                         edges=[], isEdgesToIgnore=True ):
+	"""
+	Defines "ViscousLayers2D" hypothesis to give parameters of layers of quadrilateral
+	elements to build near mesh boundary. This hypothesis can be used by several 2D algorithms:
+	NETGEN 2D, NETGEN 1D-2D, Quadrangle (mapping), MEFISTO, MG-CADSurf
+
+	Parameters:
+		thickness: total thickness of layers of quadrilaterals
+		numberOfLayers: number of layers
+		stretchFactor: factor (>1.0) of growth of layer thickness towards inside of mesh
+		edges: list of geometrical edges (or their ids).
+			Viscous layers are either generated on these edges or not, depending on
+			the value of **isEdgesToIgnore** parameter.
+		isEdgesToIgnore: if *True*, the Viscous layers are not generated on the
+			edges specified by the previous parameter (**edges**).
+	"""
+        
         if not isinstance(self.algo, SMESH._objref_SMESH_2D_Algo):
             raise TypeError, "ViscousLayers2D are supported by 2D algorithms only"
         if not "ViscousLayers2D" in self.GetCompatibleHypothesis():
@@ -345,10 +390,12 @@ class Mesh_Algorithm:
         self.mesh.AddHypothesis( hyp, self.geom )
         return hyp
 
-    ## Transform a list of either edges or tuples (edge, 1st_vertex_of_edge)
-    #  into a list acceptable to SetReversedEdges() of some 1D hypotheses
-    #  @ingroup l3_hypos_1dhyps
     def ReversedEdgeIndices(self, reverseList):
+	"""
+	Transform a list of either edges or tuples (edge, 1st_vertex_of_edge)
+	into a list acceptable to SetReversedEdges() of some 1D hypotheses
+	"""
+        
         from salome.smesh.smeshBuilder import FirstVertexOnCurve
         resList = []
         geompy = self.mesh.geompyD