1 # Copyright (C) 2007-2019 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 = "Create 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) - Create 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) - Create a new one
167 an instance of StdMeshers_MaxLength hypothesis
171 hyp = self.Hypothesis("MaxLength", [length], UseExisting=UseExisting)
172 if isinstance(length,str) or length > 0:
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) - Create 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) - Create 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) - Create 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) - Create 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) - Create 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=-1, 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) - Create a new one
475 store_geom = self.geom
476 if isinstance(vertex, int):
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 = "Create 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 = "Create 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) - Create 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 = "Create 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) - Create 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 = "Create 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) - Create 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) - Create 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) - Create 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) - Create 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) - Create 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 = "Create 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 = "Create 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) - Create 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 = "Create 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 = "Create 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 = "Create 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) - Create 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 = "Create 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 self.mesh.smeshpyD.SetEnablePublish( False ) # prevents publishing own 1D hypothesis
1233 hyp = self.mesh.smeshpyD.CreateHypothesis(hypType, so)
1234 self.mesh.smeshpyD.SetEnablePublish( True ) # enables publishing
1235 if not self.distribHyp:
1236 self.distribHyp = self.Hypothesis("LayerDistribution", UseExisting=0)
1237 self.distribHyp.SetLayerDistribution( hyp )
1240 def NumberOfLayers(self, n, UseExisting=0):
1242 Defines "NumberOfLayers" hypothesis, specifying the number of layers of
1243 prisms to build between the inner and outer shells
1247 UseExisting: if ==true - searches for the existing hypothesis created with
1248 the same parameters, else (default) - Create a new one
1250 if self.algoType != "RadialPrism_3D":
1251 print("Prism_3D algorithm doesn't support any hypothesis")
1253 self.mesh.RemoveHypothesis( self.distribHyp, self.geom )
1254 from salome.smesh.smeshBuilder import IsEqual
1255 compFun = lambda hyp, args: IsEqual(hyp.GetNumberOfLayers(), args[0])
1256 self.nbLayers = self.Hypothesis("NumberOfLayers", [n], UseExisting=UseExisting,
1257 CompareMethod=compFun)
1258 self.nbLayers.SetNumberOfLayers( n )
1259 return self.nbLayers
1261 def LocalLength(self, l, p=1e-07):
1263 Defines "LocalLength" hypothesis, specifying the segment length
1264 to build between the inner and the outer shells
1267 l: the length of segments
1268 p: the precision of rounding
1270 if self.algoType != "RadialPrism_3D":
1271 print("Prism_3D algorithm doesn't support any hypothesis")
1273 hyp = self.OwnHypothesis("LocalLength", [l,p])
1278 def NumberOfSegments(self, n, s=[]):
1280 Defines "NumberOfSegments" hypothesis, specifying the number of layers of
1281 prisms to build between the inner and the outer shells.
1284 n: the number of layers
1285 s: the scale factor (optional)
1287 if self.algoType != "RadialPrism_3D":
1288 print("Prism_3D algorithm doesn't support any hypothesis")
1291 hyp = self.OwnHypothesis("NumberOfSegments", [n])
1293 hyp = self.OwnHypothesis("NumberOfSegments", [n,s])
1294 hyp.SetScaleFactor(s)
1295 hyp.SetNumberOfSegments(n)
1298 def Arithmetic1D(self, start, end ):
1300 Defines "Arithmetic1D" hypothesis, specifying the distribution of segments
1301 to build between the inner and the outer shells with a length that changes
1302 in arithmetic progression
1305 start: the length of the first segment
1306 end: the length of the last segment
1308 if self.algoType != "RadialPrism_3D":
1309 print("Prism_3D algorithm doesn't support any hypothesis")
1311 hyp = self.OwnHypothesis("Arithmetic1D", [start, end])
1312 hyp.SetLength(start, 1)
1313 hyp.SetLength(end , 0)
1316 def GeometricProgression(self, start, ratio ):
1318 Defines "GeometricProgression" hypothesis, specifying the distribution of segments
1319 to build between the inner and the outer shells with a length that changes
1320 in Geometric progression
1323 start: the length of the first segment
1324 ratio: the common ratio of the geometric progression
1326 if self.algoType != "RadialPrism_3D":
1327 print("Prism_3D algorithm doesn't support any hypothesis")
1329 hyp = self.OwnHypothesis("GeometricProgression", [start, ratio])
1330 hyp.SetStartLength( start )
1331 hyp.SetCommonRatio( ratio )
1334 def StartEndLength(self, start, end):
1336 Defines "StartEndLength" hypothesis, specifying distribution of segments
1337 to build between the inner and the outer shells as geometric length increasing
1340 start: for the length of the first segment
1341 end: for the length of the last segment
1343 if self.algoType != "RadialPrism_3D":
1344 print("Prism_3D algorithm doesn't support any hypothesis")
1346 hyp = self.OwnHypothesis("StartEndLength", [start, end])
1347 hyp.SetLength(start, 1)
1348 hyp.SetLength(end , 0)
1351 def AutomaticLength(self, fineness=0):
1353 Defines "AutomaticLength" hypothesis, specifying the number of segments
1354 to build between the inner and outer shells
1357 fineness: defines the quality of the mesh within the range [0-1]
1359 if self.algoType != "RadialPrism_3D":
1360 print("Prism_3D algorithm doesn't support any hypothesis")
1362 hyp = self.OwnHypothesis("AutomaticLength")
1363 hyp.SetFineness( fineness )
1366 pass # end of StdMeshersBuilder_Prism3D class
1368 class StdMeshersBuilder_RadialPrism3D(StdMeshersBuilder_Prism3D):
1370 Defines Radial Prism 3D algorithm.
1371 It is created by calling smeshBuilder.Mesh.Prism(geom=0).
1372 See :class:`StdMeshersBuilder_Prism3D` for methods defining distribution of mesh layers
1373 build between the inner and outer shells.
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 = "Create 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 self.mesh.smeshpyD.SetEnablePublish( False )
1444 hyp = self.mesh.smeshpyD.CreateHypothesis(hypType, so)
1445 self.mesh.smeshpyD.SetEnablePublish( True )
1446 self.distribHyp.SetLayerDistribution( hyp )
1449 def NumberOfLayers(self, n, UseExisting=0):
1451 Defines "NumberOfLayers" hypothesis, specifying the number of layers
1455 UseExisting: if ==true - searches for the existing hypothesis created with
1456 the same parameters, else (default) - Create a new one
1459 self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp )
1460 from salome.smesh.smeshBuilder import IsEqual
1461 compFun = lambda hyp, args: IsEqual(hyp.GetNumberOfLayers(), args[0])
1462 self.nbLayers = self.Hypothesis("NumberOfLayers2D", [n], UseExisting=UseExisting,
1463 CompareMethod=compFun)
1464 self.nbLayers.SetNumberOfLayers( n )
1465 return self.nbLayers
1467 def LocalLength(self, l, p=1e-07):
1469 Defines "LocalLength" hypothesis, specifying the segment length
1472 l: the length of segments
1473 p: the precision of rounding
1475 hyp = self.OwnHypothesis("LocalLength", [l,p])
1480 def NumberOfSegments(self, n, s=[]):
1482 Defines "NumberOfSegments" hypothesis, specifying the number of layers
1485 n: the number of layers
1486 s: the scale factor (optional)
1489 hyp = self.OwnHypothesis("NumberOfSegments", [n])
1491 hyp = self.OwnHypothesis("NumberOfSegments", [n,s])
1492 hyp.SetDistrType( 1 )
1493 hyp.SetScaleFactor(s)
1494 hyp.SetNumberOfSegments(n)
1497 def Arithmetic1D(self, start, end ):
1499 Defines "Arithmetic1D" hypothesis, specifying the distribution of segments
1500 with a length that changes in arithmetic progression
1503 start: the length of the first segment
1504 end: the length of the last segment
1506 hyp = self.OwnHypothesis("Arithmetic1D", [start, end])
1507 hyp.SetLength(start, 1)
1508 hyp.SetLength(end , 0)
1511 def GeometricProgression(self, start, ratio ):
1513 Defines "GeometricProgression" hypothesis, specifying the distribution of segments
1514 with a length that changes in Geometric progression
1517 start: the length of the first segment
1518 ratio: the common ratio of the geometric progression
1520 hyp = self.OwnHypothesis("GeometricProgression", [start, ratio])
1521 hyp.SetStartLength( start )
1522 hyp.SetCommonRatio( ratio )
1525 def StartEndLength(self, start, end):
1527 Defines "StartEndLength" hypothesis, specifying distribution of segments
1528 as geometric length increasing
1531 start: for the length of the first segment
1532 end: for the length of the last segment
1534 hyp = self.OwnHypothesis("StartEndLength", [start, end])
1535 hyp.SetLength(start, 1)
1536 hyp.SetLength(end , 0)
1539 def AutomaticLength(self, fineness=0):
1541 Defines "AutomaticLength" hypothesis, specifying the number of segments
1544 fineness: defines the quality of the mesh within the range [0-1]
1546 hyp = self.OwnHypothesis("AutomaticLength")
1547 hyp.SetFineness( fineness )
1550 pass # end of StdMeshersBuilder_RadialQuadrangle1D2D class
1552 class StdMeshersBuilder_RadialQuadrangle1D2D(StdMeshersBuilder_RadialAlgorithm):
1554 Defines a Radial Quadrangle 1D-2D algorithm.
1555 It is created by calling smeshBuilder.Mesh.Quadrangle(smeshBuilder.RADIAL_QUAD,geom=0)
1558 meshMethod = "Quadrangle"
1560 name of the dynamic method in smeshBuilder.Mesh class
1562 algoType = RADIAL_QUAD
1564 type of algorithm used with helper function in smeshBuilder.Mesh class
1566 docHelper = "Create quadrangle 1D-2D algorithm for faces having a shape of disk or a disk segment"
1568 doc string of the method
1571 def __init__(self, mesh, geom=0):
1573 Private constructor.
1576 mesh: parent mesh object algorithm is assigned to
1577 geom: geometry (shape/sub-shape) algorithm is assigned to;
1578 if it is :code:`0` (default), the algorithm is assigned to the main shape
1580 StdMeshersBuilder_RadialAlgorithm.__init__(self)
1581 self.Create(mesh, geom, self.algoType)
1583 self.distribHyp = None #self.Hypothesis("LayerDistribution2D", UseExisting=0)
1584 self.nbLayers = None
1588 class StdMeshersBuilder_QuadMA_1D2D(StdMeshersBuilder_RadialAlgorithm):
1590 Defines a Quadrangle (Medial Axis Projection) 1D-2D algorithm .
1591 It is created by calling smeshBuilder.Mesh.Quadrangle(smeshBuilder.QUAD_MA_PROJ,geom=0)
1594 meshMethod = "Quadrangle"
1596 name of the dynamic method in smeshBuilder.Mesh class
1598 algoType = QUAD_MA_PROJ
1600 type of algorithm used with helper function in smeshBuilder.Mesh class
1602 docHelper = "Create quadrangle 1D-2D algorithm for faces"
1604 doc string of the method
1607 def __init__(self, mesh, geom=0):
1609 Private constructor.
1612 mesh: parent mesh object algorithm is assigned to
1613 geom: geometry (shape/sub-shape) algorithm is assigned to;
1614 if it is :code:`0` (default), the algorithm is assigned to the main shape
1616 StdMeshersBuilder_RadialAlgorithm.__init__(self)
1617 self.Create(mesh, geom, self.algoType)
1622 class StdMeshersBuilder_PolygonPerFace(Mesh_Algorithm):
1623 """ Defines a Polygon Per Face 2D algorithm.
1624 It is created by calling smeshBuilder.Mesh.Polygon(geom=0)
1627 meshMethod = "Polygon"
1629 name of the dynamic method in smeshBuilder.Mesh class
1633 type of algorithm used with helper function in smeshBuilder.Mesh class
1637 flag pointing whether this algorithm should be used by default in dynamic method
1638 of smeshBuilder.Mesh class
1640 docHelper = "Create polygon 2D algorithm for faces"
1642 doc string of the method
1645 def __init__(self, mesh, geom=0):
1647 Private constructor.
1650 mesh: parent mesh object algorithm is assigned to
1651 geom: geometry (shape/sub-shape) algorithm is assigned to;
1652 if it is :code:`0` (default), the algorithm is assigned to the main shape
1654 Mesh_Algorithm.__init__(self)
1655 self.Create(mesh, geom, self.algoType)
1660 class StdMeshersBuilder_UseExistingElements_1D(Mesh_Algorithm):
1661 """ Defines a Use Existing Elements 1D algorithm.
1663 It is created by calling smeshBuilder.Mesh.UseExisting1DElements(geom=0)
1667 meshMethod = "UseExisting1DElements"
1669 name of the dynamic method in smeshBuilder.Mesh class
1671 algoType = "Import_1D"
1673 type of algorithm used with helper function in smeshBuilder.Mesh class
1677 flag pointing whether this algorithm should be used by default in dynamic method
1678 of smeshBuilder.Mesh class
1680 docHelper = "Create 1D algorithm for edges with reusing of existing mesh elements"
1682 doc string of the method
1685 def __init__(self, mesh, geom=0):
1687 Private constructor.
1690 mesh: parent mesh object algorithm is assigned to
1691 geom: geometry (shape/sub-shape) algorithm is assigned to;
1692 if it is :code:`0` (default), the algorithm is assigned to the main shape
1694 Mesh_Algorithm.__init__(self)
1695 self.Create(mesh, geom, self.algoType)
1698 def SourceEdges(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
1700 Defines "Source edges" hypothesis, specifying groups of edges to import
1703 groups: list of groups of edges
1704 toCopyMesh: if True, the whole mesh *groups* belong to is imported
1705 toCopyGroups: if True, all groups of the mesh *groups* belong to are imported
1706 UseExisting: if ==true - searches for the existing hypothesis created with
1707 the same parameters, else (default) - Create a new one
1709 for group in groups:
1710 from salome.smesh.smeshBuilder import AssureGeomPublished
1711 AssureGeomPublished( self.mesh, group )
1712 compFun = lambda hyp, args: ( hyp.GetSourceEdges() == args[0] and \
1713 hyp.GetCopySourceMesh() == args[1], args[2] )
1714 hyp = self.Hypothesis("ImportSource1D", [groups, toCopyMesh, toCopyGroups],
1715 UseExisting=UseExisting, CompareMethod=compFun)
1716 hyp.SetSourceEdges(groups)
1717 hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups)
1720 pass # end of StdMeshersBuilder_UseExistingElements_1D class
1722 class StdMeshersBuilder_UseExistingElements_1D2D(Mesh_Algorithm):
1723 """ Defines a Use Existing Elements 1D-2D algorithm.
1725 It is created by calling smeshBuilder.Mesh.UseExisting2DElements(geom=0)
1729 meshMethod = "UseExisting2DElements"
1731 name of the dynamic method in smeshBuilder.Mesh class
1733 algoType = "Import_1D2D"
1735 type of algorithm used with helper function in smeshBuilder.Mesh class
1739 flag pointing whether this algorithm should be used by default in dynamic method
1740 of smeshBuilder.Mesh class
1742 docHelper = "Create 1D-2D algorithm for faces with reusing of existing mesh elements"
1744 doc string of the method
1747 def __init__(self, mesh, geom=0):
1749 Private constructor.
1752 mesh: parent mesh object algorithm is assigned to
1753 geom: geometry (shape/sub-shape) algorithm is assigned to;
1754 if it is :code:`0` (default), the algorithm is assigned to the main shape
1756 Mesh_Algorithm.__init__(self)
1757 self.Create(mesh, geom, self.algoType)
1760 def SourceFaces(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
1762 Defines "Source faces" hypothesis, specifying groups of faces to import
1765 groups: list of groups of faces
1766 toCopyMesh: if True, the whole mesh *groups* belong to is imported
1767 toCopyGroups: if True, all groups of the mesh *groups* belong to are imported
1768 UseExisting: if ==true - searches for the existing hypothesis created with
1769 the same parameters, else (default) - Create a new one
1772 compFun = lambda hyp, args: ( hyp.GetSourceFaces() == args[0] and \
1773 hyp.GetCopySourceMesh() == args[1], args[2] )
1774 hyp = self.Hypothesis("ImportSource2D", [groups, toCopyMesh, toCopyGroups],
1775 UseExisting=UseExisting, CompareMethod=compFun, toAdd=False)
1776 if groups and isinstance( groups, SMESH._objref_SMESH_GroupBase ):
1778 hyp.SetSourceFaces(groups)
1779 hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups)
1780 self.mesh.AddHypothesis(hyp, self.geom)
1783 pass # end of StdMeshersBuilder_UseExistingElements_1D2D class
1785 class StdMeshersBuilder_Cartesian_3D(Mesh_Algorithm):
1786 """ Defines a Body Fitting 3D algorithm.
1788 It is created by calling smeshBuilder.Mesh.BodyFitted(geom=0)
1792 meshMethod = "BodyFitted"
1794 name of the dynamic method in smeshBuilder.Mesh class
1796 algoType = "Cartesian_3D"
1798 type of algorithm used with helper function in smeshBuilder.Mesh class
1802 flag pointing whether this algorithm should be used by default in dynamic method
1803 of smeshBuilder.Mesh class
1805 docHelper = "Create Body Fitting 3D algorithm for volumes"
1807 doc string of the method
1810 def __init__(self, mesh, geom=0):
1812 Private constructor.
1815 mesh: parent mesh object algorithm is assigned to
1816 geom: geometry (shape/sub-shape) algorithm is assigned to;
1817 if it is :code:`0` (default), the algorithm is assigned to the main shape
1819 self.Create(mesh, geom, self.algoType)
1823 def SetGrid(self, xGridDef, yGridDef, zGridDef, sizeThreshold=4.0, implEdges=False):
1825 Defines "Body Fitting parameters" hypothesis
1828 xGridDef: is definition of the grid along the X asix.
1829 It can be in either of two following forms:
1831 - Explicit coordinates of nodes, e.g. [-1.5, 0.0, 3.1] or range( -100,200,10)
1832 - Functions f(t) defining grid spacing at each point on grid axis. If there are
1833 several functions, they must be accompanied by relative coordinates of
1834 points dividing the whole shape into ranges where the functions apply; points
1835 coordinates should vary within (0.0, 1.0) range. Parameter *t* of the spacing
1836 function f(t) varies from 0.0 to 1.0 within a shape range.
1839 "10.5" - defines a grid with a constant spacing
1840 [["1", "1+10*t", "11"] [0.1, 0.6]] - defines different spacing in 3 ranges.
1843 yGridDef: defines the grid along the Y asix the same way as *xGridDef* does.
1844 zGridDef: defines the grid along the Z asix the same way as *xGridDef* does.
1845 sizeThreshold: (> 1.0) defines a minimal size of a polyhedron so that
1846 a polyhedron of size less than hexSize/sizeThreshold is not created.
1847 implEdges: enables implementation of geometrical edges into the mesh.
1850 compFun = lambda hyp, args: False
1851 self.hyp = self.Hypothesis("CartesianParameters3D",
1852 [xGridDef, yGridDef, zGridDef, sizeThreshold],
1853 UseExisting=False, CompareMethod=compFun)
1854 if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ):
1855 self.mesh.AddHypothesis( self.hyp, self.geom )
1857 for axis, gridDef in enumerate( [xGridDef, yGridDef, zGridDef] ):
1858 if not gridDef: raise ValueError("Empty grid definition")
1859 if isinstance( gridDef, str ):
1860 self.hyp.SetGridSpacing( [gridDef], [], axis )
1861 elif isinstance( gridDef[0], str ):
1862 self.hyp.SetGridSpacing( gridDef, [], axis )
1863 elif isinstance( gridDef[0], int ) or \
1864 isinstance( gridDef[0], float ):
1865 self.hyp.SetGrid(gridDef, axis )
1867 self.hyp.SetGridSpacing( gridDef[0], gridDef[1], axis )
1868 self.hyp.SetSizeThreshold( sizeThreshold )
1869 self.hyp.SetToAddEdges( implEdges )
1872 def SetAxesDirs( self, xAxis, yAxis, zAxis ):
1874 Defines custom directions of axes of the grid
1877 xAxis: either SMESH.DirStruct or a vector, or 3 vector components
1878 yAxis: either SMESH.DirStruct or a vector, or 3 vector components
1879 zAxis: either SMESH.DirStruct or a vector, or 3 vector components
1882 if hasattr( xAxis, "__getitem__" ):
1883 xAxis = self.mesh.smeshpyD.MakeDirStruct( xAxis[0],xAxis[1],xAxis[2] )
1884 elif isinstance( xAxis, GEOM._objref_GEOM_Object ):
1885 xAxis = self.mesh.smeshpyD.GetDirStruct( xAxis )
1886 if hasattr( yAxis, "__getitem__" ):
1887 yAxis = self.mesh.smeshpyD.MakeDirStruct( yAxis[0],yAxis[1],yAxis[2] )
1888 elif isinstance( yAxis, GEOM._objref_GEOM_Object ):
1889 yAxis = self.mesh.smeshpyD.GetDirStruct( yAxis )
1890 if hasattr( zAxis, "__getitem__" ):
1891 zAxis = self.mesh.smeshpyD.MakeDirStruct( zAxis[0],zAxis[1],zAxis[2] )
1892 elif isinstance( zAxis, GEOM._objref_GEOM_Object ):
1893 zAxis = self.mesh.smeshpyD.GetDirStruct( zAxis )
1895 self.hyp = self.Hypothesis("CartesianParameters3D")
1896 if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ):
1897 self.mesh.AddHypothesis( self.hyp, self.geom )
1898 self.hyp.SetAxesDirs( xAxis, yAxis, zAxis )
1901 def SetOptimalAxesDirs(self, isOrthogonal=True):
1903 Automatically defines directions of axes of the grid at which
1904 a number of generated hexahedra is maximal
1907 isOrthogonal: defines whether the axes mush be orthogonal
1910 self.hyp = self.Hypothesis("CartesianParameters3D")
1911 if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ):
1912 self.mesh.AddHypothesis( self.hyp, self.geom )
1913 x,y,z = self.hyp.ComputeOptimalAxesDirs( self.geom, isOrthogonal )
1914 self.hyp.SetAxesDirs( x,y,z )
1917 def SetFixedPoint( self, p, toUnset=False ):
1919 Sets/unsets a fixed point. The algorithm makes a plane of the grid pass
1920 through the fixed point in each direction at which the grid is defined
1924 p: coordinates of the fixed point. Either SMESH.PointStruct or
1925 a vertex or 3 components of coordinates.
1926 toUnset: defines whether the fixed point is defined or removed.
1930 if not self.hyp: return
1931 p = SMESH.PointStruct(0,0,0)
1932 elif hasattr( p, "__getitem__" ):
1933 p = SMESH.PointStruct( p[0],p[1],p[2] )
1934 elif isinstance( p, GEOM._objref_GEOM_Object ):
1935 p = self.mesh.smeshpyD.GetPointStruct( p )
1937 self.hyp = self.Hypothesis("CartesianParameters3D")
1938 if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ):
1939 self.mesh.AddHypothesis( self.hyp, self.geom )
1940 self.hyp.SetFixedPoint( p, toUnset )
1944 pass # end of StdMeshersBuilder_Cartesian_3D class
1946 class StdMeshersBuilder_UseExisting_1D(Mesh_Algorithm):
1947 """ Defines a stub 1D algorithm, which enables "manual" creation of nodes and
1948 segments usable by 2D algorithms.
1950 It is created by calling smeshBuilder.Mesh.UseExistingSegments(geom=0)
1954 meshMethod = "UseExistingSegments"
1956 name of the dynamic method in smeshBuilder.Mesh class
1958 algoType = "UseExisting_1D"
1960 type of algorithm used with helper function in smeshBuilder.Mesh class
1962 docHelper = "Create 1D algorithm allowing batch meshing of edges"
1964 doc string of the method
1967 def __init__(self, mesh, geom=0):
1969 Private constructor.
1972 mesh: parent mesh object algorithm is assigned to
1973 geom: geometry (shape/sub-shape) algorithm is assigned to;
1974 if it is :code:`0` (default), the algorithm is assigned to the main shape
1976 self.Create(mesh, geom, self.algoType)
1979 pass # end of StdMeshersBuilder_UseExisting_1D class
1981 class StdMeshersBuilder_UseExisting_2D(Mesh_Algorithm):
1982 """ Defines a stub 2D algorithm, which enables "manual" creation of nodes and
1983 faces usable by 3D algorithms.
1985 It is created by calling smeshBuilder.Mesh.UseExistingFaces(geom=0)
1989 meshMethod = "UseExistingFaces"
1991 name of the dynamic method in smeshBuilder.Mesh class
1993 algoType = "UseExisting_2D"
1995 type of algorithm used with helper function in smeshBuilder.Mesh class
1997 docHelper = "Create 2D algorithm allowing batch meshing of faces"
1999 doc string of the method
2002 def __init__(self, mesh, geom=0):
2004 Private constructor.
2007 mesh: parent mesh object algorithm is assigned to
2008 geom: geometry (shape/sub-shape) algorithm is assigned to;
2009 if it is :code:`0` (default), the algorithm is assigned to the main shape
2011 self.Create(mesh, geom, self.algoType)
2014 pass # end of StdMeshersBuilder_UseExisting_2D class