]> SALOME platform Git repositories - modules/smesh.git/blob - idl/SMESH_Mesh.idl
Salome HOME
EDF 2485: Default sub-meshes priority.
[modules/smesh.git] / idl / SMESH_Mesh.idl
1 // Copyright (C) 2007-2012  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
23 //  File   : SMESH_Mesh.idl
24 //  Author : Paul RASCLE, EDF
25 //
26 #ifndef _SMESH_MESH_IDL_
27 #define _SMESH_MESH_IDL_
28
29 #include "SALOME_Exception.idl"
30 #include "SALOME_GenericObj.idl"
31 #include "GEOM_Gen.idl"
32 #include "MED.idl"
33
34 module SMESH
35 {
36   interface SMESH_Hypothesis;
37   typedef sequence<SMESH_Hypothesis> ListOfHypothesis;
38   interface SMESH_GroupBase;
39   typedef sequence<SMESH_GroupBase> ListOfGroups;
40   interface SMESH_IDSource;
41   typedef sequence<SMESH_IDSource> ListOfIDSources;
42
43   typedef sequence<double    > double_array ;
44   typedef sequence<long      > long_array ;
45   typedef sequence<string    > string_array ;
46   typedef sequence<long_array> array_of_long_array ;
47
48   enum log_command
49     {
50       ADD_NODE,
51       ADD_EDGE,
52       ADD_TRIANGLE,
53       ADD_QUADRANGLE,
54       ADD_POLYGON,
55       ADD_TETRAHEDRON,
56       ADD_PYRAMID,
57       ADD_PRISM,
58       ADD_HEXAHEDRON,
59       ADD_POLYHEDRON,
60       REMOVE_NODE,
61       REMOVE_ELEMENT,
62       MOVE_NODE,
63       CHANGE_ELEMENT_NODES,
64       CHANGE_POLYHEDRON_NODES,
65       RENUMBER,
66       CLEAR_MESH,
67       ADD_QUADEDGE,
68       ADD_QUADTRIANGLE,
69       ADD_QUADQUADRANGLE,
70       ADD_QUADTETRAHEDRON,
71       ADD_QUADPYRAMID,
72       ADD_QUADPENTAHEDRON,
73       ADD_QUADHEXAHEDRON,
74       ADD_ELEM0D,
75       ADD_BIQUAD_QUADRANGLE,
76       ADD_TRIQUAD_HEXA,
77       ADD_HEXAGONAL_PRISM,
78       ADD_BALL
79     };
80
81   struct log_block
82   {
83     long commandType;
84     long number;
85     double_array coords;
86     long_array indexes;
87   };
88
89   struct PointStruct { double x;
90                        double y;
91                        double z; } ;
92
93   typedef sequence<PointStruct> nodes_array;
94
95   struct DirStruct   { PointStruct PS ; } ;          // analog to Occ Direction
96
97   struct AxisStruct  { double x;
98                        double y;
99                        double z;
100                        double vx;
101                        double vy;
102                        double vz; } ;
103
104   /*!
105    * Node location on a shape
106    */
107   struct NodePosition {
108     long             shapeID;
109     GEOM::shape_type shapeType;
110     double_array     params; // [U] on EDGE, [U,V] on FACE, [] on the rest shapes
111   };
112
113   /*!
114    * Enumeration for element type, like in SMDS
115    */
116   enum ElementType
117   {
118     ALL,
119     NODE,
120     EDGE,
121     FACE,
122     VOLUME,
123     ELEM0D,
124     BALL
125   };
126   typedef sequence<ElementType> array_of_ElementType ;
127
128   /*!
129    * Enumeration for element geometry type, like in SMDS
130    */
131   enum GeometryType
132   {
133     Geom_POINT,
134     Geom_EDGE,
135     Geom_TRIANGLE,
136     Geom_QUADRANGLE, // when a new GeometryType is added, please
137     Geom_POLYGON,    // update a corresponding list in SMESH_2smeshpy.cxx, ln 665
138     Geom_TETRA,
139     Geom_PYRAMID,
140     Geom_HEXA,
141     Geom_PENTA,
142     Geom_HEXAGONAL_PRISM,
143     Geom_POLYHEDRA,
144     Geom_BALL
145   };
146   
147   /*!
148    * ElementOrder points out entities of what order are requested
149    */
150   enum ElementOrder {
151     ORDER_ANY,          /*! entities of any order */
152     ORDER_LINEAR,       /*! entities of 1st order */
153     ORDER_QUADRATIC     /*! entities of 2nd order */
154   };
155
156
157   /*!
158    * Enumeration of entity type used in mesh info array,
159    * it should be synchronised with enum SMDSAbs_EntityType
160    */
161   enum EntityType
162   {
163     Entity_Node,
164     Entity_0D,
165     Entity_Edge,
166     Entity_Quad_Edge,
167     Entity_Triangle,
168     Entity_Quad_Triangle,
169     Entity_Quadrangle,
170     Entity_Quad_Quadrangle,
171     Entity_BiQuad_Quadrangle,
172     Entity_Polygon,
173     Entity_Quad_Polygon,
174     Entity_Tetra,
175     Entity_Quad_Tetra,
176     Entity_Pyramid,
177     Entity_Quad_Pyramid,
178     Entity_Hexa,
179     Entity_Quad_Hexa,
180     Entity_TriQuad_Hexa,
181     Entity_Penta,
182     Entity_Quad_Penta,
183     Entity_Hexagonal_Prism,
184     Entity_Polyhedra,
185     Entity_Quad_Polyhedra,
186     Entity_Ball,
187     Entity_Last
188   };
189
190
191   /*!
192    * Enumeration for hypothesis status (used by AddHypothesis() and RemoveHypothesis() methods)
193    */
194   enum Hypothesis_Status // in the order of severity
195   {
196     HYP_OK,
197     HYP_MISSING,      // algo misses a hypothesis
198     HYP_CONCURENT,    // several applicable hypotheses
199     HYP_BAD_PARAMETER,// hypothesis has a bad parameter value
200     HYP_HIDDEN_ALGO,  // an algo is hidden by an upper dim algo generating all-dim elements
201     HYP_HIDING_ALGO,  // an algo hides lower dim algos by generating all-dim elements
202     HYP_UNKNOWN_FATAL,//  --- all statuses below should be considered as fatal
203                       //      for Add/RemoveHypothesis operations
204     HYP_INCOMPATIBLE, // hypothesis does not fit algo
205     HYP_NOTCONFORM,   // not conform mesh is produced appling a hypothesis
206     HYP_ALREADY_EXIST,// such hypothesis already exist
207     HYP_BAD_DIM,      // bad dimension
208     HYP_BAD_SUBSHAPE, // shape is neither the main one, nor its sub-shape, nor a group
209     HYP_BAD_GEOMETRY, // geometry mismatches algorithm's expectation
210     HYP_NEED_SHAPE    // algorithm can work on shape only
211   };
212
213   /*!
214    * Enumeration for DriverMED read status (used by ImportMEDFile() method)
215    */
216   enum DriverMED_ReadStatus // in the order of severity
217   {
218     DRS_OK,
219     DRS_EMPTY,          // a MED file contains no mesh with the given name
220     DRS_WARN_RENUMBER,  // a MED file has overlapped ranges of element numbers,
221                         // so the numbers from the file are ignored
222     DRS_WARN_SKIP_ELEM, // some elements were skipped due to incorrect file data
223     DRS_FAIL            // general failure (exception etc.)
224   };
225
226   /*!
227    * Enumeration for DriverMED (used by Perform() method)
228    */
229   enum MED_VERSION // in the order of severity
230   {
231     MED_V2_1,
232     MED_V2_2
233   };
234
235   typedef sequence<log_block> log_array;
236
237
238   /*!
239    * Auxilary flags for advanced extrusion.
240    * BOUNDARY: create or not boundary for result of extrusion
241    * SEW:      try to use existing nodes or create new nodes in any case
242    */
243   const long EXTRUSION_FLAG_BOUNDARY = 1;
244   const long EXTRUSION_FLAG_SEW = 2;
245   
246   /*!
247    * Structure used in mesh edit preview data (MeshPreviewStruct)
248    */
249   struct ElementSubType { ElementType SMDS_ElementType;
250                           boolean     isPoly;
251                           long        nbNodesInElement; };
252
253   typedef sequence<ElementSubType> types_array;
254
255   /*!
256    * Structure containing mesh edit preview data
257    */
258   struct MeshPreviewStruct { nodes_array nodesXYZ;
259                              long_array  elementConnectivities;
260                              types_array elementTypes; };
261
262   interface SMESH_Mesh;
263
264   interface SMESH_IDSource
265   {
266     /*!
267      * Returns a sequence of all element IDs
268      */
269     long_array GetIDs();
270
271     /*!
272      * Returns statistic of mesh elements
273      * @return array of number enityties by index of EntityType
274      */
275     long_array GetMeshInfo();
276
277     /*!
278      * Returns types of elements it contains.
279      * It's empty if the SMESH_IDSource contains no IDs
280      */
281     array_of_ElementType GetTypes();
282
283     /*!
284      * Returns the mesh
285      */
286     SMESH_Mesh GetMesh();
287
288     /*!
289      * Returns false if GetMeshInfo() returns incorrect information that may
290      * happen if mesh data is not yet fully loaded from the file of study.
291      */
292     boolean IsMeshInfoCorrect();
293   };
294
295   interface SMESH_Group;
296   interface SMESH_GroupOnGeom;
297   interface Filter;
298   interface SMESH_GroupOnFilter;
299   interface SMESH_subMesh;
300   interface SMESH_MeshEditor;
301
302   typedef sequence<SMESH_subMesh>     submesh_array;
303   typedef sequence<submesh_array>     submesh_array_array;
304
305   interface SMESH_Mesh : SALOME::GenericObj, SMESH_IDSource
306   {
307     /*!
308      * Return true if there is a geometry to be meshed
309      */
310     boolean HasShapeToMesh()
311       raises (SALOME::SALOME_Exception);
312
313     /*!
314      * Get geom shape to mesh. A result sould not be nil. Use HasShapeToMesh()
315      * to know if a returned shape 
316      */
317     GEOM::GEOM_Object GetShapeToMesh()
318       raises (SALOME::SALOME_Exception);
319
320     /*!
321      * Return false if the mesh is not yet fully loaded from the study file
322      */
323     boolean IsLoaded()
324       raises (SALOME::SALOME_Exception);
325
326     /*!
327      * Load full mesh data from the study file
328      */
329     void Load()
330       raises (SALOME::SALOME_Exception);
331
332     /*!
333      * Remove all nodes and elements
334      */
335     void Clear()
336       raises (SALOME::SALOME_Exception);
337
338     /*!
339      *  Get the list of sub-meshes existing in the mesh
340      */
341     submesh_array GetSubMeshes()
342       raises (SALOME::SALOME_Exception);
343
344     /*!
345      * Remove all nodes and elements of submesh
346      */
347     void ClearSubMesh(in long ShapeID)
348       raises (SALOME::SALOME_Exception);
349
350     /*!
351      * Get the subMesh object associated to a Sub-shape. The subMesh object
352      * gives access to nodes and elements IDs.
353      * SubMesh will be used instead of Sub-shape in a next idl version to
354      * adress a specific subMesh...
355      */
356     SMESH_subMesh GetSubMesh(in GEOM::GEOM_Object aSubObject, in string name)
357       raises (SALOME::SALOME_Exception);
358
359     /*!
360      * Remove a submesh
361      */
362     void RemoveSubMesh(in SMESH_subMesh aSubMesh)
363       raises (SALOME::SALOME_Exception);
364
365
366     /*!
367      * Create a group
368      */
369     SMESH_Group CreateGroup( in ElementType elem_type,
370                              in string      name )
371       raises (SALOME::SALOME_Exception);
372
373     /*!
374      * Create a group from geometry
375      */
376     SMESH_GroupOnGeom CreateGroupFromGEOM( in ElementType       elemType,
377                                            in string            name,
378                                            in GEOM::GEOM_Object geomObject )
379       raises (SALOME::SALOME_Exception);
380
381     /*!
382      * Create a group from filter
383      */
384     SMESH_GroupOnFilter CreateGroupFromFilter( in ElementType   elemType,
385                                                in string        name,
386                                                in SMESH::Filter filter )
387       raises (SALOME::SALOME_Exception);
388
389     /*!
390      * Remove a group
391      */
392     void RemoveGroup(in SMESH_GroupBase aGroup)
393       raises (SALOME::SALOME_Exception);
394
395     /*!
396      *  Remove group with its contents
397      */
398     void RemoveGroupWithContents( in SMESH_GroupBase aGroup )
399       raises (SALOME::SALOME_Exception);
400
401     /*!
402      *  Get the list of groups existing in the mesh
403      */
404     ListOfGroups GetGroups()
405       raises (SALOME::SALOME_Exception);
406
407     /*!
408      *  Get number of groups existing in the mesh
409      */
410     long NbGroups()
411       raises (SALOME::SALOME_Exception);
412
413     /*!
414      * Union of two groups
415      *    New group is created. All mesh elements that are
416      *    present in initial groups are added to the new one
417      */
418     SMESH_Group UnionGroups (in SMESH_GroupBase aGroup1,
419                              in SMESH_GroupBase aGroup2,
420                              in string          name )
421       raises (SALOME::SALOME_Exception);
422       
423     /*!
424      * Union of list of groups
425      * New group is created. All mesh elements that are
426      * present in initial groups are added to the new one
427      */
428     SMESH_Group UnionListOfGroups (in ListOfGroups aListOfGroups,
429                                    in string       name )
430       raises (SALOME::SALOME_Exception);
431
432     /*!
433      *  Intersection of two groups
434      *  New group is created. All mesh elements that are
435      *  present in both initial groups are added to the new one.
436      */
437     SMESH_Group IntersectGroups (in SMESH_GroupBase aGroup1,
438                                  in SMESH_GroupBase aGroup2,
439                                  in string          name )
440       raises (SALOME::SALOME_Exception);
441       
442     /*!
443      *  Intersection of list of groups
444      *  New group is created. All mesh elements that are
445      *  present in all initial groups simultaneously are added to the new one.
446      */
447     SMESH_Group IntersectListOfGroups (in ListOfGroups aListOfGroups,
448                                        in string       name)
449       raises (SALOME::SALOME_Exception);
450
451     /*!
452      *  Cut of two groups
453      *  New group is created. All mesh elements that are present in
454      *  main group but do not present in tool group are added to the new one
455      */
456     SMESH_Group CutGroups (in SMESH_GroupBase aMainGroup,
457                            in SMESH_GroupBase aToolGroup,
458                            in string          name )
459       raises (SALOME::SALOME_Exception);
460       
461     /*!
462      *  Cut of lists of groups
463      *  New group is created. All mesh elements that are present in
464      *  main groups but do not present in tool groups are added to the new one
465      */
466     SMESH_Group CutListOfGroups (in ListOfGroups aMainGroups,
467                                  in ListOfGroups aToolGroups,
468                                  in string       name)
469       raises (SALOME::SALOME_Exception);
470       
471     /*!
472      *  Create groups of entities from existing groups of superior dimensions 
473      *  New group is created. System 
474      *  1) extracts all nodes from each group,
475      *  2) combines all elements of specified dimension laying on these nodes.
476      */
477     SMESH_Group CreateDimGroup( in ListOfGroups aListOfGroups,
478                                 in ElementType  anElemType,
479                                 in string       name )
480       raises (SALOME::SALOME_Exception);
481
482     /*!
483      * Convert group on geometry or on filter into standalone group
484      */
485     SMESH_Group ConvertToStandalone( in SMESH_GroupBase theGroupOn )
486       raises (SALOME::SALOME_Exception);
487
488     /*!
489      * Add hypothesis to the mesh, under a particular Sub-shape
490      * (or the main shape itself)
491      * The Add method is only used to prepare the build of the mesh and store
492      * the algorithms and associated parameters.
493      * Actual job of mesh the shape is done by MESH_Gen.
494      * @params
495      * - aSubShape : sub-shape obtained by a shape explode in GEOM
496      *   (or main shape)
497      * - anHyp : hypothesis object
498      * @return
499      * - OK if the hypothesis is compatible with the sub-shape
500      *   (and all previous hypothesis on the sub-shape)
501      * - NOK if the hypothesis is not compatible with the sub-shape
502      *   (or one previous hypothesis on the sub-shape)
503      * raises exception if hypothesis has not been created
504      */
505     Hypothesis_Status AddHypothesis(in GEOM::GEOM_Object aSubObject,
506                                     in SMESH_Hypothesis anHyp)
507       raises (SALOME::SALOME_Exception);
508 //     boolean AddHypothesis(in SMESH_subMesh aSubMesh, in SMESH_Hypothesis anHyp)
509 //       raises (SALOME::SALOME_Exception);
510
511     /*!
512      * Remove an hypothesis previouly added with AddHypothesis.
513      */
514     Hypothesis_Status RemoveHypothesis(in GEOM::GEOM_Object aSubObject,
515                                        in SMESH_Hypothesis anHyp)
516       raises (SALOME::SALOME_Exception);
517 //     boolean RemoveHypothesis(in SMESH_subMesh aSubMesh,
518 //                           in SMESH_Hypothesis anHyp)
519 //       raises (SALOME::SALOME_Exception);
520
521     /*!
522      * Get the list of hypothesis added on a sub-shape
523      */
524     ListOfHypothesis GetHypothesisList(in GEOM::GEOM_Object aSubObject)
525       raises (SALOME::SALOME_Exception);
526 //     ListOfHypothesis GetHypothesisList(in SMESH_subMesh aSubMesh)
527 //       raises (SALOME::SALOME_Exception);
528
529     /*!
530      * Get the log of nodes and elements added or removed since previous
531      * clear of the log.
532      * @params
533      * - clearAfterGet : log is emptied after Get (safe if concurrents access)
534      */
535     //    string_array GetLog(in boolean clearAfterGet)
536     //      raises (SALOME::SALOME_Exception);
537     log_array GetLog(in boolean clearAfterGet)
538       raises (SALOME::SALOME_Exception);
539
540     /*!
541      * Clear the log of nodes and elements added or removed since previous
542      * clear. Must be used immediately after GetLog if clearAfterGet is false.
543      */
544     void ClearLog()
545       raises (SALOME::SALOME_Exception);
546
547     /*!
548      * Toggle auto color mode on the object.
549      * @params
550      * - theAutoColor : flag which toggles auto color mode.
551      */
552     void SetAutoColor(in boolean theAutoColor)
553       raises (SALOME::SALOME_Exception);
554
555     /*!
556      * Get flag of object's auto color mode.
557      */
558     boolean GetAutoColor()
559       raises (SALOME::SALOME_Exception);
560
561     /*!
562      * Get the internal Id
563      */
564     long GetId();
565
566     /*!
567      * Get the study Id
568      */
569     long GetStudyId();
570
571     /*!
572      * Obtain instance of SMESH_MeshEditor
573      */
574     SMESH_MeshEditor GetMeshEditor()
575       raises (SALOME::SALOME_Exception);
576
577     /*!
578      * Return SMESH_MeshEditor that would not modify the mesh but
579      * fill MeshPreviewStruct
580      */
581     SMESH_MeshEditor GetMeshEditPreviewer()
582       raises (SALOME::SALOME_Exception);
583
584     /*!
585      * Return true if the mesh has been edited since a total re-compute
586      * and those modifications may prevent successful partial re-compute
587      */
588     boolean HasModificationsToDiscard()
589       raises (SALOME::SALOME_Exception);
590
591     /*! Check group names for duplications.
592      *  Consider maximum group name length stored in MED file.
593      */
594     boolean HasDuplicatedGroupNamesMED();
595
596     /*!
597      * Export Mesh to different MED Formats
598      * @params
599      * - file : name of the MED file
600      * - auto_groups : boolean parameter for creating/not creating
601      *   the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
602      *   the typical use is auto_groups=false.
603      * - version : define the version of format of MED file, that will be created
604      * - overwrite : boolean parameter for overwriting/not overwriting the file, if it exists
605      */
606     void ExportToMEDX( in string      file, 
607                        in boolean     auto_groups, 
608                        in MED_VERSION version, 
609                        in boolean     overwrite ) raises (SALOME::SALOME_Exception);
610
611     /*!
612      * Export a part of Mesh into a MED file
613      * @params
614      * - meshPart : a part of mesh to store
615      * - file : name of the MED file
616      * - version : define the version of format of MED file, that will be created
617      * - overwrite : boolean parameter for overwriting/not overwriting the file, if it exists
618      */
619     void ExportPartToMED( in SMESH_IDSource meshPart, 
620                           in string         file, 
621                           in boolean        auto_groups,
622                           in MED_VERSION    version,
623                           in boolean        overwrite ) raises (SALOME::SALOME_Exception);
624
625     /*!
626      * Export Mesh to different MED Formats
627      * Works, just the same as ExportToMEDX, with overwrite parameter equal to true.
628      * The method is kept in order to support old functionality
629      */
630     void ExportToMED( in string file, in boolean auto_groups, in MED_VERSION theVersion )
631       raises (SALOME::SALOME_Exception);
632
633     /*!
634      * Export Mesh to MED_V2_1 MED format
635      * Works, just the same as ExportToMEDX with MED_VERSION parameter equal to MED_V2_1
636      * and overwrite parameter equal to true
637      * The method is kept in order to support old functionality
638      */
639     void ExportMED( in string file, in boolean auto_groups )
640       raises (SALOME::SALOME_Exception);
641
642     /*!
643      * Export Mesh to SAUV formatted file
644      * Write a temporary med file and use med2sauv
645      */
646     void ExportSAUV( in string file, in boolean auto_groups )
647       raises (SALOME::SALOME_Exception);
648
649     /*!
650      * Return string representation of a MED file version comprising nbDigits
651      */
652     string GetVersionString(in MED_VERSION version, in short nbDigits);
653
654     /*!
655      * Export Mesh to different Formats
656      * (UNV supported version is I-DEAS 10)
657      */
658     void ExportDAT( in string file ) raises (SALOME::SALOME_Exception);
659     void ExportUNV( in string file ) raises (SALOME::SALOME_Exception);
660     void ExportSTL( in string  file,
661                     in boolean isascii ) raises (SALOME::SALOME_Exception);
662     void ExportCGNS( in SMESH_IDSource meshPart, 
663                      in string         file,
664                      in boolean        overwrite ) raises (SALOME::SALOME_Exception);
665     void ExportGMF( in SMESH_IDSource  meshPart, 
666                     in string          file,
667                     in boolean         withRequiredGroups) raises (SALOME::SALOME_Exception);
668     void ExportPartToDAT( in SMESH_IDSource meshPart, 
669                           in string         file ) raises (SALOME::SALOME_Exception);
670     void ExportPartToUNV( in SMESH_IDSource meshPart, 
671                           in string         file ) raises (SALOME::SALOME_Exception);
672     void ExportPartToSTL( in SMESH_IDSource meshPart,
673                           in string         file,
674                           in boolean        isascii ) raises (SALOME::SALOME_Exception);
675
676     /*!
677      * Get MED Mesh
678      */
679     SALOME_MED::MESH GetMEDMesh()
680       raises (SALOME::SALOME_Exception);
681
682     /*!
683      * Get informations about mesh contents
684      */
685     long NbNodes()
686       raises (SALOME::SALOME_Exception);
687
688     long NbElements()
689       raises (SALOME::SALOME_Exception);
690
691     long Nb0DElements()
692       raises (SALOME::SALOME_Exception);
693
694     long NbBalls()
695       raises (SALOME::SALOME_Exception);
696
697     long NbEdges()
698       raises (SALOME::SALOME_Exception);
699
700     long NbEdgesOfOrder(in ElementOrder order)
701       raises (SALOME::SALOME_Exception);
702
703     long NbFaces()
704       raises (SALOME::SALOME_Exception);
705
706     long NbFacesOfOrder(in ElementOrder order)
707       raises (SALOME::SALOME_Exception);
708
709     long NbTriangles()
710       raises (SALOME::SALOME_Exception);
711
712     long NbTrianglesOfOrder(in ElementOrder order)
713       raises (SALOME::SALOME_Exception);
714
715     long NbQuadrangles()
716       raises (SALOME::SALOME_Exception);
717
718     long NbQuadranglesOfOrder(in ElementOrder order)
719       raises (SALOME::SALOME_Exception);
720
721     long NbBiQuadQuadrangles()
722       raises (SALOME::SALOME_Exception);
723
724     long NbPolygons()
725       raises (SALOME::SALOME_Exception);
726
727     long NbVolumes()
728       raises (SALOME::SALOME_Exception);
729
730     long NbVolumesOfOrder(in ElementOrder order)
731       raises (SALOME::SALOME_Exception);
732
733     long NbTetras()
734       raises (SALOME::SALOME_Exception);
735
736     long NbTetrasOfOrder(in ElementOrder order)
737       raises (SALOME::SALOME_Exception);
738
739     long NbHexas()
740       raises (SALOME::SALOME_Exception);
741
742     long NbHexasOfOrder(in ElementOrder order)
743       raises (SALOME::SALOME_Exception);
744
745     long NbTriQuadraticHexas()
746       raises (SALOME::SALOME_Exception);
747
748     long NbPyramids()
749       raises (SALOME::SALOME_Exception);
750
751     long NbPyramidsOfOrder(in ElementOrder order)
752       raises (SALOME::SALOME_Exception);
753
754     long NbPrisms()
755       raises (SALOME::SALOME_Exception);
756
757     long NbPrismsOfOrder(in ElementOrder order)
758       raises (SALOME::SALOME_Exception);
759
760     long NbHexagonalPrisms()
761       raises (SALOME::SALOME_Exception);
762
763     long NbPolyhedrons()
764       raises (SALOME::SALOME_Exception);
765
766     long NbSubMesh()
767       raises (SALOME::SALOME_Exception);
768
769     long_array GetElementsId()
770       raises (SALOME::SALOME_Exception);
771
772     long_array GetElementsByType( in ElementType theType )
773       raises (SALOME::SALOME_Exception);
774
775     long_array GetNodesId()
776       raises (SALOME::SALOME_Exception);
777     
778     /*!
779      * Returns type of mesh element
780      */    
781     ElementType GetElementType( in long id, in boolean iselem )
782       raises (SALOME::SALOME_Exception);
783
784     EntityType GetElementGeomType( in long id )
785       raises (SALOME::SALOME_Exception);
786
787     long_array GetSubMeshElementsId(in long ShapeID)
788       raises (SALOME::SALOME_Exception);
789
790     long_array GetSubMeshNodesId(in long ShapeID, in boolean all )
791       raises (SALOME::SALOME_Exception);
792     
793     ElementType GetSubMeshElementType(in long ShapeID)
794       raises (SALOME::SALOME_Exception);
795
796
797     /*!
798      * Methods to set meshing order of submeshes
799      */
800
801     /*!
802      * \brief Return submesh objects list in meshing order
803      */
804     submesh_array_array GetMeshOrder();
805
806     /*!
807      * \brief Set submesh object order
808      */
809     boolean SetMeshOrder(in submesh_array_array theSubMeshArray);
810
811
812     /*!
813      * Get mesh description
814      */
815     string Dump();
816
817     /*!
818      * Get mesh pointer
819      */
820     long long GetMeshPtr();
821
822     /*!
823      * Get XYZ coordinates of node as list of double
824      * If there is not node for given ID - returns empty list
825      */
826     double_array GetNodeXYZ(in long id);
827
828     /*!
829      * For given node returns list of IDs of inverse elements
830      * If there is not node for given ID - returns empty list
831      */
832     long_array GetNodeInverseElements(in long id);
833
834     /*!
835      * \brief Return position of a node on shape
836      */
837     NodePosition GetNodePosition(in long NodeID);
838
839     /*!
840      * If given element is node returns IDs of shape from position
841      * If there is not node for given ID - returns -1
842      */
843     long GetShapeID(in long id);
844
845     /*!
846      * For given element returns ID of result shape after 
847      * ::FindShape() from SMESH_MeshEditor
848      * If there is not element for given ID - returns -1
849      */
850     long GetShapeIDForElem(in long id);
851
852     /*!
853      * Returns number of nodes for given element
854      * If there is not element for given ID - returns -1
855      */
856     long GetElemNbNodes(in long id);
857
858     /*!
859      * Returns IDs of nodes of given element
860      */
861     long_array GetElemNodes(in long id);
862
863     /*!
864      * Returns ID of node by given index for given element
865      * If there is not element for given ID - returns -1
866      * If there is not node for given index - returns -2
867      */
868     long GetElemNode(in long id, in long index);
869
870     /*!
871      * Returns true if given node is medium node
872      * in given quadratic element
873      */
874     boolean IsMediumNode(in long ide, in long idn);
875
876     /*!
877      * Returns true if given node is medium node
878      * in one of quadratic elements
879      */
880     boolean IsMediumNodeOfAnyElem(in long idn, in ElementType elem_type);
881
882     /*!
883      * Returns number of edges for given element
884      */
885     long ElemNbEdges(in long id);
886
887     /*!
888      * Returns number of faces for given element
889      */
890     long ElemNbFaces(in long id);
891
892     /*!
893      * Returns nodes of given face (counted from zero) for given volumic element.
894      */
895     long_array GetElemFaceNodes(in long elemId, in short faceIndex);
896
897     /*!
898      * Returns an element based on all given nodes.
899      */
900     long FindElementByNodes(in long_array nodes);
901
902     /*!
903      * Returns true if given element is polygon
904      */
905     boolean IsPoly(in long id);
906
907     /*!
908      * Returns true if given element is quadratic
909      */
910     boolean IsQuadratic(in long id);
911
912     /*!
913      * Returns diameter of a ball discrete element or zero in case of an invalid \a id
914      */
915     double GetBallDiameter(in long id);
916
917     /*!
918      * Returns XYZ coordinates of bary center for given element
919      * as list of double
920      * If there is not element for given ID - returns empty list
921      */
922     double_array BaryCenter(in long id);
923
924     /*! Gets information about imported MED file */
925     SALOME_MED::MedFileInfo GetMEDFileInfo();
926
927     /*!
928      *  Sets list of notebook variables used for Mesh operations separated by ":" symbol
929      *  \param theParameters is a string containing the notebook variables
930      */
931     void SetParameters (in string theParameters);
932
933     /*!
934      *  Returns list of notebook variables used for Mesh operations separated by ":" symbol
935      */
936     string GetParameters();
937
938     /*!
939      *  Returns list of notebook variables used for last Mesh operation
940      */
941     string_array GetLastParameters();
942   };
943
944   interface SMESH_subMesh : SALOME::GenericObj, SMESH_IDSource
945   {
946     /*!
947      *
948      */
949     long GetNumberOfElements()
950       raises (SALOME::SALOME_Exception);
951
952     /*!
953      *
954      */
955     long GetNumberOfNodes( in boolean all )
956       raises (SALOME::SALOME_Exception);
957
958     /*!
959      *
960      */
961     long_array GetElementsId()
962       raises (SALOME::SALOME_Exception);
963
964     /*!
965      *
966      */
967     long_array GetElementsByType( in ElementType theType )
968       raises (SALOME::SALOME_Exception);
969     
970     /*!
971      * Return type of submesh element
972      */
973     ElementType GetElementType( in long id, in boolean iselem )
974       raises (SALOME::SALOME_Exception);
975
976     /*!
977      *
978      */
979     long_array GetNodesId()
980       raises (SALOME::SALOME_Exception);
981
982     /*!
983      * Get geom shape the submesh is dedicated to
984      */
985     GEOM::GEOM_Object GetSubShape()
986       raises (SALOME::SALOME_Exception);
987
988     /*!
989      * Get SMESH_Mesh which stores nodes coordinates & elements definition
990      */
991     SMESH_Mesh GetFather()
992       raises (SALOME::SALOME_Exception);
993
994     /*!
995      * Get the internal Id
996      */
997     long GetId();
998
999     /*!
1000      * Get MED subMesh
1001      */
1002     SALOME_MED::FAMILY GetFamily()
1003       raises (SALOME::SALOME_Exception);
1004   };
1005
1006 };
1007
1008 #endif