From: rnv Date: Thu, 25 Jan 2018 10:54:58 +0000 (+0300) Subject: Sphinx documentation: Minor modifications and some corrections. X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=f699d8bf4d93e3f2b35330156401c02140c2ad56;p=modules%2Fsmesh.git Sphinx documentation: Minor modifications and some corrections. --- diff --git a/doc/salome/gui/SMESH/CMakeLists.txt b/doc/salome/gui/SMESH/CMakeLists.txt index 60185cc4f..39413eb9c 100644 --- a/doc/salome/gui/SMESH/CMakeLists.txt +++ b/doc/salome/gui/SMESH/CMakeLists.txt @@ -18,17 +18,16 @@ # SALOME_INSTALL_SCRIPTS(collect_mesh_methods.py ${SALOME_INSTALL_BINS}) - + SET(DOC_SMESH_MeshersList StdMeshers) SET(smesh_file "${CMAKE_CURRENT_SOURCE_DIR}/collect_mesh_methods.py") +SET(smesh_merge_file "${CMAKE_CURRENT_SOURCE_DIR}/merge_mesh_class.py") +# Define requared environment variables SALOME_ACCUMULATE_ENVIRONMENT(SMESH_MeshersList NOCHECK ${DOC_SMESH_MeshersList}) +SALOME_ACCUMULATE_ENVIRONMENT(PYTHONPATH NOCHECK ${CMAKE_CURRENT_BINARY_DIR}/tmp1) SALOME_ACCUMULATE_ENVIRONMENT(PYTHONPATH NOCHECK ${CMAKE_CURRENT_BINARY_DIR}/tmp2) -# TODO: to think how to generate documentation with sphinx for StdMeshers -SET(_cmd_options ${smesh_file} -o tmp1/smeshBuilder.py StdMeshers) -SALOME_GENERATE_ENVIRONMENT_SCRIPT(_cmd env_script "${PYTHON_EXECUTABLE}" "${_cmd_options}") - # Make configuration file SALOME_CONFIGURE_FILE(conf.py.in conf.py) @@ -52,29 +51,43 @@ SET(POT_ALLSPHINXOPTS -c ${CMAKE_CURRENT_BINARY_DIR} -b gettext ${POT_SPHINXOPTS SET(PO_SPHINXOPTS) SET(PO_ALLSPHINXOPTS ${PO_SPHINXOPTS} update -p potfiles) +# 6. Options for generating temporary python modues +SET(_cmd_tmp_gen_options ${smesh_file} -o tmp1/smeshBuilder_dynamic.py -f sphinx StdMeshers) + +# 7. Options for generating final smeshBuilder.py script +SET(_cmd_smeshBuilder_gen_options ${smesh_merge_file} -o tmp2/smeshBuilder.py smeshBuilder) + SALOME_GENERATE_ENVIRONMENT_SCRIPT(_cmd_sphinx env_script_sphinx "${SPHINX_EXECUTABLE}" "${ALLSPHINXOPTS}") SALOME_GENERATE_ENVIRONMENT_SCRIPT(_cmd_sphinx_fr env_script_sphinx "${SPHINX_EXECUTABLE}" "${FR_ALLSPHINXOPTS}") SALOME_GENERATE_ENVIRONMENT_SCRIPT(_cmd_sphinx_pot env_script_sphinx "${SPHINX_EXECUTABLE}" "${POT_ALLSPHINXOPTS}") SALOME_GENERATE_ENVIRONMENT_SCRIPT(_cmd_sphinx_intl_build env_script_sphinx "${SPHINX_INTL_EXECUTABLE}" "build") SALOME_GENERATE_ENVIRONMENT_SCRIPT(_cmd_sphinx_intl_update env_script_sphinx "${SPHINX_INTL_EXECUTABLE}" "${PO_ALLSPHINXOPTS}") +SALOME_GENERATE_ENVIRONMENT_SCRIPT(_cmd_tmp_gen env_script "${PYTHON_EXECUTABLE}" "${_cmd_tmp_gen_options}") +SALOME_GENERATE_ENVIRONMENT_SCRIPT(_cmd_smeshBuilder_gen env_script "${PYTHON_EXECUTABLE}" "${_cmd_smeshBuilder_gen_options}") ADD_CUSTOM_TARGET(usr_docs ${CMAKE_COMMAND} -E make_directory tmp1 - + # Make temporary directory for python modules COMMAND ${CMAKE_COMMAND} -E make_directory tmp2 - # Copy python modules to be documented into memporary directory - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/src/SMESH_SWIG/smeshBuilder.py tmp2/smeshBuilder.py - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/src/SMESH_SWIG/smesh_algorithm.py tmp2/smesh_algorithm.py + # Copy python module to the temporary file + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/src/SMESH_SWIG/smeshBuilder.py ${CMAKE_CURRENT_BINARY_DIR}/tmp1/smeshBuilder_origin.py + + # Copy python modules to be documented into memporary director COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/src/SMESH_SWIG/StdMeshersBuilder.py ${CMAKE_CURRENT_BINARY_DIR}/tmp2/StdMeshersBuilder.py - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/src/SMESH_PY/smeshstudytools.py ${CMAKE_CURRENT_BINARY_DIR}/tmp2 + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/src/SMESH_SWIG/smesh_algorithm.py ${CMAKE_CURRENT_BINARY_DIR}/tmp2/smesh_algorithm.py + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/src/SMESH_PY/smeshstudytools.py ${CMAKE_CURRENT_BINARY_DIR}/tmp2/smeshstudytools.py - # collect methods from StdMeshers - COMMAND ${_cmd} + # Collect methods from StdMeshers into temporary python module + COMMAND ${_cmd_tmp_gen} + + # Generate smeshBuilder.py script + COMMAND ${_cmd_smeshBuilder_gen} # Internatiolization commands: # 1. Copy existing po files COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/locale ${CMAKE_CURRENT_BINARY_DIR}/locale + # 2. sphinx-intl "build" COMMAND ${_cmd_sphinx_intl_build} @@ -91,19 +104,19 @@ ADD_CUSTOM_TARGET(usr_docs ${CMAKE_COMMAND} -E make_directory tmp1 FILE(GLOB POFILES ${CMAKE_CURRENT_BINARY_DIR}/locale/fr/LC_MESSAGES/*.po) -ADD_CUSTOM_TARGET(check_translations +ADD_CUSTOM_TARGET(check_translations # 1. Generate potfiles COMMAND ${_cmd_sphinx_pot} # 2. Copy existing po files COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/locale ${CMAKE_CURRENT_BINARY_DIR}/locale # 3. Update PO files - COMMAND ${_cmd_sphinx_intl_update} + COMMAND ${_cmd_sphinx_intl_update} ) ADD_DEPENDENCIES(check_translations usr_docs) FOREACH(pofile ${POFILES}) - GET_FILENAME_COMPONENT(fn_wo_path ${pofile} NAME) + GET_FILENAME_COMPONENT(fn_wo_path ${pofile} NAME) ADD_CUSTOM_COMMAND(TARGET check_translations POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different ${pofile} ${CMAKE_CURRENT_SOURCE_DIR}/locale/fr/LC_MESSAGES/${fn_wo_path}) diff --git a/doc/salome/gui/SMESH/collect_mesh_methods.py b/doc/salome/gui/SMESH/collect_mesh_methods.py index 7aa83b084..780ced9c7 100755 --- a/doc/salome/gui/SMESH/collect_mesh_methods.py +++ b/doc/salome/gui/SMESH/collect_mesh_methods.py @@ -45,10 +45,9 @@ # variables are set properly; otherwise the script will fail. # ################################################################################ - import sys -def main(plugin_name, dummymeshhelp = True, output_file = "smeshBuilder.py"): +def main(plugin_name, dummymeshhelp = True, output_file = "smeshBuilder.py", format = "doxygen"): plugin_module_name = plugin_name + "Builder" plugin_module = "salome.%s.%s" % (plugin_name, plugin_module_name) try: @@ -68,29 +67,59 @@ def main(plugin_name, dummymeshhelp = True, output_file = "smeshBuilder.py"): if methods: output = [] if dummymeshhelp: - output.append( "## @package smeshBuilder" ) - output.append( "# Documentation of the methods dynamically added by the " + plugin_name + " meshing plug-in to the Mesh class." ) - output.append( "" ) + if format == "doxygen": + output.append( "## @package smeshBuilder" ) + output.append( "# Documentation of the methods dynamically added by the " + plugin_name + " meshing plug-in to the Mesh class." ) + output.append( "" ) + elif format == "sphinx": + output.append( '"""' ) + output.append( 'Documentation of the methods dynamically added by the ' + plugin_name + ' meshing plug-in to the Mesh class.' ) + output.append( '"""' ) + output.append( '' ) pass - output.append( "## This class allows defining and managing a mesh." ) - output.append( "#" ) + if format == "doxygen": + output.append( "## This class allows defining and managing a mesh." ) + output.append( "#" ) + elif format == "sphinx": + output.append( "class Mesh:" ) + output.append( ' """' ) + output.append( ' This class allows defining and managing a mesh.' ) + output.append( ' ' ) if dummymeshhelp: # Add dummy Mesh help # This is supposed to be done when generating documentation for meshing plug-ins - output.append( "# @note The documentation below does not provide complete description of class @b %Mesh" ) - output.append( "# from @b smeshBuilder package. This documentation provides only information about" ) - output.append( "# the methods dynamically added to the %Mesh class by the " + plugin_name + " plugin" ) - output.append( "# For more details on the %Mesh class, please refer to the SALOME %Mesh module" ) - output.append( "# documentation." ) + if format == "doxygen": + output.append( "# @note The documentation below does not provide complete description of class @b %Mesh" ) + output.append( "# from @b smeshBuilder package. This documentation provides only information about" ) + output.append( "# the methods dynamically added to the %Mesh class by the " + plugin_name + " plugin" ) + output.append( "# For more details on the %Mesh class, please refer to the SALOME %Mesh module" ) + output.append( "# documentation." ) + elif format == "sphinx": + output.append( ' The documentation below does not provide complete description of class @b %Mesh' ) + output.append( ' from @b smeshBuilder package. This documentation provides only information about' ) + output.append( ' the methods dynamically added to the %Mesh class by the " + plugin_name + " plugin' ) + output.append( ' For more details on the %Mesh class, please refer to the SALOME %Mesh module' ) + output.append( ' documentation.' ) + output.append( ' """' ) + output.append( ' ' ) pass else: # Extend documentation for Mesh class with information about dynamically added methods. # This is supposed to be done only when building documentation for SMESH module - output.append( "# @note Some methods are dynamically added to the @b %Mesh class in runtime by meshing " ) - output.append( "# plug-in modules. If you fail to find help on some methods in the documentation of SMESH module, " ) - output.append( "# try to look into the documentation for the meshing plug-ins." ) + if format == "doxygen": + output.append( "# @note Some methods are dynamically added to the @b %Mesh class in runtime by meshing " ) + output.append( "# plug-in modules. If you fail to find help on some methods in the documentation of SMESH module, " ) + output.append( "# try to look into the documentation for the meshing plug-ins." ) + elif format == "sphinx": + output.append( " Note:") + output.append( " Some methods are dynamically added to the @b %Mesh class in runtime by meshing " ) + output.append( " plug-in modules. If you fail to find help on some methods in the documentation of SMESH module, " ) + output.append( " try to look into the documentation for the meshing plug-ins." ) + output.append( ' """' ) + output.append( ' ' ) pass - output.append( "class Mesh:" ) + if format == "doxygen": + output.append( "class Mesh:" ) for method in methods: docHelper = "" for algo in methods[ method ]: @@ -98,18 +127,38 @@ def main(plugin_name, dummymeshhelp = True, output_file = "smeshBuilder.py"): if docHelper: break pass if not docHelper: docHelper = "Creates new algorithm." - output.append( " ## %s" % docHelper ) - output.append( " #" ) - output.append( " # This method is dynamically added to %Mesh class by the meshing plug-in(s). " ) - output.append( " #" ) - output.append( " # If the optional @a geom_shape parameter is not set, this algorithm is global (applied to whole mesh)." ) - output.append( " # Otherwise, this algorithm defines a submesh based on @a geom_shape subshape." ) - output.append( " # @param algo_type type of algorithm to be created; allowed values are specified by classes implemented by plug-in (see below)" ) - output.append( " # @param geom_shape if defined, the subshape to be meshed (GEOM_Object)" ) - output.append( " # @return An instance of Mesh_Algorithm sub-class according to the specified @a algo_type, see " ) - output.append( " # %s" % ", ".join( [ "%s.%s" % ( plugin_module_name, algo.__name__ ) for algo in methods[ method ] ] ) ) - output.append( " def %s(algo_type, geom_shape=0):" % method ) - output.append( " pass" ) + if format == "doxygen": + output.append( " ## %s" % docHelper ) + output.append( " #" ) + output.append( " # This method is dynamically added to %Mesh class by the meshing plug-in(s). " ) + output.append( " #" ) + output.append( " # If the optional @a geom_shape parameter is not set, this algorithm is global (applied to whole mesh)." ) + output.append( " # Otherwise, this algorithm defines a submesh based on @a geom_shape subshape." ) + output.append( " # @param algo_type type of algorithm to be created; allowed values are specified by classes implemented by plug-in (see below)" ) + output.append( " # @param geom_shape if defined, the subshape to be meshed (GEOM_Object)" ) + output.append( " # @return An instance of Mesh_Algorithm sub-class according to the specified @a algo_type, see " ) + output.append( " # %s" % ", ".join( [ "%s.%s" % ( plugin_module_name, algo.__name__ ) for algo in methods[ method ] ] ) ) + output.append( " def %s(algo_type, geom_shape=0):" % method ) + output.append( " pass" ) + elif format == "sphinx": + output.append( ' def %s(algo_type, geom_shape=0):' % method ) + output.append( ' """' ) + output.append( ' %s' % docHelper ) + output.append( ' ' ) + output.append( ' This method is dynamically added to **Mesh** class by the meshing plug-in(s). ' ) + output.append( ' ' ) + output.append( ' If the optional *geom_shape* parameter is not set, this algorithm is global (applied to whole mesh).' ) + output.append( ' Otherwise, this algorithm defines a submesh based on *geom_shape* subshape.' ) + output.append( ' ' ) + output.append( ' Parameters:' ) + output.append( ' algo_type: type of algorithm to be created; allowed values are specified by classes implemented by plug-in (see below)' ) + output.append( ' geom_shape (GEOM_Object): if defined, the subshape to be meshed' ) + output.append( ' ' ) + output.append( ' Returns:') + output.append( ' An instance of Mesh_Algorithm sub-class according to the specified *algo_type*, see ' ) + output.append( ' %s' % ", ".join( [ ":class:`~%s.%s`" % ( plugin_module_name, algo.__name__ ) for algo in methods[ method ] ] ) ) + output.append( ' """' ) + output.append( ' pass' ) pass f = open(output_file, "w") for line in output: f.write( line + "\n" ) @@ -134,8 +183,14 @@ if __name__ == "__main__": parser.add_option("-d", "--dummy-mesh-help", dest="dummymeshhelp", action="store_true", default=False, help=h) + h = "Format of the documentation strings in the output file. Possible values are: " + h+= "'doxygen' - documentation strings are generated in the doxygen format, before a method defenition." + h+= "'sphinx' - documentation strings are generated in the sphinx format, after a method defenition." + parser.add_option("-f", "--format", dest="format", + action="store", default="doxygen", help=h) + (options, args) = parser.parse_args() if len( args ) < 1: sys.exit("Plugin name is not specified") - main( args[0], options.dummymeshhelp, options.output ) + main( args[0], options.dummymeshhelp, options.output, options.format ) pass diff --git a/doc/salome/gui/SMESH/merge_mesh_class.py b/doc/salome/gui/SMESH/merge_mesh_class.py new file mode 100644 index 000000000..dd9806b52 --- /dev/null +++ b/doc/salome/gui/SMESH/merge_mesh_class.py @@ -0,0 +1,59 @@ +import inspect +import sys +from types import FunctionType +import copy + +ORIGIN_MODULE_SUFFIX = "_origin" +DYNAMIC_MODULE_SUFFIX = "_dynamic" + + +def main(module_name, output_file = "smeshBuilder.py"): + oringin_module_name = module_name + ORIGIN_MODULE_SUFFIX + dynamic_module_name = module_name + DYNAMIC_MODULE_SUFFIX + try: + exec( "import %s" % oringin_module_name ) + exec( "origin_module = %s" % oringin_module_name ) + origin_module_lines = inspect.getsourcelines( origin_module )[0] + origin_meshClass_lines = inspect.getsourcelines(origin_module.Mesh)[0] + origin_module_text = "".join( origin_module_lines ) + origin_meshClass_text = "".join( origin_meshClass_lines ) + + exec( "import %s" % dynamic_module_name ) + exec( "dynanmic_module = %s" % dynamic_module_name ) + dynanmic_meshClass = dynanmic_module.Mesh + + new_meshClass_lines = copy.copy(origin_meshClass_lines) + # remove end of class 'pass' + if new_meshClass_lines[-1].find("pass") > 0: + new_meshClass_lines.pop() + + dynanmic_meshClass_methods = [x for x, y in dynanmic_meshClass.__dict__.items() if type(y) == FunctionType] + for method in dynanmic_meshClass_methods: + exec( "method_lines = inspect.getsourcelines(dynanmic_module.Mesh.%s)[0]" % method) + new_meshClass_lines+=method_lines + pass + new_meshClass_text = "".join( new_meshClass_lines ) + + f = open( output_file, "w" ) + + f.write( origin_module_text.replace( origin_meshClass_text, new_meshClass_text) ) + f.close() + except Exception, e: + print e + pass + pass + + +if __name__ == "__main__": + import optparse + parser = optparse.OptionParser(usage="%prog [options] modulename") + h = "Output file (smeshBuilder.py by default)" + parser.add_option("-o", "--output", dest="output", + action="store", default="smeshBuilder.py", metavar="file", + help=h) + + (options, args) = parser.parse_args() + + if len( args ) < 1: sys.exit("Module name is not specified") + main( args[0], options.output ) + pass diff --git a/src/SMESH_SWIG/StdMeshersBuilder.py b/src/SMESH_SWIG/StdMeshersBuilder.py index 2b07e613f..180ba86be 100644 --- a/src/SMESH_SWIG/StdMeshersBuilder.py +++ b/src/SMESH_SWIG/StdMeshersBuilder.py @@ -32,47 +32,47 @@ import StdMeshers REGULAR = "Regular_1D" """ -Algorithm type: Regular 1D algorithm, see :class:`StdMeshersBuilder_Segment` +Algorithm type: Regular 1D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_Segment` """ PYTHON = "Python_1D" """ -Algorithm type: Python 1D algorithm, see StdMeshersBuilder_Segment_Python +Algorithm type: Python 1D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_Segment_Python` """ COMPOSITE = "CompositeSegment_1D" """ -Algorithm type: Composite segment 1D algorithm, see StdMeshersBuilder_CompositeSegment +Algorithm type: Composite segment 1D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_CompositeSegment` """ MEFISTO = "MEFISTO_2D" """ -Algorithm type: Triangle MEFISTO 2D algorithm, see StdMeshersBuilder_Triangle_MEFISTO +Algorithm type: Triangle MEFISTO 2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_Triangle_MEFISTO` """ Hexa = "Hexa_3D" """ -Algorithm type: Hexahedron 3D (i-j-k) algorithm, see StdMeshersBuilder_Hexahedron +Algorithm type: Hexahedron 3D (i-j-k) algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_Hexahedron` """ QUADRANGLE = "Quadrangle_2D" """ -Algorithm type: Quadrangle 2D algorithm, see StdMeshersBuilder_Quadrangle +Algorithm type: Quadrangle 2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_Quadrangle` """ RADIAL_QUAD = "RadialQuadrangle_1D2D" """ -Algorithm type: Radial Quadrangle 1D-2D algorithm, see StdMeshersBuilder_RadialQuadrangle1D2D +Algorithm type: Radial Quadrangle 1D-2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_RadialQuadrangle1D2D` """ QUAD_MA_PROJ = "QuadFromMedialAxis_1D2D" """ -Algorithm type: Quadrangle (Medial Axis Projection) 1D-2D algorithm, see StdMeshersBuilder_QuadMA_1D2D +Algorithm type: Quadrangle (Medial Axis Projection) 1D-2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_QuadMA_1D2D` """ POLYGON = "PolygonPerFace_2D" """ -Algorithm type: Polygon Per Face 2D algorithm, see StdMeshersBuilder_PolygonPerFace +Algorithm type: Polygon Per Face 2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_PolygonPerFace` """ # import items of enums diff --git a/src/SMESH_SWIG/smeshBuilder.py b/src/SMESH_SWIG/smeshBuilder.py index febf232fe..19f693cec 100644 --- a/src/SMESH_SWIG/smeshBuilder.py +++ b/src/SMESH_SWIG/smeshBuilder.py @@ -20,66 +20,6 @@ # Author : Francis KLOSS, OCC # Module : SMESH -## @package smeshBuilder -# Python API for SALOME %Mesh module - -## @defgroup l1_auxiliary Auxiliary methods and structures -## @defgroup l1_creating Creating meshes -## @{ -## @defgroup l2_impexp Importing and exporting meshes -## @{ -## @details -## These are methods of class \ref smeshBuilder.smeshBuilder "smeshBuilder" -## @} -## @defgroup l2_construct Constructing meshes -## @defgroup l2_algorithms Defining Algorithms -## @{ -## @defgroup l3_algos_basic Basic meshing algorithms -## @defgroup l3_algos_proj Projection Algorithms -## @defgroup l3_algos_segmarv Segments around Vertex -## @defgroup l3_algos_3dextr 3D extrusion meshing algorithm - -## @} -## @defgroup l2_hypotheses Defining hypotheses -## @{ -## @defgroup l3_hypos_1dhyps 1D Meshing Hypotheses -## @defgroup l3_hypos_2dhyps 2D Meshing Hypotheses -## @defgroup l3_hypos_maxvol Max Element Volume hypothesis -## @defgroup l3_hypos_quad Quadrangle Parameters hypothesis -## @defgroup l3_hypos_additi Additional Hypotheses - -## @} -## @defgroup l2_submeshes Constructing sub-meshes -## @defgroup l2_editing Editing Meshes - -## @} -## @defgroup l1_meshinfo Mesh Information -## @defgroup l1_controls Quality controls and Filtering -## @defgroup l1_grouping Grouping elements -## @{ -## @defgroup l2_grps_create Creating groups -## @defgroup l2_grps_operon Using operations on groups -## @defgroup l2_grps_delete Deleting Groups - -## @} -## @defgroup l1_modifying Modifying meshes -## @{ -## @defgroup l2_modif_add Adding nodes and elements -## @defgroup l2_modif_del Removing nodes and elements -## @defgroup l2_modif_edit Modifying nodes and elements -## @defgroup l2_modif_renumber Renumbering nodes and elements -## @defgroup l2_modif_trsf Transforming meshes (Translation, Rotation, Symmetry, Sewing, Merging) -## @defgroup l2_modif_unitetri Uniting triangles -## @defgroup l2_modif_cutquadr Cutting elements -## @defgroup l2_modif_changori Changing orientation of elements -## @defgroup l2_modif_smooth Smoothing -## @defgroup l2_modif_extrurev Extrusion and Revolution -## @defgroup l2_modif_tofromqu Convert to/from Quadratic Mesh -## @defgroup l2_modif_duplicat Duplication of nodes and elements (to emulate cracks) - -## @} -## @defgroup l1_measurements Measurements - import salome from salome.geom import geomBuilder @@ -103,9 +43,6 @@ class MeshMeta(type): """Implement issubclass(sub, cls).""" return type.__subclasscheck__(cls, sub) or (cls.__name__ == sub.__name__ and cls.__module__ == sub.__module__) -## @addtogroup l1_auxiliary -## @{ - def DegreesToRadians(AngleInDegrees): """Convert an angle from degrees to radians """ @@ -321,10 +258,6 @@ def FirstVertexOnCurve(mesh, edge): else: return vv[1] -# end of l1_auxiliary -## @} - - smeshInst = None """ Warning: @@ -1178,8 +1111,8 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): """ Get minimum distance between two objects - If @a src2 is None, and @a id2 = 0, distance from @a src1 / @a id1 to the origin is computed. - If @a src2 is None, and @a id2 != 0, it is assumed that both @a id1 and @a id2 belong to @a src1. + If *src2* is None, and *id2* = 0, distance from *src1* / *id1* to the origin is computed. + If *src2* None, and *id2* != 0, it is assumed that both *id1* and *id2* belong to *src1*. Parameters: src1: first source object @@ -1204,8 +1137,8 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): """ Get measure structure specifying minimum distance data between two objects - If @a src2 is None, and @a id2 = 0, distance from @a src1 / @a id1 to the origin is computed. - If @a src2 is None, and @a id2 != 0, it is assumed that both @a id1 and @a id2 belong to @a src1. + If *src2* is None, and *id2* = 0, distance from *src1* / *id1* to the origin is computed. + If *src2* is None, and *id2* != 0, it is assumed that both *id1* and *id2* belong to *src1*. Parameters: @@ -3556,9 +3489,9 @@ class Mesh: Parameters: id1: first node/element id - id2: second node/element id (if 0, distance from @a id1 to the origin is computed) + id2: second node/element id (if 0, distance from *id1* to the origin is computed) isElem1: *True* if *id1* is element id, *False* if it is node id - isElem2: *True* if @a id2 is element id, *False* if it is node id + isElem2: *True* if *id2* is element id, *False* if it is node id Returns: minimum distance value **GetMinDistance()** @@ -3573,7 +3506,7 @@ class Mesh: Parameters: id1: first node/element id - id2: second node/element id (if 0, distance from @a id1 to the origin is computed) + id2: second node/element id (if 0, distance from *id1* to the origin is computed) isElem1: *True* if *id1* is element id, *False* if it is node id isElem2: *True* if *id2* is element id, *False* if it is node id @@ -3606,7 +3539,7 @@ class Mesh: Parameters: objects: single source object or list of source objects or list of nodes/elements IDs isElem: if *objects* is a list of IDs, *True* value in this parameters specifies that *objects* are elements, - *False* specifies that @a objects are nodes + *False* specifies that *objects* are nodes Returns: tuple of six values (minX, minY, minZ, maxX, maxY, maxZ) **GetBoundingBox()** @@ -3626,7 +3559,7 @@ class Mesh: Parameters: IDs: single source object or list of source objects or list of nodes/elements IDs isElem: if *IDs* is a list of IDs, *True* value in this parameters specifies that *objects* are elements, - *False* specifies that @a objects are nodes + *False* specifies that *objects* are nodes Returns: Measure structure **BoundingBox()** @@ -4024,7 +3957,7 @@ class Mesh: y: the Y coordinate of a point z: the Z coordinate of a point NodeID: if specified (>0), the node with this ID is moved, - otherwise, the node closest to point (@a x,@a y,@a z) is moved + otherwise, the node closest to point (*x*, *y*, *z*) is moved Returns: the ID of a node @@ -4306,7 +4239,7 @@ class Mesh: Parameters: IDsOfElements: the faces to be splitted. theCriterion: is a numerical functor, in terms of enum SMESH.FunctorType, used to - choose a diagonal for splitting. If @a theCriterion is None, which is a default + choose a diagonal for splitting. If *theCriterion* is None, which is a default value, then quadrangles will be split by the smallest diagonal. Type SMESH.FunctorType._items in the Python Console to see all items. Note that not all items correspond to numerical functors. @@ -4329,7 +4262,7 @@ class Mesh: theObject: the object from which the list of elements is taken, this is mesh, submesh or group theCriterion: is a numerical functor, in terms of enum SMESH.FunctorType, used to - choose a diagonal for splitting. If @a theCriterion is None, which is a default + choose a diagonal for splitting. If *theCriterion* is None, which is a default value, then quadrangles will be split by the smallest diagonal. Type SMESH.FunctorType._items in the Python Console to see all items. Note that not all items correspond to numerical functors. @@ -4464,17 +4397,17 @@ class Mesh: Parameters: elems: either a list of elements or a mesh or a group or a submesh or a filter - startHexPoint: a point used to find a hexahedron for which @a facetNormal + startHexPoint: a point used to find a hexahedron for which *facetNormal* gives a normal vector defining facets to split into triangles. **startHexPoint** can be either a triple of coordinates or a vertex. facetNormal: a normal to a facet to split into triangles of a - hexahedron found by @a startHexPoint. + hexahedron found by *startHexPoint*. **facetNormal** can be either a triple of coordinates or an edge. method: flags passing splitting method: smesh.Hex_2Prisms, smesh.Hex_4Prisms. smesh.Hex_2Prisms - to split the hexahedron into 2 prisms, etc. allDomains: if :code:`False`, only hexahedra adjacent to one closest to **startHexPoint** are split, else **startHexPoint** - is used to find the facet to split in all domains present in @a elems. + is used to find the facet to split in all domains present in *elems*. """ # IDSource unRegister = genObjUnRegister() @@ -5054,7 +4987,7 @@ class Mesh: NbOfSteps: the number of steps MakeGroups: forces the generation of new groups from existing ones scaleFactors: optional scale factors to apply during extrusion - linearVariation: if *True*, scaleFactors are spread over all @a scaleFactors, + linearVariation: if *True*, scaleFactors are spread over all *scaleFactors*, else scaleFactors[i] is applied to nodes at the i-th extrusion step basePoint: optional scaling center; if not provided, a gravity center of nodes and elements being extruded is used as the scaling center. @@ -6959,13 +6892,12 @@ class genObjUnRegister: if genObj and hasattr( genObj, "UnRegister" ): genObj.UnRegister() - for pluginName in os.environ[ "SMESH_MeshersList" ].split( ":" ): """ Bind methods creating mesher plug-ins to the Mesh class """ - #print "pluginName: ", pluginName + # print "pluginName: ", pluginName pluginBuilderName = pluginName + "Builder" try: exec( "from salome.%s.%s import *" % (pluginName, pluginBuilderName)) @@ -6975,19 +6907,21 @@ for pluginName in os.environ[ "SMESH_MeshersList" ].split( ":" ): continue exec( "from salome.%s import %s" % (pluginName, pluginBuilderName)) plugin = eval( pluginBuilderName ) - #print " plugin:" , str(plugin) + # print " plugin:" , str(plugin) # add methods creating algorithms to Mesh for k in dir( plugin ): if k[0] == '_': continue algo = getattr( plugin, k ) - #print " algo:", str(algo) + # print " algo:", str(algo) if type( algo ).__name__ == 'classobj' and hasattr( algo, "meshMethod" ): - #print " meshMethod:" , str(algo.meshMethod) + # print " meshMethod:" , str(algo.meshMethod) if not hasattr( Mesh, algo.meshMethod ): setattr( Mesh, algo.meshMethod, algoCreator( algo.meshMethod )) pass - getattr( Mesh, algo.meshMethod ).add( algo ) + _mmethod = getattr( Mesh, algo.meshMethod ) + if hasattr( _mmethod, "add" ): + _mmethod.add(algo) pass pass pass diff --git a/src/SMESH_SWIG/smesh_algorithm.py b/src/SMESH_SWIG/smesh_algorithm.py index 10dbe0527..172dcca74 100644 --- a/src/SMESH_SWIG/smesh_algorithm.py +++ b/src/SMESH_SWIG/smesh_algorithm.py @@ -35,7 +35,7 @@ class Mesh_Algorithm: 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` + it is created by class Mesh (see e.g. class :class:`~StdMeshersBuilder.StdMeshersBuilder_Segment` in StdMeshersBuilder package): - :code:`meshMethod` attribute defines name of method of class smesh.Mesh by calling which the