idl/SMESH_Gen.idl

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