Structured documentation

Contents

• Structured documentation

  • Creating meshes

    • Importing and exporting meshes

    • Constructing meshes

    • Defining Algorithms

    • Defining hypotheses

      • 1D Meshing Hypotheses

      • 2D Meshing Hypotheses

      • Additional Hypotheses

    • Constructing sub-meshes

    • Editing Meshes

  • Grouping elements

    • Creating groups

    • Operations on groups

    • Deleting Groups

  • Mesh Information

  • Quality controls and Filtering

  • Measurements

  • Modifying meshes

    • Adding nodes and elements

    • Removing nodes and elements

    • Modifying nodes and elements

    • Convert to/from Quadratic Mesh

    • Extrusion and Revolution

    • Transforming meshes (Translation, Rotation, Symmetry, Sewing, Merging)

    • Changing orientation of elements

    • Uniting triangles

    • Cutting elements

    • Smoothing

    • Duplication of nodes and elements (to emulate cracks)

    • Renumbering nodes and elements

  • Auxiliary methods

Creating meshes

smeshBuilder.Concatenate(meshes, …[, …])	Concatenate the given meshes into one mesh, optionally to meshToAppendTo.
smeshBuilder.CopyMesh(meshPart, meshName[, …])	Create a mesh by copying a part of another mesh.

Importing and exporting meshes

smeshBuilder.CreateMeshesFromUNV(theFileName)	Create a Mesh object importing data from the given UNV file
smeshBuilder.CreateMeshesFromMED(theFileName)	Create a Mesh object(s) importing data from the given MED file
smeshBuilder.CreateMeshesFromSTL(theFileName)	Create a Mesh object importing data from the given STL file
smeshBuilder.CreateMeshesFromCGNS(theFileName)	Create Mesh objects importing data from the given CGNS file
smeshBuilder.CreateMeshesFromGMF(theFileName)	Create a Mesh object importing data from the given GMF file.
Mesh.ExportMED(*args, **kwargs)	Export the mesh in a file in MED format allowing to overwrite the file if it exists or add the exported data to its contents
Mesh.ExportUNV(f[, meshPart, renumber])	Export the mesh in a file in UNV format
Mesh.ExportSTL(f[, ascii, meshPart])	Export the mesh in a file in STL format
Mesh.ExportCGNS(f[, overwrite, meshPart, …])	Export the mesh in a file in CGNS format
Mesh.ExportDAT(f[, meshPart, renumber])	Export the mesh in a file in DAT format
Mesh.ExportGMF(f[, meshPart])	Export the mesh in a file in GMF format.

Constructing meshes

smeshBuilder.Mesh([obj, name])	Create a mesh.
Mesh.SetName(name)	Set a name to the mesh
Mesh.SetMeshOrder(submeshes)	Set priority of sub-meshes.
Mesh.Compute([geom, discardModifs, refresh])	Compute the mesh and return the status of the computation
Mesh.Evaluate([geom])	Evaluate size of prospective mesh on a shape
Mesh.Clear([refresh])	Remove all nodes and elements generated on geometry.
Mesh.GetMesh()	Return the mesh, that is an encapsulated instance of SMESH.SMESH_Mesh interface
Mesh.GetShape()	Return the shape associated to the mesh
Mesh.HasShapeToMesh()	Return True if this mesh is based on geometry
Mesh.GetComputeErrors([shape])	Return a list of error messages (SMESH.ComputeError) of the last Compute()
Mesh.GetAlgoState(theSubObject)	Return errors of hypotheses definition.
Mesh.GetFailedShapes([publish])	Return a list of sub-shapes meshing of which failed, grouped into GEOM groups by error of an algorithm
Mesh.GetMeshOrder()	Return sub-mesh objects list in meshing order

Defining Algorithms

Mesh.Segment([geom_shape])	Create segment 1D algorithm for edges
Mesh.Quadrangle([geom_shape])	Create quadrangle 1D-2D algorithm for faces
Mesh.Hexahedron([geom_shape])	Create hexahedron 3D algorithm for volumes
Mesh.Prism([geom_shape])	Create prism 3D algorithm for volumes
Mesh.BodyFitted([geom_shape])	Create Body Fitting 3D algorithm for volumes
Mesh.Projection1D([geom_shape])	Create projection 1D algorithm for edges
Mesh.Projection2D([geom_shape])	Create projection 2D algorithm for faces
Mesh.Projection1D2D([geom_shape])	Create projection 1D-2D algorithm for faces
Mesh.Projection3D([geom_shape])	Create projection 3D algorithm for volumes
Mesh.UseExisting1DElements([geom_shape])	Create 1D algorithm for edges with reusing of existing mesh elements
Mesh.UseExisting2DElements([geom_shape])	Create 1D-2D algorithm for faces with reusing of existing mesh elements
Mesh.UseExistingSegments([geom_shape])	Create 1D algorithm allowing batch meshing of edges
Mesh.UseExistingFaces([geom_shape])	Create 2D algorithm allowing batch meshing of faces
Mesh.AutomaticTetrahedralization([fineness])	Compute a tetrahedral mesh using AutomaticLength + Triangle + Tetrahedron
Mesh.AutomaticHexahedralization([fineness])	Compute an hexahedral mesh using AutomaticLength + Quadrangle + Hexahedron
smesh_algorithm.Mesh_Algorithm()	The base class to define meshing algorithms

Defining hypotheses

1D Meshing Hypotheses

StdMeshersBuilder_Segment.NumberOfSegments(n)	Defines “NumberOfSegments” hypothesis to cut an edge in a fixed number of segments
StdMeshersBuilder_Segment.LocalLength(l[, …])	Defines “LocalLength” hypothesis to cut an edge in several segments with the same length
StdMeshersBuilder_Segment.MaxSize([length, …])	Defines “MaxSize” hypothesis to cut an edge into segments not longer than given value
StdMeshersBuilder_Segment.Arithmetic1D(…)	Defines “Arithmetic1D” hypothesis to cut an edge in several segments with a length
StdMeshersBuilder_Segment.GeometricProgression(…)	Defines “GeometricProgression” hypothesis to cut an edge in several
StdMeshersBuilder_Segment.FixedPoints1D(points)	Defines “FixedPoints1D” hypothesis to cut an edge using parameter
StdMeshersBuilder_Segment.StartEndLength(…)	Defines “StartEndLength” hypothesis to cut an edge in several segments with increasing geometric length
StdMeshersBuilder_Segment.Adaptive(minSize, …)	Defines “Adaptive” hypothesis to cut an edge into segments keeping segment size within the given range and considering (1) deflection of segments from the edge and (2) distance from segments to closest edges and faces to have segment length not longer than two times shortest distances to edges and faces.
StdMeshersBuilder_Segment.Deflection1D(d[, …])	Defines “Deflection1D” hypothesis
StdMeshersBuilder_Segment.AutomaticLength([…])	Defines “AutomaticLength” hypothesis
StdMeshersBuilder_Segment_Python.PythonSplit1D(n, func)	Defines “PythonSplit1D” hypothesis

2D Meshing Hypotheses

StdMeshersBuilder_Quadrangle.QuadrangleParameters([…])	Defines “QuadrangleParameters” hypothesis
StdMeshersBuilder_Quadrangle.QuadranglePreference([…])	Defines “QuadrangleParams” hypothesis with a type of quadrangulation that only
StdMeshersBuilder_Quadrangle.TrianglePreference([…])	Defines “QuadrangleParams” hypothesis with a type of quadrangulation that only
StdMeshersBuilder_Quadrangle.Reduced([…])	Defines “QuadrangleParams” hypothesis with a type of quadrangulation that only
StdMeshersBuilder_Quadrangle.TriangleVertex(vertex)	Defines “QuadrangleParams” hypothesis with QUAD_STANDARD type of quadrangulation

Additional Hypotheses

smesh_algorithm.Mesh_Algorithm.ViscousLayers(…)	Defines “ViscousLayers” hypothesis to give parameters of layers of prisms to build near mesh boundary.
smesh_algorithm.Mesh_Algorithm.ViscousLayers2D(…)	Defines “ViscousLayers2D” hypothesis to give parameters of layers of quadrilateral elements to build near mesh boundary.
StdMeshersBuilder.StdMeshersBuilder_Segment.Propagation()	Defines “Propagation” hypothesis that propagates 1D hypotheses
StdMeshersBuilder.StdMeshersBuilder_Segment.PropagationOfDistribution()	Defines “Propagation of Node Distribution” hypothesis that propagates
StdMeshersBuilder.StdMeshersBuilder_Segment.QuadraticMesh()	Defines “QuadraticMesh” hypothesis, forcing construction of quadratic edges.

Constructing sub-meshes

Mesh.GetSubMesh(geom, name)	Get a sub-mesh object associated to a geom geometrical object.
Mesh.ClearSubMesh(geomId[, refresh])	Remove all nodes and elements of indicated shape

Editing Meshes

Mesh.AddHypothesis(hyp[, geom])	Assign a hypothesis
Mesh.RemoveHypothesis(hyp[, geom])	Unassign a hypothesis
Mesh.RemoveGlobalHypotheses()	Remove all global hypotheses
Mesh.GetHypothesisList(geom)	Get the list of hypotheses added on a geometry
Mesh.IsUsedHypothesis(hyp, geom)	Return True if an algorithm or hypothesis is assigned to a given shape

Grouping elements

Mesh.SetAutoColor(theAutoColor)	Toggle auto color mode on the object.
Mesh.GetAutoColor()	Get flag of object auto color mode.
Mesh.HasDuplicatedGroupNamesMED()	Check the group names for duplications.

Creating groups

Mesh.CreateEmptyGroup(elementType, name)	Create an empty standalone mesh group
Mesh.Group(grp[, name])	Create a mesh group based on the geometric object grp and give it a name.
Mesh.GroupOnGeom(grp[, name, typ])	Create a mesh group based on the geometrical object grp and give it a name.
Mesh.GroupOnFilter(typ, name, filter)	Create a mesh group with given name based on the filter.
Mesh.MakeGroupByIds(groupName, elementType, …)	Create a mesh group by the given ids of elements
Mesh.MakeGroup(groupName, elementType[, …])	Create a mesh group by the given conditions
Mesh.MakeGroupByCriterion(groupName, Criterion)	Create a mesh group by the given criterion
Mesh.MakeGroupByCriteria(groupName, theCriteria)	Create a mesh group by the given criteria (list of SMESH.Filter.Criterion)
Mesh.MakeGroupByFilter(groupName, theFilter)	Create a mesh group by the given filter
Mesh.FaceGroupsSeparatedByEdges(sharpAngle)	Distribute all faces of the mesh among groups using sharp edges and optionally existing 1D elements as group boundaries.
Mesh.CreateDimGroup(groups, elemType, name)	Create a standalone group of entities basing on nodes of other groups.
Mesh.ConvertToStandalone(group)	Convert group on geom into standalone group
Mesh.GetGroups([elemType])	Get the list of groups existing in the mesh in the order of creation (starting from the oldest one)
Mesh.NbGroups()	Get the number of groups existing in the mesh
Mesh.GetGroupNames()	Get the list of names of groups existing in the mesh
Mesh.GetGroupByName(name[, elemType])	Find groups by name and type

Operations on groups

Mesh.UnionGroups(group1, group2, name)	Produce a union of two groups.
Mesh.UnionListOfGroups(groups, name)	Produce a union list of groups.
Mesh.IntersectGroups(group1, group2, name)	Prodice an intersection of two groups.
Mesh.IntersectListOfGroups(groups, name)	Produce an intersection of groups.
Mesh.CutGroups(main_group, tool_group, name)	Produce a cut of two groups.
Mesh.CutListOfGroups(main_groups, …)	Produce a cut of groups.

Deleting Groups

Mesh.RemoveGroup(group)	Remove a group
Mesh.RemoveGroupWithContents(group)	Remove a group with its contents

Mesh Information

smeshBuilder.GetMeshInfo(obj)	Get the mesh statistic.
Mesh.GetEngine()	Return a smeshBuilder instance created this mesh
Mesh.GetGeomEngine()	Return a geomBuilder instance
Mesh.GetGeometryByMeshElement(theElementID, …)	Return a geometrical object on which the given element was built.
Mesh.MeshDimension()	Return the mesh dimension depending on the dimension of the underlying shape or, if the mesh is not based on any shape, basing on deimension of elements
Mesh.GetMeshInfo([obj])	Get the mesh statistic.
Mesh.NbNodes()	Return the number of nodes in the mesh
Mesh.NbElements()	Return the number of elements in the mesh
Mesh.Nb0DElements()	Return the number of 0d elements in the mesh
Mesh.NbBalls()	Return the number of ball discrete elements in the mesh
Mesh.NbEdges()	Return the number of edges in the mesh
Mesh.NbEdgesOfOrder(elementOrder)	Return the number of edges with the given order in the mesh
Mesh.NbFaces()	Return the number of faces in the mesh
Mesh.NbFacesOfOrder(elementOrder)	Return the number of faces with the given order in the mesh
Mesh.NbTriangles()	Return the number of triangles in the mesh
Mesh.NbTrianglesOfOrder(elementOrder)	Return the number of triangles with the given order in the mesh
Mesh.NbBiQuadTriangles()	Return the number of biquadratic triangles in the mesh
Mesh.NbQuadrangles()	Return the number of quadrangles in the mesh
Mesh.NbQuadranglesOfOrder(elementOrder)	Return the number of quadrangles with the given order in the mesh
Mesh.NbBiQuadQuadrangles()	Return the number of biquadratic quadrangles in the mesh
Mesh.NbPolygons([elementOrder])	Return the number of polygons of given order in the mesh
Mesh.NbVolumes()	Return the number of volumes in the mesh
Mesh.NbVolumesOfOrder(elementOrder)	Return the number of volumes with the given order in the mesh
Mesh.NbTetras()	Return the number of tetrahedrons in the mesh
Mesh.NbTetrasOfOrder(elementOrder)	Return the number of tetrahedrons with the given order in the mesh
Mesh.NbHexas()	Return the number of hexahedrons in the mesh
Mesh.NbHexasOfOrder(elementOrder)	Return the number of hexahedrons with the given order in the mesh
Mesh.NbTriQuadraticHexas()	Return the number of triquadratic hexahedrons in the mesh
Mesh.NbPyramids()	Return the number of pyramids in the mesh
Mesh.NbPyramidsOfOrder(elementOrder)	Return the number of pyramids with the given order in the mesh
Mesh.NbPrisms()	Return the number of prisms in the mesh
Mesh.NbPrismsOfOrder(elementOrder)	Return the number of prisms with the given order in the mesh
Mesh.NbHexagonalPrisms()	Return the number of hexagonal prisms in the mesh
Mesh.NbPolyhedrons()	Return the number of polyhedrons in the mesh
Mesh.NbSubMesh()	Return the number of submeshes in the mesh
Mesh.GetNodesId()	Return the list of mesh nodes IDs
Mesh.GetElementsId()	Return the list of all mesh elements IDs
Mesh.GetElementsByType(elementType)	Return the list of IDs of mesh elements with the given type
Mesh.GetElementType(id[, iselem])	Return the type of mesh element or node
Mesh.GetElementGeomType(id)	Return the geometric type of mesh element
Mesh.GetElementShape(id)	Return the shape type of mesh element
Mesh.GetSubMeshElementsId(Shape)	Return the list of sub-mesh elements IDs
Mesh.GetSubMeshNodesId(Shape, all)	Return the list of sub-mesh nodes IDs
Mesh.GetSubMeshElementType(Shape)	Return type of elements on given shape
Mesh.GetNodeXYZ(id)	Get XYZ coordinates of a node.
Mesh.GetNodeInverseElements(id[, elemType])	Return list of IDs of inverse elements for the given node.
Mesh.GetNodePosition(NodeID)	Return the position of a node on the shape
Mesh.GetElementPosition(ElemID)	Return the position of an element on the shape
Mesh.GetShapeID(id)	Return the ID of the shape, on which the given node was generated.
Mesh.GetShapeIDForElem(id)	Return the ID of the shape, on which the given element was generated.
Mesh.GetElemNbNodes(id)	Return the number of nodes of the given element
Mesh.GetElemNode(id, index)	Return the node ID the given (zero based) index for the given element.
Mesh.GetElemNodes(id)	Return the IDs of nodes of the given element
Mesh.IsMediumNode(elementID, nodeID)	Return true if the given node is the medium node in the given quadratic element
Mesh.IsMediumNodeOfAnyElem(nodeID[, elementType])	Return true if the given node is the medium node in one of quadratic elements
Mesh.ElemNbEdges(id)	Return the number of edges for the given element
Mesh.ElemNbFaces(id)	Return the number of faces for the given element
Mesh.GetElemFaceNodes(elemId, faceIndex)	Return nodes of given face (counted from zero) for given volumic element.
Mesh.GetFaceNormal(faceId[, normalized])	Return three components of normal of given mesh face (or an empty array in KO case)
Mesh.FindElementByNodes(nodes)	Return an element based on all given nodes.
Mesh.GetElementsByNodes(nodes[, elemType])	Return elements including all given nodes.
Mesh.IsPoly(id)	Return true if the given element is a polygon
Mesh.IsQuadratic(id)	Return true if the given element is quadratic
Mesh.GetBallDiameter(id)	Return diameter of a ball discrete element or zero in case of an invalid id
Mesh.BaryCenter(id)	Return XYZ coordinates of the barycenter of the given element.
Mesh.FindNodeClosestTo(x, y, z)	Find the node closest to a point
Mesh.FindElementsByPoint(x, y, z[, …])	Find the elements where a point lays IN or ON
Mesh.GetPointState(x, y, z)	Return point state in a closed 2D mesh in terms of TopAbs_State enumeration: smesh.TopAbs_IN, smesh.TopAbs_OUT, smesh.TopAbs_ON and smesh.TopAbs_UNKNOWN.
Mesh.Get1DBranches(edges[, startNode])	Partition given 1D elements into groups of contiguous edges.
Mesh.Dump()	Get the mesh description

Quality controls and Filtering

smeshBuilder.GetEmptyCriterion()	Create an empty criterion
smeshBuilder.GetCriterion(elementType, CritType)	Create a criterion by the given parameters Criterion structures allow to define complex filters by combining them with logical operations (AND / OR) (see example below)
smeshBuilder.GetFilter(elementType[, …])	Create a filter with the given parameters
smeshBuilder.GetFilterFromCriteria(criteria)	Create a filter from criteria
smeshBuilder.GetFunctor(theCriterion)	Create a numerical functor by its type
Mesh.GetIdsFromFilter(filter[, meshParts])	Pass mesh elements through the given filter and return IDs of fitting elements
Mesh.GetMaxElementLength(elemId)	Get maximum element length.
Mesh.GetAspectRatio(elemId)	Get aspect ratio of 2D or 3D element.
Mesh.GetWarping(elemId)	Get warping angle of 2D element.
Mesh.GetMinimumAngle(elemId)	Get minimum angle of 2D element.
Mesh.GetTaper(elemId)	Get taper of 2D element.
Mesh.GetSkew(elemId)	Get skew of 2D element.
Mesh.GetMinMax(funType[, meshPart])	Return minimal and maximal value of a given functor.
Mesh.IsManifold()	Check if a 2D mesh is manifold
Mesh.IsCoherentOrientation2D()	Check if orientation of 2D elements is coherent

Measurements

smeshBuilder.MinDistance(src1[, src2, id1, …])	Get minimum distance between two objects
smeshBuilder.GetMinDistance(src1[, src2, …])	Get SMESH.Measure structure specifying minimum distance data between two objects
smeshBuilder.BoundingBox(objects)	Get bounding box of the specified object(s)
smeshBuilder.GetBoundingBox(objects)	Get SMESH.Measure structure specifying bounding box data of the specified object(s)
smeshBuilder.GetLength(obj)	Get sum of lengths of all 1D elements in the mesh object.
smeshBuilder.GetArea(obj)	Get sum of areas of all 2D elements in the mesh object.
smeshBuilder.GetVolume(obj)	Get sum of volumes of all 3D elements in the mesh object.
smeshBuilder.GetAngle(p1, p2, p3)	Computes a radian measure of an angle defined by 3 points: <(p1,p2,p3)
Mesh.GetFreeBorders()	Verify whether a 2D mesh element has free edges (edges connected to one face only).
Mesh.MinDistance(id1[, id2, isElem1, isElem2])	Get minimum distance between two nodes, elements or distance to the origin
Mesh.GetMinDistance(id1[, id2, isElem1, isElem2])	Get SMESH.Measure structure specifying minimum distance data between two objects
Mesh.BoundingBox([objects, isElem])	Get bounding box of the specified object(s)
Mesh.GetBoundingBox([objects, isElem])	Get SMESH.Measure structure specifying bounding box data of the specified object(s)
Mesh.GetFunctor(funcType)	Return a cached numerical functor by its type.
Mesh.FunctorValue(funcType, elemId[, isElem])	Return value of a functor for a given element
Mesh.GetLength([elemId])	Get length of given 1D elements or of all 1D mesh elements
Mesh.GetArea([elemId])	Get area of given 2D elements or of all 2D mesh elements
Mesh.GetVolume([elemId])	Get volume of given 3D elements or of all 3D mesh elements
Mesh.GetAngle(node1, node2, node3)	Computes a radian measure of an angle defined by 3 nodes: <(node1,node2,node3)

Modifying meshes

smeshBuilder.GetPattern()	Create a pattern mapper.
Mesh.GetMeshEditor()	Obtain the mesh editor tool

Adding nodes and elements

Mesh.AddNode(x, y, z)	Add a node to the mesh by coordinates
Mesh.Add0DElement(IDOfNode[, DuplicateElements])	Create a 0D element on a node with given number.
Mesh.Add0DElementsToAllNodes(theObject[, …])	Create 0D elements on all nodes of the given elements except those nodes on which a 0D element already exists.
Mesh.AddBall(IDOfNode, diameter)	Create a ball element on a node with given ID.
Mesh.AddEdge(IDsOfNodes)	Create a linear or quadratic edge (this is determined by the number of given nodes).
Mesh.AddFace(IDsOfNodes)	Create a linear or quadratic face (this is determined by the number of given nodes).
Mesh.AddPolygonalFace(IdsOfNodes)	Add a polygonal face defined by a list of node IDs
Mesh.AddQuadPolygonalFace(IdsOfNodes)	Add a quadratic polygonal face defined by a list of node IDs
Mesh.AddVolume(IDsOfNodes)	Create both simple and quadratic volume (this is determined by the number of given nodes).
Mesh.AddPolyhedralVolume(IdsOfNodes, Quantities)	Create a volume of many faces, giving nodes for each face.
Mesh.AddPolyhedralVolumeByFaces(IdsOfFaces)	Create a volume of many faces, giving the IDs of the existing faces.
Mesh.SetNodeOnVertex(NodeID, Vertex)	Bind a node to a vertex
Mesh.SetNodeOnEdge(NodeID, Edge, paramOnEdge)	Store the node position on an edge
Mesh.SetNodeOnFace(NodeID, Face, u, v)	Store node position on a face
Mesh.SetNodeInVolume(NodeID, Solid)	Bind a node to a solid
Mesh.SetMeshElementOnShape(ElementID, Shape)	Bind an element to a shape
Mesh.Make2DMeshFrom3D()	Create 2D mesh as skin on boundary faces of a 3D mesh
Mesh.MakeBoundaryMesh(elements[, dimension, …])	Create missing boundary elements
Mesh.MakeBoundaryElements([dimension, …])	Create missing boundary elements around either the whole mesh or groups of elements
Mesh.Append(meshes[, uniteIdenticalGroups, …])	Append given meshes into this mesh.
Mesh.GetLastCreatedNodes()	If during the last operation of SMESH.SMESH_MeshEditor some nodes were created, this method return the list of their IDs.
Mesh.GetLastCreatedElems()	If during the last operation of SMESH.SMESH_MeshEditor some elements were created this method return the list of their IDs.
Mesh.ClearLastCreated()	Forget what nodes and elements were created by the last mesh edition operation

Removing nodes and elements

Mesh.RemoveElements(IDsOfElements)	Remove the elements from the mesh by ids
Mesh.RemoveNodes(IDsOfNodes)	Remove nodes from mesh by ids
Mesh.RemoveNodeWithReconnection(nodeID)	Remove a node along with changing surrounding faces to cover a hole.
Mesh.RemoveOrphanNodes()	Remove all orphan (free) nodes from mesh

Modifying nodes and elements

Mesh.MoveNode(NodeID, x, y, z)	Move the node with the given id
Mesh.MoveClosestNodeToPoint(x, y, z, NodeID)	Find the node closest to a point and moves it to a point location
Mesh.MeshToPassThroughAPoint(x, y, z)	Find the node closest to a point and moves it to a point location
Mesh.ChangeElemNodes(ide, newIDs)	Set new nodes for the given element.

Convert to/from Quadratic Mesh

Mesh.ConvertToQuadratic([theForce3d, …])	Convert the mesh to quadratic or bi-quadratic, deletes old elements, replacing them with quadratic with the same id.
Mesh.ConvertFromQuadratic([theSubMesh])	Convert the mesh from quadratic to ordinary, deletes old quadratic elements, replacing them with ordinary mesh elements with the same id.

Extrusion and Revolution

Mesh.RotationSweepObjects(nodes, edges, …)	Generate new elements by rotation of the given elements and nodes around the axis
Mesh.RotationSweep(IDsOfElements, Axis, …)	Generate new elements by rotation of the elements around the axis
Mesh.RotationSweepObject(theObject, Axis, …)	Generate new elements by rotation of the elements of object around the axis theObject object which elements should be sweeped.
Mesh.RotationSweepObject1D(theObject, Axis, …)	Generate new elements by rotation of the elements of object around the axis theObject object which elements should be sweeped.
Mesh.RotationSweepObject2D(theObject, Axis, …)	Generate new elements by rotation of the elements of object around the axis theObject object which elements should be sweeped.
Mesh.ExtrusionSweepObjects(nodes, edges, …)	Generate new elements by extrusion of the given elements and nodes
Mesh.ExtrusionSweep(IDsOfElements, …[, …])	Generate new elements by extrusion of the elements with given ids
Mesh.ExtrusionByNormal(Elements, StepSize, …)	Generate new elements by extrusion along the normal to a discretized surface or wire
Mesh.ExtrusionSweepObject(theObject, …[, …])	Generate new elements by extrusion of the elements or nodes which belong to the object
Mesh.ExtrusionSweepObject1D(theObject, …)	Generate new elements by extrusion of edges which belong to the object
Mesh.ExtrusionSweepObject2D(theObject, …)	Generate new elements by extrusion of faces which belong to the object
Mesh.AdvancedExtrusion(IDsOfElements, …[, …])	Generate new elements by extrusion of the elements with given ids
Mesh.ExtrusionAlongPathObjects(Nodes, Edges, …)	Generate new elements by extrusion of the given elements and nodes along the path.
Mesh.ExtrusionAlongPathX(Base, Path, NodeStart)	Generate new elements by extrusion of the given elements.
Mesh.ExtrusionAlongPath(IDsOfElements, …)	Generate new elements by extrusion of the given elements.
Mesh.ExtrusionAlongPathObject(theObject, …)	Generate new elements by extrusion of the elements which belong to the object.
Mesh.ExtrusionAlongPathObject1D(theObject, …)	Generate new elements by extrusion of mesh segments which belong to the object.
Mesh.ExtrusionAlongPathObject2D(theObject, …)	Generate new elements by extrusion of faces which belong to the object.

Transforming meshes (Translation, Rotation, Symmetry, Sewing, Merging)

Mesh.Mirror(IDsOfElements, Mirror[, …])	Create a symmetrical copy of mesh elements
Mesh.MirrorMakeMesh(IDsOfElements, Mirror[, …])	Create a new mesh by a symmetrical copy of mesh elements
Mesh.MirrorObject(theObject, Mirror[, …])	Create a symmetrical copy of the object
Mesh.MirrorObjectMakeMesh(theObject, Mirror)	Create a new mesh by a symmetrical copy of the object
Mesh.Translate(IDsOfElements, Vector, Copy)	Translate the elements
Mesh.TranslateMakeMesh(IDsOfElements, Vector)	Create a new mesh of translated elements
Mesh.TranslateObject(theObject, Vector, Copy)	Translate the object
Mesh.TranslateObjectMakeMesh(theObject, Vector)	Create a new mesh from the translated object
Mesh.Rotate(IDsOfElements, Axis, …[, …])	Rotate the elements
Mesh.RotateMakeMesh(IDsOfElements, Axis, …)	Create a new mesh of rotated elements
Mesh.RotateObject(theObject, Axis, …[, …])	Rotate the object
Mesh.RotateObjectMakeMesh(theObject, Axis, …)	Create a new mesh from the rotated object
Mesh.FindCoincidentNodes(Tolerance[, …])	Find groups of adjacent nodes within Tolerance.
Mesh.FindCoincidentNodesOnPart(…[, …])	Find groups of adjacent nodes within Tolerance.
Mesh.MergeNodes(GroupsOfNodes[, …])	Merge nodes
Mesh.FindEqualElements([…])	Find the elements built on the same nodes.
Mesh.MergeElements(GroupsOfElementsID[, …])	Merge elements in each given group.
Mesh.MergeEqualElements()	Leave one element and remove all other elements built on the same nodes.
Mesh.FindFreeBorders([ClosedOnly])	Returns all or only closed free borders
Mesh.FillHole(holeNodes[, groupName])	Fill with 2D elements a hole defined by a SMESH.FreeBorder.
Mesh.FindCoincidentFreeBorders([tolerance])	Return groups of FreeBorder’s coincident within the given tolerance.
Mesh.SewCoincidentFreeBorders(freeBorders[, …])	Sew FreeBorder’s of each group
Mesh.SewFreeBorders(FirstNodeID1, …)	Sew free borders
Mesh.SewConformFreeBorders(FirstNodeID1, …)	Sew conform free borders
Mesh.SewBorderToSide(…)	Sew border to side
Mesh.SewSideElements(IDsOfSide1Elements, …)	Sew two sides of a mesh.

Changing orientation of elements

Mesh.Reorient([IDsOfElements])	Reorient elements by ids
Mesh.ReorientObject(theObject)	Reorient all elements of the object
Mesh.Reorient2D(the2DObject, theDirection, …)	Reorient faces contained in the2DObject.
Mesh.Reorient2DByNeighbours(objectFaces[, …])	Reorient faces contained in a list of objectFaces equally to faces contained in a list of referenceFaces.
Mesh.Reorient2DBy3D(the2DObject, the3DObject)	Reorient faces according to adjacent volumes.

Uniting triangles

Mesh.DeleteDiag(NodeID1, NodeID2)	Replace two neighbour triangles sharing Node1-Node2 link with a quadrangle built on the same 4 nodes.
Mesh.TriToQuad(IDsOfElements, theCriterion, …)	Fuse the neighbouring triangles into quadrangles.
Mesh.TriToQuadObject(theObject, …)	Fuse the neighbouring triangles of the object into quadrangles

Cutting elements

Mesh.InverseDiag(NodeID1, NodeID2)	Replace two neighbour triangles sharing Node1-Node2 link with the triangles built on the same 4 nodes but having other common link.
Mesh.QuadToTri(IDsOfElements[, theCriterion])	Split quadrangles into triangles.
Mesh.QuadToTriObject(theObject[, theCriterion])	Split quadrangles into triangles.
Mesh.QuadTo4Tri([theElements])	Split each of given quadrangles into 4 triangles.
Mesh.SplitQuad(IDsOfElements, Diag13)	Split quadrangles into triangles.
Mesh.SplitQuadObject(theObject, Diag13)	Split quadrangles into triangles.
Mesh.BestSplit(IDOfQuad, theCriterion)	Find a better splitting of the given quadrangle.
Mesh.SplitVolumesIntoTetra(elems[, method, …])	Split volumic elements into tetrahedrons
Mesh.SplitBiQuadraticIntoLinear([elems])	Split bi-quadratic elements into linear ones without creation of additional nodes:
Mesh.SplitHexahedraIntoPrisms(elems, …[, …])	Split hexahedra into prisms
Mesh.SplitQuadsNearTriangularFacets()	Split quadrangle faces near triangular facets of volumes
Mesh.SplitHexaToTetras(theObject, …)	Split hexahedrons into tetrahedrons.
Mesh.SplitHexaToPrisms(theObject, …)	Split hexahedrons into prisms.
Mesh.AddNodeOnSegment(Node1, Node2[, position])	Replace each triangle bound by Node1-Node2 segment with two triangles by connecting a node made on the link with a node opposite to the link.
Mesh.AddNodeOnFace(face, x, y, z)	Split a face into triangles by adding a new node onto the face and connecting the new node with face nodes

Smoothing

Mesh.Smooth(IDsOfElements, IDsOfFixedNodes, …)	Smooth elements
Mesh.SmoothObject(theObject, …)	Smooth elements which belong to the given object
Mesh.SmoothParametric(IDsOfElements, …)	Parametrically smooth the given elements
Mesh.SmoothParametricObject(theObject, …)	Parametrically smooth the elements which belong to the given object

Duplication of nodes and elements (to emulate cracks)

Mesh.DoubleElements(theElements[, theGroupName])	Create duplicates of given elements, i.e. create new elements based on the same nodes as the given ones.
Mesh.DoubleNodes(theNodes, theModifiedElems)	Create a hole in a mesh by doubling the nodes of some particular elements
Mesh.DoubleNode(theNodeId, theModifiedElems)	Create a hole in a mesh by doubling the nodes of some particular elements.
Mesh.DoubleNodeGroup(theNodes, theModifiedElems)	Create a hole in a mesh by doubling the nodes of some particular elements.
Mesh.DoubleNodeGroups(theNodes, theModifiedElems)	Create a hole in a mesh by doubling the nodes of some particular elements.
Mesh.DoubleNodeElem(theElems, theNodesNot, …)	Create a hole in a mesh by doubling the nodes of some particular elements
Mesh.DoubleNodeElemInRegion(theElems, …)	Create a hole in a mesh by doubling the nodes of some particular elements
Mesh.DoubleNodeElemGroup(theElems, …[, …])	Create a hole in a mesh by doubling the nodes of some particular elements.
Mesh.DoubleNodeElemGroupInRegion(theElems, …)	Create a hole in a mesh by doubling the nodes of some particular elements.
Mesh.DoubleNodeElemGroups(theElems, …[, …])	Create a hole in a mesh by doubling the nodes of some particular elements.
Mesh.DoubleNodeElemGroupsInRegion(theElems, …)	Create a hole in a mesh by doubling the nodes of some particular elements.
Mesh.AffectedElemGroupsInRegion(theElems, …)	Identify the elements that will be affected by node duplication (actual duplication is not performed).
Mesh.DoubleNodesOnGroupBoundaries(…[, …])	Double nodes on shared faces between groups of volumes and create flat elements on demand.
Mesh.CreateFlatElementsOnFacesGroups(…)	Double nodes on some external faces and create flat elements.

Renumbering nodes and elements

Mesh.RenumberNodes()	Renumber mesh nodes to remove unused node IDs
Mesh.RenumberElements()	Renumber mesh elements to remove unused element IDs

Auxiliary methods

GetName(obj)	Return a name of an object
DegreesToRadians(AngleInDegrees)	Convert an angle from degrees to radians
New([instance, instanceGeom])	Create a new smeshBuilder instance.