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.SetScaleFactor(s)
160 hyp.SetNumberOfSegments(n)
163 def Arithmetic1D(self, start, end):
165 Define "Arithmetic1D" hypothesis to cut an edge in several segments with arithmetic length increasing
166 \param start for the length of the first segment
167 \param end for the length of the last segment
169 hyp = self.Hypothesis("Arithmetic1D", [start, end])
170 hyp.SetLength(start, 1)
171 hyp.SetLength(end , 0)
174 def StartEndLength(self, start, end):
176 Define "StartEndLength" hypothesis to cut an edge in several segments with geometric length increasing
177 \param start for the length of the first segment
178 \param end for the length of the last segment
180 hyp = self.Hypothesis("StartEndLength", [start, end])
181 hyp.SetLength(start, 1)
182 hyp.SetLength(end , 0)
185 def Deflection1D(self, d):
187 Define "Deflection1D" hypothesis
188 \param d for the deflection
190 hyp = self.Hypothesis("Deflection1D", [d])
194 def Propagation(self):
196 Define "Propagation" hypothesis that propagate all other hypothesis on all others edges that are in
197 the opposite side in the case of quadrangular faces
199 return self.Hypothesis("Propagation")
201 # Public class: Mesh_Segment_Python
202 # ---------------------------------
204 class Mesh_Segment_Python(Mesh_Segment):
206 Class to define a segment 1D algorithm for discretization with python function
209 def __init__(self, mesh, geom=0):
213 import Python1dPlugin
214 self.Create(mesh, geom, "Python_1D", "libPython1dEngine.so")
216 def PythonSplit1D(self, n, func):
218 Define "PythonSplit1D" hypothesis based on the Erwan Adam patch, awaiting equivalent SALOME functionality
219 \param n for the number of segments that cut an edge
220 \param func for the python function that calculate the length of all segments
222 hyp = self.Hypothesis("PythonSplit1D", [n], "libPython1dEngine.so")
223 hyp.SetNumberOfSegments(n)
224 hyp.SetPythonLog10RatioFunction(func)
227 # Public class: Mesh_Triangle
228 # ---------------------------
230 class Mesh_Triangle(Mesh_Algorithm):
232 Class to define a triangle 2D algorithm
235 def __init__(self, mesh, geom=0):
239 self.Create(mesh, geom, "MEFISTO_2D")
241 def MaxElementArea(self, area):
243 Define "MaxElementArea" hypothesis to give the maximun area of each triangles
244 \param area for the maximum area of each triangles
246 hyp = self.Hypothesis("MaxElementArea", [area])
247 hyp.SetMaxElementArea(area)
250 def LengthFromEdges(self):
252 Define "LengthFromEdges" hypothesis to build triangles based on the length of the edges taken from the wire
254 return self.Hypothesis("LengthFromEdges")
256 # Public class: Mesh_Quadrangle
257 # -----------------------------
259 class Mesh_Quadrangle(Mesh_Algorithm):
261 Class to define a quadrangle 2D algorithm
264 def __init__(self, mesh, geom=0):
268 self.Create(mesh, geom, "Quadrangle_2D")
270 # Public class: Mesh_Tetrahedron
271 # ------------------------------
273 class Mesh_Tetrahedron(Mesh_Algorithm):
275 Class to define a tetrahedron 3D algorithm
278 def __init__(self, mesh, algo, geom=0):
283 self.Create(mesh, geom, "NETGEN_3D", "libNETGENEngine.so")
286 self.Create(mesh, geom, "GHS3D_3D" , "libGHS3DEngine.so")
288 def MaxElementVolume(self, vol):
290 Define "MaxElementVolume" hypothesis to give the maximun volume of each tetrahedral
291 \param vol for the maximum volume of each tetrahedral
293 hyp = self.Hypothesis("MaxElementVolume", [vol])
294 hyp.SetMaxElementVolume(vol)
297 # Public class: Mesh_Hexahedron
298 # ------------------------------
300 class Mesh_Hexahedron(Mesh_Algorithm):
302 Class to define a hexahedron 3D algorithm
305 def __init__(self, mesh, geom=0):
309 self.Create(mesh, geom, "Hexa_3D")
316 Class to define a mesh
322 def __init__(self, geom, name=0):
326 Creates mesh on the shape \a geom,
327 sets GUI name of this mesh to \a name.
328 \param geom Shape to be meshed
329 \param name Study name of the mesh
332 self.mesh = smesh.CreateMesh(geom)
334 SetName(self.mesh, GetName(geom))
336 SetName(self.mesh, name)
340 Method that returns the mesh
346 Method that returns the shape associated to the mesh
350 def Segment(self, algo=REGULAR, geom=0):
352 Creates a segment discretization 1D algorithm.
353 If the optional \a algo parameter is not sets, this algorithm is REGULAR.
354 If the optional \a geom parameter is not sets, this algorithm is global.
355 Otherwise, this algorithm define a submesh based on \a geom subshape.
356 \param algo values are smesh.REGULAR or smesh.PYTHON for discretization via python function
357 \param geom If defined, subshape to be meshed
360 return Mesh_Segment(self, geom)
362 return Mesh_Segment_Python(self, geom)
364 return Mesh_Segment(self, algo)
366 def Triangle(self, geom=0):
368 Creates a triangle 2D algorithm for faces.
369 If the optional \a geom parameter is not sets, this algorithm is global.
370 Otherwise, this algorithm define a submesh based on \a geom subshape.
371 \param geom If defined, subshape to be meshed
373 return Mesh_Triangle(self, geom)
375 def Quadrangle(self, geom=0):
377 Creates a quadrangle 2D algorithm for faces.
378 If the optional \a geom parameter is not sets, this algorithm is global.
379 Otherwise, this algorithm define a submesh based on \a geom subshape.
380 \param geom If defined, subshape to be meshed
382 return Mesh_Quadrangle(self, geom)
384 def Tetrahedron(self, algo, geom=0):
386 Creates a tetrahedron 3D algorithm for solids.
387 The parameter \a algo permits to choice the algorithm: NETGEN or GHS3D
388 If the optional \a geom parameter is not sets, this algorithm is global.
389 Otherwise, this algorithm define a submesh based on \a geom subshape.
390 \param algo values are: smesh.NETGEN, smesh.GHS3D
391 \param geom If defined, subshape to be meshed
393 return Mesh_Tetrahedron(self, algo, geom)
395 def Hexahedron(self, geom=0):
397 Creates a hexahedron 3D algorithm for solids.
398 If the optional \a geom parameter is not sets, this algorithm is global.
399 Otherwise, this algorithm define a submesh based on \a geom subshape.
400 \param geom If defined, subshape to be meshed
402 return Mesh_Hexahedron(self, geom)
406 Compute the mesh and return the status of the computation
408 b = smesh.Compute(self.mesh, self.geom)
409 if salome.sg.hasDesktop():
410 smeshgui = salome.ImportComponentGUI("SMESH")
411 smeshgui.Init(salome.myStudyId)
412 smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), b )
413 salome.sg.updateObjBrowser(1)
416 def Group(self, grp, name=""):
418 Create a mesh group based on geometric object \a grp
419 and give a \a name, if this parameter is not defined
420 the name is the same as the geometric group name
421 \param grp is a geometric group, a vertex, an edge, a face or a solid
422 \param name is the name of the mesh group
428 tgeo = str(grp.GetShapeType())
435 elif tgeo == "SOLID":
437 elif tgeo == "SHELL":
439 elif tgeo == "COMPOUND":
440 tgeo = geompy.GetType(grp)
441 if tgeo == geompy.ShapeType["VERTEX"]:
443 elif tgeo == geompy.ShapeType["EDGE"]:
445 elif tgeo == geompy.ShapeType["FACE"]:
447 elif tgeo == geompy.ShapeType["SOLID"]:
451 print "Mesh.Group: bad first argument: expected a group, a vertex, an edge, a face or a solid"
454 return self.mesh.CreateGroupFromGEOM(type, name, grp)
456 def ExportToMED(self, f, version, opt=0):
458 Export the mesh in a file with the MED format and choice the \a version of MED format
459 \param f is the file name
460 \param version values are SMESH.MED_V2_1, SMESH.MED_V2_2
462 self.mesh.ExportToMED(f, opt, version)
464 def ExportMED(self, f, opt=0):
466 Export the mesh in a file with the MED format
467 \param f is the file name
469 self.mesh.ExportMED(f, opt)
471 def ExportDAT(self, f):
473 Export the mesh in a file with the DAT format
474 \param f is the file name
476 self.mesh.ExportDAT(f)
478 def ExportUNV(self, f):
480 Export the mesh in a file with the UNV format
481 \param f is the file name
483 self.mesh.ExportUNV(f)
485 def ExportSTL(self, f, ascii=1):
487 Export the mesh in a file with the STL format
488 \param f is the file name
489 \param ascii defined the kind of file contents
491 self.mesh.ExportSTL(f, ascii)