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