idl/SMESH_Mesh.idl

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