-# Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2014 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
# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
+# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
import SALOMEDS
import os
+class MeshMeta(type):
+ def __instancecheck__(cls, inst):
+ """Implement isinstance(inst, cls)."""
+ return any(cls.__subclasscheck__(c)
+ for c in {type(inst), inst.__class__})
+
+ def __subclasscheck__(cls, sub):
+ """Implement issubclass(sub, cls)."""
+ return type.__subclasscheck__(cls, sub) or (cls.__name__ == sub.__name__ and cls.__module__ == sub.__module__)
+
## @addtogroup l1_auxiliary
## @{
def init_smesh(self,theStudy,geompyD = None):
#print "init_smesh"
self.SetCurrentStudy(theStudy,geompyD)
-
- ## Creates an empty Mesh. This mesh can have an underlying geometry.
- # @param obj the Geometrical object on which the mesh is built. If not defined,
- # the mesh will have no underlying geometry.
+ if theStudy:
+ global notebook
+ notebook.myStudy = theStudy
+
+ ## Creates a mesh. This can be either an empty mesh, possibly having an underlying geometry,
+ # or a mesh wrapping a CORBA mesh given as a parameter.
+ # @param obj either (1) a CORBA mesh (SMESH._objref_SMESH_Mesh) got e.g. by calling
+ # salome.myStudy.FindObjectID("0:1:2:3").GetObject() or
+ # (2) a Geometrical object for meshing or
+ # (3) none.
# @param name the name for the new mesh.
# @return an instance of Mesh class.
# @ingroup l2_construct
# @return SMESH.AxisStruct
# @ingroup l1_auxiliary
def GetAxisStruct(self,theObj):
+ import GEOM
edges = self.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"] )
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])
- return axis
+ 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 )
axis = AxisStruct(p1[0], p1[1], p1[2], p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2])
- return axis
- return None
+ axis._mirrorType = SMESH.SMESH_MeshEditor.AXIS
+ elif theObj.GetShapeType() == GEOM.VERTEX:
+ x,y,z = self.geompyD.PointCoordinates( theObj )
+ axis = AxisStruct( x,y,z, 1,0,0,)
+ axis._mirrorType = SMESH.SMESH_MeshEditor.POINT
+ return axis
# From SMESH_Gen interface:
# ------------------------
# new nodes and elements and by changing the existing entities), to get information
# about a mesh and to export a mesh into different formats.
class Mesh:
+ __metaclass__ = MeshMeta
geom = 0
mesh = 0
smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True )
salome.sg.updateObjBrowser(1)
- ## Computes a tetrahedral mesh using AutomaticLength + MEFISTO + NETGEN
+ ## Computes a tetrahedral mesh using AutomaticLength + MEFISTO + Tetrahedron
# @param fineness [0.0,1.0] defines mesh fineness
# @return True or False
# @ingroup l3_algos_basic
self.Triangle().LengthFromEdges()
pass
if dim > 2 :
- from salome.NETGENPlugin.NETGENPluginBuilder import NETGEN
- self.Tetrahedron(NETGEN)
+ self.Tetrahedron()
pass
return self.Compute()
if not geom:
geom = self.mesh.GetShapeToMesh()
pass
- AssureGeomPublished( self, geom, "shape for %s" % hyp.GetName())
- status = self.mesh.AddHypothesis(geom, hyp)
- isAlgo = hyp._narrow( SMESH_Algo )
+ isApplicable = True
+ if self.mesh.HasShapeToMesh():
+ hyp_type = hyp.GetName()
+ lib_name = hyp.GetLibName()
+ checkAll = ( not geom.IsSame( self.mesh.GetShapeToMesh() ))
+ if checkAll and geom:
+ checkAll = geom.GetType() == 37
+ isApplicable = self.smeshpyD.IsApplicable(hyp_type, lib_name, geom, checkAll)
+ if isApplicable:
+ AssureGeomPublished( self, geom, "shape for %s" % hyp.GetName())
+ status = self.mesh.AddHypothesis(geom, hyp)
+ else:
+ status = HYP_BAD_GEOMETRY
hyp_name = GetName( hyp )
geom_name = ""
if geom:
- geom_name = GetName( geom )
+ geom_name = geom.GetName()
+ isAlgo = hyp._narrow( SMESH_Algo )
TreatHypoStatus( status, hyp_name, geom_name, isAlgo )
return status
# - 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 @a autoDimension is @c False, the space dimension is always 3.
+ # @param fields : list of GEOM fields defined on the shape to mesh.
+ # @param 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.
# @ingroup l2_impexp
def ExportMED(self, f, auto_groups=0, version=MED_V2_2,
- overwrite=1, meshPart=None, autoDimension=True):
- if meshPart:
+ overwrite=1, meshPart=None, autoDimension=True, fields=[], geomAssocFields=''):
+ if meshPart or fields or geomAssocFields:
unRegister = genObjUnRegister()
if isinstance( meshPart, list ):
meshPart = self.GetIDSource( meshPart, SMESH.ALL )
unRegister.set( meshPart )
- self.mesh.ExportPartToMED( meshPart, f, auto_groups, version, overwrite, autoDimension)
+ self.mesh.ExportPartToMED( meshPart, f, auto_groups, version, overwrite, autoDimension,
+ fields, geomAssocFields)
else:
self.mesh.ExportToMEDX(f, auto_groups, version, overwrite, autoDimension)
def RemoveGroupWithContents(self, group):
self.mesh.RemoveGroupWithContents(group)
- ## Gets the list of groups existing in the mesh
+ ## Gets the list of groups existing in the mesh in the order of creation (starting from the oldest one)
# @return a sequence of SMESH_GroupBase
# @ingroup l2_grps_create
def GetGroups(self):
# @param MakeGroups forces the generation of new groups from existing ones (if Copy)
# @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
# @ingroup l2_modif_trsf
- def Mirror(self, IDsOfElements, Mirror, theMirrorType, Copy=0, MakeGroups=False):
+ def Mirror(self, IDsOfElements, Mirror, theMirrorType=None, Copy=0, MakeGroups=False):
if IDsOfElements == []:
IDsOfElements = self.GetElementsId()
if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)):
- Mirror = self.smeshpyD.GetAxisStruct(Mirror)
- self.mesh.SetParameters(Mirror.parameters)
+ Mirror = self.smeshpyD.GetAxisStruct(Mirror)
+ theMirrorType = Mirror._mirrorType
+ else:
+ self.mesh.SetParameters(Mirror.parameters)
if Copy and MakeGroups:
return self.editor.MirrorMakeGroups(IDsOfElements, Mirror, theMirrorType)
self.editor.Mirror(IDsOfElements, Mirror, theMirrorType, Copy)
# @param NewMeshName a name of the new mesh to create
# @return instance of Mesh class
# @ingroup l2_modif_trsf
- def MirrorMakeMesh(self, IDsOfElements, Mirror, theMirrorType, MakeGroups=0, NewMeshName=""):
+ def MirrorMakeMesh(self, IDsOfElements, Mirror, theMirrorType=0, MakeGroups=0, NewMeshName=""):
if IDsOfElements == []:
IDsOfElements = self.GetElementsId()
if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)):
- Mirror = self.smeshpyD.GetAxisStruct(Mirror)
- self.mesh.SetParameters(Mirror.parameters)
+ Mirror = self.smeshpyD.GetAxisStruct(Mirror)
+ theMirrorType = Mirror._mirrorType
+ else:
+ self.mesh.SetParameters(Mirror.parameters)
mesh = self.editor.MirrorMakeMesh(IDsOfElements, Mirror, theMirrorType,
MakeGroups, NewMeshName)
return Mesh(self.smeshpyD,self.geompyD,mesh)
# @param MakeGroups forces the generation of new groups from existing ones (if Copy)
# @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
# @ingroup l2_modif_trsf
- def MirrorObject (self, theObject, Mirror, theMirrorType, Copy=0, MakeGroups=False):
+ def MirrorObject (self, theObject, Mirror, theMirrorType=None, Copy=0, MakeGroups=False):
if ( isinstance( theObject, Mesh )):
theObject = theObject.GetMesh()
if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)):
- Mirror = self.smeshpyD.GetAxisStruct(Mirror)
- self.mesh.SetParameters(Mirror.parameters)
+ Mirror = self.smeshpyD.GetAxisStruct(Mirror)
+ theMirrorType = Mirror._mirrorType
+ else:
+ self.mesh.SetParameters(Mirror.parameters)
if Copy and MakeGroups:
return self.editor.MirrorObjectMakeGroups(theObject, Mirror, theMirrorType)
self.editor.MirrorObject(theObject, Mirror, theMirrorType, Copy)
# @param NewMeshName the name of the new mesh to create
# @return instance of Mesh class
# @ingroup l2_modif_trsf
- def MirrorObjectMakeMesh (self, theObject, Mirror, theMirrorType,MakeGroups=0, NewMeshName=""):
+ def MirrorObjectMakeMesh (self, theObject, Mirror, theMirrorType=0,MakeGroups=0,NewMeshName=""):
if ( isinstance( theObject, Mesh )):
theObject = theObject.GetMesh()
- if (isinstance(Mirror, geomBuilder.GEOM._objref_GEOM_Object)):
- Mirror = self.smeshpyD.GetAxisStruct(Mirror)
- self.mesh.SetParameters(Mirror.parameters)
+ if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)):
+ Mirror = self.smeshpyD.GetAxisStruct(Mirror)
+ theMirrorType = Mirror._mirrorType
+ else:
+ self.mesh.SetParameters(Mirror.parameters)
mesh = self.editor.MirrorObjectMakeMesh(theObject, Mirror, theMirrorType,
MakeGroups, NewMeshName)
return Mesh( self.smeshpyD,self.geompyD,mesh )
# Triangles are transformed in prisms, and quadrangles in hexahedrons.
# @param theDomains - list of groups of volumes
# @param createJointElems - if TRUE, create the elements
+ # @param onAllBoundaries - if TRUE, the nodes and elements are also created on
+ # the boundary between \a theDomains and the rest mesh
# @return TRUE if operation has been completed successfully, FALSE otherwise
- def DoubleNodesOnGroupBoundaries(self, theDomains, createJointElems ):
- return self.editor.DoubleNodesOnGroupBoundaries( theDomains, createJointElems )
+ def DoubleNodesOnGroupBoundaries(self, theDomains, createJointElems, onAllBoundaries=False ):
+ return self.editor.DoubleNodesOnGroupBoundaries( theDomains, createJointElems, onAllBoundaries )
## Double nodes on some external faces and create flat elements.
# Flat elements are mainly used by some types of mechanic calculations.
def GetSkew(self, elemId):
return self._valueFromFunctor(SMESH.FT_Skew, elemId)
+ ## Return minimal and maximal value of a given functor.
+ # @param funType a functor type, an item of SMESH.FunctorType enum
+ # (one of SMESH.FunctorType._items)
+ # @param meshPart a part of mesh (group, sub-mesh) to treat
+ # @return tuple (min,max)
+ # @ingroup l1_measurements
+ def GetMinMax(self, funType, meshPart=None):
+ unRegister = genObjUnRegister()
+ if isinstance( meshPart, list ):
+ meshPart = self.GetIDSource( meshPart, SMESH.ALL )
+ unRegister.set( meshPart )
+ if isinstance( meshPart, Mesh ):
+ meshPart = meshPart.mesh
+ fun = self._getFunctor( funType )
+ if fun:
+ if meshPart:
+ hist = fun.GetLocalHistogram( 1, False, meshPart )
+ else:
+ hist = fun.GetHistogram( 1, False )
+ if hist:
+ return hist[0].min, hist[0].max
+ return None
+
pass # end of Mesh class
-
+
## Helper class for wrapping of SMESH.SMESH_Pattern CORBA class
#
class Pattern(SMESH._objref_SMESH_Pattern):