from salome.geom import geomBuilder
import SMESH # This is necessary for back compatibility
-import omniORB # back compatibility
-SMESH.MED_V2_1 = omniORB.EnumItem("MED_V2_1", 0) # back compatibility
-SMESH.MED_V2_2 = omniORB.EnumItem("MED_V2_2", 1) # back compatibility
+import omniORB # back compatibility
+SMESH.MED_V2_1 = 11 #omniORB.EnumItem("MED_V2_1", 11) # back compatibility: use number > MED minor version
+SMESH.MED_V2_2 = 12 #omniORB.EnumItem("MED_V2_2", 12) # back compatibility: latest minor will be used
+SMESH.MED_MINOR_0 = 20 # back compatibility
+SMESH.MED_MINOR_1 = 21 # back compatibility
+SMESH.MED_MINOR_2 = 22 # back compatibility
+SMESH.MED_MINOR_3 = 23 # back compatibility
+SMESH.MED_MINOR_4 = 24 # back compatibility
+SMESH.MED_MINOR_5 = 25 # back compatibility
+SMESH.MED_MINOR_6 = 26 # back compatibility
+SMESH.MED_MINOR_7 = 27 # back compatibility
+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
"""
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():
return SMESH._objref_SMESH_Gen.IsEmbeddedMode(self)
def UpdateStudy( self, geompyD = None ):
- """
- Update the current study. Calling UpdateStudy() allows to
- update meshes at switching GEOM->SMESH
- """
+ """
+ Update the current study. Calling UpdateStudy() allows to
+ update meshes at switching GEOM->SMESH
+ """
#self.UpdateStudy()
- if not geompyD:
+ if not geompyD:
from salome.geom import geomBuilder
geompyD = geomBuilder.geom
+ if not geompyD:
+ geompyD = geomBuilder.New()
pass
- self.geompyD=geompyD
- self.SetGeomEngine(geompyD)
- SMESH._objref_SMESH_Gen.UpdateStudy(self)
- sb = salome.myStudy.NewBuilder()
- sc = salome.myStudy.FindComponent("SMESH")
- if sc:
+ self.geompyD=geompyD
+ self.SetGeomEngine(geompyD)
+ SMESH._objref_SMESH_Gen.UpdateStudy(self)
+ sb = salome.myStudy.NewBuilder()
+ sc = salome.myStudy.FindComponent("SMESH")
+ if sc:
sb.LoadWith(sc, self)
- pass
+ pass
def SetEnablePublish( self, theIsEnablePublish ):
- """
- Sets enable publishing in the study. Calling SetEnablePublish( false ) allows to
- switch OFF publishing in the Study of mesh objects.
- """
- #self.SetEnablePublish(theIsEnablePublish)
- SMESH._objref_SMESH_Gen.SetEnablePublish(self,theIsEnablePublish)
- global notebook
- notebook = salome_notebook.NoteBook( theIsEnablePublish )
+ """
+ Set enable publishing in the study. Calling SetEnablePublish( False ) allows to
+ switch **off** publishing in the Study of mesh objects.
+ """
+ #self.SetEnablePublish(theIsEnablePublish)
+ SMESH._objref_SMESH_Gen.SetEnablePublish(self,theIsEnablePublish)
+ global notebook
+ notebook = salome_notebook.NoteBook( theIsEnablePublish )
def CreateMeshesFromUNV( self,theFileName ):
Create a new smeshBuilder instance. The smeshBuilder class provides the Python
interface to create or load meshes.
- Typical use is:
+ Typical use is::
import salome
salome.salome_init()
smesh = smeshBuilder.New()
Parameters:
- isPublished If False, the notebool will not be used.
- instance CORBA proxy of SMESH Engine. If None, the default Engine is used.
+ instance: CORBA proxy of SMESH Engine. If None, the default Engine is used.
+ instanceGeom: CORBA proxy of GEOM Engine. If None, the default Engine is used.
Returns:
:class:`smeshBuilder` instance
"""
global engine
global smeshInst
global doLcc
+ if instance and isinstance( instance, SALOMEDS._objref_Study ):
+ import sys
+ sys.stderr.write("Warning: 'study' argument is no more needed in smeshBuilder.New(). Consider updating your script!!!\n\n")
+ instance = None
engine = instance
if engine is None:
doLcc = True
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
pass
if salome.sg.hasDesktop():
if not isinstance( refresh, list): # not a call from subMesh.Compute()
- smeshgui = salome.ImportComponentGUI("SMESH")
- smeshgui.Init()
- smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), ok, (self.NbNodes()==0) )
if refresh: salome.sg.updateObjBrowser()
return ok
continue
if ids == subShapeID:
shapeText = '"%s"' % subSO.GetName()
+ break
if not shapeText:
shape = self.geompyD.GetSubShape( self.GetShape(), [subShapeID])
if shape:
self.mesh.Clear()
if ( salome.sg.hasDesktop() ):
- smeshgui = salome.ImportComponentGUI("SMESH")
- smeshgui.Init()
- smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True )
if refresh: salome.sg.updateObjBrowser()
def ClearSubMesh(self, geomId, refresh=False):
self.mesh.ClearSubMesh(geomId)
if salome.sg.hasDesktop():
- smeshgui = salome.ImportComponentGUI("SMESH")
- smeshgui.Init()
- smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True )
if refresh: salome.sg.updateObjBrowser()
def AutomaticTetrahedralization(self, fineness=0):
Parameters:
fileName: is the file name
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.
+ 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.
overwrite (boolean): parameter for overwriting/not overwriting the file
- meshPart: a part of mesh (group, sub-mesh) to export instead of the mesh
- autoDimension if @c True (default), a space dimension of a MED mesh can be either
- - 1D if all mesh nodes lie on OX coordinate axis, or
- - 2D if all mesh nodes lie on XOY coordinate plane, or
- - 3D in the rest cases.
+ 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
+
+ - 1D if all mesh nodes lie on OX coordinate axis, or
+ - 2D if all mesh nodes lie on XOY coordinate plane, or
+ - 3D in the rest cases.
+
If *autoDimension* is *False*, the space dimension is always 3.
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
+ #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
- overwrite = args[2] if len(args) > 2 else True
- meshPart = args[3] if len(args) > 3 else None
- autoDimension = args[4] if len(args) > 4 else True
- fields = args[5] if len(args) > 5 else []
- geomAssocFields = args[6] if len(args) > 6 else ''
+ minor = 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
+ fields = args[6] if len(args) > 6 else []
+ geomAssocFields = args[7] if len(args) > 7 else ''
# process keywords arguments
auto_groups = kwargs.get("auto_groups", auto_groups)
+ minor = kwargs.get("minor", minor)
overwrite = kwargs.get("overwrite", overwrite)
meshPart = kwargs.get("meshPart", meshPart)
autoDimension = kwargs.get("autoDimension", autoDimension)
if isinstance( meshPart, list ):
meshPart = self.GetIDSource( meshPart, SMESH.ALL )
unRegister.set( meshPart )
- self.mesh.ExportPartToMED( meshPart, fileName, auto_groups, overwrite, autoDimension,
+ self.mesh.ExportPartToMED( meshPart, fileName, auto_groups, minor, overwrite, autoDimension,
fields, geomAssocFields)
else:
- self.mesh.ExportMED(fileName, auto_groups, overwrite, autoDimension)
+ self.mesh.ExportMED(fileName, auto_groups, minor, overwrite, autoDimension)
def ExportSAUV(self, f, auto_groups=0):
"""
print("WARNING: ExportToMED() is deprecated, use ExportMED() instead")
# process positional arguments
- args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
+ #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
overwrite = args[2] if len(args) > 2 else True
auto_groups = kwargs.get("auto_groups", auto_groups) # new keyword name
overwrite = kwargs.get("overwrite", overwrite)
autoDimension = kwargs.get("autoDimension", autoDimension)
+ minor = -1
# invoke engine's function
- self.mesh.ExportMED(fileName, auto_groups, overwrite, autoDimension)
+ self.mesh.ExportMED(fileName, auto_groups, minor, overwrite, autoDimension)
def ExportToMEDX(self, *args, **kwargs):
"""
- 3D in the rest cases.
If **autoDimension** is *False*, the space dimension is always 3.
- """
+ """
print("WARNING: ExportToMEDX() is deprecated, use ExportMED() instead")
# process positional arguments
- args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
+ #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
overwrite = args[2] if len(args) > 2 else True
auto_groups = kwargs.get("auto_groups", auto_groups)
overwrite = kwargs.get("overwrite", overwrite)
autoDimension = kwargs.get("autoDimension", autoDimension)
+ minor = -1
# invoke engine's function
- self.mesh.ExportMED(fileName, auto_groups, overwrite, autoDimension)
+ self.mesh.ExportMED(fileName, auto_groups, minor, overwrite, autoDimension)
# Operations with groups:
# ----------------------
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
def FindCoincidentNodesOnPart (self, SubMeshOrGroup, Tolerance,
exceptNodes=[], SeparateCornerAndMediumNodes=False):
"""
- Find groups of ajacent nodes within Tolerance.
+ Find groups of adjacent nodes within Tolerance.
Parameters:
Tolerance: the value of tolerance
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.):
"""
a :class:`Mesh`, elements of highest dimension are duplicated
theGroupName: a name of group to contain the generated elements.
If a group with such a name already exists, the new elements
- are added to the existng group, else a new group is created.
+ are added to the existing group, else a new group is created.
If *theGroupName* is empty, new elements are not added
in any group.
return SMESH._objref_SMESH_Mesh.CreateDimGroup(self, *args)
def ExportToMEDX(self, *args): # function removed
print("WARNING: ExportToMEDX() is deprecated, use ExportMED() instead")
- args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
+ #args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
SMESH._objref_SMESH_Mesh.ExportMED(self, *args)
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)
+ #args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
+ 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]]
+ #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)
+ #args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
+ 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)
ok = self.mesh.Compute( self.GetSubShape(),refresh=[] )
if salome.sg.hasDesktop():
- smeshgui = salome.ImportComponentGUI("SMESH")
- smeshgui.Init()
- smeshgui.SetMeshIcon( salome.ObjectToID( self ), ok, (self.GetNumberOfElements()==0) )
if refresh: salome.sg.updateObjBrowser()
pass
algoType = sorted( self.algoTypeToClass.keys() )[0]
if algoType in self.algoTypeToClass:
#print("Create algo",algoType)
-
return self.algoTypeToClass[ algoType ]( self.mesh, shape )
raise RuntimeError( "No class found for algo type %s" % algoType)
return None