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