doc/salome/gui/SMESH/input/smesh_module.rst

   1 SMESH module
   2 ============
   3
   4 .. contents::
   5
   6 .. py:module:: SMESH
   7
   8 DriverMED_ReadStatus
   9 --------------------
  10
  11 .. py:class:: DriverMED_ReadStatus
  12
  13    Enumeration for mesh read status
  14
  15    .. py:attribute:: DRS_OK
  16
  17       Ok
  18
  19    .. py:attribute:: DRS_EMPTY
  20
  21       a file contains no mesh with the given name
  22
  23    .. py:attribute:: DRS_WARN_RENUMBER
  24
  25       a MED file has overlapped ranges of element numbers,
  26       so the numbers from the file are ignored
  27
  28    .. py:attribute:: DRS_WARN_SKIP_ELEM
  29
  30       some elements were skipped due to incorrect file data
  31
  32    .. py:attribute:: DRS_WARN_DESCENDING
  33
  34       some elements were skipped due to descending connectivity
  35
  36    .. py:attribute:: DRS_FAIL
  37
  38       general failure (exception etc.)
  39
  40 ComputeErrorName
  41 ----------------
  42
  43 .. py:class:: ComputeErrorName
  44
  45    Enumeration of computation errors
  46
  47    .. py:attribute:: COMPERR_OK
  48
  49       Ok
  50
  51    .. py:attribute:: COMPERR_BAD_INPUT_MESH
  52
  53       wrong mesh of lower sub-mesh
  54
  55    .. py:attribute:: COMPERR_STD_EXCEPTION
  56
  57       some std exception raised
  58
  59    .. py:attribute:: COMPERR_OCC_EXCEPTION
  60
  61       OCC exception raised
  62
  63    .. py:attribute:: COMPERR_SLM_EXCEPTION
  64
  65       SALOME exception raised
  66
  67    .. py:attribute:: COMPERR_EXCEPTION
  68
  69       other exception raised
  70
  71    .. py:attribute:: COMPERR_MEMORY_PB
  72
  73       memory allocation problem
  74
  75    .. py:attribute:: COMPERR_ALGO_FAILED
  76
  77       computation failed
  78
  79    .. py:attribute:: COMPERR_BAD_SHAPE
  80
  81       bad geometry
  82
  83    .. py:attribute:: COMPERR_WARNING
  84
  85       algo reports error but sub-mesh is computed anyway
  86
  87    .. py:attribute:: COMPERR_CANCELED
  88
  89       compute canceled
  90
  91    .. py:attribute:: COMPERR_NO_MESH_ON_SHAPE
  92
  93       no mesh elements assigned to sub-mesh
  94
  95    .. py:attribute:: COMPERR_BAD_PARMETERS
  96
  97       incorrect hypotheses parameters
  98
  99
 100 ComputeError
 101 ------------
 102
 103 .. py:class:: ComputeError
 104
 105    Error details
 106
 107    .. py:attribute:: code
 108
 109       ``int`` - :class:`ComputeErrorName` or, if negative, algo specific code
 110
 111    .. py:attribute:: comment
 112
 113       ``str`` - textual problem description
 114
 115    .. py:attribute:: algoName
 116
 117       ``str``
 118
 119    .. py:attribute:: subShapeID
 120
 121       ``int`` - id of sub-shape of a shape to mesh
 122
 123    .. py:attribute:: hasBadMesh
 124
 125       ``boolean`` - there are elements preventing computation available for visualization
 126
 127 Measure
 128 -------
 129
 130 .. py:class:: Measure
 131
 132    Data returned by measure operations
 133
 134    .. py:attribute:: minX, minY, minZ
 135
 136       ``double`` - coordinates of one point
 137
 138    .. py:attribute:: maxX, maxY, maxZ
 139
 140       ``double`` - coordinates of another point
 141
 142    .. py:attribute:: node1, node2
 143
 144       ``long`` - IDs of two nodes
 145
 146    .. py:attribute:: elem1, elem2
 147
 148       ``long`` - IDs of two elements
 149
 150    .. py:attribute:: value
 151
 152       ``double`` - distance
 153
 154 NodePosition
 155 ------------
 156
 157 .. py:class:: NodePosition
 158
 159    Node location on a shape
 160
 161    .. py:attribute:: shapeID
 162
 163       ``long`` - ID of a shape
 164
 165    .. py:attribute:: shapeType
 166
 167       ``GEOM.shape_type`` - type of shape
 168
 169    .. py:attribute:: params
 170
 171       ``list of float`` -
 172
 173         * [U] on EDGE,
 174         * [U,V] on FACE,
 175         * [] on the rest shapes
 176
 177 ElementPosition
 178 ---------------
 179
 180 .. py:class:: ElementPosition
 181
 182    Element location on a shape
 183
 184    .. py:attribute:: shapeID
 185
 186       ``long`` - ID of a shape
 187
 188    .. py:attribute:: shapeType
 189
 190       ``GEOM.shape_type`` - type of shape
 191
 192 PolySegment
 193 -----------
 194
 195 .. py:class:: PolySegment
 196
 197    Define a cutting plane passing through two points.
 198    Used in :meth:`~smeshBuilder.Mesh.MakePolyLine`
 199
 200    .. py:attribute:: node1ID1, node1ID2
 201
 202       ``int,int`` - *point 1*: if *node1ID2* > 0, then the point is in the middle of a face edge defined
 203                 by two nodes, else it is at *node1ID1*
 204
 205    .. py:attribute:: node2ID1, node2ID2
 206
 207       ``int,int`` - *point 2*: if *node2ID2* > 0, then the point is in the middle of a face edge defined
 208                 by two nodes, else it is at *node2ID1*
 209
 210    .. py:attribute:: vector
 211
 212       ``SMESH.DirStruct`` - vector on the plane; to use a default plane set vector = (0,0,0)
 213
 214
 215 ElementType
 216 -----------
 217
 218 .. py:class:: ElementType
 219
 220    Enumeration for element type, like in SMDS
 221
 222    .. py:attribute::
 223     ALL
 224     NODE
 225     EDGE
 226     FACE
 227     VOLUME
 228     ELEM0D
 229     BALL
 230     NB_ELEMENT_TYPES
 231
 232 EntityType
 233 ----------
 234
 235 .. py:class:: EntityType
 236
 237    Enumeration of entity type
 238
 239    .. py:attribute::
 240     Entity_Node
 241     Entity_0D
 242     Entity_Edge
 243     Entity_Quad_Edge
 244     Entity_Triangle
 245     Entity_Quad_Triangle
 246     Entity_BiQuad_Triangle
 247     Entity_Quadrangle
 248     Entity_Quad_Quadrangle
 249     Entity_BiQuad_Quadrangle
 250     Entity_Polygon
 251     Entity_Quad_Polygon
 252     Entity_Tetra
 253     Entity_Quad_Tetra
 254     Entity_Pyramid
 255     Entity_Quad_Pyramid
 256     Entity_Hexa
 257     Entity_Quad_Hexa
 258     Entity_TriQuad_Hexa
 259     Entity_Penta
 260     Entity_Quad_Penta
 261     Entity_BiQuad_Penta
 262     Entity_Hexagonal_Prism
 263     Entity_Polyhedra
 264     Entity_Quad_Polyhedra
 265     Entity_Ball
 266     Entity_Last
 267
 268 GeometryType
 269 ------------
 270
 271 .. py:class:: GeometryType
 272
 273    Enumeration of element geometry type
 274
 275    .. py:attribute::
 276     Geom_POINT
 277     Geom_EDGE
 278     Geom_TRIANGLE
 279     Geom_QUADRANGLE
 280     Geom_POLYGON
 281     Geom_TETRA
 282     Geom_PYRAMID
 283     Geom_HEXA
 284     Geom_PENTA
 285     Geom_HEXAGONAL_PRISM
 286     Geom_POLYHEDRA
 287     Geom_BALL
 288     Geom_LAST
 289
 290 Hypothesis_Status
 291 -----------------
 292
 293 .. py:class:: Hypothesis_Status
 294
 295    Enumeration of result of hypothesis addition/removal
 296
 297    .. py:attribute::  HYP_OK
 298
 299       Ok
 300
 301    .. py:attribute::  HYP_MISSING
 302
 303       algo misses a hypothesis
 304
 305    .. py:attribute::  HYP_CONCURRENT
 306
 307       several applicable hypotheses
 308
 309    .. py:attribute::  HYP_BAD_PARAMETER
 310
 311       hypothesis has a bad parameter value
 312
 313    .. py:attribute::  HYP_HIDDEN_ALGO
 314
 315       an algo is hidden by an upper dim algo generating all-dim elements
 316
 317    .. py:attribute::  HYP_HIDING_ALGO
 318
 319       an algo hides lower dim algos by generating all-dim elements
 320
 321    .. py:attribute::  HYP_UNKNOWN_FATAL
 322
 323        all statuses below should be considered as fatal for Add/RemoveHypothesis operations
 324
 325    .. py:attribute::  HYP_INCOMPATIBLE
 326
 327       hypothesis does not fit algorithm
 328
 329    .. py:attribute::  HYP_NOTCONFORM
 330
 331       not conform mesh is produced applying a hypothesis
 332
 333    .. py:attribute::  HYP_ALREADY_EXIST
 334
 335       such hypothesis already exist
 336
 337    .. py:attribute::  HYP_BAD_DIM
 338
 339       bad dimension
 340
 341    .. py:attribute::  HYP_BAD_SUBSHAPE
 342
 343       shape is neither the main one, nor its sub-shape, nor a group
 344
 345    .. py:attribute::  HYP_BAD_GEOMETRY
 346
 347       geometry mismatches algorithm's expectation
 348
 349    .. py:attribute::  HYP_NEED_SHAPE
 350
 351       algorithm can work on shape only
 352
 353    .. py:attribute::  HYP_INCOMPAT_HYPS
 354
 355       several additional hypotheses are incompatible one with other
 356
 357
 358 FunctorType
 359 -----------
 360
 361 .. py:class:: FunctorType
 362
 363    Enumeration of functor types
 364
 365    .. py:attribute::
 366     FT_AspectRatio
 367     FT_AspectRatio3D
 368     FT_Warping
 369     FT_MinimumAngle
 370     FT_Taper
 371     FT_Skew
 372     FT_Area
 373     FT_Volume3D
 374     FT_MaxElementLength2D
 375     FT_MaxElementLength3D
 376     FT_FreeBorders
 377     FT_FreeEdges
 378     FT_FreeNodes
 379     FT_FreeFaces
 380     FT_EqualNodes
 381     FT_EqualEdges
 382     FT_EqualFaces
 383     FT_EqualVolumes
 384     FT_MultiConnection
 385     FT_MultiConnection2D
 386     FT_Length
 387     FT_Length2D
 388     FT_Deflection2D
 389     FT_NodeConnectivityNumber
 390     FT_BelongToMeshGroup
 391     FT_BelongToGeom
 392     FT_BelongToPlane
 393     FT_BelongToCylinder
 394     FT_BelongToGenSurface
 395     FT_LyingOnGeom
 396     FT_RangeOfIds
 397     FT_BadOrientedVolume
 398     FT_BareBorderVolume
 399     FT_BareBorderFace
 400     FT_OverConstrainedVolume
 401     FT_OverConstrainedFace
 402     FT_LinearOrQuadratic
 403     FT_GroupColor
 404     FT_ElemGeomType
 405     FT_EntityType
 406     FT_CoplanarFaces
 407     FT_BallDiameter
 408     FT_ConnectedElements
 409     FT_LessThan
 410     FT_MoreThan
 411     FT_EqualTo
 412     FT_LogicalNOT
 413     FT_LogicalAND
 414     FT_LogicalOR
 415     FT_Undefined
 416
 417 .. py:module:: SMESH.Filter
 418    :noindex:
 419
 420 Filter.Criterion
 421 ----------------
 422
 423 .. py:class:: Criterion
 424
 425    Structure containing information of a criterion
 426
 427    .. py:attribute:: Type
 428
 429       ``long`` - value of item of :class:`SMESH.FunctorType`
 430
 431    .. py:attribute:: Compare
 432
 433       ``long`` - value of item of :class:`SMESH.FunctorType` in ( FT_LessThan, FT_MoreThan, FT_EqualTo )
 434
 435    .. py:attribute:: Threshold
 436
 437       ``double`` - threshold value
 438
 439    .. py:attribute:: ThresholdStr
 440
 441       ``string`` - Threshold value defined as string. Used for:
 442                        1. Diapason of identifiers. Example: "1,2,3,5-10,12,27-29".
 443                        2. Storing name of shape.
 444                        3. Storing group color "0.2;0;0.5".
 445                        4. Storing point coordinates.
 446
 447    .. py:attribute:: ThresholdID
 448
 449       ``string`` - One more threshold value defined as string. Used for storing id of shape
 450
 451    .. py:attribute:: UnaryOp
 452
 453       ``long`` - unary logical operation: FT_LogicalNOT or FT_Undefined
 454
 455    .. py:attribute:: BinaryOp
 456
 457       ``long`` - binary logical operation FT_LogicalAND, FT_LogicalOR etc.
 458
 459    .. py:attribute:: Tolerance
 460
 461       ``double`` - Tolerance is used for
 462                        1. Comparison of real values.
 463                        2. Detection of geometrical coincidence.
 464
 465    .. py:attribute:: TypeOfElement
 466
 467       ``ElementType`` - type of element :class:`SMESH.ElementType` (SMESH.NODE, SMESH.FACE etc.)
 468
 469    .. py:attribute:: Precision
 470
 471       ``long`` - Precision of numerical functors
 472
 473 .. py:currentmodule:: SMESH
 474
 475 FreeEdges.Border
 476 ----------------
 477
 478 .. py:class:: FreeEdges.Border
 479
 480    Free edge: edge connected to one face only
 481
 482    .. py:attribute:: myElemId
 483
 484       ``long`` - ID of a face
 485
 486    .. py:attribute:: myPnt1,myPnt2
 487
 488       ``long`` - IDs of two nodes
 489
 490 PointStruct
 491 -----------
 492
 493 .. py:class:: PointStruct
 494
 495    3D point.
 496
 497    Use :meth:`GetPointStruct() <smeshBuilder.smeshBuilder.GetPointStruct>`
 498    to convert a vertex (GEOM.GEOM_Object) to PointStruct
 499
 500    .. py:attribute:: x,y,z
 501
 502       ``double`` - point coordinates
 503
 504 DirStruct
 505 ---------
 506
 507 .. py:class:: DirStruct
 508
 509    3D vector.
 510
 511    Use :meth:`GetDirStruct() <smeshBuilder.smeshBuilder.GetDirStruct>`
 512    to convert a vector (GEOM.GEOM_Object) to DirStruct
 513
 514    .. py:attribute:: PS
 515
 516       :class:`PointStruct` - vector components
 517
 518 AxisStruct
 519 ----------
 520
 521 .. py:class:: AxisStruct
 522
 523    Axis defined by its origin and its vector.
 524
 525    Use :meth:`GetAxisStruct() <smeshBuilder.smeshBuilder.GetAxisStruct>`
 526    to convert a line or plane (GEOM.GEOM_Object) to AxisStruct
 527
 528    .. py:attribute:: x,y,z
 529
 530       ``double`` - coordinates of the origin
 531
 532    .. py:attribute:: vx,vy,vz
 533
 534       ``double`` - components of the vector
 535
 536 Filter
 537 ------
 538
 539 .. py:class:: Filter
 540
 541    Filter of mesh entities
 542
 543    .. py:function:: GetElementsId( mesh )
 544
 545       Return satisfying elements
 546
 547       :param SMESH.SMESH_Mesh mesh: the mesh;
 548                                     it can be obtained via :meth:`~smeshBuilder.Mesh.GetMesh`
 549
 550       :return: list of IDs
 551
 552    .. py:function:: GetIDs()
 553
 554       Return satisfying elements.
 555       A mesh to filter must be already set, either via :meth:`SetMesh` method
 556       or via ``mesh`` argument of :meth:`~smeshBuilder.smeshBuilder.GetFilter`
 557
 558       :return: list of IDs
 559
 560    .. py:function:: SetMesh( mesh )
 561
 562       Set mesh to filter
 563
 564       :param SMESH.SMESH_Mesh mesh: the mesh;
 565                                     it can be obtained via :meth:`~smeshBuilder.Mesh.GetMesh`
 566
 567    .. py:function:: SetCriteria( criteria )
 568
 569       Define filtering criteria
 570
 571       :param criteria:  list of :class:`SMESH.Filter.Criterion`
 572
 573 NumericalFunctor
 574 ----------------
 575
 576 .. py:class:: NumericalFunctor
 577
 578    Calculate value by ID of mesh entity. Base class of various functors
 579
 580    .. py:function:: GetValue( elementID )
 581
 582       Compute a value
 583
 584       :param elementID: ID of element or node
 585       :return: floating value
 586
 587 SMESH_Mesh
 588 ----------
 589
 590 .. py:class:: SMESH_Mesh
 591
 592    Mesh. It is a Python wrap over a CORBA interface of mesh.
 593
 594    All its methods are exposed via :class:`smeshBuilder.Mesh` class that you can obtain by calling::
 595
 596      smeshBuilder_mesh = smesh.Mesh( smesh_mesh )
 597
 598 SMESH_MeshEditor
 599 ----------------
 600
 601 .. py:class:: SMESH_MeshEditor
 602
 603    Mesh editor. It is a Python wrap over a CORBA SMESH_MeshEditor interface.
 604    All its methods are exposed via :class:`smeshBuilder.Mesh` class.
 605
 606    .. py:class:: Extrusion_Error
 607
 608       Enumeration of errors of :meth:`~smeshBuilder.Mesh.ExtrusionAlongPathObjects`
 609
 610       .. py:attribute::
 611          EXTR_OK
 612          EXTR_NO_ELEMENTS
 613          EXTR_PATH_NOT_EDGE
 614          EXTR_BAD_PATH_SHAPE
 615          EXTR_BAD_STARTING_NODE
 616          EXTR_BAD_ANGLES_NUMBER
 617          EXTR_CANT_GET_TANGENT
 618
 619 .. py:class:: SMESH_MeshEditor.Sew_Error
 620
 621       Enumeration of errors of SMESH_MeshEditor.Sewing... methods
 622
 623       .. py:attribute::
 624          SEW_OK
 625          SEW_BORDER1_NOT_FOUND
 626          SEW_BORDER2_NOT_FOUND
 627          SEW_BOTH_BORDERS_NOT_FOUND
 628          SEW_BAD_SIDE_NODES
 629          SEW_VOLUMES_TO_SPLIT
 630          SEW_DIFF_NB_OF_ELEMENTS
 631          SEW_TOPO_DIFF_SETS_OF_ELEMENTS
 632          SEW_BAD_SIDE1_NODES
 633          SEW_BAD_SIDE2_NODES
 634          SEW_INTERNAL_ERROR
 635
 636 SMESH_Pattern
 637 -------------
 638
 639 .. py:class:: SMESH_Pattern
 640
 641    Pattern mapper. Use a pattern defined by user for
 642
 643       * creating mesh elements on geometry, faces or blocks
 644       * refining existing mesh elements, faces or hexahedra
 645
 646    The pattern is defined by a string as explained :doc:`here <pattern_mapping>`.
 647
 648    Usage work-flow is:
 649
 650       * Define a pattern via Load... method
 651       * Compute future positions of nodes via Apply... method
 652       * Create nodes and elements in a mesh via :meth:`MakeMesh` method
 653
 654    .. py:function:: LoadFromFile( patternFileContents )
 655
 656       Load a pattern from the string *patternFileContents*
 657
 658       :param str patternFileContents: string defining a pattern
 659       :return: True if succeeded
 660
 661    .. py:function:: LoadFromFace( mesh, geomFace, toProject )
 662
 663       Create a 2D pattern from the mesh built on *geomFace*.
 664
 665       :param SMESH.SMESH_Mesh     mesh: source mesh
 666       :param GEOM.GEOM_Object geomFace: geometrical face whose mesh forms a pattern
 667       :param boolean         toProject: if True makes override nodes positions
 668                                           on *geomFace* computed by mesher
 669       :return: True if succeeded
 670
 671    .. py:function:: LoadFrom3DBlock( mesh, geomBlock )
 672
 673       Create a 3D pattern from the mesh built on *geomBlock*
 674
 675       :param SMESH.SMESH_Mesh      mesh: source mesh
 676       :param GEOM.GEOM_Object geomBlock: geometrical block whose mesh forms a pattern
 677       :return: True if succeeded
 678
 679    .. py:function:: ApplyToFace( geomFace, vertexOnKeyPoint1, toReverse )
 680
 681       Compute nodes coordinates by applying
 682       the loaded pattern to *geomFace*. The first key-point
 683       will be mapped into *vertexOnKeyPoint1*, which must
 684       be in the outer wire of *geomFace*
 685
 686       :param GEOM.GEOM_Object geomFace: the geometrical face to generate faces on
 687       :param GEOM.GEOM_Object vertexOnKeyPoint1: the vertex to be at the 1st key-point
 688       :param boolean          toReverse: to reverse order of key-points
 689       :return: list of :class:`SMESH.PointStruct` - computed coordinates of points of the pattern
 690
 691    .. py:function:: ApplyTo3DBlock( geomBlock, vertex000, vertex001 )
 692
 693       Compute nodes coordinates by applying
 694       the loaded pattern to *geomBlock*. The (0,0,0) key-point
 695       will be mapped into *vertex000*. The (0,0,1)
 696       key-point will be mapped into *vertex001*.
 697
 698       :param GEOM.GEOM_Object geomBlock: the geometrical block to generate volume elements on
 699       :param GEOM.GEOM_Object vertex000: the vertex to superpose (0,0,0) key-point of pattern
 700       :param GEOM.GEOM_Object vertex001: the vertex to superpose (0,0,1) key-point of pattern
 701       :return: list of :class:`SMESH.PointStruct` - computed coordinates of points of the pattern
 702
 703    .. py:function:: ApplyToMeshFaces( mesh, facesIDs, nodeIndexOnKeyPoint1, toReverse )
 704
 705       Compute nodes coordinates by applying
 706       the loaded pattern to mesh faces. The first key-point
 707       will be mapped into *nodeIndexOnKeyPoint1* -th node of each mesh face
 708
 709       :param SMESH.SMESH_Mesh    mesh: the mesh where to refine faces
 710       :param list_of_ids     facesIDs: IDs of faces to refine
 711       :param int nodeIndexOnKeyPoint1: index of a face node to be at 1-st key-point of pattern
 712       :param boolean        toReverse: to reverse order of key-points
 713       :return: list of :class:`SMESH.PointStruct` - computed coordinates of points of the pattern
 714
 715    .. py:function:: ApplyToHexahedrons( mesh, volumesIDs, node000Index, node001Index )
 716
 717       Compute nodes coordinates by applying
 718       the loaded pattern to hexahedra. The (0,0,0) key-point
 719       will be mapped into *Node000Index* -th node of each volume.
 720       The (0,0,1) key-point will be mapped into *node001Index* -th
 721       node of each volume.
 722
 723       :param SMESH.SMESH_Mesh   mesh: the mesh where to refine hexahedra
 724       :param list_of_ids  volumesIDs: IDs of volumes to refine
 725       :param long       node000Index: index of a volume node to be at (0,0,0) key-point of pattern
 726       :param long       node001Index: index of a volume node to be at (0,0,1) key-point of pattern
 727       :return: list of :class:`SMESH.PointStruct` - computed coordinates of points of the pattern
 728
 729    .. py:function:: MakeMesh( mesh, createPolygons, createPolyedrs )
 730
 731       Create nodes and elements in *mesh* using nodes
 732       coordinates computed by either of Apply...() methods.
 733       If *createPolygons* is True, replace adjacent faces by polygons
 734       to keep mesh conformity.
 735       If *createPolyedrs* is True, replace adjacent volumes by polyedrs
 736       to keep mesh conformity.
 737
 738       :param SMESH.SMESH_Mesh     mesh: the mesh to create nodes and elements in
 739       :param boolean    createPolygons: to create polygons to to keep mesh conformity
 740       :param boolean    createPolyedrs: to create polyherda to to keep mesh conformity
 741       :return: True if succeeded
 742
 743
 744 SMESH_subMesh
 745 -------------
 746
 747 .. py:class:: SMESH_subMesh
 748
 749    :doc:`Sub-mesh <constructing_submeshes>`
 750
 751    .. py:function:: GetNumberOfElements()
 752
 753       Return number of elements in the sub-mesh
 754
 755    .. py:function:: GetNumberOfNodes( all )
 756
 757       Return number of nodes in the sub-mesh
 758
 759       :param boolean all: if True, also return nodes assigned to boundary sub-meshes
 760
 761    .. py:function:: GetElementsId()
 762
 763       Return IDs of elements in the sub-mesh
 764
 765    .. py:function:: GetNodesId()
 766
 767       Return IDs of nodes in the sub-mesh
 768
 769    .. py:function:: GetSubShape()
 770
 771       Return :class:`geom shape <GEOM.GEOM_Object>` the sub-mesh is dedicated to
 772
 773    .. py:function:: GetId()
 774
 775       Return ID of the :class:`geom shape <GEOM.GEOM_Object>` the sub-mesh is dedicated to
 776
 777    .. py:function:: GetMeshInfo()
 778
 779       Return number of mesh elements of each :class:`SMESH.EntityType`.
 780       Use :meth:`~smeshBuilder.smeshBuilder.EnumToLong` to get an integer from
 781       an item of :class:`SMESH.EntityType`.
 782
 783       :return: array of number of elements per :class:`SMESH.EntityType`
 784
 785    .. py:function:: GetMesh()
 786
 787       Return the :class:`SMESH.SMESH_Mesh`
 788
 789 SMESH_GroupBase
 790 ---------------
 791
 792 .. py:class:: SMESH_GroupBase
 793
 794    :doc:`Mesh group <grouping_elements>`
 795
 796    .. py:function:: SetName( name )
 797
 798       Set group name
 799
 800    .. py:function:: GetName()
 801
 802       Return group name
 803
 804    .. py:function:: GetType()
 805
 806       Return :class:`group type <SMESH.ElementType>` (type of elements in the group)
 807
 808    .. py:function:: Size()
 809
 810       Return the number of elements in the group
 811
 812    .. py:function:: IsEmpty()
 813
 814       Return True if the group does not contain any elements
 815
 816    .. py:function:: Contains( elem_id )
 817
 818       Return True if the group contains an element with ID == *elem_id*
 819
 820    .. py:function:: GetID( elem_index )
 821
 822       Return ID of an element at position *elem_index* counted from 1
 823
 824    .. py:function:: GetNumberOfNodes()
 825
 826       Return the number of nodes of cells included to the group.
 827       For a nodal group return the same value as Size() function
 828
 829    .. py:function:: GetNodeIDs()
 830
 831       Return IDs of nodes of cells included to the group.
 832       For a nodal group return result of GetListOfID() function
 833
 834    .. py:function:: SetColor( color )
 835
 836       Set group color
 837
 838       :param SALOMEDS.Color color: color
 839
 840    .. py:function:: GetColor()
 841
 842       Return group color
 843
 844       :return: SALOMEDS.Color
 845
 846 SMESH_Group
 847 -----------
 848
 849 .. py:class:: SMESH_Group
 850
 851    :doc:`Standalone mesh group <grouping_elements>`. Inherits all methods of :class:`SMESH.SMESH_GroupBase`
 852
 853    .. py:function:: Clear()
 854
 855       Clears the group's contents
 856
 857    .. py:function:: Add( elem_ids )
 858
 859       Adds elements or nodes with specified identifiers to the group
 860
 861       :param list_of_ids elem_ids: IDs to add
 862
 863    .. py:function:: AddFrom( idSource )
 864
 865       Add all elements or nodes from the specified source to the group
 866
 867       :param SMESH.SMESH_IDSource idSource: an object to retrieve IDs from
 868
 869    .. py:function:: Remove( elem_ids )
 870
 871       Removes elements or nodes with specified identifiers from the group
 872
 873       :param list_of_ids elem_ids: IDs to remove
 874
 875 SMESH_GroupOnGeom
 876 -----------------
 877
 878 .. py:class:: SMESH_GroupOnGeom
 879
 880    Group linked to geometry. Inherits all methods of :class:`SMESH.SMESH_GroupBase`
 881
 882    .. py:function:: GetShape()
 883
 884       Return an associated geometry
 885
 886       :return: GEOM.GEOM_Object
 887
 888 SMESH_GroupOnFilter
 889 -------------------
 890
 891 .. py:class:: SMESH_GroupOnFilter
 892
 893    Group defined by filter. Inherits all methods of :class:`SMESH.SMESH_GroupBase`
 894
 895    .. py:function:: SetFilter( filter )
 896
 897       Set the :class:`filter <SMESH.Filter>`
 898
 899    .. py:function:: GetFilter()
 900
 901       Return the :class:`filter <SMESH.Filter>`
 902
 903
 904 SMESH_IDSource
 905 --------------
 906
 907 .. py:class:: SMESH_IDSource
 908
 909    Base class for classes able to return IDs of mesh entities. These classes are:
 910
 911    * :class:`SMESH.SMESH_Mesh`
 912    * :class:`SMESH.SMESH_subMesh`
 913    * :class:`SMESH.SMESH_GroupBase`
 914    * :class:`SMESH.Filter`
 915    * temporal ID source created by :meth:`~smeshBuilder.Mesh.GetIDSource`
 916
 917    .. py:function:: GetIDs()
 918
 919       Return a sequence of all element IDs
 920
 921    .. py:function:: GetMeshInfo()
 922
 923       Return number of mesh elements of each :class:`SMESH.EntityType`.
 924       Use :meth:`~smeshBuilder.smeshBuilder.EnumToLong` to get an integer from
 925       an item of :class:`SMESH.EntityType`.
 926
 927    .. py:function:: GetNbElementsByType()
 928
 929       Return number of mesh elements of each :class:`SMESH.ElementType`.
 930       Use :meth:`~smeshBuilder.smeshBuilder.EnumToLong` to get an integer from
 931       an item of :class:`SMESH.ElementType`.
 932
 933
 934    .. py:function:: GetTypes()
 935
 936       Return types of elements it contains.
 937       It's empty if the object contains no IDs
 938
 939       :return: list of :class:`SMESH.ElementType`
 940
 941    .. py:function:: GetMesh()
 942
 943       Return the :class:`SMESH.SMESH_Mesh`
 944
 945 SMESH_Hypothesis
 946 ----------------
 947
 948 .. py:class:: SMESH_Hypothesis
 949
 950    Base class of all :doc:`hypotheses <about_hypo>`
 951
 952    .. py:function:: GetName()
 953
 954       Return string of hypothesis type name, something like "Regular_1D"
 955
 956    .. py:function:: GetLibName()
 957
 958       Return string of plugin library name