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