idl/SMESH_Mesh.idl

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