Salome HOME
PAL10974. Fix SubMeshesComputed(): there may be elements but no nodes in a submesh
[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 "SMESH_HypoFilter.hxx"
36
37 #include "utilities.h"
38 #include "OpUtil.hxx"
39
40 #include <BRep_Builder.hxx>
41
42 #include <TopExp.hxx>
43 #include <TopoDS_Compound.hxx>
44 #include <TopTools_MapOfShape.hxx>
45 #include <TopTools_ListOfShape.hxx>
46 #include <TopTools_ListIteratorOfListOfShape.hxx>
47 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
48
49 #ifdef _DEBUG_
50 #include <gp_Pnt.hxx>
51 #include <BRep_Tool.hxx>
52 #include <TopoDS.hxx>
53 #include <TopTools_IndexedMapOfShape.hxx>
54 #endif
55
56 //=============================================================================
57 /*!
58  *  default constructor:
59  */
60 //=============================================================================
61
62 SMESH_subMesh::SMESH_subMesh(int Id, SMESH_Mesh * father, SMESHDS_Mesh * meshDS,
63         const TopoDS_Shape & aSubShape)
64 {
65         _subShape = aSubShape;
66         _meshDS = meshDS;
67         _subMeshDS = meshDS->MeshElements(_subShape);   // may be null ...
68         _father = father;
69         _Id = Id;
70         _dependenceAnalysed = false;
71
72         if (_subShape.ShapeType() == TopAbs_VERTEX)
73         {
74                 _algoState = HYP_OK;
75                 _computeState = READY_TO_COMPUTE;
76         }
77         else
78         {
79                 _algoState = NO_ALGO;
80                 _computeState = NOT_READY;
81         }
82 }
83
84 //=============================================================================
85 /*!
86  *
87  */
88 //=============================================================================
89
90 SMESH_subMesh::~SMESH_subMesh()
91 {
92         MESSAGE("SMESH_subMesh::~SMESH_subMesh");
93         // ****
94 }
95
96 //=============================================================================
97 /*!
98  *
99  */
100 //=============================================================================
101
102 int SMESH_subMesh::GetId() const
103 {
104         //MESSAGE("SMESH_subMesh::GetId");
105         return _Id;
106 }
107
108 //=============================================================================
109 /*!
110  *
111  */
112 //=============================================================================
113
114 SMESHDS_SubMesh * SMESH_subMesh::GetSubMeshDS()
115 {
116         //MESSAGE("SMESH_subMesh::GetSubMeshDS");
117         if (_subMeshDS==NULL)
118         {
119                 //MESSAGE("subMesh pointer still null, trying to get it...");
120                 _subMeshDS = _meshDS->MeshElements(_subShape);  // may be null ...
121                 if (_subMeshDS==NULL)
122                 {
123                         MESSAGE("problem... subMesh still empty");
124                         //NRI   ASSERT(0);
125                         //NRI   throw SALOME_Exception(LOCALIZED(subMesh still empty));
126                 }
127         }
128         return _subMeshDS;
129 }
130
131 //=============================================================================
132 /*!
133  *
134  */
135 //=============================================================================
136
137 SMESHDS_SubMesh* SMESH_subMesh::CreateSubMeshDS()
138 {
139   if ( !GetSubMeshDS() )
140     _meshDS->NewSubMesh( _meshDS->ShapeToIndex( _subShape ) );
141
142   return GetSubMeshDS();
143 }
144
145 //=============================================================================
146 /*!
147  *
148  */
149 //=============================================================================
150
151 SMESH_subMesh *SMESH_subMesh::GetFirstToCompute()
152 {
153   //MESSAGE("SMESH_subMesh::GetFirstToCompute");
154   const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
155   SMESH_subMesh *firstToCompute = 0;
156
157   map < int, SMESH_subMesh * >::const_iterator itsub;
158   for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++)
159   {
160     SMESH_subMesh *sm = (*itsub).second;
161     //       SCRUTE(sm->GetId());
162     //       SCRUTE(sm->GetComputeState());
163     bool readyToCompute = (sm->GetComputeState() == READY_TO_COMPUTE);
164     if (readyToCompute)
165     {
166       firstToCompute = sm;
167       //SCRUTE(sm->GetId());
168       break;
169     }
170   }
171   if (firstToCompute)
172   {
173     return firstToCompute;      // a subMesh of this
174   }
175   if (_computeState == READY_TO_COMPUTE)
176   {
177     return this;                // this
178   }
179   return 0;                     // nothing to compute
180 }
181
182 //=============================================================================
183 /*!
184  *
185  */
186 //=============================================================================
187
188 bool SMESH_subMesh::SubMeshesComputed()
189 {
190   //MESSAGE("SMESH_subMesh::SubMeshesComputed");
191   const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
192
193   bool subMeshesComputed = true;
194   map < int, SMESH_subMesh * >::const_iterator itsub;
195   for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++)
196   {
197     SMESH_subMesh *sm = (*itsub).second;
198     SMESHDS_SubMesh * ds = sm->GetSubMeshDS();
199     // PAL10974.
200     // There are some tricks with compute states, e.g. Penta_3D leaves
201     // one face with READY_TO_COMPUTE state in order to be able to
202     // recompute 3D when a locale triangle hypo changes (see PAL7428).
203     // So we check if mesh is really present
204     //bool computeOk = (sm->GetComputeState() == COMPUTE_OK);
205     bool computeOk = ( ds && ( ds->GetNodes()->more() || ds->GetElements()->more() ));
206     if (!computeOk)
207     {
208       const TopoDS_Shape & ss = sm->GetSubShape();
209       int type = ss.ShapeType();
210
211       subMeshesComputed = false;
212
213       switch (type)
214       {
215       case TopAbs_COMPOUND:
216         {
217           MESSAGE("The not computed sub mesh is a COMPOUND");
218           break;
219         }
220       case TopAbs_COMPSOLID:
221         {
222           MESSAGE("The not computed sub mesh is a COMPSOLID");
223           break;
224         }
225       case TopAbs_SHELL:
226         {
227           MESSAGE("The not computed sub mesh is a SHEL");
228           break;
229         }
230       case TopAbs_WIRE:
231         {
232           MESSAGE("The not computed sub mesh is a WIRE");
233           break;
234         }
235       case TopAbs_SOLID:
236         {
237           MESSAGE("The not computed sub mesh is a SOLID");
238           break;
239         }
240       case TopAbs_FACE:
241         {
242           MESSAGE("The not computed sub mesh is a FACE");
243           break;
244         }
245       case TopAbs_EDGE:
246         {
247           MESSAGE("The not computed sub mesh is a EDGE");
248           break;
249         }
250       default:
251         {
252           MESSAGE("The not computed sub mesh is of unknown type");
253           break;
254         }
255       }
256
257       break;
258     }
259   }
260   return subMeshesComputed;
261 }
262
263 //=============================================================================
264 /*!
265  *
266  */
267 //=============================================================================
268
269 bool SMESH_subMesh::SubMeshesReady()
270 {
271   MESSAGE("SMESH_subMesh::SubMeshesReady");
272   const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
273
274   bool subMeshesReady = true;
275   map < int, SMESH_subMesh * >::const_iterator itsub;
276   for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++)
277   {
278     SMESH_subMesh *sm = (*itsub).second;
279     bool computeOk = ((sm->GetComputeState() == COMPUTE_OK)
280                       || (sm->GetComputeState() == READY_TO_COMPUTE));
281     if (!computeOk)
282     {
283       subMeshesReady = false;
284       SCRUTE(sm->GetId());
285       break;
286     }
287   }
288   return subMeshesReady;
289 }
290
291 //=============================================================================
292 /*!
293  * Construct dependence on first level subMeshes. complex shapes (compsolid,
294  * shell, wire) are not analysed the same way as simple shapes (solid, face,
295  * edge).
296  * For collection shapes (compsolid, shell, wire) prepare a list of submeshes
297  * with possible multiples occurences. Multiples occurences corresponds to
298  * internal frontiers within shapes of the collection and must not be keeped.
299  * See FinalizeDependence.
300  */
301 //=============================================================================
302
303 const map < int, SMESH_subMesh * >&SMESH_subMesh::DependsOn()
304 {
305   if (_dependenceAnalysed)
306     return _mapDepend;
307
308   //MESSAGE("SMESH_subMesh::DependsOn");
309
310   int type = _subShape.ShapeType();
311   //SCRUTE(type);
312   switch (type)
313   {
314   case TopAbs_COMPOUND:
315     {
316       //MESSAGE("compound");
317       for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More();
318            exp.Next())
319       {
320         InsertDependence(exp.Current());
321       }
322       for (TopExp_Explorer exp(_subShape, TopAbs_SHELL, TopAbs_SOLID); exp.More();
323            exp.Next())
324       {
325           InsertDependence(exp.Current());      //only shell not in solid
326       }
327       for (TopExp_Explorer exp(_subShape, TopAbs_FACE, TopAbs_SHELL); exp.More();
328            exp.Next())
329       {
330         InsertDependence(exp.Current());
331       }
332       for (TopExp_Explorer exp(_subShape, TopAbs_EDGE, TopAbs_FACE); exp.More();
333            exp.Next())
334       {
335         InsertDependence(exp.Current());
336       }
337       break;
338     }
339   case TopAbs_COMPSOLID:
340     {
341                 //MESSAGE("compsolid");
342       for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More();
343            exp.Next())
344       {
345         InsertDependence(exp.Current());
346       }
347       break;
348     }
349   case TopAbs_SHELL:
350     {
351       //MESSAGE("shell");
352       for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More();
353            exp.Next())
354       {
355         InsertDependence(exp.Current());
356       }
357       break;
358     }
359   case TopAbs_WIRE:
360     {
361       //MESSAGE("wire");
362       for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More();
363            exp.Next())
364       {
365         InsertDependence(exp.Current());
366       }
367       break;
368     }
369   case TopAbs_SOLID:
370     {
371       //MESSAGE("solid");
372       for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More();
373            exp.Next())
374       {
375         InsertDependence(exp.Current());
376       }
377       break;
378     }
379   case TopAbs_FACE:
380     {
381       //MESSAGE("face");
382       for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More();
383            exp.Next())
384       {
385         InsertDependence(exp.Current());
386       }
387       break;
388     }
389   case TopAbs_EDGE:
390     {
391       //MESSAGE("edge");
392       for (TopExp_Explorer exp(_subShape, TopAbs_VERTEX); exp.More();
393            exp.Next())
394       {
395                         InsertDependence(exp.Current());
396                       }
397       break;
398     }
399   case TopAbs_VERTEX:
400     {
401       break;
402     }
403   default:
404     {
405       break;
406     }
407   }
408   _dependenceAnalysed = true;
409   return _mapDepend;
410 }
411
412 //=============================================================================
413 /*!
414  * For simple Shapes (solid, face, edge): add subMesh into dependence list.
415  */
416 //=============================================================================
417
418 void SMESH_subMesh::InsertDependence(const TopoDS_Shape aSubShape)
419 {
420   //MESSAGE("SMESH_subMesh::InsertDependence");
421   SMESH_subMesh *aSubMesh = _father->GetSubMesh(aSubShape);
422   int type = aSubShape.ShapeType();
423   int ordType = 9 - type;               // 2 = Vertex, 8 = CompSolid
424   int cle = aSubMesh->GetId();
425   cle += 10000000 * ordType;    // sort map by ordType then index
426   if (_mapDepend.find(cle) == _mapDepend.end())
427   {
428     _mapDepend[cle] = aSubMesh;
429     const map < int, SMESH_subMesh * >&subMap = aSubMesh->DependsOn();
430     map < int, SMESH_subMesh * >::const_iterator im;
431     for (im = subMap.begin(); im != subMap.end(); im++)
432     {
433       int clesub = (*im).first;
434       SMESH_subMesh *sm = (*im).second;
435       if (_mapDepend.find(clesub) == _mapDepend.end())
436         _mapDepend[clesub] = sm;
437     }
438   }
439
440 }
441
442 //=============================================================================
443 /*!
444  *
445  */
446 //=============================================================================
447
448 const TopoDS_Shape & SMESH_subMesh::GetSubShape()
449 {
450         //MESSAGE("SMESH_subMesh::GetSubShape");
451         return _subShape;
452 }
453
454
455 //=======================================================================
456 //function : CanAddHypothesis
457 //purpose  : return true if theHypothesis can be attached to me:
458 //           its dimention is checked
459 //=======================================================================
460
461 bool SMESH_subMesh::CanAddHypothesis(const SMESH_Hypothesis* theHypothesis) const
462 {
463   int aHypDim   = theHypothesis->GetDim();
464   int aShapeDim = SMESH_Gen::GetShapeDim(_subShape);
465   if ( aHypDim <= aShapeDim )
466     return true;
467 //   if ( aHypDim < aShapeDim )
468 //     return ( _father->IsMainShape( _subShape ));
469
470   return false;
471 }
472
473 //=======================================================================
474 //function : IsApplicableHypotesis
475 //purpose  : 
476 //=======================================================================
477
478 bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis,
479                                           const TopAbs_ShapeEnum  theShapeType)
480 {
481   if ( theHypothesis->GetType() > SMESHDS_Hypothesis::PARAM_ALGO)
482     // algorithm
483     return ( theHypothesis->GetShapeType() & (1<< theShapeType));
484
485   // hypothesis
486   int aShapeDim = 100;
487   switch ( theShapeType ) {
488   case TopAbs_EDGE: aShapeDim = 1; break;
489   case TopAbs_FACE: aShapeDim = 2; break;
490   case TopAbs_SHELL:aShapeDim = 3; break;
491   case TopAbs_SOLID:aShapeDim = 3; break;
492 //   case TopAbs_VERTEX:
493 //   case TopAbs_WIRE:
494 //   case TopAbs_COMPSOLID:
495 //   case TopAbs_COMPOUND:
496   default:  return false;
497   }
498
499   return ( theHypothesis->GetDim() == aShapeDim );
500 }
501
502 //=============================================================================
503 /*!
504  *
505  */
506 //=============================================================================
507
508 SMESH_Hypothesis::Hypothesis_Status
509   SMESH_subMesh::AlgoStateEngine(int event, SMESH_Hypothesis * anHyp)
510 {
511   //  MESSAGE("SMESH_subMesh::AlgoStateEngine");
512   //SCRUTE(_algoState);
513   //SCRUTE(event);
514
515   // **** les retour des evenement shape sont significatifs
516   // (add ou remove fait ou non)
517   // le retour des evenement father n'indiquent pas que add ou remove fait
518
519   SMESH_Hypothesis::Hypothesis_Status aux_ret, ret = SMESH_Hypothesis::HYP_OK;
520
521   int dim = SMESH_Gen::GetShapeDim(_subShape);
522
523   if (dim < 1)
524   {
525     _algoState = HYP_OK;
526     if (event == ADD_HYP || event == ADD_ALGO)
527       return SMESH_Hypothesis::HYP_BAD_DIM; // do not allow to assign any hyp
528     else
529       return SMESH_Hypothesis::HYP_OK;
530   }
531
532   SMESH_Gen* gen =_father->GetGen();
533 //  bool ret = false;
534   int oldAlgoState = _algoState;
535   bool modifiedHyp = false;  // if set to true, force event MODIF_ALGO_STATE
536                              // in ComputeStateEngine
537
538   // ----------------------
539   // check mesh conformity
540   // ----------------------
541   if (event == ADD_ALGO)
542   {
543     if (IsApplicableHypotesis( anHyp ) &&
544         !_father->IsNotConformAllowed() &&
545         !IsConform( static_cast< SMESH_Algo* >( anHyp )))
546       return SMESH_Hypothesis::HYP_NOTCONFORM;
547   }
548
549   // ----------------------------------
550   // add a hypothesis to DS if possible
551   // ----------------------------------
552   if (event == ADD_HYP || event == ADD_ALGO)
553   {
554     if ( ! CanAddHypothesis( anHyp ))
555       return SMESH_Hypothesis::HYP_BAD_DIM;
556
557     if ( GetSimilarAttached( _subShape, anHyp ) )
558       return SMESH_Hypothesis::HYP_ALREADY_EXIST;
559
560     if ( !_meshDS->AddHypothesis(_subShape, anHyp))
561       return SMESH_Hypothesis::HYP_ALREADY_EXIST;
562
563     // Serve Propagation of 1D hypothesis
564     if (event == ADD_HYP) {
565       bool isPropagationOk = true;
566       string hypName = anHyp->GetName();
567
568       if (hypName == "Propagation") {
569         TopExp_Explorer exp (_subShape, TopAbs_EDGE);
570         TopTools_MapOfShape aMap;
571         for (; exp.More(); exp.Next()) {
572           if (aMap.Add(exp.Current())) {
573             if (!_father->BuildPropagationChain(exp.Current())) {
574               isPropagationOk = false;
575             }
576           }
577         }
578       }
579       else if (anHyp->GetDim() == 1) { // Only 1D hypothesis can be propagated
580         TopExp_Explorer exp (_subShape, TopAbs_EDGE);
581         TopTools_MapOfShape aMap;
582         for (; exp.More(); exp.Next()) {
583           if (aMap.Add(exp.Current())) {
584             TopoDS_Shape aMainEdge;
585             if (_father->IsPropagatedHypothesis(exp.Current(), aMainEdge)) {
586               isPropagationOk = _father->RebuildPropagationChains();
587             } else if (_father->IsPropagationHypothesis(exp.Current())) {
588               isPropagationOk = _father->BuildPropagationChain(exp.Current());
589             } else {
590             }
591           }
592         }
593       } else {
594       }
595
596       if (!isPropagationOk && ret < SMESH_Hypothesis::HYP_CONCURENT) {
597         ret = SMESH_Hypothesis::HYP_CONCURENT;
598       }
599     } // Serve Propagation of 1D hypothesis
600   }
601
602   // --------------------------
603   // remove a hypothesis from DS
604   // --------------------------
605   if (event == REMOVE_HYP || event == REMOVE_ALGO)
606   {
607     if (!_meshDS->RemoveHypothesis(_subShape, anHyp))
608       return SMESH_Hypothesis::HYP_OK; // nothing changes
609
610     // Serve Propagation of 1D hypothesis
611     if (event == REMOVE_HYP)
612     {
613       bool isPropagationOk = true;
614       SMESH_HypoFilter propagFilter( SMESH_HypoFilter::HasName( "Propagation" ));
615       if ( propagFilter.IsOk( anHyp, _subShape ))
616       {
617         TopExp_Explorer exp (_subShape, TopAbs_EDGE);
618         TopTools_MapOfShape aMap;
619         for (; exp.More(); exp.Next()) {
620           if (aMap.Add(exp.Current()) &&
621               !_father->GetHypothesis( exp.Current(), propagFilter, true )) {
622             // no more Propagation on the current edge
623             if (!_father->RemovePropagationChain(exp.Current())) {
624               return SMESH_Hypothesis::HYP_UNKNOWN_FATAL;
625             }
626           }
627         }
628         // rebuild propagation chains, because removing one
629         // chain can resolve concurention, existing before
630         isPropagationOk = _father->RebuildPropagationChains();
631       }
632       else if (anHyp->GetDim() == 1) // Only 1D hypothesis can be propagated
633       {
634         isPropagationOk = _father->RebuildPropagationChains();
635       }
636
637       if (!isPropagationOk && ret < SMESH_Hypothesis::HYP_CONCURENT) {
638         ret = SMESH_Hypothesis::HYP_CONCURENT;
639       }
640     } // Serve Propagation of 1D hypothesis
641   }
642
643   // ------------------
644   // analyse algo state
645   // ------------------
646   if (!IsApplicableHypotesis( anHyp ))
647     return ret; // not applicable hypotheses do not change algo state
648
649   switch (_algoState)
650   {
651
652     // ----------------------------------------------------------------------
653
654   case NO_ALGO:
655     switch (event) {
656     case ADD_HYP:
657       break;
658     case ADD_ALGO: {
659       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
660       ASSERT(algo);
661       if (algo->CheckHypothesis((*_father),_subShape, aux_ret))
662         SetAlgoState(HYP_OK);
663       else
664         SetAlgoState(MISSING_HYP);
665       break;
666     }
667     case REMOVE_HYP:
668       break;
669     case REMOVE_ALGO:
670       break;
671     case ADD_FATHER_HYP:
672       break;
673     case ADD_FATHER_ALGO: {    // Algo just added in father
674       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
675       ASSERT(algo);
676       if ( algo == anHyp ) {
677         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret))
678           SetAlgoState(HYP_OK);
679         else
680           SetAlgoState(MISSING_HYP);
681       }
682       break;
683     }
684     case REMOVE_FATHER_HYP:
685       break;
686     case REMOVE_FATHER_ALGO: {
687       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
688       if (algo)
689       {
690         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
691             SetAlgoState(HYP_OK);
692         else
693           SetAlgoState(MISSING_HYP);
694       }
695       break;
696     }
697     default:
698       ASSERT(0);
699       break;
700     }
701     break;
702
703     // ----------------------------------------------------------------------
704
705   case MISSING_HYP:
706     switch (event)
707     {
708     case ADD_HYP: {
709       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
710       ASSERT(algo);
711       if ( algo->CheckHypothesis((*_father),_subShape, ret ))
712         SetAlgoState(HYP_OK);
713       if (SMESH_Hypothesis::IsStatusFatal( ret ))
714         _meshDS->RemoveHypothesis(_subShape, anHyp);
715       else if (!_father->IsUsedHypothesis(  anHyp, _subShape ))
716       {
717         _meshDS->RemoveHypothesis(_subShape, anHyp);
718         ret = SMESH_Hypothesis::HYP_INCOMPATIBLE;
719       }
720       break;
721     }
722     case ADD_ALGO: {           //already existing algo : on father ?
723       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
724       ASSERT(algo);
725       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))// ignore hyp status
726         SetAlgoState(HYP_OK);
727       else
728         SetAlgoState(MISSING_HYP);
729       break;
730     }
731     case REMOVE_HYP:
732       break;
733     case REMOVE_ALGO: {        // perhaps a father algo applies ?
734       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
735       if (algo == NULL)  // no more algo applying on subShape...
736       {
737         SetAlgoState(NO_ALGO);
738       }
739       else
740       {
741         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
742           SetAlgoState(HYP_OK);
743         else
744           SetAlgoState(MISSING_HYP);
745       }
746       break;
747     }
748     case ADD_FATHER_HYP: {
749       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
750       ASSERT(algo);
751       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
752         SetAlgoState(HYP_OK);
753       else
754         SetAlgoState(MISSING_HYP);
755     }
756       break;
757     case ADD_FATHER_ALGO: { // new father algo
758       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
759       ASSERT( algo );
760       if ( algo == anHyp ) {
761         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
762           SetAlgoState(HYP_OK);
763         else
764           SetAlgoState(MISSING_HYP);
765       }
766       break;
767     }
768     case REMOVE_FATHER_HYP:    // nothing to do
769       break;
770     case REMOVE_FATHER_ALGO: {
771       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
772       if (algo == NULL)  // no more applying algo on father
773       {
774         SetAlgoState(NO_ALGO);
775       }
776       else
777       {
778         if ( algo->CheckHypothesis((*_father),_subShape , aux_ret ))
779           SetAlgoState(HYP_OK);
780         else
781           SetAlgoState(MISSING_HYP);
782       }
783       break;
784     }
785     default:
786       ASSERT(0);
787       break;
788     }
789     break;
790
791     // ----------------------------------------------------------------------
792
793   case HYP_OK:
794     switch (event)
795     {
796     case ADD_HYP: {
797       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
798       ASSERT(algo);
799       if (!algo->CheckHypothesis((*_father),_subShape, ret ))
800       {
801         if ( !SMESH_Hypothesis::IsStatusFatal( ret ))
802           // ret should be fatal: anHyp was not added
803           ret = SMESH_Hypothesis::HYP_INCOMPATIBLE;
804       }
805       else if (!_father->IsUsedHypothesis(  anHyp, _subShape ))
806         ret = SMESH_Hypothesis::HYP_INCOMPATIBLE;
807
808       if (SMESH_Hypothesis::IsStatusFatal( ret ))
809       {
810         MESSAGE("do not add extra hypothesis");
811         _meshDS->RemoveHypothesis(_subShape, anHyp);
812       }
813       else
814       {
815         modifiedHyp = true;
816       }
817       break;
818     }
819     case ADD_ALGO: {           //already existing algo : on father ?
820       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
821       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
822         // check if algo changes
823         SMESH_HypoFilter f;
824         f.Init(   SMESH_HypoFilter::IsAlgo() );
825         f.And(    SMESH_HypoFilter::IsApplicableTo( _subShape ));
826         f.AndNot( SMESH_HypoFilter::Is( algo ));
827         const SMESH_Hypothesis * prevAlgo = _father->GetHypothesis( _subShape, f, true );
828         if (prevAlgo && 
829             string(algo->GetName()) != string(prevAlgo->GetName()) )
830           modifiedHyp = true;
831       }
832       else
833         SetAlgoState(MISSING_HYP);
834       break;
835     }
836     case REMOVE_HYP: {
837       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
838       ASSERT(algo);
839       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
840         SetAlgoState(HYP_OK);
841       else
842         SetAlgoState(MISSING_HYP);
843       modifiedHyp = true;
844       break;
845     }
846     case REMOVE_ALGO: {         // perhaps a father algo applies ?
847       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
848       if (algo == NULL)   // no more algo applying on subShape...
849       {
850         SetAlgoState(NO_ALGO);
851       }
852       else
853       {
854         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
855           // check if algo remains
856           if ( anHyp != algo && strcmp( anHyp->GetName(), algo->GetName()) )
857             modifiedHyp = true;
858         }
859         else
860           SetAlgoState(MISSING_HYP);
861       }
862       break;
863     }
864     case ADD_FATHER_HYP: {  // new father hypothesis ?
865       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
866       ASSERT(algo);
867       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
868       {
869         if (_father->IsUsedHypothesis( anHyp, _subShape )) // new Hyp
870           modifiedHyp = true;
871       }
872       else
873         SetAlgoState(MISSING_HYP);
874       break;
875     }
876     case ADD_FATHER_ALGO: {
877       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
878       if ( algo == anHyp ) { // a new algo on father
879         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
880           // check if algo changes
881           SMESH_HypoFilter f;
882           f.Init(   SMESH_HypoFilter::IsAlgo() );
883           f.And(    SMESH_HypoFilter::IsApplicableTo( _subShape ));
884           f.AndNot( SMESH_HypoFilter::Is( algo ));
885           const SMESH_Hypothesis* prevAlgo = _father->GetHypothesis( _subShape, f, true );
886           if (prevAlgo && 
887               string(algo->GetName()) != string(prevAlgo->GetName()) )
888             modifiedHyp = true;
889         }
890         else
891           SetAlgoState(MISSING_HYP);
892       }
893       break;
894     }
895     case REMOVE_FATHER_HYP: {
896       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
897       ASSERT(algo);
898       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
899         // is there the same local hyp or maybe a new father algo applied?
900         if ( !GetSimilarAttached( _subShape, anHyp ) )
901           modifiedHyp = true;
902       }
903       else
904         SetAlgoState(MISSING_HYP);
905       break;
906     }
907     case REMOVE_FATHER_ALGO: {
908       SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape);
909       if (algo == NULL)  // no more applying algo on father
910       {
911         SetAlgoState(NO_ALGO);
912       }
913       else
914       {
915         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
916           // check if algo changes
917           if ( string(algo->GetName()) != string( anHyp->GetName()) )
918             modifiedHyp = true;
919         }
920         else
921           SetAlgoState(MISSING_HYP);
922       }
923       break;
924     }
925     default:
926       ASSERT(0);
927       break;
928     }
929     break;
930
931     // ----------------------------------------------------------------------
932
933   default:
934     ASSERT(0);
935     break;
936   }
937
938   if ((_algoState != oldAlgoState) || modifiedHyp)
939     ComputeStateEngine(MODIF_ALGO_STATE);
940
941   return ret;
942 }
943
944
945 //=======================================================================
946 //function : IsConform
947 //purpose  : check if a conform mesh will be produced by the Algo
948 //=======================================================================
949
950 bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo)
951 {
952 //  MESSAGE( "SMESH_subMesh::IsConform" );
953
954   if ( !theAlgo ) return false;
955
956   // check only algo that doesn't NeedDescretBoundary(): because mesh made
957   // on a sub-shape will be ignored by theAlgo
958   if ( theAlgo->NeedDescretBoundary() )
959     return true;
960
961   SMESH_Gen* gen =_father->GetGen();
962
963   // only local algo is to be checked
964   if ( gen->IsGlobalHypothesis( theAlgo, *_father ))
965     return true;
966
967   // check algo attached to adjacent shapes
968
969   // loop on one level down sub-meshes
970   TopoDS_Iterator itsub( _subShape );
971   for (; itsub.More(); itsub.Next())
972   {
973     // loop on adjacent subShapes
974     TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( itsub.Value() ));
975     for (; it.More(); it.Next())
976     {
977       const TopoDS_Shape& adjacent = it.Value();
978       if ( _subShape.IsSame( adjacent )) continue;
979       if ( adjacent.ShapeType() != _subShape.ShapeType())
980         break;
981
982       // check algo attached to smAdjacent
983       SMESH_Algo * algo = gen->GetAlgo((*_father), adjacent);
984       if (algo &&
985           //algo != theAlgo &&
986           !algo->NeedDescretBoundary() /*&&
987           !gen->IsGlobalHypothesis( algo, *_father )*/)
988         return false; // NOT CONFORM MESH WILL BE PRODUCED
989     }
990   }
991
992   return true;
993 }
994
995 //=============================================================================
996 /*!
997  *
998  */
999 //=============================================================================
1000
1001 void SMESH_subMesh::SetAlgoState(int state)
1002 {
1003 //      if (state != _oldAlgoState)
1004 //     int retc = ComputeStateEngine(MODIF_ALGO_STATE);
1005                 _algoState = state;
1006 }
1007
1008 //=============================================================================
1009 /*!
1010  *
1011  */
1012 //=============================================================================
1013 SMESH_Hypothesis::Hypothesis_Status
1014   SMESH_subMesh::SubMeshesAlgoStateEngine(int event,
1015                                           SMESH_Hypothesis * anHyp)
1016 {
1017   //MESSAGE("SMESH_subMesh::SubMeshesAlgoStateEngine");
1018   SMESH_Hypothesis::Hypothesis_Status ret = SMESH_Hypothesis::HYP_OK;
1019   //EAP: a wire (dim==1) should notify edges (dim==1)
1020   //EAP: int dim = SMESH_Gen::GetShapeDim(_subShape);
1021   if (/*EAP:dim > 1*/ _subShape.ShapeType() < TopAbs_EDGE )
1022   {
1023     const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
1024
1025     map < int, SMESH_subMesh * >::const_iterator itsub;
1026     for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++)
1027     {
1028       SMESH_subMesh *sm = (*itsub).second;
1029       SMESH_Hypothesis::Hypothesis_Status ret2 =
1030         sm->AlgoStateEngine(event, anHyp);
1031       if ( ret2 > ret )
1032         ret = ret2;
1033     }
1034   }
1035   return ret;
1036 }
1037
1038 //=============================================================================
1039 /*!
1040  *
1041  */
1042 //=============================================================================
1043
1044 void SMESH_subMesh::CleanDependsOn()
1045 {
1046         MESSAGE("SMESH_subMesh::CleanDependsOn");
1047         // **** parcourir les ancetres dans l'ordre de d├ępendance
1048
1049         ComputeStateEngine(CLEAN);
1050
1051         const map < int, SMESH_subMesh * >&dependson = DependsOn();
1052         map < int, SMESH_subMesh * >::const_iterator its;
1053         for (its = dependson.begin(); its != dependson.end(); its++)
1054         {
1055                 SMESH_subMesh *sm = (*its).second;
1056                 SCRUTE((*its).first);
1057                 sm->ComputeStateEngine(CLEAN);
1058         }
1059 }
1060
1061 //=============================================================================
1062 /*!
1063  *
1064  */
1065 //=============================================================================
1066
1067 void SMESH_subMesh::DumpAlgoState(bool isMain)
1068 {
1069         int dim = SMESH_Gen::GetShapeDim(_subShape);
1070 //   if (dim < 1) return;
1071         if (isMain)
1072         {
1073                 const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
1074
1075                 map < int, SMESH_subMesh * >::const_iterator itsub;
1076                 for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++)
1077                 {
1078                         SMESH_subMesh *sm = (*itsub).second;
1079                         sm->DumpAlgoState(false);
1080                 }
1081         }
1082         int type = _subShape.ShapeType();
1083         MESSAGE("dim = " << dim << " type of shape " << type);
1084         switch (_algoState)
1085         {
1086         case NO_ALGO:
1087                 MESSAGE(" AlgoState = NO_ALGO");
1088                 break;
1089         case MISSING_HYP:
1090                 MESSAGE(" AlgoState = MISSING_HYP");
1091                 break;
1092         case HYP_OK:
1093                 MESSAGE(" AlgoState = HYP_OK");
1094                 break;
1095         }
1096         switch (_computeState)
1097         {
1098         case NOT_READY:
1099                 MESSAGE(" ComputeState = NOT_READY");
1100                 break;
1101         case READY_TO_COMPUTE:
1102                 MESSAGE(" ComputeState = READY_TO_COMPUTE");
1103                 break;
1104         case COMPUTE_OK:
1105                 MESSAGE(" ComputeState = COMPUTE_OK");
1106                 break;
1107         case FAILED_TO_COMPUTE:
1108                 MESSAGE(" ComputeState = FAILED_TO_COMPUTE");
1109                 break;
1110         }
1111 }
1112
1113 //=============================================================================
1114 /*!
1115  *
1116  */
1117 //=============================================================================
1118
1119 static void removeSubMesh( SMESHDS_Mesh * meshDS, const TopoDS_Shape& subShape)
1120 {
1121   SMESHDS_SubMesh * subMeshDS = meshDS->MeshElements(subShape);
1122   if (subMeshDS!=NULL)
1123   {
1124     SMDS_ElemIteratorPtr ite=subMeshDS->GetElements();
1125     while(ite->more())
1126     {
1127       const SMDS_MeshElement * elt = ite->next();
1128       //MESSAGE( " RM elt: "<<elt->GetID()<<" ( "<<elt->NbNodes()<<" )" );
1129       meshDS->RemoveElement(elt);
1130     }
1131
1132     SMDS_NodeIteratorPtr itn=subMeshDS->GetNodes();
1133     while(itn->more())
1134     {
1135       const SMDS_MeshNode * node = itn->next();
1136       //MESSAGE( " RM node: "<<node->GetID());
1137       meshDS->RemoveNode(node);
1138     }
1139   }
1140 }
1141
1142 //=============================================================================
1143 /*!
1144  *
1145  */
1146 //=============================================================================
1147
1148 bool SMESH_subMesh::ComputeStateEngine(int event)
1149 {
1150   //MESSAGE("SMESH_subMesh::ComputeStateEngine");
1151   //SCRUTE(_computeState);
1152   //SCRUTE(event);
1153
1154   int dim = SMESH_Gen::GetShapeDim(_subShape);
1155
1156   if (dim < 1)
1157   {
1158     if ( IsMeshComputed() )
1159       _computeState = COMPUTE_OK;
1160     else
1161       _computeState = READY_TO_COMPUTE;
1162     return true;
1163   }
1164   SMESH_Gen *gen = _father->GetGen();
1165   SMESH_Algo *algo = 0;
1166   bool ret = true;
1167   SMESH_Hypothesis::Hypothesis_Status hyp_status;
1168
1169   switch (_computeState)
1170   {
1171
1172     // ----------------------------------------------------------------------
1173
1174   case NOT_READY:
1175     switch (event)
1176     {
1177     case MODIF_HYP:             // nothing to do
1178       break;
1179     case MODIF_ALGO_STATE:
1180       if (_algoState == HYP_OK)
1181       {
1182         _computeState = READY_TO_COMPUTE;
1183       }
1184       break;
1185     case COMPUTE:                       // nothing to do
1186       break;
1187     case CLEAN:
1188       RemoveSubMeshElementsAndNodes();
1189       break;
1190     case CLEANDEP:
1191       CleanDependants();
1192       break;
1193     case SUBMESH_COMPUTED:      // nothing to do
1194       break;
1195     case SUBMESH_RESTORED:
1196       ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
1197       break;
1198     case MESH_ENTITY_REMOVED:
1199       break;
1200     case CHECK_COMPUTE_STATE:
1201       if ( IsMeshComputed() )
1202         _computeState = COMPUTE_OK;
1203       break;
1204     default:
1205       ASSERT(0);
1206       break;
1207     }
1208     break;
1209
1210     // ----------------------------------------------------------------------
1211
1212   case READY_TO_COMPUTE:
1213     switch (event)
1214     {
1215     case MODIF_HYP:             // nothing to do
1216       break;
1217     case MODIF_ALGO_STATE:
1218       _computeState = NOT_READY;
1219       algo = gen->GetAlgo((*_father), _subShape);
1220       if (algo)
1221       {
1222         ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
1223         if (ret)
1224           _computeState = READY_TO_COMPUTE;
1225       }
1226       break;
1227     case COMPUTE:
1228       {
1229         algo = gen->GetAlgo((*_father), _subShape);
1230         ASSERT(algo);
1231         ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
1232         if (!ret)
1233         {
1234           MESSAGE("***** verify compute state *****");
1235           _computeState = NOT_READY;
1236           break;
1237         }
1238         // check submeshes needed
1239         if (algo->NeedDescretBoundary())
1240           ret = SubMeshesComputed();
1241         if (!ret)
1242         {
1243           MESSAGE("Some SubMeshes not computed");
1244           _computeState = FAILED_TO_COMPUTE;
1245           break;
1246         }
1247         // compute
1248         removeSubMesh( _meshDS, _subShape );
1249         if (!algo->NeedDescretBoundary() && !algo->OnlyUnaryInput())
1250           ret = ApplyToCollection( algo, GetCollection( gen, algo ) );
1251         else
1252           ret = algo->Compute((*_father), _subShape);
1253
1254         if (!ret)
1255         {
1256           MESSAGE("problem in algo execution: failed to compute");
1257           _computeState = FAILED_TO_COMPUTE;
1258           if (!algo->NeedDescretBoundary())
1259             UpdateSubMeshState( FAILED_TO_COMPUTE );
1260
1261 #ifdef _DEBUG_
1262           // Show vertices location of a failed shape
1263           TopTools_IndexedMapOfShape vMap;
1264           TopExp::MapShapes( _subShape, TopAbs_VERTEX, vMap );
1265           for ( int iv = 1; iv <= vMap.Extent(); ++iv ) {
1266             gp_Pnt P( BRep_Tool::Pnt( TopoDS::Vertex( vMap( iv ) )));
1267             cout << P.X() << " " << P.Y() << " " << P.Z() << " " << endl;
1268           }
1269 #endif
1270           break;
1271         }
1272         else
1273         {
1274           _computeState = COMPUTE_OK;
1275           UpdateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED
1276           if (!algo->NeedDescretBoundary())
1277             UpdateSubMeshState( COMPUTE_OK );
1278         }
1279       }
1280       break;
1281     case CLEAN:
1282       RemoveSubMeshElementsAndNodes();
1283       _computeState = NOT_READY;
1284       algo = gen->GetAlgo((*_father), _subShape);
1285       if (algo)
1286       {
1287         ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
1288         if (ret)
1289           _computeState = READY_TO_COMPUTE;
1290       }
1291       break;
1292     case CLEANDEP:
1293       CleanDependants();
1294       break;
1295     case SUBMESH_COMPUTED:      // nothing to do
1296       break;
1297     case SUBMESH_RESTORED:
1298       // check if a mesh is already computed that may
1299       // happen after retrieval from a file
1300       ComputeStateEngine( CHECK_COMPUTE_STATE );
1301       ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
1302       break;
1303     case MESH_ENTITY_REMOVED:
1304       break;
1305     case CHECK_COMPUTE_STATE:
1306       if ( IsMeshComputed() )
1307         _computeState = COMPUTE_OK;
1308       break;
1309     default:
1310       ASSERT(0);
1311       break;
1312     }
1313     break;
1314
1315     // ----------------------------------------------------------------------
1316
1317   case COMPUTE_OK:
1318     switch (event)
1319     {
1320     case MODIF_HYP:
1321       CleanDependants();        // recursive recall with event CLEANDEP
1322       algo = gen->GetAlgo((*_father), _subShape);
1323       if (algo && !algo->NeedDescretBoundary())
1324         CleanDependsOn(); // remove sub-mesh with event CLEANDEP
1325       break;
1326     case MODIF_ALGO_STATE:
1327       CleanDependants();        // recursive recall with event CLEANDEP
1328       algo = gen->GetAlgo((*_father), _subShape);
1329       if (algo && !algo->NeedDescretBoundary())
1330         CleanDependsOn(); // remove sub-mesh with event CLEANDEP
1331       break;
1332     case COMPUTE:                       // nothing to do
1333       break;
1334     case CLEAN:
1335       RemoveSubMeshElementsAndNodes();
1336       _computeState = NOT_READY;
1337       algo = gen->GetAlgo((*_father), _subShape);
1338       if (algo)
1339       {
1340         ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
1341         if (ret)
1342           _computeState = READY_TO_COMPUTE;
1343       }
1344       break;
1345     case CLEANDEP:
1346       CleanDependants();        // recursive recall with event CLEANDEP
1347       break;
1348     case SUBMESH_COMPUTED:      // nothing to do
1349       break;
1350     case SUBMESH_RESTORED:
1351       ComputeStateEngine( CHECK_COMPUTE_STATE );
1352       ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
1353       break;
1354     case MESH_ENTITY_REMOVED:
1355       UpdateDependantsState( CHECK_COMPUTE_STATE );
1356       ComputeStateEngine( CHECK_COMPUTE_STATE );
1357       ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
1358       break;
1359     case CHECK_COMPUTE_STATE:
1360       if ( !IsMeshComputed() )
1361         if (_algoState == HYP_OK)
1362           _computeState = READY_TO_COMPUTE;
1363         else
1364           _computeState = NOT_READY;
1365       break;
1366     default:
1367       ASSERT(0);
1368       break;
1369     }
1370     break;
1371
1372     // ----------------------------------------------------------------------
1373
1374   case FAILED_TO_COMPUTE:
1375     switch (event)
1376     {
1377     case MODIF_HYP:
1378       if (_algoState == HYP_OK)
1379         _computeState = READY_TO_COMPUTE;
1380       else
1381         _computeState = NOT_READY;
1382       break;
1383     case MODIF_ALGO_STATE:
1384       if (_algoState == HYP_OK)
1385         _computeState = READY_TO_COMPUTE;
1386       else
1387         _computeState = NOT_READY;
1388       break;
1389     case COMPUTE:      // nothing to do
1390       break;
1391     case CLEAN:
1392       RemoveSubMeshElementsAndNodes();
1393       if (_algoState == HYP_OK)
1394         _computeState = READY_TO_COMPUTE;
1395       else
1396         _computeState = NOT_READY;
1397       break;
1398     case CLEANDEP:
1399       CleanDependants();
1400       break;
1401     case SUBMESH_COMPUTED:      // allow retry compute
1402       if (_algoState == HYP_OK)
1403         _computeState = READY_TO_COMPUTE;
1404       else
1405         _computeState = NOT_READY;
1406       break;
1407     case SUBMESH_RESTORED:
1408       ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
1409       break;
1410     case MESH_ENTITY_REMOVED:
1411       break;
1412     case CHECK_COMPUTE_STATE:
1413       if ( IsMeshComputed() )
1414         _computeState = COMPUTE_OK;
1415       else
1416         if (_algoState == HYP_OK)
1417           _computeState = READY_TO_COMPUTE;
1418         else
1419           _computeState = NOT_READY;
1420       break;
1421     default:
1422       ASSERT(0);
1423       break;
1424     }
1425     break;
1426
1427     // ----------------------------------------------------------------------
1428   default:
1429     ASSERT(0);
1430     break;
1431   }
1432
1433   //SCRUTE(_computeState);
1434   return ret;
1435 }
1436
1437 //=======================================================================
1438 //function : ApplyToCollection
1439 //purpose  : Apply theAlgo to all subshapes in theCollection
1440 //=======================================================================
1441
1442 bool SMESH_subMesh::ApplyToCollection (SMESH_Algo*         theAlgo,
1443                                        const TopoDS_Shape& theCollection)
1444 {
1445   MESSAGE("SMESH_subMesh::ApplyToCollection");
1446   ASSERT ( !theAlgo->NeedDescretBoundary() );
1447
1448   bool ret = false;
1449
1450
1451   ret = theAlgo->Compute( *_father, theCollection );
1452
1453   // set _computeState of subshapes
1454   TopExp_Explorer anExplorer( theCollection, _subShape.ShapeType() );
1455   for ( ; anExplorer.More(); anExplorer.Next() )
1456   {
1457     const TopoDS_Shape& aSubShape = anExplorer.Current();
1458     SMESH_subMesh* subMesh = _father->GetSubMeshContaining( aSubShape );
1459     if ( subMesh )
1460     {
1461       if (ret)
1462       {
1463         subMesh->_computeState = COMPUTE_OK;
1464         subMesh->UpdateDependantsState( SUBMESH_COMPUTED );
1465         subMesh->UpdateSubMeshState( COMPUTE_OK );
1466       }
1467       else
1468       {
1469         subMesh->_computeState = FAILED_TO_COMPUTE;
1470       }
1471     }
1472   }
1473   return ret;
1474 }
1475
1476
1477 //=======================================================================
1478 //function : UpdateSubMeshState
1479 //purpose  :
1480 //=======================================================================
1481
1482 void SMESH_subMesh::UpdateSubMeshState(const compute_state theState)
1483 {
1484   const map<int, SMESH_subMesh*>& smMap = DependsOn();
1485   map<int, SMESH_subMesh*>::const_iterator itsub;
1486   for (itsub = smMap.begin(); itsub != smMap.end(); itsub++)
1487   {
1488     SMESH_subMesh* sm = (*itsub).second;
1489     sm->_computeState = theState;
1490   }
1491 }
1492
1493 //=======================================================================
1494 //function : ComputeSubMeshStateEngine
1495 //purpose  :
1496 //=======================================================================
1497
1498 void SMESH_subMesh::ComputeSubMeshStateEngine(int event)
1499 {
1500   const map<int, SMESH_subMesh*>& smMap = DependsOn();
1501   map<int, SMESH_subMesh*>::const_iterator itsub;
1502   for (itsub = smMap.begin(); itsub != smMap.end(); itsub++)
1503   {
1504     SMESH_subMesh* sm = (*itsub).second;
1505     sm->ComputeStateEngine(event);
1506   }
1507 }
1508
1509 //=======================================================================
1510 //function : UpdateDependantsState
1511 //purpose  :
1512 //=======================================================================
1513
1514 void SMESH_subMesh::UpdateDependantsState(const compute_event theEvent)
1515 {
1516   //MESSAGE("SMESH_subMesh::UpdateDependantsState");
1517   TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
1518   for (; it.More(); it.Next())
1519   {
1520     const TopoDS_Shape& ancestor = it.Value();
1521     SMESH_subMesh *aSubMesh =
1522       _father->GetSubMeshContaining(ancestor);
1523     if (aSubMesh)
1524       aSubMesh->ComputeStateEngine( theEvent );
1525   }
1526 }
1527
1528 //=============================================================================
1529 /*!
1530  *
1531  */
1532 //=============================================================================
1533
1534 void SMESH_subMesh::CleanDependants()
1535 {
1536   TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
1537   for (; it.More(); it.Next())
1538   {
1539     const TopoDS_Shape& ancestor = it.Value();
1540     // PAL8021. do not go upper than SOLID, else ComputeStateEngine(CLEANDEP)
1541     // will erase mesh on other shapes in a compound
1542     if ( ancestor.ShapeType() >= TopAbs_SOLID ) {
1543       SMESH_subMesh *aSubMesh = _father->GetSubMeshContaining(ancestor);
1544       if (aSubMesh)
1545         aSubMesh->ComputeStateEngine(CLEANDEP);
1546     }
1547   }
1548   ComputeStateEngine(CLEAN);
1549 }
1550
1551 //=============================================================================
1552 /*!
1553  *
1554  */
1555 //=============================================================================
1556
1557 void SMESH_subMesh::RemoveSubMeshElementsAndNodes()
1558 {
1559   //SCRUTE(_subShape.ShapeType());
1560
1561   removeSubMesh( _meshDS, _subShape );
1562
1563   // algo may bind a submesh not to _subShape, eg 3D algo
1564   // sets nodes on SHELL while _subShape may be SOLID
1565
1566   int dim = SMESH_Gen::GetShapeDim( _subShape );
1567   int type = _subShape.ShapeType() + 1;
1568   for ( ; type <= TopAbs_EDGE; type++)
1569     if ( dim == SMESH_Gen::GetShapeDim( (TopAbs_ShapeEnum) type ))
1570     {
1571       TopExp_Explorer exp( _subShape, (TopAbs_ShapeEnum) type );
1572       for ( ; exp.More(); exp.Next() )
1573         removeSubMesh( _meshDS, exp.Current() );
1574     }
1575     else
1576       break;
1577 }
1578
1579 //=======================================================================
1580 //function : IsMeshComputed
1581 //purpose  : check if _subMeshDS contains mesh elements
1582 //=======================================================================
1583
1584 bool SMESH_subMesh::IsMeshComputed() const
1585 {
1586   // algo may bind a submesh not to _subShape, eg 3D algo
1587   // sets nodes on SHELL while _subShape may be SOLID
1588
1589   int dim = SMESH_Gen::GetShapeDim( _subShape );
1590   int type = _subShape.ShapeType();
1591   for ( ; type <= TopAbs_VERTEX; type++) {
1592     if ( dim == SMESH_Gen::GetShapeDim( (TopAbs_ShapeEnum) type ))
1593     {
1594       TopExp_Explorer exp( _subShape, (TopAbs_ShapeEnum) type );
1595       for ( ; exp.More(); exp.Next() )
1596       {
1597         SMESHDS_SubMesh * subMeshDS = _meshDS->MeshElements( exp.Current() );
1598         if ( subMeshDS != NULL &&
1599             (subMeshDS->GetElements()->more() || subMeshDS->GetNodes()->more())) {
1600           return true;
1601         }
1602       }
1603     }
1604     else
1605       break;
1606   }
1607
1608   return false;
1609 }
1610
1611
1612 //=======================================================================
1613 //function : GetCollection
1614 //purpose  : return a shape containing all sub-shapes of the MainShape that can be
1615 //           meshed at once along with _subShape
1616 //=======================================================================
1617
1618 TopoDS_Shape SMESH_subMesh::GetCollection(SMESH_Gen * theGen, SMESH_Algo* theAlgo)
1619 {
1620   MESSAGE("SMESH_subMesh::GetCollection");
1621   ASSERT (!theAlgo->NeedDescretBoundary());
1622
1623   TopoDS_Shape mainShape = _father->GetMeshDS()->ShapeToMesh();
1624
1625   if ( mainShape.IsSame( _subShape ))
1626     return _subShape;
1627
1628   list<const SMESHDS_Hypothesis*> aUsedHyp =
1629     theAlgo->GetUsedHypothesis( *_father, _subShape ); // copy
1630
1631   // put in a compound all shapes with the same hypothesis assigned
1632   // and a good ComputState
1633
1634   TopoDS_Compound aCompound;
1635   BRep_Builder aBuilder;
1636   aBuilder.MakeCompound( aCompound );
1637
1638   TopExp_Explorer anExplorer( mainShape, _subShape.ShapeType() );
1639   for ( ; anExplorer.More(); anExplorer.Next() )
1640   {
1641     const TopoDS_Shape& S = anExplorer.Current();
1642     SMESH_subMesh* subMesh = _father->GetSubMesh( S );
1643     SMESH_Algo* anAlgo = theGen->GetAlgo( *_father, S );
1644
1645     if (subMesh->GetComputeState() == READY_TO_COMPUTE &&
1646         anAlgo == theAlgo &&
1647         anAlgo->GetUsedHypothesis( *_father, S ) == aUsedHyp)
1648     {
1649       aBuilder.Add( aCompound, S );
1650     }
1651   }
1652
1653   return aCompound;
1654 }
1655
1656 //=======================================================================
1657 //function : GetSimilarAttached
1658 //purpose  : return nb of hypotheses attached to theShape.
1659 //           If theHyp is provided, similar but not same hypotheses
1660 //           are countered; else only applicable ones having theHypType
1661 //           are countered
1662 //=======================================================================
1663
1664 const SMESH_Hypothesis* SMESH_subMesh::GetSimilarAttached(const TopoDS_Shape&      theShape,
1665                                                           const SMESH_Hypothesis * theHyp,
1666                                                           const int                theHypType)
1667 {
1668   SMESH_HypoFilter filter;
1669   filter.Init( SMESH_HypoFilter::HasType( theHyp ? theHyp->GetType() : theHypType ));
1670   if ( theHyp ) {
1671     filter.And( SMESH_HypoFilter::HasDim( theHyp->GetDim() ));
1672     filter.AndNot( SMESH_HypoFilter::Is( theHyp ));
1673   }
1674   else
1675     filter.And( SMESH_HypoFilter::IsApplicableTo( theShape ));
1676
1677   return _father->GetHypothesis( theShape, filter, false );
1678 }
1679
1680 //=======================================================================
1681 //function : CheckConcurentHypothesis
1682 //purpose  : check if there are several applicable hypothesis attached to
1683 //           ansestors
1684 //=======================================================================
1685
1686 SMESH_Hypothesis::Hypothesis_Status
1687   SMESH_subMesh::CheckConcurentHypothesis (const int theHypType)
1688 {
1689   MESSAGE ("SMESH_subMesh::CheckConcurentHypothesis");
1690
1691   // is there local hypothesis on me?
1692   if ( GetSimilarAttached( _subShape, 0, theHypType ) )
1693     return SMESH_Hypothesis::HYP_OK;
1694
1695
1696   TopoDS_Shape aPrevWithHyp;
1697   const SMESH_Hypothesis* aPrevHyp = 0;
1698   TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
1699   for (; it.More(); it.Next())
1700   {
1701     const TopoDS_Shape& ancestor = it.Value();
1702     const SMESH_Hypothesis* hyp = GetSimilarAttached( ancestor, 0, theHypType );
1703     if ( hyp )
1704     {
1705       if ( aPrevWithHyp.IsNull() || aPrevWithHyp.IsSame( ancestor ))
1706       {
1707         aPrevWithHyp = ancestor;
1708         aPrevHyp     = hyp;
1709       }
1710       else if ( aPrevWithHyp.ShapeType() == ancestor.ShapeType() && aPrevHyp != hyp )
1711         return SMESH_Hypothesis::HYP_CONCURENT;
1712       else
1713         return SMESH_Hypothesis::HYP_OK;
1714     }
1715   }
1716   return SMESH_Hypothesis::HYP_OK;
1717 }