idl/SMESH_Mesh.idl

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