Salome HOME
711baf691739a8a014279b5228ebbfff735f381d
[modules/smesh.git] / src / SMESH / SMESH_subMesh.cxx
1 //  SMESH SMESH : implementaion of SMESH idl descriptions
2 //
3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
5 // 
6 //  This library is free software; you can redistribute it and/or 
7 //  modify it under the terms of the GNU Lesser General Public 
8 //  License as published by the Free Software Foundation; either 
9 //  version 2.1 of the License. 
10 // 
11 //  This library is distributed in the hope that it will be useful, 
12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of 
13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
14 //  Lesser General Public License for more details. 
15 // 
16 //  You should have received a copy of the GNU Lesser General Public 
17 //  License along with this library; if not, write to the Free Software 
18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
19 // 
20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
21 //
22 //
23 //
24 //  File   : SMESH_subMesh.cxx
25 //  Author : Paul RASCLE, EDF
26 //  Module : SMESH
27 //  $Header$
28
29 using namespace std;
30 #include "SMESH_subMesh.hxx"
31 #include "SMESH_Gen.hxx"
32 #include "SMESH_Mesh.hxx"
33 #include "SMESH_Hypothesis.hxx"
34 #include "SMESH_Algo.hxx"
35 #include "utilities.h"
36 #include "OpUtil.hxx"
37
38 #include <TopExp.hxx>
39 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
40 #include <TopTools_ListOfShape.hxx>
41 #include <TopTools_ListIteratorOfListOfShape.hxx>
42 #include <TColStd_ListIteratorOfListOfInteger.hxx>
43
44 //=============================================================================
45 /*!
46  *  default constructor:
47  */
48 //=============================================================================
49
50 SMESH_subMesh::SMESH_subMesh(int Id, SMESH_Mesh * father, SMESHDS_Mesh * meshDS,
51         const TopoDS_Shape & aSubShape)
52 {
53         //MESSAGE("SMESH_subMesh::SMESH_subMesh");
54         _subShape = aSubShape;
55         _meshDS = meshDS;
56         _subMeshDS = meshDS->MeshElements(_subShape);   // may be null ...
57         _father = father;
58         _Id = Id;
59         _vertexSet = false;                     // only for Vertex subMesh
60         _dependenceAnalysed = false;
61         _dependantsFound = false;
62
63         if (_subShape.ShapeType() == TopAbs_VERTEX)
64         {
65                 _algoState = HYP_OK;
66                 _computeState = READY_TO_COMPUTE;
67         }
68         else
69         {
70                 _algoState = NO_ALGO;
71                 _computeState = NOT_READY;
72         }
73 }
74
75 //=============================================================================
76 /*!
77  * 
78  */
79 //=============================================================================
80
81 SMESH_subMesh::~SMESH_subMesh()
82 {
83         MESSAGE("SMESH_subMesh::~SMESH_subMesh");
84         // ****
85 }
86
87 //=============================================================================
88 /*!
89  * 
90  */
91 //=============================================================================
92
93 int SMESH_subMesh::GetId()
94 {
95         //MESSAGE("SMESH_subMesh::GetId");
96         return _Id;
97 }
98
99 //=============================================================================
100 /*!
101  * Given a subShape, find the subMesh is associated to this subShape or
102  * to a collection of shapes containing this subShape. Collection = compsolid,
103  * shell, wire
104  */
105 //=============================================================================
106
107 // bool SMESH_subMesh::Contains(const TopoDS_Shape & aSubShape)
108 //   throw (SALOME_Exception)
109 // {
110 //   //MESSAGE("SMESH_subMesh::Contains");
111 //   bool contains = false;
112 //   int type = _subShape.ShapeType();
113 //   int typesub = aSubShape.ShapeType();
114 //   //SCRUTE(type)
115 //   //SCRUTE(typesub)
116 //   switch (type)
117 //     {
118 // //     case TopAbs_COMPOUND:
119 // //       {
120 // //   //MESSAGE("---");
121 // //   throw SALOME_Exception(LOCALIZED("Compound not yet treated"));
122 // //   break;
123 // //       }
124 //     case TopAbs_COMPSOLID:
125 //       {
126 //  //MESSAGE("---");
127 //  for (TopExp_Explorer exp(aSubShape,TopAbs_SOLID);exp.More();exp.Next())
128 //    {
129 //      contains = _subShape.IsSame(exp.Current());
130 //      if (contains) break;
131 //    }
132 //  break;
133 //       }
134 //     case TopAbs_SHELL:
135 //       {
136 //  //MESSAGE("---");
137 //  for (TopExp_Explorer exp(aSubShape,TopAbs_FACE);exp.More();exp.Next())
138 //    {
139 //      contains = _subShape.IsSame(exp.Current());
140 //      if (contains) break;
141 //    }
142 //  break;
143 //       }
144 //     case TopAbs_WIRE:
145 //       {
146 //  //MESSAGE("---");
147 //  for (TopExp_Explorer exp(aSubShape,TopAbs_EDGE);exp.More();exp.Next())
148 //    {
149 //      contains = _subShape.IsSame(exp.Current());
150 //      if (contains) break;
151 //    }
152 //  break;
153 //       }
154 //     case TopAbs_COMPOUND:
155 //     case TopAbs_SOLID:
156 //     case TopAbs_FACE:
157 //     case TopAbs_EDGE:
158 //     case TopAbs_VERTEX:
159 //       {
160 //  //MESSAGE("---");
161 //  contains = _subShape.IsSame(aSubShape);
162 //  break;
163 //       }
164 //     default:
165 //       {
166 //  break;
167 //       }
168 //     }
169 //   //SCRUTE(contains);
170 //   return contains;
171 // }
172
173 //=============================================================================
174 /*!
175  * 
176  */
177 //=============================================================================
178
179 SMESHDS_SubMesh * SMESH_subMesh::GetSubMeshDS() throw(SALOME_Exception)
180 {
181         //MESSAGE("SMESH_subMesh::GetSubMeshDS");
182         if (_subMeshDS==NULL)
183         {
184                 //MESSAGE("subMesh pointer still null, trying to get it...");
185                 _subMeshDS = _meshDS->MeshElements(_subShape);  // may be null ...
186                 if (_subMeshDS==NULL)
187                 {
188                         MESSAGE("problem... subMesh still empty");
189                         //NRI   ASSERT(0);
190                         //NRI   throw SALOME_Exception(LOCALIZED(subMesh still empty));
191                 }
192         }
193         return _subMeshDS;
194 }
195
196 //=============================================================================
197 /*!
198  * 
199  */
200 //=============================================================================
201
202 SMESH_subMesh *SMESH_subMesh::GetFirstToCompute() throw(SALOME_Exception)
203 {
204         //MESSAGE("SMESH_subMesh::GetFirstToCompute");
205         const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
206         SMESH_subMesh *firstToCompute = 0;
207
208         map < int, SMESH_subMesh * >::const_iterator itsub;
209         for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++)
210         {
211                 SMESH_subMesh *sm = (*itsub).second;
212 //       SCRUTE(sm->GetId());
213 //       SCRUTE(sm->GetComputeState());
214                 bool readyToCompute = (sm->GetComputeState() == READY_TO_COMPUTE);
215                 if (readyToCompute)
216                 {
217                         firstToCompute = sm;
218                         //SCRUTE(sm->GetId());
219                         break;
220                 }
221         }
222         if (firstToCompute)
223         {
224                 //MESSAGE("--- submesh to compute");
225                 return firstToCompute;  // a subMesh of this
226         }
227         if (_computeState == READY_TO_COMPUTE)
228         {
229                 //MESSAGE("--- this to compute");
230                 return this;                    // this
231         }
232         //MESSAGE("--- nothing to compute");
233         return 0;                                       // nothing to compute
234 }
235
236 //=============================================================================
237 /*!
238  * 
239  */
240 //=============================================================================
241
242 bool SMESH_subMesh::SubMeshesComputed() throw(SALOME_Exception)
243 {
244         //MESSAGE("SMESH_subMesh::SubMeshesComputed");
245         const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
246
247         bool subMeshesComputed = true;
248         map < int, SMESH_subMesh * >::const_iterator itsub;
249         for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++)
250         {
251                 SMESH_subMesh *sm = (*itsub).second;
252 //       SCRUTE(sm->GetId());
253 //       SCRUTE(sm->GetComputeState());
254                 bool computeOk = (sm->GetComputeState() == COMPUTE_OK);
255                 if (!computeOk)
256                 {
257                         subMeshesComputed = false;
258                         SCRUTE(sm->GetId());
259                         break;
260                 }
261         }
262         return subMeshesComputed;
263 }
264
265 //=============================================================================
266 /*!
267  * 
268  */
269 //=============================================================================
270
271 bool SMESH_subMesh::SubMeshesReady()
272 {
273         MESSAGE("SMESH_subMesh::SubMeshesReady");
274         const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
275
276         bool subMeshesReady = true;
277         map < int, SMESH_subMesh * >::const_iterator itsub;
278         for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++)
279         {
280                 SMESH_subMesh *sm = (*itsub).second;
281 //       SCRUTE(sm->GetId());
282 //       SCRUTE(sm->GetComputeState());
283                 bool computeOk = ((sm->GetComputeState() == COMPUTE_OK)
284                         || (sm->GetComputeState() == READY_TO_COMPUTE));
285                 if (!computeOk)
286                 {
287                         subMeshesReady = false;
288                         SCRUTE(sm->GetId());
289                         break;
290                 }
291         }
292         return subMeshesReady;
293 }
294
295 //=============================================================================
296 /*!
297  * Construct dependence on first level subMeshes. complex shapes (compsolid, 
298  * shell, wire) are not analysed the same way as simple shapes (solid, face,
299  * edge). 
300  * For collection shapes (compsolid, shell, wire) prepare a list of submeshes
301  * with possible multiples occurences. Multiples occurences corresponds to
302  * internal frontiers within shapes of the collection and must not be keeped.
303  * See FinalizeDependence.
304  */
305 //=============================================================================
306
307 const map < int, SMESH_subMesh * >&SMESH_subMesh::DependsOn()
308 {
309         if (_dependenceAnalysed)
310                 return _mapDepend;
311
312         //MESSAGE("SMESH_subMesh::DependsOn");
313
314         int type = _subShape.ShapeType();
315         //SCRUTE(type);
316         switch (type)
317         {
318         case TopAbs_COMPOUND:
319         {
320                 //MESSAGE("compound");
321                 list < TopoDS_Shape > shellInSolid;
322                 for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More();
323                         exp.Next())
324                 {
325                         InsertDependence(exp.Current());
326                         for (TopExp_Explorer
327                                 exp2(exp.Current(), TopAbs_SHELL); exp2.More(); exp2.Next())
328                         {
329                                 shellInSolid.push_back(exp2.Current());
330                         }
331                 }
332                 for (TopExp_Explorer exp(_subShape, TopAbs_SHELL); exp.More();
333                         exp.Next())
334                 {
335                         list < TopoDS_Shape >::iterator it1;
336                         bool isInSolid = false;
337                         for (it1 = shellInSolid.begin(); it1 != shellInSolid.end(); it1++)
338                         {
339                                 TopoDS_Shape aShape = (*it1);
340                                 if (aShape.IsSame(exp.Current()))
341                                 {
342                                         isInSolid = true;
343                                         break;
344                                 }
345                         }
346                         if (!isInSolid)
347                                 InsertDependence(exp.Current());        //only shell not in solid
348                 }
349                 for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More();
350                         exp.Next())
351                 {
352                         InsertDependence(exp.Current());
353                 }
354                 for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More();
355                         exp.Next())
356                 {
357                         InsertDependence(exp.Current());
358                 }
359                 break;
360         }
361         case TopAbs_COMPSOLID:
362         {
363                 //MESSAGE("compsolid");
364                 for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More();
365                         exp.Next())
366                 {
367                         InsertDependence(exp.Current());
368                 }
369 //  list<TopoDS_Shape> shapeList;
370 //  for (TopExp_Explorer exp(_subShape,TopAbs_SOLID);exp.More();exp.Next())
371 //    {
372 //      for (TopExp_Explorer 
373 //         exp2(exp.Current(),TopAbs_FACE);exp2.More();exp2.Next())
374 //        {
375 //      shapeList.push_back(exp2.Current()); 
376 //        }
377 //    }
378 //  FinalizeDependence(shapeList);
379                 break;
380         }
381         case TopAbs_SHELL:
382         {
383                 //MESSAGE("shell");
384                 for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More();
385                         exp.Next())
386                 {
387                         InsertDependence(exp.Current());
388                 }
389 //  list<TopoDS_Shape> shapeList;
390 //  for (TopExp_Explorer exp(_subShape,TopAbs_FACE);exp.More();exp.Next())
391 //    {
392 //      for (TopExp_Explorer 
393 //         exp2(exp.Current(),TopAbs_EDGE);exp2.More();exp2.Next())
394 //        {
395 //      shapeList.push_back(exp2.Current()); 
396 //        }
397 //    }
398 //  FinalizeDependence(shapeList);
399                 break;
400         }
401         case TopAbs_WIRE:
402         {
403                 //MESSAGE("wire");
404                 for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More();
405                         exp.Next())
406                 {
407                         InsertDependence(exp.Current());
408                 }
409 //  list<TopoDS_Shape> shapeList;
410 //  for (TopExp_Explorer exp(_subShape,TopAbs_EDGE);exp.More();exp.Next())
411 //    {
412 //      for (TopExp_Explorer 
413 //         exp2(exp.Current(),TopAbs_VERTEX);exp2.More();exp2.Next())
414 //        {
415 //      shapeList.push_back(exp2.Current()); 
416 //        }
417 //    }
418 //  FinalizeDependence(shapeList);
419                 break;
420         }
421         case TopAbs_SOLID:
422         {
423                 //MESSAGE("solid");
424 //  for (TopExp_Explorer exp(_subShape,TopAbs_SHELL);exp.More();exp.Next())
425 //    {
426 //      InsertDependence(exp.Current());
427 //    }
428                 for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More();
429                         exp.Next())
430                 {
431                         InsertDependence(exp.Current());
432                 }
433                 break;
434         }
435         case TopAbs_FACE:
436         {
437                 //MESSAGE("face");
438 //  for (TopExp_Explorer exp(_subShape,TopAbs_WIRE);exp.More();exp.Next())
439 //    {
440 //      InsertDependence(exp.Current());
441 //    }
442                 for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More();
443                         exp.Next())
444                 {
445                         InsertDependence(exp.Current());
446                 }
447                 break;
448         }
449         case TopAbs_EDGE:
450         {
451                 //MESSAGE("edge");
452                 for (TopExp_Explorer exp(_subShape, TopAbs_VERTEX); exp.More();
453                         exp.Next())
454                 {
455                         InsertDependence(exp.Current());
456                 }
457                 break;
458         }
459         case TopAbs_VERTEX:
460         {
461                 break;
462         }
463         default:
464         {
465                 break;
466         }
467         }
468         _dependenceAnalysed = true;
469         return _mapDepend;
470 }
471
472 //=============================================================================
473 /*!
474  * For simple Shapes (solid, face, edge): add subMesh into dependence list.
475  */
476 //=============================================================================
477
478 void SMESH_subMesh::InsertDependence(const TopoDS_Shape aSubShape)
479 {
480         //MESSAGE("SMESH_subMesh::InsertDependence");
481         //SMESH_subMesh* aSubMesh = _father->GetSubMeshContaining(aSubShape);
482         //SCRUTE(aSubMesh);
483         //if (! aSubMesh) aSubMesh = _father->GetSubMesh(aSubShape);
484
485         SMESH_subMesh *aSubMesh = _father->GetSubMesh(aSubShape);
486         int type = aSubShape.ShapeType();
487         int ordType = 9 - type;         // 2 = Vertex, 8 = CompSolid
488         int cle = aSubMesh->GetId();
489         cle += 10000000 * ordType;      // sort map by ordType then index
490         if (_mapDepend.find(cle) == _mapDepend.end())
491         {
492                 _mapDepend[cle] = aSubMesh;
493                 const map < int, SMESH_subMesh * >&subMap = aSubMesh->DependsOn();
494                 map < int, SMESH_subMesh * >::const_iterator im;
495                 for (im = subMap.begin(); im != subMap.end(); im++)
496                 {
497                         int clesub = (*im).first;
498                         SMESH_subMesh *sm = (*im).second;
499                         if (_mapDepend.find(clesub) == _mapDepend.end())
500                                 _mapDepend[clesub] = sm;
501                 }
502         }
503
504 }
505
506 //=============================================================================
507 /*!
508  * For collection shapes (compsolid, shell, wire).
509  * Add only subMesh figuring only once in multiset to dependence list 
510  */
511 //=============================================================================
512
513 // void SMESH_subMesh::FinalizeDependence(list<TopoDS_Shape>& shapeList)
514 // {
515 //   //MESSAGE("SMESH_subMesh::FinalizeDependence");
516 //   list<TopoDS_Shape>::iterator it1, it2;
517 //   for(it1 = shapeList.begin(); it1 != shapeList.end(); it1++)
518 //     {
519 //       TopoDS_Shape aSubShape = (*it1);
520 //       int count = 0;
521 //       for(it2 = shapeList.begin(); it2 != shapeList.end(); it2++)
522 //  {
523 //    TopoDS_Shape other = (*it2);
524 //    if (other.IsSame(aSubShape)) count++;
525 //  }
526 //       if (count == 1) InsertDependence(aSubShape);
527 //       SCRUTE(count);
528 //     }
529 // }
530
531 //=============================================================================
532 /*!
533  * 
534  */
535 //=============================================================================
536
537 const TopoDS_Shape & SMESH_subMesh::GetSubShape()
538 {
539         //MESSAGE("SMESH_subMesh::GetSubShape");
540         return _subShape;
541 }
542
543 //=============================================================================
544 /*!
545  * 
546  */
547 //=============================================================================
548
549 bool SMESH_subMesh::AlgoStateEngine(int event, SMESH_Hypothesis * anHyp)
550 throw(SALOME_Exception)
551 {
552         //  MESSAGE("SMESH_subMesh::AlgoStateEngine");
553         //SCRUTE(_algoState);
554         //SCRUTE(event);
555
556         // **** les retour des evenement shape sont significatifs
557         // (add ou remove fait ou non)
558         // le retour des evenement father n'indiquent pas que add ou remove fait
559         int dim = SMESH_Gen::GetShapeDim(_subShape);
560
561         if (dim < 1)
562         {
563                 _algoState = HYP_OK;
564                 //SCRUTE(_algoState);
565                 return true;
566         }
567
568         SMESH_Gen *gen = _father->GetGen();
569         bool ret;
570         _oldAlgoState = _algoState;
571         bool modifiedHyp = false;       // if set to true, force event MODIF_ALGO_STATE
572         // in ComputeStateEngine
573
574         switch (_algoState)
575         {
576
577                 // ----------------------------------------------------------------------
578
579         case NO_ALGO:
580                 switch (event)
581                 {
582                 case ADD_HYP:
583                         ASSERT(anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO);
584                         ret = _meshDS->AddHypothesis(_subShape, anHyp);
585                         break;
586                 case ADD_ALGO:
587                         ASSERT(anHyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO);
588                         if (anHyp->GetDim() <= SMESH_Gen::GetShapeDim(_subShape))
589                         {
590                                 ret = _meshDS->AddHypothesis(_subShape, anHyp);
591 //        if (ret &&(anHyp->GetDim() == SMESH_Gen::GetShapeDim(_subShape)))
592 //        if (ret &&(anHyp->GetShapeType() == _subShape.ShapeType()))
593                                 if (ret &&
594                                         (anHyp->GetShapeType() & (1 << _subShape.ShapeType())))
595                                 {
596                                         SMESH_Algo *algo = gen->GetAlgo((*_father), _subShape);
597                                         ASSERT(algo);
598                                         ret = algo->CheckHypothesis((*_father), _subShape);
599                                         if (ret)
600                                                 SetAlgoState(HYP_OK);
601                                         else
602                                                 SetAlgoState(MISSING_HYP);
603                                 }
604                         }
605                         break;
606                 case REMOVE_HYP:
607                         ASSERT(anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO);
608                         ret = _meshDS->RemoveHypothesis(_subShape, anHyp);
609                         break;
610                 case REMOVE_ALGO:
611                         ASSERT(anHyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO);
612                         ret = _meshDS->RemoveHypothesis(_subShape, anHyp);
613                         break;
614                 case ADD_FATHER_HYP:    // nothing to do
615                         break;
616                 case ADD_FATHER_ALGO:   // Algo just added in father
617                         ASSERT(anHyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO);
618 //    if (anHyp->GetDim() == SMESH_Gen::GetShapeDim(_subShape))
619 //    if (anHyp->GetShapeType() == _subShape.ShapeType())
620                         if (anHyp->GetShapeType() & (1 << _subShape.ShapeType()))
621                         {
622                                 SMESH_Algo *algo = gen->GetAlgo((*_father), _subShape);
623                                 ASSERT(algo);
624                                 ret = algo->CheckHypothesis((*_father), _subShape);
625                                 if (ret)
626                                         SetAlgoState(HYP_OK);
627                                 else
628                                         SetAlgoState(MISSING_HYP);
629                         }
630                         break;
631                 case REMOVE_FATHER_HYP: // nothing to do
632                         break;
633                 case REMOVE_FATHER_ALGO:        // nothing to do
634                         break;
635                 default:
636                         ASSERT(0);
637                         break;
638                 }
639                 break;
640
641                 // ----------------------------------------------------------------------
642
643         case MISSING_HYP:
644                 switch (event)
645                 {
646                 case ADD_HYP:
647                         ASSERT(anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO);
648                         ret = _meshDS->AddHypothesis(_subShape, anHyp);
649                         if (ret)
650                         {
651                                 SMESH_Algo *algo = gen->GetAlgo((*_father), _subShape);
652                                 ASSERT(algo);
653                                 ret = algo->CheckHypothesis((*_father), _subShape);
654                                 if (ret)
655                                         SetAlgoState(HYP_OK);
656                                 else
657                                         SetAlgoState(MISSING_HYP);
658                         }
659                         break;
660                 case ADD_ALGO:                  //already existing algo : on father ?
661                         ASSERT(anHyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO);
662                         if (anHyp->GetDim() <= SMESH_Gen::GetShapeDim(_subShape))
663                         {
664                                 ret = _meshDS->AddHypothesis(_subShape, anHyp);
665 //        if (ret &&(anHyp->GetDim() == SMESH_Gen::GetShapeDim(_subShape)))
666 //        if (ret &&(anHyp->GetShapeType() == _subShape.ShapeType()))
667                                 if (ret &&
668                                         (anHyp->GetShapeType() & (1 << _subShape.ShapeType())))
669                                 {
670                                         SMESH_Algo *algo = gen->GetAlgo((*_father), _subShape);
671                                         if (algo == NULL)       // two algo on the same subShape...
672                                         {
673                                                 MESSAGE("two algo on the same subshape not allowed");
674                                                 ret = _meshDS->RemoveHypothesis(_subShape, anHyp);
675                                                 ret = false;
676                                         }
677                                         else
678                                         {
679                                                 ret = algo->CheckHypothesis((*_father), _subShape);
680                                                 if (ret)
681                                                         SetAlgoState(HYP_OK);
682                                                 else
683                                                         SetAlgoState(MISSING_HYP);
684                                         }
685                                 }
686                         }
687                         break;
688                 case REMOVE_HYP:
689                         ASSERT(anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO);
690                         ret = _meshDS->RemoveHypothesis(_subShape, anHyp);
691                         break;
692                 case REMOVE_ALGO:               // perhaps a father algo applies ?
693                         ASSERT(anHyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO);
694                         ret = _meshDS->RemoveHypothesis(_subShape, anHyp);
695 //    if (ret &&(anHyp->GetDim() == SMESH_Gen::GetShapeDim(_subShape)))
696 //    if (ret &&(anHyp->GetShapeType() == _subShape.ShapeType()))
697                         if (ret && (anHyp->GetShapeType() & (1 << _subShape.ShapeType())))
698                         {
699                                 SMESH_Algo *algo = gen->GetAlgo((*_father), _subShape);
700                                 if (algo == NULL)       // no more algo applying on subShape...
701                                 {
702                                         SetAlgoState(NO_ALGO);
703                                 }
704                                 else
705                                 {
706                                         ret = algo->CheckHypothesis((*_father), _subShape);
707                                         if (ret)
708                                                 SetAlgoState(HYP_OK);
709                                         else
710                                                 SetAlgoState(MISSING_HYP);
711                                 }
712                         }
713                         break;
714                 case ADD_FATHER_HYP:
715                         ASSERT(anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO);
716                         {
717                                 SMESH_Algo *algo = gen->GetAlgo((*_father), _subShape);
718                                 ASSERT(algo);
719                                 ret = algo->CheckHypothesis((*_father), _subShape);
720                                 if (ret)
721                                         SetAlgoState(HYP_OK);
722                                 else
723                                         SetAlgoState(MISSING_HYP);
724                         }
725                         break;
726                 case ADD_FATHER_ALGO:   // detect if two algo of same dim on father
727                         ASSERT(anHyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO);
728 //    if (anHyp->GetDim() == SMESH_Gen::GetShapeDim(_subShape))
729 //    if (anHyp->GetShapeType() == _subShape.ShapeType())
730                         if (anHyp->GetShapeType() & (1 << _subShape.ShapeType()))
731                         {
732                                 SMESH_Algo *algo = gen->GetAlgo((*_father), _subShape);
733                                 if (algo == NULL)       // two applying algo on father
734                                 {
735                                         MESSAGE("two applying algo on fatherShape...");
736                                         SetAlgoState(NO_ALGO);
737                                 }
738                                 else
739                                 {
740                                         ret = algo->CheckHypothesis((*_father), _subShape);
741                                         if (ret)
742                                                 SetAlgoState(HYP_OK);
743                                         else
744                                                 SetAlgoState(MISSING_HYP);
745                                 }
746                         }
747                         break;
748                 case REMOVE_FATHER_HYP: // nothing to do
749                         break;
750                 case REMOVE_FATHER_ALGO:
751                         ASSERT(anHyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO);
752 //    if (anHyp->GetDim() == SMESH_Gen::GetShapeDim(_subShape))
753 //    if (anHyp->GetShapeType() == _subShape.ShapeType())
754                         if (anHyp->GetShapeType() & (1 << _subShape.ShapeType()))
755                         {
756                                 SMESH_Algo *algo = gen->GetAlgo((*_father), _subShape);
757                                 if (algo == NULL)       // no more applying algo on father
758                                 {
759                                         SetAlgoState(NO_ALGO);
760                                 }
761                                 else
762                                 {
763                                         ret = algo->CheckHypothesis((*_father), _subShape);
764                                         if (ret)
765                                                 SetAlgoState(HYP_OK);
766                                         else
767                                                 SetAlgoState(MISSING_HYP);
768                                 }
769                         }
770                         break;
771                 default:
772                         ASSERT(0);
773                         break;
774                 }
775                 break;
776
777                 // ----------------------------------------------------------------------
778
779         case HYP_OK:
780                 switch (event)
781                 {
782                 case ADD_HYP:
783                 {
784                         ASSERT(anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO);
785                         SMESH_Algo *algo = gen->GetAlgo((*_father), _subShape);
786                         ASSERT(algo);
787                         list<const SMESHDS_Hypothesis *> originalUsedHyps = algo->GetUsedHypothesis((*_father), _subShape);     // copy
788
789                         ret = _meshDS->AddHypothesis(_subShape, anHyp);
790                         if (ret)
791                         {
792                                 ret = algo->CheckHypothesis((*_father), _subShape);
793                                 if (!ret)
794                                 {
795                                         INFOS("two applying algo on the same shape not allowed");
796                                         ret = _meshDS->RemoveHypothesis(_subShape, anHyp);
797                                         ret = false;
798                                 }
799                                 else                    // compare SMESHDS_Hypothesis* lists (order important)
800                                 {
801                                         MESSAGE("---");
802                                         const list <const SMESHDS_Hypothesis *> & newUsedHyps
803                                                 = algo->GetUsedHypothesis((*_father), _subShape);
804                                         modifiedHyp = (originalUsedHyps != newUsedHyps);
805                                 }
806                         }
807                 }
808                         break;
809                 case ADD_ALGO:                  //already existing algo : on father ?
810                         ASSERT(anHyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO);
811                         if (anHyp->GetDim() <= SMESH_Gen::GetShapeDim(_subShape))
812                         {
813                                 ret = _meshDS->AddHypothesis(_subShape, anHyp);
814 //        if (ret &&(anHyp->GetDim() == SMESH_Gen::GetShapeDim(_subShape)))
815 //        if (ret &&(anHyp->GetShapeType() == _subShape.ShapeType()))
816                                 if (ret &&
817                                         (anHyp->GetShapeType() & (1 << _subShape.ShapeType())))
818                                 {
819                                         SMESH_Algo *algo = gen->GetAlgo((*_father), _subShape);
820                                         if (algo == NULL)       // two algo on the same subShape...
821                                         {
822                                                 INFOS("two algo on the same subshape not allowed");
823                                                 ret = _meshDS->RemoveHypothesis(_subShape, anHyp);
824                                                 ret = false;
825                                         }
826                                         else
827                                         {
828                                                 ret = algo->CheckHypothesis((*_father), _subShape);
829                                                 if (ret)
830                                                         SetAlgoState(HYP_OK);
831                                                 else
832                                                         SetAlgoState(MISSING_HYP);
833                                         }
834                                 }
835                         }
836                         break;
837                 case REMOVE_HYP:
838                         ASSERT(anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO);
839                         ret = _meshDS->RemoveHypothesis(_subShape, anHyp);
840                         if (ret)
841                         {
842                                 SMESH_Algo *algo = gen->GetAlgo((*_father), _subShape);
843                                 ASSERT(algo);
844                                 ret = algo->CheckHypothesis((*_father), _subShape);
845                                 if (ret)
846                                         SetAlgoState(HYP_OK);
847                                 else
848                                         SetAlgoState(MISSING_HYP);
849                                 modifiedHyp = true;
850                         }
851                         break;
852                 case REMOVE_ALGO:               // perhaps a father algo applies ?
853                         ASSERT(anHyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO);
854                         ret = _meshDS->RemoveHypothesis(_subShape, anHyp);
855 //    if (ret &&(anHyp->GetDim() == SMESH_Gen::GetShapeDim(_subShape)))
856 //    if (ret &&(anHyp->GetShapeType() == _subShape.ShapeType()))
857                         if (ret && (anHyp->GetShapeType() & (1 << _subShape.ShapeType())))
858                         {
859                                 SMESH_Algo *algo = gen->GetAlgo((*_father), _subShape);
860                                 if (algo == NULL)       // no more algo applying on subShape...
861                                 {
862                                         SetAlgoState(NO_ALGO);
863                                 }
864                                 else
865                                 {
866                                         ret = algo->CheckHypothesis((*_father), _subShape);
867                                         if (ret)
868                                                 SetAlgoState(HYP_OK);
869                                         else
870                                                 SetAlgoState(MISSING_HYP);
871                                 }
872                         }
873                         break;
874                 case ADD_FATHER_HYP:
875                         ASSERT(anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO);
876                         {
877                                 SMESH_Algo *algo = gen->GetAlgo((*_father), _subShape);
878                                 ASSERT(algo);
879                                 ret = algo->CheckHypothesis((*_father), _subShape);
880                                 if (ret)
881                                         SetAlgoState(HYP_OK);
882                                 else
883                                         SetAlgoState(MISSING_HYP);
884                         }
885                         break;
886                 case ADD_FATHER_ALGO:   // detect if two algo of same dim on father
887                         ASSERT(anHyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO);
888 //    if (anHyp->GetDim() == SMESH_Gen::GetShapeDim(_subShape))
889 //    if (anHyp->GetShapeType() == _subShape.ShapeType())
890                         if (anHyp->GetShapeType() & (1 << _subShape.ShapeType()))
891                         {
892                                 SMESH_Algo *algo = gen->GetAlgo((*_father), _subShape);
893                                 if (algo == NULL)       // two applying algo on father
894                                 {
895                                         MESSAGE("two applying algo on fatherShape...");
896                                         SetAlgoState(NO_ALGO);
897                                 }
898                                 else
899                                 {
900                                         ret = algo->CheckHypothesis((*_father), _subShape);
901                                         if (ret)
902                                                 SetAlgoState(HYP_OK);
903                                         else
904                                                 SetAlgoState(MISSING_HYP);
905                                 }
906                         }
907                         break;
908                 case REMOVE_FATHER_HYP:
909                         ASSERT(anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO);
910                         {
911                                 SMESH_Algo *algo = gen->GetAlgo((*_father), _subShape);
912                                 ASSERT(algo);
913                                 ret = algo->CheckHypothesis((*_father), _subShape);
914                                 if (ret)
915                                         SetAlgoState(HYP_OK);
916                                 else
917                                         SetAlgoState(MISSING_HYP);
918                         }
919                         break;
920                 case REMOVE_FATHER_ALGO:
921                         ASSERT(anHyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO);
922 //    if (anHyp->GetDim() == SMESH_Gen::GetShapeDim(_subShape))
923 //    if (anHyp->GetShapeType() == _subShape.ShapeType())
924                         if (anHyp->GetShapeType() & (1 << _subShape.ShapeType()))
925                         {
926                                 SMESH_Algo *algo = gen->GetAlgo((*_father), _subShape);
927                                 if (algo == NULL)       // no more applying algo on father
928                                 {
929                                         SetAlgoState(NO_ALGO);
930                                 }
931                                 else
932                                 {
933                                         ret = algo->CheckHypothesis((*_father), _subShape);
934                                         if (ret)
935                                                 SetAlgoState(HYP_OK);
936                                         else
937                                                 SetAlgoState(MISSING_HYP);
938                                 }
939                         }
940                         break;
941                 default:
942                         ASSERT(0);
943                         break;
944                 }
945                 break;
946
947                 // ----------------------------------------------------------------------
948
949         default:
950                 ASSERT(0);
951                 break;
952         }
953         //SCRUTE(_algoState);
954         if ((_algoState != _oldAlgoState) || modifiedHyp)
955                 int retc = ComputeStateEngine(MODIF_ALGO_STATE);
956         return ret;
957 }
958
959 //=============================================================================
960 /*!
961  * 
962  */
963 //=============================================================================
964
965 void SMESH_subMesh::SetAlgoState(int state)
966 {
967         if (state != _oldAlgoState)
968 //     int retc = ComputeStateEngine(MODIF_ALGO_STATE);
969                 _algoState = state;
970 }
971
972 //=============================================================================
973 /*!
974  * 
975  */
976 //=============================================================================
977
978 void SMESH_subMesh::SubMeshesAlgoStateEngine(int event,
979         SMESH_Hypothesis * anHyp) throw(SALOME_Exception)
980 {
981         //MESSAGE("SMESH_subMesh::SubMeshesAlgoStateEngine");
982         int dim = SMESH_Gen::GetShapeDim(_subShape);
983         if (dim > 1)
984         {
985                 const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
986
987                 map < int, SMESH_subMesh * >::const_iterator itsub;
988                 for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++)
989                 {
990                         SMESH_subMesh *sm = (*itsub).second;
991                         sm->AlgoStateEngine(event, anHyp);
992                 }
993         }
994 }
995
996 //=============================================================================
997 /*!
998  * 
999  */
1000 //=============================================================================
1001
1002 void SMESH_subMesh::DumpAlgoState(bool isMain)
1003 {
1004         int dim = SMESH_Gen::GetShapeDim(_subShape);
1005 //   if (dim < 1) return;
1006         if (isMain)
1007         {
1008                 const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
1009
1010                 map < int, SMESH_subMesh * >::const_iterator itsub;
1011                 for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++)
1012                 {
1013                         SMESH_subMesh *sm = (*itsub).second;
1014                         sm->DumpAlgoState(false);
1015                 }
1016         }
1017         int type = _subShape.ShapeType();
1018         MESSAGE("dim = " << dim << " type of shape " << type);
1019         switch (_algoState)
1020         {
1021         case NO_ALGO:
1022                 MESSAGE(" AlgoState = NO_ALGO");
1023                 break;
1024         case MISSING_HYP:
1025                 MESSAGE(" AlgoState = MISSING_HYP");
1026                 break;
1027         case HYP_OK:
1028                 MESSAGE(" AlgoState = HYP_OK");
1029                 break;
1030         }
1031         switch (_computeState)
1032         {
1033         case NOT_READY:
1034                 MESSAGE(" ComputeState = NOT_READY");
1035                 break;
1036         case READY_TO_COMPUTE:
1037                 MESSAGE(" ComputeState = READY_TO_COMPUTE");
1038                 break;
1039         case COMPUTE_OK:
1040                 MESSAGE(" ComputeState = COMPUTE_OK");
1041                 break;
1042         case FAILED_TO_COMPUTE:
1043                 MESSAGE(" ComputeState = FAILED_TO_COMPUTE");
1044                 break;
1045         }
1046 }
1047
1048 //=============================================================================
1049 /*!
1050  * 
1051  */
1052 //=============================================================================
1053
1054 bool SMESH_subMesh::ComputeStateEngine(int event) throw(SALOME_Exception)
1055 {
1056         //MESSAGE("SMESH_subMesh::ComputeStateEngine");
1057         //SCRUTE(_computeState);
1058         //SCRUTE(event);
1059
1060         int dim = SMESH_Gen::GetShapeDim(_subShape);
1061
1062         if (dim < 1)
1063         {
1064                 if (_vertexSet)
1065                         _computeState = COMPUTE_OK;
1066                 else
1067                         _computeState = READY_TO_COMPUTE;
1068                 //SCRUTE(_computeState);
1069                 return true;
1070         }
1071         SMESH_Gen *gen = _father->GetGen();
1072         SMESH_Algo *algo = 0;
1073         bool ret;
1074
1075         switch (_computeState)
1076         {
1077
1078                 // ----------------------------------------------------------------------
1079
1080         case NOT_READY:
1081                 switch (event)
1082                 {
1083                 case MODIF_HYP:         // nothing to do
1084                         break;
1085                 case MODIF_ALGO_STATE:
1086                         if (_algoState == HYP_OK)
1087                                 _computeState = READY_TO_COMPUTE;
1088                         break;
1089                 case COMPUTE:                   // nothing to do
1090                         break;
1091                 case CLEAN:                     // nothing to do
1092                         break;
1093                 case CLEANDEP:                  // nothing to do
1094                         RemoveSubMeshElementsAndNodes();        // recursive call...
1095                         break;
1096                 case SUBMESH_COMPUTED:  // nothing to do
1097                         break;
1098                 default:
1099                         ASSERT(0);
1100                         break;
1101                 }
1102                 break;
1103
1104                 // ----------------------------------------------------------------------
1105
1106         case READY_TO_COMPUTE:
1107                 switch (event)
1108                 {
1109                 case MODIF_HYP:         // nothing to do
1110                         break;
1111                 case MODIF_ALGO_STATE:
1112                         _computeState = NOT_READY;
1113                         algo = gen->GetAlgo((*_father), _subShape);
1114                         if (algo)
1115                         {
1116                                 ret = algo->CheckHypothesis((*_father), _subShape);
1117                                 if (ret)
1118                                         _computeState = READY_TO_COMPUTE;
1119                         }
1120                         break;
1121                 case COMPUTE:
1122                 {
1123                         algo = gen->GetAlgo((*_father), _subShape);
1124                         ASSERT(algo);
1125                         ret = algo->CheckHypothesis((*_father), _subShape);
1126                         if (!ret)
1127                         {
1128                                 MESSAGE("***** verify compute state *****");
1129                                 _computeState = NOT_READY;
1130                                 break;
1131                         }
1132                         ret = SubMeshesComputed();
1133                         if (!ret)
1134                         {
1135                                 MESSAGE("Some SubMeshes not computed");
1136                                 _computeState = FAILED_TO_COMPUTE;
1137                                 break;
1138                         }
1139                         ret = algo->Compute((*_father), _subShape);
1140                         if (!ret)
1141                         {
1142                                 MESSAGE("problem in algo execution: failed to compute");
1143                                 _computeState = FAILED_TO_COMPUTE;
1144                                 break;
1145                         }
1146                         else
1147                         {
1148                                 _computeState = COMPUTE_OK;
1149                                 UpdateDependantsState();        // send event SUBMESH_COMPUTED
1150                         }
1151                 }
1152                         break;
1153                 case CLEAN:
1154                         _computeState = NOT_READY;
1155                         algo = gen->GetAlgo((*_father), _subShape);
1156                         if (algo)
1157                         {
1158                                 ret = algo->CheckHypothesis((*_father), _subShape);
1159                                 if (ret)
1160                                         _computeState = READY_TO_COMPUTE;
1161                         }
1162                         break;
1163                 case CLEANDEP:
1164                         RemoveSubMeshElementsAndNodes();
1165                         _computeState = NOT_READY;
1166                         algo = gen->GetAlgo((*_father), _subShape);
1167                         if (algo)
1168                         {
1169                                 ret = algo->CheckHypothesis((*_father), _subShape);
1170                                 if (ret)
1171                                         _computeState = READY_TO_COMPUTE;
1172                         }
1173                         break;
1174                 case SUBMESH_COMPUTED:  // nothing to do
1175                         break;
1176                 default:
1177                         ASSERT(0);
1178                         break;
1179                 }
1180                 break;
1181
1182                 // ----------------------------------------------------------------------
1183
1184         case COMPUTE_OK:
1185                 switch (event)
1186                 {
1187                 case MODIF_HYP:
1188                         CleanDependants();      // recursive recall with event CLEANDEP
1189                         break;
1190                 case MODIF_ALGO_STATE:
1191                         CleanDependants();      // recursive recall with event CLEANDEP
1192                         break;
1193                 case COMPUTE:                   // nothing to do
1194                         break;
1195                 case CLEAN:
1196                         CleanDependants();      // recursive recall with event CLEANDEP
1197                         break;
1198                 case CLEANDEP:
1199                         RemoveSubMeshElementsAndNodes();
1200                         _computeState = NOT_READY;
1201                         algo = gen->GetAlgo((*_father), _subShape);
1202                         if (algo)
1203                         {
1204                                 ret = algo->CheckHypothesis((*_father), _subShape);
1205                                 if (ret)
1206                                         _computeState = READY_TO_COMPUTE;
1207                         }
1208                         break;
1209                 case SUBMESH_COMPUTED:  // nothing to do
1210                         break;
1211                 default:
1212                         ASSERT(0);
1213                         break;
1214                 }
1215                 break;
1216
1217                 // ----------------------------------------------------------------------
1218
1219         case FAILED_TO_COMPUTE:
1220                 switch (event)
1221                 {
1222                 case MODIF_HYP:
1223                         if (_algoState == HYP_OK)
1224                                 _computeState = READY_TO_COMPUTE;
1225                         else
1226                                 _computeState = NOT_READY;
1227                         break;
1228                 case MODIF_ALGO_STATE:
1229                         if (_algoState == HYP_OK)
1230                                 _computeState = READY_TO_COMPUTE;
1231                         else
1232                                 _computeState = NOT_READY;
1233                         break;
1234                 case COMPUTE:                   // nothing to do
1235                         break;
1236                 case CLEAN:
1237                         break;
1238                 case CLEANDEP:
1239                         RemoveSubMeshElementsAndNodes();
1240                         if (_algoState == HYP_OK)
1241                                 _computeState = READY_TO_COMPUTE;
1242                         else
1243                                 _computeState = NOT_READY;
1244                         break;
1245                 case SUBMESH_COMPUTED:  // allow retry compute
1246                         if (_algoState == HYP_OK)
1247                                 _computeState = READY_TO_COMPUTE;
1248                         else
1249                                 _computeState = NOT_READY;
1250                         break;
1251                 default:
1252                         ASSERT(0);
1253                         break;
1254                 }
1255                 break;
1256
1257                 // ----------------------------------------------------------------------
1258         default:
1259                 ASSERT(0);
1260                 break;
1261         }
1262
1263         //SCRUTE(_computeState);
1264         return ret;
1265 }
1266
1267 //=============================================================================
1268 /*!
1269  * 
1270  */
1271 //=============================================================================
1272
1273 void SMESH_subMesh::UpdateDependantsState()
1274 {
1275         //MESSAGE("SMESH_subMesh::UpdateDependantsState");
1276
1277         const map < int, SMESH_subMesh * >&dependants = Dependants();
1278         map < int, SMESH_subMesh * >::const_iterator its;
1279         for (its = dependants.begin(); its != dependants.end(); its++)
1280         {
1281                 SMESH_subMesh *sm = (*its).second;
1282                 //SCRUTE((*its).first);
1283                 sm->ComputeStateEngine(SUBMESH_COMPUTED);
1284         }
1285 }
1286
1287 //=============================================================================
1288 /*!
1289  * 
1290  */
1291 //=============================================================================
1292
1293 void SMESH_subMesh::CleanDependants()
1294 {
1295         MESSAGE("SMESH_subMesh::CleanDependants");
1296         // **** parcourir les ancetres dans l'ordre de d├ępendance
1297
1298         const map < int, SMESH_subMesh * >&dependants = Dependants();
1299         map < int, SMESH_subMesh * >::const_iterator its;
1300         for (its = dependants.begin(); its != dependants.end(); its++)
1301         {
1302                 SMESH_subMesh *sm = (*its).second;
1303                 SCRUTE((*its).first);
1304                 sm->ComputeStateEngine(CLEANDEP);
1305         }
1306         ComputeStateEngine(CLEANDEP);
1307 }
1308
1309 //=============================================================================
1310 /*!
1311  * 
1312  */
1313 //=============================================================================
1314
1315 void SMESH_subMesh::RemoveSubMeshElementsAndNodes()
1316 {
1317         MESSAGE("SMESH_subMesh::RemoveSubMeshElementsAndNodes");
1318         SCRUTE(_subShape.ShapeType());
1319         SCRUTE(_Id);
1320
1321         _subMeshDS = _meshDS->MeshElements(_subShape);
1322         if (_subMeshDS!=NULL)
1323         {
1324                 const vector<int> & indElt = _subMeshDS->GetIDElements();
1325                 vector<int>::const_iterator ite=indElt.begin();
1326                 for (; ite!=indElt.end(); ite++)
1327                 {
1328                         int eltId = *ite;
1329                         SCRUTE(eltId);
1330                         const SMDS_MeshElement * elt = _meshDS->FindElement(eltId);
1331                         _subMeshDS->RemoveElement(elt);
1332                         _meshDS->RemoveElement(eltId);
1333                 }
1334
1335                 const vector<int> & indNodes = _subMeshDS->GetIDNodes();
1336                 vector<int>::const_iterator itn=indNodes.begin();
1337                 for (; itn!=indNodes.end(); itn++)
1338                 {
1339                         int nodeId = *itn;
1340                         SCRUTE(nodeId);
1341                         const SMDS_MeshNode * node = _meshDS->FindNode(nodeId);
1342                         _subMeshDS->RemoveNode(node);
1343                         _meshDS->RemoveNode(nodeId);
1344                 }
1345         }
1346 }
1347
1348 //=============================================================================
1349 /*!
1350  * 
1351  */
1352 //=============================================================================
1353
1354 const map < int, SMESH_subMesh * >&SMESH_subMesh::Dependants()
1355 {
1356         if (_dependantsFound)
1357                 return _mapDependants;
1358
1359         //MESSAGE("SMESH_subMesh::Dependants");
1360
1361         int shapeType = _subShape.ShapeType();
1362         //SCRUTE(shapeType);
1363         TopTools_IndexedDataMapOfShapeListOfShape M;
1364         TopoDS_Shape mainShape = _meshDS->ShapeToMesh();
1365
1366         switch (shapeType)
1367         {
1368         case TopAbs_VERTEX:
1369                 break;
1370         case TopAbs_EDGE:
1371         case TopAbs_WIRE:
1372                 TopExp::MapShapesAndAncestors(mainShape, TopAbs_EDGE, TopAbs_WIRE, M);
1373                 TopExp::MapShapesAndAncestors(mainShape, TopAbs_EDGE, TopAbs_FACE, M);
1374                 TopExp::MapShapesAndAncestors(mainShape, TopAbs_EDGE, TopAbs_SHELL, M);
1375                 TopExp::MapShapesAndAncestors(mainShape, TopAbs_EDGE, TopAbs_SOLID, M);
1376                 TopExp::MapShapesAndAncestors(mainShape, TopAbs_EDGE, TopAbs_COMPSOLID,
1377                         M);
1378                 ExtractDependants(M, TopAbs_EDGE);
1379                 break;
1380         case TopAbs_FACE:
1381         case TopAbs_SHELL:
1382                 TopExp::MapShapesAndAncestors(mainShape, TopAbs_FACE, TopAbs_SHELL, M);
1383                 TopExp::MapShapesAndAncestors(mainShape, TopAbs_FACE, TopAbs_SOLID, M);
1384                 TopExp::MapShapesAndAncestors(mainShape, TopAbs_FACE, TopAbs_COMPSOLID,
1385                         M);
1386                 ExtractDependants(M, TopAbs_FACE);
1387                 break;
1388         case TopAbs_SOLID:
1389         case TopAbs_COMPSOLID:
1390                 TopExp::MapShapesAndAncestors(mainShape, TopAbs_SOLID, TopAbs_COMPSOLID,
1391                         M);
1392                 ExtractDependants(M, TopAbs_SOLID);
1393                 break;
1394         case TopAbs_COMPOUND:
1395                 break;
1396         }
1397
1398         _dependantsFound = true;
1399         return _mapDependants;
1400 }
1401
1402 //=============================================================================
1403 /*!
1404  * 
1405  */
1406 //=============================================================================
1407
1408 void SMESH_subMesh::
1409 ExtractDependants(const TopTools_IndexedDataMapOfShapeListOfShape & M,
1410         const TopAbs_ShapeEnum etype)
1411 {
1412         //MESSAGE("SMESH_subMesh::ExtractDependants");
1413
1414         TopoDS_Shape mainShape = _meshDS->ShapeToMesh();
1415         int lg = M.Extent();
1416         //SCRUTE(lg);
1417
1418         int shapeType = _subShape.ShapeType();
1419         switch (shapeType)
1420         {
1421         case TopAbs_VERTEX:
1422                 break;
1423         case TopAbs_EDGE:
1424         case TopAbs_FACE:
1425         case TopAbs_SOLID:
1426         {
1427                 const TopTools_ListOfShape & ancestors = M.FindFromKey(_subShape);
1428                 TopTools_ListIteratorOfListOfShape it(ancestors);
1429                 for (; it.More(); it.Next())
1430                 {
1431                         TopoDS_Shape ancestor = it.Value();
1432                         SMESH_subMesh *aSubMesh = _father->GetSubMeshContaining(ancestor);
1433                         //      if (! aSubMesh) aSubMesh = _father->GetSubMesh(ancestor);
1434                         if (aSubMesh)
1435                         {
1436                                 int type = aSubMesh->_subShape.ShapeType();
1437                                 int cle = aSubMesh->GetId();
1438                                 cle += 10000000 * type; // sort map by ordType then index
1439                                 if (_mapDependants.find(cle) == _mapDependants.end())
1440                                 {
1441                                         _mapDependants[cle] = aSubMesh;
1442                                         //SCRUTE(cle);
1443                                 }
1444                         }
1445                 }
1446         }
1447                 break;
1448         case TopAbs_WIRE:
1449         case TopAbs_SHELL:
1450         case TopAbs_COMPSOLID:
1451                 for (TopExp_Explorer expE(_subShape, etype); expE.More(); expE.Next())
1452                 {
1453                         TopoDS_Shape aShape = expE.Current();
1454                         const TopTools_ListOfShape & ancestors = M.FindFromKey(aShape);
1455                         TopTools_ListIteratorOfListOfShape it(ancestors);
1456                         for (; it.More(); it.Next())
1457                         {
1458                                 MESSAGE("---");
1459                                 TopoDS_Shape ancestor = it.Value();
1460                                 SMESH_subMesh *aSubMesh =
1461                                         _father->GetSubMeshContaining(ancestor);
1462                                 if (!aSubMesh)
1463                                         aSubMesh = _father->GetSubMesh(ancestor);
1464                                 int type = aSubMesh->_subShape.ShapeType();
1465                                 int cle = aSubMesh->GetId();
1466                                 cle += 10000000 * type; // sort map by ordType then index
1467                                 if (_mapDependants.find(cle) == _mapDependants.end())
1468                                 {
1469                                         _mapDependants[cle] = aSubMesh;
1470                                         SCRUTE(cle);
1471                                 }
1472                         }
1473                 }
1474                 break;
1475         case TopAbs_COMPOUND:
1476                 break;
1477         }
1478 }