idl/SMESH_Mesh.idl

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