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