src/NETGENPlugin/NETGENPluginBuilder.py

   1 # Copyright (C) 2007-2015  CEA/DEN, EDF R&D, OPEN CASCADE
   2 #
   3 # This library is free software; you can redistribute it and/or
   4 # modify it under the terms of the GNU Lesser General Public
   5 # License as published by the Free Software Foundation; either
   6 # version 2.1 of the License, or (at your option) any later version.
   7 #
   8 # This library is distributed in the hope that it will be useful,
   9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 # Lesser General Public License for more details.
  12 #
  13 # You should have received a copy of the GNU Lesser General Public
  14 # License along with this library; if not, write to the Free Software
  15 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 #
  17 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 #
  19
  20 ##
  21 # @package NETGENPluginBuilder
  22 # Python API for the NETGEN meshing plug-in module.
  23
  24 from salome.smesh.smesh_algorithm import Mesh_Algorithm
  25 from salome.smesh.smeshBuilder import AssureGeomPublished, ParseParameters, IsEqual
  26
  27 # import NETGENPlugin module if possible
  28 noNETGENPlugin = 0
  29 try:
  30     import NETGENPlugin
  31 except ImportError:
  32     noNETGENPlugin = 1
  33     pass
  34
  35 LIBRARY = "libNETGENEngine.so"
  36
  37 #----------------------------
  38 # Mesh algo type identifiers
  39 #----------------------------
  40
  41 ## Algorithm type: Netgen tetrahedron 3D algorithm, see NETGEN_3D_Algorithm
  42 NETGEN_3D     = "NETGEN_3D"
  43 ## Algorithm type: Netgen tetrahedron 1D-2D-3D algorithm, see NETGEN_1D2D3D_Algorithm
  44 NETGEN_1D2D3D = "NETGEN_2D3D"
  45 ## Algorithm type: Netgen triangle 1D-2D algorithm, see NETGEN_1D2D_Algorithm
  46 NETGEN_1D2D   = "NETGEN_2D"
  47 ## Algorithm type: Netgen triangle 2D algorithm, see NETGEN_2D_Only_Algorithm
  48 NETGEN_2D     = "NETGEN_2D_ONLY"
  49 ## Algorithm type: Synonim of NETGEN_1D2D3D, see NETGEN_1D2D3D_Algorithm
  50 NETGEN_FULL   = NETGEN_1D2D3D
  51 ## Algorithm type: Synonim of NETGEN_3D, see NETGEN_3D_Algorithm
  52 NETGEN        = NETGEN_3D
  53 ## Algorithm type: Synonim of NETGEN_1D2D3D, see NETGEN_1D2D3D_Algorithm
  54 FULL_NETGEN   = NETGEN_FULL
  55
  56 #----------------------------
  57 # Hypothesis type enumeration
  58 #----------------------------
  59
  60 ## Hypothesis type enumeration: complex hypothesis
  61 #  (full set of parameters can be specified),
  62 #  see NETGEN_Algorithm.Parameters()
  63 SOLE   = 0
  64 ## Hypothesis type enumeration: simple hypothesis
  65 #  (only major parameters are specified),
  66 #  see NETGEN_Algorithm.Parameters()
  67 SIMPLE = 1
  68
  69 #----------------------
  70 # Fineness enumeration
  71 #----------------------
  72
  73 ## Fineness enumeration: very coarse quality of mesh,
  74 #  see NETGEN_Algorithm.SetFineness()
  75 VeryCoarse = 0
  76 ## Fineness enumeration: coarse quality of mesh,
  77 #  see NETGEN_Algorithm.SetFineness()
  78 Coarse     = 1
  79 ## Fineness enumeration: moderate quality of mesh,
  80 #  see NETGEN_Algorithm.SetFineness()
  81 Moderate   = 2
  82 ## Fineness enumeration: fine quality of mesh,
  83 #  see NETGEN_Algorithm.SetFineness()
  84 Fine       = 3
  85 ## Fineness enumeration: very fine quality of mesh,
  86 #  see NETGEN_Algorithm.SetFineness()
  87 VeryFine   = 4
  88 ## Fineness enumeration: custom quality of mesh specified by other parameters),
  89 #  see NETGEN_Algorithm.SetFineness()
  90 Custom     = 5
  91
  92 #----------------------
  93 # Algorithms
  94 #----------------------
  95
  96 ## Base of all NETGEN algorithms.
  97 #
  98 #  This class provides common methods for all algorithms implemented by NETGEN plugin.
  99 #  @note This class must not be instantiated directly.
 100 class NETGEN_Algorithm(Mesh_Algorithm):
 101
 102     ## Private constructor
 103     #  @param mesh parent mesh object algorithm is assigned to
 104     #  @param geom geometry (shape/sub-shape) algorithm is assigned to;
 105     #              if it is @c 0 (default), the algorithm is assigned to the main shape
 106     def __init__(self, mesh, geom=0):
 107         Mesh_Algorithm.__init__(self)
 108         if noNETGENPlugin: print "Warning: NETGENPlugin module unavailable"
 109         self.Create(mesh, geom, self.algoType, LIBRARY)
 110         self.params = None
 111         pass
 112
 113     ## Sets @c MaxSize parameter
 114     #  @param theSize new value of the @c MaxSize parameter
 115     def SetMaxSize(self, theSize):
 116         if self.Parameters(): self.params.SetMaxSize(theSize)
 117         pass
 118
 119     ## Sets @c MinSize parameter
 120     #  @param theSize new value of the @c MinSize parameter
 121     def SetMinSize(self, theSize):
 122         if self.Parameters(): self.params.SetMinSize(theSize)
 123         pass
 124
 125     ## Sets @c Optimize flag
 126     #  @param theVal new value of the @c Optimize parameter
 127     def SetOptimize(self, theVal):
 128         if self.Parameters(): self.params.SetOptimize(theVal)
 129         pass
 130
 131     ## Sets @c Fineness parameter
 132     #  @param theFineness new value of the @c Fineness parameter; it can be:
 133     #  @ref VeryCoarse, @ref Coarse, @ref Moderate, @ref Fine, @ref VeryFine or @ref Custom
 134     def SetFineness(self, theFineness):
 135         if self.Parameters(): self.params.SetFineness(theFineness)
 136         pass
 137
 138     ## Sets @c GrowthRate parameter
 139     #  @param theRate new value of the @c GrowthRate parameter
 140     def SetGrowthRate(self, theRate):
 141         if self.Parameters(): self.params.SetGrowthRate(theRate)
 142         pass
 143
 144     ## Creates meshing hypothesis according to the chosen algorithm type
 145     #  and initializes it with default parameters
 146     #  @param which hypothesis type; can be either @ref SOLE (default) or @ref SIMPLE
 147     #  @return hypothesis object
 148     def Parameters(self, which=SOLE):
 149         if self.algoType == NETGEN_1D2D:
 150             if which == SIMPLE:
 151                 hypType = "NETGEN_SimpleParameters_2D"
 152             else:
 153                 hypType = "NETGEN_Parameters_2D"
 154         elif self.algoType == NETGEN_1D2D3D:
 155             if which == SIMPLE:
 156                 hypType = "NETGEN_SimpleParameters_3D"
 157             else:
 158                 hypType = "NETGEN_Parameters"
 159         elif self.algoType == NETGEN_2D:
 160             hypType = "NETGEN_Parameters_2D_ONLY"
 161         else:
 162             hypType = "NETGEN_Parameters_3D"
 163
 164         if self.params and self.params.GetName() != hypType:
 165             self.mesh.RemoveHypothesis( self.params, self.geom )
 166             self.params = None
 167         if not self.params:
 168             self.params = self.Hypothesis(hypType, [], LIBRARY, UseExisting=0)
 169
 170         return self.params
 171
 172     pass # end of NETGEN_Algorithm class
 173
 174
 175 ## Tetrahedron 1D-2D-3D algorithm.
 176 #
 177 #  It can be created by calling smeshBuilder.Mesh.Tetrahedron( smeshBuilder.NETGEN_1D2D3D, geom=0 ).
 178 #  This algorithm generates all 1D (edges), 2D (faces) and 3D (volumes) elements
 179 #  for given geometrical shape.
 180 class NETGEN_1D2D3D_Algorithm(NETGEN_Algorithm):
 181
 182     ## name of the dynamic method in smeshBuilder.Mesh class
 183     #  @internal
 184     meshMethod = "Tetrahedron"
 185     ## type of algorithm used with helper function in smeshBuilder.Mesh class
 186     #  @internal
 187     algoType   = NETGEN_1D2D3D
 188     ## doc string of the method
 189     #  @internal
 190     docHelper  = "Creates tetrahedron 3D algorithm for solids"
 191
 192     ## Private constructor.
 193     #  @param mesh parent mesh object algorithm is assigned to
 194     #  @param geom geometry (shape/sub-shape) algorithm is assigned to;
 195     #              if it is @c 0 (default), the algorithm is assigned to the main shape
 196     def __init__(self, mesh, geom=0):
 197         NETGEN_Algorithm.__init__(self, mesh, geom)
 198         pass
 199
 200     ## Sets @c SecondOrder flag
 201     #  @param theVal new value of the @c SecondOrder parameter
 202     def SetSecondOrder(self, theVal):
 203         if self.Parameters(): self.params.SetSecondOrder(theVal)
 204         pass
 205
 206     ## Sets @c NbSegPerEdge parameter
 207     #  @param theVal new value of the @c NbSegPerEdge parameter
 208     def SetNbSegPerEdge(self, theVal):
 209         if self.Parameters(): self.params.SetNbSegPerEdge(theVal)
 210         pass
 211
 212     ## Sets @c NbSegPerRadius parameter
 213     #  @param theVal new value of the @c NbSegPerRadius parameter
 214     def SetNbSegPerRadius(self, theVal):
 215         if self.Parameters(): self.params.SetNbSegPerRadius(theVal)
 216         pass
 217
 218     ## Sets @c QuadAllowed flag
 219     #  @param toAllow new value of the @c QuadAllowed parameter (@c True by default)
 220     def SetQuadAllowed(self, toAllow=True):
 221         if self.Parameters(): self.params.SetQuadAllowed(toAllow)
 222         pass
 223     ## Sets @c UseSurfaceCurvature flag
 224     #  @param toUse new value of the @c UseSurfaceCurvature parameter (@c True by default)
 225     def SetUseSurfaceCurvature(self, toUse=True):
 226         if self.Parameters(): self.params.SetUseSurfaceCurvature(toUse)
 227         pass
 228     ## Sets @c FuseEdges flag
 229     #  @param toFuse new value of the @c FuseEdges parameter (@c False by default)
 230     def SetFuseEdges(self, toFuse=False):
 231         if self.Parameters(): self.params.SetFuseEdges(toFuse)
 232         pass
 233
 234     ## Sets number of segments overriding the value set by SetLocalLength()
 235     #  @param theVal new value of number of segments parameter
 236     def SetNumberOfSegments(self, theVal):
 237         self.Parameters(SIMPLE).SetNumberOfSegments(theVal)
 238         pass
 239
 240     ## Sets number of segments overriding the value set by SetNumberOfSegments()
 241     #  @param theVal new value of local length parameter
 242     def SetLocalLength(self, theVal):
 243         self.Parameters(SIMPLE).SetLocalLength(theVal)
 244         pass
 245
 246     ## Defines @c MaxElementArea parameter of @c NETGEN_SimpleParameters_3D hypothesis.
 247     #  Overrides value set by LengthFromEdges()
 248     #  @param area new value of @c MaxElementArea parameter
 249     def MaxElementArea(self, area):
 250         self.Parameters(SIMPLE).SetMaxElementArea(area)
 251         pass
 252
 253     ## Defines @c LengthFromEdges parameter of @c NETGEN_SimpleParameters_3D hypothesis.
 254     #  Overrides value set by MaxElementArea()
 255     def LengthFromEdges(self):
 256         self.Parameters(SIMPLE).LengthFromEdges()
 257         pass
 258
 259     ## Defines @c LengthFromFaces parameter of @c NETGEN_SimpleParameters_3D hypothesis.
 260     #  Overrides value set by MaxElementVolume()
 261     def LengthFromFaces(self):
 262         self.Parameters(SIMPLE).LengthFromFaces()
 263         pass
 264
 265     ## Defines @c MaxElementVolume parameter of @c NETGEN_SimpleParameters_3D hypothesis.
 266     #  Overrides value set by LengthFromFaces()
 267     #  @param vol new value of @c MaxElementVolume parameter
 268     def MaxElementVolume(self, vol):
 269         self.Parameters(SIMPLE).SetMaxElementVolume(vol)
 270         pass
 271
 272     pass # end of NETGEN_1D2D3D_Algorithm class
 273
 274
 275 ## Triangle NETGEN 1D-2D algorithm.
 276 #
 277 #  It can be created by calling smeshBuilder.Mesh.Triangle( smeshBuilder.NETGEN_1D2D, geom=0 )
 278 #
 279 #  This algorithm generates 1D (edges) and 2D (faces) elements
 280 #  for given geometrical shape.
 281 class NETGEN_1D2D_Algorithm(NETGEN_1D2D3D_Algorithm):
 282
 283     ## name of the dynamic method in smeshBuilder.Mesh class
 284     #  @internal
 285     meshMethod = "Triangle"
 286     ## type of algorithm used with helper function in smeshBuilder.Mesh class
 287     #  @internal
 288     algoType   = NETGEN_1D2D
 289     ## doc string of the method
 290     #  @internal
 291     docHelper  = "Creates triangle 2D algorithm for faces"
 292
 293     ## Private constructor.
 294     #  @param mesh parent mesh object algorithm is assigned to
 295     #  @param geom geometry (shape/sub-shape) algorithm is assigned to;
 296     #              if it is @c 0 (default), the algorithm is assigned to the main shape
 297     def __init__(self, mesh, geom=0):
 298         NETGEN_1D2D3D_Algorithm.__init__(self, mesh, geom)
 299         pass
 300
 301     pass # end of NETGEN_1D2D_Algorithm class
 302
 303
 304 ## Triangle NETGEN 2D algorithm
 305 #
 306 #  It can be created by calling smeshBuilder.Mesh.Triangle( smeshBuilder.NETGEN_2D, geom=0 )
 307 #
 308 #  This algorithm generates only 2D (faces) elements for given geometrical shape
 309 #  and, in contrast to NETGEN_1D2D_Algorithm class, should be used in conjunction
 310 #  with other 1D meshing algorithm.
 311 class NETGEN_2D_Only_Algorithm(NETGEN_Algorithm):
 312
 313     ## name of the dynamic method in smeshBuilder.Mesh class
 314     #  @internal
 315     meshMethod = "Triangle"
 316     ## type of algorithm used with helper function in smeshBuilder.Mesh class
 317     #  @internal
 318     algoType = NETGEN_2D
 319     ## doc string of the method
 320     #  @internal
 321     docHelper  = "Creates triangle 2D algorithm for faces"
 322
 323     ## Private constructor.
 324     #  @param mesh parent mesh object algorithm is assigned to
 325     #  @param geom geometry (shape/sub-shape) algorithm is assigned to;
 326     #              if it is @c 0 (default), the algorithm is assigned to the main shape
 327     def __init__(self, mesh, geom=0):
 328         NETGEN_Algorithm.__init__(self, mesh, geom)
 329         pass
 330
 331     ## Defines @c MaxElementArea parameter of hypothesis basing on the definition of the
 332     #  maximum area of each triangle
 333     #  @param area maximum area value of each triangle
 334     #  @param UseExisting if \c True - searches for an existing hypothesis created with the
 335     #                     same parameters, else (default) - creates a new one
 336     #  @return hypothesis object
 337     def MaxElementArea(self, area, UseExisting=0):
 338         compFun = lambda hyp, args: IsEqual(hyp.GetMaxElementArea(), args[0])
 339         hyp = self.Hypothesis("MaxElementArea", [area], UseExisting=UseExisting,
 340                               CompareMethod=compFun)
 341         hyp.SetMaxElementArea(area)
 342         return hyp
 343
 344     ## Defines @c LengthFromEdges hypothesis to build triangles
 345     #  based on the length of the edges taken from the wire
 346     #  @return hypothesis object
 347     def LengthFromEdges(self):
 348         hyp = self.Hypothesis("LengthFromEdges", UseExisting=1, CompareMethod=self.CompareEqualHyp)
 349         return hyp
 350
 351     ## Sets @c UseSurfaceCurvature flag
 352     #  @param toUse new value of the @c UseSurfaceCurvature parameter (@c True by default)
 353     def SetUseSurfaceCurvature(self, toUse=True):
 354         if self.Parameters(): self.params.SetUseSurfaceCurvature(toUse)
 355         pass
 356
 357     ## Sets @c QuadAllowed flag.
 358     #  @param toAllow new value of the @c QuadAllowed parameter (@c True by default)
 359     #  @return hypothesis object
 360     def SetQuadAllowed(self, toAllow=True):
 361         if not self.params:
 362             # use simple hyps
 363             hasSimpleHyps = False
 364             simpleHyps = ["QuadranglePreference","LengthFromEdges","MaxElementArea"]
 365             for hyp in self.mesh.GetHypothesisList( self.geom ):
 366                 if hyp.GetName() in simpleHyps:
 367                     hasSimpleHyps = True
 368                     if hyp.GetName() == "QuadranglePreference":
 369                         if not toAllow: # remove QuadranglePreference
 370                             self.mesh.RemoveHypothesis( self.geom, hyp )
 371                         else:
 372                             return hyp
 373                         return None
 374                     pass
 375                 pass
 376             if hasSimpleHyps:
 377                 if toAllow: # add QuadranglePreference
 378                     return self.Hypothesis("QuadranglePreference", UseExisting=1, CompareMethod=self.CompareEqualHyp)
 379                 return None
 380             pass
 381         self.Parameters().SetQuadAllowed( toAllow )
 382         return self.params
 383
 384     pass # end of NETGEN_2D_Only_Algorithm class
 385
 386
 387 ## Tetrahedron 3D algorithm
 388 #
 389 #  It can be created by calling smeshBuilder.Mesh.Tetrahedron() or smeshBuilder.Mesh.Tetrahedron( smeshBuilder.NETGEN, geom=0 )
 390 #
 391 #  This algorithm generates only 3D (volumes) elements for given geometrical shape
 392 #  and, in contrast to NETGEN_1D2D3D_Algorithm class, should be used in conjunction
 393 #  with other 1D and 2D meshing algorithms.
 394 class NETGEN_3D_Algorithm(NETGEN_Algorithm):
 395
 396     ## name of the dynamic method in smeshBuilder.Mesh class
 397     #  @internal
 398     meshMethod = "Tetrahedron"
 399     ## type of algorithm used with helper function in smeshBuilder.Mesh class
 400     #  @internal
 401     algoType   = NETGEN
 402     ## flag pointing either this algorithm should be used by default in dynamic method
 403     #  of smeshBuilder.Mesh class
 404     #  @internal
 405     isDefault  = True
 406     ## doc string of the method
 407     #  @internal
 408     docHelper  = "Creates tetrahedron 3D algorithm for solids"
 409
 410     ## Private constructor.
 411     #  @param mesh parent mesh object algorithm is assigned to
 412     #  @param geom geometry (shape/sub-shape) algorithm is assigned to;
 413     #              if it is @c 0 (default), the algorithm is assigned to the main shape
 414     def __init__(self, mesh, geom=0):
 415         NETGEN_Algorithm.__init__(self, mesh, geom)
 416         pass
 417
 418     ## Defines @c MaxElementVolume hypothesis to specify the maximum volume value of each tetrahedron
 419     #  @param vol maximum volume value of each tetrahedron
 420     #  @param UseExisting if \c True - searches for the existing hypothesis created with
 421     #                   the same parameters, else (default) - creates a new one
 422     #  @return hypothesis object
 423     def MaxElementVolume(self, vol, UseExisting=0):
 424         compFun = lambda hyp, args: IsEqual(hyp.GetMaxElementVolume(), args[0])
 425         hyp = self.Hypothesis("MaxElementVolume", [vol], UseExisting=UseExisting,
 426                               CompareMethod=compFun)
 427         hyp.SetMaxElementVolume(vol)
 428         return hyp
 429
 430     pass # end of NETGEN_3D_Algorithm class
 431
 432
 433 ## Triangle (helper) 1D-2D algorithm
 434 #
 435 #  This is the helper class that is used just to allow creating of create NETGEN_1D2D algorithm
 436 #  by calling smeshBuilder.Mesh.Triangle( smeshBuilder.NETGEN, geom=0 ); this is required for backward compatibility
 437 #  with old Python scripts.
 438 #
 439 #  @note This class (and corresponding smeshBuilder.Mesh function) is obsolete;
 440 #  use smeshBuilder.Mesh.Triangle( smeshBuilder.NETGEN_1D2D, geom=0 ) instead.
 441 class NETGEN_1D2D_Algorithm_2(NETGEN_1D2D_Algorithm):
 442
 443     ## name of the dynamic method in smeshBuilder.Mesh class
 444     #  @internal
 445     algoType = NETGEN
 446
 447     ## Private constructor.
 448     #  @param mesh parent mesh object algorithm is assigned to
 449     #  @param geom geometry (shape/sub-shape) algorithm is assigned to;
 450     #              if it is @c 0 (default), the algorithm is assigned to the main shape
 451     def __init__(self, mesh, geom=0):
 452         self.algoType = NETGEN_1D2D
 453         NETGEN_1D2D_Algorithm.__init__(self,mesh, geom)
 454         pass
 455
 456     pass # end of NETGEN_1D2D_Algorithm_2 class
 457
 458
 459 ## Tetrahedron (helper) 1D-2D-3D algorithm.
 460 #
 461 #  This is the helper class that is used just to allow creating of create NETGEN_1D2D3D
 462 #  by calling smeshBuilder.Mesh.Netgen(); this is required for backward compatibility with old Python scripts.
 463 #
 464 #  @note This class (and corresponding smeshBuilder.Mesh function) is obsolete;
 465 #  use smeshBuilder.Mesh.Tetrahedron( smeshBuilder.NETGEN_1D2D3D, geom=0 ) instead.
 466 class NETGEN_1D2D3D_Algorithm_2(NETGEN_1D2D3D_Algorithm):
 467
 468     ## name of the dynamic method in smeshBuilder.Mesh class
 469     #  @internal
 470     meshMethod = "Netgen"
 471     ## doc string of the method
 472     #  @internal
 473     docHelper  = "Deprecated, used only for compatibility! See Tetrahedron() method."
 474
 475     ## Private constructor.
 476     #  @param mesh parent mesh object algorithm is assigned to
 477     #  @param geom geometry (shape/sub-shape) algorithm is assigned to;
 478     #              if it is @c 0 (default), the algorithm is assigned to the main shape
 479     def __init__(self, mesh, geom=0):
 480         NETGEN_1D2D3D_Algorithm.__init__(self,mesh, geom)
 481         pass
 482
 483     pass # end of NETGEN_1D2D3D_Algorithm_2 class