idl/SMESH_Mesh.idl

   1 // Copyright (C) 2007-2015  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, 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
  23 //  File   : SMESH_Mesh.idl
  24 //  Author : Paul RASCLE, EDF
  25 //
  26 #ifndef _SMESH_MESH_IDL_
  27 #define _SMESH_MESH_IDL_
  28
  29 #include "SALOME_Exception.idl"
  30 #include "SALOME_GenericObj.idl"
  31 #include "GEOM_Gen.idl"
  32
  33 module SMESH
  34 {
  35   interface SMESH_Hypothesis;
  36   typedef sequence<SMESH_Hypothesis> ListOfHypothesis;
  37   interface SMESH_GroupBase;
  38   typedef sequence<SMESH_GroupBase> ListOfGroups;
  39   interface SMESH_IDSource;
  40   typedef sequence<SMESH_IDSource> ListOfIDSources;
  41
  42   typedef sequence<double    > double_array ;
  43   typedef sequence<long      > long_array ;
  44   typedef sequence<string    > string_array ;
  45   typedef sequence<long_array> array_of_long_array ;
  46
  47   enum log_command
  48     {
  49       ADD_NODE,
  50       ADD_EDGE,
  51       ADD_TRIANGLE,
  52       ADD_QUADRANGLE,
  53       ADD_POLYGON,
  54       ADD_TETRAHEDRON,
  55       ADD_PYRAMID,
  56       ADD_PRISM,
  57       ADD_HEXAHEDRON,
  58       ADD_POLYHEDRON,
  59       REMOVE_NODE,
  60       REMOVE_ELEMENT,
  61       MOVE_NODE,
  62       CHANGE_ELEMENT_NODES,
  63       CHANGE_POLYHEDRON_NODES,
  64       RENUMBER,
  65       CLEAR_MESH,
  66       ADD_QUADEDGE,
  67       ADD_QUADTRIANGLE,
  68       ADD_QUADQUADRANGLE,
  69       ADD_QUADTETRAHEDRON,
  70       ADD_QUADPYRAMID,
  71       ADD_QUADPENTAHEDRON,
  72       ADD_QUADHEXAHEDRON,
  73       ADD_ELEM0D,
  74       ADD_BIQUAD_TRIANGLE,
  75       ADD_BIQUAD_QUADRANGLE,
  76       ADD_TRIQUAD_HEXA,
  77       ADD_HEXAGONAL_PRISM,
  78       ADD_BALL
  79     };
  80
  81   struct log_block
  82   {
  83     long commandType;
  84     long number;
  85     double_array coords;
  86     long_array indexes;
  87   };
  88   typedef sequence<log_block> log_array;
  89
  90   struct PointStruct { double x;
  91                        double y;
  92                        double z; } ;
  93
  94   typedef sequence<PointStruct> nodes_array;
  95
  96   struct DirStruct   { PointStruct PS ; } ;          // analog to OCCT gp_Vec
  97
  98   struct AxisStruct  { double x;
  99                        double y;
 100                        double z;
 101                        double vx;
 102                        double vy;
 103                        double vz; } ;
 104   /*!
 105    * Node location on a shape
 106    */
 107   struct NodePosition {
 108     long             shapeID;
 109     GEOM::shape_type shapeType;
 110     double_array     params; // [U] on EDGE, [U,V] on FACE, [] on the rest shapes
 111   };
 112
 113   /*!
 114    * Element location on a shape
 115    */
 116   struct ElementPosition {
 117     long             shapeID;
 118     GEOM::shape_type shapeType;
 119   };
 120
 121   /*!
 122    * Enumeration for element type, like in SMDS
 123    */
 124   enum ElementType
 125   {
 126     ALL,
 127     NODE,
 128     EDGE,
 129     FACE,
 130     VOLUME,
 131     ELEM0D,
 132     BALL,
 133     NB_ELEMENT_TYPES
 134   };
 135   typedef sequence<ElementType> array_of_ElementType ;
 136
 137   /*!
 138    * Enumeration for element geometry type, like SMDSAbs_GeometryType in SMDSAbs_ElementType.hxx
 139    */
 140   enum GeometryType
 141   {
 142     Geom_POINT,
 143     Geom_EDGE,
 144     Geom_TRIANGLE,
 145     Geom_QUADRANGLE, // when a new GeometryType is added, please
 146     Geom_POLYGON,    // update a corresponding list in SMESH_2smeshpy.cxx, ln 665
 147     Geom_TETRA,
 148     Geom_PYRAMID,
 149     Geom_HEXA,
 150     Geom_PENTA,
 151     Geom_HEXAGONAL_PRISM,
 152     Geom_POLYHEDRA,
 153     Geom_BALL,
 154     Geom_LAST
 155   };
 156
 157   /*!
 158    * ElementOrder points out entities of what order are requested
 159    */
 160   enum ElementOrder {
 161     ORDER_ANY,          /*! entities of any order */
 162     ORDER_LINEAR,       /*! entities of 1st order */
 163     ORDER_QUADRATIC     /*! entities of 2nd order */
 164   };
 165
 166   /*!
 167    * Enumeration of entity type used in mesh info array,
 168    * it should be synchronised with enum SMDSAbs_EntityType
 169    */
 170   enum EntityType
 171   {
 172     Entity_Node,
 173     Entity_0D,
 174     Entity_Edge,
 175     Entity_Quad_Edge,
 176     Entity_Triangle,
 177     Entity_Quad_Triangle,
 178     Entity_BiQuad_Triangle,
 179     Entity_Quadrangle,
 180     Entity_Quad_Quadrangle,
 181     Entity_BiQuad_Quadrangle,
 182     Entity_Polygon,
 183     Entity_Quad_Polygon,
 184     Entity_Tetra,
 185     Entity_Quad_Tetra,
 186     Entity_Pyramid,
 187     Entity_Quad_Pyramid,
 188     Entity_Hexa,
 189     Entity_Quad_Hexa,
 190     Entity_TriQuad_Hexa,
 191     Entity_Penta,
 192     Entity_Quad_Penta,
 193     Entity_Hexagonal_Prism,
 194     Entity_Polyhedra,
 195     Entity_Quad_Polyhedra,
 196     Entity_Ball,
 197     Entity_Last
 198   };
 199
 200   /*!
 201    * Enumeration for hypothesis status (used by AddHypothesis() and RemoveHypothesis() methods)
 202    */
 203   enum Hypothesis_Status // in the order of severity
 204   {
 205     HYP_OK,
 206     HYP_MISSING,      // algo misses a hypothesis
 207     HYP_CONCURENT,    // several applicable hypotheses
 208     HYP_BAD_PARAMETER,// hypothesis has a bad parameter value
 209     HYP_HIDDEN_ALGO,  // an algo is hidden by an upper dim algo generating all-dim elements
 210     HYP_HIDING_ALGO,  // an algo hides lower dim algos by generating all-dim elements
 211     HYP_UNKNOWN_FATAL,//  --- all statuses below should be considered as fatal
 212                       //      for Add/RemoveHypothesis operations
 213     HYP_INCOMPATIBLE, // hypothesis does not fit algo
 214     HYP_NOTCONFORM,   // not conform mesh is produced appling a hypothesis
 215     HYP_ALREADY_EXIST,// such hypothesis already exist
 216     HYP_BAD_DIM,      // bad dimension
 217     HYP_BAD_SUBSHAPE, // shape is neither the main one, nor its sub-shape, nor a group
 218     HYP_BAD_GEOMETRY, // geometry mismatches algorithm's expectation
 219     HYP_NEED_SHAPE,   // algorithm can work on shape only
 220     HYP_INCOMPAT_HYPS // several additional hypotheses are incompatible one with other
 221   };
 222
 223   /*!
 224    * Enumeration for mesh read status (used by SMESH_Gen::CreateMeshesFrom*() methods)
 225    */
 226   enum DriverMED_ReadStatus // in the order of severity
 227   {
 228     DRS_OK,
 229     DRS_EMPTY,          // a file contains no mesh with the given name
 230     DRS_WARN_RENUMBER,  // a MED file has overlapped ranges of element numbers,
 231                         // so the numbers from the file are ignored
 232     DRS_WARN_SKIP_ELEM, // some elements were skipped due to incorrect file data
 233     DRS_WARN_DESCENDING, // some elements were skipped due to descending connectivity
 234     DRS_FAIL            // general failure (exception etc.)
 235   };
 236
 237   /*!
 238    * Enumeration for ExportToMED*()
 239    */
 240   enum MED_VERSION
 241   {
 242     MED_V2_1,
 243     MED_V2_2
 244   };
 245
 246   /*!
 247    * \brief A structure containing information about MED file
 248    */
 249   struct MedFileInfo
 250   {
 251     string fileName; //!< name of file
 252     long   fileSize; //!< size of file
 253     long   major, minor, release; //!< MED file version
 254   };
 255
 256   /*!
 257    * Enumeration for CreateDimGroup()
 258    */
 259   enum NB_COMMON_NODES_ENUM
 260   {
 261     ALL_NODES, MAIN, AT_LEAST_ONE, MAJORITY
 262   };
 263
 264   /*!
 265    * Auxilary flags for advanced extrusion.
 266    * BOUNDARY: create or not boundary for result of extrusion
 267    * SEW:      try to use existing nodes or create new nodes in any case
 268    */
 269   const long EXTRUSION_FLAG_BOUNDARY = 1;
 270   const long EXTRUSION_FLAG_SEW = 2;
 271
 272   /*!
 273    * Structure used in mesh edit preview data (MeshPreviewStruct)
 274    */
 275   struct ElementSubType { ElementType SMDS_ElementType;
 276                           boolean     isPoly;
 277                           long        nbNodesInElement; };
 278
 279   typedef sequence<ElementSubType> types_array;
 280
 281   /*!
 282    * Structure containing mesh edit preview data
 283    */
 284   struct MeshPreviewStruct { nodes_array nodesXYZ;
 285                              long_array  elementConnectivities;
 286                              types_array elementTypes; };
 287
 288   interface SMESH_Mesh;
 289
 290   interface SMESH_IDSource : SALOME::GenericObj
 291   {
 292     /*!
 293      * Returns a sequence of all element IDs
 294      */
 295     long_array GetIDs();
 296
 297     /*!
 298      * Returns number of mesh elements of each \a EntityType
 299      * @return array of number of elements per \a EntityType
 300      */
 301     long_array GetMeshInfo();
 302
 303     /*!
 304      * Returns number of mesh elements of each \a ElementType
 305      * @return array of number of elements per \a ElementType
 306      */
 307     long_array GetNbElementsByType();
 308
 309     /*!
 310      * Returns types of elements it contains.
 311      * It's empty if the SMESH_IDSource contains no IDs
 312      */
 313     array_of_ElementType GetTypes();
 314
 315     /*!
 316      * Returns the mesh
 317      */
 318     SMESH_Mesh GetMesh();
 319
 320     /*!
 321      * Returns false if GetMeshInfo() returns incorrect information that may
 322      * happen if mesh data is not yet fully loaded from the file of study.
 323      */
 324     boolean IsMeshInfoCorrect();
 325
 326     /*!
 327      * Returns mesh unstructed grid information.
 328      */
 329     SALOMEDS::TMPFile GetVtkUgStream();
 330   };
 331
 332   interface SMESH_Group;
 333   interface SMESH_GroupOnGeom;
 334   interface Filter;
 335   interface SMESH_GroupOnFilter;
 336   interface SMESH_subMesh;
 337   interface SMESH_MeshEditor;
 338
 339   typedef sequence<SMESH_subMesh>     submesh_array;
 340   typedef sequence<submesh_array>     submesh_array_array;
 341
 342   interface SMESH_Mesh : SALOME::GenericObj, SMESH_IDSource
 343   {
 344     /*!
 345      * Return true if there is a geometry to be meshed
 346      */
 347     boolean HasShapeToMesh()
 348       raises (SALOME::SALOME_Exception);
 349
 350     /*!
 351      * Get geom shape to mesh. A result sould not be nil. Use HasShapeToMesh()
 352      * to know if a returned shape
 353      */
 354     GEOM::GEOM_Object GetShapeToMesh()
 355       raises (SALOME::SALOME_Exception);
 356
 357     /*!
 358      * Return false if the mesh is not yet fully loaded from the study file
 359      */
 360     boolean IsLoaded()
 361       raises (SALOME::SALOME_Exception);
 362
 363     /*!
 364      * Load full mesh data from the study file
 365      */
 366     void Load()
 367       raises (SALOME::SALOME_Exception);
 368
 369     /*!
 370      * Remove all nodes and elements
 371      */
 372     void Clear()
 373       raises (SALOME::SALOME_Exception);
 374
 375     /*!
 376      *  Get the list of sub-meshes existing in the mesh
 377      */
 378     submesh_array GetSubMeshes()
 379       raises (SALOME::SALOME_Exception);
 380
 381     /*!
 382      * Remove all nodes and elements of submesh
 383      */
 384     void ClearSubMesh(in long ShapeID)
 385       raises (SALOME::SALOME_Exception);
 386
 387     /*!
 388      * Get the subMesh object associated to a Sub-shape. The subMesh object
 389      * gives access to nodes and elements IDs.
 390      * SubMesh will be used instead of Sub-shape in a next idl version to
 391      * adress a specific subMesh...
 392      */
 393     SMESH_subMesh GetSubMesh(in GEOM::GEOM_Object aSubObject, in string name)
 394       raises (SALOME::SALOME_Exception);
 395
 396     /*!
 397      * Remove a submesh
 398      */
 399     void RemoveSubMesh(in SMESH_subMesh aSubMesh)
 400       raises (SALOME::SALOME_Exception);
 401
 402
 403     /*!
 404      * Create a group
 405      */
 406     SMESH_Group CreateGroup( in ElementType elem_type,
 407                              in string      name )
 408       raises (SALOME::SALOME_Exception);
 409
 410     /*!
 411      * Create a group from geometry
 412      */
 413     SMESH_GroupOnGeom CreateGroupFromGEOM( in ElementType       elemType,
 414                                            in string            name,
 415                                            in GEOM::GEOM_Object geomObject )
 416       raises (SALOME::SALOME_Exception);
 417
 418     /*!
 419      * Create a group from filter
 420      */
 421     SMESH_GroupOnFilter CreateGroupFromFilter( in ElementType   elemType,
 422                                                in string        name,
 423                                                in SMESH::Filter filter )
 424       raises (SALOME::SALOME_Exception);
 425
 426     /*!
 427      * Remove a group
 428      */
 429     void RemoveGroup(in SMESH_GroupBase aGroup)
 430       raises (SALOME::SALOME_Exception);
 431
 432     /*!
 433      *  Remove group with its contents
 434      */
 435     void RemoveGroupWithContents( in SMESH_GroupBase aGroup )
 436       raises (SALOME::SALOME_Exception);
 437
 438     /*!
 439      *  Get the list of groups existing in the mesh
 440      */
 441     ListOfGroups GetGroups()
 442       raises (SALOME::SALOME_Exception);
 443
 444     /*!
 445      *  Get number of groups existing in the mesh
 446      */
 447     long NbGroups()
 448       raises (SALOME::SALOME_Exception);
 449
 450     /*!
 451      * Union of two groups
 452      *    New group is created. All mesh elements that are
 453      *    present in initial groups are added to the new one
 454      */
 455     SMESH_Group UnionGroups (in SMESH_GroupBase aGroup1,
 456                              in SMESH_GroupBase aGroup2,
 457                              in string          name )
 458       raises (SALOME::SALOME_Exception);
 459
 460     /*!
 461      * Union of list of groups
 462      * New group is created. All mesh elements that are
 463      * present in initial groups are added to the new one
 464      */
 465     SMESH_Group UnionListOfGroups (in ListOfGroups aListOfGroups,
 466                                    in string       name )
 467       raises (SALOME::SALOME_Exception);
 468
 469     /*!
 470      *  Intersection of two groups
 471      *  New group is created. All mesh elements that are
 472      *  present in both initial groups are added to the new one.
 473      */
 474     SMESH_Group IntersectGroups (in SMESH_GroupBase aGroup1,
 475                                  in SMESH_GroupBase aGroup2,
 476                                  in string          name )
 477       raises (SALOME::SALOME_Exception);
 478
 479     /*!
 480      *  Intersection of list of groups
 481      *  New group is created. All mesh elements that are
 482      *  present in all initial groups simultaneously are added to the new one.
 483      */
 484     SMESH_Group IntersectListOfGroups (in ListOfGroups aListOfGroups,
 485                                        in string       name)
 486       raises (SALOME::SALOME_Exception);
 487
 488     /*!
 489      *  Cut of two groups
 490      *  New group is created. All mesh elements that are present in
 491      *  main group but do not present in tool group are added to the new one
 492      */
 493     SMESH_Group CutGroups (in SMESH_GroupBase aMainGroup,
 494                            in SMESH_GroupBase aToolGroup,
 495                            in string          name )
 496       raises (SALOME::SALOME_Exception);
 497
 498     /*!
 499      *  Cut of lists of groups
 500      *  New group is created. All mesh elements that are present in
 501      *  main groups but do not present in tool groups are added to the new one
 502      */
 503     SMESH_Group CutListOfGroups (in ListOfGroups aMainGroups,
 504                                  in ListOfGroups aToolGroups,
 505                                  in string       name)
 506       raises (SALOME::SALOME_Exception);
 507
 508     /*!
 509      *  Create a group of entities basing on nodes of other groups.
 510      *  \param [in] aListOfGroups - list of either groups, sub-meshes or filters.
 511      *  \param [in] anElemType - a type of elements to include to the new group.
 512      *  \param [in] name - a name of the new group.
 513      *  \param [in] nbCommonNodes - criterion of inclusion of an element to the new group.
 514      *  \param [in] underlyingOnly - if \c True, an element is included to the
 515      *         new group provided that it is based on nodes of an element of
 516      *         \a aListOfGroups
 517      *  \return SMESH_Group - the created group
 518      */
 519     SMESH_Group CreateDimGroup( in ListOfIDSources      aListOfGroups,
 520                                 in ElementType          anElemType,
 521                                 in string               name,
 522                                 in NB_COMMON_NODES_ENUM nbCommonNodes,
 523                                 in boolean              underlyingOnly )
 524       raises (SALOME::SALOME_Exception);
 525
 526     /*!
 527      * Convert group on geometry or on filter into standalone group
 528      */
 529     SMESH_Group ConvertToStandalone( in SMESH_GroupBase theGroupOn )
 530       raises (SALOME::SALOME_Exception);
 531
 532     /*!
 533      * Add hypothesis to the mesh, under a particular sub-shape
 534      * (or the main shape itself)
 535      * This method is only used to prepare the build of the mesh and store
 536      * the algorithms and associated parameters.
 537      * Actual job of meshing the shape is done by SMESH_Gen::Compute()
 538      * @params
 539      * - aSubObject : sub-shape obtained by a shape explode in GEOM
 540      *   (or main shape)
 541      * - anHyp : an hypothesis object
 542      * @return
 543      * - An enum item explaining what's up
 544      * - anErrorText: an optional textual description of a problem (if any)
 545      */
 546     Hypothesis_Status AddHypothesis(in GEOM::GEOM_Object aSubObject,
 547                                     in SMESH_Hypothesis  anHyp,
 548                                     out string           anErrorText)
 549       raises (SALOME::SALOME_Exception);
 550
 551     /*!
 552      * Remove an hypothesis previouly added with AddHypothesis.
 553      */
 554     Hypothesis_Status RemoveHypothesis(in GEOM::GEOM_Object aSubObject,
 555                                        in SMESH_Hypothesis anHyp)
 556       raises (SALOME::SALOME_Exception);
 557
 558     /*!
 559      * Get the list of hypothesis added on a sub-shape
 560      */
 561     ListOfHypothesis GetHypothesisList(in GEOM::GEOM_Object aSubObject)
 562       raises (SALOME::SALOME_Exception);
 563
 564     /*!
 565      * Get the log of nodes and elements added or removed since previous
 566      * clear of the log.
 567      * @params
 568      * - clearAfterGet : log is emptied after Get (safe if concurrents access)
 569      */
 570     log_array GetLog(in boolean clearAfterGet)
 571       raises (SALOME::SALOME_Exception);
 572
 573     /*!
 574      * Clear the log of nodes and elements added or removed since previous
 575      * clear. Must be used immediately after GetLog if clearAfterGet is false.
 576      */
 577     void ClearLog()
 578       raises (SALOME::SALOME_Exception);
 579
 580     /*!
 581      * Toggle auto color mode on the object.
 582      * @params
 583      * - theAutoColor : flag which toggles auto color mode.
 584      */
 585     void SetAutoColor(in boolean theAutoColor)
 586       raises (SALOME::SALOME_Exception);
 587
 588     /*!
 589      * Get flag of object's auto color mode.
 590      */
 591     boolean GetAutoColor()
 592       raises (SALOME::SALOME_Exception);
 593
 594     /*!
 595      * Get the internal Id
 596      */
 597     long GetId();
 598
 599     /*!
 600      * Get the study Id
 601      */
 602     long GetStudyId();
 603
 604     /*!
 605      * Obtain instance of SMESH_MeshEditor
 606      */
 607     SMESH_MeshEditor GetMeshEditor()
 608       raises (SALOME::SALOME_Exception);
 609
 610     /*!
 611      * Return SMESH_MeshEditor that would not modify the mesh but
 612      * fill MeshPreviewStruct
 613      */
 614     SMESH_MeshEditor GetMeshEditPreviewer()
 615       raises (SALOME::SALOME_Exception);
 616
 617     /*!
 618      * Return true if the mesh has been edited since a total re-compute
 619      * and those modifications may prevent successful partial re-compute
 620      */
 621     boolean HasModificationsToDiscard()
 622       raises (SALOME::SALOME_Exception);
 623
 624     /*! Check group names for duplications.
 625      *  Consider maximum group name length stored in MED file.
 626      */
 627     boolean HasDuplicatedGroupNamesMED();
 628
 629     /*!
 630      * Export Mesh to a MED Format file
 631      * @params
 632      * - file : name of the MED file
 633      * - auto_groups : boolean parameter for creating/not creating
 634      *                 the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
 635      *                 the typical use is auto_groups=false.
 636      * - version : defines the version of format of MED file, that will be created
 637      * - overwrite : boolean parameter for overwriting/not overwriting the file, if it exists
 638      * - autoDimension : if @c true, a space dimension of a MED mesh can be either
 639      *         - 1D if all mesh nodes lie on OX coordinate axis, or
 640      *         - 2D if all mesh nodes lie on XOY coordinate plane, or
 641      *         - 3D in the rest cases.
 642      *         If @a autoDimension is @c false, the space dimension is always 3.
 643      */
 644     void ExportToMEDX( in string      file,
 645                        in boolean     auto_groups,
 646                        in MED_VERSION version,
 647                        in boolean     overwrite,
 648                        in boolean     autoDimension) raises (SALOME::SALOME_Exception);
 649
 650     /*!
 651      * Export a [part of] Mesh into a MED file
 652      * @params
 653      * - meshPart : a part of mesh to store
 654      * - file : name of the MED file
 655      * - version : define the version of format of MED file, that will be created
 656      * - overwrite : boolean parameter for overwriting/not overwriting the file, if it exists
 657      * - autoDimension : if @c True, a space dimension for export is defined by mesh
 658      *                 configuration; for example a planar mesh lying on XOY plane
 659      *                 will be exported as a mesh in 2D space.
 660      *                 If @a autoDimension == @c False, the space dimension is 3.
 661      * - fields : list of GEOM fields defined on the shape to mesh.
 662      * - geomAssocFields : each character of this string means a need to export a
 663      *         corresponding field; correspondence between fields and characters is following:
 664      *         - 'v' stands for _vertices_ field;
 665      *         - 'e' stands for _edges_ field;
 666      *         - 'f' stands for _faces_ field;
 667      *         - 's' stands for _solids_ field.
 668      */
 669     void ExportPartToMED( in SMESH_IDSource     meshPart,
 670                           in string             file,
 671                           in boolean            auto_groups,
 672                           in MED_VERSION        version,
 673                           in boolean            overwrite,
 674                           in boolean            autoDimension,
 675                           in GEOM::ListOfFields fields,
 676                           in string             geomAssocFields ) raises (SALOME::SALOME_Exception);
 677
 678     /*!
 679      * Export Mesh to a MED Format file
 680      * Works, just the same as ExportToMEDX, with overwrite parameter equal to true.
 681      * The method is kept in order to support old functionality
 682      */
 683     void ExportToMED( in string file, in boolean auto_groups, in MED_VERSION theVersion )
 684       raises (SALOME::SALOME_Exception);
 685
 686     /*!
 687      * Export Mesh to MED_V2_1 MED format
 688      * Works, just the same as ExportToMEDX with MED_VERSION parameter equal to MED_V2_1
 689      * and overwrite parameter equal to true
 690      * The method is kept in order to support old functionality
 691      */
 692     void ExportMED( in string file, in boolean auto_groups )
 693       raises (SALOME::SALOME_Exception);
 694
 695     /*!
 696      * Export Mesh to SAUV formatted file
 697      * Write a temporary med file and use med2sauv
 698      */
 699     void ExportSAUV( in string file, in boolean auto_groups )
 700       raises (SALOME::SALOME_Exception);
 701
 702     /*!
 703      * Return string representation of a MED file version comprising nbDigits
 704      */
 705     string GetVersionString(in MED_VERSION version, in short nbDigits);
 706
 707     /*!
 708      * Export Mesh to different Formats
 709      * (UNV supported version is I-DEAS 10)
 710      */
 711     void ExportDAT( in string file ) raises (SALOME::SALOME_Exception);
 712     void ExportUNV( in string file ) raises (SALOME::SALOME_Exception);
 713     void ExportSTL( in string  file,
 714                     in boolean isascii ) raises (SALOME::SALOME_Exception);
 715     void ExportCGNS( in SMESH_IDSource meshPart,
 716                      in string         file,
 717                      in boolean        overwrite ) raises (SALOME::SALOME_Exception);
 718     void ExportGMF( in SMESH_IDSource  meshPart,
 719                     in string          file,
 720                     in boolean         withRequiredGroups) raises (SALOME::SALOME_Exception);
 721     void ExportPartToDAT( in SMESH_IDSource meshPart,
 722                           in string         file ) raises (SALOME::SALOME_Exception);
 723     void ExportPartToUNV( in SMESH_IDSource meshPart,
 724                           in string         file ) raises (SALOME::SALOME_Exception);
 725     void ExportPartToSTL( in SMESH_IDSource meshPart,
 726                           in string         file,
 727                           in boolean        isascii ) raises (SALOME::SALOME_Exception);
 728     /*!
 729      * Return computation progress [0.,1]
 730      */
 731     double GetComputeProgress();
 732
 733     /*!
 734      * Get informations about mesh contents
 735      */
 736     long NbNodes()
 737       raises (SALOME::SALOME_Exception);
 738
 739     long NbElements()
 740       raises (SALOME::SALOME_Exception);
 741
 742     long Nb0DElements()
 743       raises (SALOME::SALOME_Exception);
 744
 745     long NbBalls()
 746       raises (SALOME::SALOME_Exception);
 747
 748     long NbEdges()
 749       raises (SALOME::SALOME_Exception);
 750
 751     long NbEdgesOfOrder(in ElementOrder order)
 752       raises (SALOME::SALOME_Exception);
 753
 754     long NbFaces()
 755       raises (SALOME::SALOME_Exception);
 756
 757     long NbFacesOfOrder(in ElementOrder order)
 758       raises (SALOME::SALOME_Exception);
 759
 760     long NbTriangles()
 761       raises (SALOME::SALOME_Exception);
 762
 763     long NbTrianglesOfOrder(in ElementOrder order)
 764       raises (SALOME::SALOME_Exception);
 765
 766     long NbBiQuadTriangles()
 767       raises (SALOME::SALOME_Exception);
 768
 769     long NbQuadrangles()
 770       raises (SALOME::SALOME_Exception);
 771
 772     long NbQuadranglesOfOrder(in ElementOrder order)
 773       raises (SALOME::SALOME_Exception);
 774
 775     long NbBiQuadQuadrangles()
 776       raises (SALOME::SALOME_Exception);
 777
 778     long NbPolygons()
 779       raises (SALOME::SALOME_Exception);
 780
 781     long NbVolumes()
 782       raises (SALOME::SALOME_Exception);
 783
 784     long NbVolumesOfOrder(in ElementOrder order)
 785       raises (SALOME::SALOME_Exception);
 786
 787     long NbTetras()
 788       raises (SALOME::SALOME_Exception);
 789
 790     long NbTetrasOfOrder(in ElementOrder order)
 791       raises (SALOME::SALOME_Exception);
 792
 793     long NbHexas()
 794       raises (SALOME::SALOME_Exception);
 795
 796     long NbHexasOfOrder(in ElementOrder order)
 797       raises (SALOME::SALOME_Exception);
 798
 799     long NbTriQuadraticHexas()
 800       raises (SALOME::SALOME_Exception);
 801
 802     long NbPyramids()
 803       raises (SALOME::SALOME_Exception);
 804
 805     long NbPyramidsOfOrder(in ElementOrder order)
 806       raises (SALOME::SALOME_Exception);
 807
 808     long NbPrisms()
 809       raises (SALOME::SALOME_Exception);
 810
 811     long NbPrismsOfOrder(in ElementOrder order)
 812       raises (SALOME::SALOME_Exception);
 813
 814     long NbHexagonalPrisms()
 815       raises (SALOME::SALOME_Exception);
 816
 817     long NbPolyhedrons()
 818       raises (SALOME::SALOME_Exception);
 819
 820     long NbSubMesh()
 821       raises (SALOME::SALOME_Exception);
 822
 823     long_array GetElementsId()
 824       raises (SALOME::SALOME_Exception);
 825
 826     long_array GetElementsByType( in ElementType theType )
 827       raises (SALOME::SALOME_Exception);
 828
 829     long_array GetNodesId()
 830       raises (SALOME::SALOME_Exception);
 831
 832     /*!
 833      * Returns type of mesh element
 834      */
 835     ElementType GetElementType( in long id, in boolean iselem )
 836       raises (SALOME::SALOME_Exception);
 837
 838     EntityType GetElementGeomType( in long id )
 839       raises (SALOME::SALOME_Exception);
 840
 841     GeometryType GetElementShape( in long id )
 842       raises (SALOME::SALOME_Exception);
 843
 844     long_array GetSubMeshElementsId(in long ShapeID)
 845       raises (SALOME::SALOME_Exception);
 846
 847     long_array GetSubMeshNodesId(in long ShapeID, in boolean all )
 848       raises (SALOME::SALOME_Exception);
 849
 850     ElementType GetSubMeshElementType(in long ShapeID)
 851       raises (SALOME::SALOME_Exception);
 852
 853
 854     /*!
 855      * Methods to set meshing order of submeshes
 856      */
 857
 858     /*!
 859      * \brief Return \c true if a meshing order not yet set for a concurrent sub-mesh
 860      */
 861     boolean IsUnorderedSubMesh(in long submeshID);
 862
 863     /*!
 864      * \brief Return submesh objects list in meshing order
 865      */
 866     submesh_array_array GetMeshOrder();
 867
 868     /*!
 869      * \brief Set submesh object order
 870      */
 871     boolean SetMeshOrder(in submesh_array_array theSubMeshArray);
 872
 873
 874     /*!
 875      * Get mesh description
 876      */
 877     string Dump();
 878
 879     /*!
 880      * Get mesh pointer
 881      */
 882     long long GetMeshPtr();
 883
 884     /*!
 885      * Get XYZ coordinates of node as list of double
 886      * If there is not node for given ID - returns empty list
 887      */
 888     double_array GetNodeXYZ(in long id);
 889
 890     /*!
 891      * For given node returns list of IDs of inverse elements
 892      * If there is not node for given ID - returns empty list
 893      */
 894     long_array GetNodeInverseElements(in long id);
 895
 896     /*!
 897      * \brief Return position of a node on shape
 898      */
 899     NodePosition GetNodePosition(in long NodeID);
 900
 901     /*!
 902      * \brief Return position of an element on shape
 903      */
 904     ElementPosition GetElementPosition(in long ElemID);
 905
 906     /*!
 907      * If given element is node returns IDs of shape from position
 908      * If there is not node for given ID - returns -1
 909      */
 910     long GetShapeID(in long id);
 911
 912     /*!
 913      * For given element returns ID of result shape after
 914      * ::FindShape() from SMESH_MeshEditor
 915      * If there is not element for given ID - returns -1
 916      */
 917     long GetShapeIDForElem(in long id);
 918
 919     /*!
 920      * Returns number of nodes for given element
 921      * If there is not element for given ID - returns -1
 922      */
 923     long GetElemNbNodes(in long id);
 924
 925     /*!
 926      * Returns IDs of nodes of given element
 927      */
 928     long_array GetElemNodes(in long id);
 929
 930     /*!
 931      * Returns ID of node by given index for given element
 932      * If there is not element for given ID - returns -1
 933      * If there is not node for given index - returns -2
 934      */
 935     long GetElemNode(in long id, in long index);
 936
 937     /*!
 938      * Returns true if given node is medium node
 939      * in given quadratic element
 940      */
 941     boolean IsMediumNode(in long ide, in long idn);
 942
 943     /*!
 944      * Returns true if given node is medium node
 945      * in one of quadratic elements
 946      */
 947     boolean IsMediumNodeOfAnyElem(in long idn, in ElementType elem_type);
 948
 949     /*!
 950      * Returns number of edges for given element
 951      */
 952     long ElemNbEdges(in long id);
 953
 954     /*!
 955      * Returns number of faces for given element
 956      */
 957     long ElemNbFaces(in long id);
 958
 959     /*!
 960      * Returns nodes of given face (counted from zero) for given volumic element.
 961      */
 962     long_array GetElemFaceNodes(in long elemId, in short faceIndex);
 963
 964     /*!
 965      * Returns three components of normal of given mesh face (or an empty array in KO case)
 966      */
 967     double_array GetFaceNormal(in long faceId, in boolean normalized);
 968
 969     /*!
 970      * Returns an element based on all given nodes.
 971      */
 972     long FindElementByNodes(in long_array nodes);
 973
 974     /*!
 975      * Returns true if given element is polygon
 976      */
 977     boolean IsPoly(in long id);
 978
 979     /*!
 980      * Returns true if given element is quadratic
 981      */
 982     boolean IsQuadratic(in long id);
 983
 984     /*!
 985      * Returns diameter of a ball discrete element or zero in case of an invalid \a id
 986      */
 987     double GetBallDiameter(in long id);
 988
 989     /*!
 990      * Returns XYZ coordinates of bary center for given element
 991      * as list of double
 992      * If there is not element for given ID - returns empty list
 993      */
 994     double_array BaryCenter(in long id);
 995
 996     /*! Gets information about imported MED file */
 997     MedFileInfo GetMEDFileInfo();
 998
 999     /*!
1000      *  Sets list of notebook variables used for Mesh operations separated by ":" symbol
1001      *  \param theParameters is a string containing the notebook variables
1002      */
1003     void SetParameters (in string theParameters);
1004
1005     /*!
1006      *  Returns list of notebook variables used for Mesh operations separated by ":" symbol
1007      */
1008     string GetParameters();
1009
1010     /*!
1011      *  Returns list of notebook variables used for last Mesh operation
1012      */
1013     string_array GetLastParameters();
1014   };
1015
1016   interface SMESH_subMesh : SALOME::GenericObj, SMESH_IDSource
1017   {
1018     /*!
1019      *
1020      */
1021     long GetNumberOfElements()
1022       raises (SALOME::SALOME_Exception);
1023
1024     /*!
1025      *
1026      */
1027     long GetNumberOfNodes( in boolean all )
1028       raises (SALOME::SALOME_Exception);
1029
1030     /*!
1031      *
1032      */
1033     long_array GetElementsId()
1034       raises (SALOME::SALOME_Exception);
1035
1036     /*!
1037      *
1038      */
1039     long_array GetElementsByType( in ElementType theType )
1040       raises (SALOME::SALOME_Exception);
1041
1042     /*!
1043      * Return type of submesh element
1044      */
1045     ElementType GetElementType( in long id, in boolean iselem )
1046       raises (SALOME::SALOME_Exception);
1047
1048     /*!
1049      *
1050      */
1051     long_array GetNodesId()
1052       raises (SALOME::SALOME_Exception);
1053
1054     /*!
1055      * Get geom shape the submesh is dedicated to
1056      */
1057     GEOM::GEOM_Object GetSubShape()
1058       raises (SALOME::SALOME_Exception);
1059
1060     /*!
1061      * Get SMESH_Mesh which stores nodes coordinates & elements definition
1062      */
1063     SMESH_Mesh GetFather()
1064       raises (SALOME::SALOME_Exception);
1065
1066     /*!
1067      * Get the internal Id
1068      */
1069     long GetId();
1070   };
1071
1072 };
1073
1074 #endif