idl/SMESH_Gen.idl

   1 // Copyright (C) 2007-2014  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 //  File   : SMESH_Gen.idl
  23 //  Author : Paul RASCLE, EDF
  24
  25 #ifndef _SMESH_GEN_IDL_
  26 #define _SMESH_GEN_IDL_
  27
  28 #include "SALOME_Exception.idl"
  29 #include "SALOME_Component.idl"
  30 #include "SALOMEDS.idl"
  31
  32 #include "GEOM_Gen.idl"
  33
  34 #include "SMESH_Mesh.idl"
  35 #include "SMESH_Hypothesis.idl"
  36
  37 module SMESH
  38 {
  39   typedef sequence<SALOMEDS::SObject> sobject_list;
  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_0DElementsGroups       = 15;
  75   const long Tag_BallElementsGroups     = 16;
  76   const long Tag_LastGroup              = 16;
  77
  78   /*!
  79    * Hypothesis definintion error
  80    */
  81   struct AlgoStateError
  82   {
  83     Hypothesis_Status  state;
  84     string             algoName;
  85     long               algoDim;
  86     boolean            isGlobalAlgo;
  87   };
  88   typedef sequence<AlgoStateError> algo_error_array;
  89
  90   /*!
  91    * Mesh computation error
  92    */
  93   enum ComputeErrorName
  94   {
  95     COMPERR_OK            ,
  96     COMPERR_BAD_INPUT_MESH,  // wrong mesh on lower submesh
  97     COMPERR_STD_EXCEPTION ,  // some std exception raised
  98     COMPERR_OCC_EXCEPTION ,  // OCC exception raised
  99     COMPERR_SLM_EXCEPTION ,  // SALOME exception raised
 100     COMPERR_EXCEPTION     ,  // other exception raised
 101     COMPERR_MEMORY_PB     ,  // memory allocation problem
 102     COMPERR_ALGO_FAILED   ,  // computation failed
 103     COMPERR_BAD_SHAPE     ,  // bad geometry
 104     COMPERR_WARNING       ,  // algo reports error but sub-mesh is computed anyway
 105     COMPERR_CANCELED      ,  // compute canceled
 106     COMPERR_NO_MESH_ON_SHAPE,// no mesh elements assigned to sub-mesh
 107     COMPERR_BAD_PARMETERS    // incorrect hypotheses parameters
 108   };
 109   struct ComputeError
 110   {
 111     short   code;       // ComputeErrorName or, if negative, algo specific code
 112     string  comment;    // textual problem description
 113     string  algoName;
 114     short   subShapeID; // id of sub-shape of a shape to mesh
 115     boolean hasBadMesh; // there are elements preventing computation available for visualization
 116   };
 117   typedef sequence<ComputeError> compute_error_array;
 118
 119
 120   interface SMESH_Gen : Engines::EngineComponent, SALOMEDS::Driver
 121   {
 122     //GEOM::GEOM_Gen SetGeomEngine( in string containerLoc );
 123     void SetGeomEngine( in GEOM::GEOM_Gen geomcompo );
 124
 125     FilterManager CreateFilterManager();
 126
 127     SMESH_Pattern GetPattern();
 128
 129     Measurements  CreateMeasurements();
 130
 131     /*!
 132       Set the current mode
 133      */
 134     void SetEmbeddedMode( in boolean theMode );
 135
 136     /*!
 137       Get the current mode
 138      */
 139     boolean IsEmbeddedMode();
 140
 141     /*!
 142       Set the current study
 143      */
 144     void SetCurrentStudy( in SALOMEDS::Study theStudy );
 145
 146     /*!
 147       Get the current study
 148      */
 149     SALOMEDS::Study GetCurrentStudy();
 150
 151     /*!
 152      * Create a hypothesis that can be shared by differents parts of the mesh.
 153      * An hypothesis is either:
 154      * - a method used to generate or modify a part of the mesh (algorithm).
 155      * - a parameter or a law used by an algorithm.
 156      * Algorithms are 1D, 2D or 3D.
 157      */
 158     SMESH_Hypothesis CreateHypothesis( in string theHypName,
 159                                        in string theLibName )
 160       raises ( SALOME::SALOME_Exception );
 161
 162     /*!
 163      * Return a hypothesis holding parameter values corresponding either to the mesh
 164      * existing on the given geometry or to size of the geometry.
 165      * The returned hypothesis may be the one existing in a study and used
 166      * to compute the mesh, or a temporary one created just to pass parameter
 167      * values.
 168      */
 169     SMESH_Hypothesis GetHypothesisParameterValues( in string            theHypName,
 170                                                    in string            theLibName,
 171                                                    in SMESH_Mesh        theMesh,
 172                                                    in GEOM::GEOM_Object theGeom,
 173                                                    in boolean           byMesh)
 174       raises ( SALOME::SALOME_Exception );
 175
 176     /*!
 177      * Sets number of segments per diagonal of boundary box of geometry by which
 178      * default segment length of appropriate 1D hypotheses is defined
 179      */
 180     void SetBoundaryBoxSegmentation( in long theNbSegments ) raises ( SALOME::SALOME_Exception );
 181     /*!
 182      * \brief Sets default number of segments per edge
 183      */
 184     void SetDefaultNbSegments( in long theNbSegments) raises ( SALOME::SALOME_Exception );
 185
 186     /*!
 187      * Set the object name
 188      */
 189     void SetName( in string theObjectIOR,
 190                   in string theObjectName )
 191       raises ( SALOME::SALOME_Exception );
 192
 193     /*!
 194      * Create a Mesh object, given a geometry shape.
 195      * Mesh is created empty (no points, no elements).
 196      * Shape is explored via GEOM_Client to create local copies.
 197      * of TopoDS_Shapes and bind CORBA references of shape & subshapes
 198      * with TopoDS_Shapes
 199      */
 200     SMESH_Mesh CreateMesh( in GEOM::GEOM_Object theObject )
 201       raises ( SALOME::SALOME_Exception );
 202
 203     /*!
 204      * Create an empty mesh object
 205      */
 206     SMESH_Mesh CreateEmptyMesh()
 207       raises ( SALOME::SALOME_Exception );
 208
 209     /*!
 210      * Create Mesh object importing data from given UNV file
 211      * (UNV supported version is I-DEAS 10)
 212      */
 213     SMESH_Mesh CreateMeshesFromUNV( in string theFileName )
 214       raises ( SALOME::SALOME_Exception );
 215
 216     /*!
 217      * Create Mesh object(s) importing data from given MED file
 218      */
 219      mesh_array CreateMeshesFromMED( in string theFileName,
 220                                      out SMESH::DriverMED_ReadStatus theStatus )
 221        raises ( SALOME::SALOME_Exception );
 222
 223     /*!
 224      * Create Mesh object(s) importing data from given MED file
 225      */
 226      mesh_array CreateMeshesFromSAUV( in string theFileName,
 227                                       out SMESH::DriverMED_ReadStatus theStatus )
 228        raises ( SALOME::SALOME_Exception );
 229
 230     /*!
 231      * Create Mesh object importing data from given STL file
 232      */
 233     SMESH_Mesh CreateMeshesFromSTL( in string theFileName )
 234       raises ( SALOME::SALOME_Exception );
 235
 236     /*!
 237      * Create Mesh object(s) importing data from given CGNS file
 238      */
 239     mesh_array CreateMeshesFromCGNS( in string theFileName,
 240                                      out SMESH::DriverMED_ReadStatus theStatus )
 241       raises ( SALOME::SALOME_Exception );
 242
 243     /*!
 244      * Create Mesh object importing data from given GMF file
 245      *  \param theFileName - a name of file to import
 246      *  \param theMakeRequiredGroups - if true, groups of required entities will be created
 247      */
 248     SMESH_Mesh CreateMeshesFromGMF( in string               theFileName,
 249                                     in boolean              theMakeRequiredGroups,
 250                                     out SMESH::ComputeError theError)
 251       raises ( SALOME::SALOME_Exception );
 252
 253     /*!
 254      * Create a mesh by copying a part of another mesh
 255      *  \param meshPart - a part of mesh to copy
 256      *  \param meshName - a name of the new mesh
 257      *  \param toCopyGroups - to create in the new mesh groups
 258      *                        the copied elements belongs to
 259      *  \param toKeepIDs - to preserve IDs of the copied elements or not
 260      */
 261     SMESH_Mesh CopyMesh(in SMESH_IDSource meshPart,
 262                         in string         meshName,
 263                         in boolean        toCopyGroups,
 264                         in boolean        toKeepIDs)
 265       raises ( SALOME::SALOME_Exception );
 266
 267     /*!
 268      * Concatenate the given meshes into one mesh.
 269      * Union groups with the same name and type if
 270      * theUniteIdenticalGroups flag is true.
 271      * Merge coincident nodes and elements if
 272      * theMergeNodesAndElements flag is true.
 273      */
 274     SMESH_Mesh Concatenate(in mesh_array theMeshesArray,
 275                            in boolean    theUniteIdenticalGroups,
 276                            in boolean    theMergeNodesAndElements,
 277                            in double     theMergeTolerance)
 278       raises ( SALOME::SALOME_Exception );
 279
 280     /*!
 281      * Concatenate the given meshes into one mesh.
 282      * Union groups with the same name and type if
 283      * theUniteIdenticalGroups flag is true.
 284      * Merge coincident nodes and elements if
 285      * theMergeNodesAndElements flag is true.
 286      * Create the groups of all elements from initial meshes.
 287      */
 288     SMESH_Mesh ConcatenateWithGroups(in mesh_array theMeshesArray,
 289                                      in boolean    theUniteIdenticalGroups,
 290                                      in boolean    theMergeNodesAndElements,
 291                                      in double     theMergeTolerance)
 292       raises ( SALOME::SALOME_Exception );
 293
 294     /*!
 295      * Mesh a subShape.
 296      * First, verify list of hypothesis associated with the Sub-shape,
 297      * return NOK if hypothesis are not sufficient
 298      */
 299     boolean Compute( in SMESH_Mesh        theMesh,
 300                      in GEOM::GEOM_Object theSubObject )
 301       raises ( SALOME::SALOME_Exception );
 302
 303     /*!
 304      * Cancel a computation.
 305      */
 306     void CancelCompute( in SMESH_Mesh        theMesh,
 307                         in GEOM::GEOM_Object theSubObject );
 308
 309     /*!
 310      * Return true if hypotheses are defined well
 311      */
 312     boolean IsReadyToCompute( in SMESH_Mesh        theMesh,
 313                               in GEOM::GEOM_Object theSubObject )
 314       raises ( SALOME::SALOME_Exception );
 315
 316     /*!
 317      * Evaluates size of prospective mesh on a shape
 318      */
 319     long_array  Evaluate(in SMESH_Mesh        theMesh,
 320                          in GEOM::GEOM_Object theSubObject)
 321       raises ( SALOME::SALOME_Exception );
 322
 323     /*!
 324      * Calculate Mesh as preview till indicated dimension
 325      * First, verify list of hypothesis associated with the Sub-shape.
 326      * Return mesh preview structure
 327      */
 328     MeshPreviewStruct Precompute( in SMESH_Mesh        theMesh,
 329                                   in GEOM::GEOM_Object theSubObject,
 330                                   in Dimension         theDimension,
 331                                   inout long_array    theShapesId )
 332       raises ( SALOME::SALOME_Exception );
 333
 334     /*!
 335      * Return errors of hypotheses definintion
 336      * algo_error_array is empty if everything is OK
 337      */
 338     algo_error_array GetAlgoState( in SMESH_Mesh        theMesh,
 339                                    in GEOM::GEOM_Object theSubObject )
 340       raises ( SALOME::SALOME_Exception );
 341
 342     /*!
 343      * Return errors of mesh computation
 344      * compute_error_array is empty if everything is OK
 345      */
 346     compute_error_array GetComputeErrors( in SMESH_Mesh        theMesh,
 347                                           in GEOM::GEOM_Object theSubObject )
 348       raises ( SALOME::SALOME_Exception );
 349
 350     /*!
 351      * Return mesh elements preventing computation of a sub-shape
 352      */
 353     MeshPreviewStruct GetBadInputElements( in SMESH_Mesh theMesh,
 354                                            in short      theSubShapeID )
 355       raises ( SALOME::SALOME_Exception );
 356
 357     /*!
 358      * Create groups of elements preventing computation of a sub-shape
 359      */
 360     SMESH::ListOfGroups MakeGroupsOfBadInputElements( in SMESH_Mesh theMesh,
 361                                                       in short      theSubShapeID,
 362                                                       in string     theGroupName)
 363       raises ( SALOME::SALOME_Exception );
 364
 365     /*!
 366      * Return indeces of faces, edges and vertices of given sub-shapes
 367      * within theMainObject
 368      */
 369     long_array GetSubShapesId( in GEOM::GEOM_Object theMainObject,
 370                                in object_array      theListOfSubObjects )
 371        raises ( SALOME::SALOME_Exception );
 372
 373     /*!
 374      * Return geometrical object the given element is built on.
 375      * The returned geometrical object, if not nil, is either found in the
 376      * study or is published by this method with the given name
 377      */
 378     GEOM::GEOM_Object GetGeometryByMeshElement( in SMESH_Mesh  theMesh,
 379                                                 in long        theElementID,
 380                                                 in string      theGeomName)
 381       raises ( SALOME::SALOME_Exception );
 382
 383     /*!
 384      * Return geometrical object the given element is built on.
 385      * The returned geometrical object not published in study by this method.
 386      */
 387     GEOM::GEOM_Object FindGeometryByMeshElement( in SMESH_Mesh  theMesh,
 388                                                  in long        theElementID)
 389       raises ( SALOME::SALOME_Exception );
 390
 391     /*!
 392      * \brief Return id of object, registered in current study context
 393      *
 394      * Can be used to check if the object was created in the same container, as this engine.
 395      */
 396     long GetObjectId(in Object theObject);
 397
 398     /*!
 399      * \brief Get MED version of the file by its name.
 400      */
 401     boolean GetMEDVersion(in string theFileName, out MED_VERSION theVersion);
 402
 403     /*!
 404      * \brief Get names of meshes defined in file with the specified name.
 405      */
 406     string_array GetMeshNames(in string theFileName);
 407
 408     /*!
 409      * \brief Moves objects to the specified position
 410      *
 411      * This function is used in the drag-n-drop functionality.
 412      *
 413      * \param what objects being moved
 414      * \param where parent object where objects are moved to
 415      * \param row position in the parent object's children list at which objects are moved
 416      */
 417     void Move( in sobject_list what,
 418                in SALOMEDS::SObject where,
 419                in long row );
 420     /*!
 421      * Return true if algorithm can be applied
 422      */
 423     boolean IsApplicable( in string             theAlgoType,
 424                           in string             theLibName,
 425                           in GEOM::GEOM_Object  theShapeObject,
 426                           in boolean            toCheckAll );
 427   };
 428
 429 };
 430
 431 #endif