## Creates a criterion by the given parameters
# \n Criterion structures allow to define complex filters by combining them with logical operations (AND / OR) (see example below)
- # @param elementType the type of elements(NODE, EDGE, FACE, VOLUME)
- # @param CritType the type of criterion (FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc.)
- # @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo}
+ # @param elementType the type of elements(SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
+ # @param CritType the type of criterion (SMESH.FT_Taper, SMESH.FT_Area, etc.)
+ # Type SMESH.FunctorType._items in the Python Console to see all values.
+ # Note that the items starting from FT_LessThan are not suitable for CritType.
+ # @param Compare belongs to {SMESH.FT_LessThan, SMESH.FT_MoreThan, SMESH.FT_EqualTo}
# @param Threshold the threshold value (range of ids as string, shape, numeric)
- # @param UnaryOp FT_LogicalNOT or FT_Undefined
- # @param BinaryOp a binary logical operation FT_LogicalAND, FT_LogicalOR or
- # FT_Undefined (must be for the last criterion of all criteria)
- # @param Tolerance the tolerance used by FT_BelongToGeom, FT_BelongToSurface,
- # FT_LyingOnGeom, FT_CoplanarFaces criteria
+ # @param UnaryOp SMESH.FT_LogicalNOT or SMESH.FT_Undefined
+ # @param BinaryOp a binary logical operation SMESH.FT_LogicalAND, SMESH.FT_LogicalOR or
+ # SMESH.FT_Undefined
+ # @param Tolerance the tolerance used by SMESH.FT_BelongToGeom, SMESH.FT_BelongToSurface,
+ # SMESH.FT_LyingOnGeom, SMESH.FT_CoplanarFaces criteria
# @return SMESH.Filter.Criterion
#
# <a href="../tui_filters_page.html#combining_filters">Example of Criteria usage</a>
return aCriterion
## Creates a filter with the given parameters
- # @param elementType the type of elements in the group
- # @param CritType the type of criterion ( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. )
- # @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo}
- # @param Threshold the threshold value (range of id ids as string, shape, numeric)
- # @param UnaryOp FT_LogicalNOT or FT_Undefined
- # @param Tolerance the tolerance used by FT_BelongToGeom, FT_BelongToSurface,
- # FT_LyingOnGeom, FT_CoplanarFaces and FT_EqualNodes criteria
+ # @param elementType the type of elements (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
+ # @param CritType the type of criterion (SMESH.FT_Taper, SMESH.FT_Area, etc.)
+ # Type SMESH.FunctorType._items in the Python Console to see all values.
+ # Note that the items starting from FT_LessThan are not suitable for CritType.
+ # @param Compare belongs to {SMESH.FT_LessThan, SMESH.FT_MoreThan, SMESH.FT_EqualTo}
+ # @param Threshold the threshold value (range of ids as string, shape, numeric)
+ # @param UnaryOp SMESH.FT_LogicalNOT or SMESH.FT_Undefined
+ # @param Tolerance the tolerance used by SMESH.FT_BelongToGeom, SMESH.FT_BelongToSurface,
+ # SMESH.FT_LyingOnGeom, SMESH.FT_CoplanarFaces and SMESH.FT_EqualNodes criteria
# @param mesh the mesh to initialize the filter with
# @return SMESH_Filter
#
return aFilter
## Creates a numerical functor by its type
- # @param theCriterion FT_...; functor type
+ # @param theCriterion functor type - an item of SMESH.FunctorType enumeration.
+ # Type SMESH.FunctorType._items in the Python Console to see all items.
+ # Note that not all items corresponds to numerical functors.
# @return SMESH_NumericalFunctor
# @ingroup l1_controls
def GetFunctor(self,theCriterion):
# ----------------------
## Creates an empty mesh group
- # @param elementType the type of elements in the group
+ # @param elementType the type of elements in the group; either of
+ # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
# @param name the name of the mesh group
# @return SMESH_Group
# @ingroup l2_grps_create
# the name is the same as the geometrical group name
# @param grp a geometrical group, a vertex, an edge, a face or a solid
# @param name the name of the mesh group
- # @param typ the type of elements in the group. If not set, it is
- # automatically detected by the type of the geometry
+ # @param typ the type of elements in the group; either of
+ # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME). If not set, it is
+ # automatically detected by the type of the geometry
# @return SMESH_GroupOnGeom
# @ingroup l2_grps_create
def GroupOnGeom(self, grp, name="", typ=None):
## Creates a mesh group with given \a name based on the \a filter which
## is a special type of group dynamically updating it's contents during
## mesh modification
- # @param typ the type of elements in the group
+ # @param typ the type of elements in the group; either of
+ # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
# @param name the name of the mesh group
# @param filter the filter defining group contents
# @return SMESH_GroupOnFilter
## Creates a mesh group by the given ids of elements
# @param groupName the name of the mesh group
- # @param elementType the type of elements in the group
+ # @param elementType the type of elements in the group; either of
+ # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
# @param elemIDs the list of ids
# @return SMESH_Group
# @ingroup l2_grps_create
## Creates a mesh group by the given conditions
# @param groupName the name of the mesh group
- # @param elementType the type of elements in the group
- # @param CritType the type of criterion( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. )
- # @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo}
- # @param Threshold the threshold value (range of id ids as string, shape, numeric)
- # @param UnaryOp FT_LogicalNOT or FT_Undefined
- # @param Tolerance the tolerance used by FT_BelongToGeom, FT_BelongToSurface,
- # FT_LyingOnGeom, FT_CoplanarFaces criteria
+ # @param elementType the type of elements(SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
+ # @param CritType the type of criterion (SMESH.FT_Taper, SMESH.FT_Area, etc.)
+ # Type SMESH.FunctorType._items in the Python Console to see all values.
+ # Note that the items starting from FT_LessThan are not suitable for CritType.
+ # @param Compare belongs to {SMESH.FT_LessThan, SMESH.FT_MoreThan, SMESH.FT_EqualTo}
+ # @param Threshold the threshold value (range of ids as string, shape, numeric)
+ # @param UnaryOp SMESH.FT_LogicalNOT or SMESH.FT_Undefined
+ # @param Tolerance the tolerance used by SMESH.FT_BelongToGeom, SMESH.FT_BelongToSurface,
+ # SMESH.FT_LyingOnGeom, SMESH.FT_CoplanarFaces criteria
# @return SMESH_GroupOnFilter
# @ingroup l2_grps_create
def MakeGroup(self,
## Gets the list of groups existing in the mesh in the order
# of creation (starting from the oldest one)
+ # @param elemType type of elements the groups contain; either of
+ # (SMESH.ALL, SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME);
+ # by default groups of elements of all types are returned
# @return a sequence of SMESH_GroupBase
# @ingroup l2_grps_create
- def GetGroups(self):
- return self.mesh.GetGroups()
+ def GetGroups(self, elemType = SMESH.ALL):
+ groups = self.mesh.GetGroups()
+ if elemType == SMESH.ALL:
+ return groups
+ typedGroups = []
+ for g in groups:
+ if g.GetType() == elemType:
+ typedGroups.append( g )
+ pass
+ pass
+ return typedGroups
## Gets the number of groups existing in the mesh
# @return the quantity of groups as an integer value
names.append(group.GetName())
return names
+ ## Finds groups by name and type
+ # @param name name of the group of interest
+ # @param elemType type of elements the groups contain; either of
+ # (SMESH.ALL, SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME);
+ # by default one group of any type of elements is returned
+ # if elemType == SMESH.ALL then all groups of any type are returned
+ # @return a list of SMESH_GroupBase's
+ # @ingroup l2_grps_create
+ def GetGroupByName(self, name, elemType = None):
+ groups = []
+ for group in self.GetGroups():
+ if group.GetName() == name:
+ if elemType is None:
+ return [group]
+ if ( elemType == SMESH.ALL or
+ group.GetType() == elemType ):
+ groups.append( group )
+ return groups
+
## Produces a union of two groups.
# A new group is created. All mesh elements that are
# present in the initial groups are added to the new one
##
# Create a standalone group of entities basing on nodes of other groups.
# \param groups - list of groups, sub-meshes or filters, of any type.
- # \param elemType - a type of elements to include to the new group.
+ # \param elemType - a type of elements to include to the new group; either of
+ # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
# \param name - a name of the new group.
# \param nbCommonNodes - a criterion of inclusion of an element to the new group
# basing on number of element nodes common with reference \a groups.
## Wrap a list of IDs of elements or nodes into SMESH_IDSource which
# can be passed as argument to a method accepting mesh, group or sub-mesh
+ # @param ids list of IDs
+ # @param elemType type of elements; this parameter is used to distinguish
+ # IDs of nodes from IDs of elements; by default ids are treated as
+ # IDs of elements; use SMESH.NODE if ids are IDs of nodes.
# @return an instance of SMESH_IDSource
+ # @warning call UnRegister() for the returned object as soon as it is no more useful:
+ # idSrc = mesh.GetIDSource( [1,3,5], SMESH.NODE )
+ # mesh.DoSomething( idSrc )
+ # idSrc.UnRegister()
# @ingroup l1_auxiliary
- def GetIDSource(self, ids, elemType):
+ def GetIDSource(self, ids, elemType = SMESH.ALL):
return self.editor.MakeIDSource(ids, elemType)
## Returns the number of edges with the given order in the mesh
# @param elementOrder the order of elements:
- # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
+ # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
# @return an integer value
# @ingroup l1_meshinfo
def NbEdgesOfOrder(self, elementOrder):
## Returns the number of faces with the given order in the mesh
# @param elementOrder the order of elements:
- # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
+ # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
# @return an integer value
# @ingroup l1_meshinfo
def NbFacesOfOrder(self, elementOrder):
## Returns the number of triangles with the given order in the mesh
# @param elementOrder is the order of elements:
- # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
+ # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
# @return an integer value
# @ingroup l1_meshinfo
def NbTrianglesOfOrder(self, elementOrder):
## Returns the number of quadrangles with the given order in the mesh
# @param elementOrder the order of elements:
- # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
+ # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
# @return an integer value
# @ingroup l1_meshinfo
def NbQuadranglesOfOrder(self, elementOrder):
return self.mesh.NbBiQuadQuadrangles()
## Returns the number of polygons of given order in the mesh
+ # @param elementOrder the order of elements:
+ # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
# @return an integer value
# @ingroup l1_meshinfo
def NbPolygons(self, elementOrder = SMESH.ORDER_ANY):
## Returns the number of volumes with the given order in the mesh
# @param elementOrder the order of elements:
- # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
+ # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
# @return an integer value
# @ingroup l1_meshinfo
def NbVolumesOfOrder(self, elementOrder):
## Returns the number of tetrahedrons with the given order in the mesh
# @param elementOrder the order of elements:
- # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
+ # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
# @return an integer value
# @ingroup l1_meshinfo
def NbTetrasOfOrder(self, elementOrder):
## Returns the number of hexahedrons with the given order in the mesh
# @param elementOrder the order of elements:
- # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
+ # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
# @return an integer value
# @ingroup l1_meshinfo
def NbHexasOfOrder(self, elementOrder):
## Returns the number of pyramids with the given order in the mesh
# @param elementOrder the order of elements:
- # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
+ # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
# @return an integer value
# @ingroup l1_meshinfo
def NbPyramidsOfOrder(self, elementOrder):
## Returns the number of prisms with the given order in the mesh
# @param elementOrder the order of elements:
- # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
+ # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
# @return an integer value
# @ingroup l1_meshinfo
def NbPrismsOfOrder(self, elementOrder):
return self.mesh.GetElementsId()
## Returns the list of IDs of mesh elements with the given type
- # @param elementType the required type of elements (SMESH.NODE, SMESH.EDGE, SMESH.FACE or SMESH.VOLUME)
+ # @param elementType the required type of elements, either of
+ # (SMESH.NODE, SMESH.EDGE, SMESH.FACE or SMESH.VOLUME)
# @return list of integer values
# @ingroup l1_meshinfo
def GetElementsByType(self, elementType):
## Returns the type of mesh element
# @return the value from SMESH::ElementType enumeration
+ # Type SMESH.ElementType._items in the Python Console to see all possible values.
# @ingroup l1_meshinfo
def GetElementType(self, id, iselem=True):
return self.mesh.GetElementType(id, iselem)
## Returns the geometric type of mesh element
# @return the value from SMESH::EntityType enumeration
+ # Type SMESH.EntityType._items in the Python Console to see all possible values.
# @ingroup l1_meshinfo
def GetElementGeomType(self, id):
return self.mesh.GetElementGeomType(id)
## Returns the shape type of mesh element
- # @return the value from SMESH::GeometryType enumeration
+ # @return the value from SMESH::GeometryType enumeration.
+ # Type SMESH.GeometryType._items in the Python Console to see all possible values.
# @ingroup l1_meshinfo
def GetElementShape(self, id):
return self.mesh.GetElementShape(id)
return self.mesh.IsMediumNode(elementID, nodeID)
## Returns true if the given node is the medium node in one of quadratic elements
+ # @param nodeID ID of the node
+ # @param elementType the type of elements to check a state of the node, either of
+ # (SMESH.ALL, SMESH.NODE, SMESH.EDGE, SMESH.FACE or SMESH.VOLUME)
# @ingroup l1_meshinfo
def IsMediumNodeOfAnyElem(self, nodeID, elementType = SMESH.ALL ):
return self.mesh.IsMediumNodeOfAnyElem(nodeID, elementType)
# @param x the X coordinate of a point
# @param y the Y coordinate of a point
# @param z the Z coordinate of a point
- # @param elementType type of elements to find (SMESH.ALL type
- # means elements of any type excluding nodes, discrete and 0D elements)
+ # @param elementType type of elements to find; either of
+ # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME); SMESH.ALL type
+ # means elements of any type excluding nodes, discrete and 0D elements.
# @param meshPart a part of mesh (group, sub-mesh) to search within
# @return list of IDs of found elements
# @ingroup l2_modif_throughp
else:
return self.editor.FindElementsByPoint(x, y, z, elementType)
- # Return point state in a closed 2D mesh in terms of TopAbs_State enumeration:
- # 0-IN, 1-OUT, 2-ON, 3-UNKNOWN
- # TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.
-
+ ## Return point state in a closed 2D mesh in terms of TopAbs_State enumeration:
+ # 0-IN, 1-OUT, 2-ON, 3-UNKNOWN
+ # UNKNOWN state means that either mesh is wrong or the analysis fails.
def GetPointState(self, x, y, z):
return self.editor.GetPointState(x, y, z)
return self.editor.Reorient2DBy3D( the2DObject, the3DObject, theOutsideNormal )
## Fuses the neighbouring triangles into quadrangles.
- # @param IDsOfElements The triangles to be fused,
- # @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to
- # choose a neighbour to fuse with.
+ # @param IDsOfElements The triangles to be fused.
+ # @param theCriterion a numerical functor, in terms of enum SMESH.FunctorType, used to
+ # choose a neighbour to fuse with.
+ # Type SMESH.FunctorType._items in the Python Console to see all items.
+ # Note that not all items corresponds to numerical functors.
# @param MaxAngle is the maximum angle between element normals at which the fusion
- # is still performed; theMaxAngle is mesured in radians.
- # Also it could be a name of variable which defines angle in degrees.
+ # is still performed; theMaxAngle is mesured in radians.
+ # Also it could be a name of variable which defines angle in degrees.
# @return TRUE in case of success, FALSE otherwise.
# @ingroup l2_modif_unitetri
def TriToQuad(self, IDsOfElements, theCriterion, MaxAngle):
## Fuses the neighbouring triangles of the object into quadrangles
# @param theObject is mesh, submesh or group
# @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to
- # choose a neighbour to fuse with.
+ # choose a neighbour to fuse with.
+ # Type SMESH.FunctorType._items in the Python Console to see all items.
+ # Note that not all items corresponds to numerical functors.
# @param MaxAngle a max angle between element normals at which the fusion
- # is still performed; theMaxAngle is mesured in radians.
+ # is still performed; theMaxAngle is mesured in radians.
# @return TRUE in case of success, FALSE otherwise.
# @ingroup l2_modif_unitetri
def TriToQuadObject (self, theObject, theCriterion, MaxAngle):
# @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to
# choose a diagonal for splitting. If @a theCriterion is None, which is a default
# value, then quadrangles will be split by the smallest diagonal.
+ # Type SMESH.FunctorType._items in the Python Console to see all items.
+ # Note that not all items corresponds to numerical functors.
# @return TRUE in case of success, FALSE otherwise.
# @ingroup l2_modif_cutquadr
def QuadToTri (self, IDsOfElements, theCriterion = None):
# @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to
# choose a diagonal for splitting. If @a theCriterion is None, which is a default
# value, then quadrangles will be split by the smallest diagonal.
+ # Type SMESH.FunctorType._items in the Python Console to see all items.
+ # Note that not all items corresponds to numerical functors.
# @return TRUE in case of success, FALSE otherwise.
# @ingroup l2_modif_cutquadr
def QuadToTriObject (self, theObject, theCriterion = None):
# @param IDOfQuad the ID of the quadrangle to be splitted.
# @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to
# choose a diagonal for splitting.
+ # Type SMESH.FunctorType._items in the Python Console to see all items.
+ # Note that not all items corresponds to numerical functors.
# @return 1 if 1-3 diagonal is better, 2 if 2-4
# diagonal is better, 0 if error occurs.
# @ingroup l2_modif_cutquadr
elems = self.editor.MakeIDSource(elems, SMESH.VOLUME)
unRegister.set( elems )
self.editor.SplitVolumesIntoTetra(elems, method)
+ return
+
+ ## Split bi-quadratic elements into linear ones without creation of additional nodes:
+ # - bi-quadratic triangle will be split into 3 linear quadrangles;
+ # - bi-quadratic quadrangle will be split into 4 linear quadrangles;
+ # - tri-quadratic hexahedron will be split into 8 linear hexahedra.
+ # Quadratic elements of lower dimension adjacent to the split bi-quadratic element
+ # will be split in order to keep the mesh conformal.
+ # @param elems - elements to split: sub-meshes, groups, filters or element IDs;
+ # if None (default), all bi-quadratic elements will be split
+ # @ingroup l2_modif_cutquadr
+ def SplitBiQuadraticIntoLinear(self, elems=None):
+ unRegister = genObjUnRegister()
+ if elems and isinstance( elems, list ) and isinstance( elems[0], int ):
+ elems = self.editor.MakeIDSource(elems, SMESH.ALL)
+ unRegister.set( elems )
+ if elems is None:
+ elems = [ self.GetMesh() ]
+ if isinstance( elems, Mesh ):
+ elems = [ elems.GetMesh() ]
+ if not isinstance( elems, list ):
+ elems = [elems]
+ self.editor.SplitBiQuadraticIntoLinear( elems )
## Splits hexahedra into prisms
# @param elems either a list of elements or a mesh or a group or a submesh or a filter
# @param elements - elements whose boundary is to be checked:
# mesh, group, sub-mesh or list of elements
# if elements is mesh, it must be the mesh whose MakeBoundaryMesh() is called
- # @param dimension - defines type of boundary elements to create:
- # SMESH.BND_2DFROM3D, SMESH.BND_1DFROM3D, SMESH.BND_1DFROM2D
+ # @param dimension - defines type of boundary elements to create, either of
+ # { SMESH.BND_2DFROM3D, SMESH.BND_1DFROM3D, SMESH.BND_1DFROM2D }
# SMESH.BND_1DFROM3D creates mesh edges on all borders of free facets of 3D cells
# @param groupName - a name of group to store created boundary elements in,
# "" means not to create the group
##
# @brief Creates missing boundary elements around either the whole mesh or
# groups of elements
- # @param dimension - defines type of boundary elements to create
+ # @param dimension - defines type of boundary elements to create, either of
+ # { SMESH.BND_2DFROM3D, SMESH.BND_1DFROM3D, SMESH.BND_1DFROM2D }
# @param groupName - a name of group to store all boundary elements in,
# "" means not to create the group
# @param meshName - a name of a new mesh, which is a copy of the initial