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