ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-11-11 16:19:16 +05:00
Code Issues Packages Projects Releases Wiki Activity

Redesign SALOME documentation

Browse Source
This commit is contained in:
rnv 2017-12-08 17:09:48 +03:00
parent f6825d8431
commit f0f67c0b47
435 changed files with 47814 additions and 12670 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -19,6 +19,8 @@
CMAKE_MINIMUM_REQUIRED(VERSION 2.8.8 FATAL_ERROR)
PROJECT(SalomeSMESH C CXX)
INCLUDE(CMakeDependentOption)
# Ensure a proper linker behavior:
CMAKE_POLICY(SET CMP0003 NEW)
IF(WIN32)
@ -78,6 +80,8 @@ OPTION(SALOME_BUILD_GUI "Enable GUI" ON)
OPTION(SALOME_SMESH_USE_CGNS "Enable import/export to CGNS format" OFF)
OPTION(SALOME_SMESH_USE_TBB "Enable parallel computation" OFF)
OPTION(SALOME_SMESH_DYNLOAD_LOCAL "Load plug-ins' symbols locally (Linux only)" ON)
CMAKE_DEPENDENT_OPTION(SALOME_SMESH_BUILD_FRENCH_DOC "Generate SALOME SMESH French documentation" OFF
"NOT SALOME_BUILD_DOC" OFF)
IF(SALOME_SMESH_DYNLOAD_LOCAL)
ADD_DEFINITIONS(-DDYNLOAD_LOCAL)

72
doc/salome/gui/SMESH/CMakeLists.txt
View File

@ -17,42 +17,68 @@
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
SALOME_CONFIGURE_FILE(doxyfile.in doxyfile)
SALOME_CONFIGURE_FILE(doxyfile_py.in doxyfile_py)
SALOME_CONFIGURE_FILE(static/header.html.in ${CMAKE_CURRENT_BINARY_DIR}/static/header.html)
SALOME_CONFIGURE_FILE(static/header_py.html.in ${CMAKE_CURRENT_BINARY_DIR}/static/header_py.html)
INCLUDE(UseSphinx)
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(kernel_file "${KERNEL_ROOT_DIR}/bin/salome/prepare_generating_doc.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)
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)
ADD_CUSTOM_TARGET(usr_docs ${CMAKE_COMMAND} -E make_directory tmp1
IF(SALOME_SMESH_BUILD_FRENCH_DOC)
SET(BUILD_LANGUAGE_SWITCHER "true")
SALOME_CONFIGURE_FILE(static/switchers.js.in static/switchers.js)
ADD_MULTI_LANG_DOCUMENTATION(TARGET_NAME usr_docs MODULE SMESH LANGUAGES fr)
ELSE()
SET(BUILD_LANGUAGE_SWITCHER "false")
SALOME_CONFIGURE_FILE(static/switchers.js.in static/switchers.js)
ADD_MULTI_LANG_DOCUMENTATION(TARGET_NAME usr_docs MODULE SMESH)
ENDIF()
# 1. Options for generating temporary python modules
SET(_cmd_tmp_gen_options ${smesh_file} -o tmp1/smeshBuilder_dynamic.py -f sphinx StdMeshers)
SALOME_GENERATE_ENVIRONMENT_SCRIPT(_cmd_tmp_gen env_script "${PYTHON_EXECUTABLE}" "${_cmd_tmp_gen_options}")
# 2. 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_smeshBuilder_gen env_script "${PYTHON_EXECUTABLE}" "${_cmd_smeshBuilder_gen_options}")
ADD_CUSTOM_TARGET(pre_usr_docs
# 1. Make temporary directories for python modules
COMMAND ${CMAKE_COMMAND} -E make_directory tmp1
COMMAND ${CMAKE_COMMAND} -E make_directory tmp2
COMMAND ${PYTHON_EXECUTABLE} ${kernel_file} -o tmp2/smeshBuilder.py ${CMAKE_SOURCE_DIR}/src/SMESH_SWIG/smeshBuilder.py
COMMAND ${PYTHON_EXECUTABLE} ${kernel_file} -o tmp2/smesh_algorithm.py ${CMAKE_SOURCE_DIR}/src/SMESH_SWIG/smesh_algorithm.py
COMMAND ${PYTHON_EXECUTABLE} ${kernel_file} -o tmp2/StdMeshersBuilder.py ${CMAKE_SOURCE_DIR}/src/SMESH_SWIG/StdMeshersBuilder.py
COMMAND ${PYTHON_EXECUTABLE} ${kernel_file} -o tmp2/smeshstudytools.py ${CMAKE_SOURCE_DIR}/src/SMESH_PY/smeshstudytools.py
COMMAND ${_cmd}
COMMAND ${DOXYGEN_EXECUTABLE} doxyfile_py
COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
COMMAND ${CMAKE_COMMAND} -E remove_directory tmp1
COMMAND ${CMAKE_COMMAND} -E remove_directory tmp2
VERBATIM
# 2. 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
# 3. Copy python modules to be documented into memporary directory
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_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
# 4. Collect methods from StdMeshers into temporary python module
COMMAND ${_cmd_tmp_gen}
# 5. Generate smeshBuilder.py script
COMMAND ${_cmd_smeshBuilder_gen}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
)
ADD_DEPENDENCIES(usr_docs pre_usr_docs)
INSTALL(CODE "EXECUTE_PROCESS(COMMAND \"${CMAKE_COMMAND}\" --build ${PROJECT_BINARY_DIR} --target usr_docs)")
INSTALL(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/SMESH DESTINATION ${SALOME_INSTALL_DOC}/gui)
INSTALL(FILES images/head.png DESTINATION ${SALOME_INSTALL_DOC}/gui/SMESH)
INSTALL(FILES images/head.png DESTINATION ${SALOME_INSTALL_DOC}/gui/SMESH/smeshpy_doc)
IF(SALOME_SMESH_BUILD_FRENCH_DOC)
INSTALL(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/SMESH_fr DESTINATION ${SALOME_INSTALL_DOC}/gui)
ENDIF()
FILE(GLOB tag_files ${CMAKE_CURRENT_BINARY_DIR}/*.tag)
SET(make_clean_files SMESH ${tag_files})
SET(make_clean_files tmp1 tmp2)
SET_DIRECTORY_PROPERTIES(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${make_clean_files}")

113
doc/salome/gui/SMESH/collect_mesh_methods.py
View File

@ -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

224
doc/salome/gui/SMESH/conf.py.in Normal file
View File

@ -0,0 +1,224 @@
# -*- coding: utf-8 -*-
#
# yacs documentation build configuration file, created by
# sphinx-quickstart on Fri Aug 29 09:57:25 2008.
#
# This file is execfile()d with the current directory set to its containing dir.
#
# The contents of this file are pickled, so don't put values in the namespace
# that aren't pickleable (module imports are okay, they're removed automatically).
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys, os
# If your extensions are in another directory, add it here. If the directory
# is relative to the documentation root, use os.path.abspath to make it
# absolute, like shown here.
#sys.path.append(os.path.abspath('.'))
# General configuration
# ---------------------
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc',
'sphinxcontrib.napoleon'
]
#add pdfbuilder to build a pdf with rst2pdf
#extensions = ['rst2pdf.pdfbuilder']
# Add any paths that contain templates here, relative to this directory.
templates_path = [os.path.join('@CMAKE_CURRENT_SOURCE_DIR@','templates')]
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = 'Mesh'
# Copyright is shown via custom footer
html_show_copyright = False
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = '@SALOMESMESH_VERSION@'
# The full version, including alpha/beta/rc tags.
release = '@SALOMESMESH_VERSION@'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of documents that shouldn't be included in the build.
#unused_docs = []
# List of directories, relative to source directory, that shouldn't be searched
# for source files.
exclude_trees = ['.build','ref','images','CVS']
# A list of glob-style patterns that should be excluded when looking for source
# files. They are matched against the source file names relative to the
# source directory, using slashes as directory separators on all platforms.
exclude_patterns = ['**/CVS']
# The reST default role (used for this markup: `text`) to use for all documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# Options for HTML output
# -----------------------
# The theme to use for HTML and HTML Help pages. Major themes that come with
# Sphinx are currently 'default' and 'sphinxdoc'.
html_theme = '@SPHINX_THEME@'
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = [os.path.join('@CMAKE_CURRENT_BINARY_DIR@','static')]
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
html_sidebars = { '**': ['globaltoc.html', 'relations.html', 'sourcelink.html', 'searchbox.html'],}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
html_use_modindex = True
# If false, no index is generated.
html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, the reST sources are included in the HTML build as _sources/<name>.
#html_copy_source = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = ''
# Output file base name for HTML help builder.
htmlhelp_basename = 'smeshdoc'
# Options for LaTeX output
# ------------------------
# The paper size ('letter' or 'a4').
latex_paper_size = 'a4'
# The font size ('10pt', '11pt' or '12pt').
latex_font_size = '10pt'
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, document class [howto/manual]).
latex_documents = [
('index', 'Smesh.tex', 'SMESH User Documentation', '', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# Additional stuff for the LaTeX preamble.
latex_preamble = """
\RecustomVerbatimEnvironment
{Verbatim}{Verbatim}
{fontsize=\scriptsize}
"""
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
latex_use_modindex = True
#Options for rst2pdf output (through reportlab)
pdf_documents = [
('index', 'Smesh.tex', 'SMESH User Documentation', '', 'manual'),
]
# A comma-separated list of custom stylesheets.
pdf_stylesheets = ['sphinx','kerning','a4']
# Create a compressed PDF
# Use True/False or 1/0
#pdf_compressed = False
# A colon-separated list of folders to search for fonts. Example:
# pdf_font_path = ['/usr/share/fonts', '/usr/share/texmf-dist/fonts/']
# Language to be used for hyphenation support
#pdf_language = "en_US"
# Example configuration for intersphinx: refer to the Python standard library.
intersphinx_mapping = {'https://docs.python.org/': None}
locale_dirs = [os.path.join('@CMAKE_CURRENT_BINARY_DIR@','locale')] # path is example but recommended.
gettext_compact = False # optional

88
doc/salome/gui/SMESH/doxyfile.in
View File

@ -1,88 +0,0 @@
# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
#
# Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
PROJECT_NAME = "SALOME Mesh User's Guide"
OUTPUT_DIRECTORY = SMESH
CREATE_SUBDIRS = NO
OUTPUT_LANGUAGE = English
TAB_SIZE = 5
#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------
QUIET = NO
WARNINGS = YES
#---------------------------------------------------------------------------
#Input related options
#---------------------------------------------------------------------------
INPUT = @CMAKE_CURRENT_SOURCE_DIR@/input $(GEOM_ROOT_DIR)/share/doc/salome/gui/GEOM/input
FILE_PATTERNS = *.doc
EXCLUDE =
EXCLUDE_PATTERNS = tui_*.doc
IMAGE_PATH = $(GEOM_ROOT_DIR)/share/doc/salome/gui/GEOM @CMAKE_CURRENT_SOURCE_DIR@/images
EXAMPLE_PATH = @CMAKE_SOURCE_DIR@/doc/salome/examples @CMAKE_SOURCE_DIR@/src/SMESH_SWIG
#---------------------------------------------------------------------------
#HTML related options
#---------------------------------------------------------------------------
GENERATE_HTML = YES
HTML_OUTPUT = .
HTML_HEADER = @CMAKE_CURRENT_BINARY_DIR@/static/header.html
HTML_FOOTER = @CMAKE_CURRENT_SOURCE_DIR@/static/footer.html
HTML_EXTRA_STYLESHEET = @CMAKE_CURRENT_SOURCE_DIR@/static/salome_extra.css
TOC_EXPAND = YES
DISABLE_INDEX = NO
GENERATE_TREEVIEW = YES
TREEVIEW_WIDTH = 300
#---------------------------------------------------------------------------
#SORT related options
#---------------------------------------------------------------------------
SORT_GROUP_NAMES = NO
#---------------------------------------------------------------------------
#LaTeX related option
#---------------------------------------------------------------------------
GENERATE_LATEX = NO
EXTRA_PACKAGES = amsmath
#---------------------------------------------------------------------------
#RTF related options
#---------------------------------------------------------------------------
GENERATE_RTF = NO
#---------------------------------------------------------------------------
#External reference options
#---------------------------------------------------------------------------
TAGFILES = smeshpy_doc.tag=../SMESH/smeshpy_doc #rnv: 07.04.2011 Workaround for the doxygen 1.7.3:
#because it wrongly defines location of the html files for search.
SEARCHENGINE = YES
#---------------------------------------------------------------------------
#Custom commands
#---------------------------------------------------------------------------
ALIASES += tui_script{1}="\include \1 <a href=\"../../examples/SMESH/\1\">Download this script</a>"

173
doc/salome/gui/SMESH/doxyfile_py.in
View File

@ -1,173 +0,0 @@
# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
#
# Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
PROJECT_NAME = "SALOME Mesh User's Guide"
OUTPUT_DIRECTORY = SMESH
CREATE_SUBDIRS = NO
OUTPUT_LANGUAGE = English
USE_WINDOWS_ENCODING = NO
BRIEF_MEMBER_DESC = YES
REPEAT_BRIEF = YES
ALWAYS_DETAILED_SEC = YES
INLINE_INHERITED_MEMB = YES
FULL_PATH_NAMES = NO
SHORT_NAMES = NO
JAVADOC_AUTOBRIEF = YES
MULTILINE_CPP_IS_BRIEF = NO
DETAILS_AT_TOP = NO
INHERIT_DOCS = YES
SEPARATE_MEMBER_PAGES = NO
TAB_SIZE = 5
OPTIMIZE_OUTPUT_FOR_C = YES
OPTIMIZE_OUTPUT_JAVA = YES
BUILTIN_STL_SUPPORT = NO
DISTRIBUTE_GROUP_DOC = NO
SUBGROUPING = YES
#---------------------------------------------------------------------------
# Build related options
#---------------------------------------------------------------------------
EXTRACT_ALL = YES
EXTRACT_PRIVATE = YES
EXTRACT_STATIC = NO
EXTRACT_LOCAL_CLASSES = YES
EXTRACT_LOCAL_METHODS = NO
HIDE_UNDOC_MEMBERS = NO
HIDE_UNDOC_CLASSES = NO
HIDE_FRIEND_COMPOUNDS = NO
HIDE_IN_BODY_DOCS = NO
INTERNAL_DOCS = YES
CASE_SENSE_NAMES = YES
HIDE_SCOPE_NAMES = YES
SHOW_INCLUDE_FILES = YES
INLINE_INFO = YES
SORT_MEMBER_DOCS = NO
SORT_BRIEF_DOCS = NO
SORT_BY_SCOPE_NAME = NO
GENERATE_TODOLIST = YES
GENERATE_TESTLIST = YES
GENERATE_BUGLIST = YES
GENERATE_DEPRECATEDLIST= YES
MAX_INITIALIZER_LINES = 25
SHOW_USED_FILES = NO
SHOW_DIRECTORIES = NO
#---------------------------------------------------------------------------
# configuration options related to source browsing
#---------------------------------------------------------------------------
SOURCE_BROWSER = NO
INLINE_SOURCES = NO
STRIP_CODE_COMMENTS = YES
REFERENCED_BY_RELATION = NO
REFERENCES_RELATION = YES
USE_HTAGS = NO
VERBATIM_HEADERS = YES
#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------
QUIET = NO
WARNINGS = YES
WARN_IF_UNDOCUMENTED = YES
WARN_IF_DOC_ERROR = YES
WARN_NO_PARAMDOC = NO
EXCLUDE_SYMLINKS = NO
EXAMPLE_RECURSIVE = NO
#---------------------------------------------------------------------------
#Input related options
#---------------------------------------------------------------------------
INPUT = tmp2/smeshBuilder.py \
tmp2/smesh_algorithm.py \
tmp2/StdMeshersBuilder.py \
tmp2/smeshstudytools.py \
tmp1/smeshBuilder.py \
@CMAKE_CURRENT_SOURCE_DIR@/input
FILE_PATTERNS = tui_*.doc
IMAGE_PATH = @CMAKE_CURRENT_SOURCE_DIR@/images
RECURSIVE = NO
EXAMPLE_PATH = @CMAKE_SOURCE_DIR@/src/SMESH_SWIG @CMAKE_SOURCE_DIR@/doc/salome/examples
#---------------------------------------------------------------------------
#HTML related options
#---------------------------------------------------------------------------
GENERATE_HTML = YES
HTML_OUTPUT = smeshpy_doc
HTML_HEADER = @CMAKE_CURRENT_BINARY_DIR@/static/header_py.html
HTML_FOOTER = @CMAKE_CURRENT_SOURCE_DIR@/static/footer.html
HTML_EXTRA_STYLESHEET = @CMAKE_CURRENT_SOURCE_DIR@/static/salome_extra.css
TOC_EXPAND = YES
DISABLE_INDEX = NO
GENERATE_TREEVIEW = YES
TREEVIEW_WIDTH = 300
#---------------------------------------------------------------------------
#LaTeX related option
#---------------------------------------------------------------------------
GENERATE_LATEX = NO
#---------------------------------------------------------------------------
#RTF related options
#---------------------------------------------------------------------------
GENERATE_RTF = NO
#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------
CLASS_DIAGRAMS = NO
HIDE_UNDOC_RELATIONS = NO
HAVE_DOT = YES
CLASS_GRAPH = YES
COLLABORATION_GRAPH = NO
GROUP_GRAPHS = NO
UML_LOOK = NO
TEMPLATE_RELATIONS = YES
INCLUDE_GRAPH = YES
INCLUDED_BY_GRAPH = YES
CALL_GRAPH = NO
GRAPHICAL_HIERARCHY = YES
DIRECTORY_GRAPH = YES
DOT_IMAGE_FORMAT = png
DOT_FONTNAME = Arial
DOT_PATH =
DOTFILE_DIRS =
MAX_DOT_GRAPH_WIDTH = 1024
MAX_DOT_GRAPH_HEIGHT = 1024
MAX_DOT_GRAPH_DEPTH = 1000
DOT_TRANSPARENT = NO
DOT_MULTI_TARGETS = NO
GENERATE_LEGEND = NO
DOT_CLEANUP = YES
#---------------------------------------------------------------------------
#External reference options
#---------------------------------------------------------------------------
GENERATE_TAGFILE = smeshpy_doc.tag
SEARCHENGINE = YES
#---------------------------------------------------------------------------
#Custom commands
#---------------------------------------------------------------------------
ALIASES += tui_script{1}="\include \1 <a href=\"../../examples/SMESH/\1\">Download this script</a>"

370
doc/salome/gui/SMESH/input/1d_meshing_hypo.doc
View File

@ -1,370 +0,0 @@
/*!
\page a1d_meshing_hypo_page 1D Meshing Hypotheses
Basic 1D hypothesis specifies:
<ul>
<li>how \ref a1d_algos_anchor "Wire Discretization" should divide the edge;</li>
<li>how \ref a1d_algos_anchor "Composite Side Discretization" should divide the group of C1-continuous edges.</li>
</ul>
1D hypotheses can be categorized by type of nodes distribution as follows:
<ul>
<li>Uniform distribution:
<ul>
<li>\ref average_length_anchor "Local Length"</li>
<li>\ref max_length_anchor "Max Size"</li>
<li>\ref number_of_segments_anchor "Number of Segments" with Equidistant distribution</li>
<li>\ref automatic_length_anchor "Automatic Length"</li>
</ul></li>
<li>Constantly increasing or decreasing length of segments:
<ul>
<li>\ref arithmetic_1d_anchor "Arithmetic Progression"</li>
<li>\ref geometric_1d_anchor "Geometric Progression"</li>
<li>\ref start_and_end_length_anchor "Start and end length"</li>
<li>\ref number_of_segments_anchor "Number of Segments" with Scale distribution</li>
</ul></li>
<li>Distribution depending on curvature:
<ul>
<li>\ref adaptive_1d_anchor "Adaptive"</li>
<li>\ref deflection_1d_anchor "Deflection"</li>
</ul></li>
<li>Arbitrary distribution:
<ul>
<li>\ref fixed_points_1d_anchor "Fixed Points"</li>
<li>\ref number_of_segments_anchor "Number of Segments" with
\ref analyticdensity_anchor "Analytic Density Distribution" or Table Density Distribution</li>
</ul></li>
</ul>
<br>
\anchor adaptive_1d_anchor
<h2>Adaptive hypothesis</h2>
<b>Adaptive</b> hypothesis allows to split edges into segments with a
length that depends on the curvature of edges and faces and is limited by <b>Min. Size</b>
and <b>Max Size</b>. The length of a segment also depends on the lengths
of adjacent segments (that can't differ more than twice) and on the
distance to close geometrical entities (edges and faces) to avoid
creation of narrow 2D elements.
\image html adaptive1d.png
- <b>Min size</b> parameter limits the minimal segment size.
- <b>Max size</b> parameter defines the length of segments on straight edges.
- \b Deflection parameter gives maximal distance of a segment from a curved edge.
\image html adaptive1d_sample_mesh.png "Adaptive hypothesis and NETGEN 2D algorithm - the size of mesh segments reflects the size of geometrical features"
<b>See Also</b> a \ref tui_1d_adaptive "sample TUI Script" that uses Adaptive hypothesis.
<br>
\anchor arithmetic_1d_anchor
<h2>Arithmetic Progression hypothesis</h2>
<b>Arithmetic Progression</b> hypothesis allows to split edges into segments with a
length that changes in arithmetic progression (Lk = Lk-1 + d)
beginning from a given starting length and up to a given end length.
The splitting direction is defined by the orientation of the
underlying geometrical edge.
<b>Reverse Edges</b> list box allows specifying the edges, for which
the splitting should be made in the direction opposite to their
orientation. This list box is usable only if a geometry object is
selected for meshing. In this case it is possible to select edges to
be reversed either directly picking them in the 3D viewer or by
selecting the edges or groups of edges in the Object Browser. Use \b
Add button to add the selected edges to the list.
\ref reversed_edges_helper_anchor "Helper" group assists you in
defining <b>Reversed Edges</b> parameter.
\image html a-arithmetic1d.png
\image html b-ithmetic1d.png "Arithmetic Progression hypothesis - the size of mesh elements gradually increases"
<b>See Also</b> a sample TUI Script of a
\ref tui_1d_arithmetic "Defining Arithmetic Progression and Geometric Progression hypothesis" operation.
<br>
\anchor geometric_1d_anchor
<h2>Geometric Progression hypothesis</h2>
<b>Geometric Progression</b> hypothesis allows splitting edges into
segments with a length that changes in geometric progression (Lk =
Lk-1 * d) starting from a given <b>Start Length</b> and with a given
<b>Common Ratio</b>.
The splitting direction is defined by the orientation of the
underlying geometrical edge.
<b>Reverse Edges</b> list box allows specifying the edges, for which
the splitting should be made in the direction opposite to their
orientation. This list box is usable only if a geometry object is
selected for meshing. In this case it is possible to select edges to
be reversed either directly picking them in the 3D viewer or by
selecting the edges or groups of edges in the Object Browser. Use \b
Add button to add the selected edges to the list.
\ref reversed_edges_helper_anchor "Helper" group assists you in
defining <b>Reversed Edges</b> parameter.
\image html a-geometric1d.png
<b>See Also</b> a sample TUI Script of a
\ref tui_1d_arithmetic "Defining Arithmetic Progression and Geometric Progression hypothesis" operation.
<br>
\anchor deflection_1d_anchor
<h2>Deflection hypothesis</h2>
<b>Deflection</b> hypothesis can be applied for meshing curvilinear edges
composing your geometrical object. It defines only one parameter: the
value of deflection (or chord error).
A geometrical edge is divided into segments of length depending on
edge curvature. The more curved the edge, the shorter the
segment. Nodes on the edge are placed so that the maximum distance
between the edge and a segment approximating a part of edge between
two nodes should not exceed the value of deflection.
\image html a-deflection1d.png
\image html b-flection1d.png "Deflection hypothesis - useful for meshing curvilinear edges"
<b>See Also</b> a sample TUI Script of a
\ref tui_deflection_1d "Defining Deflection hypothesis" operation.
<br>
\anchor average_length_anchor
<h2>Local Length hypothesis</h2>
<b>Local Length</b> hypothesis can be applied for meshing of edges
composing your geometrical object. Definition of this hypothesis
consists of setting the \b length of segments, which will approximate these
edges, and the \b precision of rounding.
The \b precision parameter is used to round a <em>number of segments</em>,
calculated by dividing the <em>edge length</em> by the specified \b length of
segment, to the higher integer if the \a remainder exceeds the \b precision
and to the lower integer otherwise. <br>
Use value 0.5 to provide rounding to the nearest integer, 1.0 for the lower integer, 0.0 for the higher integer. Default value is 1e-07.
For example: if <em>edge length</em> is 10.0 and the segment \b length
is 3.0 then their division gives 10./3. = 3.33(3) and the \a remainder is 0.33(3).
If \b precision is less than 0.33(3) then the edge is divided into 3 segments.
If \b precision is more than 0.33(3) then the edge is divided into 4 segments.
\image html image41.gif
\image html a-averagelength.png
\image html b-erage_length.png "Local Length hypothesis - all 1D mesh segments are equal"
<b>See Also</b> a sample TUI Script of a
\ref tui_average_length "Defining Local Length" hypothesis
operation.
<br>\anchor max_length_anchor
<h2>Max Size</h2>
<b>Max Size</b> hypothesis allows splitting geometrical edges into
segments not longer than the given length. Definition of this hypothesis
consists of setting the maximal allowed \b length of segments.
<b>Use preestimated length</b> check box lets you use \b length
automatically calculated basing on size of your geometrical object,
namely as diagonal of bounding box divided by ten. The divider can be
changed via \ref diagonal_size_ratio_pref "Ratio Bounding Box Diagonal / Max Size"
preference parameter.
<b>Use preestimated length</b> check box is enabled only if the
geometrical object has been selected before hypothesis definition.
\image html a-maxsize1d.png
<br>
\anchor number_of_segments_anchor
<h2>Number of Segments hypothesis</h2>
<b>Number of Segments</b> hypothesis can be applied for approximating
edges by a definite number of mesh segments with length depending on
the selected type of distribution of nodes. The default number of
segments can be set via
\ref nb_segments_pref "Automatic Parameters / Default Number of Segments"
preference parameter.
The direction of the splitting is defined by the orientation of the
underlying geometrical edge. <b>Reverse Edges</b> list box allows to
specify the edges for which the splitting should be made in the
direction opposing to their orientation. This list box is enabled only
if the geometry object is selected for the meshing. In this case it is
possible to select edges to be reversed either by directly picking them
in the 3D viewer or by selecting the edges or groups of edges in the
Object Browser.
\ref reversed_edges_helper_anchor "Helper" group assists you in
defining <b>Reversed Edges</b> parameter.
You can set the type of node distribution for this hypothesis in the
<b>Hypothesis Construction</b> dialog bog :
\image html a-nbsegments1.png
<br><b>Equidistant Distribution</b> - all segments will have the same
length, you define only the <b>Number of Segments</b>.
<br><b>Scale Distribution</b> - length of segments gradually changes
depending on the <b>Scale Factor</b>, which is a ratio of the first
segment length to the last segment length.<br>
Length of segments changes in geometric progression with the common
ratio (A) depending on the <b>Scale Factor</b> (S) and <b>Number of
Segments</b> (N) as follows: <code> A = S**(1/(N-1))</code>. For an
edge of length L, length of the first segment is
<code>L * (1 - A)/(1 - A**N)</code>.
\image html a-nbsegments2.png
<br><b>Distribution with Analytic Density</b> - you input the formula,
which will rule the change of length of segments and the module shows
in the plot the density function curve in red and the node
distribution as blue crosses.
\image html distributionwithanalyticdensity.png
<br>
\anchor analyticdensity_anchor
The node distribution is computed so that to have the density function
integral on the range between two nodes equal for all segments.
\image html analyticdensity.png
<br><b>Distribution with Table Density</b> - you input a number of
pairs <b>t - F(t)</b>, where \b t ranges from 0 to 1, and the module computes the
formula, which will rule the change of length of segments and shows
in the plot the density function curve in red and the node
distribution as blue crosses. The node distribution is computed in the
same way as for
\ref analyticdensity_anchor "Distribution with Analytic Density". You
can select the <b>Conversion mode</b> from \b Exponent and <b>Cut
negative</b>.
\image html distributionwithtabledensity.png
<b>See Also</b> a sample TUI Script of a
\ref tui_deflection_1d "Defining Number of Segments" hypothesis
operation.
\note The plot functionality is available only if GUI module is built with Plot 2D Viewer (option SALOME_USE_PLOT2DVIEWER is ON when building GUI module).
<br>
\anchor start_and_end_length_anchor
<h2>Start and End Length hypothesis</h2>
<b>Start and End Length</b> hypothesis allows to divide a geometrical edge
into segments so that the first and the last segments have a specified
length. The length of medium segments changes with automatically chosen
geometric progression.
The direction of the splitting is defined by the orientation of the
underlying geometrical edge. <b>Reverse Edges</b> list box allows to
specify the edges, for which the splitting should be made in the
direction opposing to their orientation. This list box is enabled only
if the geometry object is selected for the meshing. In this case it is
possible to select edges to be reversed either by directly picking them
in the 3D viewer or by selecting the edges or groups of edges in the
Object Browser.
\ref reversed_edges_helper_anchor "Helper" group assists you in
defining <b>Reversed Edges</b> parameter.
\image html a-startendlength.png
\image html b-art_end_length.png "The lengths of the first and the last segment are strictly defined"
<b>See Also</b> a sample TUI Script of a
\ref tui_start_and_end_length "Defining Start and End Length"
hypothesis operation.
<br>
\anchor automatic_length_anchor
<h2>Automatic Length</h2>
The dialog box prompts you to define the quality of the future mesh by
only one parameter, which is \b Fineness, ranging from 0 (coarse mesh,
low number of segments) to 1 (extremely fine mesh, great number of
segments).
\image html automaticlength.png
Compare one and the same object (sphere) meshed with
minimum and maximum value of this parameter.
\image html image147.gif "Example of a rough mesh at Automatic Length Fineness of 0."
\image html image148.gif "Example of a fine mesh at Automatic Length Fineness of 1."
<br>
\anchor fixed_points_1d_anchor
<h2>Fixed Points hypothesis</h2>
<b>Fixed Points</b> hypothesis allows splitting edges through a
set of points parametrized on the edge (from 1 to 0) and a number of
segments for each interval limited by the points.
\image html hypo_fixedpnt_dlg.png
It is possible to check in <b>Same Nb. Segments for all intervals</b>
option and to define one value for all intervals.
The splitting direction is defined by the orientation of the
underlying geometrical edge. <b>Reverse Edges</b> list box allows to
specify the edges for which the splitting should be made in the
direction opposite to their orientation. This list box is enabled only
if the geometrical object is selected for meshing. In this case it is
possible to select the edges to be reversed either directly picking them in
the 3D viewer or selecting the edges or groups of edges in the
Object Browser.
\ref reversed_edges_helper_anchor "Helper" group assists in
defining <b>Reversed Edges</b> parameter.
\image html mesh_fixedpnt.png "Example of a sub-mesh on the edge built using Fixed Points hypothesis"
<b>See Also</b> a sample TUI Script of a
\ref tui_fixed_points "Defining Fixed Points" hypothesis operation.
\anchor reversed_edges_helper_anchor
<h2>Reversed Edges Helper</h2>
\image html rev_edges_helper_dlg.png
\b Helper group assists in defining <b>Reversed Edges</b>
parameter of the hypotheses depending on edge direction.
<b>Show whole geometry</b> check-box allows seeing the whole
geometrical model in the 3D Viewer, which can help to understand the
location of a set of edges within the model.
<b>Propagation chains</b> group allows defining <b>Reversed Edges</b>
for splitting opposite edges of quadrilateral faces in a logically
uniform direction. When this group is activated, the list is filled
with propagation chains found within the shape on which a hypothesis
is assigned. When a chain is selected in the list its edges are shown
in the Viewer with arrows, which enables choosing a common direction
for all chain edges. \b Reverse button inverts the common direction of
chain edges. \b Add button is active if some edges of a chain have a
different direction, so you can click \b Add button to add them
to <b>Reversed Edges</b> list.
\image html propagation_chain.png "The whole geometry and a propagation chain"
\note Alternatively, uniform direction of edges of one propagation
chain can be achieved by
\ref constructing_submeshes_page "definition of a sub-mesh" on one
edge of the chain and assigning a
\ref propagation_anchor "Propagation" additional hypothesis.
Orientation of this edge (and hence of all the rest edges of the chain) can be
controlled by using <b>Reversed Edges</b> field.
*/

315
doc/salome/gui/SMESH/input/1d_meshing_hypo.rst Normal file
View File

@ -0,0 +1,315 @@
.. _a1d_meshing_hypo_page:
*********************
1D Meshing Hypotheses
*********************
Basic 1D hypothesis specifies:
* how a :ref:`a1d_algos_anchor` should divide the edge;
* how a :ref:`a1d_algos_anchor` should divide the group of C1-continuous edges.
1D hypotheses can be categorized by type of nodes distribution as follows:
* Uniform distribution:
* :ref:`average_length_anchor`
* :ref:`max_length_anchor`
* :ref:`number_of_segments_anchor` with Equidistant distribution
* :ref:`automatic_length_anchor`
* Constantly increasing or decreasing length of segments:
* :ref:`arithmetic_1d_anchor`
* :ref:`geometric_1d_anchor`
* :ref:`start_and_end_length_anchor`
* :ref:`number_of_segments_anchor` with Scale distribution
* Distribution depending on curvature:
* :ref:`adaptive_1d_anchor`
* :ref:`deflection_1d_anchor`
* Arbitrary distribution:
* :ref:`fixed_points_1d_anchor`
* :ref:`number_of_segments_anchor` "Number of Segments" with :ref:`analyticdensity_anchor` or Table Density Distribution
.. _adaptive_1d_anchor:
Adaptive hypothesis
###################
**Adaptive** hypothesis allows to split edges into segments with a length that depends on the curvature of edges and faces and is limited by **Min. Size** and **Max Size**. The length of a segment also depends on the lengths of adjacent segments (that can't differ more than twice) and on the distance to close geometrical entities (edges and faces) to avoid creation of narrow 2D elements.
.. image:: ../images/adaptive1d.png
:align: center
* **Min size** parameter limits the minimal segment size.
* **Max size** parameter defines the length of segments on straight edges.
* **Deflection** parameter gives maximal distance of a segment from a curved edge.
.. image:: ../images/adaptive1d_sample_mesh.png
:align: center
.. centered::
Adaptive hypothesis and NETGEN 2D algorithm - the size of mesh segments reflects the size of geometrical features
**See Also** a :ref:`tui_1d_adaptive` that uses Adaptive hypothesis.
.. _arithmetic_1d_anchor:
Arithmetic Progression hypothesis
#################################
**Arithmetic Progression** hypothesis allows to split edges into segments with a length that changes in arithmetic progression (Lk = Lk-1 + d) beginning from a given starting length and up to a given end length.
The splitting direction is defined by the orientation of the underlying geometrical edge. **Reverse Edges** list box allows specifying the edges, for which the splitting should be made in the direction opposite to their orientation. This list box is usable only if a geometry object is selected for meshing. In this case it is possible to select edges to be reversed either directly picking them in the 3D viewer or by selecting the edges or groups of edges in the Object Browser. Use
**Add** button to add the selected edges to the list.
:ref:`reversed_edges_helper_anchor` group assists you in defining **Reversed Edges** parameter.
.. image:: ../images/a-arithmetic1d.png
:align: center
.. image:: ../images/b-ithmetic1d.png
:align: center
.. centered::
"Arithmetic Progression hypothesis - the size of mesh elements gradually increases"
**See Also** a sample TUI Script of a :ref:`tui_1d_arithmetic` operation.
.. _geometric_1d_anchor:
Geometric Progression hypothesis
################################
**Geometric Progression** hypothesis allows splitting edges into segments with a length that changes in geometric progression (Lk = Lk-1 * d) starting from a given **Start Length** and with a given **Common Ratio**.
The splitting direction is defined by the orientation of the underlying geometrical edge.
**Reverse Edges** list box allows specifying the edges, for which the splitting should be made in the direction opposite to their orientation. This list box is usable only if a geometry object is selected for meshing. In this case it is possible to select edges to be reversed either directly picking them in the 3D viewer or by selecting the edges or groups of edges in the Object Browser. Use **Add** button to add the selected edges to the list.
:ref:'reversed_edges_helper_anchor' group assists you in
defining **Reversed Edges** parameter.
.. image:: ../images/a-geometric1d.png
:align: center
**See Also** a sample TUI Script of a :ref:`tui_1d_arithmetic` operation.
.. _deflection_1d_anchor:
Deflection hypothesis
#####################
**Deflection** hypothesis can be applied for meshing curvilinear edges composing your geometrical object. It defines only one parameter: the value of deflection (or chord error).
A geometrical edge is divided into segments of length depending on edge curvature. The more curved the edge, the shorter the segment. Nodes on the edge are placed so that the maximum distance between the edge and a segment approximating a part of edge between two nodes should not exceed the value of deflection.
.. image:: ../images/a-deflection1d.png
:align: center
.. image:: ../images/b-flection1d.png
:align: center
.. centered::
"Deflection hypothesis - useful for meshing curvilinear edges"
**See Also** a sample TUI Script of a :ref:`tui_deflection_1d` operation.
.. _average_length_anchor:
Local Length hypothesis
#######################
**Local Length** hypothesis can be applied for meshing of edges composing your geometrical object. Definition of this hypothesis consists of setting the **length** of segments, which will approximate these edges, and the **precision** of rounding.
The **precision** parameter is used to round a *number of segments*, calculated by dividing the *edge length* by the specified **length** of segment, to the higher integer if the *remainder* exceeds the **precision** and to the lower integer otherwise.
Use value 0.5 to provide rounding to the nearest integer, 1.0 for the lower integer, 0.0 for the higher integer. Default value is 1e-07.
For example: if *edge length* is 10.0 and the segment **length**
is 3.0 then their division gives 10./3. = 3.33(3) and the *remainder* is 0.33(3).
If **precision** is less than 0.33(3) then the edge is divided into 3 segments.
If **precision** is more than 0.33(3) then the edge is divided into 4 segments.
.. image:: ../images/image41.gif
:align: center
.. image:: ../images/a-averagelength.png
:align: center
.. image:: ../images/b-erage_length.png
:align: center
.. centered::
"Local Length hypothesis - all 1D mesh segments are equal"
**See Also** a sample TUI Script of a :ref:`tui_average_length` hypothesis
operation.
.. _max_length_anchor:
Max Size
########
**Max Size** hypothesis allows splitting geometrical edges into segments not longer than the given length. Definition of this hypothesis consists of setting the maximal allowed **length** of segments.
**Use preestimated length** check box lets you use **length** automatically calculated basing on size of your geometrical object, namely as diagonal of bounding box divided by ten. The divider can be changed via :ref:`diagonal_size_ratio_pref` preference parameter.
**Use preestimated length** check box is enabled only if the geometrical object has been selected before hypothesis definition.
.. image:: ../images/a-maxsize1d.png
:align: center
.. _number_of_segments_anchor:
Number of Segments hypothesis
#############################
**Number of Segments** hypothesis can be applied for approximating edges by a definite number of mesh segments with length depending on the selected type of distribution of nodes. The default number of segments can be set via :ref:`nb_segments_pref` preference parameter.
The direction of the splitting is defined by the orientation of the underlying geometrical edge. **Reverse Edges** list box allows to specify the edges for which the splitting should be made in the direction opposing to their orientation. This list box is enabled only if the geometry object is selected for the meshing. In this case it is possible to select edges to be reversed either by directly picking them in the 3D viewer or by selecting the edges or groups of edges in the Object Browser.
:ref:`reversed_edges_helper_anchor` group assists you in defining **Reversed Edges** parameter.
You can set the type of node distribution for this hypothesis in the **Hypothesis Construction** dialog bog :
.. image:: ../images/a-nbsegments1.png
:align: center
**Equidistant Distribution** - all segments will have the same length, you define only the **Number of Segments**.
**Scale Distribution** - length of segments gradually changes depending on the **Scale Factor**, which is a ratio of the first segment length to the last segment length.
Length of segments changes in geometric progression with the common ratio (A) depending on the **Scale Factor** (S) and **Number of Segments** (N) as follows: <code> A = S**(1/(N-1))</code>. For an edge of length L, length of the first segment is
::
L * (1 - A)/(1 - A**N)
.. image:: ../images/a-nbsegments2.png
:align: center
**Distribution with Analytic Density** - you input the formula, which will rule the change of length of segments and the module shows in the plot the density function curve in red and the nodedistribution as blue crosses.
.. image:: ../images/distributionwithanalyticdensity.png
:align: center
.. _analyticdensity_anchor:
Analytic Density
================
The node distribution is computed so that to have the density function integral on the range between two nodes equal for all segments.
.. image:: ../images/analyticdensity.png
:align: center
**Distribution with Table Density** - you input a number of pairs **t - F(t)**, where **t** ranges from 0 to 1, and the module computes the formula, which will rule the change of length of segments and shows in the plot the density function curve in red and the node distribution as blue crosses. The node distribution is computed in the same way as for :ref:`analyticdensity_anchor`. You can select the **Conversion mode** from **Exponent** and **Cut negative**.
.. image:: ../images/distributionwithtabledensity.png
:align: center
**See Also** a sample TUI Script of a :ref:`tui_deflection_1d` hypothesis operation.
.. The plot functionality is available only if GUI module is built with Plot 2D Viewer (option SALOME_USE_PLOT2DVIEWER is ON when building GUI module).
.. _start_and_end_length_anchor:
Start and End Length hypothesis
###############################
**Start and End Length** hypothesis allows to divide a geometrical edge into segments so that the first and the last segments have a specified length. The length of medium segments changes with automatically chosen geometric progression.
The direction of the splitting is defined by the orientation of the underlying geometrical edge. **Reverse Edges** list box allows to specify the edges, for which the splitting should be made in the direction opposing to their orientation. This list box is enabled only if the geometry object is selected for the meshing. In this case it is possible to select edges to be reversed either by directly picking them in the 3D viewer or by selecting the edges or groups of edges in the Object Browser.
:ref:`reversed_edges_helper_anchor` group assists you in defining **Reversed Edges** parameter.
.. image:: ../images/a-startendlength.png
:align: center
.. image:: ../images/b-art_end_length.png
:align: center
.. centered::
"The lengths of the first and the last segment are strictly defined"
**See Also** a sample TUI Script of a :ref:`tui_start_and_end_length` hypothesis operation.
.. _automatic_length_anchor:
Automatic Length
################
The dialog box prompts you to define the quality of the future mesh by only one parameter, which is **Fineness**, ranging from 0 (coarse mesh, low number of segments) to 1 (extremely fine mesh, great number of segments).
.. image:: ../images/automaticlength.png
:align: center
Compare one and the same object (sphere) meshed with minimum and maximum value of this parameter.
.. image:: ../images/image147.gif
:align: center
.. centered::
"Example of a rough mesh at Automatic Length Fineness of 0."
.. image:: ../images/image148.gif
:align: center
.. centered::
"Example of a fine mesh at Automatic Length Fineness of 1."
.. _fixed_points_1d_anchor:
Fixed Points hypothesis
#######################
**Fixed Points** hypothesis allows splitting edges through a set of points parametrized on the edge (from 1 to 0) and a number of segments for each interval limited by the points.
.. image:: ../images/hypo_fixedpnt_dlg.png
:align: center
It is possible to check in **Same Nb. Segments for all intervals** option and to define one value for all intervals.
The splitting direction is defined by the orientation of the underlying geometrical edge. **Reverse Edges** list box allows to specify the edges for which the splitting should be made in the direction opposite to their orientation. This list box is enabled only if the geometrical object is selected for meshing. In this case it is possible to select the edges to be reversed either directly picking them in the 3D viewer or selecting the edges or groups of edges in the Object Browser.
:ref:`reversed_edges_helper_anchor` group assists in defining **Reversed Edges** parameter.
.. image:: ../images/mesh_fixedpnt.png
:align: center
.. centered::
"Example of a sub-mesh on the edge built using Fixed Points hypothesis"
**See Also** a sample TUI Script of a :ref:`tui_fixed_points` hypothesis operation.
.. _reversed_edges_helper_anchor:
Reversed Edges Helper
#####################
.. image:: ../images/rev_edges_helper_dlg.png
:align: center
**Helper** group assists in defining **Reversed Edges** parameter of the hypotheses depending on edge direction.
**Show whole geometry** check-box allows seeing the whole geometrical model in the 3D Viewer, which can help to understand the location of a set of edges within the model.
**Propagation chains** group allows defining **Reversed Edges** for splitting opposite edges of quadrilateral faces in a logically uniform direction. When this group is activated, the list is filled with propagation chains found within the shape on which a hypothesis is assigned. When a chain is selected in the list its edges are shown in the Viewer with arrows, which enables choosing a common direction for all chain edges. **Reverse** button inverts the common direction of chain edges. **Add** button is active if some edges of a chain have a different direction, so you can click **Add** button to add them to **Reversed Edges** list.
.. image:: ../images/propagation_chain.png
:align: center
.. centered::
"The whole geometry and a propagation chain"
.. note::
Alternatively, uniform direction of edges of one propagation chain can be achieved by :ref:`constructing_submeshes_page` on one edge of the chain and assigning a :ref:`propagation_anchor` additional hypothesis. Orientation of this edge (and hence of all the rest edges of the chain) can be controlled by using **Reversed Edges** field.

146
doc/salome/gui/SMESH/input/2d_meshing_hypo.doc
View File

@ -1,146 +0,0 @@
/*!
\page a2d_meshing_hypo_page 2D Meshing Hypotheses
- \ref max_element_area_anchor "Max Element Area"
- \ref length_from_edges_anchor "Length from Edges"
- \ref hypo_quad_params_anchor "Quadrangle parameters"
\anchor max_element_area_anchor
<h2>Max Element Area</h2>
<b>Max Element Area</b> hypothesis is applied for meshing of faces
composing your geometrical object. Definition of this hypothesis
consists of setting the <b>maximum area</b> of mesh faces,
which will compose the mesh of these faces.
\image html a-maxelarea.png
\n
\image html max_el_area.png "In this example, Max. element area is very small compared to the 1D hypothesis"
<b>See Also</b> a sample TUI Script of a
\ref tui_max_element_area "Maximum Element Area" hypothesis operation.
\anchor length_from_edges_anchor
<h2>Length from Edges</h2>
<b>Length from edges</b> hypothesis defines the maximum linear size of
mesh faces as an average length of mesh edges approximating
the meshed face boundary.
<b>See Also</b> a sample TUI Script of a
\ref tui_length_from_edges "Length from Edges" hypothesis operation.
\anchor hypo_quad_params_anchor
<h2>Quadrangle parameters</h2>
\image html hypo_quad_params_dialog.png "Quadrangle parameters: Transition"
<b>Quadrangle parameters</b> is a hypothesis for \ref quad_ijk_algo_page.
<b>Transition</b> tab is used to define the algorithm of transition
between opposite sides of the face with a different number of
segments on them. The following types of transition
algorithms are available:
- <b>Standard</b> is the default case, when both triangles and quadrangles
are possible in the transition area along the finer meshed sides.
- <b>Triangle preference</b> forces building only triangles in the
transition area along the finer meshed sides.
\note This type corresponds to <b>Triangle Preference</b> additional hypothesis,
which is obsolete now.
- <b>Quadrangle preference</b> forces building only quadrangles in the
transition area along the finer meshed sides. This hypothesis has a
restriction: the total quantity of segments on all
four face sides must be even (divisible by 2).
\note This type corresponds to <b>Quadrangle Preference</b> additional hypothesis,
which is obsolete now.
- <b>Quadrangle preference (reversed)</b> works in the same way and
with the same restriction as <b>Quadrangle preference</b>, but
the transition area is located along the coarser meshed sides.
- <b>Reduced</b> type forces building only quadrangles and the transition
between the sides is made gradually, layer by layer. This type has
a limitation on the number of segments: one pair of opposite sides must have
the same number of segments, the other pair must have an even total
number of segments. In addition, the number of rows
between sides with different discretization
should be enough for the transition. Following the fastest transition
pattern, three segments become one (see the image below), hence
the least number of face rows needed to reduce from Nmax segments
to Nmin segments is log<sub>3</sub>( Nmax / Nmin ). The number of
face rows is equal to the number of segments on each of equally
discretized sides.
\image html reduce_three_to_one.png "The fastest transition pattern: 3 to 1"
<b>Base vertex</b> tab allows using Quadrangle: Mapping
algorithm for meshing of trilateral faces. In this case it is
necessary to select the vertex, which will be used as the forth
degenerated side of quadrangle.
\image html hypo_quad_params_dialog_vert.png "Quadrangle parameters: Base Vertex"
\image html hypo_quad_params_1.png "A face built from 3 edges"
\image html hypo_quad_params_res.png "The resulting mesh"
This parameter can be also used to mesh a segment of a circular face.
Please, consider that there is a limitation on the selection of the
vertex for the faces built with the angle > 180 degrees (see the picture).
\image html hypo_quad_params_2.png "3/4 of a circular face"
In this case, selection of a wrong vertex for the <b>Base vertex</b>
parameter will generate a wrong mesh. The picture below
shows the good (left) and the bad (right) results of meshing.
\image html hypo_quad_params_res_2.png "The resulting meshes"
\image html hypo_quad_params_dialog_enf.png "Quadrangle parameters: Enforced nodes"
<b>Enforced nodes</b> tab allows defining points, where the
algorithm should create nodes. There are two ways to define positions
of the enforced nodes.
<ul>
<li>\b Vertices group allows to set up shapes whose vertices will
define positions of the enforced nodes. Only vertices successfully
projected to the meshed face and located close enough to the
meshed face will be used to create the enforced nodes.</li>
<li> \b Points group allows to explicitly define coordinates of
points used to create the enforced nodes. Only points successfully
projected to the meshed face and located close enough to the
meshed face will be used to create the enforced nodes.</li>
</ul>
\note <b>Enforced nodes</b> cannot be created at \b Reduced transition type.
Let us see how the algorithm works:
<ul>
<li> Initially positions of nodes are computed without taking into
account the enforced vertex (yellow point).</li>
\image html hypo_quad_params_enfnodes_algo1.png "Initial mesh"
<li> Then the node closest to the enforced vertex is
detected. Extreme nodes of the row and column of the detected node
are used to create virtual edges (yellow lines) ending at the
enforced vertex. </li>
\image html hypo_quad_params_enfnodes_algo2.png "Creation of virtual edges"
<li> Consequently, the meshed face is divided by the virtual
edges into four quadrilateral sub-domains each of which is meshed
as usually: the nodes of the row and column of the detected node are
moved to the virtual edges and the quadrilateral elements are
constructed.
\image html hypo_quad_params_enfnodes_algo3.png "Final mesh"
</ul>
If there are several enforced vertices, the algorithm is applied
recursively to the formed sub-domains.
<b>See Also</b> a sample TUI Script of a
\ref tui_quadrangle_parameters "Quadrangle Parameters" hypothesis.
<br>
*/

153
doc/salome/gui/SMESH/input/2d_meshing_hypo.rst Normal file
View File

@ -0,0 +1,153 @@
.. _a2d_meshing_hypo_page:
*********************
2D Meshing Hypotheses
*********************
- :ref:`max_element_area_anchor`
- :ref:`length_from_edges_anchor`
- :ref:`hypo_quad_params_anchor`
.. _max_element_area_anchor:
Max Element Area
################
**Max Element Area** hypothesis is applied for meshing of faces composing your geometrical object. Definition of this hypothesis consists of setting the **maximum area** of mesh faces, which will compose the mesh of these faces.
.. image:: ../images/a-maxelarea.png
:align: center
|
.. image:: ../images/max_el_area.png
:align: center
.. centered::
"In this example, Max. element area is very small compared to the 1D hypothesis"
**See Also** a sample TUI Script of a :ref:`tui_max_element_area` hypothesis operation.
.. _length_from_edges_anchor:
Length from Edges
#################
**Length from edges** hypothesis defines the maximum linear size of mesh faces as an average length of mesh edges approximating the meshed face boundary.
**See Also** a sample TUI Script of a :ref:`tui_length_from_edges` hypothesis operation.
.. _hypo_quad_params_anchor:
Quadrangle parameters
#####################
.. image:: ../images/ hypo_quad_params_dialog.png
:align: center
.. centered::
"Quadrangle parameters: Transition"
**Quadrangle parameters** is a hypothesis for :ref:`quad_ijk_algo_page`.
**Transition** tab is used to define the algorithm of transition between opposite sides of the face with a different number of segments on them. The following types of transition algorithms are available:
* **Standard** is the default case, when both triangles and quadrangles are possible in the transition area along the finer meshed sides.
* **Triangle preference** forces building only triangles in the transition area along the finer meshed sides.
.. note::
This type corresponds to **Triangle Preference** additional hypothesis, which is obsolete now.
* **Quadrangle preference** forces building only quadrangles in the transition area along the finer meshed sides. This hypothesis has a restriction: the total quantity of segments on all four face sides must be even (divisible by 2).
.. note::
This type corresponds to **Quadrangle Preference** additional hypothesis, which is obsolete now.
* **Quadrangle preference (reversed)** works in the same way and with the same restriction as **Quadrangle preference**, but the transition area is located along the coarser meshed sides.
* **Reduced** type forces building only quadrangles and the transition between the sides is made gradually, layer by layer. This type has a limitation on the number of segments: one pair of opposite sides must have the same number of segments, the other pair must have an even total number of segments. In addition, the number of rows between sides with different discretization should be enough for the transition. Following the fastest transition pattern, three segments become one (see the image below), hence the least number of face rows needed to reduce from Nmax segments to Nmin segments is log<sub>3</sub>( Nmax / Nmin ). The number of face rows is equal to the number of segments on each of equally discretized sides.
.. image:: ../images/ reduce_three_to_one.png
:align: center
.. centered::
"The fastest transition pattern: 3 to 1"
**Base vertex** tab allows using Quadrangle: Mapping algorithm for meshing of trilateral faces. In this case it is necessary to select the vertex, which will be used as the forth degenerated side of quadrangle.
.. image:: ../images/ hypo_quad_params_dialog_vert.png
:align: center
.. centered::
"Quadrangle parameters: Base Vertex"
.. image:: ../images/ hypo_quad_params_1.png
:align: center
.. centered::
"A face built from 3 edges"
.. image:: ../images/ hypo_quad_params_res.png
:align: center
.. centered::
"The resulting mesh"
This parameter can be also used to mesh a segment of a circular face. Please, consider that there is a limitation on the selection of the vertex for the faces built with the angle > 180 degrees (see the picture).
.. image:: ../images/ hypo_quad_params_2.png
:align: center
.. centered::
"3/4 of a circular face"
In this case, selection of a wrong vertex for the **Base vertex** parameter will generate a wrong mesh. The picture below shows the good (left) and the bad (right) results of meshing.
.. image:: ../images/ hypo_quad_params_res_2.png
:align: center
.. centered::
"The resulting meshes"
.. image:: ../images/ hypo_quad_params_dialog_enf.png
:align: center
.. centered::
"Quadrangle parameters: Enforced nodes"
**Enforced nodes** tab allows defining points, where the algorithm should create nodes. There are two ways to define positions of the enforced nodes.
* **Vertices** group allows to set up shapes whose vertices will define positions of the enforced nodes. Only vertices successfully projected to the meshed face and located close enough to the meshed face will be used to create the enforced nodes.
* **Points** group allows to explicitly define coordinates of points used to create the enforced nodes. Only points successfully projected to the meshed face and located close enough to the meshed face will be used to create the enforced nodes.
.. note::
**Enforced nodes** cannot be created at **Reduced** transition type.
Let us see how the algorithm works:
* Initially positions of nodes are computed without taking into account the enforced vertex (yellow point).
.. image:: ../images/ hypo_quad_params_enfnodes_algo1.png
:align: center
.. centered::
"Initial mesh"
* Then the node closest to the enforced vertex is detected. Extreme nodes of the row and column of the detected node are used to create virtual edges (yellow lines) ending at the enforced vertex.
.. image:: ../images/ hypo_quad_params_enfnodes_algo2.png
:align: center
.. centered::
"Creation of virtual edges"
* Consequently, the meshed face is divided by the virtual edges into four quadrilateral sub-domains each of which is meshed as usually: the nodes of the row and column of the detected node are moved to the virtual edges and the quadrilateral elements are constructed.
.. image:: ../images/ hypo_quad_params_enfnodes_algo3.png
:align: center
.. centered::
"Final mesh"
If there are several enforced vertices, the algorithm is applied recursively to the formed sub-domains.
**See Also** a sample TUI Script of a :ref:`tui_quadrangle_parameters` hypothesis.

35
doc/salome/gui/SMESH/input/about_filters.doc
View File

@ -1,35 +0,0 @@
/*!
\page filters_page About filters
\b Filters allow picking only the mesh elements satisfying to a
specific condition or a set of conditions. Filters can be used to create
or edit mesh groups, remove elements from the mesh, control
mesh quality by different parameters, etc.
Several \ref filtering_criteria "filtering criteria" can be combined
together by using logical operators \a AND and \a OR. In addition, a
filter criterion can be reverted using logical operator \a NOT.
Some filtering criteria use the functionality of \ref quality_page
"mesh quality controls" to filter mesh nodes / elements by specific
characteristic (Area, Length, etc).
The functinality of mesh filters is available in both GUI and TUI
modes:
- In GUI, filters are available in some dialog boxes via "Set Filters"
button, clicking on which opens the \ref filtering_elements "dialog box"
allowing to specify the list of filter criteria to be applied to the
current selection. See \subpage selection_filter_library_page page to
learn more about selection filters and their usage in GUI.
- In Python scripts, filters can be used to choose only some mesh
entities (nodes or elements) for the operations, which require the
list of entities as input parameter (create/modify group, remove
nodes/elements, etc) and for the operations, which accept objects
(groups, sub-meshes) as input parameter. The page \ref
tui_filters_page provides examples of the filters usage in Python
scripts.
*/

22
doc/salome/gui/SMESH/input/about_filters.rst Normal file
View File

@ -0,0 +1,22 @@
.. _filters_page:
*************
About filters
*************
**Filters** allow picking only the mesh elements satisfying to a specific condition or a set of conditions. Filters can be used to create or edit mesh groups, remove elements from the mesh, control mesh quality by different parameters, etc.
Several criteria can be combined together by using logical operators *AND* and *OR*. In addition, a filter criterion can be reverted using logical operator *NOT*.
Some filtering criteria use the functionality of :ref:`quality_page`:"mesh quality controls" to filter mesh nodes / elements by specific characteristic (Area, Length, etc).
The functinality of mesh filters is available in both GUI and TUI modes:
* In GUI, filters are available in some dialog boxes via "Set Filters" button, clicking on which opens the dialog box allowing to specify the list of filter criteria to be applied to the current selection. See :ref:`selection_filter_library_page` page to learn more about selection filters and their usage in GUI.
* In Python scripts, filters can be used to choose only some mesh entities (nodes or elements) for the operations, which require the list of entities as input parameter (create/modify group, remove nodes/elements, etc) and for the operations, which accept objects (groups, sub-meshes) as input parameter. The page :ref:`tui_filters_page` provides examples of the filters usage in Python scripts.
.. toctree::
:maxdepth: 2
selection_filter_library.rst

66
doc/salome/gui/SMESH/input/about_hypo.doc
View File

@ -1,66 +0,0 @@
/*!
\page about_hypo_page About Hypotheses
\b Hypotheses represent boundary conditions which will be taken into
account by meshing algorithms.
The hypotheses allow you to manage the level of detail of
the resulting mesh: when applying different hypotheses
with different parameters you can preset the quantity or size of
elements which will compose your mesh. So, it will be possible to
generate a coarse or a more refined mesh.
The choice of a hypothesis depends on the selected algorithm.
Hypotheses are created during creation and edition of
\ref constructing_meshes_page "meshes" and
\ref constructing_submeshes_page "sub-meshes".
Once created a hypotheses can be reused during creation and edition of
other meshes and sub-meshes. All created hypotheses and algorithms are
present in the Object Browser in \a Hypotheses and \a Algorithms
folders correspondingly. It is possible to open a dialog to modify the
parameters of a hypothesis from its context menu. This menu also
provides \b Unassign command that will unassign the hypothesis from
all meshes and sub-meshes using it. Modification of any parameter of a
hypothesis and its unassignment leads to automatic removal of elements
generated using it.
In \b MESH there are the following Basic Hypotheses:
<ul>
<li>\subpage a1d_meshing_hypo_page "1D Hypotheses" (for meshing of
<b>edges</b>):</li>
<ul>
<li>\ref number_of_segments_anchor "Number of Segments"</li>
<li>\ref average_length_anchor "Local Length"</li>
<li>\ref max_length_anchor "Max Size"</li>
<li>\ref adaptive_1d_anchor "Adaptive"</li>
<li>\ref arithmetic_1d_anchor "Arithmetic Progression"</li>
<li>\ref geometric_1d_anchor "Geometric Progression"</li>
<li>\ref start_and_end_length_anchor "Start and end length"</li>
<li>\ref deflection_1d_anchor "Deflection"</li>
<li>\ref automatic_length_anchor "Automatic Length"</li>
<li>\ref fixed_points_1d_anchor "Fixed points"</li>
</ul>
<li>\subpage a2d_meshing_hypo_page "2D Hypotheses" (for meshing of <b>faces</b>):</li>
<ul>
<li>\ref max_element_area_anchor "Max Element Area"</li>
<li>\ref length_from_edges_anchor "Length from Edges"</li>
<li>\ref hypo_quad_params_anchor "Quadrangle Parameters"</li>
</ul>
<li>3D Hypothesis (for meshing of <b>volumes</b>):</li>
<ul>
<li>\subpage max_element_volume_hypo_page "Max Element Volume"</li>
</ul>
</ul>
There also exist
\subpage additional_hypo_page "Additional Hypotheses":
<ul>
<li>\ref propagation_anchor "Propagation of 1D Hypothesis on opposite edges"</li>
<li>\ref propagofdistribution_anchor "Propagation of Node Distribution on Opposite Edges"</li>
<li>\ref viscous_layers_anchor "Viscous layers"</li>
<li>\ref quadratic_mesh_anchor "Quadratic mesh"</li>
<li>\ref quadrangle_preference_anchor "Quadrangle preference"</li>
</ul>
*/

58
doc/salome/gui/SMESH/input/about_hypo.rst Normal file
View File

@ -0,0 +1,58 @@
.. _about_hypo_page:
****************
About Hypotheses
****************
**Hypotheses** represent boundary conditions which will be taken into account by meshing algorithms. The hypotheses allow you to manage the level of detail of the resulting mesh: when applying different hypotheses with different parameters you can preset the quantity or size of elements which will compose your mesh. So, it will be possible to generate a coarse or a more refined mesh.
The choice of a hypothesis depends on the selected algorithm.
Hypotheses are created during creation and edition of
:ref:`constructing_meshes_page`:"meshes" and
:ref:`constructing_submeshes_page`:"sub-meshes".
Once created a hypotheses can be reused during creation and edition of other meshes and sub-meshes. All created hypotheses and algorithms are present in the Object Browser in *Hypotheses* and *Algorithms* folders correspondingly. It is possible to open a dialog to modify the parameters of a hypothesis from its context menu. This menu also provides **Unassign** command that will unassign the hypothesis from all meshes and sub-meshes using it. Modification of any parameter of a hypothesis and its unassignment leads to automatic removal of elements generated using it.
In **MESH** there are the following Basic Hypotheses:
* :ref:`a1d_meshing_hypo_page` (for meshing of **edges**):
* :ref:`number_of_segments_anchor`
* :ref:`average_length_anchor`
* :ref:`max_length_anchor`
* :ref:`adaptive_1d_anchor`
* :ref:`arithmetic_1d_anchor`
* :ref:`geometric_1d_anchor`
* :ref:`start_and_end_length_anchor`
* :ref:`deflection_1d_anchor`
* :ref:`automatic_length_anchor`
* :ref:`fixed_points_1d_anchor`
* :ref:`a2d_meshing_hypo_page` (for meshing of **faces**):
* :ref:`max_element_area_anchor`
* :ref:`length_from_edges_anchor`
* :ref:`hypo_quad_params_anchor`
* 3D Hypothesis (for meshing of **volumes**):
* :ref:`max_element_volume_hypo_page`
There also exist :ref:`additional_hypo_page`:
* :ref:`propagation_anchor`
* :ref:`propagofdistribution_anchor`
* :ref:`viscous_layers_anchor`
* :ref:`quadratic_mesh_anchor`
* :ref:`quadrangle_preference_anchor`
.. toctree::
:maxdepth: 2
1d_meshing_hypo.rst
2d_meshing_hypo.rst
max_element_volume_hypo.rst
additional_hypo.rst

118
doc/salome/gui/SMESH/input/about_meshes.doc
View File

@ -1,118 +0,0 @@
/*!
\page about_meshes_page About meshes
\n \b MESH represents a discrete approximation of a subset of the
three-dimensional space by \ref mesh_entities "elementary geometrical elements".
A SALOME study can contain multiple meshes, but they do not
implicitly compose one super-mesh, and finally each of them
can be used (e.g. exported) only individually.
Mesh module provides several ways to create the mesh:
<ul>
<li>The main way is to \subpage constructing_meshes_page "construct the mesh"
on the basis of the geometrical shape produced in the Geometry
module. This way implies selection of
- a geometrical object (<em>main shape</em>) and
- <em>meshing parameters</em> (\ref
basic_meshing_algos_page "meshing algorithms" and
characteristics (e.g. element size) of a
required mesh encapsulated in \ref about_hypo_page "hypothesis"
objects).
Construction of \subpage constructing_submeshes_page "sub-meshes"
allows to discretize some sub-shapes of the main shape, for example a face,
using the meshing parameters that differ from those used for other sub-shapes.<br>
Meshing parameters of meshes and sub-meshes can be
\subpage editing_meshes_page "edited". (Upon edition only mesh entities
generated using changed meshing parameters are removed and will be
re-computed).<br>
\note Algorithms and hypotheses used at mesh level are referred to as
\a global ones and those used at sub-mesh level are referred to as \a
local ones.
</li>
<li>Bottom-up way, using \ref modifying_meshes_page "mesh modification"
operations, especially \ref extrusion_page "extrusion" and \ref
revolution_page "revolution". To create an empty mesh not based on
geometry, use the same dialog as to \ref constructing_meshes_page
"construct the mesh on geometry" but specify neither the geometry
nor meshing algorithms.
</li>
<li>The mesh can be \subpage importing_exporting_meshes_page "imported" from
(and exported to) the file in MED, UNV, STL, CGNS, DAT, GMF and
SAUVE formats.
</li>
<li>The 3D mesh can be generated from the 2D mesh not based on geometry,
which was either \ref importing_exporting_meshes_page "imported" or created in
other way. To setup the meshing parameters of a mesh not based on geometry,
just invoke \ref editing_meshes_page "Edit mesh / sub-mesh" command on
your 2D mesh.
</li>
<li>Several meshes can be \subpage building_compounds_page "combined"
into a new mesh.
</li>
<li>The whole mesh or its part (sub-mesh or group) can be
\subpage copy_mesh_page "copied" into a new mesh.
</li>
<li>A new mesh can be created from a transformed, e.g. \ref
translation_page "translated", part of the mesh.</li>
</ul>
Meshes can be edited using the MESH functions destined for
\ref modifying_meshes_page "modification" of meshes.
Attractive meshing capabilities include:
- 3D and 2D \ref viscous_layers_anchor "Viscous Layers" (boundary
layers of highly stretched elements beneficial for high quality
viscous computations);
- automatic conformal transition between tetrahedral and hexahedral
sub-meshes.
The \b structure of a SALOME mesh is described by nodes and elements based on
these nodes. The geometry of an element is defined by the sequence of
nodes constituting it and the \ref connectivity_page "connectivity convention"
(adopted from MED library). Definition of the element basing on the elements
of a lower dimension is NOT supported.
\anchor mesh_entities
The mesh can include the following entities:
<ul>
<li>\b Node &mdash; a mesh entity defining a position in 3D
space with coordinates (x, y, z).</li>
<li>\b Edge (or segment) &mdash; 1D mesh element linking two nodes.</li>
<li>\b Face &mdash; 2D mesh element representing a part of
surface bound by links between face nodes. A face can be a
triangle, quadrangle or polygon.</li>
<li>\b Volume &mdash; 3D mesh element representing a part of 3D
space bound by volume facets. Nodes of a volume describing each
facet are defined by
the \subpage connectivity_page "connectivity convention".
A volume can be a tetrahedron, hexahedron,
pentahedron, pyramid, hexagonal prism or polyhedron.</li>
<li>\b 0D element &mdash; mesh element defined by one node.</li>
<li>\b Ball element &mdash; discrete mesh element defined by a
node and a diameter.</li>
</ul>
Every mesh entity has an attribute associating it to a sub-shape it is
generated on (if any). The node generated on the geometrical edge or
surface in addition stores its position in parametric space of the
associated geometrical entity. This attribute is set up by meshing
algorithms generating elements and nodes.
Mesh entities are identified by integer IDs starting from 1.
Nodes and elements are counted separately, i.e. there can be a node
and element with the same ID.
SALOME supports elements of second order, without a central node
(quadratic triangle, quadrangle, polygon, tetrahedron, hexahedron,
pentahedron and pyramid) and with central nodes (bi-quadratic triangle
and quadrangle and tri-quadratic hexahedron).<br>
Quadratic mesh can be obtained in three ways:
- Using a global \ref quadratic_mesh_anchor "Quadratic Mesh"
hypothesis. (Elements with the central node are not generated in this way).
- Using \ref convert_to_from_quadratic_mesh_page operation.
- Using an appropriate option of some meshing algorithms, which
generate elements of several dimensions starting from mesh segments.
*/

81
doc/salome/gui/SMESH/input/about_meshes.rst Normal file
View File

@ -0,0 +1,81 @@
.. _about_meshes_page:
************
About meshes
************
**MESH** represents a discrete approximation of a subset of the three-dimensional space by `elementary geometrical elements`_.
A SALOME study can contain multiple meshes, but they do not implicitly compose one super-mesh, and finally each of them can be used (e.g. exported) only individually.
Mesh module provides several ways to create the mesh:
* The main way is to :ref:`constructing_meshes_page` on the basis of the geometrical shape produced in the Geometry module. This way implies selection of
* a geometrical object (**main shape**) and
* **meshing parameters** ( :ref:`basic_meshing_algos_page` and characteristics (e.g. element size) of a required mesh encapsulated in :ref:`about_hypo_page` objects).
Construction of :ref:`constructing_submeshes_page` allows to discretize some sub-shapes of the main shape, for example a face, using the meshing parameters that differ from those used for other sub-shapes.
Meshing parameters of meshes and sub-meshes can be :ref:`editing_meshes_page`. (Upon edition only mesh entities generated using changed meshing parameters are removed and will be re-computed).
.. note::
Algorithms and hypotheses used at mesh level are referred to as *global* ones and those used at sub-mesh level are referred to as *local* ones.
* Bottom-up way, using :ref:`modifying_meshes_page` operations, especially :ref:`extrusion_page` and :ref:`revolution_page`. To create an empty mesh not based on geometry, use the same dialog as to :ref:`constructing_meshes_page` but specify neither the geometry nor meshing algorithms.
* The mesh can be :ref:`importing_exporting_meshes_page` from (and exported to) the file in MED, UNV, STL, CGNS, DAT, GMF and SAUVE formats.
* The 3D mesh can be generated from the 2D mesh not based on geometry, which was either :ref:`importing_exporting_meshes_page` or created in other way. To setup the meshing parameters of a mesh not based on geometry, just invoke :ref:`editing_meshes_page` command on your 2D mesh.
* Several meshes can be :ref:`building_compounds_page` into a new mesh.
* The whole mesh or its part (sub-mesh or group) can be :ref:`copy_mesh_page` into a new mesh.
* A new mesh can be created from a transformed, e.g. :ref:`translation_page`, part of the mesh.
Meshes can be edited using the MESH functions destined for :ref:`modifying_meshes_page` of meshes.
Attractive meshing capabilities include:
* 3D and 2D :ref:`viscous_layers_anchor` (boundary layers of highly stretched elements beneficial for high quality viscous computations);
* automatic conformal transition between tetrahedral and hexahedral sub-meshes.
The **structure** of a SALOME mesh is described by nodes and elements based on these nodes. The geometry of an element is defined by the sequence of nodes constituting it and the :ref:`connectivity_page` (adopted from MED library). Definition of the element basing on the elements of a lower dimension is NOT supported.
.. _elementary geometrical elements:
The mesh can include the following entities:
* **Node** - a mesh entity defining a position in 3D space with coordinates (x, y, z).
* **Edge** (or segment) - 1D mesh element linking two nodes.
* **Face** - 2D mesh element representing a part of surface bound by links between face nodes. A face can be a triangle, quadrangle or polygon.
* **Volume** - 3D mesh element representing a part of 3D space bound by volume facets. Nodes of a volume describing each facet are defined by the :ref:`connectivity_page`. A volume can be a tetrahedron, hexahedron, pentahedron, pyramid, hexagonal prism or polyhedron.
* **0D** element - mesh element defined by one node.
* **Ball** element - discrete mesh element defined by a node and a diameter.
Every mesh entity has an attribute associating it to a sub-shape it is generated on (if any). The node generated on the geometrical edge or surface in addition stores its position in parametric space of the associated geometrical entity. This attribute is set up by meshing algorithms generating elements and nodes.
Mesh entities are identified by integer IDs starting from 1.
Nodes and elements are counted separately, i.e. there can be a node and element with the same ID.
SALOME supports elements of second order, without a central node (quadratic triangle, quadrangle, polygon, tetrahedron, hexahedron,
pentahedron and pyramid) and with central nodes (bi-quadratic triangle and quadrangle and tri-quadratic hexahedron).
Quadratic mesh can be obtained in three ways:
* Using a global :ref:`quadratic_mesh_anchor` hypothesis. (Elements with the central node are not generated in this way).
* Using :ref:`convert_to_from_quadratic_mesh_page` operation.
* Using an appropriate option of some meshing algorithms, which generate elements of several dimensions starting from mesh segments.
.. toctree::
:maxdepth: 2
constructing_meshes.rst
constructing_submeshes.rst
editing_meshes.rst
importing_exporting_meshes.rst
building_compounds.rst
copy_mesh.rst
connectivity.rst

78
doc/salome/gui/SMESH/input/about_quality_controls.doc
View File

@ -1,78 +0,0 @@
/*!
\page quality_page About quality controls
\n <b>Mesh quality control</b> in MESH is destined for visual control of the generated mesh.
Application of a definite quality control consists of usage of the
corresponding algorithm, which calculates a value of a definite
geometric characteristic (Area, Length of edges, etc) for all meshing
elements, composing your mesh. Then all meshing elements are colored
according the calculated values. The reference between the coloring of
the meshing elements and these calculated values is shown with the
help of a scalar bar, which is displayed near the presentation of your
mesh.
There are four types of quality controls, corresponding to node, edge,
face and volume entity type.
Node quality controls:
<ul>
<li>\subpage free_nodes_page "Free nodes"</li>
<li>\subpage double_nodes_control_page "Double nodes"</li>
</ul>
Edge quality controls:
<ul>
<li>\subpage free_borders_page "Free borders"</li>
<li>\subpage length_page "Length"</li>
<li>\subpage borders_at_multi_connection_page "Borders at multi-connection"</li>
<li>\subpage double_elements_page "Double edges"</li>
</ul>
Face quality controls:
<ul>
<li>\subpage free_edges_page "Free edges"</li>
<li>\subpage free_faces_page "Free faces"</li>
<li>\subpage bare_border_faces_page "Bare border faces"</li>
<li>\subpage over_constrained_faces_page "Over-constrained faces"</li>
<li>\subpage length_2d_page "Length 2D"</li>
<li>\subpage deflection_2d_page "Deflection 2D"</li>
<li>\subpage borders_at_multi_connection_2d_page "Borders at multi-connection 2D"</li>
<li>\subpage area_page "Area"</li>
<li>\subpage taper_page "Taper"</li>
<li>\subpage aspect_ratio_page "Aspect ratio"</li>
<li>\subpage minimum_angle_page "Minimum angle"</li>
<li>\subpage warping_page "Warping"</li>
<li>\subpage skew_page "Skew"</li>
<li>\subpage max_element_length_2d_page "Element Diameter 2D"</li>
<li>\ref double_elements_page "Double faces"</li>
</ul>
Volume quality controls:
<ul>
<li>\subpage aspect_ratio_3d_page "Aspect ratio 3D"</li>
<li>\subpage volume_page "Volume"</li>
<li>\subpage max_element_length_3d_page "Element Diameter 3D"</li>
<li>\subpage bare_border_volumes_page "Bare border volumes"</li>
<li>\subpage over_constrained_volumes_page "Over-constrained volumes"</li>
<li>\ref double_elements_page "Double volumes"</li>
</ul>
To manage the quality controls call pop-up in the VTK viewer and select "Controls" sub-menu
\image html controls_popup.png
<ul>
<li> <b>Reset</b> switches off quality controls;</li>
<li> <b>Node Controls</b> provides access to the node quality controls;</li>
<li> <b>Edge Controls</b> provides access to the edge quality controls;</li>
<li> <b>Face Controls</b> provides access to the face quality controls;</li>
<li> <b>Volume Controls</b> provides access to the volume quality controls;</li>
<li> <b>Scalar Bar Properties</b> allows setting \subpage scalar_bar_dlg;</li>
<li> <b>Distribution -> Export ...</b> allows saving the distribution of quality control values in the text file;</li>
<li> <b>Distribution -> Show </b> Shows/Hides the distribution histogram of the quality control values in the VTK Viewer.</li>
<li> <b>Distribution -> Plot </b> Plots the distribution histogram of the quality control values in the Plot 2D Viewer.</li>
</ul>
*/

102
doc/salome/gui/SMESH/input/about_quality_controls.rst Normal file
View File

@ -0,0 +1,102 @@
.. _quality_page:
**********************
About quality controls
**********************
.. note::
**Mesh quality control** in MESH is destined for visual control of the generated mesh.
Application of a definite quality control consists of usage of the corresponding algorithm, which calculates a value of a definite geometric characteristic (Area, Length of edges, etc) for all meshing elements, composing your mesh. Then all meshing elements are colored according the calculated values. The reference between the coloring of the meshing elements and these calculated values is shown with the help of a scalar bar, which is displayed near the presentation of your mesh.
There are four types of quality controls, corresponding to node, edge, face and volume entity type.
Node quality controls:
* :ref:`free_nodes_page`
* :ref:`double_nodes_control_page`
Edge quality controls:
* :ref:`free_borders_page`
* :ref:`length_page`
* :ref:`borders_at_multi_connection_page`
* :ref:`double_elements_page`
Face quality controls:
* :ref:`free_edges_page`
* :ref:`free_faces_page`
* :ref:`bare_border_faces_page`
* :ref:`over_constrained_faces_page`
* :ref:`length_2d_page`
* :ref:`borders_at_multi_connection_2d_page`
* :ref:`area_page`
* :ref:`taper_page`
* :ref:`aspect_ratio_page`
* :ref:`minimum_angle_page`
* :ref:`warping_page`
* :ref:`skew_page`
* :ref:`max_element_length_2d_page`
* :ref:`double_elements_page`
Volume quality controls:
* :ref:`aspect_ratio_3d_page`
* :ref:`volume_page`
* :ref:`max_element_length_3d_page`
* :ref:`bare_border_volumes_page`
* :ref:`over_constrained_volumes_page`
* :ref:`double_elements_page`
To manage the quality controls call pop-up in the VTK viewer and select "Controls" sub-menu
.. image:: ../images/controls_popup.png
:align: center
* **Reset** switches off quality controls;
* **Node Controls** provides access to the node quality controls;
* **Edge Controls** provides access to the edge quality controls;
* **Face Controls** provides access to the face quality controls;
* **Volume Controls** provides access to the volume quality controls;
* **Scalar Bar Properties** allows setting :ref:scalar_bar_dlg;
* **Distribution -> Export ...** allows saving the distribution of quality control values in the text file;
* **Distribution -> Show** Shows/Hides the distribution histogram of the quality control values in the VTK Viewer.
* **Distribution -> Plot** Plots the distribution histogram of the quality control values in the Plot 2D Viewer.
.. toctree::
:maxdepth: 2
free_nodes.rst
double_nodes_control.rst
free_borders.rst
length.rst
borders_at_multi_connection.rst
double_elements_control.rst
free_edges.rst
free_faces.rst
bare_border_face.rst
over_constrained_faces.rst
length_2d.rst
borders_at_multi_connection_2d.rst
area.rst
taper.rst
aspect_ratio.rst
minimum_angle.rst
warping.rst
skew.rst
max_element_length_2d.rst
aspect_ratio_3d.rst
volume.rst
max_element_length_3d.rst
bare_border_volumes.rst
over_constrained_volumes.rst
scalar_bar.rst

243
doc/salome/gui/SMESH/input/adding_nodes_and_elements.doc
View File

@ -1,243 +0,0 @@
/*!
\page adding_nodes_and_elements_page Adding nodes and elements
\n In MESH you can add to your mesh different elements such as:
<ul>
<li>\ref adding_nodes_anchor "Nodes"</li>
<li>\ref adding_0delems_anchor "0D Elements"</li>
<li>\ref adding_0delems_on_all_nodes_anchor "0D elements on Element Nodes"</li>
<li>\ref adding_balls_anchor "Ball Elements"</li>
<li>\ref adding_edges_anchor "Edges"</li>
<li>\ref adding_triangles_anchor "Triangles"</li>
<li>\ref adding_quadrangles_anchor "Quadrangles"</li>
<li>\ref adding_polygons_anchor "Polygons"</li>
<li>\ref adding_tetrahedrons_anchor "Tetrahedrons"</li>
<li>\ref adding_hexahedrons_anchor "Hexahedrons"</li>
<li>\ref adding_octahedrons_anchor "Hexagonal prism"</li>
<li>\ref adding_polyhedrons_anchor "Polyhedrons"</li>
</ul>
The convention of nodal connectivity of elements used in SALOME is
the MED library convention. You can consult the description of
nodal connectivity of elements in the documentation on MED library or
\ref connectivity_page "here".
<em>To add a node or an element to your mesh:</em>
<ol>
<li>Select your mesh in the Object Browser or in the 3D viewer.</li>
<li>From the \b Modification menu choose the \b Add item, the
following associated sub-menu will appear:</li>
\image html image152.png
From this sub-menu select the type of element which you would like to add to your mesh.
\note All dialogs for new node or element adding to the mesh provide
the possibility to automatically add
a node or element to the specified group or to create it anew using
<b>Add to group</b> box, that allows choosing an existing group for
the created node or element or giving the name to a new group. By
default, the <b>Add to group</b> check box is switched off. If the user
switches this check box on, the combo box listing all currently
existing groups of the corresponding type becomes available. By
default, no group is selected. In this case, when the user presses
<b>Apply</b> or <b>Apply & Close</b> button, the warning message box
informs the user about the necessity to input new group name. The
combo box lists groups of all the
\ref grouping_elements_page "three types": both
\ref standalone_group "standalone groups",
\ref group_on_filter "groups on filter", and
\ref group_on_geom "groups on geometry". If the user chooses a
group on geometry or on filter, he is warned and proposed to
convert this group to standalone.
If the user rejects conversion operation, it is cancelled and
a new node/element is not created!
</ol>
<b>See Also</b> sample TUI Scripts of
\ref tui_adding_nodes_and_elements "Adding Nodes and Elements"
operations.
<br>
\anchor adding_nodes_anchor
<h2>Adding nodes</h2>
\image html addnode.png
In this dialog box set coordinates for your node in the \b Coordinates
set of fields and click the \b Apply or <b>Apply and Close</b> button. Your node will be
created:
\image html add_node.png
<br>
\anchor adding_0delems_anchor
<h2>Adding 0D elements</h2>
\image html add0delement.png
In this dialog box specify nodes which will form your 0D elements by
selecting them in the 3D viewer. Activate <b>Allow duplicate
elements</b> to get several 0D elements on a node. Click the \b Apply or
<b>Apply and Close</b> button. Your 0D elements will be created:
\image html add_0delement.png
\anchor adding_0delems_on_all_nodes_anchor
<h2>Making 0D elements on Element Nodes</h2>
There is another way to create 0D elements. It is possible to create
0D elements on all nodes of the selected mesh, sub-mesh, or a group of elements or nodes.
\image html dlg_0D_on_all_nodes.png
In this dialog
<ul>
<li> The radio-buttons allow choosing the type of object to create 0D elements on.
<ul>
<li><b> Mesh, sub-mesh, group </b> - this button allows selecting
a mesh, a sub-mesh or a group to create 0D elements on the nodes of its
elements. The name of the selected object is shown in the dialog. </li>
<li><b> Elements </b> - this button allows selecting elements in the
VTK viewer or typing their IDs in the dialog.</li>
<li><b> Nodes </b> - this button allows selecting nodes to create
0D elements on in the VTK viewer or typing their IDs in the dialog.</li>
</ul></li>
<li><b> Set Filter </b> button allows selecting elements or nodes
by filtering mesh elements or nodes with different criteria
(see \ref filtering_elements "Filter usage").</li>
<li>Activate <b>Allow duplicate elements</b> to get several 0D
elements on a node. </li>
<li> Switching on <b>Add to group</b> check-box allows specifying the
name of the group to which all created or found (existing) 0D elements will
be added. You can either select an existing group from a drop-down
list, or enter the name of the group to be created. If a selected
existing \ref grouping_elements_page "group" is not Standalone
(Group On Geometry or Group On Filter) it will be converted to
Standalone.
\warning If <b>Add to group</b> is activated it has to be filled in.
</li>
</ul>
\anchor adding_balls_anchor
<h2>Adding ball elements</h2>
\image html addball.png
In this dialog box specify the nodes, which will form your ball elements,
either by selecting them in the 3D viewer or by manually entering their IDs,
specify the ball diameter and click the \b Apply or <b>Apply and
Close</b> button.
\image html add_ball.png
<br>
\anchor adding_edges_anchor
<h2>Adding edges</h2>
\image html addedge.png
In this dialog box specify the nodes which will form your edge by
selecting them in the 3D viewer with pressed Shift button and click
the \b Apply or <b>Apply and Close</b> button. Your edge will be created:
\image html add_edge.png
<br>
\anchor adding_triangles_anchor
<h2>Adding triangles</h2>
\image html addtriangle.png
In this dialog box specify the nodes which will form your triangle by
selecting them in the 3D viewer with pressed Shift button and click
the \b Apply or <b>Apply and Close</b> button. Your triangle will be created:
\image html add_triangle.png
<br>
\anchor adding_quadrangles_anchor
<h2>Adding quadrangles</h2>
\image html addquadrangle.png
In this dialog box specify the nodes which will form your quadrangle
by selecting them in the 3D viewer with pressed Shift button and click
the \b Apply or <b>Apply and Close</b> button. Your quadrangle will be created:
\image html add_quadrangle.png
<br>
\anchor adding_polygons_anchor
<h2>Adding polygons</h2>
\image html addpolygon.png
In this dialog box specify the nodes which will form your polygon by
selecting them in the 3D viewer with pressed Shift button and click
the \b Apply or <b>Apply and Close</b> button.
\image html add_polygone.png
<br>
\anchor adding_tetrahedrons_anchor
<h2>Adding tetrahedrons</h2>
\image html addtetrahedron.png
In this dialog box specify the nodes which will form your tetrahedron
by selecting them in the 3D viewer with pressed Shift button and click
the \b Apply or <b>Apply and Close</b> button. Your tetrahedron will be created:
\image html image70.jpg
<br>
\anchor adding_hexahedrons_anchor
<h2>Adding hexahedrons</h2>
\image html addhexahedron.png
In this dialog box specify the nodes which will form your hexahedron
by selecting them in the 3D viewer with pressed Shift button and click
the \b Apply or <b>Apply and Close</b> button. Your hexahedron will be created:
\image html image71.jpg
<br>
\anchor adding_octahedrons_anchor
<h2>Adding hexagonal prism</h2>
In the Add Hexagonal Prism dialog box specify the nodes which will
form your hexagonal prism by selecting them in the 3D viewer with pressed Shift button and click
the \b Apply or <b>Apply and Close</b> button. Your hexagonal prism will be created:
\image html image_octa12.png
<br>
\anchor adding_polyhedrons_anchor
<h2>Adding polyhedrons</h2>
\image html a-createpolyhedralvolume.png
There are two different ways to add polyhedral volumes.
\n If you select \b Node as <b>Elements Type</b> you will specify the
nodes which will form the faces of your polyhedron by selecting the
nodes in the 3D viewer with pressed Shift button and clicking the \b
Add button to add the face in the list of Faces by Nodes, which will
form your polyhedron. Note, that it could be very useful to toggle
Polyhedron Preview checkbox to see the results of your selection.
\n The second way is somewhat simpler, however, there are cases when
it does not provide you with the necessary level of precision. If you
select \b Face as <b>Elements Type</b>, you will be able to select the faces
which will form your polyhedron in the 3D viewer with pressed Shift
button. If you've managed to obtain the necessary result, click the
\b Apply or <b>Apply and Close</b> button. Your polyhedron will be created:
\image html add_polyhedron.png
*/

227
doc/salome/gui/SMESH/input/adding_nodes_and_elements.rst Normal file
View File

@ -0,0 +1,227 @@
.. _adding_nodes_and_elements_page:
*************************
Adding nodes and elements
*************************
In MESH you can add to your mesh different elements such as:
* :ref:`adding_nodes_anchor`
* :ref:`adding_0delems_anchor`
* :ref:`adding_0delems_on_all_nodes_anchor`
* :ref:`adding_balls_anchor`
* :ref:`adding_edges_anchor`
* :ref:`adding_triangles_anchor`
* :ref:`adding_quadrangles_anchor`
* :ref:`adding_polygons_anchor`
* :ref:`adding_tetrahedrons_anchor`
* :ref:`adding_hexahedrons_anchor`
* :ref:`adding_octahedrons_anchor`
* :ref:`adding_polyhedrons_anchor`
The convention of nodal connectivity of elements used in SALOME is the MED library convention. You can consult the description of nodal connectivity of elements in the documentation on MED library or :ref:`connectivity_page`.
**To add a node or an element to your mesh:**
#. Select your mesh in the Object Browser or in the 3D viewer.
#. From the **Modification** menu choose the **Add** item, the following associated sub-menu will appear:
.. image:: ../images/image152.png
:align: center
From this sub-menu select the type of element which you would like to add to your mesh.
.. note::
All dialogs for new node or element adding to the mesh provide the possibility to automatically add a node or element to the specified group or to create it anew using **Add to group** box, that allows choosing an existing group for the created node or element or giving the name to a new group. By default, the **Add to group** check box is switched off. If the user switches this check box on, the combo box listing all currently existing groups of the corresponding type becomes available. By default, no group is selected. In this case, when the user presses **Apply** or **Apply & Close** button, the warning message box informs the user about the necessity to input new group name. The combo box lists groups of all the
:ref:`grouping_elements_page`: both
:ref:`standalone_group`,
:ref:`group_on_filter`, and
:ref:`group_on_geom`. If the user chooses a group on geometry or on filter, he is warned and proposed to convert this group to standalone.
If the user rejects conversion operation, it is cancelled and a new node/element is not created!
**See Also** sample TUI Scripts of :ref:`tui_adding_nodes_and_elements` operations.
.. _adding_nodes_anchor:
Adding nodes
############
.. image:: ../images/addnode.png
:align: center
In this dialog box set coordinates for your node in the **Coordinates** set of fields and click the **Apply** or **Apply and Close** button. Your node will be created:
.. image:: ../images/add_node.png
:align: center
.. _adding_0delems_anchor:
Adding 0D elements
##################
.. image:: ../images/add0delement.png
:align: center
In this dialog box specify nodes which will form your 0D elements by selecting them in the 3D viewer. Activate **Allow duplicate elements**
to get several 0D elements on a node. Click the **Apply** or **Apply and Close** button. Your 0D elements will be created:
.. image:: ../images/add_0delement.png
:align: center
.. _adding_0delems_on_all_nodes_anchor:
Making 0D elements on Element Nodes
###################################
There is another way to create 0D elements. It is possible to create 0D elements on all nodes of the selected mesh, sub-mesh, or a group of elements or nodes.
.. image:: ../images/dlg_0D_on_all_nodes.png
:align: center
In this dialog
* The radio-buttons allow choosing the type of object to create 0D elements on.
* **Mesh, sub-mesh, group** - this button allows selecting a mesh, a sub-mesh or a group to create 0D elements on the nodes of its elements. The name of the selected object is shown in the dialog.
* **Elements** - this button allows selecting elements in the VTK viewer or typing their IDs in the dialog.
* **Nodes** - this button allows selecting nodes to create 0D elements on in the VTK viewer or typing their IDs in the dialog.
* **Set Filter** button allows selecting elements or nodes by filtering mesh elements or nodes with different criteria (see :ref:`filtering_elements`).
* Activate **Allow duplicate elements** to get several 0D elements on a node.
* Switching on **Add to group** check-box allows specifying the name of the group to which all created or found (existing) 0D elements will be added. You can either select an existing group from a drop-down list, or enter the name of the group to be created. If a selected existing :ref:`grouping_elements_page` is not Standalone (Group On Geometry or Group On Filter) it will be converted to Standalone.
.. warning:: If **Add to group** is activated it has to be filled in.
.. _adding_balls_anchor:
Adding ball elements
####################
.. image:: ../images/addball.png
:align: center
In this dialog box specify the nodes, which will form your ball elements, either by selecting them in the 3D viewer or by manually entering their IDs, specify the ball diameter and click the **Apply** or **Apply and Close** button.
.. image:: ../images/add_ball.png
:align: center
.. _adding_edges_anchor:
Adding edges
############
.. image:: ../images/addedge.png
:align: center
In this dialog box specify the nodes which will form your edge by selecting them in the 3D viewer with pressed Shift button and click the **Apply** or **Apply and Close** button. Your edge will be created:
.. image:: ../images/add_edge.png
:align: center
.. _adding_triangles_anchor:
Adding triangles
################
.. image:: ../images/addtriangle.png
:align: center
In this dialog box specify the nodes which will form your triangle by selecting them in the 3D viewer with pressed Shift button and click the **Apply** or **Apply and Close** button. Your triangle will be created:
.. image:: ../images/add_triangle.png
:align: center
.. _adding_quadrangles_anchor:
Adding quadrangles
##################
.. image:: ../images/addquadrangle.png
:align: center
In this dialog box specify the nodes which will form your quadrangle by selecting them in the 3D viewer with pressed Shift button and click the **Apply** or **Apply and Close** button. Your quadrangle will be created:
.. image:: ../images/add_quadrangle.png
:align: center
.. _adding_polygons_anchor:
Adding polygons
###############
.. image:: ../images/addpolygon.png
:align: center
In this dialog box specify the nodes which will form your polygon by selecting them in the 3D viewer with pressed Shift button and click the **Apply** or **Apply and Close** button.
.. image:: ../images/add_polygone.png
:align: center
.. _adding_tetrahedrons_anchor:
Adding tetrahedrons
###################
.. image:: ../images/addtetrahedron.png
:align: center
In this dialog box specify the nodes which will form your tetrahedron by selecting them in the 3D viewer with pressed Shift button and click the **Apply** or **Apply and Close** button. Your tetrahedron will be created:
.. image:: ../images/image70.jpg
:align: center
.. _adding_hexahedrons_anchor:
Adding hexahedrons
##################
.. image:: ../images/addhexahedron.png
:align: center
In this dialog box specify the nodes which will form your hexahedron by selecting them in the 3D viewer with pressed Shift button and click
the **Apply** or **Apply and Close** button. Your hexahedron will be created:
.. image:: ../images/image71.jpg
:align: center
.. _adding_octahedrons_anchor:
Adding hexagonal prism
######################
In the Add Hexagonal Prism dialog box specify the nodes which will form your hexagonal prism by selecting them in the 3D viewer with pressed Shift button and click the **Apply** or **Apply and Close** button. Your hexagonal prism will be created:
.. image:: ../images/image_octa12.png
:align: center
.. _adding_polyhedrons_anchor:
Adding polyhedrons
##################
.. image:: ../images/a-createpolyhedralvolume.png
:align: center
There are two different ways to add polyhedral volumes.
If you select **Node** as **Elements Type** you will specify the nodes which will form the faces of your polyhedron by selecting the nodes in the 3D viewer with pressed Shift button and clicking the **Add** button to add the face in the list of Faces by Nodes, which will form your polyhedron. Note, that it could be very useful to toggle Polyhedron Preview checkbox to see the results of your selection.
The second way is somewhat simpler, however, there are cases when it does not provide you with the necessary level of precision. If you select **Face** as **Elements Type**, you will be able to select the faces which will form your polyhedron in the 3D viewer with pressed Shift button. If you've managed to obtain the necessary result, click the **Apply** or **Apply and Close** button. Your polyhedron will be created:
.. image:: ../images/add_polyhedron.png
:align: center

85
doc/salome/gui/SMESH/input/adding_quadratic_elements.doc
View File

@ -1,85 +0,0 @@
/*!
\page adding_quadratic_elements_page Adding Quadratic Elements
\n MESH module allows you to work with <b>Quadratic Elements</b>.
Quadratic elements are defined by the same corner nodes as the
corresponding linear ones, but in addition they have \a midside nodes
located between the corner nodes on element sides.
If a quadratic 2D element has an additional node at the
element center, it is a bi-quadratic element (both TRIA7 and
QUAD9 elements are supported). If a quadratic hexahedral element has 7
additional nodes: at the element center and at the center of each
side, it is a tri-quadratic element (or HEXA27).
The convention of nodal connectivity of elements used in SALOME is
the MED library convention. You can consult the description of nodal
connectivity of elements in the documentation on MED library or
\ref connectivity_page "here".
There are several ways to create quadratic elements in your mesh:
- manually (this way is described below);
- use \ref quadratic_mesh_anchor "Quadratic Mesh" hypothesis to
generate a quadratic mesh on your geometry;
- convert an existing linear mesh to a quadratic one
(see \ref convert_to_from_quadratic_mesh_page).
<em>To add a quadratic element to your mesh:</em>
<ol>
<li>Select your mesh in the Object Browser or in the 3D viewer.</li>
<li>From the \b Modification menu choose the \b Add item and select
one of the following:
\image html image152.png
\note All dialogs for adding quadratic element to the mesh
provide the possibility to automatically add an element
to the specified group or to create the group anew using
<b>Add to group</b> box, that allows choosing an existing group for
the created node or element or giving the name to a new group. By
default, the <b>Add to group</b> check box is switched off. If the user
switches this check box on, the combo box listing all currently
existing groups of the corresponding type becomes available. By
default, no group is selected. In this case, when the user presses
<b>Apply</b> or <b>Apply & Close</b> button, the warning message box
informs the user about the necessity to input a new group name. The
combo box lists groups of all the
\ref grouping_elements_page "three types": both
\ref standalone_group "standalone groups",
\ref group_on_filter "groups on filter", and
\ref group_on_geom "groups on geometry". If the user chooses a
group on geometry or on filter, he is warned and proposed to
convert this group to standalone.
If the user rejects conversion operation, it is cancelled and
a new quadratic element is not created.
To create any <b>Quadratic Element</b> specify the nodes which will
form your element by selecting them in the 3D viewer with pressed
Shift button and click \a Selection button to the right of
<b>Corner Nodes</b> label. Their numbers will appear in the dialog box
as <b>Corner Nodes</b> (alternatively you can just input numbers in
this field without selection; note that to use this way the mesh
should be selected before invoking this operation). The edges formed
by the corner nodes will appear in the table. To define the middle
nodes for each edge, double-click on the respective field and input
the number of the node (or pick the node in the viewer). For
bi-quadratic and tri-quadratic elements, your also need to specify
central nodes.
As soon as all needed nodes are specified, a preview of a new
quadratic element will be displayed in the 3D viewer. Then
you will be able to click \b Apply or <b>Apply and Close</b> button to
add the element to the mesh.
\image html aqt.png
\b Reverse button reverses the element.
</li>
</ol>
*/

49
doc/salome/gui/SMESH/input/adding_quadratic_elements.rst Normal file
View File

@ -0,0 +1,49 @@
.. _adding_quadratic_elements_page:
*************************
Adding Quadratic Elements
*************************
MESH module allows you to work with **Quadratic Elements**.
Quadratic elements are defined by the same corner nodes as the corresponding linear ones, but in addition they have *midside* nodes located between the corner nodes on element sides.
If a quadratic 2D element has an additional node at the element center, it is a bi-quadratic element (both TRIA7 and QUAD9 elements are supported). If a quadratic hexahedral element has 7 additional nodes: at the element center and at the center of each side, it is a tri-quadratic element (or HEXA27).
The convention of nodal connectivity of elements used in SALOME is the MED library convention. You can consult the description of nodal connectivity of elements in the documentation on MED library or :ref:`connectivity_page`.
There are several ways to create quadratic elements in your mesh:
* manually (this way is described below);
* use :ref:`quadratic_mesh_anchor` hypothesis to generate a quadratic mesh on your geometry;
* convert an existing linear mesh to a quadratic one (see :ref:`convert_to_from_quadratic_mesh_page`).
**To add a quadratic element to your mesh:**
#. Select your mesh in the Object Browser or in the 3D viewer.
#. From the **Modification** menu choose the **Add** item and select one of the following:
.. image:: ../images/image152.png
:align: center
.. note::
All dialogs for adding quadratic element to the mesh provide the possibility to automatically add an element to the specified group or to create the group anew using **Add to group** box, that allows choosing an existing group for the created node or element or giving the name to a new group. By default, the **Add to group** check box is switched off. If the user switches this check box on, the combo box listing all currently existing groups of the corresponding type becomes available. By default, no group is selected. In this case, when the user presses **Apply** or **Apply & Close** button, the warning message box informs the user about the necessity to input a new group name. The combo box lists groups of all the
:ref:`grouping_elements_page` both
:ref:`standalone_group`,
:ref:`group_on_filter`, and
:ref:`group_on_geom`. If the user chooses a group on geometry or on filter, he is warned and proposed to convert this group to standalone.
If the user rejects conversion operation, it is cancelled and a new quadratic element is not created.
To create any **Quadratic Element** specify the nodes which will form your element by selecting them in the 3D viewer with pressed Shift button and click *Selection* button to the right of **Corner Nodes** label. Their numbers will appear in the dialog box as **Corner Nodes** (alternatively you can just input numbers in this field without selection; note that to use this way the mesh should be selected before invoking this operation). The edges formed by the corner nodes will appear in the table. To define the middle nodes for each edge, double-click on the respective field and input the number of the node (or pick the node in the viewer). For bi-quadratic and tri-quadratic elements, your also need to specify central nodes. As soon as all needed nodes are specified, a preview of a new quadratic element will be displayed in the 3D viewer. Then you will be able to click **Apply** or **Apply and Close** button to add the element to the mesh.
.. image:: ../images/aqt.png
:align: center
**Reverse** button reverses the element.

182
doc/salome/gui/SMESH/input/additional_hypo.doc
View File

@ -1,182 +0,0 @@
/*!
\page additional_hypo_page Additional Hypotheses
\n <b>Additional Hypotheses</b> can be applied as a supplement to the
main hypotheses, introducing additional concepts to mesh creation.
An <b>Additional Hypothesis</b> can be defined in the same way as any
main hypothesis in \ref create_mesh_anchor "Create Mesh" or
\ref constructing_submeshes_page "Create Sub-Mesh" dialog.
The following additional hypothesis are available:
<ul>
<li>\ref propagation_anchor "Propagation of 1D Hypothesis on opposite edges"
and \ref propagofdistribution_anchor "Propagation of Node Distribution on Opposite Edges"
hypotheses are useful for creation of quadrangle and hexahedral
meshes.</li>
<li>\ref viscous_layers_anchor "Viscous Layers" and
\ref viscous_layers_anchor "Viscous Layers 2D"
hypotheses allow creation of layers of highly stretched
elements near mesh boundary, which is beneficial for high quality
viscous computations.</li>
<li>\ref quadratic_mesh_anchor "Quadratic Mesh" hypothesis allows
generation of second order meshes.</li>
<li>\ref quadrangle_preference_anchor "Quadrangle Preference"
enables generation of quadrangles.</li>
</ul>
\anchor propagation_anchor
<h2>Propagation of 1D Hypothesis on opposite edges</h2>
<b>Propagation of 1D Hypothesis on opposite edges</b> allows to mesh
opposite sides of a quadrangle face and other adjacent quadrangles,
using the same hypothesis assigned to only one edge.<br>
Thus you define a sub-mesh on the edge where you define 1D meshing
parameters and the \b Propagation hypothesis. These local meshing
parameters will be propagated via opposite sides of quadrangles to the
whole geometry, and this propagation stops at an edge with other local
meshing parameters.
This hypothesis can be taken into account by
\ref a1d_algos_anchor "Wire Discretization" and
\ref a1d_algos_anchor "Composite Side Discretization" algorithms.
<b>See Also</b> a sample TUI Script of a
\ref tui_propagation "Propagation hypothesis" operation
\anchor propagofdistribution_anchor
<h2>Propagation of Node Distribution on Opposite Edges</h2>
<b>Propagation of Node Distribution on Opposite Edges</b> allows to propagate
distribution of nodes onto an opposite edge. If a local hypothesis and
propagation are defined on an edge of a quadrangular face, the
opposite edge will have the same number of nodes and the same
relations between segment lengths, unless another hypothesis
has been locally defined on the opposite edge.
This hypothesis can be taken into account by
\ref a1d_algos_anchor "Wire Discretization" and
\ref a1d_algos_anchor "Composite Side Discretization" algorithms.
<b>See Also</b> a sample TUI Script of a
\ref tui_propagation "Propagation hypothesis" operation
\anchor viscous_layers_anchor
<h2>Viscous Layers and Viscous Layers 2D</h2>
<b>Viscous Layers</b> and <b>Viscous Layers 2D </b> additional
hypotheses can be used by several 3D algorithms, for example
Hexahedron(i,j,k), or 2D algorithms, for example Triangle
(MEFISTO), correspondingly. These hypotheses allow creation of layers
of highly stretched elements, prisms in 3D and quadrilaterals in 2D,
near mesh boundary, which is beneficial for high quality viscous
computations.
\image html viscous_layers_hyp.png
\image html viscous_layers_2d_hyp.png
<ul>
<li><b>Name</b> - allows to define the name of the hypothesis.</li>
<li><b>Total thickness</b> - gives the total thickness of element layers.</li>
<li><b>Number of layers</b> - defines the number of element layers.</li>
<li><b>Stretch factor</b> - defines the growth factor of element height
from the mesh boundary inwards.</li>
<li><b>Extrusion method</b> (available in 3D only) - defines how
positions of nodes are found during prism construction and how
the creation of distorted and intersecting prisms is prevented.
<ul><li><b>Surface offset + smooth</b> method extrudes nodes along the normal
to the underlying geometrical surface. Smoothing of the internal surface of
element layers is possible to avoid creation of invalid prisms.</li>
<li><b>Face offset</b> method extrudes nodes along the average normal of
surrounding mesh faces to the intersection with a neighbor mesh face
translated along its own normal by the thickness of layers. The thickness
of layers can be limited to avoid creation of invalid prisms.</li>
<li><b>Node offset</b> method extrudes nodes along the average normal of
surrounding mesh faces by the thickness of layers. The thickness of
layers can be limited to avoid creation of invalid prisms.</li>
\image html viscous_layers_extrusion_method.png "Prisms created by the tree extrusion methods at the same other parameters"
</ul></li>
<li><b>Specified Faces/Edges are</b> - defines how the shapes specified by
the next parameter are used.
<li><b> Faces/Edges with/without layers</b> -
defines geometrical faces or edges on which element layers
either should be or should not be constructed, depending on the
value of the previous parameter (<b>Specified Faces/Edges are</b>).
Faces (or edges) can be selected either in the Object Browser or in
the VTK Viewer. \b Add button becomes active as soon as a suitable
sub-shape is selected.
\note A mesh shown in the 3D Viewer can prevent selection of faces
and edges, just hide the mesh to avoid this. If a face, which should be
selected, is hidden by other faces, consider creating a
group of faces to be selected in the Geometry module.<br>
To avoid a long wait when a
geometry with many faces (or edges) is displayed, the number of faces
(edges) shown at a time is limited by the value of "Sub-shapes
preview chunk size" preference (in Preferences/Mesh/General tab).
If faces/edges without layers are specified, the element layers are
not constructed on geometrical faces shared by several solids in 3D
case and edges shared by several faces in 2D case. In other words,
in this mode the element layers can be constructed on boundary faces
and edges only, and are not constructed on internal faces and
edges. There is an exception to this rule: if a hypothesis is
assigned to a sub-mesh, the element layers can be constructed on
boundary faces/edges of the shape of this sub-mesh, at same time
possibly being internal faces/edges within the whole model.
\image html viscous_layers_on_submesh.png 2D viscous layers constructed on boundary edges of a sub-mesh on a disk face.
If you use \b several hypotheses to define viscous layers on faces of
one solid, keep in mind the following. Each hypothesis defines a set
of faces with viscous layers (even if you specify faces without
layers). The sets of faces with viscous layers defined by several
hypotheses should not intersect, else the module won't add an
hypothesis that is incompatible with another one. <br>
Also you can't define different number of layers on adjacent faces
of a solid.<br>
This logic is also valid for the 2D hypothesis.
</li>
</ul>
\image html viscous_layers_mesh.png A group containing viscous layer prisms.
<br><b>See also</b> a sample TUI script of a \ref tui_viscous_layers
"Viscous layers construction".
\anchor quadratic_mesh_anchor
<h2>Quadratic Mesh</h2>
Quadratic Mesh hypothesis allows to build a quadratic mesh (in which
links between element nodes are not straight but curved lines due to
presence of an additional mid-side node).
This 1D hypothesis can be taken into account by
\ref a1d_algos_anchor "Wire Discretization" and
\ref a1d_algos_anchor "Composite Side Discretization" algorithms. To
create a quadratic mesh assign this hypothesis at
\ref constructing_meshes_page "mesh construction".
See \ref adding_quadratic_elements_page
for more information about quadratic meshes.
\anchor quadrangle_preference_anchor
<h2>Quadrangle Preference</h2>
This additional hypothesis can be used together with 2D triangulation algorithms.
It allows 2D triangulation algorithms to build quadrangular meshes.
Usage of this hypothesis with "Quadrangle: Mapping" meshing algorithm
is obsolete since introducing
\ref hypo_quad_params_anchor "Quadrangle parameters" hypothesis.
Usage of this hypothesis with "Quadrangle: Mapping" meshing algorithm
corresponds to specifying "Quadrangle Preference" transition type of
\ref hypo_quad_params_anchor "Quadrangle parameters" hypothesis.
\note "Quadrangle Preference" transition type can be used only if the
total quantity of segments on all sides of the face is even (divisible
by 2), else "Standard" transition type is used.
*/

166
doc/salome/gui/SMESH/input/additional_hypo.rst Normal file
View File

@ -0,0 +1,166 @@
.. _additional_hypo_page:
*********************
Additional Hypotheses
*********************
**Additional Hypotheses** can be applied as a supplement to the main hypotheses, introducing additional concepts to mesh creation.
An **Additional Hypothesis** can be defined in the same way as any main hypothesis in :ref:`create_mesh_anchor` or :ref:`constructing_submeshes_page` dialog.
The following additional hypothesis are available:
* :ref:`propagation_anchor` and :ref:`propagofdistribution_anchor` hypotheses are useful for creation of quadrangle and hexahedral meshes.
* :ref:`viscous_layers_anchor` and :ref:`viscous_layers_anchor` hypotheses allow creation of layers of highly stretched elements near mesh boundary, which is beneficial for high quality viscous computations.
* :ref:`quadratic_mesh_anchor` hypothesis allows generation of second order meshes.
* :ref:`quadrangle_preference_anchor` enables generation of quadrangles.
.. _propagation_anchor:
Propagation of 1D Hypothesis on opposite edges
##############################################
**Propagation of 1D Hypothesis on opposite edges** allows to mesh
opposite sides of a quadrangle face and other adjacent quadrangles,
using the same hypothesis assigned to only one edge.
Thus you define a sub-mesh on the edge where you define 1D meshing
parameters and the **Propagation hypothesis**. These local meshing
parameters will be propagated via opposite sides of quadrangles to the
whole geometry, and this propagation stops at an edge with other local
meshing parameters.
This hypothesis can be taken into account by
:ref:`a1d_algos_anchor` and
:ref:`a1d_algos_anchor` "Composite Side Discretization" algorithms.
**See Also** a sample TUI Script of a :ref:`tui_propagation` operation
.. _propagofdistribution_anchor:
Propagation of Node Distribution on Opposite Edges
##################################################
**Propagation of Node Distribution on Opposite Edges** allows to propagate
distribution of nodes onto an opposite edge. If a local hypothesis and
propagation are defined on an edge of a quadrangular face, the
opposite edge will have the same number of nodes and the same
relations between segment lengths, unless another hypothesis
has been locally defined on the opposite edge.
This hypothesis can be taken into account by
:ref:`a1d_algos_anchor` "Wire Discretization" and
:ref:`a1d_algos_anchor` "Composite Side Discretization" algorithms.
**See Also** a sample TUI Script of a :ref:`tui_propagation` operation
.. _viscous_layers_anchor:
Viscous Layers and Viscous Layers 2D
####################################
**Viscous Layers** and **Viscous Layers 2D** additional
hypotheses can be used by several 3D algorithms, for example
Hexahedron(i,j,k), or 2D algorithms, for example Triangle
(MEFISTO), correspondingly. These hypotheses allow creation of layers
of highly stretched elements, prisms in 3D and quadrilaterals in 2D,
near mesh boundary, which is beneficial for high quality viscous
computations.
.. image:: ../images/viscous_layers_hyp.png
:align: center
.. image:: ../images/viscous_layers_2d_hyp.png
:align: center
* **Name** - allows to define the name of the hypothesis.
* **Total thickness** - gives the total thickness of element layers.
* **Number of layers** - defines the number of element layers.
* **Stretch factor** - defines the growth factor of element height from the mesh boundary inwards.
* **Extrusion method** (available in 3D only) - defines how positions of nodes are found during prism construction and how the creation of distorted and intersecting prisms is prevented.
* **Surface offset + smooth** method extrudes nodes along the normal to the underlying geometrical surface. Smoothing of the internal surface of element layers is possible to avoid creation of invalid prisms.
* **Face offset** method extrudes nodes along the average normal of surrounding mesh faces to the intersection with a neighbor mesh face translated along its own normal by the thickness of layers. The thickness of layers can be limited to avoid creation of invalid prisms.
* **Node offset** method extrudes nodes along the average normal of surrounding mesh faces by the thickness of layers. The thickness of layers can be limited to avoid creation of invalid prisms.
.. image:: ../images/viscous_layers_extrusion_method.png
:align: center
.. centered::
"Prisms created by the tree extrusion methods at the same other parameters"
* **Specified Faces/Edges are** - defines how the shapes specified by the next parameter are used.
* **Faces/Edges with/without layers** - defines geometrical faces or edges on which element layers either should be or should not be constructed, depending on the value of the previous parameter (**Specified Faces/Edges are**). Faces (or edges) can be selected either in the Object Browser or in the VTK Viewer. **Add** button becomes active as soon as a suitable sub-shape is selected.
.. note::
A mesh shown in the 3D Viewer can prevent selection of faces and edges, just hide the mesh to avoid this. If a face, which should be selected, is hidden by other faces, consider creating a group of faces to be selected in the Geometry module. To avoid a long wait when a geometry with many faces (or edges) is displayed, the number of faces (edges) shown at a time is limited by the value of "Sub-shapes preview chunk size" preference (in Preferences/Mesh/General tab).
If faces/edges without layers are specified, the element layers are
not constructed on geometrical faces shared by several solids in 3D
case and edges shared by several faces in 2D case. In other words,
in this mode the element layers can be constructed on boundary faces
and edges only, and are not constructed on internal faces and
edges. There is an exception to this rule: if a hypothesis is
assigned to a sub-mesh, the element layers can be constructed on
boundary faces/edges of the shape of this sub-mesh, at same time
possibly being internal faces/edges within the whole model.
.. image:: ../images/viscous_layers_on_submesh.png
:align: center
.. centered::
2D viscous layers constructed on boundary edges of a sub-mesh on a disk face.
If you use **several** hypotheses to define viscous layers on faces of
one solid, keep in mind the following. Each hypothesis defines a set
of faces with viscous layers (even if you specify faces without
layers). The sets of faces with viscous layers defined by several
hypotheses should not intersect, else the module won't add an
hypothesis that is incompatible with another one.
Also you can't define different number of layers on adjacent faces
of a solid.
This logic is also valid for the 2D hypothesis.
.. image:: ../images/viscous_layers_mesh.png
:align: center
.. centered::
A group containing viscous layer prisms.
**See also** a sample TUI script of a :ref:`tui_viscous_layers`.
.. _quadratic_mesh_anchor:
Quadratic Mesh
##############
Quadratic Mesh hypothesis allows to build a quadratic mesh (in which
links between element nodes are not straight but curved lines due to
presence of an additional mid-side node).
This 1D hypothesis can be taken into account by
:ref:`a1d_algos_anchor` "Wire Discretization" and
:ref:`a1d_algos_anchor` "Composite Side Discretization" algorithms. To create a quadratic mes assign this hypothesis at
:ref:`constructing_meshes_page`.
See :ref:`adding_quadratic_elements_page` for more information about quadratic meshes.
.. _quadrangle_preference_anchor:
Quadrangle Preference
#####################
This additional hypothesis can be used together with 2D triangulation algorithms.
It allows 2D triangulation algorithms to build quadrangular meshes.
Usage of this hypothesis with "Quadrangle: Mapping" meshing algorithm is obsolete since introducing :ref:`hypo_quad_params_anchor` "Quadrangle parameters" hypothesis.
Usage of this hypothesis with "Quadrangle: Mapping" meshing algorithm corresponds to specifying "Quadrangle Preference" transition type of :ref:`hypo_quad_params_anchor` "Quadrangle parameters" hypothesis.
.. note::
"Quadrangle Preference" transition type can be used only if the total quantity of segments on all sides of the face is even (divisible by 2), else "Standard" transition type is used.

28
doc/salome/gui/SMESH/input/area.doc
View File

@ -1,28 +0,0 @@
/*!
\page area_page Area
\n \b Area mesh quality control is based on the algorithm of area
calculation of mesh faces.
<em>To apply the Area quality control to your mesh:</em>
<ol>
<li>Display your mesh in the viewer.</li>
<li>Choose <b>Controls > Face Controls > Area</b> or click
<em>"Area"</em> button.
\image html image35.png
<center><em>"Area" button</em></center>
Your mesh will be displayed in the viewer with its faces colored
according to the applied mesh quality control criterion:
\image html image5.jpg
</li>
</ol>
<br><b>See Also</b> a sample TUI Script of an
\ref tui_area "Area quality control" operation.
*/

30
doc/salome/gui/SMESH/input/area.rst Normal file
View File

@ -0,0 +1,30 @@
.. _area_page:
****
Area
****
.. note:: **Area** mesh quality control is based on the algorithm of area
calculation of mesh faces.
**To apply the Area quality control to your mesh:**
#. Display your mesh in the viewer.
#. Choose **Controls > Face Controls > Area** or click **"Area"** button.
.. image:: ../images/image35.png
:align: center
.. centered::
**"Area" button**
Your mesh will be displayed in the viewer with its faces colored
according to the applied mesh quality control criterion:
.. image:: ../images/image5.jpg
:align: center
**See Also** a sample TUI Script of an :ref:`tui_area` operation.

45
doc/salome/gui/SMESH/input/aspect_ratio.doc
View File

@ -1,45 +0,0 @@
/*!
\page aspect_ratio_page Aspect Ratio
\n The <b>Aspect Ratio</b> quality criterion for mesh elements reveals
the degree of conformity of a mesh element to the regular element of
its type (with all edges having the same length).
- The <b>Aspect Ratio</b> of a \b triangle 2D element consisting of 3
nodes is calculated by the formula:
\image html formula4.png
- The <b>Aspect Ratio</b> of a \b quadrangle 2D element consisting of 4
nodes is calculated using The Verdict Geometric Quality Library
available within VTK. The calculation formula is:
\image html formula5.png
<em>To apply the Aspect Ratio quality criterion to your mesh:</em>
<ol>
<li>Display your mesh in the viewer.</li>
<li>Choose <b>Controls > Face Controls > Aspect Ratio</b> or click
<em>"Aspect Ratio"</em> button in the toolbar.
<center>
\image html image37.png
<em>"Aspect Ratio" button</em>
</center>
Your mesh will be displayed in the viewer with its elements colored
according to the applied mesh quality control criterion:
\image html image94.jpg
</li>
</ol>
<br><b>See Also</b> a sample TUI Script of an
\ref tui_aspect_ratio "Aspect Ratio quality control" operation.
*/

40
doc/salome/gui/SMESH/input/aspect_ratio.rst Normal file
View File

@ -0,0 +1,40 @@
.. _aspect_ratio_page:
************
Aspect Ratio
************
The **Aspect Ratio** quality criterion for mesh elements reveals the degree of conformity of a mesh element to the regular element of its type (with all edges having the same length).
* The **Aspect Ratio** of a **triangle** 2D element consisting of 3 nodes is calculated by the formula:
.. image:: ../images/formula4.png
:align: center
* The **Aspect Ratio** of a **quadrangle** 2D element consisting of 4 nodes is calculated using The Verdict Geometric Quality Library available within VTK. The calculation formula is:
.. image:: ../images/formula5.png
:align: center
**To apply the Aspect Ratio quality criterion to your mesh:**
#. Display your mesh in the viewer.
#. Choose **Controls > Face Controls > Aspect Ratio** or click **Aspect Ratio** button in the toolbar.
.. image:: ../images/image37.png
:align: center
.. centered::
Aspect Ratio button
Your mesh will be displayed in the viewer with its elements colored according to the applied mesh quality control criterion:
.. image:: ../images/image94.jpg
:align: center
**See Also** a sample TUI Script of an :ref:`tui_aspect_ratio` operation.

40
doc/salome/gui/SMESH/input/aspect_ratio_3d.doc
View File

@ -1,40 +0,0 @@
/*!
\page aspect_ratio_3d_page Aspect ratio 3D
\n The <b>Aspect Ratio 3D</b> mesh quality criterion calculates the same
parameter as the \ref aspect_ratio_page "Aspect ratio" criterion, but
it is applied to 3D mesh elements: tetrahedrons, pentahedrons,
hexahedrons, etc.
- The <b>Aspect Ratio</b> of a \b tetrahedron 3D element defined by
vertices {a,b,c,d } is calculated by the formula:
\image html formula1.png
- Other element types like polyhedron, pentahedron and hexahedron use
the following formula:
\image html formula2.png
<em>To apply the Aspect Ratio 3D quality criterion to your mesh:</em>
<ol>
<li>Display your mesh in the viewer.</li>
<li>Choose <b>Controls > Volume Controls > Aspect Ratio 3D</b> or click
<em>"Aspect Ratio 3D"</em> button of the toolbar.
\image html image144.png
<center><em>"Aspect Ratio 3D" button</em></center>
Your mesh will be displayed in the viewer with its elements colored
according to the applied mesh quality control criterion:
\image html image86.jpg
</li>
</ol>
<br><b>See Also</b> a sample TUI Script of a
\ref tui_aspect_ratio_3d "Aspect Ratio 3D quality control" operation.
*/

38
doc/salome/gui/SMESH/input/aspect_ratio_3d.rst Normal file
View File

@ -0,0 +1,38 @@
.. _aspect_ratio_3d_page:
***************
Aspect ratio 3D
***************
The **Aspect Ratio 3D** mesh quality criterion calculates the same parameter as the :ref:`aspect_ratio_page` criterion, but it is applied to 3D mesh elements: tetrahedrons, pentahedrons, hexahedrons, etc.
* The **Aspect Ratio** of a **tetrahedron** 3D element defined by vertices {a,b,c,d } is calculated by the formula:
.. image:: ../images/formula1.png
:align: center
* Other element types like polyhedron, pentahedron and hexahedron use the following formula:
.. image:: ../images/formula2.png
:align: center
**To apply the Aspect Ratio 3D quality criterion to your mesh:**
#. Display your mesh in the viewer.
#. Choose **Controls > Volume Controls > Aspect Ratio 3D** or click **"Aspect Ratio 3D"** button of the toolbar.
.. image:: ../images/image144.png
:align: center
.. centered::
"Aspect Ratio 3D" button
Your mesh will be displayed in the viewer with its elements colored according to the applied mesh quality control criterion:
.. image:: ../images/image86.jpg
:align: center
**See Also** a sample TUI Script of a :ref:`tui_aspect_ratio_3d` operation.

15
doc/salome/gui/SMESH/input/bare_border_face.doc
View File

@ -1,15 +0,0 @@
/*!
\page bare_border_faces_page Bare border faces
This mesh quality control highlights the faces having the border not
shared with other faces (free border) and missing an edge based on
nodes of the free border. The faces with bare border are shown with a
color different from the color of shared faces.
\image html bare_border_faces_smpl.png
\sa A sample TUI Script making a group of faces highlighted in the
picture is \ref tui_bare_border_faces "Bare border faces Control".
*/

16
doc/salome/gui/SMESH/input/bare_border_face.rst Normal file
View File

@ -0,0 +1,16 @@
.. _bare_border_faces_page:
*****************
Bare border faces
*****************
This mesh quality control highlights the faces having the border not
shared with other faces (free border) and missing an edge based on
nodes of the free border. The faces with bare border are shown with a
color different from the color of shared faces.
.. image:: ../images/bare_border_faces_smpl.png
:align: center
**See also** A sample TUI Script making a group of faces highlighted in the picture is :ref:`tui_bare_border_faces`.

15
doc/salome/gui/SMESH/input/bare_border_volumes.doc
View File

@ -1,15 +0,0 @@
/*!
\page bare_border_volumes_page Bare border volumes
This mesh quality control highlights the volumes having the border not
shared with other volumes (free border) and missing a face based on
nodes of the free border. The volumes with bare border are shown with a
color different from the color of shared volumes.
\image html bare_border_volumes_smpl.png
\sa A sample TUI Script making a group of volumes highlighted in the
picture is \ref tui_bare_border_volumes "Bare border volumes Control".
*/

17
doc/salome/gui/SMESH/input/bare_border_volumes.rst Normal file
View File

@ -0,0 +1,17 @@
.. _bare_border_volumes_page:
*******************
Bare border volumes
*******************
This mesh quality control highlights the volumes having the border not
shared with other volumes (free border) and missing a face based on
nodes of the free border. The volumes with bare border are shown with a
color different from the color of shared volumes.
.. image:: ../images/bare_border_volumes_smpl.png
:align: center
**See also** A sample TUI Script making a group of volumes highlighted in the
picture is :ref:`tui_bare_border_volumes`.

87
doc/salome/gui/SMESH/input/basic_meshing_algos.doc
View File

@ -1,87 +0,0 @@
/*!
\page basic_meshing_algos_page Basic meshing algorithms
\n The MESH module contains a set of meshing algorithms, which are
used for meshing entities (1D, 2D, 3D sub-shapes) composing
geometrical objects.
An algorithm represents either an implementation of a certain meshing
technique or an interface to the whole meshing program generating elements
of several dimensions.
<ul>
<li>For meshing of 1D entities (<b>edges</b>):</li>
\anchor a1d_algos_anchor
<ul>
<li><b>Wire Discretization</b> meshing algorithm - splits an edge into a
number of mesh segments following an 1D hypothesis.
</li>
<li><b>Composite Side Discretization</b> algorithm - allows to apply a 1D
hypothesis to a whole side of a geometrical face even if it is
composed of several edges provided that they form C1 curve in all
faces of the main shape.</li>
</ul>
<li>For meshing of 2D entities (<b>faces</b>):</li>
<ul>
<li><b>Triangle: Mefisto</b> meshing algorithm - splits faces
into triangular elements.</li>
<li>\subpage quad_ijk_algo_page "Quadrangle: Mapping" meshing
algorithm - splits faces into quadrangular elements.</li>
</ul>
\image html image123.gif "Example of a triangular 2D mesh"
\image html image124.gif "Example of a quadrangular 2D mesh"
<li>For meshing of 3D entities (<b>solid objects</b>):</li>
<ul>
<li><b>Hexahedron (i,j,k)</b> meshing algorithm - solids are
split into hexahedral elements thus forming a structured 3D
mesh. The algorithm requires that 2D mesh generated on a solid could
be considered as a mesh of a box, i.e. there should be eight nodes
shared by three quadrangles and the rest nodes should be shared by
four quadrangles.
\image html hexa_ijk_mesh.png "Structured mesh generated by Hexahedron (i,j,k) on a solid bound by 16 faces"
</li>
<li>\subpage cartesian_algo_page "Body Fitting" meshing
algorithm - solids are split into hexahedral elements forming
a Cartesian grid; polyhedra and other types of elements are generated
where the geometrical boundary intersects Cartesian cells.</li>
</ul>
\image html image125.gif "Example of a tetrahedral 3D mesh"
\image html image126.gif "Example of a hexahedral 3D mesh"
</ul>
Some 3D meshing algorithms, such as Hexahedron(i,j,k) also can
generate 3D meshes from 2D meshes, working without geometrical
objects.
There is also a number of more specific algorithms:
<ul>
<li>\subpage prism_3d_algo_page "Extrusion 3D" - for meshing prismatic 3D shapes with hexahedra and prisms.</li>
<li>\subpage quad_from_ma_algo_page "Quadrangle: Medial Axis Projection" - for quadrangle meshing of faces with sinuous borders and rings.</li>
<li> <b>Polygon per Face</b> meshing algorithm - generates one mesh
face (either a triangle, a quadrangle or a polygon) per a geometrical
face using all nodes from the face boundary.</li>
<li>\subpage projection_algos_page "Projection algorithms" - for meshing by projection of another mesh.</li>
<li>\subpage import_algos_page "Import algorithms" - for meshing by importing elements from another mesh.</li>
<li>\subpage radial_prism_algo_page "Radial Prism" - for meshing 3D geometrical objects with cavities with hexahedra and prisms.</li>
<li>\subpage radial_quadrangle_1D2D_algo_page "Radial Quadrangle 1D-2D" - for quadrangle meshing of disks and parts of disks.</li>
<li>\subpage use_existing_page "Use Faces/Edges to be Created Manually" - to create a 1D or a 2D mesh in a python script.</li>
<li>\subpage segments_around_vertex_algo_page "Segments around Vertex" - for defining the length of mesh segments around certain vertices.</li>
</ul>
\ref constructing_meshes_page "Constructing meshes" page describes in
detail how to apply meshing algorithms.
<br><b>See Also</b> a sample TUI Script of a
\ref tui_defining_meshing_algos "Define Meshing Algorithm" operation.
*/

97
doc/salome/gui/SMESH/input/basic_meshing_algos.rst Normal file
View File

@ -0,0 +1,97 @@
.. _basic_meshing_algos_page:
************************
Basic meshing algorithms
************************
The MESH module contains a set of meshing algorithms, which are used for meshing entities (1D, 2D, 3D sub-shapes) composing geometrical objects.
An algorithm represents either an implementation of a certain meshing technique or an interface to the whole meshing program generating elements of several dimensions.
.. _a1d_algos_anchor:
1D Entities
===========
* For meshing of 1D entities (**edges**):
* **Wire Discretization** meshing algorithm - splits an edge into a number of mesh segments following an 1D hypothesis.
* **Composite Side Discretization** algorithm - allows to apply a 1D hypothesis to a whole side of a geometrical face even if it is composed of several edges provided that they form C1 curve in all faces of the main shape.
* For meshing of 2D entities (**faces**):
* **Triangle: Mefisto** meshing algorithm - splits faces into triangular elements.
* :ref:`quad_ijk_algo_page` meshing algorithm - splits faces into quadrangular elements.
.. image:: ../images/image123.gif
:align: center
.. centered::
"Example of a triangular 2D mesh"
.. image:: ../images/image124.gif
:align: center
.. centered::
"Example of a quadrangular 2D mesh"
* For meshing of 3D entities (**solid objects**):
* **Hexahedron (i,j,k)** meshing algorithm - solids are split into hexahedral elements thus forming a structured 3D mesh. The algorithm requires that 2D mesh generated on a solid could be considered as a mesh of a box, i.e. there should be eight nodes shared by three quadrangles and the rest nodes should be shared by four quadrangles.
.. image:: ../images/hexa_ijk_mesh.png
:align: center
.. centered::
"Structured mesh generated by Hexahedron (i,j,k) on a solid bound by 16 faces"
* :ref:`cartesian_algo_page` meshing algorithm - solids are split into hexahedral elements forming a Cartesian grid; polyhedra and other types of elements are generated where the geometrical boundary intersects Cartesian cells.
.. image:: ../images/image125.gif
:align: center
.. centered::
"Example of a tetrahedral 3D mesh"
.. image:: ../images/image126.gif
:align: center
.. centered::
"Example of a hexahedral 3D mesh"
Some 3D meshing algorithms, such as Hexahedron(i,j,k) also can
generate 3D meshes from 2D meshes, working without geometrical
objects.
There is also a number of more specific algorithms:
* :ref:`prism_3d_algo_page` - for meshing prismatic 3D shapes with hexahedra and prisms.
* :ref:`quad_from_ma_algo_page` - for quadrangle meshing of faces with sinuous borders and rings.
* **Polygon per Face** meshing algorithm - generates one mesh face (either a triangle, a quadrangle or a polygon) per a geometrical face using all nodes from the face boundary.
* :ref:`projection_algos_page` - for meshing by projection of another mesh.
* :ref:`import_algos_page` - for meshing by importing elements from another mesh.
* :ref:`radial_prism_algo_page` - for meshing 3D geometrical objects with cavities with hexahedra and prisms.
* :ref:`radial_quadrangle_1D2D_algo_page` - for quadrangle meshing of disks and parts of disks.
* :ref:`use_existing_page` - to create a 1D or a 2D mesh in a python script.
* :ref:`segments_around_vertex_algo_page` - for defining the length of mesh segments around certain vertices.
:ref:`constructing_meshes_page` page describes in detail how to apply meshing algorithms.
**See Also** a sample TUI Script of a :ref:`tui_defining_meshing_algos` operation.
.. toctree::
:maxdepth: 2
quad_ijk_algo.rst
cartesian_algo.rst
prism_3d_algo.rst
quad_from_ma_algo.rst
projection_algos.rst
use_existing_algos.rst
radial_prism_algo.rst
radial_quadrangle_1D2D_algo.rst
define_mesh_by_script.rst
segments_around_vertex_algo.rst

15
doc/salome/gui/SMESH/input/borders_at_multi_connection.doc
View File

@ -1,15 +0,0 @@
/*!
\page borders_at_multi_connection_page Borders at multi-connection
\n This mesh quality control highlights segments according to the number
of elements, faces and volumes, to which the segment belongs.
\image html image151.gif
In this picture the borders at multi-connection are displayed in blue.
<br><b>See Also</b> a sample TUI Script of a
\ref tui_borders_at_multiconnection "Borders at Multi-Connection quality control" operation.
*/

15
doc/salome/gui/SMESH/input/borders_at_multi_connection.rst Normal file
View File

@ -0,0 +1,15 @@
.. _borders_at_multi_connection_page:
***************************
Borders at multi-connection
***************************
This mesh quality control highlights segments according to the number of elements, faces and volumes, to which the segment belongs.
.. image:: ../images/image151.gif
:align: center
In this picture the borders at multi-connection are displayed in blue.
**See Also** a sample TUI Script of a :ref:`tui_borders_at_multiconnection` operation.

13
doc/salome/gui/SMESH/input/borders_at_multi_connection_2d.doc
View File

@ -1,13 +0,0 @@
/*!
\page borders_at_multi_connection_2d_page Borders at multi-connection 2D
\n This mesh quality control highlights borders of faces (links
between nodes) according to the number of faces, to which the link belongs.
\image html image127.gif
<br><b>See Also</b> a sample TUI Script of a
\ref tui_borders_at_multiconnection_2d "Borders at Multi-Connection quality control" operation.
*/

13
doc/salome/gui/SMESH/input/borders_at_multi_connection_2d.rst Normal file
View File

@ -0,0 +1,13 @@
.. _borders_at_multi_connection_2d_page:
******************************
Borders at multi-connection 2D
******************************
This mesh quality control highlights borders of faces (links between nodes) according to the number of faces, to which the link belongs.
.. image:: ../images/image127.gif
:align: center
**See Also** a sample TUI Script of a :ref:`tui_borders_at_multiconnection_2d` operation.

60
doc/salome/gui/SMESH/input/building_compounds.doc
View File

@ -1,60 +0,0 @@
/*!
\page building_compounds_page Building Compound Meshes
\n Compound Mesh is a combination of several meshes. All elements and
groups present in input meshes are present in the compound
mesh. However, it does not use geometry or hypotheses of the initial meshes.
The links between the input meshes and the compound mesh are not
supported, consequently the modification of an input mesh does not lead to
the update of the compound mesh.
<em>To Build a compound mesh:</em>
\par
From the \b Mesh menu select <b>Build Compound</b> or click <em>"Build
Compound Mesh"</em> button in the toolbar.
\image html image161.png
<center><em>"Build Compound Mesh" button</em></center>
\par
The following dialog box will appear:
\image html buildcompound.png
\par
<ul>
<li>\b Name - allows selecting the name of the resulting \b Compound mesh.</li>
<li><b>Meshes, sub-meshes, groups</b> - allows selecting the meshes,
sub-meshes and groups to be concatenated. They can be
chosen in the Object Browser while holding \b Ctrl button.</li>
<li><b>Processing identical groups</b> - allows selecting the method
of processing the namesake groups existing in the input meshes.
They can be either <ul>
<li>\b United - all elements of \em Group1 of \em Mesh_1 and \em
Group1 of \em Mesh_2 become the elements of \em Group1 of the
\em Compound_Mesh, or</li>
<li>\b Renamed - \em Group1 of \em Mesh_1 becomes \em Group1_1
and \em Group1 of \em Mesh_2 becomes \em Group1_2.</li>
</ul>
See \ref grouping_elements_page "Creating Groups" for more information
about groups.</li>
<li><b>Create groups from input objects</b> check-box permits to
automatically create groups corresponding to every initial mesh.
\image html buildcompound_groups.png "Groups created from input meshes 'Box_large' and 'Box_small'"
<p></li>
<li>You can choose to additionally
\ref merging_nodes_page "Merge coincident nodes"
\ref merging_elements_page "and elements" in the compound mesh, in
which case it is possible to define the \b Tolerance for this
operation.</li>
</ul>
\image html image160.gif "Example of a compound of two meshed cubes"
<b>See Also</b> a sample
\ref tui_building_compound "TUI Example of building compounds."
*/

49
doc/salome/gui/SMESH/input/building_compounds.rst Normal file
View File

@ -0,0 +1,49 @@
.. _building_compounds_page:
************************
Building Compound Meshes
************************
Compound Mesh is a combination of several meshes. All elements and groups present in input meshes are present in the compound mesh. However, it does not use geometry or hypotheses of the initial meshes.
The links between the input meshes and the compound mesh are not supported, consequently the modification of an input mesh does not lead to the update of the compound mesh.
**To Build a compound mesh:**
From the **Mesh** menu select **Build Compound** or click **"Build Compound Mesh"** button in the toolbar.
.. image:: ../images/image161.png
:align: center
**"Build Compound Mesh" button**
The following dialog box will appear:
.. image:: ../images/buildcompound.png
:align: center
* **Name** - allows selecting the name of the resulting **Compound** mesh.
* **Meshes, sub-meshes, groups** - allows selecting the meshes, sub-meshes and groups to be concatenated. They can be chosen in the Object Browser while holding **Ctrl** button.
* **Processing identical groups** - allows selecting the method of processing the namesake groups existing in the input meshes. They can be either
* **United** - all elements of **Group1** of **Mesh_1** and **Group1** of **Mesh_2** become the elements of **Group1** of the **Compound_Mesh**, or
* **Renamed** - **Group1** of **Mesh_1** becomes **Group1_1** and **Group1** of **Mesh_2** becomes **Group1_2**.
See :ref:`grouping_elements_page` for more information about groups.
* **Create groups from input objects** check-box permits to automatically create groups corresponding to every initial mesh.
.. image:: ../images/buildcompound_groups.png
:align: center
.. centered::
"Groups created from input meshes 'Box_large' and 'Box_small'"
* You can choose to additionally :ref:`merging_nodes_page`, :ref:`merging_elements_page` in the compound mesh, in which case it is possible to define the **Tolerance** for this operation.
.. image:: ../images/image160.gif
:align: center
.. centered::
"Example of a compound of two meshed cubes"
**See Also** a sample :ref:`tui_building_compound`.

113
doc/salome/gui/SMESH/input/cartesian_algo.doc
View File

@ -1,113 +0,0 @@
/*!
\page cartesian_algo_page Body Fitting 3D meshing algorithm
Body Fitting algorithm generates hexahedrons of a Cartesian grid in
the internal part of geometry and polyhedrons and other types of
elements at the intersection of Cartesian cells with the geometrical
boundary.
\image html cartesian3D_sphere.png "A sphere meshed by Body Fitting algorithm"
The meshing algorithm is as follows.
<ol>
<li> Lines of a Cartesian structured grid defined by
\ref cartesian_hyp_anchor "Body Fitting Parameters" hypothesis are
intersected with the geometry boundary, thus nodes lying on the
boundary are found. This step also allows finding out for each node of
the Cartesian grid if it is inside or outside the geometry. </li>
<li> For each cell of the grid, check how many of its nodes are outside
of the geometry boundary. Depending on a result of this check
<ul>
<li> skip a cell, if all its nodes are outside </li>
<li> skip a cell, if it is too small according to <b> Size
Threshold </b> parameter</li>
<li> add a hexahedron in the mesh, if all nodes are inside </li>
<li> add a polyhedron or another cell type in the mesh, if some
nodes are inside and some outside. </li>
</ul>
</li>
</ol>
To apply this algorithm when you define your mesh, select <b>Body
Fitting</b> in the list of 3D algorithms and add <b>Body Fitting
Parameters</b> hypothesis. The following dialog will appear:
<br>
\anchor cartesian_hyp_anchor
<h2>Body Fitting Parameters hypothesis</h2>
\image html cartesian3D_hyp.png "Body Fitting Parameters hypothesis dialog"
This dialog allows to define
<ul>
<li>\b Name of the algorithm. </li>
<li> Minimal size of a cell truncated by the geometry boundary. If the
size of a truncated grid cell is \b Threshold times less than a
initial cell size, then a mesh element is not created. </li>
<li> <b> Implement Edges </b> check-box activates incorporation of
geometrical edges in the mesh.
\image html cartesian_implement_edge.png "Implement Edges switched off to the left and on to the right"
<li> <b>Definition mode</b> allows choosing how Cartesian structured
grid is defined. Location of nodes along each grid axis is defined
individually:
<ul>
<li> You can specify the \b Coordinates of grid nodes. \b Insert button
inserts a node at \b Step distance (negative or positive) from the
selected node. \b Delete button removes the selected node. Double
click on a coordinate in the list enables its edition.
\b Note that node coordinates are measured along directions of
axes that can differ from the directions of the Global Coordinate
System.</li>
<li> You can define the \b Spacing of a grid as an algebraic formula
<em>f(t)</em> where \a t is a position along a grid axis
normalized at [0.0,1.0]. <em>f(t)</em> must be non-negative
at 0. <= \a t <= 1. The whole extent of geometry can be
divided into ranges with their own spacing formulas to apply;
\a t varies between 0.0 and 1.0 within each \b Range. \b Insert button
divides a selected range into two. \b Delete button adds the
selected sub-range to the previous one. Double click on a range in
the list enables edition of its right boundary. Double click on a
function in the list enables its edition.
</li> </ul>
</li>
<li> <b> Fixed Point</b> group allows defining an exact location of
a grid node in the direction defined by spacing. The following cases
are possible:
<ul>
<li>If all three directions are defined by spacing, there will
be a mesh node at the <b> Fixed Point</b>. </li>
<li>If two directions are defined by spacing, there will be at
least a link between mesh nodes passing through the <b> Fixed
Point</b>.</li>
<li> If only one direction is defined by spacing, there will be
at least an element facet passing through the <b> Fixed
Point</b>.</li>
<li>If no directions are defined by spacing, <b> Fixed Point</b>
is disabled.</li>
</ul>
</li>
<li> <b> Directions of Axes</b> group allows setting the directions of grid axes.
<ul>
<li>If <b> Orthogonal Axes </b> check-box is activated the
axes remain orthogonal during their modification. </li>
<li> Selection buttons enable snapping corresponding axes to
direction of a geometrical edge selected in the Object
Browser. Edge direction is defined by coordinates of its end
points.</li>
<li><b> Optimal Axes</b> button runs an algorithm that tries to
set the axes to maximize the number of generated hexahedra.</li>
<li><b> Reset </b> button returns the axes in a default position
parallel to the axes of the Global Coordinate System.</li>
</ul>
</li>
</ul>
<br>
<b>See Also</b> a sample TUI Script of a
\ref tui_cartesian_algo "Usage of Body Fitting algorithm".
*/

77
doc/salome/gui/SMESH/input/cartesian_algo.rst Normal file
View File

@ -0,0 +1,77 @@
.. _cartesian_algo_page:
*********************************
Body Fitting 3D meshing algorithm
*********************************
Body Fitting algorithm generates hexahedrons of a Cartesian grid in
the internal part of geometry and polyhedrons and other types of
elements at the intersection of Cartesian cells with the geometrical
boundary.
.. image:: ../images/cartesian3D_sphere.png
:align: center
.. centered::
"A sphere meshed by Body Fitting algorithm"
The meshing algorithm is as follows.
#. Lines of a Cartesian structured grid defined by :ref:`cartesian_hyp_anchor` hypothesis are intersected with the geometry boundary, thus nodes lying on the boundary are found. This step also allows finding out for each node of the Cartesian grid if it is inside or outside the geometry.
#. For each cell of the grid, check how many of its nodes are outside of the geometry boundary. Depending on a result of this check
#. skip a cell, if all its nodes are outside
#. skip a cell, if it is too small according to **Size Threshold** parameter
#. add a hexahedron in the mesh, if all nodes are inside
#. add a polyhedron or another cell type in the mesh, if some nodes are inside and some outside.
To apply this algorithm when you define your mesh, select **Body Fitting** in the list of 3D algorithms and add **Body Fitting Parameters** hypothesis. The following dialog will appear:
.. _cartesian_hyp_anchor:
Body Fitting Parameters hypothesis
##################################
.. image:: ../images/cartesian3D_hyp.png
:align: center
.. centered::
"Body Fitting Parameters hypothesis dialog"
This dialog allows to define
* **Name** of the algorithm.
* Minimal size of a cell truncated by the geometry boundary. If the size of a truncated grid cell is **Threshold** times less than a initial cell size, then a mesh element is not created.
* **Implement Edges** check-box activates incorporation of geometrical edges in the mesh.
.. image:: ../images/cartesian_implement_edge.png
:align: center
.. centered::
"Implement Edges switched off to the left and on to the right"
* **Definition mode** allows choosing how Cartesian structured grid is defined. Location of nodes along each grid axis is defined individually:
* You can specify the **Coordinates** of grid nodes. **Insert** button inserts a node at **Step** distance (negative or positive) from the selected node. **Delete** button removes the selected node. Double click on a coordinate in the list enables its edition.
.. note::
that node coordinates are measured along directions of axes that can differ from the directions of the Global Coordinate System.
* You can define the **Spacing** of a grid as an algebraic formula **f(t)** where *t* is a position along a grid axis normalized at [0.0,1.0]. **f(t)** must be non-negative at 0. <= *t* <= 1. The whole extent of geometry can be divided into ranges with their own spacing formulas to apply; a t varies between 0.0 and 1.0 within each **Range**. **Insert** button divides a selected range into two. **Delete** button adds the selected sub-range to the previous one. Double click on a range in the list enables edition of its right boundary. Double click on a function in the list enables its edition.
* **Fixed Point** group allows defining an exact location of a grid node in the direction defined by spacing. The following cases are possible:
* If all three directions are defined by spacing, there will be a mesh node at the **Fixed Point**.
* If two directions are defined by spacing, there will be at least a link between mesh nodes passing through the **Fixed Point**.
* If only one direction is defined by spacing, there will be at least an element facet passing through the **Fixed Point**.
* If no directions are defined by spacing, **Fixed Point** is disabled.
* **Directions of Axes** group allows setting the directions of grid axes.
* If **Orthogonal Axes** check-box is activated the axes remain orthogonal during their modification.
* Selection buttons enable snapping corresponding axes to direction of a geometrical edge selected in the Object Browser. Edge direction is defined by coordinates of its end points.
* **Optimal Axes** button runs an algorithm that tries to set the axes to maximize the number of generated hexahedra.
* **Reset** button returns the axes in a default position parallel to the axes of the Global Coordinate System.
**See Also** a sample TUI Script of a :ref:`tui_cartesian_algo`.

46
doc/salome/gui/SMESH/input/changing_orientation_of_elements.doc
View File

@ -1,46 +0,0 @@
/*!
\page changing_orientation_of_elements_page Changing orientation of elements
\n Orientation of an element is changed by changing the order of its nodes.
<em>To change orientation of elements:</em>
<ol>
<li>Select a mesh (and display it in the 3D Viewer if you are going to pick elements by mouse).</li>
<li>In the \b Modification menu select the \b Orientation item or click
<em>Orientation</em> button in the toolbar.
<center>
\image html image79.png
<em>"Orientation" button</em>
</center>
The following dialog box will appear:
<center>
\image html orientaation1.png
</center>
<ul>
<li>Select type of elements to reorient: \b Face or \b Volume.</li>
<li><b>The main list</b> shall contain the elements which will be
reoriented. You can click on an element in the 3D viewer and it will
be highlighted. After that click the \b Add button and the ID of this
element will be added to the list. To remove a selected element or
elements from the list click the \b Remove button. The \b Sort button
allows to sort the list of elements IDs. The <b>Set filter</b> button
allows to apply a definite \ref filtering_elements "filter" to the
selection of elements.</li>
<li><b>Apply to all</b> radio button allows to modify the orientation
of all elements of the selected mesh.</li>
<li><b>Select from</b> set of fields allows to choose a sub-mesh or an
existing group whose elements can be added to the list.</li>
</ul>
</li>
<li>Click the \b Apply or <b>Apply and Close</b> button to confirm the operation.</li>
</ol>
<br><b>See Also</b> a sample TUI Script of a
\ref tui_orientation "Change Orientation" operation.
*/

33
doc/salome/gui/SMESH/input/changing_orientation_of_elements.rst Normal file
View File

@ -0,0 +1,33 @@
.. _changing_orientation_of_elements_page:
********************************
Changing orientation of elements
********************************
Orientation of an element is changed by changing the order of its nodes.
**To change orientation of elements:**
#. Select a mesh (and display it in the 3D Viewer if you are going to pick elements by mouse).
#. In the **Modification** menu select the **Orientation** item or click **Orientation** button in the toolbar.
.. image:: ../images/image79.png
:align: center
.. centered::
**"Orientation" button**
The following dialog box will appear:
.. image:: ../images/orientaation1.png
:align: center
* Select type of elements to reorient: **Face** or **Volume**.
* **The main list** shall contain the elements which will be reoriented. You can click on an element in the 3D viewer and it will be highlighted. After that click the **Add** button and the ID of this element will be added to the list. To remove a selected element or elements from the list click the **Remove** button. The **Sort** button allows to sort the list of elements IDs. The **Set filter** button allows to apply a definite :ref:`filtering_elements` "filter" to the selection of elements.
* **Apply to all** radio button allows to modify the orientation of all elements of the selected mesh.
* *Select from** set of fields allows to choose a sub-mesh or an existing group whose elements can be added to the list.
#. Click the **Apply** or **Apply and Close** button to confirm the operation.
**See Also** a sample TUI Script of a :ref:`tui_orientation` operation.

62
doc/salome/gui/SMESH/input/clipping.doc
View File

@ -1,62 +0,0 @@
/*!
\page clipping_page Clipping
\b Clipping allows creating cross-section views (clipping planes)
of your mesh.
It is available as a sub-item in the context menu of an active mesh.
To create a clipping plane, click on the \b New button in the dialog and choose how it is defined: by \b Absolute or \b Relative coordinates.
<b>Absolute Coordinates</b>
\image html Clipping_Absolute.png
- <b>Base point</b> - allows defining the coordinates of the base
point for the clipping plane.
- <b>Reset</b> - returns the base point to coordinate origin.
- <b>Direction</b> - allows defining the orientation of the
clipping plane.
- <b>Invert</b> - allows selecting, which part of the object will be
removed and which will remain after clipping.
<b>Relative mode</b>
\image html Clipping_Relative.png
- \b Orientation ( ||X-Y, ||X-Z or ||Y-Z).
- \b Distance between the opposite extremities of the boundary box of
selected objects, if it is set to 0.5 the boundary box is split in two halves.
- \b Rotation (in angle degrees) <b>around X</b> (Y to Z) and <b>around
Y</b> (X to Z) (depending on the chosen Orientation)
\image html before_clipping_preview.png "The preview plane and the cut object"
The other parameters are available in both modes :
- <b>OpenGL clipping</b> check-box allows choosing OpenGL native clipping, which clips the whole presentation. If it is unchecked, the clipping is done on the dataset i.e. only the visibility of separate mesh cells is changed (see the examples).
- The List contains <b>Meshes, sub-meshes and groups</b> to which the cross-section will be applied.
- <b>Select all</b> check-box allows to selecting and deselecting all available objects at once.
- <b>Show preview</b> check-box shows the clipping plane in the <b>3D Viewer</b>.
- <b>Auto Apply</b> check-box shows button is on, you can preview the
cross-section in the <b>3D Viewer</b>.
It is also possible to interact with the clipping plane directly in 3D
view using the mouse.
To get a new object from \b Clipping, click \b Apply.
<b>Examples:</b>
\image html dataset_clipping.png "The cross-section using dataset"
\image html opengl_clipping.png "The OpenGL cross-section"
*/

58
doc/salome/gui/SMESH/input/clipping.rst Normal file
View File

@ -0,0 +1,58 @@
.. _clipping_page:
********
Clipping
********
**Clipping** allows creating cross-section views (clipping planes) of your mesh.
It is available as a sub-item in the context menu of an active mesh.
To create a clipping plane, click on the **New** button in the dialog and choose how it is defined: by **Absolute** or **Relative** coordinates.
**Absolute Coordinates**
.. image:: ../images/Clipping_Absolute.png
:align: center
* **Base point** - allows defining the coordinates of the base point for the clipping plane.
* **Reset** - returns the base point to coordinate origin.
* **Direction** - allows defining the orientation of the clipping plane.
* **Invert** - allows selecting, which part of the object will be removed and which will remain after clipping.
**Relative mode**
.. image:: ../images/Clipping_Relative.png
:align: center
* **Orientation** ( ||X-Y, ||X-Z or ||Y-Z).
* **Distance** between the opposite extremities of the boundary box of selected objects, if it is set to 0.5 the boundary box is split in two halves.
* **Rotation** (in angle degrees) **around X** (Y to Z) and **around Y** (X to Z) (depending on the chosen Orientation)
.. image:: ../images/before_clipping_preview.png
:align: center
"The preview plane and the cut object"
The other parameters are available in both modes :
* **OpenGL clipping** check-box allows choosing OpenGL native clipping, which clips the whole presentation. If it is unchecked, the clipping is done on the dataset i.e. only the visibility of separate mesh cells is changed (see the examples).
* The List contains **Meshes, sub-meshes and groups** to which the cross-section will be applied.
* **Select all** check-box allows to selecting and deselecting all available objects at once.
* **Show preview** check-box shows the clipping plane in the **3D Viewer**.
* **Auto Apply** check-box shows button is on, you can preview the cross-section in the **3D Viewer**.
It is also possible to interact with the clipping plane directly in 3D view using the mouse.
To get a new object from **Clipping**, click **Apply**.
**Examples:**
.. image:: ../images/dataset_clipping.png
:align: center
"The cross-section using dataset"
.. image:: ../images/opengl_clipping.png
:align: center
"The OpenGL cross-section"

52
doc/salome/gui/SMESH/input/colors_size.doc
View File

@ -1,52 +0,0 @@
/*!
\page colors_size_page Properties
\image html colors_size.png
Using this dialog you can customize different properties of the mesh visualization
parameters.
The GUI elements in the "Properties" dialog box are grouped according
to the entity types of mesh data. If some data entities are not
present in the mesh object, the corresponding GUI elements are not
shown.
- \b Nodes:
- \b Color - color of nodes.
- \b Type and \b Scale - these options allow changing the nodes
representation (see \subpage point_marker_page "Point Marker" page
for more details).
- <b>Edges / wireframe</b>:
- \b Color - color of element borders in wireframe mode.
- \b Width - width of lines (edges and borders of elements
in wireframe mode).
- \b Faces:
- \b Front - surface color of face elements (seen in shading mode).
- \b Back - backside surface color of face elements. Use the slider to
select this color generated on the base of the \b Face color by
changing its brightness and saturation.
- \b Volumes:
- \b Normal - surface color of normal volume elements (seen in shading mode).
- \b Reversed - surface color of volume elements. Use the slider to
select this color generated on the base of the \b Normal color by
changing its brightness and saturation.
- \b Outlines:
- \b Color - color of element borders in shading mode.
- \b Width - width of outlines (borders of elements
in shading mode).
- <b>0D elements</b>:
- \b Color - color of 0D elements.
- \b Size - size of 0D elements.
- \b Balls:
- \b Color - color of discrete ball elements.
- \b Size - size of discrete ball elements.
- \b Scale - scale factor of discrete ball elements.
- <b>Orientation vectors</b>:
- \b Color - color of orientation vectors.
- \b Scale - size of orientation vectors.
- <b>3D vectors</b> - allows to choose between 2D planar and 3D vectors.
- <b>Shrink coef.</b> - relative space of elements compared to gaps between
them in shrink mode.
*/

41
doc/salome/gui/SMESH/input/colors_size.rst Normal file
View File

@ -0,0 +1,41 @@
.. _colors_size_page:
**********
Properties
**********
.. image:: ../images/colors_size.png
:align: center
Using this dialog you can customize different properties of the mesh visualization parameters.
The GUI elements in the "Properties" dialog box are grouped according to the entity types of mesh data. If some data entities are not present in the mesh object, the corresponding GUI elements are not shown.
* **Nodes**:
* **Color** - color of nodes.
* **Type** and **Scale** - these options allow changing the nodes representation (see :ref:point_marker_page "Point Marker" page for more details).
* **Edges / wireframe**:
* **Color** - color of element borders in wireframe mode.
* **Width** - width of lines (edges and borders of elements in wireframe mode).
* **Faces**:
* **Front** - surface color of face elements (seen in shading mode).
* **Back** - backside surface color of face elements. Use the slider to select this color generated on the base of the **Face** color by changing its brightness and saturation.
* **Volumes**:
* **Normal** - surface color of normal volume elements (seen in shading mode).
* **Reversed** - surface color of volume elements. Use the slider to select this color generated on the base of the **Normal** color by changing its brightness and saturation.
* **Outlines**:
* **Color** - color of element borders in shading mode.
* **Width** - width of outlines (borders of elements in shading mode).
* **0D elements**:
* **Color** - color of 0D elements.
* **Size** - size of 0D elements.
* **Balls**:
* **Color** - color of discrete ball elements.
* **Size** - size of discrete ball elements.
* **Scale** - scale factor of discrete ball elements.
* **Orientation vectors**:
* **Color** - color of orientation vectors.
* **Scale** - size of orientation vectors.
* **3D vectors** - allows to choose between 2D planar and 3D vectors.
* **Shrink coef.** - relative space of elements compared to gaps between them in shrink mode.

45
doc/salome/gui/SMESH/input/connectivity.doc
View File

@ -1,45 +0,0 @@
/*!
\page connectivity_page Nodal connectivity of elements
The following images show order of nodes in correctly defined elements.
<table>
<tr><td> Edge (segment): linear and quadratic<br>
\image html connectivity_edge.png </td></tr>
<tr><td> Triangle: linear, quadratic and bi-quadratic <br>
\image html connectivity_tria.png </td></tr>
<tr><td> Quadrangle: linear, quadratic and bi-quadratic <br>
\image html connectivity_quad.png </td></tr>
<tr><td align="left"> Polygon: linear and quadratic <br>
\image html connectivity_polygon.png </td></tr>
<tr><td> Tetrahedron: linear and quadratic <br>
\image html connectivity_tetra.png </td></tr>
<tr><td> Hexahedron: linear, quadratic and tri-quadratic <br>
\image html connectivity_hexa.png </td></tr>
<tr><td> Pentahedron: linear and quadratic <br>
\image html connectivity_penta.png </td></tr>
<tr><td> Pyramid: linear and quadratic <br>
\image html connectivity_pyramid.png </td></tr>
<tr><td> Hexagonal prism <br>
\image html connectivity_hex_prism.png </td></tr>
<tr><td> Polyhedron is defined by <ul>
<li> a sequence of nodes defining all facets</li>
<li> a sequence of number of nodes per facet</li>
</ul>
\b Nodes: <br>
Node1_of_Facet1, Node2_of_Facet1, ..., NodeN_of_Facet1, <br>
Node1_of_Facet2, Node2_of_Facet2, ..., NodeN_of_Facet2, <br>
Node1_of_FacetM, Node2_of_FacetM, ..., NodeN_of_FacetM <br>
\b Quantity of nodes per facet: <br>
NbNodes_in_Facet1, NbNodes_in_Facet2, ..., NbNodes_in_FacetM
For example the polyhedron shown in the image below is defined by nodes <br>
[ 1,2,3, 1,4,5,2, 2,5,6,3, 3,6,4,1, 4,7,9,5, 5,9,8,6, 6,8,7,4, 7,8,9 ]<br>
and quantities [ 3, 4, 4, 4, 4, 4, 4, 3 ]
\image html connectivity_polyhedron.png
Order of nodes of a facet must assure outward direction of its normal.
</td></tr>
</table>
*/

67
doc/salome/gui/SMESH/input/connectivity.rst Normal file
View File

@ -0,0 +1,67 @@
.. _connectivity_page:
******************************
Nodal connectivity of elements
******************************
The following images show order of nodes in correctly defined elements.
+------------------------------------------------------------------------------+
| Edge (segment): linear and quadratic |
| .. image:: ../images/connectivity_edge.png |
| :align: center |
+------------------------------------------------------------------------------+
| Triangle: linear, quadratic and bi-quadratic |
| .. image:: ../images/connectivity_tria.png |
| :align: center |
+------------------------------------------------------------------------------+
| Quadrangle: linear, quadratic and bi-quadratic |
| .. image:: ../images/connectivity_quad.png |
| :align: center |
+------------------------------------------------------------------------------+
| Polygon: linear and quadratic |
| .. image:: ../images/connectivity_polygon.png |
| :align: center |
+------------------------------------------------------------------------------+
| Tetrahedron: linear and quadratic |
| .. image:: ../images/connectivity_tetra.png |
| :align: center |
+------------------------------------------------------------------------------+
| Hexahedron: linear, quadratic and tri-quadratic |
| .. image:: ../images/connectivity_hexa.png |
| :align: center |
+------------------------------------------------------------------------------+
| Pentahedron: linear and quadratic |
| .. image:: ../images/connectivity_penta.png |
| :align: center |
+------------------------------------------------------------------------------+
| Pyramid: linear and quadratic |
| .. image:: ../images/connectivity_pyramid.png |
| :align: center |
+------------------------------------------------------------------------------+
| Hexagonal prism |
| .. image:: ../images/connectivity_hex_prism.png |
| :align: center |
+------------------------------------------------------------------------------+
| Polyhedron is defined by |
| * a sequence of nodes defining all facets |
| * a sequence of number of nodes per facet |
| |
| **Nodes**: |
| Node1_of_Facet1, Node2_of_Facet1, ..., NodeN_of_Facet1, |
| Node1_of_Facet2, Node2_of_Facet2, ..., NodeN_of_Facet2, |
| Node1_of_FacetM, Node2_of_FacetM, ..., NodeN_of_FacetM |
| |
| **Quantity** of nodes per facet: |
| NbNodes_in_Facet1, NbNodes_in_Facet2, ..., NbNodes_in_FacetM |
| |
| For example the polyhedron shown in the image below is defined by nodes |
| [ 1,2,3, 1,4,5,2, 2,5,6,3, 3,6,4,1, 4,7,9,5, 5,9,8,6, 6,8,7,4, 7,8,9 ] |
| and quantities [ 3, 4, 4, 4, 4, 4, 4, 3 ] |
| |
| .. image:: ../images/connectivity_polyhedron.png |
| :align: center |
| |
| Order of nodes of a facet must assure outward direction of its normal. |
+------------------------------------------------------------------------------+

483
doc/salome/gui/SMESH/input/constructing_meshes.doc
View File

@ -1,483 +0,0 @@
/*!
\page constructing_meshes_page Constructing meshes
To create a mesh on geometry, it is necessary to create a mesh object by choosing
- a geometrical shape produced in the Geometry module (<em>main shape</em>);
- <em>meshing parameters</em>, including
- \ref basic_meshing_algos_page "meshing algorithms" and
- \ref about_hypo_page "hypotheses" specifying constraints to be
taken into account by the chosen meshing algorithms.
Then you can launch mesh generation by invoking \ref compute_anchor "Compute" command.
The generated mesh will be automatically shown in the Viewer. You can
switch off automatic visualization or limit mesh size until which it is
automatically shown in \ref mesh_preferences_page (<em>Automatic update</em> entry).
\note Sometimes \a hypotheses term is used to refer to both algorithms
and hypotheses.
Mesh generation on the geometry is performed in the bottom-up
flow: nodes on vertices are created first, then edges are divided into
segments using nodes on vertices; the nodes of segments are then
used to mesh faces; then the nodes of faces are used to mesh
solids. This automatically assures the conformity of the mesh.
It is required to choose a meshing algorithm for every dimension of
sub-shapes up to the highest dimension to be generated. Note
that some algorithms generate elements of several dimensions, and
others of only one. It is not necessary to define meshing
parameters for all dimensions at once; you can start from 1D
meshing parameters only, compute the 1D mesh, then define 2D meshing
parameters and compute the 2D mesh (note that 1D mesh will not be
re-computed).
An algorithm of a certain dimension chosen at mesh creation is applied
to discretize every sub-shape of this dimension. It is possible to
specify a different algorithm or hypothesis to be applied to one or
a group of sub-shapes by creating a \ref constructing_submeshes_page
"sub-mesh". You can specify no algorithms at all at mesh object
creation and specify the meshing parameters on sub-meshes only; then
only the sub-shapes, for which an algorithm and a hypothesis (if any)
have been defined will be discretized.
\n Construction of a mesh on a geometry includes at least two
(\ref create_mesh_anchor "mesh creation" and
\ref compute_anchor "computing") of the following steps:
<ul>
<li> \ref create_mesh_anchor "Creation of a mesh object", where you
can specify meshing parameters to apply to all sub-shapes of the
main shape.</li>
<li> \ref constructing_submeshes_page "Creation of sub-meshes",
(optional) where you can specify meshing parameters to apply to the
selected sub-shapes.</li>
<li> \ref evaluate_anchor "Evaluating mesh size" (optional) can be
used to know an approximate number of elements before their actual generation.</li>
<li> \ref preview_anchor "Previewing the mesh" (optional) can be
used to generate mesh of only lower dimension(s) in order to
visually estimate it before full mesh generation, which can be much
longer.</li>
<li> \ref submesh_order_anchor "Changing sub-mesh priority"
(optional) can be useful if there are concurrent sub-meshes
defined.</li>
<li> \ref compute_anchor "Computing the mesh" uses defined meshing
parameters to generate mesh elements.</li>
<li> \ref edit_anchor "Editing the mesh" (optional) can be used to
\ref modifying_meshes_page "modify" the mesh of a lower dimension before
\ref compute_anchor "computing" elements of an upper dimension.</li>
</ul>
\anchor create_mesh_anchor
<h2>Creation of a mesh object</h2>
<em>To construct a mesh:</em>
<ol>
<li>Select a geometrical object for meshing.</li>
<li>In the \b Mesh menu select <b>Create Mesh</b> or click <em>"Create
Mesh"</em> button in the toolbar.
<center>
\image html image32.png
<em>"Create Mesh" button</em>
</center>
The following dialog box will appear:
\image html createmesh-inv.png
<br>
</li>
<li> To filter off irrelevant meshing algorithms, you can
select <b>Mesh Type</b> in the corresponding list from <b>Any,
Hexahedral, Tetrahedral, Triangular </b> and \b Quadrilateral (there
can be less items for the geometry of lower dimensions).
Selection of a mesh type hides all meshing algorithms that cannot
generate elements of this type.</li>
<li>Apply \subpage basic_meshing_algos_page "meshing algorithms" and
\subpage about_hypo_page "hypotheses" which will be used to compute
this mesh.
"Create mesh" dialog box contains several tab pages titled \b 3D,
\b 2D, \b 1D and \b 0D. The title of each page reflects the
dimension of the sub-shapes the algorithms listed on
this page affect and the maximal dimension of elements the algorithms
generate. For example, \b 3D page lists the algorithms that affect
3D sub-shapes (solids) and generate 3D mesh elements
(tetrahedra, hexahedra etc.)
As soon as you have selected an algorithm, you can create a
hypothesis (or select an already created one). A set of accessible
hypotheses includes only the hypotheses that can be used by the
selected algorithm.
\note
- Some page(s) can be disabled if the geometrical
object does not include shapes (sub-shapes) of the corresponding
dimension(s). For example, if the input object is a geometrical face,
\b 3D page is disabled.
- Some algorithms affect the geometry of several dimensions,
i.e. 1D+2D or 1D+2D+3D. If such an algorithm is selected, the
dialog pages related to the corresponding lower dimensions are
disabled.
- \b 0D page refers to 0D geometry (vertices) rather than
to 0D elements. Mesh module does not provide algorithms that
produce 0D elements. Currently \b 0D page provides only one
algorithm "Segments around vertex" that allows specifying the required
size of mesh edges about the selected vertex (or vertices).
For example, you need to mesh a 3D object.
First, you can change a default name of your mesh in the \b Name
box. Then check that the selected geometrical object indicated in
\b Geometry field, is what you wish to mesh; if not, select
the correct object in the Object Browser. Click "Select" button
near \b Geometry field if the name of the object has not yet
appeared in \b Geometry field.
<center>
\image html image120.png
<em>"Select" button</em>
</center>
Now you can define 3D Algorithm and 3D Hypotheses, which will be
applied to discretize the solids of your geometrical object using
3D elements. Click the <em>"Add Hypothesis"</em> button to create
and add a hypothesis.
<center>
\image html image121.png
<em>"Add Hypothesis" button</em>
</center>
Click the <em>"Plus"</em> button to enable adding more additional hypotheses.
Click the <em>"Edit Hypothesis"</em> button to change the values for the
current hypothesis.
<center>
\image html image122.png
<em>"Edit Hypothesis" button</em>
</center>
Most 2D and 3D algorithms can work without hypotheses using
default meshing parameters. Some algorithms do not require any
hypotheses. After selection of an algorithm "Hypothesis" field of
the dialog can contain:
<ul>
<li> <em>\<Default\></em> if the algorithm can work using default
parameters.</li>
<li> <em>\<None\></em> if the algorithm requires a hypothesis defining
its parameters.</li>
<li> If the algorithm does not use hypotheses, this field is grayed.</li>
</ul>
After selection of an algorithm <b>Add. Hypothesis</b> field can contain:
<ul>
<li> <em>\<None\></em> if the algorithm can be tuned
using an additional hypothesis.</li>
<li> If the algorithm does not use additional hypotheses, this field is grayed.</li>
</ul>
Proceed in the same way with 2D and 1D Algorithms and Hypotheses that
will be used to mesh faces and edges of your geometry. (Note
that any object has edges, even if their existence is not
apparent, for example, a sphere has 4 edges). Note that the
choice of hypotheses and lower dimension algorithms depends on
the higher dimension algorithm.
If you wish you can select other algorithms and/or hypotheses
for meshing some sub-shapes of your CAD model by \ref constructing_submeshes_page.
Some algorithms generate mesh of several dimensions, while others
produce mesh of only one dimension. In the latter case there must
be one Algorithm and zero or several
Hypotheses for each dimension of your object, otherwise you will
not get any mesh at all. Of course, if you wish to mesh a face,
which is a 2D object, you do not need to define a 3D Algorithm and
Hypotheses.
In the <b>Object Browser</b> the structure of the new mesh is
displayed as follows:
\image html image88.jpg
It contains:
<ul>
<li>a mesh name (<em>Mesh_mechanic</em>);
<li>a reference to the geometrical object on the basis of
which the mesh has been constructed (\a mechanic);</li>
<li><b>Applied hypotheses</b> folder containing the references
to the hypotheses chosen at the construction of the mesh;</li>
<li><b>Applied algorithms</b> folder containing the references
to the algorithms chosen at the construction of the mesh.</li>
<li><b>SubMeshes on Face</b> folder containing the sub-meshes
defined on geometrical faces. There also can be folders for
sub-meshes on vertices, edges, wires, shells, solids and
compounds.</li>
<li><b>Groups of Faces</b> folder containing the groups of mesh
faces. There also can be folders for groups of nodes, edges,
volumes 0D elements and balls.</li>
</ul>
There is an alternative way to assign Algorithms and Hypotheses by
clicking <b>Assign a set of hypotheses</b> button and selecting among
pre-defined sets of algorithms and hypotheses. In addition to the built-in
sets of hypotheses, it is possible to create custom sets by editing
CustomMeshers.xml file located in the home directory. CustomMeshers.xml
file must describe sets of hypotheses in the
same way as ${SMESH_ROOT_DIR}/share/salome/resources/smesh/StdMeshers.xml
file does (sets of hypotheses are enclosed between \<hypotheses-set-group\>
tags). For example:
~~~~~~{.xml}
<?xml version='1.0' encoding='us-ascii'?>
<!DOCTYPE meshers PUBLIC "" "desktop.dtd">
<meshers>
<hypotheses-set-group>
<hypotheses-set name="My favorite hypotheses"
hypos="AutomaticLength"
algos="CompositeSegment_1D, Quadrangle_2D, GHS3D_3D"/>
</hypotheses-set-group>
</meshers>
~~~~~~
If the file contents are incorrect, there can be an error at
activation of Mesh module: <em>"fatal parsing error: error
triggered by consumer in line ..."</em>
<br>
<center>
\image html hypo_sets.png
List of sets of hypotheses. Tag <em>[custom]</em> is
automatically added to the sets defined by the user.
</center>
\note
- \a "Automatic" in the names of predefined sets of hypotheses
does not actually mean that they are suitable for meshing any
geometry.
- The list of sets of hypotheses can be shorter than in the
above image depending on the geometry dimension.
</li>
</ol>
Consider trying a sample script for construction of a mesh from our
\ref tui_creating_meshes_page "TUI Scripts" section.
\anchor evaluate_anchor
<h2>Evaluating mesh size</h2>
After the mesh object is created and all hypotheses are assigned and
before \ref compute_anchor "Compute" operation, it is possible to
calculate the eventual mesh size. For this, select the mesh in
the <b>Object Browser</b> and from the \b Mesh menu select \b
Evaluate. The result of evaluation will be displayed in the following
information box:
\image html mesh_evaluation_succeed.png
\anchor preview_anchor
<h2>Previewing the mesh</h2>
Before \ref compute_anchor "the mesh computation", it is also possible
to see the mesh preview. This operation allows to incrementally
compute the mesh, dimension by dimension, and to discard an
unsatisfactory mesh.
For this, select the mesh in the Object Browser. From the \b Mesh menu
select \b Preview or click "Preview" button in the toolbar or activate
"Preview" item from the pop-up menu.
<center>
\image html mesh_precompute.png
<em>"Preview" button</em>
</center>
Select <b>1D mesh</b> or <b>2D mesh</b> preview mode in the Preview dialog.
\image html preview_mesh_1D.png "1D mesh preview shows nodes computed on geometry edges"
<br>
\image html preview_mesh_2D.png "2D mesh preview shows edge mesh elements, computed on geometry faces"
<b>Compute</b> button computes the whole mesh.
When the Preview dialog is closed, the question about the storage of temporarily
created mesh elements appears:
\image html preview_tmp_data.png
These elements can be kept in the mesh.
\anchor submesh_order_anchor
<h2>Changing sub-mesh priority</h2>
If the mesh contains concurrent \ref constructing_submeshes_page "sub-meshes",
it is possible to change the priority of their computation, i.e. to
change the priority of applying algorithms to the shared sub-shapes of
the Mesh shape.
<em>To change sub-mesh priority:</em>
Choose "Change sub-mesh priority" from the Mesh menu or a pop-up
menu. The opened dialog shows a list of sub-meshes in the order of
their priority.
There is an example of sub-mesh order modifications taking a Mesh created on a Box
shape. The main Mesh object:
<ul>
<li><i>1D</i> <b>Wire discretisation</b> with <b>Number of Segments</b>=20</li>
<li><i>2D</i> <b>Triangle: Mefisto</b> with Hypothesis<b>Max Element Area</b>
</li>
</ul>
The first sub-mesh <b>Submesh_1</b> created on <b>Face_1</b> is:
<ul>
<li><i>1D</i> <b>Wire discretisation</b> with <b>Number of Segments</b>=4</li>
<li><i>2D</i> <b>Triangle: Mefisto</b> with Hypothesis <b>MaxElementArea</b>=1200</li>
</ul>
The second sub-mesh <b>Submesh_2</b> created on <b>Face_2</b> is:
<ul>
<li><i>1D</i> <b>Wire discretisation</b> with <b>Number of Segments</b>=8</li>
<li><i>2D</i> <b>Triangle: Mefisto</b> with Hypothesis <b>MaxElementArea</b>=1200</li>
</ul>
And the last sub-mesh <b>Submesh_3</b> created on <b>Face_3</b> is:
<ul>
<li><i>1D</i> <b>Wire discretisation</b> with <b>Number of Segments</b>=12</li>
<li><i>2D</i> <b>Triangle: Mefisto</b> with Hypothesis <b>MaxElementArea</b>=1200</li>
</ul>
The sub-meshes become concurrent if they share sub-shapes that can be
meshed with different algorithms (or different hypotheses). In the
example, we have three sub-meshes with concurrent algorithms, because
they have different hypotheses.
The first mesh computation is made with:
<center>
\image html mesh_order_123.png
<em>"Mesh order SubMesh_1, SubMesh_2, SubMesh_3"</em></center>
<center>
\image html mesh_order_123_res.png
<em>"Result mesh with order SubMesh_1, SubMesh_2, SubMesh_3 "</em></center>
The next mesh computation is made with:
<center>
\image html mesh_order_213.png
<em>"Mesh order SubMesh_2, SubMesh_1, SubMesh_3"</em></center>
<center>
\image html mesh_order_213_res.png
<em>"Result mesh with order SubMesh_2, SubMesh_1, SubMesh_3 "</em></center>
And the last mesh computation is made with:
<center>
\image html mesh_order_321.png
<em>"Mesh order SubMesh_3, SubMesh_2, SubMesh_1"</em></center>
<center>\image html mesh_order_321_res.png
<em>"Result mesh with order SubMesh_3, SubMesh_2, SubMesh_1 "</em></center>
As we can see, each mesh computation has a different number of result
elements and a different mesh discretization on the shared edges (the edges
that are shared between <b>Face_1</b>, <b>Face_2</b> and <b>Face_3</b>)
Additionally, sub-mesh priority (the order of applied algorithms) can
be modified not only in a separate dialog box, but also in
the <b>Preview</b>. This helps to preview different mesh results,
modifying the order of sub-meshes.
<center>
\image html mesh_order_preview.png
<em>"Preview with sub-mesh priority list box"</em></center>
If there are no concurrent sub-meshes under the Mesh object, the user
will see the following information.
<center>
\image html mesh_order_no_concurrent.png
<em>"No concurrent submeshes detected"</em></center>
\anchor compute_anchor
<h2>Computing the mesh</h2>
It is equally possible to skip \ref evaluate_anchor "the Evaluation"
and \ref preview_anchor "the Preview" and to \b Compute the mesh after
the hypotheses are assigned. For this, select your mesh in
the <b>Object Browser</b>. From the \b Mesh menu or the context menu
select \b Compute or click \a "Compute" button of the toolbar.
<center>
\image html image28.png
<em>"Compute" button</em>
</center>
After the mesh computation finishes, the Mesh Computation information
box appears. If you close this box and click "Compute" button again,
without previously changing meshing parameters, the mesh will NOT be
re-computed and the Mesh Computation information box will be shown
with the same contents. (To fully re-compute the mesh, invoke
\ref clear_mesh_anchor "Clear Mesh Data" command before).
\anchor meshing_result_anchor
If the mesh computation has been a success, the box shows information
on the number of entities of different types in the mesh.
\image html meshcomputationsucceed.png
\anchor meshing_failed_anchor
If the mesh computation has failed, the information about the cause of the
failure is provided in \b Errors table.
\image html meshcomputationfail.png
After you select an error in \b Errors table, <b>Show Sub-shape</b> button allows
visualizing in magenta the geometrical entity meshing of which failed
(Name of this entity or its ID and type is shown in \a Sub-shape column).
<center>
\image html failed_computation.png
<em>3D algorithm failed to compute mesh on a box shown using <b>Show
Sub-shape</b> button</em>
</center>
<b>Publish Sub-shape</b> button publishes the sub-shape, whose meshing
has failed, in the Geometry component as a child of the main shape, which
allows analyzing the problematic geometry and creating a sub-mesh on it in
order to locally tune the hypotheses.
If the failure is caused by an invalid input mesh and the algorithm has
found which mesh entities are bad, <b>Show bad Mesh</b>
button appears in the dialog. Clicked, it shows the bad mesh entities in
the Viewer in magenta. Sometimes the shown mesh entities are too small
or/and hidden by other mesh elements. They can be seen after
switching the mesh to Wireframe visualization mode or switching off
the visualization of faces and volumes (if any).
<b>Bad Mesh to Group</b> button creates groups of bad mesh entities
to facilitate their analysis.
<center>
\image html show_bad_mesh.png
<em>Edges bounding a hole in the surface are shown in magenta using <b>Show
bad Mesh</b> button</em>
</center>
\note Mesh Computation Information box does not appear if you set
\ref show_comp_result_pref "Mesh computation/Show a computation result notification" preference
to the "Never" value. This option gives the possibility to control mesh
computation reporting. There are the following possibilities: always
show the information box, show only if an error occurs or never.
By default, the information box is always shown after mesh computation operation.
<p><p>
\anchor edit_anchor
<h2>Editing the mesh</h2>
It is possible to \ref modifying_meshes_page "edit the mesh" of a
lower dimension before generation of the mesh of a higher dimension.
For example you can generate a 2D mesh, modify it using e.g.
\ref pattern_mapping_page, and then generate a 3D mesh basing on the
modified 2D mesh. The workflow is as follows:
- Define 1D and 2D meshing algorithms.
- Compute the mesh. 2D mesh is generated.
- Apply \ref pattern_mapping_page.
- Define 3D meshing algorithms without modifying 1D and 2D algorithms
and hypotheses.
- Compute the mesh. 3D mesh is generated.
\note Nodes and elements added \ref adding_nodes_and_elements_page
"manually" cannot be used in this workflow because the manually created
entities are not attached to any geometry and thus (usually) cannot be
found by the mesher paving a geometry.
<b>See Also</b> a sample TUI Script demonstrates the possibility of
\ref tui_editing_while_meshing "Intermediate edition while meshing"
*/

435
doc/salome/gui/SMESH/input/constructing_meshes.rst Normal file
View File

@ -0,0 +1,435 @@
.. _constructing_meshes_page:
*******************
Constructing meshes
*******************
To create a mesh on geometry, it is necessary to create a mesh object by choosing
* a geometrical shape produced in the Geometry module (*main shape*);
* *meshing parameters*, including
* :ref:`basic_meshing_algos_page` and
* :ref:`about_hypo_page` specifying constraints to be taken into account by the chosen meshing algorithms.
Then you can launch mesh generation by invoking :ref:`compute_anchor` command.
The generated mesh will be automatically shown in the Viewer. You can
switch off automatic visualization or limit mesh size until which it is
automatically shown in :ref:`mesh_preferences_page` (**Automatic update** entry).
.. note::
Sometimes *hypotheses* term is used to refer to both algorithms and hypotheses.
Mesh generation on the geometry is performed in the bottom-up
flow: nodes on vertices are created first, then edges are divided into
segments using nodes on vertices; the nodes of segments are then
used to mesh faces; then the nodes of faces are used to mesh
solids. This automatically assures the conformity of the mesh.
It is required to choose a meshing algorithm for every dimension of
sub-shapes up to the highest dimension to be generated. Note
that some algorithms generate elements of several dimensions, and
others of only one. It is not necessary to define meshing
parameters for all dimensions at once; you can start from 1D
meshing parameters only, compute the 1D mesh, then define 2D meshing
parameters and compute the 2D mesh (note that 1D mesh will not be
re-computed).
An algorithm of a certain dimension chosen at mesh creation is applied
to discretize every sub-shape of this dimension. It is possible to
specify a different algorithm or hypothesis to be applied to one or
a group of sub-shapes by creating a :ref:`constructing_submeshes_page`.
You can specify no algorithms at all at mesh object
creation and specify the meshing parameters on sub-meshes only; then
only the sub-shapes, for which an algorithm and a hypothesis (if any)
have been defined will be discretized.
.. note:: Construction of a mesh on a geometry includes at least two (:ref:`create_mesh_anchor` and :ref:`compute_anchor`) of the following steps:
* :ref:`create_mesh_anchor`, where you can specify meshing parameters to apply to all sub-shapes of the main shape.
* :ref:`constructing_submeshes_page`, (optional) where you can specify meshing parameters to apply to the selected sub-shapes.
* :ref:`evaluate_anchor` (optional) can be used to know an approximate number of elements before their actual generation.
* :ref:`preview_anchor` (optional) can be used to generate mesh of only lower dimension(s) in order to visually estimate it before full mesh generation, which can be much longer.
* :ref:`submesh_order_anchor` (optional) can be useful if there are concurrent sub-meshes defined.
* :ref:`compute_anchor` uses defined meshing parameters to generate mesh elements.
* :ref:`edit_anchor` (optional) can be used to :ref:`modifying_meshes_page` the mesh of a lower dimension before :ref:`compute_anchor` elements of an upper dimension.
.. _create_mesh_anchor:
Creation of a mesh object
#########################
**To construct a mesh:**
#. Select a geometrical object for meshing.
#. In the **Mesh** menu select **Create Mesh** or click **"Create Mesh"** button in the toolbar.
.. image:: ../images/image32.png
:align: center
.. centered::
**"Create Mesh" button**
The following dialog box will appear:
.. image:: ../images/createmesh-inv.png
:align: center
#. To filter off irrelevant meshing algorithms, you can select **Mesh Type** in the corresponding list from **Any, Hexahedral, Tetrahedral, Triangular** and **Quadrilateral** (there can be less items for the geometry of lower dimensions). Selection of a mesh type hides all meshing algorithms that cannot generate elements of this type.
#. Apply :ref:`basic_meshing_algos_page` and :ref:`about_hypo_page` which will be used to compute this mesh.
"Create mesh" dialog box contains several tab pages titled **3D**, **2D**, **1D** and **0D**. The title of each page reflects the dimension of the sub-shapes the algorithms listed on this page affect and the maximal dimension of elements the algorithms generate. For example, **3D** page lists the algorithms that affect 3D sub-shapes (solids) and generate 3D mesh elements (tetrahedra, hexahedra etc.)
As soon as you have selected an algorithm, you can create a hypothesis (or select an already created one). A set of accessible hypotheses includes only the hypotheses that can be used by the selected algorithm.
.. note::
* Some page(s) can be disabled if the geometrical object does not include shapes (sub-shapes) of the corresponding dimension(s). For example, if the input object is a geometrical face, **3D** page is disabled.
* Some algorithms affect the geometry of several dimensions, i.e. 1D+2D or 1D+2D+3D. If such an algorithm is selected, the dialog pages related to the corresponding lower dimensions are disabled.
* **0D** page refers to 0D geometry (vertices) rather than to 0D elements. Mesh module does not provide algorithms that produce 0D elements. Currently **0D** page provides only one algorithm "Segments around vertex" that allows specifying the required size of mesh edges about the selected vertex (or vertices).
For example, you need to mesh a 3D object.
First, you can change a default name of your mesh in the **Name** box. Then check that the selected geometrical object indicated in **Geometry** field, is what you wish to mesh; if not, select the correct object in the Object Browser. Click "Select" button near **Geometry** field if the name of the object has not yet appeared in **Geometry** field.
.. image:: ../images/image120.png
:align: center
.. centered::
**"Select" button**
Now you can define 3D Algorithm and 3D Hypotheses, which will be applied to discretize the solids of your geometrical object using 3D elements. Click the **"Add Hypothesis"** button to create and add a hypothesis.
.. image:: ../images/image121.png
:align: center
.. centered::
**"Add Hypothesis" button**
Click the **"Plus"** button to enable adding more additional hypotheses.
Click the **"Edit Hypothesis"** button to change the values for the current hypothesis.
.. image:: ../images/image122.png
:align: center
.. centered::
**"Edit Hypothesis" button**
Most 2D and 3D algorithms can work without hypotheses using default meshing parameters. Some algorithms do not require any hypotheses. After selection of an algorithm "Hypothesis" field of the dialog can contain:
* **\<Default\>** if the algorithm can work using default parameters.
* **\<None\>** if the algorithm requires a hypothesis defining its parameters.
* If the algorithm does not use hypotheses, this field is grayed.
After selection of an algorithm **Add. Hypothesis** field can contain:
* **\<None\>** if the algorithm can be tuned using an additional hypothesis.
* If the algorithm does not use additional hypotheses, this field is grayed.
Proceed in the same way with 2D and 1D Algorithms and Hypotheses that will be used to mesh faces and edges of your geometry. (Note that any object has edges, even if their existence is not apparent, for example, a sphere has 4 edges). Note that the choice of hypotheses and lower dimension algorithms depends on the higher dimension algorithm.
If you wish you can select other algorithms and/or hypotheses for meshing some sub-shapes of your CAD model by :ref:`constructing_submeshes_page`.
Some algorithms generate mesh of several dimensions, while others produce mesh of only one dimension. In the latter case there must be one Algorithm and zero or several Hypotheses for each dimension of your object, otherwise you will not get any mesh at all. Of course, if you wish to mesh a face, which is a 2D object, you do not need to define a 3D Algorithm and Hypotheses.
In the **Object Browser** the structure of the new mesh is displayed as follows:
.. image:: ../images/image88.jpg
:align: center
It contains:
* a mesh name (**Mesh_mechanic**);
* a reference to the geometrical object on the basis of which the mesh has been constructed (*mechanic*);
* **Applied hypotheses** folder containing the references to the hypotheses chosen at the construction of the mesh;
* **Applied algorithms** folder containing the references to the algorithms chosen at the construction of the mesh.
* **SubMeshes on Face** folder containing the sub-meshes defined on geometrical faces. There also can be folders for sub-meshes on vertices, edges, wires, shells, solids and compounds.
* **Groups of Faces** folder containing the groups of mesh faces. There also can be folders for groups of nodes, edges, volumes 0D elements and balls.
There is an alternative way to assign Algorithms and Hypotheses by clicking **Assign a set of hypotheses** button and selecting among pre-defined sets of algorithms and hypotheses. In addition to the built-in sets of hypotheses, it is possible to create custom sets by editing CustomMeshers.xml file located in the home directory. CustomMeshers.xml file must describe sets of hypotheses in the same way as ${SMESH_ROOT_DIR}/share/salome/resources/smesh/StdMeshers.xml file does (sets of hypotheses are enclosed between \<hypotheses-set-group\> tags). For example:
::
<?xml version='1.0' encoding='us-ascii'?>
<!DOCTYPE meshers PUBLIC "" "desktop.dtd">
<meshers>
<hypotheses-set-group>
<hypotheses-set name="My favorite hypotheses"
hypos="AutomaticLength"
algos="CompositeSegment_1D, Quadrangle_2D, GHS3D_3D"/>
</hypotheses-set-group>
</meshers>
If the file contents are incorrect, there can be an error at activation of Mesh module: **"fatal parsing error: error triggered by consumer in line ..."**
.. image:: ../images/hypo_sets.png
:align: center
List of sets of hypotheses. Tag **[custom]** is automatically added to the sets defined by the user.
.. note::
* *"Automatic"* in the names of predefined sets of hypotheses does not actually mean that they are suitable for meshing any geometry.
* The list of sets of hypotheses can be shorter than in the above image depending on the geometry dimension.
Consider trying a sample script for construction of a mesh from our :ref:`tui_creating_meshes_page` section.
.. _evaluate_anchor:
Evaluating mesh size
####################
After the mesh object is created and all hypotheses are assigned and before :ref:`compute_anchor` operation, it is possible to calculate the eventual mesh size. For this, select the mesh in the **Object Browser** and from the **Mesh** menu select **Evaluate**.
The result of evaluation will be displayed in the following information box:
.. image:: ../images/mesh_evaluation_succeed.png
:align: center
.. _preview_anchor:
Previewing the mesh
###################
Before :ref:`compute_anchor` , it is also possible to see the mesh preview. This operation allows to incrementally compute the mesh, dimension by dimension, and to discard an unsatisfactory mesh.
For this, select the mesh in the Object Browser. From the **Mesh** menu select **Preview** or click "Preview" button in the toolbar or activate "Preview" item from the pop-up menu.
.. image:: ../images/mesh_precompute.png
:align: center
.. centered::
**"Preview" button**
Select **1D mesh** or **2D mesh** preview mode in the Preview dialog.
.. image:: ../images/preview_mesh_1D.png
:align: center
.. centered::
"1D mesh preview shows nodes computed on geometry edges"
.. image:: ../images/preview_mesh_2D.png
:align: center
.. centered::
"2D mesh preview shows edge mesh elements, computed on geometry faces"
**Compute** button computes the whole mesh.
When the Preview dialog is closed, the question about the storage of temporarily created mesh elements appears:
.. image:: ../images/preview_tmp_data.png
:align: center
These elements can be kept in the mesh.
.. _submesh_order_anchor:
Changing sub-mesh priority
##########################
If the mesh contains concurrent :ref:`constructing_submeshes_page`, it is possible to change the priority of their computation, i.e. to change the priority of applying algorithms to the shared sub-shapes of the Mesh shape.
**To change sub-mesh priority:**
Choose "Change sub-mesh priority" from the Mesh menu or a pop-up menu. The opened dialog shows a list of sub-meshes in the order of their priority.
There is an example of sub-mesh order modifications taking a Mesh created on a Box shape. The main Mesh object:
* *1D* **Wire discretisation** with **Number of Segments** =20
* *2D* **Triangle: Mefisto** with Hypothesis **Max Element Area**
The first sub-mesh **Submesh_1** created on **Face_1** is:
* *1D* **Wire discretisation** with **Number of Segments** =4
* *2D* **Triangle: Mefisto** with Hypothesis **MaxElementArea** =1200
The second sub-mesh **Submesh_2** created on **Face_2** is:
* *1D* **Wire discretisation** with **Number of Segments** =8
* *2D* **Triangle: Mefisto** with Hypothesis **MaxElementArea** =1200
And the last sub-mesh **Submesh_3** created on **Face_3** is:
* *1D* **Wire discretisation** with **Number of Segments** =12
* *2D* **Triangle: Mefisto** with Hypothesis **MaxElementArea** =1200
The sub-meshes become concurrent if they share sub-shapes that can be meshed with different algorithms (or different hypotheses). In the example, we have three sub-meshes with concurrent algorithms, because they have different hypotheses.
The first mesh computation is made with:
.. image:: ../images/mesh_order_123.png
:align: center
.. centered::
**"Mesh order SubMesh_1, SubMesh_2, SubMesh_3"**
.. image:: ../images/mesh_order_123_res.png
:align: center
.. centered::
**"Result mesh with order SubMesh_1, SubMesh_2, SubMesh_3 "**
The next mesh computation is made with:
.. image:: ../images/mesh_order_213.png
:align: center
.. centered::
**"Mesh order SubMesh_2, SubMesh_1, SubMesh_3"**
.. image:: ../images/mesh_order_213_res.png
:align: center
.. centered::
**"Result mesh with order SubMesh_2, SubMesh_1, SubMesh_3 "**
And the last mesh computation is made with:
.. image:: ../images/mesh_order_321.png
:align: center
.. centered::
**"Mesh order SubMesh_3, SubMesh_2, SubMesh_1"**
.. image:: ../images/mesh_order_321_res.png
:align: center
.. centered::
**"Result mesh with order SubMesh_3, SubMesh_2, SubMesh_1 "**
As we can see, each mesh computation has a different number of result
elements and a different mesh discretization on the shared edges (the edges
that are shared between **Face_1**, **Face_2** and **Face_3**)
Additionally, sub-mesh priority (the order of applied algorithms) can
be modified not only in a separate dialog box, but also in
the **Preview**. This helps to preview different mesh results,
modifying the order of sub-meshes.
.. image:: ../images/mesh_order_preview.png
:align: center
.. centered::
**"Preview with sub-mesh priority list box"**
If there are no concurrent sub-meshes under the Mesh object, the user
will see the following information.
.. image:: ../images/mesh_order_no_concurrent.png
:align: center
.. centered::
**"No concurrent submeshes detected"**
.. _compute_anchor:
Computing the mesh
##################
It is equally possible to skip :ref:`evaluate_anchor`
and :ref:`preview_anchor` and to **Compute** the mesh after
the hypotheses are assigned. For this, select your mesh in
the **Object Browser**. From the **Mesh** menu or the context menu
select **Compute** or click *"Compute"* button of the toolbar.
.. image:: ../images/image28.png
:align: center
.. centered::
**"Compute" button**
After the mesh computation finishes, the Mesh Computation information
box appears. If you close this box and click "Compute" button again,
without previously changing meshing parameters, the mesh will NOT be
re-computed and the Mesh Computation information box will be shown
with the same contents. (To fully re-compute the mesh, invoke
:ref:`clear_mesh_anchor` command before).
.. _meshing_result_anchor:
Meshing Results
===============
If the mesh computation has been a success, the box shows information on the number of entities of different types in the mesh.
.. image:: ../images/meshcomputationsucceed.png
:align: center
.. _meshing_failed_anchor:
Meshing Failed
==============
If the mesh computation has failed, the information about the cause of the failure is provided in **Errors** table.
.. image:: ../images/meshcomputationfail.png
:align: center
After you select an error in **Errors** table, **Show Sub-shape** button allows
visualizing in magenta the geometrical entity meshing of which failed
(Name of this entity or its ID and type is shown in *Sub-shape* column).
.. image:: ../images/failed_computation.png
:align: center
.. centered::
3D algorithm failed to compute mesh on a box shown using **Show Sub-shape** button
**Publish Sub-shape** button publishes the sub-shape, whose meshing
has failed, in the Geometry component as a child of the main shape, which
allows analyzing the problematic geometry and creating a sub-mesh on it in
order to locally tune the hypotheses.
If the failure is caused by an invalid input mesh and the algorithm has
found which mesh entities are bad, **Show bad Mesh**
button appears in the dialog. Clicked, it shows the bad mesh entities in
the Viewer in magenta. Sometimes the shown mesh entities are too small
or/and hidden by other mesh elements. They can be seen after
switching the mesh to Wireframe visualization mode or switching off
the visualization of faces and volumes (if any).
**Bad Mesh to Group** button creates groups of bad mesh entities to facilitate their analysis.
.. image:: ../images/show_bad_mesh.png
:align: center
Edges bounding a hole in the surface are shown in magenta using **Show bad Mesh** button
.. note::
Mesh Computation Information box does not appear if you set :ref:`show_comp_result_pref` preference to the "Never" value. This option gives the possibility to control mesh computation reporting. There are the following possibilities: always show the information box, show only if an error occurs or never. By default, the information box is always shown after mesh computation operation.
.. _edit_anchor:
Editing the mesh
################
It is possible to :ref:`modifying_meshes_page` of a
lower dimension before generation of the mesh of a higher dimension.
For example you can generate a 2D mesh, modify it using e.g. :ref:`pattern_mapping_page`, and then generate a 3D mesh basing on the modified 2D mesh. The workflow is as follows:
* Define 1D and 2D meshing algorithms.
* Compute the mesh. 2D mesh is generated.
* Apply :ref:`pattern_mapping_page`.
* Define 3D meshing algorithms without modifying 1D and 2D algorithms and hypotheses.
* Compute the mesh. 3D mesh is generated.
.. note::
Nodes and elements added :ref:`adding_nodes_and_elements_page` cannot be used in this workflow because the manually created entities are not attached to any geometry and thus (usually) cannot be found by the mesher paving a geometry.
**See Also** a sample TUI Script demonstrates the possibility of :ref:`tui_editing_while_meshing`.
.. toctree::
:maxdepth: 2
basic_meshing_algos.rst
about_hypo.rst

159
doc/salome/gui/SMESH/input/constructing_submeshes.doc
View File

@ -1,159 +0,0 @@
/*!
\page constructing_submeshes_page Constructing sub-meshes
\tableofcontents
By purpose, the sub-mesh is an object used to assign to a sub-shape
different meshing parameters than those assigned to the main shape.
Structurally, the sub-mesh is a mesh on a certain sub-shape, or a group of
sub-shapes, possibly generated using different meshing algorithms
and/or hypotheses than those used to generate the mesh on other
sub-shapes.
Creation of a sub-mesh allows to control individually meshing of a
certain sub-shape, thus to get a locally coarser or finer mesh, to get
elements of different types in the same mesh, etc.
A sub-mesh can be meshed individually. To achieve this, select a
sub-mesh and either invoke <b>Compute Sub-mesh</b> vai the contextual
menu in the Object Browser or invoke <b> Mesh > Compute </b> menu.
\section submesh_shape_section How to get a sub-shape for sub-mesh construction
A sub-shape to create a sub-mesh on should be retrieved from the main shape
in one of the following ways: <ul>
<li> In Geometry module, via <em>New Entity > Explode</em> menu.</li>
<li> In Geometry module, by creation of a group (<em>New Entity >
Group > Create Group</em> menu).</li>
<li> In Mesh module, by
\ref subshape_by_mesh_elem "selecting a mesh element" generated on a
sub-shape of interest. This way is accessible if the mesh is
already computed.</li>
<li> In Mesh module, by clicking <em>Publish Sub-shape</em> button in a
dialog showing \ref meshing_failed_anchor "meshing errors".</li>
</ul>
\section submesh_priority How hypotheses are selected among sub-meshes
Internally, definition of meshing parameters to apply for
discretization of a certain sub-shape, for example an edge of a
compound of solids, starts from searching an algorithm, 1D as for the
edge. The following sub-shapes are sequentially checked for presence
of a sub-mesh where 1D algorithm is assigned:
<ul>
<li> the \b edge itself</li>
<li> <b>groups of edges</b> containing the edge, if any</li>
<li> \b wires sharing the edge</li>
<li> \b faces sharing the edge</li>
<li> <b>groups of faces</b> sharing the edge, if any</li>
<li> \b shells sharing the edge</li>
<li> \b solids sharing the edge</li>
<li> <b>groups of solids</b> sharing the edge, if any</li>
<li> the <b>main shape</b></li>
</ul>
(This sequence of sub-shapes defines the priority of sub-meshes. Thus more
local, i.e. assigned to sub-shape of lower dimension, algorithms and
hypotheses have higher priority during the search of hypotheses to
apply.)
As soon as a 1D algorithm is found, the search stops and the same
sequence of sub-shapes is checked to find the main and additional 1D
hypotheses, which can be taken into account by the found 1D algorithm.
The multi-dimensional algorithms have a higher priority than
uni-dimensional ones if they are assigned to sub-meshes of the
same priority.
If meshing parameters are defined on sub-meshes of the same priority,
for example, different 1D hypotheses are assigned to two faces sharing
an edge, the hypothesis assigned to a sub-shape with a lower ID will
be used for meshing. You can \ref submesh_order_anchor "change" mutual
priority of such concurrent sub-meshes.
\section submesh_definition How to construct a sub-mesh
\n Construction of a sub-mesh consists of:
<ul>
<li>Selecting a mesh which will encapsulate the sub-mesh</li>
<li>Selecting a sub-shape for meshing</li>
<li>Applying one or several
\ref about_hypo_page "hypotheses" and
\ref basic_meshing_algos_page "meshing algorithms" which will be used
for discretization of this sub-shape.</li>
</ul>
<br><em>To construct a sub-mesh:</em>
\par
From the \b Mesh menu select <b>Create Sub-mesh</b> or click <em>"Create
Sum-mesh"</em> button in the toolbar.
<center>
\image html image33.gif
<em>"Create Sub-mesh" button</em>
</center>
\par
The following dialog box will appear:
\par
\image html createmesh-inv2.png
It allows to define the \b Name, the parent \b Mesh and the \b
Geometry (e.g. a face if the parent mesh has been built on box) of the
sub-mesh. You can define meshing algorithms and hypotheses in the same way as
in \ref constructing_meshes_page "Create mesh" dialog.
Later you can change the applied hypotheses or their parameters in
\ref editing_meshes_page "Edit mesh/sub-mesh" dialog. Mesh entities
generated using changed hypotheses are automatically removed.
\anchor subshape_by_mesh_elem
If the parent mesh is already computed, then you can define the
\b Geometry by picking mesh elements computed on a sub-shape of interest
in the 3D Viewer, i.e. you do not have to extract this sub-shape
in Geometry module beforehand. To start element selection, press \a
Selection button to the right of \b Geometry label. If this button is
already down, then click it to release and then click it again. The
following pop-up menu allowing to choose a way of geometry definition will
appear.
\image html choose_geom_selection_way.png
<b>Direct geometry selection</b> enables selecting the sub-shape in the Object
Browser.
<b>Find geometry by mesh element selection</b> activates the following dialog.
\image html find_geom_by_mesh_elem.png
In this dialog, <b> Element Type </b> defines a kind of element to pick in the
Viewer.
Instead of picking an element in the Viewer, you can type its
ID in <b> Element ID</b> field.
<b> Geometry name </b> field allows defining a name of the sub-shape,
with which the sub-shape will appear in the Object Browser (if not yet
there).
\section submesh_tree Sub-mesh in the Object Browser
In the Object Browser the structure of the new sub-mesh will be
displayed as follows:
\image html image10.jpg
It contains:
<ul>
<li>a sub-mesh name (\a SubMeshFace1)
<li>a reference to the geometrical object on the basis of which the
sub-mesh has been constructed (<em>Cylindrical Face_1</em>);</li>
<li><em>Applied hypotheses</em> folder containing references to
hypotheses assigned to the sub-mesh;</li>
<li><em>Applied algorithms</em> folder containing references to
algorithms assigned to the sub-mesh.</li>
</ul>
<br><b>See Also</b> a sample TUI Script of a
\ref tui_construction_submesh "Construct Sub-mesh" operation.
*/

145
doc/salome/gui/SMESH/input/constructing_submeshes.rst Normal file
View File

@ -0,0 +1,145 @@
.. _constructing_submeshes_page:
***********************
Constructing sub-meshes
***********************
.. contents:: `Table of contents`
By purpose, the sub-mesh is an object used to assign to a sub-shape
different meshing parameters than those assigned to the main shape.
Structurally, the sub-mesh is a mesh on a certain sub-shape, or a group of
sub-shapes, possibly generated using different meshing algorithms
and/or hypotheses than those used to generate the mesh on other
sub-shapes.
Creation of a sub-mesh allows to control individually meshing of a
certain sub-shape, thus to get a locally coarser or finer mesh, to get
elements of different types in the same mesh, etc.
A sub-mesh can be meshed individually. To achieve this, select a
sub-mesh and either invoke **Compute Sub-mesh** vai the contextual
menu in the Object Browser or invoke **Mesh > Compute** menu.
.. _submesh_shape_section:
How to get a sub-shape for sub-mesh construction
################################################
A sub-shape to create a sub-mesh on should be retrieved from the main shape
in one of the following ways:
* In Geometry module, via **New Entity > Explode** menu.
* In Geometry module, by creation of a group (**New Entity > Group > Create Group** menu).
* In Mesh module, by :ref:`subshape_by_mesh_elem` generated on a sub-shape of interest. This way is accessible if the mesh is already computed.
* In Mesh module, by clicking **Publish Sub-shape** button in a dialog showing :ref:`meshing_failed_anchor`.
.. :submesh_priority:
How hypotheses are selected among sub-meshes
############################################
Internally, definition of meshing parameters to apply for
discretization of a certain sub-shape, for example an edge of a
compound of solids, starts from searching an algorithm, 1D as for the
edge. The following sub-shapes are sequentially checked for presence
of a sub-mesh where 1D algorithm is assigned:
* the **edge** itself
* **groups of edges** containing the edge, if any
* **wires** sharing the edge
* **faces** sharing the edge
* **groups of faces** sharing the edge, if any
* **shells** sharing the edge
* **solids** sharing the edge
* **groups of solids** sharing the edge, if any
* the **main shape**
(This sequence of sub-shapes defines the priority of sub-meshes. Thus more
local, i.e. assigned to sub-shape of lower dimension, algorithms and
hypotheses have higher priority during the search of hypotheses to
apply.)
As soon as a 1D algorithm is found, the search stops and the same
sequence of sub-shapes is checked to find the main and additional 1D
hypotheses, which can be taken into account by the found 1D algorithm.
The multi-dimensional algorithms have a higher priority than
uni-dimensional ones if they are assigned to sub-meshes of the
same priority.
If meshing parameters are defined on sub-meshes of the same priority,
for example, different 1D hypotheses are assigned to two faces sharing
an edge, the hypothesis assigned to a sub-shape with a lower ID will
be used for meshing. You can :ref:`submesh_order_anchor` mutual
priority of such concurrent sub-meshes.
.. _submesh_definition:
How to construct a sub-mesh
###########################
.. note:: Construction of a sub-mesh consists of:
* Selecting a mesh which will encapsulate the sub-mesh
* Selecting a sub-shape for meshing
* Applying one or several :ref:`about_hypo_page` and :ref:`basic_meshing_algos_page` which will be used for discretization of this sub-shape.
**To construct a sub-mesh:**
From the **Mesh** menu select **Create Sub-mesh** or click **"Create Sum-mesh"** button in the toolbar.
.. image:: ../images/image33.gif
:align: center
.. centered::
**"Create Sub-mesh" button**
The following dialog box will appear:
.. image:: ../images/createmesh-inv2.png
:align: center
It allows to define the **Name**, the parent **Mesh** and the **Geometry** (e.g. a face if the parent mesh has been built on box) of the sub-mesh. You can define meshing algorithms and hypotheses in the same way as in :ref:`constructing_meshes_page` dialog.
Later you can change the applied hypotheses or their parameters in :ref:`editing_meshes_page` dialog. Mesh entities generated using changed hypotheses are automatically removed.
.. _subshape_by_mesh_elem:
Subshape by mesh element
========================
If the parent mesh is already computed, then you can define the **Geometry** by picking mesh elements computed on a sub-shape of interest in the 3D Viewer, i.e. you do not have to extract this sub-shape in Geometry module beforehand. To start element selection, press *Selection* button to the right of **Geometry** label. If this button is already down, then click it to release and then click it again. The following pop-up menu allowing to choose a way of geometry definition will appear.
.. image:: ../images/choose_geom_selection_way.png
:align: center
**Direct geometry selection** enables selecting the sub-shape in the Objec Browser.
**Find geometry by mesh element selection** activates the following dialog.
.. image:: ../images/find_geom_by_mesh_elem.png
:align: center
In this dialog, **Element Type** defines a kind of element to pick in the Viewer. Instead of picking an element in the Viewer, you can type its ID in **Element ID** field. **Geometry name** field allows defining a name of the sub-shape, with which the sub-shape will appear in the Object Browser (if not yet there).
.. _submesh_tree:
Sub-mesh in the Object Browser
##############################
In the Object Browser the structure of the new sub-mesh will be displayed as follows:
.. image:: ../images/image10.jpg
:align: center
It contains:
* a sub-mesh name (*SubMeshFace1*)
* a reference to the geometrical object on the basis of which the sub-mesh has been constructed (**Cylindrical Face_1**);
* **Applied hypotheses** folder containing references to hypotheses assigned to the sub-mesh;
* **Applied algorithms** folder containing references to algorithms assigned to the sub-mesh.
**See Also** a sample TUI Script of a :ref:`tui_construction_submesh` operation.

59
doc/salome/gui/SMESH/input/convert_to_from_quadratic_mesh.doc
View File

@ -1,59 +0,0 @@
/*!
\page convert_to_from_quadratic_mesh_page Convert to/from Quadratic Mesh
\n This functionality allows transforming linear meshes (or
sub-meshes) to quadratic and vice versa.
Note that conversion of a sub-mesh most probably will produce a
non-conformal mesh. Elements on the boundary between quadratic and
linear sub-meshes become (or remain) quadratic.
See \ref adding_quadratic_elements_page for more information about
quadratic meshes.
<em>To produce a conversion:</em>
<ol>
<li>Select a mesh or a sub-mesh in the Object Browser or in the
Viewer.</li>
<li>From the Modification menu or from the contextual menu in the
Object Browser choose <b> Convert to/from Quadratic Mesh</b> item,
or click <em>"Convert to/from quadratic"</em> button in the
toolbar.
<center>
\image html image154.png
<em>"Convert to/from quadratic" button</em>
</center>
The following dialog box will appear:
\image html convert.png
</li>
<li>In this dialog box specify:
<ul>
<li>If it is necessary to convert a linear mesh to quadratic or a quadratic
mesh to linear. **Convert to bi-quadratic** creates some types of quadratic
elements with additional central nodes: TRIA7, QUAD9 and HEXA27
elements instead of TRIA6, QUAD8, and HEXA20 elements
respectively.</li>
<li>If it is necessary to place **medium nodes** of the quadratic mesh **on the
geometry** (meshed shape). This option is relevant for conversion to
quadratic provided that the mesh is based on a geometry (not imported
from file).</li>
</ul>
\image html image156.gif
<center>Linear mesh (coarse mesh on a torus)</center>
\image html image155.gif
<center>Quadratic mesh</center>
</li>
<li>Click the \b Apply or <b>Apply and Close</b> button.</li>
</ol>
<br><b>See Also</b> a sample TUI Script of a \ref tui_quadratic "Convert to/from quadratic" operation.
*/

54
doc/salome/gui/SMESH/input/convert_to_from_quadratic_mesh.rst Normal file
View File

@ -0,0 +1,54 @@
.. _convert_to_from_quadratic_mesh_page:
****************************************
Convert to/from Quadratic Mesh
****************************************
This functionality allows transforming linear meshes (or sub-meshes) to quadratic and vice versa.
.. Note::
that conversion of a sub-mesh most probably will produce a non-conformal mesh. Elements on the boundary between quadratic and linear sub-meshes become (or remain) quadratic.
See :ref:`adding_quadratic_elements_page` for more information about quadratic meshes.
**To produce a conversion:**
#. Select a mesh or a sub-mesh in the Object Browser or in the Viewer.
#. From the Modification menu or from the contextual menu in the Object Browser choose **Convert to/from Quadratic Mesh** item, or click **"Convert to/from quadratic"** button in the toolbar.
.. image:: ../images/image154.png
:align: center
.. centered::
**"Convert to/from quadratic" button**
The following dialog box will appear:
.. image:: ../images/convert.png
:align: center
#. In this dialog box specify:
* If it is necessary to convert a linear mesh to quadratic or a quadratic mesh to linear. **Convert to bi-quadratic** creates some types of quadratic elements with additional central nodes: TRIA7, QUAD9 and HEXA27 elements instead of TRIA6, QUAD8, and HEXA20 elements respectively.
* If it is necessary to place **medium nodes** of the quadratic mesh **on the geometry** (meshed shape). This option is relevant for conversion to quadratic provided that the mesh is based on a geometry (not imported from file).
.. image:: ../images/image156.gif
:align: center
.. centered::
Linear mesh (coarse mesh on a torus)
.. image:: ../images/image155.gif
:align: center
.. centered::
Quadratic mesh
* Click the **Apply** or **Apply and Close** button.
**See Also** a sample TUI Script of a :ref:`tui_quadratic` operation.

54
doc/salome/gui/SMESH/input/copy_mesh.doc
View File

@ -1,54 +0,0 @@
/*!
\page copy_mesh_page Copy Mesh
\n A mesh can be created by copying a part of or the whole other mesh.
<em>To make a copy of a mesh:</em>
\par
From the contextual menu in the Object Browser of from the \b Mesh
menu select <b>Copy Mesh</b> or click <em>"Copy Mesh"</em> button in
the toolbar.
\image html copy_mesh_icon.png
<center><em>"Copy Mesh" button</em></center>
\par
The following dialog box will appear:
\image html copy_mesh_dlg.png
\par
In the dialog:
<ul>
<li>specify the part of mesh to copy:
<ul>
<li><b>Select whole mesh, sub-mesh or group</b> by mouse activating
this checkbox; or</li>
<li>choose mesh elements with the mouse in the 3D Viewer. It is
possible to select a whole area with a mouse frame; or</li>
<li>input the <b>Source Element IDs</b> directly in this field. The
selected elements will be highlighted in the viewer; or</li>
<li>apply Filters. <b>Set filter</b> button allows to apply a filter
to the selection of elements. See more about filters in the \ref
selection_filter_library_page "Selection filter library" page.</li>
</ul>
</li>
<li>specify the <b>New Mesh Name</b>;</li>
<li>specify the conditions of copying:
<ul>
<li>activate <b>Generate groups</b> checkbox to copy the groups of
the source mesh to the newly created mesh.</li>
</ul>
</li>
<li>Click \b Apply or <b>Apply and Close</b> button to confirm the operation.</li>
</ul>
<b>See Also</b> a sample
\ref tui_copy_mesh "TUI Example of mesh copying."
*/

43
doc/salome/gui/SMESH/input/copy_mesh.rst Normal file
View File

@ -0,0 +1,43 @@
.. _copy_mesh_page:
*********
Copy Mesh
*********
A mesh can be created by copying a part of or the whole other mesh.
**To make a copy of a mesh:**
From the contextual menu in the Object Browser of from the **Mesh** menu select **Copy Mesh** or click **"Copy Mesh"** button in the toolbar.
.. image:: ../images/copy_mesh_icon.png
:align: center
.. centered::
**"Copy Mesh" button**
The following dialog box will appear:
.. image:: ../images/copy_mesh_dlg.png
:align: center
In the dialog:
* specify the part of mesh to copy:
* **Select whole mesh, sub-mesh or group** by mouse activating this checkbox; or
* choose mesh elements with the mouse in the 3D Viewer. It is possible to select a whole area with a mouse frame; or
* input the **Source Element IDs** directly in this field. The selected elements will be highlighted in the viewer; or
* apply Filters. **Set filter** button allows to apply a filter to the selection of elements. See more about filters in the :ref:`selection_filter_library_page` "Selection filter library" page.
* specify the **New Mesh Name**;
* specify the conditions of copying:
* activate **Generate groups** checkbox to copy the groups of the source mesh to the newly created mesh.
* Click **Apply** or **Apply and Close** button to confirm the operation.
**See Also** a sample :ref:`tui_copy_mesh`.

26
doc/salome/gui/SMESH/input/create_groups_from_geometry.doc
View File

@ -1,26 +0,0 @@
/*!
\page create_groups_from_geometry_page Create Groups from Geometry
This operation allows creating groups on geometry on all selected
shapes. Only the main shape of the mesh and its sub-shapes can be selected.
The type of each new group is defined automatically by the nature of
the <b>Geometry</b>.
The group names will be the same as the names of geometrical objects.
\warning It's impossible to create a group of <em>0D elements</em> or <em>ball
elements</em> with this operation. For this, it is necessary to use
\ref creating_groups_page "Create Group" operation.
To use this operation, select in the \b Mesh menu or in the contextual
menu in the Object browser <b>Create Groups from Geometry</b> item.
\image html create_groups_from_geometry.png
In this dialog \b Elements group contains a list of shapes, on which
groups of elements will be created; \b Nodes group contains a list of shapes,
on which groups of nodes will be created.
*/

22
doc/salome/gui/SMESH/input/create_groups_from_geometry.rst Normal file
View File

@ -0,0 +1,22 @@
.. _create_groups_from_geometry_page:
***************************
Create Groups from Geometry
***************************
This operation allows creating groups on geometry on all selected shapes. Only the main shape of the mesh and its sub-shapes can be selected.
The type of each new group is defined automatically by the nature of the **Geometry**.
The group names will be the same as the names of geometrical objects.
.. warning:: It's impossible to create a group of **0D elements** or **ball elements** with this operation. For this, it is necessary to use :ref:`creating_groups_page` operation.
To use this operation, select in the **Mesh** menu or in the contextual menu in the Object browser **Create Groups from Geometry** item.
.. image:: ../images/create_groups_from_geometry.png
:align: center
In this dialog **Elements** group contains a list of shapes, on which groups of elements will be created; **Nodes** group contains a list of shapes, on which groups of nodes will be created.

145
doc/salome/gui/SMESH/input/creating_groups.doc
View File

@ -1,145 +0,0 @@
/*!
\page creating_groups_page Creating groups
\n In MESH you can create a \ref grouping_elements_page "group" of
elements of a certain type. The main way to create a group, is to
select in the \b Mesh menu <b>Create Group</b> item (also available in
the context menu of the mesh).<br>
To create a group you should define the following:
<ul>
<li><b>Mesh</b> - the mesh whose elements will form your
group. You can select your mesh in the Objet Browser or in the 3D
viewer.</li>
<li><b>Elements Type</b> - set of radio buttons allows to select the type of
elements which will form your group:</li>
<ul>
<li><b>Nodes</b></li>
<li><b>0D Element</b></li>
<li><b>Ball</b></li>
<li><b>Edges</b></li>
<li><b>Faces</b></li>
<li><b>Volumes</b></li>
</ul>
<li><b>Name</b> field allows to enter the name of your new group.</li>
<li><b>Color</b> - allows to assign to the group a certain color. The
chosen color is used to display the elements of the group.<br>
Activation of <em>Auto Color</em> item in mesh context menu
switches on a random choice of a color for a new group.</li>
</ul>
Mesh module distinguishes between the three Group types:
<b>Standalone Group</b>, <b>Group on Geometry</b> and <b>Group on Filter</b>.
\anchor standalone_group <br><h2>"Standalone Group"</h2>
<b>Standalone Group</b> contains a list of mesh elements, which you can define in
the following ways:
<ul>
<li>By adding all entities of the chosen type existing in the
mesh. For this, turn on the <b>Select All</b> check-box. In this mode
all controls, which allow selecting the entities, are
disabled.</li>
<li>By choosing entities manually with the mouse in the 3D Viewer. For
this, turn on the <b>Enable manual edition</b> check box. You can
click on an element in the 3D viewer and it will be highlighted. After
that click the \b Add button and the ID of this element will be
added to the list.<br>
The <b>Set filter</b> button allows to define the filter for
selection of the elements for your group. See more about filters on
the \ref selection_filter_library_page "Selection filter library"
page.</li>
<li>By adding entities from either a sub-mesh or another
group. For this, turn on the <b>Enable manual edition</b> check
box. <b>Select from</b> fields group allows to select a sub-mesh or
a group of the appropriate type and to \b Add their elements to the
group.</li>
</ul>
In the <b>manual edition</b> mode you can
<ul>
<li>click the \b Remove button to remove the selected items from
the list.</li>
<li>click the <b>Sort List</b> button to sort the list of IDs of
mesh elements.</li>
</ul>
\image html creategroup.png
For example, to create a new group containing all faces of an
existing group and some other faces selected in the viewer:
<ul>
<li> Select the \b Face type of entities and input the name of the new group.</li>
<li> Check the \b Group checkbox in <b>Select From</b> group.</li>
<li> Select the existing group of faces in the object browser or in the viewer.</li>
<li> Click \b Add in \b Content group. <b>Id Elements</b> list will be filled
with IDs of faces belonging to the selected group.</li>
<li> Select other faces in the viewer.</li>
<li> Click \b Add in \b Content group.</li>
<li> Click \b Apply button to create the new group.</li>
</ul>
Please note that the new group does not have references to the source
group. It contains only the list of face IDs. So if the source group
is changed, the new one is not updated accordingly.
\image html image130.gif
<center>In this picture the brown cells belong to a group defined
manually.</center>
<b>See Also</b> a sample TUI Script of a
\ref tui_create_standalone_group "Create a Standalone Group"
operation.
\anchor group_on_geom <br><h2>"Group on Geometry"</h2>
To create a group on geometry check <b>Group on geometry</b> in the \b
Group \b type field. The group on geometry contains the elements
of a certain type generated on the selected geometrical object. Group
contents are dynamically updated if the mesh is modified. The group on
geometry can be created only if the mesh is based on geometry.
To define a group, click the \a Selection button and choose
- <em>Direct geometry selection</em> to select a shape in the Object
Browser or in the Viewer;
- <em>Find geometry by mesh element selection</em> to activate a
dialog which retrieves a shape by the selected element generated on
this shape.
Note that this choice is available only if the mesh elements are
already generated.
\image html a-creategroup.png
After confirmation of the operation a new group of mesh elements will
be created.
\image html image132.gif
<center>In this picture the cells which belong to a certain
geometrical face are selected in green.</center>
<b>See Also</b> a sample TUI Script of a
\ref tui_create_group_on_geometry "Create a Group on Geometry"
operation.
\anchor group_on_filter <br><h2>"Group on Filter"</h2>
To create a group on filter check <b>Group on filter</b> in the <b>
Group type</b> field. The group on filter contains the elements
of a certain type satisfying the defined filter. Group contents are
dynamically updated if the mesh is modified.
To define a group, click the <b>Set filter</b> button and define
criteria of the filter in the opened dialog. After the
operation is confirmed, a new group of mesh elements will be created. See more about
filters on the
\ref selection_filter_library_page "Selection filter library" page.
\image html creategroup_on_filter.png
<b>See Also</b> a sample TUI Script of a
\ref tui_create_group_on_filter "Create a Group on Filter" operation.
*/

112
doc/salome/gui/SMESH/input/creating_groups.rst Normal file
View File

@ -0,0 +1,112 @@
.. _creating_groups_page:
***************
Creating groups
***************
In MESH you can create a :ref:`grouping_elements_page` of elements of a certain type. The main way to create a group, is to
select in the **Mesh** menu **Create Group** item (also available in the context menu of the mesh).
To create a group you should define the following:
* **Mesh** - the mesh whose elements will form your group. You can select your mesh in the Objet Browser or in the 3D viewer.
* **Elements Type** - set of radio buttons allows to select the type of elements which will form your group:
* **Nodes**
* **0D Element**
* **Ball**
* **Edges**
* **Faces**
* **Volumes**
* **Name** field allows to enter the name of your new group.
* **Color** - allows to assign to the group a certain color. The chosen color is used to display the elements of the group. Activation of **Auto Color** item in mesh context menu switches on a random choice of a color for a new group.
Mesh module distinguishes between the three Group types:
**Standalone Group**, **Group on Geometry** and **Group on Filter**.
.. _standalone_group:
"Standalone Group"
##################
**Standalone Group** contains a list of mesh elements, which you can define in
the following ways:
* By adding all entities of the chosen type existing in the mesh. For this, turn on the **Select All** check-box. In this mode all controls, which allow selecting the entities, are disabled.
* By choosing entities manually with the mouse in the 3D Viewer. For this, turn on the **Enable manual edition** check box. You can click on an element in the 3D viewer and it will be highlighted. After that click the **Add** button and the ID of this element will be added to the list. The **Set filter** button allows to define the filter for selection of the elements for your group. See more about filters on the :ref:`selection_filter_library_page` "Selection filter library" page.
* By adding entities from either a sub-mesh or another group. For this, turn on the **Enable manual edition** check box. **Select from** fields group allows to select a sub-mesh or a group of the appropriate type and to **Add** their elements to the group.
In the **manual edition** mode you can
* click the **Remove** button to remove the selected items from the list.
* click the **Sort List** button to sort the list of IDs of mesh elements.
.. image:: ../images/creategroup.png
:align: center
For example, to create a new group containing all faces of an existing group and some other faces selected in the viewer:
* Select the **Face** type of entities and input the name of the new group.
* Check the **Group** checkbox in **Select From** group.
* Select the existing group of faces in the object browser or in the viewer.
* Click **Add** in **Content** group. **Id Elements** list will be filled with IDs of faces belonging to the selected group.
* Select other faces in the viewer.
* Click **Add** in **Content** group.
* Click **Apply** button to create the new group.
Please note that the new group does not have references to the source group. It contains only the list of face IDs. So if the source group is changed, the new one is not updated accordingly.
.. image:: ../images/image130.gif
:align: center
.. centered::
In this picture the brown cells belong to a group defined manually.
**See Also** a sample TUI Script of a :ref:`tui_create_standalone_group` operation.
.. _group_on_geom:
"Group on Geometry"
###################
To create a group on geometry check **Group on geometry** in the **Group** **type** field. The group on geometry contains the elements of a certain type generated on the selected geometrical object. Group contents are dynamically updated if the mesh is modified. The group on geometry can be created only if the mesh is based on geometry.
To define a group, click the *Selection* button and choose
* **Direct geometry selection** to select a shape in the Object Browser or in the Viewer;
* **Find geometry by mesh element selection** to activate a dialog which retrieves a shape by the selected element generated on this shape.
.. note::
that this choice is available only if the mesh elements are already generated.
.. image:: ../images/a-creategroup.png
:align: center
After confirmation of the operation a new group of mesh elements will be created.
.. image:: ../images/image132.gif
:align: center
In this picture the cells which belong to a certain geometrical face are selected in green.
**See Also** a sample TUI Script of a :ref:`tui_create_group_on_geometry` operation.
.. _group_on_filter:
"Group on Filter"
#################
To create a group on filter check **Group on filter** in the **Group type** field.
The group on filter contains the elements of a certain type satisfying the defined filter.
Group contents are dynamically updated if the mesh is modified.
To define a group, click the **Set filter** button and define criteria of the filter in the opened dialog. After the operation is confirmed, a new group of mesh elements will be created. See more about filters on the :ref:`selection_filter_library_page` page.
.. image:: ../images/creategroup_on_filter.png
:align: center
**See Also** a sample TUI Script of a :ref:`tui_create_group_on_filter` operation.

55
doc/salome/gui/SMESH/input/cut_mesh_by_plane.doc
View File

@ -1,55 +0,0 @@
/*!
\page cut_mesh_by_plane_page Cut a tetrahedron mesh by a plane
\n MeshCut works only with MED files and produces MED files, and is a standalone program.
It can be used either directly from a command shell outside SALOME, or with a GUI interface in SMESH,
provided in a python plugin that needs to be installed in your SALOME application.
\n MeshCut allows to cut a mesh constituted of linear tetrahedrons by a plane.
\n The tetrahedrons intersected by the plane are cut and replaced by elements of various types,
(tetrahedron, pyramid, pentahedron).
<br>
\anchor meshcut_standalone
<h2>Using MeshCut as a standalone program, outside SALOME</h2>
\n MeshCut is a standalone program, reading and producing med files.
\n
\n Syntax:
\code
MeshCut input.med output.med resuMeshName aboveGroup belowGroup nx ny nz px py pz T
\endcode
\n
\n where:
\n input.med = name of the original mesh file in med format
\n output.med = name of the result mesh file in med format
\n resuMeshName = name of the result mesh
\n aboveGroup = name of the group of volumes above the cut plane
\n belowGroups = name of the group of volumes below the cut plane
\n nx ny nz = vector normal to the cut plane
\n px py pz = a point of the cut plane
\n T = 0 < T < 1 : vertices of a tetrahedron are considered as belonging to
\n the cut plane if their distance from the plane is inferior to L*T,
\n where L is the mean edge size of the tetrahedron
<br>
\anchor meshcut_plugin
<h2>Using MeshCut inside SALOME</h2>
When the MeshCut plugin is installed, it can be found in the Mesh menu, sub-menu SMESH_plugins.
\n If the plugin is not installed, the file meshcut_plugin.py is in
SMESH installation in subdirectory bin/salome/meshcut_plugin.py.
\n If there are already plugins defined in a smesh_plugins.py file,
this file should be added at the end.
if not, copied as ${HOME}/Plugins/smesh_plugins.py or ${APPLI}/Plugins/smesh_plugins.py
or in ${PLUGINPATH} Directory.
From the Mesh menu, sub-menu SMESH_plugins, choose "MeshCut" item
The following dialog box will appear:
\image html meshcut_plugin.png "MeshCut Plugin dialog box"
See above for the meaning of the parameters.
*/

59
doc/salome/gui/SMESH/input/cut_mesh_by_plane.rst Normal file
View File

@ -0,0 +1,59 @@
.. _cut_mesh_by_plane_page:
*********************************
Cut a tetrahedron mesh by a plane
*********************************
MeshCut works only with MED files and produces MED files, and is a standalone program. It can be used either directly from a command shell outside SALOME, or with a GUI interface in SMESH, provided in a python plugin that needs to be installed in your SALOME application.
MeshCut allows to cut a mesh constituted of linear tetrahedrons by a plane.
The tetrahedrons intersected by the plane are cut and replaced by elements of various types, (tetrahedron, pyramid, pentahedron).
.. _meshcut_standalone:
Using MeshCut as a standalone program, outside SALOME
#####################################################
MeshCut is a standalone program, reading and producing med files.
Syntax::
MeshCut input.med output.med resuMeshName aboveGroup belowGroup nx ny nz px py pz T
where::
input.med = name of the original mesh file in med format
output.med = name of the result mesh file in med format
resuMeshName = name of the result mesh
aboveGroup = name of the group of volumes above the cut plane
belowGroups = name of the group of volumes below the cut plane
nx ny nz = vector normal to the cut plane
px py pz = a point of the cut plane
T = 0 < T < 1 : vertices of a tetrahedron are considered as belonging to the cut plane if their distance from the plane is inferior to L*T,
where L is the mean edge size of the tetrahedron
.. _meshcut_plugin:
Using MeshCut inside SALOME
###########################
When the MeshCut plugin is installed, it can be found in the Mesh menu, sub-menu SMESH_plugins.
If the plugin is not installed, the file meshcut_plugin.py is in SMESH installation in subdirectory
*bin/salome/meshcut_plugin.py*.
If there are already plugins defined in a smesh_plugins.py file, this file should be added at the end. If not, copied as
*${HOME}/Plugins/smesh_plugins.py* or *${APPLI}/Plugins/smesh_plugins.py* or in *${PLUGINPATH}* directory.
From the Mesh menu, sub-menu SMESH_plugins, choose **"MeshCut"** item
The following dialog box will appear:
.. image:: ../images/meshcut_plugin.png
:align: center
.. centered::
"MeshCut Plugin dialog box"
See above for the meaning of the parameters.

51
doc/salome/gui/SMESH/input/cutting_quadrangles.doc
View File

@ -1,51 +0,0 @@
/*!
\page cutting_quadrangles_page Cutting quadrangles
This operation allows cutting one or several quadrangle elements into two or four triangles.
<em>To cut quadrangles:</em>
1) Select a mesh (and display it in the 3D Viewer if you are going to pick elements by mouse).
2) In the \b Modification menu select the <b>Cutting of quadrangles</b> item or
click <em>"Cutting of quadrangles"</em> button in the toolbar.
\image html image82.png
<center><em>"Cutting of quadrangles" button</em></center>
The following dialog box will appear:
\image html a-cuttingofquadrangles.png
- The main list contains the list of quadrangles selected for cutting. You can
click on a quadrangle in the 3D viewer and it will be highlighted (lock Shift
keyboard button to select several quadrangles):
- Click \b Add button and the ID of this quadrangle will be added to the list.
- To remove a selected element or elements from the list click \b Remove button.
- <b>Sort list</b> button allows sorting the list of IDs.
- \b Filter button allows applying a definite \ref filtering_elements "filter"
to the selection of quadrangles.
- <b>Apply to all</b> check box allows cutting all quadrangles of the selected mesh.
- \b Preview provides a preview of cutting in the viewer. It is disabled for <b>Cut into 4 triangles</b> as this cutting way implies no ambiguity.
- \b Criterion defines the way of cutting:
- <b>Cut into 4 triangles</b> allows cutting a quadrangle into four triangles by inserting a new node at the center of the quadrangle. The other options allow cutting a quadrangle into two triangles by connecting the nodes of a diagonal.
- <b>Use diagonal 1-3</b> and <b>Use diagonal 2-4</b> allow specifying the opposite corners, which will be connected to form two new triangles.
- <b>Use numeric functor</b> allows selecting in the field below a quality metric, which will be optimized when choosing a diagonal for cutting a quadrangle:
- <b>Minimum diagonal</b> cuts by the shortest diagonal.
- <b>Aspect Ratio</b> cuts by the diagonal splitting the quadrangle into triangles with \ref aspect_ratio_page "Aspect Ratio" closer to 1
- <b>Minimum Angle</b> cuts by the diagonal splitting the quadrangle into triangles with \ref minimum_angle_page "Minimum Angle" closer to 60 degrees.
- <b>Skew</b> cuts by the diagonal splitting the quadrangle into triangles with \ref skew_page "Skew" closer to 0.0 degrees.
- <b>Select from</b> allows choosing a sub-mesh or an existing group, whose quadrangle elements then can be added to the main list.
3) Click the \b Apply or <b>Apply and Close</b> button to confirm the operation.
\image html image52.jpg "The chosen quadrangular element"
\image html image51.jpg "Two resulting triangular elements"
<br><b>See Also</b> a sample TUI Script of a
\ref tui_cutting_quadrangles "Cutting Quadrangles" operation.
*/

61
doc/salome/gui/SMESH/input/cutting_quadrangles.rst Normal file
View File

@ -0,0 +1,61 @@
.. _cutting_quadrangles_page:
*******************
Cutting quadrangles
*******************
This operation allows cutting one or several quadrangle elements into two or four triangles.
**To cut quadrangles:**
1. Select a mesh (and display it in the 3D Viewer if you are going to pick elements by mouse).
2. In the **Modification** menu select the **Cutting of quadrangles** item or click **"Cutting of quadrangles"** button in the toolbar.
.. image:: ../images/image82.png
:align: center
.. centered::
**"Cutting of quadrangles" button**
The following dialog box will appear:
.. image:: ../images/a-cuttingofquadrangles.png
:align: center
* The main list contains the list of quadrangles selected for cutting. You can click on a quadrangle in the 3D viewer and it will be highlighted (lock Shift keyboard button to select several quadrangles):
* Click **Add** button and the ID of this quadrangle will be added to the list.
* To remove a selected element or elements from the list click **Remove** button.
* **Sort list** button allows sorting the list of IDs.
* **Filter** button allows applying a definite :ref:`filtering_elements` "filter" to the selection of quadrangles.
* **Apply to all** check box allows cutting all quadrangles of the selected mesh.
* **Preview** provides a preview of cutting in the viewer. It is disabled for **Cut into 4 triangles** as this cutting way implies no ambiguity.
* **Criterion** defines the way of cutting:
* **Cut into 4 triangles** allows cutting a quadrangle into four triangles by inserting a new node at the center of the quadrangle. The other options allow cutting a quadrangle into two triangles by connecting the nodes of a diagonal.
* **Use diagonal 1-3** and **Use diagonal 2-4** allow specifying the opposite corners, which will be connected to form two new triangles.
* **Use numeric functor** allows selecting in the field below a quality metric, which will be optimized when choosing a diagonal for cutting a quadrangle:
* **Minimum diagonal** cuts by the shortest diagonal.
* **Aspect Ratio** cuts by the diagonal splitting the quadrangle into triangles with :ref:`aspect_ratio_page` "Aspect Ratio" closer to 1
* **Minimum Angle** cuts by the diagonal splitting the quadrangle into triangles with :ref:`minimum_angle_page` "Minimum Angle" closer to 60 degrees.
* **Skew** cuts by the diagonal splitting the quadrangle into triangles with :ref:`skew_page` "Skew" closer to 0.0 degrees.
* **Select from** allows choosing a sub-mesh or an existing group, whose quadrangle elements then can be added to the main list.
3. Click the **Apply** or **Apply and Close** button to confirm the operation.
.. image:: ../images/image52.jpg
:align: center
.. centered::
"The chosen quadrangular element"
|
.. image:: ../images/image51.jpg
:align: center
.. centered::
"Two resulting triangular elements"
**See Also** a sample TUI Script of a :ref:`tui_cutting_quadrangles` operation.

33
doc/salome/gui/SMESH/input/define_mesh_by_script.doc
View File

@ -1,33 +0,0 @@
/*!
\page use_existing_page Use Edges/Faces to be Created Manually
The algorithms <b>Use Edges to be Created Manually</b> and
<b>Use Faces to be Created Manually</b> allow creating a 1D or a 2D mesh
in a python script (using <em>AddNode, AddEdge</em>
and <em>AddFace</em> commands) and then using such sub-meshes in the
construction of a 2D or a 3D mesh.
For example, you want to use standard algorithms to generate 1D and 3D
meshes and to create 2D mesh by your python code. For this, you
<ol>
<li> create a mesh object, assign a 1D algorithm,</li>
<li> invoke \b Compute command, which computes a 1D mesh,</li>
<li> assign <b>Use Faces to be Created Manually</b> and a 3D algorithm,</li>
<li> run your python code, which creates a 2D mesh,</li>
<li> invoke \b Compute command, which computes a 3D mesh.</li>
</ol>
\warning <b>Use Edges to be Created Manually</b> and <b>Use Faces to
be Created Manually</b> algorithms should be assigned _before_
mesh generation by the Python code.
Consider trying a sample script demonstrating the usage of
\ref tui_use_existing_faces "Use Faces to be Created Manually"
algorithm for construction of a 2D mesh using Python commands.
\image html use_existing_face_sample_mesh.png
<em> Mesh computed by \ref tui_use_existing_faces "the sample script"
shown in a Shrink mode.</em>
*/

28
doc/salome/gui/SMESH/input/define_mesh_by_script.rst Normal file
View File

@ -0,0 +1,28 @@
.. _use_existing_page:
**************************************
Use Edges/Faces to be Created Manually
**************************************
The algorithms **Use Edges to be Created Manually** and **Use Faces to be Created Manually** allow creating a 1D or a 2D mesh in a python script (using **AddNode, AddEdge** and **AddFace** commands) and then using such sub-meshes in the construction of a 2D or a 3D mesh.
For example, you want to use standard algorithms to generate 1D and 3D
meshes and to create 2D mesh by your python code. For this, you
#. create a mesh object, assign a 1D algorithm,
#. invoke **Compute** command, which computes a 1D mesh,
#. assign **Use Faces to be Created Manually** and a 3D algorithm,
#. run your python code, which creates a 2D mesh,
#. invoke **Compute** command, which computes a 3D mesh.
.. warning:: **Use Edges to be Created Manually** and **Use Faces to be Created Manually** algorithms should be assigned _before_ mesh generation by the Python code.
Consider trying a sample script demonstrating the usage of :ref:`tui_use_existing_faces` algorithm for construction of a 2D mesh using Python commands.
.. image:: ../images/use_existing_face_sample_mesh.png
:align: center
**Mesh computed by** :ref:`tui_use_existing_faces` shown in a Shrink mode.

25
doc/salome/gui/SMESH/input/deflection_2d.doc
View File

@ -1,25 +0,0 @@
/*!
\page deflection_2d_page Deflection 2D
\n This quality control criterion consists of calculation of distance
between a mesh face gravity corner and the surface the face discretizes.
<em>To apply the Deflection 2D quality criterion to your mesh:</em>
<ol>
<li>Display your mesh in the viewer. </li>
<li>Choose <b>Controls > Face Controls > Deflection 2D</b> or click
<em>"Deflection 2D"</em> button in the toolbar.
Your mesh will be displayed in the viewer with faces colored according
to the applied mesh quality control criterion:
\image html deflection_2d.png
</li>
</ol>
<br><b>See Also</b> a sample TUI Script of a
\ref tui_deflection_2d "Deflection 2D quality control" operation.
*/

22
doc/salome/gui/SMESH/input/deleting_groups.doc
View File

@ -1,22 +0,0 @@
/*!
\page deleting_groups_page Deleting groups with content
To delete groups and their content, in the menu select
<b>Modification -> Remove -> Delete groups with Contents</b>
and select one or several groups you wish to delete in the 3D viewer
or in the Object Browser.
The selected groups will be listed in <b>Delete groups with contents</b> menu.
Then click <b>Apply and Close</b> button to remove the selected groups
and close the menu or \b Apply button to remove them and proceed with
the selection.
\image html deletegroups.png
\n Please, note that this operation removes groups <b>with their
elements</b>. To delete a group and leave its elements intact, right-click
on the group in the Object Browser and select \b Delete in the pop-up
menu or select the group and choose <b>Edit -> Delete</b> in the main menu.
*/

18
doc/salome/gui/SMESH/input/deleting_groups.rst Normal file
View File

@ -0,0 +1,18 @@
.. _deleting_groups_page:
****************************
Deleting groups with content
****************************
To delete groups and their content, in the menu select **Modification -> Remove -> Delete groups with Contents** and select one or several groups you wish to delete in the 3D viewer or in the Object Browser.
The selected groups will be listed in **Delete groups with contents** menu.
Then click **Apply and Close** button to remove the selected groups and close the menu or **Apply** button to remove them and proceed with the selection.
.. image:: ../images/deletegroups.png
:align: center
.. note::
Please, note that this operation removes groups **with their elements**. To delete a group and leave its elements intact, right-click on the group in the Object Browser and select **Delete** in the pop-up menu or select the group and choose **Edit -> Delete** in the main menu.

34
doc/salome/gui/SMESH/input/diagonal_inversion_of_elements.doc
View File

@ -1,34 +0,0 @@
/*!
\page diagonal_inversion_of_elements_page Diagonal inversion of two triangles
\n In MESH you can inverse the diagonal (edge) of a pseudo-quadrangle
formed by two neighboring triangles with one common edge.
<em>To inverse the diagonal:</em>
<ol>
<li>From the \b Modification menu choose the <b>Diagonal inversion</b> item or
click <em>"Diagonal Inversion"</em> button in the toolbar.
\image html image70.png
<center><em>"Diagonal Inversion" button</em></center>
The following dialog box shall appear:
\image html diagonalinversion.png
</li>
<li>Enter IDs of nodes forming the required edge in the \b Edge field
(the node IDs must be separated by dashes) or select
this edge in the 3D viewer.</li>
<li>Click the \b Apply or <b>Apply and Close</b> button.</li>
</ol>
\image html image38.jpg "The selected edge"
\image html image36.jpg "The inverted edge"
<br><b>See Also</b> a sample TUI Script of a
\ref tui_diagonal_inversion "Diagonal Inversion of Elements" operation.
*/

42
doc/salome/gui/SMESH/input/diagonal_inversion_of_elements.rst Normal file
View File

@ -0,0 +1,42 @@
.. _diagonal_inversion_of_elements_page:
***********************************
Diagonal inversion of two triangles
***********************************
In MESH you can inverse the diagonal (edge) of a pseudo-quadrangle
formed by two neighboring triangles with one common edge.
**To inverse the diagonal:**
#. From the **Modification** menu choose the **Diagonal inversion** item or click **"Diagonal Inversion"** button in the toolbar.
.. image:: ../images/image70.png
:align: center
.. centered::
**"Diagonal Inversion" button**
The following dialog box shall appear:
.. image:: ../images/diagonalinversion.png
:align: center
#. Enter IDs of nodes forming the required edge in the **Edge** field (the node IDs must be separated by dashes) or select this edge in the 3D viewer.
#. Click the **Apply** or **Apply and Close** button.
.. image:: ../images/image38.jpg
:align: center
.. centered::
"The selected edge"
.. image:: ../images/image36.jpg
:align: center
.. centered::
"The inverted edge"
**See Also** a sample TUI Script of a :ref:`tui_diagonal_inversion` operation.

23
doc/salome/gui/SMESH/input/display_entity.doc
View File

@ -1,23 +0,0 @@
/*!
\page display_entity_page Display Entity
\n In this submenu you can choose to display only volumes, faces or
edges or combine them.
\image html image56.jpg Only Faces
\image html image58.png Only Edges
\image html image59.png Edges + Faces
If the mesh contains a lot of elements, select <b>Choose...</b> item,
\image html display_entity_choose_item.png Item to call 'Display Entity' dialog box
and <b>Display Entity</b> dialog box will provide a way to display only some entities at the first display instead of displaying all entities, which can take a long time.
\image html display_entity_dlg.png 'Display Entity' dialog allows to select entities before displaying
\note This menu item is available from the context menu in both Object browser and 3D viewer.
*/

43
doc/salome/gui/SMESH/input/display_entity.rst Normal file
View File

@ -0,0 +1,43 @@
.. _display_entity_page:
**************
Display Entity
**************
In this submenu you can choose to display only volumes, faces or edges or combine them.
.. image:: ../images/image56.jpg
:align: center
.. centered::
Only Faces
.. image:: ../images/image58.png
:align: center
.. centered::
Only Edges
.. image:: ../images/image59.png
:align: center
.. centered::
Edges + Faces
If the mesh contains a lot of elements, select **Choose...** item,
.. image:: ../images/display_entity_choose_item.png
:align: center
.. centered::
Item to call 'Display Entity' dialog box
and **Display Entity** dialog box will provide a way to display only some entities at the first display instead of displaying all entities, which can take a long time.
.. image:: ../images/display_entity_dlg.png
:align: center
.. centered::
'Display Entity' dialog allows to select entities before displaying
This menu item is available from the context menu in both Object browser and 3D viewer.

23
doc/salome/gui/SMESH/input/display_mode.doc
View File

@ -1,23 +0,0 @@
/*!
\page display_mode_page Display Mode
\n By default your objects are represented as defined in
\ref mesh_tab_preferences "Preferences".
\n However, right-clicking on the mesh in the <b>Object Browser</b>,
and selecting <b>Display Mode</b>, you can display your mesh as:
\image html image53.gif Wireframe
\image html image37.jpg Shading
\image html image56.gif Nodes
\b Wireframe can combine with \b Nodes and \b Shading.
\b Shading and \b Wireframe modes can combine with \b Shrink, however
\b Nodes can't.
\image html image55.gif Shrink
*/

41
doc/salome/gui/SMESH/input/display_mode.rst Normal file
View File

@ -0,0 +1,41 @@
.. _display_mode_page:
************
Display Mode
************
By default your objects are represented as defined in :ref:`mesh_tab_preferences`.
However, right-clicking on the mesh in the **Object Browser**, and selecting **Display Mode**, you can display your mesh as:
.. image:: ../images/image53.gif
:align: center
.. centered::
Wireframe
.. image:: ../images/image37.jpg
:align: center
.. centered::
Shading
.. image:: ../images/image56.gif
:align: center
.. centered::
Nodes
**Wireframe** can combine with **Nodes** and **Shading**.
**Shading** and **Wireframe** modes can combine with **Shrink**, however **Nodes** can't.
.. image:: ../images/image55.gif
:align: center
.. centered::
Shrink

14
doc/salome/gui/SMESH/input/double_elements_control.doc
View File

@ -1,14 +0,0 @@
/*!
\page double_elements_page Double edge, Double faces and Double volumes
These mesh quality controls highlight the mesh elements basing on the same set of nodes.
\image html double_faces.png
In this picture some faces are coincident after copying all elements
with translation with subsequent Merge of nodes.
\sa A sample TUI Script of a \ref filter_double_elements "Filters of Double Elements".
*/

16
doc/salome/gui/SMESH/input/double_elements_control.rst Normal file
View File

@ -0,0 +1,16 @@
.. _double_elements_page:
********************************************
Double edge, Double faces and Double volumes
********************************************
These mesh quality controls highlight the mesh elements basing on the same set of nodes.
.. image:: ../images/double_faces.png
:align: center
In this picture some faces are coincident after copying all elements with translation with subsequent Merge of nodes.
*A sample TUI Script of a* :ref:`filter_double_elements`:.

17
doc/salome/gui/SMESH/input/double_nodes_control.doc
View File

@ -1,17 +0,0 @@
/*!
\page double_nodes_control_page Double nodes
This mesh quality control highlights the nodes which are coincident
with other nodes (within a given tolerance). Distance at which two
nodes are considered coincident is defined by
\ref dbl_nodes_tol_pref "Quality Controls/Double nodes tolerance"
preference.
\image html double_nodes.png
In this picture some nodes are coincident after copying all elements with translation.
\sa A sample TUI Script of a \ref tui_double_nodes_control "Double Nodes" filter.
*/

16
doc/salome/gui/SMESH/input/double_nodes_control.rst Normal file
View File

@ -0,0 +1,16 @@
.. _double_nodes_control_page:
************
Double nodes
************
This mesh quality control highlights the nodes which are coincident with other nodes (within a given tolerance). Distance at which two nodes are considered coincident is defined by :ref:`dbl_nodes_tol_pref` preference.
.. image:: ../images/double_nodes.png
:align: center
In this picture some nodes are coincident after copying all elements with translation.
**See also**: A sample TUI Script of a :ref:`tui_double_nodes_control` filter.

164
doc/salome/gui/SMESH/input/double_nodes_page.doc
View File

@ -1,164 +0,0 @@
/*!
\page double_nodes_page Duplicate Nodes or/and Elements
\n This operation allows duplicating mesh nodes or/and elements, which can be useful to emulate a crack in the model.
Duplication consists in creation of mesh elements "equal" to existing ones.
<em>To duplicate nodes or/and elements:</em>
<ol>
<li>From the \b Modification menu choose \b Transformation -> <b> Duplicate
Nodes or/and Elements </b> item or click <em>"Duplicate Nodes or/and
Elements"</em> button in the toolbar.
<br>
\image html duplicate_nodes.png "Duplicate Nodes or/and Elements button"
</li>
<li>Check in the dialog box one of four radio buttons corresponding to
the type of duplication operation you would like to perform.</li>
<li>Fill the other fields available in the dialog box (depending on
the chosen operation mode).</li>
<li>Click the \b Apply or <b>Apply and Close</b> button to perform the
operation of duplication.</li>
</ol>
\n "Duplicate Nodes or/and Elements" dialog has four working modes:
<ul>
<li>\ref mode_without_elem_anchor "Duplicate nodes only"</li>
<li>\ref mode_with_elem_anchor "Duplicate nodes and border elements"</li>
<li>\ref mode_elem_only_anchor "Duplicate elements only"</li>
<li>\ref mode_group_boundary_anchor "Duplicate nodes on group boundaries"</li>
</ul>
<br>
\anchor mode_without_elem_anchor
<h2>Duplicate nodes only</h2>
\image html duplicate01.png
Parameters to be defined in this mode:
<ul>
<li><b>Group of nodes to duplicate</b> (<em>mandatory</em>): these
nodes will be duplicated.</li>
<li><b>Group of elements to replace nodes with new ones</b>
(<em>optional</em>): the new nodes will replace the duplicated nodes
within these elements. \b Generate button automatically creates
these groups.
</li>
<li><b>Construct group with newly created nodes</b> option
(<em>checked by default</em>): if checked - the group with newly
created nodes will be built.</li>
</ul>
A schema below illustrates how the crack is emulated using the node duplication.
\image html crack_emulation_double_nodes.png "Crack emulation"
This schema shows a virtual crack in a 2D mesh created using this duplication
mode:
- Black balls are <b>duplicated nodes</b>.
- Red balls are <b>new nodes</b>.
- <b>Elements to replace nodes with new ones</b> are marked with green.
Note that in the reality <b>duplicated nodes</b> coincide with <b>new nodes</b>.
<br>
\anchor mode_with_elem_anchor
<h2>Duplicate nodes and border elements</h2>
\image html duplicate02.png
Parameters to be defined in this mode:
<ul>
<li><b>Group of elements to duplicate</b> (<em>mandatory</em>): these
elements will be duplicated.</li>
<li><b>Group of nodes not to duplicate</b> (<em>optional</em>):
group of nodes at crack bottom which will not be duplicated.</li>
<li><b>Group of elements to replace nodes with new ones</b>
(<em>mandatory</em>): the new nodes will replace the nodes to
duplicate within these elements. \b Generate button automatically
creates these groups.</li>
<li><b>Construct group with newly created elements</b> option
(<em>checked by default</em>): if checked - the group of newly created
elements will be built.</li>
<li><b>Construct group with newly created nodes</b> option
(<em>checked by default</em>): if checked - the group of newly
created nodes will be built.</li>
</ul>
A schema below explains the crack emulation using the node duplication
with border elements.
\image html crack_emulation_double_nodes_with_elems.png "Crack emulation"
This schema shows a virtual crack in a 2D mesh created using this duplication
mode. In this schema:
- Black segments are <b>duplicated elements</b> (edges in 2D case).
- Black balls (except for the lowest one) are duplicated nodes of <b>duplicated elements</b>.
- The lowest black ball is the <b>non-duplicated node</b>.
- Red balls are <b>newly created nodes</b>.
- Red segments are <b>created elements</b> (edges).
- <b>Elements to replace nodes with new ones</b> are marked with green.
Note that in the reality <b>nodes to duplicate</b> coincide with <b>new nodes</b>.
<br>
In a 3D case, where <b>elements to duplicate</b> are faces, the edges
located at the "crack" (if any) are cloned automatically.
<br>
\anchor mode_elem_only_anchor
<h2>Duplicate elements only</h2>
This mode duplicates the given elements, i.e. creates new elements with the same nodes as the given elements.
<br>
\image html duplicate03.png
Parameters to be defined in this mode:
<ul>
<li><b>Group of elements to duplicate</b> (<em>mandatory</em>): these
elements will be duplicated.</li>
<li><b>Construct group with newly created elements</b> option
(<em>checked by default</em>): if checked - the group of newly created
elements will be built. The name of the created group starts from
"DoubleElements".</li>
</ul>
<br>
\anchor mode_group_boundary_anchor
<h2>Duplicate nodes on group boundaries</h2>
This mode duplicates nodes located on boundaries between given groups of volumes.
<br>
\image html duplicate04.png
Parameters to be defined in this mode:
<ul>
<li><b>Groups (faces or volumes) </b> (<em>mandatory</em>): list of mesh
groups. These groups should be disjoint, i.e. should not have shared
elements.</li>
<li> If <b>Create joint elements</b> option is activated, flat
elements are created on the duplicated nodes: a triangular facet
shared by two volumes of two groups generates a flat prism, a
quadrangular facet generates a flat hexahedron.
Correspondingly 2D joint elements (null area faces) are generated
where edges are shared by two faces.
<br>
The created flat volumes (or faces) are stored in groups. These groups are named
according to the position of the group in the list of groups: group
"j_n_p" is a group of flat elements that are built between the group \#n
and the group \#p in the group list. All flat elements are gathered
into the group named "joints3D" (correspondingly "joints2D"). The flat elements of multiple
junctions between the simple junction are stored in a group named
"jointsMultiples".</li>
<li> If <b>On all boundaries</b> option is activated, the volumes (or faces),
which are not included into <b>Groups</b> input, are considered
as another group and thus the nodes on the boundary
between <b>Groups</b> and the remaining mesh are also
duplicated.</li>
</ul>
<br><b>See Also</b> a sample TUI Script of a
\ref tui_duplicate_nodes "Duplicate nodes or/and elements" operation.
*/

145
doc/salome/gui/SMESH/input/double_nodes_page.rst Normal file
View File

@ -0,0 +1,145 @@
.. _double_nodes_page:
*******************************
Duplicate Nodes or/and Elements
*******************************
This operation allows duplicating mesh nodes or/and elements, which can be useful to emulate a crack in the model.
Duplication consists in creation of mesh elements "equal" to existing ones.
**To duplicate nodes or/and elements:**
#. From the **Modification** menu choose **Transformation** -> **Duplicate Nodes or/and Elements** item or click **"Duplicate Nodes or/and Elements"** button in the toolbar.
.. image:: ../images/duplicate_nodes.png
:align: center
.. centered::
"Duplicate Nodes or/and Elements button"
#. Check in the dialog box one of four radio buttons corresponding to the type of duplication operation you would like to perform.
#. Fill the other fields available in the dialog box (depending on the chosen operation mode).
#. Click the **Apply** or **Apply and Close** button to perform the operation of duplication.
"Duplicate Nodes or/and Elements" dialog has four working modes:
* :ref:`mode_without_elem_anchor`
* :ref:`mode_with_elem_anchor`
* :ref:`mode_elem_only_anchor`
* :ref:`mode_group_boundary_anchor`
.. _mode_without_elem_anchor:
Duplicate nodes only
####################
.. image:: ../images/duplicate01.png
:align: center
Parameters to be defined in this mode:
* **Group of nodes to duplicate** (**mandatory**): these nodes will be duplicated.
* **Group of elements to replace nodes with new ones** (**optional**): the new nodes will replace the duplicated nodes within these elements.
* **Construct group with newly created nodes** option (**checked by default**): if checked - the group with newly created nodes will be built.
A schema below illustrates how the crack is emulated using the node duplication.
.. image:: ../images/crack_emulation_double_nodes.png
:align: center
.. centered::
"Crack emulation"
This schema shows a virtual crack in a 2D mesh created using this duplication mode:
* Black balls are **duplicated nodes**.
* Red balls are **new nodes**.
* **Elements to replace nodes with new ones** are marked with green.
.. note::
Note that in the reality **duplicated nodes** coincide with **new nodes**.
.. _mode_with_elem_anchor:
Duplicate nodes and border elements
###################################
.. image:: ../images/duplicate02.png
:align: center
Parameters to be defined in this mode:
* **Group of elements to duplicate** (**mandatory**): these elements will be duplicated.
* **Group of nodes not to duplicate** (**optional**): group of nodes at crack bottom which will not be duplicated.
* **Group of elements to replace nodes with new ones** (**mandatory**): the new nodes will replace the nodes to duplicate within these elements.
* **Construct group with newly created elements** option (**checked by default**): if checked - the group of newly created elements will be built.
* **Construct group with newly created nodes** option (**checked by default**): if checked - the group of newly created nodes will be built.
A schema below explains the crack emulation using the node duplication with border elements.
.. image:: ../images/crack_emulation_double_nodes_with_elems.png
:align: center
.. centered::
"Crack emulation"
This schema shows a virtual crack in a 2D mesh created using this duplication mode. In this schema:
* Black segments are **duplicated elements** (edges in 2D case).
* Black balls (except for the lowest one) are duplicated nodes of **duplicated elements**.
* The lowest black ball is the **non-duplicated node**.
* Red balls are **newly created nodes**.
* Red segments are **created elements** (edges).
* **Elements to replace nodes with new ones** are marked with green.
Note that in the reality **nodes to duplicate** coincide with **new nodes**.
In a 3D case, where **elements to duplicate** are faces, the edges
located at the "crack" (if any) are cloned automatically.
.. _mode_elem_only_anchor:
Duplicate elements only
#######################
This mode duplicates the given elements, i.e. creates new elements with the same nodes as the given elements.
.. image:: ../images/duplicate03.png
:align: center
Parameters to be defined in this mode:
* **Group of elements to duplicate** (**mandatory**): these elements will be duplicated.
* **Construct group with newly created elements** option (**checked by default**): if checked - the group of newly created elements will be built. The name of the created group starts from "DoubleElements".
.. _mode_group_boundary_anchor:
Duplicate nodes on group boundaries
###################################
This mode duplicates nodes located on boundaries between given groups of volumes.
.. image:: ../images/duplicate04.png
:align: center
Parameters to be defined in this mode:
* **Groups (faces or volumes)** (**mandatory**): list of mesh groups. These groups should be disjoint, i.e. should not have shared elements.
* If **Create joint elements** option is activated, flat elements are created on the duplicated nodes: a triangular facet shared by two volumes of two groups generates a flat prism, a quadrangular facet generates a flat hexahedron. Correspondingly 2D joint elements (null area faces) are generated where edges are shared by two faces. The created flat volumes (or faces) are stored in groups. These groups are named according to the position of the group in the list of groups: group "j_n_p" is a group of flat elements that are built between the group \#n and the group \#p in the group list. All flat elements are gathered into the group named "joints3D" (correspondingly "joints2D"). The flat elements of multiple junctions between the simple junction are stored in a group named "jointsMultiples".
* If **On all boundaries** option is activated, the volumes (or faces), which are not included into **Groups** input, are considered as another group and thus the nodes on the boundary between **Groups** and the remaining mesh are also duplicated.
**See Also** a sample TUI Script of a :ref:`tui_duplicate_nodes` operation.

49
doc/salome/gui/SMESH/input/editing_groups.doc
View File

@ -1,49 +0,0 @@
/*!
\page editing_groups_page Editing groups
<em>To edit an existing group of elements:</em>
<ol>
<li>Select your group in the Object Browser and in the \b Mesh menu click
the <b>Edit Group</b> item or <em>"Edit Group"</em> button in the toolbar.</li>
\image html image74.gif
<center><em>"Edit Group" button</em></center>
The following dialog box will appear (if the selected group
is <em>standalone</em>, else this dialog looks different):
\image html editgroup.png
In this dialog box you can modify the name and the color of your group
despite of its type. You can add or remove the elements composing a
<em>standalone group</em>. You can change criteria of the filter of
a <em>group on filter</em>. For more information see
\ref creating_groups_page "Creating Groups" page.
<li>Click the \b Apply or <b>Apply and Close</b> button to confirm
modification of the group.</li>
</ol>
<br>
\anchor convert_to_standalone
<em>To convert an existing group on geometry or a group on filer into
a standalone group and modify its contents:</em>
<ol>
<li>Select your group on geometry or on filter in the
Object Browser and in the \b Mesh menu click the <b>Edit Group as
Standalone</b> item.</li>
\image html image74.gif
<center><em>"Edit Group as Standalone" button</em></center>
The selected group will be converted into a standalone group and
its contents can be modified.
<li>Click the \b Apply or <b>Apply and Close</b> button to confirm modification of the
group.</li>
</ol>
\sa A sample TUI Script of an \ref tui_edit_group "Edit Group" operation.
*/

51
doc/salome/gui/SMESH/input/editing_groups.rst Normal file
View File

@ -0,0 +1,51 @@
.. _editing_groups_page:
**************
Editing groups
**************
**To edit an existing group of elements:**
#. Select your group in the Object Browser and in the **Mesh** menu click the **Edit Group** item or **"Edit Group"** button in the toolbar.
.. image:: ../images/image74.gif
:align: center
.. centered::
**"Edit Group" button**
The following dialog box will appear (if the selected group is **standalone**, else this dialog looks different):
.. image:: ../images/editgroup.png
:align: center
In this dialog box you can modify the name and the color of your group despite of its type. You can add or remove the elements composing a **standalone group**. You can change criteria of the filter of a **group on filter**. For more information see :ref:`creating_groups_page`:"Creating Groups" page.
#. Click the **Apply** or **Apply and Close** button to confirm modification of the group.
.. _convert_to_standalone:
Convert to stanalone group
==========================
**To convert an existing group on geometry or a group on filer into a standalone group and modify its contents:**
#. Select your group on geometry or on filter in the Object Browser and in the **Mesh** menu click the **Edit Group as Standalone** item.
.. image:: ../images/image74.gif
:align: center
.. centered::
**"Edit Group as Standalone" button**
The selected group will be converted into a standalone group and its contents can be modified.
#. Click the **Apply** or **Apply and Close** button to confirm modification of the group.
**See also:** A sample TUI Script of an :ref:`tui_edit_group` operation.

32
doc/salome/gui/SMESH/input/editing_meshes.doc
View File

@ -1,32 +0,0 @@
/*!
\page editing_meshes_page Editing Meshes
\n After you have created a mesh or sub-mesh with definite applied
meshing algorithms and hypotheses you can edit your mesh by \b assigning other
algorithms and/or hypotheses or \b unassigning the applied hypotheses and
algorithms. The editing proceeds in the same way as
\ref create_mesh_anchor "Mesh Creation".
\image html createmesh-inv3.png
You can also change values for the current hypothesis by clicking the
<em>"Edit Hypothesis"</em> button.
\image html image122.png
<center><em>"Edit Hypothesis" button</em></center>
Mesh entities generated before using changed hypotheses are automatically removed.
See how the mesh constructed on a geometrical object
changes if we apply different meshing parameters to it.
\image html edit_mesh1.png "Example of a mesh with Max. Element area 2D hypothesis roughly corresponding to 1D hypotheses on edges"
<br>
\image html edit_mesh_change_value_hyp.png "And now the Max Element area is greatly reduced"
<br><b>See Also</b> a sample TUI Script of an
\ref tui_editing_mesh "Edit Mesh" operation.
*/

43
doc/salome/gui/SMESH/input/editing_meshes.rst Normal file
View File

@ -0,0 +1,43 @@
.. _editing_meshes_page:
**************
Editing Meshes
**************
After you have created a mesh or sub-mesh with definite applied meshing algorithms and hypotheses you can edit your mesh by **assigning** other
algorithms and/or hypotheses or **unassigning** the applied hypotheses and algorithms. The editing proceeds in the same way as
:ref:`create_mesh_anchor`:"Mesh Creation".
.. image:: ../images/createmesh-inv3.png
:align: center
You can also change values for the current hypothesis by clicking the
**"Edit Hypothesis"** button.
.. image:: ../images/image122.png
:align: center
.. centered::
**"Edit Hypothesis" button**
Mesh entities generated before using changed hypotheses are automatically removed.
See how the mesh constructed on a geometrical object
changes if we apply different meshing parameters to it.
.. image:: ../images/edit_mesh1.png
:align: center
.. centered::
"Example of a mesh with Max. Element area 2D hypothesis roughly corresponding to 1D hypotheses on edges"
.. image:: ../images/edit_mesh_change_value_hyp.png
:align: center
.. centered::
"And now the Max Element area is greatly reduced"
**See Also** a sample TUI Script of an :ref:`tui_editing_mesh` operation.

181
doc/salome/gui/SMESH/input/extrusion.doc
View File

@ -1,181 +0,0 @@
/*!
\page extrusion_page Extrusion
\n Extrusion is used to build mesh elements of plus one
dimension than the input ones. Boundary elements around generated
mesh of plus one dimension are additionally created. All created
elements can be automatically grouped. Extrusion can be used to create
a \ref extrusion_struct "structured mesh from scratch".
\image html extrusion_box.png "If you extrude several quadrangles, you get exactly the same mesh as if you meshed a geometrical box (except for that the initial quadrangles can be incorrectly oriented): quadrangles and segments are created on the boundary of the generated mesh"
<p>Any node, segment or 2D element can be extruded. Each type of
elements is extruded into a corresponding type of result elements:
<table>
<tr><td><b>Extruded element</b></td><td><b> Result element </b></td></tr>
<tr><td>Node </td><td> Segment </td></tr>
<tr><td>Segment </td><td> Quadrilateral </td></tr>
<tr><td>Triangle </td><td> Pentahedron </td></tr>
<tr><td>Quadrilateral </td><td> Hexahedron </td></tr>
<tr><td>Polygon </td><td> Polyhedron </td></tr>
<tr><td>Hexagonal polygon </td><td> Hexagonal prism </td></tr>
</table>
When 2D elements are extruded, in addition to 3D elements segments are
created on the ribs of the resulting 3D mesh. Free edges of input 2D elements
generate logically horizontal rib segments. Logically vertical rib
segments are generated from the nodes belonging to a sole input 2D element
(the figure below illustrates this rule).
\image html extru_rib_segs.png "Two triangles extruded: no vertical rib segments generated from nodes #2 and #3 as they are shared by both triangles"
<em>To use extrusion:</em>
<ol>
<li>From the \b Modification menu choose the \b Extrusion item or click
<em>"Extrusion"</em> button in the toolbar.
<center>
\image html image91.png
<em>"Extrusion" button</em>
</center>
The following dialog will appear:
\image html extrusionalongaline1.png
</li>
<li>In this dialog:
<ul>
<li>Use \a Selection button to specify what you are going to
select at a given moment, \b Nodes, \b Edges or \b Faces.
\image html image120.png
<center><em>"Selection" button</em></center>
</li>
<li>Specify \b Nodes, \b Edges and \b Faces, which will be extruded, by one
of following means:
<ul>
<li><b>Select the whole mesh, sub-mesh or group</b> activating the
corresponding check-box.</li>
<li>Choose mesh elements with the mouse in the 3D Viewer. It is
possible to select a whole area with a mouse frame.</li>
<li>Input the element IDs directly in <b>Node IDs</b>, <b>Edge
IDs</b> and <b>Face IDs</b> fields. The selected elements will
be highlighted in the viewer, if the mesh is shown there.</li>
<li>Apply Filters. <b>Set filter</b> button allows to apply a
filter to the selection of elements. See more about filters in
the \ref filtering_elements "Selection filters" page.</li>
</ul>
</li>
<li>If the <b>Extrusion to Distance</b> radio button is selected
<ul>
<li> specify the translation vector by which the elements will
be extruded.</li>
</ul>
</li>
<li>If the <b>Extrusion Along Vector</b> radio button is selected
\image html extrusionalongaline2.png
<ul>
<li>specify the components of the \b Vector along which the elements
will be extruded, either directly or by selecting the mesh face (the
normal to the face will define the vector),</li>
<li>specify the \b Distance of extrusion along the vector (it can
be negative).</li>
</ul>
</li>
<li>If the <b>Extrusion By Normal</b> radio button is selected,
every node of the selected faces is extruded along the \a average
of the \a normal vectors to the faces sharing the node. (Nodes and
edges cannot be extruded in this mode.)
\image html extrusionalongaline3.png
<ul>
<li>Specify the \b Distance of extrusion (it can be negative),</li>
<li>Use <b>Along average normal</b> check-box to specify along
which vector the distance is measured.
<ul>
<li>If it is \a activated the distance is measured along the
average normal mentioned above. </li>
<li>If it is \a deactivated every node is extruded along the
average normal till its intersection with a virtual plane obtained
by translation of the face sharing the node along its own normal
by the \b Distance.</li>
</ul>
The picture below shows a cross-section of a 2D mesh extruded
with <b>Along average normal</b> activated (to the left) and
deactivated (to the right).
\image html extrusionbynormal_alongavgnorm.png "'Along average normal' activated (to the left) and deactivated (to the right)"
<p></li>
<li><b>Use only input elements</b> check-box specifies what
elements will be used to compute the average normal.<ul>
<li> If it is \a activated only selected faces, among faces
sharing the node, are used to compute the average normal at
the node. </li>
<li>Else all faces sharing the node are used.</li></ul>
The picture below shows a cross-section of a 2D mesh the upper
plane of which is extruded with <b>Use only input elements</b>
activated (to the left) and deactivated (to the right).
\image html extrusionbynormal_useonly.png "'Use only input elements' activated (to the left) and deactivated (to the right)"
<p></li>
</li>
</ul>
<li>Specify the <b>Number of steps</b>.</li>
<li>Optionally specify <b>Scale Factors</b>. Each scale factor in
the list is applied to nodes of a corresponding extrusion step
unless <b>Linear Variation of Scale Factors</b> is checked, is
which case the scale factors are spread over all extrusion steps.</li>
<ul>
<li><b>Scaling Center</b> can be defined either using spin boxes
or by picking a node in the Viewer or by picking a geometrical
vertex in the Object Browser.</li>
<li>\b Add button adds a scale factor to the list.
\image html add.png
<center><em>"Add" button</em></center>
</li>
<li>\b Remove button removes selected scale factors from the list.
\image html remove.png
<center><em>"Remove" button</em></center>
</li>
</ul>
<li>If you activate <b>Generate Groups</b> check-box, the <em>result elements</em>
created from <em>selected elements</em> contained in groups will be
included into new groups named by pattern "<old group
name>_extruded" and "<old group name>_top". For example if a
selected quadrangle is included in \a g_Faces group (see figures
below) then result hexahedra will be included in \a
g_Faces_extruded group and a quadrangle created at the "top" of
extruded mesh will be included in \a g_Faces_top group. <br>
\image html extrusion_groups.png
\image html extrusion_groups_res.png
<p> This check-box is active only if there are some groups in the mesh.
</li>
</ul>
<li>Click \b Apply or <b> Apply and Close</b> button to confirm the operation.</li>
</ol>
<p>
\anchor extrusion_struct
<h2>Example: creation of a structured mesh from scratch</h2>
\image html image75.jpg "A node is extruded into a line of segments"
<br>
\image html image76.jpg "The line of segments is extruded into a quadrangle mesh"
<br>
\image html image77.jpg "The quadrangle mesh is revolved into a hexahedral mesh"
<br><b>See Also</b> a sample TUI Script of an
\ref tui_extrusion "Extrusion" operation.
*/

183
doc/salome/gui/SMESH/input/extrusion.rst Normal file
View File

@ -0,0 +1,183 @@
.. _extrusion_page:
*********
Extrusion
*********
Extrusion is used to build mesh elements of plus one dimension than the input ones. Boundary elements around generated mesh of plus one dimension are additionally created. All created elements can be automatically grouped. Extrusion can be used to create a :ref:`extrusion_struct`:"structured mesh from scratch".
.. image:: ../images/extrusion_box.png
:align: center
.. centered::
"If you extrude several quadrangles, you get exactly the same mesh as if you meshed a geometrical box (except for that the initial quadrangles can be incorrectly oriented): quadrangles and segments are created on the boundary of the generated mesh"
Any node, segment or 2D element can be extruded. Each type of elements is extruded into a corresponding type of result elements:
+----------------------+--------------------+
| **Extruded element** | **Result element** |
+======================+====================+
|Node | Segment |
+----------------------+--------------------+
|Segment | Quadrilateral |
+----------------------+--------------------+
|Triangle | Pentahedron |
+----------------------+--------------------+
|Quadrilateral | Hexahedron |
+----------------------+--------------------+
|Polygon | Polyhedron |
+----------------------+--------------------+
|Hexagonal polygon | Hexagonal prism |
+----------------------+--------------------+
When 2D elements are extruded, in addition to 3D elements segments are created on the ribs of the resulting 3D mesh. Free edges of input 2D elements generate logically horizontal rib segments. Logically vertical rib segments are generated from the nodes belonging to a sole input 2D element (the figure below illustrates this rule).
.. image:: ../images/extru_rib_segs.png
:align: center
.. centered::
"Two triangles extruded: no vertical rib segments generated from nodes #2 and #3 as they are shared by both triangles"
**To use extrusion:**
#. From the **Modification** menu choose the **Extrusion** item or click **"Extrusion"** button in the toolbar.
.. image:: ../images/image91.png
:align: center
.. centered::
**"Extrusion" button**
The following dialog will appear:
.. image:: ../images/extrusionalongaline1.png
:align: center
#. In this dialog:
* Use *Selection* button to specify what you are going to select at a given moment, **Nodes**, **Edges** or **Faces**.
.. image:: ../images/image120.png
:align: center
.. centered::
**"Selection" button**
* Specify **Nodes**, **Edges** and **Faces**, which will be extruded, by one of following means:
* **Select the whole mesh, sub-mesh or group** activating the corresponding check-box.
* Choose mesh elements with the mouse in the 3D Viewer. It is possible to select a whole area with a mouse frame.
* Input the element IDs directly in **Node IDs**, **Edge IDs** and **Face IDs** fields. The selected elements will be highlighted in the viewer, if the mesh is shown there.
* Apply Filters. **Set filter** button allows to apply a filter to the selection of elements. See more about filters in the :ref:`filtering_elements`:"Selection filters" page.
* If the **Extrusion to Distance** radio button is selected
* specify the translation vector by which the elements will be extruded.
* If the **Extrusion Along Vector** radio button is selected
.. image:: ../images/extrusionalongaline2.png
:align: center
* specify the components of the **Vector** along which the elements will be extruded, either directly or by selecting the mesh face (the normal to the face will define the vector),
* specify the **Distance** of extrusion along the vector (it can be negative).
* If the **Extrusion By Normal** radio button is selected, every node of the selected faces is extruded along the *average* of the *normal* vectors to the faces sharing the node. (Nodes and edges cannot be extruded in this mode.)
.. image:: ../images/extrusionalongaline3.png
:align: center
* Specify the **Distance** of extrusion (it can be negative),
* Use **Along average normal** check-box to specify along which vector the distance is measured.
* If it is *activated* the distance is measured along the average normal mentioned above.
* If it is *deactivated* every node is extruded along the average normal till its intersection with a virtual plane obtained by translation of the face sharing the node along its own normal by the **Distance**.
The picture below shows a cross-section of a 2D mesh extruded with **Along average normal** activated (to the left) and deactivated (to the right).
.. image:: ../images/extrusionbynormal_alongavgnorm.png
:align: center
.. centered::
"'Along average normal' activated (to the left) and deactivated (to the right)"
* **Use only input elements** check-box specifies what elements will be used to compute the average normal.
* If it is *activated* only selected faces, among faces sharing the node, are used to compute the average normal at the node.
* Else all faces sharing the node are used.
The picture below shows a cross-section of a 2D mesh the upper plane of which is extruded with **Use only input elements** activated (to the left) and deactivated (to the right).
.. image:: ../images/extrusionbynormal_useonly.png
:align: center
.. centered::
"'Use only input elements' activated (to the left) and deactivated (to the right)"
* Specify the **Number of steps**.
* Optionally specify **Scale Factors**. Each scale factor in the list is applied to nodes of a corresponding extrusion step unless **Linear Variation of Scale Factors** is checked, is which case the scale factors are spread over all extrusion steps.
* **Scaling Center** can be defined either using spin boxes or by picking a node in the Viewer or by picking a geometrical vertex in the Object Browser.
* **Add** button adds a scale factor to the list.
.. image:: ../images/add.png
:align: center
.. centered::
**"Add" button**
* **Remove** button removes selected scale factors from the list.
.. image:: ../images/remove.png
:align: center
.. centered::
**"Remove" button**
* If you activate **Generate Groups** check-box, the **result elements** created from **selected elements** contained in groups will be included into new groups named by pattern "<old group name>_extruded" and "<old group name>_top". For example if a selected quadrangle is included in *g_Faces* group (see figures below) then result hexahedra will be included in *g_Faces_extruded* group and a quadrangle created at the "top" of extruded mesh will be included in *g_Faces_top group*.
.. image:: ../images/extrusion_groups.png
:align: center
.. image:: ../images/extrusion_groups_res.png
:align: center
This check-box is active only if there are some groups in the mesh.
#. Click **Apply** or **Apply and Close** button to confirm the operation.
.. _extrusion_struct:
Example: creation of a structured mesh from scratch
###################################################
.. image:: ../images/image75.jpg
:align: center
.. centered::
"A node is extruded into a line of segments"
.. image:: ../images/image76.jpg
:align: center
.. centered::
"The line of segments is extruded into a quadrangle mesh"
.. image:: ../images/image77.jpg
:align: center
.. centered::
"The quadrangle mesh is revolved into a hexahedral mesh"
**See Also** a sample TUI Script of an :ref:`tui_extrusion` operation.

176
doc/salome/gui/SMESH/input/extrusion_along_path.doc
View File

@ -1,176 +0,0 @@
/*!
\page extrusion_along_path_page Extrusion along Path
\n In principle, <b>Extrusion along Path</b> works in the same way
as \ref extrusion_page "Extrusion", the main difference is that we
define not a vector, but a path of extrusion which must be an 1D mesh
or 1D sub-mesh.
To get an idea of how this algorithm works, examine several examples,
starting from the most simple case of extrusion along a straight edge.
In the examples the sample mesh will be extruded along different
paths and with different parameters.
This 2D mesh has two quadrangle faces and seven edges. Look
at the picture, where white digits are the node numbers and green
are the element numbers:
\image html mesh_for_extr_along_path.png
<br><center><h2>Extrusion along a straight edge</h2>(not using base point
or angles)</center>
\image html straight_before.png
<center>The image shows a 1D path mesh, built on a linear edge, and the initial 2D mesh.</center>
\image html straight_after.png
<center> The image shows the result of extrusion of two edges
(#1 and #2) of the initial mesh along the path. \n Node #1 of path mesh
has been selected as Start node.</center>
<br><center><h2>Extrusion along a curvilinear edge</h2>(with and
without angles)</center>
\image html curvi_simple_before.png
<center>The image shows a 1D path mesh, built on curvilinear edge, and
the initial 2D mesh.</center>
\image html curvi_simple_after.png
<center>The central image shows the result of extrusion of one edge
(#2) of the initial mesh along the path. \n Node #1 of path mesh has
been selected as <b>Start node</b>.</center>
\image html curvi_angles_after.png
<center>The same, but using angles {45, 45, 45, 0, -45, -45, -45}</center>
<br><center><h2>Extrusion of a 2D face along a mesh built on a wire</h2></center>
In this example the path mesh has been built on a wire containing 3
edges. Node 1 is a start node. Linear angle variation by 180 degrees
has also been applied.
\image html extr_along_wire_before.png
<center><em>Meshed wire</em></center>
\image html extr_along_wire_after.png
<center><em>The resulting extrusion</em></center>
<br><center><h2>Extrusion of 2d elements along a closed path</h2></center>
\image html circle_simple_before.png
<center>The image shows a path mesh built on a closed edge
(circle).</center>
\image html circle_simple_after.png
<center>The central image shows the result of extrusion of both faces
of the initial mesh. \n Note, that no sewing has been done, so, there are
six coincident nodes and two coincident faces in the resulting
mesh.</center>
\image html circle_angles_after.png
<center>The same, but using angles {45, -45, 45, -45, 45, -45, 45, -45}
</center>
<br><em>To use Extrusion along Path:</em>
<ol>
<li>From the \b Modification menu choose the <b>Extrusion along a
path</b> item or click <em>"Extrusion along a path"</em> button in the toolbar.
\image html image101.png
<center><em>"Extrusion along a path" button</em></center>
The following dialog will appear:
\image html extrusion_along_path_dlg.png
</li>
<li>In this dialog:
<ul>
<li>Use \a Selection button to specify what you are going to
select at a given moment, \b Nodes, \b Edges or \b Faces.
\image html image120.png
<center><em>"Selection" button</em></center>
</li>
<li>Specify \b Nodes, \b Edges and \b Faces, which will be extruded, by one
of following means:
<ul>
<li><b>Select the whole mesh, sub-mesh or group</b> activating this
check-box.</li>
<li>Choose mesh elements with the mouse in the 3D Viewer. It is
possible to select a whole area with a mouse frame.</li>
<li>Input the element IDs directly in <b>Node IDs</b>, <b>Edge
IDs</b> and <b>Face IDs</b> fields. The selected elements will
be highlighted in the viewer, if the mesh is shown there.</li>
<li>Apply Filters. <b>Set filter</b> button allows to apply a
filter to the selection of elements. See more about filters in
the \ref filtering_elements "Selection filters" page.</li>
</ul>
</li>
<li>Define the \b Path along which the elements will be extruded.<br>
Path definition consists of several elements:
<ul>
<li><b>Mesh or sub-mesh</b> - 1D mesh or sub-mesh, along which
proceeds the extrusion.</li>
<li><b>Start node</b> - the start node of the Path. It is used
to define the direction of extrusion. </li>
</ul>
</li>
<li>If you activate <b>Generate Groups</b> check-box, the <em>result elements</em>
created from <em>selected elements</em> contained in groups will be
included into new groups named by pattern "<old group
name>_extruded" and "<old group name>_top". For example if a
selected quadrangle is included in \a g_Faces group (see figures
below) then result hexahedra will be included in \a
g_Faces_extruded group and a quadrangle created at the "top" of
extruded mesh will be included in \a g_Faces_top group. <br>
\image html extrusion_groups.png
\image html extrusion_groups_res.png
<p> This check-box is active only if there are some groups in the mesh.
</li>
</ul>
</li>
<li>There are two optional parameters, which can be very useful:
<ul>
<li>If the path of extrusion is curvilinear, at each iteration the
extruded elements are rotated to keep its initial angularity to the
curve. By default, the <b>Base Point</b> around which the elements
are rotated is the mass center of the elements (note that it can
differ from the gravity center computed by \a Geometry module for the
underlying shape), however, you can specify any point as the <b>Base
Point</b> and the elements will be rotated with respect to this
point.<br>
Note that only the displacement of the <b>Base Point</b> exactly
equals to the path, and all other extruded elements simply keep
their position relatively to the <b>Base Point</b> at each
iteration.</li>
<li>The elements can also be rotated around the path to get the
resulting mesh in a helical fashion. You can set the values of
angles at the right, add them to the list of angles at the left by
pressing the <em>"Add"</em> button and remove them from the list by
pressing the <em>"Remove"</em> button.
\image html add.png
<center><em>"Add" button</em></center>
\image html remove.png
<center><em>"Remove" button</em></center>
<b>Linear variation of the angles</b> option allows defining the angle
of gradual rotation for the whole path. At each step the elements will
be rotated by <code>( angle / nb. of steps )</code>.
</li>
</ul>
</li>
<li>Click \b Apply or <b> Apply and Close</b> button to confirm the
operation. Mesh edges will be extruded into faces, faces into
volumes. The external surface of the resulting 3d mesh (if faces
have been extruded) is covered with faces, and corners with
edges. If the path is closed, the resulting mesh can contain
duplicated nodes and faces, because no sewing is done.
</li>
</ol>
<br><b>See Also</b> a sample TUI Script of an
\ref tui_extrusion_along_path "Extrusion along a Path" operation.
*/

176
doc/salome/gui/SMESH/input/extrusion_along_path.rst Normal file
View File

@ -0,0 +1,176 @@
.. _extrusion_along_path_page:
********************
Extrusion along Path
********************
In principle, **Extrusion along Path** works in the same way as :ref:`extrusion_page`, the main difference is that we define not a vector, but a path of extrusion which must be an 1D mesh or 1D sub-mesh.
To get an idea of how this algorithm works, examine several examples, starting from the most simple case of extrusion along a straight edge.
In the examples the sample mesh will be extruded along different paths and with different parameters.
This 2D mesh has two quadrangle faces and seven edges. Look at the picture, where white digits are the node numbers and green are the element numbers:
.. image:: ../images/mesh_for_extr_along_path.png
:align: center
Extrusion along a straight edge
*******************************
(not using base point or angles)
.. image:: ../images/straight_before.png
:align: center
.. centered::
The image shows a 1D path mesh, built on a linear edge, and the initial 2D mesh.
.. image:: ../images/straight_after.png
:align: center
.. centered::
The image shows the result of extrusion of two edges (#1 and #2) of the initial mesh along the path.
.. note:: Node #1 of path mesh has been selected as Start node.
Extrusion along a curvilinear edge
##################################
(with and without angles)
.. image:: ../images/curvi_simple_before.png
:align: center
.. centered::
The image shows a 1D path mesh, built on curvilinear edge, and the initial 2D mesh.
.. image:: ../images/curvi_simple_after.png
:align: center
.. centered::
The central image shows the result of extrusion of one edge (#2) of the initial mesh along the path.
.. note:: Node #1 of path mesh has been selected as **Start node**.
.. image:: ../images/curvi_angles_after.png
:align: center
.. centered::
The same, but using angles {45, 45, 45, 0, -45, -45, -45}
Extrusion of a 2D face along a mesh built on a wire
###################################################
In this example the path mesh has been built on a wire containing 3 edges. Node 1 is a start node. Linear angle variation by 180 degrees has also been applied.
.. image:: ../images/extr_along_wire_before.png
:align: center
.. centered::
**Meshed wire**
.. image:: ../images/extr_along_wire_after.png
:align: center
.. centered::
**The resulting extrusion**
Extrusion of 2d elements along a closed path
############################################
.. image:: ../images/circle_simple_before.png
:align: center
.. centered::
The image shows a path mesh built on a closed edge (circle).
.. image:: ../images/circle_simple_after.png
:align: center
.. centered::
The central image shows the result of extrusion of both faces of the initial mesh.
.. note:: Note, that no sewing has been done, so, there are six coincident nodes and two coincident faces in the resulting mesh.
.. image:: ../images/circle_angles_after.png
:align: center
.. centered::
The same, but using angles {45, -45, 45, -45, 45, -45, 45, -45}
**To use Extrusion along Path:**
#. From the **Modification** menu choose the **Extrusion along a path** item or click **"Extrusion along a path"** button in the toolbar.
.. image:: ../images/image101.png
:align: center
.. centered::
**"Extrusion along a path" button**
The following dialog will appear:
.. image:: ../images/extrusion_along_path_dlg.png
#. In this dialog:
* Use *Selection* button to specify what you are going to select at a given moment, **Nodes**, **Edges** or **Faces**.
.. image:: ../images/image120.png
:align: center
.. centered::
**"Selection" button**
* Specify **Nodes**, **Edges** and **Faces**, which will be extruded, by one of following means:
* **Select the whole mesh, sub-mesh or group** activating this check-box.
* Choose mesh elements with the mouse in the 3D Viewer. It is possible to select a whole area with a mouse frame.
* Input the element IDs directly in **Node IDs**, **Edge IDs** and **Face IDs** fields. The selected elements will be highlighted in the viewer, if the mesh is shown there.
* Apply Filters. **Set filter** button allows to apply a filter to the selection of elements. See more about filters in the :ref:`filtering_elements` page.
* Define the **Path** along which the elements will be extruded.Path definition consists of several elements:
* **Mesh or sub-mesh** - 1D mesh or sub-mesh, along which proceeds the extrusion.
* **Start node** - the start node of the Path. It is used to define the direction of extrusion.
* If you activate **Generate Groups** check-box, the **result elements** created from **selected elements** contained in groups will be included into new groups named by pattern "<old group name>_extruded" and "<old group name>_top". For example if a selected quadrangle is included in *g_Faces* group (see figures below) then result hexahedra will be included in *g_Faces_extruded* group and a quadrangle created at the "top" of extruded mesh will be included in *g_Faces_top group*.
.. image:: ../images/extrusion_groups.png
:align: center
.. image:: ../images/extrusion_groups_res.png
:align: center
This check-box is active only if there are some groups in the mesh.
#. There are two optional parameters, which can be very useful:
#. If the path of extrusion is curvilinear, at each iteration the extruded elements are rotated to keep its initial angularity to the curve. By default, the **Base Point** around which the elements are rotated is the mass center of the elements (note that it can differ from the gravity center computed by *Geometry* module for the underlying shape), however, you can specify any point as the **Base Point** and the elements will be rotated with respect to this point. Note that only the displacement of the **Base Point** exactly equals to the path, and all other extruded elements simply keep their position relatively to the **Base Point** at each iteration.
#. The elements can also be rotated around the path to get the resulting mesh in a helical fashion. You can set the values of angles at the right, add them to the list of angles at the left by pressing the **"Add"** button and remove them from the list by pressing the **"Remove"** button.
.. image:: ../images/add.png
:align: center
.. centered::
**"Add" button**
.. image:: ../images/remove.png
:align: center
.. centered::
**"Remove" button**
**Linear variation of the angles** option allows defining the angle of gradual rotation for the whole path. At each step the elements will be rotated by *( angle / nb. of steps )*.
#. Click **Apply** or **Apply and Close** button to confirm the operation. Mesh edges will be extruded into faces, faces into volumes. The external surface of the resulting 3d mesh (if faces have been extruded) is covered with faces, and corners with edges. If the path is closed, the resulting mesh can contain duplicated nodes and faces, because no sewing is done.
**See Also** a sample TUI Script of an :ref:`tui_extrusion_along_path` operation.

41
doc/salome/gui/SMESH/input/find_element_by_point.doc
View File

@ -1,41 +0,0 @@
/*!
\page find_element_by_point_page Find Element by Point
\n This functionality allows you to find all mesh elements to which
belongs a certain point.
<em>To find the elements:</em>
<ol>
<li>Select a mesh or a group</li>
<li>Select from the Mesh menu or from the context menu the Find
Element by Point item.
\image html findelement3.png
<center><em>"Find Element by Point" button</em></center>
The following dialog box will appear:
\image html findelement2.png
</li>
<li>In this dialog box you should select:
<ul>
<li>the coordinates of the point;</li>
<li>the type of elements to be found; it is also possible to find elements
of all types related to the reference point. Choose type "All" to find
elements of any type except for nodes and 0D elements.</li>
</ul>
</li>
<li>Click the \b Find button.
</ol>
\image html findelement1.png
<center>The reference point and the related elements.</center>
<br><b>See Also</b> a sample TUI Script of a \ref tui_find_element_by_point "Find Element by Point" operation.
*/

39
doc/salome/gui/SMESH/input/find_element_by_point.rst Normal file
View File

@ -0,0 +1,39 @@
.. _find_element_by_point_page:
*********************
Find Element by Point
*********************
This functionality allows you to find all mesh elements to which belongs a certain point.
**To find the elements:**
#. Select a mesh or a group
#. Select from the Mesh menu or from the context menu the Find Element by Point item.
.. image:: ../images/findelement3.png
:align: center
.. centered::
**"Find Element by Point" button**
The following dialog box will appear:
.. image:: ../images/findelement2.png
:align: center
#. In this dialog box you should select:
* the coordinates of the point;
* the type of elements to be found; it is also possible to find elements of all types related to the reference point. Choose type "All" to find elements of any type except for nodes and 0D elements.
#. Click the **Find** button.
.. image:: ../images/findelement1.png
:align: center
.. centered::
The reference point and the related elements.
**See Also** a sample TUI Script of a :ref:`tui_find_element_by_point` operation.

17
doc/salome/gui/SMESH/input/free_borders.doc
View File

@ -1,17 +0,0 @@
/*!
\page free_borders_page Free borders
\n This mesh quality control highlights 1D elements (segments)
belonging to one element (face or volume) only.
\image html free_borders1.png
In this picture the free borders are displayed in red. (Faces are
explicitly shown via <em>Display Entity</em> menu as all elements but
segments are hidden upon this control activation).
<br><b>See Also</b> a sample TUI Script of a
\ref tui_free_borders "Free Borders quality control" operation.
*/

16
doc/salome/gui/SMESH/input/free_borders.rst Normal file
View File

@ -0,0 +1,16 @@
.. _free_borders_page:
************
Free borders
************
This mesh quality control highlights 1D elements (segments) belonging to one element (face or volume) only.
.. image:: ../images/free_borders1.png
:align: center
In this picture the free borders are displayed in red. (Faces are explicitly shown via **Display Entity** menu as all elements but segments are hidden upon this control activation).
**See Also** a sample TUI Script of a :ref:`tui_free_borders` operation.

15
doc/salome/gui/SMESH/input/free_edges.doc
View File

@ -1,15 +0,0 @@
/*!
\page free_edges_page Free edges
\n This mesh quality control highlights borders of faces
(links between nodes, not mesh segments) belonging to one face only.
\image html free_edges.png
<center>In this picture some elements of mesh have been deleted and
the "holes" are outlined in red.</center>
<br><b>See Also</b> a sample TUI Script of a
\ref tui_free_edges "Free Edges quality control" operation.
*/

17
doc/salome/gui/SMESH/input/free_edges.rst Normal file
View File

@ -0,0 +1,17 @@
.. _free_edges_page:
**********
Free edges
**********
This mesh quality control highlights borders of faces (links between nodes, not mesh segments) belonging to one face only.
.. image:: ../images/free_edges.png
:align: center
.. centered::
In this picture some elements of mesh have been deleted and the "holes" are outlined in red.
**See Also** a sample TUI Script of a :ref:`tui_free_edges` operation.

18
doc/salome/gui/SMESH/input/free_faces.doc
View File

@ -1,18 +0,0 @@
/*!
\page free_faces_page Free faces
This mesh quality control highlights the faces connected to
less than two mesh volume elements. The free faces are shown with a
color different from the color of shared faces.
\image html free_faces.png
In this picture some volume mesh elements have been removed, as
a result some faces became connected only to one
volume. i.e. became free.
\sa A sample TUI Script of a \ref tui_free_faces "Free Faces quality control"
operation.
*/

Some files were not shown because too many files have changed in this diff Show More