idl/SMESH_Mesh.idl

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