idl/SMESH_Gen.idl

   1 // Copyright (C) 2007-2016  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 definition 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 different 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      * Create a mesh by copying definitions of another mesh to a given geometry
 280      *  \param sourceMesh - a mesh to copy
 281      *  \param newGeometry - a new geometry
 282      *  \param meshName - a name of the new mesh
 283      *  \param toCopyGroups - to create groups in the new mesh
 284      *  \param toReuseHypotheses - if True, existing hypothesis will be used by the new mesh,
 285      *         otherwise new hypotheses with the same parameters will be created for the new mesh.
 286      *  \param toCopyElements - to copy mesh elements of same sub-shapes of the two geometries
 287      *  \param newMesh - return a new mesh
 288      *  \param newGroups - return new groups
 289      *  \param newSubmeshes - return new sub-meshes
 290      *  \param newHypotheses - return new algorithms and hypotheses
 291      *  \param invalidEntries - return study entries of objects whose
 292      *         counterparts are not found in the newGeometry, followed by entries
 293      *         of mesh sub-objects that are invalid because they depend on a not found
 294      *         preceeding sub-shape
 295      */
 296     boolean CopyMeshWithGeom( in SMESH_Mesh        sourceMesh,
 297                               in GEOM::GEOM_Object newGeometry,
 298                               in string            meshName,
 299                               in boolean           toCopyGroups,
 300                               in boolean           toReuseHypotheses,
 301                               in boolean           toCopyElements,
 302                               out SMESH_Mesh       newMesh,
 303                               out ListOfGroups     newGroups,
 304                               out submesh_array    newSubmeshes,
 305                               out ListOfHypothesis newHypotheses,
 306                               out string_array     invalidEntries)
 307       raises ( SALOME::SALOME_Exception );
 308
 309     /*!
 310      * Concatenate the given meshes or groups into one mesh.
 311      * Union groups with the same name and type if
 312      * theUniteIdenticalGroups flag is true.
 313      * Merge coincident nodes and elements if
 314      * theMergeNodesAndElements flag is true.
 315      */
 316     SMESH_Mesh Concatenate(in ListOfIDSources theMeshesArray,
 317                            in boolean         theUniteIdenticalGroups,
 318                            in boolean         theMergeNodesAndElements,
 319                            in double          theMergeTolerance)
 320       raises ( SALOME::SALOME_Exception );
 321
 322     /*!
 323      * Concatenate the given meshes into one mesh.
 324      * Union groups with the same name and type if
 325      * theUniteIdenticalGroups flag is true.
 326      * Merge coincident nodes and elements if
 327      * theMergeNodesAndElements flag is true.
 328      * Create the groups of all elements from initial meshes.
 329      */
 330     SMESH_Mesh ConcatenateWithGroups(in ListOfIDSources theMeshesArray,
 331                                      in boolean         theUniteIdenticalGroups,
 332                                      in boolean         theMergeNodesAndElements,
 333                                      in double          theMergeTolerance)
 334       raises ( SALOME::SALOME_Exception );
 335
 336     /*!
 337      * Mesh a subShape.
 338      * First, verify list of hypothesis associated with the Sub-shape,
 339      * return NOK if hypothesis are not sufficient
 340      */
 341     boolean Compute( in SMESH_Mesh        theMesh,
 342                      in GEOM::GEOM_Object theSubObject )
 343       raises ( SALOME::SALOME_Exception );
 344
 345     /*!
 346      * Cancel a computation.
 347      */
 348     void CancelCompute( in SMESH_Mesh        theMesh,
 349                         in GEOM::GEOM_Object theSubObject );
 350
 351     /*!
 352      * Return true if hypotheses are defined well
 353      */
 354     boolean IsReadyToCompute( in SMESH_Mesh        theMesh,
 355                               in GEOM::GEOM_Object theSubObject )
 356       raises ( SALOME::SALOME_Exception );
 357
 358     /*!
 359      * Evaluates size of prospective mesh on a shape
 360      */
 361     long_array  Evaluate(in SMESH_Mesh        theMesh,
 362                          in GEOM::GEOM_Object theSubObject)
 363       raises ( SALOME::SALOME_Exception );
 364
 365     /*!
 366      * Calculate Mesh as preview till indicated dimension
 367      * First, verify list of hypothesis associated with the Sub-shape.
 368      * Return mesh preview structure
 369      */
 370     MeshPreviewStruct Precompute( in SMESH_Mesh        theMesh,
 371                                   in GEOM::GEOM_Object theSubObject,
 372                                   in Dimension         theDimension,
 373                                   inout long_array    theShapesId )
 374       raises ( SALOME::SALOME_Exception );
 375
 376     /*!
 377      * Return errors of hypotheses definition
 378      * algo_error_array is empty if everything is OK
 379      */
 380     algo_error_array GetAlgoState( in SMESH_Mesh        theMesh,
 381                                    in GEOM::GEOM_Object theSubObject )
 382       raises ( SALOME::SALOME_Exception );
 383
 384     /*!
 385      * Return errors of mesh computation
 386      * compute_error_array is empty if everything is OK
 387      */
 388     compute_error_array GetComputeErrors( in SMESH_Mesh        theMesh,
 389                                           in GEOM::GEOM_Object theSubObject )
 390       raises ( SALOME::SALOME_Exception );
 391
 392     /*!
 393      * Return mesh elements preventing computation of a sub-shape
 394      */
 395     MeshPreviewStruct GetBadInputElements( in SMESH_Mesh theMesh,
 396                                            in short      theSubShapeID )
 397       raises ( SALOME::SALOME_Exception );
 398
 399     /*!
 400      * Create groups of elements preventing computation of a sub-shape
 401      */
 402     SMESH::ListOfGroups MakeGroupsOfBadInputElements( in SMESH_Mesh theMesh,
 403                                                       in short      theSubShapeID,
 404                                                       in string     theGroupName)
 405       raises ( SALOME::SALOME_Exception );
 406
 407     /*!
 408      * Return indices of faces, edges and vertices of given sub-shapes
 409      * within theMainObject
 410      */
 411     long_array GetSubShapesId( in GEOM::GEOM_Object theMainObject,
 412                                in object_array      theListOfSubObjects )
 413        raises ( SALOME::SALOME_Exception );
 414
 415     /*!
 416      * Return geometrical object the given element is built on.
 417      * The returned geometrical object, if not nil, is either found in the
 418      * study or is published by this method with the given name
 419      */
 420     GEOM::GEOM_Object GetGeometryByMeshElement( in SMESH_Mesh  theMesh,
 421                                                 in long        theElementID,
 422                                                 in string      theGeomName)
 423       raises ( SALOME::SALOME_Exception );
 424
 425     /*!
 426      * Return geometrical object the given element is built on.
 427      * The returned geometrical object not published in study by this method.
 428      */
 429     GEOM::GEOM_Object FindGeometryByMeshElement( in SMESH_Mesh  theMesh,
 430                                                  in long        theElementID)
 431       raises ( SALOME::SALOME_Exception );
 432
 433     /*!
 434      * \brief Return id of object, registered in current study context
 435      *
 436      * Can be used to check if the object was created in the same container, as this engine.
 437      */
 438     long GetObjectId(in Object theObject);
 439
 440     /*!
 441      * \brief Get MED version of the file by its name.
 442      */
 443     boolean GetMEDVersion(in string theFileName, out MED_VERSION theVersion);
 444
 445     /*!
 446      * \brief Get names of meshes defined in file with the specified name.
 447      */
 448     string_array GetMeshNames(in string theFileName);
 449
 450     /*!
 451      * \brief Moves objects to the specified position
 452      *  \param what objects being moved
 453      *  \param where parent object where objects are moved to
 454      *  \param row position in the parent object's children list at which objects are moved
 455      *
 456      * This function is used in the drag-n-drop functionality.
 457      */
 458     void Move( in sobject_list what,
 459                in SALOMEDS::SObject where,
 460                in long row );
 461     /*!
 462      * Returns true if algorithm can be used to mesh a given geometry
 463      *  \param theAlgoType - the algorithm type
 464      *  \param theLibName - a name of the Plug-in library implementing the algorithm
 465      *  \param theShapeObject - the geometry to mesh
 466      *  \param toCheckAll - if \c True, returns \c True if all shapes are meshable,
 467      *         else, returns \c True if at least one shape is meshable
 468      */
 469     boolean IsApplicable( in string             theAlgoType,
 470                           in string             theLibName,
 471                           in GEOM::GEOM_Object  theShapeObject,
 472                           in boolean            toCheckAll );
 473
 474
 475     /*!
 476      * Return indices of elements, which are located inside the sphere
 477      *  \param theSource - mesh, sub-mesh or group
 478      *  \param theElemType - mesh element type
 479      *  \param theX - x cooridate of the center of the sphere
 480      *  \param theY - y cooridate of the center of the sphere
 481      *  \param theZ - y cooridate of the center of the sphere
 482      *  \param theR - radius of the sphere
 483      */
 484     long_array GetInsideSphere( in SMESH_IDSource theSource,
 485                                 in ElementType    theElemType,
 486                                 in double theX,
 487                                 in double theY,
 488                                 in double theZ,
 489                                 in double theR );
 490
 491     /*!
 492      * Return indices of elements, which are located inside the box
 493      *  \param theSource - mesh, sub-mesh or group
 494      *  \param theElemType - mesh element type
 495      *  \param theX1 - x cooridate of the first opposite point
 496      *  \param theY1 - y cooridate of the first opposite point
 497      *  \param theZ1 - y cooridate of the first opposite point
 498      *  \param theX2 - x cooridate of the second opposite point
 499      *  \param theY2 - y cooridate of the second opposite point
 500      *  \param theZ2 - y cooridate of the second opposite point
 501      */
 502     long_array GetInsideBox( in SMESH_IDSource theSource,
 503                              in ElementType    theElemType,
 504                              in double theX1,
 505                              in double theY1,
 506                              in double theZ1,
 507                              in double theX2,
 508                              in double theY2,
 509                              in double theZ2);
 510     /*!
 511      * Return indices of elements, which are located inside the box
 512      *  \param theSource - mesh, sub-mesh or group
 513      *  \param theElemType - mesh element type
 514      *  \param theX - x cooridate of the cented of the bottom face
 515      *  \param theY - y cooridate of the cented of the bottom face
 516      *  \param theZ - y cooridate of the cented of the bottom face
 517      *  \param theDX - x cooridate of the cented of the base vector
 518      *  \param theDY - y cooridate of the cented of the base vector
 519      *  \param theDZ - z cooridate of the cented of the base vector
 520      *  \param theH - height of the cylinder
 521      *  \param theR - radius of the cylinder
 522      */
 523     long_array GetInsideCylinder( in SMESH_IDSource theSource,
 524                                   in ElementType    theElemType,
 525                                   in double theX,
 526                                   in double theY,
 527                                   in double theZ,
 528                                   in double theDX,
 529                                   in double theDY,
 530                                   in double theDZ,
 531                                   in double theH,
 532                                   in double theR );
 533     /*!
 534      * Return indices of elements, which are located inside the geometry
 535      *  \param theSource - mesh, sub-mesh or group
 536      *  \param theElemType - mesh element type
 537      *  \param theGeom - geometrical object
 538      *  \param theTolerance - tolerance for selection.
 539      */
 540     long_array GetInside( in SMESH_IDSource theSource,
 541                           in ElementType    theElemType,
 542                           in GEOM::GEOM_Object theGeom,
 543                           in double theTolerance );
 544
 545
 546   };
 547
 548 };
 549
 550 #endif