idl/SMESH_Mesh.idl

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