1 # Copyright (C) 2007-2016 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 Python API for the standard meshing plug-in module.
24 LIBRARY = "libStdMeshersEngine.so"
26 from salome.smesh.smesh_algorithm import Mesh_Algorithm
29 #----------------------------
30 # Mesh algo type identifiers
31 #----------------------------
33 REGULAR = "Regular_1D"
35 Algorithm type: Regular 1D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_Segment`
40 Algorithm type: Python 1D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_Segment_Python`
43 COMPOSITE = "CompositeSegment_1D"
46 Algorithm type: Composite segment 1D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_CompositeSegment`
48 MEFISTO = "MEFISTO_2D"
50 Algorithm type: Triangle MEFISTO 2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_Triangle_MEFISTO`
55 Algorithm type: Hexahedron 3D (i-j-k) algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_Hexahedron`
58 QUADRANGLE = "Quadrangle_2D"
60 Algorithm type: Quadrangle 2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_Quadrangle`
63 RADIAL_QUAD = "RadialQuadrangle_1D2D"
65 Algorithm type: Radial Quadrangle 1D-2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_RadialQuadrangle1D2D`
68 QUAD_MA_PROJ = "QuadFromMedialAxis_1D2D"
70 Algorithm type: Quadrangle (Medial Axis Projection) 1D-2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_QuadMA_1D2D`
73 POLYGON = "PolygonPerFace_2D"
75 Algorithm type: Polygon Per Face 2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_PolygonPerFace`
78 # import items of enums
79 for e in StdMeshers.QuadType._items: exec('%s = StdMeshers.%s'%(e,e))
80 for e in StdMeshers.VLExtrusionMethod._items: exec('%s = StdMeshers.%s'%(e,e))
82 #----------------------
84 #----------------------
86 class StdMeshersBuilder_Segment(Mesh_Algorithm):
88 Defines segment 1D algorithm for edges discretization.
90 It can be created by calling smeshBuilder.Mesh.Segment(geom=0)
94 meshMethod = "Segment"
96 name of the dynamic method in smeshBuilder.Mesh class
101 type of algorithm used with helper function in smeshBuilder.Mesh class
106 flag pointing whether this algorithm should be used by default in dynamic method
107 of smeshBuilder.Mesh class
110 docHelper = "Creates segment 1D algorithm for edges"
112 doc string of the method
115 def __init__(self, mesh, geom=0):
119 mesh: parent mesh object algorithm is assigned to
120 geom: geometry (shape/sub-shape) algorithm is assigned to;
121 if it is :code:`0` (default), the algorithm is assigned to the main shape
123 Mesh_Algorithm.__init__(self)
124 self.Create(mesh, geom, self.algoType)
127 def LocalLength(self, l, UseExisting=0, p=1e-07):
129 Defines "LocalLength" hypothesis to cut an edge in several segments with the same length
132 l : for the length of segments that cut an edge
133 UseExisting : if == true - searches for an existing hypothesis created with
134 the same parameters, else (default) - creates a new one
135 p : precision, used for calculation of the number of segments.
136 The precision should be a positive, meaningful value within the range [0,1].
137 In general, the number of segments is calculated with the formula:
138 nb = ceil((edge_length / l) - p)
139 Function ceil rounds its argument to the higher integer.
140 So, p=0 means rounding of (edge_length / l) to the higher integer,
141 p=0.5 means rounding of (edge_length / l) to the nearest integer,
142 p=1 means rounding of (edge_length / l) to the lower integer.
143 Default value is 1e-07.
146 an instance of StdMeshers_LocalLength hypothesis
149 from salome.smesh.smeshBuilder import IsEqual
150 comFun=lambda hyp, args: IsEqual(hyp.GetLength(), args[0]) and IsEqual(hyp.GetPrecision(), args[1])
151 hyp = self.Hypothesis("LocalLength", [l,p], UseExisting=UseExisting, CompareMethod=comFun)
156 def MaxSize(self, length=0.0, UseExisting=0):
158 Defines "MaxSize" hypothesis to cut an edge into segments not longer than given value
161 length : is optional maximal allowed length of segment, if it is omitted
162 the preestimated length is used that depends on geometry size
163 UseExisting : if ==true - searches for an existing hypothesis created with
164 the same parameters, else (default) - creates a new one
167 an instance of StdMeshers_MaxLength hypothesis
171 hyp = self.Hypothesis("MaxLength", [length], UseExisting=UseExisting)
174 hyp.SetLength(length)
176 # set preestimated length
177 gen = self.mesh.smeshpyD
178 initHyp = gen.GetHypothesisParameterValues("MaxLength", "libStdMeshersEngine.so",
179 self.mesh.GetMesh(), self.mesh.GetShape(),
181 preHyp = initHyp._narrow(StdMeshers.StdMeshers_MaxLength)
183 hyp.SetPreestimatedLength( preHyp.GetPreestimatedLength() )
186 hyp.SetUsePreestimatedLength( length == 0.0 )
189 def NumberOfSegments(self, n, s=[], reversedEdges=[], UseExisting=0):
191 Defines "NumberOfSegments" hypothesis to cut an edge in a fixed number of segments
194 n: for the number of segments that cut an edge
195 s: for the scale factor (optional)
196 reversedEdges: is a list of edges to mesh using reversed orientation.
197 A list item can also be a tuple (edge, 1st_vertex_of_edge)
198 UseExisting: if ==true - searches for an existing hypothesis created with
199 the same parameters, else (default) - create a new one
202 an instance of StdMeshers_NumberOfSegments hypothesis
206 if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
207 reversedEdges, UseExisting = [], reversedEdges
208 entry = self.MainShapeEntry()
209 reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
211 hyp = self.Hypothesis("NumberOfSegments", [n, reversedEdgeInd, entry],
212 UseExisting=UseExisting,
213 CompareMethod=self._compareNumberOfSegments)
215 hyp = self.Hypothesis("NumberOfSegments", [n,s, reversedEdgeInd, entry],
216 UseExisting=UseExisting,
217 CompareMethod=self._compareNumberOfSegments)
218 hyp.SetScaleFactor(s)
219 hyp.SetNumberOfSegments(n)
220 hyp.SetReversedEdges( reversedEdgeInd )
221 hyp.SetObjectEntry( entry )
224 def _compareNumberOfSegments(self, hyp, args):
227 Checks if the given "NumberOfSegments" hypothesis has the same parameters as the given arguments
229 if hyp.GetNumberOfSegments() == args[0]:
231 if hyp.GetReversedEdges() == args[1]:
232 if not args[1] or hyp.GetObjectEntry() == args[2]:
235 from salome.smesh.smeshBuilder import IsEqual
236 if hyp.GetReversedEdges() == args[2]:
237 if not args[2] or hyp.GetObjectEntry() == args[3]:
238 if hyp.GetDistrType() == 1:
239 if IsEqual(hyp.GetScaleFactor(), args[1]):
243 def Adaptive(self, minSize, maxSize, deflection, UseExisting=False):
245 Defines "Adaptive" hypothesis to cut an edge into segments keeping segment size
246 within the given range and considering (1) deflection of segments from the edge
247 and (2) distance from segments to closest edges and faces to have segment length
248 not longer than two times shortest distances to edges and faces.
251 minSize: defines the minimal allowed segment length
252 maxSize: defines the maximal allowed segment length
253 deflection: defines the maximal allowed distance from a segment to an edge
254 UseExisting: if ==true - searches for an existing hypothesis created with
255 the same parameters, else (default) - creates a new one
258 an instance of StdMeshers_Adaptive1D hypothesis
261 from salome.smesh.smeshBuilder import IsEqual
262 compFun = lambda hyp, args: ( IsEqual(hyp.GetMinSize(), args[0]) and \
263 IsEqual(hyp.GetMaxSize(), args[1]) and \
264 IsEqual(hyp.GetDeflection(), args[2]))
265 hyp = self.Hypothesis("Adaptive1D", [minSize, maxSize, deflection],
266 UseExisting=UseExisting, CompareMethod=compFun)
267 hyp.SetMinSize(minSize)
268 hyp.SetMaxSize(maxSize)
269 hyp.SetDeflection(deflection)
272 def Arithmetic1D(self, start, end, reversedEdges=[], UseExisting=0):
274 Defines "Arithmetic1D" hypothesis to cut an edge in several segments with a length
275 that changes in arithmetic progression
278 start: defines the length of the first segment
279 end: defines the length of the last segment
280 reversedEdges: is a list of edges to mesh using reversed orientation.
281 A list item can also be a tuple (edge, 1st_vertex_of_edge)
282 UseExisting: if ==true - searches for an existing hypothesis created with
283 the same parameters, else (default) - creates a new one
286 an instance of StdMeshers_Arithmetic1D hypothesis
289 if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
290 reversedEdges, UseExisting = [], reversedEdges
291 reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
292 entry = self.MainShapeEntry()
293 from salome.smesh.smeshBuilder import IsEqual
294 compFun = lambda hyp, args: ( IsEqual(hyp.GetLength(1), args[0]) and \
295 IsEqual(hyp.GetLength(0), args[1]) and \
296 hyp.GetReversedEdges() == args[2] and \
297 (not args[2] or hyp.GetObjectEntry() == args[3]))
298 hyp = self.Hypothesis("Arithmetic1D", [start, end, reversedEdgeInd, entry],
299 UseExisting=UseExisting, CompareMethod=compFun)
300 hyp.SetStartLength(start)
301 hyp.SetEndLength(end)
302 hyp.SetReversedEdges( reversedEdgeInd )
303 hyp.SetObjectEntry( entry )
306 def GeometricProgression(self, start, ratio, reversedEdges=[], UseExisting=0):
308 Defines "GeometricProgression" hypothesis to cut an edge in several
309 segments with a length that changes in Geometric progression
312 start: defines the length of the first segment
313 ratio: defines the common ratio of the geometric progression
314 reversedEdges: is a list of edges to mesh using reversed orientation.
315 A list item can also be a tuple (edge, 1st_vertex_of_edge)
316 UseExisting: if ==true - searches for an existing hypothesis created with
317 the same parameters, else (default) - creates a new one
320 an instance of StdMeshers_Geometric1D hypothesis
323 reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
324 entry = self.MainShapeEntry()
325 from salome.smesh.smeshBuilder import IsEqual
326 compFun = lambda hyp, args: ( IsEqual(hyp.GetLength(1), args[0]) and \
327 IsEqual(hyp.GetLength(0), args[1]) and \
328 hyp.GetReversedEdges() == args[2] and \
329 (not args[2] or hyp.GetObjectEntry() == args[3]))
330 hyp = self.Hypothesis("GeometricProgression", [start, ratio, reversedEdgeInd, entry],
331 UseExisting=UseExisting, CompareMethod=compFun)
332 hyp.SetStartLength( start )
333 hyp.SetCommonRatio( ratio )
334 hyp.SetReversedEdges( reversedEdgeInd )
335 hyp.SetObjectEntry( entry )
338 def FixedPoints1D(self, points, nbSegs=[1], reversedEdges=[], UseExisting=0):
340 Defines "FixedPoints1D" hypothesis to cut an edge using parameter
341 on curve from 0 to 1 (additionally it is neecessary to check
342 orientation of edges and create list of reversed edges if it is
343 needed) and sets numbers of segments between given points (default
347 points: defines the list of parameters on curve
348 nbSegs: defines the list of numbers of segments
349 reversedEdges: is a list of edges to mesh using reversed orientation.
350 A list item can also be a tuple (edge, 1st_vertex_of_edge)
351 UseExisting: if ==true - searches for an existing hypothesis created with
352 the same parameters, else (default) - creates a new one
355 an instance of StdMeshers_FixedPoints1D hypothesis
358 if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
359 reversedEdges, UseExisting = [], reversedEdges
360 reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
361 entry = self.MainShapeEntry()
362 compFun = lambda hyp, args: ( hyp.GetPoints() == args[0] and \
363 hyp.GetNbSegments() == args[1] and \
364 hyp.GetReversedEdges() == args[2] and \
365 (not args[2] or hyp.GetObjectEntry() == args[3]))
366 hyp = self.Hypothesis("FixedPoints1D", [points, nbSegs, reversedEdgeInd, entry],
367 UseExisting=UseExisting, CompareMethod=compFun)
368 hyp.SetPoints(points)
369 hyp.SetNbSegments(nbSegs)
370 hyp.SetReversedEdges(reversedEdgeInd)
371 hyp.SetObjectEntry(entry)
374 def StartEndLength(self, start, end, reversedEdges=[], UseExisting=0):
376 Defines "StartEndLength" hypothesis to cut an edge in several segments with increasing geometric length
379 start: defines the length of the first segment
380 end: defines the length of the last segment
381 reversedEdges: is a list of edges to mesh using reversed orientation.
382 A list item can also be a tuple (edge, 1st_vertex_of_edge)
383 UseExisting: if ==true - searches for an existing hypothesis created with
384 the same parameters, else (default) - creates a new one
387 an instance of StdMeshers_StartEndLength hypothesis
390 if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
391 reversedEdges, UseExisting = [], reversedEdges
392 reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
393 entry = self.MainShapeEntry()
394 from salome.smesh.smeshBuilder import IsEqual
395 compFun = lambda hyp, args: ( IsEqual(hyp.GetLength(1), args[0]) and \
396 IsEqual(hyp.GetLength(0), args[1]) and \
397 hyp.GetReversedEdges() == args[2] and \
398 (not args[2] or hyp.GetObjectEntry() == args[3]))
399 hyp = self.Hypothesis("StartEndLength", [start, end, reversedEdgeInd, entry],
400 UseExisting=UseExisting, CompareMethod=compFun)
401 hyp.SetStartLength(start)
402 hyp.SetEndLength(end)
403 hyp.SetReversedEdges( reversedEdgeInd )
404 hyp.SetObjectEntry( entry )
407 def Deflection1D(self, d, UseExisting=0):
409 Defines "Deflection1D" hypothesis
412 d: for the deflection
413 UseExisting: if ==true - searches for an existing hypothesis created with
414 the same parameters, else (default) - create a new one
417 from salome.smesh.smeshBuilder import IsEqual
418 compFun = lambda hyp, args: IsEqual(hyp.GetDeflection(), args[0])
419 hyp = self.Hypothesis("Deflection1D", [d], UseExisting=UseExisting, CompareMethod=compFun)
423 def Propagation(self):
425 Defines "Propagation" hypothesis that propagates 1D hypotheses
426 from an edge where this hypothesis is assigned to
427 on all other edges that are at the opposite side in case of quadrangular faces
428 This hypothesis should be assigned to an edge to propagate a hypothesis from.
431 return self.Hypothesis("Propagation", UseExisting=1, CompareMethod=self.CompareEqualHyp)
433 def PropagationOfDistribution(self):
435 Defines "Propagation of Node Distribution" hypothesis that propagates
436 distribution of nodes from an edge where this hypothesis is assigned to,
437 to opposite edges of quadrangular faces, so that number of segments on all these
438 edges will be the same, as well as relations between segment lengths.
441 return self.Hypothesis("PropagOfDistribution", UseExisting=1,
442 CompareMethod=self.CompareEqualHyp)
444 def AutomaticLength(self, fineness=0, UseExisting=0):
446 Defines "AutomaticLength" hypothesis
449 fineness: for the fineness [0-1]
450 UseExisting: if ==true - searches for an existing hypothesis created with the
451 same parameters, else (default) - create a new one
454 from salome.smesh.smeshBuilder import IsEqual
455 compFun = lambda hyp, args: IsEqual(hyp.GetFineness(), args[0])
456 hyp = self.Hypothesis("AutomaticLength",[fineness],UseExisting=UseExisting,
457 CompareMethod=compFun)
458 hyp.SetFineness( fineness )
461 def LengthNearVertex(self, length, vertex=0, UseExisting=0):
463 Defines "SegmentLengthAroundVertex" hypothesis
466 length: for the segment length
467 vertex: for the length localization: the vertex index [0,1] | vertex object.
468 Any other integer value means that the hypothesis will be set on the
469 whole 1D shape, where Mesh_Segment algorithm is assigned.
470 UseExisting: if ==true - searches for an existing hypothesis created with
471 the same parameters, else (default) - creates a new one
475 store_geom = self.geom
476 if type(vertex) is types.IntType:
477 if vertex == 0 or vertex == 1:
478 from salome.geom import geomBuilder
479 vertex = self.mesh.geompyD.ExtractShapes(self.geom, geomBuilder.geomBuilder.ShapeType["VERTEX"],True)[vertex]
487 if self.geom is None:
488 self.geom = store_geom
489 raise RuntimeError, "Attempt to create SegmentAroundVertex_0D algorithm on None shape"
490 from salome.smesh.smeshBuilder import AssureGeomPublished, GetName, TreatHypoStatus
491 AssureGeomPublished( self.mesh, self.geom )
492 name = GetName(self.geom)
494 algo = self.FindAlgorithm("SegmentAroundVertex_0D", self.mesh.smeshpyD)
496 algo = self.mesh.smeshpyD.CreateHypothesis("SegmentAroundVertex_0D", "libStdMeshersEngine.so")
498 status = self.mesh.mesh.AddHypothesis(self.geom, algo)
499 TreatHypoStatus(status, "SegmentAroundVertex_0D", name, True, self.mesh)
501 from salome.smesh.smeshBuilder import IsEqual
502 comFun = lambda hyp, args: IsEqual(hyp.GetLength(), args[0])
503 hyp = self.Hypothesis("SegmentLengthAroundVertex", [length], UseExisting=UseExisting,
504 CompareMethod=comFun)
505 self.geom = store_geom
506 hyp.SetLength( length )
509 def QuadraticMesh(self):
511 Defines "QuadraticMesh" hypothesis, forcing construction of quadratic edges.
512 If the 2D mesher sees that all boundary edges are quadratic,
513 it generates quadratic faces, else it generates linear faces using
514 medium nodes as if they are vertices.
515 The 3D mesher generates quadratic volumes only if all boundary faces
516 are quadratic, else it fails.
519 hyp = self.Hypothesis("QuadraticMesh", UseExisting=1, CompareMethod=self.CompareEqualHyp)
522 pass # end of StdMeshersBuilder_Segment class
524 class StdMeshersBuilder_CompositeSegment(StdMeshersBuilder_Segment):
526 Segment 1D algorithm for discretization of a set of adjacent edges as one edge.
528 It is created by calling smeshBuilder.Mesh.Segment(smeshBuilder.COMPOSITE,geom=0)
532 meshMethod = "Segment"
534 name of the dynamic method in smeshBuilder.Mesh class
539 type of algorithm used with helper function in smeshBuilder.Mesh class
544 flag pointing whether this algorithm should be used by default in dynamic method
545 of smeshBuilder.Mesh class
548 docHelper = "Creates segment 1D algorithm for edges"
550 doc string of the method
553 def __init__(self, mesh, geom=0):
558 mesh: parent mesh object algorithm is assigned to
559 geom: geometry (shape/sub-shape) algorithm is assigned to;
560 if it is :code:`0` (default), the algorithm is assigned to the main shape
562 self.Create(mesh, geom, self.algoType)
565 pass # end of StdMeshersBuilder_CompositeSegment class
567 class StdMeshersBuilder_Segment_Python(Mesh_Algorithm):
569 Defines a segment 1D algorithm for discretization of edges with Python function
570 It is created by calling smeshBuilder.Mesh.Segment(smeshBuilder.PYTHON,geom=0)
574 meshMethod = "Segment"
576 name of the dynamic method in smeshBuilder.Mesh class
580 type of algorithm used with helper function in smeshBuilder.Mesh class
582 docHelper = "Creates segment 1D algorithm for edges"
584 doc string of the method
587 def __init__(self, mesh, geom=0):
592 mesh: parent mesh object algorithm is assigned to
593 geom: geometry (shape/sub-shape) algorithm is assigned to;
594 if it is :code:`0` (default), the algorithm is assigned to the main shape
596 import Python1dPlugin
597 self.Create(mesh, geom, self.algoType, "libPython1dEngine.so")
600 def PythonSplit1D(self, n, func, UseExisting=0):
602 Defines "PythonSplit1D" hypothesis
605 n: for the number of segments that cut an edge
606 func: for the python function that calculates the length of all segments
607 UseExisting: if ==true - searches for the existing hypothesis created with
608 the same parameters, else (default) - creates a new one
611 compFun = lambda hyp, args: False
612 hyp = self.Hypothesis("PythonSplit1D", [n], "libPython1dEngine.so",
613 UseExisting=UseExisting, CompareMethod=compFun)
614 hyp.SetNumberOfSegments(n)
615 hyp.SetPythonLog10RatioFunction(func)
618 pass # end of StdMeshersBuilder_Segment_Python class
620 class StdMeshersBuilder_Triangle_MEFISTO(Mesh_Algorithm):
622 Triangle MEFISTO 2D algorithm
623 It is created by calling smeshBuilder.Mesh.Triangle(smeshBuilder.MEFISTO,geom=0)
627 meshMethod = "Triangle"
629 name of the dynamic method in smeshBuilder.Mesh class
633 type of algorithm used with helper function in smeshBuilder.Mesh class
637 flag pointing whether this algorithm should be used by default in dynamic method
638 of smeshBuilder.Mesh class
640 docHelper = "Creates triangle 2D algorithm for faces"
642 doc string of the method
645 def __init__(self, mesh, geom=0):
650 mesh: parent mesh object algorithm is assigned to
651 geom: geometry (shape/sub-shape) algorithm is assigned to;
652 if it is :code:`0` (default), the algorithm is assigned to the main shape
654 Mesh_Algorithm.__init__(self)
655 self.Create(mesh, geom, self.algoType)
658 def MaxElementArea(self, area, UseExisting=0):
660 Defines "MaxElementArea" hypothesis basing on the definition of the maximum area of each triangle
663 area: for the maximum area of each triangle
664 UseExisting: if ==true - searches for an existing hypothesis created with the
665 same parameters, else (default) - creates a new one
668 from salome.smesh.smeshBuilder import IsEqual
669 comparator = lambda hyp, args: IsEqual(hyp.GetMaxElementArea(), args[0])
670 hyp = self.Hypothesis("MaxElementArea", [area], UseExisting=UseExisting,
671 CompareMethod=comparator)
672 hyp.SetMaxElementArea(area)
675 def LengthFromEdges(self):
677 Defines "LengthFromEdges" hypothesis to build triangles
678 based on the length of the edges taken from the wire
681 hyp = self.Hypothesis("LengthFromEdges", UseExisting=1, CompareMethod=self.CompareEqualHyp)
684 pass # end of StdMeshersBuilder_Triangle_MEFISTO class
686 class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
688 Defines a quadrangle 2D algorithm
689 It is created by calling smeshBuilder.Mesh.Quadrangle(geom=0)
693 meshMethod = "Quadrangle"
695 name of the dynamic method in smeshBuilder.Mesh class
697 algoType = QUADRANGLE
699 type of algorithm used with helper function in smeshBuilder.Mesh class
703 flag pointing whether this algorithm should be used by default in dynamic method
704 of smeshBuilder.Mesh class
706 docHelper = "Creates quadrangle 2D algorithm for faces"
708 doc string of the method
712 hypothesis associated with algorithm
715 def __init__(self, mesh, geom=0):
720 mesh: parent mesh object algorithm is assigned to
721 geom: geometry (shape/sub-shape) algorithm is assigned to;
722 if it is :code:`0` (default), the algorithm is assigned to the main shape
724 Mesh_Algorithm.__init__(self)
725 self.Create(mesh, geom, self.algoType)
728 def QuadrangleParameters(self, quadType=StdMeshers.QUAD_STANDARD, triangleVertex=0,
729 enfVertices=[],enfPoints=[],UseExisting=0):
731 Defines "QuadrangleParameters" hypothesis
732 quadType defines the algorithm of transition between differently descretized
733 sides of a geometrical face:
735 - QUAD_STANDARD - both triangles and quadrangles are possible in the transition
736 area along the finer meshed sides.
737 - QUAD_TRIANGLE_PREF - only triangles are built in the transition area along the
739 - QUAD_QUADRANGLE_PREF - only quadrangles are built in the transition area along
740 the finer meshed sides, iff the total quantity of segments on
741 all four sides of the face is even (divisible by 2).
742 - QUAD_QUADRANGLE_PREF_REVERSED - same as QUAD_QUADRANGLE_PREF but the transition
743 area is located along the coarser meshed sides.
744 - QUAD_REDUCED - only quadrangles are built and the transition between the sides
745 is made gradually, layer by layer. This type has a limitation on
746 the number of segments: one pair of opposite sides must have the
747 same number of segments, the other pair must have an even difference
748 between the numbers of segments on the sides.
751 triangleVertex: vertex of a trilateral geometrical face, around which triangles
752 will be created while other elements will be quadrangles.
753 Vertex can be either a GEOM_Object or a vertex ID within the
755 enfVertices: list of shapes defining positions where nodes (enforced nodes)
756 must be created by the mesher. Shapes can be of any type,
757 vertices of given shapes define positions of enforced nodes.
758 Only vertices successfully projected to the face are used.
759 enfPoints: list of points giving positions of enforced nodes.
760 Point can be defined either as SMESH.PointStruct's
761 ([SMESH.PointStruct(x1,y1,z1), SMESH.PointStruct(x2,y2,z2),...])
762 or triples of values ([[x1,y1,z1], [x2,y2,z2], ...]).
763 In the case if the defined QuadrangleParameters() refer to a sole face,
764 all given points must lie on this face, else the mesher fails.
765 UseExisting: if *True* - searches for the existing hypothesis created with
766 the same parameters, else (default) - creates a new one
771 vertexID = triangleVertex
772 if isinstance( triangleVertex, GEOM._objref_GEOM_Object ):
773 vertexID = self.mesh.geompyD.GetSubShapeID( self.mesh.geom, triangleVertex )
774 if isinstance( enfVertices, int ) and not enfPoints and not UseExisting:
775 # a call of old syntax, before inserting enfVertices and enfPoints before UseExisting
776 UseExisting, enfVertices = enfVertices, []
777 pStructs, xyz = [], []
779 if isinstance( p, SMESH.PointStruct ):
780 xyz.append(( p.x, p.y, p.z ))
783 xyz.append(( p[0], p[1], p[2] ))
784 pStructs.append( SMESH.PointStruct( p[0], p[1], p[2] ))
786 compFun = lambda hyp,args: \
787 hyp.GetQuadType() == args[0] and \
788 (hyp.GetTriaVertex()==args[1] or ( hyp.GetTriaVertex()<1 and args[1]<1)) and \
789 ((hyp.GetEnforcedNodes()) == (args[2],args[3])) # True w/o enfVertices only
790 entries = [ shape.GetStudyEntry() for shape in enfVertices ]
791 self.params = self.Hypothesis("QuadrangleParams", [quadType,vertexID,entries,xyz],
792 UseExisting = UseExisting, CompareMethod=compFun)
794 if self.params.GetQuadType() != quadType:
795 self.params.SetQuadType(quadType)
797 self.params.SetTriaVertex( vertexID )
798 from salome.smesh.smeshBuilder import AssureGeomPublished
799 for v in enfVertices:
800 AssureGeomPublished( self.mesh, v )
801 self.params.SetEnforcedNodes( enfVertices, pStructs )
804 def QuadranglePreference(self, reversed=False, UseExisting=0):
806 Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only
807 quadrangles are built in the transition area along the finer meshed sides,
808 if the total quantity of segments on all four sides of the face is even.
811 reversed: if True, transition area is located along the coarser meshed sides.
812 UseExisting: if ==true - searches for the existing hypothesis created with
813 the same parameters, else (default) - creates a new one
817 return self.QuadrangleParameters(QUAD_QUADRANGLE_PREF_REVERSED,UseExisting=UseExisting)
818 return self.QuadrangleParameters(QUAD_QUADRANGLE_PREF,UseExisting=UseExisting)
820 def TrianglePreference(self, UseExisting=0):
822 Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only
823 triangles are built in the transition area along the finer meshed sides.
826 UseExisting: if ==true - searches for the existing hypothesis created with
827 the same parameters, else (default) - creates a new one
830 return self.QuadrangleParameters(QUAD_TRIANGLE_PREF,UseExisting=UseExisting)
832 def Reduced(self, UseExisting=0):
834 Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only
835 quadrangles are built and the transition between the sides is made gradually,
836 layer by layer. This type has a limitation on the number of segments: one pair
837 of opposite sides must have the same number of segments, the other pair must
838 have an even difference between the numbers of segments on the sides.
841 UseExisting: if ==true - searches for the existing hypothesis created with
842 the same parameters, else (default) - creates a new one
845 return self.QuadrangleParameters(QUAD_REDUCED,UseExisting=UseExisting)
847 def TriangleVertex(self, vertex, UseExisting=0):
849 Defines "QuadrangleParams" hypothesis with QUAD_STANDARD type of quadrangulation
852 vertex: vertex of a trilateral geometrical face, around which triangles
853 will be created while other elements will be quadrangles.
854 Vertex can be either a GEOM_Object or a vertex ID within the
856 UseExisting: if ==true - searches for the existing hypothesis created with
857 the same parameters, else (default) - creates a new one
860 return self.QuadrangleParameters(QUAD_STANDARD,vertex,UseExisting)
862 pass # end of StdMeshersBuilder_Quadrangle class
864 class StdMeshersBuilder_Hexahedron(Mesh_Algorithm):
866 Defines a hexahedron 3D algorithm
867 It is created by calling smeshBuilder.Mesh.Hexahedron(geom=0)
871 meshMethod = "Hexahedron"
873 name of the dynamic method in smeshBuilder.Mesh class
877 type of algorithm used with helper function in smeshBuilder.Mesh class
881 flag pointing whether this algorithm should be used by default in dynamic method
882 of smeshBuilder.Mesh class
884 docHelper = "Creates hexahedron 3D algorithm for volumes"
886 doc string of the method
889 def __init__(self, mesh, geom=0):
894 mesh: parent mesh object algorithm is assigned to
895 geom: geometry (shape/sub-shape) algorithm is assigned to;
896 if it is :code:`0` (default), the algorithm is assigned to the main shape
898 Mesh_Algorithm.__init__(self)
899 self.Create(mesh, geom, Hexa)
902 pass # end of StdMeshersBuilder_Hexahedron class
904 class StdMeshersBuilder_Projection1D(Mesh_Algorithm):
906 Defines a projection 1D algorithm
907 It is created by calling smeshBuilder.Mesh.Projection1D(geom=0)
911 meshMethod = "Projection1D"
913 name of the dynamic method in smeshBuilder.Mesh class
915 algoType = "Projection_1D"
917 type of algorithm used with helper function in smeshBuilder.Mesh class
921 flag pointing whether this algorithm should be used by default in dynamic method
922 of smeshBuilder.Mesh class
924 docHelper = "Creates projection 1D algorithm for edges"
926 doc string of the method
928 def __init__(self, mesh, geom=0):
933 mesh: parent mesh object algorithm is assigned to
934 geom: geometry (shape/sub-shape) algorithm is assigned to;
935 if it is :code:`0` (default), the algorithm is assigned to the main shape
937 Mesh_Algorithm.__init__(self)
938 self.Create(mesh, geom, self.algoType)
941 def SourceEdge(self, edge, mesh=None, srcV=None, tgtV=None, UseExisting=0):
943 Defines "Source Edge" hypothesis, specifying a meshed edge, from where
944 a mesh pattern is taken, and, optionally, the association of vertices
945 between the source edge and a target edge (to which a hypothesis is assigned)
948 edge: from which nodes distribution is taken
949 mesh: from which nodes distribution is taken (optional)
950 srcV: a vertex of *edge* to associate with *tgtV* (optional)
951 tgtV: a vertex of *the edge* to which the algorithm is assigned, to associate with *srcV* (optional)
952 UseExisting: if ==true - searches for the existing hypothesis created with
953 the same parameters, else (default) - creates a new one
955 from salome.smesh.smeshBuilder import AssureGeomPublished, Mesh
956 AssureGeomPublished( self.mesh, edge )
957 AssureGeomPublished( self.mesh, srcV )
958 AssureGeomPublished( self.mesh, tgtV )
959 hyp = self.Hypothesis("ProjectionSource1D", [edge,mesh,srcV,tgtV],
961 # it does not seem to be useful to reuse the existing "SourceEdge" hypothesis
962 #UseExisting=UseExisting, CompareMethod=self.CompareSourceEdge)
963 hyp.SetSourceEdge( edge )
964 if not mesh is None and isinstance(mesh, Mesh):
965 mesh = mesh.GetMesh()
966 hyp.SetSourceMesh( mesh )
967 hyp.SetVertexAssociation( srcV, tgtV )
970 pass # end of StdMeshersBuilder_Projection1D class
972 class StdMeshersBuilder_Projection2D(Mesh_Algorithm):
974 Defines a projection 2D algorithm
975 It is created by calling smeshBuilder.Mesh.Projection2D(geom=0)
979 meshMethod = "Projection2D"
981 name of the dynamic method in smeshBuilder.Mesh class
983 algoType = "Projection_2D"
985 type of algorithm used with helper function in smeshBuilder.Mesh class
989 flag pointing whether this algorithm should be used by default in dynamic method
990 of smeshBuilder.Mesh class
992 docHelper = "Creates projection 2D algorithm for faces"
994 doc string of the method
997 def __init__(self, mesh, geom=0):
1002 mesh: parent mesh object algorithm is assigned to
1003 geom: geometry (shape/sub-shape) algorithm is assigned to;
1004 if it is :code:`0` (default), the algorithm is assigned to the main shape
1006 Mesh_Algorithm.__init__(self)
1007 self.Create(mesh, geom, self.algoType)
1011 def SourceFace(self, face, mesh=None, srcV1=None, tgtV1=None,
1012 srcV2=None, tgtV2=None, UseExisting=0):
1014 Defines "Source Face" hypothesis, specifying a meshed face, from where
1015 a mesh pattern is taken, and, optionally, the association of vertices
1016 between the source face and the target face (to which a hypothesis is assigned)
1019 face: from which the mesh pattern is taken
1020 mesh: from which the mesh pattern is taken (optional)
1021 srcV1: a vertex of *face* to associate with *tgtV1* (optional)
1022 tgtV1: a vertex of *the face* to which the algorithm is assigned, to associate with *srcV1* (optional)
1023 srcV2: a vertex of *face* to associate with *tgtV1* (optional)
1024 tgtV2: a vertex of *the face* to which the algorithm is assigned, to associate with *srcV2* (optional)
1025 UseExisting: if ==true - forces the search for the existing hypothesis created with
1026 he same parameters, else (default) - forces the creation a new one
1029 all association vertices must belong to one edge of a face
1031 from salome.smesh.smeshBuilder import Mesh
1032 if isinstance(mesh, Mesh):
1033 mesh = mesh.GetMesh()
1034 for geom in [ face, srcV1, tgtV1, srcV2, tgtV2 ]:
1035 from salome.smesh.smeshBuilder import AssureGeomPublished
1036 AssureGeomPublished( self.mesh, geom )
1037 hyp = self.Hypothesis("ProjectionSource2D", [face,mesh,srcV1,tgtV1,srcV2,tgtV2],
1038 UseExisting=0, toAdd=False)
1039 # it does not seem to be useful to reuse the existing "SourceFace" hypothesis
1040 #UseExisting=UseExisting, CompareMethod=self.CompareSourceFace)
1041 hyp.SetSourceFace( face )
1042 hyp.SetSourceMesh( mesh )
1043 hyp.SetVertexAssociation( srcV1, srcV2, tgtV1, tgtV2 )
1044 self.mesh.AddHypothesis(hyp, self.geom)
1047 pass # end of StdMeshersBuilder_Projection2D class
1049 class StdMeshersBuilder_Projection1D2D(StdMeshersBuilder_Projection2D):
1051 Defines a projection 1D-2D algorithm
1052 It is created by calling smeshBuilder.Mesh.Projection1D2D(geom=0)
1056 meshMethod = "Projection1D2D"
1058 name of the dynamic method in smeshBuilder.Mesh class
1060 algoType = "Projection_1D2D"
1062 type of algorithm used with helper function in smeshBuilder.Mesh class
1064 docHelper = "Creates projection 1D-2D algorithm for faces"
1066 doc string of the method
1069 def __init__(self, mesh, geom=0):
1071 Private constructor.
1074 mesh: parent mesh object algorithm is assigned to
1075 geom: geometry (shape/sub-shape) algorithm is assigned to;
1076 if it is :code:`0` (default), the algorithm is assigned to the main shape
1078 StdMeshersBuilder_Projection2D.__init__(self, mesh, geom)
1081 pass # end of StdMeshersBuilder_Projection1D2D class
1083 class StdMeshersBuilder_Projection3D(Mesh_Algorithm):
1085 Defines a projection 3D algorithm
1086 It is created by calling smeshBuilder.Mesh.Projection3D(geom=0)
1090 meshMethod = "Projection3D"
1092 name of the dynamic method in smeshBuilder.Mesh class
1094 algoType = "Projection_3D"
1096 type of algorithm used with helper function in smeshBuilder.Mesh class
1098 docHelper = "Creates projection 3D algorithm for volumes"
1100 doc string of the method
1103 def __init__(self, mesh, geom=0):
1105 Private constructor.
1108 mesh: parent mesh object algorithm is assigned to
1109 geom" geometry (shape/sub-shape) algorithm is assigned to;
1110 if it is :code:`0` (default), the algorithm is assigned to the main shape
1112 Mesh_Algorithm.__init__(self)
1113 self.Create(mesh, geom, self.algoType)
1116 def SourceShape3D(self, solid, mesh=0, srcV1=0, tgtV1=0,
1117 srcV2=0, tgtV2=0, UseExisting=0):
1119 Defines the "Source Shape 3D" hypothesis, specifying a meshed solid, from where
1120 the mesh pattern is taken, and, optionally, the association of vertices
1121 between the source and the target solid (to which a hipothesis is assigned)
1124 solid: from where the mesh pattern is taken
1125 mesh: from where the mesh pattern is taken (optional)
1126 srcV1: a vertex of *solid* to associate with *tgtV1* (optional)
1127 tgtV1: a vertex of *the solid* where the algorithm is assigned, to associate with *srcV1* (optional)
1128 srcV2: a vertex of *solid* to associate with *tgtV1* (optional)
1129 tgtV2: a vertex of *the solid* to which the algorithm is assigned,to associate with *srcV2* (optional)
1130 UseExisting: if ==true - searches for the existing hypothesis created with
1131 the same parameters, else (default) - creates a new one
1134 association vertices must belong to one edge of a solid
1136 for geom in [ solid, srcV1, tgtV1, srcV2, tgtV2 ]:
1137 from salome.smesh.smeshBuilder import AssureGeomPublished
1138 AssureGeomPublished( self.mesh, geom )
1139 hyp = self.Hypothesis("ProjectionSource3D",
1140 [solid,mesh,srcV1,tgtV1,srcV2,tgtV2],
1142 # seems to be not really useful to reuse existing "SourceShape3D" hypothesis
1143 #UseExisting=UseExisting, CompareMethod=self.CompareSourceShape3D)
1144 hyp.SetSource3DShape( solid )
1145 from salome.smesh.smeshBuilder import Mesh
1146 if isinstance(mesh, Mesh):
1147 mesh = mesh.GetMesh()
1149 hyp.SetSourceMesh( mesh )
1150 if srcV1 and srcV2 and tgtV1 and tgtV2:
1151 hyp.SetVertexAssociation( srcV1, srcV2, tgtV1, tgtV2 )
1152 #elif srcV1 or srcV2 or tgtV1 or tgtV2:
1155 pass # end of StdMeshersBuilder_Projection3D class
1157 class StdMeshersBuilder_Prism3D(Mesh_Algorithm):
1159 Defines a Prism 3D algorithm, which is either "Extrusion 3D" or "Radial Prism" depending on geometry
1160 It is created by calling smeshBuilder.Mesh.Prism(geom=0)
1164 meshMethod = "Prism"
1166 name of the dynamic method in smeshBuilder.Mesh class
1168 algoType = "Prism_3D"
1170 type of algorithm used with helper function in smeshBuilder.Mesh class
1172 docHelper = "Creates prism 3D algorithm for volumes"
1174 doc string of the method
1178 flag pointing whether this algorithm should be used by default in dynamic method
1179 of smeshBuilder.Mesh class
1182 def __init__(self, mesh, geom=0):
1184 Private constructor.
1187 mesh: parent mesh object algorithm is assigned to
1188 geom: geometry (shape/sub-shape) algorithm is assigned to;
1189 if it is :code:`0` (default), the algorithm is assigned to the main shape
1191 Mesh_Algorithm.__init__(self)
1196 isRadial = mesh.smeshpyD.IsApplicable("RadialPrism_3D", LIBRARY, shape, False )
1198 self.Create(mesh, geom, "Prism_3D")
1201 self.algoType = "RadialPrism_3D"
1202 self.Create(mesh, geom, "RadialPrism_3D")
1203 self.distribHyp = None #self.Hypothesis("LayerDistribution", UseExisting=0)
1204 self.nbLayers = None
1208 def Get3DHypothesis(self):
1211 3D hypothesis holding the 1D one
1213 if self.algoType != "RadialPrism_3D":
1214 print "Prism_3D algorithm doesn't support any hypothesis"
1216 return self.distribHyp
1218 def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"):
1220 Private method creating a 1D hypothesis and storing it in the LayerDistribution
1224 the created hypothesis
1226 if self.algoType != "RadialPrism_3D":
1227 print "Prism_3D algorithm doesn't support any hypothesis"
1229 if not self.nbLayers is None:
1230 self.mesh.GetMesh().RemoveHypothesis( self.geom, self.nbLayers )
1231 self.mesh.GetMesh().AddHypothesis( self.geom, self.distribHyp )
1232 study = self.mesh.smeshpyD.GetCurrentStudy() # prevents publishing own 1D hypothesis
1233 self.mesh.smeshpyD.SetCurrentStudy( None )
1234 hyp = self.mesh.smeshpyD.CreateHypothesis(hypType, so)
1235 self.mesh.smeshpyD.SetCurrentStudy( study ) # enables publishing
1236 if not self.distribHyp:
1237 self.distribHyp = self.Hypothesis("LayerDistribution", UseExisting=0)
1238 self.distribHyp.SetLayerDistribution( hyp )
1241 def NumberOfLayers(self, n, UseExisting=0):
1243 Defines "NumberOfLayers" hypothesis, specifying the number of layers of
1244 prisms to build between the inner and outer shells
1248 UseExisting: if ==true - searches for the existing hypothesis created with
1249 the same parameters, else (default) - creates a new one
1251 if self.algoType != "RadialPrism_3D":
1252 print "Prism_3D algorithm doesn't support any hypothesis"
1254 self.mesh.RemoveHypothesis( self.distribHyp, self.geom )
1255 from salome.smesh.smeshBuilder import IsEqual
1256 compFun = lambda hyp, args: IsEqual(hyp.GetNumberOfLayers(), args[0])
1257 self.nbLayers = self.Hypothesis("NumberOfLayers", [n], UseExisting=UseExisting,
1258 CompareMethod=compFun)
1259 self.nbLayers.SetNumberOfLayers( n )
1260 return self.nbLayers
1262 def LocalLength(self, l, p=1e-07):
1264 Defines "LocalLength" hypothesis, specifying the segment length
1265 to build between the inner and the outer shells
1268 l: the length of segments
1269 p: the precision of rounding
1271 if self.algoType != "RadialPrism_3D":
1272 print "Prism_3D algorithm doesn't support any hypothesis"
1274 hyp = self.OwnHypothesis("LocalLength", [l,p])
1279 def NumberOfSegments(self, n, s=[]):
1281 Defines "NumberOfSegments" hypothesis, specifying the number of layers of
1282 prisms to build between the inner and the outer shells.
1285 n: the number of layers
1286 s: the scale factor (optional)
1288 if self.algoType != "RadialPrism_3D":
1289 print "Prism_3D algorithm doesn't support any hypothesis"
1292 hyp = self.OwnHypothesis("NumberOfSegments", [n])
1294 hyp = self.OwnHypothesis("NumberOfSegments", [n,s])
1295 hyp.SetScaleFactor(s)
1296 hyp.SetNumberOfSegments(n)
1299 def Arithmetic1D(self, start, end ):
1301 Defines "Arithmetic1D" hypothesis, specifying the distribution of segments
1302 to build between the inner and the outer shells with a length that changes
1303 in arithmetic progression
1306 start: the length of the first segment
1307 end: the length of the last segment
1309 if self.algoType != "RadialPrism_3D":
1310 print "Prism_3D algorithm doesn't support any hypothesis"
1312 hyp = self.OwnHypothesis("Arithmetic1D", [start, end])
1313 hyp.SetLength(start, 1)
1314 hyp.SetLength(end , 0)
1317 def GeometricProgression(self, start, ratio ):
1319 Defines "GeometricProgression" hypothesis, specifying the distribution of segments
1320 to build between the inner and the outer shells with a length that changes
1321 in Geometric progression
1324 start: the length of the first segment
1325 ratio: the common ratio of the geometric progression
1327 if self.algoType != "RadialPrism_3D":
1328 print "Prism_3D algorithm doesn't support any hypothesis"
1330 hyp = self.OwnHypothesis("GeometricProgression", [start, ratio])
1331 hyp.SetStartLength( start )
1332 hyp.SetCommonRatio( ratio )
1335 def StartEndLength(self, start, end):
1337 Defines "StartEndLength" hypothesis, specifying distribution of segments
1338 to build between the inner and the outer shells as geometric length increasing
1341 start: for the length of the first segment
1342 end: for the length of the last segment
1344 if self.algoType != "RadialPrism_3D":
1345 print "Prism_3D algorithm doesn't support any hypothesis"
1347 hyp = self.OwnHypothesis("StartEndLength", [start, end])
1348 hyp.SetLength(start, 1)
1349 hyp.SetLength(end , 0)
1352 def AutomaticLength(self, fineness=0):
1354 Defines "AutomaticLength" hypothesis, specifying the number of segments
1355 to build between the inner and outer shells
1358 fineness: defines the quality of the mesh within the range [0-1]
1360 if self.algoType != "RadialPrism_3D":
1361 print "Prism_3D algorithm doesn't support any hypothesis"
1363 hyp = self.OwnHypothesis("AutomaticLength")
1364 hyp.SetFineness( fineness )
1367 pass # end of StdMeshersBuilder_Prism3D class
1369 class StdMeshersBuilder_RadialPrism3D(StdMeshersBuilder_Prism3D):
1371 Defines Radial Prism 3D algorithm
1372 It is created by calling smeshBuilder.Mesh.Prism(geom=0)
1376 meshMethod = "Prism"
1378 name of the dynamic method in smeshBuilder.Mesh class
1380 algoType = "RadialPrism_3D"
1382 type of algorithm used with helper function in smeshBuilder.Mesh class
1384 docHelper = "Creates Raial Prism 3D algorithm for volumes"
1386 doc string of the method
1389 def __init__(self, mesh, geom=0):
1391 Private constructor.
1394 mesh: parent mesh object algorithm is assigned to
1395 geom: geometry (shape/sub-shape) algorithm is assigned to;
1396 if it is :code:`0` (default), the algorithm is assigned to the main shape
1398 Mesh_Algorithm.__init__(self)
1403 self.Create(mesh, geom, "RadialPrism_3D")
1404 self.distribHyp = None
1405 self.nbLayers = None
1408 class StdMeshersBuilder_RadialAlgorithm(Mesh_Algorithm):
1410 Base class for algorithms supporting radial distribution hypotheses
1414 Mesh_Algorithm.__init__(self)
1416 self.distribHyp = None #self.Hypothesis("LayerDistribution2D", UseExisting=0)
1417 self.nbLayers = None
1420 def Get2DHypothesis(self):
1423 2D hypothesis holding the 1D one
1425 if not self.distribHyp:
1426 self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0)
1427 return self.distribHyp
1429 def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"):
1431 Private method creating a 1D hypothesis and storing it in the LayerDistribution
1435 the created hypothesis
1438 self.mesh.GetMesh().RemoveHypothesis( self.geom, self.nbLayers )
1439 if self.distribHyp is None:
1440 self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0)
1442 self.mesh.GetMesh().AddHypothesis( self.geom, self.distribHyp )
1443 study = self.mesh.smeshpyD.GetCurrentStudy() # prevents publishing own 1D hypothesis
1444 self.mesh.smeshpyD.SetCurrentStudy( None )
1445 hyp = self.mesh.smeshpyD.CreateHypothesis(hypType, so)
1446 self.mesh.smeshpyD.SetCurrentStudy( study ) # enables publishing
1447 self.distribHyp.SetLayerDistribution( hyp )
1450 def NumberOfLayers(self, n, UseExisting=0):
1452 Defines "NumberOfLayers" hypothesis, specifying the number of layers
1456 UseExisting: if ==true - searches for the existing hypothesis created with
1457 the same parameters, else (default) - creates a new one
1460 self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp )
1461 from salome.smesh.smeshBuilder import IsEqual
1462 compFun = lambda hyp, args: IsEqual(hyp.GetNumberOfLayers(), args[0])
1463 self.nbLayers = self.Hypothesis("NumberOfLayers2D", [n], UseExisting=UseExisting,
1464 CompareMethod=compFun)
1465 self.nbLayers.SetNumberOfLayers( n )
1466 return self.nbLayers
1468 def LocalLength(self, l, p=1e-07):
1470 Defines "LocalLength" hypothesis, specifying the segment length
1473 l: the length of segments
1474 p: the precision of rounding
1476 hyp = self.OwnHypothesis("LocalLength", [l,p])
1481 def NumberOfSegments(self, n, s=[]):
1483 Defines "NumberOfSegments" hypothesis, specifying the number of layers
1486 n: the number of layers
1487 s: the scale factor (optional)
1490 hyp = self.OwnHypothesis("NumberOfSegments", [n])
1492 hyp = self.OwnHypothesis("NumberOfSegments", [n,s])
1493 hyp.SetDistrType( 1 )
1494 hyp.SetScaleFactor(s)
1495 hyp.SetNumberOfSegments(n)
1498 def Arithmetic1D(self, start, end ):
1500 Defines "Arithmetic1D" hypothesis, specifying the distribution of segments
1501 with a length that changes in arithmetic progression
1504 start: the length of the first segment
1505 end: the length of the last segment
1507 hyp = self.OwnHypothesis("Arithmetic1D", [start, end])
1508 hyp.SetLength(start, 1)
1509 hyp.SetLength(end , 0)
1512 def GeometricProgression(self, start, ratio ):
1514 Defines "GeometricProgression" hypothesis, specifying the distribution of segments
1515 with a length that changes in Geometric progression
1518 start: the length of the first segment
1519 ratio: the common ratio of the geometric progression
1521 hyp = self.OwnHypothesis("GeometricProgression", [start, ratio])
1522 hyp.SetStartLength( start )
1523 hyp.SetCommonRatio( ratio )
1526 def StartEndLength(self, start, end):
1528 Defines "StartEndLength" hypothesis, specifying distribution of segments
1529 as geometric length increasing
1532 start: for the length of the first segment
1533 end: for the length of the last segment
1535 hyp = self.OwnHypothesis("StartEndLength", [start, end])
1536 hyp.SetLength(start, 1)
1537 hyp.SetLength(end , 0)
1540 def AutomaticLength(self, fineness=0):
1542 Defines "AutomaticLength" hypothesis, specifying the number of segments
1545 fineness: defines the quality of the mesh within the range [0-1]
1547 hyp = self.OwnHypothesis("AutomaticLength")
1548 hyp.SetFineness( fineness )
1551 pass # end of StdMeshersBuilder_RadialQuadrangle1D2D class
1553 class StdMeshersBuilder_RadialQuadrangle1D2D(StdMeshersBuilder_RadialAlgorithm):
1555 Defines a Radial Quadrangle 1D-2D algorithm
1556 It is created by calling smeshBuilder.Mesh.Quadrangle(smeshBuilder.RADIAL_QUAD,geom=0)
1559 meshMethod = "Quadrangle"
1561 name of the dynamic method in smeshBuilder.Mesh class
1563 algoType = RADIAL_QUAD
1565 type of algorithm used with helper function in smeshBuilder.Mesh class
1567 docHelper = "Creates quadrangle 1D-2D algorithm for faces having a shape of disk or a disk segment"
1569 doc string of the method
1572 def __init__(self, mesh, geom=0):
1574 Private constructor.
1577 mesh: parent mesh object algorithm is assigned to
1578 geom: geometry (shape/sub-shape) algorithm is assigned to;
1579 if it is :code:`0` (default), the algorithm is assigned to the main shape
1581 StdMeshersBuilder_RadialAlgorithm.__init__(self)
1582 self.Create(mesh, geom, self.algoType)
1584 self.distribHyp = None #self.Hypothesis("LayerDistribution2D", UseExisting=0)
1585 self.nbLayers = None
1589 class StdMeshersBuilder_QuadMA_1D2D(StdMeshersBuilder_RadialAlgorithm):
1591 Defines a Quadrangle (Medial Axis Projection) 1D-2D algorithm
1592 It is created by calling smeshBuilder.Mesh.Quadrangle(smeshBuilder.QUAD_MA_PROJ,geom=0)
1595 meshMethod = "Quadrangle"
1597 name of the dynamic method in smeshBuilder.Mesh class
1599 algoType = QUAD_MA_PROJ
1601 type of algorithm used with helper function in smeshBuilder.Mesh class
1603 docHelper = "Creates quadrangle 1D-2D algorithm for faces"
1605 doc string of the method
1608 def __init__(self, mesh, geom=0):
1610 Private constructor.
1613 mesh: parent mesh object algorithm is assigned to
1614 geom: geometry (shape/sub-shape) algorithm is assigned to;
1615 if it is :code:`0` (default), the algorithm is assigned to the main shape
1617 StdMeshersBuilder_RadialAlgorithm.__init__(self)
1618 self.Create(mesh, geom, self.algoType)
1623 class StdMeshersBuilder_PolygonPerFace(Mesh_Algorithm):
1624 """ Defines a Polygon Per Face 2D algorithm
1625 It is created by calling smeshBuilder.Mesh.Polygon(geom=0)
1628 meshMethod = "Polygon"
1630 name of the dynamic method in smeshBuilder.Mesh class
1634 type of algorithm used with helper function in smeshBuilder.Mesh class
1638 flag pointing whether this algorithm should be used by default in dynamic method
1639 of smeshBuilder.Mesh class
1641 docHelper = "Creates polygon 2D algorithm for faces"
1643 doc string of the method
1646 def __init__(self, mesh, geom=0):
1648 Private constructor.
1651 mesh: parent mesh object algorithm is assigned to
1652 geom: geometry (shape/sub-shape) algorithm is assigned to;
1653 if it is :code:`0` (default), the algorithm is assigned to the main shape
1655 Mesh_Algorithm.__init__(self)
1656 self.Create(mesh, geom, self.algoType)
1661 class StdMeshersBuilder_UseExistingElements_1D(Mesh_Algorithm):
1662 """ Defines a Use Existing Elements 1D algorithm
1664 It is created by calling smeshBuilder.Mesh.UseExisting1DElements(geom=0)
1668 meshMethod = "UseExisting1DElements"
1670 name of the dynamic method in smeshBuilder.Mesh class
1672 algoType = "Import_1D"
1674 type of algorithm used with helper function in smeshBuilder.Mesh class
1678 flag pointing whether this algorithm should be used by default in dynamic method
1679 of smeshBuilder.Mesh class
1681 docHelper = "Creates 1D algorithm for edges with reusing of existing mesh elements"
1683 doc string of the method
1686 def __init__(self, mesh, geom=0):
1688 Private constructor.
1691 mesh: parent mesh object algorithm is assigned to
1692 geom: geometry (shape/sub-shape) algorithm is assigned to;
1693 if it is :code:`0` (default), the algorithm is assigned to the main shape
1695 Mesh_Algorithm.__init__(self)
1696 self.Create(mesh, geom, self.algoType)
1699 def SourceEdges(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
1701 Defines "Source edges" hypothesis, specifying groups of edges to import
1704 groups: list of groups of edges
1705 toCopyMesh: if True, the whole mesh *groups* belong to is imported
1706 toCopyGroups: if True, all groups of the mesh *groups* belong to are imported
1707 UseExisting: if ==true - searches for the existing hypothesis created with
1708 the same parameters, else (default) - creates a new one
1710 for group in groups:
1711 from salome.smesh.smeshBuilder import AssureGeomPublished
1712 AssureGeomPublished( self.mesh, group )
1713 compFun = lambda hyp, args: ( hyp.GetSourceEdges() == args[0] and \
1714 hyp.GetCopySourceMesh() == args[1], args[2] )
1715 hyp = self.Hypothesis("ImportSource1D", [groups, toCopyMesh, toCopyGroups],
1716 UseExisting=UseExisting, CompareMethod=compFun)
1717 hyp.SetSourceEdges(groups)
1718 hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups)
1721 pass # end of StdMeshersBuilder_UseExistingElements_1D class
1723 class StdMeshersBuilder_UseExistingElements_1D2D(Mesh_Algorithm):
1724 """ Defines a Use Existing Elements 1D-2D algorithm
1726 It is created by calling smeshBuilder.Mesh.UseExisting2DElements(geom=0)
1730 meshMethod = "UseExisting2DElements"
1732 name of the dynamic method in smeshBuilder.Mesh class
1734 algoType = "Import_1D2D"
1736 type of algorithm used with helper function in smeshBuilder.Mesh class
1740 flag pointing whether this algorithm should be used by default in dynamic method
1741 of smeshBuilder.Mesh class
1743 docHelper = "Creates 1D-2D algorithm for faces with reusing of existing mesh elements"
1745 doc string of the method
1748 def __init__(self, mesh, geom=0):
1750 Private constructor.
1753 mesh: parent mesh object algorithm is assigned to
1754 geom: geometry (shape/sub-shape) algorithm is assigned to;
1755 if it is :code:`0` (default), the algorithm is assigned to the main shape
1757 Mesh_Algorithm.__init__(self)
1758 self.Create(mesh, geom, self.algoType)
1761 def SourceFaces(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
1763 Defines "Source faces" hypothesis, specifying groups of faces to import
1766 groups: list of groups of faces
1767 toCopyMesh: if True, the whole mesh *groups* belong to is imported
1768 toCopyGroups: if True, all groups of the mesh *groups* belong to are imported
1769 UseExisting: if ==true - searches for the existing hypothesis created with
1770 the same parameters, else (default) - creates a new one
1773 compFun = lambda hyp, args: ( hyp.GetSourceFaces() == args[0] and \
1774 hyp.GetCopySourceMesh() == args[1], args[2] )
1775 hyp = self.Hypothesis("ImportSource2D", [groups, toCopyMesh, toCopyGroups],
1776 UseExisting=UseExisting, CompareMethod=compFun, toAdd=False)
1777 if groups and isinstance( groups, SMESH._objref_SMESH_GroupBase ):
1779 hyp.SetSourceFaces(groups)
1780 hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups)
1781 self.mesh.AddHypothesis(hyp, self.geom)
1784 pass # end of StdMeshersBuilder_UseExistingElements_1D2D class
1786 class StdMeshersBuilder_Cartesian_3D(Mesh_Algorithm):
1787 """ Defines a Body Fitting 3D algorithm
1789 It is created by calling smeshBuilder.Mesh.BodyFitted(geom=0)
1793 meshMethod = "BodyFitted"
1795 name of the dynamic method in smeshBuilder.Mesh class
1797 algoType = "Cartesian_3D"
1799 type of algorithm used with helper function in smeshBuilder.Mesh class
1803 flag pointing whether this algorithm should be used by default in dynamic method
1804 of smeshBuilder.Mesh class
1806 docHelper = "Creates Body Fitting 3D algorithm for volumes"
1808 doc string of the method
1811 def __init__(self, mesh, geom=0):
1813 Private constructor.
1816 mesh: parent mesh object algorithm is assigned to
1817 geom: geometry (shape/sub-shape) algorithm is assigned to;
1818 if it is :code:`0` (default), the algorithm is assigned to the main shape
1820 self.Create(mesh, geom, self.algoType)
1824 def SetGrid(self, xGridDef, yGridDef, zGridDef, sizeThreshold=4.0, implEdges=False):
1826 Defines "Body Fitting parameters" hypothesis
1829 xGridDef: is definition of the grid along the X asix.
1830 It can be in either of two following forms:
1832 - Explicit coordinates of nodes, e.g. [-1.5, 0.0, 3.1] or range( -100,200,10)
1833 - Functions f(t) defining grid spacing at each point on grid axis. If there are
1834 several functions, they must be accompanied by relative coordinates of
1835 points dividing the whole shape into ranges where the functions apply; points
1836 coodrinates should vary within (0.0, 1.0) range. Parameter *t* of the spacing
1837 function f(t) varies from 0.0 to 1.0 within a shape range.
1840 "10.5" - defines a grid with a constant spacing
1841 [["1", "1+10*t", "11"] [0.1, 0.6]] - defines different spacing in 3 ranges.
1844 yGridDef: defines the grid along the Y asix the same way as *xGridDef* does.
1845 zGridDef: defines the grid along the Z asix the same way as *xGridDef* does.
1846 sizeThreshold: (> 1.0) defines a minimal size of a polyhedron so that
1847 a polyhedron of size less than hexSize/sizeThreshold is not created.
1848 implEdges: enables implementation of geometrical edges into the mesh.
1851 compFun = lambda hyp, args: False
1852 self.hyp = self.Hypothesis("CartesianParameters3D",
1853 [xGridDef, yGridDef, zGridDef, sizeThreshold],
1854 UseExisting=False, CompareMethod=compFun)
1855 if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ):
1856 self.mesh.AddHypothesis( self.hyp, self.geom )
1858 for axis, gridDef in enumerate( [xGridDef, yGridDef, zGridDef] ):
1859 if not gridDef: raise ValueError, "Empty grid definition"
1860 if isinstance( gridDef, str ):
1861 self.hyp.SetGridSpacing( [gridDef], [], axis )
1862 elif isinstance( gridDef[0], str ):
1863 self.hyp.SetGridSpacing( gridDef, [], axis )
1864 elif isinstance( gridDef[0], int ) or \
1865 isinstance( gridDef[0], float ):
1866 self.hyp.SetGrid(gridDef, axis )
1868 self.hyp.SetGridSpacing( gridDef[0], gridDef[1], axis )
1869 self.hyp.SetSizeThreshold( sizeThreshold )
1870 self.hyp.SetToAddEdges( implEdges )
1873 def SetAxesDirs( self, xAxis, yAxis, zAxis ):
1875 Defines custom directions of axes of the grid
1878 xAxis: either SMESH.DirStruct or a vector, or 3 vector components
1879 yAxis: either SMESH.DirStruct or a vector, or 3 vector components
1880 zAxis: either SMESH.DirStruct or a vector, or 3 vector components
1883 if hasattr( xAxis, "__getitem__" ):
1884 xAxis = self.mesh.smeshpyD.MakeDirStruct( xAxis[0],xAxis[1],xAxis[2] )
1885 elif isinstance( xAxis, GEOM._objref_GEOM_Object ):
1886 xAxis = self.mesh.smeshpyD.GetDirStruct( xAxis )
1887 if hasattr( yAxis, "__getitem__" ):
1888 yAxis = self.mesh.smeshpyD.MakeDirStruct( yAxis[0],yAxis[1],yAxis[2] )
1889 elif isinstance( yAxis, GEOM._objref_GEOM_Object ):
1890 yAxis = self.mesh.smeshpyD.GetDirStruct( yAxis )
1891 if hasattr( zAxis, "__getitem__" ):
1892 zAxis = self.mesh.smeshpyD.MakeDirStruct( zAxis[0],zAxis[1],zAxis[2] )
1893 elif isinstance( zAxis, GEOM._objref_GEOM_Object ):
1894 zAxis = self.mesh.smeshpyD.GetDirStruct( zAxis )
1896 self.hyp = self.Hypothesis("CartesianParameters3D")
1897 if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ):
1898 self.mesh.AddHypothesis( self.hyp, self.geom )
1899 self.hyp.SetAxesDirs( xAxis, yAxis, zAxis )
1902 def SetOptimalAxesDirs(self, isOrthogonal=True):
1904 Automatically defines directions of axes of the grid at which
1905 a number of generated hexahedra is maximal
1908 isOrthogonal: defines whether the axes mush be orthogonal
1911 self.hyp = self.Hypothesis("CartesianParameters3D")
1912 if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ):
1913 self.mesh.AddHypothesis( self.hyp, self.geom )
1914 x,y,z = self.hyp.ComputeOptimalAxesDirs( self.geom, isOrthogonal )
1915 self.hyp.SetAxesDirs( x,y,z )
1918 def SetFixedPoint( self, p, toUnset=False ):
1920 Sets/unsets a fixed point. The algorithm makes a plane of the grid pass
1921 through the fixed point in each direction at which the grid is defined
1925 p: coordinates of the fixed point. Either SMESH.PointStruct or
1926 a vertex or 3 components of coordinates.
1927 toUnset: defines whether the fixed point is defined or removed.
1931 if not self.hyp: return
1932 p = SMESH.PointStruct(0,0,0)
1933 elif hasattr( p, "__getitem__" ):
1934 p = SMESH.PointStruct( p[0],p[1],p[2] )
1935 elif isinstance( p, GEOM._objref_GEOM_Object ):
1936 p = self.mesh.smeshpyD.GetPointStruct( p )
1938 self.hyp = self.Hypothesis("CartesianParameters3D")
1939 if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ):
1940 self.mesh.AddHypothesis( self.hyp, self.geom )
1941 self.hyp.SetFixedPoint( p, toUnset )
1945 pass # end of StdMeshersBuilder_Cartesian_3D class
1947 class StdMeshersBuilder_UseExisting_1D(Mesh_Algorithm):
1948 """ Defines a stub 1D algorithm, which enables "manual" creation of nodes and
1949 segments usable by 2D algorithms
1951 It is created by calling smeshBuilder.Mesh.UseExistingSegments(geom=0)
1955 meshMethod = "UseExistingSegments"
1957 name of the dynamic method in smeshBuilder.Mesh class
1959 algoType = "UseExisting_1D"
1961 type of algorithm used with helper function in smeshBuilder.Mesh class
1963 docHelper = "Creates 1D algorithm allowing batch meshing of edges"
1965 doc string of the method
1968 def __init__(self, mesh, geom=0):
1970 Private constructor.
1973 mesh: parent mesh object algorithm is assigned to
1974 geom: geometry (shape/sub-shape) algorithm is assigned to;
1975 if it is :code:`0` (default), the algorithm is assigned to the main shape
1977 self.Create(mesh, geom, self.algoType)
1980 pass # end of StdMeshersBuilder_UseExisting_1D class
1982 class StdMeshersBuilder_UseExisting_2D(Mesh_Algorithm):
1983 """ Defines a stub 2D algorithm, which enables "manual" creation of nodes and
1984 faces usable by 3D algorithms
1986 It is created by calling smeshBuilder.Mesh.UseExistingFaces(geom=0)
1990 meshMethod = "UseExistingFaces"
1992 name of the dynamic method in smeshBuilder.Mesh class
1994 algoType = "UseExisting_2D"
1996 type of algorithm used with helper function in smeshBuilder.Mesh class
1998 docHelper = "Creates 2D algorithm allowing batch meshing of faces"
2000 doc string of the method
2003 def __init__(self, mesh, geom=0):
2005 Private constructor.
2008 mesh: parent mesh object algorithm is assigned to
2009 geom: geometry (shape/sub-shape) algorithm is assigned to;
2010 if it is :code:`0` (default), the algorithm is assigned to the main shape
2012 self.Create(mesh, geom, self.algoType)
2015 pass # end of StdMeshersBuilder_UseExisting_2D class