idl/SMESH_Mesh.idl

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