SMESH_Gen.idl

Go to the documentation of this file.

// Copyright (C) 2007-2023  CEA, EDF, 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_Gen.idl
//  Author : Paul RASCLE, EDF
 
#ifndef _SMESH_GEN_IDL_
#define _SMESH_GEN_IDL_
 
#include "SALOME_Exception.idl"
#include "SALOME_Component.idl"
#include "SALOMEDS.idl"
 
#include "GEOM_Gen.idl"
 
#include "SMESH_Mesh.idl"
#include "SMESH_Hypothesis.idl"
#include "SMESH_smIdType.idl"
 
module SMESHHOMARD
{
  interface HOMARD_Gen;
};
 
module SMESH
{
  typedef sequence<SALOMEDS::SObject> sobject_list;
  typedef sequence<GEOM::GEOM_Object> object_array;
  typedef sequence<SMESH_Mesh>        mesh_array;
 
  interface FilterManager;
  interface SMESH_Pattern;
  interface Measurements;
  interface MG_ADAPT;
  interface MG_ADAPT_OBJECT;
 
  // Top level
  const long Tag_HypothesisRoot = 1; // hypotheses root
  const long Tag_AlgorithmsRoot = 2; // algorithms root
  const long Tag_FirstMeshRoot  = 3; // first mesh root
  // Mesh/Submesh
  const long Tag_RefOnShape             = 1; // references to shape
  const long Tag_RefOnAppliedHypothesis = 2; // applied hypotheses root
  const long Tag_RefOnAppliedAlgorithms = 3; // applied algorithms root
  // Mesh only: sub-meshes roots by type
  const long Tag_FirstSubMesh           =  4;
  const long Tag_SubMeshOnVertex        =  4;
  const long Tag_SubMeshOnEdge          =  5;
  const long Tag_SubMeshOnWire          =  6;
  const long Tag_SubMeshOnFace          =  7;
  const long Tag_SubMeshOnShell         =  8;
  const long Tag_SubMeshOnSolid         =  9;
  const long Tag_SubMeshOnCompound      = 10;
  const long Tag_LastSubMesh            = 10;
  // Mesh only: group roots by type
  const long Tag_FirstGroup             = 11;
  const long Tag_NodeGroups             = 11;
  const long Tag_EdgeGroups             = 12;
  const long Tag_FaceGroups             = 13;
  const long Tag_VolumeGroups           = 14;
  const long Tag_0DElementsGroups       = 15;
  const long Tag_BallElementsGroups     = 16;
  const long Tag_LastGroup              = 16;
 
  struct AlgoStateError
  {
    Hypothesis_Status  state;
    string             algoName;
    long               algoDim;
    boolean            isGlobalAlgo;
  };
  typedef sequence<AlgoStateError> algo_error_array;
 
  enum ComputeErrorName
  {
    COMPERR_OK            ,
    COMPERR_BAD_INPUT_MESH,  // wrong mesh on lower submesh
    COMPERR_STD_EXCEPTION ,  // some std exception raised
    COMPERR_OCC_EXCEPTION ,  // OCC exception raised
    COMPERR_SLM_EXCEPTION ,  // SALOME exception raised
    COMPERR_EXCEPTION     ,  // other exception raised
    COMPERR_MEMORY_PB     ,  // memory allocation problem
    COMPERR_ALGO_FAILED   ,  // computation failed
    COMPERR_BAD_SHAPE     ,  // bad geometry
    COMPERR_WARNING       ,  // algo reports error but sub-mesh is computed anyway
    COMPERR_CANCELED      ,  // compute canceled
    COMPERR_NO_MESH_ON_SHAPE,// no mesh elements assigned to sub-mesh
    COMPERR_BAD_PARMETERS    // incorrect hypotheses parameters
  };
  struct ComputeError
  {
    short   code;       // ComputeErrorName or, if negative, algo specific code
    string  comment;    // textual problem description
    string  algoName;
    long    subShapeID; // id of sub-shape of a shape to mesh
    boolean hasBadMesh; // there are elements preventing computation available for visualization
  };
  typedef sequence<ComputeError> compute_error_array;
 
  struct HypInitParams
  {
    short   way; // 0 - by mesh, 1 - by geometry size + preferred parameters, 2 - by averageLength
    double  averageLength;
    boolean quadDominated;
  };
 
  interface SMESH_Gen : Engines::EngineComponent, SALOMEDS::Driver
  {
    //GEOM::GEOM_Gen SetGeomEngine( in string containerLoc );
    void SetGeomEngine( in GEOM::GEOM_Gen geomcompo );
 
    FilterManager CreateFilterManager();
 
    SMESH_Pattern GetPattern();
 
    Measurements  CreateMeasurements();
 
    void SetEmbeddedMode( in boolean theMode );
 
    boolean IsEmbeddedMode();
 
    void UpdateStudy();
 
    void SetEnablePublish( in boolean theIsEnablePublish );
 
    boolean IsEnablePublish();
 
    SMESH_Hypothesis CreateHypothesis( in string theHypName,
                                       in string theLibName )
      raises ( SALOME::SALOME_Exception );
 
    SMESH_Hypothesis CreateHypothesisByAverageLength( in string  theHypName,
                                                      in string  theLibName,
                                                      in double  theAverageLength,
                                                      in boolean theQuadDominated)
      raises ( SALOME::SALOME_Exception );
 
    SMESH_Hypothesis GetHypothesisParameterValues( in string            theHypName,
                                                   in string            theLibName,
                                                   in SMESH_Mesh        theMesh,
                                                   in GEOM::GEOM_Object theGeom,
                                                   in HypInitParams     theWay)
      raises ( SALOME::SALOME_Exception );
 
    boolean GetSoleSubMeshUsingHyp( in SMESH_Hypothesis   theHyp,
                                    out SMESH_Mesh        theMesh,
                                    out GEOM::GEOM_Object theShape);
 
    void SetBoundaryBoxSegmentation( in long theNbSegments ) raises ( SALOME::SALOME_Exception );
    void SetDefaultNbSegments( in long theNbSegments) raises ( SALOME::SALOME_Exception );
 
    void SetName( in string theObjectIOR,
                  in string theObjectName )
      raises ( SALOME::SALOME_Exception );
 
    SMESH_Mesh CreateMesh( in GEOM::GEOM_Object theObject )
      raises ( SALOME::SALOME_Exception );
 
    SMESH_ParallelMesh CreateParallelMesh( in GEOM::GEOM_Object theObject )
      raises ( SALOME::SALOME_Exception );
    SMESH_Mesh CreateEmptyMesh()
      raises ( SALOME::SALOME_Exception );
 
    SMESH_Mesh CreateMeshesFromUNV( in string theFileName )
      raises ( SALOME::SALOME_Exception );
 
    mesh_array CreateMeshesFromMED( in string theFileName,
                                    out SMESH::DriverMED_ReadStatus theStatus )
      raises ( SALOME::SALOME_Exception );
 
    SMESH_Mesh CreateMeshesFromSTL( in string theFileName )
      raises ( SALOME::SALOME_Exception );
 
    mesh_array CreateMeshesFromCGNS( in string theFileName,
                                     out SMESH::DriverMED_ReadStatus theStatus )
      raises ( SALOME::SALOME_Exception );
 
    SMESH_Mesh CreateMeshesFromGMF( in string               theFileName,
                                    in boolean              theMakeRequiredGroups,
                                    out SMESH::ComputeError theError)
      raises ( SALOME::SALOME_Exception );
    SMESH_Mesh CreateDualMesh(in SMESH_IDSource mesh,
                              in string         meshName,
                              in boolean        adaptToShape)
      raises ( SALOME::SALOME_Exception );
 
    SMESH_Mesh CopyMesh(in SMESH_IDSource meshPart,
                        in string         meshName,
                        in boolean        toCopyGroups,
                        in boolean        toKeepIDs)
      raises ( SALOME::SALOME_Exception );
 
    boolean CopyMeshWithGeom( in SMESH_Mesh        sourceMesh,
                              in GEOM::GEOM_Object newGeometry,
                              in string            meshName,
                              in boolean           toCopyGroups,
                              in boolean           toReuseHypotheses,
                              in boolean           toCopyElements,
                              out SMESH_Mesh       newMesh,
                              out ListOfGroups     newGroups,
                              out submesh_array    newSubmeshes,
                              out ListOfHypothesis newHypotheses,
                              out string_array     invalidEntries)
      raises ( SALOME::SALOME_Exception );
 
    SMESH_Mesh Concatenate(in ListOfIDSources theMeshesArray,
                           in boolean         theUniteIdenticalGroups,
                           in boolean         theMergeNodesAndElements,
                           in double          theMergeTolerance,
                           in SMESH_Mesh      theMeshToAppendTo)
      raises ( SALOME::SALOME_Exception );
 
    SMESH_Mesh ConcatenateWithGroups(in ListOfIDSources theMeshesArray,
                                     in boolean         theUniteIdenticalGroups,
                                     in boolean         theMergeNodesAndElements,
                                     in double          theMergeTolerance,
                                     in SMESH_Mesh      theMeshToAppendTo)
      raises ( SALOME::SALOME_Exception );
 
    boolean Compute( in SMESH_Mesh        theMesh,
                     in GEOM::GEOM_Object theSubObject )
      raises ( SALOME::SALOME_Exception );
 
    void CancelCompute( in SMESH_Mesh        theMesh,
               in GEOM::GEOM_Object theSubObject );
 
    boolean IsReadyToCompute( in SMESH_Mesh        theMesh,
                              in GEOM::GEOM_Object theSubObject )
      raises ( SALOME::SALOME_Exception );
 
    smIdType_array  Evaluate(in SMESH_Mesh        theMesh,
                             in GEOM::GEOM_Object theSubObject)
      raises ( SALOME::SALOME_Exception );
 
    MeshPreviewStruct Precompute( in SMESH_Mesh        theMesh,
                                  in GEOM::GEOM_Object theSubObject,
                                  in Dimension         theDimension,
                                  inout long_array    theShapesId )
      raises ( SALOME::SALOME_Exception );
 
    algo_error_array GetAlgoState( in SMESH_Mesh        theMesh,
                                   in GEOM::GEOM_Object theSubObject )
      raises ( SALOME::SALOME_Exception );
 
    compute_error_array GetComputeErrors( in SMESH_Mesh        theMesh,
                                          in GEOM::GEOM_Object theSubObject )
      raises ( SALOME::SALOME_Exception );
 
    MeshPreviewStruct GetBadInputElements( in SMESH_Mesh theMesh,
                                           in short      theSubShapeID )
      raises ( SALOME::SALOME_Exception );
 
    SMESH::ListOfGroups MakeGroupsOfBadInputElements( in SMESH_Mesh theMesh,
                                                      in short      theSubShapeID,
                                                      in string     theGroupName)
      raises ( SALOME::SALOME_Exception );
 
    long_array GetSubShapesId( in GEOM::GEOM_Object theMainObject,
                               in object_array      theListOfSubObjects )
       raises ( SALOME::SALOME_Exception );
 
    GEOM::GEOM_Object GetGeometryByMeshElement( in SMESH_Mesh theMesh,
                                                in smIdType   theElementID,
                                                in string     theGeomName)
      raises ( SALOME::SALOME_Exception );
 
    GEOM::GEOM_Object FindGeometryByMeshElement( in SMESH_Mesh theMesh,
                                                 in smIdType   theElementID)
      raises ( SALOME::SALOME_Exception );
 
    long GetObjectId(in Object theObject);
 
    string GetMEDFileVersion();
 
    string GetMEDVersion(in string theFileName);
 
    boolean CheckCompatibility(in string theFileName);
 
    boolean CheckWriteCompatibility(in string theFileName);
 
    string_array GetMeshNames(in string theFileName);
 
    void Move( in sobject_list what,
            in SALOMEDS::SObject where,
            in long row );
    boolean IsApplicable( in string             theAlgoType,
                          in string             theLibName,
                          in GEOM::GEOM_Object  theShapeObject,
                          in boolean            toCheckAll );
 
 
    long_array GetInsideSphere( in SMESH_IDSource theSource,
                    in ElementType    theElemType,
                    in double theX,
                    in double theY,
                    in double theZ,
                    in double theR );
 
    long_array GetInsideBox( in SMESH_IDSource theSource,
                    in ElementType    theElemType,
                    in double theX1,
                    in double theY1,
                    in double theZ1,
                    in double theX2,
                    in double theY2,
                    in double theZ2);
    long_array GetInsideCylinder( in SMESH_IDSource theSource,
                      in ElementType    theElemType,
                      in double theX,
                      in double theY,
                      in double theZ,
                      in double theDX,
                      in double theDY,
                      in double theDZ,
                      in double theH,
                      in double theR );
    long_array GetInside( in SMESH_IDSource theSource,
                 in ElementType    theElemType,
                 in GEOM::GEOM_Object theGeom,
                 in double theTolerance );
 
    MG_ADAPT CreateMG_ADAPT();
    SMESHHOMARD::HOMARD_Gen CreateHOMARD_ADAPT() raises ( SALOME::SALOME_Exception );
    //MG_ADAPT_OBJECT Adaptation(in string adaptType);
    SALOME::GenericObj Adaptation(in string adaptType) raises ( SALOME::SALOME_Exception );
    MG_ADAPT CreateAdaptationHypothesis();
  };
 
};
 
#endif