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)