Salome HOME
2fb7de23f19e59c0fc2f19c5dd4022d183d50514
[modules/smesh.git] / src / SMESH_SWIG / smesh.py
1 #  Copyright (C) 2005  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
2 #  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
3 #
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.
8 #
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.
13 #
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
17 #
18 #  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
19 #
20 #  File   : smesh.py
21 #  Author : Francis KLOSS, OCC
22 #  Module : SMESH
23
24 """
25  \namespace smesh
26  \brief Module smesh
27 """
28
29 import salome
30 import geompy
31 import StdMeshers
32 import SMESH
33
34 # Public variables
35 # ----------------
36
37 REGULAR = 1
38 PYTHON  = 2
39
40 NETGEN  = 3
41 GHS3D   = 4
42
43 smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
44 smesh.SetCurrentStudy(salome.myStudy)
45
46 # Private functions
47 # -----------------
48
49 NO_NAME = "NoName"
50
51 def GetName(obj):
52     ior  = salome.orb.object_to_string(obj)
53     sobj = salome.myStudy.FindObjectIOR(ior)
54     if sobj is None:
55         return NO_NAME
56     else:
57         attr = sobj.FindAttribute("AttributeName")[1]
58         return attr.Value()
59
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]
64     attr.SetValue(name)
65
66 # Algorithms and hypothesis
67 # =========================
68
69 # Private class: Mesh_Algorithm
70 # -----------------------------
71
72 class Mesh_Algorithm:
73     """
74     Mother class to define algorithm, recommended to don't use directly
75     """
76
77     mesh = 0
78     geom = 0
79     subm = 0
80
81     def GetSubMesh(self):
82         """
83          If the algorithm is global, return 0
84          else return the submesh associated to this algorithm
85         """
86         return self.subm
87
88     def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"):
89         """
90          Private method
91         """
92         self.mesh = mesh
93         piece = mesh.geom
94         if geom==0:
95             self.geom = piece
96             name = GetName(piece)
97         else:
98             self.geom = geom
99             name = GetName(geom)
100             if name==NO_NAME:
101                 name = geompy.SubShapeName(geom, piece)
102                 geompy.addToStudyInFather(piece, geom, name)
103             self.subm = mesh.mesh.GetSubMesh(geom, hypo)
104
105         algo = smesh.CreateHypothesis(hypo, so)
106         SetName(algo, name + "/" + hypo)
107         mesh.mesh.AddHypothesis(self.geom, algo)
108
109     def Hypothesis(self, hyp, args=[], so="libStdMeshersEngine.so"):
110         """
111          Private method
112         """
113         hypo = smesh.CreateHypothesis(hyp, so)
114         a = ""
115         s = "="
116         i = 0
117         n = len(args)
118         while i<n:
119             a = a + s + str(args[i])
120             s = ","
121             i = i + 1
122         SetName(hypo, GetName(self.geom) + "/" + hyp + a)
123         self.mesh.mesh.AddHypothesis(self.geom, hypo)
124         return hypo
125
126 # Public class: Mesh_Segment
127 # --------------------------
128
129 class Mesh_Segment(Mesh_Algorithm):
130     """
131     Class to define a segment 1D algorithm for discretization
132     """
133
134     def __init__(self, mesh, geom=0):
135         """
136          Private constructor
137         """
138         self.Create(mesh, geom, "Regular_1D")
139
140     def LocalLength(self, l):
141         """
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
144         """
145         hyp = self.Hypothesis("LocalLength", [l])
146         hyp.SetLength(l)
147         return hyp
148
149     def NumberOfSegments(self, n, s=[]):
150         """
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)
154         """
155         if s == []:
156             hyp = self.Hypothesis("NumberOfSegments", [n])
157         else:
158             hyp = self.Hypothesis("NumberOfSegments", [n,s])
159             hyp.SetScaleFactor(s)
160         hyp.SetNumberOfSegments(n)
161         return hyp
162
163     def Arithmetic1D(self, start, end):
164         """
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
168         """
169         hyp = self.Hypothesis("Arithmetic1D", [start, end])
170         hyp.SetLength(start, 1)
171         hyp.SetLength(end  , 0)
172         return hyp
173
174     def StartEndLength(self, start, end):
175         """
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
179         """
180         hyp = self.Hypothesis("StartEndLength", [start, end])
181         hyp.SetLength(start, 1)
182         hyp.SetLength(end  , 0)
183         return hyp
184
185     def Deflection1D(self, d):
186         """
187          Define "Deflection1D" hypothesis
188          \param d for the deflection
189         """
190         hyp = self.Hypothesis("Deflection1D", [d])
191         hyp.SetDeflection(d)
192         return hyp
193
194     def Propagation(self):
195         """
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
198         """
199         return self.Hypothesis("Propagation")
200
201 # Public class: Mesh_Segment_Python
202 # ---------------------------------
203
204 class Mesh_Segment_Python(Mesh_Segment):
205     """
206     Class to define a segment 1D algorithm for discretization with python function
207     """
208
209     def __init__(self, mesh, geom=0):
210         """
211          Private constructor
212         """
213         import Python1dPlugin
214         self.Create(mesh, geom, "Python_1D", "libPython1dEngine.so")
215
216     def PythonSplit1D(self, n, func):
217         """
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
221         """
222         hyp = self.Hypothesis("PythonSplit1D", [n], "libPython1dEngine.so")
223         hyp.SetNumberOfSegments(n)
224         hyp.SetPythonLog10RatioFunction(func)
225         return hyp
226
227 # Public class: Mesh_Triangle
228 # ---------------------------
229
230 class Mesh_Triangle(Mesh_Algorithm):
231     """
232     Class to define a triangle 2D algorithm
233     """
234
235     def __init__(self, mesh, geom=0):
236         """
237          Private constructor
238         """
239         self.Create(mesh, geom, "MEFISTO_2D")
240
241     def MaxElementArea(self, area):
242         """
243          Define "MaxElementArea" hypothesis to give the maximun area of each triangles
244          \param area for the maximum area of each triangles
245         """
246         hyp = self.Hypothesis("MaxElementArea", [area])
247         hyp.SetMaxElementArea(area)
248         return hyp
249
250     def LengthFromEdges(self):
251         """
252          Define "LengthFromEdges" hypothesis to build triangles based on the length of the edges taken from the wire
253         """
254         return self.Hypothesis("LengthFromEdges")
255
256 # Public class: Mesh_Quadrangle
257 # -----------------------------
258
259 class Mesh_Quadrangle(Mesh_Algorithm):
260     """
261     Class to define a quadrangle 2D algorithm
262     """
263
264     def __init__(self, mesh, geom=0):
265         """
266          Private constructor
267         """
268         self.Create(mesh, geom, "Quadrangle_2D")
269
270 # Public class: Mesh_Tetrahedron
271 # ------------------------------
272
273 class Mesh_Tetrahedron(Mesh_Algorithm):
274     """
275     Class to define a tetrahedron 3D algorithm
276     """
277
278     def __init__(self, mesh, algo, geom=0):
279         """
280          Private constructor
281         """
282         if algo == NETGEN:
283             self.Create(mesh, geom, "NETGEN_3D", "libNETGENEngine.so")
284         elif algo == GHS3D:
285             import GHS3DPlugin
286             self.Create(mesh, geom, "GHS3D_3D" , "libGHS3DEngine.so")
287
288     def MaxElementVolume(self, vol):
289         """
290          Define "MaxElementVolume" hypothesis to give the maximun volume of each tetrahedral
291          \param vol for the maximum volume of each tetrahedral
292         """
293         hyp = self.Hypothesis("MaxElementVolume", [vol])
294         hyp.SetMaxElementVolume(vol)
295         return hyp
296
297 # Public class: Mesh_Hexahedron
298 # ------------------------------
299
300 class Mesh_Hexahedron(Mesh_Algorithm):
301     """
302     Class to define a hexahedron 3D algorithm
303     """
304
305     def __init__(self, mesh, geom=0):
306         """
307          Private constructor
308         """
309         self.Create(mesh, geom, "Hexa_3D")
310
311 # Public class: Mesh
312 # ==================
313
314 class Mesh:
315     """
316     Class to define a mesh
317     """
318
319     geom = 0
320     mesh = 0
321
322     def __init__(self, geom, name=0):
323         """
324          Constructor
325
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
330         """
331         self.geom = geom
332         self.mesh = smesh.CreateMesh(geom)
333         if name == 0:
334             SetName(self.mesh, GetName(geom))
335         else:
336             SetName(self.mesh, name)
337
338     def GetMesh(self):
339         """
340          Method that returns the mesh
341         """
342         return self.mesh
343
344     def GetShape(self):
345         """
346          Method that returns the shape associated to the mesh
347         """
348         return self.geom
349
350     def Segment(self, algo=REGULAR, geom=0):
351         """
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
358         """
359         if algo == REGULAR:
360             return Mesh_Segment(self, geom)
361         elif algo == PYTHON:
362             return Mesh_Segment_Python(self, geom)
363         else:
364             return Mesh_Segment(self, algo)
365
366     def Triangle(self, geom=0):
367         """
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
372         """
373         return Mesh_Triangle(self, geom)
374
375     def Quadrangle(self, geom=0):
376         """
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
381         """
382         return Mesh_Quadrangle(self, geom)
383
384     def Tetrahedron(self, algo, geom=0):
385         """
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
392         """
393         return Mesh_Tetrahedron(self, algo, geom)
394
395     def Hexahedron(self, geom=0):
396         """
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
401         """
402         return Mesh_Hexahedron(self, geom)
403
404     def Compute(self):
405         """
406          Compute the mesh and return the status of the computation
407         """
408         b = smesh.Compute(self.mesh, self.geom)
409         if salome.sg.hasDesktop():
410             salome.sg.updateObjBrowser(1)
411         return b
412
413     def Group(self, grp, name=""):
414         """
415          Create a mesh group based on geometric object \a grp
416          and give a \a name, if this parameter is not defined
417          the name is the same as the geometric group name
418          \param grp  is a geometric group, a vertex, an edge, a face or a solid
419          \param name is the name of the mesh group
420         """
421         if name == "":
422             name = grp.GetName()
423
424         type = []
425         tgeo = str(grp.GetShapeType())
426         if tgeo == "VERTEX":
427             type = SMESH.NODE
428         elif tgeo == "EDGE":
429             type = SMESH.EDGE
430         elif tgeo == "FACE":
431             type = SMESH.FACE
432         elif tgeo == "SOLID":
433             type = SMESH.VOLUME
434         elif tgeo == "COMPOUND":
435             tgeo = geompy.GetType(grp)
436             if tgeo == geompy.ShapeType["VERTEX"]:
437                 type = SMESH.NODE
438             elif tgeo == geompy.ShapeType["EDGE"]:
439                 type = SMESH.EDGE
440             elif tgeo == geompy.ShapeType["FACE"]:
441                 type = SMESH.FACE
442             elif tgeo == geompy.ShapeType["SOLID"]:
443                 type = SMESH.VOLUME
444
445         if type == []:
446             print "Mesh.Group: bad first argument: expected a group, a vertex, an edge, a face or a solid"
447             return 0
448         else:
449             return self.mesh.CreateGroupFromGEOM(type, name, grp)
450
451     def ExportToMED(self, f, version, opt=0):
452         """
453          Export the mesh in a file with the MED format and choice the \a version of MED format
454          \param f is the file name
455          \param version values are smesh.MED_V2_1, smesh.MED_V2_2
456         """
457         self.mesh.ExportToMED(f, opt, version)
458
459     def ExportMED(self, f, opt=0):
460         """
461          Export the mesh in a file with the MED format
462          \param f is the file name
463         """
464         self.mesh.ExportMED(f, opt)
465
466     def ExportDAT(self, f):
467         """
468          Export the mesh in a file with the DAT format
469          \param f is the file name
470         """
471         self.mesh.ExportDAT(f)
472
473     def ExportUNV(self, f):
474         """
475          Export the mesh in a file with the UNV format
476          \param f is the file name
477         """
478         self.mesh.ExportUNV(f)
479
480     def ExportSTL(self, f, ascii=1):
481         """
482          Export the mesh in a file with the STL format
483          \param f is the file name
484          \param ascii defined the kind of file contents
485         """
486         self.mesh.ExportSTL(f, ascii)