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.SetDistrType( 1 )
 160             hyp.SetScaleFactor(s)
 161         hyp.SetNumberOfSegments(n)
 162         return hyp
 163
 164     def Arithmetic1D(self, start, end):
 165         """
 166          Define "Arithmetic1D" hypothesis to cut an edge in several segments with arithmetic length increasing
 167          \param start for the length of the first segment
 168          \param end   for the length of the last  segment
 169         """
 170         hyp = self.Hypothesis("Arithmetic1D", [start, end])
 171         hyp.SetLength(start, 1)
 172         hyp.SetLength(end  , 0)
 173         return hyp
 174
 175     def StartEndLength(self, start, end):
 176         """
 177          Define "StartEndLength" hypothesis to cut an edge in several segments with geometric length increasing
 178          \param start for the length of the first segment
 179          \param end   for the length of the last  segment
 180         """
 181         hyp = self.Hypothesis("StartEndLength", [start, end])
 182         hyp.SetLength(start, 1)
 183         hyp.SetLength(end  , 0)
 184         return hyp
 185
 186     def Deflection1D(self, d):
 187         """
 188          Define "Deflection1D" hypothesis
 189          \param d for the deflection
 190         """
 191         hyp = self.Hypothesis("Deflection1D", [d])
 192         hyp.SetDeflection(d)
 193         return hyp
 194
 195     def Propagation(self):
 196         """
 197          Define "Propagation" hypothesis that propagate all other hypothesis on all others edges that are in
 198          the opposite side in the case of quadrangular faces
 199         """
 200         return self.Hypothesis("Propagation")
 201
 202 # Public class: Mesh_Segment_Python
 203 # ---------------------------------
 204
 205 class Mesh_Segment_Python(Mesh_Segment):
 206     """
 207     Class to define a segment 1D algorithm for discretization with python function
 208     """
 209
 210     def __init__(self, mesh, geom=0):
 211         """
 212          Private constructor
 213         """
 214         import Python1dPlugin
 215         self.Create(mesh, geom, "Python_1D", "libPython1dEngine.so")
 216
 217     def PythonSplit1D(self, n, func):
 218         """
 219          Define "PythonSplit1D" hypothesis based on the Erwan Adam patch, awaiting equivalent SALOME functionality
 220          \param n for the number of segments that cut an edge
 221          \param func for the python function that calculate the length of all segments
 222         """
 223         hyp = self.Hypothesis("PythonSplit1D", [n], "libPython1dEngine.so")
 224         hyp.SetNumberOfSegments(n)
 225         hyp.SetPythonLog10RatioFunction(func)
 226         return hyp
 227
 228 # Public class: Mesh_Triangle
 229 # ---------------------------
 230
 231 class Mesh_Triangle(Mesh_Algorithm):
 232     """
 233     Class to define a triangle 2D algorithm
 234     """
 235
 236     def __init__(self, mesh, geom=0):
 237         """
 238          Private constructor
 239         """
 240         self.Create(mesh, geom, "MEFISTO_2D")
 241
 242     def MaxElementArea(self, area):
 243         """
 244          Define "MaxElementArea" hypothesis to give the maximun area of each triangles
 245          \param area for the maximum area of each triangles
 246         """
 247         hyp = self.Hypothesis("MaxElementArea", [area])
 248         hyp.SetMaxElementArea(area)
 249         return hyp
 250
 251     def LengthFromEdges(self):
 252         """
 253          Define "LengthFromEdges" hypothesis to build triangles based on the length of the edges taken from the wire
 254         """
 255         return self.Hypothesis("LengthFromEdges")
 256
 257 # Public class: Mesh_Quadrangle
 258 # -----------------------------
 259
 260 class Mesh_Quadrangle(Mesh_Algorithm):
 261     """
 262     Class to define a quadrangle 2D algorithm
 263     """
 264
 265     def __init__(self, mesh, geom=0):
 266         """
 267          Private constructor
 268         """
 269         self.Create(mesh, geom, "Quadrangle_2D")
 270
 271 # Public class: Mesh_Tetrahedron
 272 # ------------------------------
 273
 274 class Mesh_Tetrahedron(Mesh_Algorithm):
 275     """
 276     Class to define a tetrahedron 3D algorithm
 277     """
 278
 279     def __init__(self, mesh, algo, geom=0):
 280         """
 281          Private constructor
 282         """
 283         if algo == NETGEN:
 284             self.Create(mesh, geom, "NETGEN_3D", "libNETGENEngine.so")
 285         elif algo == GHS3D:
 286             import GHS3DPlugin
 287             self.Create(mesh, geom, "GHS3D_3D" , "libGHS3DEngine.so")
 288
 289     def MaxElementVolume(self, vol):
 290         """
 291          Define "MaxElementVolume" hypothesis to give the maximun volume of each tetrahedral
 292          \param vol for the maximum volume of each tetrahedral
 293         """
 294         hyp = self.Hypothesis("MaxElementVolume", [vol])
 295         hyp.SetMaxElementVolume(vol)
 296         return hyp
 297
 298 # Public class: Mesh_Hexahedron
 299 # ------------------------------
 300
 301 class Mesh_Hexahedron(Mesh_Algorithm):
 302     """
 303     Class to define a hexahedron 3D algorithm
 304     """
 305
 306     def __init__(self, mesh, geom=0):
 307         """
 308          Private constructor
 309         """
 310         self.Create(mesh, geom, "Hexa_3D")
 311
 312 # Public class: Mesh
 313 # ==================
 314
 315 class Mesh:
 316     """
 317     Class to define a mesh
 318     """
 319
 320     geom = 0
 321     mesh = 0
 322
 323     def __init__(self, geom, name=0):
 324         """
 325          Constructor
 326
 327          Creates mesh on the shape \a geom,
 328          sets GUI name of this mesh to \a name.
 329          \param geom Shape to be meshed
 330          \param name Study name of the mesh
 331         """
 332         self.geom = geom
 333         self.mesh = smesh.CreateMesh(geom)
 334         if name == 0:
 335             SetName(self.mesh, GetName(geom))
 336         else:
 337             SetName(self.mesh, name)
 338
 339     def GetMesh(self):
 340         """
 341          Method that returns the mesh
 342         """
 343         return self.mesh
 344
 345     def GetShape(self):
 346         """
 347          Method that returns the shape associated to the mesh
 348         """
 349         return self.geom
 350
 351     def Segment(self, algo=REGULAR, geom=0):
 352         """
 353          Creates a segment discretization 1D algorithm.
 354          If the optional \a algo parameter is not sets, this algorithm is REGULAR.
 355          If the optional \a geom parameter is not sets, this algorithm is global.
 356          Otherwise, this algorithm define a submesh based on \a geom subshape.
 357          \param algo values are smesh.REGULAR or smesh.PYTHON for discretization via python function
 358          \param geom If defined, subshape to be meshed
 359         """
 360         if algo == REGULAR:
 361             return Mesh_Segment(self, geom)
 362         elif algo == PYTHON:
 363             return Mesh_Segment_Python(self, geom)
 364         else:
 365             return Mesh_Segment(self, algo)
 366
 367     def Triangle(self, geom=0):
 368         """
 369          Creates a triangle 2D algorithm for faces.
 370          If the optional \a geom parameter is not sets, this algorithm is global.
 371          Otherwise, this algorithm define a submesh based on \a geom subshape.
 372          \param geom If defined, subshape to be meshed
 373         """
 374         return Mesh_Triangle(self, geom)
 375
 376     def Quadrangle(self, geom=0):
 377         """
 378          Creates a quadrangle 2D algorithm for faces.
 379          If the optional \a geom parameter is not sets, this algorithm is global.
 380          Otherwise, this algorithm define a submesh based on \a geom subshape.
 381          \param geom If defined, subshape to be meshed
 382         """
 383         return Mesh_Quadrangle(self, geom)
 384
 385     def Tetrahedron(self, algo, geom=0):
 386         """
 387          Creates a tetrahedron 3D algorithm for solids.
 388          The parameter \a algo permits to choice the algorithm: NETGEN or GHS3D
 389          If the optional \a geom parameter is not sets, this algorithm is global.
 390          Otherwise, this algorithm define a submesh based on \a geom subshape.
 391          \param algo values are: smesh.NETGEN, smesh.GHS3D
 392          \param geom If defined, subshape to be meshed
 393         """
 394         return Mesh_Tetrahedron(self, algo, geom)
 395
 396     def Hexahedron(self, geom=0):
 397         """
 398          Creates a hexahedron 3D algorithm for solids.
 399          If the optional \a geom parameter is not sets, this algorithm is global.
 400          Otherwise, this algorithm define a submesh based on \a geom subshape.
 401          \param geom If defined, subshape to be meshed
 402         """
 403         return Mesh_Hexahedron(self, geom)
 404
 405     def Compute(self):
 406         """
 407          Compute the mesh and return the status of the computation
 408         """
 409         b = smesh.Compute(self.mesh, self.geom)
 410         if salome.sg.hasDesktop():
 411             smeshgui = salome.ImportComponentGUI("SMESH")
 412             smeshgui.Init(salome.myStudyId)
 413             smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), b )
 414             salome.sg.updateObjBrowser(1)
 415         return b
 416
 417     def Group(self, grp, name=""):
 418         """
 419          Create a mesh group based on geometric object \a grp
 420          and give a \a name, if this parameter is not defined
 421          the name is the same as the geometric group name
 422          \param grp  is a geometric group, a vertex, an edge, a face or a solid
 423          \param name is the name of the mesh group
 424         """
 425         if name == "":
 426             name = grp.GetName()
 427
 428         type = []
 429         tgeo = str(grp.GetShapeType())
 430         if tgeo == "VERTEX":
 431             type = SMESH.NODE
 432         elif tgeo == "EDGE":
 433             type = SMESH.EDGE
 434         elif tgeo == "FACE":
 435             type = SMESH.FACE
 436         elif tgeo == "SOLID":
 437             type = SMESH.VOLUME
 438         elif tgeo == "SHELL":
 439             type = SMESH.VOLUME
 440         elif tgeo == "COMPOUND":
 441             tgeo = geompy.GetType(grp)
 442             if tgeo == geompy.ShapeType["VERTEX"]:
 443                 type = SMESH.NODE
 444             elif tgeo == geompy.ShapeType["EDGE"]:
 445                 type = SMESH.EDGE
 446             elif tgeo == geompy.ShapeType["FACE"]:
 447                 type = SMESH.FACE
 448             elif tgeo == geompy.ShapeType["SOLID"]:
 449                 type = SMESH.VOLUME
 450
 451         if type == []:
 452             print "Mesh.Group: bad first argument: expected a group, a vertex, an edge, a face or a solid"
 453             return 0
 454         else:
 455             return self.mesh.CreateGroupFromGEOM(type, name, grp)
 456
 457     def ExportToMED(self, f, version, opt=0):
 458         """
 459          Export the mesh in a file with the MED format and choice the \a version of MED format
 460          \param f is the file name
 461          \param version values are smesh.MED_V2_1, smesh.MED_V2_2
 462         """
 463         self.mesh.ExportToMED(f, opt, version)
 464
 465     def ExportMED(self, f, opt=0):
 466         """
 467          Export the mesh in a file with the MED format
 468          \param f is the file name
 469         """
 470         self.mesh.ExportMED(f, opt)
 471
 472     def ExportDAT(self, f):
 473         """
 474          Export the mesh in a file with the DAT format
 475          \param f is the file name
 476         """
 477         self.mesh.ExportDAT(f)
 478
 479     def ExportUNV(self, f):
 480         """
 481          Export the mesh in a file with the UNV format
 482          \param f is the file name
 483         """
 484         self.mesh.ExportUNV(f)
 485
 486     def ExportSTL(self, f, ascii=1):
 487         """
 488          Export the mesh in a file with the STL format
 489          \param f is the file name
 490          \param ascii defined the kind of file contents
 491         """
 492         self.mesh.ExportSTL(f, ascii)