src/SMESH/SMESH_subMesh.cxx

   1 // Copyright (C) 2007-2019  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 //  SMESH SMESH : implementation of SMESH idl descriptions
  24 //  File   : SMESH_subMesh.cxx
  25 //  Author : Paul RASCLE, EDF
  26 //  Module : SMESH
  27
  28 #include "SMESH_subMesh.hxx"
  29
  30 #include "SMDS_SetIterator.hxx"
  31 #include "SMESHDS_Mesh.hxx"
  32 #include "SMESH_Algo.hxx"
  33 #include "SMESH_Comment.hxx"
  34 #include "SMESH_Gen.hxx"
  35 #include "SMESH_HypoFilter.hxx"
  36 #include "SMESH_Hypothesis.hxx"
  37 #include "SMESH_Mesh.hxx"
  38 #include "SMESH_MesherHelper.hxx"
  39 #include "SMESH_subMeshEventListener.hxx"
  40
  41 #include "utilities.h"
  42 #include "OpUtil.hxx"
  43 #include "Basics_Utils.hxx"
  44
  45 #include <BRep_Builder.hxx>
  46 #include <BRep_Tool.hxx>
  47 #include <TopExp.hxx>
  48 #include <TopExp_Explorer.hxx>
  49 #include <TopTools_IndexedMapOfShape.hxx>
  50 #include <TopTools_ListIteratorOfListOfShape.hxx>
  51 #include <TopTools_ListOfShape.hxx>
  52 #include <TopoDS.hxx>
  53 #include <TopoDS_Compound.hxx>
  54 #include <TopoDS_Iterator.hxx>
  55 #include <gp_Pnt.hxx>
  56
  57 #include <Standard_OutOfMemory.hxx>
  58 #include <Standard_ErrorHandler.hxx>
  59
  60 #include <numeric>
  61
  62 using namespace std;
  63
  64 #ifdef _DEBUG_
  65 // enable printing algo + shape id + hypo used while meshing
  66 //#define PRINT_WHO_COMPUTE_WHAT
  67 #endif
  68
  69 //=============================================================================
  70 /*!
  71  * \brief Allocate some memory at construction and release it at destruction.
  72  * Is used to be able to continue working after mesh generation breaks due to
  73  * lack of memory
  74  */
  75 //=============================================================================
  76
  77 struct MemoryReserve
  78 {
  79   char* myBuf;
  80   MemoryReserve(): myBuf( new char[1024*1024*2] ){}
  81   ~MemoryReserve() { delete [] myBuf; }
  82 };
  83
  84 //=============================================================================
  85 /*!
  86  *  default constructor:
  87  */
  88 //=============================================================================
  89
  90 SMESH_subMesh::SMESH_subMesh(int                  Id,
  91                              SMESH_Mesh *         father,
  92                              SMESHDS_Mesh *       meshDS,
  93                              const TopoDS_Shape & aSubShape)
  94 {
  95   _subShape           = aSubShape;
  96   _subMeshDS          = meshDS->MeshElements(_subShape);   // may be null ...
  97   _father             = father;
  98   _Id                 = Id;
  99   _dependenceAnalysed = _alwaysComputed = false;
 100   _algo               = 0;
 101   if (_subShape.ShapeType() == TopAbs_VERTEX)
 102   {
 103     _algoState = HYP_OK;
 104     _computeState = READY_TO_COMPUTE;
 105   }
 106   else
 107   {
 108     _algoState = NO_ALGO;
 109     _computeState = NOT_READY;
 110   }
 111   _computeCost = 0; // how costly is to compute this sub-mesh
 112   _realComputeCost = 0;
 113 }
 114
 115 //=============================================================================
 116 /*!
 117  *
 118  */
 119 //=============================================================================
 120
 121 SMESH_subMesh::~SMESH_subMesh()
 122 {
 123   deleteOwnListeners();
 124 }
 125
 126 //=============================================================================
 127 /*!
 128  *
 129  */
 130 //=============================================================================
 131
 132 int SMESH_subMesh::GetId() const
 133 {
 134   //MESSAGE("SMESH_subMesh::GetId");
 135   return _Id;
 136 }
 137
 138 //=============================================================================
 139 /*!
 140  *
 141  */
 142 //=============================================================================
 143
 144 SMESHDS_SubMesh * SMESH_subMesh::GetSubMeshDS()
 145 {
 146   // submesh appears in DS only when a mesher set nodes and elements on a shape
 147   return _subMeshDS ? _subMeshDS : _subMeshDS = _father->GetMeshDS()->MeshElements(_subShape); // may be null
 148 }
 149
 150 //=============================================================================
 151 /*!
 152  *
 153  */
 154 //=============================================================================
 155
 156 const SMESHDS_SubMesh * SMESH_subMesh::GetSubMeshDS() const
 157 {
 158   return ((SMESH_subMesh*) this )->GetSubMeshDS();
 159 }
 160
 161 //=============================================================================
 162 /*!
 163  *
 164  */
 165 //=============================================================================
 166
 167 SMESHDS_SubMesh* SMESH_subMesh::CreateSubMeshDS()
 168 {
 169   if ( !GetSubMeshDS() ) {
 170     SMESHDS_Mesh* meshDS = _father->GetMeshDS();
 171     meshDS->NewSubMesh( meshDS->ShapeToIndex( _subShape ) );
 172   }
 173   return GetSubMeshDS();
 174 }
 175
 176 //=============================================================================
 177 /*!
 178  *
 179  */
 180 //=============================================================================
 181
 182 SMESH_subMesh *SMESH_subMesh::GetFirstToCompute()
 183 {
 184   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(true,false);
 185   while ( smIt->more() ) {
 186     SMESH_subMesh *sm = smIt->next();
 187     if ( sm->GetComputeState() == READY_TO_COMPUTE )
 188       return sm;
 189   }
 190   return 0;                     // nothing to compute
 191 }
 192
 193 //================================================================================
 194 /*!
 195  * \brief Returns a current algorithm
 196  */
 197 //================================================================================
 198
 199 SMESH_Algo* SMESH_subMesh::GetAlgo() const
 200 {
 201   if ( !_algo )
 202   {
 203     SMESH_subMesh* me = const_cast< SMESH_subMesh* >( this );
 204     me->_algo = _father->GetGen()->GetAlgo( me );
 205   }
 206   return _algo;
 207 }
 208
 209 //================================================================================
 210 /*!
 211  * \brief Allow algo->Compute() if a sub-shape of lower dim is meshed but
 212  *        none mesh entity is bound to it (PAL13615, 2nd part)
 213  */
 214 //================================================================================
 215
 216 void SMESH_subMesh::SetIsAlwaysComputed(bool isAlCo)
 217 {
 218   _alwaysComputed = isAlCo;
 219   if ( _alwaysComputed )
 220     _computeState = COMPUTE_OK;
 221   else
 222     ComputeStateEngine( CHECK_COMPUTE_STATE );
 223 }
 224
 225 //=======================================================================
 226 /*!
 227  * \brief Return true if no mesh entities is bound to the submesh
 228  */
 229 //=======================================================================
 230
 231 bool SMESH_subMesh::IsEmpty() const
 232 {
 233   if (SMESHDS_SubMesh * subMeshDS = ((SMESH_subMesh*)this)->GetSubMeshDS())
 234     return (!subMeshDS->NbElements() && !subMeshDS->NbNodes());
 235   return true;
 236 }
 237
 238 //=======================================================================
 239 //function : IsMeshComputed
 240 //purpose  : check if _subMeshDS contains mesh elements
 241 //=======================================================================
 242
 243 bool SMESH_subMesh::IsMeshComputed() const
 244 {
 245   if ( _alwaysComputed )
 246     return true;
 247   // algo may bind a sub-mesh not to _subShape, eg 3D algo
 248   // sets nodes on SHELL while _subShape may be SOLID
 249
 250   SMESHDS_Mesh* meshDS = _father->GetMeshDS();
 251   int dim = SMESH_Gen::GetShapeDim( _subShape );
 252   int type = _subShape.ShapeType();
 253   for ( ; type <= TopAbs_VERTEX; type++) {
 254     if ( dim == SMESH_Gen::GetShapeDim( (TopAbs_ShapeEnum) type ))
 255     {
 256       TopExp_Explorer exp( _subShape, (TopAbs_ShapeEnum) type );
 257       for ( ; exp.More(); exp.Next() )
 258       {
 259         if ( SMESHDS_SubMesh * smDS = meshDS->MeshElements( exp.Current() ))
 260         {
 261           bool computed = (dim > 0) ? smDS->NbElements() : smDS->NbNodes();
 262           if ( computed )
 263             return true;
 264         }
 265       }
 266     }
 267     else
 268       break;
 269   }
 270
 271   return false;
 272 }
 273
 274 //=============================================================================
 275 /*!
 276  * Return true if all sub-meshes have been meshed
 277  */
 278 //=============================================================================
 279
 280 bool SMESH_subMesh::SubMeshesComputed(bool * isFailedToCompute/*=0*/) const
 281 {
 282   int myDim = SMESH_Gen::GetShapeDim( _subShape );
 283   int dimToCheck = myDim - 1;
 284   bool subMeshesComputed = true;
 285   if ( isFailedToCompute ) *isFailedToCompute = false;
 286   // check sub-meshes with upper dimension => reverse iteration
 287   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true);
 288   while ( smIt->more() )
 289   {
 290     SMESH_subMesh *sm = smIt->next();
 291     if ( sm->_alwaysComputed )
 292       continue;
 293     const TopoDS_Shape & ss = sm->GetSubShape();
 294
 295     // MSV 07.04.2006: restrict checking to myDim-1 only. Ex., there is no sense
 296     // in checking of existence of edges if the algo needs only faces. Moreover,
 297     // degenerated edges may have no sub-mesh, as after computing NETGEN_2D.
 298     if ( !_algo || _algo->NeedDiscreteBoundary() ) {
 299       int dim = SMESH_Gen::GetShapeDim( ss );
 300       if (dim < dimToCheck)
 301         break; // the rest sub-meshes are all of less dimension
 302     }
 303     SMESHDS_SubMesh * ds = sm->GetSubMeshDS();
 304     bool computeOk = ((sm->GetComputeState() == COMPUTE_OK ) ||
 305                       (ds && ( dimToCheck ? ds->NbElements() : ds->NbNodes() )));
 306     if (!computeOk)
 307     {
 308       subMeshesComputed = false;
 309
 310       if ( isFailedToCompute && !(*isFailedToCompute) )
 311         *isFailedToCompute = ( sm->GetComputeState() == FAILED_TO_COMPUTE );
 312
 313       if ( !isFailedToCompute )
 314         break;
 315     }
 316   }
 317   return subMeshesComputed;
 318 }
 319
 320 //================================================================================
 321 /*!
 322  * \brief Return cost of computing this sub-mesh. If hypotheses are not well defined,
 323  *        zero is returned
 324  *  \return int - the computation cost in abstract units.
 325  */
 326 //================================================================================
 327
 328 int SMESH_subMesh::GetComputeCost() const
 329 {
 330   return _realComputeCost;
 331 }
 332
 333 //================================================================================
 334 /*!
 335  * \brief Return cost of computing this sub-mesh. The cost depends on the shape type
 336  *        and number of sub-meshes this one DependsOn().
 337  *  \return int - the computation cost in abstract units.
 338  */
 339 //================================================================================
 340
 341 int SMESH_subMesh::computeCost() const
 342 {
 343   if ( !_computeCost )
 344   {
 345     int computeCost;
 346     switch ( _subShape.ShapeType() ) {
 347     case TopAbs_SOLID:
 348     case TopAbs_SHELL: computeCost = 5000; break;
 349     case TopAbs_FACE:  computeCost = 500; break;
 350     case TopAbs_EDGE:  computeCost = 2; break;
 351     default:           computeCost = 1;
 352     }
 353     SMESH_subMeshIteratorPtr childIt = getDependsOnIterator(/*includeSelf=*/false);
 354     while ( childIt->more() )
 355       computeCost += childIt->next()->computeCost();
 356
 357     ((SMESH_subMesh*)this)->_computeCost = computeCost;
 358   }
 359   return _computeCost;
 360 }
 361
 362 //=============================================================================
 363 /*!
 364  * Returns all sub-meshes this one depend on
 365  */
 366 //=============================================================================
 367
 368 const std::map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn()
 369 {
 370   if ( _dependenceAnalysed || !_father->HasShapeToMesh() )
 371     return _mapDepend;
 372
 373   int type = _subShape.ShapeType();
 374   switch (type)
 375   {
 376   case TopAbs_COMPOUND:
 377   {
 378     list< TopoDS_Shape > compounds( 1, _subShape );
 379     list< TopoDS_Shape >::iterator comp = compounds.begin();
 380     for ( ; comp != compounds.end(); ++comp )
 381     {
 382       for ( TopoDS_Iterator sub( *comp ); sub.More(); sub.Next() )
 383         switch ( sub.Value().ShapeType() )
 384         {
 385         case TopAbs_COMPOUND:  compounds.push_back( sub.Value() ); break;
 386         case TopAbs_COMPSOLID: insertDependence( sub.Value(), TopAbs_SOLID ); break;
 387         case TopAbs_SOLID:     insertDependence( sub.Value(), TopAbs_SOLID ); break;
 388         case TopAbs_SHELL:     insertDependence( sub.Value(), TopAbs_FACE ); break;
 389         case TopAbs_FACE:      insertDependence( sub.Value(), TopAbs_FACE ); break;
 390         case TopAbs_WIRE:      insertDependence( sub.Value(), TopAbs_EDGE ); break;
 391         case TopAbs_EDGE:      insertDependence( sub.Value(), TopAbs_EDGE ); break;
 392         case TopAbs_VERTEX:    insertDependence( sub.Value(), TopAbs_VERTEX ); break;
 393         default:;
 394         }
 395     }
 396   }
 397   break;
 398   case TopAbs_COMPSOLID: insertDependence( _subShape, TopAbs_SOLID ); break;
 399   case TopAbs_SOLID:     insertDependence( _subShape, TopAbs_FACE );
 400   { /*internal EDGE*/    insertDependence( _subShape, TopAbs_EDGE, TopAbs_WIRE ); break; }
 401   case TopAbs_SHELL:     insertDependence( _subShape, TopAbs_FACE ); break;
 402   case TopAbs_FACE:      insertDependence( _subShape, TopAbs_EDGE ); break;
 403   case TopAbs_WIRE:      insertDependence( _subShape, TopAbs_EDGE ); break;
 404   case TopAbs_EDGE:      insertDependence( _subShape, TopAbs_VERTEX ); break;
 405   default:;
 406   }
 407   _dependenceAnalysed = true;
 408   return _mapDepend;
 409 }
 410
 411 //================================================================================
 412 /*!
 413  * \brief Return a key for SMESH_subMesh::_mapDepend map
 414  */
 415 //================================================================================
 416
 417 namespace
 418 {
 419   int dependsOnMapKey( TopAbs_ShapeEnum type, int shapeID )
 420   {
 421     int ordType = 9 - int(type);               // 2 = Vertex, 8 = CompSolid
 422     int     cle = shapeID;
 423     cle += 10000000 * ordType;    // sort map by ordType then index
 424     return cle;
 425   }
 426   int dependsOnMapKey( const SMESH_subMesh* sm )
 427   {
 428     return dependsOnMapKey( sm->GetSubShape().ShapeType(), sm->GetId() );
 429   }
 430 }
 431
 432 //=============================================================================
 433 /*!
 434  * Add sub-meshes on sub-shapes of a given type into the dependence map.
 435  */
 436 //=============================================================================
 437
 438 void SMESH_subMesh::insertDependence(const TopoDS_Shape aShape,
 439                                      TopAbs_ShapeEnum   aSubType,
 440                                      TopAbs_ShapeEnum   avoidType)
 441 {
 442   TopExp_Explorer sub( aShape, aSubType, avoidType );
 443   for ( ; sub.More(); sub.Next() )
 444   {
 445     SMESH_subMesh *aSubMesh = _father->GetSubMesh( sub.Current() );
 446     if ( aSubMesh->GetId() == 0 )
 447       continue;  // not a sub-shape of the shape to mesh
 448     int cle = dependsOnMapKey( aSubMesh );
 449     if ( _mapDepend.find( cle ) == _mapDepend.end())
 450     {
 451       _mapDepend[cle] = aSubMesh;
 452       const map < int, SMESH_subMesh * > & subMap = aSubMesh->DependsOn();
 453       _mapDepend.insert( subMap.begin(), subMap.end() );
 454     }
 455   }
 456 }
 457
 458 //================================================================================
 459 /*!
 460  * \brief Return \c true if \a this sub-mesh depends on \a other
 461  */
 462 //================================================================================
 463
 464 bool SMESH_subMesh::DependsOn( const SMESH_subMesh* other ) const
 465 {
 466   return other ? _mapDepend.count( dependsOnMapKey( other )) : false;
 467 }
 468
 469 //================================================================================
 470 /*!
 471  * \brief Return \c true if \a this sub-mesh depends on a \a shape
 472  */
 473 //================================================================================
 474
 475 bool SMESH_subMesh::DependsOn( const int shapeID ) const
 476 {
 477   return DependsOn( _father->GetSubMeshContaining( shapeID ));
 478 }
 479
 480 //=============================================================================
 481 /*!
 482  * Return a shape of \a this sub-mesh
 483  */
 484 //=============================================================================
 485
 486 const TopoDS_Shape & SMESH_subMesh::GetSubShape() const
 487 {
 488   return _subShape;
 489 }
 490
 491 //=======================================================================
 492 //function : CanAddHypothesis
 493 //purpose  : return true if theHypothesis can be attached to me:
 494 //           its dimension is checked
 495 //=======================================================================
 496
 497 bool SMESH_subMesh::CanAddHypothesis(const SMESH_Hypothesis* theHypothesis) const
 498 {
 499   int aHypDim   = theHypothesis->GetDim();
 500   int aShapeDim = SMESH_Gen::GetShapeDim(_subShape);
 501   // issue 21106. Forbid 3D mesh on the SHELL
 502   // if (aHypDim == 3 && aShapeDim == 3) {
 503   //   // check case of open shell
 504   //   //if (_subShape.ShapeType() == TopAbs_SHELL && !_subShape.Closed())
 505   //   if (_subShape.ShapeType() == TopAbs_SHELL && !BRep_Tool::IsClosed(_subShape))
 506   //     return false;
 507   // }
 508   if ( aHypDim <= aShapeDim )
 509     return true;
 510
 511   return false;
 512 }
 513
 514 //=======================================================================
 515 //function : IsApplicableHypothesis
 516 //purpose  : check if this sub-mesh can be computed using a hypothesis
 517 //=======================================================================
 518
 519 bool SMESH_subMesh::IsApplicableHypothesis(const SMESH_Hypothesis* theHypothesis) const
 520 {
 521   if ( !_father->HasShapeToMesh() && _subShape.ShapeType() == TopAbs_SOLID )
 522     return true; // true for the PseudoShape
 523
 524   return IsApplicableHypothesis( theHypothesis, _subShape.ShapeType() );
 525 }
 526
 527 //=======================================================================
 528 //function : IsApplicableHypothesis
 529 //purpose  : compare shape type and hypothesis type
 530 //=======================================================================
 531
 532 bool SMESH_subMesh::IsApplicableHypothesis(const SMESH_Hypothesis* theHypothesis,
 533                                            const TopAbs_ShapeEnum  theShapeType)
 534 {
 535   if ( theHypothesis->GetType() > SMESHDS_Hypothesis::PARAM_ALGO)
 536   {
 537     // algorithm
 538     if ( theHypothesis->GetShapeType() & (1<< theShapeType))
 539       // issue 21106. Forbid 3D mesh on the SHELL
 540       return !( theHypothesis->GetDim() == 3 && theShapeType == TopAbs_SHELL );
 541     else
 542       return false;
 543   }
 544
 545   // hypothesis
 546   switch ( theShapeType ) {
 547   case TopAbs_VERTEX:
 548   case TopAbs_EDGE:
 549   case TopAbs_FACE:
 550   case TopAbs_SOLID:
 551     return SMESH_Gen::GetShapeDim( theShapeType ) == theHypothesis->GetDim();
 552
 553   case TopAbs_SHELL:
 554     // Special case for algorithms, building 2D mesh on a whole shell.
 555     // Before this fix there was a problem after restoring from study,
 556     // because in that case algorithm is assigned before hypothesis
 557     // (on shell in problem case) and hypothesis is checked on faces
 558     // (because it is 2D), where we have NO_ALGO state.
 559     // Now 2D hypothesis is also applicable to shells.
 560     return (theHypothesis->GetDim() == 2 || theHypothesis->GetDim() == 3);
 561
 562 //   case TopAbs_WIRE:
 563 //   case TopAbs_COMPSOLID:
 564 //   case TopAbs_COMPOUND:
 565   default:;
 566   }
 567   return false;
 568 }
 569
 570 //================================================================================
 571 /*!
 572  * \brief Treats modification of hypotheses definition
 573  *  \param [in] event - what happens
 574  *  \param [in] anHyp - a hypothesis
 575  *  \return SMESH_Hypothesis::Hypothesis_Status - a treatment result.
 576  *
 577  * Optional description of a problematic situation (if any) can be retrieved
 578  * via GetComputeError().
 579  */
 580 //================================================================================
 581
 582 SMESH_Hypothesis::Hypothesis_Status
 583   SMESH_subMesh::AlgoStateEngine(algo_event event, SMESH_Hypothesis * anHyp)
 584 {
 585   // **** les retour des evenement shape sont significatifs
 586   // (add ou remove fait ou non)
 587   // le retour des evenement father n'indiquent pas que add ou remove fait
 588
 589   SMESH_Hypothesis::Hypothesis_Status aux_ret, ret = SMESH_Hypothesis::HYP_OK;
 590   if ( _Id == 0 ) return ret; // not a sub-shape of the shape to mesh
 591
 592   SMESHDS_Mesh* meshDS =_father->GetMeshDS();
 593   SMESH_Algo*   algo   = 0;
 594   _algo = 0;
 595
 596   if (_subShape.ShapeType() == TopAbs_VERTEX )
 597   {
 598     if ( anHyp->GetDim() != 0) {
 599       if (event == ADD_HYP || event == ADD_ALGO)
 600         return SMESH_Hypothesis::HYP_BAD_DIM;
 601       else
 602         return SMESH_Hypothesis::HYP_OK;
 603     }
 604     // 0D hypothesis
 605     else if ( _algoState == HYP_OK ) {
 606       // update default _algoState
 607       if ( event != REMOVE_FATHER_ALGO )
 608       {
 609         _algoState = NO_ALGO;
 610         algo = GetAlgo();
 611         if ( algo ) {
 612           _algoState = MISSING_HYP;
 613           if ( event == REMOVE_FATHER_HYP ||
 614                algo->CheckHypothesis(*_father,_subShape, aux_ret))
 615             _algoState = HYP_OK;
 616         }
 617       }
 618     }
 619   }
 620
 621   int oldAlgoState = _algoState;
 622   bool modifiedHyp = (event == MODIF_HYP);  // if set to true, force event MODIF_ALGO_STATE
 623   SMESH_Algo* algoRequiringCleaning = 0;
 624
 625   bool isApplicableHyp = IsApplicableHypothesis( anHyp );
 626
 627   if (event == ADD_ALGO || event == ADD_FATHER_ALGO)
 628   {
 629     // -------------------------------------------
 630     // check if a shape needed by algo is present
 631     // -------------------------------------------
 632     algo = static_cast< SMESH_Algo* >( anHyp );
 633     if ( !_father->HasShapeToMesh() && algo->NeedShape() )
 634       return SMESH_Hypothesis::HYP_NEED_SHAPE;
 635     // ----------------------
 636     // check mesh conformity
 637     // ----------------------
 638     if (isApplicableHyp && !_father->IsNotConformAllowed() && !IsConform( algo ))
 639       return SMESH_Hypothesis::HYP_NOTCONFORM;
 640
 641     // check if all-dimensional algo is hidden by other local one
 642     if ( event == ADD_ALGO ) {
 643       SMESH_HypoFilter filter( SMESH_HypoFilter::HasType( algo->GetType() ));
 644       filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+1 ));
 645       filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+2 ));
 646       if ( SMESH_Algo * curAlgo = (SMESH_Algo*)_father->GetHypothesis( this, filter, true ))
 647         if ( !curAlgo->NeedDiscreteBoundary() && curAlgo != anHyp )
 648           algoRequiringCleaning = curAlgo;
 649     }
 650   }
 651
 652   // ----------------------------------
 653   // add a hypothesis to DS if possible
 654   // ----------------------------------
 655   if (event == ADD_HYP || event == ADD_ALGO)
 656   {
 657     if ( ! CanAddHypothesis( anHyp )) // check dimension
 658       return SMESH_Hypothesis::HYP_BAD_DIM;
 659
 660     if ( !anHyp->IsAuxiliary() && getSimilarAttached( _subShape, anHyp ) )
 661       return SMESH_Hypothesis::HYP_ALREADY_EXIST;
 662
 663     if ( !meshDS->AddHypothesis(_subShape, anHyp))
 664       return SMESH_Hypothesis::HYP_ALREADY_EXIST;
 665   }
 666
 667   // --------------------------
 668   // remove a hypothesis from DS
 669   // --------------------------
 670   if (event == REMOVE_HYP || event == REMOVE_ALGO)
 671   {
 672     if (!meshDS->RemoveHypothesis(_subShape, anHyp))
 673       return SMESH_Hypothesis::HYP_OK; // nothing changes
 674
 675     if (event == REMOVE_ALGO)
 676     {
 677       algo = dynamic_cast<SMESH_Algo*> (anHyp);
 678       if (!algo->NeedDiscreteBoundary())
 679         algoRequiringCleaning = algo;
 680     }
 681   }
 682
 683   // ------------------
 684   // analyse algo state
 685   // ------------------
 686   if (!isApplicableHyp)
 687     return ret; // not applicable hypotheses do not change algo state
 688
 689   if (( algo = GetAlgo()))
 690     algo->InitComputeError();
 691
 692   switch (_algoState)
 693   {
 694
 695     // ----------------------------------------------------------------------
 696
 697   case NO_ALGO:
 698     switch (event) {
 699     case ADD_HYP:
 700       break;
 701     case ADD_ALGO: {
 702       algo = GetAlgo();
 703       ASSERT(algo);
 704       if (algo->CheckHypothesis((*_father),_subShape, aux_ret))
 705         setAlgoState(HYP_OK);
 706       else if ( algo->IsStatusFatal( aux_ret )) {
 707         meshDS->RemoveHypothesis(_subShape, anHyp);
 708         ret = aux_ret;
 709       }
 710       else
 711         setAlgoState(MISSING_HYP);
 712       break;
 713     }
 714     case REMOVE_HYP:
 715     case REMOVE_ALGO:
 716     case ADD_FATHER_HYP:
 717       break;
 718     case ADD_FATHER_ALGO: {    // Algo just added in father
 719       algo = GetAlgo();
 720       ASSERT(algo);
 721       if ( algo == anHyp ) {
 722         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret))
 723           setAlgoState(HYP_OK);
 724         else
 725           setAlgoState(MISSING_HYP);
 726       }
 727       break;
 728     }
 729     case REMOVE_FATHER_HYP:
 730       break;
 731     case REMOVE_FATHER_ALGO: {
 732       algo = GetAlgo();
 733       if (algo)
 734       {
 735         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
 736             setAlgoState(HYP_OK);
 737         else
 738           setAlgoState(MISSING_HYP);
 739       }
 740       break;
 741     }
 742     case MODIF_HYP: break;
 743     default:
 744       ASSERT(0);
 745       break;
 746     }
 747     break;
 748
 749     // ----------------------------------------------------------------------
 750
 751   case MISSING_HYP:
 752     switch (event)
 753     {
 754     case ADD_HYP: {
 755       algo = GetAlgo();
 756       ASSERT(algo);
 757       if ( algo->CheckHypothesis((*_father),_subShape, ret ))
 758         setAlgoState(HYP_OK);
 759       if (SMESH_Hypothesis::IsStatusFatal( ret ))
 760         meshDS->RemoveHypothesis(_subShape, anHyp);
 761       else if (!_father->IsUsedHypothesis( anHyp, this ))
 762       {
 763         meshDS->RemoveHypothesis(_subShape, anHyp);
 764         ret = SMESH_Hypothesis::HYP_INCOMPATIBLE;
 765       }
 766       break;
 767     }
 768     case ADD_ALGO: {           //already existing algo : on father ?
 769       algo = GetAlgo();
 770       ASSERT(algo);
 771       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))// ignore hyp status
 772         setAlgoState(HYP_OK);
 773       else if ( algo->IsStatusFatal( aux_ret )) {
 774         meshDS->RemoveHypothesis(_subShape, anHyp);
 775         ret = aux_ret;
 776       }
 777       else
 778         setAlgoState(MISSING_HYP);
 779       break;
 780     }
 781     case REMOVE_HYP:
 782       break;
 783     case REMOVE_ALGO: {        // perhaps a father algo applies ?
 784       algo = GetAlgo();
 785       if (algo == NULL)  // no more algo applying on sub-shape...
 786       {
 787         setAlgoState(NO_ALGO);
 788       }
 789       else
 790       {
 791         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
 792           setAlgoState(HYP_OK);
 793         else
 794           setAlgoState(MISSING_HYP);
 795       }
 796       break;
 797     }
 798     case MODIF_HYP: // assigned hypothesis value may become good
 799     case ADD_FATHER_HYP: {
 800       algo = GetAlgo();
 801       ASSERT(algo);
 802       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
 803         setAlgoState(HYP_OK);
 804       else
 805         setAlgoState(MISSING_HYP);
 806       break;
 807     }
 808     case ADD_FATHER_ALGO: { // new father algo
 809       algo = GetAlgo();
 810       ASSERT( algo );
 811       if ( algo == anHyp ) {
 812         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
 813           setAlgoState(HYP_OK);
 814         else
 815           setAlgoState(MISSING_HYP);
 816       }
 817       break;
 818     }
 819     case REMOVE_FATHER_HYP:    // nothing to do
 820       break;
 821     case REMOVE_FATHER_ALGO: {
 822       algo = GetAlgo();
 823       if (algo == NULL)  // no more applying algo on father
 824       {
 825         setAlgoState(NO_ALGO);
 826       }
 827       else
 828       {
 829         if ( algo->CheckHypothesis((*_father),_subShape , aux_ret ))
 830           setAlgoState(HYP_OK);
 831         else
 832           setAlgoState(MISSING_HYP);
 833       }
 834       break;
 835     }
 836     default:
 837       ASSERT(0);
 838       break;
 839     }
 840     break;
 841
 842     // ----------------------------------------------------------------------
 843
 844   case HYP_OK:
 845     switch (event)
 846     {
 847     case ADD_HYP: {
 848       algo = GetAlgo();
 849       ASSERT(algo);
 850       if (!algo->CheckHypothesis((*_father),_subShape, ret ))
 851       {
 852         if ( !SMESH_Hypothesis::IsStatusFatal( ret ))
 853           // ret should be fatal: anHyp was not added
 854           ret = SMESH_Hypothesis::HYP_INCOMPATIBLE;
 855       }
 856       else if (!_father->IsUsedHypothesis( anHyp, this ))
 857         ret = SMESH_Hypothesis::HYP_INCOMPATIBLE;
 858
 859       if (SMESH_Hypothesis::IsStatusFatal( ret ))
 860       {
 861         MESSAGE("do not add extra hypothesis");
 862         meshDS->RemoveHypothesis(_subShape, anHyp);
 863       }
 864       else
 865       {
 866         modifiedHyp = true;
 867       }
 868       break;
 869     }
 870     case ADD_ALGO: {           //already existing algo : on father ?
 871       algo = GetAlgo();
 872       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
 873         // check if algo changes
 874         SMESH_HypoFilter f;
 875         f.Init(   SMESH_HypoFilter::IsAlgo() );
 876         f.And(    SMESH_HypoFilter::IsApplicableTo( _subShape ));
 877         f.AndNot( SMESH_HypoFilter::Is( algo ));
 878         const SMESH_Hypothesis * prevAlgo = _father->GetHypothesis( this, f, true );
 879         if (prevAlgo &&
 880             string( algo->GetName()) != prevAlgo->GetName())
 881           modifiedHyp = true;
 882       }
 883       else
 884         setAlgoState(MISSING_HYP);
 885       break;
 886     }
 887     case REMOVE_HYP: {
 888       algo = GetAlgo();
 889       ASSERT(algo);
 890       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
 891         setAlgoState(HYP_OK);
 892       else
 893         setAlgoState(MISSING_HYP);
 894       modifiedHyp = true;
 895       break;
 896     }
 897     case REMOVE_ALGO: {         // perhaps a father algo applies ?
 898       algo = GetAlgo();
 899       if (algo == NULL)   // no more algo applying on sub-shape...
 900       {
 901         setAlgoState(NO_ALGO);
 902       }
 903       else
 904       {
 905         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
 906           // check if algo remains
 907           if ( anHyp != algo && strcmp( anHyp->GetName(), algo->GetName()) )
 908             modifiedHyp = true;
 909         }
 910         else
 911           setAlgoState(MISSING_HYP);
 912       }
 913       break;
 914     }
 915     case MODIF_HYP: // hypothesis value may become bad
 916     case ADD_FATHER_HYP: {  // new father hypothesis ?
 917       algo = GetAlgo();
 918       ASSERT(algo);
 919       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
 920       {
 921         if (_father->IsUsedHypothesis( anHyp, this )) // new Hyp
 922           modifiedHyp = true;
 923       }
 924       else
 925         setAlgoState(MISSING_HYP);
 926       break;
 927     }
 928     case ADD_FATHER_ALGO: {
 929       algo = GetAlgo();
 930       if ( algo == anHyp ) { // a new algo on father
 931         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
 932           // check if algo changes
 933           SMESH_HypoFilter f;
 934           f.Init(   SMESH_HypoFilter::IsAlgo() );
 935           f.And(    SMESH_HypoFilter::IsApplicableTo( _subShape ));
 936           f.AndNot( SMESH_HypoFilter::Is( algo ));
 937           const SMESH_Hypothesis* prevAlgo = _father->GetHypothesis( this, f, true );
 938           if (prevAlgo &&
 939               string(algo->GetName()) != string(prevAlgo->GetName()) )
 940             modifiedHyp = true;
 941         }
 942         else
 943           setAlgoState(MISSING_HYP);
 944       }
 945       break;
 946     }
 947     case REMOVE_FATHER_HYP: {
 948       algo = GetAlgo();
 949       ASSERT(algo);
 950       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
 951         // is there the same local hyp or maybe a new father algo applied?
 952         if ( !getSimilarAttached( _subShape, anHyp ) )
 953           modifiedHyp = true;
 954       }
 955       else
 956         setAlgoState(MISSING_HYP);
 957       break;
 958     }
 959     case REMOVE_FATHER_ALGO: {
 960       // IPAL21346. Edges not removed when Netgen 1d-2d is removed from a SOLID.
 961       // CLEAN was not called at event REMOVE_ALGO because the algo is not applicable to SOLID.
 962       algo = dynamic_cast<SMESH_Algo*> (anHyp);
 963       if (!algo->NeedDiscreteBoundary())
 964         algoRequiringCleaning = algo;
 965       algo = GetAlgo();
 966       if (algo == NULL)  // no more applying algo on father
 967       {
 968         setAlgoState(NO_ALGO);
 969       }
 970       else
 971       {
 972         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
 973           // check if algo changes
 974           if ( string(algo->GetName()) != string( anHyp->GetName()) )
 975             modifiedHyp = true;
 976         }
 977         else
 978           setAlgoState(MISSING_HYP);
 979       }
 980       break;
 981     }
 982     default:
 983       ASSERT(0);
 984       break;
 985     }
 986     break;
 987
 988     // ----------------------------------------------------------------------
 989
 990   default:
 991     ASSERT(0);
 992     break;
 993   }
 994
 995   // detect algorithm hiding
 996   //
 997   if ( ret == SMESH_Hypothesis::HYP_OK &&
 998        ( event == ADD_ALGO || event == ADD_FATHER_ALGO ) && algo &&
 999        algo->GetName() == anHyp->GetName() )
1000   {
1001     // is algo hidden?
1002     SMESH_Gen* gen = _father->GetGen();
1003     const std::vector< SMESH_subMesh * > & ancestors = GetAncestors();
1004     for ( size_t iA = 0; ( ret == SMESH_Hypothesis::HYP_OK && iA < ancestors.size()); ++iA ) {
1005       if ( SMESH_Algo* upperAlgo = ancestors[ iA ]->GetAlgo() )
1006         if ( !upperAlgo->NeedDiscreteBoundary() && !upperAlgo->SupportSubmeshes())
1007           ret = SMESH_Hypothesis::HYP_HIDDEN_ALGO;
1008     }
1009     // is algo hiding?
1010     if ( ret == SMESH_Hypothesis::HYP_OK &&
1011          !algo->NeedDiscreteBoundary()    &&
1012          !algo->SupportSubmeshes())
1013     {
1014       TopoDS_Shape algoAssignedTo, otherAssignedTo;
1015       gen->GetAlgo( this, &algoAssignedTo );
1016       map<int, SMESH_subMesh*>::reverse_iterator i_sm = _mapDepend.rbegin();
1017       for ( ; ( ret == SMESH_Hypothesis::HYP_OK && i_sm != _mapDepend.rend()) ; ++i_sm )
1018         if ( gen->GetAlgo( i_sm->second, &otherAssignedTo ) &&
1019              SMESH_MesherHelper::IsSubShape( /*sub=*/otherAssignedTo, /*main=*/algoAssignedTo ))
1020           ret = SMESH_Hypothesis::HYP_HIDING_ALGO;
1021     }
1022   }
1023
1024   if ( _algo ) { // get an error description set by _algo->CheckHypothesis()
1025     _computeError = _algo->GetComputeError();
1026     _algo->InitComputeError();
1027   }
1028
1029   bool stateChange = ( _algoState != oldAlgoState );
1030
1031   if ( stateChange && _algoState == HYP_OK ) // hyp becomes OK
1032     algo->SetEventListener( this );
1033
1034   if ( event == REMOVE_ALGO || event == REMOVE_FATHER_ALGO )
1035     _algo = 0;
1036
1037   notifyListenersOnEvent( event, ALGO_EVENT, anHyp );
1038
1039   if ( stateChange && oldAlgoState == HYP_OK ) { // hyp becomes KO
1040     deleteOwnListeners();
1041     SetIsAlwaysComputed( false );
1042     if (_subShape.ShapeType() == TopAbs_VERTEX ) {
1043       // restore default states
1044       _algoState = HYP_OK;
1045       _computeState = READY_TO_COMPUTE;
1046     }
1047   }
1048
1049   if ( algoRequiringCleaning ) {
1050     // added or removed algo is all-dimensional
1051     ComputeStateEngine( CLEAN );
1052     cleanDependsOn( algoRequiringCleaning );
1053     ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
1054   }
1055
1056   if ( stateChange || modifiedHyp )
1057     ComputeStateEngine( MODIF_ALGO_STATE );
1058
1059   _realComputeCost = ( _algoState == HYP_OK ) ? computeCost() : 0;
1060
1061   return ret;
1062 }
1063
1064 //=======================================================================
1065 //function : IsConform
1066 //purpose  : check if a conform mesh will be produced by the Algo
1067 //=======================================================================
1068
1069 bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo)
1070 {
1071 //  MESSAGE( "SMESH_subMesh::IsConform" );
1072   if ( !theAlgo ) return false;
1073
1074   // Suppose that theAlgo is applicable to _subShape, do not check it here
1075   //if ( !IsApplicableHypothesis( theAlgo )) return false;
1076
1077   // check only algo that doesn't NeedDiscreteBoundary(): because mesh made
1078   // on a sub-shape will be ignored by theAlgo
1079   if ( theAlgo->NeedDiscreteBoundary() ||
1080        !theAlgo->OnlyUnaryInput() ) // all adjacent shapes will be meshed by this algo?
1081     return true;
1082
1083   // only local algo is to be checked
1084   //if ( gen->IsGlobalHypothesis( theAlgo, *_father ))
1085   if ( _subShape.ShapeType() == _father->GetMeshDS()->ShapeToMesh().ShapeType() )
1086     return true;
1087
1088   // check algo attached to adjacent shapes
1089
1090   // loop on one level down sub-meshes
1091   TopoDS_Iterator itsub( _subShape );
1092   for (; itsub.More(); itsub.Next())
1093   {
1094     // loop on adjacent subShapes
1095     const std::vector< SMESH_subMesh * > & ancestors = GetAncestors();
1096     for ( size_t iA = 0; iA < ancestors.size(); ++iA )
1097     {
1098       const TopoDS_Shape& adjacent = ancestors[ iA ]->GetSubShape();
1099       if ( _subShape.IsSame( adjacent )) continue;
1100       if ( adjacent.ShapeType() != _subShape.ShapeType())
1101         break;
1102
1103       // check algo attached to smAdjacent
1104       SMESH_Algo * algo = ancestors[ iA ]->GetAlgo();
1105       if (algo &&
1106           !algo->NeedDiscreteBoundary() &&
1107           algo->OnlyUnaryInput())
1108         return false; // NOT CONFORM MESH WILL BE PRODUCED
1109     }
1110   }
1111
1112   return true;
1113 }
1114
1115 //=============================================================================
1116 /*!
1117  *
1118  */
1119 //=============================================================================
1120
1121 void SMESH_subMesh::setAlgoState(algo_state state)
1122 {
1123   _algoState = state;
1124 }
1125
1126 //================================================================================
1127 /*!
1128  * \brief Send an event to sub-meshes
1129  *  \param [in] event - the event
1130  *  \param [in] anHyp - an hypothesis
1131  *  \param [in] exitOnFatal - to stop iteration on sub-meshes if a sub-mesh
1132  *              reports a fatal result
1133  *  \return SMESH_Hypothesis::Hypothesis_Status - the worst result
1134  *
1135  * Optional description of a problematic situation (if any) can be retrieved
1136  * via GetComputeError().
1137  */
1138 //================================================================================
1139
1140 SMESH_Hypothesis::Hypothesis_Status
1141   SMESH_subMesh::SubMeshesAlgoStateEngine(algo_event         event,
1142                                           SMESH_Hypothesis * anHyp,
1143                                           bool               exitOnFatal)
1144 {
1145   SMESH_Hypothesis::Hypothesis_Status ret = SMESH_Hypothesis::HYP_OK;
1146   //EAP: a wire (dim==1) should notify edges (dim==1)
1147   //EAP: int dim = SMESH_Gen::GetShapeDim(_subShape);
1148   //if (_subShape.ShapeType() < TopAbs_EDGE ) // wire,face etc
1149   {
1150     SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
1151     while ( smIt->more() ) {
1152       SMESH_subMesh* sm = smIt->next();
1153       SMESH_Hypothesis::Hypothesis_Status ret2 = sm->AlgoStateEngine(event, anHyp);
1154       if ( ret2 > ret )
1155       {
1156         ret = ret2;
1157         _computeError = sm->_computeError;
1158         sm->_computeError.reset();
1159         if ( exitOnFatal && SMESH_Hypothesis::IsStatusFatal( ret ))
1160           break;
1161       }
1162     }
1163   }
1164   return ret;
1165 }
1166
1167 //================================================================================
1168 /*!
1169  * \brief Remove elements from sub-meshes.
1170  *  \param algoRequiringCleaning - an all-dimensional algorithm whose presence
1171  *         causes the cleaning.
1172  */
1173 //================================================================================
1174
1175 void SMESH_subMesh::cleanDependsOn( SMESH_Algo* algoRequiringCleaning/*=0*/ )
1176 {
1177   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,
1178                                                        /*complexShapeFirst=*/true);
1179   if ( _father->NbNodes() == 0 )
1180   {
1181     while ( smIt->more() )
1182       smIt->next()->ComputeStateEngine(CHECK_COMPUTE_STATE);
1183   }
1184   else if ( !algoRequiringCleaning || !algoRequiringCleaning->SupportSubmeshes() )
1185   {
1186     while ( smIt->more() )
1187       smIt->next()->ComputeStateEngine(CLEAN);
1188   }
1189   else if ( algoRequiringCleaning && algoRequiringCleaning->SupportSubmeshes() )
1190   {
1191     // find sub-meshes to keep elements on
1192     set< SMESH_subMesh* > smToKeep;
1193     TopAbs_ShapeEnum prevShapeType = TopAbs_SHAPE;
1194     bool toKeepPrevShapeType = false;
1195     while ( smIt->more() )
1196     {
1197       SMESH_subMesh* sm = smIt->next();
1198       sm->ComputeStateEngine(CHECK_COMPUTE_STATE);
1199       if ( !sm->IsEmpty() )
1200       {
1201         const bool sameShapeType = ( prevShapeType == sm->GetSubShape().ShapeType() );
1202         bool       keepSubMeshes = ( sameShapeType && toKeepPrevShapeType );
1203         if ( !sameShapeType )
1204         {
1205           // check if the algo allows presence of global algos of dimension the algo
1206           // can generate it-self;
1207           // always keep a node on VERTEX, as this node can be shared by segments
1208           // lying on EDGEs not shared by the VERTEX of sm, due to MergeNodes (PAL23068)
1209           int  shapeDim = SMESH_Gen::GetShapeDim( sm->GetSubShape() );
1210           keepSubMeshes = ( algoRequiringCleaning->NeedLowerHyps( shapeDim ) || shapeDim == 0 );
1211           prevShapeType = sm->GetSubShape().ShapeType();
1212           toKeepPrevShapeType = keepSubMeshes;
1213         }
1214         if ( !keepSubMeshes )
1215         {
1216           // look for a local algo used to mesh sm
1217           TopoDS_Shape algoShape = SMESH_MesherHelper::GetShapeOfHypothesis
1218             ( algoRequiringCleaning, _subShape, _father );
1219           SMESH_HypoFilter moreLocalAlgo;
1220           moreLocalAlgo.Init( SMESH_HypoFilter::IsMoreLocalThan( algoShape, *_father ));
1221           moreLocalAlgo.And ( SMESH_HypoFilter::IsAlgo() );
1222           bool localAlgoFound = _father->GetHypothesis( sm->_subShape, moreLocalAlgo, true );
1223           keepSubMeshes = localAlgoFound;
1224         }
1225         // remember all sub-meshes of sm
1226         if ( keepSubMeshes )
1227         {
1228           SMESH_subMeshIteratorPtr smIt2 = sm->getDependsOnIterator(true);
1229           while ( smIt2->more() )
1230             smToKeep.insert( smIt2->next() );
1231         }
1232       }
1233     }
1234     // remove elements
1235     SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true);
1236     while ( smIt->more() )
1237     {
1238       SMESH_subMesh* sm = smIt->next();
1239       if ( !smToKeep.count( sm ))
1240         sm->ComputeStateEngine(CLEAN);
1241     }
1242   }
1243 }
1244
1245 //=============================================================================
1246 /*!
1247  *
1248  */
1249 //=============================================================================
1250
1251 void SMESH_subMesh::DumpAlgoState(bool isMain)
1252 {
1253   if (isMain)
1254   {
1255     const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
1256
1257     map < int, SMESH_subMesh * >::const_iterator itsub;
1258     for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++)
1259     {
1260       SMESH_subMesh *sm = (*itsub).second;
1261       sm->DumpAlgoState(false);
1262     }
1263   }
1264   MESSAGE("dim = " << SMESH_Gen::GetShapeDim(_subShape) <<
1265           " type of shape " << _subShape.ShapeType());
1266   switch (_algoState)
1267   {
1268   case NO_ALGO          : MESSAGE(" AlgoState = NO_ALGO"); break;
1269   case MISSING_HYP      : MESSAGE(" AlgoState = MISSING_HYP"); break;
1270   case HYP_OK           : MESSAGE(" AlgoState = HYP_OK");break;
1271   }
1272   switch (_computeState)
1273   {
1274   case NOT_READY        : MESSAGE(" ComputeState = NOT_READY");break;
1275   case READY_TO_COMPUTE : MESSAGE(" ComputeState = READY_TO_COMPUTE");break;
1276   case COMPUTE_OK       : MESSAGE(" ComputeState = COMPUTE_OK");break;
1277   case FAILED_TO_COMPUTE: MESSAGE(" ComputeState = FAILED_TO_COMPUTE");break;
1278   }
1279 }
1280
1281 //================================================================================
1282 /*!
1283  * \brief Remove nodes and elements bound to submesh
1284   * \param subMesh - submesh containing nodes and elements
1285  */
1286 //================================================================================
1287
1288 static void cleanSubMesh( SMESH_subMesh * subMesh )
1289 {
1290   if (subMesh) {
1291     if (SMESHDS_SubMesh * subMeshDS = subMesh->GetSubMeshDS())
1292     {
1293       SMESHDS_Mesh * meshDS = subMesh->GetFather()->GetMeshDS();
1294       int nbElems = subMeshDS->NbElements();
1295       if ( nbElems > 0 )
1296         for ( SMDS_ElemIteratorPtr ite = subMeshDS->GetElements(); ite->more(); )
1297           meshDS->RemoveFreeElement( ite->next(), subMeshDS );
1298
1299       int nbNodes = subMeshDS->NbNodes();
1300       if ( nbNodes > 0 )
1301         for ( SMDS_NodeIteratorPtr itn = subMeshDS->GetNodes(); itn->more() ; )
1302         {
1303           const SMDS_MeshNode * node = itn->next();
1304           if ( node->NbInverseElements() == 0 )
1305             meshDS->RemoveFreeNode( node, subMeshDS );
1306           else // for StdMeshers_CompositeSegment_1D: node in one submesh, edge in another
1307             meshDS->RemoveNode( node );
1308         }
1309       subMeshDS->Clear();
1310     }
1311   }
1312 }
1313
1314 //=============================================================================
1315 /*!
1316  *
1317  */
1318 //=============================================================================
1319
1320 bool SMESH_subMesh::ComputeStateEngine(compute_event event)
1321 {
1322   switch ( event ) {
1323   case MODIF_ALGO_STATE:
1324   case COMPUTE:
1325   case COMPUTE_SUBMESH:
1326     //case COMPUTE_CANCELED:
1327   case CLEAN:
1328     //case SUBMESH_COMPUTED:
1329     //case SUBMESH_RESTORED:
1330     //case SUBMESH_LOADED:
1331     //case MESH_ENTITY_REMOVED:
1332     //case CHECK_COMPUTE_STATE:
1333     _computeError.reset(); break;
1334   default:;
1335   }
1336
1337   if ( event == CLEAN )
1338     _alwaysComputed = false; // Unset 'true' set by MergeNodes() (issue 0022182)
1339
1340   if (_subShape.ShapeType() == TopAbs_VERTEX)
1341   {
1342     _computeState = READY_TO_COMPUTE;
1343     SMESHDS_SubMesh* smDS = GetSubMeshDS();
1344     if ( smDS && smDS->NbNodes() )
1345     {
1346       if ( event == CLEAN ) {
1347         cleanDependants();
1348         cleanSubMesh( this );
1349       }
1350       else
1351         _computeState = COMPUTE_OK;
1352     }
1353     else if (( event == COMPUTE || event == COMPUTE_SUBMESH )
1354              && !_alwaysComputed )
1355     {
1356       const TopoDS_Vertex & V = TopoDS::Vertex( _subShape );
1357       gp_Pnt P = BRep_Tool::Pnt(V);
1358       if ( SMDS_MeshNode * n = _father->GetMeshDS()->AddNode(P.X(), P.Y(), P.Z()) ) {
1359         _father->GetMeshDS()->SetNodeOnVertex(n,_Id);
1360         _computeState = COMPUTE_OK;
1361       }
1362     }
1363     if ( event == MODIF_ALGO_STATE )
1364       cleanDependants();
1365     return true;
1366   }
1367   SMESH_Gen *gen = _father->GetGen();
1368   SMESH_Algo *algo = 0;
1369   bool ret = true;
1370   SMESH_Hypothesis::Hypothesis_Status hyp_status;
1371   //algo_state oldAlgoState = (algo_state) GetAlgoState();
1372
1373   switch (_computeState)
1374   {
1375
1376     // ----------------------------------------------------------------------
1377
1378   case NOT_READY:
1379     switch (event)
1380     {
1381     case MODIF_ALGO_STATE:
1382       algo = GetAlgo();
1383       if (algo && !algo->NeedDiscreteBoundary())
1384         cleanDependsOn( algo ); // clean sub-meshes with event CLEAN
1385       if ( _algoState == HYP_OK )
1386         _computeState = READY_TO_COMPUTE;
1387       break;
1388     case COMPUTE:               // nothing to do
1389     case COMPUTE_SUBMESH:
1390       break;
1391     case COMPUTE_CANCELED:      // nothing to do
1392       break;
1393     case CLEAN:
1394       cleanDependants();
1395       removeSubMeshElementsAndNodes();
1396       break;
1397     case SUBMESH_COMPUTED:      // nothing to do
1398       break;
1399     case SUBMESH_RESTORED:
1400       ComputeSubMeshStateEngine( SUBMESH_RESTORED );
1401       break;
1402     case MESH_ENTITY_REMOVED:
1403       break;
1404     case SUBMESH_LOADED:
1405       loadDependentMeshes();
1406       ComputeSubMeshStateEngine( SUBMESH_LOADED );
1407       //break;
1408     case CHECK_COMPUTE_STATE:
1409       if ( IsMeshComputed() )
1410         _computeState = COMPUTE_OK;
1411       break;
1412     default:
1413       ASSERT(0);
1414       break;
1415     }
1416     break;
1417
1418     // ----------------------------------------------------------------------
1419
1420   case READY_TO_COMPUTE:
1421     switch (event)
1422     {
1423     case MODIF_ALGO_STATE:
1424       _computeState = NOT_READY;
1425       algo = GetAlgo();
1426       if (algo)
1427       {
1428         if (!algo->NeedDiscreteBoundary())
1429           cleanDependsOn( algo ); // clean sub-meshes with event CLEAN
1430         if ( _algoState == HYP_OK )
1431           _computeState = READY_TO_COMPUTE;
1432       }
1433       break;
1434
1435     case COMPUTE_NOGEOM:  // no geometry; can be several algos
1436       if ( !_father->HasShapeToMesh() )
1437       {
1438         algo = GetAlgo(); // current algo
1439         if ( algo )
1440         {
1441           // apply algos in the order of increasing dimension
1442           std::list< const SMESHDS_Hypothesis * > algos = _father->GetHypothesisList( _subShape );
1443           for ( int t = SMESHDS_Hypothesis::ALGO_1D; t <= SMESHDS_Hypothesis::ALGO_3D; ++t )
1444           {
1445             std::list<const SMESHDS_Hypothesis *>::iterator al = algos.begin();
1446             for ( ; al != algos.end(); ++al )
1447               if ( (*al)->GetType() == t )
1448               {
1449                 _algo = (SMESH_Algo*) *al;
1450                 _computeState = READY_TO_COMPUTE;
1451                 if ( !ComputeStateEngine( COMPUTE ))
1452                   break;
1453               }
1454           }
1455           _algo = algo; // restore
1456         }
1457         break;
1458       }
1459     case COMPUTE:
1460     case COMPUTE_SUBMESH:
1461       {
1462         algo = GetAlgo();
1463         ASSERT(algo);
1464         ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
1465         if (!ret)
1466         {
1467           MESSAGE("***** verify compute state *****");
1468           _computeState = NOT_READY;
1469           setAlgoState(MISSING_HYP);
1470           break;
1471         }
1472         TopoDS_Shape shape = _subShape;
1473         algo->SubMeshesToCompute().assign( 1, this );
1474         // check submeshes needed
1475         if (_father->HasShapeToMesh() ) {
1476           bool subComputed = false, subFailed = false;
1477           if (!algo->OnlyUnaryInput()) {
1478             if ( event == COMPUTE /*&&
1479                  ( algo->NeedDiscreteBoundary() || algo->SupportSubmeshes() )*/)
1480               shape = getCollection( gen, algo, subComputed, subFailed, algo->SubMeshesToCompute());
1481             else
1482               subComputed = SubMeshesComputed( & subFailed );
1483           }
1484           else {
1485             subComputed = SubMeshesComputed();
1486           }
1487           ret = ( algo->NeedDiscreteBoundary() ? subComputed :
1488                   algo->SupportSubmeshes() ? !subFailed :
1489                   ( !subComputed || _father->IsNotConformAllowed() ));
1490           if (!ret)
1491           {
1492             _computeState = FAILED_TO_COMPUTE;
1493             if ( !algo->NeedDiscreteBoundary() && !subFailed )
1494               _computeError =
1495                 SMESH_ComputeError::New(COMPERR_BAD_INPUT_MESH,
1496                                         "Unexpected computed sub-mesh",algo);
1497             break; // goto exit
1498           }
1499         }
1500         // Compute
1501
1502         // to restore cout that may be redirected by algo
1503         std::streambuf* coutBuffer = std::cout.rdbuf();
1504
1505         //cleanDependants(); for "UseExisting_*D" algos
1506         //removeSubMeshElementsAndNodes();
1507         loadDependentMeshes();
1508         ret = false;
1509         _computeState = FAILED_TO_COMPUTE;
1510         _computeError = SMESH_ComputeError::New(COMPERR_OK,"",algo);
1511         try {
1512           OCC_CATCH_SIGNALS;
1513
1514           algo->InitComputeError();
1515
1516           MemoryReserve aMemoryReserve;
1517           SMDS_Mesh::CheckMemory();
1518           Kernel_Utils::Localizer loc;
1519           if ( !_father->HasShapeToMesh() ) // no shape
1520           {
1521             SMESH_MesherHelper helper( *_father );
1522             helper.SetSubShape( shape );
1523             helper.SetElementsOnShape( true );
1524             ret = algo->Compute(*_father, &helper );
1525           }
1526           else
1527           {
1528             ret = algo->Compute((*_father), shape);
1529           }
1530           // algo can set _computeError of submesh
1531           _computeError = SMESH_ComputeError::Worst( _computeError, algo->GetComputeError() );
1532         }
1533         catch ( ::SMESH_ComputeError& comperr ) {
1534           cout << " SMESH_ComputeError caught" << endl;
1535           if ( !_computeError ) _computeError = SMESH_ComputeError::New();
1536           *_computeError = comperr;
1537         }
1538         catch ( std::bad_alloc& exc ) {
1539           MESSAGE("std::bad_alloc thrown inside algo->Compute()");
1540           if ( _computeError ) {
1541             _computeError->myName = COMPERR_MEMORY_PB;
1542           }
1543           cleanSubMesh( this );
1544           throw exc;
1545         }
1546         catch ( Standard_OutOfMemory& exc ) {
1547           MESSAGE("Standard_OutOfMemory thrown inside algo->Compute()");
1548           if ( _computeError ) {
1549             _computeError->myName = COMPERR_MEMORY_PB;
1550           }
1551           cleanSubMesh( this );
1552           throw std::bad_alloc();
1553         }
1554         catch (Standard_Failure& ex) {
1555           if ( !_computeError ) _computeError = SMESH_ComputeError::New();
1556           _computeError->myName    = COMPERR_OCC_EXCEPTION;
1557           _computeError->myComment += ex.DynamicType()->Name();
1558           if ( ex.GetMessageString() && strlen( ex.GetMessageString() )) {
1559             _computeError->myComment += ": ";
1560             _computeError->myComment += ex.GetMessageString();
1561           }
1562         }
1563         catch ( SALOME_Exception& S_ex ) {
1564           const int skipSalomeShift = 7; /* to skip "Salome " of
1565                                             "Salome Exception" prefix returned
1566                                             by SALOME_Exception::what() */
1567           if ( !_computeError ) _computeError = SMESH_ComputeError::New();
1568           _computeError->myName    = COMPERR_SLM_EXCEPTION;
1569           _computeError->myComment = S_ex.what() + skipSalomeShift;
1570         }
1571         catch ( std::exception& exc ) {
1572           if ( !_computeError ) _computeError = SMESH_ComputeError::New();
1573           _computeError->myName    = COMPERR_STD_EXCEPTION;
1574           _computeError->myComment = exc.what();
1575         }
1576         catch ( ... ) {
1577           if ( _computeError )
1578             _computeError->myName = COMPERR_EXCEPTION;
1579           else
1580             ret = false;
1581         }
1582         std::cout.rdbuf( coutBuffer ); // restore cout that could be redirected by algo
1583
1584         // check if an error reported on any sub-shape
1585         bool isComputeErrorSet = !checkComputeError( algo, ret, shape );
1586         if ( isComputeErrorSet )
1587           ret = false;
1588         // check if anything was built
1589         TopExp_Explorer subS(shape, _subShape.ShapeType());
1590         if ( ret )
1591         {
1592           for (; ret && subS.More(); subS.Next())
1593             if ( !_father->GetSubMesh( subS.Current() )->IsMeshComputed() &&
1594                  ( _subShape.ShapeType() != TopAbs_EDGE ||
1595                    !algo->isDegenerated( TopoDS::Edge( subS.Current() ))))
1596               ret = false;
1597         }
1598 #ifdef PRINT_WHO_COMPUTE_WHAT
1599         for (subS.ReInit(); subS.More(); subS.Next())
1600         {
1601           const std::list <const SMESHDS_Hypothesis *> & hyps =
1602             _algo->GetUsedHypothesis( *_father, _subShape );
1603           SMESH_Comment hypStr;
1604           if ( !hyps.empty() )
1605           {
1606             hypStr << hyps.front()->GetName() << " ";
1607             ((SMESHDS_Hypothesis*)hyps.front())->SaveTo( hypStr.Stream() );
1608             hypStr << " ";
1609           }
1610           cout << _algo->GetName()
1611                << " " << _father->GetSubMesh( subS.Current() )->GetId()
1612                << " " << hypStr << endl;
1613         }
1614 #endif
1615         // Set _computeError
1616         if ( !ret && !isComputeErrorSet )
1617         {
1618           for ( subS.ReInit(); subS.More(); subS.Next() )
1619           {
1620             SMESH_subMesh* sm = _father->GetSubMesh( subS.Current() );
1621             if ( !sm->IsMeshComputed() )
1622             {
1623               if ( !sm->_computeError )
1624                 sm->_computeError = SMESH_ComputeError::New();
1625               if ( sm->_computeError->IsOK() )
1626                 sm->_computeError->myName = COMPERR_ALGO_FAILED;
1627               sm->_computeState = FAILED_TO_COMPUTE;
1628               sm->_computeError->myAlgo = algo;
1629             }
1630           }
1631         }
1632         if ( ret && _computeError && _computeError->myName != COMPERR_WARNING )
1633         {
1634           _computeError.reset();
1635         }
1636
1637         // transform errors into warnings if it is caused by mesh edition (imp 0023068)
1638         if (!ret && _father->GetIsModified() )
1639         {
1640           for (subS.ReInit(); subS.More(); subS.Next())
1641           {
1642             SMESH_subMesh* sm = _father->GetSubMesh( subS.Current() );
1643             if ( !sm->IsMeshComputed() && sm->_computeError )
1644             {
1645               // check if there is a VERTEX w/o nodes
1646               // with READY_TO_COMPUTE state (after MergeNodes())
1647               SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(false,false);
1648               while ( smIt->more() )
1649               {
1650                 SMESH_subMesh * vertSM = smIt->next();
1651                 if ( vertSM->_subShape.ShapeType() != TopAbs_VERTEX ) break;
1652                 if ( vertSM->GetComputeState() == READY_TO_COMPUTE )
1653                 {
1654                   SMESHDS_SubMesh * ds = vertSM->GetSubMeshDS();
1655                   if ( !ds || ds->NbNodes() == 0 )
1656                   {
1657                     sm->_computeState = READY_TO_COMPUTE;
1658                     sm->_computeError->myName = COMPERR_WARNING;
1659                     break;
1660                   }
1661                 }
1662               }
1663             }
1664           }
1665         }
1666
1667         // send event SUBMESH_COMPUTED
1668         if ( ret ) {
1669           if ( !algo->NeedDiscreteBoundary() )
1670             // send SUBMESH_COMPUTED to dependants of all sub-meshes of shape
1671             for (subS.ReInit(); subS.More(); subS.Next())
1672             {
1673               SMESH_subMesh* sm = _father->GetSubMesh( subS.Current() );
1674               SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(false,false);
1675               while ( smIt->more() ) {
1676                 sm = smIt->next();
1677                 if ( sm->GetSubShape().ShapeType() == TopAbs_VERTEX )
1678                   sm->updateDependantsState( SUBMESH_COMPUTED );
1679                 else
1680                   break;
1681               }
1682             }
1683           else
1684             updateDependantsState( SUBMESH_COMPUTED );
1685         }
1686         // let algo clear its data gathered while algo->Compute()
1687         algo->CheckHypothesis((*_father), _subShape, hyp_status);
1688       }
1689       break;
1690     case COMPUTE_CANCELED:               // nothing to do
1691       break;
1692     case CLEAN:
1693       cleanDependants();
1694       removeSubMeshElementsAndNodes();
1695       _computeState = NOT_READY;
1696       algo = GetAlgo();
1697       if (algo)
1698       {
1699         ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
1700         if (ret)
1701           _computeState = READY_TO_COMPUTE;
1702         else
1703           setAlgoState(MISSING_HYP);
1704       }
1705       break;
1706     case SUBMESH_COMPUTED:      // nothing to do
1707       break;
1708     case SUBMESH_RESTORED:
1709       // check if a mesh is already computed that may
1710       // happen after retrieval from a file
1711       ComputeStateEngine( CHECK_COMPUTE_STATE );
1712       ComputeSubMeshStateEngine( SUBMESH_RESTORED );
1713       algo = GetAlgo();
1714       if (algo) algo->SubmeshRestored( this );
1715       break;
1716     case MESH_ENTITY_REMOVED:
1717       break;
1718     case SUBMESH_LOADED:
1719       loadDependentMeshes();
1720       ComputeSubMeshStateEngine( SUBMESH_LOADED );
1721       //break;
1722     case CHECK_COMPUTE_STATE:
1723       if ( IsMeshComputed() )
1724         _computeState = COMPUTE_OK;
1725       else if ( _computeError && _computeError->IsKO() )
1726         _computeState = FAILED_TO_COMPUTE;
1727       break;
1728     default:
1729       ASSERT(0);
1730       break;
1731     }
1732     break;
1733
1734     // ----------------------------------------------------------------------
1735
1736   case COMPUTE_OK:
1737     switch (event)
1738     {
1739     case MODIF_ALGO_STATE:
1740       ComputeStateEngine( CLEAN );
1741       algo = GetAlgo();
1742       if (algo && !algo->NeedDiscreteBoundary())
1743         cleanDependsOn( algo ); // clean sub-meshes with event CLEAN
1744       break;
1745     case COMPUTE:               // nothing to do
1746       break;
1747     case COMPUTE_CANCELED:      // nothing to do
1748       break;
1749     case CLEAN:
1750       cleanDependants();  // clean sub-meshes, dependent on this one, with event CLEAN
1751       removeSubMeshElementsAndNodes();
1752       _computeState = NOT_READY;
1753       if ( _algoState == HYP_OK )
1754         _computeState = READY_TO_COMPUTE;
1755       break;
1756     case SUBMESH_COMPUTED:      // nothing to do
1757       break;
1758     case SUBMESH_RESTORED:
1759       ComputeStateEngine( CHECK_COMPUTE_STATE );
1760       ComputeSubMeshStateEngine( SUBMESH_RESTORED );
1761       algo = GetAlgo();
1762       if (algo) algo->SubmeshRestored( this );
1763       break;
1764     case MESH_ENTITY_REMOVED:
1765       updateDependantsState    ( CHECK_COMPUTE_STATE );
1766       ComputeStateEngine       ( CHECK_COMPUTE_STATE );
1767       ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
1768       break;
1769     case CHECK_COMPUTE_STATE:
1770       if ( !IsMeshComputed() ) {
1771         if (_algoState == HYP_OK)
1772           _computeState = READY_TO_COMPUTE;
1773         else
1774           _computeState = NOT_READY;
1775       }
1776       break;
1777     case SUBMESH_LOADED:
1778       // already treated event, thanks to which _computeState == COMPUTE_OK
1779       break;
1780     default:
1781       ASSERT(0);
1782       break;
1783     }
1784     break;
1785
1786     // ----------------------------------------------------------------------
1787
1788   case FAILED_TO_COMPUTE:
1789     switch (event)
1790     {
1791     case MODIF_ALGO_STATE:
1792       if ( !IsEmpty() )
1793         ComputeStateEngine( CLEAN );
1794       algo = GetAlgo();
1795       if (algo && !algo->NeedDiscreteBoundary())
1796         cleanDependsOn( algo ); // clean sub-meshes with event CLEAN
1797       if (_algoState == HYP_OK)
1798         _computeState = READY_TO_COMPUTE;
1799       else
1800         _computeState = NOT_READY;
1801       break;
1802     case COMPUTE:        // nothing to do
1803     case COMPUTE_SUBMESH:
1804       break;
1805     case COMPUTE_CANCELED:
1806       {
1807         algo = GetAlgo();
1808         algo->CancelCompute();
1809       }
1810       break;
1811     case CLEAN:
1812       cleanDependants(); // submeshes dependent on me should be cleaned as well
1813       removeSubMeshElementsAndNodes();
1814       break;
1815     case SUBMESH_COMPUTED:      // allow retry compute
1816       if ( IsEmpty() ) // 23061
1817       {
1818         if (_algoState == HYP_OK)
1819           _computeState = READY_TO_COMPUTE;
1820         else
1821           _computeState = NOT_READY;
1822       }
1823       break;
1824     case SUBMESH_RESTORED:
1825       ComputeSubMeshStateEngine( SUBMESH_RESTORED );
1826       break;
1827     case MESH_ENTITY_REMOVED:
1828       break;
1829     case CHECK_COMPUTE_STATE:
1830       if ( IsMeshComputed() )
1831         _computeState = COMPUTE_OK;
1832       else
1833         if (_algoState == HYP_OK)
1834           _computeState = READY_TO_COMPUTE;
1835         else
1836           _computeState = NOT_READY;
1837       break;
1838     // case SUBMESH_LOADED:
1839     //   break;
1840     default:
1841       ASSERT(0);
1842       break;
1843     }
1844     break;
1845
1846     // ----------------------------------------------------------------------
1847   default:
1848     ASSERT(0);
1849     break;
1850   }
1851
1852   notifyListenersOnEvent( event, COMPUTE_EVENT );
1853
1854   return ret;
1855 }
1856
1857
1858 //=============================================================================
1859 /*!
1860  *
1861  */
1862 //=============================================================================
1863
1864 bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap)
1865 {
1866   _computeError.reset();
1867
1868   bool ret = true;
1869
1870   if (_subShape.ShapeType() == TopAbs_VERTEX) {
1871     vector<int> aVec(SMDSEntity_Last,0);
1872     aVec[SMDSEntity_Node] = 1;
1873     aResMap.insert(make_pair(this,aVec));
1874     return ret;
1875   }
1876
1877   //SMESH_Gen *gen = _father->GetGen();
1878   SMESH_Algo *algo = 0;
1879   SMESH_Hypothesis::Hypothesis_Status hyp_status;
1880
1881   algo = GetAlgo();
1882   if( algo && !aResMap.count( this ))
1883   {
1884     ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
1885     if (!ret) return false;
1886
1887     if (_father->HasShapeToMesh() && algo->NeedDiscreteBoundary() )
1888     {
1889       // check submeshes needed
1890       bool subMeshEvaluated = true;
1891       int dimToCheck = SMESH_Gen::GetShapeDim( _subShape ) - 1;
1892       SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,/*complexShapeFirst=*/true);
1893       while ( smIt->more() && subMeshEvaluated )
1894       {
1895         SMESH_subMesh* sm = smIt->next();
1896         int dim = SMESH_Gen::GetShapeDim( sm->GetSubShape() );
1897         if (dim < dimToCheck) break; // the rest subMeshes are all of less dimension
1898         const vector<int> & nbs = aResMap[ sm ];
1899         subMeshEvaluated = (std::accumulate( nbs.begin(), nbs.end(), 0 ) > 0 );
1900       }
1901       if ( !subMeshEvaluated )
1902         return false;
1903     }
1904     _computeError = SMESH_ComputeError::New(COMPERR_OK,"",algo);
1905
1906     if ( IsMeshComputed() )
1907     {
1908       vector<int> & nbEntities = aResMap[ this ];
1909       nbEntities.resize( SMDSEntity_Last, 0 );
1910       if ( SMESHDS_SubMesh* sm = GetSubMeshDS() )
1911       {
1912         nbEntities[ SMDSEntity_Node ] = sm->NbNodes();
1913         SMDS_ElemIteratorPtr   elemIt = sm->GetElements();
1914         while ( elemIt->more() )
1915           nbEntities[ elemIt->next()->GetEntityType() ]++;
1916       }
1917     }
1918     else
1919     {
1920       ret = algo->Evaluate((*_father), _subShape, aResMap);
1921     }
1922     aResMap.insert( make_pair( this,vector<int>(0)));
1923   }
1924
1925   return ret;
1926 }
1927
1928
1929 //=======================================================================
1930 /*!
1931  * \brief Update compute_state by _computeError and send proper events to
1932  * dependent submeshes
1933   * \retval bool - true if _computeError is NOT set
1934  */
1935 //=======================================================================
1936
1937 bool SMESH_subMesh::checkComputeError(SMESH_Algo*         theAlgo,
1938                                       const bool          theComputeOK,
1939                                       const TopoDS_Shape& theShape)
1940 {
1941   bool noErrors = true;
1942
1943   if ( !theShape.IsNull() )
1944   {
1945     // Check state of submeshes
1946     if ( !theAlgo->NeedDiscreteBoundary())
1947     {
1948       SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
1949       while ( smIt->more() )
1950         if ( !smIt->next()->checkComputeError( theAlgo, theComputeOK ))
1951           noErrors = false;
1952     }
1953
1954     // Check state of neighbours
1955     if ( !theAlgo->OnlyUnaryInput() &&
1956          theShape.ShapeType() == TopAbs_COMPOUND &&
1957          !theShape.IsSame( _subShape ))
1958     {
1959       for (TopoDS_Iterator subIt( theShape ); subIt.More(); subIt.Next()) {
1960         SMESH_subMesh* sm = _father->GetSubMesh( subIt.Value() );
1961         if ( sm != this ) {
1962           if ( !sm->checkComputeError( theAlgo, theComputeOK, sm->GetSubShape() ))
1963             noErrors = false;
1964           updateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED
1965         }
1966       }
1967     }
1968   }
1969   {
1970
1971     // Set my _computeState
1972
1973     if ( !_computeError || _computeError->IsOK() )
1974     {
1975       // no error description is set to this sub-mesh, check if any mesh is computed
1976       _computeState = IsMeshComputed() ? COMPUTE_OK : FAILED_TO_COMPUTE;
1977       if ( _computeState != COMPUTE_OK )
1978       {
1979         if ( _subShape.ShapeType() == TopAbs_EDGE &&
1980              SMESH_Algo::isDegenerated( TopoDS::Edge( _subShape )) )
1981           _computeState = COMPUTE_OK;
1982         else if ( theComputeOK )
1983           _computeError = SMESH_ComputeError::New(COMPERR_NO_MESH_ON_SHAPE,"",theAlgo);
1984       }
1985     }
1986
1987     if ( _computeError && !_computeError->IsOK() )
1988     {
1989       if ( !_computeError->myAlgo )
1990         _computeError->myAlgo = theAlgo;
1991
1992       // Show error
1993       SMESH_Comment text;
1994       text << theAlgo->GetName() << " failed on sub-shape #" << _Id << " with error ";
1995       if (_computeError->IsCommon() )
1996         text << _computeError->CommonName();
1997       else
1998         text << _computeError->myName;
1999       if ( _computeError->myComment.size() > 0 )
2000         text << " \"" << _computeError->myComment << "\"";
2001
2002       INFOS( text );
2003
2004       _computeState = _computeError->IsKO() ? FAILED_TO_COMPUTE : COMPUTE_OK;
2005
2006       noErrors = false;
2007     }
2008   }
2009   return noErrors;
2010 }
2011
2012 //=======================================================================
2013 //function : updateSubMeshState
2014 //purpose  :
2015 //=======================================================================
2016
2017 void SMESH_subMesh::updateSubMeshState(const compute_state theState)
2018 {
2019   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
2020   while ( smIt->more() )
2021     smIt->next()->_computeState = theState;
2022 }
2023
2024 //=======================================================================
2025 //function : ComputeSubMeshStateEngine
2026 //purpose  :
2027 //=======================================================================
2028
2029 void SMESH_subMesh::ComputeSubMeshStateEngine(compute_event event, const bool includeSelf)
2030 {
2031   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(includeSelf,false);
2032   while ( smIt->more() )
2033     smIt->next()->ComputeStateEngine(event);
2034 }
2035
2036 //=======================================================================
2037 //function : updateDependantsState
2038 //purpose  :
2039 //=======================================================================
2040
2041 void SMESH_subMesh::updateDependantsState(const compute_event theEvent)
2042 {
2043   const std::vector< SMESH_subMesh * > & ancestors = GetAncestors();
2044   for ( size_t iA = 0; iA < ancestors.size(); ++iA )
2045   {
2046     ancestors[ iA ]->ComputeStateEngine( theEvent );
2047   }
2048 }
2049
2050 //=======================================================================
2051 //function : cleanDependants
2052 //purpose  :
2053 //=======================================================================
2054
2055 void SMESH_subMesh::cleanDependants()
2056 {
2057   int dimToClean = SMESH_Gen::GetShapeDim( _subShape ) + 1;
2058
2059   const std::vector< SMESH_subMesh * > & ancestors = GetAncestors();
2060   for ( size_t iA = 0; iA < ancestors.size(); ++iA )
2061   {
2062     const TopoDS_Shape& ancestor = ancestors[ iA ]->GetSubShape();
2063     if ( SMESH_Gen::GetShapeDim( ancestor ) == dimToClean )
2064     {
2065       // PAL8021. do not go upper than SOLID, else ComputeStateEngine(CLEAN)
2066       // will erase mesh on other shapes in a compound
2067       if ( ancestor.ShapeType() >= TopAbs_SOLID &&
2068            !ancestors[ iA ]->IsEmpty() )  // prevent infinite CLEAN via event lesteners
2069         ancestors[ iA ]->ComputeStateEngine(CLEAN);
2070     }
2071   }
2072 }
2073
2074 //=======================================================================
2075 //function : removeSubMeshElementsAndNodes
2076 //purpose  :
2077 //=======================================================================
2078
2079 void SMESH_subMesh::removeSubMeshElementsAndNodes()
2080 {
2081   cleanSubMesh( this );
2082
2083   // algo may bind a submesh not to _subShape, eg 3D algo
2084   // sets nodes on SHELL while _subShape may be SOLID
2085
2086   int dim = SMESH_Gen::GetShapeDim( _subShape );
2087   int type = _subShape.ShapeType() + 1;
2088   for ( ; type <= TopAbs_EDGE; type++) {
2089     if ( dim == SMESH_Gen::GetShapeDim( (TopAbs_ShapeEnum) type ))
2090     {
2091       TopExp_Explorer exp( _subShape, (TopAbs_ShapeEnum) type );
2092       for ( ; exp.More(); exp.Next() )
2093         cleanSubMesh( _father->GetSubMeshContaining( exp.Current() ));
2094     }
2095     else
2096       break;
2097   }
2098 }
2099
2100 //=======================================================================
2101 //function : getCollection
2102 //purpose  : return a shape containing all sub-shapes of the MainShape that can be
2103 //           meshed at once along with _subShape
2104 //=======================================================================
2105
2106 TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen,
2107                                           SMESH_Algo* theAlgo,
2108                                           bool &      theSubComputed,
2109                                           bool &      theSubFailed,
2110                                           std::vector<SMESH_subMesh*>& theSubs)
2111 {
2112   theSubComputed = SubMeshesComputed( & theSubFailed );
2113
2114   TopoDS_Shape mainShape = _father->GetMeshDS()->ShapeToMesh();
2115
2116   if ( mainShape.IsSame( _subShape ))
2117     return _subShape;
2118
2119   const bool skipAuxHyps = false;
2120   list<const SMESHDS_Hypothesis*> aUsedHyp =
2121     theAlgo->GetUsedHypothesis( *_father, _subShape, skipAuxHyps ); // copy
2122
2123   // put in a compound all shapes with the same hypothesis assigned
2124   // and a good ComputeState
2125
2126   TopoDS_Compound aCompound;
2127   BRep_Builder aBuilder;
2128   aBuilder.MakeCompound( aCompound );
2129
2130   theSubs.clear();
2131
2132   SMESH_subMeshIteratorPtr smIt = _father->GetSubMesh( mainShape )->getDependsOnIterator(false);
2133   while ( smIt->more() )
2134   {
2135     SMESH_subMesh* subMesh = smIt->next();
2136     const TopoDS_Shape&  S = subMesh->_subShape;
2137     if ( S.ShapeType() != this->_subShape.ShapeType() )
2138       continue;
2139     if ( subMesh == this )
2140     {
2141       aBuilder.Add( aCompound, S );
2142       theSubs.push_back( subMesh );
2143     }
2144     else if ( subMesh->GetComputeState() == READY_TO_COMPUTE )
2145     {
2146       SMESH_Algo* anAlgo = subMesh->GetAlgo();
2147       if (( anAlgo->IsSameName( *theAlgo )) && // same algo
2148           ( anAlgo->GetUsedHypothesis( *_father, S, skipAuxHyps ) == aUsedHyp )) // same hyps
2149       {
2150         aBuilder.Add( aCompound, S );
2151         if ( !subMesh->SubMeshesComputed() )
2152           theSubComputed = false;
2153         theSubs.push_back( subMesh );
2154       }
2155     }
2156   }
2157
2158   return aCompound;
2159 }
2160
2161 //=======================================================================
2162 //function : getSimilarAttached
2163 //purpose  : return a hypothesis attached to theShape.
2164 //           If theHyp is provided, similar but not same hypotheses
2165 //           is returned; else only applicable ones having theHypType
2166 //           is returned
2167 //=======================================================================
2168
2169 const SMESH_Hypothesis* SMESH_subMesh::getSimilarAttached(const TopoDS_Shape&      theShape,
2170                                                           const SMESH_Hypothesis * theHyp,
2171                                                           const int                theHypType)
2172 {
2173   SMESH_HypoFilter hypoKind;
2174   hypoKind.Init( hypoKind.HasType( theHyp ? theHyp->GetType() : theHypType ));
2175   if ( theHyp ) {
2176     hypoKind.And   ( hypoKind.HasDim( theHyp->GetDim() ));
2177     hypoKind.AndNot( hypoKind.Is( theHyp ));
2178     if ( theHyp->IsAuxiliary() )
2179       hypoKind.And( hypoKind.HasName( theHyp->GetName() ));
2180     else
2181       hypoKind.AndNot( hypoKind.IsAuxiliary());
2182   }
2183   else {
2184     hypoKind.And( hypoKind.IsApplicableTo( theShape ));
2185   }
2186
2187   return _father->GetHypothesis( theShape, hypoKind, false );
2188 }
2189
2190 //=======================================================================
2191 //function : CheckConcurrentHypothesis
2192 //purpose  : check if there are several applicable hypothesis attached to
2193 //           ancestors
2194 //=======================================================================
2195
2196 SMESH_Hypothesis::Hypothesis_Status
2197   SMESH_subMesh::CheckConcurrentHypothesis (const int theHypType)
2198 {
2199   // is there local hypothesis on me?
2200   if ( getSimilarAttached( _subShape, 0, theHypType ) )
2201     return SMESH_Hypothesis::HYP_OK;
2202
2203
2204   TopoDS_Shape aPrevWithHyp;
2205   const SMESH_Hypothesis* aPrevHyp = 0;
2206   TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
2207   for (; it.More(); it.Next())
2208   {
2209     const TopoDS_Shape& ancestor = it.Value();
2210     const SMESH_Hypothesis* hyp = getSimilarAttached( ancestor, 0, theHypType );
2211     if ( hyp )
2212     {
2213       if ( aPrevWithHyp.IsNull() || aPrevWithHyp.IsSame( ancestor ))
2214       {
2215         aPrevWithHyp = ancestor;
2216         aPrevHyp     = hyp;
2217       }
2218       else if ( aPrevWithHyp.ShapeType() == ancestor.ShapeType() && aPrevHyp != hyp )
2219         return SMESH_Hypothesis::HYP_CONCURRENT;
2220       else
2221         return SMESH_Hypothesis::HYP_OK;
2222     }
2223   }
2224   return SMESH_Hypothesis::HYP_OK;
2225 }
2226
2227 //================================================================================
2228 /*!
2229  * \brief Constructor of OwnListenerData
2230  */
2231 //================================================================================
2232
2233 SMESH_subMesh::OwnListenerData::OwnListenerData( SMESH_subMesh* sm, EventListener* el):
2234   mySubMesh( sm ),
2235   myMeshID( sm ? sm->GetFather()->GetId() : -1 ),
2236   mySubMeshID( sm ? sm->GetId() : -1 ),
2237   myListener( el )
2238 {
2239 }
2240
2241 //================================================================================
2242 /*!
2243  * \brief Sets an event listener and its data to a submesh
2244  * \param listener - the listener to store
2245  * \param data - the listener data to store
2246  * \param where - the submesh to store the listener and it's data
2247  *
2248  * It remembers the submesh where it puts the listener in order to delete
2249  * them when HYP_OK algo_state is lost
2250  * After being set, event listener is notified on each event of where submesh.
2251  */
2252 //================================================================================
2253
2254 void SMESH_subMesh::SetEventListener(EventListener*     listener,
2255                                      EventListenerData* data,
2256                                      SMESH_subMesh*     where)
2257 {
2258   if ( listener && where ) {
2259     where->setEventListener( listener, data );
2260     _ownListeners.push_back( OwnListenerData( where, listener ));
2261   }
2262 }
2263
2264 //================================================================================
2265 /*!
2266  * \brief Sets an event listener and its data to a submesh
2267  * \param listener - the listener to store
2268  * \param data - the listener data to store
2269  *
2270  * After being set, event listener is notified on each event of a submesh.
2271  */
2272 //================================================================================
2273
2274 void SMESH_subMesh::setEventListener(EventListener*     listener,
2275                                      EventListenerData* data)
2276 {
2277   map< EventListener*, EventListenerData* >::iterator l_d =
2278     _eventListeners.find( listener );
2279   if ( l_d != _eventListeners.end() ) {
2280     EventListenerData* curData = l_d->second;
2281     l_d->second = data;
2282     if ( curData && curData != data && curData->IsDeletable() )
2283       delete curData;
2284   }
2285   else
2286   {
2287     for ( l_d = _eventListeners.begin(); l_d != _eventListeners.end(); ++l_d )
2288       if ( listener->GetName() == l_d->first->GetName() )
2289       {
2290         EventListenerData* curData = l_d->second;
2291         l_d->second = 0;
2292         if ( curData && curData != data && curData->IsDeletable() )
2293           delete curData;
2294         if ( l_d->first != listener && l_d->first->IsDeletable() )
2295           delete l_d->first;
2296         _eventListeners.erase( l_d );
2297         break;
2298       }
2299     _eventListeners.insert( make_pair( listener, data ));
2300   }
2301 }
2302
2303 //================================================================================
2304 /*!
2305  * \brief Return an event listener data
2306  * \param listener - the listener whose data is
2307  * \param myOwn - if \c true, returns a listener set by this sub-mesh,
2308  *        else returns a listener listening to events of this sub-mesh
2309  * \retval EventListenerData* - found data, maybe NULL
2310  */
2311 //================================================================================
2312
2313 EventListenerData* SMESH_subMesh::GetEventListenerData(EventListener* listener,
2314                                                        const bool     myOwn) const
2315 {
2316   if ( myOwn )
2317   {
2318     list< OwnListenerData >::const_iterator d;
2319     for ( d = _ownListeners.begin(); d != _ownListeners.end(); ++d )
2320     {
2321       if ( d->myListener == listener && _father->MeshExists( d->myMeshID ))
2322         return d->mySubMesh->GetEventListenerData( listener, !myOwn );
2323     }
2324   }
2325   else
2326   {
2327     map< EventListener*, EventListenerData* >::const_iterator l_d =
2328       _eventListeners.find( listener );
2329     if ( l_d != _eventListeners.end() )
2330       return l_d->second;
2331   }
2332   return 0;
2333 }
2334
2335 //================================================================================
2336 /*!
2337  * \brief Return an event listener data
2338  * \param listenerName - the listener name
2339  * \param myOwn - if \c true, returns a listener set by this sub-mesh,
2340  *        else returns a listener listening to events of this sub-mesh
2341  * \retval EventListenerData* - found data, maybe NULL
2342  */
2343 //================================================================================
2344
2345 EventListenerData* SMESH_subMesh::GetEventListenerData(const string& listenerName,
2346                                                        const bool    myOwn) const
2347 {
2348   if ( myOwn )
2349   {
2350     list< OwnListenerData >::const_iterator d;
2351     for ( d = _ownListeners.begin(); d != _ownListeners.end(); ++d )
2352     {
2353       if ( _father->MeshExists( d->myMeshID ) && listenerName == d->myListener->GetName())
2354         return d->mySubMesh->GetEventListenerData( listenerName, !myOwn );
2355     }
2356   }
2357   else
2358   {
2359     map< EventListener*, EventListenerData* >::const_iterator l_d = _eventListeners.begin();
2360     for ( ; l_d != _eventListeners.end(); ++l_d )
2361       if ( listenerName == l_d->first->GetName() )
2362         return l_d->second;
2363   }
2364   return 0;
2365 }
2366
2367 //================================================================================
2368 /*!
2369  * \brief Notify stored event listeners on the occurred event
2370  * \param event - algo_event or compute_event itself
2371  * \param eventType - algo_event or compute_event
2372  * \param hyp - hypothesis, if eventType is algo_event
2373  */
2374 //================================================================================
2375
2376 void SMESH_subMesh::notifyListenersOnEvent( const int         event,
2377                                             const event_type  eventType,
2378                                             SMESH_Hypothesis* hyp)
2379 {
2380   list< pair< EventListener*, EventListenerData* > > eventListeners( _eventListeners.begin(),
2381                                                                      _eventListeners.end());
2382   list< pair< EventListener*, EventListenerData* > >::iterator l_d = eventListeners.begin();
2383   for ( ; l_d != eventListeners.end(); ++l_d )
2384   {
2385     std::pair< EventListener*, EventListenerData* > li_da = *l_d;
2386     if ( !_eventListeners.count( li_da.first )) continue;
2387
2388     if ( li_da.first->myBusySM.insert( this ).second )
2389     {
2390       const bool isDeletable = li_da.first->IsDeletable();
2391
2392       li_da.first->ProcessEvent( event, eventType, this, li_da.second, hyp );
2393
2394       if ( !isDeletable || _eventListeners.count( li_da.first ))
2395         li_da.first->myBusySM.erase( this ); // a listener is hopefully not dead
2396     }
2397   }
2398 }
2399
2400 //================================================================================
2401 /*!
2402  * \brief Unregister the listener and delete listener's data
2403  * \param listener - the event listener
2404  */
2405 //================================================================================
2406
2407 void SMESH_subMesh::DeleteEventListener(EventListener* listener)
2408 {
2409   map< EventListener*, EventListenerData* >::iterator l_d =
2410     _eventListeners.find( listener );
2411   if ( l_d != _eventListeners.end() && l_d->first )
2412   {
2413     if ( l_d->second && l_d->second->IsDeletable() )
2414     {
2415       delete l_d->second;
2416     }
2417     l_d->first->myBusySM.erase( this );
2418     if ( l_d->first->IsDeletable() )
2419     {
2420       l_d->first->BeforeDelete( this, l_d->second );
2421       delete l_d->first;
2422     }
2423     _eventListeners.erase( l_d );
2424   }
2425 }
2426
2427 //================================================================================
2428 /*!
2429  * \brief Delete event listeners depending on algo of this submesh
2430  */
2431 //================================================================================
2432
2433 void SMESH_subMesh::deleteOwnListeners()
2434 {
2435   list< OwnListenerData >::iterator d;
2436   for ( d = _ownListeners.begin(); d != _ownListeners.end(); ++d )
2437   {
2438     SMESH_Mesh* mesh = _father->FindMesh( d->myMeshID );
2439     if ( !mesh || !mesh->GetSubMeshContaining( d->mySubMeshID ))
2440       continue;
2441     d->mySubMesh->DeleteEventListener( d->myListener );
2442   }
2443   _ownListeners.clear();
2444 }
2445
2446 //=======================================================================
2447 //function : loadDependentMeshes
2448 //purpose  : loads dependent meshes on SUBMESH_LOADED event
2449 //=======================================================================
2450
2451 void SMESH_subMesh::loadDependentMeshes()
2452 {
2453   list< OwnListenerData >::iterator d;
2454   for ( d = _ownListeners.begin(); d != _ownListeners.end(); ++d )
2455     if ( _father != d->mySubMesh->_father )
2456       d->mySubMesh->_father->Load();
2457
2458   // map< EventListener*, EventListenerData* >::iterator l_d = _eventListeners.begin();
2459   // for ( ; l_d != _eventListeners.end(); ++l_d )
2460   //   if ( l_d->second )
2461   //   {
2462   //     const list<SMESH_subMesh*>& smList = l_d->second->mySubMeshes;
2463   //     list<SMESH_subMesh*>::const_iterator sm = smList.begin();
2464   //     for ( ; sm != smList.end(); ++sm )
2465   //       if ( _father != (*sm)->_father )
2466   //         (*sm)->_father->Load();
2467   //   }
2468 }
2469
2470 //================================================================================
2471 /*!
2472  * \brief Do something on a certain event
2473  * \param event - algo_event or compute_event itself
2474  * \param eventType - algo_event or compute_event
2475  * \param subMesh - the submesh where the event occurs
2476  * \param data - listener data stored in the subMesh
2477  * \param hyp - hypothesis, if eventType is algo_event
2478  *
2479  * The base implementation translates CLEAN event to the subMesh
2480  * stored in listener data. Also it sends SUBMESH_COMPUTED event in case of
2481  * successful COMPUTE event.
2482  */
2483 //================================================================================
2484
2485 void SMESH_subMeshEventListener::ProcessEvent(const int          event,
2486                                               const int          eventType,
2487                                               SMESH_subMesh*     subMesh,
2488                                               EventListenerData* data,
2489                                               const SMESH_Hypothesis*  /*hyp*/)
2490 {
2491   if ( data && !data->mySubMeshes.empty() &&
2492        eventType == SMESH_subMesh::COMPUTE_EVENT)
2493   {
2494     ASSERT( data->mySubMeshes.front() != subMesh );
2495     list<SMESH_subMesh*>::iterator smIt = data->mySubMeshes.begin();
2496     list<SMESH_subMesh*>::iterator smEnd = data->mySubMeshes.end();
2497     switch ( event ) {
2498     case SMESH_subMesh::CLEAN:
2499       for ( ; smIt != smEnd; ++ smIt)
2500         (*smIt)->ComputeStateEngine( SMESH_subMesh::compute_event( event ));
2501       break;
2502     case SMESH_subMesh::COMPUTE:
2503     case SMESH_subMesh::COMPUTE_SUBMESH:
2504       if ( subMesh->GetComputeState() == SMESH_subMesh::COMPUTE_OK )
2505         for ( ; smIt != smEnd; ++ smIt)
2506           (*smIt)->ComputeStateEngine( SMESH_subMesh::SUBMESH_COMPUTED );
2507       break;
2508     default:;
2509     }
2510   }
2511 }
2512
2513 namespace {
2514
2515   //================================================================================
2516   /*!
2517    * \brief Iterator over submeshes and optionally prepended or appended one
2518    */
2519   //================================================================================
2520
2521   struct _Iterator : public SMDS_Iterator<SMESH_subMesh*>
2522   {
2523     _Iterator(SMDS_Iterator<SMESH_subMesh*>* subIt,
2524               SMESH_subMesh*                 prepend,
2525               SMESH_subMesh*                 append): myAppend(append), myIt(subIt)
2526     {
2527       myCur = prepend ? prepend : myIt->more() ? myIt->next() : append;
2528       if ( myCur == append ) append = 0;
2529     }
2530     /// Return true if and only if there are other object in this iterator
2531     virtual bool more()
2532     {
2533       return myCur;
2534     }
2535     /// Return the current object and step to the next one
2536     virtual SMESH_subMesh* next()
2537     {
2538       SMESH_subMesh* res = myCur;
2539       if ( myIt->more() ) { myCur = myIt->next(); }
2540       else                { myCur = myAppend; myAppend = 0; }
2541       return res;
2542     }
2543     /// ~
2544     ~_Iterator()
2545     { delete myIt; }
2546     ///
2547     SMESH_subMesh                 *myAppend, *myCur;
2548     SMDS_Iterator<SMESH_subMesh*> *myIt;
2549   };
2550 }
2551
2552 //================================================================================
2553 /*!
2554  * \brief Return iterator on the submeshes this one depends on
2555  *  \param includeSelf - this submesh to be returned also
2556  *  \param reverse - if true, complex shape submeshes go first
2557  */
2558 //================================================================================
2559
2560 SMESH_subMeshIteratorPtr SMESH_subMesh::getDependsOnIterator(const bool includeSelf,
2561                                                              const bool reverse) const
2562 {
2563   SMESH_subMesh *me = (SMESH_subMesh*) this;
2564   SMESH_subMesh *prepend=0, *append=0;
2565   if ( includeSelf ) {
2566     if ( reverse ) prepend = me;
2567     else            append = me;
2568   }
2569   typedef map < int, SMESH_subMesh * > TMap;
2570   if ( reverse )
2571   {
2572     return SMESH_subMeshIteratorPtr
2573       ( new _Iterator( new SMDS_mapReverseIterator<TMap>( me->DependsOn() ), prepend, append ));
2574   }
2575   {
2576     return SMESH_subMeshIteratorPtr
2577       ( new _Iterator( new SMDS_mapIterator<TMap>( me->DependsOn() ), prepend, append ));
2578   }
2579 }
2580
2581 //================================================================================
2582 /*!
2583  * \brief Returns ancestor sub-meshes. Finds them if not yet found.
2584  */
2585 //================================================================================
2586
2587 const std::vector< SMESH_subMesh * > & SMESH_subMesh::GetAncestors() const
2588 {
2589   if ( _ancestors.empty() &&
2590        !_subShape.IsSame( _father->GetShapeToMesh() ))
2591   {
2592     const TopTools_ListOfShape& ancShapes = _father->GetAncestors( _subShape );
2593
2594     SMESH_subMesh* me = const_cast< SMESH_subMesh* >( this );
2595     me->_ancestors.reserve( ancShapes.Extent() );
2596
2597     // assure that all sub-meshes exist
2598     TopoDS_Shape mainShape = _father->GetShapeToMesh();
2599     if ( !mainShape.IsNull() )
2600       _father->GetSubMesh( mainShape )->DependsOn();
2601
2602     TopTools_MapOfShape map;
2603
2604     for ( TopTools_ListIteratorOfListOfShape it( ancShapes ); it.More(); it.Next() )
2605       if ( SMESH_subMesh* sm = _father->GetSubMeshContaining( it.Value() ))
2606         if ( map.Add( it.Value() ))
2607           me->_ancestors.push_back( sm );
2608   }
2609
2610   return _ancestors;
2611 }
2612
2613 //================================================================================
2614 /*!
2615  * \brief Clears the vector of ancestor sub-meshes
2616  */
2617 //================================================================================
2618
2619 void SMESH_subMesh::ClearAncestors()
2620 {
2621   _ancestors.clear();
2622 }
2623
2624 //================================================================================
2625 /*!
2626  * \brief  Find common submeshes (based on shared sub-shapes with other
2627   * \param theOther submesh to check
2628   * \param theSetOfCommon set of common submesh
2629  */
2630 //================================================================================
2631
2632 bool SMESH_subMesh::FindIntersection(const SMESH_subMesh*            theOther,
2633                                      std::set<const SMESH_subMesh*>& theSetOfCommon ) const
2634 {
2635   size_t oldNb = theSetOfCommon.size();
2636
2637   // check main submeshes
2638   const map <int, SMESH_subMesh*>::const_iterator otherEnd = theOther->_mapDepend.end();
2639   if ( theOther->_mapDepend.find(this->GetId()) != otherEnd )
2640     theSetOfCommon.insert( this );
2641   if ( _mapDepend.find(theOther->GetId()) != _mapDepend.end() )
2642     theSetOfCommon.insert( theOther );
2643
2644   // check common submeshes
2645   map <int, SMESH_subMesh*>::const_iterator mapIt = _mapDepend.begin();
2646   for( ; mapIt != _mapDepend.end(); mapIt++ )
2647     if ( theOther->_mapDepend.find((*mapIt).first) != otherEnd )
2648       theSetOfCommon.insert( (*mapIt).second );
2649   return oldNb < theSetOfCommon.size();
2650 }