1 # Copyright (C) 2005 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
2 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 # See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
21 # Author : Francis KLOSS, OCC
43 smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
44 smesh.SetCurrentStudy(salome.myStudy)
52 ior = salome.orb.object_to_string(obj)
53 sobj = salome.myStudy.FindObjectIOR(ior)
57 attr = sobj.FindAttribute("AttributeName")[1]
60 def SetName(obj, name):
61 ior = salome.orb.object_to_string(obj)
62 sobj = salome.myStudy.FindObjectIOR(ior)
63 attr = sobj.FindAttribute("AttributeName")[1]
66 # Algorithms and hypothesis
67 # =========================
69 # Private class: Mesh_Algorithm
70 # -----------------------------
74 Mother class to define algorithm, recommended to don't use directly
83 If the algorithm is global, return 0
84 else return the submesh associated to this algorithm
88 def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"):
101 name = geompy.SubShapeName(geom, piece)
102 geompy.addToStudyInFather(piece, geom, name)
103 self.subm = mesh.mesh.GetSubMesh(geom, hypo)
105 algo = smesh.CreateHypothesis(hypo, so)
106 SetName(algo, name + "/" + hypo)
107 mesh.mesh.AddHypothesis(self.geom, algo)
109 def Hypothesis(self, hyp, args=[], so="libStdMeshersEngine.so"):
113 hypo = smesh.CreateHypothesis(hyp, so)
119 a = a + s + str(args[i])
122 SetName(hypo, GetName(self.geom) + "/" + hyp + a)
123 self.mesh.mesh.AddHypothesis(self.geom, hypo)
126 # Public class: Mesh_Segment
127 # --------------------------
129 class Mesh_Segment(Mesh_Algorithm):
131 Class to define a segment 1D algorithm for discretization
134 def __init__(self, mesh, geom=0):
138 self.Create(mesh, geom, "Regular_1D")
140 def LocalLength(self, l):
142 Define "LocalLength" hypothesis to cut an edge in several segments with the same length
143 \param l for the length of segments that cut an edge
145 hyp = self.Hypothesis("LocalLength", [l])
149 def NumberOfSegments(self, n, s=[]):
151 Define "NumberOfSegments" hypothesis to cut an edge in several fixed number of segments
152 \param n for the number of segments that cut an edge
153 \param s for the scale factor (optional)
156 hyp = self.Hypothesis("NumberOfSegments", [n])
158 hyp = self.Hypothesis("NumberOfSegments", [n,s])
159 hyp.SetDistrType( 1 )
160 hyp.SetScaleFactor(s)
161 hyp.SetNumberOfSegments(n)
164 def Arithmetic1D(self, start, end):
166 Define "Arithmetic1D" hypothesis to cut an edge in several segments with arithmetic length increasing
167 \param start for the length of the first segment
168 \param end for the length of the last segment
170 hyp = self.Hypothesis("Arithmetic1D", [start, end])
171 hyp.SetLength(start, 1)
172 hyp.SetLength(end , 0)
175 def StartEndLength(self, start, end):
177 Define "StartEndLength" hypothesis to cut an edge in several segments with geometric length increasing
178 \param start for the length of the first segment
179 \param end for the length of the last segment
181 hyp = self.Hypothesis("StartEndLength", [start, end])
182 hyp.SetLength(start, 1)
183 hyp.SetLength(end , 0)
186 def Deflection1D(self, d):
188 Define "Deflection1D" hypothesis
189 \param d for the deflection
191 hyp = self.Hypothesis("Deflection1D", [d])
195 def Propagation(self):
197 Define "Propagation" hypothesis that propagate all other hypothesis on all others edges that are in
198 the opposite side in the case of quadrangular faces
200 return self.Hypothesis("Propagation")
202 def AutomaticLength(self):
204 Define "AutomaticLength" hypothesis
206 return self.Hypothesis("AutomaticLength")
208 # Public class: Mesh_Segment_Python
209 # ---------------------------------
211 class Mesh_Segment_Python(Mesh_Segment):
213 Class to define a segment 1D algorithm for discretization with python function
216 def __init__(self, mesh, geom=0):
220 import Python1dPlugin
221 self.Create(mesh, geom, "Python_1D", "libPython1dEngine.so")
223 def PythonSplit1D(self, n, func):
225 Define "PythonSplit1D" hypothesis based on the Erwan Adam patch, awaiting equivalent SALOME functionality
226 \param n for the number of segments that cut an edge
227 \param func for the python function that calculate the length of all segments
229 hyp = self.Hypothesis("PythonSplit1D", [n], "libPython1dEngine.so")
230 hyp.SetNumberOfSegments(n)
231 hyp.SetPythonLog10RatioFunction(func)
234 # Public class: Mesh_Triangle
235 # ---------------------------
237 class Mesh_Triangle(Mesh_Algorithm):
239 Class to define a triangle 2D algorithm
242 def __init__(self, mesh, geom=0):
246 self.Create(mesh, geom, "MEFISTO_2D")
248 def MaxElementArea(self, area):
250 Define "MaxElementArea" hypothesis to give the maximun area of each triangles
251 \param area for the maximum area of each triangles
253 hyp = self.Hypothesis("MaxElementArea", [area])
254 hyp.SetMaxElementArea(area)
257 def LengthFromEdges(self):
259 Define "LengthFromEdges" hypothesis to build triangles based on the length of the edges taken from the wire
261 return self.Hypothesis("LengthFromEdges")
263 # Public class: Mesh_Quadrangle
264 # -----------------------------
266 class Mesh_Quadrangle(Mesh_Algorithm):
268 Class to define a quadrangle 2D algorithm
271 def __init__(self, mesh, geom=0):
275 self.Create(mesh, geom, "Quadrangle_2D")
277 # Public class: Mesh_Tetrahedron
278 # ------------------------------
280 class Mesh_Tetrahedron(Mesh_Algorithm):
282 Class to define a tetrahedron 3D algorithm
285 def __init__(self, mesh, algo, geom=0):
290 self.Create(mesh, geom, "NETGEN_3D", "libNETGENEngine.so")
293 self.Create(mesh, geom, "GHS3D_3D" , "libGHS3DEngine.so")
295 def MaxElementVolume(self, vol):
297 Define "MaxElementVolume" hypothesis to give the maximun volume of each tetrahedral
298 \param vol for the maximum volume of each tetrahedral
300 hyp = self.Hypothesis("MaxElementVolume", [vol])
301 hyp.SetMaxElementVolume(vol)
304 # Public class: Mesh_Hexahedron
305 # ------------------------------
307 class Mesh_Hexahedron(Mesh_Algorithm):
309 Class to define a hexahedron 3D algorithm
312 def __init__(self, mesh, geom=0):
316 self.Create(mesh, geom, "Hexa_3D")
323 Class to define a mesh
329 def __init__(self, geom, name=0):
333 Creates mesh on the shape \a geom,
334 sets GUI name of this mesh to \a name.
335 \param geom Shape to be meshed
336 \param name Study name of the mesh
339 self.mesh = smesh.CreateMesh(geom)
341 SetName(self.mesh, GetName(geom))
343 SetName(self.mesh, name)
347 Method that returns the mesh
353 Method that returns the shape associated to the mesh
357 def MeshDimension(self):
359 Returns mesh dimension depending on shape one
361 shells = geompy.SubShapeAllIDs( self.geom, geompy.ShapeType["SHELL"] )
362 if len( shells ) > 0 :
364 elif geompy.NumberOfFaces( self.geom ) > 0 :
366 elif geompy.NumberOfEdges( self.geom ) > 0 :
372 def Segment(self, algo=REGULAR, geom=0):
374 Creates a segment discretization 1D algorithm.
375 If the optional \a algo parameter is not sets, this algorithm is REGULAR.
376 If the optional \a geom parameter is not sets, this algorithm is global.
377 Otherwise, this algorithm define a submesh based on \a geom subshape.
378 \param algo values are smesh.REGULAR or smesh.PYTHON for discretization via python function
379 \param geom If defined, subshape to be meshed
382 return Mesh_Segment(self, geom)
384 return Mesh_Segment_Python(self, geom)
386 return Mesh_Segment(self, algo)
388 def Triangle(self, geom=0):
390 Creates a triangle 2D algorithm for faces.
391 If the optional \a geom parameter is not sets, this algorithm is global.
392 Otherwise, this algorithm define a submesh based on \a geom subshape.
393 \param geom If defined, subshape to be meshed
395 return Mesh_Triangle(self, geom)
397 def Quadrangle(self, geom=0):
399 Creates a quadrangle 2D algorithm for faces.
400 If the optional \a geom parameter is not sets, this algorithm is global.
401 Otherwise, this algorithm define a submesh based on \a geom subshape.
402 \param geom If defined, subshape to be meshed
404 return Mesh_Quadrangle(self, geom)
406 def Tetrahedron(self, algo, geom=0):
408 Creates a tetrahedron 3D algorithm for solids.
409 The parameter \a algo permits to choice the algorithm: NETGEN or GHS3D
410 If the optional \a geom parameter is not sets, this algorithm is global.
411 Otherwise, this algorithm define a submesh based on \a geom subshape.
412 \param algo values are: smesh.NETGEN, smesh.GHS3D
413 \param geom If defined, subshape to be meshed
415 return Mesh_Tetrahedron(self, algo, geom)
417 def Hexahedron(self, geom=0):
419 Creates a hexahedron 3D algorithm for solids.
420 If the optional \a geom parameter is not sets, this algorithm is global.
421 Otherwise, this algorithm define a submesh based on \a geom subshape.
422 \param geom If defined, subshape to be meshed
424 return Mesh_Hexahedron(self, geom)
428 Compute the mesh and return the status of the computation
430 b = smesh.Compute(self.mesh, self.geom)
431 if salome.sg.hasDesktop():
432 smeshgui = salome.ImportComponentGUI("SMESH")
433 smeshgui.Init(salome.myStudyId)
434 smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), b )
435 salome.sg.updateObjBrowser(1)
438 def AutomaticTetrahedralization(self):
440 Compute tetrahedral mesh using AutomaticLength + MEFISTO + NETGEN
442 dim = self.MeshDimension()
444 self.RemoveGlobalHypotheses()
445 self.Segment().AutomaticLength()
447 self.Triangle().LengthFromEdges()
450 self.Tetrahedron(NETGEN)
455 def AutomaticHexahedralization(self):
457 Compute hexahedral mesh using AutomaticLength + Quadrangle + Hexahedron
459 dim = self.MeshDimension()
461 self.RemoveGlobalHypotheses()
462 self.Segment().AutomaticLength()
472 def RemoveGlobalHypotheses(self):
474 Removes all global hypotheses
476 current_hyps = self.mesh.GetHypothesisList( self.geom )
477 for hyp in current_hyps:
478 self.mesh.RemoveHypothesis( self.geom, hyp )
482 def Group(self, grp, name=""):
484 Create a mesh group based on geometric object \a grp
485 and give a \a name, if this parameter is not defined
486 the name is the same as the geometric group name
487 \param grp is a geometric group, a vertex, an edge, a face or a solid
488 \param name is the name of the mesh group
494 tgeo = str(grp.GetShapeType())
501 elif tgeo == "SOLID":
503 elif tgeo == "SHELL":
505 elif tgeo == "COMPOUND":
506 tgeo = geompy.GetType(grp)
507 if tgeo == geompy.ShapeType["VERTEX"]:
509 elif tgeo == geompy.ShapeType["EDGE"]:
511 elif tgeo == geompy.ShapeType["FACE"]:
513 elif tgeo == geompy.ShapeType["SOLID"]:
517 print "Mesh.Group: bad first argument: expected a group, a vertex, an edge, a face or a solid"
520 return self.mesh.CreateGroupFromGEOM(type, name, grp)
522 def ExportToMED(self, f, version, opt=0):
524 Export the mesh in a file with the MED format and choice the \a version of MED format
525 \param f is the file name
526 \param version values are smesh.MED_V2_1, smesh.MED_V2_2
528 self.mesh.ExportToMED(f, opt, version)
530 def ExportMED(self, f, opt=0):
532 Export the mesh in a file with the MED format
533 \param f is the file name
535 self.mesh.ExportMED(f, opt)
537 def ExportDAT(self, f):
539 Export the mesh in a file with the DAT format
540 \param f is the file name
542 self.mesh.ExportDAT(f)
544 def ExportUNV(self, f):
546 Export the mesh in a file with the UNV format
547 \param f is the file name
549 self.mesh.ExportUNV(f)
551 def ExportSTL(self, f, ascii=1):
553 Export the mesh in a file with the STL format
554 \param f is the file name
555 \param ascii defined the kind of file contents
557 self.mesh.ExportSTL(f, ascii)