idl/SMESH_Gen.idl

   1 // Copyright (C) 2007-2024  CEA, EDF, 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, or (at your option) any later version.
  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_Gen.idl
  23 //  Author : Paul RASCLE, EDF
  24
  25 #ifndef _SMESH_GEN_IDL_
  26 #define _SMESH_GEN_IDL_
  27
  28 #include "SALOME_Exception.idl"
  29 #include "SALOME_Component.idl"
  30 #include "SALOMEDS.idl"
  31
  32 #include "GEOM_Gen.idl"
  33
  34 #include "SMESH_Mesh.idl"
  35 #include "SMESH_Hypothesis.idl"
  36 #include "SMESH_smIdType.idl"
  37
  38 module SMESHHOMARD
  39 {
  40   interface HOMARD_Gen;
  41 };
  42
  43 module SMESH
  44 {
  45   typedef sequence<SALOMEDS::SObject> sobject_list;
  46   typedef sequence<GEOM::GEOM_Object> object_array;
  47   typedef sequence<SMESH_Mesh>        mesh_array;
  48
  49   interface FilterManager;
  50   interface SMESH_Pattern;
  51   interface Measurements;
  52   interface MG_ADAPT;
  53   interface MG_ADAPT_OBJECT;
  54
  55   /*!
  56    * Tags definition
  57    */
  58   // Top level
  59   const long Tag_HypothesisRoot = 1; // hypotheses root
  60   const long Tag_AlgorithmsRoot = 2; // algorithms root
  61   const long Tag_FirstMeshRoot  = 3; // first mesh root
  62   // Mesh/Submesh
  63   const long Tag_RefOnShape             = 1; // references to shape
  64   const long Tag_RefOnAppliedHypothesis = 2; // applied hypotheses root
  65   const long Tag_RefOnAppliedAlgorithms = 3; // applied algorithms root
  66   // Mesh only: sub-meshes roots by type
  67   const long Tag_FirstSubMesh           =  4;
  68   const long Tag_SubMeshOnVertex        =  4;
  69   const long Tag_SubMeshOnEdge          =  5;
  70   const long Tag_SubMeshOnWire          =  6;
  71   const long Tag_SubMeshOnFace          =  7;
  72   const long Tag_SubMeshOnShell         =  8;
  73   const long Tag_SubMeshOnSolid         =  9;
  74   const long Tag_SubMeshOnCompound      = 10;
  75   const long Tag_LastSubMesh            = 10;
  76   // Mesh only: group roots by type
  77   const long Tag_FirstGroup             = 11;
  78   const long Tag_NodeGroups             = 11;
  79   const long Tag_EdgeGroups             = 12;
  80   const long Tag_FaceGroups             = 13;
  81   const long Tag_VolumeGroups           = 14;
  82   const long Tag_0DElementsGroups       = 15;
  83   const long Tag_BallElementsGroups     = 16;
  84   const long Tag_LastGroup              = 16;
  85
  86   /*!
  87    * Hypothesis definition error
  88    */
  89   struct AlgoStateError
  90   {
  91     Hypothesis_Status  state;
  92     string             algoName;
  93     long               algoDim;
  94     boolean            isGlobalAlgo;
  95   };
  96   typedef sequence<AlgoStateError> algo_error_array;
  97
  98   /*!
  99    * Mesh computation error
 100    */
 101   enum ComputeErrorName
 102   {
 103     COMPERR_OK            ,
 104     COMPERR_BAD_INPUT_MESH,  // wrong mesh on lower submesh
 105     COMPERR_STD_EXCEPTION ,  // some std exception raised
 106     COMPERR_OCC_EXCEPTION ,  // OCC exception raised
 107     COMPERR_SLM_EXCEPTION ,  // SALOME exception raised
 108     COMPERR_EXCEPTION     ,  // other exception raised
 109     COMPERR_MEMORY_PB     ,  // memory allocation problem
 110     COMPERR_ALGO_FAILED   ,  // computation failed
 111     COMPERR_BAD_SHAPE     ,  // bad geometry
 112     COMPERR_WARNING       ,  // algo reports error but sub-mesh is computed anyway
 113     COMPERR_CANCELED      ,  // compute canceled
 114     COMPERR_NO_MESH_ON_SHAPE,// no mesh elements assigned to sub-mesh
 115     COMPERR_BAD_PARMETERS    // incorrect hypotheses parameters
 116   };
 117   struct ComputeError
 118   {
 119     short   code;       // ComputeErrorName or, if negative, algo specific code
 120     string  comment;    // textual problem description
 121     string  algoName;
 122     long    subShapeID; // id of sub-shape of a shape to mesh
 123     boolean hasBadMesh; // there are elements preventing computation available for visualization
 124   };
 125   typedef sequence<ComputeError> compute_error_array;
 126
 127   /*!
 128    * Way to initialize hypothesis
 129    */
 130   struct HypInitParams
 131   {
 132     short   way; // 0 - by mesh, 1 - by geometry size + preferred parameters, 2 - by averageLength
 133     double  averageLength;
 134     boolean quadDominated;
 135   };
 136
 137   interface SMESH_Gen : Engines::EngineComponent, SALOMEDS::Driver
 138   {
 139     //GEOM::GEOM_Gen SetGeomEngine( in string containerLoc );
 140     void SetGeomEngine( in GEOM::GEOM_Gen geomcompo );
 141
 142     FilterManager CreateFilterManager();
 143
 144     SMESH_Pattern GetPattern();
 145
 146     Measurements  CreateMeasurements();
 147
 148     /*!
 149       Set the current mode
 150      */
 151     void SetEmbeddedMode( in boolean theMode );
 152
 153     /*!
 154       Get the current mode
 155      */
 156     boolean IsEmbeddedMode();
 157
 158     /*!
 159       Update the study
 160      */
 161     void UpdateStudy();
 162
 163     /*!
 164       Set enable publishing in the study
 165      */
 166     void SetEnablePublish( in boolean theIsEnablePublish );
 167
 168     /*!
 169       Get enable publishing in the study
 170      */
 171     boolean IsEnablePublish();
 172
 173     /*!
 174      * Create a hypothesis that can be shared by different parts of the mesh.
 175      * An hypothesis is either:
 176      * - a method used to generate or modify a part of the mesh (algorithm).
 177      * - a parameter or a law used by an algorithm.
 178      * Algorithms are 1D, 2D or 3D.
 179      */
 180     SMESH_Hypothesis CreateHypothesis( in string theHypName,
 181                                        in string theLibName )
 182       raises ( SALOME::SALOME_Exception );
 183
 184     /*!
 185      * Create a hypothesis and initialize it by average length
 186      */
 187     SMESH_Hypothesis CreateHypothesisByAverageLength( in string  theHypName,
 188                                                       in string  theLibName,
 189                                                       in double  theAverageLength,
 190                                                       in boolean theQuadDominated)
 191       raises ( SALOME::SALOME_Exception );
 192
 193     /*!
 194      * Return a hypothesis holding parameter values corresponding either to the mesh
 195      * existing on the given geometry or to size of the geometry.
 196      * The returned hypothesis may be the one existing in a study and used
 197      * to compute the mesh, or a temporary one created just to pass parameter
 198      * values.
 199      */
 200     SMESH_Hypothesis GetHypothesisParameterValues( in string            theHypName,
 201                                                    in string            theLibName,
 202                                                    in SMESH_Mesh        theMesh,
 203                                                    in GEOM::GEOM_Object theGeom,
 204                                                    in HypInitParams     theWay)
 205       raises ( SALOME::SALOME_Exception );
 206
 207     /*!
 208      * Returns \c True if a hypothesis is assigned to a sole sub-mesh in a current Study
 209      *  \param [in] theHyp - the hypothesis of interest
 210      *  \param [out] theMesh - the sole mesh using \a theHyp
 211      *  \param [out] theShape - the sole geometry \a theHyp is assigned to
 212      *  \return boolean - \c True if \a theMesh and \a theShape are sole using \a theHyp
 213      */
 214     boolean GetSoleSubMeshUsingHyp( in SMESH_Hypothesis   theHyp,
 215                                     out SMESH_Mesh        theMesh,
 216                                     out GEOM::GEOM_Object theShape);
 217
 218     /*!
 219      * Sets number of segments per diagonal of boundary box of geometry by which
 220      * default segment length of appropriate 1D hypotheses is defined
 221      */
 222     void SetBoundaryBoxSegmentation( in long theNbSegments ) raises ( SALOME::SALOME_Exception );
 223     /*!
 224      * \brief Sets default number of segments per edge
 225      */
 226     void SetDefaultNbSegments( in long theNbSegments) raises ( SALOME::SALOME_Exception );
 227
 228     /*!
 229      * Set the object name
 230      */
 231     void SetName( in string theObjectIOR,
 232                   in string theObjectName )
 233       raises ( SALOME::SALOME_Exception );
 234
 235     /*!
 236      * Create a Mesh object, given a geometry shape.
 237      * Mesh is created empty (no points, no elements).
 238      * Shape is explored via GEOM_Client to create local copies.
 239      * of TopoDS_Shapes and bind CORBA references of shape & subshapes
 240      * with TopoDS_Shapes
 241      */
 242     SMESH_Mesh CreateMesh( in GEOM::GEOM_Object theObject )
 243       raises ( SALOME::SALOME_Exception );
 244
 245     /*!
 246      * Create a Mesh object, given a geometry shape.
 247      * Mesh is created empty (no points, no elements).
 248      * Shape is explored via GEOM_Client to create local copies.
 249      * of TopoDS_Shapes and bind CORBA references of shape & subshapes
 250      * with TopoDS_Shapes
 251      * The mesh is a parallel one
 252      */
 253     SMESH_ParallelMesh CreateParallelMesh( in GEOM::GEOM_Object theObject )
 254       raises ( SALOME::SALOME_Exception );
 255     /*!
 256      * Create an empty mesh object
 257      */
 258     SMESH_Mesh CreateEmptyMesh()
 259       raises ( SALOME::SALOME_Exception );
 260
 261     /*!
 262      * Create Mesh object importing data from given UNV file
 263      * (UNV supported version is I-DEAS 10)
 264      */
 265     SMESH_Mesh CreateMeshesFromUNV( in string theFileName )
 266       raises ( SALOME::SALOME_Exception );
 267
 268     /*!
 269      * Create Mesh object(s) importing data from given MED file
 270      */
 271     mesh_array CreateMeshesFromMED( in string theFileName,
 272                                     out SMESH::DriverMED_ReadStatus theStatus )
 273       raises ( SALOME::SALOME_Exception );
 274
 275     /*!
 276      * Create Mesh object importing data from given STL file
 277      */
 278     SMESH_Mesh CreateMeshesFromSTL( in string theFileName )
 279       raises ( SALOME::SALOME_Exception );
 280
 281     /*!
 282      * Create Mesh object(s) importing data from given CGNS file
 283      */
 284     mesh_array CreateMeshesFromCGNS( in string theFileName,
 285                                      out SMESH::DriverMED_ReadStatus theStatus )
 286       raises ( SALOME::SALOME_Exception );
 287
 288     /*!
 289      * Create Mesh object importing data from given GMF file
 290      *  \param theFileName - a name of file to import
 291      *  \param theMakeRequiredGroups - if true, groups of required entities will be created
 292      */
 293     SMESH_Mesh CreateMeshesFromGMF( in string               theFileName,
 294                                     in boolean              theMakeRequiredGroups,
 295                                     out SMESH::ComputeError theError)
 296       raises ( SALOME::SALOME_Exception );
 297
 298     /*!
 299      * Create a mesh and import data from any file supported by meshio library
 300      */
 301     mesh_array CreateMeshesFromMESHIO(in string theFileName,
 302                                       out SMESH::DriverMED_ReadStatus theStatus)
 303       raises (SALOME::SALOME_Exception);
 304
 305     /*!
 306      * Create a dual mesh of a Tetrahedron mesh
 307      *  \param mesh - TetraHedron mesh to create dual from
 308      *  \param meshName - a name of the new mesh
 309      *  \param adaptToShape - if True project boundary point on shape
 310      */
 311     SMESH_Mesh CreateDualMesh(in SMESH_IDSource mesh,
 312                               in string         meshName,
 313                               in boolean        adaptToShape)
 314       raises ( SALOME::SALOME_Exception );
 315
 316     /*!
 317      * Create a mesh by copying a part of another mesh
 318      *  \param meshPart - a part of mesh to copy
 319      *  \param meshName - a name of the new mesh
 320      *  \param toCopyGroups - to create in the new mesh groups
 321      *                        the copied elements belongs to
 322      *  \param toKeepIDs - to preserve IDs of the copied elements or not
 323      */
 324     SMESH_Mesh CopyMesh(in SMESH_IDSource meshPart,
 325                         in string         meshName,
 326                         in boolean        toCopyGroups,
 327                         in boolean        toKeepIDs)
 328       raises ( SALOME::SALOME_Exception );
 329
 330     /*!
 331      * Create a mesh by copying definitions of another mesh to a given geometry
 332      *  \param sourceMesh - a mesh to copy
 333      *  \param newGeometry - a new geometry
 334      *  \param meshName - a name of the new mesh
 335      *  \param toCopyGroups - to create groups in the new mesh
 336      *  \param toReuseHypotheses - if True, existing hypothesis will be used by the new mesh,
 337      *         otherwise new hypotheses with the same parameters will be created for the new mesh.
 338      *  \param toCopyElements - to copy mesh elements of same sub-shapes of the two geometries
 339      *  \param newMesh - return a new mesh
 340      *  \param newGroups - return new groups
 341      *  \param newSubmeshes - return new sub-meshes
 342      *  \param newHypotheses - return new algorithms and hypotheses
 343      *  \param invalidEntries - return study entries of objects whose
 344      *         counterparts are not found in the newGeometry, followed by entries
 345      *         of mesh sub-objects that are invalid because they depend on a not found
 346      *         preceding sub-shape
 347      */
 348     boolean CopyMeshWithGeom( in SMESH_Mesh        sourceMesh,
 349                               in GEOM::GEOM_Object newGeometry,
 350                               in string            meshName,
 351                               in boolean           toCopyGroups,
 352                               in boolean           toReuseHypotheses,
 353                               in boolean           toCopyElements,
 354                               out SMESH_Mesh       newMesh,
 355                               out ListOfGroups     newGroups,
 356                               out submesh_array    newSubmeshes,
 357                               out ListOfHypothesis newHypotheses,
 358                               out string_array     invalidEntries)
 359       raises ( SALOME::SALOME_Exception );
 360
 361     /*!
 362      * Concatenate the given meshes or groups into one mesh,
 363      * optionally to theMeshToAppendTo.
 364      * Union groups with the same name and type if
 365      * theUniteIdenticalGroups flag is true.
 366      * Merge coincident nodes and elements if
 367      * theMergeNodesAndElements flag is true.
 368      */
 369     SMESH_Mesh Concatenate(in ListOfIDSources theMeshesArray,
 370                            in boolean         theUniteIdenticalGroups,
 371                            in boolean         theMergeNodesAndElements,
 372                            in double          theMergeTolerance,
 373                            in SMESH_Mesh      theMeshToAppendTo)
 374       raises ( SALOME::SALOME_Exception );
 375
 376     /*!
 377      * Concatenate the given meshes into one mesh,
 378      * optionally to theMeshToAppendTo.
 379      * Union groups with the same name and type if
 380      * theUniteIdenticalGroups flag is true.
 381      * Merge coincident nodes and elements if
 382      * theMergeNodesAndElements flag is true.
 383      * Create the groups of all elements from initial meshes.
 384      */
 385     SMESH_Mesh ConcatenateWithGroups(in ListOfIDSources theMeshesArray,
 386                                      in boolean         theUniteIdenticalGroups,
 387                                      in boolean         theMergeNodesAndElements,
 388                                      in double          theMergeTolerance,
 389                                      in SMESH_Mesh      theMeshToAppendTo)
 390       raises ( SALOME::SALOME_Exception );
 391
 392     /*!
 393      * Mesh a subShape.
 394      * First, verify list of hypothesis associated with the Sub-shape,
 395      * return NOK if hypothesis are not sufficient
 396      */
 397     boolean Compute( in SMESH_Mesh        theMesh,
 398                      in GEOM::GEOM_Object theSubObject )
 399       raises ( SALOME::SALOME_Exception );
 400
 401     /*!
 402      * Cancel a computation.
 403      */
 404     void CancelCompute( in SMESH_Mesh        theMesh,
 405                         in GEOM::GEOM_Object theSubObject );
 406
 407     /*!
 408      * Return true if hypotheses are defined well
 409      */
 410     boolean IsReadyToCompute( in SMESH_Mesh        theMesh,
 411                               in GEOM::GEOM_Object theSubObject )
 412       raises ( SALOME::SALOME_Exception );
 413
 414     /*!
 415      * Evaluates size of prospective mesh on a shape
 416      */
 417     smIdType_array  Evaluate(in SMESH_Mesh        theMesh,
 418                              in GEOM::GEOM_Object theSubObject)
 419       raises ( SALOME::SALOME_Exception );
 420
 421     /*!
 422      * Calculate Mesh as preview till indicated dimension
 423      * First, verify list of hypothesis associated with the Sub-shape.
 424      * Return mesh preview structure
 425      */
 426     MeshPreviewStruct Precompute( in SMESH_Mesh        theMesh,
 427                                   in GEOM::GEOM_Object theSubObject,
 428                                   in Dimension         theDimension,
 429                                   inout long_array    theShapesId )
 430       raises ( SALOME::SALOME_Exception );
 431
 432     /*!
 433      * Return errors of hypotheses definition
 434      * algo_error_array is empty if everything is OK
 435      */
 436     algo_error_array GetAlgoState( in SMESH_Mesh        theMesh,
 437                                    in GEOM::GEOM_Object theSubObject )
 438       raises ( SALOME::SALOME_Exception );
 439
 440     /*!
 441      * Return errors of mesh computation
 442      * compute_error_array is empty if everything is OK
 443      */
 444     compute_error_array GetComputeErrors( in SMESH_Mesh        theMesh,
 445                                           in GEOM::GEOM_Object theSubObject )
 446       raises ( SALOME::SALOME_Exception );
 447
 448     /*!
 449      * Return mesh elements preventing computation of a sub-shape
 450      */
 451     MeshPreviewStruct GetBadInputElements( in SMESH_Mesh theMesh,
 452                                            in short      theSubShapeID )
 453       raises ( SALOME::SALOME_Exception );
 454
 455     /*!
 456      * Create groups of elements preventing computation of a sub-shape
 457      */
 458     SMESH::ListOfGroups MakeGroupsOfBadInputElements( in SMESH_Mesh theMesh,
 459                                                       in short      theSubShapeID,
 460                                                       in string     theGroupName)
 461       raises ( SALOME::SALOME_Exception );
 462
 463     /*!
 464      * Return indices of faces, edges and vertices of given sub-shapes
 465      * within theMainObject
 466      */
 467     long_array GetSubShapesId( in GEOM::GEOM_Object theMainObject,
 468                                in object_array      theListOfSubObjects )
 469        raises ( SALOME::SALOME_Exception );
 470
 471     /*!
 472      * Return geometrical object the given element is built on.
 473      * The returned geometrical object, if not nil, is either found in the
 474      * study or is published by this method with the given name
 475      */
 476     GEOM::GEOM_Object GetGeometryByMeshElement( in SMESH_Mesh theMesh,
 477                                                 in smIdType   theElementID,
 478                                                 in string     theGeomName)
 479       raises ( SALOME::SALOME_Exception );
 480
 481     /*!
 482      * Return geometrical object the given element is built on.
 483      * The returned geometrical object not published in study by this method.
 484      */
 485     GEOM::GEOM_Object FindGeometryByMeshElement( in SMESH_Mesh theMesh,
 486                                                  in smIdType   theElementID)
 487       raises ( SALOME::SALOME_Exception );
 488
 489     /*!
 490      * \brief Return id of object, registered in current study context
 491      *
 492      * Can be used to check if the object was created in the same container, as this engine.
 493      */
 494     long GetObjectId(in Object theObject);
 495
 496     /*!
 497      * \brief Get version of MED format being used.
 498      */
 499     string GetMEDFileVersion();
 500
 501     /*!
 502      * \brief Get MED version of the file by its name.
 503      */
 504     string GetMEDVersion(in string theFileName);
 505
 506     /*!
 507      * \brief Check compatibility of file with MED format being used, for read only.
 508      */
 509     boolean CheckCompatibility(in string theFileName);
 510
 511     /*!
 512      * \brief Check compatibility of file with MED format being used, for append on write.
 513      */
 514     boolean CheckWriteCompatibility(in string theFileName);
 515
 516     /*!
 517      * \brief Get names of meshes defined in file with the specified name.
 518      */
 519     string_array GetMeshNames(in string theFileName);
 520
 521     /*!
 522      * \brief Moves objects to the specified position
 523      *  \param what objects being moved
 524      *  \param where parent object where objects are moved to
 525      *  \param row position in the parent object's children list at which objects are moved
 526      *
 527      * This function is used in the drag-n-drop functionality.
 528      */
 529     void Move( in sobject_list what,
 530                in SALOMEDS::SObject where,
 531                in long row );
 532     /*!
 533      * Returns true if algorithm can be used to mesh a given geometry
 534      *  \param theAlgoType - the algorithm type
 535      *  \param theLibName - a name of the Plug-in library implementing the algorithm
 536      *  \param theShapeObject - the geometry to mesh
 537      *  \param toCheckAll - if \c True, returns \c True if all shapes are meshable,
 538      *         else, returns \c True if at least one shape is meshable
 539      */
 540     boolean IsApplicable( in string             theAlgoType,
 541                           in string             theLibName,
 542                           in GEOM::GEOM_Object  theShapeObject,
 543                           in boolean            toCheckAll );
 544
 545
 546     /*!
 547      * Return indices of elements, which are located inside the sphere
 548      *  \param theSource - mesh, sub-mesh or group
 549      *  \param theElemType - mesh element type
 550      *  \param theX - x coordinate of the center of the sphere
 551      *  \param theY - y coordinate of the center of the sphere
 552      *  \param theZ - y coordinate of the center of the sphere
 553      *  \param theR - radius of the sphere
 554      */
 555     long_array GetInsideSphere( in SMESH_IDSource theSource,
 556                                 in ElementType    theElemType,
 557                                 in double theX,
 558                                 in double theY,
 559                                 in double theZ,
 560                                 in double theR );
 561
 562     /*!
 563      * Return indices of elements, which are located inside the box
 564      *  \param theSource - mesh, sub-mesh or group
 565      *  \param theElemType - mesh element type
 566      *  \param theX1 - x coordinate of the first opposite point
 567      *  \param theY1 - y coordinate of the first opposite point
 568      *  \param theZ1 - y coordinate of the first opposite point
 569      *  \param theX2 - x coordinate of the second opposite point
 570      *  \param theY2 - y coordinate of the second opposite point
 571      *  \param theZ2 - y coordinate of the second opposite point
 572      */
 573     long_array GetInsideBox( in SMESH_IDSource theSource,
 574                              in ElementType    theElemType,
 575                              in double theX1,
 576                              in double theY1,
 577                              in double theZ1,
 578                              in double theX2,
 579                              in double theY2,
 580                              in double theZ2);
 581     /*!
 582      * Return indices of elements, which are located inside the box
 583      *  \param theSource - mesh, sub-mesh or group
 584      *  \param theElemType - mesh element type
 585      *  \param theX - x coordinate of the cented of the bottom face
 586      *  \param theY - y coordinate of the cented of the bottom face
 587      *  \param theZ - y coordinate of the cented of the bottom face
 588      *  \param theDX - x coordinate of the cented of the base vector
 589      *  \param theDY - y coordinate of the cented of the base vector
 590      *  \param theDZ - z coordinate of the cented of the base vector
 591      *  \param theH - height of the cylinder
 592      *  \param theR - radius of the cylinder
 593      */
 594     long_array GetInsideCylinder( in SMESH_IDSource theSource,
 595                                   in ElementType    theElemType,
 596                                   in double theX,
 597                                   in double theY,
 598                                   in double theZ,
 599                                   in double theDX,
 600                                   in double theDY,
 601                                   in double theDZ,
 602                                   in double theH,
 603                                   in double theR );
 604     /*!
 605      * Return indices of elements, which are located inside the geometry
 606      *  \param theSource - mesh, sub-mesh or group
 607      *  \param theElemType - mesh element type
 608      *  \param theGeom - geometrical object
 609      *  \param theTolerance - tolerance for selection.
 610      */
 611     long_array GetInside( in SMESH_IDSource theSource,
 612                           in ElementType    theElemType,
 613                           in GEOM::GEOM_Object theGeom,
 614                           in double theTolerance );
 615
 616     MG_ADAPT CreateMG_ADAPT();
 617     SMESHHOMARD::HOMARD_Gen CreateHOMARD_ADAPT() raises ( SALOME::SALOME_Exception );
 618     //MG_ADAPT_OBJECT Adaptation(in string adaptType);
 619     SALOME::GenericObj Adaptation(in string adaptType) raises ( SALOME::SALOME_Exception );
 620     MG_ADAPT CreateAdaptationHypothesis();
 621   };
 622
 623 };
 624
 625 #endif