]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMESH_I/SMESH_Mesh_i.hxx
Salome HOME
Fix
[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 "SMESH_Hypothesis.hxx"
32 #include "SMESH_Mesh.hxx"
33 #include "SMESH_subMesh.hxx"
34
35 #include <SALOME_GenericObj_i.hh>
36 #include <SALOMEconfig.h>
37 #include CORBA_SERVER_HEADER(SMESH_Gen)
38 #include CORBA_SERVER_HEADER(SMESH_Mesh)
39 #include CORBA_SERVER_HEADER(SMESH_Group)
40 #include CORBA_SERVER_HEADER(SMESH_Hypothesis)
41 #include CORBA_CLIENT_HEADER(GEOM_Gen)
42
43 #include <map>
44
45 class SMESH_Gen_i;
46 class SMESH_GroupBase_i;
47 class SMESH_subMesh_i;
48 class SMESH_PreMeshInfo;
49 class SMESH_MeshEditor_i;
50
51 class SMESH_I_EXPORT SMESH_Mesh_i:
52   public virtual POA_SMESH::SMESH_Mesh,
53   public virtual SALOME::GenericObj_i
54 {
55   SMESH_Mesh_i();
56   SMESH_Mesh_i(const SMESH_Mesh_i&);
57 public:
58   SMESH_Mesh_i( PortableServer::POA_ptr thePOA,
59                 SMESH_Gen_i*            myGen_i,
60                 CORBA::Long             studyId );
61
62   virtual ~SMESH_Mesh_i();
63
64   // --- CORBA
65
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     throw (SALOME::SALOME_Exception);
168
169   SMESH::log_array* GetLog(CORBA::Boolean clearAfterGet)
170     throw (SALOME::SALOME_Exception);
171
172   SMESH::SMESH_MeshEditor_ptr GetMeshEditor() throw (SALOME::SALOME_Exception);
173
174   SMESH::SMESH_MeshEditor_ptr GetMeshEditPreviewer() throw (SALOME::SALOME_Exception);
175
176   CORBA::Boolean HasModificationsToDiscard() throw (SALOME::SALOME_Exception);
177
178   void ClearLog() throw (SALOME::SALOME_Exception);
179
180   CORBA::Long GetId() throw (SALOME::SALOME_Exception);
181
182   CORBA::Long GetStudyId() throw (SALOME::SALOME_Exception);
183
184   // --- C++ interface
185
186   void SetImpl(::SMESH_Mesh* impl);
187   ::SMESH_Mesh& GetImpl();         // :: force no namespace here
188
189   SMESH_Gen_i* GetGen() { return _gen_i; }
190
191   int ImportUNVFile( const char* theFileName )
192     throw (SALOME::SALOME_Exception);
193
194   int ImportSTLFile( const char* theFileName )
195     throw (SALOME::SALOME_Exception);
196
197   SMESH::ComputeError* ImportGMFFile( const char* theFileName,
198                                       bool        theMakeRequiredGroups)
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,
234                      CORBA::Boolean     autoDimension=true) 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,
258                        CORBA::Boolean            autoDim=true) throw (SALOME::SALOME_Exception);
259   void ExportPartToDAT(SMESH::SMESH_IDSource_ptr meshPart,
260                        const char*               file) throw (SALOME::SALOME_Exception);
261   void ExportPartToUNV(SMESH::SMESH_IDSource_ptr meshPart,
262                        const char*               file) throw (SALOME::SALOME_Exception);
263   void ExportPartToSTL(SMESH::SMESH_IDSource_ptr meshPart,
264                        const char*               file,
265                        CORBA::Boolean            isascii) throw (SALOME::SALOME_Exception);
266
267   CORBA::Double GetComputeProgress();
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 SMESH::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    * \brief Return submesh objects list in meshing order
582    */
583   virtual SMESH::submesh_array_array* GetMeshOrder();
584   /*!
585    * \brief Set submesh object order
586    */
587   virtual ::CORBA::Boolean SetMeshOrder(const SMESH::submesh_array_array& theSubMeshArray);
588
589
590   /*!
591    * Collect statistic of mesh elements given by iterator
592    */
593   static void CollectMeshInfo(const SMDS_ElemIteratorPtr theItr,
594                               SMESH::long_array&         theInfo);
595   /*!
596    * \brief Return iterator on elements of given type in given object
597    */
598   static SMDS_ElemIteratorPtr GetElements(SMESH::SMESH_IDSource_ptr obj,
599                                           SMESH::ElementType        type);
600
601   // =========================
602   // SMESH_IDSource interface
603   // =========================
604
605   virtual SMESH::long_array* GetIDs();
606   /*!
607    * Returns number of mesh elements of each \a EntityType
608    * Result array of number of elements per \a EntityType
609    * Inherited from SMESH_IDSource
610    */
611   virtual SMESH::long_array* GetMeshInfo();
612   /*!
613    * Returns number of mesh elements of each \a ElementType
614    */
615   virtual SMESH::long_array* GetNbElementsByType();
616   /*!
617    * Returns types of elements it contains
618    */
619   virtual SMESH::array_of_ElementType* GetTypes();
620   /*!
621    * Returns self
622    */
623   virtual SMESH::SMESH_Mesh_ptr GetMesh();
624   /*!
625    * Returns false if GetMeshInfo() returns incorrect information that may
626    * happen if mesh data is not yet fully loaded from the file of study.
627    */
628   bool IsMeshInfoCorrect();
629
630   std::map<int, SMESH_subMesh_i*> _mapSubMesh_i; //NRI
631   std::map<int, ::SMESH_subMesh*> _mapSubMesh;   //NRI
632
633 private:
634   std::string prepareMeshNameAndGroups( const char* file, CORBA::Boolean overwrite );
635
636   /*!
637    * Check and correct names of mesh groups
638    */
639   void checkGroupNames();
640
641   /*!
642    * Convert submesh ids into submesh interfaces
643    */
644   void convertMeshOrder(const TListOfListOfInt&     theIdsOrder,
645                         SMESH::submesh_array_array& theSubMeshOrder,
646                         const bool                  theIsDump);
647
648 private:
649
650   static int    _idGenerator;
651   ::SMESH_Mesh* _impl;        // :: force no namespace here
652   SMESH_Gen_i*  _gen_i;
653   int           _id;          // id given by creator (unique within the creator instance)
654   int           _studyId;
655   std::map<int, SMESH::SMESH_subMesh_ptr>    _mapSubMeshIor;
656   std::map<int, SMESH::SMESH_GroupBase_ptr>  _mapGroups;
657   std::map<int, SMESH::SMESH_Hypothesis_ptr> _mapHypo;
658   SMESH_MeshEditor_i*    _editor;
659   SMESH_MeshEditor_i*    _previewEditor;
660   SMESH::MedFileInfo_var _medFileInfo;
661   SMESH_PreMeshInfo*     _preMeshInfo; // mesh info before full loading from study file
662
663   SMESH_PreMeshInfo* & changePreMeshInfo() { return _preMeshInfo; }
664   friend class SMESH_PreMeshInfo;
665
666 private:
667
668   // Data used to track changes of GEOM groups
669   struct TGeomGroupData {
670     // keep study entry but not ior because GEOM_Object actually changes if
671     // number of items in a group varies (1) <-> (>1)
672     std::string       _groupEntry;
673     std::set<int>     _indices; // indices of group items within group's main shape
674     CORBA::Object_var _smeshObject; // SMESH object depending on GEOM group
675   };
676   std::list<TGeomGroupData> _geomGroupData;
677
678   /*!
679    * Remember GEOM group data
680    */
681   void addGeomGroupData(GEOM::GEOM_Object_ptr theGeomObj,
682                         CORBA::Object_ptr     theSmeshObj);
683   /*!
684    * Remove GEOM group data relating to removed smesh object
685    */
686   void removeGeomGroupData(CORBA::Object_ptr theSmeshObj);
687   /*!
688    * Return new group contents if it has been changed and update group data
689    */
690   TopoDS_Shape newGroupShape( TGeomGroupData & groupData);
691
692 };
693
694 #endif