idl/SMESH_Gen.idl

   1 // Copyright (C) 2007-2021  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   interface MG_ADAPT;
  47   interface MG_ADAPT_OBJECT;
  48
  49   /*!
  50    * Tags definition
  51    */
  52   // Top level
  53   const long Tag_HypothesisRoot = 1; // hypotheses root
  54   const long Tag_AlgorithmsRoot = 2; // algorithms root
  55   const long Tag_FirstMeshRoot  = 3; // first mesh root
  56   // Mesh/Submesh
  57   const long Tag_RefOnShape             = 1; // references to shape
  58   const long Tag_RefOnAppliedHypothesis = 2; // applied hypotheses root
  59   const long Tag_RefOnAppliedAlgorithms = 3; // applied algorithms root
  60   // Mesh only: sub-meshes roots by type
  61   const long Tag_FirstSubMesh           =  4;
  62   const long Tag_SubMeshOnVertex        =  4;
  63   const long Tag_SubMeshOnEdge          =  5;
  64   const long Tag_SubMeshOnWire          =  6;
  65   const long Tag_SubMeshOnFace          =  7;
  66   const long Tag_SubMeshOnShell         =  8;
  67   const long Tag_SubMeshOnSolid         =  9;
  68   const long Tag_SubMeshOnCompound      = 10;
  69   const long Tag_LastSubMesh            = 10;
  70   // Mesh only: group roots by type
  71   const long Tag_FirstGroup             = 11;
  72   const long Tag_NodeGroups             = 11;
  73   const long Tag_EdgeGroups             = 12;
  74   const long Tag_FaceGroups             = 13;
  75   const long Tag_VolumeGroups           = 14;
  76   const long Tag_0DElementsGroups       = 15;
  77   const long Tag_BallElementsGroups     = 16;
  78   const long Tag_LastGroup              = 16;
  79
  80   /*!
  81    * Hypothesis definition error
  82    */
  83   struct AlgoStateError
  84   {
  85     Hypothesis_Status  state;
  86     string             algoName;
  87     long               algoDim;
  88     boolean            isGlobalAlgo;
  89   };
  90   typedef sequence<AlgoStateError> algo_error_array;
  91
  92   /*!
  93    * Mesh computation error
  94    */
  95   enum ComputeErrorName
  96   {
  97     COMPERR_OK            ,
  98     COMPERR_BAD_INPUT_MESH,  // wrong mesh on lower submesh
  99     COMPERR_STD_EXCEPTION ,  // some std exception raised
 100     COMPERR_OCC_EXCEPTION ,  // OCC exception raised
 101     COMPERR_SLM_EXCEPTION ,  // SALOME exception raised
 102     COMPERR_EXCEPTION     ,  // other exception raised
 103     COMPERR_MEMORY_PB     ,  // memory allocation problem
 104     COMPERR_ALGO_FAILED   ,  // computation failed
 105     COMPERR_BAD_SHAPE     ,  // bad geometry
 106     COMPERR_WARNING       ,  // algo reports error but sub-mesh is computed anyway
 107     COMPERR_CANCELED      ,  // compute canceled
 108     COMPERR_NO_MESH_ON_SHAPE,// no mesh elements assigned to sub-mesh
 109     COMPERR_BAD_PARMETERS    // incorrect hypotheses parameters
 110   };
 111   struct ComputeError
 112   {
 113     short   code;       // ComputeErrorName or, if negative, algo specific code
 114     string  comment;    // textual problem description
 115     string  algoName;
 116     short   subShapeID; // id of sub-shape of a shape to mesh
 117     boolean hasBadMesh; // there are elements preventing computation available for visualization
 118   };
 119   typedef sequence<ComputeError> compute_error_array;
 120
 121   /*!
 122    * Way to initialize hypothesis
 123    */
 124   struct HypInitParams
 125   {
 126     short   way; // 0 - by mesh, 1 - by geometry size + preferred parameters, 2 - by averageLength
 127     double  averageLength;
 128     boolean quadDominated;
 129   };
 130
 131   interface SMESH_Gen : Engines::EngineComponent, SALOMEDS::Driver
 132   {
 133     //GEOM::GEOM_Gen SetGeomEngine( in string containerLoc );
 134     void SetGeomEngine( in GEOM::GEOM_Gen geomcompo );
 135
 136     FilterManager CreateFilterManager();
 137
 138     SMESH_Pattern GetPattern();
 139
 140     Measurements  CreateMeasurements();
 141
 142     /*!
 143       Set the current mode
 144      */
 145     void SetEmbeddedMode( in boolean theMode );
 146
 147     /*!
 148       Get the current mode
 149      */
 150     boolean IsEmbeddedMode();
 151
 152     /*!
 153       Update the study
 154      */
 155     void UpdateStudy();
 156
 157     /*!
 158       Set enable publishing in the study
 159      */
 160     void SetEnablePublish( in boolean theIsEnablePublish );
 161
 162     /*!
 163       Get enable publishing in the study
 164      */
 165     boolean IsEnablePublish();
 166
 167     /*!
 168      * Create a hypothesis that can be shared by different parts of the mesh.
 169      * An hypothesis is either:
 170      * - a method used to generate or modify a part of the mesh (algorithm).
 171      * - a parameter or a law used by an algorithm.
 172      * Algorithms are 1D, 2D or 3D.
 173      */
 174     SMESH_Hypothesis CreateHypothesis( in string theHypName,
 175                                        in string theLibName )
 176       raises ( SALOME::SALOME_Exception );
 177
 178     /*!
 179      * Create a hypothesis and initialize it by average length
 180      */
 181     SMESH_Hypothesis CreateHypothesisByAverageLength( in string  theHypName,
 182                                                       in string  theLibName,
 183                                                       in double  theAverageLength,
 184                                                       in boolean theQuadDominated)
 185       raises ( SALOME::SALOME_Exception );
 186
 187     /*!
 188      * Return a hypothesis holding parameter values corresponding either to the mesh
 189      * existing on the given geometry or to size of the geometry.
 190      * The returned hypothesis may be the one existing in a study and used
 191      * to compute the mesh, or a temporary one created just to pass parameter
 192      * values.
 193      */
 194     SMESH_Hypothesis GetHypothesisParameterValues( in string            theHypName,
 195                                                    in string            theLibName,
 196                                                    in SMESH_Mesh        theMesh,
 197                                                    in GEOM::GEOM_Object theGeom,
 198                                                    in HypInitParams     theWay)
 199       raises ( SALOME::SALOME_Exception );
 200
 201     /*!
 202      * Returns \c True if a hypothesis is assigned to a sole sub-mesh in a current Study
 203      *  \param [in] theHyp - the hypothesis of interest
 204      *  \param [out] theMesh - the sole mesh using \a theHyp
 205      *  \param [out] theShape - the sole geometry \a theHyp is assigned to
 206      *  \return boolean - \c True if \a theMesh and \a theShape are sole using \a theHyp
 207      */
 208     boolean GetSoleSubMeshUsingHyp( in SMESH_Hypothesis   theHyp,
 209                                     out SMESH_Mesh        theMesh,
 210                                     out GEOM::GEOM_Object theShape);
 211
 212     /*!
 213      * Sets number of segments per diagonal of boundary box of geometry by which
 214      * default segment length of appropriate 1D hypotheses is defined
 215      */
 216     void SetBoundaryBoxSegmentation( in long theNbSegments ) raises ( SALOME::SALOME_Exception );
 217     /*!
 218      * \brief Sets default number of segments per edge
 219      */
 220     void SetDefaultNbSegments( in long theNbSegments) raises ( SALOME::SALOME_Exception );
 221
 222     /*!
 223      * Set the object name
 224      */
 225     void SetName( in string theObjectIOR,
 226                   in string theObjectName )
 227       raises ( SALOME::SALOME_Exception );
 228
 229     /*!
 230      * Create a Mesh object, given a geometry shape.
 231      * Mesh is created empty (no points, no elements).
 232      * Shape is explored via GEOM_Client to create local copies.
 233      * of TopoDS_Shapes and bind CORBA references of shape & subshapes
 234      * with TopoDS_Shapes
 235      */
 236     SMESH_Mesh CreateMesh( in GEOM::GEOM_Object theObject )
 237       raises ( SALOME::SALOME_Exception );
 238
 239     /*!
 240      * Create an empty mesh object
 241      */
 242     SMESH_Mesh CreateEmptyMesh()
 243       raises ( SALOME::SALOME_Exception );
 244
 245     /*!
 246      * Create Mesh object importing data from given UNV file
 247      * (UNV supported version is I-DEAS 10)
 248      */
 249     SMESH_Mesh CreateMeshesFromUNV( in string theFileName )
 250       raises ( SALOME::SALOME_Exception );
 251
 252     /*!
 253      * Create Mesh object(s) importing data from given MED file
 254      */
 255      mesh_array CreateMeshesFromMED( in string theFileName,
 256                                      out SMESH::DriverMED_ReadStatus theStatus )
 257        raises ( SALOME::SALOME_Exception );
 258
 259     /*!
 260      * Create Mesh object(s) importing data from given MED file
 261      */
 262      mesh_array CreateMeshesFromSAUV( in string theFileName,
 263                                       out SMESH::DriverMED_ReadStatus theStatus )
 264        raises ( SALOME::SALOME_Exception );
 265
 266     /*!
 267      * Create Mesh object importing data from given STL file
 268      */
 269     SMESH_Mesh CreateMeshesFromSTL( in string theFileName )
 270       raises ( SALOME::SALOME_Exception );
 271
 272     /*!
 273      * Create Mesh object(s) importing data from given CGNS file
 274      */
 275     mesh_array CreateMeshesFromCGNS( in string theFileName,
 276                                      out SMESH::DriverMED_ReadStatus theStatus )
 277       raises ( SALOME::SALOME_Exception );
 278
 279     /*!
 280      * Create Mesh object importing data from given GMF file
 281      *  \param theFileName - a name of file to import
 282      *  \param theMakeRequiredGroups - if true, groups of required entities will be created
 283      */
 284     SMESH_Mesh CreateMeshesFromGMF( in string               theFileName,
 285                                     in boolean              theMakeRequiredGroups,
 286                                     out SMESH::ComputeError theError)
 287       raises ( SALOME::SALOME_Exception );
 288
 289     /*!
 290      * Create a mesh by copying a part of another mesh
 291      *  \param meshPart - a part of mesh to copy
 292      *  \param meshName - a name of the new mesh
 293      *  \param toCopyGroups - to create in the new mesh groups
 294      *                        the copied elements belongs to
 295      *  \param toKeepIDs - to preserve IDs of the copied elements or not
 296      */
 297     SMESH_Mesh CopyMesh(in SMESH_IDSource meshPart,
 298                         in string         meshName,
 299                         in boolean        toCopyGroups,
 300                         in boolean        toKeepIDs)
 301       raises ( SALOME::SALOME_Exception );
 302
 303     /*!
 304      * Create a mesh by copying definitions of another mesh to a given geometry
 305      *  \param sourceMesh - a mesh to copy
 306      *  \param newGeometry - a new geometry
 307      *  \param meshName - a name of the new mesh
 308      *  \param toCopyGroups - to create groups in the new mesh
 309      *  \param toReuseHypotheses - if True, existing hypothesis will be used by the new mesh,
 310      *         otherwise new hypotheses with the same parameters will be created for the new mesh.
 311      *  \param toCopyElements - to copy mesh elements of same sub-shapes of the two geometries
 312      *  \param newMesh - return a new mesh
 313      *  \param newGroups - return new groups
 314      *  \param newSubmeshes - return new sub-meshes
 315      *  \param newHypotheses - return new algorithms and hypotheses
 316      *  \param invalidEntries - return study entries of objects whose
 317      *         counterparts are not found in the newGeometry, followed by entries
 318      *         of mesh sub-objects that are invalid because they depend on a not found
 319      *         preceding sub-shape
 320      */
 321     boolean CopyMeshWithGeom( in SMESH_Mesh        sourceMesh,
 322                               in GEOM::GEOM_Object newGeometry,
 323                               in string            meshName,
 324                               in boolean           toCopyGroups,
 325                               in boolean           toReuseHypotheses,
 326                               in boolean           toCopyElements,
 327                               out SMESH_Mesh       newMesh,
 328                               out ListOfGroups     newGroups,
 329                               out submesh_array    newSubmeshes,
 330                               out ListOfHypothesis newHypotheses,
 331                               out string_array     invalidEntries)
 332       raises ( SALOME::SALOME_Exception );
 333
 334     /*!
 335      * Concatenate the given meshes or groups into one mesh,
 336      * optionally to theMeshToAppendTo.
 337      * Union groups with the same name and type if
 338      * theUniteIdenticalGroups flag is true.
 339      * Merge coincident nodes and elements if
 340      * theMergeNodesAndElements flag is true.
 341      */
 342     SMESH_Mesh Concatenate(in ListOfIDSources theMeshesArray,
 343                            in boolean         theUniteIdenticalGroups,
 344                            in boolean         theMergeNodesAndElements,
 345                            in double          theMergeTolerance,
 346                            in SMESH_Mesh      theMeshToAppendTo)
 347       raises ( SALOME::SALOME_Exception );
 348
 349     /*!
 350      * Concatenate the given meshes into one mesh,
 351      * optionally to theMeshToAppendTo.
 352      * Union groups with the same name and type if
 353      * theUniteIdenticalGroups flag is true.
 354      * Merge coincident nodes and elements if
 355      * theMergeNodesAndElements flag is true.
 356      * Create the groups of all elements from initial meshes.
 357      */
 358     SMESH_Mesh ConcatenateWithGroups(in ListOfIDSources theMeshesArray,
 359                                      in boolean         theUniteIdenticalGroups,
 360                                      in boolean         theMergeNodesAndElements,
 361                                      in double          theMergeTolerance,
 362                                      in SMESH_Mesh      theMeshToAppendTo)
 363       raises ( SALOME::SALOME_Exception );
 364
 365     /*!
 366      * Mesh a subShape.
 367      * First, verify list of hypothesis associated with the Sub-shape,
 368      * return NOK if hypothesis are not sufficient
 369      */
 370     boolean Compute( in SMESH_Mesh        theMesh,
 371                      in GEOM::GEOM_Object theSubObject )
 372       raises ( SALOME::SALOME_Exception );
 373
 374     /*!
 375      * Cancel a computation.
 376      */
 377     void CancelCompute( in SMESH_Mesh        theMesh,
 378                         in GEOM::GEOM_Object theSubObject );
 379
 380     /*!
 381      * Return true if hypotheses are defined well
 382      */
 383     boolean IsReadyToCompute( in SMESH_Mesh        theMesh,
 384                               in GEOM::GEOM_Object theSubObject )
 385       raises ( SALOME::SALOME_Exception );
 386
 387     /*!
 388      * Evaluates size of prospective mesh on a shape
 389      */
 390     long_array  Evaluate(in SMESH_Mesh        theMesh,
 391                          in GEOM::GEOM_Object theSubObject)
 392       raises ( SALOME::SALOME_Exception );
 393
 394     /*!
 395      * Calculate Mesh as preview till indicated dimension
 396      * First, verify list of hypothesis associated with the Sub-shape.
 397      * Return mesh preview structure
 398      */
 399     MeshPreviewStruct Precompute( in SMESH_Mesh        theMesh,
 400                                   in GEOM::GEOM_Object theSubObject,
 401                                   in Dimension         theDimension,
 402                                   inout long_array    theShapesId )
 403       raises ( SALOME::SALOME_Exception );
 404
 405     /*!
 406      * Return errors of hypotheses definition
 407      * algo_error_array is empty if everything is OK
 408      */
 409     algo_error_array GetAlgoState( in SMESH_Mesh        theMesh,
 410                                    in GEOM::GEOM_Object theSubObject )
 411       raises ( SALOME::SALOME_Exception );
 412
 413     /*!
 414      * Return errors of mesh computation
 415      * compute_error_array is empty if everything is OK
 416      */
 417     compute_error_array GetComputeErrors( in SMESH_Mesh        theMesh,
 418                                           in GEOM::GEOM_Object theSubObject )
 419       raises ( SALOME::SALOME_Exception );
 420
 421     /*!
 422      * Return mesh elements preventing computation of a sub-shape
 423      */
 424     MeshPreviewStruct GetBadInputElements( in SMESH_Mesh theMesh,
 425                                            in short      theSubShapeID )
 426       raises ( SALOME::SALOME_Exception );
 427
 428     /*!
 429      * Create groups of elements preventing computation of a sub-shape
 430      */
 431     SMESH::ListOfGroups MakeGroupsOfBadInputElements( in SMESH_Mesh theMesh,
 432                                                       in short      theSubShapeID,
 433                                                       in string     theGroupName)
 434       raises ( SALOME::SALOME_Exception );
 435
 436     /*!
 437      * Return indices of faces, edges and vertices of given sub-shapes
 438      * within theMainObject
 439      */
 440     long_array GetSubShapesId( in GEOM::GEOM_Object theMainObject,
 441                                in object_array      theListOfSubObjects )
 442        raises ( SALOME::SALOME_Exception );
 443
 444     /*!
 445      * Return geometrical object the given element is built on.
 446      * The returned geometrical object, if not nil, is either found in the
 447      * study or is published by this method with the given name
 448      */
 449     GEOM::GEOM_Object GetGeometryByMeshElement( in SMESH_Mesh  theMesh,
 450                                                 in long        theElementID,
 451                                                 in string      theGeomName)
 452       raises ( SALOME::SALOME_Exception );
 453
 454     /*!
 455      * Return geometrical object the given element is built on.
 456      * The returned geometrical object not published in study by this method.
 457      */
 458     GEOM::GEOM_Object FindGeometryByMeshElement( in SMESH_Mesh  theMesh,
 459                                                  in long        theElementID)
 460       raises ( SALOME::SALOME_Exception );
 461
 462     /*!
 463      * \brief Return id of object, registered in current study context
 464      *
 465      * Can be used to check if the object was created in the same container, as this engine.
 466      */
 467     long GetObjectId(in Object theObject);
 468
 469     /*!
 470      * \brief Get version of MED format being used.
 471      */
 472     string GetMEDFileVersion();
 473
 474     /*!
 475      * \brief Get MED version of the file by its name.
 476      */
 477     string GetMEDVersion(in string theFileName);
 478
 479     /*!
 480      * \brief Check compatibility of file with MED format being used, for read only.
 481      */
 482     boolean CheckCompatibility(in string theFileName);
 483
 484     /*!
 485      * \brief Check compatibility of file with MED format being used, for append on write.
 486      */
 487     boolean CheckWriteCompatibility(in string theFileName);
 488
 489     /*!
 490      * \brief Get names of meshes defined in file with the specified name.
 491      */
 492     string_array GetMeshNames(in string theFileName);
 493
 494     /*!
 495      * \brief Moves objects to the specified position
 496      *  \param what objects being moved
 497      *  \param where parent object where objects are moved to
 498      *  \param row position in the parent object's children list at which objects are moved
 499      *
 500      * This function is used in the drag-n-drop functionality.
 501      */
 502     void Move( in sobject_list what,
 503                in SALOMEDS::SObject where,
 504                in long row );
 505     /*!
 506      * Returns true if algorithm can be used to mesh a given geometry
 507      *  \param theAlgoType - the algorithm type
 508      *  \param theLibName - a name of the Plug-in library implementing the algorithm
 509      *  \param theShapeObject - the geometry to mesh
 510      *  \param toCheckAll - if \c True, returns \c True if all shapes are meshable,
 511      *         else, returns \c True if at least one shape is meshable
 512      */
 513     boolean IsApplicable( in string             theAlgoType,
 514                           in string             theLibName,
 515                           in GEOM::GEOM_Object  theShapeObject,
 516                           in boolean            toCheckAll );
 517
 518
 519     /*!
 520      * Return indices of elements, which are located inside the sphere
 521      *  \param theSource - mesh, sub-mesh or group
 522      *  \param theElemType - mesh element type
 523      *  \param theX - x coordinate of the center of the sphere
 524      *  \param theY - y coordinate of the center of the sphere
 525      *  \param theZ - y coordinate of the center of the sphere
 526      *  \param theR - radius of the sphere
 527      */
 528     long_array GetInsideSphere( in SMESH_IDSource theSource,
 529                                 in ElementType    theElemType,
 530                                 in double theX,
 531                                 in double theY,
 532                                 in double theZ,
 533                                 in double theR );
 534
 535     /*!
 536      * Return indices of elements, which are located inside the box
 537      *  \param theSource - mesh, sub-mesh or group
 538      *  \param theElemType - mesh element type
 539      *  \param theX1 - x coordinate of the first opposite point
 540      *  \param theY1 - y coordinate of the first opposite point
 541      *  \param theZ1 - y coordinate of the first opposite point
 542      *  \param theX2 - x coordinate of the second opposite point
 543      *  \param theY2 - y coordinate of the second opposite point
 544      *  \param theZ2 - y coordinate of the second opposite point
 545      */
 546     long_array GetInsideBox( in SMESH_IDSource theSource,
 547                              in ElementType    theElemType,
 548                              in double theX1,
 549                              in double theY1,
 550                              in double theZ1,
 551                              in double theX2,
 552                              in double theY2,
 553                              in double theZ2);
 554     /*!
 555      * Return indices of elements, which are located inside the box
 556      *  \param theSource - mesh, sub-mesh or group
 557      *  \param theElemType - mesh element type
 558      *  \param theX - x coordinate of the cented of the bottom face
 559      *  \param theY - y coordinate of the cented of the bottom face
 560      *  \param theZ - y coordinate of the cented of the bottom face
 561      *  \param theDX - x coordinate of the cented of the base vector
 562      *  \param theDY - y coordinate of the cented of the base vector
 563      *  \param theDZ - z coordinate of the cented of the base vector
 564      *  \param theH - height of the cylinder
 565      *  \param theR - radius of the cylinder
 566      */
 567     long_array GetInsideCylinder( in SMESH_IDSource theSource,
 568                                   in ElementType    theElemType,
 569                                   in double theX,
 570                                   in double theY,
 571                                   in double theZ,
 572                                   in double theDX,
 573                                   in double theDY,
 574                                   in double theDZ,
 575                                   in double theH,
 576                                   in double theR );
 577     /*!
 578      * Return indices of elements, which are located inside the geometry
 579      *  \param theSource - mesh, sub-mesh or group
 580      *  \param theElemType - mesh element type
 581      *  \param theGeom - geometrical object
 582      *  \param theTolerance - tolerance for selection.
 583      */
 584     long_array GetInside( in SMESH_IDSource theSource,
 585                           in ElementType    theElemType,
 586                           in GEOM::GEOM_Object theGeom,
 587                           in double theTolerance );
 588
 589     MG_ADAPT CreateMG_ADAPT();
 590     MG_ADAPT_OBJECT Adaptation(in string adaptType);
 591     MG_ADAPT CreateAdaptationHypothesis();
 592   };
 593
 594 };
 595
 596 #endif