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
84 If the algorithm is global, return 0
85 else return the submesh associated to this algorithm
89 def GetAlgorithm(self):
91 Return the wrapped mesher
95 def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"):
103 name = GetName(piece)
108 name = geompy.SubShapeName(geom, piece)
109 geompy.addToStudyInFather(piece, geom, name)
110 self.subm = mesh.mesh.GetSubMesh(geom, hypo)
112 self.algo = smesh.CreateHypothesis(hypo, so)
113 SetName(self.algo, name + "/" + hypo)
114 mesh.mesh.AddHypothesis(self.geom, self.algo)
116 def Hypothesis(self, hyp, args=[], so="libStdMeshersEngine.so"):
120 hypo = smesh.CreateHypothesis(hyp, so)
126 a = a + s + str(args[i])
129 SetName(hypo, GetName(self.geom) + "/" + hyp + a)
130 self.mesh.mesh.AddHypothesis(self.geom, hypo)
133 # Public class: Mesh_Segment
134 # --------------------------
136 class Mesh_Segment(Mesh_Algorithm):
138 Class to define a segment 1D algorithm for discretization
141 def __init__(self, mesh, geom=0):
145 self.Create(mesh, geom, "Regular_1D")
147 def LocalLength(self, l):
149 Define "LocalLength" hypothesis to cut an edge in several segments with the same length
150 \param l for the length of segments that cut an edge
152 hyp = self.Hypothesis("LocalLength", [l])
156 def NumberOfSegments(self, n, s=[]):
158 Define "NumberOfSegments" hypothesis to cut an edge in several fixed number of segments
159 \param n for the number of segments that cut an edge
160 \param s for the scale factor (optional)
163 hyp = self.Hypothesis("NumberOfSegments", [n])
165 hyp = self.Hypothesis("NumberOfSegments", [n,s])
166 hyp.SetDistrType( 1 )
167 hyp.SetScaleFactor(s)
168 hyp.SetNumberOfSegments(n)
171 def Arithmetic1D(self, start, end):
173 Define "Arithmetic1D" hypothesis to cut an edge in several segments with arithmetic length increasing
174 \param start for the length of the first segment
175 \param end for the length of the last segment
177 hyp = self.Hypothesis("Arithmetic1D", [start, end])
178 hyp.SetLength(start, 1)
179 hyp.SetLength(end , 0)
182 def StartEndLength(self, start, end):
184 Define "StartEndLength" hypothesis to cut an edge in several segments with geometric length increasing
185 \param start for the length of the first segment
186 \param end for the length of the last segment
188 hyp = self.Hypothesis("StartEndLength", [start, end])
189 hyp.SetLength(start, 1)
190 hyp.SetLength(end , 0)
193 def Deflection1D(self, d):
195 Define "Deflection1D" hypothesis
196 \param d for the deflection
198 hyp = self.Hypothesis("Deflection1D", [d])
202 def Propagation(self):
204 Define "Propagation" hypothesis that propagate all other hypothesis on all others edges that are in
205 the opposite side in the case of quadrangular faces
207 return self.Hypothesis("Propagation")
209 def AutomaticLength(self):
211 Define "AutomaticLength" hypothesis
213 return self.Hypothesis("AutomaticLength")
215 # Public class: Mesh_Segment_Python
216 # ---------------------------------
218 class Mesh_Segment_Python(Mesh_Segment):
220 Class to define a segment 1D algorithm for discretization with python function
223 def __init__(self, mesh, geom=0):
227 import Python1dPlugin
228 self.Create(mesh, geom, "Python_1D", "libPython1dEngine.so")
230 def PythonSplit1D(self, n, func):
232 Define "PythonSplit1D" hypothesis based on the Erwan Adam patch, awaiting equivalent SALOME functionality
233 \param n for the number of segments that cut an edge
234 \param func for the python function that calculate the length of all segments
236 hyp = self.Hypothesis("PythonSplit1D", [n], "libPython1dEngine.so")
237 hyp.SetNumberOfSegments(n)
238 hyp.SetPythonLog10RatioFunction(func)
241 # Public class: Mesh_Triangle
242 # ---------------------------
244 class Mesh_Triangle(Mesh_Algorithm):
246 Class to define a triangle 2D algorithm
249 def __init__(self, mesh, geom=0):
253 self.Create(mesh, geom, "MEFISTO_2D")
255 def MaxElementArea(self, area):
257 Define "MaxElementArea" hypothesis to give the maximun area of each triangles
258 \param area for the maximum area of each triangles
260 hyp = self.Hypothesis("MaxElementArea", [area])
261 hyp.SetMaxElementArea(area)
264 def LengthFromEdges(self):
266 Define "LengthFromEdges" hypothesis to build triangles based on the length of the edges taken from the wire
268 return self.Hypothesis("LengthFromEdges")
270 # Public class: Mesh_Quadrangle
271 # -----------------------------
273 class Mesh_Quadrangle(Mesh_Algorithm):
275 Class to define a quadrangle 2D algorithm
278 def __init__(self, mesh, geom=0):
282 self.Create(mesh, geom, "Quadrangle_2D")
284 # Public class: Mesh_Tetrahedron
285 # ------------------------------
287 class Mesh_Tetrahedron(Mesh_Algorithm):
289 Class to define a tetrahedron 3D algorithm
292 def __init__(self, mesh, algo, geom=0):
297 self.Create(mesh, geom, "NETGEN_3D", "libNETGENEngine.so")
300 self.Create(mesh, geom, "GHS3D_3D" , "libGHS3DEngine.so")
302 def MaxElementVolume(self, vol):
304 Define "MaxElementVolume" hypothesis to give the maximun volume of each tetrahedral
305 \param vol for the maximum volume of each tetrahedral
307 hyp = self.Hypothesis("MaxElementVolume", [vol])
308 hyp.SetMaxElementVolume(vol)
311 # Public class: Mesh_Hexahedron
312 # ------------------------------
314 class Mesh_Hexahedron(Mesh_Algorithm):
316 Class to define a hexahedron 3D algorithm
319 def __init__(self, mesh, geom=0):
323 self.Create(mesh, geom, "Hexa_3D")
330 Class to define a mesh
336 def __init__(self, geom, name=0):
340 Creates mesh on the shape \a geom,
341 sets GUI name of this mesh to \a name.
342 \param geom Shape to be meshed
343 \param name Study name of the mesh
346 self.mesh = smesh.CreateMesh(geom)
348 SetName(self.mesh, GetName(geom))
350 SetName(self.mesh, name)
354 Method that returns the mesh
360 Method that returns the shape associated to the mesh
364 def MeshDimension(self):
366 Returns mesh dimension depending on shape one
368 shells = geompy.SubShapeAllIDs( self.geom, geompy.ShapeType["SHELL"] )
369 if len( shells ) > 0 :
371 elif geompy.NumberOfFaces( self.geom ) > 0 :
373 elif geompy.NumberOfEdges( self.geom ) > 0 :
379 def Segment(self, algo=REGULAR, geom=0):
381 Creates a segment discretization 1D algorithm.
382 If the optional \a algo parameter is not sets, this algorithm is REGULAR.
383 If the optional \a geom parameter is not sets, this algorithm is global.
384 Otherwise, this algorithm define a submesh based on \a geom subshape.
385 \param algo values are smesh.REGULAR or smesh.PYTHON for discretization via python function
386 \param geom If defined, subshape to be meshed
388 ## if Segment(geom) is called by mistake
389 if ( isinstance( algo, geompy.GEOM._objref_GEOM_Object)):
390 algo, geom = geom, algo
393 return Mesh_Segment(self, geom)
395 return Mesh_Segment_Python(self, geom)
397 return Mesh_Segment(self, geom)
399 def Triangle(self, geom=0):
401 Creates a triangle 2D algorithm for faces.
402 If the optional \a geom parameter is not sets, this algorithm is global.
403 Otherwise, this algorithm define a submesh based on \a geom subshape.
404 \param geom If defined, subshape to be meshed
406 return Mesh_Triangle(self, geom)
408 def Quadrangle(self, geom=0):
410 Creates a quadrangle 2D algorithm for faces.
411 If the optional \a geom parameter is not sets, this algorithm is global.
412 Otherwise, this algorithm define a submesh based on \a geom subshape.
413 \param geom If defined, subshape to be meshed
415 return Mesh_Quadrangle(self, geom)
417 def Tetrahedron(self, algo, geom=0):
419 Creates a tetrahedron 3D algorithm for solids.
420 The parameter \a algo permits to choice the algorithm: NETGEN or GHS3D
421 If the optional \a geom parameter is not sets, this algorithm is global.
422 Otherwise, this algorithm define a submesh based on \a geom subshape.
423 \param algo values are: smesh.NETGEN, smesh.GHS3D
424 \param geom If defined, subshape to be meshed
426 ## if Tetrahedron(geom) is called by mistake
427 if ( isinstance( algo, geompy.GEOM._objref_GEOM_Object)):
428 algo, geom = geom, algo
430 return Mesh_Tetrahedron(self, algo, geom)
432 def Hexahedron(self, geom=0):
434 Creates a hexahedron 3D algorithm for solids.
435 If the optional \a geom parameter is not sets, this algorithm is global.
436 Otherwise, this algorithm define a submesh based on \a geom subshape.
437 \param geom If defined, subshape to be meshed
439 return Mesh_Hexahedron(self, geom)
443 Compute the mesh and return the status of the computation
445 b = smesh.Compute(self.mesh, self.geom)
446 if salome.sg.hasDesktop():
447 smeshgui = salome.ImportComponentGUI("SMESH")
448 smeshgui.Init(salome.myStudyId)
449 smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), b )
450 salome.sg.updateObjBrowser(1)
453 def AutomaticTetrahedralization(self):
455 Compute tetrahedral mesh using AutomaticLength + MEFISTO + NETGEN
457 dim = self.MeshDimension()
459 self.RemoveGlobalHypotheses()
460 self.Segment().AutomaticLength()
462 self.Triangle().LengthFromEdges()
465 self.Tetrahedron(NETGEN)
467 return self.Compute()
469 def AutomaticHexahedralization(self):
471 Compute hexahedral mesh using AutomaticLength + Quadrangle + Hexahedron
473 dim = self.MeshDimension()
475 self.RemoveGlobalHypotheses()
476 self.Segment().AutomaticLength()
483 return self.Compute()
485 def RemoveGlobalHypotheses(self):
487 Removes all global hypotheses
489 current_hyps = self.mesh.GetHypothesisList( self.geom )
490 for hyp in current_hyps:
491 self.mesh.RemoveHypothesis( self.geom, hyp )
495 def Group(self, grp, name=""):
497 Create a mesh group based on geometric object \a grp
498 and give a \a name, if this parameter is not defined
499 the name is the same as the geometric group name
500 \param grp is a geometric group, a vertex, an edge, a face or a solid
501 \param name is the name of the mesh group
507 tgeo = str(grp.GetShapeType())
514 elif tgeo == "SOLID":
516 elif tgeo == "SHELL":
518 elif tgeo == "COMPOUND":
519 tgeo = geompy.GetType(grp)
520 if tgeo == geompy.ShapeType["VERTEX"]:
522 elif tgeo == geompy.ShapeType["EDGE"]:
524 elif tgeo == geompy.ShapeType["FACE"]:
526 elif tgeo == geompy.ShapeType["SOLID"]:
530 print "Mesh.Group: bad first argument: expected a group, a vertex, an edge, a face or a solid"
533 return self.mesh.CreateGroupFromGEOM(type, name, grp)
535 def ExportToMED(self, f, version, opt=0):
537 Export the mesh in a file with the MED format and choice the \a version of MED format
538 \param f is the file name
539 \param version values are smesh.MED_V2_1, smesh.MED_V2_2
541 self.mesh.ExportToMED(f, opt, version)
543 def ExportMED(self, f, opt=0):
545 Export the mesh in a file with the MED format
546 \param f is the file name
548 self.mesh.ExportMED(f, opt)
550 def ExportDAT(self, f):
552 Export the mesh in a file with the DAT format
553 \param f is the file name
555 self.mesh.ExportDAT(f)
557 def ExportUNV(self, f):
559 Export the mesh in a file with the UNV format
560 \param f is the file name
562 self.mesh.ExportUNV(f)
564 def ExportSTL(self, f, ascii=1):
566 Export the mesh in a file with the STL format
567 \param f is the file name
568 \param ascii defined the kind of file contents
570 self.mesh.ExportSTL(f, ascii)