"""
Private method. Add geom (sub-shape of the main shape) into the study if not yet there
"""
+ if not mesh.smeshpyD.IsEnablePublish():
+ return
if not isinstance( geom, geomBuilder.GEOM._objref_GEOM_Object ):
return
if not geom.GetStudyEntry():
algo1D = mesh.Segment(geom=Edge_1)
- creates a sub-mesh on *Edge_1* and assign Wire Discretization algorithm to it.
+ create a sub-mesh on *Edge_1* and assign Wire Discretization algorithm to it.
The created sub-mesh can be retrieved from the algorithm::
submesh = algo1D.GetSubMesh()
self.mesh = self.smeshpyD.CreateMesh(geom)
+ def HasShapeToMesh(self):
+ """
+ Return ``True`` if this mesh is based on geometry
+ """
+ return self.mesh.HasShapeToMesh()
+
def Load(self):
"""
Load mesh from the study after opening the study
fields: list of GEOM fields defined on the shape to mesh.
geomAssocFields: each character of this string means a need to export a
corresponding field; correspondence between fields and characters is following:
- - 'v' stands for "_vertices _" field;
- - 'e' stands for "_edges _" field;
- - 'f' stands for "_faces _" field;
- - 's' stands for "_solids _" field.
+
+ - 'v' stands for "_vertices_" field;
+ - 'e' stands for "_edges_" field;
+ - 'f' stands for "_faces_" field;
+ - 's' stands for "_solids_" field.
"""
# process positional arguments
#args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
# ----------------------
def CreateEmptyGroup(self, elementType, name):
"""
- Create an empty mesh group
+ Create an empty standalone mesh group
Parameters:
elementType: the :class:`type <SMESH.ElementType>` of elements in the group;
def GroupOnGeom(self, grp, name="", typ=None):
"""
Create a mesh group based on the geometrical object *grp*
- and gives a *name*.
+ and give it a *name*.
if *name* is not defined the name of the geometric group is used
Parameters:
def GroupOnFilter(self, typ, name, filter):
"""
- Create a mesh group with given *name* based on the *filter* which
- is a special type of group dynamically updating it's contents during
+ Create a mesh group with given *name* based on the *filter*.
+ It is a special type of group dynamically updating it's contents during
mesh modification
Parameters:
def GetGroups(self, elemType = SMESH.ALL):
"""
- Get the list of groups existing in the mesh in the order
- of creation (starting from the oldest one)
+ Get the list of groups existing in the mesh in the order of creation
+ (starting from the oldest one)
Parameters:
elemType (SMESH.ElementType): type of elements the groups contain;
by default groups of elements of all types are returned
Returns:
- a sequence of :class:`SMESH.SMESH_GroupBase`
+ a list of :class:`SMESH.SMESH_GroupBase`
"""
groups = self.mesh.GetGroups()
isElem2: *True* if *id2* is element id, *False* if it is node id
Returns:
- minimum distance value **GetMinDistance()**
+ minimum distance value
+ See Also:
+ :meth:`GetMinDistance`
"""
aMeasure = self.GetMinDistance(id1, id2, isElem1, isElem2)
def SetNodeOnVertex(self, NodeID, Vertex):
"""
- Binds a node to a vertex
+ Bind a node to a vertex
Parameters:
NodeID: a node ID
def SetNodeOnEdge(self, NodeID, Edge, paramOnEdge):
"""
- Stores the node position on an edge
+ Store the node position on an edge
Parameters:
NodeID: a node ID
def SetNodeOnFace(self, NodeID, Face, u, v):
"""
- Stores node position on a face
+ Store node position on a face
Parameters:
NodeID: a node ID
def SetNodeInVolume(self, NodeID, Solid):
"""
- Binds a node to a solid
+ Bind a node to a solid
Parameters:
NodeID: a node ID
def GetPointState(self, x, y, z):
"""
Return point state in a closed 2D mesh in terms of TopAbs_State enumeration:
- 0-IN, 1-OUT, 2-ON, 3-UNKNOWN.
+ smesh.TopAbs_IN, smesh.TopAbs_OUT, smesh.TopAbs_ON and smesh.TopAbs_UNKNOWN.
UNKNOWN state means that either mesh is wrong or the analysis fails.
"""
Parameters:
IDsOfElements: list of elements ids
Mirror: is :class:`SMESH.AxisStruct` or geom object (point, line, plane)
- theMirrorType: smeshBuilder.POINT, smeshBuilder.AXIS or smeshBuilder.PLANE.
+ theMirrorType: smesh.POINT, smesh.AXIS or smesh.PLANE.
If the *Mirror* is a geom object this parameter is unnecessary
Copy: allows to copy element (Copy is 1) or to replace with its mirroring (Copy is 0)
MakeGroups: forces the generation of new groups from existing ones (if Copy)
Parameters:
IDsOfElements: the list of elements ids
Mirror: is :class:`SMESH.AxisStruct` or geom object (point, line, plane)
- theMirrorType: smeshBuilder.POINT, smeshBuilder.AXIS or smeshBuilder.PLANE.
+ theMirrorType: smesh.POINT, smesh.AXIS or smesh.PLANE.
If the *Mirror* is a geom object this parameter is unnecessary
MakeGroups: to generate new groups from existing ones
NewMeshName: a name of the new mesh to create
Parameters:
theObject: :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`
Mirror: :class:`SMESH.AxisStruct` or geom object (point, line, plane)
- theMirrorType: smeshBuilder.POINT, smeshBuilder.AXIS or smeshBuilder.PLANE.
+ theMirrorType: smesh.POINT, smesh.AXIS or smesh.PLANE.
If the *Mirror* is a geom object this parameter is unnecessary
Copy: allows copying the element (Copy==True) or replacing it with its mirror (Copy==False)
MakeGroups: forces the generation of new groups from existing ones (if Copy)
Parameters:
theObject: :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`
Mirror: :class:`SMESH.AxisStruct` or geom object (point, line, plane)
- theMirrorType: smeshBuilder.POINT, smeshBuilder.AXIS or smeshBuilder.PLANE.
+ theMirrorType: smesh.POINT, smesh.AXIS or smesh.PLANE.
If the *Mirror* is a geom object this parameter is unnecessary
MakeGroups: forces the generation of new groups from existing ones
NewMeshName: the name of the new mesh to create
return self.editor.FindFreeBorders( ClosedOnly )
- def FillHole(self, holeNodes):
+ def FillHole(self, holeNodes, groupName=""):
"""
Fill with 2D elements a hole defined by a SMESH.FreeBorder.
FreeBorder: either a SMESH.FreeBorder or a list on node IDs. These nodes
must describe all sequential nodes of the hole border. The first and the last
nodes must be the same. Use :meth:`FindFreeBorders` to get nodes of holes.
+ groupName (string): name of a group to add new faces
+ Returns:
+ a :class:`group <SMESH.SMESH_GroupBase>` containing the new faces; or :code:`None` if :option:`groupName` == ""
"""
holeNodes = SMESH.FreeBorder(nodeIDs=holeNodes)
if not isinstance( holeNodes, SMESH.FreeBorder ):
raise TypeError("holeNodes must be either SMESH.FreeBorder or list of integer and not %s" % holeNodes)
- self.editor.FillHole( holeNodes )
+ self.editor.FillHole( holeNodes, groupName )
def FindCoincidentFreeBorders (self, tolerance=0.):
"""
def ExportToMED(self, *args): # function removed
print("WARNING: ExportToMED() is deprecated, use ExportMED() instead")
#args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
- while len(args) < 4: # !!!! nb of parameters for ExportToMED IDL's method
- args.append(True)
- SMESH._objref_SMESH_Mesh.ExportMED(self, *args)
+ args2 = list(args)
+ while len(args2) < 5: # !!!! nb of parameters for ExportToMED IDL's method
+ args2.append(True)
+ SMESH._objref_SMESH_Mesh.ExportMED(self, *args2)
def ExportPartToMED(self, *args): # 'version' parameter removed
#args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
SMESH._objref_SMESH_Mesh.ExportPartToMED(self, *args)
def ExportMED(self, *args): # signature of method changed
#args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
- while len(args) < 4: # !!!! nb of parameters for ExportToMED IDL's method
- args.append(True)
- SMESH._objref_SMESH_Mesh.ExportMED(self, *args)
+ args2 = list(args)
+ while len(args2) < 5: # !!!! nb of parameters for ExportToMED IDL's method
+ args2.append(True)
+ SMESH._objref_SMESH_Mesh.ExportMED(self, *args2)
pass
omniORB.registerObjref(SMESH._objref_SMESH_Mesh._NP_RepositoryId, meshProxy)
