]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMESH_I/SMESH_Mesh_i.hxx
Salome HOME
Make ElemEntityType pass nodes through as well
[modules/smesh.git] / src / SMESH_I / SMESH_Mesh_i.hxx
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_Mesh_i.hxx
23 //  Author : Paul RASCLE, EDF
24 //  Module : SMESH
25
26 #ifndef _SMESH_MESH_I_HXX_
27 #define _SMESH_MESH_I_HXX_
28
29 #include "SMESH.hxx"
30
31 #include <SALOMEconfig.h>
32 #include CORBA_SERVER_HEADER(SMESH_Gen)
33 #include CORBA_SERVER_HEADER(SMESH_Mesh)
34 #include CORBA_SERVER_HEADER(SMESH_Group)
35 #include CORBA_SERVER_HEADER(SMESH_Hypothesis)
36 #include CORBA_CLIENT_HEADER(GEOM_Gen)
37 #include CORBA_CLIENT_HEADER(MED)
38
39 #include "SMESH_Hypothesis.hxx"
40 #include "SMESH_Mesh.hxx"
41 #include "SMESH_subMesh.hxx"
42
43 #include "SALOME_GenericObj_i.hh"
44
45 class SMESH_Gen_i;
46 class SMESH_GroupBase_i;
47 class SMESH_subMesh_i;
48 class SMESH_PreMeshInfo;
49
50 #include <map>
51
52 class SMESH_I_EXPORT SMESH_Mesh_i:
53   public virtual POA_SMESH::SMESH_Mesh,
54   public virtual SALOME::GenericObj_i
55 {
56   SMESH_Mesh_i();
57   SMESH_Mesh_i(const SMESH_Mesh_i&);
58 public:
59   SMESH_Mesh_i( PortableServer::POA_ptr thePOA,
60                 SMESH_Gen_i*            myGen_i,
61                 CORBA::Long             studyId );
62
63   virtual ~SMESH_Mesh_i();
64
65   // --- CORBA
66
67   void SetShape( GEOM::GEOM_Object_ptr theShapeObject )
68     throw (SALOME::SALOME_Exception);
69
70   CORBA::Boolean HasShapeToMesh()
71     throw (SALOME::SALOME_Exception);
72
73   GEOM::GEOM_Object_ptr GetShapeToMesh()
74     throw (SALOME::SALOME_Exception);
75
76   CORBA::Boolean IsLoaded()
77     throw (SALOME::SALOME_Exception);
78
79   void Load()
80     throw (SALOME::SALOME_Exception);
81
82   void Clear()
83     throw (SALOME::SALOME_Exception);
84
85   void ClearSubMesh(CORBA::Long ShapeID)
86     throw (SALOME::SALOME_Exception);
87
88   SMESH::Hypothesis_Status AddHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject,
89                                          SMESH::SMESH_Hypothesis_ptr anHyp)
90     throw (SALOME::SALOME_Exception);
91
92   SMESH::Hypothesis_Status RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject,
93                                             SMESH::SMESH_Hypothesis_ptr anHyp)
94     throw (SALOME::SALOME_Exception);
95
96   SMESH::ListOfHypothesis* GetHypothesisList(GEOM::GEOM_Object_ptr aSubShapeObject)
97     throw (SALOME::SALOME_Exception);
98
99   SMESH::submesh_array* GetSubMeshes()
100     throw (SALOME::SALOME_Exception);
101
102   SMESH::SMESH_subMesh_ptr GetSubMesh(GEOM::GEOM_Object_ptr aSubShapeObject, const char* theName)
103     throw (SALOME::SALOME_Exception);
104
105   void RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
106     throw (SALOME::SALOME_Exception);
107
108   SMESH::SMESH_Group_ptr CreateGroup( SMESH::ElementType theElemType, const char* theName )
109     throw (SALOME::SALOME_Exception);
110
111   SMESH::SMESH_GroupOnGeom_ptr CreateGroupFromGEOM(SMESH::ElementType    theElemType,
112                                                    const char*           theName,
113                                                    GEOM::GEOM_Object_ptr theGeomObj )
114     throw (SALOME::SALOME_Exception);
115
116   SMESH::SMESH_GroupOnFilter_ptr CreateGroupFromFilter(SMESH::ElementType theElemType,
117                                                        const char*        theName,
118                                                        SMESH::Filter_ptr  theFilter )
119     throw (SALOME::SALOME_Exception);
120
121   void RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
122     throw (SALOME::SALOME_Exception);
123
124   void RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup )
125     throw (SALOME::SALOME_Exception);
126
127   SMESH::ListOfGroups* GetGroups()
128     throw (SALOME::SALOME_Exception);
129
130   CORBA::Long NbGroups()
131     throw (SALOME::SALOME_Exception);
132
133   SMESH::SMESH_Group_ptr UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
134                                       SMESH::SMESH_GroupBase_ptr theGroup2,
135                                       const char* theName )
136     throw (SALOME::SALOME_Exception);
137
138   SMESH::SMESH_Group_ptr UnionListOfGroups( const SMESH::ListOfGroups& theGroups,
139                                             const char* theName)
140     throw (SALOME::SALOME_Exception);
141
142   SMESH::SMESH_Group_ptr IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
143                                           SMESH::SMESH_GroupBase_ptr theGroup2,
144                                           const char* theName )
145     throw (SALOME::SALOME_Exception);
146
147   SMESH::SMESH_Group_ptr IntersectListOfGroups( const SMESH::ListOfGroups&  theGroups,
148                                                 const char* theName )
149     throw (SALOME::SALOME_Exception);
150
151   SMESH::SMESH_Group_ptr CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
152                                     SMESH::SMESH_GroupBase_ptr theGroup2,
153                                     const char* theName )
154     throw (SALOME::SALOME_Exception);
155
156   SMESH::SMESH_Group_ptr CutListOfGroups( const SMESH::ListOfGroups& theMainGroups,
157                                           const SMESH::ListOfGroups& theToolGroups,
158                                           const char* theName )
159     throw (SALOME::SALOME_Exception);
160
161   SMESH::SMESH_Group_ptr CreateDimGroup( const SMESH::ListOfGroups& theGroups,
162                                          SMESH::ElementType theElemType,
163                                          const char* theName )
164     throw (SALOME::SALOME_Exception);
165
166
167   SMESH::SMESH_Group_ptr ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroupOn )
168     throw (SALOME::SALOME_Exception);
169
170   SMESH::log_array* GetLog(CORBA::Boolean clearAfterGet)
171     throw (SALOME::SALOME_Exception);
172
173   SMESH::SMESH_MeshEditor_ptr GetMeshEditor() throw (SALOME::SALOME_Exception);
174
175   SMESH::SMESH_MeshEditor_ptr GetMeshEditPreviewer() throw (SALOME::SALOME_Exception);
176
177   CORBA::Boolean HasModificationsToDiscard() throw (SALOME::SALOME_Exception);
178
179   void ClearLog() throw (SALOME::SALOME_Exception);
180
181   CORBA::Long GetId() throw (SALOME::SALOME_Exception);
182
183   CORBA::Long GetStudyId() throw (SALOME::SALOME_Exception);
184
185   // --- C++ interface
186
187   void SetImpl(::SMESH_Mesh* impl);
188   ::SMESH_Mesh& GetImpl();         // :: force no namespace here
189
190   SMESH_Gen_i* GetGen() { return _gen_i; }
191
192   int ImportUNVFile( const char* theFileName )
193     throw (SALOME::SALOME_Exception);
194
195   int ImportSTLFile( const char* theFileName )
196     throw (SALOME::SALOME_Exception);
197
198   SMESH::ComputeError* ImportGMFFile( const char* theFileName,
199                                       bool        theMakeRequiredGroups)
200     throw (SALOME::SALOME_Exception);
201
202   /*!
203    * consult DriverMED_R_SMESHDS_Mesh::ReadStatus for returned value
204    */
205   SMESH::DriverMED_ReadStatus ImportMEDFile( const char* theFileName, const char* theMeshName )
206     throw (SALOME::SALOME_Exception);
207
208   SMESH::DriverMED_ReadStatus ImportCGNSFile( const char*  theFileName,
209                                               const int    theMeshIndex,
210                                               std::string& theMeshName)
211     throw (SALOME::SALOME_Exception);
212
213   /*!
214    *  Auto color
215    */
216   void SetAutoColor(CORBA::Boolean theAutoColor)
217     throw (SALOME::SALOME_Exception);
218
219   CORBA::Boolean GetAutoColor()
220     throw (SALOME::SALOME_Exception);
221
222   /*! Check group names for duplications.
223    *  Consider maximum group name length stored in MED file.
224    */
225   CORBA::Boolean HasDuplicatedGroupNamesMED();
226   /*!
227    * Return string representation of a MED file version comprising nbDigits
228    */
229   char* GetVersionString(SMESH::MED_VERSION version, CORBA::Short nbDigits);
230
231   void ExportToMEDX( const char*        file,
232                      CORBA::Boolean     auto_groups,
233                      SMESH::MED_VERSION version,
234                      CORBA::Boolean     overwrite ) throw (SALOME::SALOME_Exception);
235   void ExportToMED ( const char*        file,
236                      CORBA::Boolean     auto_groups,
237                      SMESH::MED_VERSION version ) throw (SALOME::SALOME_Exception);
238   void ExportMED   ( const char*        file,
239                      CORBA::Boolean     auto_groups ) throw (SALOME::SALOME_Exception);
240
241   void ExportSAUV( const char* file, CORBA::Boolean auto_groups ) throw (SALOME::SALOME_Exception);
242
243   void ExportDAT( const char* file ) throw (SALOME::SALOME_Exception);
244   void ExportUNV( const char* file ) throw (SALOME::SALOME_Exception);
245   void ExportSTL( const char* file, bool isascii ) throw (SALOME::SALOME_Exception);
246   void ExportCGNS(SMESH::SMESH_IDSource_ptr meshPart,
247                   const char*               file,
248                   CORBA::Boolean            overwrite) throw (SALOME::SALOME_Exception);
249   void ExportGMF(SMESH::SMESH_IDSource_ptr meshPart,
250                  const char*               file,
251                  CORBA::Boolean            withRequiredGroups) throw (SALOME::SALOME_Exception);
252
253   void ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
254                        const char*               file,
255                        CORBA::Boolean            auto_groups,
256                        SMESH::MED_VERSION        version,
257                        CORBA::Boolean            overwrite) throw (SALOME::SALOME_Exception);
258   void ExportPartToDAT(SMESH::SMESH_IDSource_ptr meshPart,
259                        const char*               file) throw (SALOME::SALOME_Exception);
260   void ExportPartToUNV(SMESH::SMESH_IDSource_ptr meshPart,
261                        const char*               file) throw (SALOME::SALOME_Exception);
262   void ExportPartToSTL(SMESH::SMESH_IDSource_ptr meshPart,
263                        const char*               file,
264                        CORBA::Boolean            isascii) throw (SALOME::SALOME_Exception);
265
266   SALOME_MED::MESH_ptr GetMEDMesh()
267     throw (SALOME::SALOME_Exception);
268
269   CORBA::Long NbNodes()
270     throw (SALOME::SALOME_Exception);
271
272   CORBA::Long NbElements()
273     throw (SALOME::SALOME_Exception);
274
275   CORBA::Long Nb0DElements()
276     throw (SALOME::SALOME_Exception);
277
278   CORBA::Long NbBalls()
279     throw (SALOME::SALOME_Exception);
280
281   CORBA::Long NbEdges()
282     throw (SALOME::SALOME_Exception);
283
284   CORBA::Long NbEdgesOfOrder(SMESH::ElementOrder order)
285     throw (SALOME::SALOME_Exception);
286
287   CORBA::Long NbFaces()
288     throw (SALOME::SALOME_Exception);
289
290   CORBA::Long NbFacesOfOrder(SMESH::ElementOrder order)
291     throw (SALOME::SALOME_Exception);
292
293   CORBA::Long NbTriangles()
294     throw (SALOME::SALOME_Exception);
295
296   CORBA::Long NbTrianglesOfOrder(SMESH::ElementOrder order)
297     throw (SALOME::SALOME_Exception);
298
299   CORBA::Long NbBiQuadTriangles()
300     throw (SALOME::SALOME_Exception);
301
302   CORBA::Long NbQuadrangles()
303     throw (SALOME::SALOME_Exception);
304
305   CORBA::Long NbQuadranglesOfOrder(SMESH::ElementOrder order)
306     throw (SALOME::SALOME_Exception);
307
308   CORBA::Long NbBiQuadQuadrangles()
309     throw (SALOME::SALOME_Exception);
310
311   CORBA::Long NbPolygons()
312     throw (SALOME::SALOME_Exception);
313
314   CORBA::Long NbVolumes()
315     throw (SALOME::SALOME_Exception);
316
317   CORBA::Long NbVolumesOfOrder(SMESH::ElementOrder order)
318     throw (SALOME::SALOME_Exception);
319
320   CORBA::Long NbTetras()
321     throw (SALOME::SALOME_Exception);
322
323   CORBA::Long NbTetrasOfOrder(SMESH::ElementOrder order)
324     throw (SALOME::SALOME_Exception);
325
326   CORBA::Long NbHexas()
327     throw (SALOME::SALOME_Exception);
328
329   CORBA::Long NbHexasOfOrder(SMESH::ElementOrder order)
330     throw (SALOME::SALOME_Exception);
331
332   CORBA::Long NbTriQuadraticHexas()
333     throw (SALOME::SALOME_Exception);
334
335   CORBA::Long NbPyramids()
336     throw (SALOME::SALOME_Exception);
337
338   CORBA::Long NbPyramidsOfOrder(SMESH::ElementOrder order)
339     throw (SALOME::SALOME_Exception);
340
341   CORBA::Long NbPrisms()
342     throw (SALOME::SALOME_Exception);
343
344   CORBA::Long NbPrismsOfOrder(SMESH::ElementOrder order)
345     throw (SALOME::SALOME_Exception);
346
347   CORBA::Long NbHexagonalPrisms()
348     throw (SALOME::SALOME_Exception);
349
350   CORBA::Long NbPolyhedrons()
351     throw (SALOME::SALOME_Exception);
352
353   CORBA::Long NbSubMesh()
354     throw (SALOME::SALOME_Exception);
355
356   SMESH::long_array* GetElementsId()
357     throw (SALOME::SALOME_Exception);
358
359   SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType )
360     throw (SALOME::SALOME_Exception);
361
362   SMESH::long_array* GetNodesId()
363     throw (SALOME::SALOME_Exception);
364
365   SMESH::ElementType GetElementType( CORBA::Long id, bool iselem )
366     throw (SALOME::SALOME_Exception);
367
368   SMESH::EntityType GetElementGeomType( CORBA::Long id )
369     throw (SALOME::SALOME_Exception);
370
371   /*!
372    * Returns ID of elements for given submesh
373    */
374   SMESH::long_array* GetSubMeshElementsId(CORBA::Long ShapeID)
375     throw (SALOME::SALOME_Exception);
376
377   /*!
378    * Returns ID of nodes for given submesh
379    * If param all==true - returns all nodes, else -
380    * returns only nodes on shapes.
381    */
382   SMESH::long_array* GetSubMeshNodesId(CORBA::Long ShapeID, CORBA::Boolean all)
383     throw (SALOME::SALOME_Exception);
384
385   /*!
386    * Returns type of elements for given submesh
387    */
388   SMESH::ElementType GetSubMeshElementType(CORBA::Long ShapeID)
389     throw (SALOME::SALOME_Exception);
390
391   char* Dump();
392
393   // Create groups of elements preventing computation of a sub-shape
394   SMESH::ListOfGroups* MakeGroupsOfBadInputElements( int         theSubShapeID,
395                                                      const char* theGroupName)
396     throw (SALOME::SALOME_Exception);
397
398   // Internal methods not available through CORBA
399   // They are called by corresponding interface methods
400   SMESH_Hypothesis::Hypothesis_Status addHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject,
401                                                     SMESH::SMESH_Hypothesis_ptr anHyp);
402
403   SMESH_Hypothesis::Hypothesis_Status removeHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject,
404                                                        SMESH::SMESH_Hypothesis_ptr anHyp);
405
406   static SMESH::Hypothesis_Status
407   ConvertHypothesisStatus (SMESH_Hypothesis::Hypothesis_Status theStatus);
408
409   static void PrepareForWriting (const char* file, bool overwrite = true);
410
411   //int importMEDFile( const char* theFileName, const char* theMeshName );
412
413   SMESH::SMESH_subMesh_ptr createSubMesh( GEOM::GEOM_Object_ptr theSubShapeObject );
414
415   bool removeSubMesh(SMESH::SMESH_subMesh_ptr theSubMesh,
416                      GEOM::GEOM_Object_ptr theSubShapeObject );
417
418   SMESH::SMESH_GroupBase_ptr createGroup(SMESH::ElementType        theElemType,
419                                          const char*               theName,
420                                          const TopoDS_Shape&       theShape = TopoDS_Shape(),
421                                          const SMESH_PredicatePtr& thePred = SMESH_PredicatePtr());
422
423   void removeGroup( const int theId );
424
425   SMESH::SMESH_subMesh_ptr getSubMesh(int shapeID);
426   // return an existing subMesh object for the shapeID. shapeID == submeshID.
427
428   const std::map<int, SMESH::SMESH_GroupBase_ptr>& getGroups() { return _mapGroups; }
429   // return existing group objects
430
431   void onHypothesisModified();
432   // callback from _impl to forget not loaded mesh data (issue 0021208)
433
434   void checkMeshLoaded();
435
436   /*!
437    * \brief Update hypotheses assigned to geom groups if the latter change
438    *
439    * NPAL16168: "geometrical group edition from a submesh don't modifiy mesh computation"
440    */
441   void CheckGeomGroupModif();
442
443   CORBA::LongLong GetMeshPtr();
444
445   /*!
446    * \brief Assure that all groups are published
447    */
448   void CreateGroupServants();
449
450   /*!
451    * \brief Return groups cantained in _mapGroups by their IDs
452    */
453   SMESH::ListOfGroups* GetGroups(const std::list<int>& groupIDs) const;
454
455   /*!
456    * Get XYZ coordinates of node as list of double
457    * If there is not node for given ID - returns empty list
458    */
459   SMESH::double_array* GetNodeXYZ(CORBA::Long id);
460
461   /*!
462    * For given node returns list of IDs of inverse elements
463    * If there is not node for given ID - returns empty list
464    */
465   SMESH::long_array* GetNodeInverseElements(CORBA::Long id);
466
467   /*!
468    * \brief Return position of a node on shape
469    */
470   SMESH::NodePosition* GetNodePosition(CORBA::Long NodeID);
471
472   /*!
473    * \brief Return position of an element on shape
474    */
475   SMESH::ElementPosition GetElementPosition(CORBA::Long ElemID);
476
477   /*!
478    * If given element is node returns IDs of shape from position
479    * If there is not node for given ID - returns -1
480    */
481   CORBA::Long GetShapeID(CORBA::Long id);
482
483   /*!
484    * For given element returns ID of result shape after
485    * ::FindShape() from SMESH_MeshEditor
486    * If there is not element for given ID - returns -1
487    */
488   CORBA::Long GetShapeIDForElem(CORBA::Long id);
489
490   /*!
491    * Returns number of nodes for given element
492    * If there is not element for given ID - returns -1
493    */
494   CORBA::Long GetElemNbNodes(CORBA::Long id);
495
496   /*!
497    * Returns IDs of nodes of given element
498    */
499   SMESH::long_array* GetElemNodes(CORBA::Long id);
500
501   /*!
502    * Returns ID of node by given index for given element
503    * If there is not element for given ID - returns -1
504    * If there is not node for given index - returns -2
505    */
506   CORBA::Long GetElemNode(CORBA::Long id, CORBA::Long index);
507
508   /*!
509    * Returns true if given node is medium node
510    * in given quadratic element
511    */
512   CORBA::Boolean IsMediumNode(CORBA::Long ide, CORBA::Long idn);
513
514   /*!
515    * Returns true if given node is medium node
516    * in one of quadratic elements
517    */
518   CORBA::Boolean IsMediumNodeOfAnyElem(CORBA::Long idn,
519                                        SMESH::ElementType theElemType);
520
521   /*!
522    * Returns number of edges for given element
523    */
524   CORBA::Long ElemNbEdges(CORBA::Long id);
525
526   /*!
527    * Returns number of faces for given element
528    */
529   CORBA::Long ElemNbFaces(CORBA::Long id);
530   /*!
531    * Returns nodes of given face (counted from zero) for given element.
532    */
533   SMESH::long_array* GetElemFaceNodes(CORBA::Long elemId, CORBA::Short faceIndex);
534
535   /*!
536    * Returns an element based on all given nodes.
537    */
538   CORBA::Long FindElementByNodes(const SMESH::long_array& nodes);
539
540   /*!
541    * Returns true if given element is polygon
542    */
543   CORBA::Boolean IsPoly(CORBA::Long id);
544
545   /*!
546    * Returns true if given element is quadratic
547    */
548   CORBA::Boolean IsQuadratic(CORBA::Long id);
549
550   /*!
551    * Returns diameter of ball discrete element or zero in case of an invalid \a id
552    */
553   CORBA::Double GetBallDiameter(CORBA::Long id);
554
555   /*!
556    * Returns bary center for given element
557    */
558   SMESH::double_array* BaryCenter(CORBA::Long id);
559
560   /*!
561    * Returns information about imported MED file
562    */
563   virtual SALOME_MED::MedFileInfo* GetMEDFileInfo();
564
565   /*!
566    * Sets list of notebook variables used for Mesh operations separated by ":" symbol
567    */
568   void SetParameters (const char* theParameters);
569
570   /*!
571    * Returns list of notebook variables used for Mesh operations separated by ":" symbol
572    */
573   char* GetParameters();
574
575   /*!
576    * Returns list of notebook variables used for last Mesh operation
577    */
578   SMESH::string_array* GetLastParameters();
579
580   /*!
581    * Collect statistic of mesh elements given by iterator
582    */
583   static void CollectMeshInfo(const SMDS_ElemIteratorPtr theItr,
584                               SMESH::long_array&         theInfo);
585
586   /*!
587    * \brief Return submesh objects list in meshing order
588    */
589   virtual SMESH::submesh_array_array* GetMeshOrder();
590   /*!
591    * \brief Set submesh object order
592    */
593   virtual ::CORBA::Boolean SetMeshOrder(const SMESH::submesh_array_array& theSubMeshArray);
594
595
596   // =========================
597   // SMESH_IDSource interface
598   // =========================
599
600   virtual SMESH::long_array* GetIDs();
601   /*!
602    * Returns statistic of mesh elements
603    * Result array of number enityties
604    * Inherited from SMESH_IDSource
605    */
606   virtual SMESH::long_array* GetMeshInfo();
607   /*!
608    * Returns types of elements it contains
609    */
610   virtual SMESH::array_of_ElementType* GetTypes();
611   /*!
612    * Returns self
613    */
614   virtual SMESH::SMESH_Mesh_ptr GetMesh();
615   /*!
616    * Returns false if GetMeshInfo() returns incorrect information that may
617    * happen if mesh data is not yet fully loaded from the file of study.
618    */
619   bool IsMeshInfoCorrect();
620
621   std::map<int, SMESH_subMesh_i*> _mapSubMesh_i; //NRI
622   std::map<int, ::SMESH_subMesh*> _mapSubMesh;   //NRI
623
624 private:
625   std::string prepareMeshNameAndGroups( const char* file, CORBA::Boolean overwrite );
626
627   /*!
628    * Check and correct names of mesh groups
629    */
630   void checkGroupNames();
631
632   /*!
633    * Convert submesh ids into submesh interfaces
634    */
635   void convertMeshOrder(const TListOfListOfInt&     theIdsOrder,
636                         SMESH::submesh_array_array& theSubMeshOrder,
637                         const bool                  theIsDump);
638
639 private:
640
641   static int    _idGenerator;
642   ::SMESH_Mesh* _impl;        // :: force no namespace here
643   SMESH_Gen_i*  _gen_i;
644   int           _id;          // id given by creator (unique within the creator instance)
645   int           _studyId;
646   std::map<int, SMESH::SMESH_subMesh_ptr>    _mapSubMeshIor;
647   std::map<int, SMESH::SMESH_GroupBase_ptr>  _mapGroups;
648   std::map<int, SMESH::SMESH_Hypothesis_ptr> _mapHypo;
649   SALOME_MED::MedFileInfo_var _medFileInfo;
650   SMESH_PreMeshInfo*          _preMeshInfo; // mesh info before full loading from study file
651
652   SMESH_PreMeshInfo* & changePreMeshInfo() { return _preMeshInfo; }
653   friend class SMESH_PreMeshInfo;
654
655 private:
656
657   // Data used to track changes of GEOM groups
658   struct TGeomGroupData {
659     // keep study entry but not ior because GEOM_Object actually changes if
660     // number of items in a group varies (1) <-> (>1)
661     std::string       _groupEntry;
662     std::set<int>     _indices; // indices of group items within group's main shape
663     CORBA::Object_ptr _smeshObject; // SMESH object depending on GEOM group
664   };
665   std::list<TGeomGroupData> _geomGroupData;
666
667   /*!
668    * Remember GEOM group data
669    */
670   void addGeomGroupData(GEOM::GEOM_Object_ptr theGeomObj,
671                         CORBA::Object_ptr     theSmeshObj);
672   /*!
673    * Remove GEOM group data relating to removed smesh object
674    */
675   void removeGeomGroupData(CORBA::Object_ptr theSmeshObj);
676   /*!
677    * \brief Return new group contents if it has been changed and update group data
678    */
679   TopoDS_Shape newGroupShape( TGeomGroupData & groupData);
680
681 };
682
683 #endif