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