SMESH_Mesh.idl

Go to the documentation of this file.

// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//

//  File   : SMESH_Mesh.idl
//  Author : Paul RASCLE, EDF
//
#ifndef _SMESH_MESH_IDL_
#define _SMESH_MESH_IDL_

#include "SALOME_Exception.idl"
#include "SALOME_GenericObj.idl"
#include "GEOM_Gen.idl"

module SMESH
{
  interface SMESH_Hypothesis;
  typedef sequence<SMESH_Hypothesis> ListOfHypothesis;
  interface SMESH_GroupBase;
  typedef sequence<SMESH_GroupBase> ListOfGroups;
  interface SMESH_IDSource;
  typedef sequence<SMESH_IDSource> ListOfIDSources;

  typedef sequence<double    > double_array ;
  typedef sequence<long      > long_array ;
  typedef sequence<string    > string_array ;
  typedef sequence<long_array> array_of_long_array ;

  enum log_command
    {
      ADD_NODE,
      ADD_EDGE,
      ADD_TRIANGLE,
      ADD_QUADRANGLE,
      ADD_POLYGON,
      ADD_TETRAHEDRON,
      ADD_PYRAMID,
      ADD_PRISM,
      ADD_HEXAHEDRON,
      ADD_POLYHEDRON,
      REMOVE_NODE,
      REMOVE_ELEMENT,
      MOVE_NODE,
      CHANGE_ELEMENT_NODES,
      CHANGE_POLYHEDRON_NODES,
      RENUMBER,
      CLEAR_MESH,
      ADD_QUADEDGE,
      ADD_QUADTRIANGLE,
      ADD_QUADQUADRANGLE,
      ADD_QUADPOLYGON,
      ADD_QUADTETRAHEDRON,
      ADD_QUADPYRAMID,
      ADD_QUADPENTAHEDRON,
      ADD_QUADHEXAHEDRON,
      ADD_ELEM0D,
      ADD_BIQUAD_TRIANGLE,
      ADD_BIQUAD_QUADRANGLE,
      ADD_TRIQUAD_HEXA,
      ADD_HEXAGONAL_PRISM,
      ADD_BALL
    };

  struct log_block
  {
    long commandType;
    long number;
    double_array coords;
    long_array indexes;
  };
  typedef sequence<log_block> log_array;

  struct PointStruct { double x;
                       double y;
                       double z; };

  typedef sequence<PointStruct> nodes_array;

  struct DirStruct   { PointStruct PS; };          // analog to OCCT gp_Vec

  struct AxisStruct  { double x;
                       double y;
                       double z;
                       double vx;
                       double vy;
                       double vz; };
  struct NodePosition {
    long             shapeID;
    GEOM::shape_type shapeType;
    double_array     params; // [U] on EDGE, [U,V] on FACE, [] on the rest shapes
  };

  struct ElementPosition {
    long             shapeID;
    GEOM::shape_type shapeType;
  };

  enum ElementType
  {
    ALL,
    NODE,
    EDGE,
    FACE,
    VOLUME,
    ELEM0D,
    BALL,
    NB_ELEMENT_TYPES
  };
  typedef sequence<ElementType> array_of_ElementType;

  enum GeometryType
  {
    Geom_POINT,
    Geom_EDGE,
    Geom_TRIANGLE,
    Geom_QUADRANGLE, // when a new GeometryType is added, please
    Geom_POLYGON,    // update a corresponding list in SMESH_2smeshpy.cxx, ln 665
    Geom_TETRA,
    Geom_PYRAMID,
    Geom_HEXA,
    Geom_PENTA,
    Geom_HEXAGONAL_PRISM,
    Geom_POLYHEDRA,
    Geom_BALL,
    Geom_LAST
  };
  
  enum ElementOrder {
    ORDER_ANY,          
    ORDER_LINEAR,       
    ORDER_QUADRATIC     
  };

  enum EntityType
  {
    Entity_Node,
    Entity_0D,
    Entity_Edge,
    Entity_Quad_Edge,
    Entity_Triangle,
    Entity_Quad_Triangle,
    Entity_BiQuad_Triangle,
    Entity_Quadrangle,
    Entity_Quad_Quadrangle,
    Entity_BiQuad_Quadrangle,
    Entity_Polygon,
    Entity_Quad_Polygon,
    Entity_Tetra,
    Entity_Quad_Tetra,
    Entity_Pyramid,
    Entity_Quad_Pyramid,
    Entity_Hexa,
    Entity_Quad_Hexa,
    Entity_TriQuad_Hexa,
    Entity_Penta,
    Entity_Quad_Penta,
    Entity_Hexagonal_Prism,
    Entity_Polyhedra,
    Entity_Quad_Polyhedra,
    Entity_Ball,
    Entity_Last
  };

  enum Hypothesis_Status // in the order of severity
  {
    HYP_OK,
    HYP_MISSING,      // algo misses a hypothesis
    HYP_CONCURENT,    // several applicable hypotheses
    HYP_BAD_PARAMETER,// hypothesis has a bad parameter value
    HYP_HIDDEN_ALGO,  // an algo is hidden by an upper dim algo generating all-dim elements
    HYP_HIDING_ALGO,  // an algo hides lower dim algos by generating all-dim elements
    HYP_UNKNOWN_FATAL,//  --- all statuses below should be considered as fatal
                      //      for Add/RemoveHypothesis operations
    HYP_INCOMPATIBLE, // hypothesis does not fit algo
    HYP_NOTCONFORM,   // not conform mesh is produced appling a hypothesis
    HYP_ALREADY_EXIST,// such hypothesis already exist
    HYP_BAD_DIM,      // bad dimension
    HYP_BAD_SUBSHAPE, // shape is neither the main one, nor its sub-shape, nor a group
    HYP_BAD_GEOMETRY, // geometry mismatches algorithm's expectation
    HYP_NEED_SHAPE,   // algorithm can work on shape only
    HYP_INCOMPAT_HYPS // several additional hypotheses are incompatible one with other
  };

  enum DriverMED_ReadStatus // in the order of severity
  {
    DRS_OK,
    DRS_EMPTY,          // a file contains no mesh with the given name
    DRS_WARN_RENUMBER,  // a MED file has overlapped ranges of element numbers,
                        // so the numbers from the file are ignored
    DRS_WARN_SKIP_ELEM, // some elements were skipped due to incorrect file data
    DRS_WARN_DESCENDING, // some elements were skipped due to descending connectivity
    DRS_FAIL            // general failure (exception etc.)
  };

  enum MED_VERSION
  {
    MED_V2_1,
    MED_V2_2
  };

  struct MedFileInfo
  {
    string fileName; 
    long   fileSize; 
    long   major, minor, release; 
  };

  enum NB_COMMON_NODES_ENUM
  {
    ALL_NODES, MAIN, AT_LEAST_ONE, MAJORITY
  };

  const long EXTRUSION_FLAG_BOUNDARY = 1;
  const long EXTRUSION_FLAG_SEW = 2;
  
  struct ElementSubType { ElementType SMDS_ElementType;
                          boolean     isPoly;
                          long        nbNodesInElement; };

  typedef sequence<ElementSubType> types_array;

  struct MeshPreviewStruct { nodes_array nodesXYZ;
                             long_array  elementConnectivities;
                             types_array elementTypes; };

  interface SMESH_Mesh;

  interface SMESH_IDSource : SALOME::GenericObj
  {
    long_array GetIDs();

    long_array GetMeshInfo();

    long_array GetNbElementsByType();

    array_of_ElementType GetTypes();

    SMESH_Mesh GetMesh();

    boolean IsMeshInfoCorrect();

    SALOMEDS::TMPFile GetVtkUgStream();
  };

  interface SMESH_Group;
  interface SMESH_GroupOnGeom;
  interface Filter;
  interface SMESH_GroupOnFilter;
  interface SMESH_subMesh;
  interface SMESH_MeshEditor;

  typedef sequence<SMESH_subMesh>     submesh_array;
  typedef sequence<submesh_array>     submesh_array_array;

  interface SMESH_Mesh : SALOME::GenericObj, SMESH_IDSource
  {
    boolean HasShapeToMesh()
      raises (SALOME::SALOME_Exception);

    GEOM::GEOM_Object GetShapeToMesh()
      raises (SALOME::SALOME_Exception);

    boolean IsLoaded()
      raises (SALOME::SALOME_Exception);

    void Load()
      raises (SALOME::SALOME_Exception);

    void Clear()
      raises (SALOME::SALOME_Exception);

    submesh_array GetSubMeshes()
      raises (SALOME::SALOME_Exception);

    void ClearSubMesh(in long ShapeID)
      raises (SALOME::SALOME_Exception);

    SMESH_subMesh GetSubMesh(in GEOM::GEOM_Object aSubObject, in string name)
      raises (SALOME::SALOME_Exception);

    void RemoveSubMesh(in SMESH_subMesh aSubMesh)
      raises (SALOME::SALOME_Exception);


    SMESH_Group CreateGroup( in ElementType elem_type,
                             in string      name )
      raises (SALOME::SALOME_Exception);

    SMESH_GroupOnGeom CreateGroupFromGEOM( in ElementType       elemType,
                                           in string            name,
                                           in GEOM::GEOM_Object geomObject )
      raises (SALOME::SALOME_Exception);

    SMESH_GroupOnFilter CreateGroupFromFilter( in ElementType   elemType,
                                               in string        name,
                                               in SMESH::Filter filter )
      raises (SALOME::SALOME_Exception);

    void RemoveGroup(in SMESH_GroupBase aGroup)
      raises (SALOME::SALOME_Exception);

    void RemoveGroupWithContents( in SMESH_GroupBase aGroup )
      raises (SALOME::SALOME_Exception);

    ListOfGroups GetGroups()
      raises (SALOME::SALOME_Exception);

    long NbGroups()
      raises (SALOME::SALOME_Exception);

    SMESH_Group UnionGroups (in SMESH_GroupBase aGroup1,
                             in SMESH_GroupBase aGroup2,
                             in string          name )
      raises (SALOME::SALOME_Exception);
      
    SMESH_Group UnionListOfGroups (in ListOfGroups aListOfGroups,
                                   in string       name )
      raises (SALOME::SALOME_Exception);

    SMESH_Group IntersectGroups (in SMESH_GroupBase aGroup1,
                                 in SMESH_GroupBase aGroup2,
                                 in string          name )
      raises (SALOME::SALOME_Exception);
      
    SMESH_Group IntersectListOfGroups (in ListOfGroups aListOfGroups,
                                       in string       name)
      raises (SALOME::SALOME_Exception);

    SMESH_Group CutGroups (in SMESH_GroupBase aMainGroup,
                           in SMESH_GroupBase aToolGroup,
                           in string          name )
      raises (SALOME::SALOME_Exception);
      
    SMESH_Group CutListOfGroups (in ListOfGroups aMainGroups,
                                 in ListOfGroups aToolGroups,
                                 in string       name)
      raises (SALOME::SALOME_Exception);
      
    SMESH_Group CreateDimGroup( in ListOfIDSources      aListOfGroups,
                                in ElementType          anElemType,
                                in string               name,
                                in NB_COMMON_NODES_ENUM nbCommonNodes,
                                in boolean              underlyingOnly )
      raises (SALOME::SALOME_Exception);

    SMESH_Group ConvertToStandalone( in SMESH_GroupBase theGroupOn )
      raises (SALOME::SALOME_Exception);

    Hypothesis_Status AddHypothesis(in GEOM::GEOM_Object aSubObject,
                                    in SMESH_Hypothesis  anHyp,
                                    out string           anErrorText)
      raises (SALOME::SALOME_Exception);

    Hypothesis_Status RemoveHypothesis(in GEOM::GEOM_Object aSubObject,
                                       in SMESH_Hypothesis anHyp)
      raises (SALOME::SALOME_Exception);

    ListOfHypothesis GetHypothesisList(in GEOM::GEOM_Object aSubObject)
      raises (SALOME::SALOME_Exception);

    log_array GetLog(in boolean clearAfterGet)
      raises (SALOME::SALOME_Exception);

    void ClearLog()
      raises (SALOME::SALOME_Exception);

    void SetAutoColor(in boolean theAutoColor)
      raises (SALOME::SALOME_Exception);

    boolean GetAutoColor()
      raises (SALOME::SALOME_Exception);

    long GetId();

    long GetStudyId();

    SMESH_MeshEditor GetMeshEditor()
      raises (SALOME::SALOME_Exception);

    SMESH_MeshEditor GetMeshEditPreviewer()
      raises (SALOME::SALOME_Exception);

    boolean HasModificationsToDiscard()
      raises (SALOME::SALOME_Exception);

    boolean HasDuplicatedGroupNamesMED();

    void ExportToMEDX( in string      file, 
                       in boolean     auto_groups, 
                       in MED_VERSION version, 
                       in boolean     overwrite,
                       in boolean     autoDimension) raises (SALOME::SALOME_Exception);

    void ExportPartToMED( in SMESH_IDSource     meshPart,
                          in string             file,
                          in boolean            auto_groups,
                          in MED_VERSION        version,
                          in boolean            overwrite,
                          in boolean            autoDimension,
                          in GEOM::ListOfFields fields,
                          in string             geomAssocFields ) raises (SALOME::SALOME_Exception);

    void ExportToMED( in string file, in boolean auto_groups, in MED_VERSION theVersion )
      raises (SALOME::SALOME_Exception);

    void ExportMED( in string file, in boolean auto_groups )
      raises (SALOME::SALOME_Exception);

    void ExportSAUV( in string file, in boolean auto_groups )
      raises (SALOME::SALOME_Exception);

    string GetVersionString(in MED_VERSION version, in short nbDigits);

    void ExportDAT( in string file ) raises (SALOME::SALOME_Exception);
    void ExportUNV( in string file ) raises (SALOME::SALOME_Exception);
    void ExportSTL( in string  file,
                    in boolean isascii ) raises (SALOME::SALOME_Exception);
    void ExportCGNS( in SMESH_IDSource meshPart, 
                     in string         file,
                     in boolean        overwrite ) raises (SALOME::SALOME_Exception);
    void ExportGMF( in SMESH_IDSource  meshPart, 
                    in string          file,
                    in boolean         withRequiredGroups) raises (SALOME::SALOME_Exception);
    void ExportPartToDAT( in SMESH_IDSource meshPart, 
                          in string         file ) raises (SALOME::SALOME_Exception);
    void ExportPartToUNV( in SMESH_IDSource meshPart, 
                          in string         file ) raises (SALOME::SALOME_Exception);
    void ExportPartToSTL( in SMESH_IDSource meshPart,
                          in string         file,
                          in boolean        isascii ) raises (SALOME::SALOME_Exception);
    double GetComputeProgress();

    long NbNodes()
      raises (SALOME::SALOME_Exception);

    long NbElements()
      raises (SALOME::SALOME_Exception);

    long Nb0DElements()
      raises (SALOME::SALOME_Exception);

    long NbBalls()
      raises (SALOME::SALOME_Exception);

    long NbEdges()
      raises (SALOME::SALOME_Exception);

    long NbEdgesOfOrder(in ElementOrder order)
      raises (SALOME::SALOME_Exception);

    long NbFaces()
      raises (SALOME::SALOME_Exception);

    long NbFacesOfOrder(in ElementOrder order)
      raises (SALOME::SALOME_Exception);

    long NbTriangles()
      raises (SALOME::SALOME_Exception);

    long NbTrianglesOfOrder(in ElementOrder order)
      raises (SALOME::SALOME_Exception);

    long NbBiQuadTriangles()
      raises (SALOME::SALOME_Exception);

    long NbQuadrangles()
      raises (SALOME::SALOME_Exception);

    long NbQuadranglesOfOrder(in ElementOrder order)
      raises (SALOME::SALOME_Exception);

    long NbBiQuadQuadrangles()
      raises (SALOME::SALOME_Exception);

    long NbPolygons()
      raises (SALOME::SALOME_Exception);

    long NbPolygonsOfOrder(in ElementOrder order)
      raises (SALOME::SALOME_Exception);

    long NbVolumes()
      raises (SALOME::SALOME_Exception);

    long NbVolumesOfOrder(in ElementOrder order)
      raises (SALOME::SALOME_Exception);

    long NbTetras()
      raises (SALOME::SALOME_Exception);

    long NbTetrasOfOrder(in ElementOrder order)
      raises (SALOME::SALOME_Exception);

    long NbHexas()
      raises (SALOME::SALOME_Exception);

    long NbHexasOfOrder(in ElementOrder order)
      raises (SALOME::SALOME_Exception);

    long NbTriQuadraticHexas()
      raises (SALOME::SALOME_Exception);

    long NbPyramids()
      raises (SALOME::SALOME_Exception);

    long NbPyramidsOfOrder(in ElementOrder order)
      raises (SALOME::SALOME_Exception);

    long NbPrisms()
      raises (SALOME::SALOME_Exception);

    long NbPrismsOfOrder(in ElementOrder order)
      raises (SALOME::SALOME_Exception);

    long NbHexagonalPrisms()
      raises (SALOME::SALOME_Exception);

    long NbPolyhedrons()
      raises (SALOME::SALOME_Exception);

    long NbSubMesh()
      raises (SALOME::SALOME_Exception);

    long_array GetElementsId()
      raises (SALOME::SALOME_Exception);

    long_array GetElementsByType( in ElementType theType )
      raises (SALOME::SALOME_Exception);

    long_array GetNodesId()
      raises (SALOME::SALOME_Exception);
    
    ElementType GetElementType( in long id, in boolean iselem )
      raises (SALOME::SALOME_Exception);

    EntityType GetElementGeomType( in long id )
      raises (SALOME::SALOME_Exception);

    GeometryType GetElementShape( in long id )
      raises (SALOME::SALOME_Exception);

    long_array GetSubMeshElementsId(in long ShapeID)
      raises (SALOME::SALOME_Exception);

    long_array GetSubMeshNodesId(in long ShapeID, in boolean all )
      raises (SALOME::SALOME_Exception);
    
    ElementType GetSubMeshElementType(in long ShapeID)
      raises (SALOME::SALOME_Exception);


    boolean IsUnorderedSubMesh(in long submeshID);

    submesh_array_array GetMeshOrder();

    boolean SetMeshOrder(in submesh_array_array theSubMeshArray);


    string Dump();

    long long GetMeshPtr();

    double_array GetNodeXYZ(in long id);

    long_array GetNodeInverseElements(in long id);

    NodePosition GetNodePosition(in long NodeID);

    ElementPosition GetElementPosition(in long ElemID);

    long GetShapeID(in long id);

    long GetShapeIDForElem(in long id);

    long GetElemNbNodes(in long id);

    long_array GetElemNodes(in long id);

    long GetElemNode(in long id, in long index);

    boolean IsMediumNode(in long ide, in long idn);

    boolean IsMediumNodeOfAnyElem(in long idn, in ElementType elem_type);

    long ElemNbEdges(in long id);

    long ElemNbFaces(in long id);

    long_array GetElemFaceNodes(in long elemId, in short faceIndex);

    double_array GetFaceNormal(in long faceId, in boolean normalized);

    long FindElementByNodes(in long_array nodes);

    boolean IsPoly(in long id);

    boolean IsQuadratic(in long id);

    double GetBallDiameter(in long id);

    double_array BaryCenter(in long id);

    MedFileInfo GetMEDFileInfo();

    void SetParameters (in string theParameters);

    string GetParameters();

    string_array GetLastParameters();
  };

  interface SMESH_subMesh : SALOME::GenericObj, SMESH_IDSource
  {
    long GetNumberOfElements()
      raises (SALOME::SALOME_Exception);

    long GetNumberOfNodes( in boolean all )
      raises (SALOME::SALOME_Exception);

    long_array GetElementsId()
      raises (SALOME::SALOME_Exception);

    long_array GetElementsByType( in ElementType theType )
      raises (SALOME::SALOME_Exception);
    
    ElementType GetElementType( in long id, in boolean iselem )
      raises (SALOME::SALOME_Exception);

    long_array GetNodesId()
      raises (SALOME::SALOME_Exception);

    GEOM::GEOM_Object GetSubShape()
      raises (SALOME::SALOME_Exception);

    SMESH_Mesh GetFather()
      raises (SALOME::SALOME_Exception);

    long GetId();
  };

};

#endif