idl/SMESH_MeshEditor.idl

   1 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //  File   : SMESH_MeshEditor.idl
  23
  24 #ifndef _SMESH_MESHEDITOR_IDL_
  25 #define _SMESH_MESHEDITOR_IDL_
  26
  27 #include "SMESH_Mesh.idl"
  28
  29 module SMESH
  30 {
  31   enum Bnd_Dimension { BND_2DFROM3D, BND_1DFROM3D, BND_1DFROM2D };
  32
  33   /*!
  34    * This interface makes modifications on the Mesh - removing elements and nodes etc.
  35    */
  36   interface NumericalFunctor;
  37   interface SMESH_MeshEditor
  38   {
  39     /*!
  40      * \brief Wrap a sequence of ids in a SMESH_IDSource
  41      * \param IDsOfElements list of mesh elements identifiers
  42      * \return new ID source object
  43      */
  44     SMESH_IDSource MakeIDSource(in long_array IDsOfElements, in ElementType type);
  45
  46     /*!
  47      * \brief Remove mesh elements specified by their identifiers.
  48      * \param IDsOfElements list of mesh elements identifiers
  49      * \return \c true if elements are correctly removed or \c false otherwise
  50      */
  51     boolean RemoveElements(in long_array IDsOfElements);
  52
  53     /*!
  54      * \brief Remove mesh nodes specified by their identifiers.
  55      * \param IDsOfNodes list of mesh nodes identifiers
  56      * \return \c true if nodes are correctly removed or \c false otherwise
  57      */
  58     boolean RemoveNodes(in long_array IDsOfNodes);
  59
  60     /*!
  61      * \brief Remove all orphan nodes.
  62      * \return number of removed nodes
  63      */
  64     long RemoveOrphanNodes();
  65
  66     /*!
  67      * \brief Add new node.
  68      * \param x X coordinate of new node
  69      * \param y Y coordinate of new node
  70      * \param z Z coordinate of new node
  71      * \return integer identifier of new node
  72      */
  73     long AddNode(in double x, in double y, in double z);
  74
  75     /*!
  76      *  Create 0D element on the given node.
  77      *  \param IdOfNode Node IDs for creation of element.
  78      */
  79     long Add0DElement(in long IDOfNode);
  80
  81     /*!
  82      *  Create edge, either linear and quadratic (this is determed
  83      *  by number of given nodes).
  84      *  \param IdsOfNodes List of node IDs for creation of element.
  85      *  Needed order of nodes in this list corresponds to description
  86      *  of MED. This description is located by the following link:
  87      *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
  88      */
  89     long AddEdge(in long_array IDsOfNodes);
  90
  91     /*!
  92      *  Create face, either linear and quadratic (this is determed
  93      *  by number of given nodes).
  94      *  \param IdsOfNodes List of node IDs for creation of element.
  95      *  Needed order of nodes in this list corresponds to description
  96      *  of MED. This description is located by the following link:
  97      *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
  98      */
  99     long AddFace(in long_array IDsOfNodes);
 100
 101     long AddPolygonalFace(in long_array IdsOfNodes);
 102
 103     /*!
 104      *  Create volume, either linear and quadratic (this is determed
 105      *  by number of given nodes).
 106      *  \param IdsOfNodes List of node IDs for creation of element.
 107      *  Needed order of nodes in this list corresponds to description
 108      *  of MED. This description is located by the following link:
 109      *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
 110      */
 111     long AddVolume(in long_array IDsOfNodes);
 112
 113     /*!
 114      *  Create volume of many faces, giving nodes for each face.
 115      *  \param IdsOfNodes List of node IDs for volume creation face by face.
 116      *  \param Quantities List of integer values, Quantities[i]
 117      *         gives quantity of nodes in face number i.
 118      */
 119     long AddPolyhedralVolume (in long_array IdsOfNodes,
 120                               in long_array Quantities);
 121
 122     /*!
 123      *  Create volume of many faces, giving IDs of existing faces.
 124      *  \param IdsOfFaces List of face IDs for volume creation.
 125      *  \note The created volume will refer only to nodes
 126      *        of the given faces, not to the faces itself.
 127      */
 128     long AddPolyhedralVolumeByFaces (in long_array IdsOfFaces);
 129
 130     /*!
 131      * \brief Bind a node to a vertex
 132       * \param NodeID - node ID
 133       * \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
 134      */
 135     void SetNodeOnVertex(in long NodeID, in long VertexID)
 136       raises (SALOME::SALOME_Exception);
 137     /*!
 138      * \brief Store node position on an edge
 139       * \param NodeID - node ID
 140       * \param EdgeID - edge ID available through GEOM_Object.GetSubShapeIndices()[0]
 141       * \param paramOnEdge - parameter on edge where the node is located
 142      */
 143     void SetNodeOnEdge(in long NodeID, in long EdgeID, in double paramOnEdge)
 144       raises (SALOME::SALOME_Exception);
 145     /*!
 146      * \brief Store node position on a face
 147       * \param NodeID - node ID
 148       * \param FaceID - face ID available through GEOM_Object.GetSubShapeIndices()[0]
 149       * \param u - U parameter on face where the node is located
 150       * \param v - V parameter on face where the node is located
 151      */
 152     void SetNodeOnFace(in long NodeID, in long FaceID, in double u, in double v)
 153       raises (SALOME::SALOME_Exception);
 154     /*!
 155      * \brief Bind a node to a solid
 156       * \param NodeID - node ID
 157       * \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
 158      */
 159     void SetNodeInVolume(in long NodeID, in long SolidID)
 160       raises (SALOME::SALOME_Exception);
 161     /*!
 162      * \brief Bind an element to a shape
 163       * \param ElementID - element ID
 164       * \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
 165      */
 166     void SetMeshElementOnShape(in long ElementID, in long ShapeID)
 167       raises (SALOME::SALOME_Exception);
 168
 169
 170     boolean MoveNode(in long NodeID, in double x, in double y, in double z);
 171
 172     boolean InverseDiag(in long NodeID1, in long NodeID2);
 173
 174     boolean DeleteDiag(in long NodeID1, in long NodeID2);
 175
 176     boolean Reorient(in long_array IDsOfElements);
 177
 178     boolean ReorientObject(in SMESH_IDSource theObject);
 179     /*!
 180      * \brief Reorient faces contained in \a the2Dgroup.
 181      * \param the2Dgroup - the mesh or its part to reorient
 182      * \param theDirection - desired direction of normal of \a theFace
 183      * \param theFace - ID of face whose orientation is checked.
 184      *        It can be < 1 then \a thePoint is used to find a face.
 185      * \param thePoint - is used to find a face if \a theFace < 1.
 186      * \return number of reoriented elements.
 187      */
 188     long Reorient2D(in SMESH_IDSource the2Dgroup,
 189                     in DirStruct      theDirection,
 190                     in long           theFace,
 191                     in PointStruct    thePoint) raises (SALOME::SALOME_Exception);
 192
 193     /*!
 194      * \brief Fuse neighbour triangles into quadrangles.
 195      * \param theElems     The triangles to be fused.
 196      * \param theCriterion Is used to choose a neighbour to fuse with.
 197      * \param theMaxAngle  Is a max angle between element normals at which fusion
 198      *                     is still performed; theMaxAngle is mesured in radians.
 199      * \return TRUE in case of success, FALSE otherwise.
 200      */
 201     boolean TriToQuad (in long_array       IDsOfElements,
 202                        in NumericalFunctor Criterion,
 203                        in double           MaxAngle);
 204
 205     /*!
 206      * \brief Fuse neighbour triangles into quadrangles.
 207      *
 208      * Behaves like the above method, taking list of elements from \a theObject
 209      */
 210     boolean TriToQuadObject (in SMESH_IDSource   theObject,
 211                              in NumericalFunctor Criterion,
 212                              in double           MaxAngle);
 213
 214     /*!
 215      * \brief Split quadrangles into triangles.
 216      * \param theElems     The faces to be splitted.
 217      * \param theCriterion Is used to choose a diagonal for splitting.
 218      * \return TRUE in case of success, FALSE otherwise.
 219      */
 220     boolean QuadToTri (in long_array       IDsOfElements,
 221                        in NumericalFunctor Criterion);
 222
 223     /*!
 224      * \brief Split quadrangles into triangles.
 225      *
 226      * Behaves like the above method, taking list of elements from \a theObject
 227      */
 228     boolean QuadToTriObject (in SMESH_IDSource   theObject,
 229                              in NumericalFunctor Criterion);
 230
 231     /*!
 232      * \brief Split quadrangles into triangles.
 233      * \param theElems  The faces to be splitted.
 234      * \param the13Diag Is used to choose a diagonal for splitting.
 235      * \return TRUE in case of success, FALSE otherwise.
 236      */
 237     boolean SplitQuad (in long_array IDsOfElements,
 238                        in boolean    Diag13);
 239
 240     /*!
 241      * \brief Split quadrangles into triangles.
 242      *
 243      * Behaves like the above method, taking list of elements from \a theObject
 244      */
 245     boolean SplitQuadObject (in SMESH_IDSource theObject,
 246                              in boolean        Diag13);
 247
 248     /*!
 249      *  Find better splitting of the given quadrangle.
 250      *  \param IDOfQuad  ID of the quadrangle to be splitted.
 251      *  \param Criterion A criterion to choose a diagonal for splitting.
 252      *  \return 1 if 1-3 diagonal is better, 2 if 2-4
 253      *          diagonal is better, 0 if error occurs.
 254      */
 255     long BestSplit (in long             IDOfQuad,
 256                     in NumericalFunctor Criterion);
 257
 258     /*!
 259      * \brief Split volumic elements into tetrahedrons
 260      *  \param elems - elements to split
 261      *  \param methodFlags - flags passing splitting method:
 262      *         1 - split the hexahedron into 5 tetrahedrons
 263      *         2 - split the hexahedron into 6 tetrahedrons
 264      *         3 - split the hexahedron into 24 tetrahedrons
 265      */
 266     void SplitVolumesIntoTetra(in SMESH_IDSource elems, in short methodFlags)
 267       raises (SALOME::SALOME_Exception);
 268
 269
 270     enum Smooth_Method { LAPLACIAN_SMOOTH, CENTROIDAL_SMOOTH };
 271
 272     boolean Smooth(in long_array    IDsOfElements,
 273                    in long_array    IDsOfFixedNodes,
 274                    in long          MaxNbOfIterations,
 275                    in double        MaxAspectRatio,
 276                    in Smooth_Method Method);
 277
 278     boolean SmoothObject(in SMESH_IDSource  theObject,
 279                          in long_array      IDsOfFixedNodes,
 280                          in long            MaxNbOfIterations,
 281                          in double          MaxAspectRatio,
 282                          in Smooth_Method   Method);
 283
 284     boolean SmoothParametric(in long_array    IDsOfElements,
 285                              in long_array    IDsOfFixedNodes,
 286                              in long          MaxNbOfIterations,
 287                              in double        MaxAspectRatio,
 288                              in Smooth_Method Method);
 289
 290     boolean SmoothParametricObject(in SMESH_IDSource  theObject,
 291                                    in long_array      IDsOfFixedNodes,
 292                                    in long            MaxNbOfIterations,
 293                                    in double          MaxAspectRatio,
 294                                    in Smooth_Method   Method);
 295
 296     void ConvertToQuadratic(in boolean theForce3d);
 297
 298     boolean ConvertFromQuadratic();
 299
 300     void ConvertToQuadraticObject(in boolean        theForce3d,
 301                                   in SMESH_IDSource theObject)
 302       raises (SALOME::SALOME_Exception);
 303
 304     void ConvertFromQuadraticObject(in SMESH_IDSource theObject)
 305       raises (SALOME::SALOME_Exception);
 306
 307     void RenumberNodes();
 308
 309     void RenumberElements();
 310
 311     /*!
 312      * \brief Genarate dim+1 elements by rotation of given elements around axis
 313      * \param IDsOfElements - elements to ratate
 314      * \param Axix - rotation axis
 315      * \param AngleInRadians - rotation angle
 316      * \param NbOfSteps - number of elements to generate from one element
 317      */
 318     void RotationSweep(in long_array       IDsOfElements,
 319                        in AxisStruct       Axix,
 320                        in double           AngleInRadians,
 321                        in long             NbOfSteps,
 322                        in double           Tolerance);
 323     /*!
 324      * \brief Same as previous but additionally create groups of elements
 325      *  generated from elements belonging to preexisting groups
 326      */
 327     ListOfGroups RotationSweepMakeGroups(in long_array       IDsOfElements,
 328                                          in AxisStruct       Axix,
 329                                          in double           AngleInRadians,
 330                                          in long             NbOfSteps,
 331                                          in double           Tolerance);
 332     /*!
 333      * \brief Genarate dim+1 elements by rotation of the object around axis
 334      * \param theObject - object containing elements to ratate
 335      * \param Axix - rotation axis
 336      * \param AngleInRadians - rotation angle
 337      * \param NbOfSteps - number of elements to generate from one element
 338      */
 339     void RotationSweepObject(in SMESH_IDSource  theObject,
 340                              in AxisStruct      Axix,
 341                              in double          AngleInRadians,
 342                              in long            NbOfSteps,
 343                              in double          Tolerance);
 344     /*!
 345      * \brief Same as previous but additionally create groups of elements
 346      *  generated from elements belonging to preexisting groups
 347      */
 348     ListOfGroups RotationSweepObjectMakeGroups(in SMESH_IDSource  theObject,
 349                                                in AxisStruct      Axix,
 350                                                in double          AngleInRadians,
 351                                                in long            NbOfSteps,
 352                                                in double          Tolerance);
 353     /*!
 354      * \brief Genarate dim+1 elements by rotation of the object around axis
 355      * \param theObject - object containing elements to ratate
 356      * \param Axix - rotation axis
 357      * \param AngleInRadians - rotation angle
 358      * \param NbOfSteps - number of elements to generate from one element
 359      */
 360     void RotationSweepObject1D(in SMESH_IDSource  theObject,
 361                                in AxisStruct      Axix,
 362                                in double          AngleInRadians,
 363                                in long            NbOfSteps,
 364                                in double          Tolerance);
 365     /*!
 366      * \brief Same as previous but additionally create groups of elements
 367      *  generated from elements belonging to preexisting groups
 368      */
 369     ListOfGroups RotationSweepObject1DMakeGroups(in SMESH_IDSource  theObject,
 370                                                  in AxisStruct      Axix,
 371                                                  in double          AngleInRadians,
 372                                                  in long            NbOfSteps,
 373                                                  in double          Tolerance);
 374     /*!
 375      * \brief Genarate dim+1 elements by rotation of the object around axis
 376      * \param theObject - object containing elements to ratate
 377      * \param Axix - rotation axis
 378      * \param AngleInRadians - rotation angle
 379      * \param NbOfSteps - number of elements to generate from one element
 380      */
 381     void RotationSweepObject2D(in SMESH_IDSource  theObject,
 382                                in AxisStruct      Axix,
 383                                in double          AngleInRadians,
 384                                in long            NbOfSteps,
 385                                in double          Tolerance);
 386     /*!
 387      * \brief Same as previous but additionally create groups of elements
 388      *  generated from elements belonging to preexisting groups
 389      */
 390     ListOfGroups RotationSweepObject2DMakeGroups(in SMESH_IDSource  theObject,
 391                                                  in AxisStruct      Axix,
 392                                                  in double          AngleInRadians,
 393                                                  in long            NbOfSteps,
 394                                                  in double          Tolerance);
 395     /*!
 396      * \brief Genarate dim+1 elements by extrusion of elements along vector
 397      * \param IDsOfElements - elements to sweep
 398      * \param StepVector - vector giving direction and distance of an extrusion step
 399      * \param NbOfSteps - number of elements to generate from one element
 400      */
 401     void ExtrusionSweep(in long_array      IDsOfElements,
 402                         in DirStruct       StepVector,
 403                         in long            NbOfSteps);
 404     /*!
 405      * \brief Genarate dim+1 elements by extrusion of elements along vector
 406      * \param IDsOfElements - elements to sweep
 407      * \param StepVector - vector giving direction and distance of an extrusion step
 408      * \param NbOfSteps - number of elements to generate from one element
 409      */
 410     void ExtrusionSweep0D(in long_array    IDsOfElements,
 411                         in DirStruct       StepVector,
 412                         in long            NbOfSteps);
 413     /*!
 414      * \brief Same as previous but additionally create groups of elements
 415      *  generated from elements belonging to preexisting groups
 416      */
 417     ListOfGroups ExtrusionSweepMakeGroups(in long_array      IDsOfElements,
 418                                           in DirStruct       StepVector,
 419                                           in long            NbOfSteps);
 420    /*!
 421      * \brief Same as previous but elements are nodes
 422      */
 423     ListOfGroups ExtrusionSweepMakeGroups0D(in long_array      IDsOfElements,
 424                                           in DirStruct       StepVector,
 425                                           in long            NbOfSteps);
 426    /*!
 427     * Generate new elements by extrusion of theElements
 428     * by StepVector by NbOfSteps
 429     * param ExtrFlags set flags for performing extrusion
 430     * param SewTolerance - uses for comparing locations of nodes if flag
 431     *   EXTRUSION_FLAG_SEW is set
 432     */
 433     void AdvancedExtrusion(in long_array      IDsOfElements,
 434                            in DirStruct       StepVector,
 435                            in long            NbOfSteps,
 436                            in long            ExtrFlags,
 437                            in double          SewTolerance);
 438     /*!
 439      * \brief Same as previous but additionally create groups of elements
 440      *  generated from elements belonging to preexisting groups
 441      */
 442     ListOfGroups AdvancedExtrusionMakeGroups(in long_array      IDsOfElements,
 443                                              in DirStruct       StepVector,
 444                                              in long            NbOfSteps,
 445                                              in long            ExtrFlags,
 446                                              in double          SewTolerance);
 447
 448     void ExtrusionSweepObject(in SMESH_IDSource  theObject,
 449                               in DirStruct       StepVector,
 450                               in long            NbOfSteps);
 451     ListOfGroups ExtrusionSweepObjectMakeGroups(in SMESH_IDSource  theObject,
 452                                                 in DirStruct       StepVector,
 453                                                 in long            NbOfSteps);
 454
 455     void ExtrusionSweepObject0D(in SMESH_IDSource theObject,
 456                                 in DirStruct      StepVector,
 457                                 in long           NbOfSteps);
 458     ListOfGroups ExtrusionSweepObject0DMakeGroups(in SMESH_IDSource theObject,
 459                                                   in DirStruct      StepVector,
 460                                                   in long           NbOfSteps);
 461
 462     void ExtrusionSweepObject1D(in SMESH_IDSource theObject,
 463                                 in DirStruct      StepVector,
 464                                 in long           NbOfSteps);
 465     ListOfGroups ExtrusionSweepObject1DMakeGroups(in SMESH_IDSource theObject,
 466                                                   in DirStruct      StepVector,
 467                                                   in long           NbOfSteps);
 468
 469     void ExtrusionSweepObject2D(in SMESH_IDSource theObject,
 470                                 in DirStruct      StepVector,
 471                                 in long           NbOfSteps);
 472     ListOfGroups ExtrusionSweepObject2DMakeGroups(in SMESH_IDSource theObject,
 473                                                   in DirStruct      StepVector,
 474                                                   in long           NbOfSteps);
 475
 476     enum Extrusion_Error {
 477       EXTR_OK,
 478       EXTR_NO_ELEMENTS,
 479       EXTR_PATH_NOT_EDGE,
 480       EXTR_BAD_PATH_SHAPE,
 481       EXTR_BAD_STARTING_NODE,
 482       EXTR_BAD_ANGLES_NUMBER,
 483       EXTR_CANT_GET_TANGENT
 484       };
 485
 486     ListOfGroups ExtrusionAlongPathX(in long_array        IDsOfElements,
 487                                      in SMESH_IDSource    Path,
 488                                      in long              NodeStart,
 489                                      in boolean           HasAngles,
 490                                      in double_array      Angles,
 491                                      in boolean           LinearVariation,
 492                                      in boolean           HasRefPoint,
 493                                      in PointStruct       RefPoint,
 494                                      in boolean           MakeGroups,
 495                                      in ElementType       ElemType,
 496                                      out Extrusion_Error  Error);
 497
 498     ListOfGroups ExtrusionAlongPathObjX(in SMESH_IDSource    theObject,
 499                                         in SMESH_IDSource    Path,
 500                                         in long              NodeStart,
 501                                         in boolean           HasAngles,
 502                                         in double_array      Angles,
 503                                         in boolean           LinearVariation,
 504                                         in boolean           HasRefPoint,
 505                                         in PointStruct       RefPoint,
 506                                         in boolean           MakeGroups,
 507                                         in ElementType       ElemType,
 508                                         out Extrusion_Error  Error);
 509
 510     Extrusion_Error ExtrusionAlongPath(in long_array        IDsOfElements,
 511                                        in SMESH_Mesh        PathMesh,
 512                                        in GEOM::GEOM_Object PathShape,
 513                                        in long              NodeStart,
 514                                        in boolean           HasAngles,
 515                                        in double_array      Angles,
 516                                        in boolean           HasRefPoint,
 517                                        in PointStruct       RefPoint);
 518     ListOfGroups ExtrusionAlongPathMakeGroups(in long_array        IDsOfElements,
 519                                               in SMESH_Mesh        PathMesh,
 520                                               in GEOM::GEOM_Object PathShape,
 521                                               in long              NodeStart,
 522                                               in boolean           HasAngles,
 523                                               in double_array      Angles,
 524                                               in boolean           HasRefPoint,
 525                                               in PointStruct       RefPoint,
 526                                               out Extrusion_Error  Error);
 527
 528     Extrusion_Error ExtrusionAlongPathObject(in SMESH_IDSource    theObject,
 529                                              in SMESH_Mesh        PathMesh,
 530                                              in GEOM::GEOM_Object PathShape,
 531                                              in long              NodeStart,
 532                                              in boolean           HasAngles,
 533                                              in double_array      Angles,
 534                                              in boolean           HasRefPoint,
 535                                              in PointStruct       RefPoint);
 536     ListOfGroups ExtrusionAlongPathObjectMakeGroups(in SMESH_IDSource    theObject,
 537                                                     in SMESH_Mesh        PathMesh,
 538                                                     in GEOM::GEOM_Object PathShape,
 539                                                     in long              NodeStart,
 540                                                     in boolean           HasAngles,
 541                                                     in double_array      Angles,
 542                                                     in boolean           HasRefPoint,
 543                                                     in PointStruct       RefPoint,
 544                                                     out Extrusion_Error  Error);
 545
 546     Extrusion_Error ExtrusionAlongPathObject1D(in SMESH_IDSource    theObject,
 547                                                in SMESH_Mesh        PathMesh,
 548                                                in GEOM::GEOM_Object PathShape,
 549                                                in long              NodeStart,
 550                                                in boolean           HasAngles,
 551                                                in double_array      Angles,
 552                                                in boolean           HasRefPoint,
 553                                                in PointStruct       RefPoint);
 554     ListOfGroups ExtrusionAlongPathObject1DMakeGroups(in SMESH_IDSource    theObject,
 555                                                       in SMESH_Mesh        PathMesh,
 556                                                       in GEOM::GEOM_Object PathShape,
 557                                                       in long              NodeStart,
 558                                                       in boolean           HasAngles,
 559                                                       in double_array      Angles,
 560                                                       in boolean           HasRefPoint,
 561                                                       in PointStruct       RefPoint,
 562                                                       out Extrusion_Error  Error);
 563
 564     Extrusion_Error ExtrusionAlongPathObject2D(in SMESH_IDSource    theObject,
 565                                                in SMESH_Mesh        PathMesh,
 566                                                in GEOM::GEOM_Object PathShape,
 567                                                in long              NodeStart,
 568                                                in boolean           HasAngles,
 569                                                in double_array      Angles,
 570                                                in boolean           HasRefPoint,
 571                                                in PointStruct       RefPoint);
 572     ListOfGroups ExtrusionAlongPathObject2DMakeGroups(in SMESH_IDSource    theObject,
 573                                                       in SMESH_Mesh        PathMesh,
 574                                                       in GEOM::GEOM_Object PathShape,
 575                                                       in long              NodeStart,
 576                                                       in boolean           HasAngles,
 577                                                       in double_array      Angles,
 578                                                       in boolean           HasRefPoint,
 579                                                       in PointStruct       RefPoint,
 580                                                       out Extrusion_Error  Error);
 581
 582    /*!
 583     * Compute rotation angles for ExtrusionAlongPath as linear variation
 584     * of given angles along path steps
 585     * param PathMesh mesh containing a 1D sub-mesh on the edge, along
 586     *                which proceeds the extrusion
 587     * param PathShape is shape(edge); as the mesh can be complex, the edge
 588     *                 is used to define the sub-mesh for the path
 589     */
 590     double_array LinearAnglesVariation(in SMESH_Mesh        PathMesh,
 591                                        in GEOM::GEOM_Object PathShape,
 592                                        in double_array      Angles);
 593
 594     enum MirrorType { POINT, AXIS, PLANE };
 595
 596     void Mirror (in long_array IDsOfElements,
 597                  in AxisStruct Mirror,
 598                  in MirrorType Type,
 599                  in boolean    Copy);
 600     ListOfGroups MirrorMakeGroups (in long_array IDsOfElements,
 601                                    in AxisStruct Mirror,
 602                                    in MirrorType Type);
 603     SMESH_Mesh MirrorMakeMesh (in long_array IDsOfElements,
 604                                in AxisStruct Mirror,
 605                                in MirrorType Type,
 606                                in boolean    CopyGroups,
 607                                in string     MeshName);
 608
 609     void MirrorObject (in SMESH_IDSource theObject,
 610                        in AxisStruct     Mirror,
 611                        in MirrorType     Type,
 612                        in boolean        Copy);
 613     ListOfGroups MirrorObjectMakeGroups (in SMESH_IDSource theObject,
 614                                          in AxisStruct     Mirror,
 615                                          in MirrorType     Type);
 616     SMESH_Mesh MirrorObjectMakeMesh (in SMESH_IDSource theObject,
 617                                      in AxisStruct     Mirror,
 618                                      in MirrorType     Type,
 619                                      in boolean        CopyGroups,
 620                                      in string         MeshName);
 621
 622     void Translate (in long_array IDsOfElements,
 623                     in DirStruct  Vector,
 624                     in boolean    Copy);
 625     ListOfGroups TranslateMakeGroups (in long_array IDsOfElements,
 626                                       in DirStruct  Vector);
 627     SMESH_Mesh TranslateMakeMesh (in long_array IDsOfElements,
 628                                   in DirStruct  Vector,
 629                                   in boolean    CopyGroups,
 630                                   in string     MeshName);
 631
 632     void TranslateObject (in SMESH_IDSource theObject,
 633                           in DirStruct      Vector,
 634                           in boolean        Copy);
 635     ListOfGroups TranslateObjectMakeGroups (in SMESH_IDSource theObject,
 636                                             in DirStruct      Vector);
 637     SMESH_Mesh TranslateObjectMakeMesh (in SMESH_IDSource theObject,
 638                                         in DirStruct      Vector,
 639                                         in boolean        CopyGroups,
 640                                         in string         MeshName);
 641
 642     void Scale (in SMESH_IDSource theObject,
 643                 in PointStruct    thePoint,
 644                 in double_array   theScaleFact,
 645                 in boolean        Copy);
 646     ListOfGroups ScaleMakeGroups (in SMESH_IDSource theObject,
 647                                   in PointStruct    thePoint,
 648                                   in double_array   theScaleFact);
 649     SMESH_Mesh ScaleMakeMesh (in SMESH_IDSource theObject,
 650                               in PointStruct    thePoint,
 651                               in double_array   theScaleFact,
 652                               in boolean        CopyGroups,
 653                               in string         MeshName);
 654
 655     void Rotate (in long_array IDsOfElements,
 656                  in AxisStruct Axis,
 657                  in double     AngleInRadians,
 658                  in boolean    Copy);
 659     ListOfGroups RotateMakeGroups (in long_array IDsOfElements,
 660                                    in AxisStruct Axis,
 661                                    in double     AngleInRadians);
 662     SMESH_Mesh RotateMakeMesh (in long_array IDsOfElements,
 663                                in AxisStruct Axis,
 664                                in double     AngleInRadians,
 665                                in boolean    CopyGroups,
 666                                in string     MeshName);
 667
 668     void RotateObject (in SMESH_IDSource theObject,
 669                        in AxisStruct     Axis,
 670                        in double         AngleInRadians,
 671                        in boolean        Copy);
 672     ListOfGroups RotateObjectMakeGroups (in SMESH_IDSource theObject,
 673                                          in AxisStruct     Axis,
 674                                          in double         AngleInRadians);
 675     SMESH_Mesh RotateObjectMakeMesh (in SMESH_IDSource theObject,
 676                                      in AxisStruct     Axis,
 677                                      in double         AngleInRadians,
 678                                      in boolean        CopyGroups,
 679                                      in string         MeshName);
 680
 681     void FindCoincidentNodes (in  double              Tolerance,
 682                               out array_of_long_array GroupsOfNodes);
 683
 684     void FindCoincidentNodesOnPart (in  SMESH_IDSource      SubMeshOrGroup,
 685                                     in  double              Tolerance,
 686                                     out array_of_long_array GroupsOfNodes);
 687
 688     void FindCoincidentNodesOnPartBut (in  SMESH_IDSource      SubMeshOrGroup,
 689                                        in  double              Tolerance,
 690                                        out array_of_long_array GroupsOfNodes,
 691                                        in  ListOfIDSources     ExceptSubMeshOrGroups);
 692
 693     void MergeNodes (in array_of_long_array GroupsOfNodes);
 694
 695     /*!
 696      * \brief Find elements built on the same nodes.
 697      * \param MeshOrSubMeshOrGroup Mesh or SubMesh, or Group of elements for searching.
 698      * \return List of groups of equal elements.
 699      */
 700     void FindEqualElements (in  SMESH_IDSource      MeshOrSubMeshOrGroup,
 701                             out array_of_long_array GroupsOfElementsID);
 702
 703     /*!
 704      * \brief Merge elements in each given group.
 705      * \param GroupsOfElementsID Groups of elements for merging.
 706      */
 707     void MergeElements(in array_of_long_array GroupsOfElementsID);
 708
 709     /*!
 710      * \brief Merge equal elements in the whole mesh.
 711      */
 712     void MergeEqualElements();
 713
 714     /*!
 715      * If the given ID is a valid node ID (nodeID > 0), just move this node, else
 716      * move the node closest to the point to point's location and return ID of the node
 717      */
 718     long MoveClosestNodeToPoint(in double x, in double y, in double z, in long nodeID);
 719
 720     /*!
 721      * Return ID of node closest to a given point
 722      */
 723     long FindNodeClosestTo(in double x, in double y, in double z);
 724
 725     /*!
 726      * Return elements of given type where the given point is IN or ON.
 727      *
 728      * 'ALL' type means elements of any type excluding nodes and 0D elements
 729      */
 730     long_array FindElementsByPoint(in double x, in double y, in double z, in ElementType type);
 731
 732     /*!
 733      * Searching among the given elements, return elements of given type
 734      * where the given point is IN or ON.
 735      *
 736      * 'ALL' type means elements of any type excluding nodes and 0D elements
 737      */
 738     long_array FindAmongElementsByPoint(in SMESH_IDSource elements,
 739                                         in double x, in double y, in double z,
 740                                         in ElementType type);
 741
 742     /*!
 743      * Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
 744      * TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.
 745      */
 746     short GetPointState(in double x, in double y, in double z);
 747
 748     enum Sew_Error {
 749       SEW_OK,
 750       SEW_BORDER1_NOT_FOUND,
 751       SEW_BORDER2_NOT_FOUND,
 752       SEW_BOTH_BORDERS_NOT_FOUND,
 753       SEW_BAD_SIDE_NODES,
 754       SEW_VOLUMES_TO_SPLIT,
 755       // for SewSideElements() only:
 756       SEW_DIFF_NB_OF_ELEMENTS,
 757       SEW_TOPO_DIFF_SETS_OF_ELEMENTS,
 758       SEW_BAD_SIDE1_NODES,
 759       SEW_BAD_SIDE2_NODES
 760       };
 761
 762     Sew_Error SewFreeBorders (in long FirstNodeID1,
 763                               in long SecondNodeID1,
 764                               in long LastNodeID1,
 765                               in long FirstNodeID2,
 766                               in long SecondNodeID2,
 767                               in long LastNodeID2,
 768                               in boolean CreatePolygons,
 769                               in boolean CreatePolyedrs);
 770
 771     Sew_Error SewConformFreeBorders (in long FirstNodeID1,
 772                                      in long SecondNodeID1,
 773                                      in long LastNodeID1,
 774                                      in long FirstNodeID2,
 775                                      in long SecondNodeID2);
 776
 777     Sew_Error SewBorderToSide (in long FirstNodeIDOnFreeBorder,
 778                                in long SecondNodeIDOnFreeBorder,
 779                                in long LastNodeIDOnFreeBorder,
 780                                in long FirstNodeIDOnSide,
 781                                in long LastNodeIDOnSide,
 782                                in boolean CreatePolygons,
 783                                in boolean CreatePolyedrs);
 784
 785     Sew_Error SewSideElements (in long_array IDsOfSide1Elements,
 786                                in long_array IDsOfSide2Elements,
 787                                in long       NodeID1OfSide1ToMerge,
 788                                in long       NodeID1OfSide2ToMerge,
 789                                in long       NodeID2OfSide1ToMerge,
 790                                in long       NodeID2OfSide2ToMerge);
 791
 792    /*!
 793     * Set new nodes for given element.
 794     * If number of nodes is not corresponded to type of
 795     * element - returns false
 796     */
 797     boolean ChangeElemNodes(in long ide, in long_array newIDs);
 798
 799    /*!
 800     * Return data of mesh edition preview which is computed provided
 801     * that the editor was obtained trough SMESH_Mesh::GetMeshEditPreviewer()
 802     */
 803     MeshPreviewStruct GetPreviewData();
 804
 805    /*!
 806     * If during last operation of MeshEditor some nodes were
 807     * created this method returns list of it's IDs, if new nodes
 808     * not creared - returns empty list
 809     */
 810     long_array GetLastCreatedNodes();
 811
 812    /*!
 813     * If during last operation of MeshEditor some elements were
 814     * created this method returns list of it's IDs, if new elements
 815     * not creared - returns empty list
 816     */
 817     long_array GetLastCreatedElems();
 818
 819     /*!
 820      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 821      * \param theNodes - identifiers of nodes to be doubled
 822      * \param theModifiedElems - identifiers of elements to be updated by the new (doubled)
 823      *        nodes. If list of element identifiers is empty then nodes are doubled but
 824      *        they not assigned to elements
 825      *        \return TRUE if operation has been completed successfully, FALSE otherwise
 826      * \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()
 827      */
 828     boolean DoubleNodes( in long_array theNodes, in long_array theModifiedElems );
 829
 830     /*!
 831      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 832      * This method provided for convenience works as DoubleNodes() described above.
 833      * \param theNodeId - identifier of node to be doubled.
 834      * \param theModifiedElems - identifiers of elements to be updated.
 835      * \return TRUE if operation has been completed successfully, FALSE otherwise
 836      * \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
 837      */
 838     boolean DoubleNode( in long theNodeId, in long_array theModifiedElems );
 839
 840     /*!
 841      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 842      * This method provided for convenience works as DoubleNodes() described above.
 843      * \param theNodes - group of nodes to be doubled.
 844      * \param theModifiedElems - group of elements to be updated.
 845      * \return TRUE if operation has been completed successfully, FALSE otherwise
 846      * \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups(), DoubleNodeGroupNew()
 847      */
 848     boolean DoubleNodeGroup( in SMESH_GroupBase theNodes,
 849                              in SMESH_GroupBase theModifiedElems );
 850     /*!
 851      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
 852      * Works as DoubleNodeGroup() described above, but returns a new group with
 853      * newly created nodes.
 854      * \param theNodes - group of nodes to be doubled.
 855      * \param theModifiedElems - group of elements to be updated.
 856      * \return a new group with newly created nodes
 857      * \sa DoubleNodeGroup()
 858      */
 859     SMESH_Group DoubleNodeGroupNew( in SMESH_GroupBase theNodes,
 860                                     in SMESH_GroupBase theModifiedElems );
 861
 862     /*!
 863      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 864      * This method provided for convenience works as DoubleNodes() described above.
 865      * \param theNodes - list of groups of nodes to be doubled
 866      * \param theModifiedElems - list of groups of elements to be updated.
 867      * \return TRUE if operation has been completed successfully, FALSE otherwise
 868      * \sa DoubleNode(), DoubleNodeGroup(), DoubleNodes()
 869      */
 870     boolean DoubleNodeGroups( in ListOfGroups theNodes,
 871                               in ListOfGroups theModifiedElems );
 872     /*!
 873      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 874      * Works as DoubleNodeGroups() described above, but returns a new group with
 875      * newly created nodes.
 876      * \param theNodes - list of groups of nodes to be doubled
 877      * \param theModifiedElems - list of groups of elements to be updated.
 878      * \return a new group with newly created nodes
 879      * \sa DoubleNodeGroups()
 880      */
 881     SMESH_Group DoubleNodeGroupsNew( in ListOfGroups theNodes,
 882                                      in ListOfGroups theModifiedElems );
 883
 884     /*!
 885      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 886      * \param theElems - the list of elements (edges or faces) to be replicated
 887      *        The nodes for duplication could be found from these elements
 888      * \param theNodesNot - list of nodes to NOT replicate
 889      * \param theAffectedElems - the list of elements (cells and edges) to which the
 890      *        replicated nodes should be associated to.
 891      * \return TRUE if operation has been completed successfully, FALSE otherwise
 892      * \sa DoubleNodeGroup(), DoubleNodeGroups()
 893      */
 894     boolean DoubleNodeElem( in long_array theElems,
 895                             in long_array theNodesNot,
 896                             in long_array theAffectedElems );
 897
 898     /*!
 899      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 900      * \param theElems - the list of elements (edges or faces) to be replicated
 901      *        The nodes for duplication could be found from these elements
 902      * \param theNodesNot - list of nodes to NOT replicate
 903      * \param theShape - shape to detect affected elements (element which geometric center
 904      *        located on or inside shape).
 905      *        The replicated nodes should be associated to affected elements.
 906      * \return TRUE if operation has been completed successfully, FALSE otherwise
 907      * \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
 908      */
 909     boolean DoubleNodeElemInRegion( in long_array theElems,
 910                                     in long_array theNodesNot,
 911                                     in GEOM::GEOM_Object theShape );
 912
 913     /*!
 914      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 915      * This method provided for convenience works as DoubleNodes() described above.
 916      * \param theElems - group of of elements (edges or faces) to be replicated
 917      * \param theNodesNot - group of nodes not to replicated
 918      * \param theAffectedElems - group of elements to which the replicated nodes
 919      *        should be associated to.
 920      * \return TRUE if operation has been completed successfully, FALSE otherwise
 921      * \sa DoubleNodes(), DoubleNodeGroups(), DoubleNodeElemGroupNew()
 922      */
 923     boolean DoubleNodeElemGroup( in SMESH_GroupBase theElems,
 924                                  in SMESH_GroupBase theNodesNot,
 925                                  in SMESH_GroupBase theAffectedElems );
 926     /*!
 927      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
 928      * Works as DoubleNodeElemGroup() described above, but returns a new group with
 929      * newly created elements.
 930      * \param theElems - group of of elements (edges or faces) to be replicated
 931      * \param theNodesNot - group of nodes not to replicated
 932      * \param theAffectedElems - group of elements to which the replicated nodes
 933      *        should be associated to.
 934      * \return a new group with newly created elements
 935      * \sa DoubleNodeElemGroup()
 936      */
 937     SMESH_Group DoubleNodeElemGroupNew( in SMESH_GroupBase theElems,
 938                                         in SMESH_GroupBase theNodesNot,
 939                                         in SMESH_GroupBase theAffectedElems );
 940     /*!
 941      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
 942      * Works as DoubleNodeElemGroup() described above, but returns two new groups:
 943      * a group of newly created elements and a group of newly created nodes
 944      * \param theElems - group of of elements (edges or faces) to be replicated
 945      * \param theNodesNot - group of nodes not to replicated
 946      * \param theAffectedElems - group of elements to which the replicated nodes
 947      *        should be associated to.
 948      * \param theElemGroupNeeded - to create group of new elements or not
 949      * \param theNodeGroupNeeded - to create group of new nodes or not
 950      * \return two new groups of newly created elements (1st) and nodes (2nd)
 951      * \sa DoubleNodeElemGroup()
 952      */
 953     ListOfGroups DoubleNodeElemGroup2New( in SMESH_GroupBase theElems,
 954                                           in SMESH_GroupBase theNodesNot,
 955                                           in SMESH_GroupBase theAffectedElems,
 956                                           in boolean         theElemGroupNeeded,
 957                                           in boolean         theNodeGroupNeeded);
 958
 959     /*!
 960      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 961      * This method provided for convenience works as DoubleNodes() described above.
 962      * \param theElems - group of elements (edges or faces) to be replicated
 963      * \param theNodesNot - group of nodes not to replicated
 964      * \param theShape - shape to detect affected elements (element which geometric center
 965      *        located on or inside shape).
 966      *        The replicated nodes should be associated to affected elements.
 967      * \return TRUE if operation has been completed successfully, FALSE otherwise
 968      * \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
 969      */
 970     boolean DoubleNodeElemGroupInRegion( in SMESH_GroupBase theElems,
 971                                          in SMESH_GroupBase theNodesNot,
 972                                          in GEOM::GEOM_Object theShape );
 973
 974     /*!
 975      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 976      * This method provided for convenience works as DoubleNodes() described above.
 977      * \param theElems - list of groups of elements (edges or faces) to be replicated
 978      * \param theNodesNot - list of groups of nodes not to replicated
 979      * \param theAffectedElems - group of elements to which the replicated nodes
 980      *        should be associated to.
 981      * \return TRUE if operation has been completed successfully, FALSE otherwise
 982      * \sa DoubleNodeGroup(), DoubleNodes(), DoubleNodeElemGroupsNew()
 983      */
 984     boolean DoubleNodeElemGroups( in ListOfGroups theElems,
 985                                   in ListOfGroups theNodesNot,
 986                                   in ListOfGroups theAffectedElems );
 987     /*!
 988      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
 989      * Works as DoubleNodeElemGroups() described above, but returns a new group with
 990      * newly created elements.
 991      * \param theElems - list of groups of elements (edges or faces) to be replicated
 992      * \param theNodesNot - list of groups of nodes not to replicated
 993      * \param theAffectedElems - group of elements to which the replicated nodes
 994      *        should be associated to.
 995      * \return a new group with newly created elements
 996      * \sa DoubleNodeElemGroups()
 997      */
 998     SMESH_Group DoubleNodeElemGroupsNew( in ListOfGroups theElems,
 999                                          in ListOfGroups theNodesNot,
1000                                          in ListOfGroups theAffectedElems );
1001     /*!
1002      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
1003      * Works as DoubleNodeElemGroups() described above, but returns two new groups:
1004      * a group of newly created elements and a group of newly created nodes.
1005      * \param theElems - list of groups of elements (edges or faces) to be replicated
1006      * \param theNodesNot - list of groups of nodes not to replicated
1007      * \param theAffectedElems - group of elements to which the replicated nodes
1008      *        should be associated to.
1009      * \param theElemGroupNeeded - to create group of new elements or not
1010      * \param theNodeGroupNeeded - to create group of new nodes or not
1011      * \return two new groups of newly created elements (1st) and nodes (2nd)
1012      * \sa DoubleNodeElemGroups()
1013      */
1014     ListOfGroups DoubleNodeElemGroups2New( in ListOfGroups theElems,
1015                                            in ListOfGroups theNodesNot,
1016                                            in ListOfGroups theAffectedElems,
1017                                            in boolean         theElemGroupNeeded,
1018                                            in boolean         theNodeGroupNeeded );
1019
1020     /*!
1021      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1022      * This method provided for convenience works as DoubleNodes() described above.
1023      * \param theElems - list of groups of elements (edges or faces) to be replicated
1024      * \param theNodesNot - list of groups of nodes not to replicated
1025      * \param theShape - shape to detect affected elements (element which geometric center
1026      *        located on or inside shape).
1027      *        The replicated nodes should be associated to affected elements.
1028      * \return TRUE if operation has been completed successfully, FALSE otherwise
1029      * \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion()
1030      */
1031     boolean DoubleNodeElemGroupsInRegion( in ListOfGroups theElems,
1032                                           in ListOfGroups theNodesNot,
1033                                           in GEOM::GEOM_Object theShape );
1034
1035     /*!
1036      * \brief Generates skin mesh (containing 2D cells) from 3D mesh
1037      * The created 2D mesh elements based on nodes of free faces of boundary volumes
1038      * \return TRUE if operation has been completed successfully, FALSE otherwise
1039      */
1040     boolean Make2DMeshFrom3D();
1041
1042     /*!
1043      * \brief Creates missing boundary elements
1044      *  \param elements - elements whose boundary is to be checked
1045      *  \param dimension - defines type of boundary elements to create
1046      *    BND_1DFROM3D creates mesh edges on all borders of free facets of 3D elements.
1047      *  \param groupName - a name of group to store created boundary elements in,
1048      *                     "" means not to create the group
1049      *  \param meshName - a name of new mesh to store created boundary elements in,
1050      *                     "" means not to create the new mesh
1051      *  \param toCopyElements - if true, the checked elements will be copied into the new mesh
1052      *                          else only boundary elements will be copied into the new mesh
1053      *  \param toCopyExistingBondary - if true, not only new but also pre-existing
1054      *                                boundary elements will be copied into the new mesh
1055      *  \param group - returns the create group, if any
1056      *  \retval SMESH::SMESH_Mesh - the mesh where elements were added to
1057      */
1058     SMESH_Mesh MakeBoundaryMesh(in SMESH_IDSource elements,
1059                                 in Bnd_Dimension  dimension,
1060                                 in string         groupName,
1061                                 in string         meshName,
1062                                 in boolean        toCopyElements,
1063                                 in boolean        toCopyExistingBondary,
1064                                 out SMESH_Group   group);
1065     /*!
1066      * \brief Creates missing boundary elements around either the whole mesh or
1067      *    groups of 2D elements
1068      *  \param dimension - defines type of boundary elements to create
1069      *  \param groupName - a name of group to store all boundary elements in,
1070      *    "" means not to create the group
1071      *  \param meshName - a name of a new mesh, which is a copy of the initial
1072      *    mesh + created boundary elements; "" means not to create the new mesh
1073      *  \param toCopyAll - if true, the whole initial mesh will be copied into
1074      *    the new mesh else only boundary elements will be copied into the new mesh
1075      *  \param groups - optional groups of 2D elements to make boundary around
1076      *  \param mesh - returns the mesh where elements were added to
1077      *  \param group - returns the created group, if any
1078      *  \retval long - number of added boundary elements
1079      */
1080     long MakeBoundaryElements(in Bnd_Dimension   dimension,
1081                               in string          groupName,
1082                               in string          meshName,
1083                               in boolean         toCopyAll,
1084                               in ListOfIDSources groups,
1085                               out SMESH_Mesh     mesh,
1086                               out SMESH_Group    group) raises (SALOME::SALOME_Exception);
1087
1088     /*!
1089      * \brief Double nodes on shared faces between groups of volumes and create flat elements on demand.
1090      * Flat elements are mainly used by some types of mechanic calculations.
1091      *
1092      * The list of groups must describe a partition of the mesh volumes.
1093      * The nodes of the internal faces at the boundaries of the groups are doubled.
1094      * In option, the internal faces are replaced by flat elements.
1095      * Triangles are transformed in prisms, and quadrangles in hexahedrons.
1096      * \param theDomains - list of groups of volumes
1097      * \param createJointElems - if TRUE, create the elements
1098      * \return TRUE if operation has been completed successfully, FALSE otherwise
1099      */
1100     boolean DoubleNodesOnGroupBoundaries( in ListOfGroups theDomains,
1101                                           in boolean createJointElems )
1102       raises (SALOME::SALOME_Exception);
1103
1104     /*!
1105      * \brief Double nodes on some external faces and create flat elements.
1106      * Flat elements are mainly used by some types of mechanic calculations.
1107      *
1108      * Each group of the list must be constituted of faces.
1109      * Triangles are transformed in prisms, and quadrangles in hexahedrons.
1110      * \param theGroupsOfFaces - list of groups of faces
1111      * \return TRUE if operation has been completed successfully, FALSE otherwise
1112      */
1113     boolean CreateFlatElementsOnFacesGroups( in ListOfGroups theGroupsOfFaces );
1114   };
1115 };
1116
1117 #endif