Salome HOME
Merge from BR_WIN_INDUS_514 04/10/2010
[modules/smesh.git] / src / SMESH_I / SMESH_Mesh_i.cxx
1 //  Copyright (C) 2007-2010  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 //  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
23 //  File   : SMESH_Mesh_i.cxx
24 //  Author : Paul RASCLE, EDF
25 //  Module : SMESH
26
27 #include "SMESH_Mesh_i.hxx"
28
29 #include "SMESH_Filter_i.hxx"
30 #include "SMESH_Gen_i.hxx"
31 #include "SMESH_Group_i.hxx"
32 #include "SMESH_MEDMesh_i.hxx"
33 #include "SMESH_MeshEditor_i.hxx"
34 #include "SMESH_PythonDump.hxx"
35 #include "SMESH_subMesh_i.hxx"
36
37 #include "DriverMED_R_SMESHDS_Mesh.h"
38 #include "DriverMED_W_SMESHDS_Mesh.h"
39 #include "SMDS_VolumeTool.hxx"
40 #include "SMDS_ElemIterator.hxx"
41 #include "SMESHDS_Command.hxx"
42 #include "SMESHDS_CommandType.hxx"
43 #include "SMESHDS_GroupOnGeom.hxx"
44 #include "SMESH_Group.hxx"
45 #include "SMESH_MeshEditor.hxx"
46 #include "SMESH_MesherHelper.hxx"
47 #include "SMDS_EdgePosition.hxx"
48 #include "SMDS_FacePosition.hxx"
49
50 #include "OpUtil.hxx"
51 #include "SALOME_NamingService.hxx"
52 #include "Utils_CorbaException.hxx"
53 #include "Utils_ExceptHandlers.hxx"
54 #include "Utils_SINGLETON.hxx"
55 #include "utilities.h"
56 #include "GEOMImpl_Types.hxx"
57
58 // OCCT Includes
59 #include <BRep_Builder.hxx>
60 #include <OSD_Directory.hxx>
61 #include <OSD_File.hxx>
62 #include <OSD_Path.hxx>
63 #include <OSD_Protection.hxx>
64 #include <TColStd_MapIteratorOfMapOfInteger.hxx>
65 #include <TColStd_MapOfInteger.hxx>
66 #include <TColStd_SequenceOfInteger.hxx>
67 #include <TCollection_AsciiString.hxx>
68 #include <TopExp.hxx>
69 #include <TopExp_Explorer.hxx>
70 #include <TopoDS_Compound.hxx>
71 #include <TopTools_MapOfShape.hxx>
72 #include <TopTools_MapIteratorOfMapOfShape.hxx>
73
74 // STL Includes
75 #include <algorithm>
76 #include <string>
77 #include <iostream>
78 #include <sstream>
79 #include <sys/stat.h>
80
81 #ifdef _DEBUG_
82 static int MYDEBUG = 0;
83 #else
84 static int MYDEBUG = 0;
85 #endif
86
87 using namespace std;
88 using SMESH::TPythonDump;
89
90 int SMESH_Mesh_i::myIdGenerator = 0;
91
92 //To disable automatic genericobj management, the following line should be commented.
93 //Otherwise, it should be uncommented. Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
94 #define WITHGENERICOBJ
95
96 //=============================================================================
97 /*!
98  *  Constructor
99  */
100 //=============================================================================
101
102 SMESH_Mesh_i::SMESH_Mesh_i( PortableServer::POA_ptr thePOA,
103                             SMESH_Gen_i*            gen_i,
104                             CORBA::Long studyId )
105 : SALOME::GenericObj_i( thePOA )
106 {
107   MESSAGE("SMESH_Mesh_i");
108   _impl = NULL;
109   _gen_i = gen_i;
110   _id = myIdGenerator++;
111   _studyId = studyId;
112 }
113
114 //=============================================================================
115 /*!
116  *  Destructor
117  */
118 //=============================================================================
119
120 SMESH_Mesh_i::~SMESH_Mesh_i()
121 {
122   INFOS("~SMESH_Mesh_i");
123
124 #ifdef WITHGENERICOBJ
125   // destroy groups
126   map<int, SMESH::SMESH_GroupBase_ptr>::iterator itGr;
127   for (itGr = _mapGroups.begin(); itGr != _mapGroups.end(); itGr++) {
128     if ( CORBA::is_nil( itGr->second ))
129       continue;
130     SMESH_GroupBase_i* aGroup = dynamic_cast<SMESH_GroupBase_i*>(SMESH_Gen_i::GetServant(itGr->second).in());
131     if (aGroup) {
132       // this method is called from destructor of group (PAL6331)
133       //_impl->RemoveGroup( aGroup->GetLocalID() );
134       aGroup->myMeshServant = 0;
135       aGroup->Destroy();
136     }
137   }
138   _mapGroups.clear();
139
140   // destroy submeshes
141   map<int, SMESH::SMESH_subMesh_ptr>::iterator itSM;
142   for ( itSM = _mapSubMeshIor.begin(); itSM != _mapSubMeshIor.end(); itSM++ ) {
143     if ( CORBA::is_nil( itSM->second ))
144       continue;
145     SMESH_subMesh_i* aSubMesh = dynamic_cast<SMESH_subMesh_i*>(SMESH_Gen_i::GetServant(itSM->second).in());
146     if (aSubMesh) {
147       aSubMesh->Destroy();
148     }
149   }
150   _mapSubMeshIor.clear();
151
152   // destroy hypotheses
153   map<int, SMESH::SMESH_Hypothesis_ptr>::iterator itH;
154   for ( itH = _mapHypo.begin(); itH != _mapHypo.end(); itH++ ) {
155     if ( CORBA::is_nil( itH->second ))
156       continue;
157     SMESH_Hypothesis_i* aHypo = dynamic_cast<SMESH_Hypothesis_i*>(SMESH_Gen_i::GetServant(itH->second).in());
158     if (aHypo) {
159       aHypo->Destroy();
160     }
161   }
162   _mapHypo.clear();
163 #endif
164
165   delete _impl;
166 }
167
168 //=============================================================================
169 /*!
170  *  SetShape
171  *
172  *  Associates <this> mesh with <theShape> and puts a reference
173  *  to <theShape> into the current study;
174  *  the previous shape is substituted by the new one.
175  */
176 //=============================================================================
177
178 void SMESH_Mesh_i::SetShape( GEOM::GEOM_Object_ptr theShapeObject )
179     throw (SALOME::SALOME_Exception)
180 {
181   Unexpect aCatch(SALOME_SalomeException);
182   try {
183     _impl->ShapeToMesh( _gen_i->GeomObjectToShape( theShapeObject ));
184   }
185   catch(SALOME_Exception & S_ex) {
186     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
187   }
188   // to track changes of GEOM groups
189   addGeomGroupData( theShapeObject, _this() );
190 }
191
192 //================================================================================
193 /*!
194  * \brief return true if mesh has a shape to build a shape on
195  */
196 //================================================================================
197
198 CORBA::Boolean SMESH_Mesh_i::HasShapeToMesh()
199   throw (SALOME::SALOME_Exception)
200 {
201   Unexpect aCatch(SALOME_SalomeException);
202   bool res = false;
203   try {
204     res = _impl->HasShapeToMesh();
205   }
206   catch(SALOME_Exception & S_ex) {
207     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
208   }
209   return res;
210 }
211
212 //=======================================================================
213 //function : GetShapeToMesh
214 //purpose  :
215 //=======================================================================
216
217 GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh()
218   throw (SALOME::SALOME_Exception)
219 {
220   Unexpect aCatch(SALOME_SalomeException);
221   GEOM::GEOM_Object_var aShapeObj;
222   try {
223     TopoDS_Shape S = _impl->GetMeshDS()->ShapeToMesh();
224     if ( !S.IsNull() )
225       aShapeObj = _gen_i->ShapeToGeomObject( S );
226   }
227   catch(SALOME_Exception & S_ex) {
228     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
229   }
230   return aShapeObj._retn();
231 }
232
233 //================================================================================
234 /*!
235  * \brief Remove all nodes and elements
236  */
237 //================================================================================
238
239 void SMESH_Mesh_i::Clear() throw (SALOME::SALOME_Exception)
240 {
241   Unexpect aCatch(SALOME_SalomeException);
242   try {
243     _impl->Clear();
244     CheckGeomGroupModif(); // issue 20145
245   }
246   catch(SALOME_Exception & S_ex) {
247     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
248   }
249   TPythonDump() <<  _this() << ".Clear()";
250 }
251
252 //================================================================================
253 /*!
254  * \brief Remove all nodes and elements for indicated shape
255  */
256 //================================================================================
257
258 void SMESH_Mesh_i::ClearSubMesh(CORBA::Long ShapeID)
259   throw (SALOME::SALOME_Exception)
260 {
261   Unexpect aCatch(SALOME_SalomeException);
262   try {
263     _impl->ClearSubMesh( ShapeID );
264   }
265   catch(SALOME_Exception & S_ex) {
266     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
267   }
268 }
269
270 //=============================================================================
271 /*!
272  *
273  */
274 //=============================================================================
275
276 static SMESH::DriverMED_ReadStatus ConvertDriverMEDReadStatus (int theStatus)
277 {
278   SMESH::DriverMED_ReadStatus res;
279   switch (theStatus)
280   {
281   case DriverMED_R_SMESHDS_Mesh::DRS_OK:
282     res = SMESH::DRS_OK; break;
283   case DriverMED_R_SMESHDS_Mesh::DRS_EMPTY:
284     res = SMESH::DRS_EMPTY; break;
285   case DriverMED_R_SMESHDS_Mesh::DRS_WARN_RENUMBER:
286     res = SMESH::DRS_WARN_RENUMBER; break;
287   case DriverMED_R_SMESHDS_Mesh::DRS_WARN_SKIP_ELEM:
288     res = SMESH::DRS_WARN_SKIP_ELEM; break;
289   case DriverMED_R_SMESHDS_Mesh::DRS_FAIL:
290   default:
291     res = SMESH::DRS_FAIL; break;
292   }
293   return res;
294 }
295
296 //=============================================================================
297 /*!
298  *  ImportMEDFile
299  *
300  *  Imports mesh data from MED file
301  */
302 //=============================================================================
303
304 SMESH::DriverMED_ReadStatus
305 SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName )
306   throw ( SALOME::SALOME_Exception )
307 {
308   Unexpect aCatch(SALOME_SalomeException);
309   int status;
310   try {
311     status = _impl->MEDToMesh( theFileName, theMeshName );
312   }
313   catch( SALOME_Exception& S_ex ) {
314     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
315   }
316   catch ( ... ) {
317     THROW_SALOME_CORBA_EXCEPTION("ImportMEDFile(): unknown exception", SALOME::BAD_PARAM);
318   }
319
320   CreateGroupServants();
321
322   int major, minor, release;
323   if( !MED::getMEDVersion( theFileName, major, minor, release ) )
324     major = minor = release = -1;
325   myFileInfo           = new SALOME_MED::MedFileInfo();
326   myFileInfo->fileName = theFileName;
327   myFileInfo->fileSize = 0;
328 #ifdef WIN32
329   struct _stati64 d;
330   if ( ::_stati64( theFileName, &d ) != -1 )
331 #else
332   struct stat64 d;
333   if ( ::stat64( theFileName, &d ) != -1 )
334 #endif
335     myFileInfo->fileSize = d.st_size;
336   myFileInfo->major    = major;
337   myFileInfo->minor    = minor;
338   myFileInfo->release  = release;
339
340   return ConvertDriverMEDReadStatus(status);
341 }
342
343 //================================================================================
344 /*!
345  * \brief Return string representation of a MED file version comprising nbDigits
346  */
347 //================================================================================
348
349 char* SMESH_Mesh_i::GetVersionString(SMESH::MED_VERSION version, CORBA::Short nbDigits)
350 {
351   string ver = DriverMED_W_SMESHDS_Mesh::GetVersionString(MED::EVersion(version),
352                                                                nbDigits);
353   return CORBA::string_dup( ver.c_str() );
354 }
355
356 //=============================================================================
357 /*!
358  *  ImportUNVFile
359  *
360  *  Imports mesh data from MED file
361  */
362 //=============================================================================
363
364 int SMESH_Mesh_i::ImportUNVFile( const char* theFileName )
365   throw ( SALOME::SALOME_Exception )
366 {
367   // Read mesh with name = <theMeshName> into SMESH_Mesh
368   _impl->UNVToMesh( theFileName );
369
370   CreateGroupServants();
371
372   return 1;
373 }
374
375 //=============================================================================
376 /*!
377  *  ImportSTLFile
378  *
379  *  Imports mesh data from STL file
380  */
381 //=============================================================================
382 int SMESH_Mesh_i::ImportSTLFile( const char* theFileName )
383   throw ( SALOME::SALOME_Exception )
384 {
385   // Read mesh with name = <theMeshName> into SMESH_Mesh
386   _impl->STLToMesh( theFileName );
387
388   return 1;
389 }
390
391 //=============================================================================
392 /*!
393  *  importMEDFile
394  *
395  *  Imports mesh data from MED file
396  */
397 //=============================================================================
398
399 // int SMESH_Mesh_i::importMEDFile( const char* theFileName, const char* theMeshName )
400 // {
401 //   // Read mesh with name = <theMeshName> and all its groups into SMESH_Mesh
402 //   int status = _impl->MEDToMesh( theFileName, theMeshName );
403 //   CreateGroupServants();
404
405 //   return status;
406 // }
407
408 //=============================================================================
409 /*!
410  *
411  */
412 //=============================================================================
413
414 #define RETURNCASE(hyp_stat) case SMESH_Hypothesis::hyp_stat: return SMESH::hyp_stat;
415
416 SMESH::Hypothesis_Status SMESH_Mesh_i::ConvertHypothesisStatus
417                          (SMESH_Hypothesis::Hypothesis_Status theStatus)
418 {
419   switch (theStatus) {
420   RETURNCASE( HYP_OK            );
421   RETURNCASE( HYP_MISSING       );
422   RETURNCASE( HYP_CONCURENT     );
423   RETURNCASE( HYP_BAD_PARAMETER );
424   RETURNCASE( HYP_HIDDEN_ALGO   );
425   RETURNCASE( HYP_HIDING_ALGO   );
426   RETURNCASE( HYP_UNKNOWN_FATAL );
427   RETURNCASE( HYP_INCOMPATIBLE  );
428   RETURNCASE( HYP_NOTCONFORM    );
429   RETURNCASE( HYP_ALREADY_EXIST );
430   RETURNCASE( HYP_BAD_DIM       );
431   RETURNCASE( HYP_BAD_SUBSHAPE  );
432   RETURNCASE( HYP_BAD_GEOMETRY  );
433   RETURNCASE( HYP_NEED_SHAPE    );
434   default:;
435   }
436   return SMESH::HYP_UNKNOWN_FATAL;
437 }
438
439 //=============================================================================
440 /*!
441  *  AddHypothesis
442  *
443  *  calls internal addHypothesis() and then adds a reference to <anHyp> under
444  *  the SObject actually having a reference to <aSubShape>.
445  *  NB: For this method to work, it is necessary to add a reference to sub-shape first.
446  */
447 //=============================================================================
448
449 SMESH::Hypothesis_Status SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject,
450                                                      SMESH::SMESH_Hypothesis_ptr anHyp)
451   throw(SALOME::SALOME_Exception)
452 {
453   Unexpect aCatch(SALOME_SalomeException);
454   SMESH_Hypothesis::Hypothesis_Status status = addHypothesis( aSubShapeObject, anHyp );
455
456   if ( !SMESH_Hypothesis::IsStatusFatal(status) )
457     _gen_i->AddHypothesisToShape(_gen_i->GetCurrentStudy(), _this(),
458                                  aSubShapeObject, anHyp );
459
460   if(MYDEBUG) MESSAGE( " AddHypothesis(): status = " << status );
461
462   // Update Python script
463   if(_impl->HasShapeToMesh()) {
464     TPythonDump() << "status = " << _this() << ".AddHypothesis( "
465                   << aSubShapeObject << ", " << anHyp << " )";
466   }
467   else {
468     TPythonDump() << "status = " << _this() << ".AddHypothesis( "<< anHyp << " )";
469   }
470   
471   return ConvertHypothesisStatus(status);
472 }
473
474 //=============================================================================
475 /*!
476  *
477  */
478 //=============================================================================
479
480 SMESH_Hypothesis::Hypothesis_Status
481   SMESH_Mesh_i::addHypothesis(GEOM::GEOM_Object_ptr       aSubShapeObject,
482                               SMESH::SMESH_Hypothesis_ptr anHyp)
483 {
484   if(MYDEBUG) MESSAGE("addHypothesis");
485
486   if (CORBA::is_nil(aSubShapeObject) && HasShapeToMesh())
487     THROW_SALOME_CORBA_EXCEPTION("bad subShape reference",
488                                  SALOME::BAD_PARAM);
489
490   SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(anHyp);
491   if (CORBA::is_nil(myHyp))
492     THROW_SALOME_CORBA_EXCEPTION("bad hypothesis reference",
493                                  SALOME::BAD_PARAM);
494
495   SMESH_Hypothesis::Hypothesis_Status status = SMESH_Hypothesis::HYP_OK;
496   try
497   {
498     TopoDS_Shape myLocSubShape;
499     //use PseudoShape in case if mesh has no shape
500     if(HasShapeToMesh())
501       myLocSubShape = _gen_i->GeomObjectToShape( aSubShapeObject);
502     else              
503       myLocSubShape = _impl->GetShapeToMesh();
504     
505     int hypId = myHyp->GetId();
506     status = _impl->AddHypothesis(myLocSubShape, hypId);
507     if ( !SMESH_Hypothesis::IsStatusFatal(status) ) {
508       _mapHypo[hypId] = SMESH::SMESH_Hypothesis::_duplicate( myHyp );
509 #ifdef WITHGENERICOBJ
510       _mapHypo[hypId]->Register();
511 #endif
512       // assure there is a corresponding submesh
513       if ( !_impl->IsMainShape( myLocSubShape )) {
514         int shapeId = _impl->GetMeshDS()->ShapeToIndex( myLocSubShape );
515         if ( _mapSubMesh_i.find( shapeId ) == _mapSubMesh_i.end() )
516           createSubMesh( aSubShapeObject );
517       }
518     }
519   }
520   catch(SALOME_Exception & S_ex)
521   {
522     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
523   }
524   return status;
525 }
526
527 //=============================================================================
528 /*!
529  *
530  */
531 //=============================================================================
532
533 SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject,
534                                                         SMESH::SMESH_Hypothesis_ptr anHyp)
535      throw(SALOME::SALOME_Exception)
536 {
537   Unexpect aCatch(SALOME_SalomeException);
538   SMESH_Hypothesis::Hypothesis_Status status = removeHypothesis( aSubShapeObject, anHyp );
539
540   if ( !SMESH_Hypothesis::IsStatusFatal(status) )
541     _gen_i->RemoveHypothesisFromShape(_gen_i->GetCurrentStudy(), _this(),
542                                       aSubShapeObject, anHyp );
543
544   // Update Python script
545     // Update Python script
546   if(_impl->HasShapeToMesh()) {
547   TPythonDump() << "status = " << _this() << ".RemoveHypothesis( "
548                 << aSubShapeObject << ", " << anHyp << " )";
549   }
550   else {
551     TPythonDump() << "status = " << _this() << ".RemoveHypothesis( "
552                   << anHyp << " )";
553   }
554
555   return ConvertHypothesisStatus(status);
556 }
557
558 //=============================================================================
559 /*!
560  *
561  */
562 //=============================================================================
563
564 SMESH_Hypothesis::Hypothesis_Status
565 SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr       aSubShapeObject,
566                                SMESH::SMESH_Hypothesis_ptr anHyp)
567 {
568   if(MYDEBUG) MESSAGE("removeHypothesis()");
569   // **** proposer liste de subShape (selection multiple)
570
571   if (CORBA::is_nil(aSubShapeObject) && HasShapeToMesh())
572     THROW_SALOME_CORBA_EXCEPTION("bad subShape reference", SALOME::BAD_PARAM);
573
574   SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(anHyp);
575   if (CORBA::is_nil(myHyp))
576     THROW_SALOME_CORBA_EXCEPTION("bad hypothesis reference", SALOME::BAD_PARAM);
577
578   SMESH_Hypothesis::Hypothesis_Status status = SMESH_Hypothesis::HYP_OK;
579   try
580   {
581     TopoDS_Shape myLocSubShape;
582     //use PseudoShape in case if mesh has no shape
583     if(HasShapeToMesh())
584       myLocSubShape = _gen_i->GeomObjectToShape( aSubShapeObject);
585     else
586       myLocSubShape = _impl->GetShapeToMesh();
587
588     int hypId = myHyp->GetId();
589     status = _impl->RemoveHypothesis(myLocSubShape, hypId);
590 //     if ( !SMESH_Hypothesis::IsStatusFatal(status) ) EAP: hyp can be used on many subshapes
591 //       _mapHypo.erase( hypId );
592   }
593   catch(SALOME_Exception & S_ex)
594   {
595     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
596   }
597   return status;
598 }
599
600 //=============================================================================
601 /*!
602  *
603  */
604 //=============================================================================
605
606 SMESH::ListOfHypothesis *
607         SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShapeObject)
608 throw(SALOME::SALOME_Exception)
609 {
610   Unexpect aCatch(SALOME_SalomeException);
611   if (MYDEBUG) MESSAGE("GetHypothesisList");
612   if (_impl->HasShapeToMesh() && CORBA::is_nil(aSubShapeObject))
613     THROW_SALOME_CORBA_EXCEPTION("bad subShape reference", SALOME::BAD_PARAM);
614
615   SMESH::ListOfHypothesis_var aList = new SMESH::ListOfHypothesis();
616
617   try {
618     TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(aSubShapeObject);
619     if ( myLocSubShape.IsNull() && !_impl->HasShapeToMesh() )
620       myLocSubShape = _impl->GetShapeToMesh();
621     const list<const SMESHDS_Hypothesis*>& aLocalList = _impl->GetHypothesisList( myLocSubShape );
622     int i = 0, n = aLocalList.size();
623     aList->length( n );
624
625     for ( list<const SMESHDS_Hypothesis*>::const_iterator anIt = aLocalList.begin(); i < n && anIt != aLocalList.end(); anIt++ ) {
626       SMESHDS_Hypothesis* aHyp = (SMESHDS_Hypothesis*)(*anIt);
627       if ( _mapHypo.find( aHyp->GetID() ) != _mapHypo.end() )
628         aList[i++] = SMESH::SMESH_Hypothesis::_narrow( _mapHypo[aHyp->GetID()] );
629     }
630
631     aList->length( i );
632   }
633   catch(SALOME_Exception & S_ex) {
634     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
635   }
636
637   return aList._retn();
638 }
639
640 //=============================================================================
641 /*!
642  *
643  */
644 //=============================================================================
645 SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShapeObject,
646                                                   const char*           theName )
647      throw(SALOME::SALOME_Exception)
648 {
649   Unexpect aCatch(SALOME_SalomeException);
650   MESSAGE("SMESH_Mesh_i::GetSubMesh");
651   if (CORBA::is_nil(aSubShapeObject))
652     THROW_SALOME_CORBA_EXCEPTION("bad subShape reference",
653                                  SALOME::BAD_PARAM);
654
655   SMESH::SMESH_subMesh_var subMesh;
656   SMESH::SMESH_Mesh_var    aMesh = SMESH::SMESH_Mesh::_narrow(_this());
657   try {
658     TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(aSubShapeObject);
659
660     //Get or Create the SMESH_subMesh object implementation
661
662     int subMeshId = _impl->GetMeshDS()->ShapeToIndex( myLocSubShape );
663     if ( !subMeshId && ! _impl->GetMeshDS()->IsGroupOfSubShapes( myLocSubShape ))
664       THROW_SALOME_CORBA_EXCEPTION("not sub-shape of the main shape", SALOME::BAD_PARAM);
665
666     subMesh = getSubMesh( subMeshId );
667
668     // create a new subMesh object servant if there is none for the shape
669     if ( subMesh->_is_nil() )
670       subMesh = createSubMesh( aSubShapeObject );
671     if ( _gen_i->CanPublishInStudy( subMesh )) {
672       SALOMEDS::SObject_var aSO =
673         _gen_i->PublishSubMesh(_gen_i->GetCurrentStudy(), aMesh,
674                                subMesh, aSubShapeObject, theName );
675       if ( !aSO->_is_nil()) {
676         // Update Python script
677         TPythonDump() << aSO << " = " << _this() << ".GetSubMesh( "
678                       << aSubShapeObject << ", '" << theName << "' )";
679       }
680     }
681   }
682   catch(SALOME_Exception & S_ex) {
683     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
684   }
685   return subMesh._retn();
686 }
687
688 //=============================================================================
689 /*!
690  *
691  */
692 //=============================================================================
693
694 void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
695      throw (SALOME::SALOME_Exception)
696 {
697   if(MYDEBUG) MESSAGE("SMESH_Mesh_i::RemoveSubMesh");
698   if ( theSubMesh->_is_nil() )
699     return;
700
701   GEOM::GEOM_Object_var aSubShapeObject;
702   SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
703   if ( !aStudy->_is_nil() )  {
704     // Remove submesh's SObject
705     SALOMEDS::SObject_var anSO = _gen_i->ObjectToSObject( aStudy, theSubMesh );
706     if ( !anSO->_is_nil() ) {
707       long aTag = SMESH_Gen_i::GetRefOnShapeTag();
708       SALOMEDS::SObject_var anObj, aRef;
709       if ( anSO->FindSubObject( aTag, anObj ) && anObj->ReferencedObject( aRef ) )
710         aSubShapeObject = GEOM::GEOM_Object::_narrow( aRef->GetObject() );
711
712 //       if ( aSubShapeObject->_is_nil() ) // not published shape (IPAL13617)
713 //         aSubShapeObject = theSubMesh->GetSubShape();
714
715       aStudy->NewBuilder()->RemoveObjectWithChildren( anSO );
716
717       // Update Python script
718       TPythonDump() << _this() << ".RemoveSubMesh( " << anSO << " )";
719     }
720   }
721
722   removeSubMesh( theSubMesh, aSubShapeObject.in() );
723 }
724
725 //=============================================================================
726 /*!
727  *  ElementTypeString
728  */
729 //=============================================================================
730 #define CASE2STRING(enum) case SMESH::enum: return "SMESH."#enum;
731 inline TCollection_AsciiString ElementTypeString (SMESH::ElementType theElemType)
732 {
733   switch (theElemType) {
734     CASE2STRING( ALL );
735     CASE2STRING( NODE );
736     CASE2STRING( EDGE );
737     CASE2STRING( FACE );
738     CASE2STRING( VOLUME );
739     CASE2STRING( ELEM0D );
740   default:;
741   }
742   return "";
743 }
744
745 //=============================================================================
746 /*!
747  *
748  */
749 //=============================================================================
750
751 SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType,
752                                                  const char*         theName )
753      throw(SALOME::SALOME_Exception)
754 {
755   Unexpect aCatch(SALOME_SalomeException);
756   SMESH::SMESH_Group_var aNewGroup =
757     SMESH::SMESH_Group::_narrow( createGroup( theElemType, theName ));
758
759   if ( _gen_i->CanPublishInStudy( aNewGroup ) ) {
760     SALOMEDS::SObject_var aSO =
761       _gen_i->PublishGroup(_gen_i->GetCurrentStudy(), _this(),
762                            aNewGroup, GEOM::GEOM_Object::_nil(), theName);
763     if ( !aSO->_is_nil()) {
764       // Update Python script
765       TPythonDump() << aSO << " = " << _this() << ".CreateGroup( "
766                     << ElementTypeString(theElemType) << ", '" << theName << "' )";
767     }
768   }
769   return aNewGroup._retn();
770 }
771
772
773 //=============================================================================
774 /*!
775  *
776  */
777 //=============================================================================
778 SMESH::SMESH_GroupOnGeom_ptr SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType    theElemType,
779                                                                 const char*           theName,
780                                                                 GEOM::GEOM_Object_ptr theGeomObj)
781      throw(SALOME::SALOME_Exception)
782 {
783   Unexpect aCatch(SALOME_SalomeException);
784   SMESH::SMESH_GroupOnGeom_var aNewGroup;
785
786   TopoDS_Shape aShape = _gen_i->GeomObjectToShape( theGeomObj );
787   if ( !aShape.IsNull() )
788   {
789     aNewGroup = SMESH::SMESH_GroupOnGeom::_narrow
790       ( createGroup( theElemType, theName, aShape ));
791
792     if ( _gen_i->CanPublishInStudy( aNewGroup ) ) {
793       SALOMEDS::SObject_var aSO =
794         _gen_i->PublishGroup(_gen_i->GetCurrentStudy(), _this(),
795                              aNewGroup, theGeomObj, theName);
796       if ( !aSO->_is_nil()) {
797         // Update Python script
798         TPythonDump() << aSO << " = " << _this() << ".CreateGroupFromGEOM("
799                       << ElementTypeString(theElemType) << ", '" << theName << "', "
800                       << theGeomObj << " )";
801       }
802     }
803   }
804
805   return aNewGroup._retn();
806 }
807
808 //=============================================================================
809 /*!
810  *
811  */
812 //=============================================================================
813
814 void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
815      throw (SALOME::SALOME_Exception)
816 {
817   if ( theGroup->_is_nil() )
818     return;
819
820   SMESH_GroupBase_i* aGroup =
821     dynamic_cast<SMESH_GroupBase_i*>( SMESH_Gen_i::GetServant( theGroup ).in() );
822   if ( !aGroup )
823     return;
824
825   SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
826   if ( !aStudy->_is_nil() )  {
827     SALOMEDS::SObject_var aGroupSO = _gen_i->ObjectToSObject( aStudy, theGroup );
828
829     if ( !aGroupSO->_is_nil() ) {
830       // Update Python script
831       TPythonDump() << _this() << ".RemoveGroup( " << aGroupSO << " )";
832
833       // Remove group's SObject
834       aStudy->NewBuilder()->RemoveObjectWithChildren( aGroupSO );
835     }
836   }
837
838   // Remove the group from SMESH data structures
839   removeGroup( aGroup->GetLocalID() );
840 }
841
842 //=============================================================================
843 /*! RemoveGroupWithContents
844  *  Remove group with its contents
845  */
846 //=============================================================================
847 void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup )
848   throw (SALOME::SALOME_Exception)
849 {
850   if ( theGroup->_is_nil() )
851     return;
852
853   SMESH_GroupBase_i* aGroup =
854     dynamic_cast<SMESH_GroupBase_i*>( SMESH_Gen_i::GetServant( theGroup ).in() );
855   if ( !aGroup )
856     return;
857
858   SMESH::long_array_var anIds = aGroup->GetListOfID();
859   SMESH::SMESH_MeshEditor_var aMeshEditor = SMESH_Mesh_i::GetMeshEditor();
860
861   // Update Python script
862   TPythonDump() << _this() << ".RemoveGroupWithContents( " << theGroup << " )";
863
864   // Remove contents
865   if ( aGroup->GetType() == SMESH::NODE )
866     aMeshEditor->RemoveNodes( anIds );
867   else
868     aMeshEditor->RemoveElements( anIds );
869
870   // Remove group
871   RemoveGroup( theGroup );
872
873   // Clear python lines, created by RemoveNodes/Elements() and RemoveGroup()
874   _gen_i->RemoveLastFromPythonScript(_gen_i->GetCurrentStudy()->StudyId());
875   _gen_i->RemoveLastFromPythonScript(_gen_i->GetCurrentStudy()->StudyId());
876 }
877
878
879 //================================================================================
880 /*!
881  * \brief Get the list of groups existing in the mesh
882   * \retval SMESH::ListOfGroups * - list of groups
883  */
884 //================================================================================
885
886 SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups() throw(SALOME::SALOME_Exception)
887 {
888   Unexpect aCatch(SALOME_SalomeException);
889   if (MYDEBUG) MESSAGE("GetGroups");
890
891   SMESH::ListOfGroups_var aList = new SMESH::ListOfGroups();
892
893   // Python Dump
894   TPythonDump aPythonDump;
895   if ( !_mapGroups.empty() ) // (IMP13463) avoid "SyntaxError: can't assign to []"
896     aPythonDump << "[ ";
897
898   try {
899     aList->length( _mapGroups.size() );
900     int i = 0;
901     map<int, SMESH::SMESH_GroupBase_ptr>::iterator it = _mapGroups.begin();
902     for ( ; it != _mapGroups.end(); it++ ) {
903       if ( CORBA::is_nil( it->second )) continue;
904       aList[i++] = SMESH::SMESH_GroupBase::_duplicate( it->second );
905       // Python Dump
906       if (i > 1) aPythonDump << ", ";
907       aPythonDump << it->second;
908     }
909     aList->length( i );
910   }
911   catch(SALOME_Exception & S_ex) {
912     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
913   }
914
915   // Update Python script
916   if ( !_mapGroups.empty() ) // (IMP13463) avoid "SyntaxError: can't assign to []"
917     aPythonDump << " ] = " << _this() << ".GetGroups()";
918
919   return aList._retn();
920 }
921 //=============================================================================
922 /*!
923  *  Get number of groups existing in the mesh
924  */
925 //=============================================================================
926
927 CORBA::Long SMESH_Mesh_i::NbGroups() throw (SALOME::SALOME_Exception)
928 {
929   Unexpect aCatch(SALOME_SalomeException);
930   return _mapGroups.size();
931 }
932
933 //=============================================================================
934 /*! UnionGroups
935  *  New group is created. All mesh elements that are
936  *  present in initial groups are added to the new one
937  */
938 //=============================================================================
939 SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
940                                                   SMESH::SMESH_GroupBase_ptr theGroup2,
941                                                   const char* theName )
942   throw (SALOME::SALOME_Exception)
943 {
944   try
945   {
946     if ( theGroup1->_is_nil() || theGroup2->_is_nil() ||
947          theGroup1->GetType() != theGroup2->GetType() )
948       return SMESH::SMESH_Group::_nil();
949
950     // Create Union
951     SMESH::SMESH_Group_var aResGrp = CreateGroup( theGroup1->GetType(), theName );
952     if ( aResGrp->_is_nil() )
953       return SMESH::SMESH_Group::_nil();
954
955     SMESH::long_array_var anIds1 = theGroup1->GetListOfID();
956     SMESH::long_array_var anIds2 = theGroup2->GetListOfID();
957
958     TColStd_MapOfInteger aResMap;
959
960     for ( int i1 = 0, n1 = anIds1->length(); i1 < n1; i1++ )
961       aResMap.Add( anIds1[ i1 ] );
962
963     for ( int i2 = 0, n2 = anIds2->length(); i2 < n2; i2++ )
964       aResMap.Add( anIds2[ i2 ] );
965
966     SMESH::long_array_var aResIds = new SMESH::long_array;
967     aResIds->length( aResMap.Extent() );
968
969     int resI = 0;
970     TColStd_MapIteratorOfMapOfInteger anIter( aResMap );
971     for( ; anIter.More(); anIter.Next() )
972       aResIds[ resI++ ] = anIter.Key();
973
974     aResGrp->Add( aResIds );
975
976     // Clear python lines, created by CreateGroup() and Add()
977     SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
978     _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
979     _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
980
981     // Update Python script
982     TPythonDump() << aResGrp << " = " << _this() << ".UnionGroups( "
983                   << theGroup1 << ", " << theGroup2 << ", '"
984                   << theName << "' )";
985
986     return aResGrp._retn();
987   }
988   catch( ... )
989   {
990     return SMESH::SMESH_Group::_nil();
991   }
992 }
993
994 //=============================================================================
995 /*!
996   \brief Union list of groups. New group is created. All mesh elements that are
997    present in initial groups are added to the new one.
998   \param theGroups list of groups
999   \param theName name of group to be created
1000   \return pointer on the group
1001 */
1002 //=============================================================================
1003 SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups& theGroups,
1004                                                        const char*                theName )
1005 throw (SALOME::SALOME_Exception)
1006 {
1007   if ( !theName )
1008     return SMESH::SMESH_Group::_nil();
1009
1010   try
1011   {
1012     NCollection_Map< int > anIds;
1013     SMESH::ElementType aType = SMESH::ALL;
1014     for ( int g = 0, n = theGroups.length(); g < n; g++ )
1015     {
1016       SMESH::SMESH_GroupBase_var aGrp = theGroups[ g ];
1017       if ( CORBA::is_nil( aGrp ) )
1018         continue;
1019
1020       // check type
1021       SMESH::ElementType aCurrType = aGrp->GetType();
1022       if ( aType == SMESH::ALL )
1023         aType = aCurrType;
1024       else 
1025       {
1026         if ( aType != aCurrType )
1027           return SMESH::SMESH_Group::_nil();
1028       }
1029
1030       // unite ids
1031       SMESH::long_array_var aCurrIds = aGrp->GetListOfID();
1032       for ( int i = 0, n = aCurrIds->length(); i < n; i++ )
1033       {
1034         int aCurrId = aCurrIds[ i ];
1035         anIds.Add( aCurrId );
1036       }
1037     }
1038
1039     // Create group
1040     SMESH::SMESH_Group_var aResGrp = CreateGroup( aType, theName );
1041     if ( aResGrp->_is_nil() )
1042       return SMESH::SMESH_Group::_nil();
1043     
1044     // Create array of identifiers
1045     SMESH::long_array_var aResIds = new SMESH::long_array;
1046     aResIds->length( anIds.Extent() );
1047     
1048     NCollection_Map< int >::Iterator anIter( anIds );
1049     for ( int i = 0; anIter.More(); anIter.Next(), i++ )
1050     {
1051       aResIds[ i ] = anIter.Value();
1052     }
1053     aResGrp->Add( aResIds );
1054
1055     // Clear python lines, created by CreateGroup() and Add()
1056     SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
1057     _gen_i->RemoveLastFromPythonScript( aStudy->StudyId() );
1058     _gen_i->RemoveLastFromPythonScript( aStudy->StudyId() );
1059
1060     // Update Python script
1061     
1062     TPythonDump() << aResGrp << " = " << _this() << ".UnionListOfGroups( "
1063                   << &theGroups << ", '" << theName << "' )";
1064
1065     return aResGrp._retn();
1066   }
1067   catch( ... )
1068   {
1069     return SMESH::SMESH_Group::_nil();
1070   }
1071 }
1072
1073 //=============================================================================
1074 /*! IntersectGroups
1075  *  New group is created. All mesh elements that are
1076  *  present in both initial groups are added to the new one.
1077  */
1078 //=============================================================================
1079 SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
1080                                                       SMESH::SMESH_GroupBase_ptr theGroup2,
1081                                                       const char* theName )
1082   throw (SALOME::SALOME_Exception)
1083 {
1084   if ( theGroup1->_is_nil() || theGroup2->_is_nil() ||
1085        theGroup1->GetType() != theGroup2->GetType() )
1086     return SMESH::SMESH_Group::_nil();
1087
1088   // Create Intersection
1089   SMESH::SMESH_Group_var aResGrp = CreateGroup( theGroup1->GetType(), theName );
1090   if ( aResGrp->_is_nil() )
1091     return aResGrp;
1092
1093   SMESH::long_array_var anIds1 = theGroup1->GetListOfID();
1094   SMESH::long_array_var anIds2 = theGroup2->GetListOfID();
1095
1096   TColStd_MapOfInteger aMap1;
1097
1098   for ( int i1 = 0, n1 = anIds1->length(); i1 < n1; i1++ )
1099     aMap1.Add( anIds1[ i1 ] );
1100
1101   TColStd_SequenceOfInteger aSeq;
1102
1103   for ( int i2 = 0, n2 = anIds2->length(); i2 < n2; i2++ )
1104     if ( aMap1.Contains( anIds2[ i2 ] ) )
1105       aSeq.Append( anIds2[ i2 ] );
1106
1107   SMESH::long_array_var aResIds = new SMESH::long_array;
1108   aResIds->length( aSeq.Length() );
1109
1110   for ( int resI = 0, resN = aSeq.Length(); resI < resN; resI++ )
1111     aResIds[ resI ] = aSeq( resI + 1 );
1112
1113   aResGrp->Add( aResIds );
1114
1115   // Clear python lines, created by CreateGroup() and Add()
1116   SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
1117   _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
1118   _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
1119
1120   // Update Python script
1121   TPythonDump() << aResGrp << " = " << _this() << ".IntersectGroups( "
1122                 << theGroup1 << ", " << theGroup2 << ", '" << theName << "')";
1123
1124   return aResGrp._retn();
1125 }
1126
1127 //=============================================================================
1128 /*!
1129   \brief Intersect list of groups. New group is created. All mesh elements that 
1130   are present in all initial groups simultaneously are added to the new one.
1131   \param theGroups list of groups
1132   \param theName name of group to be created
1133   \return pointer on the group
1134 */
1135 //=============================================================================
1136 SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectListOfGroups( 
1137   const SMESH::ListOfGroups& theGroups, const char* theName )
1138 throw (SALOME::SALOME_Exception)
1139 {
1140   if ( !theName )
1141     return SMESH::SMESH_Group::_nil();
1142
1143   try
1144   {
1145     NCollection_DataMap< int, int > anIdToCount;
1146     SMESH::ElementType aType = SMESH::ALL;
1147     for ( int g = 0, n = theGroups.length(); g < n; g++ )
1148     {
1149       SMESH::SMESH_GroupBase_var aGrp = theGroups[ g ];
1150       if ( CORBA::is_nil( aGrp ) )
1151         continue;
1152
1153       // check type
1154       SMESH::ElementType aCurrType = aGrp->GetType();
1155       if ( aType == SMESH::ALL )
1156         aType = aCurrType;
1157       else 
1158       {
1159         if ( aType != aCurrType )
1160           return SMESH::SMESH_Group::_nil();
1161       }
1162
1163       // calculates number of occurance ids in groups
1164       SMESH::long_array_var aCurrIds = aGrp->GetListOfID();
1165       for ( int i = 0, n = aCurrIds->length(); i < n; i++ )
1166       {
1167         int aCurrId = aCurrIds[ i ];
1168         if ( !anIdToCount.IsBound( aCurrId ) )
1169           anIdToCount.Bind( aCurrId, 1 );
1170         else 
1171           anIdToCount( aCurrId ) = anIdToCount( aCurrId ) + 1;
1172       }
1173     }
1174     
1175     // create map of ids
1176     int nbGrp = theGroups.length();
1177     NCollection_Map< int > anIds;
1178     NCollection_DataMap< int, int >::Iterator anIter( anIdToCount );
1179     for ( ; anIter.More(); anIter.Next() )
1180     {
1181       int aCurrId = anIter.Key();
1182       int aCurrNb = anIter.Value();
1183       if ( aCurrNb == nbGrp )
1184         anIds.Add( aCurrId );
1185     }
1186
1187     // Create group
1188     SMESH::SMESH_Group_var aResGrp = CreateGroup( aType, theName );
1189     if ( aResGrp->_is_nil() )
1190       return SMESH::SMESH_Group::_nil();
1191     
1192     // Create array of identifiers
1193     SMESH::long_array_var aResIds = new SMESH::long_array;
1194     aResIds->length( anIds.Extent() );
1195     
1196     NCollection_Map< int >::Iterator aListIter( anIds );
1197     for ( int i = 0; aListIter.More(); aListIter.Next(), i++ )
1198     {
1199       aResIds[ i ] = aListIter.Value();
1200     }
1201     aResGrp->Add( aResIds );
1202
1203     // Clear python lines, created by CreateGroup() and Add()
1204     SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
1205     _gen_i->RemoveLastFromPythonScript( aStudy->StudyId() );
1206     _gen_i->RemoveLastFromPythonScript( aStudy->StudyId() );
1207
1208     // Update Python script
1209     
1210     TPythonDump() << aResGrp << " = " << _this() << ".IntersectListOfGroups( "
1211                   << &theGroups << ", '" << theName << "' )";
1212
1213     return aResGrp._retn();
1214   }
1215   catch( ... )
1216   {
1217     return SMESH::SMESH_Group::_nil();
1218   }
1219 }
1220
1221 //=============================================================================
1222 /*! CutGroups
1223  *  New group is created. All mesh elements that are present in
1224  *  main group but do not present in tool group are added to the new one
1225  */
1226 //=============================================================================
1227 SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
1228                                                 SMESH::SMESH_GroupBase_ptr theGroup2,
1229                                                 const char* theName )
1230   throw (SALOME::SALOME_Exception)
1231 {
1232   if ( theGroup1->_is_nil() || theGroup2->_is_nil() ||
1233        theGroup1->GetType() != theGroup2->GetType() )
1234     return SMESH::SMESH_Group::_nil();
1235
1236   // Perform Cutting
1237   SMESH::SMESH_Group_var aResGrp = CreateGroup( theGroup1->GetType(), theName );
1238   if ( aResGrp->_is_nil() )
1239     return aResGrp;
1240
1241   SMESH::long_array_var anIds1 = theGroup1->GetListOfID();
1242   SMESH::long_array_var anIds2 = theGroup2->GetListOfID();
1243
1244   TColStd_MapOfInteger aMap2;
1245
1246   for ( int i2 = 0, n2 = anIds2->length(); i2 < n2; i2++ )
1247     aMap2.Add( anIds2[ i2 ] );
1248
1249   TColStd_SequenceOfInteger aSeq;
1250   for ( int i1 = 0, n1 = anIds1->length(); i1 < n1; i1++ )
1251     if ( !aMap2.Contains( anIds1[ i1 ] ) )
1252       aSeq.Append( anIds1[ i1 ] );
1253
1254   SMESH::long_array_var aResIds = new SMESH::long_array;
1255   aResIds->length( aSeq.Length() );
1256
1257   for ( int resI = 0, resN = aSeq.Length(); resI < resN; resI++ )
1258     aResIds[ resI ] = aSeq( resI + 1 );
1259
1260   aResGrp->Add( aResIds );
1261
1262   // Clear python lines, created by CreateGroup() and Add()
1263   SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
1264   _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
1265   _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
1266
1267   // Update Python script
1268   TPythonDump() << aResGrp << " = " << _this() << ".CutGroups( "
1269                 << theGroup1 << ", " << theGroup2 << ", '"
1270                 << theName << "' )";
1271
1272   return aResGrp._retn();
1273 }
1274
1275 //=============================================================================
1276 /*!
1277   \brief Cut lists of groups. New group is created. All mesh elements that are 
1278   present in main groups but do not present in tool groups are added to the new one
1279   \param theMainGroups list of main groups
1280   \param theToolGroups list of tool groups
1281   \param theName name of group to be created
1282   \return pointer on the group
1283 */
1284 //=============================================================================
1285 SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutListOfGroups( 
1286   const SMESH::ListOfGroups& theMainGroups, 
1287   const SMESH::ListOfGroups& theToolGroups, 
1288   const char* theName )
1289   throw (SALOME::SALOME_Exception)
1290 {
1291   if ( !theName )
1292     return SMESH::SMESH_Group::_nil();
1293
1294   try
1295   {
1296     NCollection_Map< int > aToolIds;
1297     SMESH::ElementType aType = SMESH::ALL;
1298     int g, n;
1299     // iterate through tool groups
1300     for ( g = 0, n = theToolGroups.length(); g < n; g++ )
1301     {
1302       SMESH::SMESH_GroupBase_var aGrp = theToolGroups[ g ];
1303       if ( CORBA::is_nil( aGrp ) )
1304         continue;
1305
1306       // check type
1307       SMESH::ElementType aCurrType = aGrp->GetType();
1308       if ( aType == SMESH::ALL )
1309         aType = aCurrType;
1310       else 
1311       {
1312         if ( aType != aCurrType )
1313           return SMESH::SMESH_Group::_nil();
1314       }
1315
1316       // unite tool ids
1317       SMESH::long_array_var aCurrIds = aGrp->GetListOfID();
1318       for ( int i = 0, n = aCurrIds->length(); i < n; i++ )
1319       {
1320         int aCurrId = aCurrIds[ i ];
1321         aToolIds.Add( aCurrId );
1322       }
1323     }
1324
1325     NCollection_Map< int > anIds; // result
1326
1327     // Iterate through main group 
1328     for ( g = 0, n = theMainGroups.length(); g < n; g++ )
1329     {
1330       SMESH::SMESH_GroupBase_var aGrp = theMainGroups[ g ];
1331       if ( CORBA::is_nil( aGrp ) )
1332         continue;
1333
1334       // check type
1335       SMESH::ElementType aCurrType = aGrp->GetType();
1336       if ( aType == SMESH::ALL )
1337         aType = aCurrType;
1338       else 
1339       {
1340         if ( aType != aCurrType )
1341           return SMESH::SMESH_Group::_nil();
1342       }
1343
1344       // unite tool ids
1345       SMESH::long_array_var aCurrIds = aGrp->GetListOfID();
1346       for ( int i = 0, n = aCurrIds->length(); i < n; i++ )
1347       {
1348         int aCurrId = aCurrIds[ i ];
1349         if ( !aToolIds.Contains( aCurrId ) )
1350           anIds.Add( aCurrId );
1351       }
1352     }
1353
1354     // Create group
1355     SMESH::SMESH_Group_var aResGrp = CreateGroup( aType, theName );
1356     if ( aResGrp->_is_nil() )
1357       return SMESH::SMESH_Group::_nil();
1358     
1359     // Create array of identifiers
1360     SMESH::long_array_var aResIds = new SMESH::long_array;
1361     aResIds->length( anIds.Extent() );
1362     
1363     NCollection_Map< int >::Iterator anIter( anIds );
1364     for ( int i = 0; anIter.More(); anIter.Next(), i++ )
1365     {
1366       aResIds[ i ] = anIter.Value();
1367     }
1368     aResGrp->Add( aResIds );
1369
1370     // Clear python lines, created by CreateGroup() and Add()
1371     SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
1372     _gen_i->RemoveLastFromPythonScript( aStudy->StudyId() );
1373     _gen_i->RemoveLastFromPythonScript( aStudy->StudyId() );
1374
1375     // Update Python script
1376
1377     TPythonDump() << aResGrp << " = " << _this() << ".CutListOfGroups( "
1378                   << &theMainGroups << ", " << &theToolGroups << ", '"
1379                   << theName << "' )";
1380     
1381     return aResGrp._retn();
1382   }
1383   catch( ... )
1384   {
1385     return SMESH::SMESH_Group::_nil();
1386   }
1387 }
1388
1389 //=============================================================================
1390 /*!
1391   \brief Create groups of entities from existing groups of superior dimensions 
1392   System 
1393   1) extract all nodes from each group,
1394   2) combine all elements of specified dimension laying on these nodes.
1395   \param theGroups list of source groups 
1396   \param theElemType dimension of elements 
1397   \param theName name of new group
1398   \return pointer on new group
1399 */
1400 //=============================================================================
1401 SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateDimGroup( 
1402   const SMESH::ListOfGroups& theGroups, 
1403   SMESH::ElementType         theElemType, 
1404   const char*                theName )
1405   throw (SALOME::SALOME_Exception)
1406 {
1407   SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
1408
1409   if ( !theName || !aMeshDS )
1410     return SMESH::SMESH_Group::_nil();
1411
1412   SMDSAbs_ElementType anElemType = (SMDSAbs_ElementType)theElemType;
1413
1414   try
1415   {
1416     // Create map of nodes from all groups 
1417
1418     NCollection_Map< int > aNodeMap;
1419     
1420     for ( int g = 0, n = theGroups.length(); g < n; g++ )
1421     {
1422       SMESH::SMESH_GroupBase_var aGrp = theGroups[ g ];
1423       if ( CORBA::is_nil( aGrp ) )
1424         continue;
1425
1426       SMESH::ElementType aType = aGrp->GetType();
1427       if ( aType == SMESH::ALL )
1428         continue;
1429       else if ( aType == SMESH::NODE )
1430       {
1431         SMESH::long_array_var aCurrIds = aGrp->GetListOfID();
1432         for ( int i = 0, n = aCurrIds->length(); i < n; i++ )
1433         {
1434           int aCurrId = aCurrIds[ i ];
1435           const SMDS_MeshNode* aNode = aMeshDS->FindNode( aCurrId );
1436           if ( aNode )
1437             aNodeMap.Add( aNode->GetID() );
1438         }
1439       }
1440       else 
1441       {
1442         SMESH::long_array_var aCurrIds = aGrp->GetListOfID();
1443         for ( int i = 0, n = aCurrIds->length(); i < n; i++ )
1444         {
1445           int aCurrId = aCurrIds[ i ];
1446           const SMDS_MeshElement* anElem = aMeshDS->FindElement( aCurrId );
1447           if ( !anElem )
1448             continue;
1449           SMDS_ElemIteratorPtr aNodeIter = anElem->nodesIterator();
1450           while( aNodeIter->more() )
1451           {
1452             const SMDS_MeshNode* aNode = 
1453               dynamic_cast<const SMDS_MeshNode*>( aNodeIter->next() );
1454             if ( aNode )
1455               aNodeMap.Add( aNode->GetID() );
1456           }
1457         }
1458       }
1459     }
1460
1461     // Get result identifiers 
1462
1463     NCollection_Map< int > aResultIds;
1464     if ( theElemType == SMESH::NODE )
1465     {
1466       NCollection_Map< int >::Iterator aNodeIter( aNodeMap );
1467       for ( ; aNodeIter.More(); aNodeIter.Next() )
1468         aResultIds.Add( aNodeIter.Value() );
1469     }
1470     else
1471     {
1472       // Create list of elements of given dimension constructed on the nodes
1473       NCollection_Map< int > anElemList;
1474       NCollection_Map< int >::Iterator aNodeIter( aNodeMap );
1475       for ( ; aNodeIter.More(); aNodeIter.Next() )
1476       {
1477         const SMDS_MeshElement* aNode = 
1478           dynamic_cast<const SMDS_MeshElement*>( aMeshDS->FindNode( aNodeIter.Value() ) );
1479         if ( !aNode )
1480           continue;
1481
1482          SMDS_ElemIteratorPtr anElemIter = aNode->elementsIterator( anElemType );
1483         while( anElemIter->more() )
1484         {
1485           const SMDS_MeshElement* anElem = 
1486             dynamic_cast<const SMDS_MeshElement*>( anElemIter->next() );
1487           if ( anElem && anElem->GetType() == anElemType )
1488             anElemList.Add( anElem->GetID() );
1489         }
1490       }
1491
1492       // check whether all nodes of elements are present in nodes map
1493       NCollection_Map< int >::Iterator anIter( anElemList );
1494       for ( ; anIter.More(); anIter.Next() )
1495       {
1496         const SMDS_MeshElement* anElem = aMeshDS->FindElement( anIter.Value() );
1497         if ( !anElem )
1498           continue;
1499
1500         bool isOk = true;
1501         SMDS_ElemIteratorPtr aNodeIter = anElem->nodesIterator();
1502         while( aNodeIter->more() )
1503         {
1504           const SMDS_MeshNode* aNode = 
1505             dynamic_cast<const SMDS_MeshNode*>( aNodeIter->next() );
1506           if ( !aNode || !aNodeMap.Contains( aNode->GetID() ) )
1507           {
1508             isOk = false;
1509             break;
1510           }
1511         } 
1512         if ( isOk )
1513           aResultIds.Add( anElem->GetID() );
1514       }
1515     }
1516
1517     // Create group
1518
1519     SMESH::SMESH_Group_var aResGrp = CreateGroup( theElemType, theName );
1520     if ( aResGrp->_is_nil() )
1521       return SMESH::SMESH_Group::_nil();
1522     
1523     // Create array of identifiers
1524     SMESH::long_array_var aResIds = new SMESH::long_array;
1525     aResIds->length( aResultIds.Extent() );
1526     
1527     NCollection_Map< int >::Iterator aResIter( aResultIds );
1528     for ( int i = 0; aResIter.More(); aResIter.Next(), i++ )
1529       aResIds[ i ] = aResIter.Value();
1530     aResGrp->Add( aResIds );
1531
1532     // Remove strings corresponding to group creation
1533     SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
1534     _gen_i->RemoveLastFromPythonScript( aStudy->StudyId() );
1535     _gen_i->RemoveLastFromPythonScript( aStudy->StudyId() );
1536
1537     // Update Python script
1538     
1539     TPythonDump() << aResGrp << " = " << _this() << ".CreateDimGroup( "
1540                   << &theGroups << ", " << theElemType << ", '" << theName << "' )";
1541
1542     return aResGrp._retn();
1543   }
1544   catch( ... )
1545   {
1546     return SMESH::SMESH_Group::_nil();
1547   }
1548 }
1549
1550 //================================================================================
1551 /*!
1552  * \brief Remember GEOM group data
1553  */
1554 //================================================================================
1555
1556 void SMESH_Mesh_i::addGeomGroupData(GEOM::GEOM_Object_ptr theGeomObj,
1557                                     CORBA::Object_ptr     theSmeshObj)
1558 {
1559   if ( CORBA::is_nil( theGeomObj ) || theGeomObj->GetType() != GEOM_GROUP )
1560     return;
1561   // group SO
1562   SALOMEDS::Study_var   study  = _gen_i->GetCurrentStudy();
1563   SALOMEDS::SObject_var groupSO = _gen_i->ObjectToSObject( study, theGeomObj );
1564   if ( groupSO->_is_nil() )
1565     return;
1566   // group indices
1567   GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine();
1568   GEOM::GEOM_IGroupOperations_var groupOp =
1569     geomGen->GetIGroupOperations( _gen_i->GetCurrentStudyID() );
1570   GEOM::ListOfLong_var ids = groupOp->GetObjects( theGeomObj );
1571
1572   // store data
1573   _geomGroupData.push_back( TGeomGroupData() );
1574   TGeomGroupData & groupData = _geomGroupData.back();
1575   // entry
1576   CORBA::String_var entry = groupSO->GetID();
1577   groupData._groupEntry = entry.in();
1578   // indices
1579   for ( int i = 0; i < ids->length(); ++i )
1580     groupData._indices.insert( ids[i] );
1581   // SMESH object
1582   groupData._smeshObject = theSmeshObj;
1583 }
1584
1585 //================================================================================
1586 /*!
1587  * Remove GEOM group data relating to removed smesh object
1588  */
1589 //================================================================================
1590
1591 void SMESH_Mesh_i::removeGeomGroupData(CORBA::Object_ptr theSmeshObj)
1592 {
1593   list<TGeomGroupData>::iterator
1594     data = _geomGroupData.begin(), dataEnd = _geomGroupData.end();
1595   for ( ; data != dataEnd; ++data ) {
1596     if ( theSmeshObj->_is_equivalent( data->_smeshObject )) {
1597       _geomGroupData.erase( data );
1598       return;
1599     }
1600   }
1601 }
1602
1603 //================================================================================
1604 /*!
1605  * \brief Return new group contents if it has been changed and update group data
1606  */
1607 //================================================================================
1608
1609 TopoDS_Shape SMESH_Mesh_i::newGroupShape( TGeomGroupData & groupData)
1610 {
1611   TopoDS_Shape newShape;
1612
1613   // get geom group
1614   SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
1615   if ( study->_is_nil() ) return newShape; // means "not changed"
1616   SALOMEDS::SObject_var groupSO = study->FindObjectID( groupData._groupEntry.c_str() );
1617   if ( !groupSO->_is_nil() )
1618   {
1619     CORBA::Object_var groupObj = _gen_i->SObjectToObject( groupSO );
1620     if ( CORBA::is_nil( groupObj )) return newShape;
1621     GEOM::GEOM_Object_var geomGroup = GEOM::GEOM_Object::_narrow( groupObj );
1622
1623     // get indices of group items
1624     set<int> curIndices;
1625     GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine();
1626     GEOM::GEOM_IGroupOperations_var groupOp =
1627       geomGen->GetIGroupOperations( _gen_i->GetCurrentStudyID() );
1628     GEOM::ListOfLong_var ids = groupOp->GetObjects( geomGroup );
1629     for ( int i = 0; i < ids->length(); ++i )
1630       curIndices.insert( ids[i] );
1631
1632     if ( groupData._indices == curIndices )
1633       return newShape; // group not changed
1634
1635     // update data
1636     groupData._indices = curIndices;
1637
1638     GEOM_Client* geomClient = _gen_i->GetShapeReader();
1639     if ( !geomClient ) return newShape;
1640     TCollection_AsciiString groupIOR = geomGen->GetStringFromIOR( geomGroup );
1641     geomClient->RemoveShapeFromBuffer( groupIOR );
1642     newShape = _gen_i->GeomObjectToShape( geomGroup );
1643   }    
1644
1645   if ( newShape.IsNull() ) {
1646     // geom group becomes empty - return empty compound
1647     TopoDS_Compound compound;
1648     BRep_Builder().MakeCompound(compound);
1649     newShape = compound;
1650   }
1651   return newShape;
1652 }
1653
1654 namespace {
1655   //=============================================================================
1656   /*!
1657    * \brief Storage of shape and index used in CheckGeomGroupModif()
1658    */
1659   //=============================================================================
1660   struct TIndexedShape {
1661     int          _index;
1662     TopoDS_Shape _shape;
1663     TIndexedShape( int i, const TopoDS_Shape& s ):_index(i), _shape(s) {}
1664   };
1665 }
1666 //=============================================================================
1667 /*!
1668  * \brief Update objects depending on changed geom groups
1669  * 
1670  * NPAL16168: geometrical group edition from a submesh don't modifiy mesh computation
1671  * issue 0020210: Update of a smesh group after modification of the associated geom group
1672  */
1673 //=============================================================================
1674
1675 void SMESH_Mesh_i::CheckGeomGroupModif()
1676 {
1677   if ( !_impl->HasShapeToMesh() ) return;
1678
1679   SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
1680   if ( study->_is_nil() ) return;
1681
1682   CORBA::Long nbEntities = NbNodes() + NbElements();
1683
1684   // Check if group contents changed
1685
1686   typedef map< string, TopoDS_Shape > TEntry2Geom;
1687   TEntry2Geom newGroupContents;
1688
1689   list<TGeomGroupData>::iterator
1690     data = _geomGroupData.begin(), dataEnd = _geomGroupData.end();
1691   for ( ; data != dataEnd; ++data )
1692   {
1693     pair< TEntry2Geom::iterator, bool > it_new =
1694       newGroupContents.insert( make_pair( data->_groupEntry, TopoDS_Shape() ));
1695     bool processedGroup    = !it_new.second;
1696     TopoDS_Shape& newShape = it_new.first->second;
1697     if ( !processedGroup )
1698       newShape = newGroupShape( *data );
1699     if ( newShape.IsNull() )
1700       continue; // no changes
1701
1702     if ( processedGroup ) { // update group indices
1703       list<TGeomGroupData>::iterator data2 = data;
1704       for ( --data2; data2->_groupEntry != data->_groupEntry; --data2) {}
1705       data->_indices = data2->_indices;
1706     }
1707
1708     // Update SMESH objects according to new GEOM group contents
1709
1710     SMESH::SMESH_subMesh_var submesh = SMESH::SMESH_subMesh::_narrow( data->_smeshObject );
1711     if ( !submesh->_is_nil() ) // -------------- Sub mesh ---------------------
1712     {
1713       int oldID = submesh->GetId();
1714       if ( _mapSubMeshIor.find( oldID ) == _mapSubMeshIor.end() )
1715         continue;
1716       TopoDS_Shape oldShape = _mapSubMesh[oldID]->GetSubShape();
1717
1718       // update hypotheses
1719       list <const SMESHDS_Hypothesis * > hyps = _impl->GetHypothesisList(oldShape);
1720       list <const SMESHDS_Hypothesis * >::iterator hypIt;
1721       for ( hypIt = hyps.begin(); hypIt != hyps.end(); ++hypIt )
1722       {
1723         _impl->RemoveHypothesis( oldShape, (*hypIt)->GetID());
1724         _impl->AddHypothesis   ( newShape, (*hypIt)->GetID());
1725       }
1726       // care of submeshes
1727       SMESH_subMesh* newSubmesh = _impl->GetSubMesh( newShape );
1728       int newID = newSubmesh->GetId();
1729       if ( newID != oldID ) {
1730         _mapSubMesh   [ newID ] = newSubmesh;
1731         _mapSubMesh_i [ newID ] = _mapSubMesh_i [ oldID ];
1732         _mapSubMeshIor[ newID ] = _mapSubMeshIor[ oldID ];
1733         _mapSubMesh.   erase(oldID);
1734         _mapSubMesh_i. erase(oldID);
1735         _mapSubMeshIor.erase(oldID);
1736         _mapSubMesh_i [ newID ]->changeLocalId( newID );
1737       }
1738       continue;
1739     }
1740
1741     SMESH::SMESH_GroupOnGeom_var smeshGroup =
1742       SMESH::SMESH_GroupOnGeom::_narrow( data->_smeshObject );
1743     if ( !smeshGroup->_is_nil() ) // ------------ GROUP -----------------------
1744     {
1745       SMESH_GroupOnGeom_i* group_i = SMESH::DownCast<SMESH_GroupOnGeom_i*>( smeshGroup );
1746       if ( group_i ) {
1747         ::SMESH_Group* group = _impl->GetGroup( group_i->GetLocalID() );
1748         SMESHDS_GroupOnGeom* ds = static_cast<SMESHDS_GroupOnGeom*>( group->GetGroupDS() );
1749         ds->SetShape( newShape );
1750       }
1751       continue;
1752     }
1753
1754     SMESH::SMESH_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow( data->_smeshObject );
1755     if ( !mesh->_is_nil() ) // -------------- MESH ----------------------------
1756     {
1757       // Remove groups and submeshes basing on removed sub-shapes
1758
1759       TopTools_MapOfShape newShapeMap;
1760       TopoDS_Iterator shapeIt( newShape );
1761       for ( ; shapeIt.More(); shapeIt.Next() )
1762         newShapeMap.Add( shapeIt.Value() );
1763
1764       SMESHDS_Mesh* meshDS = _impl->GetMeshDS();
1765       for ( shapeIt.Initialize( meshDS->ShapeToMesh() ); shapeIt.More(); shapeIt.Next() )
1766       {
1767         if ( newShapeMap.Contains( shapeIt.Value() ))
1768           continue;
1769         TopTools_IndexedMapOfShape oldShapeMap;
1770         TopExp::MapShapes( shapeIt.Value(), oldShapeMap );
1771         for ( int i = 1; i <= oldShapeMap.Extent(); ++i )
1772         {
1773           const TopoDS_Shape& oldShape = oldShapeMap(i);
1774           int oldInd = meshDS->ShapeToIndex( oldShape );
1775           // -- submeshes --
1776           map<int, SMESH::SMESH_subMesh_ptr>::iterator i_smIor = _mapSubMeshIor.find( oldInd );
1777           if ( i_smIor != _mapSubMeshIor.end() ) {
1778             RemoveSubMesh( i_smIor->second ); // one submesh per shape index
1779           }
1780           // --- groups ---
1781           map<int, SMESH::SMESH_GroupBase_ptr>::iterator i_grp = _mapGroups.begin();
1782           for ( ; i_grp != _mapGroups.end(); ++i_grp )
1783           {
1784             // check if a group bases on oldInd shape
1785             SMESHDS_GroupOnGeom* grpOnGeom = 0;
1786             if ( ::SMESH_Group* g = _impl->GetGroup( i_grp->first ))
1787               grpOnGeom = dynamic_cast<SMESHDS_GroupOnGeom*>( g->GetGroupDS() );
1788             if ( grpOnGeom && oldShape.IsSame( grpOnGeom->GetShape() ))
1789             { // remove
1790               RemoveGroup( i_grp->second ); // several groups can base on same shape
1791               i_grp = _mapGroups.begin(); // _mapGroups changed - restart iteration
1792             }
1793           }
1794         }
1795       }
1796       // Reassign hypotheses and update groups after setting the new shape to mesh
1797
1798       // collect anassigned hypotheses
1799       typedef list< pair< TIndexedShape, list<const SMESHDS_Hypothesis*> > > TShapeHypList;
1800       list <const SMESHDS_Hypothesis * >::const_iterator hypIt;
1801       TShapeHypList assignedHyps;
1802       for ( int i = 1; i <= meshDS->MaxShapeIndex(); ++i )
1803       {
1804         const TopoDS_Shape& oldShape = meshDS->IndexToShape(i);
1805         list<const SMESHDS_Hypothesis*> hyps = meshDS->GetHypothesis( oldShape );// copy
1806         if ( !hyps.empty() ) {
1807           assignedHyps.push_back( make_pair( TIndexedShape(i,oldShape), hyps ));
1808           for ( hypIt = hyps.begin(); hypIt != hyps.end(); ++hypIt )
1809             _impl->RemoveHypothesis( oldShape, (*hypIt)->GetID());
1810         }
1811       }
1812       // collect shapes supporting groups
1813       typedef list < pair< TIndexedShape, SMDSAbs_ElementType > > TShapeTypeList;
1814       TShapeTypeList groupData;
1815       const set<SMESHDS_GroupBase*>& groups = meshDS->GetGroups();
1816       set<SMESHDS_GroupBase*>::const_iterator grIt = groups.begin();
1817       for ( ; grIt != groups.end(); ++grIt )
1818       {
1819         if ( SMESHDS_GroupOnGeom* gog = dynamic_cast<SMESHDS_GroupOnGeom*>( *grIt ))
1820           groupData.push_back
1821             ( make_pair( TIndexedShape( gog->GetID(),gog->GetShape()), gog->GetType()));
1822       }
1823       // set new shape to mesh -> DS of submeshes and geom groups is deleted
1824       _impl->ShapeToMesh( newShape );
1825       
1826       // reassign hypotheses
1827       TShapeHypList::iterator indS_hyps = assignedHyps.begin();
1828       for ( ; indS_hyps != assignedHyps.end(); ++indS_hyps )
1829       {
1830         TIndexedShape&                   geom = indS_hyps->first;
1831         list<const SMESHDS_Hypothesis*>& hyps = indS_hyps->second;
1832         int oldID = geom._index;
1833         int newID = meshDS->ShapeToIndex( geom._shape );
1834         if ( !newID )
1835           continue;
1836         if ( oldID == 1 ) { // main shape
1837           newID = 1;
1838           geom._shape = newShape;
1839         }
1840         for ( hypIt = hyps.begin(); hypIt != hyps.end(); ++hypIt )
1841           _impl->AddHypothesis( geom._shape, (*hypIt)->GetID());
1842         // care of submeshes
1843         SMESH_subMesh* newSubmesh = _impl->GetSubMesh( geom._shape );
1844         if ( newID != oldID ) {
1845           _mapSubMesh   [ newID ] = newSubmesh;
1846           _mapSubMesh_i [ newID ] = _mapSubMesh_i [ oldID ];
1847           _mapSubMeshIor[ newID ] = _mapSubMeshIor[ oldID ];
1848           _mapSubMesh.   erase(oldID);
1849           _mapSubMesh_i. erase(oldID);
1850           _mapSubMeshIor.erase(oldID);
1851           _mapSubMesh_i [ newID ]->changeLocalId( newID );
1852         }
1853       }
1854       // recreate groups
1855       TShapeTypeList::iterator geomType = groupData.begin();
1856       for ( ; geomType != groupData.end(); ++geomType )
1857       {
1858         const TIndexedShape& geom = geomType->first;
1859         int oldID = geom._index;
1860         if ( _mapGroups.find( oldID ) == _mapGroups.end() )
1861           continue;
1862         // get group name
1863         SALOMEDS::SObject_var groupSO = _gen_i->ObjectToSObject( study,_mapGroups[oldID] );
1864         CORBA::String_var     name    = groupSO->GetName();
1865         // update
1866         SMESH_GroupBase_i* group_i    = SMESH::DownCast<SMESH_GroupBase_i*>(_mapGroups[oldID] );
1867         int newID;
1868         if ( group_i && _impl->AddGroup( geomType->second, name.in(), newID, geom._shape ))
1869           group_i->changeLocalId( newID );
1870       }
1871
1872       break; // everything has been updated
1873
1874     } // update mesh
1875   } // loop on group data
1876
1877   // Update icons
1878
1879   CORBA::Long newNbEntities = NbNodes() + NbElements();
1880   list< SALOMEDS::SObject_var > soToUpdateIcons;
1881   if ( newNbEntities != nbEntities )
1882   {
1883     // Add all SObjects with icons
1884     soToUpdateIcons.push_back( _gen_i->ObjectToSObject( study, _this() )); // mesh
1885
1886     for (map<int, SMESH::SMESH_subMesh_ptr>::iterator i_sm = _mapSubMeshIor.begin();
1887          i_sm != _mapSubMeshIor.end(); ++i_sm ) // submeshes
1888       soToUpdateIcons.push_back( _gen_i->ObjectToSObject( study, i_sm->second ));
1889
1890     for ( map<int, SMESH::SMESH_GroupBase_ptr>::iterator i_gr = _mapGroups.begin();
1891           i_gr != _mapGroups.end(); ++i_gr ) // groups
1892       soToUpdateIcons.push_back( _gen_i->ObjectToSObject( study, i_gr->second ));
1893   }
1894
1895   list< SALOMEDS::SObject_var >::iterator so = soToUpdateIcons.begin();
1896   for ( ; so != soToUpdateIcons.end(); ++so )
1897     _gen_i->SetPixMap( *so, "ICON_SMESH_TREE_MESH_WARN" );
1898 }
1899
1900 //=============================================================================
1901 /*!
1902  * \brief Create standalone group instead if group on geometry
1903  */
1904 //=============================================================================
1905
1906 SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupOnGeom_ptr theGroup )
1907 {
1908   SMESH::SMESH_Group_var aGroup;
1909   if ( theGroup->_is_nil() )
1910     return aGroup._retn();
1911
1912   Unexpect aCatch(SALOME_SalomeException);
1913
1914   SMESH_GroupBase_i* aGroupToRem =
1915     dynamic_cast<SMESH_GroupBase_i*>( SMESH_Gen_i::GetServant( theGroup ).in() );
1916   if ( !aGroupToRem )
1917     return aGroup._retn();
1918
1919   int anId = aGroupToRem->GetLocalID();
1920   if ( !_impl->ConvertToStandalone( anId ) )
1921     return aGroup._retn();
1922   removeGeomGroupData( theGroup );
1923
1924   SMESH_GroupBase_i* aGroupImpl = new SMESH_Group_i( SMESH_Gen_i::GetPOA(), this, anId );
1925
1926   // remove old instance of group from own map
1927   _mapGroups.erase( anId );
1928
1929   SALOMEDS::StudyBuilder_var builder;
1930   SALOMEDS::SObject_var aGroupSO;
1931   SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
1932   if ( !aStudy->_is_nil() )  {
1933     builder = aStudy->NewBuilder();
1934     aGroupSO = _gen_i->ObjectToSObject( aStudy, theGroup );
1935     if ( !aGroupSO->_is_nil() ) {
1936
1937     // remove reference to geometry
1938     SALOMEDS::ChildIterator_var chItr = aStudy->NewChildIterator(aGroupSO);
1939     for ( ; chItr->More(); chItr->Next() )
1940       // Remove group's child SObject
1941       builder->RemoveObject( chItr->Value() );
1942
1943       // Update Python script
1944       TPythonDump() << aGroupSO << " = " << _this() << ".ConvertToStandalone( "
1945                     << aGroupSO << " )";
1946     }
1947   }
1948
1949   // PAL7962: san -- To ensure correct mapping of servant and correct reference counting in GenericObj_i
1950   SMESH_Gen_i::GetPOA()->activate_object( aGroupImpl );
1951   aGroupImpl->Register();
1952   // PAL7962: san -- To ensure correct mapping of servant and correct reference counting in GenericObj_i
1953
1954   // remember new group in own map
1955   aGroup = SMESH::SMESH_Group::_narrow( aGroupImpl->_this() );
1956   _mapGroups[anId] = SMESH::SMESH_GroupBase::_duplicate( aGroup );
1957
1958   // register CORBA object for persistence
1959   /*int nextId =*/ _gen_i->RegisterObject( aGroup );
1960
1961   builder->SetIOR( aGroupSO, _gen_i->GetORB()->object_to_string( aGroup ) );
1962
1963   return aGroup._retn();
1964 }
1965
1966 //=============================================================================
1967 /*!
1968  *
1969  */
1970 //=============================================================================
1971
1972 SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::createSubMesh( GEOM::GEOM_Object_ptr theSubShapeObject )
1973 {
1974   if(MYDEBUG) MESSAGE( "createSubMesh" );
1975   TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(theSubShapeObject);
1976
1977   ::SMESH_subMesh * mySubMesh = _impl->GetSubMesh(myLocSubShape);
1978   int subMeshId = _impl->GetMeshDS()->ShapeToIndex( myLocSubShape );
1979   SMESH_subMesh_i *subMeshServant = new SMESH_subMesh_i(myPOA, _gen_i, this, subMeshId);
1980   SMESH::SMESH_subMesh_var subMesh
1981     = SMESH::SMESH_subMesh::_narrow(subMeshServant->_this());
1982
1983   _mapSubMesh[subMeshId] = mySubMesh;
1984   _mapSubMesh_i[subMeshId] = subMeshServant;
1985   _mapSubMeshIor[subMeshId] = SMESH::SMESH_subMesh::_duplicate(subMesh);
1986
1987   // register CORBA object for persistence
1988   int nextId = _gen_i->RegisterObject( subMesh );
1989   if(MYDEBUG) MESSAGE( "Add submesh to map with id = "<< nextId);
1990
1991   // to track changes of GEOM groups
1992   addGeomGroupData( theSubShapeObject, subMesh );
1993
1994   return subMesh._retn();
1995 }
1996
1997 //=======================================================================
1998 //function : getSubMesh
1999 //purpose  :
2000 //=======================================================================
2001
2002 SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::getSubMesh(int shapeID)
2003 {
2004   map<int, SMESH::SMESH_subMesh_ptr>::iterator it = _mapSubMeshIor.find( shapeID );
2005   if ( it == _mapSubMeshIor.end() )
2006     return SMESH::SMESH_subMesh::_nil();
2007
2008   return SMESH::SMESH_subMesh::_duplicate( (*it).second );
2009 }
2010
2011
2012 //=============================================================================
2013 /*!
2014  *
2015  */
2016 //=============================================================================
2017
2018 void SMESH_Mesh_i::removeSubMesh (SMESH::SMESH_subMesh_ptr theSubMesh,
2019                                   GEOM::GEOM_Object_ptr    theSubShapeObject )
2020 {
2021   MESSAGE("SMESH_Mesh_i::removeSubMesh()");
2022   if ( theSubMesh->_is_nil() /*|| theSubShapeObject->_is_nil()*/ )
2023     return;
2024
2025   if ( theSubShapeObject->_is_nil() )  // not published shape (IPAL13617)
2026   {
2027     CORBA::Long shapeId = theSubMesh->GetId();
2028     if ( _mapSubMesh.find( shapeId ) != _mapSubMesh.end())
2029     {
2030       TopoDS_Shape S = _mapSubMesh[ shapeId ]->GetSubShape();
2031       if ( !S.IsNull() )
2032       {
2033         list<const SMESHDS_Hypothesis*> hyps = _impl->GetHypothesisList( S );
2034         list<const SMESHDS_Hypothesis*>::const_iterator hyp = hyps.begin();
2035         for ( ; hyp != hyps.end(); ++hyp )
2036           _impl->RemoveHypothesis(S, (*hyp)->GetID());
2037       }
2038     }
2039   }
2040   else
2041   {
2042     try {
2043       SMESH::ListOfHypothesis_var aHypList = GetHypothesisList( theSubShapeObject );
2044       for ( int i = 0, n = aHypList->length(); i < n; i++ ) {
2045         removeHypothesis( theSubShapeObject, aHypList[i] );
2046       }
2047     }
2048     catch( const SALOME::SALOME_Exception& ) {
2049       INFOS("SMESH_Mesh_i::removeSubMesh(): exception caught!");
2050     }
2051     removeGeomGroupData( theSubShapeObject );
2052   }
2053   int subMeshId = theSubMesh->GetId();
2054
2055   _mapSubMesh.erase(subMeshId);
2056   _mapSubMesh_i.erase(subMeshId);
2057   _mapSubMeshIor.erase(subMeshId);
2058   if(MYDEBUG) MESSAGE("SMESH_Mesh_i::removeSubMesh() completed");
2059 }
2060
2061 //=============================================================================
2062 /*!
2063  *
2064  */
2065 //=============================================================================
2066
2067 SMESH::SMESH_GroupBase_ptr SMESH_Mesh_i::createGroup (SMESH::ElementType theElemType,
2068                                                       const char*         theName,
2069                                                       const TopoDS_Shape& theShape )
2070 {
2071   int anId;
2072   SMESH::SMESH_GroupBase_var aGroup;
2073   if ( _impl->AddGroup( (SMDSAbs_ElementType)theElemType, theName, anId, theShape )) {
2074     SMESH_GroupBase_i* aGroupImpl;
2075     if ( !theShape.IsNull() )
2076       aGroupImpl = new SMESH_GroupOnGeom_i( SMESH_Gen_i::GetPOA(), this, anId );
2077     else
2078       aGroupImpl = new SMESH_Group_i( SMESH_Gen_i::GetPOA(), this, anId );
2079
2080     // PAL7962: san -- To ensure correct mapping of servant and correct reference counting in GenericObj_i
2081     SMESH_Gen_i::GetPOA()->activate_object( aGroupImpl );
2082     aGroupImpl->Register();
2083     // PAL7962: san -- To ensure correct mapping of servant and correct reference counting in GenericObj_i
2084
2085     aGroup = SMESH::SMESH_GroupBase::_narrow( aGroupImpl->_this() );
2086     _mapGroups[anId] = SMESH::SMESH_GroupBase::_duplicate( aGroup );
2087
2088     // register CORBA object for persistence
2089     int nextId = _gen_i->RegisterObject( aGroup );
2090     if(MYDEBUG) MESSAGE( "Add group to map with id = "<< nextId);
2091
2092     // to track changes of GEOM groups
2093     if ( !theShape.IsNull() ) {
2094       GEOM::GEOM_Object_var geom = _gen_i->ShapeToGeomObject( theShape );
2095       addGeomGroupData( geom, aGroup );
2096     }
2097   }
2098   return aGroup._retn();
2099 }
2100
2101 //=============================================================================
2102 /*!
2103  * SMESH_Mesh_i::removeGroup
2104  *
2105  * Should be called by ~SMESH_Group_i()
2106  */
2107 //=============================================================================
2108
2109 void SMESH_Mesh_i::removeGroup( const int theId )
2110 {
2111   if(MYDEBUG) MESSAGE("SMESH_Mesh_i::removeGroup()" );
2112   if ( _mapGroups.find( theId ) != _mapGroups.end() ) {
2113     removeGeomGroupData( _mapGroups[theId] );
2114     _mapGroups.erase( theId );
2115     _impl->RemoveGroup( theId );
2116   }
2117 }
2118
2119
2120 //=============================================================================
2121 /*!
2122  *
2123  */
2124 //=============================================================================
2125
2126 SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet)
2127 throw(SALOME::SALOME_Exception)
2128 {
2129   if(MYDEBUG) MESSAGE("SMESH_Mesh_i::GetLog");
2130
2131   SMESH::log_array_var aLog;
2132   try{
2133     list < SMESHDS_Command * >logDS = _impl->GetLog();
2134     aLog = new SMESH::log_array;
2135     int indexLog = 0;
2136     int lg = logDS.size();
2137     SCRUTE(lg);
2138     aLog->length(lg);
2139     list < SMESHDS_Command * >::iterator its = logDS.begin();
2140     while(its != logDS.end()){
2141       SMESHDS_Command *com = *its;
2142       int comType = com->GetType();
2143       //SCRUTE(comType);
2144       int lgcom = com->GetNumber();
2145       //SCRUTE(lgcom);
2146       const list < int >&intList = com->GetIndexes();
2147       int inum = intList.size();
2148       //SCRUTE(inum);
2149       list < int >::const_iterator ii = intList.begin();
2150       const list < double >&coordList = com->GetCoords();
2151       int rnum = coordList.size();
2152       //SCRUTE(rnum);
2153       list < double >::const_iterator ir = coordList.begin();
2154       aLog[indexLog].commandType = comType;
2155       aLog[indexLog].number = lgcom;
2156       aLog[indexLog].coords.length(rnum);
2157       aLog[indexLog].indexes.length(inum);
2158       for(int i = 0; i < rnum; i++){
2159         aLog[indexLog].coords[i] = *ir;
2160         //MESSAGE(" "<<i<<" "<<ir.Value());
2161         ir++;
2162       }
2163       for(int i = 0; i < inum; i++){
2164         aLog[indexLog].indexes[i] = *ii;
2165         //MESSAGE(" "<<i<<" "<<ii.Value());
2166         ii++;
2167       }
2168       indexLog++;
2169       its++;
2170     }
2171     if(clearAfterGet)
2172       _impl->ClearLog();
2173   }
2174   catch(SALOME_Exception & S_ex){
2175     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
2176   }
2177   return aLog._retn();
2178 }
2179
2180
2181 //=============================================================================
2182 /*!
2183  *
2184  */
2185 //=============================================================================
2186
2187 void SMESH_Mesh_i::ClearLog() throw(SALOME::SALOME_Exception)
2188 {
2189   if(MYDEBUG) MESSAGE("SMESH_Mesh_i::ClearLog");
2190   _impl->ClearLog();
2191 }
2192
2193 //=============================================================================
2194 /*!
2195  *
2196  */
2197 //=============================================================================
2198
2199 CORBA::Long SMESH_Mesh_i::GetId()throw(SALOME::SALOME_Exception)
2200 {
2201   if(MYDEBUG) MESSAGE("SMESH_Mesh_i::GetId");
2202   return _id;
2203 }
2204
2205 //=============================================================================
2206 /*!
2207  *
2208  */
2209 //=============================================================================
2210
2211 CORBA::Long SMESH_Mesh_i::GetStudyId()throw(SALOME::SALOME_Exception)
2212 {
2213   return _studyId;
2214 }
2215
2216 //=============================================================================
2217 /*!
2218  *
2219  */
2220 //=============================================================================
2221
2222 void SMESH_Mesh_i::SetImpl(::SMESH_Mesh * impl)
2223 {
2224   if(MYDEBUG) MESSAGE("SMESH_Mesh_i::SetImpl");
2225   _impl = impl;
2226 }
2227
2228 //=============================================================================
2229 /*!
2230  *
2231  */
2232 //=============================================================================
2233
2234 ::SMESH_Mesh & SMESH_Mesh_i::GetImpl()
2235 {
2236   if(MYDEBUG) MESSAGE("SMESH_Mesh_i::GetImpl()");
2237   return *_impl;
2238 }
2239
2240 //=============================================================================
2241 /*!
2242  * Return mesh editor
2243  */
2244 //=============================================================================
2245
2246 SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor()
2247 {
2248   // Create MeshEditor
2249   SMESH_MeshEditor_i *aMeshEditor = new SMESH_MeshEditor_i( this, false );
2250   SMESH::SMESH_MeshEditor_var aMesh = aMeshEditor->_this();
2251
2252   // Update Python script
2253   TPythonDump() << aMeshEditor << " = " << _this() << ".GetMeshEditor()";
2254
2255   return aMesh._retn();
2256 }
2257
2258 //=============================================================================
2259 /*!
2260  * Return mesh edition previewer
2261  */
2262 //=============================================================================
2263
2264 SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditPreviewer()
2265 {
2266   SMESH_MeshEditor_i *aMeshEditor = new SMESH_MeshEditor_i( this, true );
2267   SMESH::SMESH_MeshEditor_var aMesh = aMeshEditor->_this();
2268   return aMesh._retn();
2269 }
2270
2271 //================================================================================
2272 /*!
2273  * \brief Return true if the mesh has been edited since a last total re-compute
2274  *        and those modifications may prevent successful partial re-compute
2275  */
2276 //================================================================================
2277
2278 CORBA::Boolean SMESH_Mesh_i::HasModificationsToDiscard() throw(SALOME::SALOME_Exception)
2279 {
2280   Unexpect aCatch(SALOME_SalomeException);
2281   return _impl->HasModificationsToDiscard();
2282 }
2283
2284 //=============================================================================
2285 /*!
2286  *
2287  */
2288 //=============================================================================
2289 void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor) throw(SALOME::SALOME_Exception)
2290 {
2291   Unexpect aCatch(SALOME_SalomeException);
2292   _impl->SetAutoColor(theAutoColor);
2293 }
2294
2295 //=============================================================================
2296 /*!
2297  *
2298  */
2299 //=============================================================================
2300 CORBA::Boolean SMESH_Mesh_i::GetAutoColor() throw(SALOME::SALOME_Exception)
2301 {
2302   Unexpect aCatch(SALOME_SalomeException);
2303   return _impl->GetAutoColor();
2304 }
2305
2306
2307 //=============================================================================
2308 /*!
2309  *  Export in different formats
2310  */
2311 //=============================================================================
2312
2313 CORBA::Boolean SMESH_Mesh_i::HasDuplicatedGroupNamesMED()
2314 {
2315   return _impl->HasDuplicatedGroupNamesMED();
2316 }
2317
2318 void SMESH_Mesh_i::PrepareForWriting (const char* file, bool overwrite)
2319 {
2320   TCollection_AsciiString aFullName ((char*)file);
2321   OSD_Path aPath (aFullName);
2322   OSD_File aFile (aPath);
2323   if (aFile.Exists()) {
2324     // existing filesystem node
2325     if (aFile.KindOfFile() == OSD_FILE) {
2326       if (aFile.IsWriteable()) {
2327         if (overwrite) {
2328           aFile.Reset();
2329           aFile.Remove();
2330         }
2331         if (aFile.Failed()) {
2332           TCollection_AsciiString msg ("File ");
2333           msg += aFullName + " cannot be replaced.";
2334           THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM);
2335         }
2336       } else {
2337         TCollection_AsciiString msg ("File ");
2338         msg += aFullName + " cannot be overwritten.";
2339         THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM);
2340       }
2341     } else {
2342       TCollection_AsciiString msg ("Location ");
2343       msg += aFullName + " is not a file.";
2344       THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM);
2345     }
2346   } else {
2347     // nonexisting file; check if it can be created
2348     aFile.Reset();
2349     aFile.Build(OSD_WriteOnly, OSD_Protection());
2350     if (aFile.Failed()) {
2351       TCollection_AsciiString msg ("You cannot create the file ");
2352       msg += aFullName + ". Check the directory existance and access rights.";
2353       THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM);
2354     } else {
2355       aFile.Close();
2356       aFile.Remove();
2357     }
2358   }
2359 }
2360
2361 void SMESH_Mesh_i::ExportToMEDX (const char* file,
2362                                  CORBA::Boolean auto_groups,
2363                                  SMESH::MED_VERSION theVersion,
2364                                  CORBA::Boolean overwrite)
2365   throw(SALOME::SALOME_Exception)
2366 {
2367   Unexpect aCatch(SALOME_SalomeException);
2368
2369   // Perform Export
2370   PrepareForWriting(file, overwrite);
2371   const char* aMeshName = "Mesh";
2372   SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
2373   if ( !aStudy->_is_nil() ) {
2374     SALOMEDS::SObject_var aMeshSO = _gen_i->ObjectToSObject( aStudy, _this() );
2375     if ( !aMeshSO->_is_nil() ) {
2376       aMeshName = aMeshSO->GetName();
2377       // asv : 27.10.04 : fix of 6903: check for StudyLocked before adding attributes
2378       if ( !aStudy->GetProperties()->IsLocked() )
2379         {
2380         SALOMEDS::GenericAttribute_var anAttr;
2381         SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
2382         SALOMEDS::AttributeExternalFileDef_var aFileName;
2383         anAttr=aStudyBuilder->FindOrCreateAttribute(aMeshSO, "AttributeExternalFileDef");
2384         aFileName = SALOMEDS::AttributeExternalFileDef::_narrow(anAttr);
2385         ASSERT(!aFileName->_is_nil());
2386         aFileName->SetValue(file);
2387         SALOMEDS::AttributeFileType_var aFileType;
2388         anAttr=aStudyBuilder->FindOrCreateAttribute(aMeshSO, "AttributeFileType");
2389         aFileType = SALOMEDS::AttributeFileType::_narrow(anAttr);
2390         ASSERT(!aFileType->_is_nil());
2391         aFileType->SetValue("FICHIERMED");
2392         }
2393     }
2394   }
2395   // Update Python script
2396   // set name of mesh before export
2397   TPythonDump() << _gen_i << ".SetName(" << _this() << ", '" << aMeshName << "')";
2398   
2399   // check names of groups
2400   checkGroupNames();
2401
2402   TPythonDump() << _this() << ".ExportToMEDX( r'"
2403                 << file << "', " << auto_groups << ", " << theVersion << ", " << overwrite << " )";
2404
2405   _impl->ExportMED( file, aMeshName, auto_groups, theVersion );
2406 }
2407
2408 void SMESH_Mesh_i::ExportToMED (const char* file,
2409                                 CORBA::Boolean auto_groups,
2410                                 SMESH::MED_VERSION theVersion)
2411   throw(SALOME::SALOME_Exception)
2412 {
2413   ExportToMEDX(file,auto_groups,theVersion,true);
2414 }
2415
2416 void SMESH_Mesh_i::ExportMED (const char* file,
2417                               CORBA::Boolean auto_groups)
2418   throw(SALOME::SALOME_Exception)
2419 {
2420   ExportToMEDX(file,auto_groups,SMESH::MED_V2_1,true);
2421 }
2422
2423 void SMESH_Mesh_i::ExportDAT (const char *file)
2424   throw(SALOME::SALOME_Exception)
2425 {
2426   Unexpect aCatch(SALOME_SalomeException);
2427
2428   // Update Python script
2429   // check names of groups
2430   checkGroupNames();
2431   TPythonDump() << _this() << ".ExportDAT( r'" << file << "' )";
2432
2433   // Perform Export
2434   PrepareForWriting(file);
2435   _impl->ExportDAT(file);
2436 }
2437
2438 void SMESH_Mesh_i::ExportUNV (const char *file)
2439   throw(SALOME::SALOME_Exception)
2440 {
2441   Unexpect aCatch(SALOME_SalomeException);
2442
2443   // Update Python script
2444   // check names of groups
2445   checkGroupNames();
2446   TPythonDump() << _this() << ".ExportUNV( r'" << file << "' )";
2447
2448   // Perform Export
2449   PrepareForWriting(file);
2450   _impl->ExportUNV(file);
2451 }
2452
2453 void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii)
2454   throw(SALOME::SALOME_Exception)
2455 {
2456   Unexpect aCatch(SALOME_SalomeException);
2457
2458   // Update Python script
2459   // check names of groups
2460   checkGroupNames();
2461   TPythonDump() << _this() << ".ExportSTL( r'" << file << "', " << isascii << " )";
2462
2463   // Perform Export
2464   PrepareForWriting(file);
2465   _impl->ExportSTL(file, isascii);
2466 }
2467
2468 //=============================================================================
2469 /*!
2470  *
2471  */
2472 //=============================================================================
2473
2474 SALOME_MED::MESH_ptr SMESH_Mesh_i::GetMEDMesh()throw(SALOME::SALOME_Exception)
2475 {
2476   Unexpect aCatch(SALOME_SalomeException);
2477   SMESH_MEDMesh_i *aMedMesh = new SMESH_MEDMesh_i(this);
2478   SALOME_MED::MESH_var aMesh = aMedMesh->_this();
2479   return aMesh._retn();
2480 }
2481
2482 //=============================================================================
2483 /*!
2484  *
2485  */
2486 //=============================================================================
2487 CORBA::Long SMESH_Mesh_i::NbNodes()throw(SALOME::SALOME_Exception)
2488 {
2489   Unexpect aCatch(SALOME_SalomeException);
2490   return _impl->NbNodes();
2491 }
2492
2493 //=============================================================================
2494 /*!
2495  *
2496  */
2497 //=============================================================================
2498 CORBA::Long SMESH_Mesh_i::NbElements()throw (SALOME::SALOME_Exception)
2499 {
2500   Unexpect aCatch(SALOME_SalomeException);
2501   return Nb0DElements() + NbEdges() + NbFaces() + NbVolumes();
2502 }
2503
2504 //=============================================================================
2505 /*!
2506  *
2507  */
2508 //=============================================================================
2509 CORBA::Long SMESH_Mesh_i::Nb0DElements()throw (SALOME::SALOME_Exception)
2510 {
2511   Unexpect aCatch(SALOME_SalomeException);
2512   return _impl->Nb0DElements();
2513 }
2514
2515 //=============================================================================
2516 /*!
2517  *
2518  */
2519 //=============================================================================
2520 CORBA::Long SMESH_Mesh_i::NbEdges()throw(SALOME::SALOME_Exception)
2521 {
2522   Unexpect aCatch(SALOME_SalomeException);
2523   return _impl->NbEdges();
2524 }
2525
2526 CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order)
2527   throw(SALOME::SALOME_Exception)
2528 {
2529   Unexpect aCatch(SALOME_SalomeException);
2530   return _impl->NbEdges( (SMDSAbs_ElementOrder) order);
2531 }
2532
2533 //=============================================================================
2534 /*!
2535  *
2536  */
2537 //=============================================================================
2538 CORBA::Long SMESH_Mesh_i::NbFaces()throw(SALOME::SALOME_Exception)
2539 {
2540   Unexpect aCatch(SALOME_SalomeException);
2541   return _impl->NbFaces();
2542 }
2543
2544 CORBA::Long SMESH_Mesh_i::NbTriangles()throw(SALOME::SALOME_Exception)
2545 {
2546   Unexpect aCatch(SALOME_SalomeException);
2547   return _impl->NbTriangles();
2548 }
2549
2550 CORBA::Long SMESH_Mesh_i::NbQuadrangles()throw(SALOME::SALOME_Exception)
2551 {
2552   Unexpect aCatch(SALOME_SalomeException);
2553   return _impl->NbQuadrangles();
2554 }
2555
2556 CORBA::Long SMESH_Mesh_i::NbPolygons()throw(SALOME::SALOME_Exception)
2557 {
2558   Unexpect aCatch(SALOME_SalomeException);
2559   return _impl->NbPolygons();
2560 }
2561
2562 CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order)
2563   throw(SALOME::SALOME_Exception)
2564 {
2565   Unexpect aCatch(SALOME_SalomeException);
2566   return _impl->NbFaces( (SMDSAbs_ElementOrder) order);
2567 }
2568
2569 CORBA::Long SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order)
2570   throw(SALOME::SALOME_Exception)
2571 {
2572   Unexpect aCatch(SALOME_SalomeException);
2573   return _impl->NbTriangles( (SMDSAbs_ElementOrder) order);
2574 }
2575
2576 CORBA::Long SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order)
2577   throw(SALOME::SALOME_Exception)
2578 {
2579   Unexpect aCatch(SALOME_SalomeException);
2580   return _impl->NbQuadrangles( (SMDSAbs_ElementOrder) order);
2581 }
2582
2583 //=============================================================================
2584 /*!
2585  *
2586  */
2587 //=============================================================================
2588 CORBA::Long SMESH_Mesh_i::NbVolumes()throw(SALOME::SALOME_Exception)
2589 {
2590   Unexpect aCatch(SALOME_SalomeException);
2591   return _impl->NbVolumes();
2592 }
2593
2594 CORBA::Long SMESH_Mesh_i::NbTetras()throw(SALOME::SALOME_Exception)
2595 {
2596   Unexpect aCatch(SALOME_SalomeException);
2597   return _impl->NbTetras();
2598 }
2599
2600 CORBA::Long SMESH_Mesh_i::NbHexas()throw(SALOME::SALOME_Exception)
2601 {
2602   Unexpect aCatch(SALOME_SalomeException);
2603   return _impl->NbHexas();
2604 }
2605
2606 CORBA::Long SMESH_Mesh_i::NbPyramids()throw(SALOME::SALOME_Exception)
2607 {
2608   Unexpect aCatch(SALOME_SalomeException);
2609   return _impl->NbPyramids();
2610 }
2611
2612 CORBA::Long SMESH_Mesh_i::NbPrisms()throw(SALOME::SALOME_Exception)
2613 {
2614   Unexpect aCatch(SALOME_SalomeException);
2615   return _impl->NbPrisms();
2616 }
2617
2618 CORBA::Long SMESH_Mesh_i::NbPolyhedrons()throw(SALOME::SALOME_Exception)
2619 {
2620   Unexpect aCatch(SALOME_SalomeException);
2621   return _impl->NbPolyhedrons();
2622 }
2623
2624 CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order)
2625   throw(SALOME::SALOME_Exception)
2626 {
2627   Unexpect aCatch(SALOME_SalomeException);
2628   return _impl->NbVolumes( (SMDSAbs_ElementOrder) order);
2629 }
2630
2631 CORBA::Long SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order)
2632   throw(SALOME::SALOME_Exception)
2633 {
2634   Unexpect aCatch(SALOME_SalomeException);
2635   return _impl->NbTetras( (SMDSAbs_ElementOrder) order);
2636 }
2637
2638 CORBA::Long SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order)
2639   throw(SALOME::SALOME_Exception)
2640 {
2641   Unexpect aCatch(SALOME_SalomeException);
2642   return _impl->NbHexas( (SMDSAbs_ElementOrder) order);
2643 }
2644
2645 CORBA::Long SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order)
2646   throw(SALOME::SALOME_Exception)
2647 {
2648   Unexpect aCatch(SALOME_SalomeException);
2649   return _impl->NbPyramids( (SMDSAbs_ElementOrder) order);
2650 }
2651
2652 CORBA::Long SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order)
2653   throw(SALOME::SALOME_Exception)
2654 {
2655   Unexpect aCatch(SALOME_SalomeException);
2656   return _impl->NbPrisms( (SMDSAbs_ElementOrder) order);
2657 }
2658
2659 //=============================================================================
2660 /*!
2661  *
2662  */
2663 //=============================================================================
2664 CORBA::Long SMESH_Mesh_i::NbSubMesh()throw(SALOME::SALOME_Exception)
2665 {
2666   Unexpect aCatch(SALOME_SalomeException);
2667   return _mapSubMesh_i.size();
2668 }
2669
2670 //=============================================================================
2671 /*!
2672  *
2673  */
2674 //=============================================================================
2675 char* SMESH_Mesh_i::Dump()
2676 {
2677   ostringstream os;
2678   _impl->Dump( os );
2679   return CORBA::string_dup( os.str().c_str() );
2680 }
2681
2682 //=============================================================================
2683 /*!
2684  *
2685  */
2686 //=============================================================================
2687 SMESH::long_array* SMESH_Mesh_i::GetIDs()
2688 {
2689 //   SMESH::long_array_var aResult = new SMESH::long_array();
2690 //   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
2691 //   int aMinId = aSMESHDS_Mesh->MinElementID();
2692 //   int aMaxId =  aSMESHDS_Mesh->MaxElementID();
2693
2694 //   aResult->length(aMaxId - aMinId + 1);
2695
2696 //   for (int i = 0, id = aMinId; id <= aMaxId; id++  )
2697 //     aResult[i++] = id;
2698
2699 //   return aResult._retn();
2700   // PAL12398
2701   return GetElementsId();
2702 }
2703
2704 //=============================================================================
2705 /*!
2706  *
2707  */
2708 //=============================================================================
2709
2710 SMESH::long_array* SMESH_Mesh_i::GetElementsId()
2711      throw (SALOME::SALOME_Exception)
2712 {
2713   Unexpect aCatch(SALOME_SalomeException);
2714   MESSAGE("SMESH_Mesh_i::GetElementsId");
2715   SMESH::long_array_var aResult = new SMESH::long_array();
2716   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
2717
2718   if ( aSMESHDS_Mesh == NULL )
2719     return aResult._retn();
2720
2721   long nbElements = NbElements();
2722   aResult->length( nbElements );
2723   SMDS_ElemIteratorPtr anIt = aSMESHDS_Mesh->elementsIterator();
2724   for ( int i = 0, n = nbElements; i < n && anIt->more(); i++ )
2725     aResult[i] = anIt->next()->GetID();
2726
2727   return aResult._retn();
2728 }
2729
2730
2731 //=============================================================================
2732 /*!
2733  *
2734  */
2735 //=============================================================================
2736
2737 SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemType )
2738     throw (SALOME::SALOME_Exception)
2739 {
2740   Unexpect aCatch(SALOME_SalomeException);
2741   MESSAGE("SMESH_subMesh_i::GetElementsByType");
2742   SMESH::long_array_var aResult = new SMESH::long_array();
2743   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
2744
2745   if ( aSMESHDS_Mesh == NULL )
2746     return aResult._retn();
2747
2748   long nbElements = NbElements();
2749
2750   // No sense in returning ids of elements along with ids of nodes:
2751   // when theElemType == SMESH::ALL, return node ids only if
2752   // there are no elements
2753   if ( theElemType == SMESH::NODE || theElemType == SMESH::ALL && nbElements == 0 )
2754     return GetNodesId();
2755
2756   aResult->length( nbElements );
2757
2758   int i = 0;
2759
2760   SMDS_ElemIteratorPtr anIt = aSMESHDS_Mesh->elementsIterator();
2761   while ( i < nbElements && anIt->more() ) {
2762     const SMDS_MeshElement* anElem = anIt->next();
2763     if ( theElemType == SMESH::ALL || anElem->GetType() == (SMDSAbs_ElementType)theElemType )
2764       aResult[i++] = anElem->GetID();
2765   }
2766
2767   aResult->length( i );
2768
2769   return aResult._retn();
2770 }
2771
2772 //=============================================================================
2773 /*!
2774  *
2775  */
2776 //=============================================================================
2777
2778 SMESH::long_array* SMESH_Mesh_i::GetNodesId()
2779   throw (SALOME::SALOME_Exception)
2780 {
2781   Unexpect aCatch(SALOME_SalomeException);
2782   MESSAGE("SMESH_subMesh_i::GetNodesId");
2783   SMESH::long_array_var aResult = new SMESH::long_array();
2784   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
2785
2786   if ( aSMESHDS_Mesh == NULL )
2787     return aResult._retn();
2788
2789   long nbNodes = NbNodes();
2790   aResult->length( nbNodes );
2791   SMDS_NodeIteratorPtr anIt = aSMESHDS_Mesh->nodesIterator();
2792   for ( int i = 0, n = nbNodes; i < n && anIt->more(); i++ )
2793     aResult[i] = anIt->next()->GetID();
2794
2795   return aResult._retn();
2796 }
2797
2798 //=============================================================================
2799 /*!
2800  *
2801  */
2802 //=============================================================================
2803
2804 SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const bool iselem )
2805   throw (SALOME::SALOME_Exception)
2806 {
2807   return ( SMESH::ElementType )_impl->GetElementType( id, iselem );
2808 }
2809
2810 //=============================================================================
2811 /*!
2812  *
2813  */
2814 //=============================================================================
2815
2816 SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const CORBA::Long id )
2817   throw (SALOME::SALOME_Exception)
2818 {
2819   const SMDS_MeshElement* e = _impl->GetMeshDS()->FindElement(id);
2820   if ( !e )
2821     THROW_SALOME_CORBA_EXCEPTION( "invalid element id", SALOME::BAD_PARAM );
2822
2823   return ( SMESH::EntityType ) e->GetEntityType();
2824 }
2825
2826 //=============================================================================
2827 /*!
2828  * Returns ID of elements for given submesh
2829  */
2830 //=============================================================================
2831 SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID)
2832      throw (SALOME::SALOME_Exception)
2833 {
2834   SMESH::long_array_var aResult = new SMESH::long_array();
2835
2836   SMESH_subMesh* SM = _impl->GetSubMeshContaining(ShapeID);
2837   if(!SM) return aResult._retn();
2838
2839   SMESHDS_SubMesh* SDSM = SM->GetSubMeshDS();
2840   if(!SDSM) return aResult._retn();
2841
2842   aResult->length(SDSM->NbElements());
2843
2844   SMDS_ElemIteratorPtr eIt = SDSM->GetElements();
2845   int i = 0;
2846   while ( eIt->more() ) {
2847     aResult[i++] = eIt->next()->GetID();
2848   }
2849
2850   return aResult._retn();
2851 }
2852
2853
2854 //=============================================================================
2855 /*!
2856  * Returns ID of nodes for given submesh
2857  * If param all==true - returns all nodes, else -
2858  * returns only nodes on shapes.
2859  */
2860 //=============================================================================
2861 SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID, CORBA::Boolean all)
2862      throw (SALOME::SALOME_Exception)
2863 {
2864   SMESH::long_array_var aResult = new SMESH::long_array();
2865
2866   SMESH_subMesh* SM = _impl->GetSubMeshContaining(ShapeID);
2867   if(!SM) return aResult._retn();
2868
2869   SMESHDS_SubMesh* SDSM = SM->GetSubMeshDS();
2870   if(!SDSM) return aResult._retn();
2871
2872   set<int> theElems;
2873   if( !all || (SDSM->NbElements()==0) ) { // internal nodes or vertex submesh
2874     SMDS_NodeIteratorPtr nIt = SDSM->GetNodes();
2875     while ( nIt->more() ) {
2876       const SMDS_MeshNode* elem = nIt->next();
2877       theElems.insert( elem->GetID() );
2878     }
2879   }
2880   else { // all nodes of submesh elements
2881     SMDS_ElemIteratorPtr eIt = SDSM->GetElements();
2882     while ( eIt->more() ) {
2883       const SMDS_MeshElement* anElem = eIt->next();
2884       SMDS_ElemIteratorPtr nIt = anElem->nodesIterator();
2885       while ( nIt->more() ) {
2886         const SMDS_MeshElement* elem = nIt->next();
2887         theElems.insert( elem->GetID() );
2888       }
2889     }
2890   }
2891
2892   aResult->length(theElems.size());
2893   set<int>::iterator itElem;
2894   int i = 0;
2895   for ( itElem = theElems.begin(); itElem != theElems.end(); itElem++ )
2896     aResult[i++] = *itElem;
2897
2898   return aResult._retn();
2899 }
2900   
2901
2902 //=============================================================================
2903 /*!
2904  * Returns type of elements for given submesh
2905  */
2906 //=============================================================================
2907 SMESH::ElementType SMESH_Mesh_i::GetSubMeshElementType(const CORBA::Long ShapeID)
2908      throw (SALOME::SALOME_Exception)
2909 {
2910   SMESH_subMesh* SM = _impl->GetSubMeshContaining(ShapeID);
2911   if(!SM) return SMESH::ALL;
2912
2913   SMESHDS_SubMesh* SDSM = SM->GetSubMeshDS();
2914   if(!SDSM) return SMESH::ALL;
2915
2916   if(SDSM->NbElements()==0)
2917     return (SM->GetSubShape().ShapeType() == TopAbs_VERTEX) ? SMESH::NODE : SMESH::ALL;
2918
2919   SMDS_ElemIteratorPtr eIt = SDSM->GetElements();
2920   const SMDS_MeshElement* anElem = eIt->next();
2921   return ( SMESH::ElementType ) anElem->GetType();
2922 }
2923   
2924
2925 //=============================================================================
2926 /*!
2927  *
2928  */
2929 //=============================================================================
2930
2931 CORBA::LongLong SMESH_Mesh_i::GetMeshPtr()
2932 {
2933   CORBA::LongLong pointeur = CORBA::LongLong(_impl);
2934   if ( MYDEBUG )
2935     MESSAGE("CORBA::LongLong SMESH_Mesh_i::GetMeshPtr() "<<pointeur);
2936   return pointeur;
2937 }
2938
2939
2940 //=============================================================================
2941 /*!
2942  * Get XYZ coordinates of node as list of double
2943  * If there is not node for given ID - returns empty list
2944  */
2945 //=============================================================================
2946
2947 SMESH::double_array* SMESH_Mesh_i::GetNodeXYZ(const CORBA::Long id)
2948 {
2949   SMESH::double_array_var aResult = new SMESH::double_array();
2950   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
2951   if ( aSMESHDS_Mesh == NULL )
2952     return aResult._retn();
2953
2954   // find node
2955   const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(id);
2956   if(!aNode)
2957     return aResult._retn();
2958
2959   // add coordinates
2960   aResult->length(3);
2961   aResult[0] = aNode->X();
2962   aResult[1] = aNode->Y();
2963   aResult[2] = aNode->Z();
2964   return aResult._retn();
2965 }
2966
2967
2968 //=============================================================================
2969 /*!
2970  * For given node returns list of IDs of inverse elements
2971  * If there is not node for given ID - returns empty list
2972  */
2973 //=============================================================================
2974
2975 SMESH::long_array* SMESH_Mesh_i::GetNodeInverseElements(const CORBA::Long id)
2976 {
2977   SMESH::long_array_var aResult = new SMESH::long_array();
2978   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
2979   if ( aSMESHDS_Mesh == NULL )
2980     return aResult._retn();
2981
2982   // find node
2983   const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(id);
2984   if(!aNode)
2985     return aResult._retn();
2986
2987   // find inverse elements
2988   SMDS_ElemIteratorPtr eIt = aNode->GetInverseElementIterator();
2989   TColStd_SequenceOfInteger IDs;
2990   while(eIt->more()) {
2991     const SMDS_MeshElement* elem = eIt->next();
2992     IDs.Append(elem->GetID());
2993   }
2994   if(IDs.Length()>0) {
2995     aResult->length(IDs.Length());
2996     int i = 1;
2997     for(; i<=IDs.Length(); i++) {
2998       aResult[i-1] = IDs.Value(i);
2999     }
3000   }
3001   return aResult._retn();
3002 }
3003
3004 //=============================================================================
3005 /*!
3006  * \brief Return position of a node on shape
3007  */
3008 //=============================================================================
3009
3010 SMESH::NodePosition* SMESH_Mesh_i::GetNodePosition(CORBA::Long NodeID)
3011 {
3012   SMESH::NodePosition* aNodePosition = new SMESH::NodePosition();
3013   aNodePosition->shapeID = 0;
3014   aNodePosition->shapeType = GEOM::SHAPE;
3015
3016   SMESHDS_Mesh* mesh = _impl->GetMeshDS();
3017   if ( !mesh ) return aNodePosition;
3018
3019   if ( const SMDS_MeshNode* aNode = mesh->FindNode(NodeID) )
3020   {
3021     if ( SMDS_PositionPtr pos = aNode->GetPosition() )
3022     {
3023       aNodePosition->shapeID = pos->GetShapeId();
3024       switch ( pos->GetTypeOfPosition() ) {
3025       case SMDS_TOP_EDGE:
3026         aNodePosition->shapeType = GEOM::EDGE;
3027         aNodePosition->params.length(1);
3028         aNodePosition->params[0] =
3029           static_cast<SMDS_EdgePosition*>( pos.get() )->GetUParameter();
3030         break;
3031       case SMDS_TOP_FACE:
3032         aNodePosition->shapeType = GEOM::FACE;
3033         aNodePosition->params.length(2);
3034         aNodePosition->params[0] =
3035           static_cast<SMDS_FacePosition*>( pos.get() )->GetUParameter();
3036         aNodePosition->params[1] =
3037           static_cast<SMDS_FacePosition*>( pos.get() )->GetVParameter();
3038         break;
3039       case SMDS_TOP_VERTEX:
3040         aNodePosition->shapeType = GEOM::VERTEX;
3041         break;
3042       case SMDS_TOP_3DSPACE:
3043         if ( TopExp_Explorer(_impl->GetShapeToMesh(), TopAbs_SOLID).More() )
3044           aNodePosition->shapeType = GEOM::SOLID;
3045         else if ( TopExp_Explorer(_impl->GetShapeToMesh(), TopAbs_SHELL).More() )
3046           aNodePosition->shapeType = GEOM::SHELL;
3047         break;
3048       default:;
3049       }
3050     }
3051   }
3052   return aNodePosition;
3053 }
3054
3055 //=============================================================================
3056 /*!
3057  * If given element is node returns IDs of shape from position
3058  * If there is not node for given ID - returns -1
3059  */
3060 //=============================================================================
3061
3062 CORBA::Long SMESH_Mesh_i::GetShapeID(const CORBA::Long id)
3063 {
3064   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
3065   if ( aSMESHDS_Mesh == NULL )
3066     return -1;
3067
3068   // try to find node
3069   const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(id);
3070   if(aNode) {
3071     SMDS_PositionPtr pos = aNode->GetPosition();
3072     if(!pos)
3073       return -1;
3074     else
3075       return pos->GetShapeId();
3076   }
3077
3078   return -1;
3079 }
3080
3081
3082 //=============================================================================
3083 /*!
3084  * For given element returns ID of result shape after 
3085  * ::FindShape() from SMESH_MeshEditor
3086  * If there is not element for given ID - returns -1
3087  */
3088 //=============================================================================
3089
3090 CORBA::Long SMESH_Mesh_i::GetShapeIDForElem(const CORBA::Long id)
3091 {
3092   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
3093   if ( aSMESHDS_Mesh == NULL )
3094     return -1;
3095
3096   // try to find element
3097   const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
3098   if(!elem)
3099     return -1;
3100
3101   //SMESH::SMESH_MeshEditor_var aMeshEditor = SMESH_Mesh_i::GetMeshEditor();
3102   ::SMESH_MeshEditor aMeshEditor(_impl);
3103   int index = aMeshEditor.FindShape( elem );
3104   if(index>0)
3105     return index;
3106
3107   return -1;
3108 }
3109
3110
3111 //=============================================================================
3112 /*!
3113  * Returns number of nodes for given element
3114  * If there is not element for given ID - returns -1
3115  */
3116 //=============================================================================
3117
3118 CORBA::Long SMESH_Mesh_i::GetElemNbNodes(const CORBA::Long id)
3119 {
3120   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
3121   if ( aSMESHDS_Mesh == NULL ) return -1;
3122   // try to find element
3123   const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
3124   if(!elem) return -1;
3125   return elem->NbNodes();
3126 }
3127
3128
3129 //=============================================================================
3130 /*!
3131  * Returns ID of node by given index for given element
3132  * If there is not element for given ID - returns -1
3133  * If there is not node for given index - returns -2
3134  */
3135 //=============================================================================
3136
3137 CORBA::Long SMESH_Mesh_i::GetElemNode(const CORBA::Long id, const CORBA::Long index)
3138 {
3139   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
3140   if ( aSMESHDS_Mesh == NULL ) return -1;
3141   const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
3142   if(!elem) return -1;
3143   if( index>=elem->NbNodes() || index<0 ) return -1;
3144   return elem->GetNode(index)->GetID();
3145 }
3146
3147 //=============================================================================
3148 /*!
3149  * Returns IDs of nodes of given element
3150  */
3151 //=============================================================================
3152
3153 SMESH::long_array* SMESH_Mesh_i::GetElemNodes(const CORBA::Long id)
3154 {
3155   SMESH::long_array_var aResult = new SMESH::long_array();
3156   if ( SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS() )
3157   {
3158     if ( const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id) )
3159     {
3160       aResult->length( elem->NbNodes() );
3161       for ( int i = 0; i < elem->NbNodes(); ++i )
3162         aResult[ i ] = elem->GetNode( i )->GetID();
3163     }
3164   }
3165   return aResult._retn();
3166 }
3167
3168 //=============================================================================
3169 /*!
3170  * Returns true if given node is medium node
3171  * in given quadratic element
3172  */
3173 //=============================================================================
3174
3175 CORBA::Boolean SMESH_Mesh_i::IsMediumNode(const CORBA::Long ide, const CORBA::Long idn)
3176 {
3177   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
3178   if ( aSMESHDS_Mesh == NULL ) return false;
3179   // try to find node
3180   const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(idn);
3181   if(!aNode) return false;
3182   // try to find element
3183   const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(ide);
3184   if(!elem) return false;
3185
3186   return elem->IsMediumNode(aNode);
3187 }
3188
3189
3190 //=============================================================================
3191 /*!
3192  * Returns true if given node is medium node
3193  * in one of quadratic elements
3194  */
3195 //=============================================================================
3196
3197 CORBA::Boolean SMESH_Mesh_i::IsMediumNodeOfAnyElem(const CORBA::Long idn,
3198                                                    SMESH::ElementType theElemType)
3199 {
3200   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
3201   if ( aSMESHDS_Mesh == NULL ) return false;
3202
3203   // try to find node
3204   const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(idn);
3205   if(!aNode) return false;
3206
3207   SMESH_MesherHelper aHelper( *(_impl) );
3208
3209   SMDSAbs_ElementType aType;
3210   if(theElemType==SMESH::EDGE) aType = SMDSAbs_Edge;
3211   else if(theElemType==SMESH::FACE) aType = SMDSAbs_Face;
3212   else if(theElemType==SMESH::VOLUME) aType = SMDSAbs_Volume;
3213   else aType = SMDSAbs_All;
3214
3215   return aHelper.IsMedium(aNode,aType);
3216 }
3217
3218
3219 //=============================================================================
3220 /*!
3221  * Returns number of edges for given element
3222  */
3223 //=============================================================================
3224
3225 CORBA::Long SMESH_Mesh_i::ElemNbEdges(const CORBA::Long id)
3226 {
3227   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
3228   if ( aSMESHDS_Mesh == NULL ) return -1;
3229   const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
3230   if(!elem) return -1;
3231   return elem->NbEdges();
3232 }
3233
3234
3235 //=============================================================================
3236 /*!
3237  * Returns number of faces for given element
3238  */
3239 //=============================================================================
3240
3241 CORBA::Long SMESH_Mesh_i::ElemNbFaces(const CORBA::Long id)
3242 {
3243   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
3244   if ( aSMESHDS_Mesh == NULL ) return -1;
3245   const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
3246   if(!elem) return -1;
3247   return elem->NbFaces();
3248 }
3249
3250 //=======================================================================
3251 //function : GetElemFaceNodes
3252 //purpose  : Returns nodes of given face (counted from zero) for given element.
3253 //=======================================================================
3254
3255 SMESH::long_array* SMESH_Mesh_i::GetElemFaceNodes(CORBA::Long  elemId,
3256                                                   CORBA::Short faceIndex)
3257 {
3258   SMESH::long_array_var aResult = new SMESH::long_array();
3259   if ( SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS() )
3260   {
3261     if ( const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(elemId) )
3262     {
3263       SMDS_VolumeTool vtool( elem );
3264       if ( faceIndex < vtool.NbFaces() )
3265       {
3266         aResult->length( vtool.NbFaceNodes( faceIndex ));
3267         const SMDS_MeshNode** nn = vtool.GetFaceNodes( faceIndex );
3268         for ( int i = 0; i < aResult->length(); ++i )
3269           aResult[ i ] = nn[ i ]->GetID();
3270       }
3271     }
3272   }
3273   return aResult._retn();
3274 }