-# Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
SMESH.MED_MINOR_8 = 28 # back compatibility
SMESH.MED_MINOR_9 = 29 # back compatibility
-from SMESH import *
-from salome.smesh.smesh_algorithm import Mesh_Algorithm
+from SMESH import *
+from salome.smesh.smesh_algorithm import Mesh_Algorithm
+from StdMeshers import BlockCS
import SALOME
import SALOMEDS
"""
if not mesh.smeshpyD.IsEnablePublish():
return
- if not isinstance( geom, geomBuilder.GEOM._objref_GEOM_Object ):
+ if not hasattr( geom, "GetShapeType" ):
return
if not geom.GetStudyEntry():
## get a name
mesh.geompyD.addToStudyInFather( mesh.geom, geom, name )
return
-def FirstVertexOnCurve(mesh, edge):
- """
- Returns:
- the first vertex of a geometrical edge by ignoring orientation
- """
- vv = mesh.geompyD.SubShapeAll( edge, geomBuilder.geomBuilder.ShapeType["VERTEX"])
- if not vv:
- raise TypeError("Given object has no vertices")
- if len( vv ) == 1: return vv[0]
- v0 = mesh.geompyD.MakeVertexOnCurve(edge,0.)
- xyz = mesh.geompyD.PointCoordinates( v0 ) # coords of the first vertex
- xyz1 = mesh.geompyD.PointCoordinates( vv[0] )
- xyz2 = mesh.geompyD.PointCoordinates( vv[1] )
- dist1, dist2 = 0,0
- for i in range(3):
- dist1 += abs( xyz[i] - xyz1[i] )
- dist2 += abs( xyz[i] - xyz2[i] )
- if dist1 < dist2:
- return vv[0]
- else:
- return vv[1]
+# def FirstVertexOnCurve(mesh, edge):
+# """
+# Returns:
+# the first vertex of a geometrical edge by ignoring orientation
+# """
+# return mesh.geompyD.GetVertexByIndex( edge, 0, False )
+
smeshInst = None
"""
Returns:
:class:`SMESH.PointStruct`
"""
-
- [x, y, z] = self.geompyD.PointCoordinates(theVertex)
+ geompyD = theVertex.GetGen()
+ [x, y, z] = geompyD.PointCoordinates(theVertex)
return PointStruct(x,y,z)
def GetDirStruct(self,theVector):
Returns:
:class:`SMESH.DirStruct`
"""
-
- vertices = self.geompyD.SubShapeAll( theVector, geomBuilder.geomBuilder.ShapeType["VERTEX"] )
+ geompyD = theVector.GetGen()
+ vertices = geompyD.SubShapeAll( theVector, geomBuilder.geomBuilder.ShapeType["VERTEX"] )
if(len(vertices) != 2):
print("Error: vector object is incorrect.")
return None
- p1 = self.geompyD.PointCoordinates(vertices[0])
- p2 = self.geompyD.PointCoordinates(vertices[1])
+ p1 = geompyD.PointCoordinates(vertices[0])
+ p2 = geompyD.PointCoordinates(vertices[1])
pnt = PointStruct(p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2])
dirst = DirStruct(pnt)
return dirst
:class:`SMESH.AxisStruct`
"""
import GEOM
- edges = self.geompyD.SubShapeAll( theObj, geomBuilder.geomBuilder.ShapeType["EDGE"] )
+ geompyD = theObj.GetGen()
+ edges = geompyD.SubShapeAll( theObj, geomBuilder.geomBuilder.ShapeType["EDGE"] )
axis = None
if len(edges) > 1:
- vertex1, vertex2 = self.geompyD.SubShapeAll( edges[0], geomBuilder.geomBuilder.ShapeType["VERTEX"] )
- vertex3, vertex4 = self.geompyD.SubShapeAll( edges[1], geomBuilder.geomBuilder.ShapeType["VERTEX"] )
- vertex1 = self.geompyD.PointCoordinates(vertex1)
- vertex2 = self.geompyD.PointCoordinates(vertex2)
- vertex3 = self.geompyD.PointCoordinates(vertex3)
- vertex4 = self.geompyD.PointCoordinates(vertex4)
+ vertex1, vertex2 = geompyD.SubShapeAll( edges[0], geomBuilder.geomBuilder.ShapeType["VERTEX"] )
+ vertex3, vertex4 = geompyD.SubShapeAll( edges[1], geomBuilder.geomBuilder.ShapeType["VERTEX"] )
+ vertex1 = geompyD.PointCoordinates(vertex1)
+ vertex2 = geompyD.PointCoordinates(vertex2)
+ vertex3 = geompyD.PointCoordinates(vertex3)
+ vertex4 = geompyD.PointCoordinates(vertex4)
v1 = [vertex2[0]-vertex1[0], vertex2[1]-vertex1[1], vertex2[2]-vertex1[2]]
v2 = [vertex4[0]-vertex3[0], vertex4[1]-vertex3[1], vertex4[2]-vertex3[2]]
normal = [ v1[1]*v2[2]-v2[1]*v1[2], v1[2]*v2[0]-v2[2]*v1[0], v1[0]*v2[1]-v2[0]*v1[1] ]
axis = AxisStruct(vertex1[0], vertex1[1], vertex1[2], normal[0], normal[1], normal[2])
axis._mirrorType = SMESH.SMESH_MeshEditor.PLANE
elif len(edges) == 1:
- vertex1, vertex2 = self.geompyD.SubShapeAll( edges[0], geomBuilder.geomBuilder.ShapeType["VERTEX"] )
- p1 = self.geompyD.PointCoordinates( vertex1 )
- p2 = self.geompyD.PointCoordinates( vertex2 )
+ vertex1, vertex2 = geompyD.SubShapeAll( edges[0], geomBuilder.geomBuilder.ShapeType["VERTEX"] )
+ p1 = geompyD.PointCoordinates( vertex1 )
+ p2 = geompyD.PointCoordinates( vertex2 )
axis = AxisStruct(p1[0], p1[1], p1[2], p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2])
axis._mirrorType = SMESH.SMESH_MeshEditor.AXIS
elif theObj.GetShapeType() == GEOM.VERTEX:
- x,y,z = self.geompyD.PointCoordinates( theObj )
+ x,y,z = geompyD.PointCoordinates( theObj )
axis = AxisStruct( x,y,z, 1,0,0,)
axis._mirrorType = SMESH.SMESH_MeshEditor.POINT
return axis
name = aCriterion.ThresholdStr
if not name:
name = "%s_%s"%(aThreshold.GetShapeType(), id(aThreshold)%10000)
- aCriterion.ThresholdID = self.geompyD.addToStudy( aThreshold, name )
+ geompyD = aThreshold.GetGen()
+ aCriterion.ThresholdID = geompyD.addToStudy( aThreshold, name )
# or a name of GEOM object
elif isinstance( aThreshold, str ):
aCriterion.ThresholdStr = aThreshold
name = aThreshold.GetName()
if not name:
name = "%s_%s"%(aThreshold.GetShapeType(), id(aThreshold)%10000)
- aCriterion.ThresholdID = self.geompyD.addToStudy( aThreshold, name )
+ geompyD = aThreshold.GetGen()
+ aCriterion.ThresholdID = geompyD.addToStudy( aThreshold, name )
elif isinstance(aThreshold, int): # node id
aCriterion.Threshold = aThreshold
elif isinstance(aThreshold, list): # 3 point coordinates
return hyp
+ def GetHypothesisParameterValues( self, hypType, libName, mesh, shape, initParams ):
+ """
+ Create hypothesis initialized according to parameters
+
+ Parameters:
+ hypType (string): hypothesis type
+ libName (string): plug-in library name
+ mesh: optional mesh by which a hypotheses can initialize self
+ shape: optional geometry by size of which a hypotheses can initialize self
+ initParams: structure SMESH.HypInitParams defining how to initialize a hypothesis
+
+ Returns:
+ created hypothesis instance
+ """
+ if isinstance( mesh, Mesh ):
+ mesh = mesh.GetMesh()
+ if isinstance( initParams, (bool,int)):
+ initParams = SMESH.HypInitParams( not initParams, 1.0, not mesh )
+ return SMESH._objref_SMESH_Gen.GetHypothesisParameterValues(self, hypType, libName,
+ mesh, shape, initParams )
+
def GetMeshInfo(self, obj):
"""
Get the mesh statistic.
Parameters:
theMesh: a :class:`SMESH.SMESH_Mesh` object
"""
-
-
# do not call Register() as this prevents mesh servant deletion at closing study
#if self.mesh: self.mesh.UnRegister()
self.mesh = theMesh
if self.mesh:
#self.mesh.Register()
self.geom = self.mesh.GetShapeToMesh()
+ if self.geom:
+ self.geompyD = None
+ try:
+ so = salome.ObjectToSObject( self.geom )
+ comp = so.GetFatherComponent()
+ if comp.ComponentDataType() == "SHAPERSTUDY":
+ import shaperBuilder
+ self.geompyD = shaperBuilder.New()
+ except:
+ pass
+ if not self.geompyD:
+ self.geompyD = self.geom.GetGen()
+ pass
pass
def GetMesh(self):
"""
if geom == 0 or not isinstance(geom, geomBuilder.GEOM._objref_GEOM_Object):
- if self.geom == 0:
- geom = self.mesh.GetShapeToMesh()
- else:
- geom = self.geom
+ geom = self.mesh.GetShapeToMesh()
ok = False
try:
if discardModifs and self.mesh.HasModificationsToDiscard(): # issue 0020693
def SetMeshOrder(self, submeshes):
"""
- Set order in which concurrent sub-meshes should be meshed
+ Set priority of sub-meshes. It works in two ways:
+
+ * For sub-meshes with assigned algorithms of same dimension generating mesh of
+ *several dimensions*, it sets the order in which the sub-meshes are computed.
+ * For the rest sub-meshes, it sets the order in which the sub-meshes are checked
+ when looking for meshing parameters to apply to a sub-shape. To impose the
+ order in which sub-meshes with uni-dimensional algorithms are computed,
+ call **submesh.Compute()** in a desired order.
Parameters:
submeshes: list of lists of :class:`sub-meshes <SMESH.SMESH_subMesh>`
+
+ Warning: the method is for setting the order for all sub-meshes at once:
+ SetMeshOrder( [ [sm1, sm2, sm3], [sm4, sm5] ] )
"""
return self.mesh.SetMeshOrder(submeshes)
auto_groups (boolean): parameter for creating/not creating
the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
the typical use is auto_groups=False.
- minor (int): define the minor version (y, where version is x.y.z) of MED file format.
- The minor must be between 0 and the current minor version of MED file library.
- If minor is equal to -1, the minor version is not changed (default).
- The major version (x, where version is x.y.z) cannot be changed.
+ version (int): define the version (xy, where version is x.y.z) of MED file format.
+ For instance med 3.2.1 is coded 3*10+2 = 32, med 4.0.0 is coded 4*10+0 = 40.
+ The rules of compatibility to write a mesh in an older version than
+ the current version depend on the current version. For instance,
+ with med 4.0 it is possible to write/append med files in 4.0.0 (default)
+ or 3.2.1 or 3.3.1 formats.
+ If the version is equal to -1, the version is not changed (default).
overwrite (boolean): parameter for overwriting/not overwriting the file
meshPart: a part of mesh (:class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`) to export instead of the mesh
autoDimension: if *True* (default), a space dimension of a MED mesh can be either
#args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
fileName = args[0]
auto_groups = args[1] if len(args) > 1 else False
- minor = args[2] if len(args) > 2 else -1
+ version = args[2] if len(args) > 2 else -1
overwrite = args[3] if len(args) > 3 else True
meshPart = args[4] if len(args) > 4 else None
autoDimension = args[5] if len(args) > 5 else True
z_tolerance = args[8] if len(args) > 8 else -1.
# process keywords arguments
auto_groups = kwargs.get("auto_groups", auto_groups)
- minor = kwargs.get("minor", minor)
+ version = kwargs.get("version", version)
+ version = kwargs.get("minor", version)
overwrite = kwargs.get("overwrite", overwrite)
meshPart = kwargs.get("meshPart", meshPart)
autoDimension = kwargs.get("autoDimension", autoDimension)
z_tolerance,Parameters,hasVars = ParseParameters(z_tolerance)
self.mesh.SetParameters(Parameters)
- self.mesh.ExportPartToMED( meshPart, fileName, auto_groups, minor, overwrite, autoDimension,
+ self.mesh.ExportPartToMED( meshPart, fileName, auto_groups,
+ version, overwrite, autoDimension,
fields, geomAssocFields, z_tolerance)
else:
- self.mesh.ExportMED(fileName, auto_groups, minor, overwrite, autoDimension)
+ self.mesh.ExportMED(fileName, auto_groups, version, overwrite, autoDimension)
def ExportSAUV(self, f, auto_groups=0):
"""
tgeo = str(shape.GetShapeType())
if tgeo == "VERTEX":
typ = NODE
- elif tgeo == "EDGE":
+ elif tgeo == "EDGE" or tgeo == "WIRE":
typ = EDGE
elif tgeo == "FACE" or tgeo == "SHELL":
typ = FACE
Parameters:
group (SMESH.SMESH_GroupBase): group to remove
+
+ Note:
+ This operation can create gaps in numeration of nodes or elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
self.mesh.RemoveGroupWithContents(group)
Returns:
True or False
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
return self.editor.RemoveElements(IDsOfElements)
Returns:
True or False
+
+ Note:
+ This operation can create gaps in numeration of nodes.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
return self.editor.RemoveNodes(IDsOfNodes)
Returns:
number of the removed nodes
+
+ Note:
+ This operation can create gaps in numeration of nodes.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
return self.editor.RemoveOrphanNodes()
Returns:
A list of edge groups and a list of corresponding node groups,
- where the group is a list of IDs of edges or elements, like follows
+ where the group is a list of IDs of edges or nodes, like follows
[[[branch_edges_1],[branch_edges_2]], [[branch_nodes_1],[branch_nodes_2]]].
If a group is closed, the first and last nodes of the group are same.
"""
Returns:
False if proper faces were not found
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
return self.editor.DeleteDiag(NodeID1, NodeID2)
Returns:
True in case of success, False otherwise.
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
MaxAngle,Parameters,hasVars = ParseAngles(MaxAngle)
Returns:
True in case of success, False otherwise.
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
MaxAngle,Parameters,hasVars = ParseAngles(MaxAngle)
Returns:
True in case of success, False otherwise.
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
if IDsOfElements == []:
IDsOfElements = self.GetElementsId()
Returns:
True in case of success, False otherwise.
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
if ( isinstance( theObject, Mesh )):
theObject = theObject.GetMesh()
theElements: the faces to be splitted. This can be either
:class:`mesh, sub-mesh, group, filter <SMESH.SMESH_IDSource>`
or a list of face IDs. By default all quadrangles are split
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
unRegister = genObjUnRegister()
if isinstance( theElements, Mesh ):
Returns:
True in case of success, False otherwise.
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
if IDsOfElements == []:
IDsOfElements = self.GetElementsId()
Returns:
True in case of success, False otherwise.
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
if ( isinstance( theObject, Mesh )):
theObject = theObject.GetMesh()
* 1 if 1-3 diagonal is better,
* 2 if 2-4 diagonal is better,
* 0 if error occurs.
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
return self.editor.BestSplit(IDOfQuad, self.smeshpyD.GetFunctor(theCriterion))
method: flags passing splitting method:
smesh.Hex_5Tet, smesh.Hex_6Tet, smesh.Hex_24Tet.
smesh.Hex_5Tet - to split the hexahedron into 5 tetrahedrons, etc.
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
unRegister = genObjUnRegister()
if isinstance( elems, Mesh ):
Parameters:
elems: elements to split\: :class:`mesh, sub-mesh, group, filter <SMESH.SMESH_IDSource>` or element IDs;
if None (default), all bi-quadratic elements will be split
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
unRegister = genObjUnRegister()
if elems and isinstance( elems, list ) and isinstance( elems[0], int ):
allDomains: if :code:`False`, only hexahedra adjacent to one closest
to *startHexPoint* are split, else *startHexPoint*
is used to find the facet to split in all domains present in *elems*.
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
# IDSource
unRegister = genObjUnRegister()
def SplitQuadsNearTriangularFacets(self):
"""
Split quadrangle faces near triangular facets of volumes
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
faces_array = self.GetElementsByType(SMESH.FACE)
for face_id in faces_array:
Returns:
True in case of success, False otherwise.
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
# Pattern:
# 5.---------.6
Returns:
True in case of success, False otherwise.
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
# Pattern: 5.---------.6
# /|# /|
Warning:
If *theSubMesh* is provided, the mesh can become non-conformal
+
+ Note:
+ This operation can create gaps in numeration of nodes or elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
if isinstance( theSubMesh, Mesh ):
Warning:
If *theSubMesh* is provided, the mesh can become non-conformal
+
+ Note:
+ This operation can create gaps in numeration of nodes or elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
if theSubMesh:
if isinstance( Elements, list ):
if not Elements:
raise RuntimeError("Elements empty!")
+ if isinstance( Elements[0], Mesh ):
+ Elements = [ Elements[0].GetMesh() ]
if isinstance( Elements[0], int ):
Elements = self.GetIDSource( Elements, SMESH.ALL )
unRegister.set( Elements )
theValue,Parameters,hasVars = ParseParameters(Value)
mesh_groups = self.editor.Offset(theObject, Value, MakeGroups, CopyElements, NewMeshName)
self.mesh.SetParameters(Parameters)
- # if mesh_groups[0]:
- # return Mesh( self.smeshpyD, self.geompyD, mesh_groups[0] ), mesh_groups[1]
+ if mesh_groups[0]:
+ return Mesh( self.smeshpyD, self.geompyD, mesh_groups[0] ), mesh_groups[1]
return mesh_groups
def FindCoincidentNodes (self, Tolerance, SeparateCornerAndMediumNodes=False):
then the first node in the group is kept.
AvoidMakingHoles: prevent merging nodes which cause removal of elements becoming
invalid
+
+ Note:
+ This operation can create gaps in numeration of nodes or elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
self.editor.MergeNodes( GroupsOfNodes, NodesToKeep, AvoidMakingHoles )
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.
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
unRegister = genObjUnRegister()
def MergeEqualElements(self):
"""
Leave one element and remove all other elements built on the same nodes.
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
self.editor.MergeEqualElements()
Returns:
a number of successfully sewed groups
+
+ Note:
+ This operation can create gaps in numeration of nodes or elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
if freeBorders and isinstance( freeBorders, list ):
Returns:
:class:`error code <SMESH.SMESH_MeshEditor.Sew_Error>`
+
+ Note:
+ This operation can create gaps in numeration of nodes or elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
return self.editor.SewFreeBorders(FirstNodeID1, SecondNodeID1, LastNodeID1,
Returns:
:class:`error code <SMESH.SMESH_MeshEditor.Sew_Error>`
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
return self.editor.SewConformFreeBorders(FirstNodeID1, SecondNodeID1, LastNodeID1,
Returns:
:class:`error code <SMESH.SMESH_MeshEditor.Sew_Error>`
+
+ Note:
+ This operation can create gaps in numeration of elements.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
return self.editor.SewBorderToSide(FirstNodeIDOnFreeBorder, SecondNodeIDOnFreeBorder, LastNodeIDOnFreeBorder,
Returns:
:class:`error code <SMESH.SMESH_MeshEditor.Sew_Error>`
+
+ Note:
+ This operation can create gaps in numeration of nodes.
+ Call :meth:`RenumberElements` to remove the gaps.
"""
return self.editor.SewSideElements(IDsOfSide1Elements, IDsOfSide2Elements,
def ChangeElemNodes(self, ide, newIDs):
"""
- Set new nodes for the given element.
+ Set new nodes for the given element. Number of nodes should be kept.
Parameters:
ide: the element ID
def MakeSlot(self, segmentGroup, width ):
"""
Create a slot of given width around given 1D elements lying on a triangle mesh.
- The slot is consrtucted by cutting faces by cylindrical surfaces made
+ The slot is constructed by cutting faces by cylindrical surfaces made
around each segment. Segments are expected to be created by MakePolyLine().
Returns:
if genObj and hasattr( genObj, "UnRegister" ):
genObj.UnRegister()
-for pluginName in os.environ[ "SMESH_MeshersList" ].split( ":" ):
+for pluginName in os.environ[ "SMESH_MeshersList" ].split( os.pathsep ):
"""
Bind methods creating mesher plug-ins to the Mesh class
"""