mergeTolerance: tolerance for merging nodes
allGroups: forces creation of groups corresponding to every input mesh
name: name of a new mesh
- meshToAppendTo a mesh to append all given meshes
+ meshToAppendTo: a mesh to append all given meshes
Returns:
an instance of class :class:`Mesh`
+
+ See also:
+ :meth:`Mesh.Append`
"""
if not meshes: return None
- for i,m in enumerate(meshes):
- if isinstance(m, Mesh):
+ if not isinstance( meshes, list ):
+ meshes = [ meshes ]
+ for i,m in enumerate( meshes ):
+ if isinstance( m, Mesh ):
meshes[i] = m.GetMesh()
- mergeTolerance,Parameters,hasVars = ParseParameters(mergeTolerance)
+ mergeTolerance,Parameters,hasVars = ParseParameters( mergeTolerance )
if hasattr(meshes[0], "SetParameters"):
- meshes[0].SetParameters(Parameters)
+ meshes[0].SetParameters( Parameters )
else:
- meshes[0].GetMesh().SetParameters(Parameters)
+ meshes[0].GetMesh().SetParameters( Parameters )
if isinstance( meshToAppendTo, Mesh ):
meshToAppendTo = meshToAppendTo.GetMesh()
if allGroups:
aSmeshMesh = SMESH._objref_SMESH_Gen.ConcatenateWithGroups(
self,meshes,uniteIdenticalGroups,mergeNodesAndElements,
- mergeTolerance,meshToAppendTo)
+ mergeTolerance,meshToAppendTo )
else:
aSmeshMesh = SMESH._objref_SMESH_Gen.Concatenate(
self,meshes,uniteIdenticalGroups,mergeNodesAndElements,
- mergeTolerance,meshToAppendTo)
+ mergeTolerance,meshToAppendTo )
- aMesh = Mesh(self, self.geompyD, aSmeshMesh, name=name)
+ aMesh = Mesh( self, self.geompyD, aSmeshMesh, name=name )
return aMesh
def CopyMesh( self, meshPart, meshName, toCopyGroups=False, toKeepIDs=False):
functor = aFilterMgr.CreateLength()
elif theCriterion == FT_Length2D:
functor = aFilterMgr.CreateLength2D()
+ elif theCriterion == FT_Length3D:
+ functor = aFilterMgr.CreateLength3D()
elif theCriterion == FT_Deflection2D:
functor = aFilterMgr.CreateDeflection2D()
elif theCriterion == FT_NodeConnectivityNumber:
minor = -1
# invoke engine's function
self.mesh.ExportMED(fileName, auto_groups, minor, overwrite, autoDimension)
+ return
+
+
+ def Append(self, meshes, uniteIdenticalGroups = True,
+ mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False):
+ """
+ Append given meshes into this mesh.
+ All groups of input meshes will be created in this mesh.
+
+ Parameters:
+ meshes: :class:`meshes, sub-meshes, groups or filters <SMESH.SMESH_IDSource>` to append
+ uniteIdenticalGroups: if True, groups with same names are united, else they are renamed
+ mergeNodesAndElements: if True, equal nodes and elements are merged
+ mergeTolerance: tolerance for merging nodes
+ allGroups: forces creation of groups corresponding to every input mesh
+ """
+ self.smeshpyD.Concatenate( meshes, uniteIdenticalGroups,
+ mergeNodesAndElements, mergeTolerance, allGroups,
+ meshToAppendTo = self.GetMesh() )
# Operations with groups:
# ----------------------
NbOfSteps, Tolerance, MakeGroups, TotalAngle)
def ExtrusionSweepObjects(self, nodes, edges, faces, StepVector, NbOfSteps, MakeGroups=False,
- scaleFactors=[], linearVariation=False, basePoint=[] ):
+ scaleFactors=[], linearVariation=False, basePoint=[],
+ angles=[], anglesVariation=False):
"""
Generate new elements by extrusion of the given elements and nodes
NbOfSteps: the number of steps
MakeGroups: forces the generation of new groups from existing ones
scaleFactors: optional scale factors to apply during extrusion
- linearVariation: if *True*, scaleFactors are spread over all *scaleFactors*,
- else scaleFactors[i] is applied to nodes at the i-th extrusion step
- basePoint: optional scaling center; if not provided, a gravity center of
+ linearVariation: if *True*, *scaleFactors* are spread over all *NbOfSteps*,
+ else *scaleFactors* [i] is applied to nodes at the i-th extrusion step
+ basePoint: optional scaling and rotation center; if not provided, a gravity center of
nodes and elements being extruded is used as the scaling center.
It can be either
- a list of tree components of the point or
- a node ID or
- a GEOM point
+ angles: list of angles in radians. Nodes at each extrusion step are rotated
+ around *basePoint*, additionally to previous steps.
+ anglesVariation: forces the computation of rotation angles as linear
+ variation of the given *angles* along path steps
Returns:
the list of created :class:`groups <SMESH.SMESH_GroupBase>` if *MakeGroups* == True, empty list otherwise
basePoint = self.geompyD.PointCoordinates( basePoint )
NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps)
- Parameters = StepVector.PS.parameters + var_separator + Parameters
+ scaleFactors,scaleParameters,hasVars = ParseParameters(scaleFactors)
+ angles,angleParameters,hasVars = ParseAngles(angles)
+ Parameters = StepVector.PS.parameters + var_separator + \
+ Parameters + var_separator + \
+ scaleParameters + var_separator + angleParameters
self.mesh.SetParameters(Parameters)
return self.editor.ExtrusionSweepObjects( nodes, edges, faces,
- StepVector, NbOfSteps,
+ StepVector, NbOfSteps, MakeGroups,
scaleFactors, linearVariation, basePoint,
- MakeGroups)
+ angles, anglesVariation )
def ExtrusionSweep(self, IDsOfElements, StepVector, NbOfSteps, MakeGroups=False, IsNodes = False):
return self.editor.AdvancedExtrusion(IDsOfElements, StepVector, NbOfSteps,
ExtrFlags, SewTolerance, MakeGroups)
- def ExtrusionAlongPathObjects(self, Nodes, Edges, Faces, PathMesh, PathShape=None,
+ def ExtrusionAlongPathObjects(self, Nodes, Edges, Faces, PathObject, PathShape=None,
NodeStart=1, HasAngles=False, Angles=[], LinearVariation=False,
- HasRefPoint=False, RefPoint=[0,0,0], MakeGroups=False):
+ HasRefPoint=False, RefPoint=[0,0,0], MakeGroups=False,
+ ScaleFactors=[], ScalesVariation=False):
"""
Generate new elements by extrusion of the given elements and nodes along the path.
The path of extrusion must be a meshed edge.
Nodes: nodes to extrude: a list including ids, :class:`a mesh, sub-meshes, groups or filters <SMESH.SMESH_IDSource>`
Edges: edges to extrude: a list including ids, :class:`a mesh, sub-meshes, groups or filters <SMESH.SMESH_IDSource>`
Faces: faces to extrude: a list including ids, :class:`a mesh, sub-meshes, groups or filters <SMESH.SMESH_IDSource>`
- PathMesh: 1D mesh or 1D sub-mesh, along which proceeds the extrusion
- PathShape: shape (edge) defines the sub-mesh of PathMesh if PathMesh
- contains not only path segments, else it can be None
+ PathObject: :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>` containing edges along which proceeds the extrusion
+ PathShape: optional shape (edge or wire) which defines the sub-mesh of the mesh defined by *PathObject* if the mesh contains not only path segments, else it can be None
NodeStart: the first or the last node on the path. Defines the direction of extrusion
- HasAngles: allows the shape to be rotated around the path
- to get the resulting mesh in a helical fashion
- Angles: list of angles
+ HasAngles: not used obsolete
+ Angles: list of angles in radians. Nodes at each extrusion step are rotated
+ around *basePoint*, additionally to previous steps.
LinearVariation: forces the computation of rotation angles as linear
variation of the given Angles along path steps
HasRefPoint: allows using the reference point
- RefPoint: the reference point around which the shape is rotated (the mass center of the
- shape by default). The User can specify any point as the Reference Point.
+ RefPoint: optional scaling and rotation center (mass center of the extruded
+ elements by default). The User can specify any point as the Reference Point.
*RefPoint* can be either GEOM Vertex, [x,y,z] or :class:`SMESH.PointStruct`
MakeGroups: forces the generation of new groups from existing ones
+ ScaleFactors: optional scale factors to apply during extrusion
+ ScalesVariation: if *True*, *scaleFactors* are spread over all *NbOfSteps*,
+ else *scaleFactors* [i] is applied to nodes at the i-th extrusion step
Returns:
list of created :class:`groups <SMESH.SMESH_GroupBase>` and
if isinstance( RefPoint, list ):
if not RefPoint: RefPoint = [0,0,0]
RefPoint = SMESH.PointStruct( *RefPoint )
- if isinstance( PathMesh, Mesh ):
- PathMesh = PathMesh.GetMesh()
+ if isinstance( PathObject, Mesh ):
+ PathObject = PathObject.GetMesh()
Angles,AnglesParameters,hasVars = ParseAngles(Angles)
- Parameters = AnglesParameters + var_separator + RefPoint.parameters
+ ScaleFactors,ScalesParameters,hasVars = ParseParameters(ScaleFactors)
+ Parameters = AnglesParameters + var_separator + \
+ RefPoint.parameters + var_separator + ScalesParameters
self.mesh.SetParameters(Parameters)
return self.editor.ExtrusionAlongPathObjects(Nodes, Edges, Faces,
- PathMesh, PathShape, NodeStart,
+ PathObject, PathShape, NodeStart,
HasAngles, Angles, LinearVariation,
- HasRefPoint, RefPoint, MakeGroups)
+ HasRefPoint, RefPoint, MakeGroups,
+ ScaleFactors, ScalesVariation)
def ExtrusionAlongPathX(self, Base, Path, NodeStart,
HasAngles=False, Angles=[], LinearVariation=False,
Base: :class:`mesh, sub-mesh, group, filter <SMESH.SMESH_IDSource>`, or list of ids of elements for extrusion
Path: 1D mesh or 1D sub-mesh, along which proceeds the extrusion
NodeStart: the start node from Path. Defines the direction of extrusion
- HasAngles: allows the shape to be rotated around the path
- to get the resulting mesh in a helical fashion
- Angles: list of angles in radians
+ HasAngles: not used obsolete
+ Angles: list of angles in radians. Nodes at each extrusion step are rotated
+ around *basePoint*, additionally to previous steps.
LinearVariation: forces the computation of rotation angles as linear
variation of the given Angles along path steps
HasRefPoint: allows using the reference point
PathMesh: mesh containing a 1D sub-mesh on the edge, along which proceeds the extrusion
PathShape: shape (edge) defines the sub-mesh for the path
NodeStart: the first or the last node on the edge. Defines the direction of extrusion
- HasAngles: allows the shape to be rotated around the path
- to get the resulting mesh in a helical fashion
- Angles: list of angles in radians
+ HasAngles: not used obsolete
+ Angles: list of angles in radians. Nodes at each extrusion step are rotated
+ around *basePoint*, additionally to previous steps.
HasRefPoint: allows using the reference point
RefPoint: the reference point around which the shape is rotated (the mass center of the shape by default).
The User can specify any point as the Reference Point.
Example: :ref:`tui_extrusion_along_path`
"""
+ if not IDsOfElements:
+ IDsOfElements = [ self.GetMesh() ]
n,e,f = [],IDsOfElements,IDsOfElements
gr,er = self.ExtrusionAlongPathObjects(n,e,f, PathMesh, PathShape,
NodeStart, HasAngles, Angles,
PathMesh: mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds
PathShape: shape (edge) defines the sub-mesh for the path
NodeStart: the first or the last node on the edge. Defines the direction of extrusion
- HasAngles: allows the shape to be rotated around the path
- to get the resulting mesh in a helical fashion
- Angles: list of angles
+ HasAngles: not used obsolete
+ Angles: list of angles in radians. Nodes at each extrusion step are rotated
+ around *basePoint*, additionally to previous steps.
HasRefPoint: allows using the reference point
RefPoint: the reference point around which the shape is rotated (the mass center of the shape by default).
The User can specify any point as the Reference Point.
PathMesh: mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds
PathShape: shape (edge) defines the sub-mesh for the path
NodeStart: the first or the last node on the edge. Defines the direction of extrusion
- HasAngles: allows the shape to be rotated around the path
- to get the resulting mesh in a helical fashion
- Angles: list of angles
+ HasAngles: not used obsolete
+ Angles: list of angles in radians. Nodes at each extrusion step are rotated
+ around *basePoint*, additionally to previous steps.
HasRefPoint: allows using the reference point
RefPoint: the reference point around which the shape is rotated (the mass center of the shape by default).
The User can specify any point as the Reference Point.
PathMesh: mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds
PathShape: shape (edge) defines the sub-mesh for the path
NodeStart: the first or the last node on the edge. Defines the direction of extrusion
- HasAngles: allows the shape to be rotated around the path
- to get the resulting mesh in a helical fashion
- Angles: list of angles
+ HasAngles: not used obsolete
+ Angles: list of angles in radians. Nodes at each extrusion step are rotated
+ around *basePoint*, additionally to previous steps.
HasRefPoint: allows using the reference point
RefPoint: the reference point around which the shape is rotated (the mass center of the shape by default).
The User can specify any point as the Reference Point.
Parameters:
Tolerance: the value of tolerance
- SubMeshOrGroup: :class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>` or node IDs
+ SubMeshOrGroup: list of :class:`sub-meshes, groups or filters <SMESH.SMESH_IDSource>` or of node IDs
exceptNodes: list of either SubMeshes, Groups or node IDs to exclude from search
SeparateCornerAndMediumNodes: if *True*, in quadratic mesh puts
corner and medium nodes in separate groups thus preventing
"""
unRegister = genObjUnRegister()
- if (isinstance( SubMeshOrGroup, Mesh )):
- SubMeshOrGroup = SubMeshOrGroup.GetMesh()
- if isinstance( SubMeshOrGroup, list ):
- SubMeshOrGroup = self.GetIDSource( SubMeshOrGroup, SMESH.NODE )
- unRegister.set( SubMeshOrGroup )
+ if not isinstance( SubMeshOrGroup, list ):
+ SubMeshOrGroup = [ SubMeshOrGroup ]
+ for i,obj in enumerate( SubMeshOrGroup ):
+ if isinstance( obj, Mesh ):
+ SubMeshOrGroup = [ obj.GetMesh() ]
+ break
+ if isinstance( obj, int ):
+ SubMeshOrGroup = self.GetIDSource( SubMeshOrGroup, SMESH.NODE )
+ unRegister.set( SubMeshOrGroup )
+ break
if not isinstance( exceptNodes, list ):
exceptNodes = [ exceptNodes ]
Parameters:
GroupsOfNodes: a list of groups of nodes IDs for merging.
E.g. [[1,12,13],[25,4]] means that nodes 12, 13 and 4 will be removed and replaced
- in all elements and groups by nodes 1 and 25 correspondingly
+ in all elements and mesh groups by nodes 1 and 25 correspondingly
NodesToKeep: nodes to keep in the mesh: a list of groups, sub-meshes or node IDs.
If *NodesToKeep* does not include a node to keep for some group to merge,
then the first node in the group is kept.
AvoidMakingHoles: prevent merging nodes which cause removal of elements becoming
invalid
"""
- # NodesToKeep are converted to SMESH.SMESH_IDSource in meshEditor.MergeNodes()
self.editor.MergeNodes( GroupsOfNodes, NodesToKeep, AvoidMakingHoles )
- def FindEqualElements (self, MeshOrSubMeshOrGroup=None):
+ def FindEqualElements (self, MeshOrSubMeshOrGroup=None, exceptElements=[]):
"""
Find the elements built on the same nodes.
Parameters:
- MeshOrSubMeshOrGroup: :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`
+ MeshOrSubMeshOrGroup: :class:`mesh, sub-meshes, groups or filters <SMESH.SMESH_IDSource>` or element IDs to check for equal elements
+ exceptElements: list of either SubMeshes, Groups or elements IDs to exclude from search
+
Returns:
the list of groups of equal elements IDs (e.g. [[1,12,13],[4,25]])
"""
- if not MeshOrSubMeshOrGroup:
- MeshOrSubMeshOrGroup=self.mesh
+ unRegister = genObjUnRegister()
+ if MeshOrSubMeshOrGroup is None:
+ MeshOrSubMeshOrGroup = [ self.mesh ]
elif isinstance( MeshOrSubMeshOrGroup, Mesh ):
- MeshOrSubMeshOrGroup = MeshOrSubMeshOrGroup.GetMesh()
- return self.editor.FindEqualElements( MeshOrSubMeshOrGroup )
-
- def MergeElements(self, GroupsOfElementsID):
+ MeshOrSubMeshOrGroup = [ MeshOrSubMeshOrGroup.GetMesh() ]
+ elif not isinstance( MeshOrSubMeshOrGroup, list ):
+ MeshOrSubMeshOrGroup = [ MeshOrSubMeshOrGroup ]
+ if isinstance( MeshOrSubMeshOrGroup[0], int ):
+ MeshOrSubMeshOrGroup = [ self.GetIDSource( MeshOrSubMeshOrGroup, SMESH.ALL )]
+ unRegister.set( MeshOrSubMeshOrGroup )
+ for item in MeshOrSubMeshOrGroup:
+ if isinstance( item, Mesh ):
+ MeshOrSubMeshOrGroup = [ item.GetMesh() ]
+
+ if not isinstance( exceptElements, list ):
+ exceptElements = [ exceptElements ]
+ if exceptElements and isinstance( exceptElements[0], int ):
+ exceptElements = [ self.GetIDSource( exceptElements, SMESH.ALL )]
+ unRegister.set( exceptElements )
+
+ return self.editor.FindEqualElements( MeshOrSubMeshOrGroup, exceptElements )
+
+ def MergeElements(self, GroupsOfElementsID, ElementsToKeep=[]):
"""
Merge elements in each given group.
Parameters:
GroupsOfElementsID: a list of groups (lists) of elements IDs for merging
(e.g. [[1,12,13],[25,4]] means that elements 12, 13 and 4 will be removed and
- replaced in all groups by elements 1 and 25)
+ replaced in all mesh groups by elements 1 and 25)
+ ElementsToKeep: elements to keep in the mesh: a list of groups, sub-meshes or node IDs.
+ If *ElementsToKeep* does not include an element to keep for some group to merge,
+ then the first element in the group is kept.
"""
- self.editor.MergeElements(GroupsOfElementsID)
+ unRegister = genObjUnRegister()
+ if ElementsToKeep:
+ if not isinstance( ElementsToKeep, list ):
+ ElementsToKeep = [ ElementsToKeep ]
+ if isinstance( ElementsToKeep[0], int ):
+ ElementsToKeep = [ self.GetIDSource( ElementsToKeep, SMESH.ALL )]
+ unRegister.set( ElementsToKeep )
+
+ self.editor.MergeElements( GroupsOfElementsID, ElementsToKeep )
def MergeEqualElements(self):
"""