1 # Copyright (C) 2007-2021 CEA/DEN, EDF R&D, OPEN CASCADE
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.
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.
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
17 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 # @package NETGENPluginBuilder
22 # Python API for the NETGEN meshing plug-in module.
24 from salome.smesh.smesh_algorithm import Mesh_Algorithm
25 from salome.smesh.smeshBuilder import AssureGeomPublished, ParseParameters, IsEqual
27 # import NETGENPlugin module if possible
35 LIBRARY = "libNETGENEngine.so"
37 #----------------------------
38 # Mesh algo type identifiers
39 #----------------------------
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
53 ## Algorithm type: Synonim of NETGEN_1D2D3D, see NETGEN_1D2D3D_Algorithm
54 FULL_NETGEN = NETGEN_FULL
56 #----------------------------
57 # Hypothesis type enumeration
58 #----------------------------
60 ## Hypothesis type enumeration: complex hypothesis
61 # (full set of parameters can be specified),
62 # see NETGEN_Algorithm.Parameters()
64 ## Hypothesis type enumeration: simple hypothesis
65 # (only major parameters are specified),
66 # see NETGEN_Algorithm.Parameters()
69 #----------------------
70 # Fineness enumeration
71 #----------------------
73 ## Fineness enumeration: very coarse quality of mesh,
74 # see NETGEN_Algorithm.SetFineness()
76 ## Fineness enumeration: coarse quality of mesh,
77 # see NETGEN_Algorithm.SetFineness()
79 ## Fineness enumeration: moderate quality of mesh,
80 # see NETGEN_Algorithm.SetFineness()
82 ## Fineness enumeration: fine quality of mesh,
83 # see NETGEN_Algorithm.SetFineness()
85 ## Fineness enumeration: very fine quality of mesh,
86 # see NETGEN_Algorithm.SetFineness()
88 ## Fineness enumeration: custom quality of mesh specified by other parameters),
89 # see NETGEN_Algorithm.SetFineness()
92 #----------------------
94 #----------------------
96 ## Base of all NETGEN algorithms.
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):
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 if not mesh.GetMesh().HasShapeToMesh() and \
110 self.meshMethod == "Triangle": # create a 2D remesher
111 self.Create(mesh, geom, "NETGEN_Remesher_2D", LIBRARY)
113 self.Create(mesh, geom, self.algoType, LIBRARY)
117 ## Sets @c MaxSize parameter
118 # @param theSize new value of the @c MaxSize parameter
119 def SetMaxSize(self, theSize):
120 if self.Parameters(): self.params.SetMaxSize(theSize)
123 ## Sets @c MinSize parameter
124 # @param theSize new value of the @c MinSize parameter
125 def SetMinSize(self, theSize):
126 if self.Parameters(): self.params.SetMinSize(theSize)
129 ## Sets @c Optimize flag
130 # @param theVal new value of the @c Optimize parameter
131 def SetOptimize(self, theVal):
132 if self.Parameters(): self.params.SetOptimize(theVal)
135 ## Sets @c Fineness parameter
136 # @param theFineness new value of the @c Fineness parameter; it can be:
137 # @ref VeryCoarse, @ref Coarse, @ref Moderate, @ref Fine, @ref VeryFine or @ref Custom
138 def SetFineness(self, theFineness):
139 if self.Parameters(): self.params.SetFineness(theFineness)
142 ## Sets @c GrowthRate parameter
143 # @param theRate new value of the @c GrowthRate parameter
144 def SetGrowthRate(self, theRate):
145 if self.Parameters(): self.params.SetGrowthRate(theRate)
148 ## Creates meshing hypothesis according to the chosen algorithm type
149 # and initializes it with default parameters
150 # @param which hypothesis type; can be either @ref SOLE (default) or @ref SIMPLE
151 # @return hypothesis object
152 def Parameters(self, which=SOLE):
153 if self.algoType == NETGEN_1D2D:
155 hypType = "NETGEN_SimpleParameters_2D"
157 hypType = "NETGEN_Parameters_2D"
158 elif self.algoType == NETGEN_1D2D3D:
160 hypType = "NETGEN_SimpleParameters_3D"
162 hypType = "NETGEN_Parameters"
163 elif self.algoType == NETGEN_2D:
164 hypType = "NETGEN_Parameters_2D_ONLY"
166 hypType = "NETGEN_Parameters_3D"
168 if self.algo.GetName() == "NETGEN_Remesher_2D":
169 hypType = "NETGEN_RemesherParameters_2D"
171 if self.params and self.params.GetName() != hypType:
172 self.mesh.RemoveHypothesis( self.params, self.geom )
175 self.params = self.Hypothesis(hypType, [], LIBRARY, UseExisting=0)
179 ## Defines a file specifying size of elements at points and lines
180 # @param file name of the file
181 def SetMeshSizeFile(self, file):
182 self.Parameters().SetMeshSizeFile(file)
185 ## Set size of elements on a shape
186 # @param shape - geometry
187 # @param size - element size
188 def SetLocalSizeOnShape(self, shape, size ):
189 self.Parameters().SetLocalSizeOnShape(shape, size)
193 pass # end of NETGEN_Algorithm class
196 ## Tetrahedron 1D-2D-3D algorithm.
198 # It can be created by calling smeshBuilder.Mesh.Tetrahedron( smeshBuilder.NETGEN_1D2D3D, geom=0 ).
199 # This algorithm generates all 1D (edges), 2D (faces) and 3D (volumes) elements
200 # for given geometrical shape.
201 class NETGEN_1D2D3D_Algorithm(NETGEN_Algorithm):
203 ## name of the dynamic method in smeshBuilder.Mesh class
205 meshMethod = "Tetrahedron"
206 ## type of algorithm used with helper function in smeshBuilder.Mesh class
208 algoType = NETGEN_1D2D3D
209 ## doc string of the method
211 docHelper = "Creates tetrahedron 3D algorithm for solids"
213 ## Private constructor.
214 # @param mesh parent mesh object algorithm is assigned to
215 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
216 # if it is @c 0 (default), the algorithm is assigned to the main shape
217 def __init__(self, mesh, geom=0):
218 NETGEN_Algorithm.__init__(self, mesh, geom)
221 ## Sets @c SecondOrder flag
222 # @param theVal new value of the @c SecondOrder parameter
223 def SetSecondOrder(self, theVal):
224 if self.Parameters(): self.params.SetSecondOrder(theVal)
227 ## Sets @c NbSegPerEdge parameter
228 # @param theVal new value of the @c NbSegPerEdge parameter
229 def SetNbSegPerEdge(self, theVal):
230 if self.Parameters(): self.params.SetNbSegPerEdge(theVal)
233 ## Sets @c NbSegPerRadius parameter
234 # @param theVal new value of the @c NbSegPerRadius parameter
235 def SetNbSegPerRadius(self, theVal):
236 if self.Parameters(): self.params.SetNbSegPerRadius(theVal)
239 ## Sets @c ChordalError parameter
240 # @param theVal new value of the @c ChordalError parameter
241 def SetChordalError(self, theVal):
242 if self.Parameters():
243 self.params.SetChordalError(theVal)
244 self.params.SetChordalErrorEnabled( theVal > 0 )
247 ## Sets @c RidgeAngle parameter
248 # @param theVal new value of the @c RidgeAngle parameter
249 def SetRidgeAngle(self, theVal):
250 if self.Parameters():
251 self.params.SetRidgeAngle(theVal)
254 ## Sets @c QuadAllowed flag
255 # @param toAllow new value of the @c QuadAllowed parameter (@c True by default)
256 def SetQuadAllowed(self, toAllow=True):
257 if self.Parameters(): self.params.SetQuadAllowed(toAllow)
259 ## Sets @c UseSurfaceCurvature flag
260 # @param toUse new value of the @c UseSurfaceCurvature parameter (@c True by default)
261 def SetUseSurfaceCurvature(self, toUse=True):
262 if self.Parameters(): self.params.SetUseSurfaceCurvature(toUse)
264 ## Sets @c FuseEdges flag
265 # @param toFuse new value of the @c FuseEdges parameter (@c False by default)
266 def SetFuseEdges(self, toFuse=False):
267 if self.Parameters(): self.params.SetFuseEdges(toFuse)
270 ## Sets number of segments overriding the value set by SetLocalLength()
271 # @param theVal new value of number of segments parameter
272 def SetNumberOfSegments(self, theVal):
273 self.Parameters(SIMPLE).SetNumberOfSegments(theVal)
276 ## Sets number of segments overriding the value set by SetNumberOfSegments()
277 # @param theVal new value of local length parameter
278 def SetLocalLength(self, theVal):
279 self.Parameters(SIMPLE).SetLocalLength(theVal)
282 ## Defines @c MaxElementArea parameter of @c NETGEN_SimpleParameters_3D hypothesis.
283 # Overrides value set by LengthFromEdges()
284 # @param area new value of @c MaxElementArea parameter
285 def MaxElementArea(self, area):
286 self.Parameters(SIMPLE).SetMaxElementArea(area)
289 ## Defines @c LengthFromEdges parameter of @c NETGEN_SimpleParameters_3D hypothesis.
290 # Overrides value set by MaxElementArea()
291 def LengthFromEdges(self):
292 self.Parameters(SIMPLE).LengthFromEdges()
295 ## Defines @c LengthFromFaces parameter of @c NETGEN_SimpleParameters_3D hypothesis.
296 # Overrides value set by MaxElementVolume()
297 def LengthFromFaces(self):
298 self.Parameters(SIMPLE).LengthFromFaces()
301 ## Defines @c MaxElementVolume parameter of @c NETGEN_SimpleParameters_3D hypothesis.
302 # Overrides value set by LengthFromFaces()
303 # @param vol new value of @c MaxElementVolume parameter
304 def MaxElementVolume(self, vol):
305 self.Parameters(SIMPLE).SetMaxElementVolume(vol)
308 pass # end of NETGEN_1D2D3D_Algorithm class
311 ## Triangle NETGEN 1D-2D algorithm.
313 # It can be created by calling smeshBuilder.Mesh.Triangle( smeshBuilder.NETGEN_1D2D, geom=0 )
315 # This algorithm generates 1D (edges) and 2D (faces) elements
316 # for given geometrical shape.
317 class NETGEN_1D2D_Algorithm(NETGEN_1D2D3D_Algorithm):
319 ## name of the dynamic method in smeshBuilder.Mesh class
321 meshMethod = "Triangle"
322 ## type of algorithm used with helper function in smeshBuilder.Mesh class
324 algoType = NETGEN_1D2D
325 ## doc string of the method
327 docHelper = "Creates triangle 2D algorithm for faces"
329 ## Private constructor.
330 # @param mesh parent mesh object algorithm is assigned to
331 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
332 # if it is @c 0 (default), the algorithm is assigned to the main shape
333 def __init__(self, mesh, geom=0):
334 NETGEN_1D2D3D_Algorithm.__init__(self, mesh, geom)
337 pass # end of NETGEN_1D2D_Algorithm class
340 ## Triangle NETGEN 2D algorithm
342 # It can be created by calling smeshBuilder.Mesh.Triangle( smeshBuilder.NETGEN_2D, geom=0 )
344 # This algorithm generates only 2D (faces) elements for given geometrical shape
345 # and, in contrast to NETGEN_1D2D_Algorithm class, should be used in conjunction
346 # with other 1D meshing algorithm.
347 class NETGEN_2D_Only_Algorithm(NETGEN_Algorithm):
349 ## name of the dynamic method in smeshBuilder.Mesh class
351 meshMethod = "Triangle"
352 ## type of algorithm used with helper function in smeshBuilder.Mesh class
355 ## doc string of the method
357 docHelper = "Creates triangle 2D algorithm for faces"
359 ## Private constructor.
360 # @param mesh parent mesh object algorithm is assigned to
361 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
362 # if it is @c 0 (default), the algorithm is assigned to the main shape
363 def __init__(self, mesh, geom=0):
364 NETGEN_Algorithm.__init__(self, mesh, geom)
367 ## Defines @c MaxElementArea parameter of hypothesis basing on the definition of the
368 # maximum area of each triangle
369 # @param area maximum area value of each triangle
370 # @param UseExisting if \c True - searches for an existing hypothesis created with the
371 # same parameters, else (default) - creates a new one
372 # @return hypothesis object
373 def MaxElementArea(self, area, UseExisting=0):
374 compFun = lambda hyp, args: IsEqual(hyp.GetMaxElementArea(), args[0])
375 hyp = self.Hypothesis("MaxElementArea", [area], UseExisting=UseExisting,
376 CompareMethod=compFun)
377 hyp.SetMaxElementArea(area)
380 ## Defines @c LengthFromEdges hypothesis to build triangles
381 # based on the length of the edges taken from the wire
382 # @return hypothesis object
383 def LengthFromEdges(self):
384 hyp = self.Hypothesis("LengthFromEdges", UseExisting=1, CompareMethod=self.CompareEqualHyp)
387 ## Sets @c UseSurfaceCurvature flag
388 # @param toUse new value of the @c UseSurfaceCurvature parameter (@c True by default)
389 def SetUseSurfaceCurvature(self, toUse=True):
390 if self.Parameters(): self.params.SetUseSurfaceCurvature(toUse)
393 ## Sets @c QuadAllowed flag.
394 # @param toAllow new value of the @c QuadAllowed parameter (@c True by default)
395 # @return hypothesis object
396 def SetQuadAllowed(self, toAllow=True):
399 hasSimpleHyps = False
400 simpleHyps = ["QuadranglePreference","LengthFromEdges","MaxElementArea"]
401 for hyp in self.mesh.GetHypothesisList( self.geom ):
402 if hyp.GetName() in simpleHyps:
404 if hyp.GetName() == "QuadranglePreference":
405 if not toAllow: # remove QuadranglePreference
406 self.mesh.RemoveHypothesis( self.geom, hyp )
413 if toAllow: # add QuadranglePreference
414 return self.Hypothesis("QuadranglePreference", UseExisting=1, CompareMethod=self.CompareEqualHyp)
417 self.Parameters().SetQuadAllowed( toAllow )
420 pass # end of NETGEN_2D_Only_Algorithm class
423 ## Tetrahedron 3D algorithm
425 # It can be created by calling smeshBuilder.Mesh.Tetrahedron() or smeshBuilder.Mesh.Tetrahedron( smeshBuilder.NETGEN, geom=0 )
427 # This algorithm generates only 3D (volumes) elements for given geometrical shape
428 # and, in contrast to NETGEN_1D2D3D_Algorithm class, should be used in conjunction
429 # with other 1D and 2D meshing algorithms.
430 class NETGEN_3D_Algorithm(NETGEN_Algorithm):
432 ## name of the dynamic method in smeshBuilder.Mesh class
434 meshMethod = "Tetrahedron"
435 ## type of algorithm used with helper function in smeshBuilder.Mesh class
438 ## flag pointing either this algorithm should be used by default in dynamic method
439 # of smeshBuilder.Mesh class
442 ## doc string of the method
444 docHelper = "Creates tetrahedron 3D algorithm for solids"
446 ## Private constructor.
447 # @param mesh parent mesh object algorithm is assigned to
448 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
449 # if it is @c 0 (default), the algorithm is assigned to the main shape
450 def __init__(self, mesh, geom=0):
451 NETGEN_Algorithm.__init__(self, mesh, geom)
454 ## Defines @c MaxElementVolume hypothesis to specify the maximum volume value of each tetrahedron
455 # @param vol maximum volume value of each tetrahedron
456 # @param UseExisting if \c True - searches for the existing hypothesis created with
457 # the same parameters, else (default) - creates a new one
458 # @return hypothesis object
459 def MaxElementVolume(self, vol, UseExisting=0):
460 compFun = lambda hyp, args: IsEqual(hyp.GetMaxElementVolume(), args[0])
461 hyp = self.Hypothesis("MaxElementVolume", [vol], UseExisting=UseExisting,
462 CompareMethod=compFun)
463 hyp.SetMaxElementVolume(vol)
466 pass # end of NETGEN_3D_Algorithm class
469 ## Triangle (helper) 1D-2D algorithm
471 # This is the helper class that is used just to allow creating of create NETGEN_1D2D algorithm
472 # by calling smeshBuilder.Mesh.Triangle( smeshBuilder.NETGEN, geom=0 ); this is required for backward compatibility
473 # with old Python scripts.
475 # @note This class (and corresponding smeshBuilder.Mesh function) is obsolete;
476 # use smeshBuilder.Mesh.Triangle( smeshBuilder.NETGEN_1D2D, geom=0 ) instead.
477 class NETGEN_1D2D_Algorithm_2(NETGEN_1D2D_Algorithm):
479 ## name of the dynamic method in smeshBuilder.Mesh class
483 ## Private constructor.
484 # @param mesh parent mesh object algorithm is assigned to
485 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
486 # if it is @c 0 (default), the algorithm is assigned to the main shape
487 def __init__(self, mesh, geom=0):
488 self.algoType = NETGEN_1D2D
489 NETGEN_1D2D_Algorithm.__init__(self,mesh, geom)
492 pass # end of NETGEN_1D2D_Algorithm_2 class
495 ## Tetrahedron (helper) 1D-2D-3D algorithm.
497 # This is the helper class that is used just to allow creating of create NETGEN_1D2D3D
498 # by calling smeshBuilder.Mesh.Netgen(); this is required for backward compatibility with old Python scripts.
500 # @note This class (and corresponding smeshBuilder.Mesh function) is obsolete;
501 # use smeshBuilder.Mesh.Tetrahedron( smeshBuilder.NETGEN_1D2D3D, geom=0 ) instead.
502 class NETGEN_1D2D3D_Algorithm_2(NETGEN_1D2D3D_Algorithm):
504 ## name of the dynamic method in smeshBuilder.Mesh class
506 meshMethod = "Netgen"
507 ## doc string of the method
509 docHelper = "Deprecated, used only for compatibility! See Tetrahedron() method."
511 ## Private constructor.
512 # @param mesh parent mesh object algorithm is assigned to
513 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
514 # if it is @c 0 (default), the algorithm is assigned to the main shape
515 def __init__(self, mesh, geom=0):
516 NETGEN_1D2D3D_Algorithm.__init__(self,mesh, geom)
519 pass # end of NETGEN_1D2D3D_Algorithm_2 class