Salome HOME
MEDCoupling Memory output from SMESH engine now deal with fields too.
[modules/smesh.git] / src / SMESH_I / SMESH_Mesh_i.cxx
1 // Copyright (C) 2007-2021  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, or (at your option) any later version.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22 //  File   : SMESH_Mesh_i.cxx
23 //  Author : Paul RASCLE, EDF
24 //  Module : SMESH
25
26 #include "SMESH_Mesh_i.hxx"
27
28 #include "DriverMED_R_SMESHDS_Mesh.h"
29 #include "DriverMED_W_Field.h"
30 #include "DriverMED_W_SMESHDS_Mesh.h"
31 #include "MED_Factory.hxx"
32 #include "SMDS_LinearEdge.hxx"
33 #include "SMDS_EdgePosition.hxx"
34 #include "SMDS_ElemIterator.hxx"
35 #include "SMDS_FacePosition.hxx"
36 #include "SMDS_IteratorOnIterators.hxx"
37 #include "SMDS_MeshGroup.hxx"
38 #include "SMDS_SetIterator.hxx"
39 #include "SMDS_StdIterator.hxx"
40 #include "SMDS_VolumeTool.hxx"
41 #include "SMESHDS_Command.hxx"
42 #include "SMESHDS_CommandType.hxx"
43 #include "SMESHDS_Group.hxx"
44 #include "SMESHDS_GroupOnGeom.hxx"
45 #include "SMESH_Controls.hxx"
46 #include "SMESH_File.hxx"
47 #include "SMESH_Filter_i.hxx"
48 #include "SMESH_Gen_i.hxx"
49 #include "SMESH_Group.hxx"
50 #include "SMESH_Group_i.hxx"
51 #include "SMESH_Mesh.hxx"
52 #include "SMESH_MeshAlgos.hxx"
53 #include "SMESH_MeshEditor.hxx"
54 #include "SMESH_MeshEditor_i.hxx"
55 #include "SMESH_MeshPartDS.hxx"
56 #include "SMESH_MesherHelper.hxx"
57 #include "SMESH_PreMeshInfo.hxx"
58 #include "SMESH_PythonDump.hxx"
59 #include "SMESH_subMesh_i.hxx"
60
61 #include <SALOMEDS_Attributes_wrap.hxx>
62 #include <SALOMEDS_wrap.hxx>
63 #include <Utils_ExceptHandlers.hxx>
64 #include <utilities.h>
65
66 #include <GEOMImpl_Types.hxx>
67 #include <GEOM_wrap.hxx>
68
69 // OCCT Includes
70 #include <BRep_Builder.hxx>
71 #include <Standard_ErrorHandler.hxx>
72 #include <TColStd_MapOfInteger.hxx>
73 #include <TopExp.hxx>
74 #include <TopExp_Explorer.hxx>
75 #include <TopTools_DataMapOfShapeShape.hxx>
76 #include <TopTools_MapIteratorOfMapOfShape.hxx>
77 #include <TopTools_MapOfShape.hxx>
78 #include <TopoDS_Compound.hxx>
79
80 // STL Includes
81 #include <algorithm>
82 #include <iostream>
83 #include <sstream>
84
85 #include <vtkUnstructuredGridWriter.h>
86
87 // to pass CORBA exception and TooLargeForExport exception through SMESH_TRY
88 #define SMY_OWN_CATCH                                                                           \
89   catch( SALOME::SALOME_Exception& se ) { throw se; }                                           \
90   catch( ::SMESH_Mesh::TooLargeForExport& ex )                                                  \
91   { SALOME::ExceptionStruct se = {                                                              \
92       SALOME::COMM,                                                                             \
93       CORBA::string_dup(SMESH_Comment("Mesh is too large for export in format ") << ex.what()), \
94       CORBA::string_dup(SMESH_Comment("format=") <<  ex.what() ), 0 };                          \
95     throw SALOME::SALOME_Exception( se );  }
96
97 #include "SMESH_TryCatch.hxx" // include after OCCT headers!
98
99 #ifdef _DEBUG_
100 static int MYDEBUG = 0;
101 #else
102 static int MYDEBUG = 0;
103 #endif
104
105 using namespace std;
106 using SMESH::TPythonDump;
107 using SMESH::TVar;
108
109 int SMESH_Mesh_i::_idGenerator = 0;
110
111 //=============================================================================
112 /*!
113  *  Constructor
114  */
115 //=============================================================================
116
117 SMESH_Mesh_i::SMESH_Mesh_i( PortableServer::POA_ptr thePOA,
118                             SMESH_Gen_i*            gen_i )
119 : SALOME::GenericObj_i( thePOA )
120 {
121   _impl          = NULL;
122   _gen_i         = gen_i;
123   _id            = _idGenerator++;
124   _nbInvalidHypos= -1;
125   _editor        = NULL;
126   _previewEditor = NULL;
127   _preMeshInfo   = NULL;
128   _mainShapeTick = 0;
129 }
130
131 //=============================================================================
132 /*!
133  *  Destructor
134  */
135 //=============================================================================
136
137 SMESH_Mesh_i::~SMESH_Mesh_i()
138 {
139   // destroy groups
140   map<int, SMESH::SMESH_GroupBase_ptr>::iterator itGr;
141   for (itGr = _mapGroups.begin(); itGr != _mapGroups.end(); itGr++)
142     if (SMESH_GroupBase_i* aGroup = SMESH::DownCast<SMESH_GroupBase_i*>(itGr->second))
143     {
144       aGroup->UnRegister();
145       SMESH::SMESH_GroupBase_var( itGr->second );
146     }
147   _mapGroups.clear();
148
149   // destroy submeshes
150   map<int, SMESH::SMESH_subMesh_ptr>::iterator itSM;
151   for ( itSM = _mapSubMeshIor.begin(); itSM != _mapSubMeshIor.end(); itSM++ )
152     if ( SMESH_subMesh_i* aSubMesh = SMESH::DownCast<SMESH_subMesh_i*>( itSM->second ))
153     {
154       aSubMesh->UnRegister();
155       SMESH::SMESH_subMesh_var( itSM->second );
156     }
157   _mapSubMeshIor.clear();
158
159   // destroy hypotheses. _mapHypo contains all hyps ever been assigned
160   map<int, SMESH::SMESH_Hypothesis_ptr>::iterator itH;
161   for ( itH = _mapHypo.begin(); itH != _mapHypo.end(); itH++ ) {
162     if ( SMESH_Hypothesis_i* hyp_i = SMESH::DownCast<SMESH_Hypothesis_i*>( itH->second ))
163       if ( SMESH_Hypothesis * smHyp = _impl->GetHypothesis( itH->first ))
164         if ( _impl->GetMeshDS()->IsUsedHypothesis( smHyp ))
165           hyp_i->UnRegister();
166
167     SMESH::SMESH_Hypothesis_var( itH->second ); // decref CORBA object
168   }
169   _mapHypo.clear();
170
171   // clear cached shapes if no more meshes remain; (the cache is blame,
172   // together with publishing, of spent time increasing in issue 22874)
173   if ( _impl->NbMeshes() == 1 )
174     _gen_i->GetShapeReader()->ClearClientBuffer();
175
176   delete _editor; _editor = NULL;
177   delete _previewEditor; _previewEditor = NULL;
178   delete _impl; _impl = NULL;
179   delete _preMeshInfo; _preMeshInfo = NULL;
180 }
181
182 //=============================================================================
183 /*!
184  *  SetShape
185  *
186  *  Associate <this> mesh with <theShape> and put a reference
187  *  to <theShape> into the current study;
188  *  the previous shape is substituted by the new one.
189  */
190 //=============================================================================
191
192 void SMESH_Mesh_i::SetShape( GEOM::GEOM_Object_ptr theShapeObject )
193 {
194   Unexpect aCatch(SALOME_SalomeException);
195   try {
196     _impl->ShapeToMesh( _gen_i->GeomObjectToShape( theShapeObject ));
197   }
198   catch(SALOME_Exception & S_ex) {
199     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
200   }
201   // to track changes of GEOM groups
202   SMESH::SMESH_Mesh_var mesh = _this();
203   addGeomGroupData( theShapeObject, mesh );
204   if ( !CORBA::is_nil( theShapeObject ))
205     _mainShapeTick = theShapeObject->GetTick();
206 }
207
208 //================================================================================
209 /*!
210  * \brief Return true if mesh has a shape to build a shape on
211  */
212 //================================================================================
213
214 CORBA::Boolean SMESH_Mesh_i::HasShapeToMesh()
215 {
216   Unexpect aCatch(SALOME_SalomeException);
217   bool res = false;
218   try {
219     res = _impl->HasShapeToMesh();
220   }
221   catch(SALOME_Exception & S_ex) {
222     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
223   }
224   return res;
225 }
226
227 //================================================================================
228 /*!
229  * \brief Return the shape to mesh
230  */
231 //================================================================================
232
233 GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh()
234 {
235   Unexpect aCatch(SALOME_SalomeException);
236   GEOM::GEOM_Object_var aShapeObj;
237   try {
238     TopoDS_Shape S = _impl->GetMeshDS()->ShapeToMesh();
239     if ( !S.IsNull() )
240     {
241       aShapeObj = _gen_i->ShapeToGeomObject( S );
242       if ( aShapeObj->_is_nil() )
243       {
244         // S was removed from GEOM_Client by newGroupShape() called by other mesh;
245         // find GEOM_Object by entry (IPAL52735)
246         list<TGeomGroupData>::iterator data = _geomGroupData.begin();
247         for ( ; data != _geomGroupData.end(); ++data )
248           if ( data->_smeshObject->_is_equivalent( _this() ))
249           {
250             SALOMEDS::SObject_wrap so = _gen_i->getStudyServant()->FindObjectID( data->_groupEntry.c_str() );
251             CORBA::Object_var     obj = _gen_i->SObjectToObject( so );
252             aShapeObj = GEOM::GEOM_Object::_narrow( obj );
253             break;
254           }
255       }
256     }
257   }
258   catch(SALOME_Exception & S_ex) {
259     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
260   }
261   return aShapeObj._retn();
262 }
263
264 //================================================================================
265 /*!
266  * \brief Return false if the mesh is not yet fully loaded from the study file
267  */
268 //================================================================================
269
270 CORBA::Boolean SMESH_Mesh_i::IsLoaded()
271 {
272   Unexpect aCatch(SALOME_SalomeException);
273   return !_preMeshInfo;
274 }
275
276 //================================================================================
277 /*!
278  * \brief Load full mesh data from the study file
279  */
280 //================================================================================
281
282 void SMESH_Mesh_i::Load()
283 {
284   Unexpect aCatch(SALOME_SalomeException);
285   if ( _preMeshInfo )
286     _preMeshInfo->FullLoadFromFile();
287 }
288
289 //================================================================================
290 /*!
291  * \brief Remove all nodes and elements
292  */
293 //================================================================================
294
295 void SMESH_Mesh_i::Clear()
296 {
297   Unexpect aCatch(SALOME_SalomeException);
298   if ( _preMeshInfo )
299     _preMeshInfo->ForgetOrLoad(); // load in case if !HasShapeToMesh()
300
301   try {
302     _impl->Clear();
303     //CheckGeomGroupModif(); // issue 20145
304   }
305   catch(SALOME_Exception & S_ex) {
306     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
307   }
308
309   TPythonDump() <<  SMESH::SMESH_Mesh_var(_this()) << ".Clear()";
310
311   SMESH::SMESH_Mesh_var mesh = _this();
312   _gen_i->UpdateIcons( mesh );
313 }
314
315 //================================================================================
316 /*!
317  * \brief Remove all nodes and elements for indicated shape
318  */
319 //================================================================================
320
321 void SMESH_Mesh_i::ClearSubMesh(CORBA::Long ShapeID)
322 {
323   Unexpect aCatch(SALOME_SalomeException);
324   if ( _preMeshInfo )
325     _preMeshInfo->FullLoadFromFile();
326
327   try {
328     _impl->ClearSubMesh( ShapeID );
329   }
330   catch(SALOME_Exception & S_ex) {
331     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
332   }
333   _impl->GetMeshDS()->Modified();
334
335   TPythonDump() <<  SMESH::SMESH_Mesh_var(_this()) << ".ClearSubMesh( " << ShapeID << " )";
336 }
337
338 //=============================================================================
339 /*!
340  * Convert enum Driver_Mesh::Status to SMESH::DriverMED_ReadStatus
341  */
342 //=============================================================================
343
344 static SMESH::DriverMED_ReadStatus ConvertDriverMEDReadStatus (int theStatus)
345 {
346   SMESH::DriverMED_ReadStatus res;
347   switch (theStatus)
348   {
349   case DriverMED_R_SMESHDS_Mesh::DRS_OK:
350     res = SMESH::DRS_OK; break;
351   case DriverMED_R_SMESHDS_Mesh::DRS_EMPTY:
352     res = SMESH::DRS_EMPTY; break;
353   case DriverMED_R_SMESHDS_Mesh::DRS_WARN_RENUMBER:
354     res = SMESH::DRS_WARN_RENUMBER; break;
355   case DriverMED_R_SMESHDS_Mesh::DRS_WARN_SKIP_ELEM:
356     res = SMESH::DRS_WARN_SKIP_ELEM; break;
357   case DriverMED_R_SMESHDS_Mesh::DRS_WARN_DESCENDING:
358     res = SMESH::DRS_WARN_DESCENDING; break;
359   case DriverMED_R_SMESHDS_Mesh::DRS_FAIL:
360   default:
361     res = SMESH::DRS_FAIL; break;
362   }
363   return res;
364 }
365
366 //=============================================================================
367 /*!
368  * Convert ::SMESH_ComputeError to SMESH::ComputeError
369  */
370 //=============================================================================
371
372 static SMESH::ComputeError* ConvertComputeError( SMESH_ComputeErrorPtr errorPtr )
373 {
374   SMESH::ComputeError_var errVar = new SMESH::ComputeError();
375   errVar->subShapeID = -1;
376   errVar->hasBadMesh = false;
377
378   if ( !errorPtr || errorPtr->IsOK() )
379   {
380     errVar->code = SMESH::COMPERR_OK;
381   }
382   else
383   {
384     errVar->code    = ConvertDriverMEDReadStatus( errorPtr->myName );
385     errVar->comment = errorPtr->myComment.c_str();
386   }
387   return errVar._retn();
388 }
389
390 //=============================================================================
391 /*!
392  *  ImportMEDFile
393  *
394  *  Import mesh data from MED file
395  */
396 //=============================================================================
397
398 SMESH::DriverMED_ReadStatus
399 SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName )
400 {
401   Unexpect aCatch(SALOME_SalomeException);
402   int status;
403   try {
404     status = _impl->MEDToMesh( theFileName, theMeshName );
405   }
406   catch( SALOME_Exception& S_ex ) {
407     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
408   }
409   catch ( ... ) {
410     THROW_SALOME_CORBA_EXCEPTION("ImportMEDFile(): unknown exception", SALOME::BAD_PARAM);
411   }
412
413   CreateGroupServants();
414
415   int major, minor, release;
416   major = minor = release = 0;
417   MED::GetMEDVersion(theFileName, major, minor, release);
418   _medFileInfo           = new SMESH::MedFileInfo();
419   _medFileInfo->fileName = theFileName;
420   _medFileInfo->fileSize = 0;
421   _medFileInfo->major    = major;
422   _medFileInfo->minor    = minor;
423   _medFileInfo->release  = release;
424   _medFileInfo->fileSize = SMESH_File( theFileName ).size();
425
426   return ConvertDriverMEDReadStatus(status);
427 }
428
429 //================================================================================
430 /*!
431  * \brief Import mesh data from the CGNS file
432  */
433 //================================================================================
434
435 SMESH::DriverMED_ReadStatus SMESH_Mesh_i::ImportCGNSFile( const char*  theFileName,
436                                                           const int    theMeshIndex,
437                                                           std::string& theMeshName )
438 {
439   Unexpect aCatch(SALOME_SalomeException);
440   int status;
441   try {
442     status = _impl->CGNSToMesh( theFileName, theMeshIndex, theMeshName );
443   }
444   catch( SALOME_Exception& S_ex ) {
445     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
446   }
447   catch ( ... ) {
448     THROW_SALOME_CORBA_EXCEPTION("ImportCGNSFile(): unknown exception", SALOME::BAD_PARAM);
449   }
450
451   CreateGroupServants();
452
453   _medFileInfo           = new SMESH::MedFileInfo();
454   _medFileInfo->fileName = theFileName;
455   _medFileInfo->major    = 0;
456   _medFileInfo->minor    = 0;
457   _medFileInfo->release  = 0;
458   _medFileInfo->fileSize = SMESH_File( theFileName ).size();
459
460   return ConvertDriverMEDReadStatus(status);
461 }
462
463 //================================================================================
464 /*!
465  * \brief Return string representation of a MED file version comprising nbDigits
466  */
467 //================================================================================
468
469 char* SMESH_Mesh_i::GetVersionString(CORBA::Long minor, CORBA::Short nbDigits)
470 {
471   string ver = DriverMED_W_SMESHDS_Mesh::GetVersionString(minor, nbDigits);
472   return CORBA::string_dup( ver.c_str() );
473 }
474
475 //================================================================================
476 /*!
477  *  Return the list of med versions compatibles for write/append,
478  *  encoded in 10*major+minor (for instance, code for med 3.2.1 is 32)
479  */
480 //================================================================================
481
482 SMESH::long_array* SMESH_Mesh_i::GetMEDVersionsCompatibleForAppend()
483 {
484   SMESH::long_array_var aResult = new SMESH::long_array();
485   std::vector<int> mvok = MED::GetMEDVersionsAppendCompatible();
486   long nbver = mvok.size();
487   aResult->length( nbver );
488   for ( int i = 0; i < nbver; i++ )
489     aResult[i] = mvok[i];
490   return aResult._retn();
491 }
492
493 //=============================================================================
494 /*!
495  *  ImportUNVFile
496  *
497  *  Import mesh data from MED file
498  */
499 //=============================================================================
500
501 int SMESH_Mesh_i::ImportUNVFile( const char* theFileName )
502 {
503   SMESH_TRY;
504
505   // Read mesh with name = <theMeshName> into SMESH_Mesh
506   _impl->UNVToMesh( theFileName );
507
508   CreateGroupServants();
509
510   _medFileInfo           = new SMESH::MedFileInfo();
511   _medFileInfo->fileName = theFileName;
512   _medFileInfo->major    = 0;
513   _medFileInfo->minor    = 0;
514   _medFileInfo->release  = 0;
515   _medFileInfo->fileSize = SMESH_File( theFileName ).size();
516
517   SMESH_CATCH( SMESH::throwCorbaException );
518
519   return 1;
520 }
521
522 //=============================================================================
523 /*!
524  *  ImportSTLFile
525  *
526  *  Import mesh data from STL file
527  */
528 //=============================================================================
529
530 int SMESH_Mesh_i::ImportSTLFile( const char* theFileName )
531 {
532   SMESH_TRY;
533
534   // Read mesh with name = <theMeshName> into SMESH_Mesh
535   std::string name = _impl->STLToMesh( theFileName );
536   if ( !name.empty() )
537   {
538     SALOMEDS::SObject_wrap meshSO = _gen_i->ObjectToSObject( _this() );
539     _gen_i->SetName( meshSO, name.c_str() );
540   }
541   _medFileInfo           = new SMESH::MedFileInfo();
542   _medFileInfo->fileName = theFileName;
543   _medFileInfo->major    = 0;
544   _medFileInfo->minor    = 0;
545   _medFileInfo->release  = 0;
546   _medFileInfo->fileSize = SMESH_File( theFileName ).size();
547
548   SMESH_CATCH( SMESH::throwCorbaException );
549
550   return 1;
551 }
552
553 //================================================================================
554 /*!
555  * \brief Function used in SMESH_CATCH by ImportGMFFile()
556  */
557 //================================================================================
558
559 namespace
560 {
561   SMESH_ComputeErrorPtr exceptionToComputeError(const char* excText)
562   {
563     return SMESH_ComputeError::New( Driver_Mesh::DRS_FAIL, excText );
564   }
565 }
566
567 //================================================================================
568 /*!
569  * \brief Import data from a GMF file and return an error description
570  */
571 //================================================================================
572
573 SMESH::ComputeError* SMESH_Mesh_i::ImportGMFFile( const char* theFileName,
574                                                   bool        theMakeRequiredGroups )
575 {
576   SMESH_ComputeErrorPtr error;
577
578 #undef SMESH_CAUGHT
579 #define SMESH_CAUGHT error =
580   SMESH_TRY;
581
582   error = _impl->GMFToMesh( theFileName, theMakeRequiredGroups );
583
584   _medFileInfo           = new SMESH::MedFileInfo();
585   _medFileInfo->fileName = theFileName;
586   _medFileInfo->major    = 0;
587   _medFileInfo->minor    = 0;
588   _medFileInfo->release  = 0;
589   _medFileInfo->fileSize = SMESH_File( theFileName ).size();
590
591   SMESH_CATCH( exceptionToComputeError );
592 #undef SMESH_CAUGHT
593 #define SMESH_CAUGHT
594
595   CreateGroupServants();
596
597   return ConvertComputeError( error );
598 }
599
600 //=============================================================================
601 /*!
602  * \brief Convert SMESH_Hypothesis::Hypothesis_Status into SMESH::Hypothesis_Status
603  */
604 //=============================================================================
605
606 #define RETURNCASE(hyp_stat) case SMESH_Hypothesis::hyp_stat: return SMESH::hyp_stat;
607
608 SMESH::Hypothesis_Status SMESH_Mesh_i::ConvertHypothesisStatus
609                          (SMESH_Hypothesis::Hypothesis_Status theStatus)
610 {
611   switch (theStatus) {
612   RETURNCASE( HYP_OK            );
613   RETURNCASE( HYP_MISSING       );
614   RETURNCASE( HYP_CONCURRENT    );
615   RETURNCASE( HYP_BAD_PARAMETER );
616   RETURNCASE( HYP_HIDDEN_ALGO   );
617   RETURNCASE( HYP_HIDING_ALGO   );
618   RETURNCASE( HYP_UNKNOWN_FATAL );
619   RETURNCASE( HYP_INCOMPATIBLE  );
620   RETURNCASE( HYP_NOTCONFORM    );
621   RETURNCASE( HYP_ALREADY_EXIST );
622   RETURNCASE( HYP_BAD_DIM       );
623   RETURNCASE( HYP_BAD_SUBSHAPE  );
624   RETURNCASE( HYP_BAD_GEOMETRY  );
625   RETURNCASE( HYP_NEED_SHAPE    );
626   RETURNCASE( HYP_INCOMPAT_HYPS );
627   default:;
628   }
629   return SMESH::HYP_UNKNOWN_FATAL;
630 }
631
632 //=============================================================================
633 /*!
634  *  AddHypothesis
635  *
636  *  Call internal addHypothesis() and then add a reference to <anHyp> under
637  *  the SObject actually having a reference to <aSubShape>.
638  *  NB: For this method to work, it is necessary to add a reference to sub-shape first.
639  */
640 //=============================================================================
641
642 SMESH::Hypothesis_Status
643 SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
644                             SMESH::SMESH_Hypothesis_ptr anHyp,
645                             CORBA::String_out           anErrorText)
646 {
647   Unexpect aCatch(SALOME_SalomeException);
648
649   const smIdType prevNbMeshEnt = NbNodes() + NbElements();
650
651   if ( _preMeshInfo )
652     _preMeshInfo->ForgetOrLoad();
653
654   std::string error;
655   SMESH_Hypothesis::Hypothesis_Status status = addHypothesis( aSubShape, anHyp, &error );
656   anErrorText = error.c_str();
657
658   SMESH::SMESH_Mesh_var mesh( _this() );
659   if ( !SMESH_Hypothesis::IsStatusFatal(status) )
660   {
661     _gen_i->AddHypothesisToShape( mesh, aSubShape, anHyp );
662
663     //int newNbMeshEnt = _impl->NbNodes() + _impl->GetMeshDS()->NbElements();
664     if ( prevNbMeshEnt > 0 /*newNbMeshEnt != prevNbMeshEnt*/ )
665       _gen_i->UpdateIcons( mesh );
666   }
667   if(MYDEBUG) MESSAGE( " AddHypothesis(): status = " << status );
668
669   // Update Python script
670   TPythonDump() << "status = " << mesh << ".AddHypothesis( "
671                 << aSubShape << ", " << anHyp << " )";
672
673   return ConvertHypothesisStatus(status);
674 }
675
676 //================================================================================
677 /*!
678  * \brief Create  a sub-mesh and add a hypothesis to it
679  */
680 //================================================================================
681
682 SMESH_Hypothesis::Hypothesis_Status
683 SMESH_Mesh_i::addHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
684                             SMESH::SMESH_Hypothesis_ptr anHyp,
685                             std::string*                anErrorText)
686 {
687   if(MYDEBUG) MESSAGE("addHypothesis");
688
689   if (CORBA::is_nil( aSubShape ) && HasShapeToMesh())
690     THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference",SALOME::BAD_PARAM);
691
692   if (CORBA::is_nil( anHyp ))
693     THROW_SALOME_CORBA_EXCEPTION("bad hypothesis reference",SALOME::BAD_PARAM);
694
695   SMESH_Hypothesis::Hypothesis_Status status = SMESH_Hypothesis::HYP_OK;
696   try
697   {
698     TopoDS_Shape myLocSubShape;
699     //use PseudoShape in case if mesh has no shape
700     if(HasShapeToMesh())
701       myLocSubShape = _gen_i->GeomObjectToShape( aSubShape);
702     else
703       myLocSubShape = _impl->GetShapeToMesh();
704
705     const int hypId = anHyp->GetId();
706     std::string error;
707     status = _impl->AddHypothesis( myLocSubShape, hypId, &error );
708     if ( !SMESH_Hypothesis::IsStatusFatal(status) )
709     {
710       _mapHypo[hypId] = SMESH::SMESH_Hypothesis::_duplicate( anHyp );
711       anHyp->Register();
712       // assure there is a corresponding submesh
713       if ( !_impl->IsMainShape( myLocSubShape )) {
714         int shapeId = _impl->GetMeshDS()->ShapeToIndex( myLocSubShape );
715         if ( _mapSubMesh_i.find( shapeId ) == _mapSubMesh_i.end() )
716           SMESH::SMESH_subMesh_var( createSubMesh( aSubShape ));
717       }
718     }
719     else if ( anErrorText )
720     {
721       *anErrorText = error;
722     }
723   }
724   catch(SALOME_Exception & S_ex)
725   {
726     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
727   }
728   return status;
729 }
730
731 //================================================================================
732 /*!
733  * \brief Un-assign a hypothesis from a sub-mesh dedicate to the given sub-shape
734  */
735 //================================================================================
736
737 SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
738                                                         SMESH::SMESH_Hypothesis_ptr anHyp)
739 {
740   Unexpect aCatch(SALOME_SalomeException);
741   if ( _preMeshInfo )
742     _preMeshInfo->ForgetOrLoad();
743
744   SMESH_Hypothesis::Hypothesis_Status status = removeHypothesis( aSubShape, anHyp );
745   SMESH::SMESH_Mesh_var mesh = _this();
746
747   if ( !SMESH_Hypothesis::IsStatusFatal(status) )
748   {
749     _gen_i->RemoveHypothesisFromShape( mesh, aSubShape, anHyp );
750     _gen_i->UpdateIcons( mesh );
751   }
752   // Update Python script
753   if(_impl->HasShapeToMesh())
754     TPythonDump() << "status = " << mesh << ".RemoveHypothesis( "
755                   << aSubShape << ", " << anHyp << " )";
756   else
757     TPythonDump() << "status = " << mesh << ".RemoveHypothesis( "
758                   << anHyp << " )";
759
760   return ConvertHypothesisStatus(status);
761 }
762
763 //=============================================================================
764 /*!
765  * \brief Un-assign a hypothesis from a sub-mesh dedicate to the given sub-shape
766  */
767 //=============================================================================
768
769 SMESH_Hypothesis::Hypothesis_Status
770 SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
771                                SMESH::SMESH_Hypothesis_ptr anHyp)
772 {
773   if(MYDEBUG) MESSAGE("removeHypothesis()");
774
775   if (CORBA::is_nil( aSubShape ) && HasShapeToMesh())
776     THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM);
777
778   if (CORBA::is_nil( anHyp ))
779     THROW_SALOME_CORBA_EXCEPTION("bad hypothesis reference", SALOME::BAD_PARAM);
780
781   if ( _preMeshInfo )
782     _preMeshInfo->ForgetOrLoad();
783
784   SMESH_Hypothesis::Hypothesis_Status status = SMESH_Hypothesis::HYP_OK;
785   try
786   {
787     TopoDS_Shape myLocSubShape;
788     //use PseudoShape in case if mesh has no shape
789     if( _impl->HasShapeToMesh() )
790       myLocSubShape = _gen_i->GeomObjectToShape( aSubShape );
791     else
792       myLocSubShape = _impl->GetShapeToMesh();
793
794     const int hypId = anHyp->GetId();
795     status = _impl->RemoveHypothesis(myLocSubShape, hypId);
796     if ( !SMESH_Hypothesis::IsStatusFatal(status) )
797     {
798       // _mapHypo.erase( hypId ); EAP: hyp can be used on many sub-shapes
799       anHyp->UnRegister();
800     }
801   }
802   catch(SALOME_Exception & S_ex)
803   {
804     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
805   }
806   return status;
807 }
808
809 //================================================================================
810 /*!
811  * \brief Return hypotheses assigned to a given sub-shape
812  */
813 //================================================================================
814
815 SMESH::ListOfHypothesis *
816 SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape)
817 {
818   Unexpect aCatch(SALOME_SalomeException);
819   if (MYDEBUG) MESSAGE("GetHypothesisList");
820   if (_impl->HasShapeToMesh() && CORBA::is_nil(aSubShape))
821     THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM);
822
823   SMESH::ListOfHypothesis_var aList = new SMESH::ListOfHypothesis();
824
825   try {
826     TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(aSubShape);
827     if ( myLocSubShape.IsNull() && !_impl->HasShapeToMesh() )
828       myLocSubShape = _impl->GetShapeToMesh();
829     const list<const SMESHDS_Hypothesis*>& aLocalList = _impl->GetHypothesisList( myLocSubShape );
830     int i = 0, n = aLocalList.size();
831     aList->length( n );
832
833     list<const SMESHDS_Hypothesis*>::const_iterator aHyp = aLocalList.begin();
834     std::map<int, SMESH::SMESH_Hypothesis_ptr>::iterator id_hypptr;
835     for ( ; i < n && aHyp != aLocalList.end(); aHyp++ )
836     {
837       id_hypptr = _mapHypo.find( (*aHyp)->GetID() );
838       if ( id_hypptr != _mapHypo.end() )
839         aList[i++] = SMESH::SMESH_Hypothesis::_narrow( id_hypptr->second );
840     }
841     aList->length( i );
842   }
843   catch(SALOME_Exception & S_ex) {
844     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
845   }
846
847   return aList._retn();
848 }
849
850 //================================================================================
851 /*!
852  * \brief Return sub-meshes
853  */
854 //================================================================================
855
856 SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes()
857 {
858   Unexpect aCatch(SALOME_SalomeException);
859   if (MYDEBUG) MESSAGE("GetSubMeshes");
860
861   SMESH::submesh_array_var aList = new SMESH::submesh_array();
862
863   // Python Dump
864   TPythonDump aPythonDump;
865   if ( !_mapSubMeshIor.empty() )
866     aPythonDump << "[ ";
867
868   try {
869     aList->length( _mapSubMeshIor.size() );
870     int i = 0;
871     map<int, SMESH::SMESH_subMesh_ptr>::iterator it = _mapSubMeshIor.begin();
872     for ( ; it != _mapSubMeshIor.end(); it++ ) {
873       if ( CORBA::is_nil( it->second )) continue;
874       aList[i++] = SMESH::SMESH_subMesh::_duplicate( it->second );
875       // Python Dump
876       if (i > 1) aPythonDump << ", ";
877       aPythonDump << it->second;
878     }
879     aList->length( i );
880   }
881   catch(SALOME_Exception & S_ex) {
882     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
883   }
884
885   // Update Python script
886   if ( !_mapSubMeshIor.empty() )
887     aPythonDump << " ] = " << SMESH::SMESH_Mesh_var( _this() ) << ".GetSubMeshes()";
888
889   return aList._retn();
890 }
891
892 //================================================================================
893 /*!
894  * \brief Create and return a sub-mesh on the given sub-shape
895  */
896 //================================================================================
897
898 SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShape,
899                                                   const char*           theName )
900 {
901   Unexpect aCatch(SALOME_SalomeException);
902   if (CORBA::is_nil(aSubShape))
903     THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM);
904
905   SMESH::SMESH_subMesh_var subMesh;
906   SMESH::SMESH_Mesh_var    aMesh = _this();
907   try {
908     TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(aSubShape);
909
910     //Get or Create the SMESH_subMesh object implementation
911
912     TopoDS_Iterator it( myLocSubShape );
913     int   subMeshId = _impl->GetMeshDS()->ShapeToIndex( myLocSubShape );
914     bool isValidSub = ( subMeshId || _impl->GetMeshDS()->IsGroupOfSubShapes( myLocSubShape ));
915     if ( isValidSub && myLocSubShape.ShapeType() == TopAbs_COMPOUND )
916       isValidSub = !it.Value().IsSame( _impl->GetShapeToMesh() );
917     if ( !isValidSub )
918     {
919       if ( it.More() )
920         THROW_SALOME_CORBA_EXCEPTION("Not a sub-shape of the main shape", SALOME::BAD_PARAM);
921     }
922     subMesh = getSubMesh( subMeshId );
923
924     // create a new subMesh object servant if there is none for the shape
925     if ( subMesh->_is_nil() )
926       subMesh = createSubMesh( aSubShape );
927     if ( _gen_i->CanPublishInStudy( subMesh ))
928     {
929       SALOMEDS::SObject_wrap aSO =
930         _gen_i->PublishSubMesh( aMesh, subMesh, aSubShape, theName );
931       if ( !aSO->_is_nil()) {
932         // Update Python script
933         TPythonDump() << aSO << " = " << aMesh << ".GetSubMesh( "
934                       << aSubShape << ", '" << theName << "' )";
935       }
936     }
937   }
938   catch(SALOME_Exception & S_ex) {
939     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
940   }
941   return subMesh._retn();
942 }
943
944 //================================================================================
945 /*!
946  * \brief Remove a sub-mesh
947  */
948 //================================================================================
949
950 void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
951 {
952   SMESH_TRY;
953
954   if ( theSubMesh->_is_nil() )
955     return;
956
957   GEOM::GEOM_Object_var aSubShape;
958   // Remove submesh's SObject
959   SALOMEDS::SObject_wrap anSO = _gen_i->ObjectToSObject( theSubMesh );
960   if ( !anSO->_is_nil() ) {
961     long aTag = SMESH_Gen_i::GetRefOnShapeTag();
962     SALOMEDS::SObject_wrap anObj, aRef;
963     if ( anSO->FindSubObject( aTag, anObj.inout() ) &&
964          anObj->ReferencedObject( aRef.inout() ))
965     {
966       CORBA::Object_var obj = aRef->GetObject();
967       aSubShape = GEOM::GEOM_Object::_narrow( obj );
968     }
969     // if ( aSubShape->_is_nil() ) // not published shape (IPAL13617)
970     //   aSubShape = theSubMesh->GetSubShape();
971
972     SALOMEDS::StudyBuilder_var builder = _gen_i->getStudyServant()->NewBuilder();
973     builder->RemoveObjectWithChildren( anSO );
974
975     // Update Python script
976     TPythonDump() << SMESH::SMESH_Mesh_var( _this() ) << ".RemoveSubMesh( " << anSO << " )";
977   }
978
979   if ( removeSubMesh( theSubMesh, aSubShape.in() ))
980     if ( _preMeshInfo )
981       _preMeshInfo->ForgetOrLoad();
982
983   SMESH_CATCH( SMESH::throwCorbaException );
984 }
985
986 //================================================================================
987 /*!
988  * \brief Create a standalone group
989  */
990 //================================================================================
991
992 SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType,
993                                                   const char*        theName )
994 {
995   Unexpect aCatch(SALOME_SalomeException);
996   if ( _preMeshInfo )
997     _preMeshInfo->FullLoadFromFile();
998
999   SMESH::SMESH_Group_var aNewGroup =
1000     SMESH::SMESH_Group::_narrow( createGroup( theElemType, theName ));
1001
1002   if ( _gen_i->CanPublishInStudy( aNewGroup ) )
1003   {
1004     SMESH::SMESH_Mesh_var mesh = _this();
1005     SALOMEDS::SObject_wrap aSO =
1006       _gen_i->PublishGroup( mesh, aNewGroup, GEOM::GEOM_Object::_nil(), theName);
1007     if ( !aSO->_is_nil())
1008       // Update Python script
1009       TPythonDump() << aSO << " = " << mesh << ".CreateGroup( "
1010                     << theElemType << ", '" << theName << "' )";
1011   }
1012   return aNewGroup._retn();
1013 }
1014
1015 //================================================================================
1016 /*!
1017  * \brief Create a group based on the given geometry
1018  */
1019 //================================================================================
1020
1021 SMESH::SMESH_GroupOnGeom_ptr
1022 SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType    theElemType,
1023                                    const char*           theName,
1024                                    GEOM::GEOM_Object_ptr theGeomObj)
1025 {
1026   Unexpect aCatch(SALOME_SalomeException);
1027   if ( _preMeshInfo )
1028     _preMeshInfo->FullLoadFromFile();
1029
1030   SMESH::SMESH_GroupOnGeom_var aNewGroup;
1031
1032   TopoDS_Shape aShape = _gen_i->GeomObjectToShape( theGeomObj );
1033   if ( !aShape.IsNull() )
1034   {
1035     aNewGroup =
1036       SMESH::SMESH_GroupOnGeom::_narrow( createGroup( theElemType, theName, /*id=*/-1, aShape ));
1037
1038     if ( _gen_i->CanPublishInStudy( aNewGroup ) )
1039     {
1040       SMESH::SMESH_Mesh_var mesh = _this();
1041       SALOMEDS::SObject_wrap aSO =
1042         _gen_i->PublishGroup( mesh, aNewGroup, theGeomObj, theName );
1043       if ( !aSO->_is_nil())
1044         TPythonDump() << aSO << " = " << mesh << ".CreateGroupFromGEOM( "
1045                       << theElemType << ", '" << theName << "', " << theGeomObj << " )";
1046     }
1047   }
1048
1049   return aNewGroup._retn();
1050 }
1051
1052 //================================================================================
1053 /*!
1054  * \brief Creates a group whose contents is defined by filter
1055  *  \param theElemType - group type
1056  *  \param theName - group name
1057  *  \param theFilter - the filter
1058  *  \retval SMESH::SMESH_GroupOnFilter_ptr - group defined by filter
1059  */
1060 //================================================================================
1061
1062 SMESH::SMESH_GroupOnFilter_ptr
1063 SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType,
1064                                     const char*        theName,
1065                                     SMESH::Filter_ptr  theFilter )
1066 {
1067   Unexpect aCatch(SALOME_SalomeException);
1068   if ( _preMeshInfo )
1069     _preMeshInfo->FullLoadFromFile();
1070
1071   if ( CORBA::is_nil( theFilter ))
1072     THROW_SALOME_CORBA_EXCEPTION("NULL filter", SALOME::BAD_PARAM);
1073
1074   SMESH_PredicatePtr predicate = SMESH_GroupOnFilter_i::GetPredicate( theFilter );
1075   if ( !predicate )
1076     THROW_SALOME_CORBA_EXCEPTION("Invalid filter", SALOME::BAD_PARAM);
1077
1078   SMESH::SMESH_GroupOnFilter_var aNewGroup = SMESH::SMESH_GroupOnFilter::_narrow
1079     ( createGroup( theElemType, theName, /*id=*/-1, TopoDS_Shape(), predicate ));
1080
1081   TPythonDump pd;
1082   if ( !aNewGroup->_is_nil() )
1083     aNewGroup->SetFilter( theFilter );
1084
1085   if ( _gen_i->CanPublishInStudy( aNewGroup ) )
1086   {
1087     SMESH::SMESH_Mesh_var mesh = _this();
1088     SALOMEDS::SObject_wrap aSO =
1089       _gen_i->PublishGroup( mesh, aNewGroup, GEOM::GEOM_Object::_nil(), theName );
1090
1091     if ( !aSO->_is_nil())
1092       pd << aSO << " = " << mesh << ".CreateGroupFromFilter( "
1093          << theElemType << ", '" << theName << "', " << theFilter << " )";
1094   }
1095   return aNewGroup._retn();
1096 }
1097
1098 //================================================================================
1099 /*!
1100  * \brief Remove a group
1101  */
1102 //================================================================================
1103
1104 void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
1105 {
1106   if ( theGroup->_is_nil() )
1107     return;
1108
1109   SMESH_TRY;
1110
1111   SMESH_GroupBase_i* aGroup = SMESH::DownCast<SMESH_GroupBase_i*>( theGroup );
1112   if ( !aGroup )
1113     return;
1114
1115   if ( aGroup->GetMeshServant() != this )
1116     THROW_SALOME_CORBA_EXCEPTION( "RemoveGroup(): group does not belong to this mesh",
1117                                   SALOME::BAD_PARAM );
1118
1119   SALOMEDS::SObject_wrap aGroupSO = _gen_i->ObjectToSObject( theGroup );
1120   if ( !aGroupSO->_is_nil() )
1121   {
1122     // Update Python script
1123     TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".RemoveGroup( " << aGroupSO << " )";
1124
1125     // Remove group's SObject
1126     SALOMEDS::StudyBuilder_var builder = SMESH_Gen_i::GetSMESHGen()->getStudyServant()->NewBuilder();
1127     builder->RemoveObjectWithChildren( aGroupSO );
1128   }
1129   aGroup->Modified(/*removed=*/true); // notify dependent Filter with FT_BelongToMeshGroup criterion
1130
1131   // Remove the group from SMESH data structures
1132   removeGroup( aGroup->GetLocalID() );
1133
1134   SMESH_CATCH( SMESH::throwCorbaException );
1135 }
1136
1137 //=============================================================================
1138 /*!
1139  *  Remove group with its contents
1140  */
1141 //=============================================================================
1142
1143 void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup )
1144 {
1145   SMESH_TRY;
1146   if ( _preMeshInfo )
1147     _preMeshInfo->FullLoadFromFile();
1148
1149   if ( theGroup->_is_nil() )
1150     return;
1151
1152   SMESH_GroupBase_i* groupImpl = SMESH::DownCast< SMESH_GroupBase_i* >( theGroup );
1153   if ( !groupImpl || groupImpl->GetMeshServant() != this )
1154     THROW_SALOME_CORBA_EXCEPTION( "RemoveGroupWithContents(): group does not belong to this mesh",
1155                                   SALOME::BAD_PARAM);
1156
1157   vector<smIdType> nodeIds; // to remove nodes becoming free
1158   bool isNodal = ( theGroup->GetType() == SMESH::NODE );
1159   if ( !isNodal && !theGroup->IsEmpty() )
1160   {
1161     SMESH::smIdType elemID = theGroup->GetID( 1 );
1162     int nbElemNodes = GetElemNbNodes( elemID );
1163     if ( nbElemNodes > 0 )
1164       nodeIds.reserve( theGroup->Size() * nbElemNodes );
1165   }
1166
1167   // Retrieve contents
1168   SMESH::SMESH_IDSource_var idSrc = SMESH::SMESH_IDSource::_narrow( theGroup );
1169   SMDS_ElemIteratorPtr     elemIt = GetElements( idSrc, theGroup->GetType() );
1170   SMDS_StdIterator< const SMDS_MeshElement*, SMDS_ElemIteratorPtr > elemBeg( elemIt ), elemEnd;
1171   std::vector< const SMDS_MeshElement* > elems( theGroup->Size() );
1172   elems.assign( elemBeg, elemEnd );
1173
1174   TPythonDump pyDump; // Suppress dump from RemoveGroup()
1175
1176   // Remove group
1177   RemoveGroup( theGroup );
1178
1179   // Remove contents
1180   for ( size_t i = 0; i < elems.size(); ++i )
1181   {
1182     // if ( !_impl->GetMeshDS()->Contains( elems[i] ))
1183     //   continue;
1184     if ( !isNodal )
1185     {
1186       for ( SMDS_ElemIteratorPtr nIt = elems[i]->nodesIterator(); nIt->more(); )
1187         nodeIds.push_back( nIt->next()->GetID() );
1188
1189       _impl->GetMeshDS()->RemoveFreeElement( elems[i], /*sm=*/0 );
1190     }
1191     else
1192     {
1193       _impl->GetMeshDS()->RemoveElement( elems[i] );
1194     }
1195   }
1196
1197   // Remove free nodes
1198   for ( size_t i = 0 ; i < nodeIds.size(); ++i )
1199     if ( const SMDS_MeshNode* n = _impl->GetMeshDS()->FindNode( nodeIds[i] ))
1200       if ( n->NbInverseElements() == 0 )
1201         _impl->GetMeshDS()->RemoveFreeNode( n, /*sm=*/0 );
1202
1203   _impl->GetMeshDS()->Modified();
1204   _impl->SetIsModified( true );
1205
1206   // Update Python script (theGroup must be alive for this)
1207   pyDump << SMESH::SMESH_Mesh_var(_this())
1208          << ".RemoveGroupWithContents( " << theGroup << " )";
1209
1210   SMESH_CATCH( SMESH::throwCorbaException );
1211 }
1212
1213 //================================================================================
1214 /*!
1215  * \brief Get the list of groups existing in the mesh
1216  *  \retval SMESH::ListOfGroups * - list of groups
1217  */
1218 //================================================================================
1219
1220 SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups()
1221 {
1222   Unexpect aCatch(SALOME_SalomeException);
1223   if (MYDEBUG) MESSAGE("GetGroups");
1224
1225   SMESH::ListOfGroups_var aList = new SMESH::ListOfGroups();
1226
1227   // Python Dump
1228   TPythonDump aPythonDump;
1229   if ( !_mapGroups.empty() )
1230   {
1231     aPythonDump << "[ ";
1232     try {
1233       aList->length( _mapGroups.size() );
1234       int i = 0;
1235       map<int, SMESH::SMESH_GroupBase_ptr>::iterator it = _mapGroups.begin();
1236       for ( ; it != _mapGroups.end(); it++ ) {
1237         if ( CORBA::is_nil( it->second )) continue;
1238         aList[i++] = SMESH::SMESH_GroupBase::_duplicate( it->second );
1239         // Python Dump
1240         if (i > 1) aPythonDump << ", ";
1241         aPythonDump << it->second;
1242       }
1243       aList->length( i );
1244     }
1245     catch(SALOME_Exception & S_ex) {
1246       THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
1247     }
1248     aPythonDump << " ] = " << SMESH::SMESH_Mesh_var(_this()) << ".GetGroups()";
1249   }
1250   return aList._retn();
1251 }
1252
1253 //=============================================================================
1254 /*!
1255  *  Get number of groups existing in the mesh
1256  */
1257 //=============================================================================
1258
1259 CORBA::Long SMESH_Mesh_i::NbGroups()
1260 {
1261   Unexpect aCatch(SALOME_SalomeException);
1262   return _mapGroups.size();
1263 }
1264
1265 //=============================================================================
1266 /*!
1267  * New group including all mesh elements present in initial groups is created.
1268  */
1269 //=============================================================================
1270
1271 SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
1272                                                   SMESH::SMESH_GroupBase_ptr theGroup2,
1273                                                   const char*                theName )
1274 {
1275   SMESH::SMESH_Group_var aResGrp;
1276
1277   SMESH_TRY;
1278   if ( _preMeshInfo )
1279     _preMeshInfo->FullLoadFromFile();
1280
1281   if ( theGroup1->_is_nil() || theGroup2->_is_nil() )
1282     THROW_SALOME_CORBA_EXCEPTION("UnionGroups(): NULL Group",
1283                                  SALOME::BAD_PARAM);
1284   if ( theGroup1->GetType() != theGroup2->GetType() )
1285     THROW_SALOME_CORBA_EXCEPTION("UnionGroups(): different group types",
1286                                  SALOME::BAD_PARAM);
1287   TPythonDump pyDump;
1288
1289   // Create Union
1290   aResGrp = CreateGroup( theGroup1->GetType(), theName );
1291   if ( aResGrp->_is_nil() )
1292     return SMESH::SMESH_Group::_nil();
1293
1294   aResGrp->AddFrom( theGroup1 );
1295   aResGrp->AddFrom( theGroup2 );
1296
1297   // Update Python script
1298   pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var(_this())
1299          << ".UnionGroups( " << theGroup1 << ", " << theGroup2 << ", '" << theName << "' )";
1300
1301   SMESH_CATCH( SMESH::throwCorbaException );
1302
1303   return aResGrp._retn();
1304 }
1305
1306 //=============================================================================
1307 /*!
1308  * \brief New group including all mesh elements present in initial groups is created.
1309  *  \param theGroups list of groups
1310  *  \param theName name of group to be created
1311  *  \return pointer to the new group
1312  */
1313 //=============================================================================
1314
1315 SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups& theGroups,
1316                                                        const char*                theName )
1317 {
1318   SMESH::SMESH_Group_var aResGrp;
1319
1320   if ( _preMeshInfo )
1321     _preMeshInfo->FullLoadFromFile();
1322
1323   if ( !theName )
1324     return SMESH::SMESH_Group::_nil();
1325
1326   SMESH_TRY;
1327
1328   // check types
1329   SMESH::ElementType aType = SMESH::ALL;
1330   for ( int g = 0, n = theGroups.length(); g < n; g++ )
1331   {
1332     SMESH::SMESH_GroupBase_var aGrp = theGroups[ g ];
1333     if ( CORBA::is_nil( aGrp ) )
1334       continue;
1335     if ( aType == SMESH::ALL )
1336       aType = aGrp->GetType();
1337     else if ( aType != aGrp->GetType() )
1338       THROW_SALOME_CORBA_EXCEPTION("UnionListOfGroups(): different group types",
1339                                    SALOME::BAD_PARAM);
1340   }
1341   if ( aType == SMESH::ALL )
1342     return SMESH::SMESH_Group::_nil();
1343
1344   TPythonDump pyDump;
1345
1346   // Create Union
1347   aResGrp = CreateGroup( aType, theName );
1348   if ( aResGrp->_is_nil() )
1349     return SMESH::SMESH_Group::_nil();
1350
1351   pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var(_this()) << ".UnionListOfGroups([ ";
1352   for ( int g = 0, n = theGroups.length(); g < n; g++ )
1353   {
1354     SMESH::SMESH_GroupBase_var aGrp = theGroups[ g ];
1355     if ( !CORBA::is_nil( aGrp ) )
1356     {
1357       aResGrp->AddFrom( aGrp );
1358       if ( g > 0 ) pyDump << ", ";
1359       pyDump << aGrp;
1360     }
1361   }
1362   pyDump << " ], '" << theName << "' )";
1363
1364   SMESH_CATCH( SMESH::throwCorbaException );
1365
1366   return aResGrp._retn();
1367 }
1368
1369 //=============================================================================
1370 /*!
1371  *  New group is created. All mesh elements that are
1372  *  present in both initial groups are added to the new one.
1373  */
1374 //=============================================================================
1375
1376 SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
1377                                                       SMESH::SMESH_GroupBase_ptr theGroup2,
1378                                                       const char*                theName )
1379 {
1380   SMESH::SMESH_Group_var aResGrp;
1381
1382   SMESH_TRY;
1383
1384   if ( _preMeshInfo )
1385     _preMeshInfo->FullLoadFromFile();
1386
1387   if ( theGroup1->_is_nil() || theGroup2->_is_nil() )
1388     THROW_SALOME_CORBA_EXCEPTION("IntersectGroups(): NULL Group",
1389                                  SALOME::BAD_PARAM);
1390   if ( theGroup1->GetType() != theGroup2->GetType() )
1391     THROW_SALOME_CORBA_EXCEPTION("IntersectGroups(): different group types",
1392                                  SALOME::BAD_PARAM);
1393   TPythonDump pyDump;
1394
1395   // Create Intersection
1396   aResGrp = CreateGroup( theGroup1->GetType(), theName );
1397   if ( aResGrp->_is_nil() )
1398     return aResGrp._retn();
1399
1400   SMESHDS_GroupBase* groupDS1 = 0;
1401   if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( theGroup1 ))
1402     groupDS1 = grp_i->GetGroupDS();
1403
1404   SMESHDS_GroupBase* groupDS2 = 0;
1405   if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( theGroup2 ))
1406     groupDS2 = grp_i->GetGroupDS();
1407
1408   SMESHDS_Group* resGroupDS = 0;
1409   if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( aResGrp ))
1410     resGroupDS = dynamic_cast<SMESHDS_Group*>( grp_i->GetGroupDS() );
1411
1412   if ( groupDS1 && groupDS2 && resGroupDS && !groupDS2->IsEmpty() )
1413   {
1414     SMDS_ElemIteratorPtr elemIt1 = groupDS1->GetElements();
1415     while ( elemIt1->more() )
1416     {
1417       const SMDS_MeshElement* e = elemIt1->next();
1418       if ( groupDS2->Contains( e ))
1419         resGroupDS->SMDSGroup().Add( e );
1420     }
1421   }
1422   // Update Python script
1423   pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var(_this()) << ".IntersectGroups( "
1424          << theGroup1 << ", " << theGroup2 << ", '" << theName << "')";
1425
1426   SMESH_CATCH( SMESH::throwCorbaException );
1427
1428   return aResGrp._retn();
1429 }
1430
1431 //=============================================================================
1432 /*!
1433   \brief Intersect list of groups. New group is created. All mesh elements that
1434   are present in all initial groups simultaneously are added to the new one.
1435   \param theGroups list of groups
1436   \param theName name of group to be created
1437   \return pointer on the group
1438 */
1439 //=============================================================================
1440
1441 SMESH::SMESH_Group_ptr
1442 SMESH_Mesh_i::IntersectListOfGroups(const SMESH::ListOfGroups& theGroups,
1443                                     const char*                theName )
1444 {
1445   SMESH::SMESH_Group_var aResGrp;
1446
1447   SMESH_TRY;
1448
1449   if ( _preMeshInfo )
1450     _preMeshInfo->FullLoadFromFile();
1451
1452   if ( !theName )
1453     return SMESH::SMESH_Group::_nil();
1454
1455   // check types and get SMESHDS_GroupBase's
1456   SMESH::ElementType aType = SMESH::ALL;
1457   vector< SMESHDS_GroupBase* > groupVec;
1458   for ( int g = 0, n = theGroups.length(); g < n; g++ )
1459   {
1460     SMESH::SMESH_GroupBase_var aGrp = theGroups[ g ];
1461     if ( CORBA::is_nil( aGrp ) )
1462       continue;
1463     if ( aType == SMESH::ALL )
1464       aType = aGrp->GetType();
1465     else if ( aType != aGrp->GetType() )
1466       THROW_SALOME_CORBA_EXCEPTION("IntersectListOfGroups(): different group types",
1467                                    SALOME::BAD_PARAM);
1468
1469     if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( aGrp ))
1470       if ( SMESHDS_GroupBase* grpDS = grp_i->GetGroupDS() )
1471       {
1472         if ( grpDS->IsEmpty() )
1473         {
1474           groupVec.clear();
1475           break;
1476         }
1477         groupVec.push_back( grpDS );
1478       }
1479   }
1480   if ( aType == SMESH::ALL ) // all groups are nil
1481     return SMESH::SMESH_Group::_nil();
1482
1483   TPythonDump pyDump;
1484
1485   // Create a group
1486   aResGrp = CreateGroup( aType, theName );
1487
1488   SMESHDS_Group* resGroupDS = 0;
1489   if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( aResGrp ))
1490     resGroupDS = dynamic_cast<SMESHDS_Group*>( grp_i->GetGroupDS() );
1491   if ( !resGroupDS || groupVec.empty() )
1492     return aResGrp._retn();
1493
1494   // Fill the group
1495   size_t i, nb = groupVec.size();
1496   SMDS_ElemIteratorPtr elemIt1 = groupVec[0]->GetElements();
1497   while ( elemIt1->more() )
1498   {
1499     const SMDS_MeshElement* e = elemIt1->next();
1500     bool inAll = true;
1501     for ( i = 1; ( i < nb && inAll ); ++i )
1502       inAll = groupVec[i]->Contains( e );
1503
1504     if ( inAll )
1505       resGroupDS->SMDSGroup().Add( e );
1506   }
1507
1508   // Update Python script
1509   pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var( _this() )
1510          << ".IntersectListOfGroups( " << theGroups << ", '" << theName << "' )";
1511
1512   SMESH_CATCH( SMESH::throwCorbaException );
1513
1514   return aResGrp._retn();
1515 }
1516
1517 //=============================================================================
1518 /*!
1519  *  New group is created. All mesh elements that are present in
1520  *  a main group but is not present in a tool group are added to the new one
1521  */
1522 //=============================================================================
1523
1524 SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
1525                                                 SMESH::SMESH_GroupBase_ptr theGroup2,
1526                                                 const char*                theName )
1527 {
1528   SMESH::SMESH_Group_var aResGrp;
1529
1530   SMESH_TRY;
1531
1532   if ( _preMeshInfo )
1533     _preMeshInfo->FullLoadFromFile();
1534
1535   if ( theGroup1->_is_nil() || theGroup2->_is_nil() )
1536     THROW_SALOME_CORBA_EXCEPTION("CutGroups(): NULL Group",
1537                                  SALOME::BAD_PARAM);
1538   if ( theGroup1->GetType() != theGroup2->GetType() )
1539     THROW_SALOME_CORBA_EXCEPTION("CutGroups(): different group types",
1540                                  SALOME::BAD_PARAM);
1541   TPythonDump pyDump;
1542
1543   aResGrp = CreateGroup( theGroup1->GetType(), theName );
1544   if ( aResGrp->_is_nil() )
1545     return aResGrp._retn();
1546
1547   SMESHDS_GroupBase* groupDS1 = 0;
1548   if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( theGroup1 ))
1549     groupDS1 = grp_i->GetGroupDS();
1550
1551   SMESHDS_GroupBase* groupDS2 = 0;
1552   if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( theGroup2 ))
1553     groupDS2 = grp_i->GetGroupDS();
1554
1555   SMESHDS_Group* resGroupDS = 0;
1556   if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( aResGrp ))
1557     resGroupDS = dynamic_cast<SMESHDS_Group*>( grp_i->GetGroupDS() );
1558
1559   if ( groupDS1 && groupDS2 && resGroupDS )
1560   {
1561     SMDS_ElemIteratorPtr elemIt1 = groupDS1->GetElements();
1562     while ( elemIt1->more() )
1563     {
1564       const SMDS_MeshElement* e = elemIt1->next();
1565       if ( !groupDS2->Contains( e ))
1566         resGroupDS->SMDSGroup().Add( e );
1567     }
1568   }
1569   // Update Python script
1570   pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var(_this()) << ".CutGroups( "
1571          << theGroup1 << ", " << theGroup2 << ", '" << theName << "')";
1572
1573   SMESH_CATCH( SMESH::throwCorbaException );
1574
1575   return aResGrp._retn();
1576 }
1577
1578 //=============================================================================
1579 /*!
1580   \brief Cut lists of groups. New group is created. All mesh elements that are
1581   present in main groups but do not present in tool groups are added to the new one
1582   \param theMainGroups list of main groups
1583   \param theToolGroups list of tool groups
1584   \param theName name of group to be created
1585   \return pointer on the group
1586 */
1587 //=============================================================================
1588
1589 SMESH::SMESH_Group_ptr
1590 SMESH_Mesh_i::CutListOfGroups(const SMESH::ListOfGroups& theMainGroups,
1591                               const SMESH::ListOfGroups& theToolGroups,
1592                               const char*                theName )
1593 {
1594   SMESH::SMESH_Group_var aResGrp;
1595
1596   SMESH_TRY;
1597
1598   if ( _preMeshInfo )
1599     _preMeshInfo->FullLoadFromFile();
1600
1601   if ( !theName )
1602     return SMESH::SMESH_Group::_nil();
1603
1604   // check types and get SMESHDS_GroupBase's
1605   SMESH::ElementType aType = SMESH::ALL;
1606   vector< SMESHDS_GroupBase* >   toolGroupVec;
1607   vector< SMDS_ElemIteratorPtr > mainIterVec;
1608
1609   for ( int g = 0, n = theMainGroups.length(); g < n; g++ )
1610   {
1611     SMESH::SMESH_GroupBase_var aGrp = theMainGroups[ g ];
1612     if ( CORBA::is_nil( aGrp ) )
1613       continue;
1614     if ( aType == SMESH::ALL )
1615       aType = aGrp->GetType();
1616     else if ( aType != aGrp->GetType() )
1617       THROW_SALOME_CORBA_EXCEPTION("CutListOfGroups(): different group types",
1618                                    SALOME::BAD_PARAM);
1619     if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( aGrp ))
1620       if ( SMESHDS_GroupBase* grpDS = grp_i->GetGroupDS() )
1621         if ( !grpDS->IsEmpty() )
1622           mainIterVec.push_back( grpDS->GetElements() );
1623   }
1624   if ( aType == SMESH::ALL ) // all main groups are nil
1625     return SMESH::SMESH_Group::_nil();
1626   if ( mainIterVec.empty() ) // all main groups are empty
1627     return aResGrp._retn();
1628
1629   for ( int g = 0, n = theToolGroups.length(); g < n; g++ )
1630   {
1631     SMESH::SMESH_GroupBase_var aGrp = theToolGroups[ g ];
1632     if ( CORBA::is_nil( aGrp ) )
1633       continue;
1634     if ( aType != aGrp->GetType() )
1635       THROW_SALOME_CORBA_EXCEPTION("CutListOfGroups(): different group types",
1636                                    SALOME::BAD_PARAM);
1637     if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( aGrp ))
1638       if ( SMESHDS_GroupBase* grpDS = grp_i->GetGroupDS() )
1639         toolGroupVec.push_back( grpDS );
1640   }
1641
1642   TPythonDump pyDump;
1643
1644   // Create a group
1645   aResGrp = CreateGroup( aType, theName );
1646
1647   SMESHDS_Group* resGroupDS = 0;
1648   if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( aResGrp ))
1649     resGroupDS = dynamic_cast<SMESHDS_Group*>( grp_i->GetGroupDS() );
1650   if ( !resGroupDS )
1651     return aResGrp._retn();
1652
1653   // Fill the group
1654   size_t i, nb = toolGroupVec.size();
1655   SMDS_ElemIteratorPtr mainElemIt
1656     ( new SMDS_IteratorOnIterators
1657       < const SMDS_MeshElement*, vector< SMDS_ElemIteratorPtr > >( mainIterVec ));
1658   while ( mainElemIt->more() )
1659   {
1660     const SMDS_MeshElement* e = mainElemIt->next();
1661     bool isIn = false;
1662     for ( i = 0; ( i < nb && !isIn ); ++i )
1663       isIn = toolGroupVec[i]->Contains( e );
1664
1665     if ( !isIn )
1666       resGroupDS->SMDSGroup().Add( e );
1667   }
1668
1669   // Update Python script
1670   pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var( _this() )
1671          << ".CutListOfGroups( " << theMainGroups << ", "
1672          << theToolGroups << ", '" << theName << "' )";
1673
1674   SMESH_CATCH( SMESH::throwCorbaException );
1675
1676   return aResGrp._retn();
1677 }
1678
1679 namespace // functions making checks according to SMESH::NB_COMMON_NODES_ENUM
1680 {
1681   bool isAllNodesCommon(int nbChecked, int nbCommon, int nbNodes, int /*nbCorners*/,
1682                         bool & toStopChecking )
1683   {
1684     toStopChecking = ( nbCommon < nbChecked );
1685     return nbCommon == nbNodes;
1686   }
1687   bool isMainNodesCommon(int nbChecked, int nbCommon, int /*nbNodes*/, int nbCorners,
1688                          bool & toStopChecking )
1689   {
1690     toStopChecking = ( nbCommon < nbChecked || nbChecked >= nbCorners );
1691     return nbCommon == nbCorners;
1692   }
1693   bool isAtLeastOneNodeCommon(int /*nbChecked*/, int nbCommon, int /*nbNodes*/, int /*nbCorners*/,
1694                               bool & /*toStopChecking*/ )
1695   {
1696     return nbCommon > 0;
1697   }
1698   bool isMajorityOfNodesCommon(int /*nbChecked*/, int nbCommon, int nbNodes, int /*nbCorners*/,
1699                                bool & /*toStopChecking*/ )
1700   {
1701     return nbCommon >= (nbNodes+1) / 2;
1702   }
1703 }
1704
1705 //=============================================================================
1706 /*!
1707  * Create a group of entities basing on nodes of other groups.
1708  *  \param [in] theGroups - list of either groups, sub-meshes or filters.
1709  *  \param [in] anElemType - a type of elements to include to the new group.
1710  *  \param [in] theName - a name of the new group.
1711  *  \param [in] theNbCommonNodes - criterion of inclusion of an element to the new group.
1712  *  \param [in] theUnderlyingOnly - if \c True, an element is included to the
1713  *         new group provided that it is based on nodes of an element of \a aListOfGroups
1714  *  \return SMESH_Group - the created group
1715 */
1716 // IMP 19939, bug 22010, IMP 22635
1717 //=============================================================================
1718
1719 SMESH::SMESH_Group_ptr
1720 SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfIDSources& theGroups,
1721                              SMESH::ElementType            theElemType,
1722                              const char*                   theName,
1723                              SMESH::NB_COMMON_NODES_ENUM   theNbCommonNodes,
1724                              CORBA::Boolean                theUnderlyingOnly)
1725 {
1726   SMESH::SMESH_Group_var aResGrp;
1727
1728   SMESH_TRY;
1729   if ( _preMeshInfo )
1730     _preMeshInfo->FullLoadFromFile();
1731
1732   SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
1733
1734   if ( !theName || !aMeshDS )
1735     return SMESH::SMESH_Group::_nil();
1736
1737   SMDSAbs_ElementType anElemType = (SMDSAbs_ElementType)theElemType;
1738
1739   bool (*isToInclude)(int nbChecked, int nbCommon, int nbNodes, int nbCorners, bool & toStop);
1740   SMESH_Comment nbCoNoStr( "SMESH.");
1741   switch ( theNbCommonNodes ) {
1742   case SMESH::ALL_NODES   : isToInclude = isAllNodesCommon;        nbCoNoStr<<"ALL_NODES"   ;break;
1743   case SMESH::MAIN        : isToInclude = isMainNodesCommon;       nbCoNoStr<<"MAIN"        ;break;
1744   case SMESH::AT_LEAST_ONE: isToInclude = isAtLeastOneNodeCommon;  nbCoNoStr<<"AT_LEAST_ONE";break;
1745   case SMESH::MAJORITY    : isToInclude = isMajorityOfNodesCommon; nbCoNoStr<<"MAJORITY"    ;break;
1746   default: return aResGrp._retn();
1747   }
1748   int nbChecked, nbCommon, nbNodes, nbCorners;
1749
1750   // Create a group
1751
1752   TPythonDump pyDump;
1753
1754   aResGrp = CreateGroup( theElemType, theName );
1755   if ( aResGrp->_is_nil() )
1756     return SMESH::SMESH_Group::_nil();
1757
1758   SMESHDS_GroupBase* groupBaseDS =
1759     SMESH::DownCast<SMESH_GroupBase_i*>( aResGrp )->GetGroupDS();
1760   SMDS_MeshGroup& resGroupCore = static_cast< SMESHDS_Group* >( groupBaseDS )->SMDSGroup();
1761
1762   vector<bool> isNodeInGroups;
1763
1764   for ( int g = 0, n = theGroups.length(); g < n; g++ ) // loop on theGroups
1765   {
1766     SMESH::SMESH_IDSource_var aGrp = theGroups[ g ];
1767     if ( CORBA::is_nil( aGrp ) )
1768       continue;
1769     SMESH::SMESH_Mesh_var mesh = aGrp->GetMesh();
1770     if ( mesh->_is_nil() || mesh->GetId() != this->GetId() )
1771       continue;
1772
1773     SMDS_ElemIteratorPtr elIt = GetElements( aGrp, SMESH::ALL );
1774     if ( !elIt ) continue;
1775
1776     if ( theElemType == SMESH::NODE ) // get all nodes of elements
1777     {
1778       while ( elIt->more() ) {
1779         const SMDS_MeshElement* el = elIt->next();
1780         SMDS_ElemIteratorPtr nIt = el->nodesIterator();
1781         while ( nIt->more() )
1782           resGroupCore.Add( nIt->next() );
1783       }
1784     }
1785     // get elements of theElemType based on nodes of every element of group
1786     else if ( theUnderlyingOnly )
1787     {
1788       while ( elIt->more() )
1789       {
1790         const SMDS_MeshElement* el = elIt->next(); // an element of ref group
1791         TIDSortedElemSet elNodes( el->begin_nodes(), el->end_nodes() );
1792         TIDSortedElemSet checkedElems;
1793         SMDS_NodeIteratorPtr nIt = el->nodeIterator();
1794         while ( nIt->more() )
1795         {
1796           const SMDS_MeshNode* n = nIt->next();
1797           SMDS_ElemIteratorPtr elOfTypeIt = n->GetInverseElementIterator( anElemType );
1798           // check nodes of elements of theElemType around el
1799           while ( elOfTypeIt->more() )
1800           {
1801             const SMDS_MeshElement* elOfType = elOfTypeIt->next();
1802             if ( !checkedElems.insert( elOfType ).second ) continue;
1803             nbNodes   = elOfType->NbNodes();
1804             nbCorners = elOfType->NbCornerNodes();
1805             nbCommon  = 0;
1806             bool toStopChecking = false;
1807             SMDS_ElemIteratorPtr nIt2 = elOfType->nodesIterator();
1808             for ( nbChecked = 1; nIt2->more() && !toStopChecking; ++nbChecked )
1809               if ( elNodes.count( nIt2->next() ) &&
1810                    isToInclude( nbChecked, ++nbCommon, nbNodes, nbCorners, toStopChecking ))
1811               {
1812                 resGroupCore.Add( elOfType );
1813                 break;
1814               }
1815           }
1816         }
1817       }
1818     }
1819     // get all nodes of elements of groups
1820     else
1821     {
1822       while ( elIt->more() )
1823       {
1824         const SMDS_MeshElement* el = elIt->next(); // an element of group
1825         SMDS_NodeIteratorPtr nIt = el->nodeIterator();
1826         while ( nIt->more() )
1827         {
1828           const SMDS_MeshNode* n = nIt->next();
1829           if ( n->GetID() >= (int) isNodeInGroups.size() )
1830             isNodeInGroups.resize( n->GetID() + 1, false );
1831           isNodeInGroups[ n->GetID() ] = true;
1832         }
1833       }
1834     }
1835   }
1836
1837   // Get elements of theElemType based on a certain number of nodes of elements of groups
1838   if ( !theUnderlyingOnly && !isNodeInGroups.empty() )
1839   {
1840     const SMDS_MeshNode* n;
1841     vector<bool> isElemChecked( aMeshDS->MaxElementID() + 1 );
1842     const int isNodeInGroupsSize = isNodeInGroups.size();
1843     for ( int iN = 0; iN < isNodeInGroupsSize; ++iN )
1844     {
1845       if ( !isNodeInGroups[ iN ] ||
1846            !( n = aMeshDS->FindNode( iN )))
1847         continue;
1848
1849       // check nodes of elements of theElemType around n
1850       SMDS_ElemIteratorPtr elOfTypeIt = n->GetInverseElementIterator( anElemType );
1851       while ( elOfTypeIt->more() )
1852       {
1853         const SMDS_MeshElement*  elOfType = elOfTypeIt->next();
1854         vector<bool>::reference isChecked = isElemChecked[ elOfType->GetID() ];
1855         if ( isChecked )
1856           continue;
1857         isChecked = true;
1858
1859         nbNodes   = elOfType->NbNodes();
1860         nbCorners = elOfType->NbCornerNodes();
1861         nbCommon  = 0;
1862         bool toStopChecking = false;
1863         SMDS_ElemIteratorPtr nIt = elOfType->nodesIterator();
1864         for ( nbChecked = 1; nIt->more() && !toStopChecking; ++nbChecked )
1865         {
1866           const smIdType nID = nIt->next()->GetID();
1867           if ( nID < isNodeInGroupsSize && isNodeInGroups[ nID ] &&
1868                isToInclude( nbChecked, ++nbCommon, nbNodes, nbCorners, toStopChecking ))
1869           {
1870             resGroupCore.Add( elOfType );
1871             break;
1872           }
1873         }
1874       }
1875     }
1876   }
1877
1878   // Update Python script
1879   pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var( _this())
1880          << ".CreateDimGroup( "
1881          << theGroups << ", " << theElemType << ", '" << theName << "', "
1882          << nbCoNoStr << ", " << theUnderlyingOnly << ")";
1883
1884   SMESH_CATCH( SMESH::throwCorbaException );
1885
1886   return aResGrp._retn();
1887 }
1888
1889 //================================================================================
1890 /*!
1891  * \brief Distribute all faces of the mesh between groups using sharp edges and optionally
1892  *        existing 1D elements as group boundaries.
1893  *  \param [in] theSharpAngle - edge is considered sharp if an angle between normals of
1894  *              adjacent faces is more than \a sharpAngle in degrees.
1895  *  \param [in] theCreateEdges - to create 1D elements for detected sharp edges.
1896  *  \param [in] theUseExistingEdges - to use existing edges as group boundaries
1897  *  \return ListOfGroups - the created groups
1898  */
1899 //================================================================================
1900
1901 SMESH::ListOfGroups*
1902 SMESH_Mesh_i::FaceGroupsSeparatedByEdges( CORBA::Double  theSharpAngle,
1903                                           CORBA::Boolean theCreateEdges,
1904                                           CORBA::Boolean theUseExistingEdges )
1905 {
1906   if ( theSharpAngle < 0 || theSharpAngle > 180 )
1907     THROW_SALOME_CORBA_EXCEPTION("Invalid sharp angle, it must be between 0 and 180 degrees",
1908                                  SALOME::BAD_PARAM);
1909
1910   SMESH::ListOfGroups_var resultGroups = new SMESH::ListOfGroups;
1911
1912   TPythonDump pyDump;
1913
1914   SMESH_TRY;
1915   if ( _preMeshInfo )
1916     _preMeshInfo->FullLoadFromFile();
1917
1918   SMESHDS_Mesh* meshDS = _impl->GetMeshDS();
1919
1920   std::vector< SMESH_MeshAlgos::Edge > edges =
1921     SMESH_MeshAlgos::FindSharpEdges( meshDS, theSharpAngle, theUseExistingEdges );
1922
1923   if ( theCreateEdges )
1924   {
1925     std::vector<const SMDS_MeshNode *> nodes(2);
1926     for ( size_t i = 0; i < edges.size(); ++i )
1927     {
1928       nodes[0] = edges[i]._node1;
1929       nodes[1] = edges[i]._node2;
1930       if ( meshDS->FindElement( nodes, SMDSAbs_Edge ))
1931         continue;
1932       if ( edges[i]._medium )
1933         meshDS->AddEdge( edges[i]._node1, edges[i]._node2, edges[i]._medium );
1934       else
1935         meshDS->AddEdge( edges[i]._node1, edges[i]._node2 );
1936     }
1937   }
1938
1939   std::vector< std::vector< const SMDS_MeshElement* > > faceGroups =
1940     SMESH_MeshAlgos::SeparateFacesByEdges( meshDS, edges );
1941
1942   SMESH::SMESH_MeshEditor_var editor = GetMeshEditor(); // create _editor
1943
1944   resultGroups->length( faceGroups.size() );
1945   for ( size_t iG = 0; iG < faceGroups.size(); ++iG )
1946   {
1947     SMESH::SMESH_Group_var group = CreateGroup( SMESH::FACE,
1948                                                 _editor->GenerateGroupName("Group").c_str());
1949     resultGroups[iG] = SMESH::SMESH_Group::_duplicate( group );
1950
1951     SMESHDS_GroupBase* groupBaseDS =
1952       SMESH::DownCast<SMESH_GroupBase_i*>( group )->GetGroupDS();
1953     SMDS_MeshGroup& groupCore = static_cast< SMESHDS_Group* >( groupBaseDS )->SMDSGroup();
1954
1955     std::vector< const SMDS_MeshElement* >& faces = faceGroups[ iG ];
1956     for ( size_t i = 0; i < faces.size(); ++i )
1957       groupCore.Add( faces[i] );
1958   }
1959
1960   pyDump << resultGroups << " = " << SMESH::SMESH_Mesh_var(_this())
1961          << ".FaceGroupsSeparatedByEdges( "
1962          << TVar( theSharpAngle ) << ", "
1963          << theCreateEdges << ", "
1964          << theUseExistingEdges << " )";
1965
1966   SMESH_CATCH( SMESH::throwCorbaException );
1967   return resultGroups._retn();
1968
1969 }
1970
1971 //================================================================================
1972 /*!
1973  * \brief Remember GEOM group data
1974  */
1975 //================================================================================
1976
1977 void SMESH_Mesh_i::addGeomGroupData(GEOM::GEOM_Object_ptr theGeomObj,
1978                                     CORBA::Object_ptr     theSmeshObj)
1979 {
1980   if ( CORBA::is_nil( theGeomObj ) || theGeomObj->GetType() != GEOM_GROUP )
1981     return;
1982   // group SO
1983   SALOMEDS::SObject_wrap groupSO = _gen_i->ObjectToSObject( theGeomObj );
1984   if ( groupSO->_is_nil() )
1985     return;
1986   // group indices
1987   GEOM::GEOM_Gen_var               geomGen = _gen_i->GetGeomEngine( theGeomObj );
1988   GEOM::GEOM_IGroupOperations_wrap groupOp = geomGen->GetIGroupOperations();
1989   GEOM::ListOfLong_var                 ids = groupOp->GetObjects( theGeomObj );
1990
1991   // store data
1992   _geomGroupData.push_back( TGeomGroupData() );
1993   TGeomGroupData & groupData = _geomGroupData.back();
1994   // entry
1995   CORBA::String_var entry = groupSO->GetID();
1996   groupData._groupEntry = entry.in();
1997   // indices
1998   for ( CORBA::ULong i = 0; i < ids->length(); ++i )
1999     groupData._indices.insert( ids[i] );
2000   // SMESH object
2001   groupData._smeshObject = CORBA::Object::_duplicate( theSmeshObj );
2002   // shape index in SMESHDS
2003   // TopoDS_Shape shape = _gen_i->GeomObjectToShape( theGeomObj );
2004   // groupData._dsID = shape.IsNull() ? 0 : _impl->GetSubMesh( shape )->GetId();
2005 }
2006
2007 //================================================================================
2008 /*!
2009  * Remove GEOM group data relating to removed smesh object
2010  */
2011 //================================================================================
2012
2013 void SMESH_Mesh_i::removeGeomGroupData(CORBA::Object_ptr theSmeshObj)
2014 {
2015   list<TGeomGroupData>::iterator
2016     data = _geomGroupData.begin(), dataEnd = _geomGroupData.end();
2017   for ( ; data != dataEnd; ++data ) {
2018     if ( theSmeshObj->_is_equivalent( data->_smeshObject )) {
2019       _geomGroupData.erase( data );
2020       return;
2021     }
2022   }
2023 }
2024
2025 //================================================================================
2026 /*!
2027 * \brief Replace a shape in the mesh upon Break Link
2028 */
2029 //================================================================================
2030
2031 void SMESH_Mesh_i::ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom)
2032 {
2033   // check if geometry changed
2034   bool geomChanged = true;
2035   GEOM::GEOM_Object_var oldGeom = GetShapeToMesh();
2036   if ( !theNewGeom->_is_nil() && !oldGeom->_is_nil() )
2037     geomChanged = ( oldGeom->GetTick() != theNewGeom->GetTick() );
2038
2039   TopoDS_Shape S = _impl->GetShapeToMesh();
2040   GEOM_Client* geomClient = _gen_i->GetShapeReader();
2041   TCollection_AsciiString aIOR;
2042   if ( geomClient->Find( S, aIOR ))
2043     geomClient->RemoveShapeFromBuffer( aIOR );
2044
2045   // clear buffer also for sub-groups
2046   SMESHDS_Mesh* meshDS = _impl->GetMeshDS();
2047   const std::set<SMESHDS_GroupBase*>& groups = meshDS->GetGroups();
2048   std::set<SMESHDS_GroupBase*>::const_iterator g = groups.begin();
2049   for (; g != groups.end(); ++g)
2050     if (const SMESHDS_GroupOnGeom* group = dynamic_cast<SMESHDS_GroupOnGeom*>(*g))
2051     {
2052       const TopoDS_Shape& s = group->GetShape();
2053       if ( geomClient->Find( s, aIOR ))
2054         geomClient->RemoveShapeFromBuffer( aIOR );
2055     }
2056
2057   // clear buffer also for sub-meshes
2058   std::map<int, SMESH_subMesh_i*>::const_iterator aSubMeshIter = _mapSubMesh_i.cbegin();
2059   for(; aSubMeshIter != _mapSubMesh_i.cend(); aSubMeshIter++) {
2060     int aShapeID = aSubMeshIter->first;
2061     const TopoDS_Shape& aSubShape = meshDS->IndexToShape(aShapeID);
2062     TCollection_AsciiString aShapeIOR;
2063     if ( geomClient->Find( aSubShape, aShapeIOR ))
2064       geomClient->RemoveShapeFromBuffer( aShapeIOR );
2065   }
2066
2067   typedef struct {
2068     int shapeID; smIdType fromID, toID; // indices of elements of a sub-mesh
2069   } TRange;
2070   std::vector< TRange > elemRanges, nodeRanges; // elements of sub-meshes
2071   std::vector< SMDS_PositionPtr > positions; // node positions
2072   if ( !geomChanged )
2073   {
2074     // store positions of elements on geometry
2075     Load();
2076     if ( meshDS->MaxNodeID()    > meshDS->NbNodes() ||
2077          meshDS->MaxElementID() > meshDS->NbElements() )
2078     {
2079       meshDS->Modified();
2080       meshDS->CompactMesh();
2081     }
2082     positions.resize( meshDS->NbNodes() + 1 );
2083     for ( SMDS_NodeIteratorPtr nodeIt = meshDS->nodesIterator(); nodeIt->more(); )
2084     {
2085       const SMDS_MeshNode* n = nodeIt->next();
2086       positions[ n->GetID() ] = n->GetPosition();
2087     }
2088
2089     // remove elements from sub-meshes to avoid their removal at hypotheses addition
2090     for ( int isNode = 0; isNode < 2; ++isNode )
2091     {
2092       std::vector< TRange > & ranges = isNode ? nodeRanges : elemRanges;
2093       ranges.reserve( meshDS->MaxShapeIndex() + 10 );
2094       ranges.push_back( TRange{ 0,0,0 });
2095       SMDS_ElemIteratorPtr elemIt = meshDS->elementsIterator( isNode ? SMDSAbs_Node : SMDSAbs_All );
2096       while ( elemIt->more() )
2097       {
2098         const SMDS_MeshElement* e = elemIt->next();
2099         const smIdType     elemID = e->GetID();
2100         const int         shapeID = e->GetShapeID();
2101         TRange &        lastRange = ranges.back();
2102         if ( lastRange.shapeID != shapeID ||
2103              lastRange.toID    != elemID )
2104           ranges.push_back( TRange{ shapeID, elemID, elemID + 1 });
2105         else
2106           lastRange.toID = elemID + 1;
2107
2108         if ( SMESHDS_SubMesh* sm = meshDS->MeshElements( shapeID ))
2109         {
2110           if ( isNode ) sm->RemoveNode( static_cast< const SMDS_MeshNode *>( e ));
2111           else          sm->RemoveElement( e );
2112         }
2113       }
2114     }
2115   }
2116
2117
2118   // update the reference to theNewGeom (needed for correct execution of a dumped python script)
2119   SMESH::SMESH_Mesh_var   me = _this();
2120   SALOMEDS::SObject_wrap aSO = _gen_i->ObjectToSObject( me );
2121   CORBA::String_var    entry = theNewGeom->GetStudyEntry();
2122   if ( !aSO->_is_nil() )
2123   {
2124     SALOMEDS::SObject_wrap aShapeRefSO;
2125     if ( aSO->FindSubObject( _gen_i->GetRefOnShapeTag(), aShapeRefSO.inout() ))
2126     {
2127       SALOMEDS::SObject_wrap    aShapeSO = _gen_i->getStudyServant()->FindObjectID( entry );
2128       SALOMEDS::StudyBuilder_var builder = _gen_i->getStudyServant()->NewBuilder();
2129       builder->Addreference( aShapeRefSO, aShapeSO );
2130     }
2131   }
2132
2133   // re-assign global hypotheses to the new shape
2134   _mainShapeTick = geomChanged ? -1 : theNewGeom->GetTick();
2135   CheckGeomModif( true );
2136
2137   if ( !geomChanged )
2138   {
2139     // restore positions of elements on geometry
2140     for ( int isNode = 0; isNode < 2; ++isNode )
2141     {
2142       std::vector< TRange > & ranges = isNode ? nodeRanges : elemRanges;
2143       for ( size_t i = 1; i < ranges.size(); ++i )
2144       {
2145         int elemID = ranges[ i ].fromID;
2146         int   toID = ranges[ i ].toID;
2147         SMESHDS_SubMesh * smDS = meshDS->NewSubMesh( ranges[ i ].shapeID );
2148         if ( isNode )
2149           for ( ; elemID < toID; ++elemID )
2150             smDS->AddNode( meshDS->FindNode( elemID ));
2151         else
2152           for ( ; elemID < toID; ++elemID )
2153             smDS->AddElement( meshDS->FindElement( elemID ));
2154
2155         if ( SMESH_subMesh* sm = _impl->GetSubMeshContaining( ranges[ i ].shapeID ))
2156           sm->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
2157       }
2158     }
2159     for ( unsigned int nodeID = 1; nodeID < positions.size(); ++nodeID )
2160       if ( positions[ nodeID ])
2161         if ( SMDS_MeshNode* n = const_cast< SMDS_MeshNode*>( meshDS->FindNode( nodeID )))
2162           n->SetPosition( positions[ nodeID ], n->GetShapeID() );
2163
2164     // restore icons
2165     _gen_i->UpdateIcons( SMESH::SMESH_Mesh_var( _this() ));
2166   }
2167
2168   TPythonDump() << "SHAPERSTUDY.breakLinkForSubElements(salome.ObjectToSObject("
2169                 << me <<".GetMesh()), " << entry.in() << ")";
2170
2171   TPythonDump() <<  me << ".ReplaceShape( " << entry.in() << " )";
2172
2173 }
2174
2175 //================================================================================
2176 /*!
2177  * \brief Return new group contents if it has been changed and update group data
2178  */
2179 //================================================================================
2180
2181 enum { ONLY_IF_CHANGED, IS_BREAK_LINK, MAIN_TRANSFORMED };
2182
2183 TopoDS_Shape SMESH_Mesh_i::newGroupShape( TGeomGroupData & groupData, int how )
2184 {
2185   TopoDS_Shape newShape;
2186   SALOMEDS::SObject_wrap groupSO;
2187
2188   if ( how == IS_BREAK_LINK )
2189   {
2190     SALOMEDS::SObject_wrap meshSO = _gen_i->ObjectToSObject( groupData._smeshObject );
2191     SALOMEDS::SObject_wrap geomRefSO;
2192     if ( !meshSO->_is_nil() &&
2193          meshSO->FindSubObject( SMESH::Tag_RefOnShape, geomRefSO.inout() ))
2194     {
2195       geomRefSO->ReferencedObject( groupSO.inout() );
2196     }
2197   }
2198   else
2199   {
2200     // get geom group
2201     groupSO = _gen_i->getStudyServant()->FindObjectID( groupData._groupEntry.c_str() );
2202   }
2203
2204   if ( groupSO->_is_nil() )
2205     return newShape;
2206
2207   CORBA::Object_var      groupObj = _gen_i->SObjectToObject( groupSO );
2208   GEOM::GEOM_Object_var geomGroup = GEOM::GEOM_Object::_narrow( groupObj );
2209   if ( geomGroup->_is_nil() )
2210     return newShape;
2211
2212   // get indices of group items
2213   set<int> curIndices;
2214   GEOM::GEOM_Gen_var               geomGen = _gen_i->GetGeomEngine( geomGroup );
2215   GEOM::GEOM_IGroupOperations_wrap groupOp = geomGen->GetIGroupOperations();
2216   GEOM::ListOfLong_var                 ids = groupOp->GetObjects( geomGroup );
2217   for ( CORBA::ULong i = 0; i < ids->length(); ++i )
2218     curIndices.insert( ids[i] );
2219
2220   bool sameIndices = ( groupData._indices == curIndices );
2221   if ( how == ONLY_IF_CHANGED && sameIndices )
2222     return newShape; // group not changed
2223
2224   // update data
2225   CORBA::String_var entry = geomGroup->GetStudyEntry();
2226   groupData._groupEntry = entry.in();
2227   groupData._indices = curIndices;
2228
2229   newShape = _gen_i->GeomObjectToShape( geomGroup );
2230
2231   // check if newShape is up-to-date
2232   if ( !newShape.IsNull() && ids->length() > 0 )
2233   {
2234     bool toUpdate = ! _impl->GetMeshDS()->IsGroupOfSubShapes( newShape );
2235     if ( !toUpdate )
2236     {
2237       TopExp_Explorer exp( newShape, (TopAbs_ShapeEnum)( groupOp->GetType( geomGroup )));
2238       for ( ; exp.More() && !toUpdate; exp.Next() )
2239       {
2240         int ind = _impl->GetMeshDS()->ShapeToIndex( exp.Current() );
2241         toUpdate = ( curIndices.erase( ind ) == 0 );
2242       }
2243       if ( !curIndices.empty() )
2244         toUpdate = true;
2245     }
2246     if ( toUpdate )
2247     {
2248       GEOM_Client*    geomClient = _gen_i->GetShapeReader();
2249       CORBA::String_var groupIOR = geomGen->GetStringFromIOR( geomGroup );
2250       geomClient->RemoveShapeFromBuffer( groupIOR.in() );
2251       newShape = _gen_i->GeomObjectToShape( geomGroup );
2252     }
2253   }
2254   else
2255   {
2256     // geom group becomes empty - return empty compound
2257     TopoDS_Compound compound;
2258     BRep_Builder().MakeCompound(compound);
2259     newShape = compound;
2260   }
2261
2262   return newShape;
2263 }
2264
2265 namespace
2266 {
2267   //-----------------------------------------------------------------------------
2268   /*!
2269    * \brief Storage of shape and index used in CheckGeomGroupModif()
2270    */
2271   struct TIndexedShape
2272   {
2273     int          _index;
2274     TopoDS_Shape _shape;
2275     TIndexedShape( int i, const TopoDS_Shape& s ):_index(i), _shape(s) {}
2276   };
2277   //-----------------------------------------------------------------------------
2278   /*!
2279    * \brief Data to re-create a group on geometry
2280    */
2281   struct TGroupOnGeomData
2282   {
2283     int                 _oldID;
2284     TopoDS_Shape        _shape;
2285     SMDSAbs_ElementType _type;
2286     std::string         _name;
2287     Quantity_Color      _color;
2288
2289     TGroupOnGeomData( const SMESHDS_GroupOnGeom* group )
2290     {
2291       _oldID = group->GetID();
2292       _type  = group->GetType();
2293       _name  = group->GetStoreName();
2294       _color = group->GetColor();
2295     }
2296   };
2297
2298   //-----------------------------------------------------------------------------
2299   /*!
2300    * \brief Check if a filter is still valid after geometry removal
2301    */
2302   bool isValidGeomFilter( SMESH::Filter_var theFilter )
2303   {
2304     if ( theFilter->_is_nil() )
2305       return false;
2306     SMESH::Filter::Criteria_var criteria;
2307     theFilter->GetCriteria( criteria.out() );
2308
2309     for ( CORBA::ULong iCr = 0; iCr < criteria->length(); ++iCr )
2310     {
2311       const char* thresholdID = criteria[ iCr ].ThresholdID.in();
2312       std::string entry;
2313       switch ( criteria[ iCr ].Type )
2314       {
2315       case SMESH::FT_BelongToGeom:
2316       case SMESH::FT_BelongToPlane:
2317       case SMESH::FT_BelongToCylinder:
2318       case SMESH::FT_BelongToGenSurface:
2319       case SMESH::FT_LyingOnGeom:
2320         entry = thresholdID;
2321         break;
2322       case SMESH::FT_ConnectedElements:
2323         if ( thresholdID )
2324         {
2325           entry = thresholdID;
2326           break;
2327         }
2328       default:
2329         continue;
2330       }
2331       SMESH_Gen_i*           gen = SMESH_Gen_i::GetSMESHGen();
2332       SALOMEDS::SObject_wrap  so = gen->getStudyServant()->FindObjectID( entry.c_str() );
2333       if ( so->_is_nil() )
2334         return false;
2335       CORBA::Object_var      obj = so->GetObject();
2336       GEOM::GEOM_Object_var geom = GEOM::GEOM_Object::_narrow( obj );
2337       if ( gen->GeomObjectToShape( geom ).IsNull() )
2338         return false;
2339
2340     } // loop on criteria
2341
2342     return true;
2343   }
2344 }
2345
2346 //=============================================================================
2347 /*!
2348  * \brief Update data if geometry changes
2349  *
2350  * Issue 0022501
2351  */
2352 //=============================================================================
2353
2354 void SMESH_Mesh_i::CheckGeomModif( bool theIsBreakLink )
2355 {
2356   SMESH::SMESH_Mesh_var me = _this();
2357   GEOM::GEOM_Object_var mainGO = GetShapeToMesh();
2358
2359   TPythonDump dumpNothing; // prevent any dump
2360
2361   //bool removedFromClient = false;
2362
2363   if ( mainGO->_is_nil() ) // GEOM_Client cleared or geometry removed? (IPAL52735, PAL23636)
2364   {
2365     //removedFromClient = _impl->HasShapeToMesh();
2366
2367     // try to find geometry by study reference
2368     SALOMEDS::SObject_wrap meshSO = _gen_i->ObjectToSObject( me );
2369     SALOMEDS::SObject_wrap geomRefSO, geomSO;
2370     if ( !meshSO->_is_nil() &&
2371          meshSO->FindSubObject( SMESH::Tag_RefOnShape, geomRefSO.inout() ) &&
2372          geomRefSO->ReferencedObject( geomSO.inout() ))
2373     {
2374       CORBA::Object_var geomObj = _gen_i->SObjectToObject( geomSO );
2375       mainGO = GEOM::GEOM_Object::_narrow( geomObj );
2376     }
2377
2378     if ( mainGO->_is_nil() &&    // geometry removed ==>
2379          !geomRefSO->_is_nil() ) // remove geom dependent data: sub-meshes etc.
2380     {
2381       // convert geom dependent groups into standalone ones
2382       CheckGeomGroupModif();
2383
2384       _impl->ShapeToMesh( TopoDS_Shape() );
2385
2386       // remove sub-meshes
2387       std::map<int, SMESH::SMESH_subMesh_ptr>::iterator i_sm = _mapSubMeshIor.begin();
2388       while ( i_sm != _mapSubMeshIor.end() )
2389       {
2390         SMESH::SMESH_subMesh_ptr sm = i_sm->second;
2391         ++i_sm;
2392         RemoveSubMesh( sm );
2393       }
2394       // remove all children except groups in the study
2395       SALOMEDS::StudyBuilder_var builder = _gen_i->getStudyServant()->NewBuilder();
2396       SALOMEDS::SObject_wrap so;
2397       for ( CORBA::Long tag = SMESH::Tag_RefOnShape; tag <= SMESH::Tag_LastSubMesh; ++tag )
2398         if ( meshSO->FindSubObject( tag, so.inout() ))
2399           builder->RemoveObjectWithChildren( so );
2400
2401       _gen_i->SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED" );
2402
2403       return;
2404     }
2405   }
2406
2407   if ( !_impl->HasShapeToMesh() ) return;
2408
2409
2410   // Update after group modification
2411
2412   const bool geomChanged = ( mainGO->GetTick() != _mainShapeTick );
2413   if ( !theIsBreakLink )
2414     if ( mainGO->GetType() == GEOM_GROUP || !geomChanged )  // is group or not modified
2415     {
2416       smIdType nb = NbNodes() + NbElements();
2417       CheckGeomGroupModif();
2418       if ( nb != NbNodes() + NbElements() ) // something removed due to hypotheses change
2419         _gen_i->UpdateIcons( me );
2420       return;
2421     }
2422
2423   // Update after shape modification or breakLink w/o geometry change
2424
2425   GEOM_Client* geomClient = _gen_i->GetShapeReader();
2426   if ( !geomClient ) return;
2427   GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine( mainGO );
2428   if ( geomGen->_is_nil() ) return;
2429   CORBA::String_var geomComponentType = geomGen->ComponentDataType();
2430   bool isShaper = ( strcmp( geomComponentType.in(), "SHAPERSTUDY" ) == 0 );
2431
2432   SMESHDS_Mesh * meshDS = _impl->GetMeshDS();
2433
2434   TopoDS_Shape newShape = _gen_i->GeomObjectToShape( mainGO );
2435   if ( meshDS->ShapeToIndex( newShape ) == 1 ) // not yet updated
2436   {
2437     CORBA::String_var ior = geomGen->GetStringFromIOR( mainGO );
2438     geomClient->RemoveShapeFromBuffer( ior.in() );
2439     newShape = _gen_i->GeomObjectToShape( mainGO );
2440   }
2441
2442   // Update data taking into account that if topology doesn't change
2443   // all sub-shapes change but IDs of sub-shapes remain (except for geom groups)
2444
2445   if ( _preMeshInfo )
2446     _preMeshInfo->ForgetAllData();
2447
2448   if ( geomChanged || !isShaper )
2449     _impl->Clear();
2450   if ( newShape.IsNull() )
2451     return;
2452
2453   _mainShapeTick = mainGO->GetTick();
2454
2455   // store data of groups on geometry including new TopoDS_Shape's
2456   std::vector< TGroupOnGeomData > groupsData;
2457   const std::set<SMESHDS_GroupBase*>& groups = meshDS->GetGroups();
2458   groupsData.reserve( groups.size() );
2459   TopTools_DataMapOfShapeShape old2newShapeMap;
2460   std::set<SMESHDS_GroupBase*>::const_iterator g = groups.begin();
2461   for ( ; g != groups.end(); ++g )
2462   {
2463     if ( const SMESHDS_GroupOnGeom* group = dynamic_cast< SMESHDS_GroupOnGeom* >( *g ))
2464     {
2465       groupsData.push_back( TGroupOnGeomData( group ));
2466
2467       // get a new shape
2468       SMESH::SMESH_GroupOnGeom_var gog;
2469       std::map<int, SMESH::SMESH_GroupBase_ptr>::iterator i_grp = _mapGroups.find( group->GetID() );
2470       if ( i_grp != _mapGroups.end() )
2471         gog = SMESH::SMESH_GroupOnGeom::_narrow( i_grp->second );
2472
2473       GEOM::GEOM_Object_var geom;
2474       if ( !gog->_is_nil() )
2475       {
2476         if ( !theIsBreakLink )
2477           geom = gog->GetShape();
2478
2479         if ( theIsBreakLink || geom->_is_nil() )
2480         {
2481           SALOMEDS::SObject_wrap grpSO = _gen_i->ObjectToSObject( gog );
2482           SALOMEDS::SObject_wrap geomRefSO, geomSO;
2483           if ( !grpSO->_is_nil() &&
2484                grpSO->FindSubObject( SMESH::Tag_RefOnShape, geomRefSO.inout() ) &&
2485                geomRefSO->ReferencedObject( geomSO.inout() ))
2486           {
2487             CORBA::Object_var geomObj = _gen_i->SObjectToObject( geomSO );
2488             geom = GEOM::GEOM_Object::_narrow( geomObj );
2489           }
2490         }
2491       }
2492       if ( old2newShapeMap.IsBound( group->GetShape() ))
2493       {
2494         groupsData.back()._shape = old2newShapeMap( group->GetShape() );
2495       }
2496       else if ( !geom->_is_nil() )
2497       {
2498         groupsData.back()._shape = _gen_i->GeomObjectToShape( geom );
2499         if ( meshDS->IsGroupOfSubShapes( groupsData.back()._shape ))
2500         {
2501           CORBA::String_var ior = geomGen->GetStringFromIOR( geom );
2502           geomClient->RemoveShapeFromBuffer( ior.in() );
2503           groupsData.back()._shape = _gen_i->GeomObjectToShape( geom );
2504         }
2505         old2newShapeMap.Bind( group->GetShape(), groupsData.back()._shape );
2506       }
2507       
2508     }
2509   }
2510   // store assigned hypotheses
2511   std::vector< pair< int, THypList > > ids2Hyps;
2512   const ShapeToHypothesis & hyps = meshDS->GetHypotheses();
2513   for ( ShapeToHypothesis::Iterator s2hyps( hyps ); s2hyps.More(); s2hyps.Next() )
2514   {
2515     const TopoDS_Shape& s = s2hyps.Key();
2516     const THypList&  hyps = s2hyps.ChangeValue();
2517     ids2Hyps.push_back( make_pair( meshDS->ShapeToIndex( s ), hyps ));
2518   }
2519
2520   std::multimap< std::set<int>, int > ii2iMap; // group sub-ids to group id in SMESHDS
2521
2522   // count shapes excluding compounds corresponding to geom groups
2523   int oldNbSubShapes = meshDS->MaxShapeIndex();
2524   for ( ; oldNbSubShapes > 0; --oldNbSubShapes )
2525   {
2526     const TopoDS_Shape& s = meshDS->IndexToShape( oldNbSubShapes );
2527     if ( s.IsNull() || s.ShapeType() != TopAbs_COMPOUND )
2528       break;
2529     // fill ii2iMap
2530     std::set<int> subIds;
2531     for ( TopoDS_Iterator it( s ); it.More(); it.Next() )
2532       subIds.insert( meshDS->ShapeToIndex( it.Value() ));
2533     ii2iMap.insert( std::make_pair( subIds, oldNbSubShapes ));
2534   }
2535
2536   // check if shape topology changes - save shape type per shape ID
2537   std::vector< TopAbs_ShapeEnum > shapeTypes( Max( oldNbSubShapes + 1, 1 ));
2538   for ( int shapeID = oldNbSubShapes; shapeID > 0; --shapeID )
2539     shapeTypes[ shapeID ] = meshDS->IndexToShape( shapeID ).ShapeType();
2540
2541   // change shape to mesh
2542   _impl->ShapeToMesh( TopoDS_Shape() );
2543   _impl->ShapeToMesh( newShape );
2544
2545   // check if shape topology changes - check new shape types
2546   bool sameTopology = ( oldNbSubShapes == meshDS->MaxShapeIndex() );
2547   for ( int shapeID = oldNbSubShapes; shapeID > 0 &&  sameTopology; --shapeID )
2548   {
2549     const TopoDS_Shape& s = meshDS->IndexToShape( shapeID );
2550     sameTopology = ( !s.IsNull() && s.ShapeType() == shapeTypes[ shapeID ]);
2551   }
2552
2553   // re-add shapes (compounds) of geom groups
2554   typedef std::map< std::vector< int >, TGeomGroupData* > TIndices2GroupData;
2555   TIndices2GroupData ii2grData;
2556   std::vector< int > ii;
2557   std::map< int, int > old2newIDs; // group IDs
2558   std::list<TGeomGroupData>::iterator dataIt = _geomGroupData.begin();
2559   for ( ; dataIt != _geomGroupData.end(); ++dataIt )
2560   {
2561     TGeomGroupData* data = &(*dataIt);
2562     ii.reserve( data->_indices.size() );
2563     ii.assign( data->_indices.begin(), data->_indices.end() );
2564     TIndices2GroupData::iterator ii2gd = ii2grData.insert( std::make_pair( ii, data )).first;
2565     if ( ii2gd->second != data )
2566     {
2567       data->_groupEntry = ii2gd->second->_groupEntry;
2568       data->_indices    = ii2gd->second->_indices;
2569       continue;
2570     }
2571     const int  oldNbSub = data->_indices.size();
2572     const int soleOldID = oldNbSub == 1 ? *data->_indices.begin() : 0;
2573     int oldID = 0;
2574     std::multimap< std::set<int>, int >::iterator ii2i = ii2iMap.find( data->_indices );
2575     if ( ii2i != ii2iMap.end() )
2576     {
2577       oldID = ii2i->second;
2578       ii2iMap.erase( ii2i );
2579     }
2580     if ( !oldID && oldNbSub == 1 )
2581       oldID = soleOldID;
2582     if ( old2newIDs.count( oldID ))
2583       continue;
2584
2585     int how = ( theIsBreakLink || !sameTopology ) ? IS_BREAK_LINK : MAIN_TRANSFORMED;
2586     newShape = newGroupShape( *data, how );
2587
2588     if ( !newShape.IsNull() )
2589     {
2590       if ( oldNbSub > 1 && meshDS->ShapeToIndex( newShape ) > 0 ) // group reduced to one sub-shape
2591       {
2592         TopoDS_Compound compound;
2593         BRep_Builder().MakeCompound( compound );
2594         BRep_Builder().Add( compound, newShape );
2595         newShape = compound;
2596       }
2597       int newID = _impl->GetSubMesh( newShape )->GetId();
2598       if ( oldID /*&& oldID != newID*/ )
2599         old2newIDs.insert( std::make_pair( oldID, newID ));
2600       if ( oldNbSub == 1 )
2601         old2newIDs.insert( std::make_pair( soleOldID, newID ));
2602     }
2603   }
2604
2605   // re-assign hypotheses
2606   for ( size_t i = 0; i < ids2Hyps.size(); ++i )
2607   {
2608     int sID = ids2Hyps[i].first;
2609     if ( sID != 1 )
2610     {
2611       std::map< int, int >::iterator o2n = old2newIDs.find( sID );
2612       if ( o2n != old2newIDs.end() )
2613         sID = o2n->second;
2614       else if ( !sameTopology )
2615         continue;
2616     }
2617     const TopoDS_Shape& s = meshDS->IndexToShape( sID );
2618     if ( s.IsNull() )
2619       continue;
2620     const THypList& hyps = ids2Hyps[i].second;
2621     THypList::const_iterator h = hyps.begin();
2622     for ( ; h != hyps.end(); ++h )
2623       _impl->AddHypothesis( s, (*h)->GetID() );
2624   }
2625
2626   {
2627     // restore groups on geometry
2628     for ( size_t i = 0; i < groupsData.size(); ++i )
2629     {
2630       const TGroupOnGeomData& data = groupsData[i];
2631       if ( data._shape.IsNull() )
2632         continue;
2633
2634       std::map<int, SMESH::SMESH_GroupBase_ptr>::iterator i2g = _mapGroups.find( data._oldID );
2635       if ( i2g == _mapGroups.end() ) continue;
2636
2637       SMESH_GroupBase_i* gr_i = SMESH::DownCast<SMESH_GroupBase_i*>( i2g->second );
2638       if ( !gr_i ) continue;
2639
2640       SMESH_Group* g = _impl->AddGroup( data._type, data._name.c_str(), data._oldID, data._shape );
2641       if ( !g )
2642         _mapGroups.erase( i2g );
2643       else
2644         g->GetGroupDS()->SetColor( data._color );
2645     }
2646
2647     if ( !sameTopology )
2648     {
2649       std::map< int, int >::iterator o2n = old2newIDs.begin();
2650       for ( ; o2n != old2newIDs.end(); ++o2n )
2651       {
2652         int newID = o2n->second, oldID = o2n->first;
2653         if ( newID == oldID || !_mapSubMesh.count( oldID ))
2654           continue;
2655         if ( newID > 0 )
2656         {
2657           _mapSubMesh   [ newID ] = _impl->GetSubMeshContaining( newID );
2658           _mapSubMesh_i [ newID ] = _mapSubMesh_i [ oldID ];
2659           _mapSubMeshIor[ newID ] = _mapSubMeshIor[ oldID ];
2660         }
2661         _mapSubMesh.   erase(oldID);
2662         _mapSubMesh_i. erase(oldID);
2663         _mapSubMeshIor.erase(oldID);
2664         if ( newID > 0 )
2665           _mapSubMesh_i [ newID ]->changeLocalId( newID );
2666       }
2667     }
2668
2669     // update _mapSubMesh
2670     std::map<int, ::SMESH_subMesh*>::iterator i_sm = _mapSubMesh.begin();
2671     for ( ; i_sm != _mapSubMesh.end(); ++i_sm )
2672       i_sm->second = _impl->GetSubMesh( meshDS->IndexToShape( i_sm->first ));
2673   }
2674
2675   if ( !sameTopology )
2676   {
2677     // remove invalid study sub-objects
2678     CheckGeomGroupModif();
2679   }
2680
2681   _gen_i->UpdateIcons( me );
2682
2683   if ( !theIsBreakLink && isShaper )
2684   {
2685     SALOMEDS::SObject_wrap meshSO = _gen_i->ObjectToSObject( me );
2686     if ( !meshSO->_is_nil() )
2687       _gen_i->SetPixMap(meshSO, "ICON_SMESH_TREE_GEOM_MODIF");
2688   }
2689 }
2690
2691 //=============================================================================
2692 /*!
2693  * \brief Update objects depending on changed geom groups
2694  *
2695  * NPAL16168: geometrical group edition from a submesh don't modify mesh computation
2696  * issue 0020210: Update of a smesh group after modification of the associated geom group
2697  */
2698 //=============================================================================
2699
2700 void SMESH_Mesh_i::CheckGeomGroupModif()
2701 {
2702   // remove sub-meshes referring a removed sub-shapes (if main shape still exists)
2703   SALOMEDS::StudyBuilder_var builder = _gen_i->getStudyServant()->NewBuilder();
2704   GEOM::GEOM_Object_var  mainGO = GetShapeToMesh();
2705   SALOMEDS::SObject_wrap meshSO = _gen_i->ObjectToSObject( SMESH::SMESH_Mesh_var( _this() ));
2706   if ( !mainGO->_is_nil() && !meshSO->_is_nil() )
2707   {
2708     SALOMEDS::SObject_wrap rootSO, geomRefSO, geomSO;
2709     for ( CORBA::Long tag = SMESH::Tag_FirstSubMesh; tag <= SMESH::Tag_LastSubMesh; ++tag )
2710       if ( meshSO->FindSubObject( tag, rootSO.inout() ))
2711       {
2712         int nbValid = 0, nbRemoved = 0;
2713         SALOMEDS::ChildIterator_wrap chItr = _gen_i->getStudyServant()->NewChildIterator( rootSO );
2714         for ( ; chItr->More(); chItr->Next() )
2715         {
2716           SALOMEDS::SObject_wrap smSO = chItr->Value(); // sub-mesh SO
2717           if ( !smSO->_is_nil() &&
2718                smSO->FindSubObject( SMESH::Tag_RefOnShape, geomRefSO.inout() ) &&
2719                geomRefSO->ReferencedObject( geomSO.inout() )) // find geometry by reference
2720           {
2721             CORBA::Object_var  geomObj = _gen_i->SObjectToObject( geomSO );
2722             GEOM::GEOM_Object_var geom = GEOM::GEOM_Object::_narrow( geomObj );
2723             if ( !geom->_non_existent() )
2724             {
2725               ++nbValid;
2726               continue; // keep the sub-mesh
2727             }
2728           }
2729           CORBA::Object_var     smObj = _gen_i->SObjectToObject( smSO );
2730           SMESH::SMESH_subMesh_var sm = SMESH::SMESH_subMesh::_narrow( smObj );
2731           if ( !sm->_is_nil() && !sm->_non_existent() )
2732           {
2733             GEOM::GEOM_Object_var smGeom = sm->GetSubShape();
2734             if ( smGeom->_is_nil() )
2735             {
2736               RemoveSubMesh( sm );
2737               ++nbRemoved;
2738             }
2739           }
2740           else
2741           {
2742             if ( _preMeshInfo )
2743               _preMeshInfo->ForgetAllData(); // unknown hypothesis modified
2744             builder->RemoveObjectWithChildren( smSO ); // sub-shape removed before loading SMESH
2745             ++nbRemoved;
2746           }
2747         }
2748         if ( /*nbRemoved > 0 &&*/ nbValid == 0 )
2749           builder->RemoveObjectWithChildren( rootSO );
2750       }
2751   }
2752
2753   // check for removed sub-shapes and convert geom dependent groups into standalone ones
2754   std::map<int, SMESH::SMESH_GroupBase_ptr>::iterator i_gr = _mapGroups.begin();
2755   while ( i_gr != _mapGroups.end())
2756   {
2757     SMESH::SMESH_GroupBase_ptr group = i_gr->second;
2758     ++i_gr;
2759     SALOMEDS::SObject_wrap        groupSO = _gen_i->ObjectToSObject( group ), refSO, geomSO;
2760     SMESH::SMESH_GroupOnGeom_var   onGeom = SMESH::SMESH_GroupOnGeom::_narrow  ( group );
2761     SMESH::SMESH_GroupOnFilter_var onFilt = SMESH::SMESH_GroupOnFilter::_narrow( group );
2762     bool isValidGeom = false;
2763     if ( !onGeom->_is_nil() )
2764     {
2765       isValidGeom = ( ! GEOM::GEOM_Object_var( onGeom->GetShape() )->_is_nil() ); // check TopoDS
2766       if ( !isValidGeom ) // check reference
2767       {
2768         isValidGeom = ( ! groupSO->_is_nil() &&
2769                         groupSO->FindSubObject( SMESH::Tag_RefOnShape, refSO.inout() ) &&
2770                         refSO->ReferencedObject( geomSO.inout() ) &&
2771                         ! geomSO->_is_nil() &&
2772                         !CORBA::is_nil( CORBA::Object_var( geomSO->GetObject() )));
2773       }
2774     }
2775     else if ( !onFilt->_is_nil() )
2776     {
2777       isValidGeom = isValidGeomFilter( onFilt->GetFilter() );
2778     }
2779     else // standalone
2780     {
2781       isValidGeom = ( !groupSO->_is_nil() &&
2782                       !groupSO->FindSubObject( SMESH::Tag_RefOnShape, refSO.inout() ));
2783     }
2784     if ( !isValidGeom )
2785     {
2786       if ( !IsLoaded() || group->IsEmpty() )
2787       {
2788         RemoveGroup( group );
2789       }
2790       else if ( !onGeom->_is_nil() || !onFilt->_is_nil() )
2791       {
2792         SMESH::SMESH_Group_var ( ConvertToStandalone( group ));
2793       }
2794       else // is it possible?
2795       {
2796         builder->RemoveObjectWithChildren( refSO );
2797       }
2798     }
2799   }
2800
2801
2802   if ( !_impl->HasShapeToMesh() ) return;
2803
2804   SMESH::smIdType nbEntities = NbNodes() + NbElements();
2805
2806   // Check if group contents changed
2807
2808   typedef map< string, TopoDS_Shape > TEntry2Geom;
2809   TEntry2Geom newGroupContents;
2810
2811   list<TGeomGroupData>::iterator
2812     data = _geomGroupData.begin(), dataEnd = _geomGroupData.end();
2813   for ( ; data != dataEnd; ++data )
2814   {
2815     pair< TEntry2Geom::iterator, bool > it_new =
2816       newGroupContents.insert( make_pair( data->_groupEntry, TopoDS_Shape() ));
2817     bool processedGroup    = !it_new.second;
2818     TopoDS_Shape& newShape = it_new.first->second;
2819     if ( !processedGroup )
2820       newShape = newGroupShape( *data, ONLY_IF_CHANGED );
2821     if ( newShape.IsNull() )
2822       continue; // no changes
2823
2824     if ( _preMeshInfo )
2825       _preMeshInfo->ForgetOrLoad();
2826
2827     if ( processedGroup ) { // update group indices
2828       list<TGeomGroupData>::iterator data2 = data;
2829       for ( --data2; data2->_groupEntry != data->_groupEntry; --data2) {}
2830       data->_indices = data2->_indices;
2831     }
2832
2833     // Update SMESH objects according to new GEOM group contents
2834
2835     SMESH::SMESH_subMesh_var submesh = SMESH::SMESH_subMesh::_narrow( data->_smeshObject );
2836     if ( !submesh->_is_nil() ) // -------------- Sub mesh ---------------------
2837     {
2838       int oldID = submesh->GetId();
2839       if ( !_mapSubMeshIor.count( oldID ))
2840         continue;
2841       TopoDS_Shape oldShape = _mapSubMesh[oldID]->GetSubShape();
2842
2843       // update hypotheses
2844       list <const SMESHDS_Hypothesis * > hyps = _impl->GetHypothesisList(oldShape);
2845       list <const SMESHDS_Hypothesis * >::iterator hypIt;
2846       for ( hypIt = hyps.begin(); hypIt != hyps.end(); ++hypIt )
2847       {
2848         _impl->RemoveHypothesis( oldShape, (*hypIt)->GetID());
2849         _impl->AddHypothesis   ( newShape, (*hypIt)->GetID());
2850       }
2851       // care of submeshes
2852       SMESH_subMesh* newSubmesh = _impl->GetSubMesh( newShape );
2853       int newID = newSubmesh->GetId();
2854       if ( newID != oldID ) {
2855         _mapSubMesh   [ newID ] = newSubmesh;
2856         _mapSubMesh_i [ newID ] = _mapSubMesh_i [ oldID ];
2857         _mapSubMeshIor[ newID ] = _mapSubMeshIor[ oldID ];
2858         _mapSubMesh.   erase(oldID);
2859         _mapSubMesh_i. erase(oldID);
2860         _mapSubMeshIor.erase(oldID);
2861         _mapSubMesh_i [ newID ]->changeLocalId( newID );
2862       }
2863       continue;
2864     }
2865
2866     SMESH::SMESH_GroupOnGeom_var smeshGroup =
2867       SMESH::SMESH_GroupOnGeom::_narrow( data->_smeshObject );
2868     if ( !smeshGroup->_is_nil() ) // ------------ GROUP -----------------------
2869     {
2870       SMESH_GroupOnGeom_i* group_i = SMESH::DownCast<SMESH_GroupOnGeom_i*>( smeshGroup );
2871       if ( group_i ) {
2872         ::SMESH_Group* group = _impl->GetGroup( group_i->GetLocalID() );
2873         SMESHDS_GroupOnGeom* ds = static_cast<SMESHDS_GroupOnGeom*>( group->GetGroupDS() );
2874         ds->SetShape( newShape );
2875       }
2876       continue;
2877     }
2878
2879     SMESH::SMESH_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow( data->_smeshObject );
2880     if ( !mesh->_is_nil() ) // -------------- MESH ----------------------------
2881     {
2882       // Remove groups and submeshes basing on removed sub-shapes
2883
2884       TopTools_MapOfShape newShapeMap;
2885       TopoDS_Iterator shapeIt( newShape );
2886       for ( ; shapeIt.More(); shapeIt.Next() )
2887         newShapeMap.Add( shapeIt.Value() );
2888
2889       SMESHDS_Mesh* meshDS = _impl->GetMeshDS();
2890       for ( shapeIt.Initialize( meshDS->ShapeToMesh() ); shapeIt.More(); shapeIt.Next() )
2891       {
2892         if ( newShapeMap.Contains( shapeIt.Value() ))
2893           continue;
2894         TopTools_IndexedMapOfShape oldShapeMap;
2895         TopExp::MapShapes( shapeIt.Value(), oldShapeMap );
2896         for ( int i = 1; i <= oldShapeMap.Extent(); ++i )
2897         {
2898           const TopoDS_Shape& oldShape = oldShapeMap(i);
2899           int oldInd = meshDS->ShapeToIndex( oldShape );
2900           // -- submeshes --
2901           map<int, SMESH::SMESH_subMesh_ptr>::iterator i_smIor = _mapSubMeshIor.find( oldInd );
2902           if ( i_smIor != _mapSubMeshIor.end() ) {
2903             RemoveSubMesh( i_smIor->second ); // one submesh per shape index
2904           }
2905           // --- groups ---
2906           map<int, SMESH::SMESH_GroupBase_ptr>::iterator i_grp = _mapGroups.begin();
2907           for ( ; i_grp != _mapGroups.end(); ++i_grp )
2908           {
2909             // check if a group bases on oldInd shape
2910             SMESHDS_GroupOnGeom* grpOnGeom = 0;
2911             if ( ::SMESH_Group* g = _impl->GetGroup( i_grp->first ))
2912               grpOnGeom = dynamic_cast<SMESHDS_GroupOnGeom*>( g->GetGroupDS() );
2913             if ( grpOnGeom && oldShape.IsSame( grpOnGeom->GetShape() ))
2914             { // remove
2915               RemoveGroup( i_grp->second ); // several groups can base on same shape
2916               i_grp = _mapGroups.begin(); // _mapGroups changed - restart iteration
2917             }
2918           }
2919         }
2920       }
2921       // Reassign hypotheses and update groups after setting the new shape to mesh
2922
2923       // collect anassigned hypotheses
2924       typedef list< pair< TIndexedShape, list<const SMESHDS_Hypothesis*> > > TShapeHypList;
2925       list <const SMESHDS_Hypothesis * >::const_iterator hypIt;
2926       TShapeHypList assignedHyps;
2927       for ( int i = 1; i <= meshDS->MaxShapeIndex(); ++i )
2928       {
2929         const TopoDS_Shape& oldShape = meshDS->IndexToShape(i);
2930         list<const SMESHDS_Hypothesis*> hyps = meshDS->GetHypothesis( oldShape );// copy
2931         if ( !hyps.empty() ) {
2932           assignedHyps.push_back( make_pair( TIndexedShape(i,oldShape), hyps ));
2933           for ( hypIt = hyps.begin(); hypIt != hyps.end(); ++hypIt )
2934             _impl->RemoveHypothesis( oldShape, (*hypIt)->GetID());
2935         }
2936       }
2937       // collect shapes supporting groups
2938       typedef list < pair< TIndexedShape, SMDSAbs_ElementType > > TShapeTypeList;
2939       TShapeTypeList groupData;
2940       const set<SMESHDS_GroupBase*>& groups = meshDS->GetGroups();
2941       set<SMESHDS_GroupBase*>::const_iterator grIt = groups.begin();
2942       for ( ; grIt != groups.end(); ++grIt )
2943       {
2944         if ( SMESHDS_GroupOnGeom* gog = dynamic_cast<SMESHDS_GroupOnGeom*>( *grIt ))
2945           groupData.push_back
2946             ( make_pair( TIndexedShape( gog->GetID(),gog->GetShape()), gog->GetType()));
2947       }
2948       // set new shape to mesh -> DS of sub-meshes and geom groups is deleted
2949       _impl->Clear();
2950       _impl->ShapeToMesh( TopoDS_Shape() ); // IPAL52730
2951       _impl->ShapeToMesh( newShape );
2952
2953       // reassign hypotheses
2954       TShapeHypList::iterator indS_hyps = assignedHyps.begin();
2955       for ( ; indS_hyps != assignedHyps.end(); ++indS_hyps )
2956       {
2957         TIndexedShape&                   geom = indS_hyps->first;
2958         list<const SMESHDS_Hypothesis*>& hyps = indS_hyps->second;
2959         int oldID = geom._index;
2960         int newID = meshDS->ShapeToIndex( geom._shape );
2961         if ( oldID == 1 ) { // main shape
2962           newID = 1;
2963           geom._shape = newShape;
2964         }
2965         if ( !newID )
2966           continue;
2967         for ( hypIt = hyps.begin(); hypIt != hyps.end(); ++hypIt )
2968           _impl->AddHypothesis( geom._shape, (*hypIt)->GetID());
2969         // care of sub-meshes
2970         SMESH_subMesh* newSubmesh = _impl->GetSubMesh( geom._shape );
2971         if ( newID != oldID ) {
2972           _mapSubMesh   [ newID ] = newSubmesh;
2973           _mapSubMesh_i [ newID ] = _mapSubMesh_i [ oldID ];
2974           _mapSubMeshIor[ newID ] = _mapSubMeshIor[ oldID ];
2975           _mapSubMesh.   erase(oldID);
2976           _mapSubMesh_i. erase(oldID);
2977           _mapSubMeshIor.erase(oldID);
2978           _mapSubMesh_i [ newID ]->changeLocalId( newID );
2979         }
2980       }
2981       // recreate groups
2982       TShapeTypeList::iterator geomType = groupData.begin();
2983       for ( ; geomType != groupData.end(); ++geomType )
2984       {
2985         const TIndexedShape& geom = geomType->first;
2986         int oldID = geom._index;
2987         if ( _mapGroups.find( oldID ) == _mapGroups.end() )
2988           continue;
2989         // get group name
2990         SALOMEDS::SObject_wrap groupSO = _gen_i->ObjectToSObject( _mapGroups[oldID] );
2991         CORBA::String_var      name    = groupSO->GetName();
2992         // update
2993         if ( SMESH_GroupBase_i* group_i = SMESH::DownCast<SMESH_GroupBase_i*>(_mapGroups[oldID]))
2994           if ( SMESH_Group* group = _impl->AddGroup( geomType->second, name.in(),
2995                                                      /*id=*/-1, geom._shape ))
2996             group_i->changeLocalId( group->GetID() );
2997       }
2998
2999       break; // everything has been updated
3000
3001     } // update mesh
3002   } // loop on group data
3003
3004   // Update icons
3005
3006   SMESH::smIdType newNbEntities = NbNodes() + NbElements();
3007   list< SALOMEDS::SObject_wrap > soToUpdateIcons;
3008   if ( newNbEntities != nbEntities )
3009   {
3010     // Add all SObjects with icons to soToUpdateIcons
3011     soToUpdateIcons.push_back( _gen_i->ObjectToSObject( _this() )); // mesh
3012
3013     for (map<int, SMESH::SMESH_subMesh_ptr>::iterator i_sm = _mapSubMeshIor.begin();
3014          i_sm != _mapSubMeshIor.end(); ++i_sm ) // submeshes
3015       soToUpdateIcons.push_back( _gen_i->ObjectToSObject( i_sm->second ));
3016
3017     for ( map<int, SMESH::SMESH_GroupBase_ptr>::iterator i_gr = _mapGroups.begin();
3018           i_gr != _mapGroups.end(); ++i_gr ) // groups
3019       soToUpdateIcons.push_back( _gen_i->ObjectToSObject( i_gr->second ));
3020   }
3021
3022   list< SALOMEDS::SObject_wrap >::iterator so = soToUpdateIcons.begin();
3023   for ( ; so != soToUpdateIcons.end(); ++so )
3024     _gen_i->SetPixMap( *so, "ICON_SMESH_TREE_MESH_WARN" );
3025 }
3026
3027 //=============================================================================
3028 /*!
3029  * \brief Create standalone group from a group on geometry or filter
3030  */
3031 //=============================================================================
3032
3033 SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroup )
3034 {
3035   SMESH::SMESH_Group_var aGroup;
3036
3037   SMESH_TRY;
3038
3039   if ( _preMeshInfo )
3040     _preMeshInfo->FullLoadFromFile();
3041
3042   if ( theGroup->_is_nil() )
3043     return aGroup._retn();
3044
3045   SMESH_GroupBase_i* aGroupToRem = SMESH::DownCast<SMESH_GroupBase_i*>( theGroup );
3046   if ( !aGroupToRem )
3047     return aGroup._retn();
3048
3049   const bool isOnFilter = ( SMESH::DownCast< SMESH_GroupOnFilter_i* > ( theGroup ));
3050
3051   const int anId = aGroupToRem->GetLocalID();
3052   if ( !_impl->ConvertToStandalone( anId ) )
3053     return aGroup._retn();
3054   removeGeomGroupData( theGroup );
3055
3056   SMESH_GroupBase_i* aGroupImpl = new SMESH_Group_i( SMESH_Gen_i::GetPOA(), this, anId );
3057
3058   // remove old instance of group from own map
3059   { SMESH::SMESH_GroupBase_var var( _mapGroups[anId] ); } // decref CORBA object
3060   _mapGroups.erase( anId );
3061
3062   SALOMEDS::StudyBuilder_var builder;
3063   SALOMEDS::SObject_wrap     aGroupSO;
3064   SALOMEDS::Study_var        aStudy = SMESH_Gen_i::GetSMESHGen()->getStudyServant();
3065   if ( !aStudy->_is_nil() ) {
3066     builder  = aStudy->NewBuilder();
3067     aGroupSO = _gen_i->ObjectToSObject( theGroup );
3068     if ( !aGroupSO->_is_nil() )
3069     {
3070       // remove reference to geometry
3071       SALOMEDS::ChildIterator_wrap chItr = aStudy->NewChildIterator(aGroupSO);
3072       for ( ; chItr->More(); chItr->Next() )
3073       {
3074         // Remove group's child SObject
3075         SALOMEDS::SObject_wrap so = chItr->Value();
3076         builder->RemoveObject( so );
3077       }
3078       // Update Python script
3079       TPythonDump() << aGroupSO << " = " << SMESH::SMESH_Mesh_var(_this())
3080                     << ".ConvertToStandalone( " << aGroupSO << " )";
3081
3082       // change icon of Group on Filter
3083       if ( isOnFilter )
3084       {
3085         // SMESH::array_of_ElementType_var elemTypes = aGroupImpl->GetTypes();
3086         // const int isEmpty = ( elemTypes->length() == 0 );
3087         // if ( !isEmpty )
3088         {
3089           SALOMEDS::GenericAttribute_wrap anAttr =
3090             builder->FindOrCreateAttribute( aGroupSO, "AttributePixMap" );
3091           SALOMEDS::AttributePixMap_wrap pm = anAttr;
3092           pm->SetPixMap( "ICON_SMESH_TREE_GROUP" );
3093         }
3094       }
3095     }
3096   }
3097
3098   // remember new group in own map
3099   aGroup = SMESH::SMESH_Group::_narrow( aGroupImpl->_this() );
3100   _mapGroups[anId] = SMESH::SMESH_GroupBase::_duplicate( aGroup );
3101
3102   // register CORBA object for persistence
3103   _gen_i->RegisterObject( aGroup );
3104
3105   CORBA::String_var ior = _gen_i->GetORB()->object_to_string( aGroup );
3106   builder->SetIOR( aGroupSO, ior.in() ); //  == aGroup->Register();
3107   //aGroup->Register();
3108   aGroupToRem->UnRegister();
3109
3110   SMESH_CATCH( SMESH::throwCorbaException );
3111
3112   return aGroup._retn();
3113 }
3114
3115 //================================================================================
3116 /*!
3117  * \brief Create a sub-mesh on a given sub-shape
3118  */
3119 //================================================================================
3120
3121 SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::createSubMesh( GEOM::GEOM_Object_ptr theSubShapeObject )
3122 {
3123   if(MYDEBUG) MESSAGE( "createSubMesh" );
3124   TopoDS_Shape  myLocSubShape = _gen_i->GeomObjectToShape(theSubShapeObject);
3125   ::SMESH_subMesh * mySubMesh = _impl->GetSubMesh(myLocSubShape);
3126   int               subMeshId = 0;
3127
3128   SMESH_subMesh_i * subMeshServant;
3129   if ( mySubMesh )
3130   {
3131     subMeshId = mySubMesh->GetId();
3132     subMeshServant = new SMESH_subMesh_i(myPOA, _gen_i, this, subMeshId);
3133   }
3134   else // "invalid sub-mesh"
3135   {
3136     // The invalid sub-mesh is created for the case where a valid sub-shape not found
3137     // by SMESH_Gen_i::CopyMeshWithGeom(). The invalid sub-mesh has GetId() < 0.
3138     if ( _mapSubMesh.empty() )
3139       subMeshId = -1;
3140     else
3141       subMeshId = _mapSubMesh.begin()->first - 1;
3142     subMeshServant = new SMESH_Invalid_subMesh_i(myPOA, _gen_i, this, subMeshId, theSubShapeObject);
3143   }
3144
3145   SMESH::SMESH_subMesh_var subMesh = subMeshServant->_this();
3146
3147   _mapSubMesh   [subMeshId] = mySubMesh;
3148   _mapSubMesh_i [subMeshId] = subMeshServant;
3149   _mapSubMeshIor[subMeshId] = SMESH::SMESH_subMesh::_duplicate( subMesh );
3150
3151   subMeshServant->Register();
3152
3153   // register CORBA object for persistence
3154   int nextId = _gen_i->RegisterObject( subMesh );
3155   if(MYDEBUG) { MESSAGE( "Add submesh to map with id = "<< nextId); }
3156   else        { (void)nextId; } // avoid "unused variable" warning
3157
3158   // to track changes of GEOM groups
3159   if ( subMeshId > 0 )
3160     addGeomGroupData( theSubShapeObject, subMesh );
3161
3162   return subMesh._retn();
3163 }
3164
3165 //================================================================================
3166 /*!
3167  * \brief Return an existing sub-mesh based on a sub-shape with the given ID
3168  */
3169 //================================================================================
3170
3171 SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::getSubMesh(int shapeID)
3172 {
3173   map<int, SMESH::SMESH_subMesh_ptr>::iterator it = _mapSubMeshIor.find( shapeID );
3174   if ( it == _mapSubMeshIor.end() )
3175     return SMESH::SMESH_subMesh::_nil();
3176
3177   return SMESH::SMESH_subMesh::_duplicate( (*it).second );