src/SMESH_SWIG/StdMeshersBuilder.py

   1 # Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
   2 #
   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.
   7 #
   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.
  12 #
  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
  16 #
  17 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 #
  19
  20 """
  21 Python API for the standard meshing plug-in module.
  22 """
  23
  24 LIBRARY = "libStdMeshersEngine.so"
  25
  26 from salome.smesh.smesh_algorithm import Mesh_Algorithm
  27 import StdMeshers
  28
  29 #----------------------------
  30 # Mesh algo type identifiers
  31 #----------------------------
  32
  33 REGULAR     = "Regular_1D"
  34 """
  35 Algorithm type: Regular 1D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_Segment`
  36 """
  37
  38 PYTHON      = "Python_1D"
  39 """
  40 Algorithm type: Python 1D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_Segment_Python`
  41 """
  42
  43 COMPOSITE   = "CompositeSegment_1D"
  44 """
  45
  46 Algorithm type: Composite segment 1D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_CompositeSegment`
  47 """
  48 MEFISTO     = "MEFISTO_2D"
  49 """
  50 Algorithm type: Triangle MEFISTO 2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_Triangle_MEFISTO`
  51 """
  52
  53 Hexa        = "Hexa_3D"
  54 """
  55 Algorithm type: Hexahedron 3D (i-j-k) algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_Hexahedron`
  56 """
  57
  58 QUADRANGLE  = "Quadrangle_2D"
  59 """
  60 Algorithm type: Quadrangle 2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_Quadrangle`
  61 """
  62
  63 RADIAL_QUAD = "RadialQuadrangle_1D2D"
  64 """
  65 Algorithm type: Radial Quadrangle 1D-2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_RadialQuadrangle1D2D`
  66 """
  67
  68 QUAD_MA_PROJ = "QuadFromMedialAxis_1D2D"
  69 """
  70 Algorithm type: Quadrangle (Medial Axis Projection) 1D-2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_QuadMA_1D2D`
  71 """
  72
  73 POLYGON     = "PolygonPerFace_2D"
  74 """
  75 Algorithm type: Polygon Per Face 2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_PolygonPerFace`
  76 """
  77
  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))
  81
  82 #----------------------
  83 # Algorithms
  84 #----------------------
  85
  86 class StdMeshersBuilder_Segment(Mesh_Algorithm):
  87     """
  88     Defines segment 1D algorithm for edges discretization.
  89
  90     It can be created by calling smeshBuilder.Mesh.Segment(geom=0)
  91     """
  92
  93
  94     meshMethod = "Segment"
  95     """
  96     name of the dynamic method in smeshBuilder.Mesh class
  97     """
  98
  99     algoType   = REGULAR
 100     """
 101     type of algorithm used with helper function in smeshBuilder.Mesh class
 102     """
 103
 104     isDefault  = True
 105     """
 106     flag pointing whether this algorithm should be used by default in dynamic method
 107     of smeshBuilder.Mesh class
 108     """
 109
 110     docHelper  = "Creates segment 1D algorithm for edges"
 111     """
 112     doc string of the method
 113     """
 114
 115     def __init__(self, mesh, geom=0):
 116         """
 117         Private constructor.
 118         Parameters:
 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
 122         """
 123         Mesh_Algorithm.__init__(self)
 124         self.Create(mesh, geom, self.algoType)
 125         pass
 126
 127     def LocalLength(self, l, UseExisting=0, p=1e-07):
 128         """
 129         Defines "LocalLength" hypothesis to cut an edge in several segments with the same length
 130
 131         Parameters:
 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.
 144
 145         Returns:
 146             an instance of StdMeshers_LocalLength hypothesis
 147         """
 148
 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)
 152         hyp.SetLength(l)
 153         hyp.SetPrecision(p)
 154         return hyp
 155
 156     def MaxSize(self, length=0.0, UseExisting=0):
 157         """
 158         Defines "MaxSize" hypothesis to cut an edge into segments not longer than given value
 159
 160         Parameters:
 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
 165
 166         Returns:
 167             an instance of StdMeshers_MaxLength hypothesis
 168         """
 169
 170
 171         hyp = self.Hypothesis("MaxLength", [length], UseExisting=UseExisting)
 172         if length > 0.0:
 173             # set given length
 174             hyp.SetLength(length)
 175         if not UseExisting:
 176             # set preestimated length
 177             gen = self.mesh.smeshpyD
 178             initHyp = gen.GetHypothesisParameterValues("MaxLength", "libStdMeshersEngine.so",
 179                                                        self.mesh.GetMesh(), self.mesh.GetShape(),
 180                                                        False) # <- byMesh
 181             preHyp = initHyp._narrow(StdMeshers.StdMeshers_MaxLength)
 182             if preHyp:
 183                 hyp.SetPreestimatedLength( preHyp.GetPreestimatedLength() )
 184                 pass
 185             pass
 186         hyp.SetUsePreestimatedLength( length == 0.0 )
 187         return hyp
 188
 189     def NumberOfSegments(self, n, s=[], reversedEdges=[], UseExisting=0):
 190         """
 191         Defines "NumberOfSegments" hypothesis to cut an edge in a fixed number of segments
 192
 193         Parameters:
 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
 200
 201         Returns:
 202             an instance of StdMeshers_NumberOfSegments hypothesis
 203         """
 204
 205
 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)
 210         if not s:
 211             hyp = self.Hypothesis("NumberOfSegments", [n, reversedEdgeInd, entry],
 212                                   UseExisting=UseExisting,
 213                                   CompareMethod=self._compareNumberOfSegments)
 214         else:
 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 )
 222         return hyp
 223
 224     def _compareNumberOfSegments(self, hyp, args):
 225         """
 226         Private method
 227         Checks if the given "NumberOfSegments" hypothesis has the same parameters as the given arguments
 228         """
 229         if hyp.GetNumberOfSegments() == args[0]:
 230             if len(args) == 3:
 231                 if hyp.GetReversedEdges() == args[1]:
 232                     if not args[1] or hyp.GetObjectEntry() == args[2]:
 233                         return True
 234             else:
 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]):
 240                                 return True
 241         return False
 242
 243     def Adaptive(self, minSize, maxSize, deflection, UseExisting=False):
 244         """
 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.
 249
 250         Parameters:
 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
 256
 257         Returns:
 258             an instance of StdMeshers_Adaptive1D hypothesis
 259         """
 260
 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)
 270         return hyp
 271
 272     def Arithmetic1D(self, start, end, reversedEdges=[], UseExisting=0):
 273         """
 274         Defines "Arithmetic1D" hypothesis to cut an edge in several segments with a length
 275                 that changes in arithmetic progression
 276
 277         Parameters:
 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
 284
 285         Returns:
 286                 an instance of StdMeshers_Arithmetic1D hypothesis
 287         """
 288
 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 )
 304         return hyp
 305
 306     def GeometricProgression(self, start, ratio, reversedEdges=[], UseExisting=0):
 307         """
 308             Defines "GeometricProgression" hypothesis to cut an edge in several
 309                 segments with a length that changes in Geometric progression
 310
 311             Parameters:
 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
 318
 319             Returns:
 320                 an instance of StdMeshers_Geometric1D hypothesis
 321         """
 322
 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 )
 336         return hyp
 337
 338     def FixedPoints1D(self, points, nbSegs=[1], reversedEdges=[], UseExisting=0):
 339         """
 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
 344                 values are 1)
 345
 346         Parameters:
 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
 353
 354         Returns:
 355                 an instance of StdMeshers_FixedPoints1D hypothesis
 356         """
 357
 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)
 372         return hyp
 373
 374     def StartEndLength(self, start, end, reversedEdges=[], UseExisting=0):
 375         """
 376         Defines "StartEndLength" hypothesis to cut an edge in several segments with increasing geometric length
 377
 378         Parameters:
 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
 385
 386         Returns:
 387             an instance of StdMeshers_StartEndLength hypothesis
 388         """
 389
 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 )
 405         return hyp
 406
 407     def Deflection1D(self, d, UseExisting=0):
 408         """
 409         Defines "Deflection1D" hypothesis
 410
 411         Parameters:
 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
 415         """
 416
 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)
 420         hyp.SetDeflection(d)
 421         return hyp
 422
 423     def Propagation(self):
 424         """
 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.
 429         """
 430
 431         return self.Hypothesis("Propagation", UseExisting=1, CompareMethod=self.CompareEqualHyp)
 432
 433     def PropagationOfDistribution(self):
 434         """
 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.
 439         """
 440
 441         return self.Hypothesis("PropagOfDistribution", UseExisting=1,
 442                                CompareMethod=self.CompareEqualHyp)
 443
 444     def AutomaticLength(self, fineness=0, UseExisting=0):
 445         """
 446         Defines "AutomaticLength" hypothesis
 447
 448         Parameters:
 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
 452         """
 453
 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 )
 459         return hyp
 460
 461     def LengthNearVertex(self, length, vertex=0, UseExisting=0):
 462         """
 463         Defines "SegmentLengthAroundVertex" hypothesis
 464
 465         Parameters:
 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
 472         """
 473
 474         import types
 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]
 480                 self.geom = vertex
 481                 pass
 482             pass
 483         else:
 484             self.geom = vertex
 485             pass
 486         # 0D algorithm
 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)
 493
 494         algo = self.FindAlgorithm("SegmentAroundVertex_0D", self.mesh.smeshpyD)
 495         if algo is None:
 496             algo = self.mesh.smeshpyD.CreateHypothesis("SegmentAroundVertex_0D", "libStdMeshersEngine.so")
 497             pass
 498         status = self.mesh.mesh.AddHypothesis(self.geom, algo)
 499         TreatHypoStatus(status, "SegmentAroundVertex_0D", name, True, self.mesh)
 500         #
 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 )
 507         return hyp
 508
 509     def QuadraticMesh(self):
 510         """
 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.
 517         """
 518
 519         hyp = self.Hypothesis("QuadraticMesh", UseExisting=1, CompareMethod=self.CompareEqualHyp)
 520         return hyp
 521
 522     pass # end of StdMeshersBuilder_Segment class
 523
 524 class StdMeshersBuilder_CompositeSegment(StdMeshersBuilder_Segment):
 525     """
 526     Segment 1D algorithm for discretization of a set of adjacent edges as one edge.
 527
 528     It is created by calling smeshBuilder.Mesh.Segment(smeshBuilder.COMPOSITE,geom=0)
 529     """
 530
 531
 532     meshMethod = "Segment"
 533     """
 534     name of the dynamic method in smeshBuilder.Mesh class
 535     """
 536
 537     algoType   = COMPOSITE
 538     """
 539     type of algorithm used with helper function in smeshBuilder.Mesh class
 540     """
 541
 542     isDefault  = False
 543     """
 544     flag pointing whether this algorithm should be used by default in dynamic method
 545         of smeshBuilder.Mesh class
 546     """
 547
 548     docHelper  = "Creates segment 1D algorithm for edges"
 549     """
 550     doc string of the method
 551     """
 552
 553     def __init__(self, mesh, geom=0):
 554         """
 555         Private constructor.
 556
 557         Parameters:
 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
 561         """
 562         self.Create(mesh, geom, self.algoType)
 563         pass
 564
 565     pass # end of StdMeshersBuilder_CompositeSegment class
 566
 567 class StdMeshersBuilder_Segment_Python(Mesh_Algorithm):
 568     """
 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)
 571     """
 572
 573
 574     meshMethod = "Segment"
 575     """
 576     name of the dynamic method in smeshBuilder.Mesh class
 577     """
 578     algoType   = PYTHON
 579     """
 580     type of algorithm used with helper function in smeshBuilder.Mesh class
 581     """
 582     docHelper  = "Creates segment 1D algorithm for edges"
 583     """
 584     doc string of the method
 585     """
 586
 587     def __init__(self, mesh, geom=0):
 588         """
 589         Private constructor.
 590
 591         Parameters:
 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
 595         """
 596         import Python1dPlugin
 597         self.Create(mesh, geom, self.algoType, "libPython1dEngine.so")
 598         pass
 599
 600     def PythonSplit1D(self, n, func, UseExisting=0):
 601         """
 602         Defines "PythonSplit1D" hypothesis
 603
 604         Parameters:
 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
 609         """
 610
 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)
 616         return hyp
 617
 618     pass # end of StdMeshersBuilder_Segment_Python class
 619
 620 class StdMeshersBuilder_Triangle_MEFISTO(Mesh_Algorithm):
 621     """
 622     Triangle MEFISTO 2D algorithm.
 623     It is created by calling smeshBuilder.Mesh.Triangle(smeshBuilder.MEFISTO,geom=0)
 624     """
 625
 626
 627     meshMethod = "Triangle"
 628     """
 629     name of the dynamic method in smeshBuilder.Mesh class
 630     """
 631     algoType   = MEFISTO
 632     """
 633     type of algorithm used with helper function in smeshBuilder.Mesh class
 634     """
 635     isDefault  = True
 636     """
 637     flag pointing whether this algorithm should be used by default in dynamic method
 638         of smeshBuilder.Mesh class
 639     """
 640     docHelper  = "Creates triangle 2D algorithm for faces"
 641     """
 642     doc string of the method
 643     """
 644
 645     def __init__(self, mesh, geom=0):
 646         """
 647         Private constructor.
 648
 649         Parameters:
 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
 653         """
 654         Mesh_Algorithm.__init__(self)
 655         self.Create(mesh, geom, self.algoType)
 656         pass
 657
 658     def MaxElementArea(self, area, UseExisting=0):
 659         """
 660         Defines "MaxElementArea" hypothesis basing on the definition of the maximum area of each triangle
 661
 662         Parameters:
 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
 666         """
 667
 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)
 673         return hyp
 674
 675     def LengthFromEdges(self):
 676         """
 677         Defines "LengthFromEdges" hypothesis to build triangles
 678             based on the length of the edges taken from the wire
 679         """
 680
 681         hyp = self.Hypothesis("LengthFromEdges", UseExisting=1, CompareMethod=self.CompareEqualHyp)
 682         return hyp
 683
 684     pass # end of StdMeshersBuilder_Triangle_MEFISTO class
 685
 686 class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
 687     """
 688     Defines a quadrangle 2D algorithm.
 689     It is created by calling smeshBuilder.Mesh.Quadrangle(geom=0)
 690     """
 691
 692
 693     meshMethod = "Quadrangle"
 694     """
 695     name of the dynamic method in smeshBuilder.Mesh class
 696     """
 697     algoType   = QUADRANGLE
 698     """
 699     type of algorithm used with helper function in smeshBuilder.Mesh class
 700     """
 701     isDefault  = True
 702     """
 703     flag pointing whether this algorithm should be used by default in dynamic method
 704         of smeshBuilder.Mesh class
 705     """
 706     docHelper  = "Creates quadrangle 2D algorithm for faces"
 707     """
 708     doc string of the method
 709     """
 710     params     = 0
 711     """
 712     hypothesis associated with algorithm
 713     """
 714
 715     def __init__(self, mesh, geom=0):
 716         """
 717         Private constructor.
 718
 719         Parameters:
 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
 723         """
 724         Mesh_Algorithm.__init__(self)
 725         self.Create(mesh, geom, self.algoType)
 726         pass
 727
 728     def QuadrangleParameters(self, quadType=StdMeshers.QUAD_STANDARD, triangleVertex=0,
 729                              enfVertices=[],enfPoints=[],UseExisting=0):
 730         """
 731         Defines "QuadrangleParameters" hypothesis
 732             quadType defines the algorithm of transition between differently descretized
 733             sides of a geometrical face:
 734
 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
 738                 finer meshed sides.
 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.
 749
 750         Parameters:
 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
 754                 shape to mesh
 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
 767         """
 768
 769
 770         import GEOM, SMESH
 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 = [], []
 778         for p in enfPoints:
 779             if isinstance( p, SMESH.PointStruct ):
 780                 xyz.append(( p.x, p.y, p.z ))
 781                 pStructs.append( p )
 782             else:
 783                 xyz.append(( p[0], p[1], p[2] ))
 784                 pStructs.append( SMESH.PointStruct( p[0], p[1], p[2] ))
 785         if not self.params:
 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)
 793             pass
 794         if self.params.GetQuadType() != quadType:
 795             self.params.SetQuadType(quadType)
 796         if vertexID > 0:
 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 )
 802         return self.params
 803
 804     def QuadranglePreference(self, reversed=False, UseExisting=0):
 805         """
 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.
 809
 810         Parameters:
 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
 814         """
 815
 816         if reversed:
 817             return self.QuadrangleParameters(QUAD_QUADRANGLE_PREF_REVERSED,UseExisting=UseExisting)
 818         return self.QuadrangleParameters(QUAD_QUADRANGLE_PREF,UseExisting=UseExisting)
 819
 820     def TrianglePreference(self, UseExisting=0):
 821         """
 822         Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only
 823             triangles are built in the transition area along the finer meshed sides.
 824
 825         Parameters:
 826             UseExisting: if ==true - searches for the existing hypothesis created with
 827                 the same parameters, else (default) - creates a new one
 828         """
 829
 830         return self.QuadrangleParameters(QUAD_TRIANGLE_PREF,UseExisting=UseExisting)
 831
 832     def Reduced(self, UseExisting=0):
 833         """
 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.
 839
 840         Parameters:
 841             UseExisting: if ==true - searches for the existing hypothesis created with
 842                 the same parameters, else (default) - creates a new one
 843         """
 844
 845         return self.QuadrangleParameters(QUAD_REDUCED,UseExisting=UseExisting)
 846
 847     def TriangleVertex(self, vertex, UseExisting=0):
 848         """
 849         Defines "QuadrangleParams" hypothesis with QUAD_STANDARD type of quadrangulation
 850
 851         Parameters:
 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
 855                 shape to mesh
 856              UseExisting: if ==true - searches for the existing hypothesis created with
 857                 the same parameters, else (default) - creates a new one
 858         """
 859
 860         return self.QuadrangleParameters(QUAD_STANDARD,vertex,UseExisting)
 861
 862     pass # end of StdMeshersBuilder_Quadrangle class
 863
 864 class StdMeshersBuilder_Hexahedron(Mesh_Algorithm):
 865     """
 866     Defines a hexahedron 3D algorithm.
 867     It is created by calling smeshBuilder.Mesh.Hexahedron(geom=0)
 868     """
 869
 870
 871     meshMethod = "Hexahedron"
 872     """
 873     name of the dynamic method in smeshBuilder.Mesh class
 874     """
 875     algoType   = Hexa
 876     """
 877     type of algorithm used with helper function in smeshBuilder.Mesh class
 878     """
 879     isDefault  = True
 880     """
 881     flag pointing whether this algorithm should be used by default in dynamic method
 882         of smeshBuilder.Mesh class
 883     """
 884     docHelper  = "Creates hexahedron 3D algorithm for volumes"
 885     """
 886     doc string of the method
 887     """
 888
 889     def __init__(self, mesh, geom=0):
 890         """
 891         Private constructor.
 892
 893         Parameters:
 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
 897         """
 898         Mesh_Algorithm.__init__(self)
 899         self.Create(mesh, geom, Hexa)
 900         pass
 901
 902     pass # end of StdMeshersBuilder_Hexahedron class
 903
 904 class StdMeshersBuilder_Projection1D(Mesh_Algorithm):
 905     """
 906     Defines a projection 1D algorithm.
 907     It is created by calling smeshBuilder.Mesh.Projection1D(geom=0)
 908     """
 909
 910
 911     meshMethod = "Projection1D"
 912     """
 913     name of the dynamic method in smeshBuilder.Mesh class
 914     """
 915     algoType   = "Projection_1D"
 916     """
 917     type of algorithm used with helper function in smeshBuilder.Mesh class
 918     """
 919     isDefault  = True
 920     """
 921     flag pointing whether this algorithm should be used by default in dynamic method
 922         of smeshBuilder.Mesh class
 923     """
 924     docHelper  = "Creates projection 1D algorithm for edges"
 925     """
 926     doc string of the method
 927     """
 928     def __init__(self, mesh, geom=0):
 929         """
 930         Private constructor.
 931
 932         Parameters:
 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
 936         """
 937         Mesh_Algorithm.__init__(self)
 938         self.Create(mesh, geom, self.algoType)
 939         pass
 940
 941     def SourceEdge(self, edge, mesh=None, srcV=None, tgtV=None, UseExisting=0):
 942         """
 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)
 946
 947         Parameters:
 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
 954         """
 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],
 960                               UseExisting=0)
 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 )
 968         return hyp
 969
 970     pass # end of StdMeshersBuilder_Projection1D class
 971
 972 class StdMeshersBuilder_Projection2D(Mesh_Algorithm):
 973     """
 974     Defines a projection 2D algorithm.
 975     It is created by calling smeshBuilder.Mesh.Projection2D(geom=0)
 976     """
 977
 978
 979     meshMethod = "Projection2D"
 980     """
 981     name of the dynamic method in smeshBuilder.Mesh class
 982     """
 983     algoType   = "Projection_2D"
 984     """
 985     type of algorithm used with helper function in smeshBuilder.Mesh class
 986     """
 987     isDefault  = True
 988     """
 989     flag pointing whether this algorithm should be used by default in dynamic method
 990         of smeshBuilder.Mesh class
 991     """
 992     docHelper  = "Creates projection 2D algorithm for faces"
 993     """
 994     doc string of the method
 995     """
 996
 997     def __init__(self, mesh, geom=0):
 998         """
 999         Private constructor.
1000
1001         Parameters:
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
1005         """
1006         Mesh_Algorithm.__init__(self)
1007         self.Create(mesh, geom, self.algoType)
1008         pass
1009
1010
1011     def SourceFace(self, face, mesh=None, srcV1=None, tgtV1=None,
1012                    srcV2=None, tgtV2=None, UseExisting=0):
1013         """
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)
1017
1018         Parameters:
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
1027
1028         Note:
1029             all association vertices must belong to one edge of a face
1030         """
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)
1045         return hyp
1046
1047     pass # end of StdMeshersBuilder_Projection2D class
1048
1049 class StdMeshersBuilder_Projection1D2D(StdMeshersBuilder_Projection2D):
1050     """
1051     Defines a projection 1D-2D algorithm.
1052     It is created by calling smeshBuilder.Mesh.Projection1D2D(geom=0)
1053     """
1054
1055
1056     meshMethod = "Projection1D2D"
1057     """
1058     name of the dynamic method in smeshBuilder.Mesh class
1059     """
1060     algoType   = "Projection_1D2D"
1061     """
1062     type of algorithm used with helper function in smeshBuilder.Mesh class
1063     """
1064     docHelper  = "Creates projection 1D-2D algorithm for faces"
1065     """
1066     doc string of the method
1067     """
1068
1069     def __init__(self, mesh, geom=0):
1070         """
1071         Private constructor.
1072
1073         Parameters:
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
1077         """
1078         StdMeshersBuilder_Projection2D.__init__(self, mesh, geom)
1079         pass
1080
1081     pass # end of StdMeshersBuilder_Projection1D2D class
1082
1083 class StdMeshersBuilder_Projection3D(Mesh_Algorithm):
1084     """
1085     Defines a projection 3D algorithm.
1086     It is created by calling smeshBuilder.Mesh.Projection3D(geom=0)
1087     """
1088
1089
1090     meshMethod = "Projection3D"
1091     """
1092     name of the dynamic method in smeshBuilder.Mesh class
1093     """
1094     algoType   = "Projection_3D"
1095     """
1096     type of algorithm used with helper function in smeshBuilder.Mesh class
1097     """
1098     docHelper  = "Creates projection 3D algorithm for volumes"
1099     """
1100     doc string of the method
1101     """
1102
1103     def __init__(self, mesh, geom=0):
1104         """
1105         Private constructor.
1106
1107         Parameters:
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
1111         """
1112         Mesh_Algorithm.__init__(self)
1113         self.Create(mesh, geom, self.algoType)
1114         pass
1115
1116     def SourceShape3D(self, solid, mesh=0, srcV1=0, tgtV1=0,
1117                       srcV2=0, tgtV2=0, UseExisting=0):
1118         """
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)
1122
1123         Parameters:
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
1132
1133         Note:
1134             association vertices must belong to one edge of a solid
1135         """
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],
1141                               UseExisting=0)
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()
1148         if mesh:
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:
1153         return hyp
1154
1155     pass # end of StdMeshersBuilder_Projection3D class
1156
1157 class StdMeshersBuilder_Prism3D(Mesh_Algorithm):
1158     """
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)
1161     """
1162
1163
1164     meshMethod = "Prism"
1165     """
1166     name of the dynamic method in smeshBuilder.Mesh class
1167     """
1168     algoType   = "Prism_3D"
1169     """
1170     type of algorithm used with helper function in smeshBuilder.Mesh class
1171     """
1172     docHelper  = "Creates prism 3D algorithm for volumes"
1173     """
1174     doc string of the method
1175     """
1176     isDefault  = True
1177     """
1178     flag pointing whether this algorithm should be used by default in dynamic method
1179         of smeshBuilder.Mesh class
1180     """
1181
1182     def __init__(self, mesh, geom=0):
1183         """
1184         Private constructor.
1185
1186         Parameters:
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
1190         """
1191         Mesh_Algorithm.__init__(self)
1192
1193         shape = geom
1194         if not shape:
1195             shape = mesh.geom
1196         isRadial = mesh.smeshpyD.IsApplicable("RadialPrism_3D", LIBRARY, shape, False )
1197         if not isRadial:
1198             self.Create(mesh, geom, "Prism_3D")
1199             pass
1200         else:
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
1205             pass
1206         pass
1207
1208     def Get3DHypothesis(self):
1209         """
1210         Returns:
1211             3D hypothesis holding the 1D one
1212         """
1213         if self.algoType != "RadialPrism_3D":
1214             print("Prism_3D algorithm doesn't support any hypothesis")
1215             return None
1216         return self.distribHyp
1217
1218     def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"):
1219         """
1220         Private method creating a 1D hypothesis and storing it in the LayerDistribution
1221             hypothesis.
1222
1223         Returns:
1224             the created hypothesis
1225         """
1226         if self.algoType != "RadialPrism_3D":
1227             print("Prism_3D algorithm doesn't support any hypothesis")
1228             return None
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 )
1238         return hyp
1239
1240     def NumberOfLayers(self, n, UseExisting=0):
1241         """
1242         Defines "NumberOfLayers" hypothesis, specifying the number of layers of
1243             prisms to build between the inner and outer shells
1244
1245         Parameters:
1246             n: number of layers
1247             UseExisting: if ==true - searches for the existing hypothesis created with
1248                 the same parameters, else (default) - creates a new one
1249         """
1250         if self.algoType != "RadialPrism_3D":
1251             print("Prism_3D algorithm doesn't support any hypothesis")
1252             return None
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
1260
1261     def LocalLength(self, l, p=1e-07):
1262         """
1263         Defines "LocalLength" hypothesis, specifying the segment length
1264             to build between the inner and the outer shells
1265
1266         Parameters:
1267             l: the length of segments
1268             p: the precision of rounding
1269         """
1270         if self.algoType != "RadialPrism_3D":
1271             print("Prism_3D algorithm doesn't support any hypothesis")
1272             return None
1273         hyp = self.OwnHypothesis("LocalLength", [l,p])
1274         hyp.SetLength(l)
1275         hyp.SetPrecision(p)
1276         return hyp
1277
1278     def NumberOfSegments(self, n, s=[]):
1279         """
1280         Defines "NumberOfSegments" hypothesis, specifying the number of layers of
1281             prisms to build between the inner and the outer shells.
1282
1283         Parameters:
1284             n: the number of layers
1285             s: the scale factor (optional)
1286         """
1287         if self.algoType != "RadialPrism_3D":
1288             print("Prism_3D algorithm doesn't support any hypothesis")
1289             return None
1290         if not s:
1291             hyp = self.OwnHypothesis("NumberOfSegments", [n])
1292         else:
1293             hyp = self.OwnHypothesis("NumberOfSegments", [n,s])
1294             hyp.SetScaleFactor(s)
1295         hyp.SetNumberOfSegments(n)
1296         return hyp
1297
1298     def Arithmetic1D(self, start, end ):
1299         """
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
1303
1304         Parameters:
1305             start:  the length of the first segment
1306             end:    the length of the last  segment
1307         """
1308         if self.algoType != "RadialPrism_3D":
1309             print("Prism_3D algorithm doesn't support any hypothesis")
1310             return None
1311         hyp = self.OwnHypothesis("Arithmetic1D", [start, end])
1312         hyp.SetLength(start, 1)
1313         hyp.SetLength(end  , 0)
1314         return hyp
1315
1316     def GeometricProgression(self, start, ratio ):
1317         """
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
1321
1322         Parameters:
1323             start:  the length of the first segment
1324             ratio:  the common ratio of the geometric progression
1325         """
1326         if self.algoType != "RadialPrism_3D":
1327             print("Prism_3D algorithm doesn't support any hypothesis")
1328             return None
1329         hyp = self.OwnHypothesis("GeometricProgression", [start, ratio])
1330         hyp.SetStartLength( start )
1331         hyp.SetCommonRatio( ratio )
1332         return hyp
1333
1334     def StartEndLength(self, start, end):
1335         """
1336         Defines "StartEndLength" hypothesis, specifying distribution of segments
1337             to build between the inner and the outer shells as geometric length increasing
1338
1339         Parameters:
1340             start: for the length of the first segment
1341         end:   for the length of the last  segment
1342         """
1343         if self.algoType != "RadialPrism_3D":
1344             print("Prism_3D algorithm doesn't support any hypothesis")
1345             return None
1346         hyp = self.OwnHypothesis("StartEndLength", [start, end])
1347         hyp.SetLength(start, 1)
1348         hyp.SetLength(end  , 0)
1349         return hyp
1350
1351     def AutomaticLength(self, fineness=0):
1352         """
1353         Defines "AutomaticLength" hypothesis, specifying the number of segments
1354             to build between the inner and outer shells
1355
1356         Parameters:
1357             fineness: defines the quality of the mesh within the range [0-1]
1358         """
1359         if self.algoType != "RadialPrism_3D":
1360             print("Prism_3D algorithm doesn't support any hypothesis")
1361             return None
1362         hyp = self.OwnHypothesis("AutomaticLength")
1363         hyp.SetFineness( fineness )
1364         return hyp
1365
1366     pass # end of StdMeshersBuilder_Prism3D class
1367
1368 class StdMeshersBuilder_RadialPrism3D(StdMeshersBuilder_Prism3D):
1369     """
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.
1374     """
1375
1376     meshMethod = "Prism"
1377     """
1378     name of the dynamic method in smeshBuilder.Mesh class
1379     """
1380     algoType   = "RadialPrism_3D"
1381     """
1382     type of algorithm used with helper function in smeshBuilder.Mesh class
1383     """
1384     docHelper  = "Creates Raial Prism 3D algorithm for volumes"
1385     """
1386     doc string of the method
1387     """
1388
1389     def __init__(self, mesh, geom=0):
1390         """
1391         Private constructor.
1392
1393         Parameters:
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
1397         """
1398         Mesh_Algorithm.__init__(self)
1399
1400         shape = geom
1401         if not shape:
1402             shape = mesh.geom
1403         self.Create(mesh, geom, "RadialPrism_3D")
1404         self.distribHyp = None
1405         self.nbLayers = None
1406         return
1407
1408 class StdMeshersBuilder_RadialAlgorithm(Mesh_Algorithm):
1409     """
1410     Base class for algorithms supporting radial distribution hypotheses
1411     """
1412
1413     def __init__(self):
1414         Mesh_Algorithm.__init__(self)
1415
1416         self.distribHyp = None #self.Hypothesis("LayerDistribution2D", UseExisting=0)
1417         self.nbLayers = None
1418         pass
1419
1420     def Get2DHypothesis(self):
1421         """
1422         Returns:
1423             2D hypothesis holding the 1D one
1424         """
1425         if not self.distribHyp:
1426             self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0)
1427         return self.distribHyp
1428
1429     def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"):
1430         """
1431         Private method creating a 1D hypothesis and storing it in the LayerDistribution
1432             hypothesis.
1433
1434         Returns:
1435             the created hypothesis
1436         """
1437         if self.nbLayers:
1438             self.mesh.GetMesh().RemoveHypothesis( self.geom, self.nbLayers )
1439         if self.distribHyp is None:
1440             self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0)
1441         else:
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 )
1447         return hyp
1448
1449     def NumberOfLayers(self, n, UseExisting=0):
1450         """
1451         Defines "NumberOfLayers" hypothesis, specifying the number of layers
1452
1453         Parameters:
1454             n: number of layers
1455             UseExisting: if ==true - searches for the existing hypothesis created with
1456                 the same parameters, else (default) - creates a new one
1457         """
1458         if self.distribHyp:
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
1466
1467     def LocalLength(self, l, p=1e-07):
1468         """
1469         Defines "LocalLength" hypothesis, specifying the segment length
1470
1471         Parameters:
1472             l: the length of segments
1473             p: the precision of rounding
1474         """
1475         hyp = self.OwnHypothesis("LocalLength", [l,p])
1476         hyp.SetLength(l)
1477         hyp.SetPrecision(p)
1478         return hyp
1479
1480     def NumberOfSegments(self, n, s=[]):
1481         """
1482         Defines "NumberOfSegments" hypothesis, specifying the number of layers
1483
1484         Parameters:
1485             n: the number of layers
1486             s: the scale factor (optional)
1487         """
1488         if s == []:
1489             hyp = self.OwnHypothesis("NumberOfSegments", [n])
1490         else:
1491             hyp = self.OwnHypothesis("NumberOfSegments", [n,s])
1492             hyp.SetDistrType( 1 )
1493             hyp.SetScaleFactor(s)
1494         hyp.SetNumberOfSegments(n)
1495         return hyp
1496
1497     def Arithmetic1D(self, start, end ):
1498         """
1499         Defines "Arithmetic1D" hypothesis, specifying the distribution of segments
1500             with a length that changes in arithmetic progression
1501
1502         Parameters:
1503             start:  the length of the first segment
1504             end:    the length of the last  segment
1505         """
1506         hyp = self.OwnHypothesis("Arithmetic1D", [start, end])
1507         hyp.SetLength(start, 1)
1508         hyp.SetLength(end  , 0)
1509         return hyp
1510
1511     def GeometricProgression(self, start, ratio ):
1512         """
1513         Defines "GeometricProgression" hypothesis, specifying the distribution of segments
1514             with a length that changes in Geometric progression
1515
1516         Parameters:
1517             start:  the length of the first segment
1518             ratio:  the common ratio of the geometric progression
1519         """
1520         hyp = self.OwnHypothesis("GeometricProgression", [start, ratio])
1521         hyp.SetStartLength( start )
1522         hyp.SetCommonRatio( ratio )
1523         return hyp
1524
1525     def StartEndLength(self, start, end):
1526         """
1527         Defines "StartEndLength" hypothesis, specifying distribution of segments
1528             as geometric length increasing
1529
1530         Parameters:
1531             start: for the length of the first segment
1532             end:   for the length of the last  segment
1533         """
1534         hyp = self.OwnHypothesis("StartEndLength", [start, end])
1535         hyp.SetLength(start, 1)
1536         hyp.SetLength(end  , 0)
1537         return hyp
1538
1539     def AutomaticLength(self, fineness=0):
1540         """
1541         Defines "AutomaticLength" hypothesis, specifying the number of segments
1542
1543         Parameters:
1544             fineness: defines the quality of the mesh within the range [0-1]
1545         """
1546         hyp = self.OwnHypothesis("AutomaticLength")
1547         hyp.SetFineness( fineness )
1548         return hyp
1549
1550     pass # end of StdMeshersBuilder_RadialQuadrangle1D2D class
1551
1552 class StdMeshersBuilder_RadialQuadrangle1D2D(StdMeshersBuilder_RadialAlgorithm):
1553     """
1554     Defines a Radial Quadrangle 1D-2D algorithm.
1555     It is created by calling smeshBuilder.Mesh.Quadrangle(smeshBuilder.RADIAL_QUAD,geom=0)
1556     """
1557
1558     meshMethod = "Quadrangle"
1559     """
1560     name of the dynamic method in smeshBuilder.Mesh class
1561     """
1562     algoType   = RADIAL_QUAD
1563     """
1564     type of algorithm used with helper function in smeshBuilder.Mesh class
1565     """
1566     docHelper  = "Creates quadrangle 1D-2D algorithm for faces having a shape of disk or a disk segment"
1567     """
1568     doc string of the method
1569     """
1570
1571     def __init__(self, mesh, geom=0):
1572         """
1573         Private constructor.
1574
1575         Parameters:
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
1579         """
1580         StdMeshersBuilder_RadialAlgorithm.__init__(self)
1581         self.Create(mesh, geom, self.algoType)
1582
1583         self.distribHyp = None #self.Hypothesis("LayerDistribution2D", UseExisting=0)
1584         self.nbLayers = None
1585         pass
1586
1587
1588 class StdMeshersBuilder_QuadMA_1D2D(StdMeshersBuilder_RadialAlgorithm):
1589     """
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)
1592     """
1593
1594     meshMethod = "Quadrangle"
1595     """
1596     name of the dynamic method in smeshBuilder.Mesh class
1597     """
1598     algoType   = QUAD_MA_PROJ
1599     """
1600     type of algorithm used with helper function in smeshBuilder.Mesh class
1601     """
1602     docHelper  = "Creates quadrangle 1D-2D algorithm for faces"
1603     """
1604     doc string of the method
1605     """
1606
1607     def __init__(self, mesh, geom=0):
1608         """
1609         Private constructor.
1610
1611         Parameters:
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
1615         """
1616         StdMeshersBuilder_RadialAlgorithm.__init__(self)
1617         self.Create(mesh, geom, self.algoType)
1618         pass
1619
1620     pass
1621
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)
1625     """
1626
1627     meshMethod = "Polygon"
1628     """
1629     name of the dynamic method in smeshBuilder.Mesh class
1630     """
1631     algoType   = POLYGON
1632     """
1633     type of algorithm used with helper function in smeshBuilder.Mesh class
1634     """
1635     isDefault  = True
1636     """
1637     flag pointing whether this algorithm should be used by default in dynamic method
1638         of smeshBuilder.Mesh class
1639     """
1640     docHelper  = "Creates polygon 2D algorithm for faces"
1641     """
1642     doc string of the method
1643     """
1644
1645     def __init__(self, mesh, geom=0):
1646         """
1647         Private constructor.
1648
1649         Parameters:
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
1653         """
1654         Mesh_Algorithm.__init__(self)
1655         self.Create(mesh, geom, self.algoType)
1656         pass
1657
1658     pass
1659
1660 class StdMeshersBuilder_UseExistingElements_1D(Mesh_Algorithm):
1661     """ Defines a Use Existing Elements 1D algorithm.
1662
1663     It is created by calling smeshBuilder.Mesh.UseExisting1DElements(geom=0)
1664     """
1665
1666
1667     meshMethod = "UseExisting1DElements"
1668     """
1669     name of the dynamic method in smeshBuilder.Mesh class
1670     """
1671     algoType   = "Import_1D"
1672     """
1673     type of algorithm used with helper function in smeshBuilder.Mesh class
1674     """
1675     isDefault  = True
1676     """
1677     flag pointing whether this algorithm should be used by default in dynamic method
1678         of smeshBuilder.Mesh class
1679     """
1680     docHelper  = "Creates 1D algorithm for edges with reusing of existing mesh elements"
1681     """
1682     doc string of the method
1683     """
1684
1685     def __init__(self, mesh, geom=0):
1686         """
1687         Private constructor.
1688
1689         Parameters:
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
1693         """
1694         Mesh_Algorithm.__init__(self)
1695         self.Create(mesh, geom, self.algoType)
1696         pass
1697
1698     def SourceEdges(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
1699         """
1700         Defines "Source edges" hypothesis, specifying groups of edges to import
1701
1702         Parameters:
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) - creates a new one
1708         """
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)
1718         return hyp
1719
1720     pass # end of StdMeshersBuilder_UseExistingElements_1D class
1721
1722 class StdMeshersBuilder_UseExistingElements_1D2D(Mesh_Algorithm):
1723     """ Defines a Use Existing Elements 1D-2D algorithm.
1724
1725     It is created by calling smeshBuilder.Mesh.UseExisting2DElements(geom=0)
1726     """
1727
1728
1729     meshMethod = "UseExisting2DElements"
1730     """
1731     name of the dynamic method in smeshBuilder.Mesh class
1732     """
1733     algoType   = "Import_1D2D"
1734     """
1735     type of algorithm used with helper function in smeshBuilder.Mesh class
1736     """
1737     isDefault  = True
1738     """
1739     flag pointing whether this algorithm should be used by default in dynamic method
1740         of smeshBuilder.Mesh class
1741     """
1742     docHelper  = "Creates 1D-2D algorithm for faces with reusing of existing mesh elements"
1743     """
1744     doc string of the method
1745     """
1746
1747     def __init__(self, mesh, geom=0):
1748         """
1749         Private constructor.
1750
1751         Parameters:
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
1755         """
1756         Mesh_Algorithm.__init__(self)
1757         self.Create(mesh, geom, self.algoType)
1758         pass
1759
1760     def SourceFaces(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
1761         """
1762         Defines "Source faces" hypothesis, specifying groups of faces to import
1763
1764         Parameters:
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) - creates a new one
1770         """
1771         import SMESH
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 ):
1777             groups = [groups]
1778         hyp.SetSourceFaces(groups)
1779         hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups)
1780         self.mesh.AddHypothesis(hyp, self.geom)
1781         return hyp
1782
1783     pass # end of StdMeshersBuilder_UseExistingElements_1D2D class
1784
1785 class StdMeshersBuilder_Cartesian_3D(Mesh_Algorithm):
1786     """ Defines a Body Fitting 3D algorithm.
1787
1788     It is created by calling smeshBuilder.Mesh.BodyFitted(geom=0)
1789     """
1790
1791
1792     meshMethod = "BodyFitted"
1793     """
1794     name of the dynamic method in smeshBuilder.Mesh class
1795     """
1796     algoType   = "Cartesian_3D"
1797     """
1798     type of algorithm used with helper function in smeshBuilder.Mesh class
1799     """
1800     isDefault  = True
1801     """
1802     flag pointing whether this algorithm should be used by default in dynamic method
1803         of smeshBuilder.Mesh class
1804     """
1805     docHelper  = "Creates Body Fitting 3D algorithm for volumes"
1806     """
1807     doc string of the method
1808     """
1809
1810     def __init__(self, mesh, geom=0):
1811         """
1812         Private constructor.
1813
1814         Parameters:
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
1818         """
1819         self.Create(mesh, geom, self.algoType)
1820         self.hyp = None
1821         pass
1822
1823     def SetGrid(self, xGridDef, yGridDef, zGridDef, sizeThreshold=4.0, implEdges=False):
1824         """
1825         Defines "Body Fitting parameters" hypothesis
1826
1827         Parameters:
1828             xGridDef: is definition of the grid along the X asix.
1829                 It can be in either of two following forms:
1830
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                         coodrinates 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.
1837
1838         Examples:
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.
1841
1842         Parameters:
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.
1848         """
1849         if not self.hyp:
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 )
1856
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 )
1866             else:
1867                 self.hyp.SetGridSpacing( gridDef[0], gridDef[1], axis )
1868         self.hyp.SetSizeThreshold( sizeThreshold )
1869         self.hyp.SetToAddEdges( implEdges )
1870         return self.hyp
1871
1872     def SetAxesDirs( self, xAxis, yAxis, zAxis ):
1873         """
1874         Defines custom directions of axes of the grid
1875
1876         Parameters:
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
1880         """
1881         import GEOM
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 )
1894         if not self.hyp:
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 )
1899         return self.hyp
1900
1901     def SetOptimalAxesDirs(self, isOrthogonal=True):
1902         """
1903         Automatically defines directions of axes of the grid at which
1904             a number of generated hexahedra is maximal
1905
1906         Parameters:
1907             isOrthogonal: defines whether the axes mush be orthogonal
1908         """
1909         if not self.hyp:
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 )
1915         return self.hyp
1916
1917     def SetFixedPoint( self, p, toUnset=False ):
1918         """
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
1921             by spacing
1922
1923         Parameters:
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.
1927         """
1928         import SMESH, GEOM
1929         if toUnset:
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 )
1936         if not self.hyp:
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 )
1941         return self.hyp
1942
1943
1944     pass # end of StdMeshersBuilder_Cartesian_3D class
1945
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.
1949
1950     It is created by calling smeshBuilder.Mesh.UseExistingSegments(geom=0)
1951     """
1952
1953
1954     meshMethod = "UseExistingSegments"
1955     """
1956     name of the dynamic method in smeshBuilder.Mesh class
1957     """
1958     algoType   = "UseExisting_1D"
1959     """
1960     type of algorithm used with helper function in smeshBuilder.Mesh class
1961     """
1962     docHelper  = "Creates 1D algorithm allowing batch meshing of edges"
1963     """
1964     doc string of the method
1965     """
1966
1967     def __init__(self, mesh, geom=0):
1968         """
1969         Private constructor.
1970
1971         Parameters:
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
1975         """
1976         self.Create(mesh, geom, self.algoType)
1977         pass
1978
1979     pass # end of StdMeshersBuilder_UseExisting_1D class
1980
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.
1984
1985     It is created by calling smeshBuilder.Mesh.UseExistingFaces(geom=0)
1986     """
1987
1988
1989     meshMethod = "UseExistingFaces"
1990     """
1991     name of the dynamic method in smeshBuilder.Mesh class
1992     """
1993     algoType   = "UseExisting_2D"
1994     """
1995     type of algorithm used with helper function in smeshBuilder.Mesh class
1996     """
1997     docHelper  = "Creates 2D algorithm allowing batch meshing of faces"
1998     """
1999     doc string of the method
2000     """
2001
2002     def __init__(self, mesh, geom=0):
2003         """
2004         Private constructor.
2005
2006         Parameters:
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
2010         """
2011         self.Create(mesh, geom, self.algoType)
2012         pass
2013
2014     pass # end of StdMeshersBuilder_UseExisting_2D class