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