# Private functions
# -----------------
+NO_NAME = "NoName"
+
def GetName(obj):
ior = salome.orb.object_to_string(obj)
sobj = salome.myStudy.FindObjectIOR(ior)
- attr = sobj.FindAttribute("AttributeName")[1]
- return attr.Value()
+ if sobj is None:
+ return NO_NAME
+ else:
+ attr = sobj.FindAttribute("AttributeName")[1]
+ return attr.Value()
def SetName(obj, name):
ior = salome.orb.object_to_string(obj)
mesh = 0
geom = 0
subm = 0
+ algo = 0
def GetSubMesh(self):
"""
"""
return self.subm
+ def GetAlgorithm(self):
+ """
+ Return the wrapped mesher
+ """
+ return self.algo
+
def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"):
"""
Private method
name = GetName(piece)
else:
self.geom = geom
- name = geompy.SubShapeName(geom, piece)
- geompy.addToStudyInFather(piece, geom, name)
+ name = GetName(geom)
+ if name==NO_NAME:
+ name = geompy.SubShapeName(geom, piece)
+ geompy.addToStudyInFather(piece, geom, name)
self.subm = mesh.mesh.GetSubMesh(geom, hypo)
- algo = smesh.CreateHypothesis(hypo, so)
- SetName(algo, name + "/" + hypo)
- mesh.mesh.AddHypothesis(self.geom, algo)
+ self.algo = smesh.CreateHypothesis(hypo, so)
+ SetName(self.algo, name + "/" + hypo)
+ mesh.mesh.AddHypothesis(self.geom, self.algo)
def Hypothesis(self, hyp, args=[], so="libStdMeshersEngine.so"):
"""
hyp = self.Hypothesis("NumberOfSegments", [n])
else:
hyp = self.Hypothesis("NumberOfSegments", [n,s])
+ hyp.SetDistrType( 1 )
hyp.SetScaleFactor(s)
hyp.SetNumberOfSegments(n)
return hyp
"""
return self.Hypothesis("Propagation")
+ def AutomaticLength(self, fineness):
+ """
+ Define "AutomaticLength" hypothesis
+ \param fineness for the fineness [0-1]
+ """
+ hyp = self.Hypothesis("AutomaticLength")
+ hyp.SetFineness( fineness )
+ return hyp
+
# Public class: Mesh_Segment_Python
# ---------------------------------
"""
self.Create(mesh, geom, "Quadrangle_2D")
+ def QuadranglePreference(self):
+ """
+ Define "QuadranglePreference" hypothesis, forcing construction
+ of quadrangles if the number of nodes on opposite edges is not the same
+ in the case where the global number of nodes on edges is even
+ """
+ hyp = self.Hypothesis("QuadranglePreference")
+ return hyp
+
# Public class: Mesh_Tetrahedron
# ------------------------------
"""
return self.geom
+ def MeshDimension(self):
+ """
+ Returns mesh dimension depending on shape one
+ """
+ shells = geompy.SubShapeAllIDs( self.geom, geompy.ShapeType["SHELL"] )
+ if len( shells ) > 0 :
+ return 3
+ elif geompy.NumberOfFaces( self.geom ) > 0 :
+ return 2
+ elif geompy.NumberOfEdges( self.geom ) > 0 :
+ return 1
+ else:
+ return 0;
+ pass
+
def Segment(self, algo=REGULAR, geom=0):
"""
Creates a segment discretization 1D algorithm.
\param algo values are smesh.REGULAR or smesh.PYTHON for discretization via python function
\param geom If defined, subshape to be meshed
"""
+ ## if Segment(geom) is called by mistake
+ if ( isinstance( algo, geompy.GEOM._objref_GEOM_Object)):
+ algo, geom = geom, algo
+ pass
if algo == REGULAR:
return Mesh_Segment(self, geom)
elif algo == PYTHON:
return Mesh_Segment_Python(self, geom)
else:
- return Mesh_Segment(self, algo)
+ return Mesh_Segment(self, geom)
def Triangle(self, geom=0):
"""
\param algo values are: smesh.NETGEN, smesh.GHS3D
\param geom If defined, subshape to be meshed
"""
+ ## if Tetrahedron(geom) is called by mistake
+ if ( isinstance( algo, geompy.GEOM._objref_GEOM_Object)):
+ algo, geom = geom, algo
+ pass
return Mesh_Tetrahedron(self, algo, geom)
def Hexahedron(self, geom=0):
"""
b = smesh.Compute(self.mesh, self.geom)
if salome.sg.hasDesktop():
+ smeshgui = salome.ImportComponentGUI("SMESH")
+ smeshgui.Init(salome.myStudyId)
+ smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), b )
salome.sg.updateObjBrowser(1)
return b
+ def AutomaticTetrahedralization(self):
+ """
+ Compute tetrahedral mesh using AutomaticLength + MEFISTO + NETGEN
+ """
+ dim = self.MeshDimension()
+ # assign hypotheses
+ self.RemoveGlobalHypotheses()
+ self.Segment().AutomaticLength()
+ if dim > 1 :
+ self.Triangle().LengthFromEdges()
+ pass
+ if dim > 2 :
+ self.Tetrahedron(NETGEN)
+ pass
+ return self.Compute()
+
+ def AutomaticHexahedralization(self):
+ """
+ Compute hexahedral mesh using AutomaticLength + Quadrangle + Hexahedron
+ """
+ dim = self.MeshDimension()
+ # assign hypotheses
+ self.RemoveGlobalHypotheses()
+ self.Segment().AutomaticLength()
+ if dim > 1 :
+ self.Quadrangle()
+ pass
+ if dim > 2 :
+ self.Hexahedron()
+ pass
+ return self.Compute()
+
+ def RemoveGlobalHypotheses(self):
+ """
+ Removes all global hypotheses
+ """
+ current_hyps = self.mesh.GetHypothesisList( self.geom )
+ for hyp in current_hyps:
+ self.mesh.RemoveHypothesis( self.geom, hyp )
+ pass
+ pass
+
def Group(self, grp, name=""):
"""
Create a mesh group based on geometric object \a grp
type = SMESH.FACE
elif tgeo == "SOLID":
type = SMESH.VOLUME
+ elif tgeo == "SHELL":
+ type = SMESH.VOLUME
elif tgeo == "COMPOUND":
tgeo = geompy.GetType(grp)
if tgeo == geompy.ShapeType["VERTEX"]:
