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     """
1373
1374
1375     meshMethod = "Prism"
1376     """
1377     name of the dynamic method in smeshBuilder.Mesh class
1378     """
1379     algoType   = "RadialPrism_3D"
1380     """
1381     type of algorithm used with helper function in smeshBuilder.Mesh class
1382     """
1383     docHelper  = "Creates Raial Prism 3D algorithm for volumes"
1384     """
1385     doc string of the method
1386     """
1387
1388     def __init__(self, mesh, geom=0):
1389         """
1390         Private constructor.
1391
1392         Parameters:
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
1396         """
1397         Mesh_Algorithm.__init__(self)
1398
1399         shape = geom
1400         if not shape:
1401             shape = mesh.geom
1402         self.Create(mesh, geom, "RadialPrism_3D")
1403         self.distribHyp = None
1404         self.nbLayers = None
1405         return
1406
1407 class StdMeshersBuilder_RadialAlgorithm(Mesh_Algorithm):
1408     """
1409     Base class for algorithms supporting radial distribution hypotheses
1410     """
1411
1412     def __init__(self):
1413         Mesh_Algorithm.__init__(self)
1414
1415         self.distribHyp = None #self.Hypothesis("LayerDistribution2D", UseExisting=0)
1416         self.nbLayers = None
1417         pass
1418
1419     def Get2DHypothesis(self):
1420         """
1421         Returns:
1422             2D hypothesis holding the 1D one
1423         """
1424         if not self.distribHyp:
1425             self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0)
1426         return self.distribHyp
1427
1428     def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"):
1429         """
1430         Private method creating a 1D hypothesis and storing it in the LayerDistribution
1431             hypothesis.
1432
1433         Returns:
1434             the created hypothesis
1435         """
1436         if self.nbLayers:
1437             self.mesh.GetMesh().RemoveHypothesis( self.geom, self.nbLayers )
1438         if self.distribHyp is None:
1439             self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0)
1440         else:
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 )
1446         return hyp
1447
1448     def NumberOfLayers(self, n, UseExisting=0):
1449         """
1450         Defines "NumberOfLayers" hypothesis, specifying the number of layers
1451
1452         Parameters:
1453             n: number of layers
1454             UseExisting: if ==true - searches for the existing hypothesis created with
1455                 the same parameters, else (default) - creates a new one
1456         """
1457         if self.distribHyp:
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
1465
1466     def LocalLength(self, l, p=1e-07):
1467         """
1468         Defines "LocalLength" hypothesis, specifying the segment length
1469
1470         Parameters:
1471             l: the length of segments
1472             p: the precision of rounding
1473         """
1474         hyp = self.OwnHypothesis("LocalLength", [l,p])
1475         hyp.SetLength(l)
1476         hyp.SetPrecision(p)
1477         return hyp
1478
1479     def NumberOfSegments(self, n, s=[]):
1480         """
1481         Defines "NumberOfSegments" hypothesis, specifying the number of layers
1482
1483         Parameters:
1484             n: the number of layers
1485             s: the scale factor (optional)
1486         """
1487         if s == []:
1488             hyp = self.OwnHypothesis("NumberOfSegments", [n])
1489         else:
1490             hyp = self.OwnHypothesis("NumberOfSegments", [n,s])
1491             hyp.SetDistrType( 1 )
1492             hyp.SetScaleFactor(s)
1493         hyp.SetNumberOfSegments(n)
1494         return hyp
1495
1496     def Arithmetic1D(self, start, end ):
1497         """
1498         Defines "Arithmetic1D" hypothesis, specifying the distribution of segments
1499             with a length that changes in arithmetic progression
1500
1501         Parameters:
1502             start:  the length of the first segment
1503             end:    the length of the last  segment
1504         """
1505         hyp = self.OwnHypothesis("Arithmetic1D", [start, end])
1506         hyp.SetLength(start, 1)
1507         hyp.SetLength(end  , 0)
1508         return hyp
1509
1510     def GeometricProgression(self, start, ratio ):
1511         """
1512         Defines "GeometricProgression" hypothesis, specifying the distribution of segments
1513             with a length that changes in Geometric progression
1514
1515         Parameters:
1516             start:  the length of the first segment
1517             ratio:  the common ratio of the geometric progression
1518         """
1519         hyp = self.OwnHypothesis("GeometricProgression", [start, ratio])
1520         hyp.SetStartLength( start )
1521         hyp.SetCommonRatio( ratio )
1522         return hyp
1523
1524     def StartEndLength(self, start, end):
1525         """
1526         Defines "StartEndLength" hypothesis, specifying distribution of segments
1527             as geometric length increasing
1528
1529         Parameters:
1530             start: for the length of the first segment
1531             end:   for the length of the last  segment
1532         """
1533         hyp = self.OwnHypothesis("StartEndLength", [start, end])
1534         hyp.SetLength(start, 1)
1535         hyp.SetLength(end  , 0)
1536         return hyp
1537
1538     def AutomaticLength(self, fineness=0):
1539         """
1540         Defines "AutomaticLength" hypothesis, specifying the number of segments
1541
1542         Parameters:
1543             fineness: defines the quality of the mesh within the range [0-1]
1544         """
1545         hyp = self.OwnHypothesis("AutomaticLength")
1546         hyp.SetFineness( fineness )
1547         return hyp
1548
1549     pass # end of StdMeshersBuilder_RadialQuadrangle1D2D class
1550
1551 class StdMeshersBuilder_RadialQuadrangle1D2D(StdMeshersBuilder_RadialAlgorithm):
1552     """
1553     Defines a Radial Quadrangle 1D-2D algorithm
1554     It is created by calling smeshBuilder.Mesh.Quadrangle(smeshBuilder.RADIAL_QUAD,geom=0)
1555     """
1556
1557     meshMethod = "Quadrangle"
1558     """
1559     name of the dynamic method in smeshBuilder.Mesh class
1560     """
1561     algoType   = RADIAL_QUAD
1562     """
1563     type of algorithm used with helper function in smeshBuilder.Mesh class
1564     """
1565     docHelper  = "Creates quadrangle 1D-2D algorithm for faces having a shape of disk or a disk segment"
1566     """
1567     doc string of the method
1568     """
1569
1570     def __init__(self, mesh, geom=0):
1571         """
1572         Private constructor.
1573
1574         Parameters:
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
1578         """
1579         StdMeshersBuilder_RadialAlgorithm.__init__(self)
1580         self.Create(mesh, geom, self.algoType)
1581
1582         self.distribHyp = None #self.Hypothesis("LayerDistribution2D", UseExisting=0)
1583         self.nbLayers = None
1584         pass
1585
1586
1587 class StdMeshersBuilder_QuadMA_1D2D(StdMeshersBuilder_RadialAlgorithm):
1588     """
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)
1591     """
1592
1593     meshMethod = "Quadrangle"
1594     """
1595     name of the dynamic method in smeshBuilder.Mesh class
1596     """
1597     algoType   = QUAD_MA_PROJ
1598     """
1599     type of algorithm used with helper function in smeshBuilder.Mesh class
1600     """
1601     docHelper  = "Creates quadrangle 1D-2D algorithm for faces"
1602     """
1603     doc string of the method
1604     """
1605
1606     def __init__(self, mesh, geom=0):
1607         """
1608         Private constructor.
1609
1610         Parameters:
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
1614         """
1615         StdMeshersBuilder_RadialAlgorithm.__init__(self)
1616         self.Create(mesh, geom, self.algoType)
1617         pass
1618
1619     pass
1620
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)
1624     """
1625
1626     meshMethod = "Polygon"
1627     """
1628     name of the dynamic method in smeshBuilder.Mesh class
1629     """
1630     algoType   = POLYGON
1631     """
1632     type of algorithm used with helper function in smeshBuilder.Mesh class
1633     """
1634     isDefault  = True
1635     """
1636     flag pointing whether this algorithm should be used by default in dynamic method
1637         of smeshBuilder.Mesh class
1638     """
1639     docHelper  = "Creates polygon 2D algorithm for faces"
1640     """
1641     doc string of the method
1642     """
1643
1644     def __init__(self, mesh, geom=0):
1645         """
1646         Private constructor.
1647
1648         Parameters:
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
1652         """
1653         Mesh_Algorithm.__init__(self)
1654         self.Create(mesh, geom, self.algoType)
1655         pass
1656
1657     pass
1658
1659 class StdMeshersBuilder_UseExistingElements_1D(Mesh_Algorithm):
1660     """ Defines a Use Existing Elements 1D algorithm
1661
1662     It is created by calling smeshBuilder.Mesh.UseExisting1DElements(geom=0)
1663     """
1664
1665
1666     meshMethod = "UseExisting1DElements"
1667     """
1668     name of the dynamic method in smeshBuilder.Mesh class
1669     """
1670     algoType   = "Import_1D"
1671     """
1672     type of algorithm used with helper function in smeshBuilder.Mesh class
1673     """
1674     isDefault  = True
1675     """
1676     flag pointing whether this algorithm should be used by default in dynamic method
1677         of smeshBuilder.Mesh class
1678     """
1679     docHelper  = "Creates 1D algorithm for edges with reusing of existing mesh elements"
1680     """
1681     doc string of the method
1682     """
1683
1684     def __init__(self, mesh, geom=0):
1685         """
1686         Private constructor.
1687
1688         Parameters:
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
1692         """
1693         Mesh_Algorithm.__init__(self)
1694         self.Create(mesh, geom, self.algoType)
1695         pass
1696
1697     def SourceEdges(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
1698         """
1699         Defines "Source edges" hypothesis, specifying groups of edges to import
1700
1701         Parameters:
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
1707         """
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)
1717         return hyp
1718
1719     pass # end of StdMeshersBuilder_UseExistingElements_1D class
1720
1721 class StdMeshersBuilder_UseExistingElements_1D2D(Mesh_Algorithm):
1722     """ Defines a Use Existing Elements 1D-2D algorithm
1723
1724     It is created by calling smeshBuilder.Mesh.UseExisting2DElements(geom=0)
1725     """
1726
1727
1728     meshMethod = "UseExisting2DElements"
1729     """
1730     name of the dynamic method in smeshBuilder.Mesh class
1731     """
1732     algoType   = "Import_1D2D"
1733     """
1734     type of algorithm used with helper function in smeshBuilder.Mesh class
1735     """
1736     isDefault  = True
1737     """
1738     flag pointing whether this algorithm should be used by default in dynamic method
1739         of smeshBuilder.Mesh class
1740     """
1741     docHelper  = "Creates 1D-2D algorithm for faces with reusing of existing mesh elements"
1742     """
1743     doc string of the method
1744     """
1745
1746     def __init__(self, mesh, geom=0):
1747         """
1748         Private constructor.
1749
1750         Parameters:
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
1754         """
1755         Mesh_Algorithm.__init__(self)
1756         self.Create(mesh, geom, self.algoType)
1757         pass
1758
1759     def SourceFaces(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
1760         """
1761         Defines "Source faces" hypothesis, specifying groups of faces to import
1762
1763         Parameters:
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
1769         """
1770         import SMESH
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 ):
1776             groups = [groups]
1777         hyp.SetSourceFaces(groups)
1778         hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups)
1779         self.mesh.AddHypothesis(hyp, self.geom)
1780         return hyp
1781
1782     pass # end of StdMeshersBuilder_UseExistingElements_1D2D class
1783
1784 class StdMeshersBuilder_Cartesian_3D(Mesh_Algorithm):
1785     """ Defines a Body Fitting 3D algorithm
1786
1787     It is created by calling smeshBuilder.Mesh.BodyFitted(geom=0)
1788     """
1789
1790
1791     meshMethod = "BodyFitted"
1792     """
1793     name of the dynamic method in smeshBuilder.Mesh class
1794     """
1795     algoType   = "Cartesian_3D"
1796     """
1797     type of algorithm used with helper function in smeshBuilder.Mesh class
1798     """
1799     isDefault  = True
1800     """
1801     flag pointing whether this algorithm should be used by default in dynamic method
1802         of smeshBuilder.Mesh class
1803     """
1804     docHelper  = "Creates Body Fitting 3D algorithm for volumes"
1805     """
1806     doc string of the method
1807     """
1808
1809     def __init__(self, mesh, geom=0):
1810         """
1811         Private constructor.
1812
1813         Parameters:
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
1817         """
1818         self.Create(mesh, geom, self.algoType)
1819         self.hyp = None
1820         pass
1821
1822     def SetGrid(self, xGridDef, yGridDef, zGridDef, sizeThreshold=4.0, implEdges=False):
1823         """
1824         Defines "Body Fitting parameters" hypothesis
1825
1826         Parameters:
1827             xGridDef: is definition of the grid along the X asix.
1828                 It can be in either of two following forms:
1829
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.
1836
1837         Examples:
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.
1840
1841         Parameters:
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.
1847         """
1848         if not self.hyp:
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 )
1855
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 )
1865             else:
1866                 self.hyp.SetGridSpacing( gridDef[0], gridDef[1], axis )
1867         self.hyp.SetSizeThreshold( sizeThreshold )
1868         self.hyp.SetToAddEdges( implEdges )
1869         return self.hyp
1870
1871     def SetAxesDirs( self, xAxis, yAxis, zAxis ):
1872         """
1873         Defines custom directions of axes of the grid
1874
1875         Parameters:
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
1879         """
1880         import GEOM
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 )
1893         if not self.hyp:
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 )
1898         return self.hyp
1899
1900     def SetOptimalAxesDirs(self, isOrthogonal=True):
1901         """
1902         Automatically defines directions of axes of the grid at which
1903             a number of generated hexahedra is maximal
1904
1905         Parameters:
1906             isOrthogonal: defines whether the axes mush be orthogonal
1907         """
1908         if not self.hyp:
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 )
1914         return self.hyp
1915
1916     def SetFixedPoint( self, p, toUnset=False ):
1917         """
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
1920             by spacing
1921
1922         Parameters:
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.
1926         """
1927         import SMESH, GEOM
1928         if toUnset:
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 )
1935         if not self.hyp:
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 )
1940         return self.hyp
1941
1942
1943     pass # end of StdMeshersBuilder_Cartesian_3D class
1944
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
1948
1949     It is created by calling smeshBuilder.Mesh.UseExistingSegments(geom=0)
1950     """
1951
1952
1953     meshMethod = "UseExistingSegments"
1954     """
1955     name of the dynamic method in smeshBuilder.Mesh class
1956     """
1957     algoType   = "UseExisting_1D"
1958     """
1959     type of algorithm used with helper function in smeshBuilder.Mesh class
1960     """
1961     docHelper  = "Creates 1D algorithm allowing batch meshing of edges"
1962     """
1963     doc string of the method
1964     """
1965
1966     def __init__(self, mesh, geom=0):
1967         """
1968         Private constructor.
1969
1970         Parameters:
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
1974         """
1975         self.Create(mesh, geom, self.algoType)
1976         pass
1977
1978     pass # end of StdMeshersBuilder_UseExisting_1D class
1979
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
1983
1984     It is created by calling smeshBuilder.Mesh.UseExistingFaces(geom=0)
1985     """
1986
1987
1988     meshMethod = "UseExistingFaces"
1989     """
1990     name of the dynamic method in smeshBuilder.Mesh class
1991     """
1992     algoType   = "UseExisting_2D"
1993     """
1994     type of algorithm used with helper function in smeshBuilder.Mesh class
1995     """
1996     docHelper  = "Creates 2D algorithm allowing batch meshing of faces"
1997     """
1998     doc string of the method
1999     """
2000
2001     def __init__(self, mesh, geom=0):
2002         """
2003         Private constructor.
2004
2005         Parameters:
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
2009         """
2010         self.Create(mesh, geom, self.algoType)
2011         pass
2012
2013     pass # end of StdMeshersBuilder_UseExisting_2D class