idl/SMESH_Gen.idl

   1 // Copyright (C) 2007-2015  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      * Returns \c True if a hypothesis is assigned to a sole sub-mesh in a current Study
 178      *  \param [in] theHyp - the hypothesis of interest
 179      *  \param [out] theMesh - the sole mesh using \a theHyp
 180      *  \param [out] theShape - the sole geometry \a theHyp is assigned to
 181      *  \return boolean - \c True if \a theMesh and \a theShape are sole using \a theHyp
 182      */
 183     boolean GetSoleSubMeshUsingHyp( in SMESH_Hypothesis   theHyp,
 184                                     out SMESH_Mesh        theMesh,
 185                                     out GEOM::GEOM_Object theShape);
 186
 187     /*!
 188      * Sets number of segments per diagonal of boundary box of geometry by which
 189      * default segment length of appropriate 1D hypotheses is defined
 190      */
 191     void SetBoundaryBoxSegmentation( in long theNbSegments ) raises ( SALOME::SALOME_Exception );
 192     /*!
 193      * \brief Sets default number of segments per edge
 194      */
 195     void SetDefaultNbSegments( in long theNbSegments) raises ( SALOME::SALOME_Exception );
 196
 197     /*!
 198      * Set the object name
 199      */
 200     void SetName( in string theObjectIOR,
 201                   in string theObjectName )
 202       raises ( SALOME::SALOME_Exception );
 203
 204     /*!
 205      * Create a Mesh object, given a geometry shape.
 206      * Mesh is created empty (no points, no elements).
 207      * Shape is explored via GEOM_Client to create local copies.
 208      * of TopoDS_Shapes and bind CORBA references of shape & subshapes
 209      * with TopoDS_Shapes
 210      */
 211     SMESH_Mesh CreateMesh( in GEOM::GEOM_Object theObject )
 212       raises ( SALOME::SALOME_Exception );
 213
 214     /*!
 215      * Create an empty mesh object
 216      */
 217     SMESH_Mesh CreateEmptyMesh()
 218       raises ( SALOME::SALOME_Exception );
 219
 220     /*!
 221      * Create Mesh object importing data from given UNV file
 222      * (UNV supported version is I-DEAS 10)
 223      */
 224     SMESH_Mesh CreateMeshesFromUNV( in string theFileName )
 225       raises ( SALOME::SALOME_Exception );
 226
 227     /*!
 228      * Create Mesh object(s) importing data from given MED file
 229      */
 230      mesh_array CreateMeshesFromMED( in string theFileName,
 231                                      out SMESH::DriverMED_ReadStatus theStatus )
 232        raises ( SALOME::SALOME_Exception );
 233
 234     /*!
 235      * Create Mesh object(s) importing data from given MED file
 236      */
 237      mesh_array CreateMeshesFromSAUV( in string theFileName,
 238                                       out SMESH::DriverMED_ReadStatus theStatus )
 239        raises ( SALOME::SALOME_Exception );
 240
 241     /*!
 242      * Create Mesh object importing data from given STL file
 243      */
 244     SMESH_Mesh CreateMeshesFromSTL( in string theFileName )
 245       raises ( SALOME::SALOME_Exception );
 246
 247     /*!
 248      * Create Mesh object(s) importing data from given CGNS file
 249      */
 250     mesh_array CreateMeshesFromCGNS( in string theFileName,
 251                                      out SMESH::DriverMED_ReadStatus theStatus )
 252       raises ( SALOME::SALOME_Exception );
 253
 254     /*!
 255      * Create Mesh object importing data from given GMF file
 256      *  \param theFileName - a name of file to import
 257      *  \param theMakeRequiredGroups - if true, groups of required entities will be created
 258      */
 259     SMESH_Mesh CreateMeshesFromGMF( in string               theFileName,
 260                                     in boolean              theMakeRequiredGroups,
 261                                     out SMESH::ComputeError theError)
 262       raises ( SALOME::SALOME_Exception );
 263
 264     /*!
 265      * Create a mesh by copying a part of another mesh
 266      *  \param meshPart - a part of mesh to copy
 267      *  \param meshName - a name of the new mesh
 268      *  \param toCopyGroups - to create in the new mesh groups
 269      *                        the copied elements belongs to
 270      *  \param toKeepIDs - to preserve IDs of the copied elements or not
 271      */
 272     SMESH_Mesh CopyMesh(in SMESH_IDSource meshPart,
 273                         in string         meshName,
 274                         in boolean        toCopyGroups,
 275                         in boolean        toKeepIDs)
 276       raises ( SALOME::SALOME_Exception );
 277
 278     /*!
 279      * Concatenate the given meshes or groups into one mesh.
 280      * Union groups with the same name and type if
 281      * theUniteIdenticalGroups flag is true.
 282      * Merge coincident nodes and elements if
 283      * theMergeNodesAndElements flag is true.
 284      */
 285     SMESH_Mesh Concatenate(in ListOfIDSources theMeshesArray,
 286                            in boolean         theUniteIdenticalGroups,
 287                            in boolean         theMergeNodesAndElements,
 288                            in double          theMergeTolerance)
 289       raises ( SALOME::SALOME_Exception );
 290
 291     /*!
 292      * Concatenate the given meshes into one mesh.
 293      * Union groups with the same name and type if
 294      * theUniteIdenticalGroups flag is true.
 295      * Merge coincident nodes and elements if
 296      * theMergeNodesAndElements flag is true.
 297      * Create the groups of all elements from initial meshes.
 298      */
 299     SMESH_Mesh ConcatenateWithGroups(in ListOfIDSources theMeshesArray,
 300                                      in boolean         theUniteIdenticalGroups,
 301                                      in boolean         theMergeNodesAndElements,
 302                                      in double          theMergeTolerance)
 303       raises ( SALOME::SALOME_Exception );
 304
 305     /*!
 306      * Mesh a subShape.
 307      * First, verify list of hypothesis associated with the Sub-shape,
 308      * return NOK if hypothesis are not sufficient
 309      */
 310     boolean Compute( in SMESH_Mesh        theMesh,
 311                      in GEOM::GEOM_Object theSubObject )
 312       raises ( SALOME::SALOME_Exception );
 313
 314     /*!
 315      * Cancel a computation.
 316      */
 317     void CancelCompute( in SMESH_Mesh        theMesh,
 318                         in GEOM::GEOM_Object theSubObject );
 319
 320     /*!
 321      * Return true if hypotheses are defined well
 322      */
 323     boolean IsReadyToCompute( in SMESH_Mesh        theMesh,
 324                               in GEOM::GEOM_Object theSubObject )
 325       raises ( SALOME::SALOME_Exception );
 326
 327     /*!
 328      * Evaluates size of prospective mesh on a shape
 329      */
 330     long_array  Evaluate(in SMESH_Mesh        theMesh,
 331                          in GEOM::GEOM_Object theSubObject)
 332       raises ( SALOME::SALOME_Exception );
 333
 334     /*!
 335      * Calculate Mesh as preview till indicated dimension
 336      * First, verify list of hypothesis associated with the Sub-shape.
 337      * Return mesh preview structure
 338      */
 339     MeshPreviewStruct Precompute( in SMESH_Mesh        theMesh,
 340                                   in GEOM::GEOM_Object theSubObject,
 341                                   in Dimension         theDimension,
 342                                   inout long_array    theShapesId )
 343       raises ( SALOME::SALOME_Exception );
 344
 345     /*!
 346      * Return errors of hypotheses definintion
 347      * algo_error_array is empty if everything is OK
 348      */
 349     algo_error_array GetAlgoState( in SMESH_Mesh        theMesh,
 350                                    in GEOM::GEOM_Object theSubObject )
 351       raises ( SALOME::SALOME_Exception );
 352
 353     /*!
 354      * Return errors of mesh computation
 355      * compute_error_array is empty if everything is OK
 356      */
 357     compute_error_array GetComputeErrors( in SMESH_Mesh        theMesh,
 358                                           in GEOM::GEOM_Object theSubObject )
 359       raises ( SALOME::SALOME_Exception );
 360
 361     /*!
 362      * Return mesh elements preventing computation of a sub-shape
 363      */
 364     MeshPreviewStruct GetBadInputElements( in SMESH_Mesh theMesh,
 365                                            in short      theSubShapeID )
 366       raises ( SALOME::SALOME_Exception );
 367
 368     /*!
 369      * Create groups of elements preventing computation of a sub-shape
 370      */
 371     SMESH::ListOfGroups MakeGroupsOfBadInputElements( in SMESH_Mesh theMesh,
 372                                                       in short      theSubShapeID,
 373                                                       in string     theGroupName)
 374       raises ( SALOME::SALOME_Exception );
 375
 376     /*!
 377      * Return indices of faces, edges and vertices of given sub-shapes
 378      * within theMainObject
 379      */
 380     long_array GetSubShapesId( in GEOM::GEOM_Object theMainObject,
 381                                in object_array      theListOfSubObjects )
 382        raises ( SALOME::SALOME_Exception );
 383
 384     /*!
 385      * Return geometrical object the given element is built on.
 386      * The returned geometrical object, if not nil, is either found in the
 387      * study or is published by this method with the given name
 388      */
 389     GEOM::GEOM_Object GetGeometryByMeshElement( in SMESH_Mesh  theMesh,
 390                                                 in long        theElementID,
 391                                                 in string      theGeomName)
 392       raises ( SALOME::SALOME_Exception );
 393
 394     /*!
 395      * Return geometrical object the given element is built on.
 396      * The returned geometrical object not published in study by this method.
 397      */
 398     GEOM::GEOM_Object FindGeometryByMeshElement( in SMESH_Mesh  theMesh,
 399                                                  in long        theElementID)
 400       raises ( SALOME::SALOME_Exception );
 401
 402     /*!
 403      * \brief Return id of object, registered in current study context
 404      *
 405      * Can be used to check if the object was created in the same container, as this engine.
 406      */
 407     long GetObjectId(in Object theObject);
 408
 409     /*!
 410      * \brief Get MED version of the file by its name.
 411      */
 412     boolean GetMEDVersion(in string theFileName, out MED_VERSION theVersion);
 413
 414     /*!
 415      * \brief Get names of meshes defined in file with the specified name.
 416      */
 417     string_array GetMeshNames(in string theFileName);
 418
 419     /*!
 420      * \brief Moves objects to the specified position
 421      *  \param what objects being moved
 422      *  \param where parent object where objects are moved to
 423      *  \param row position in the parent object's children list at which objects are moved
 424      *
 425      * This function is used in the drag-n-drop functionality.
 426      */
 427     void Move( in sobject_list what,
 428                in SALOMEDS::SObject where,
 429                in long row );
 430     /*!
 431      * Returns true if algorithm can be used to mesh a given geometry
 432      *  \param theAlgoType - the algorithm type
 433      *  \param theLibName - a name of the Plug-in library implementing the algorithm
 434      *  \param theShapeObject - the geometry to mesh
 435      *  \param toCheckAll - if \c True, returns \c True if all shapes are meshable,
 436      *         else, returns \c True if at least one shape is meshable
 437      */
 438     boolean IsApplicable( in string             theAlgoType,
 439                           in string             theLibName,
 440                           in GEOM::GEOM_Object  theShapeObject,
 441                           in boolean            toCheckAll );
 442
 443
 444     /*!
 445      * Return indices of elements, which are located inside the sphere
 446      *  \param theSource - mesh, sub-mesh or group
 447      *  \param theElemType - mesh element type
 448      *  \param theX - x cooridate of the center of the sphere
 449      *  \param theY - y cooridate of the center of the sphere
 450      *  \param theZ - y cooridate of the center of the sphere
 451      *  \param theR - radius of the sphere
 452      */
 453     long_array GetInsideSphere( in SMESH_IDSource theSource,
 454                                 in ElementType    theElemType,
 455                                 in double theX,
 456                                 in double theY,
 457                                 in double theZ,
 458                                 in double theR );
 459
 460     /*!
 461      * Return indices of elements, which are located inside the box
 462      *  \param theSource - mesh, sub-mesh or group
 463      *  \param theElemType - mesh element type
 464      *  \param theX1 - x cooridate of the first opposite point
 465      *  \param theY1 - y cooridate of the first opposite point
 466      *  \param theZ1 - y cooridate of the first opposite point
 467      *  \param theX2 - x cooridate of the second opposite point
 468      *  \param theY2 - y cooridate of the second opposite point
 469      *  \param theZ2 - y cooridate of the second opposite point
 470      */
 471     long_array GetInsideBox( in SMESH_IDSource theSource,
 472                              in ElementType    theElemType,
 473                              in double theX1,
 474                              in double theY1,
 475                              in double theZ1,
 476                              in double theX2,
 477                              in double theY2,
 478                              in double theZ2);
 479     /*!
 480      * Return indices of elements, which are located inside the box
 481      *  \param theSource - mesh, sub-mesh or group
 482      *  \param theElemType - mesh element type
 483      *  \param theX - x cooridate of the cented of the bottom face
 484      *  \param theY - y cooridate of the cented of the bottom face
 485      *  \param theZ - y cooridate of the cented of the bottom face
 486      *  \param theDX - x cooridate of the cented of the base vector
 487      *  \param theDY - y cooridate of the cented of the base vector
 488      *  \param theDZ - z cooridate of the cented of the base vector
 489      *  \param theH - height of the cylinder
 490      *  \param theR - radius of the cylinder
 491      */
 492     long_array GetInsideCylinder( in SMESH_IDSource theSource,
 493                                   in ElementType    theElemType,
 494                                   in double theX,
 495                                   in double theY,
 496                                   in double theZ,
 497                                   in double theDX,
 498                                   in double theDY,
 499                                   in double theDZ,
 500                                   in double theH,
 501                                   in double theR );
 502     /*!
 503      * Return indices of elements, which are located inside the geometry
 504      *  \param theSource - mesh, sub-mesh or group
 505      *  \param theElemType - mesh element type
 506      *  \param theGeom - geometrical object
 507      *  \param theTolerance - tolerance for selection.
 508      */
 509     long_array GetInside( in SMESH_IDSource theSource,
 510                           in ElementType    theElemType,
 511                           in GEOM::GEOM_Object theGeom,
 512                           in double theTolerance );
 513
 514
 515   };
 516
 517 };
 518
 519 #endif