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 def QuadranglePreference(self):
286 Define "QuadranglePreference" hypothesis, forcing construction
287 of quadrangles if the number of nodes on opposite edges is not the same
288 in the case where the global number of nodes on edges is even
290 hyp = self.Hypothesis("QuadranglePreference")
293 # Public class: Mesh_Tetrahedron
294 # ------------------------------
296 class Mesh_Tetrahedron(Mesh_Algorithm):
298 Class to define a tetrahedron 3D algorithm
301 def __init__(self, mesh, algo, geom=0):
306 self.Create(mesh, geom, "NETGEN_3D", "libNETGENEngine.so")
309 self.Create(mesh, geom, "GHS3D_3D" , "libGHS3DEngine.so")
311 def MaxElementVolume(self, vol):
313 Define "MaxElementVolume" hypothesis to give the maximun volume of each tetrahedral
314 \param vol for the maximum volume of each tetrahedral
316 hyp = self.Hypothesis("MaxElementVolume", [vol])
317 hyp.SetMaxElementVolume(vol)
320 # Public class: Mesh_Hexahedron
321 # ------------------------------
323 class Mesh_Hexahedron(Mesh_Algorithm):
325 Class to define a hexahedron 3D algorithm
328 def __init__(self, mesh, geom=0):
332 self.Create(mesh, geom, "Hexa_3D")
339 Class to define a mesh
345 def __init__(self, geom, name=0):
349 Creates mesh on the shape \a geom,
350 sets GUI name of this mesh to \a name.
351 \param geom Shape to be meshed
352 \param name Study name of the mesh
355 self.mesh = smesh.CreateMesh(geom)
357 SetName(self.mesh, GetName(geom))
359 SetName(self.mesh, name)
363 Method that returns the mesh
369 Method that returns the shape associated to the mesh
373 def MeshDimension(self):
375 Returns mesh dimension depending on shape one
377 shells = geompy.SubShapeAllIDs( self.geom, geompy.ShapeType["SHELL"] )
378 if len( shells ) > 0 :
380 elif geompy.NumberOfFaces( self.geom ) > 0 :
382 elif geompy.NumberOfEdges( self.geom ) > 0 :
388 def Segment(self, algo=REGULAR, geom=0):
390 Creates a segment discretization 1D algorithm.
391 If the optional \a algo parameter is not sets, this algorithm is REGULAR.
392 If the optional \a geom parameter is not sets, this algorithm is global.
393 Otherwise, this algorithm define a submesh based on \a geom subshape.
394 \param algo values are smesh.REGULAR or smesh.PYTHON for discretization via python function
395 \param geom If defined, subshape to be meshed
397 ## if Segment(geom) is called by mistake
398 if ( isinstance( algo, geompy.GEOM._objref_GEOM_Object)):
399 algo, geom = geom, algo
402 return Mesh_Segment(self, geom)
404 return Mesh_Segment_Python(self, geom)
406 return Mesh_Segment(self, geom)
408 def Triangle(self, geom=0):
410 Creates a triangle 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_Triangle(self, geom)
417 def Quadrangle(self, geom=0):
419 Creates a quadrangle 2D algorithm for faces.
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_Quadrangle(self, geom)
426 def Tetrahedron(self, algo, geom=0):
428 Creates a tetrahedron 3D algorithm for solids.
429 The parameter \a algo permits to choice the algorithm: NETGEN or GHS3D
430 If the optional \a geom parameter is not sets, this algorithm is global.
431 Otherwise, this algorithm define a submesh based on \a geom subshape.
432 \param algo values are: smesh.NETGEN, smesh.GHS3D
433 \param geom If defined, subshape to be meshed
435 ## if Tetrahedron(geom) is called by mistake
436 if ( isinstance( algo, geompy.GEOM._objref_GEOM_Object)):
437 algo, geom = geom, algo
439 return Mesh_Tetrahedron(self, algo, geom)
441 def Hexahedron(self, geom=0):
443 Creates a hexahedron 3D algorithm for solids.
444 If the optional \a geom parameter is not sets, this algorithm is global.
445 Otherwise, this algorithm define a submesh based on \a geom subshape.
446 \param geom If defined, subshape to be meshed
448 return Mesh_Hexahedron(self, geom)
452 Compute the mesh and return the status of the computation
454 b = smesh.Compute(self.mesh, self.geom)
455 if salome.sg.hasDesktop():
456 smeshgui = salome.ImportComponentGUI("SMESH")
457 smeshgui.Init(salome.myStudyId)
458 smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), b )
459 salome.sg.updateObjBrowser(1)
462 def AutomaticTetrahedralization(self):
464 Compute tetrahedral mesh using AutomaticLength + MEFISTO + NETGEN
466 dim = self.MeshDimension()
468 self.RemoveGlobalHypotheses()
469 self.Segment().AutomaticLength()
471 self.Triangle().LengthFromEdges()
474 self.Tetrahedron(NETGEN)
476 return self.Compute()
478 def AutomaticHexahedralization(self):
480 Compute hexahedral mesh using AutomaticLength + Quadrangle + Hexahedron
482 dim = self.MeshDimension()
484 self.RemoveGlobalHypotheses()
485 self.Segment().AutomaticLength()
492 return self.Compute()
494 def RemoveGlobalHypotheses(self):
496 Removes all global hypotheses
498 current_hyps = self.mesh.GetHypothesisList( self.geom )
499 for hyp in current_hyps:
500 self.mesh.RemoveHypothesis( self.geom, hyp )
504 def Group(self, grp, name=""):
506 Create a mesh group based on geometric object \a grp
507 and give a \a name, if this parameter is not defined
508 the name is the same as the geometric group name
509 \param grp is a geometric group, a vertex, an edge, a face or a solid
510 \param name is the name of the mesh group
516 tgeo = str(grp.GetShapeType())
523 elif tgeo == "SOLID":
525 elif tgeo == "SHELL":
527 elif tgeo == "COMPOUND":
528 tgeo = geompy.GetType(grp)
529 if tgeo == geompy.ShapeType["VERTEX"]:
531 elif tgeo == geompy.ShapeType["EDGE"]:
533 elif tgeo == geompy.ShapeType["FACE"]:
535 elif tgeo == geompy.ShapeType["SOLID"]:
539 print "Mesh.Group: bad first argument: expected a group, a vertex, an edge, a face or a solid"
542 return self.mesh.CreateGroupFromGEOM(type, name, grp)
544 def ExportToMED(self, f, version, opt=0):
546 Export the mesh in a file with the MED format and choice the \a version of MED format
547 \param f is the file name
548 \param version values are smesh.MED_V2_1, smesh.MED_V2_2
550 self.mesh.ExportToMED(f, opt, version)
552 def ExportMED(self, f, opt=0):
554 Export the mesh in a file with the MED format
555 \param f is the file name
557 self.mesh.ExportMED(f, opt)
559 def ExportDAT(self, f):
561 Export the mesh in a file with the DAT format
562 \param f is the file name
564 self.mesh.ExportDAT(f)
566 def ExportUNV(self, f):
568 Export the mesh in a file with the UNV format
569 \param f is the file name
571 self.mesh.ExportUNV(f)
573 def ExportSTL(self, f, ascii=1):
575 Export the mesh in a file with the STL format
576 \param f is the file name
577 \param ascii defined the kind of file contents
579 self.mesh.ExportSTL(f, ascii)