idl/SMESH_Gen.idl

   1 //  Copyright (C) 2007-2010  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_Gen.idl
  24 //  Author : Paul RASCLE, EDF
  25 //
  26 #ifndef _SMESH_GEN_IDL_
  27 #define _SMESH_GEN_IDL_
  28
  29 #include "SALOME_Exception.idl"
  30 #include "SALOME_Component.idl"
  31 #include "SALOMEDS.idl"
  32
  33 #include "GEOM_Gen.idl"
  34
  35 #include "SMESH_Mesh.idl"
  36 #include "SMESH_Hypothesis.idl"
  37
  38 module SMESH
  39 {
  40   typedef sequence<GEOM::GEOM_Object> object_array;
  41   typedef sequence<SMESH_Mesh>        mesh_array;
  42
  43   interface FilterManager;
  44   interface SMESH_Pattern;
  45   interface Measurements;
  46
  47   /*!
  48    * Tags definition
  49    */
  50   // Top level
  51   const long Tag_HypothesisRoot = 1; // hypotheses root
  52   const long Tag_AlgorithmsRoot = 2; // algorithms root
  53   const long Tag_FirstMeshRoot  = 3; // first mesh root
  54   // Mesh/Submesh
  55   const long Tag_RefOnShape             = 1; // references to shape
  56   const long Tag_RefOnAppliedHypothesis = 2; // applied hypotheses root
  57   const long Tag_RefOnAppliedAlgorithms = 3; // applied algorithms root
  58   // Mesh only: sub-meshes roots by type
  59   const long Tag_FirstSubMesh           =  4;
  60   const long Tag_SubMeshOnVertex        =  4;
  61   const long Tag_SubMeshOnEdge          =  5;
  62   const long Tag_SubMeshOnWire          =  6;
  63   const long Tag_SubMeshOnFace          =  7;
  64   const long Tag_SubMeshOnShell         =  8;
  65   const long Tag_SubMeshOnSolid         =  9;
  66   const long Tag_SubMeshOnCompound      = 10;
  67   const long Tag_LastSubMesh            = 10;
  68   // Mesh only: group roots by type
  69   const long Tag_FirstGroup             = 11;
  70   const long Tag_NodeGroups             = 11;
  71   const long Tag_EdgeGroups             = 12;
  72   const long Tag_FaceGroups             = 13;
  73   const long Tag_VolumeGroups           = 14;
  74   const long Tag_LastGroup              = 14;
  75
  76   /*!
  77    * Hypothesis definintion error
  78    */
  79   struct AlgoStateError
  80   {
  81     Hypothesis_Status  state;
  82     string             algoName;
  83     long               algoDim;
  84     boolean            isGlobalAlgo;
  85   };
  86   typedef sequence<AlgoStateError> algo_error_array;
  87
  88   /*!
  89    * Mesh computation error
  90    */
  91   enum ComputeErrorName
  92   {
  93     COMPERR_OK            ,
  94     COMPERR_BAD_INPUT_MESH,  // wrong mesh on lower submesh
  95     COMPERR_STD_EXCEPTION ,  // some std exception raised
  96     COMPERR_OCC_EXCEPTION ,  // OCC exception raised
  97     COMPERR_SLM_EXCEPTION ,  // SALOME exception raised
  98     COMPERR_EXCEPTION     ,  // other exception raised
  99     COMPERR_MEMORY_PB     ,  // memory allocation problem
 100     COMPERR_ALGO_FAILED   ,  // computation failed
 101     COMPERR_BAD_SHAPE        // bad geometry
 102   };
 103   struct ComputeError
 104   {
 105     short   code;       // ComputeErrorName or, if negative, algo specific code
 106     string  comment;    // textual problem description
 107     string  algoName;
 108     short   subShapeID; // id of subshape of a shape to mesh
 109     boolean hasBadMesh; // there are elements preventing computation available for visualization
 110   };
 111   typedef sequence<ComputeError> compute_error_array;
 112
 113
 114   interface SMESH_Gen : Engines::Component, SALOMEDS::Driver
 115   {
 116     //GEOM::GEOM_Gen SetGeomEngine( in string containerLoc );
 117     void SetGeomEngine( in GEOM::GEOM_Gen geomcompo );
 118
 119     FilterManager CreateFilterManager();
 120
 121     SMESH_Pattern GetPattern();
 122
 123     Measurements  CreateMeasurements();
 124
 125     /*!
 126       Set the current mode
 127      */
 128     void SetEmbeddedMode( in boolean theMode );
 129
 130     /*!
 131       Get the current mode
 132      */
 133     boolean IsEmbeddedMode();
 134
 135     /*!
 136       Set the current study
 137      */
 138     void SetCurrentStudy( in SALOMEDS::Study theStudy );
 139
 140     /*!
 141       Get the current study
 142      */
 143     SALOMEDS::Study GetCurrentStudy();
 144
 145     /*!
 146      * Create a hypothesis that can be shared by differents parts of the mesh.
 147      * An hypothesis is either:
 148      * - a method used to generate or modify a part of the mesh (algorithm).
 149      * - a parameter or a law used by an algorithm.
 150      * Algorithms are 1D, 2D or 3D.
 151      */
 152     SMESH_Hypothesis CreateHypothesis( in string theHypName,
 153                                        in string theLibName )
 154       raises ( SALOME::SALOME_Exception );
 155
 156     /*!
 157      * Return a hypothesis holding parameter values corresponding either to the mesh
 158      * existing on the given geometry or to size of the geometry.
 159      * The returned hypothesis may be the one existing in a study and used
 160      * to compute the mesh, or a temporary one created just to pass parameter
 161      * values.
 162      */
 163     SMESH_Hypothesis GetHypothesisParameterValues( in string            theHypName,
 164                                                    in string            theLibName,
 165                                                    in SMESH_Mesh        theMesh,
 166                                                    in GEOM::GEOM_Object theGeom,
 167                                                    in boolean           byMesh)
 168       raises ( SALOME::SALOME_Exception );
 169
 170     /*!
 171      * Sets number of segments per diagonal of boundary box of geometry by which
 172      * default segment length of appropriate 1D hypotheses is defined
 173      */
 174     void SetBoundaryBoxSegmentation( in long theNbSegments ) raises ( SALOME::SALOME_Exception );
 175     /*!
 176      * \brief Sets default number of segments per edge
 177      */
 178     void SetDefaultNbSegments( in long theNbSegments) raises ( SALOME::SALOME_Exception );
 179
 180     /*!
 181      * Set the object name
 182      */
 183     void SetName( in string theObjectIOR,
 184                   in string theObjectName )
 185       raises ( SALOME::SALOME_Exception );
 186
 187     /*!
 188      * Create a Mesh object, given a geometry shape.
 189      * Mesh is created empty (no points, no elements).
 190      * Shape is explored via GEOM_Client to create local copies.
 191      * of TopoDS_Shapes and bind CORBA references of shape & subshapes
 192      * with TopoDS_Shapes
 193      */
 194     SMESH_Mesh CreateMesh( in GEOM::GEOM_Object theObject )
 195       raises ( SALOME::SALOME_Exception );
 196
 197     /*!
 198      * Create an empty mesh object
 199      */
 200     SMESH_Mesh CreateEmptyMesh()
 201       raises ( SALOME::SALOME_Exception );
 202
 203     /*!
 204      * Create Mesh object importing data from given UNV file
 205      * (UNV supported version is I-DEAS 10)
 206      */
 207     SMESH_Mesh CreateMeshesFromUNV( in string theFileName )
 208       raises ( SALOME::SALOME_Exception );
 209
 210     /*!
 211      * Create Mesh object(s) importing data from given MED file
 212      */
 213      mesh_array CreateMeshesFromMED( in string theFileName,
 214                                      out SMESH::DriverMED_ReadStatus theStatus )
 215        raises ( SALOME::SALOME_Exception );
 216
 217     /*!
 218      * Create Mesh object importing data from given STL file
 219      */
 220     SMESH_Mesh CreateMeshesFromSTL( in string theFileName )
 221       raises ( SALOME::SALOME_Exception );
 222
 223     /*!
 224      * Create a mesh by copying a part of another mesh
 225      *  \param meshPart - a part of mesh to copy
 226      *  \param meshName - a name of the new mesh
 227      *  \param toCopyGroups - to create in the new mesh groups
 228      *                        the copied elements belongs to
 229      *  \param toKeepIDs - to preserve IDs of the copied elements or not
 230      */
 231     SMESH_Mesh CopyMesh(in SMESH_IDSource meshPart,
 232                         in string         meshName,
 233                         in boolean        toCopyGroups,
 234                         in boolean        toKeepIDs)
 235       raises ( SALOME::SALOME_Exception );
 236
 237     /*!
 238      * Concatenate the given meshes into one mesh.
 239      * Union groups with the same name and type if
 240      * theUniteIdenticalGroups flag is true.
 241      * Merge coincident nodes and elements if
 242      * theMergeNodesAndElements flag is true.
 243      */
 244     SMESH_Mesh Concatenate(in mesh_array theMeshesArray,
 245                            in boolean    theUniteIdenticalGroups,
 246                            in boolean    theMergeNodesAndElements,
 247                            in double     theMergeTolerance)
 248       raises ( SALOME::SALOME_Exception );
 249
 250     /*!
 251      * Concatenate the given meshes into one mesh.
 252      * Union groups with the same name and type if
 253      * theUniteIdenticalGroups flag is true.
 254      * Merge coincident nodes and elements if
 255      * theMergeNodesAndElements flag is true.
 256      * Create the groups of all elements from initial meshes.
 257      */
 258     SMESH_Mesh ConcatenateWithGroups(in mesh_array theMeshesArray,
 259                                      in boolean    theUniteIdenticalGroups,
 260                                      in boolean    theMergeNodesAndElements,
 261                                      in double     theMergeTolerance)
 262       raises ( SALOME::SALOME_Exception );
 263
 264     /*!
 265      * Mesh a subShape.
 266      * First, verify list of hypothesis associated with the subShape,
 267      * return NOK if hypothesis are not sufficient
 268      */
 269     boolean Compute( in SMESH_Mesh        theMesh,
 270                      in GEOM::GEOM_Object theSubObject )
 271       raises ( SALOME::SALOME_Exception );
 272
 273     /*!
 274      * Return true if hypotheses are defined well
 275      */
 276     boolean IsReadyToCompute( in SMESH_Mesh        theMesh,
 277                               in GEOM::GEOM_Object theSubObject )
 278       raises ( SALOME::SALOME_Exception );
 279
 280     /*!
 281      * Evaluates size of prospective mesh on a shape
 282      */
 283     long_array  Evaluate(in SMESH_Mesh        theMesh,
 284                          in GEOM::GEOM_Object theSubObject)
 285       raises ( SALOME::SALOME_Exception );
 286
 287     /*!
 288      * Calculate Mesh as preview till indicated dimension
 289      * First, verify list of hypothesis associated with the subShape.
 290      * Return mesh preview structure
 291      */
 292     MeshPreviewStruct Precompute( in SMESH_Mesh        theMesh,
 293                                   in GEOM::GEOM_Object theSubObject,
 294                                   in Dimension         theDimension,
 295                                   inout long_array    theShapesId )
 296       raises ( SALOME::SALOME_Exception );
 297
 298     /*!
 299      * Return errors of hypotheses definintion
 300      * algo_error_array is empty if everything is OK
 301      */
 302     algo_error_array GetAlgoState( in SMESH_Mesh        theMesh,
 303                                    in GEOM::GEOM_Object theSubObject )
 304       raises ( SALOME::SALOME_Exception );
 305
 306     /*!
 307      * Return errors of mesh computation
 308      * compute_error_array is empty if everything is OK
 309      */
 310     compute_error_array GetComputeErrors( in SMESH_Mesh        theMesh,
 311                                           in GEOM::GEOM_Object theSubObject )
 312       raises ( SALOME::SALOME_Exception );
 313
 314     /*!
 315      * Return mesh elements preventing computation of a subshape
 316      */
 317     MeshPreviewStruct GetBadInputElements( in SMESH_Mesh theMesh,
 318                                            in short      theSubShapeID )
 319       raises ( SALOME::SALOME_Exception );
 320
 321     /*!
 322      * Return indeces of faces, edges and vertices of given subshapes
 323      * within theMainObject
 324      */
 325     long_array GetSubShapesId( in GEOM::GEOM_Object theMainObject,
 326                                in object_array      theListOfSubObjects )
 327        raises ( SALOME::SALOME_Exception );
 328
 329     /*!
 330      * Return geometrical object the given element is built on.
 331      * The returned geometrical object, if not nil, is either found in the
 332      * study or is published by this method with the given name
 333      */
 334     GEOM::GEOM_Object GetGeometryByMeshElement( in SMESH_Mesh  theMesh,
 335                                                 in long        theElementID,
 336                                                 in string      theGeomName)
 337       raises ( SALOME::SALOME_Exception );
 338
 339     /*!
 340      * Return geometrical object the given element is built on.
 341      * The returned geometrical object not published in study by this method.
 342      */
 343     GEOM::GEOM_Object FindGeometryByMeshElement( in SMESH_Mesh  theMesh,
 344                                                  in long        theElementID)
 345       raises ( SALOME::SALOME_Exception );
 346
 347     /*!
 348      * \brief Return id of object, registered in current study context
 349      *
 350      * Can be used to check if the object was created in the same container, as this engine.
 351      */
 352     long GetObjectId(in Object theObject);
 353
 354     /*!
 355      * \brief Get MED version of the file by its name.
 356      */
 357     boolean GetMEDVersion(in string theFileName, out MED_VERSION theVersion);
 358
 359     /*!
 360      * \brief Get names of meshes defined in file with the specified name.
 361      */
 362     string_array GetMeshNames(in string theFileName);
 363   };
 364
 365 };
 366
 367 #endif