idl/SMESH_Gen.idl

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