1 # Copyright (C) 2007-2015 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 StdMeshersBuilder
22 # Python API for the standard meshing plug-in module.
24 from salome.smesh.smesh_algorithm import Mesh_Algorithm
27 #----------------------------
28 # Mesh algo type identifiers
29 #----------------------------
31 ## Algorithm type: Regular 1D algorithm, see StdMeshersBuilder_Segment
32 REGULAR = "Regular_1D"
33 ## Algorithm type: Python 1D algorithm, see StdMeshersBuilder_Segment_Python
35 ## Algorithm type: Composite segment 1D algorithm, see StdMeshersBuilder_CompositeSegment
36 COMPOSITE = "CompositeSegment_1D"
37 ## Algorithm type: Triangle MEFISTO 2D algorithm, see StdMeshersBuilder_Triangle_MEFISTO
38 MEFISTO = "MEFISTO_2D"
39 ## Algorithm type: Hexahedron 3D (i-j-k) algorithm, see StdMeshersBuilder_Hexahedron
41 ## Algorithm type: Quadrangle 2D algorithm, see StdMeshersBuilder_Quadrangle
42 QUADRANGLE = "Quadrangle_2D"
43 ## Algorithm type: Radial Quadrangle 1D-2D algorithm, see StdMeshersBuilder_RadialQuadrangle1D2D
44 RADIAL_QUAD = "RadialQuadrangle_1D2D"
46 # import items of enums
47 for e in StdMeshers.QuadType._items: exec('%s = StdMeshers.%s'%(e,e))
48 for e in StdMeshers.VLExtrusionMethod._items: exec('%s = StdMeshers.%s'%(e,e))
50 #----------------------
52 #----------------------
54 ## Defines segment 1D algorithm for edges discretization.
56 # It can be created by calling smeshBuilder.Mesh.Segment(geom=0)
58 # @ingroup l3_algos_basic
59 class StdMeshersBuilder_Segment(Mesh_Algorithm):
61 ## name of the dynamic method in smeshBuilder.Mesh class
63 meshMethod = "Segment"
64 ## type of algorithm used with helper function in smeshBuilder.Mesh class
67 ## flag pointing either this algorithm should be used by default in dynamic method
68 # of smeshBuilder.Mesh class
71 ## doc string of the method
73 docHelper = "Creates segment 1D algorithm for edges"
75 ## Private constructor.
76 # @param mesh parent mesh object algorithm is assigned to
77 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
78 # if it is @c 0 (default), the algorithm is assigned to the main shape
79 def __init__(self, mesh, geom=0):
80 Mesh_Algorithm.__init__(self)
81 self.Create(mesh, geom, self.algoType)
84 ## Defines "LocalLength" hypothesis to cut an edge in several segments with the same length
85 # @param l for the length of segments that cut an edge
86 # @param UseExisting if ==true - searches for an existing hypothesis created with
87 # the same parameters, else (default) - creates a new one
88 # @param p precision, used for calculation of the number of segments.
89 # The precision should be a positive, meaningful value within the range [0,1].
90 # In general, the number of segments is calculated with the formula:
91 # nb = ceil((edge_length / l) - p)
92 # Function ceil rounds its argument to the higher integer.
93 # So, p=0 means rounding of (edge_length / l) to the higher integer,
94 # p=0.5 means rounding of (edge_length / l) to the nearest integer,
95 # p=1 means rounding of (edge_length / l) to the lower integer.
96 # Default value is 1e-07.
97 # @return an instance of StdMeshers_LocalLength hypothesis
98 # @ingroup l3_hypos_1dhyps
99 def LocalLength(self, l, UseExisting=0, p=1e-07):
100 from salome.smesh.smeshBuilder import IsEqual
101 comFun=lambda hyp, args: IsEqual(hyp.GetLength(), args[0]) and IsEqual(hyp.GetPrecision(), args[1])
102 hyp = self.Hypothesis("LocalLength", [l,p], UseExisting=UseExisting, CompareMethod=comFun)
107 ## Defines "MaxSize" hypothesis to cut an edge into segments not longer than given value
108 # @param length is optional maximal allowed length of segment, if it is omitted
109 # the preestimated length is used that depends on geometry size
110 # @param UseExisting if ==true - searches for an existing hypothesis created with
111 # the same parameters, else (default) - creates a new one
112 # @return an instance of StdMeshers_MaxLength hypothesis
113 # @ingroup l3_hypos_1dhyps
114 def MaxSize(self, length=0.0, UseExisting=0):
115 hyp = self.Hypothesis("MaxLength", [length], UseExisting=UseExisting)
118 hyp.SetLength(length)
120 # set preestimated length
121 gen = self.mesh.smeshpyD
122 initHyp = gen.GetHypothesisParameterValues("MaxLength", "libStdMeshersEngine.so",
123 self.mesh.GetMesh(), self.mesh.GetShape(),
125 preHyp = initHyp._narrow(StdMeshers.StdMeshers_MaxLength)
127 hyp.SetPreestimatedLength( preHyp.GetPreestimatedLength() )
130 hyp.SetUsePreestimatedLength( length == 0.0 )
133 ## Defines "NumberOfSegments" hypothesis to cut an edge in a fixed number of segments
134 # @param n for the number of segments that cut an edge
135 # @param s for the scale factor (optional)
136 # @param reversedEdges is a list of edges to mesh using reversed orientation.
137 # A list item can also be a tuple (edge, 1st_vertex_of_edge)
138 # @param UseExisting if ==true - searches for an existing hypothesis created with
139 # the same parameters, else (default) - create a new one
140 # @return an instance of StdMeshers_NumberOfSegments hypothesis
141 # @ingroup l3_hypos_1dhyps
142 def NumberOfSegments(self, n, s=[], reversedEdges=[], UseExisting=0):
143 if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
144 reversedEdges, UseExisting = [], reversedEdges
145 entry = self.MainShapeEntry()
146 reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
148 hyp = self.Hypothesis("NumberOfSegments", [n, reversedEdgeInd, entry],
149 UseExisting=UseExisting,
150 CompareMethod=self._compareNumberOfSegments)
152 hyp = self.Hypothesis("NumberOfSegments", [n,s, reversedEdgeInd, entry],
153 UseExisting=UseExisting,
154 CompareMethod=self._compareNumberOfSegments)
155 hyp.SetDistrType( 1 )
156 hyp.SetScaleFactor(s)
157 hyp.SetNumberOfSegments(n)
158 hyp.SetReversedEdges( reversedEdgeInd )
159 hyp.SetObjectEntry( entry )
164 # Checks if the given "NumberOfSegments" hypothesis has the same parameters as the given arguments
165 def _compareNumberOfSegments(self, hyp, args):
166 if hyp.GetNumberOfSegments() == args[0]:
168 if hyp.GetReversedEdges() == args[1]:
169 if not args[1] or hyp.GetObjectEntry() == args[2]:
172 from salome.smesh.smeshBuilder import IsEqual
173 if hyp.GetReversedEdges() == args[2]:
174 if not args[2] or hyp.GetObjectEntry() == args[3]:
175 if hyp.GetDistrType() == 1:
176 if IsEqual(hyp.GetScaleFactor(), args[1]):
180 ## Defines "Adaptive" hypothesis to cut an edge into segments keeping segment size
181 # within the given range and considering (1) deflection of segments from the edge
182 # and (2) distance from segments to closest edges and faces to have segment length
183 # not longer than two times shortest distances to edges and faces.
184 # @param minSize defines the minimal allowed segment length
185 # @param maxSize defines the maximal allowed segment length
186 # @param deflection defines the maximal allowed distance from a segment to an edge
187 # @param UseExisting if ==true - searches for an existing hypothesis created with
188 # the same parameters, else (default) - creates a new one
189 # @return an instance of StdMeshers_Adaptive1D hypothesis
190 # @ingroup l3_hypos_1dhyps
191 def Adaptive(self, minSize, maxSize, deflection, UseExisting=False):
192 from salome.smesh.smeshBuilder import IsEqual
193 compFun = lambda hyp, args: ( IsEqual(hyp.GetMinSize(), args[0]) and \
194 IsEqual(hyp.GetMaxSize(), args[1]) and \
195 IsEqual(hyp.GetDeflection(), args[2]))
196 hyp = self.Hypothesis("Adaptive1D", [minSize, maxSize, deflection],
197 UseExisting=UseExisting, CompareMethod=compFun)
198 hyp.SetMinSize(minSize)
199 hyp.SetMaxSize(maxSize)
200 hyp.SetDeflection(deflection)
203 ## Defines "Arithmetic1D" hypothesis to cut an edge in several segments with a length
204 # that changes in arithmetic progression
205 # @param start defines the length of the first segment
206 # @param end defines the length of the last segment
207 # @param reversedEdges is a list of edges to mesh using reversed orientation.
208 # A list item can also be a tuple (edge, 1st_vertex_of_edge)
209 # @param UseExisting if ==true - searches for an existing hypothesis created with
210 # the same parameters, else (default) - creates a new one
211 # @return an instance of StdMeshers_Arithmetic1D hypothesis
212 # @ingroup l3_hypos_1dhyps
213 def Arithmetic1D(self, start, end, reversedEdges=[], UseExisting=0):
214 if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
215 reversedEdges, UseExisting = [], reversedEdges
216 reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
217 entry = self.MainShapeEntry()
218 from salome.smesh.smeshBuilder import IsEqual
219 compFun = lambda hyp, args: ( IsEqual(hyp.GetLength(1), args[0]) and \
220 IsEqual(hyp.GetLength(0), args[1]) and \
221 hyp.GetReversedEdges() == args[2] and \
222 (not args[2] or hyp.GetObjectEntry() == args[3]))
223 hyp = self.Hypothesis("Arithmetic1D", [start, end, reversedEdgeInd, entry],
224 UseExisting=UseExisting, CompareMethod=compFun)
225 hyp.SetStartLength(start)
226 hyp.SetEndLength(end)
227 hyp.SetReversedEdges( reversedEdgeInd )
228 hyp.SetObjectEntry( entry )
231 ## Defines "GeometricProgression" hypothesis to cut an edge in several
232 # segments with a length that changes in Geometric progression
233 # @param start defines the length of the first segment
234 # @param ratio defines the common ratio of the geometric progression
235 # @param reversedEdges is a list of edges to mesh using reversed orientation.
236 # A list item can also be a tuple (edge, 1st_vertex_of_edge)
237 # @param UseExisting if ==true - searches for an existing hypothesis created with
238 # the same parameters, else (default) - creates a new one
239 # @return an instance of StdMeshers_Geometric1D hypothesis
240 # @ingroup l3_hypos_1dhyps
241 def GeometricProgression(self, start, ratio, reversedEdges=[], UseExisting=0):
242 reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
243 entry = self.MainShapeEntry()
244 from salome.smesh.smeshBuilder import IsEqual
245 compFun = lambda hyp, args: ( IsEqual(hyp.GetLength(1), args[0]) and \
246 IsEqual(hyp.GetLength(0), args[1]) and \
247 hyp.GetReversedEdges() == args[2] and \
248 (not args[2] or hyp.GetObjectEntry() == args[3]))
249 hyp = self.Hypothesis("GeometricProgression", [start, ratio, reversedEdgeInd, entry],
250 UseExisting=UseExisting, CompareMethod=compFun)
251 hyp.SetStartLength( start )
252 hyp.SetCommonRatio( ratio )
253 hyp.SetReversedEdges( reversedEdgeInd )
254 hyp.SetObjectEntry( entry )
257 ## Defines "FixedPoints1D" hypothesis to cut an edge using parameter
258 # on curve from 0 to 1 (additionally it is neecessary to check
259 # orientation of edges and create list of reversed edges if it is
260 # needed) and sets numbers of segments between given points (default
261 # values are equals 1
262 # @param points defines the list of parameters on curve
263 # @param nbSegs defines the list of numbers of segments
264 # @param reversedEdges is a list of edges to mesh using reversed orientation.
265 # A list item can also be a tuple (edge, 1st_vertex_of_edge)
266 # @param UseExisting if ==true - searches for an existing hypothesis created with
267 # the same parameters, else (default) - creates a new one
268 # @return an instance of StdMeshers_FixedPoints1D hypothesis
269 # @ingroup l3_hypos_1dhyps
270 def FixedPoints1D(self, points, nbSegs=[1], reversedEdges=[], UseExisting=0):
271 if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
272 reversedEdges, UseExisting = [], reversedEdges
273 reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
274 entry = self.MainShapeEntry()
275 compFun = lambda hyp, args: ( hyp.GetPoints() == args[0] and \
276 hyp.GetNbSegments() == args[1] and \
277 hyp.GetReversedEdges() == args[2] and \
278 (not args[2] or hyp.GetObjectEntry() == args[3]))
279 hyp = self.Hypothesis("FixedPoints1D", [points, nbSegs, reversedEdgeInd, entry],
280 UseExisting=UseExisting, CompareMethod=compFun)
281 hyp.SetPoints(points)
282 hyp.SetNbSegments(nbSegs)
283 hyp.SetReversedEdges(reversedEdgeInd)
284 hyp.SetObjectEntry(entry)
287 ## Defines "StartEndLength" hypothesis to cut an edge in several segments with increasing geometric length
288 # @param start defines the length of the first segment
289 # @param end defines the length of the last segment
290 # @param reversedEdges is a list of edges to mesh using reversed orientation.
291 # A list item can also be a tuple (edge, 1st_vertex_of_edge)
292 # @param UseExisting if ==true - searches for an existing hypothesis created with
293 # the same parameters, else (default) - creates a new one
294 # @return an instance of StdMeshers_StartEndLength hypothesis
295 # @ingroup l3_hypos_1dhyps
296 def StartEndLength(self, start, end, reversedEdges=[], UseExisting=0):
297 if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
298 reversedEdges, UseExisting = [], reversedEdges
299 reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
300 entry = self.MainShapeEntry()
301 from salome.smesh.smeshBuilder import IsEqual
302 compFun = lambda hyp, args: ( IsEqual(hyp.GetLength(1), args[0]) and \
303 IsEqual(hyp.GetLength(0), args[1]) and \
304 hyp.GetReversedEdges() == args[2] and \
305 (not args[2] or hyp.GetObjectEntry() == args[3]))
306 hyp = self.Hypothesis("StartEndLength", [start, end, reversedEdgeInd, entry],
307 UseExisting=UseExisting, CompareMethod=compFun)
308 hyp.SetStartLength(start)
309 hyp.SetEndLength(end)
310 hyp.SetReversedEdges( reversedEdgeInd )
311 hyp.SetObjectEntry( entry )
314 ## Defines "Deflection1D" hypothesis
315 # @param d for the deflection
316 # @param UseExisting if ==true - searches for an existing hypothesis created with
317 # the same parameters, else (default) - create a new one
318 # @ingroup l3_hypos_1dhyps
319 def Deflection1D(self, d, UseExisting=0):
320 from salome.smesh.smeshBuilder import IsEqual
321 compFun = lambda hyp, args: IsEqual(hyp.GetDeflection(), args[0])
322 hyp = self.Hypothesis("Deflection1D", [d], UseExisting=UseExisting, CompareMethod=compFun)
326 ## Defines "Propagation" hypothesis that propagates 1D hypotheses
327 # from an edge where this hypothesis is assigned to
328 # on all other edges that are at the opposite side in case of quadrangular faces
329 # This hypothesis should be assigned to an edge to propagate a hypothesis from.
330 # @ingroup l3_hypos_additi
331 def Propagation(self):
332 return self.Hypothesis("Propagation", UseExisting=1, CompareMethod=self.CompareEqualHyp)
334 ## Defines "Propagation of Node Distribution" hypothesis that propagates
335 # distribution of nodes from an edge where this hypothesis is assigned to,
336 # to opposite edges of quadrangular faces, so that number of segments on all these
337 # edges will be the same, as well as relations between segment lengths.
338 # @ingroup l3_hypos_additi
339 def PropagationOfDistribution(self):
340 return self.Hypothesis("PropagOfDistribution", UseExisting=1,
341 CompareMethod=self.CompareEqualHyp)
343 ## Defines "AutomaticLength" hypothesis
344 # @param fineness for the fineness [0-1]
345 # @param UseExisting if ==true - searches for an existing hypothesis created with the
346 # same parameters, else (default) - create a new one
347 # @ingroup l3_hypos_1dhyps
348 def AutomaticLength(self, fineness=0, UseExisting=0):
349 from salome.smesh.smeshBuilder import IsEqual
350 compFun = lambda hyp, args: IsEqual(hyp.GetFineness(), args[0])
351 hyp = self.Hypothesis("AutomaticLength",[fineness],UseExisting=UseExisting,
352 CompareMethod=compFun)
353 hyp.SetFineness( fineness )
356 ## Defines "SegmentLengthAroundVertex" hypothesis
357 # @param length for the segment length
358 # @param vertex for the length localization: the vertex index [0,1] | vertex object.
359 # Any other integer value means that the hypothesis will be set on the
360 # whole 1D shape, where Mesh_Segment algorithm is assigned.
361 # @param UseExisting if ==true - searches for an existing hypothesis created with
362 # the same parameters, else (default) - creates a new one
363 # @ingroup l3_algos_segmarv
364 def LengthNearVertex(self, length, vertex=0, UseExisting=0):
366 store_geom = self.geom
367 if type(vertex) is types.IntType:
368 if vertex == 0 or vertex == 1:
369 from salome.geom import geomBuilder
370 vertex = self.mesh.geompyD.ExtractShapes(self.geom, geomBuilder.geomBuilder.ShapeType["VERTEX"],True)[vertex]
378 if self.geom is None:
379 raise RuntimeError, "Attemp to create SegmentAroundVertex_0D algoritm on None shape"
380 from salome.smesh.smeshBuilder import AssureGeomPublished, GetName, TreatHypoStatus
381 AssureGeomPublished( self.mesh, self.geom )
382 name = GetName(self.geom)
384 algo = self.FindAlgorithm("SegmentAroundVertex_0D", self.mesh.smeshpyD)
386 algo = self.mesh.smeshpyD.CreateHypothesis("SegmentAroundVertex_0D", "libStdMeshersEngine.so")
388 status = self.mesh.mesh.AddHypothesis(self.geom, algo)
389 TreatHypoStatus(status, "SegmentAroundVertex_0D", name, True, self.mesh)
391 from salome.smesh.smeshBuilder import IsEqual
392 comFun = lambda hyp, args: IsEqual(hyp.GetLength(), args[0])
393 hyp = self.Hypothesis("SegmentLengthAroundVertex", [length], UseExisting=UseExisting,
394 CompareMethod=comFun)
395 self.geom = store_geom
396 hyp.SetLength( length )
399 ## Defines "QuadraticMesh" hypothesis, forcing construction of quadratic edges.
400 # If the 2D mesher sees that all boundary edges are quadratic,
401 # it generates quadratic faces, else it generates linear faces using
402 # medium nodes as if they are vertices.
403 # The 3D mesher generates quadratic volumes only if all boundary faces
404 # are quadratic, else it fails.
406 # @ingroup l3_hypos_additi
407 def QuadraticMesh(self):
408 hyp = self.Hypothesis("QuadraticMesh", UseExisting=1, CompareMethod=self.CompareEqualHyp)
411 pass # end of StdMeshersBuilder_Segment class
413 ## Segment 1D algorithm for discretization of a set of adjacent edges as one edge.
415 # It is created by calling smeshBuilder.Mesh.Segment(smeshBuilder.COMPOSITE,geom=0)
417 # @ingroup l3_algos_basic
418 class StdMeshersBuilder_CompositeSegment(StdMeshersBuilder_Segment):
420 ## name of the dynamic method in smeshBuilder.Mesh class
422 meshMethod = "Segment"
423 ## type of algorithm used with helper function in smeshBuilder.Mesh class
426 ## flag pointing either this algorithm should be used by default in dynamic method
427 # of smeshBuilder.Mesh class
430 ## doc string of the method
432 docHelper = "Creates segment 1D algorithm for edges"
434 ## Private constructor.
435 # @param mesh parent mesh object algorithm is assigned to
436 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
437 # if it is @c 0 (default), the algorithm is assigned to the main shape
438 def __init__(self, mesh, geom=0):
439 self.Create(mesh, geom, self.algoType)
442 pass # end of StdMeshersBuilder_CompositeSegment class
444 ## Defines a segment 1D algorithm for discretization of edges with Python function
446 # It is created by calling smeshBuilder.Mesh.Segment(smeshBuilder.PYTHON,geom=0)
448 # @ingroup l3_algos_basic
449 class StdMeshersBuilder_Segment_Python(Mesh_Algorithm):
451 ## name of the dynamic method in smeshBuilder.Mesh class
453 meshMethod = "Segment"
454 ## type of algorithm used with helper function in smeshBuilder.Mesh class
457 ## doc string of the method
459 docHelper = "Creates tetrahedron 3D algorithm for solids"
460 ## doc string of the method
462 docHelper = "Creates segment 1D algorithm for edges"
464 ## Private constructor.
465 # @param mesh parent mesh object algorithm is assigned to
466 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
467 # if it is @c 0 (default), the algorithm is assigned to the main shape
468 def __init__(self, mesh, geom=0):
469 import Python1dPlugin
470 self.Create(mesh, geom, self.algoType, "libPython1dEngine.so")
473 ## Defines "PythonSplit1D" hypothesis
474 # @param n for the number of segments that cut an edge
475 # @param func for the python function that calculates the length of all segments
476 # @param UseExisting if ==true - searches for the existing hypothesis created with
477 # the same parameters, else (default) - creates a new one
478 # @ingroup l3_hypos_1dhyps
479 def PythonSplit1D(self, n, func, UseExisting=0):
480 compFun = lambda hyp, args: False
481 hyp = self.Hypothesis("PythonSplit1D", [n], "libPython1dEngine.so",
482 UseExisting=UseExisting, CompareMethod=compFun)
483 hyp.SetNumberOfSegments(n)
484 hyp.SetPythonLog10RatioFunction(func)
487 pass # end of StdMeshersBuilder_Segment_Python class
489 ## Triangle MEFISTO 2D algorithm
491 # It is created by calling smeshBuilder.Mesh.Triangle(smeshBuilder.MEFISTO,geom=0)
493 # @ingroup l3_algos_basic
494 class StdMeshersBuilder_Triangle_MEFISTO(Mesh_Algorithm):
496 ## name of the dynamic method in smeshBuilder.Mesh class
498 meshMethod = "Triangle"
499 ## type of algorithm used with helper function in smeshBuilder.Mesh class
502 ## flag pointing either this algorithm should be used by default in dynamic method
503 # of smeshBuilder.Mesh class
506 ## doc string of the method
508 docHelper = "Creates triangle 2D algorithm for faces"
510 ## Private constructor.
511 # @param mesh parent mesh object algorithm is assigned to
512 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
513 # if it is @c 0 (default), the algorithm is assigned to the main shape
514 def __init__(self, mesh, geom=0):
515 Mesh_Algorithm.__init__(self)
516 self.Create(mesh, geom, self.algoType)
519 ## Defines "MaxElementArea" hypothesis basing on the definition of the maximum area of each triangle
520 # @param area for the maximum area of each triangle
521 # @param UseExisting if ==true - searches for an existing hypothesis created with the
522 # same parameters, else (default) - creates a new one
524 # @ingroup l3_hypos_2dhyps
525 def MaxElementArea(self, area, UseExisting=0):
526 from salome.smesh.smeshBuilder import IsEqual
527 comparator = lambda hyp, args: IsEqual(hyp.GetMaxElementArea(), args[0])
528 hyp = self.Hypothesis("MaxElementArea", [area], UseExisting=UseExisting,
529 CompareMethod=comparator)
530 hyp.SetMaxElementArea(area)
533 ## Defines "LengthFromEdges" hypothesis to build triangles
534 # based on the length of the edges taken from the wire
536 # @ingroup l3_hypos_2dhyps
537 def LengthFromEdges(self):
538 hyp = self.Hypothesis("LengthFromEdges", UseExisting=1, CompareMethod=self.CompareEqualHyp)
541 pass # end of StdMeshersBuilder_Triangle_MEFISTO class
543 ## Defines a quadrangle 2D algorithm
545 # It is created by calling smeshBuilder.Mesh.Quadrangle(geom=0)
547 # @ingroup l3_algos_basic
548 class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
550 ## name of the dynamic method in smeshBuilder.Mesh class
552 meshMethod = "Quadrangle"
553 ## type of algorithm used with helper function in smeshBuilder.Mesh class
555 algoType = QUADRANGLE
556 ## flag pointing either this algorithm should be used by default in dynamic method
557 # of smeshBuilder.Mesh class
560 ## doc string of the method
562 docHelper = "Creates quadrangle 2D algorithm for faces"
563 ## hypothesis associated with algorithm
567 ## Private constructor.
568 # @param mesh parent mesh object algorithm is assigned to
569 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
570 # if it is @c 0 (default), the algorithm is assigned to the main shape
571 def __init__(self, mesh, geom=0):
572 Mesh_Algorithm.__init__(self)
573 self.Create(mesh, geom, self.algoType)
576 ## Defines "QuadrangleParameters" hypothesis
577 # @param quadType defines the algorithm of transition between differently descretized
578 # sides of a geometrical face:
579 # - QUAD_STANDARD - both triangles and quadrangles are possible in the transition
580 # area along the finer meshed sides.
581 # - QUAD_TRIANGLE_PREF - only triangles are built in the transition area along the
582 # finer meshed sides.
583 # - QUAD_QUADRANGLE_PREF - only quadrangles are built in the transition area along
584 # the finer meshed sides, iff the total quantity of segments on
585 # all four sides of the face is even (divisible by 2).
586 # - QUAD_QUADRANGLE_PREF_REVERSED - same as QUAD_QUADRANGLE_PREF but the transition
587 # area is located along the coarser meshed sides.
588 # - QUAD_REDUCED - only quadrangles are built and the transition between the sides
589 # is made gradually, layer by layer. This type has a limitation on
590 # the number of segments: one pair of opposite sides must have the
591 # same number of segments, the other pair must have an even difference
592 # between the numbers of segments on the sides.
593 # @param triangleVertex: vertex of a trilateral geometrical face, around which triangles
594 # will be created while other elements will be quadrangles.
595 # Vertex can be either a GEOM_Object or a vertex ID within the
597 # @param enfVertices: list of shapes defining positions where nodes (enforced nodes)
598 # must be created by the mesher. Shapes can be of any type,
599 # vertices of given shapes define positions of enforced nodes.
600 # Only vertices successfully projected to the face are used.
601 # @param enfPoints: list of points giving positions of enforced nodes.
602 # Point can be defined either as SMESH.PointStruct's
603 # ([SMESH.PointStruct(x1,y1,z1), SMESH.PointStruct(x2,y2,z2),...])
604 # or triples of values ([[x1,y1,z1], [x2,y2,z2], ...]).
605 # In the case if the defined QuadrangleParameters() refer to a sole face,
606 # all given points must lie on this face, else the mesher fails.
607 # @param UseExisting: if \c True - searches for the existing hypothesis created with
608 # the same parameters, else (default) - creates a new one
609 # @ingroup l3_hypos_quad
610 def QuadrangleParameters(self, quadType=StdMeshers.QUAD_STANDARD, triangleVertex=0,
611 enfVertices=[],enfPoints=[],UseExisting=0):
613 vertexID = triangleVertex
614 if isinstance( triangleVertex, GEOM._objref_GEOM_Object ):
615 vertexID = self.mesh.geompyD.GetSubShapeID( self.mesh.geom, triangleVertex )
616 if isinstance( enfVertices, int ) and not enfPoints and not UseExisting:
617 # a call of old syntax, before inserting enfVertices and enfPoints before UseExisting
618 UseExisting, enfVertices = enfVertices, []
619 pStructs, xyz = [], []
621 if isinstance( p, SMESH.PointStruct ):
622 xyz.append(( p.x, p.y, p.z ))
625 xyz.append(( p[0], p[1], p[2] ))
626 pStructs.append( SMESH.PointStruct( p[0], p[1], p[2] ))
628 compFun = lambda hyp,args: \
629 hyp.GetQuadType() == args[0] and \
630 (hyp.GetTriaVertex()==args[1] or ( hyp.GetTriaVertex()<1 and args[1]<1)) and \
631 ((hyp.GetEnforcedNodes()) == (args[2],args[3])) # True w/o enfVertices only
632 entries = [ shape.GetStudyEntry() for shape in enfVertices ]
633 self.params = self.Hypothesis("QuadrangleParams", [quadType,vertexID,entries,xyz],
634 UseExisting = UseExisting, CompareMethod=compFun)
636 if self.params.GetQuadType() != quadType:
637 self.params.SetQuadType(quadType)
639 self.params.SetTriaVertex( vertexID )
640 from salome.smesh.smeshBuilder import AssureGeomPublished
641 for v in enfVertices:
642 AssureGeomPublished( self.mesh, v )
643 self.params.SetEnforcedNodes( enfVertices, pStructs )
646 ## Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only
647 # quadrangles are built in the transition area along the finer meshed sides,
648 # iff the total quantity of segments on all four sides of the face is even.
649 # @param reversed if True, transition area is located along the coarser meshed sides.
650 # @param UseExisting: if ==true - searches for the existing hypothesis created with
651 # the same parameters, else (default) - creates a new one
652 # @ingroup l3_hypos_quad
653 def QuadranglePreference(self, reversed=False, UseExisting=0):
655 return self.QuadrangleParameters(QUAD_QUADRANGLE_PREF_REVERSED,UseExisting=UseExisting)
656 return self.QuadrangleParameters(QUAD_QUADRANGLE_PREF,UseExisting=UseExisting)
658 ## Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only
659 # triangles are built in the transition area along the finer meshed sides.
660 # @param UseExisting: if ==true - searches for the existing hypothesis created with
661 # the same parameters, else (default) - creates a new one
662 # @ingroup l3_hypos_quad
663 def TrianglePreference(self, UseExisting=0):
664 return self.QuadrangleParameters(QUAD_TRIANGLE_PREF,UseExisting=UseExisting)
666 ## Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only
667 # quadrangles are built and the transition between the sides is made gradually,
668 # layer by layer. This type has a limitation on the number of segments: one pair
669 # of opposite sides must have the same number of segments, the other pair must
670 # have an even difference between the numbers of segments on the sides.
671 # @param UseExisting: if ==true - searches for the existing hypothesis created with
672 # the same parameters, else (default) - creates a new one
673 # @ingroup l3_hypos_quad
674 def Reduced(self, UseExisting=0):
675 return self.QuadrangleParameters(QUAD_REDUCED,UseExisting=UseExisting)
677 ## Defines "QuadrangleParams" hypothesis with QUAD_STANDARD type of quadrangulation
678 # @param vertex: vertex of a trilateral geometrical face, around which triangles
679 # will be created while other elements will be quadrangles.
680 # Vertex can be either a GEOM_Object or a vertex ID within the
682 # @param UseExisting: if ==true - searches for the existing hypothesis created with
683 # the same parameters, else (default) - creates a new one
684 # @ingroup l3_hypos_quad
685 def TriangleVertex(self, vertex, UseExisting=0):
686 return self.QuadrangleParameters(QUAD_STANDARD,vertex,UseExisting)
688 pass # end of StdMeshersBuilder_Quadrangle class
690 ## Defines a hexahedron 3D algorithm
692 # It is created by calling smeshBuilder.Mesh.Hexahedron(geom=0)
694 # @ingroup l3_algos_basic
695 class StdMeshersBuilder_Hexahedron(Mesh_Algorithm):
697 ## name of the dynamic method in smeshBuilder.Mesh class
699 meshMethod = "Hexahedron"
700 ## type of algorithm used with helper function in smeshBuilder.Mesh class
703 ## flag pointing either this algorithm should be used by default in dynamic method
704 # of smeshBuilder.Mesh class
707 ## doc string of the method
709 docHelper = "Creates hexahedron 3D algorithm for volumes"
711 ## Private constructor.
712 # @param mesh parent mesh object algorithm is assigned to
713 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
714 # if it is @c 0 (default), the algorithm is assigned to the main shape
715 def __init__(self, mesh, geom=0):
716 Mesh_Algorithm.__init__(self)
717 self.Create(mesh, geom, Hexa)
720 pass # end of StdMeshersBuilder_Hexahedron class
722 ## Defines a projection 1D algorithm
724 # It is created by calling smeshBuilder.Mesh.Projection1D(geom=0)
726 # @ingroup l3_algos_proj
727 class StdMeshersBuilder_Projection1D(Mesh_Algorithm):
729 ## name of the dynamic method in smeshBuilder.Mesh class
731 meshMethod = "Projection1D"
732 ## type of algorithm used with helper function in smeshBuilder.Mesh class
734 algoType = "Projection_1D"
735 ## flag pointing either this algorithm should be used by default in dynamic method
736 # of smeshBuilder.Mesh class
739 ## doc string of the method
741 docHelper = "Creates projection 1D algorithm for edges"
743 ## Private constructor.
744 # @param mesh parent mesh object algorithm is assigned to
745 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
746 # if it is @c 0 (default), the algorithm is assigned to the main shape
747 def __init__(self, mesh, geom=0):
748 Mesh_Algorithm.__init__(self)
749 self.Create(mesh, geom, self.algoType)
752 ## Defines "Source Edge" hypothesis, specifying a meshed edge, from where
753 # a mesh pattern is taken, and, optionally, the association of vertices
754 # between the source edge and a target edge (to which a hypothesis is assigned)
755 # @param edge from which nodes distribution is taken
756 # @param mesh from which nodes distribution is taken (optional)
757 # @param srcV a vertex of \a edge to associate with \a tgtV (optional)
758 # @param tgtV a vertex of \a the edge to which the algorithm is assigned,
759 # to associate with \a srcV (optional)
760 # @param UseExisting if ==true - searches for the existing hypothesis created with
761 # the same parameters, else (default) - creates a new one
762 def SourceEdge(self, edge, mesh=None, srcV=None, tgtV=None, UseExisting=0):
763 from salome.smesh.smeshBuilder import AssureGeomPublished, Mesh
764 AssureGeomPublished( self.mesh, edge )
765 AssureGeomPublished( self.mesh, srcV )
766 AssureGeomPublished( self.mesh, tgtV )
767 hyp = self.Hypothesis("ProjectionSource1D", [edge,mesh,srcV,tgtV],
769 # it does not seem to be useful to reuse the existing "SourceEdge" hypothesis
770 #UseExisting=UseExisting, CompareMethod=self.CompareSourceEdge)
771 hyp.SetSourceEdge( edge )
772 if not mesh is None and isinstance(mesh, Mesh):
773 mesh = mesh.GetMesh()
774 hyp.SetSourceMesh( mesh )
775 hyp.SetVertexAssociation( srcV, tgtV )
778 pass # end of StdMeshersBuilder_Projection1D class
780 ## Defines a projection 2D algorithm
782 # It is created by calling smeshBuilder.Mesh.Projection2D(geom=0)
784 # @ingroup l3_algos_proj
785 class StdMeshersBuilder_Projection2D(Mesh_Algorithm):
787 ## name of the dynamic method in smeshBuilder.Mesh class
789 meshMethod = "Projection2D"
790 ## type of algorithm used with helper function in smeshBuilder.Mesh class
792 algoType = "Projection_2D"
793 ## flag pointing either this algorithm should be used by default in dynamic method
794 # of smeshBuilder.Mesh class
797 ## doc string of the method
799 docHelper = "Creates projection 2D algorithm for faces"
801 ## Private constructor.
802 # @param mesh parent mesh object algorithm is assigned to
803 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
804 # if it is @c 0 (default), the algorithm is assigned to the main shape
805 def __init__(self, mesh, geom=0):
806 Mesh_Algorithm.__init__(self)
807 self.Create(mesh, geom, self.algoType)
810 ## Defines "Source Face" hypothesis, specifying a meshed face, from where
811 # a mesh pattern is taken, and, optionally, the association of vertices
812 # between the source face and the target face (to which a hypothesis is assigned)
813 # @param face from which the mesh pattern is taken
814 # @param mesh from which the mesh pattern is taken (optional)
815 # @param srcV1 a vertex of \a face to associate with \a tgtV1 (optional)
816 # @param tgtV1 a vertex of \a the face to which the algorithm is assigned,
817 # to associate with \a srcV1 (optional)
818 # @param srcV2 a vertex of \a face to associate with \a tgtV1 (optional)
819 # @param tgtV2 a vertex of \a the face to which the algorithm is assigned,
820 # to associate with \a srcV2 (optional)
821 # @param UseExisting if ==true - forces the search for the existing hypothesis created with
822 # the same parameters, else (default) - forces the creation a new one
824 # Note: all association vertices must belong to one edge of a face
825 def SourceFace(self, face, mesh=None, srcV1=None, tgtV1=None,
826 srcV2=None, tgtV2=None, UseExisting=0):
827 from salome.smesh.smeshBuilder import Mesh
828 if isinstance(mesh, Mesh):
829 mesh = mesh.GetMesh()
830 for geom in [ face, srcV1, tgtV1, srcV2, tgtV2 ]:
831 from salome.smesh.smeshBuilder import AssureGeomPublished
832 AssureGeomPublished( self.mesh, geom )
833 hyp = self.Hypothesis("ProjectionSource2D", [face,mesh,srcV1,tgtV1,srcV2,tgtV2],
834 UseExisting=0, toAdd=False)
835 # it does not seem to be useful to reuse the existing "SourceFace" hypothesis
836 #UseExisting=UseExisting, CompareMethod=self.CompareSourceFace)
837 hyp.SetSourceFace( face )
838 hyp.SetSourceMesh( mesh )
839 hyp.SetVertexAssociation( srcV1, srcV2, tgtV1, tgtV2 )
840 self.mesh.AddHypothesis(hyp, self.geom)
843 pass # end of StdMeshersBuilder_Projection2D class
845 ## Defines a projection 1D-2D algorithm
847 # It is created by calling smeshBuilder.Mesh.Projection1D2D(geom=0)
849 # @ingroup l3_algos_proj
850 class StdMeshersBuilder_Projection1D2D(StdMeshersBuilder_Projection2D):
852 ## name of the dynamic method in smeshBuilder.Mesh class
854 meshMethod = "Projection1D2D"
855 ## type of algorithm used with helper function in smeshBuilder.Mesh class
857 algoType = "Projection_1D2D"
858 ## doc string of the method
860 docHelper = "Creates projection 1D-2D algorithm for edges and faces"
862 ## Private constructor.
863 # @param mesh parent mesh object algorithm is assigned to
864 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
865 # if it is @c 0 (default), the algorithm is assigned to the main shape
866 def __init__(self, mesh, geom=0):
867 StdMeshersBuilder_Projection2D.__init__(self, mesh, geom)
870 pass # end of StdMeshersBuilder_Projection1D2D class
872 ## Defines a projection 3D algorithm
874 # It is created by calling smeshBuilder.Mesh.Projection3D(geom=0)
876 # @ingroup l3_algos_proj
877 class StdMeshersBuilder_Projection3D(Mesh_Algorithm):
879 ## name of the dynamic method in smeshBuilder.Mesh class
881 meshMethod = "Projection3D"
882 ## type of algorithm used with helper function in smeshBuilder.Mesh class
884 algoType = "Projection_3D"
885 ## doc string of the method
887 docHelper = "Creates projection 3D algorithm for volumes"
889 ## Private constructor.
890 # @param mesh parent mesh object algorithm is assigned to
891 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
892 # if it is @c 0 (default), the algorithm is assigned to the main shape
893 def __init__(self, mesh, geom=0):
894 Mesh_Algorithm.__init__(self)
895 self.Create(mesh, geom, self.algoType)
898 ## Defines the "Source Shape 3D" hypothesis, specifying a meshed solid, from where
899 # the mesh pattern is taken, and, optionally, the association of vertices
900 # between the source and the target solid (to which a hipothesis is assigned)
901 # @param solid from where the mesh pattern is taken
902 # @param mesh from where the mesh pattern is taken (optional)
903 # @param srcV1 a vertex of \a solid to associate with \a tgtV1 (optional)
904 # @param tgtV1 a vertex of \a the solid where the algorithm is assigned,
905 # to associate with \a srcV1 (optional)
906 # @param srcV2 a vertex of \a solid to associate with \a tgtV1 (optional)
907 # @param tgtV2 a vertex of \a the solid to which the algorithm is assigned,
908 # to associate with \a srcV2 (optional)
909 # @param UseExisting - if ==true - searches for the existing hypothesis created with
910 # the same parameters, else (default) - creates a new one
912 # Note: association vertices must belong to one edge of a solid
913 def SourceShape3D(self, solid, mesh=0, srcV1=0, tgtV1=0,
914 srcV2=0, tgtV2=0, UseExisting=0):
915 for geom in [ solid, srcV1, tgtV1, srcV2, tgtV2 ]:
916 from salome.smesh.smeshBuilder import AssureGeomPublished
917 AssureGeomPublished( self.mesh, geom )
918 hyp = self.Hypothesis("ProjectionSource3D",
919 [solid,mesh,srcV1,tgtV1,srcV2,tgtV2],
921 # seems to be not really useful to reuse existing "SourceShape3D" hypothesis
922 #UseExisting=UseExisting, CompareMethod=self.CompareSourceShape3D)
923 hyp.SetSource3DShape( solid )
924 from salome.smesh.smeshBuilder import Mesh
925 if isinstance(mesh, Mesh):
926 mesh = mesh.GetMesh()
928 hyp.SetSourceMesh( mesh )
929 if srcV1 and srcV2 and tgtV1 and tgtV2:
930 hyp.SetVertexAssociation( srcV1, srcV2, tgtV1, tgtV2 )
931 #elif srcV1 or srcV2 or tgtV1 or tgtV2:
934 pass # end of StdMeshersBuilder_Projection3D class
936 ## Defines a Prism 3D algorithm, which is either "Extrusion 3D" or "Radial Prism"
937 # depending on geometry
939 # It is created by calling smeshBuilder.Mesh.Prism(geom=0)
941 # @ingroup l3_algos_3dextr
942 class StdMeshersBuilder_Prism3D(Mesh_Algorithm):
944 ## name of the dynamic method in smeshBuilder.Mesh class
947 ## type of algorithm used with helper function in smeshBuilder.Mesh class
949 algoType = "Prism_3D"
950 ## doc string of the method
952 docHelper = "Creates prism 3D algorithm for volumes"
954 ## Private constructor.
955 # @param mesh parent mesh object algorithm is assigned to
956 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
957 # if it is @c 0 (default), the algorithm is assigned to the main shape
958 def __init__(self, mesh, geom=0):
959 Mesh_Algorithm.__init__(self)
964 from salome.geom import geomBuilder
965 nbSolids = len( geomBuilder.geom.SubShapeAll( shape, geomBuilder.geomBuilder.ShapeType["SOLID"] ))
966 nbShells = len( geomBuilder.geom.SubShapeAll( shape, geomBuilder.geomBuilder.ShapeType["SHELL"] ))
967 if nbSolids == 0 or nbSolids == nbShells:
968 self.Create(mesh, geom, "Prism_3D")
971 self.algoType = "RadialPrism_3D"
972 self.Create(mesh, geom, "RadialPrism_3D")
973 self.distribHyp = None #self.Hypothesis("LayerDistribution", UseExisting=0)
978 ## Return 3D hypothesis holding the 1D one
979 def Get3DHypothesis(self):
980 if self.algoType != "RadialPrism_3D":
981 print "Prism_3D algorith doesn't support any hyposesis"
983 return self.distribHyp
985 ## Private method creating a 1D hypothesis and storing it in the LayerDistribution
986 # hypothesis. Returns the created hypothesis
987 def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"):
988 if self.algoType != "RadialPrism_3D":
989 print "Prism_3D algorith doesn't support any hyposesis"
991 if not self.nbLayers is None:
992 self.mesh.GetMesh().RemoveHypothesis( self.geom, self.nbLayers )
993 self.mesh.GetMesh().AddHypothesis( self.geom, self.distribHyp )
994 study = self.mesh.smeshpyD.GetCurrentStudy() # prevents publishing own 1D hypothesis
995 self.mesh.smeshpyD.SetCurrentStudy( None )
996 hyp = self.mesh.smeshpyD.CreateHypothesis(hypType, so)
997 self.mesh.smeshpyD.SetCurrentStudy( study ) # enables publishing
998 if not self.distribHyp:
999 self.distribHyp = self.Hypothesis("LayerDistribution", UseExisting=0)
1000 self.distribHyp.SetLayerDistribution( hyp )
1003 ## Defines "NumberOfLayers" hypothesis, specifying the number of layers of
1004 # prisms to build between the inner and outer shells
1005 # @param n number of layers
1006 # @param UseExisting if ==true - searches for the existing hypothesis created with
1007 # the same parameters, else (default) - creates a new one
1008 def NumberOfLayers(self, n, UseExisting=0):
1009 if self.algoType != "RadialPrism_3D":
1010 print "Prism_3D algorith doesn't support any hyposesis"
1012 self.mesh.RemoveHypothesis( self.distribHyp, self.geom )
1013 from salome.smesh.smeshBuilder import IsEqual
1014 compFun = lambda hyp, args: IsEqual(hyp.GetNumberOfLayers(), args[0])
1015 self.nbLayers = self.Hypothesis("NumberOfLayers", [n], UseExisting=UseExisting,
1016 CompareMethod=compFun)
1017 self.nbLayers.SetNumberOfLayers( n )
1018 return self.nbLayers
1020 ## Defines "LocalLength" hypothesis, specifying the segment length
1021 # to build between the inner and the outer shells
1022 # @param l the length of segments
1023 # @param p the precision of rounding
1024 def LocalLength(self, l, p=1e-07):
1025 if self.algoType != "RadialPrism_3D":
1026 print "Prism_3D algorith doesn't support any hyposesis"
1028 hyp = self.OwnHypothesis("LocalLength", [l,p])
1033 ## Defines "NumberOfSegments" hypothesis, specifying the number of layers of
1034 # prisms to build between the inner and the outer shells.
1035 # @param n the number of layers
1036 # @param s the scale factor (optional)
1037 def NumberOfSegments(self, n, s=[]):
1038 if self.algoType != "RadialPrism_3D":
1039 print "Prism_3D algorith doesn't support any hyposesis"
1042 hyp = self.OwnHypothesis("NumberOfSegments", [n])
1044 hyp = self.OwnHypothesis("NumberOfSegments", [n,s])
1045 hyp.SetDistrType( 1 )
1046 hyp.SetScaleFactor(s)
1047 hyp.SetNumberOfSegments(n)
1050 ## Defines "Arithmetic1D" hypothesis, specifying the distribution of segments
1051 # to build between the inner and the outer shells with a length that changes
1052 # in arithmetic progression
1053 # @param start the length of the first segment
1054 # @param end the length of the last segment
1055 def Arithmetic1D(self, start, end ):
1056 if self.algoType != "RadialPrism_3D":
1057 print "Prism_3D algorith doesn't support any hyposesis"
1059 hyp = self.OwnHypothesis("Arithmetic1D", [start, end])
1060 hyp.SetLength(start, 1)
1061 hyp.SetLength(end , 0)
1064 ## Defines "GeometricProgression" hypothesis, specifying the distribution of segments
1065 # to build between the inner and the outer shells with a length that changes
1066 # in Geometric progression
1067 # @param start the length of the first segment
1068 # @param ratio the common ratio of the geometric progression
1069 def GeometricProgression(self, start, ratio ):
1070 if self.algoType != "RadialPrism_3D":
1071 print "Prism_3D algorith doesn't support any hyposesis"
1073 hyp = self.OwnHypothesis("GeometricProgression", [start, ratio])
1074 hyp.SetStartLength( start )
1075 hyp.SetCommonRatio( ratio )
1078 ## Defines "StartEndLength" hypothesis, specifying distribution of segments
1079 # to build between the inner and the outer shells as geometric length increasing
1080 # @param start for the length of the first segment
1081 # @param end for the length of the last segment
1082 def StartEndLength(self, start, end):
1083 if self.algoType != "RadialPrism_3D":
1084 print "Prism_3D algorith doesn't support any hyposesis"
1086 hyp = self.OwnHypothesis("StartEndLength", [start, end])
1087 hyp.SetLength(start, 1)
1088 hyp.SetLength(end , 0)
1091 ## Defines "AutomaticLength" hypothesis, specifying the number of segments
1092 # to build between the inner and outer shells
1093 # @param fineness defines the quality of the mesh within the range [0-1]
1094 def AutomaticLength(self, fineness=0):
1095 if self.algoType != "RadialPrism_3D":
1096 print "Prism_3D algorith doesn't support any hyposesis"
1098 hyp = self.OwnHypothesis("AutomaticLength")
1099 hyp.SetFineness( fineness )
1102 pass # end of StdMeshersBuilder_Prism3D class
1104 ## Defines a Prism 3D algorithm, which is either "Extrusion 3D" or "Radial Prism"
1105 # depending on geometry
1107 # It is created by calling smeshBuilder.Mesh.Prism(geom=0)
1109 # @ingroup l3_algos_3dextr
1110 class StdMeshersBuilder_RadialPrism3D(StdMeshersBuilder_Prism3D):
1112 ## name of the dynamic method in smeshBuilder.Mesh class
1114 meshMethod = "Prism"
1115 ## type of algorithm used with helper function in smeshBuilder.Mesh class
1117 algoType = "RadialPrism_3D"
1118 ## doc string of the method
1120 docHelper = "Creates prism 3D algorithm for volumes"
1122 ## Private constructor.
1123 # @param mesh parent mesh object algorithm is assigned to
1124 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
1125 # if it is @c 0 (default), the algorithm is assigned to the main shape
1126 def __init__(self, mesh, geom=0):
1127 Mesh_Algorithm.__init__(self)
1132 self.Create(mesh, geom, "RadialPrism_3D")
1133 self.distribHyp = None
1134 self.nbLayers = None
1137 ## Defines a Radial Quadrangle 1D-2D algorithm
1139 # It is created by calling smeshBuilder.Mesh.Quadrangle(smeshBuilder.RADIAL_QUAD,geom=0)
1141 # @ingroup l2_algos_radialq
1142 class StdMeshersBuilder_RadialQuadrangle1D2D(Mesh_Algorithm):
1144 ## name of the dynamic method in smeshBuilder.Mesh class
1146 meshMethod = "Quadrangle"
1147 ## type of algorithm used with helper function in smeshBuilder.Mesh class
1149 algoType = RADIAL_QUAD
1150 ## doc string of the method
1152 docHelper = "Creates quadrangle 1D-2D algorithm for triangular faces"
1154 ## Private constructor.
1155 # @param mesh parent mesh object algorithm is assigned to
1156 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
1157 # if it is @c 0 (default), the algorithm is assigned to the main shape
1158 def __init__(self, mesh, geom=0):
1159 Mesh_Algorithm.__init__(self)
1160 self.Create(mesh, geom, self.algoType)
1162 self.distribHyp = None #self.Hypothesis("LayerDistribution2D", UseExisting=0)
1163 self.nbLayers = None
1166 ## Return 2D hypothesis holding the 1D one
1167 def Get2DHypothesis(self):
1168 if not self.distribHyp:
1169 self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0)
1170 return self.distribHyp
1172 ## Private method creating a 1D hypothesis and storing it in the LayerDistribution
1173 # hypothesis. Returns the created hypothesis
1174 def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"):
1176 self.mesh.GetMesh().RemoveHypothesis( self.geom, self.nbLayers )
1177 if self.distribHyp is None:
1178 self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0)
1180 self.mesh.GetMesh().AddHypothesis( self.geom, self.distribHyp )
1181 study = self.mesh.smeshpyD.GetCurrentStudy() # prevents publishing own 1D hypothesis
1182 self.mesh.smeshpyD.SetCurrentStudy( None )
1183 hyp = self.mesh.smeshpyD.CreateHypothesis(hypType, so)
1184 self.mesh.smeshpyD.SetCurrentStudy( study ) # enables publishing
1185 self.distribHyp.SetLayerDistribution( hyp )
1188 ## Defines "NumberOfLayers" hypothesis, specifying the number of layers
1189 # @param n number of layers
1190 # @param UseExisting if ==true - searches for the existing hypothesis created with
1191 # the same parameters, else (default) - creates a new one
1192 def NumberOfLayers(self, n, UseExisting=0):
1194 self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp )
1195 from salome.smesh.smeshBuilder import IsEqual
1196 compFun = lambda hyp, args: IsEqual(hyp.GetNumberOfLayers(), args[0])
1197 self.nbLayers = self.Hypothesis("NumberOfLayers2D", [n], UseExisting=UseExisting,
1198 CompareMethod=compFun)
1199 self.nbLayers.SetNumberOfLayers( n )
1200 return self.nbLayers
1202 ## Defines "LocalLength" hypothesis, specifying the segment length
1203 # @param l the length of segments
1204 # @param p the precision of rounding
1205 def LocalLength(self, l, p=1e-07):
1206 hyp = self.OwnHypothesis("LocalLength", [l,p])
1211 ## Defines "NumberOfSegments" hypothesis, specifying the number of layers
1212 # @param n the number of layers
1213 # @param s the scale factor (optional)
1214 def NumberOfSegments(self, n, s=[]):
1216 hyp = self.OwnHypothesis("NumberOfSegments", [n])
1218 hyp = self.OwnHypothesis("NumberOfSegments", [n,s])
1219 hyp.SetDistrType( 1 )
1220 hyp.SetScaleFactor(s)
1221 hyp.SetNumberOfSegments(n)
1224 ## Defines "Arithmetic1D" hypothesis, specifying the distribution of segments
1225 # with a length that changes in arithmetic progression
1226 # @param start the length of the first segment
1227 # @param end the length of the last segment
1228 def Arithmetic1D(self, start, end ):
1229 hyp = self.OwnHypothesis("Arithmetic1D", [start, end])
1230 hyp.SetLength(start, 1)
1231 hyp.SetLength(end , 0)
1234 ## Defines "GeometricProgression" hypothesis, specifying the distribution of segments
1235 # with a length that changes in Geometric progression
1236 # @param start the length of the first segment
1237 # @param ratio the common ratio of the geometric progression
1238 def GeometricProgression(self, start, ratio ):
1239 hyp = self.OwnHypothesis("GeometricProgression", [start, ratio])
1240 hyp.SetStartLength( start )
1241 hyp.SetCommonRatio( ratio )
1244 ## Defines "StartEndLength" hypothesis, specifying distribution of segments
1245 # as geometric length increasing
1246 # @param start for the length of the first segment
1247 # @param end for the length of the last segment
1248 def StartEndLength(self, start, end):
1249 hyp = self.OwnHypothesis("StartEndLength", [start, end])
1250 hyp.SetLength(start, 1)
1251 hyp.SetLength(end , 0)
1254 ## Defines "AutomaticLength" hypothesis, specifying the number of segments
1255 # @param fineness defines the quality of the mesh within the range [0-1]
1256 def AutomaticLength(self, fineness=0):
1257 hyp = self.OwnHypothesis("AutomaticLength")
1258 hyp.SetFineness( fineness )
1261 pass # end of StdMeshersBuilder_RadialQuadrangle1D2D class
1263 ## Defines a Use Existing Elements 1D algorithm
1265 # It is created by calling smeshBuilder.Mesh.UseExisting1DElements(geom=0)
1267 # @ingroup l3_algos_basic
1268 class StdMeshersBuilder_UseExistingElements_1D(Mesh_Algorithm):
1270 ## name of the dynamic method in smeshBuilder.Mesh class
1272 meshMethod = "UseExisting1DElements"
1273 ## type of algorithm used with helper function in smeshBuilder.Mesh class
1275 algoType = "Import_1D"
1276 ## flag pointing either this algorithm should be used by default in dynamic method
1277 # of smeshBuilder.Mesh class
1280 ## doc string of the method
1282 docHelper = "Creates 1D algorithm for edges with reusing of existing mesh elements"
1284 ## Private constructor.
1285 # @param mesh parent mesh object algorithm is assigned to
1286 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
1287 # if it is @c 0 (default), the algorithm is assigned to the main shape
1288 def __init__(self, mesh, geom=0):
1289 Mesh_Algorithm.__init__(self)
1290 self.Create(mesh, geom, self.algoType)
1293 ## Defines "Source edges" hypothesis, specifying groups of edges to import
1294 # @param groups list of groups of edges
1295 # @param toCopyMesh if True, the whole mesh \a groups belong to is imported
1296 # @param toCopyGroups if True, all groups of the mesh \a groups belong to are imported
1297 # @param UseExisting if ==true - searches for the existing hypothesis created with
1298 # the same parameters, else (default) - creates a new one
1299 def SourceEdges(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
1300 for group in groups:
1301 from salome.smesh.smeshBuilder import AssureGeomPublished
1302 AssureGeomPublished( self.mesh, group )
1303 compFun = lambda hyp, args: ( hyp.GetSourceEdges() == args[0] and \
1304 hyp.GetCopySourceMesh() == args[1], args[2] )
1305 hyp = self.Hypothesis("ImportSource1D", [groups, toCopyMesh, toCopyGroups],
1306 UseExisting=UseExisting, CompareMethod=compFun)
1307 hyp.SetSourceEdges(groups)
1308 hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups)
1311 pass # end of StdMeshersBuilder_UseExistingElements_1D class
1313 ## Defines a Use Existing Elements 1D-2D algorithm
1315 # It is created by calling smeshBuilder.Mesh.UseExisting2DElements(geom=0)
1317 # @ingroup l3_algos_basic
1318 class StdMeshersBuilder_UseExistingElements_1D2D(Mesh_Algorithm):
1320 ## name of the dynamic method in smeshBuilder.Mesh class
1322 meshMethod = "UseExisting2DElements"
1323 ## type of algorithm used with helper function in smeshBuilder.Mesh class
1325 algoType = "Import_1D2D"
1326 ## flag pointing either this algorithm should be used by default in dynamic method
1327 # of smeshBuilder.Mesh class
1330 ## doc string of the method
1332 docHelper = "Creates 1D-2D algorithm for edges/faces with reusing of existing mesh elements"
1334 ## Private constructor.
1335 # @param mesh parent mesh object algorithm is assigned to
1336 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
1337 # if it is @c 0 (default), the algorithm is assigned to the main shape
1338 def __init__(self, mesh, geom=0):
1339 Mesh_Algorithm.__init__(self)
1340 self.Create(mesh, geom, self.algoType)
1343 ## Defines "Source faces" hypothesis, specifying groups of faces to import
1344 # @param groups list of groups of faces
1345 # @param toCopyMesh if True, the whole mesh \a groups belong to is imported
1346 # @param toCopyGroups if True, all groups of the mesh \a groups belong to are imported
1347 # @param UseExisting if ==true - searches for the existing hypothesis created with
1348 # the same parameters, else (default) - creates a new one
1349 def SourceFaces(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
1350 for group in groups:
1351 from salome.smesh.smeshBuilder import AssureGeomPublished
1352 AssureGeomPublished( self.mesh, group )
1353 compFun = lambda hyp, args: ( hyp.GetSourceFaces() == args[0] and \
1354 hyp.GetCopySourceMesh() == args[1], args[2] )
1355 hyp = self.Hypothesis("ImportSource2D", [groups, toCopyMesh, toCopyGroups],
1356 UseExisting=UseExisting, CompareMethod=compFun)
1357 hyp.SetSourceFaces(groups)
1358 hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups)
1361 pass # end of StdMeshersBuilder_UseExistingElements_1D2D class
1363 ## Defines a Body Fitting 3D algorithm
1365 # It is created by calling smeshBuilder.Mesh.BodyFitted(geom=0)
1367 # @ingroup l3_algos_basic
1368 class StdMeshersBuilder_Cartesian_3D(Mesh_Algorithm):
1370 ## name of the dynamic method in smeshBuilder.Mesh class
1372 meshMethod = "BodyFitted"
1373 ## type of algorithm used with helper function in smeshBuilder.Mesh class
1375 algoType = "Cartesian_3D"
1376 ## flag pointing either this algorithm should be used by default in dynamic method
1377 # of smeshBuilder.Mesh class
1380 ## doc string of the method
1382 docHelper = "Creates body fitting 3D algorithm for volumes"
1384 ## Private constructor.
1385 # @param mesh parent mesh object algorithm is assigned to
1386 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
1387 # if it is @c 0 (default), the algorithm is assigned to the main shape
1388 def __init__(self, mesh, geom=0):
1389 self.Create(mesh, geom, self.algoType)
1393 ## Defines "Body Fitting parameters" hypothesis
1394 # @param xGridDef is definition of the grid along the X asix.
1395 # It can be in either of two following forms:
1396 # - Explicit coordinates of nodes, e.g. [-1.5, 0.0, 3.1] or range( -100,200,10)
1397 # - Functions f(t) defining grid spacing at each point on grid axis. If there are
1398 # several functions, they must be accompanied by relative coordinates of
1399 # points dividing the whole shape into ranges where the functions apply; points
1400 # coodrinates should vary within (0.0, 1.0) range. Parameter \a t of the spacing
1401 # function f(t) varies from 0.0 to 1.0 witin a shape range.
1403 # - "10.5" - defines a grid with a constant spacing
1404 # - [["1", "1+10*t", "11"] [0.1, 0.6]] - defines different spacing in 3 ranges.
1405 # @param yGridDef defines the grid along the Y asix the same way as \a xGridDef does.
1406 # @param zGridDef defines the grid along the Z asix the same way as \a xGridDef does.
1407 # @param sizeThreshold (> 1.0) defines a minimal size of a polyhedron so that
1408 # a polyhedron of size less than hexSize/sizeThreshold is not created.
1409 # @param implEdges enables implementation of geometrical edges into the mesh.
1410 def SetGrid(self, xGridDef, yGridDef, zGridDef, sizeThreshold=4.0, implEdges=False):
1412 compFun = lambda hyp, args: False
1413 self.hyp = self.Hypothesis("CartesianParameters3D",
1414 [xGridDef, yGridDef, zGridDef, sizeThreshold],
1415 UseExisting=False, CompareMethod=compFun)
1416 if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ):
1417 self.mesh.AddHypothesis( self.hyp, self.geom )
1419 for axis, gridDef in enumerate( [xGridDef, yGridDef, zGridDef] ):
1420 if not gridDef: raise ValueError, "Empty grid definition"
1421 if isinstance( gridDef, str ):
1422 self.hyp.SetGridSpacing( [gridDef], [], axis )
1423 elif isinstance( gridDef[0], str ):
1424 self.hyp.SetGridSpacing( gridDef, [], axis )
1425 elif isinstance( gridDef[0], int ) or \
1426 isinstance( gridDef[0], float ):
1427 self.hyp.SetGrid(gridDef, axis )
1429 self.hyp.SetGridSpacing( gridDef[0], gridDef[1], axis )
1430 self.hyp.SetSizeThreshold( sizeThreshold )
1431 self.hyp.SetToAddEdges( implEdges )
1434 ## Defines custom directions of axes of the grid
1435 # @param xAxis either SMESH.DirStruct or a vector, or 3 vector components
1436 # @param yAxis either SMESH.DirStruct or a vector, or 3 vector components
1437 # @param zAxis either SMESH.DirStruct or a vector, or 3 vector components
1438 def SetAxesDirs( self, xAxis, yAxis, zAxis ):
1440 if hasattr( xAxis, "__getitem__" ):
1441 xAxis = self.mesh.smeshpyD.MakeDirStruct( xAxis[0],xAxis[1],xAxis[2] )
1442 elif isinstance( xAxis, GEOM._objref_GEOM_Object ):
1443 xAxis = self.mesh.smeshpyD.GetDirStruct( xAxis )
1444 if hasattr( yAxis, "__getitem__" ):
1445 yAxis = self.mesh.smeshpyD.MakeDirStruct( yAxis[0],yAxis[1],yAxis[2] )
1446 elif isinstance( yAxis, GEOM._objref_GEOM_Object ):
1447 yAxis = self.mesh.smeshpyD.GetDirStruct( yAxis )
1448 if hasattr( zAxis, "__getitem__" ):
1449 zAxis = self.mesh.smeshpyD.MakeDirStruct( zAxis[0],zAxis[1],zAxis[2] )
1450 elif isinstance( zAxis, GEOM._objref_GEOM_Object ):
1451 zAxis = self.mesh.smeshpyD.GetDirStruct( zAxis )
1453 self.hyp = self.Hypothesis("CartesianParameters3D")
1454 if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ):
1455 self.mesh.AddHypothesis( self.hyp, self.geom )
1456 self.hyp.SetAxesDirs( xAxis, yAxis, zAxis )
1459 ## Automatically defines directions of axes of the grid at which
1460 # a number of generated hexahedra is maximal
1461 # @param isOrthogonal defines whether the axes mush be orthogonal
1462 def SetOptimalAxesDirs(self, isOrthogonal=True):
1464 self.hyp = self.Hypothesis("CartesianParameters3D")
1465 if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ):
1466 self.mesh.AddHypothesis( self.hyp, self.geom )
1467 x,y,z = self.hyp.ComputeOptimalAxesDirs( self.geom, isOrthogonal )
1468 self.hyp.SetAxesDirs( x,y,z )
1471 ## Sets/unsets a fixed point. The algorithm makes a plane of the grid pass
1472 # through the fixed point in each direction at which the grid is defined
1474 # @param p coordinates of the fixed point. Either SMESH.PointStruct or
1475 # a vertex or 3 components of coordinates.
1476 # @param toUnset defines whether the fixed point is defined or removed.
1477 def SetFixedPoint( self, p, toUnset=False ):
1480 if not self.hyp: return
1481 p = SMESH.PointStruct(0,0,0)
1482 elif hasattr( p, "__getitem__" ):
1483 p = SMESH.PointStruct( p[0],p[1],p[2] )
1484 elif isinstance( p, GEOM._objref_GEOM_Object ):
1485 p = self.mesh.smeshpyD.GetPointStruct( p )
1487 self.hyp = self.Hypothesis("CartesianParameters3D")
1488 if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ):
1489 self.mesh.AddHypothesis( self.hyp, self.geom )
1490 self.hyp.SetFixedPoint( p, toUnset )
1494 pass # end of StdMeshersBuilder_Cartesian_3D class
1496 ## Defines a stub 1D algorithm, which enables "manual" creation of nodes and
1497 # segments usable by 2D algoritms
1499 # It is created by calling smeshBuilder.Mesh.UseExistingSegments(geom=0)
1501 # @ingroup l3_algos_basic
1502 class StdMeshersBuilder_UseExisting_1D(Mesh_Algorithm):
1504 ## name of the dynamic method in smeshBuilder.Mesh class
1506 meshMethod = "UseExistingSegments"
1507 ## type of algorithm used with helper function in smeshBuilder.Mesh class
1509 algoType = "UseExisting_1D"
1510 ## doc string of the method
1512 docHelper = "Creates 1D algorithm for edges with reusing of existing mesh elements"
1514 ## Private constructor.
1515 # @param mesh parent mesh object algorithm is assigned to
1516 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
1517 # if it is @c 0 (default), the algorithm is assigned to the main shape
1518 def __init__(self, mesh, geom=0):
1519 self.Create(mesh, geom, self.algoType)
1522 pass # end of StdMeshersBuilder_UseExisting_1D class
1524 ## Defines a stub 2D algorithm, which enables "manual" creation of nodes and
1525 # faces usable by 3D algoritms
1527 # It is created by calling smeshBuilder.Mesh.UseExistingFaces(geom=0)
1529 # @ingroup l3_algos_basic
1530 class StdMeshersBuilder_UseExisting_2D(Mesh_Algorithm):
1532 ## name of the dynamic method in smeshBuilder.Mesh class
1534 meshMethod = "UseExistingFaces"
1535 ## type of algorithm used with helper function in smeshBuilder.Mesh class
1537 algoType = "UseExisting_2D"
1538 ## doc string of the method
1540 docHelper = "Creates 2D algorithm for faces with reusing of existing mesh elements"
1542 ## Private constructor.
1543 # @param mesh parent mesh object algorithm is assigned to
1544 # @param geom geometry (shape/sub-shape) algorithm is assigned to;
1545 # if it is @c 0 (default), the algorithm is assigned to the main shape
1546 def __init__(self, mesh, geom=0):
1547 self.Create(mesh, geom, self.algoType)
1550 pass # end of StdMeshersBuilder_UseExisting_2D class