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 object, control mesh quality by different parameters, etc.
Several filters can be combined together by using logical operators AND and OR. In addition, applied filter criterion can be reverted using logical operator NOT.
Mesh filters use the functionality of mesh quality controls to filter mesh nodes / elements by a specific characteristic (Area, Length, etc).
This page provides a short description of the existing mesh filters, describes required parameters and gives simple examples of usage in Python scripts.
- See Also
- Quality Controls
Aspect ratio
Filter 2D mesh elements (faces) according to the aspect ratio value:
- element type should be smesh.FACE
- functor type should be smesh.FT_AspectRatio
- threshold is floating point value (aspect ratio)
# create mesh
from SMESH_mechanic import *
# get faces with aspect ratio > 6.5
filter = smesh.GetFilter(smesh.FACE, smesh.FT_AspectRatio, smesh.FT_MoreThan, 6.5)
ids = mesh.GetIdsFromFilter(filter)
print "Number of faces with aspect ratio > 6.5:", len(ids)
- See Also
- Aspect Ratio
Aspect ratio 3D
Filter 3D mesh elements (volumes) according to the aspect ratio value:
- element type is smesh.VOLUME
- functor type is smesh.FT_AspectRatio3D
- threshold is floating point value (aspect ratio)
# create mesh with volumes
from SMESH_mechanic import *
mesh.Tetrahedron()
mesh.Compute()
# get volumes with aspect ratio < 2.0
filter = smesh.GetFilter(smesh.VOLUME, smesh.FT_AspectRatio3D, smesh.FT_LessThan, 2.0)
ids = mesh.GetIdsFromFilter(filter)
print "Number of volumes with aspect ratio < 2.0:", len(ids)
- See Also
- Aspect Ratio 3D
Warping angle
Filter 2D mesh elements (faces) according to the warping angle value:
- element type is smesh.FACE
- functor type is smesh.FT_Warping
- threshold is floating point value (warping angle)
# create mesh
from SMESH_mechanic import *
# get faces with warping angle = 2.0e-13 with tolerance 5.0e-14
criterion = smesh.GetCriterion(smesh.FACE, smesh.FT_Warping, smesh.FT_EqualTo, 2.0e-13)
criterion.Tolerance = 5.0e-14
filter = smesh.CreateFilterManager().CreateFilter()
filter.SetCriteria([criterion])
ids = mesh.GetIdsFromFilter(filter)
print "Number of faces with warping angle = 2.0e-13 (tolerance 5.0e-14):", len(ids)
- See Also
- Warping
Minimum angle
Filter 2D mesh elements (faces) according to the minimum angle value:
- element type is smesh.FACE
- functor type is smesh.FT_MinimumAngle
- threshold is floating point value (minimum angle)
# create mesh
from SMESH_mechanic import *
# get faces with minimum angle > 75
filter = smesh.GetFilter(smesh.FACE, smesh.FT_MinimumAngle,">", 75)
ids = mesh.GetIdsFromFilter(filter)
print "Number of faces with minimum angle > 75:", len(ids)
- See Also
- Minimum Angle
Taper
Filter 2D mesh elements (faces) according to the taper value:
- element type is smesh.FACE
- functor type is smesh.FT_Taper
- threshold is floating point value (taper)
# create mesh
from SMESH_mechanic import *
# get faces with taper < 1.e-15
filter = smesh.GetFilter(smesh.FACE, smesh.FT_Taper, smesh.FT_LessThan, 1.e-15)
ids = mesh.GetIdsFromFilter(filter)
print "Number of faces with taper < 1.e-15:", len(ids)
- See Also
- Taper
Skew
Filter 2D mesh elements (faces) according to the skew value:
- element type is smesh.FACE
- functor type is smesh.FT_Skew
- threshold is floating point value (skew)
# create mesh
from SMESH_mechanic import *
# get faces with skew > 50
filter = smesh.GetFilter(smesh.FACE, smesh.FT_Skew, smesh.FT_MoreThan, 50)
ids = mesh.GetIdsFromFilter(filter)
print "Number of faces with skew > 50:", len(ids)
- See Also
- Skew
Area
Filter 2D mesh elements (faces) according to the area value:
- element type is smesh.FACE
- functor type is smesh.FT_Area
- threshold is floating point value (area)
# create mesh
from SMESH_mechanic import *
# get faces with area > 60 and < 90
criterion1 = smesh.GetCriterion(smesh.FACE, smesh.FT_Area, smesh.FT_MoreThan, 60,\
smesh.FT_Undefined, smesh.FT_LogicalAND)
criterion2 = smesh.GetCriterion(smesh.FACE, smesh.FT_Area, smesh.FT_LessThan, 90)
filter = smesh.CreateFilterManager().CreateFilter()
filter.SetCriteria([criterion1,criterion2])
ids = mesh.GetIdsFromFilter(filter)
print "Number of faces with area in range (60,90):", len(ids)
- See Also
- Area
Volume
Filter 3D mesh elements (volumes) according to the volume value:
- element type is smesh.VOLUME
- functor type is smesh.FT_Volume3D
- threshold is floating point value (volume)
# create mesh with volumes
from SMESH_mechanic import *
mesh.Tetrahedron()
mesh.Compute()
# get volumes faces with volume > 100
filter = smesh.GetFilter(smesh.VOLUME, smesh.FT_Volume3D, smesh.FT_MoreThan, 100)
ids = mesh.GetIdsFromFilter(filter)
print "Number of volumes with volume > 100:", len(ids)
- See Also
- Volume
Free borders
Filter 1D mesh elements (edges) which represent free borders of a mesh:
- element type is smesh.EDGE
- functor type is smesh.FT_FreeBorders
- threshold value is not required
# create mesh
import geompy, smesh, StdMeshers
face = geompy.MakeFaceHW(100, 100, 1)
geompy.addToStudy( face, "quadrangle" )
mesh = smesh.Mesh(face)
mesh.Segment().NumberOfSegments(10)
mesh.Triangle().MaxElementArea(25)
mesh.Compute()
# get all free borders
filter = smesh.GetFilter(smesh.EDGE, smesh.FT_FreeBorders)
ids = mesh.GetIdsFromFilter(filter)
print "Number of edges on free borders:", len(ids)
- See Also
- Free Borders
Free edges
Filter 2D mesh elements (faces) consisting of edges belonging to one element of mesh only:
- element type is smesh.FACE
- functor type is smesh.FT_FreeEdges
- threshold value is not required
# create mesh
import geompy, smesh, StdMeshers
face = geompy.MakeFaceHW(100, 100, 1)
geompy.addToStudy( face, "quadrangle" )
mesh = smesh.Mesh(face)
mesh.Segment().NumberOfSegments(10)
mesh.Triangle().MaxElementArea(25)
mesh.Compute()
# get all faces with free edges
filter = smesh.GetFilter(smesh.FACE, smesh.FT_FreeEdges)
ids = mesh.GetIdsFromFilter(filter)
print "Number of faces with free edges:", len(ids)
- See Also
- Free Edges
Free nodes
Filter free nodes:
- element type is smesh.NODE
- functor type is smesh.FT_FreeNodes
- threshold value is not required
# create mesh
from SMESH_mechanic import *
# add node
mesh.AddNode(0,0,0)
# get all free nodes
filter = smesh.GetFilter(smesh.NODE, smesh.FT_FreeNodes)
ids = mesh.GetIdsFromFilter(filter)
print "Number of free nodes:", len(ids)
- See Also
- Free Nodes
Free faces
Filter free faces:
- element type is smesh.FACE
- functor type is smesh.FT_FreeFaces
- threshold value is not required
# create mesh
from SMESH_mechanic import *
# get all free faces
filter = smesh.GetFilter(smesh.FACE, smesh.FT_FreeFaces)
ids = mesh.GetIdsFromFilter(filter)
print "Number of free faces:", len(ids)
- See Also
- Free Faces
Bare border faces
Filter faces with bare borders:
- element type is smesh.FACE
- functor type is smesh.FT_BareBorderFace
- threshold value is not required
# create mesh
from SMESH_mechanic import *
# remove some faces to have faces with bare borders
mesh.RemoveElements( mesh.GetElementsByType(FACE)[0:5] )
# get all faces bare borders
filter = smesh.GetFilter(smesh.FACE, smesh.FT_BareBorderFace)
ids = mesh.GetIdsFromFilter(filter)
print "Faces with bare borders:", ids
- See Also
- Bare border faces
Coplanar faces
Filter faces with bare borders:
- element type is smesh.FACE
- functor type is smesh.FT_CoplanarFaces
- threshold value is the face ID
- tolerance is in degrees
# create mesh
from SMESH_mechanic import *
faceID = mesh.GetElementsByType(FACE)[0]
# get all faces co-planar to the first face with tolerance 5 degrees
filter = smesh.GetFilter(smesh.FACE, smesh.FT_CoplanarFaces,faceID,Tolerance=5.0)
ids = mesh.GetIdsFromFilter(filter)
print "Number of faces coplanar with the first one:", len(ids)
Over-constrained faces
Filter over-constrained faces:
- element type is smesh.FACE
- functor type is smesh.FT_OverConstrainedFace
- threshold value is not required
# create mesh
from SMESH_mechanic import *
# get all over-constrained faces
filter = smesh.GetFilter(smesh.FACE, smesh.FT_OverConstrainedFace)
ids = mesh.GetIdsFromFilter(filter)
print "Over-constrained faces:", ids
- See Also
- Over-constrained faces
Double edges, Double faces, Double volumes
filter mesh elements basing on the same set of nodes:
- element type is either smesh.EGDE, smesh.FACE or smesh.VOLUME
- functor type is either smesh.FT_EqualEdges, smesh.FT_EqualFaces or smesh.FT_EqualVolumes,
- threshold value is not required
from smesh import *
# make a mesh on a box
box = geompy.MakeBoxDXDYDZ(100,100,100)
mesh =
Mesh( box,
"Box" )
mesh.Segment().NumberOfSegments(10)
mesh.Quadrangle()
mesh.Hexahedron()
# copy all elements with translation and Merge nodes
mesh.MergeNodes( mesh.FindCoincidentNodes(1e-7) )
# create filters to find equal elements
equalEdgesFilter =
GetFilter(SMESH.EDGE, FT_EqualEdges)
equalFacesFilter =
GetFilter(SMESH.FACE, FT_EqualFaces)
equalVolumesFilter =
GetFilter(SMESH.VOLUME, FT_EqualVolumes)
# get equal elements
print "Number of equal edges:", len( mesh.GetIdsFromFilter( equalEdgesFilter ))
print "Number of equal faces:", len( mesh.GetIdsFromFilter( equalFacesFilter ))
print "Number of equal volumes:", len( mesh.GetIdsFromFilter( equalVolumesFilter ))
Double nodes
filters mesh nodes which are coincident with other nodes (within a given tolerance):
- element type is smesh.NODE
- functor type is smesh.FT_EqualNodes
- threshold value is not required
- default tolerance is 1.0e-7
from smesh import *
# make a mesh on a box
box = geompy.MakeBoxDXDYDZ(100,100,100)
mesh =
Mesh( box,
"Box" )
mesh.Segment().NumberOfSegments(10)
mesh.Quadrangle()
mesh.Hexahedron()
# copy all elements with translation
# create filters to find nodes equal within tolerance of 1e-5
filter =
GetFilter(SMESH.NODE, FT_EqualNodes, Tolerance=1e-5)
# get equal nodes
print "Number of equal nodes:", len( mesh.GetIdsFromFilter( filter ))
Borders at multi-connection
Filter border 1D mesh elements (edges) according to the specified number of connections (faces belonging the border edges)
- element type is smesh.EDGE
- functor type is smesh.FT_MultiConnection
- threshold is integer value (number of connections)
# create mesh
from SMESH_mechanic import *
# get border edges with number of connected faces = 5
filter = smesh.GetFilter(smesh.EDGE, smesh.FT_MultiConnection, 5)
ids = mesh.GetIdsFromFilter(filter)
print "Number of border edges with 5 faces connected:", len(ids)
- See Also
- Borders at Multiconnection
Borders at multi-connection 2D
Filter 2D mesh elements (faces) which consist of edges belonging to the specified number of mesh elements
- element type is smesh.FACE
- functor type is smesh.FT_MultiConnection2D
- threshold is integer value (number of connections)
# create mesh
from SMESH_mechanic import *
# get faces which consist of edges belonging to 2 mesh elements
filter = smesh.GetFilter(smesh.FACE, smesh.FT_MultiConnection2D, 2)
ids = mesh.GetIdsFromFilter(filter)
print "Number of faces consisting of edges belonging to 2 faces:", len(ids)
- See Also
- Borders at Multiconnection 2D
Length
Filter 1D mesh elements (edges) according to the edge length value:
- element type should be smesh.EDGE
- functor type should be smesh.FT_Length
- threshold is floating point value (length)
# create mesh
from SMESH_mechanic import *
# get edges with length > 14
filter = smesh.GetFilter(smesh.EDGE, smesh.FT_Length, smesh.FT_MoreThan, 14)
ids = mesh.GetIdsFromFilter(filter)
print "Number of edges with length > 14:", len(ids)
- See Also
- Length 1D
Length 2D
Filter 2D mesh elements (faces) corresponding to the maximum length. value of its edges:
- element type should be smesh.FACE
- functor type should be smesh.FT_Length2D
- threshold is floating point value (edge length)
# create mesh
from SMESH_mechanic import *
# get all faces that have edges with length > 14
filter = smesh.GetFilter(smesh.FACE, smesh.FT_Length2D, smesh.FT_MoreThan, 14)
ids = mesh.GetIdsFromFilter(filter)
print "Number of faces with maximum edge length > 14:", len(ids)
- See Also
- Length 2D
Element Diameter 2D
Filter 2D mesh elements (faces) corresponding to the maximum length value of its edges and diagonals:
- element type should be smesh.FACE
- functor type should be smesh.FT_MaxElementLength2D
- threshold is floating point value (edge/diagonal length)
# create mesh
from SMESH_mechanic import *
# get all faces that have elements with length > 10
filter = smesh.GetFilter(smesh.FACE, smesh.FT_MaxElementLength2D, smesh.FT_MoreThan, 10)
ids = mesh.GetIdsFromFilter(filter)
print "Number of faces with maximum element length > 10:", len(ids)
- See Also
- Element Diameter 2D
Element Diameter 3D
Filter 3D mesh elements (volumes) corresponding to the maximum length value of its edges and diagonals:
- element type should be smesh.VOLUME
- functor type should be smesh.FT_MaxElementLength3D
- threshold is floating point value (edge/diagonal length)
# create mesh with volumes
from SMESH_mechanic import *
mesh.Tetrahedron()
mesh.Compute()
# get all volumes that have elements with length > 10
filter = smesh.GetFilter(smesh.VOLUME, smesh.FT_MaxElementLength3D, smesh.FT_MoreThan, 10)
ids = mesh.GetIdsFromFilter(filter)
print "Number of volumes with maximum element length > 10:", len(ids)
- See Also
- Element Diameter 3D
Bare border volumes
Filter 3D mesh elements with bare borders:
- element type is smesh.VOLUME
- functor type is smesh.FT_BareBorderVolume
- threshold value is not required
# create mesh
from SMESH_mechanic import *
mesh.Tetrahedron()
mesh.Compute()
# remove some volumes to have volumes with bare borders
mesh.RemoveElements( mesh.GetElementsByType(VOLUME)[0:5] )
# get all volumes with bare borders
filter = smesh.GetFilter(smesh.VOLUME, smesh.FT_BareBorderVolume)
ids = mesh.GetIdsFromFilter(filter)
print "Volumes with bare borders:", ids
- See Also
- Bare border volumes
Over-constrained volumes
Filter over-constrained volumes:
- element type is smesh.VOLUME
- functor type is smesh.FT_OverConstrainedVolume
- threshold value is not required
# create mesh
from SMESH_mechanic import *
mesh.Tetrahedron()
mesh.Compute()
# get all over-constrained volumes
filter = smesh.GetFilter(smesh.VOLUME, smesh.FT_OverConstrainedVolume)
ids = mesh.GetIdsFromFilter(filter)
print "Over-constrained volumes:", ids
- See Also
- Over-constrained faces
Belong to Geom
Filter mesh entities (nodes or elements) which all nodes lie on the shape defined by threshold value:
- element type can be any entity type, from smesh.NODE to smesh.VOLUME
- functor type should be smesh.FT_BelongToGeom
- threshold is geometrical object
# create mesh
from SMESH_mechanic import *
# get all faces which nodes lie on the face sub_face3
filter = smesh.GetFilter(smesh.FACE, smesh.FT_BelongToGeom, sub_face3)
ids = mesh.GetIdsFromFilter(filter)
print "Number of faces which nodes lie on sub_face3:", len(ids)
Lying on Geom
Filter mesh entities (nodes or elements) at least one node of which lies on the shape defined by threshold value:
- element type can be any entity type, from smesh.NODE to smesh.VOLUME
- functor type should be smesh.FT_LyingOnGeom
- threshold is geometrical object
# create mesh
from SMESH_mechanic import *
# get all faces at least one node of each lies on the face sub_face3
filter = smesh.GetFilter(smesh.FACE, smesh.FT_LyingOnGeom, sub_face3)
ids = mesh.GetIdsFromFilter(filter)
print "Number of faces at least one node of each lies on sub_face3:", len(ids)
Belong to Plane
Filter mesh entities (nodes or elements) which all nodes belong to the plane defined by threshold value with the given tolerance:
- element type can be: smesh.NODE, smesh.EDGE, smesh.FACE
- functor type should be smesh.FT_BelongToPlane
- threshold is geometrical object (plane)
- default tolerance is 1.0e-7
# create mesh
from SMESH_mechanic import *
# create plane
import geompy
plane_1 = geompy.MakePlane(p3,seg1,2000)
geompy.addToStudy(plane_1, "plane_1")
# get all nodes which lie on the plane \a plane_1
filter = smesh.GetFilter(smesh.NODE, smesh.FT_BelongToPlane, plane_1)
ids = mesh.GetIdsFromFilter(filter)
print "Number of nodes which lie on the plane plane_1:", len(ids)
Belong to Cylinder
Filter mesh entities (nodes or elements) which all nodes belong to the cylindrical face defined by threshold value with the given tolerance:
- element type can be: smesh.NODE, smesh.EDGE, smesh.FACE
- functor type should be smesh.FT_BelongToCylinder
- threshold is geometrical object (cylindrical face)
- default tolerance is 1.0e-7
# create mesh
from SMESH_mechanic import *
# get all faces which lie on the cylindrical face \a sub_face1
filter = smesh.GetFilter(smesh.FACE, smesh.FT_BelongToCylinder, sub_face1)
ids = mesh.GetIdsFromFilter(filter)
print "Number of faces which lie on the cylindrical surface sub_face1:", len(ids)
Belong to Surface
Filter mesh entities (nodes or elements) which all nodes belong to the arbitrary surface defined by threshold value with the given tolerance:
- element type can be: smesh.NODE, smesh.EDGE, smesh.FACE
- functor type should be smesh.FT_BelongToGenSurface
- threshold is geometrical object (arbitrary surface)
- default tolerance is 1.0e-7
# create mesh
from SMESH_mechanic import *
# create b-spline
spline_1 = geompy.MakeInterpol([p4,p6,p3,p1])
surface_1 = geompy.MakePrismVecH( spline_1, vz, 70.0 )
geompy.addToStudy(surface_1, "surface_1")
# get all nodes which lie on the surface \a surface_1
filter = smesh.GetFilter(smesh.NODE, smesh.FT_BelongToGenSurface, surface_1)
ids = mesh.GetIdsFromFilter(filter)
print "Number of nodes which lie on the surface surface_1:", len(ids)
Range of IDs
Filter mesh entities elements (nodes or elements) according to the specified identifiers range:
- element type can be any entity type, from smesh.NODE to smesh.VOLUME
- functor type is smesh.FT_RangeOfIds
- threshold is string listing required IDs and/or ranges of IDs, e.g."1,2,3,50-60,63,67,70-78"
# create mesh
from SMESH_mechanic import *
# get nodes with identifiers [5-10] and [15-30]
criterion1 = smesh.GetCriterion(smesh.NODE, smesh.FT_RangeOfIds, Treshold="5-10",\
BinaryOp=smesh.FT_LogicalOR)
criterion2 = smesh.GetCriterion(smesh.NODE, smesh.FT_RangeOfIds, Treshold="15-30")
filter = smesh.CreateFilterManager().CreateFilter()
filter.SetCriteria([criterion1,criterion2])
ids = mesh.GetIdsFromFilter(filter)
print "Number of nodes in ranges [5-10] and [15-30]:", len(ids)
Badly oriented volume
Filter 3D mesh elements (volumes), which are incorrectly oriented from the point of view of MED convention.
- element type should be smesh.VOLUME
- functor type is smesh.FT_BadOrientedVolume
- threshold is not required
# create mesh with volumes
from SMESH_mechanic import *
mesh.Tetrahedron()
mesh.Compute()
# get all badly oriented volumes
filter = smesh.GetFilter(smesh.VOLUME, smesh.FT_BadOrientedVolume)
ids = mesh.GetIdsFromFilter(filter)
print "Number of badly oriented volumes:", len(ids)
Linear / quadratic
Filter linear / quadratic mesh elements:
- element type should be any element type, e.g.: smesh.EDGE, smesh.FACE, smesh.VOLUME
- functor type is smesh.FT_LinearOrQuadratic
- threshold is not required
- if unary operator is set to smesh.FT_LogicalNOT, the quadratic elements are selected, otherwise (by default) linear elements are selected
# create mesh
from SMESH_mechanic import *
# get number of linear and quadratic edges
filter_linear = smesh.GetFilter(smesh.EDGE, smesh.FT_LinearOrQuadratic)
filter_quadratic = smesh.GetFilter(smesh.EDGE, smesh.FT_LinearOrQuadratic, smesh.FT_LogicalNOT)
ids_linear = mesh.GetIdsFromFilter(filter_linear)
ids_quadratic = mesh.GetIdsFromFilter(filter_quadratic)
print "Number of linear edges:", len(ids_linear), "; number of quadratic edges:", len(ids_quadratic)
# convert mesh to quadratic
print "Convert to quadratic..."
mesh.ConvertToQuadratic(True)
# get number of linear and quadratic edges
ids_linear = mesh.GetIdsFromFilter(filter_linear)
ids_quadratic = mesh.GetIdsFromFilter(filter_quadratic)
print "Number of linear edges:", len(ids_linear), "; number of quadratic edges:", len(ids_quadratic)
Group color
Filter mesh entities, belonging to the group with the color defined by the threshold value.
- element type can be any entity type, from smesh.NODE to smesh.VOLUME
- functor type is smesh.FT_GroupColor
- threshold should be of SALOMEDS.Color type
# create mesh
from SMESH_mechanic import *
# create group of edges
all_edges = mesh.GetElementsByType(smesh.EDGE)
grp = mesh.MakeGroupByIds("edges group", smesh.EDGE, all_edges[:len(all_edges)/4])
import SALOMEDS
c = SALOMEDS.Color(0.1, 0.5, 1.0)
grp.SetColor(c)
# get number of the edges not belonging to the group with the given color
filter = smesh.GetFilter(smesh.EDGE, smesh.FT_GroupColor, c, smesh.FT_LogicalNOT)
ids = mesh.GetIdsFromFilter(filter)
print "Number of edges not beloging to the group with color (0.1, 0.5, 1.0):", len(ids)
Geometry type
Filter mesh elements by the geometric type defined with the threshold value. The list of available geometric types depends on the element entity type.
- element type should be any element type, e.g.: smesh.EDGE, smesh.FACE, smesh.VOLUME
- functor type should be smesh.FT_ElemGeomType
- threshold is of smesh.GeometryType value
# create mesh with volumes
from SMESH_mechanic import *
mesh.Tetrahedron()
mesh.Compute()
# get all triangles, quadrangles, tetrahedrons, pyramids
filter_tri = smesh.GetFilter(smesh.FACE, smesh.FT_ElemGeomType, smesh.Geom_TRIANGLE)
filter_qua = smesh.GetFilter(smesh.FACE, smesh.FT_ElemGeomType, smesh.Geom_QUADRANGLE)
filter_tet = smesh.GetFilter(smesh.VOLUME, smesh.FT_ElemGeomType, smesh.Geom_TETRA)
filter_pyr = smesh.GetFilter(smesh.VOLUME, smesh.FT_ElemGeomType, smesh.Geom_PYRAMID)
ids_tri = mesh.GetIdsFromFilter(filter_tri)
ids_qua = mesh.GetIdsFromFilter(filter_qua)
ids_tet = mesh.GetIdsFromFilter(filter_tet)
ids_pyr = mesh.GetIdsFromFilter(filter_pyr)
print "Number of triangles:", len(ids_tri)
print "Number of quadrangles:", len(ids_qua)
print "Number of tetrahedrons:", len(ids_tet)
print "Number of pyramids:", len(ids_pyr)
How to combine filters with Criterion structures?
Filters can be combined by making use of "criteria".
Example :
# create mesh
from SMESH_mechanic import *
# get all the quadrangle faces ...
criterion1 = smesh.GetCriterion(smesh.FACE, smesh.FT_ElemGeomType, smesh.Geom_QUADRANGLE, smesh.FT_LogicalAND)
# ... AND do NOT get those from sub_face3
criterion2 = smesh.GetCriterion(smesh.FACE, smesh.FT_BelongToGeom, sub_face3, smesh.FT_LogicalNOT)
filter = smesh.CreateFilterManager().CreateFilter()
filter.SetCriteria([criterion1,criterion2])
ids = mesh.GetIdsFromFilter(filter)
myGroup = mesh.MakeGroupByIds("Quads_on_cylindrical_faces",smesh.FACE,ids)