]> SALOME platform Git repositories - modules/smesh.git/blob - idl/SMESH_Gen.idl
Salome HOME
Improve documentation
[modules/smesh.git] / idl / SMESH_Gen.idl
1 // Copyright (C) 2007-2013  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.
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<GEOM::GEOM_Object> object_array;
40   typedef sequence<SMESH_Mesh>        mesh_array;
41
42   interface FilterManager;
43   interface SMESH_Pattern;
44   interface Measurements;
45
46   /*!
47    * Tags definition
48    */
49   // Top level
50   const long Tag_HypothesisRoot = 1; // hypotheses root
51   const long Tag_AlgorithmsRoot = 2; // algorithms root
52   const long Tag_FirstMeshRoot  = 3; // first mesh root
53   // Mesh/Submesh
54   const long Tag_RefOnShape             = 1; // references to shape
55   const long Tag_RefOnAppliedHypothesis = 2; // applied hypotheses root
56   const long Tag_RefOnAppliedAlgorithms = 3; // applied algorithms root
57   // Mesh only: sub-meshes roots by type
58   const long Tag_FirstSubMesh           =  4;
59   const long Tag_SubMeshOnVertex        =  4;
60   const long Tag_SubMeshOnEdge          =  5;
61   const long Tag_SubMeshOnWire          =  6;
62   const long Tag_SubMeshOnFace          =  7;
63   const long Tag_SubMeshOnShell         =  8;
64   const long Tag_SubMeshOnSolid         =  9;
65   const long Tag_SubMeshOnCompound      = 10;
66   const long Tag_LastSubMesh            = 10;
67   // Mesh only: group roots by type
68   const long Tag_FirstGroup             = 11;
69   const long Tag_NodeGroups             = 11;
70   const long Tag_EdgeGroups             = 12;
71   const long Tag_FaceGroups             = 13;
72   const long Tag_VolumeGroups           = 14;
73   const long Tag_0DElementsGroups       = 15;
74   const long Tag_BallElementsGroups     = 16;
75   const long Tag_LastGroup              = 16;
76
77   /*!
78    * Hypothesis definintion error
79    */
80   struct AlgoStateError
81   {
82     Hypothesis_Status  state;
83     string             algoName;
84     long               algoDim;
85     boolean            isGlobalAlgo;
86   };
87   typedef sequence<AlgoStateError> algo_error_array;
88
89   /*!
90    * Mesh computation error
91    */
92   enum ComputeErrorName
93   {
94     COMPERR_OK            ,
95     COMPERR_BAD_INPUT_MESH,  // wrong mesh on lower submesh
96     COMPERR_STD_EXCEPTION ,  // some std exception raised
97     COMPERR_OCC_EXCEPTION ,  // OCC exception raised
98     COMPERR_SLM_EXCEPTION ,  // SALOME exception raised
99     COMPERR_EXCEPTION     ,  // other exception raised
100     COMPERR_MEMORY_PB     ,  // memory allocation problem
101     COMPERR_ALGO_FAILED   ,  // computation failed
102     COMPERR_BAD_SHAPE     ,  // bad geometry
103     COMPERR_WARNING       ,  // algo reports error but sub-mesh is computed anyway
104     COMPERR_CANCELED      ,  // compute canceled
105     COMPERR_NO_MESH_ON_SHAPE // no mesh elements assigned to sub-mesh
106   };
107   struct ComputeError
108   {
109     short   code;       // ComputeErrorName or, if negative, algo specific code
110     string  comment;    // textual problem description
111     string  algoName;
112     short   subShapeID; // id of sub-shape of a shape to mesh
113     boolean hasBadMesh; // there are elements preventing computation available for visualization
114   };
115   typedef sequence<ComputeError> compute_error_array;
116
117
118   interface SMESH_Gen : Engines::EngineComponent, SALOMEDS::Driver
119   {
120     //GEOM::GEOM_Gen SetGeomEngine( in string containerLoc );
121     void SetGeomEngine( in GEOM::GEOM_Gen geomcompo );
122
123     FilterManager CreateFilterManager();
124
125     SMESH_Pattern GetPattern();
126
127     Measurements  CreateMeasurements();
128
129     /*!
130       Set the current mode
131      */
132     void SetEmbeddedMode( in boolean theMode );
133
134     /*!
135       Get the current mode
136      */
137     boolean IsEmbeddedMode();
138
139     /*!
140       Set the current study
141      */
142     void SetCurrentStudy( in SALOMEDS::Study theStudy );
143
144     /*!
145       Get the current study
146      */
147     SALOMEDS::Study GetCurrentStudy();
148
149     /*!
150      * Create a hypothesis that can be shared by differents parts of the mesh.
151      * An hypothesis is either:
152      * - a method used to generate or modify a part of the mesh (algorithm).
153      * - a parameter or a law used by an algorithm.
154      * Algorithms are 1D, 2D or 3D.
155      */
156     SMESH_Hypothesis CreateHypothesis( in string theHypName,
157                                        in string theLibName )
158       raises ( SALOME::SALOME_Exception );
159
160     /*!
161      * Return a hypothesis holding parameter values corresponding either to the mesh
162      * existing on the given geometry or to size of the geometry.
163      * The returned hypothesis may be the one existing in a study and used
164      * to compute the mesh, or a temporary one created just to pass parameter
165      * values.
166      */
167     SMESH_Hypothesis GetHypothesisParameterValues( in string            theHypName,
168                                                    in string            theLibName,
169                                                    in SMESH_Mesh        theMesh,
170                                                    in GEOM::GEOM_Object theGeom,
171                                                    in boolean           byMesh)
172       raises ( SALOME::SALOME_Exception );
173
174     /*!
175      * Sets number of segments per diagonal of boundary box of geometry by which
176      * default segment length of appropriate 1D hypotheses is defined
177      */
178     void SetBoundaryBoxSegmentation( in long theNbSegments ) raises ( SALOME::SALOME_Exception );
179     /*!
180      * \brief Sets default number of segments per edge
181      */
182     void SetDefaultNbSegments( in long theNbSegments) raises ( SALOME::SALOME_Exception );
183
184     /*!
185      * Set the object name
186      */
187     void SetName( in string theObjectIOR,
188                   in string theObjectName )
189       raises ( SALOME::SALOME_Exception );
190
191     /*!
192      * Create a Mesh object, given a geometry shape.
193      * Mesh is created empty (no points, no elements).
194      * Shape is explored via GEOM_Client to create local copies.
195      * of TopoDS_Shapes and bind CORBA references of shape & subshapes
196      * with TopoDS_Shapes
197      */
198     SMESH_Mesh CreateMesh( in GEOM::GEOM_Object theObject )
199       raises ( SALOME::SALOME_Exception );
200
201     /*!
202      * Create an empty mesh object
203      */
204     SMESH_Mesh CreateEmptyMesh()
205       raises ( SALOME::SALOME_Exception );
206
207     /*!
208      * Create Mesh object importing data from given UNV file
209      * (UNV supported version is I-DEAS 10)
210      */
211     SMESH_Mesh CreateMeshesFromUNV( in string theFileName )
212       raises ( SALOME::SALOME_Exception );
213
214     /*!
215      * Create Mesh object(s) importing data from given MED file
216      */
217      mesh_array CreateMeshesFromMED( in string theFileName,
218                                      out SMESH::DriverMED_ReadStatus theStatus )
219        raises ( SALOME::SALOME_Exception );
220
221     /*!
222      * Create Mesh object(s) importing data from given MED file
223      */
224      mesh_array CreateMeshesFromSAUV( in string theFileName,
225                                       out SMESH::DriverMED_ReadStatus theStatus )
226        raises ( SALOME::SALOME_Exception );
227
228     /*!
229      * Create Mesh object importing data from given STL file
230      */
231     SMESH_Mesh CreateMeshesFromSTL( in string theFileName )
232       raises ( SALOME::SALOME_Exception );
233
234     /*!
235      * Create Mesh object(s) importing data from given CGNS file
236      */
237     mesh_array CreateMeshesFromCGNS( in string theFileName,
238                                      out SMESH::DriverMED_ReadStatus theStatus )
239       raises ( SALOME::SALOME_Exception );
240
241     /*!
242      * Create Mesh object importing data from given GMF file
243      *  \param theFileName - a name of file to import
244      *  \param theMakeRequiredGroups - if true, groups of required entities will be created
245      */
246     SMESH_Mesh CreateMeshesFromGMF( in string               theFileName,
247                                     in boolean              theMakeRequiredGroups,
248                                     out SMESH::ComputeError theError)
249       raises ( SALOME::SALOME_Exception );
250
251     /*!
252      * Create a mesh by copying a part of another mesh
253      *  \param meshPart - a part of mesh to copy
254      *  \param meshName - a name of the new mesh
255      *  \param toCopyGroups - to create in the new mesh groups
256      *                        the copied elements belongs to
257      *  \param toKeepIDs - to preserve IDs of the copied elements or not
258      */
259     SMESH_Mesh CopyMesh(in SMESH_IDSource meshPart,
260                         in string         meshName,
261                         in boolean        toCopyGroups,
262                         in boolean        toKeepIDs)
263       raises ( SALOME::SALOME_Exception );
264
265     /*!
266      * Concatenate the given meshes into one mesh.
267      * Union groups with the same name and type if
268      * theUniteIdenticalGroups flag is true.
269      * Merge coincident nodes and elements if
270      * theMergeNodesAndElements flag is true.
271      */
272     SMESH_Mesh Concatenate(in mesh_array theMeshesArray,
273                            in boolean    theUniteIdenticalGroups,
274                            in boolean    theMergeNodesAndElements,
275                            in double     theMergeTolerance)
276       raises ( SALOME::SALOME_Exception );
277
278     /*!
279      * Concatenate the given meshes into one mesh.
280      * Union groups with the same name and type if
281      * theUniteIdenticalGroups flag is true.
282      * Merge coincident nodes and elements if
283      * theMergeNodesAndElements flag is true.
284      * Create the groups of all elements from initial meshes.
285      */
286     SMESH_Mesh ConcatenateWithGroups(in mesh_array theMeshesArray,
287                                      in boolean    theUniteIdenticalGroups,
288                                      in boolean    theMergeNodesAndElements,
289                                      in double     theMergeTolerance)
290       raises ( SALOME::SALOME_Exception );
291
292     /*!
293      * Mesh a subShape.
294      * First, verify list of hypothesis associated with the Sub-shape,
295      * return NOK if hypothesis are not sufficient
296      */
297     boolean Compute( in SMESH_Mesh        theMesh,
298                      in GEOM::GEOM_Object theSubObject )
299       raises ( SALOME::SALOME_Exception );
300
301     /*!
302      * Cancel a computation.
303      */
304     void CancelCompute( in SMESH_Mesh        theMesh,
305                         in GEOM::GEOM_Object theSubObject );
306
307     /*!
308      * Return true if hypotheses are defined well
309      */
310     boolean IsReadyToCompute( in SMESH_Mesh        theMesh,
311                               in GEOM::GEOM_Object theSubObject )
312       raises ( SALOME::SALOME_Exception );
313
314     /*!
315      * Evaluates size of prospective mesh on a shape
316      */
317     long_array  Evaluate(in SMESH_Mesh        theMesh,
318                          in GEOM::GEOM_Object theSubObject)
319       raises ( SALOME::SALOME_Exception );
320
321     /*!
322      * Calculate Mesh as preview till indicated dimension
323      * First, verify list of hypothesis associated with the Sub-shape.
324      * Return mesh preview structure
325      */
326     MeshPreviewStruct Precompute( in SMESH_Mesh        theMesh,
327                                   in GEOM::GEOM_Object theSubObject,
328                                   in Dimension         theDimension,
329                                   inout long_array    theShapesId )
330       raises ( SALOME::SALOME_Exception );
331
332     /*!
333      * Return errors of hypotheses definintion
334      * algo_error_array is empty if everything is OK
335      */
336     algo_error_array GetAlgoState( in SMESH_Mesh        theMesh,
337                                    in GEOM::GEOM_Object theSubObject )
338       raises ( SALOME::SALOME_Exception );
339
340     /*!
341      * Return errors of mesh computation
342      * compute_error_array is empty if everything is OK
343      */
344     compute_error_array GetComputeErrors( in SMESH_Mesh        theMesh,
345                                           in GEOM::GEOM_Object theSubObject )
346       raises ( SALOME::SALOME_Exception );
347
348     /*!
349      * Return mesh elements preventing computation of a sub-shape
350      */
351     MeshPreviewStruct GetBadInputElements( in SMESH_Mesh theMesh,
352                                            in short      theSubShapeID )
353       raises ( SALOME::SALOME_Exception );
354
355     /*!
356      * Return indeces of faces, edges and vertices of given sub-shapes
357      * within theMainObject
358      */
359     long_array GetSubShapesId( in GEOM::GEOM_Object theMainObject,
360                                in object_array      theListOfSubObjects )
361        raises ( SALOME::SALOME_Exception );
362
363     /*!
364      * Return geometrical object the given element is built on.
365      * The returned geometrical object, if not nil, is either found in the
366      * study or is published by this method with the given name
367      */
368     GEOM::GEOM_Object GetGeometryByMeshElement( in SMESH_Mesh  theMesh,
369                                                 in long        theElementID,
370                                                 in string      theGeomName)
371       raises ( SALOME::SALOME_Exception );
372
373     /*!
374      * Return geometrical object the given element is built on.
375      * The returned geometrical object not published in study by this method.
376      */
377     GEOM::GEOM_Object FindGeometryByMeshElement( in SMESH_Mesh  theMesh,
378                                                  in long        theElementID)
379       raises ( SALOME::SALOME_Exception );
380
381     /*!
382      * \brief Return id of object, registered in current study context
383      *
384      * Can be used to check if the object was created in the same container, as this engine.
385      */
386     long GetObjectId(in Object theObject);
387
388     /*!
389      * \brief Get MED version of the file by its name.
390      */
391     boolean GetMEDVersion(in string theFileName, out MED_VERSION theVersion);
392
393     /*!
394      * \brief Get names of meshes defined in file with the specified name.
395      */
396     string_array GetMeshNames(in string theFileName);
397   };
398
399 };
400
401 #endif