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 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 = "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 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) - creates 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)
1375 meshMethod = "Prism"
1377 name of the dynamic method in smeshBuilder.Mesh class
1379 algoType = "RadialPrism_3D"
1381 type of algorithm used with helper function in smeshBuilder.Mesh class
1383 docHelper = "Creates Raial Prism 3D algorithm for volumes"
1385 doc string of the method
1388 def __init__(self, mesh, geom=0):
1390 Private constructor.
1393 mesh: parent mesh object algorithm is assigned to
1394 geom: geometry (shape/sub-shape) algorithm is assigned to;
1395 if it is :code:`0` (default), the algorithm is assigned to the main shape
1397 Mesh_Algorithm.__init__(self)
1402 self.Create(mesh, geom, "RadialPrism_3D")
1403 self.distribHyp = None
1404 self.nbLayers = None
1407 class StdMeshersBuilder_RadialAlgorithm(Mesh_Algorithm):
1409 Base class for algorithms supporting radial distribution hypotheses
1413 Mesh_Algorithm.__init__(self)
1415 self.distribHyp = None #self.Hypothesis("LayerDistribution2D", UseExisting=0)
1416 self.nbLayers = None
1419 def Get2DHypothesis(self):
1422 2D hypothesis holding the 1D one
1424 if not self.distribHyp:
1425 self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0)
1426 return self.distribHyp
1428 def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"):
1430 Private method creating a 1D hypothesis and storing it in the LayerDistribution
1434 the created hypothesis
1437 self.mesh.GetMesh().RemoveHypothesis( self.geom, self.nbLayers )
1438 if self.distribHyp is None:
1439 self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0)
1441 self.mesh.GetMesh().AddHypothesis( self.geom, self.distribHyp )
1442 self.mesh.smeshpyD.SetEnablePublish( False )
1443 hyp = self.mesh.smeshpyD.CreateHypothesis(hypType, so)
1444 self.mesh.smeshpyD.SetEnablePublish( True )
1445 self.distribHyp.SetLayerDistribution( hyp )
1448 def NumberOfLayers(self, n, UseExisting=0):
1450 Defines "NumberOfLayers" hypothesis, specifying the number of layers
1454 UseExisting: if ==true - searches for the existing hypothesis created with
1455 the same parameters, else (default) - creates a new one
1458 self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp )
1459 from salome.smesh.smeshBuilder import IsEqual
1460 compFun = lambda hyp, args: IsEqual(hyp.GetNumberOfLayers(), args[0])
1461 self.nbLayers = self.Hypothesis("NumberOfLayers2D", [n], UseExisting=UseExisting,
1462 CompareMethod=compFun)
1463 self.nbLayers.SetNumberOfLayers( n )
1464 return self.nbLayers
1466 def LocalLength(self, l, p=1e-07):
1468 Defines "LocalLength" hypothesis, specifying the segment length
1471 l: the length of segments
1472 p: the precision of rounding
1474 hyp = self.OwnHypothesis("LocalLength", [l,p])
1479 def NumberOfSegments(self, n, s=[]):
1481 Defines "NumberOfSegments" hypothesis, specifying the number of layers
1484 n: the number of layers
1485 s: the scale factor (optional)
1488 hyp = self.OwnHypothesis("NumberOfSegments", [n])
1490 hyp = self.OwnHypothesis("NumberOfSegments", [n,s])
1491 hyp.SetDistrType( 1 )
1492 hyp.SetScaleFactor(s)
1493 hyp.SetNumberOfSegments(n)
1496 def Arithmetic1D(self, start, end ):
1498 Defines "Arithmetic1D" hypothesis, specifying the distribution of segments
1499 with a length that changes in arithmetic progression
1502 start: the length of the first segment
1503 end: the length of the last segment
1505 hyp = self.OwnHypothesis("Arithmetic1D", [start, end])
1506 hyp.SetLength(start, 1)
1507 hyp.SetLength(end , 0)
1510 def GeometricProgression(self, start, ratio ):
1512 Defines "GeometricProgression" hypothesis, specifying the distribution of segments
1513 with a length that changes in Geometric progression
1516 start: the length of the first segment
1517 ratio: the common ratio of the geometric progression
1519 hyp = self.OwnHypothesis("GeometricProgression", [start, ratio])
1520 hyp.SetStartLength( start )
1521 hyp.SetCommonRatio( ratio )
1524 def StartEndLength(self, start, end):
1526 Defines "StartEndLength" hypothesis, specifying distribution of segments
1527 as geometric length increasing
1530 start: for the length of the first segment
1531 end: for the length of the last segment
1533 hyp = self.OwnHypothesis("StartEndLength", [start, end])
1534 hyp.SetLength(start, 1)
1535 hyp.SetLength(end , 0)
1538 def AutomaticLength(self, fineness=0):
1540 Defines "AutomaticLength" hypothesis, specifying the number of segments
1543 fineness: defines the quality of the mesh within the range [0-1]
1545 hyp = self.OwnHypothesis("AutomaticLength")
1546 hyp.SetFineness( fineness )
1549 pass # end of StdMeshersBuilder_RadialQuadrangle1D2D class
1551 class StdMeshersBuilder_RadialQuadrangle1D2D(StdMeshersBuilder_RadialAlgorithm):
1553 Defines a Radial Quadrangle 1D-2D algorithm
1554 It is created by calling smeshBuilder.Mesh.Quadrangle(smeshBuilder.RADIAL_QUAD,geom=0)
1557 meshMethod = "Quadrangle"
1559 name of the dynamic method in smeshBuilder.Mesh class
1561 algoType = RADIAL_QUAD
1563 type of algorithm used with helper function in smeshBuilder.Mesh class
1565 docHelper = "Creates quadrangle 1D-2D algorithm for faces having a shape of disk or a disk segment"
1567 doc string of the method
1570 def __init__(self, mesh, geom=0):
1572 Private constructor.
1575 mesh: parent mesh object algorithm is assigned to
1576 geom: geometry (shape/sub-shape) algorithm is assigned to;
1577 if it is :code:`0` (default), the algorithm is assigned to the main shape
1579 StdMeshersBuilder_RadialAlgorithm.__init__(self)
1580 self.Create(mesh, geom, self.algoType)
1582 self.distribHyp = None #self.Hypothesis("LayerDistribution2D", UseExisting=0)
1583 self.nbLayers = None
1587 class StdMeshersBuilder_QuadMA_1D2D(StdMeshersBuilder_RadialAlgorithm):
1589 Defines a Quadrangle (Medial Axis Projection) 1D-2D algorithm
1590 It is created by calling smeshBuilder.Mesh.Quadrangle(smeshBuilder.QUAD_MA_PROJ,geom=0)
1593 meshMethod = "Quadrangle"
1595 name of the dynamic method in smeshBuilder.Mesh class
1597 algoType = QUAD_MA_PROJ
1599 type of algorithm used with helper function in smeshBuilder.Mesh class
1601 docHelper = "Creates quadrangle 1D-2D algorithm for faces"
1603 doc string of the method
1606 def __init__(self, mesh, geom=0):
1608 Private constructor.
1611 mesh: parent mesh object algorithm is assigned to
1612 geom: geometry (shape/sub-shape) algorithm is assigned to;
1613 if it is :code:`0` (default), the algorithm is assigned to the main shape
1615 StdMeshersBuilder_RadialAlgorithm.__init__(self)
1616 self.Create(mesh, geom, self.algoType)
1621 class StdMeshersBuilder_PolygonPerFace(Mesh_Algorithm):
1622 """ Defines a Polygon Per Face 2D algorithm
1623 It is created by calling smeshBuilder.Mesh.Polygon(geom=0)
1626 meshMethod = "Polygon"
1628 name of the dynamic method in smeshBuilder.Mesh class
1632 type of algorithm used with helper function in smeshBuilder.Mesh class
1636 flag pointing whether this algorithm should be used by default in dynamic method
1637 of smeshBuilder.Mesh class
1639 docHelper = "Creates polygon 2D algorithm for faces"
1641 doc string of the method
1644 def __init__(self, mesh, geom=0):
1646 Private constructor.
1649 mesh: parent mesh object algorithm is assigned to
1650 geom: geometry (shape/sub-shape) algorithm is assigned to;
1651 if it is :code:`0` (default), the algorithm is assigned to the main shape
1653 Mesh_Algorithm.__init__(self)
1654 self.Create(mesh, geom, self.algoType)
1659 class StdMeshersBuilder_UseExistingElements_1D(Mesh_Algorithm):
1660 """ Defines a Use Existing Elements 1D algorithm
1662 It is created by calling smeshBuilder.Mesh.UseExisting1DElements(geom=0)
1666 meshMethod = "UseExisting1DElements"
1668 name of the dynamic method in smeshBuilder.Mesh class
1670 algoType = "Import_1D"
1672 type of algorithm used with helper function in smeshBuilder.Mesh class
1676 flag pointing whether this algorithm should be used by default in dynamic method
1677 of smeshBuilder.Mesh class
1679 docHelper = "Creates 1D algorithm for edges with reusing of existing mesh elements"
1681 doc string of the method
1684 def __init__(self, mesh, geom=0):
1686 Private constructor.
1689 mesh: parent mesh object algorithm is assigned to
1690 geom: geometry (shape/sub-shape) algorithm is assigned to;
1691 if it is :code:`0` (default), the algorithm is assigned to the main shape
1693 Mesh_Algorithm.__init__(self)
1694 self.Create(mesh, geom, self.algoType)
1697 def SourceEdges(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
1699 Defines "Source edges" hypothesis, specifying groups of edges to import
1702 groups: list of groups of edges
1703 toCopyMesh: if True, the whole mesh *groups* belong to is imported
1704 toCopyGroups: if True, all groups of the mesh *groups* belong to are imported
1705 UseExisting: if ==true - searches for the existing hypothesis created with
1706 the same parameters, else (default) - creates a new one
1708 for group in groups:
1709 from salome.smesh.smeshBuilder import AssureGeomPublished
1710 AssureGeomPublished( self.mesh, group )
1711 compFun = lambda hyp, args: ( hyp.GetSourceEdges() == args[0] and \
1712 hyp.GetCopySourceMesh() == args[1], args[2] )
1713 hyp = self.Hypothesis("ImportSource1D", [groups, toCopyMesh, toCopyGroups],
1714 UseExisting=UseExisting, CompareMethod=compFun)
1715 hyp.SetSourceEdges(groups)
1716 hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups)
1719 pass # end of StdMeshersBuilder_UseExistingElements_1D class
1721 class StdMeshersBuilder_UseExistingElements_1D2D(Mesh_Algorithm):
1722 """ Defines a Use Existing Elements 1D-2D algorithm
1724 It is created by calling smeshBuilder.Mesh.UseExisting2DElements(geom=0)
1728 meshMethod = "UseExisting2DElements"
1730 name of the dynamic method in smeshBuilder.Mesh class
1732 algoType = "Import_1D2D"
1734 type of algorithm used with helper function in smeshBuilder.Mesh class
1738 flag pointing whether this algorithm should be used by default in dynamic method
1739 of smeshBuilder.Mesh class
1741 docHelper = "Creates 1D-2D algorithm for faces with reusing of existing mesh elements"
1743 doc string of the method
1746 def __init__(self, mesh, geom=0):
1748 Private constructor.
1751 mesh: parent mesh object algorithm is assigned to
1752 geom: geometry (shape/sub-shape) algorithm is assigned to;
1753 if it is :code:`0` (default), the algorithm is assigned to the main shape
1755 Mesh_Algorithm.__init__(self)
1756 self.Create(mesh, geom, self.algoType)
1759 def SourceFaces(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
1761 Defines "Source faces" hypothesis, specifying groups of faces to import
1764 groups: list of groups of faces
1765 toCopyMesh: if True, the whole mesh *groups* belong to is imported
1766 toCopyGroups: if True, all groups of the mesh *groups* belong to are imported
1767 UseExisting: if ==true - searches for the existing hypothesis created with
1768 the same parameters, else (default) - creates a new one
1771 compFun = lambda hyp, args: ( hyp.GetSourceFaces() == args[0] and \
1772 hyp.GetCopySourceMesh() == args[1], args[2] )
1773 hyp = self.Hypothesis("ImportSource2D", [groups, toCopyMesh, toCopyGroups],
1774 UseExisting=UseExisting, CompareMethod=compFun, toAdd=False)
1775 if groups and isinstance( groups, SMESH._objref_SMESH_GroupBase ):
1777 hyp.SetSourceFaces(groups)
1778 hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups)
1779 self.mesh.AddHypothesis(hyp, self.geom)
1782 pass # end of StdMeshersBuilder_UseExistingElements_1D2D class
1784 class StdMeshersBuilder_Cartesian_3D(Mesh_Algorithm):
1785 """ Defines a Body Fitting 3D algorithm
1787 It is created by calling smeshBuilder.Mesh.BodyFitted(geom=0)
1791 meshMethod = "BodyFitted"
1793 name of the dynamic method in smeshBuilder.Mesh class
1795 algoType = "Cartesian_3D"
1797 type of algorithm used with helper function in smeshBuilder.Mesh class
1801 flag pointing whether this algorithm should be used by default in dynamic method
1802 of smeshBuilder.Mesh class
1804 docHelper = "Creates Body Fitting 3D algorithm for volumes"
1806 doc string of the method
1809 def __init__(self, mesh, geom=0):
1811 Private constructor.
1814 mesh: parent mesh object algorithm is assigned to
1815 geom: geometry (shape/sub-shape) algorithm is assigned to;
1816 if it is :code:`0` (default), the algorithm is assigned to the main shape
1818 self.Create(mesh, geom, self.algoType)
1822 def SetGrid(self, xGridDef, yGridDef, zGridDef, sizeThreshold=4.0, implEdges=False):
1824 Defines "Body Fitting parameters" hypothesis
1827 xGridDef: is definition of the grid along the X asix.
1828 It can be in either of two following forms:
1830 - Explicit coordinates of nodes, e.g. [-1.5, 0.0, 3.1] or range( -100,200,10)
1831 - Functions f(t) defining grid spacing at each point on grid axis. If there are
1832 several functions, they must be accompanied by relative coordinates of
1833 points dividing the whole shape into ranges where the functions apply; points
1834 coodrinates should vary within (0.0, 1.0) range. Parameter *t* of the spacing
1835 function f(t) varies from 0.0 to 1.0 within a shape range.
1838 "10.5" - defines a grid with a constant spacing
1839 [["1", "1+10*t", "11"] [0.1, 0.6]] - defines different spacing in 3 ranges.
1842 yGridDef: defines the grid along the Y asix the same way as *xGridDef* does.
1843 zGridDef: defines the grid along the Z asix the same way as *xGridDef* does.
1844 sizeThreshold: (> 1.0) defines a minimal size of a polyhedron so that
1845 a polyhedron of size less than hexSize/sizeThreshold is not created.
1846 implEdges: enables implementation of geometrical edges into the mesh.
1849 compFun = lambda hyp, args: False
1850 self.hyp = self.Hypothesis("CartesianParameters3D",
1851 [xGridDef, yGridDef, zGridDef, sizeThreshold],
1852 UseExisting=False, CompareMethod=compFun)
1853 if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ):
1854 self.mesh.AddHypothesis( self.hyp, self.geom )
1856 for axis, gridDef in enumerate( [xGridDef, yGridDef, zGridDef] ):
1857 if not gridDef: raise ValueError("Empty grid definition")
1858 if isinstance( gridDef, str ):
1859 self.hyp.SetGridSpacing( [gridDef], [], axis )
1860 elif isinstance( gridDef[0], str ):
1861 self.hyp.SetGridSpacing( gridDef, [], axis )
1862 elif isinstance( gridDef[0], int ) or \
1863 isinstance( gridDef[0], float ):
1864 self.hyp.SetGrid(gridDef, axis )
1866 self.hyp.SetGridSpacing( gridDef[0], gridDef[1], axis )
1867 self.hyp.SetSizeThreshold( sizeThreshold )
1868 self.hyp.SetToAddEdges( implEdges )
1871 def SetAxesDirs( self, xAxis, yAxis, zAxis ):
1873 Defines custom directions of axes of the grid
1876 xAxis: either SMESH.DirStruct or a vector, or 3 vector components
1877 yAxis: either SMESH.DirStruct or a vector, or 3 vector components
1878 zAxis: either SMESH.DirStruct or a vector, or 3 vector components
1881 if hasattr( xAxis, "__getitem__" ):
1882 xAxis = self.mesh.smeshpyD.MakeDirStruct( xAxis[0],xAxis[1],xAxis[2] )
1883 elif isinstance( xAxis, GEOM._objref_GEOM_Object ):
1884 xAxis = self.mesh.smeshpyD.GetDirStruct( xAxis )
1885 if hasattr( yAxis, "__getitem__" ):
1886 yAxis = self.mesh.smeshpyD.MakeDirStruct( yAxis[0],yAxis[1],yAxis[2] )
1887 elif isinstance( yAxis, GEOM._objref_GEOM_Object ):
1888 yAxis = self.mesh.smeshpyD.GetDirStruct( yAxis )
1889 if hasattr( zAxis, "__getitem__" ):
1890 zAxis = self.mesh.smeshpyD.MakeDirStruct( zAxis[0],zAxis[1],zAxis[2] )
1891 elif isinstance( zAxis, GEOM._objref_GEOM_Object ):
1892 zAxis = self.mesh.smeshpyD.GetDirStruct( zAxis )
1894 self.hyp = self.Hypothesis("CartesianParameters3D")
1895 if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ):
1896 self.mesh.AddHypothesis( self.hyp, self.geom )
1897 self.hyp.SetAxesDirs( xAxis, yAxis, zAxis )
1900 def SetOptimalAxesDirs(self, isOrthogonal=True):
1902 Automatically defines directions of axes of the grid at which
1903 a number of generated hexahedra is maximal
1906 isOrthogonal: defines whether the axes mush be orthogonal
1909 self.hyp = self.Hypothesis("CartesianParameters3D")
1910 if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ):
1911 self.mesh.AddHypothesis( self.hyp, self.geom )
1912 x,y,z = self.hyp.ComputeOptimalAxesDirs( self.geom, isOrthogonal )
1913 self.hyp.SetAxesDirs( x,y,z )
1916 def SetFixedPoint( self, p, toUnset=False ):
1918 Sets/unsets a fixed point. The algorithm makes a plane of the grid pass
1919 through the fixed point in each direction at which the grid is defined
1923 p: coordinates of the fixed point. Either SMESH.PointStruct or
1924 a vertex or 3 components of coordinates.
1925 toUnset: defines whether the fixed point is defined or removed.
1929 if not self.hyp: return
1930 p = SMESH.PointStruct(0,0,0)
1931 elif hasattr( p, "__getitem__" ):
1932 p = SMESH.PointStruct( p[0],p[1],p[2] )
1933 elif isinstance( p, GEOM._objref_GEOM_Object ):
1934 p = self.mesh.smeshpyD.GetPointStruct( p )
1936 self.hyp = self.Hypothesis("CartesianParameters3D")
1937 if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ):
1938 self.mesh.AddHypothesis( self.hyp, self.geom )
1939 self.hyp.SetFixedPoint( p, toUnset )
1943 pass # end of StdMeshersBuilder_Cartesian_3D class
1945 class StdMeshersBuilder_UseExisting_1D(Mesh_Algorithm):
1946 """ Defines a stub 1D algorithm, which enables "manual" creation of nodes and
1947 segments usable by 2D algorithms
1949 It is created by calling smeshBuilder.Mesh.UseExistingSegments(geom=0)
1953 meshMethod = "UseExistingSegments"
1955 name of the dynamic method in smeshBuilder.Mesh class
1957 algoType = "UseExisting_1D"
1959 type of algorithm used with helper function in smeshBuilder.Mesh class
1961 docHelper = "Creates 1D algorithm allowing batch meshing of edges"
1963 doc string of the method
1966 def __init__(self, mesh, geom=0):
1968 Private constructor.
1971 mesh: parent mesh object algorithm is assigned to
1972 geom: geometry (shape/sub-shape) algorithm is assigned to;
1973 if it is :code:`0` (default), the algorithm is assigned to the main shape
1975 self.Create(mesh, geom, self.algoType)
1978 pass # end of StdMeshersBuilder_UseExisting_1D class
1980 class StdMeshersBuilder_UseExisting_2D(Mesh_Algorithm):
1981 """ Defines a stub 2D algorithm, which enables "manual" creation of nodes and
1982 faces usable by 3D algorithms
1984 It is created by calling smeshBuilder.Mesh.UseExistingFaces(geom=0)
1988 meshMethod = "UseExistingFaces"
1990 name of the dynamic method in smeshBuilder.Mesh class
1992 algoType = "UseExisting_2D"
1994 type of algorithm used with helper function in smeshBuilder.Mesh class
1996 docHelper = "Creates 2D algorithm allowing batch meshing of faces"
1998 doc string of the method
2001 def __init__(self, mesh, geom=0):
2003 Private constructor.
2006 mesh: parent mesh object algorithm is assigned to
2007 geom: geometry (shape/sub-shape) algorithm is assigned to;
2008 if it is :code:`0` (default), the algorithm is assigned to the main shape
2010 self.Create(mesh, geom, self.algoType)
2013 pass # end of StdMeshersBuilder_UseExisting_2D class