src/SMESH/SMESH_subMesh.cxx

   1 //  SMESH SMESH : implementaion of SMESH idl descriptions
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //
  23 //
  24 //  File   : SMESH_subMesh.cxx
  25 //  Author : Paul RASCLE, EDF
  26 //  Module : SMESH
  27 //  $Header$
  28
  29 #include "SMESH_subMesh.hxx"
  30
  31 #include "SMESH_Algo.hxx"
  32 #include "SMESH_Gen.hxx"
  33 #include "SMESH_HypoFilter.hxx"
  34 #include "SMESH_Hypothesis.hxx"
  35 #include "SMESH_Mesh.hxx"
  36 #include "SMESH_MesherHelper.hxx"
  37 #include "SMESH_subMeshEventListener.hxx"
  38 #include "SMESH_Comment.hxx"
  39 #include "SMDS_SetIterator.hxx"
  40
  41 #include "utilities.h"
  42 #include "OpUtil.hxx"
  43
  44 #include <BRep_Builder.hxx>
  45 #include <BRep_Tool.hxx>
  46 #include <TopExp.hxx>
  47 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
  48 #include <TopTools_IndexedMapOfShape.hxx>
  49 #include <TopTools_ListIteratorOfListOfShape.hxx>
  50 #include <TopTools_ListOfShape.hxx>
  51 #include <TopTools_MapOfShape.hxx>
  52 #include <TopoDS.hxx>
  53 #include <TopoDS_Compound.hxx>
  54 #include <gp_Pnt.hxx>
  55
  56 #include <Standard_OutOfMemory.hxx>
  57 #include <Standard_ErrorHandler.hxx>
  58
  59 using namespace std;
  60
  61 //=============================================================================
  62 /*!
  63  * \brief Allocate some memory at construction and release it at destruction.
  64  * Is used to be able to continue working after mesh generation breaks due to
  65  * lack of memory
  66  */
  67 //=============================================================================
  68
  69 struct MemoryReserve
  70 {
  71   char* myBuf;
  72   MemoryReserve(): myBuf( new char[1024*1024*2] ){}
  73   ~MemoryReserve() { delete [] myBuf; }
  74 };
  75
  76 //=============================================================================
  77 /*!
  78  *  default constructor:
  79  */
  80 //=============================================================================
  81
  82 SMESH_subMesh::SMESH_subMesh(int                  Id,
  83                              SMESH_Mesh *         father,
  84                              SMESHDS_Mesh *       meshDS,
  85                              const TopoDS_Shape & aSubShape)
  86 {
  87         _subShape = aSubShape;
  88         _subMeshDS = meshDS->MeshElements(_subShape);   // may be null ...
  89         _father = father;
  90         _Id = Id;
  91         _dependenceAnalysed = _alwaysComputed = false;
  92
  93         if (_subShape.ShapeType() == TopAbs_VERTEX)
  94         {
  95                 _algoState = HYP_OK;
  96                 _computeState = READY_TO_COMPUTE;
  97         }
  98         else
  99         {
 100           _algoState = NO_ALGO;
 101           _computeState = NOT_READY;
 102         }
 103 }
 104
 105 //=============================================================================
 106 /*!
 107  *
 108  */
 109 //=============================================================================
 110
 111 SMESH_subMesh::~SMESH_subMesh()
 112 {
 113   MESSAGE("SMESH_subMesh::~SMESH_subMesh");
 114   // ****
 115   DeleteOwnListeners();
 116 }
 117
 118 //=============================================================================
 119 /*!
 120  *
 121  */
 122 //=============================================================================
 123
 124 int SMESH_subMesh::GetId() const
 125 {
 126   //MESSAGE("SMESH_subMesh::GetId");
 127   return _Id;
 128 }
 129
 130 //=============================================================================
 131 /*!
 132  *
 133  */
 134 //=============================================================================
 135
 136 SMESHDS_SubMesh * SMESH_subMesh::GetSubMeshDS()
 137 {
 138   // submesh appears in DS only when a mesher set nodes and elements on a shape
 139   return _subMeshDS ? _subMeshDS : _subMeshDS = _father->GetMeshDS()->MeshElements(_subShape); // may be null
 140 }
 141
 142 //=============================================================================
 143 /*!
 144  *
 145  */
 146 //=============================================================================
 147
 148 SMESHDS_SubMesh* SMESH_subMesh::CreateSubMeshDS()
 149 {
 150   if ( !GetSubMeshDS() ) {
 151     SMESHDS_Mesh* meshDS = _father->GetMeshDS();
 152     meshDS->NewSubMesh( meshDS->ShapeToIndex( _subShape ) );
 153   }
 154   return GetSubMeshDS();
 155 }
 156
 157 //=============================================================================
 158 /*!
 159  *
 160  */
 161 //=============================================================================
 162
 163 SMESH_subMesh *SMESH_subMesh::GetFirstToCompute()
 164 {
 165   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(true,false);
 166   while ( smIt->more() ) {
 167     SMESH_subMesh *sm = smIt->next();
 168     if ( sm->GetComputeState() == READY_TO_COMPUTE )
 169       return sm;
 170   }
 171   return 0;                     // nothing to compute
 172 }
 173
 174 //================================================================================
 175 /*!
 176  * \brief Allow algo->Compute() if a subshape of lower dim is meshed but
 177  *        none mesh entity is bound to it (PAL13615, 2nd part)
 178  */
 179 //================================================================================
 180
 181 void SMESH_subMesh::SetIsAlwaysComputed(bool isAlCo)
 182 {
 183   _alwaysComputed = isAlCo;
 184   if ( _alwaysComputed )
 185     _computeState = COMPUTE_OK;
 186   else
 187     ComputeStateEngine( CHECK_COMPUTE_STATE );
 188 }
 189
 190 //=======================================================================
 191 //function : IsMeshComputed
 192 //purpose  : check if _subMeshDS contains mesh elements
 193 //=======================================================================
 194
 195 bool SMESH_subMesh::IsMeshComputed() const
 196 {
 197   if ( _alwaysComputed )
 198     return true;
 199   // algo may bind a submesh not to _subShape, eg 3D algo
 200   // sets nodes on SHELL while _subShape may be SOLID
 201
 202   SMESHDS_Mesh* meshDS = _father->GetMeshDS();
 203   int dim = SMESH_Gen::GetShapeDim( _subShape );
 204   int type = _subShape.ShapeType();
 205   for ( ; type <= TopAbs_VERTEX; type++) {
 206     if ( dim == SMESH_Gen::GetShapeDim( (TopAbs_ShapeEnum) type ))
 207     {
 208       TopExp_Explorer exp( _subShape, (TopAbs_ShapeEnum) type );
 209       for ( ; exp.More(); exp.Next() )
 210       {
 211         if ( SMESHDS_SubMesh * smDS = meshDS->MeshElements( exp.Current() ))
 212         {
 213           bool computed = (dim > 0) ? smDS->NbElements() : smDS->NbNodes();
 214           if ( computed )
 215             return true;
 216         }
 217       }
 218     }
 219     else
 220       break;
 221   }
 222
 223   return false;
 224 }
 225
 226 //=============================================================================
 227 /*!
 228  *
 229  */
 230 //=============================================================================
 231
 232 bool SMESH_subMesh::SubMeshesComputed()
 233 {
 234   int myDim = SMESH_Gen::GetShapeDim( _subShape );
 235   int dimToCheck = myDim - 1;
 236   bool subMeshesComputed = true;
 237   // check subMeshes with upper dimension => reverse iteration
 238   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true);
 239   while ( smIt->more() )
 240   {
 241     SMESH_subMesh *sm = smIt->next();
 242     if ( sm->_alwaysComputed )
 243       continue;
 244     const TopoDS_Shape & ss = sm->GetSubShape();
 245     // MSV 07.04.2006: restrict checking to myDim-1 only. Ex., there is no sense
 246     // in checking of existence of edges if the algo needs only faces. Moreover,
 247     // degenerated edges may have no submesh, as after computing NETGEN_2D.
 248     int dim = SMESH_Gen::GetShapeDim( ss );
 249     if (dim < dimToCheck)
 250       break; // the rest subMeshes are all of less dimension
 251     SMESHDS_SubMesh * ds = sm->GetSubMeshDS();
 252     bool computeOk = (sm->GetComputeState() == COMPUTE_OK ||
 253                       (ds && ( ds->NbNodes() || ds->NbElements() )));
 254     if (!computeOk)
 255     {
 256       int type = ss.ShapeType();
 257
 258       subMeshesComputed = false;
 259
 260       switch (type)
 261       {
 262       case TopAbs_COMPOUND:
 263         {
 264           MESSAGE("The not computed sub mesh is a COMPOUND");
 265           break;
 266         }
 267       case TopAbs_COMPSOLID:
 268         {
 269           MESSAGE("The not computed sub mesh is a COMPSOLID");
 270           break;
 271         }
 272       case TopAbs_SHELL:
 273         {
 274           MESSAGE("The not computed sub mesh is a SHEL");
 275           break;
 276         }
 277       case TopAbs_WIRE:
 278         {
 279           MESSAGE("The not computed sub mesh is a WIRE");
 280           break;
 281         }
 282       case TopAbs_SOLID:
 283         {
 284           MESSAGE("The not computed sub mesh is a SOLID");
 285           break;
 286         }
 287       case TopAbs_FACE:
 288         {
 289           MESSAGE("The not computed sub mesh is a FACE");
 290           break;
 291         }
 292       case TopAbs_EDGE:
 293         {
 294           MESSAGE("The not computed sub mesh is a EDGE");
 295           break;
 296         }
 297       default:
 298         {
 299           MESSAGE("The not computed sub mesh is of unknown type");
 300           break;
 301         }
 302       }
 303
 304       break;
 305     }
 306   }
 307   return subMeshesComputed;
 308 }
 309
 310 //=============================================================================
 311 /*!
 312  *
 313  */
 314 //=============================================================================
 315
 316 bool SMESH_subMesh::SubMeshesReady()
 317 {
 318   bool subMeshesReady = true;
 319   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true);
 320   while ( smIt->more() ) {
 321     SMESH_subMesh *sm = smIt->next();
 322     bool computeOk = (sm->GetComputeState() == COMPUTE_OK ||
 323                       sm->GetComputeState() == READY_TO_COMPUTE);
 324     if (!computeOk)
 325     {
 326       subMeshesReady = false;
 327       SCRUTE(sm->GetId());
 328       break;
 329     }
 330   }
 331   return subMeshesReady;
 332 }
 333
 334 //=============================================================================
 335 /*!
 336  * Construct dependence on first level subMeshes. complex shapes (compsolid,
 337  * shell, wire) are not analysed the same way as simple shapes (solid, face,
 338  * edge).
 339  * For collection shapes (compsolid, shell, wire) prepare a list of submeshes
 340  * with possible multiples occurences. Multiples occurences corresponds to
 341  * internal frontiers within shapes of the collection and must not be keeped.
 342  * See FinalizeDependence.
 343  */
 344 //=============================================================================
 345
 346 const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn()
 347 {
 348   if (_dependenceAnalysed)
 349     return _mapDepend;
 350
 351   //MESSAGE("SMESH_subMesh::DependsOn");
 352
 353   int type = _subShape.ShapeType();
 354   //SCRUTE(type);
 355   switch (type)
 356   {
 357   case TopAbs_COMPOUND:
 358     {
 359       //MESSAGE("compound");
 360       for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More();
 361            exp.Next())
 362       {
 363         InsertDependence(exp.Current());
 364       }
 365       for (TopExp_Explorer exp(_subShape, TopAbs_SHELL, TopAbs_SOLID); exp.More();
 366            exp.Next())
 367       {
 368           InsertDependence(exp.Current());      //only shell not in solid
 369       }
 370       for (TopExp_Explorer exp(_subShape, TopAbs_FACE, TopAbs_SHELL); exp.More();
 371            exp.Next())
 372       {
 373         InsertDependence(exp.Current());
 374       }
 375       for (TopExp_Explorer exp(_subShape, TopAbs_EDGE, TopAbs_FACE); exp.More();
 376            exp.Next())
 377       {
 378         InsertDependence(exp.Current());
 379       }
 380       break;
 381     }
 382   case TopAbs_COMPSOLID:
 383     {
 384                 //MESSAGE("compsolid");
 385       for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More();
 386            exp.Next())
 387       {
 388         InsertDependence(exp.Current());
 389       }
 390       break;
 391     }
 392   case TopAbs_SHELL:
 393     {
 394       //MESSAGE("shell");
 395       for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More();
 396            exp.Next())
 397       {
 398         InsertDependence(exp.Current());
 399       }
 400       break;
 401     }
 402   case TopAbs_WIRE:
 403     {
 404       //MESSAGE("wire");
 405       for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More();
 406            exp.Next())
 407       {
 408         InsertDependence(exp.Current());
 409       }
 410       break;
 411     }
 412   case TopAbs_SOLID:
 413     {
 414       //MESSAGE("solid");
 415       for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More();
 416            exp.Next())
 417       {
 418         InsertDependence(exp.Current());
 419       }
 420       break;
 421     }
 422   case TopAbs_FACE:
 423     {
 424       //MESSAGE("face");
 425       for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More();
 426            exp.Next())
 427       {
 428         InsertDependence(exp.Current());
 429       }
 430       break;
 431     }
 432   case TopAbs_EDGE:
 433     {
 434       //MESSAGE("edge");
 435       for (TopExp_Explorer exp(_subShape, TopAbs_VERTEX); exp.More();
 436            exp.Next())
 437       {
 438                         InsertDependence(exp.Current());
 439                       }
 440       break;
 441     }
 442   case TopAbs_VERTEX:
 443     {
 444       break;
 445     }
 446   default:
 447     {
 448       break;
 449     }
 450   }
 451   _dependenceAnalysed = true;
 452   return _mapDepend;
 453 }
 454
 455 //=============================================================================
 456 /*!
 457  * For simple Shapes (solid, face, edge): add subMesh into dependence list.
 458  */
 459 //=============================================================================
 460
 461 void SMESH_subMesh::InsertDependence(const TopoDS_Shape aSubShape)
 462 {
 463   //MESSAGE("SMESH_subMesh::InsertDependence");
 464   SMESH_subMesh *aSubMesh = _father->GetSubMesh(aSubShape);
 465   int type = aSubShape.ShapeType();
 466   int ordType = 9 - type;               // 2 = Vertex, 8 = CompSolid
 467   int cle = aSubMesh->GetId();
 468   cle += 10000000 * ordType;    // sort map by ordType then index
 469   if ( _mapDepend.find( cle ) == _mapDepend.end())
 470   {
 471     _mapDepend[cle] = aSubMesh;
 472     const map < int, SMESH_subMesh * > & subMap = aSubMesh->DependsOn();
 473     _mapDepend.insert( subMap.begin(), subMap.end() );
 474   }
 475 }
 476
 477 //=============================================================================
 478 /*!
 479  *
 480  */
 481 //=============================================================================
 482
 483 const TopoDS_Shape & SMESH_subMesh::GetSubShape() const
 484 {
 485         //MESSAGE("SMESH_subMesh::GetSubShape");
 486         return _subShape;
 487 }
 488
 489
 490 //=======================================================================
 491 //function : CanAddHypothesis
 492 //purpose  : return true if theHypothesis can be attached to me:
 493 //           its dimention is checked
 494 //=======================================================================
 495
 496 bool SMESH_subMesh::CanAddHypothesis(const SMESH_Hypothesis* theHypothesis) const
 497 {
 498   int aHypDim   = theHypothesis->GetDim();
 499   int aShapeDim = SMESH_Gen::GetShapeDim(_subShape);
 500   if ( aHypDim <= aShapeDim )
 501     return true;
 502 //   if ( aHypDim < aShapeDim )
 503 //     return ( _father->IsMainShape( _subShape ));
 504
 505   return false;
 506 }
 507
 508 //=======================================================================
 509 //function : IsApplicableHypotesis
 510 //purpose  :
 511 //=======================================================================
 512
 513 bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis,
 514                                           const TopAbs_ShapeEnum  theShapeType)
 515 {
 516   if ( theHypothesis->GetType() > SMESHDS_Hypothesis::PARAM_ALGO)
 517     // algorithm
 518     return ( theHypothesis->GetShapeType() & (1<< theShapeType));
 519
 520   // hypothesis
 521   switch ( theShapeType ) {
 522   case TopAbs_VERTEX:
 523   case TopAbs_EDGE:
 524   case TopAbs_FACE:
 525   case TopAbs_SOLID:
 526     return SMESH_Gen::GetShapeDim( theShapeType ) == theHypothesis->GetDim();
 527
 528   case TopAbs_SHELL:
 529     // Special case for algorithms, building 2D mesh on a whole shell.
 530     // Before this fix there was a problem after restoring from study,
 531     // because in that case algorithm is assigned before hypothesis
 532     // (on shell in problem case) and hypothesis is checked on faces
 533     // (because it is 2D), where we have NO_ALGO state.
 534     // Now 2D hypothesis is also applicable to shells.
 535     return (theHypothesis->GetDim() == 2 || theHypothesis->GetDim() == 3);
 536
 537 //   case TopAbs_WIRE:
 538 //   case TopAbs_COMPSOLID:
 539 //   case TopAbs_COMPOUND:
 540   default:;
 541   }
 542   return false;
 543 }
 544
 545 //=============================================================================
 546 /*!
 547  *
 548  */
 549 //=============================================================================
 550
 551 SMESH_Hypothesis::Hypothesis_Status
 552   SMESH_subMesh::AlgoStateEngine(int event, SMESH_Hypothesis * anHyp)
 553 {
 554   //  MESSAGE("SMESH_subMesh::AlgoStateEngine");
 555   //SCRUTE(_algoState);
 556   //SCRUTE(event);
 557
 558   // **** les retour des evenement shape sont significatifs
 559   // (add ou remove fait ou non)
 560   // le retour des evenement father n'indiquent pas que add ou remove fait
 561
 562   SMESH_Hypothesis::Hypothesis_Status aux_ret, ret = SMESH_Hypothesis::HYP_OK;
 563
 564   SMESHDS_Mesh* meshDS =_father->GetMeshDS();
 565   SMESH_Gen*    gen    =_father->GetGen();
 566   SMESH_Algo*   algo   = 0;
 567
 568   if (_subShape.ShapeType() == TopAbs_VERTEX )
 569   {
 570     if ( anHyp->GetDim() != 0) {
 571       if (event == ADD_HYP || event == ADD_ALGO)
 572         return SMESH_Hypothesis::HYP_BAD_DIM;
 573       else
 574         return SMESH_Hypothesis::HYP_OK;
 575     }
 576     // 0D hypothesis
 577     else if ( _algoState == HYP_OK ) {
 578       // update default _algoState
 579       if ( event != REMOVE_FATHER_ALGO )
 580       {
 581         _algoState = NO_ALGO;
 582         algo = gen->GetAlgo(*_father, _subShape);
 583         if ( algo ) {
 584           _algoState = MISSING_HYP;
 585           if ( event == REMOVE_FATHER_HYP ||
 586                algo->CheckHypothesis(*_father,_subShape, aux_ret))
 587             _algoState = HYP_OK;
 588         }
 589       }
 590     }
 591   }
 592
 593   int oldAlgoState = _algoState;
 594   bool modifiedHyp = (event == MODIF_HYP);  // if set to true, force event MODIF_ALGO_STATE
 595
 596   bool isApplicableHyp = IsApplicableHypotesis( anHyp );
 597
 598   if (event == ADD_ALGO || event == ADD_FATHER_ALGO)
 599   {
 600     // -------------------------------------------
 601     // check if a shape needed by algo is present
 602     // -------------------------------------------
 603     algo = static_cast< SMESH_Algo* >( anHyp );
 604     if ( !_father->HasShapeToMesh() && algo->NeedShape() )
 605       return SMESH_Hypothesis::HYP_BAD_GEOMETRY;
 606     // ----------------------
 607     // check mesh conformity
 608     // ----------------------
 609     if (isApplicableHyp && !_father->IsNotConformAllowed() && !IsConform( algo ))
 610       return SMESH_Hypothesis::HYP_NOTCONFORM;
 611   }
 612
 613   // ----------------------------------
 614   // add a hypothesis to DS if possible
 615   // ----------------------------------
 616   if (event == ADD_HYP || event == ADD_ALGO)
 617   {
 618     if ( ! CanAddHypothesis( anHyp )) // check dimension
 619       return SMESH_Hypothesis::HYP_BAD_DIM;
 620
 621     if ( /*!anHyp->IsAuxiliary() &&*/ GetSimilarAttached( _subShape, anHyp ) )
 622       return SMESH_Hypothesis::HYP_ALREADY_EXIST;
 623
 624     if ( !meshDS->AddHypothesis(_subShape, anHyp))
 625       return SMESH_Hypothesis::HYP_ALREADY_EXIST;
 626   }
 627
 628   // --------------------------
 629   // remove a hypothesis from DS
 630   // --------------------------
 631   if (event == REMOVE_HYP || event == REMOVE_ALGO)
 632   {
 633     if (!meshDS->RemoveHypothesis(_subShape, anHyp))
 634       return SMESH_Hypothesis::HYP_OK; // nothing changes
 635
 636     if (event == REMOVE_ALGO)
 637     {
 638       algo = dynamic_cast<SMESH_Algo*> (anHyp);
 639       if (!algo->NeedDescretBoundary())
 640       {
 641         // clean all mesh in the tree of the current submesh;
 642         // we must perform it now because later
 643         // we will have no information about the type of the removed algo
 644         CleanDependants();
 645         ComputeStateEngine( CLEAN );
 646         CleanDependsOn();
 647         ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
 648       }
 649     }
 650   }
 651
 652   // ------------------
 653   // analyse algo state
 654   // ------------------
 655   if (!isApplicableHyp)
 656     return ret; // not applicable hypotheses do not change algo state
 657
 658   switch (_algoState)
 659   {
 660
 661     // ----------------------------------------------------------------------
 662
 663   case NO_ALGO:
 664     switch (event) {
 665     case ADD_HYP:
 666       break;
 667     case ADD_ALGO: {
 668       algo = gen->GetAlgo((*_father), _subShape);
 669       ASSERT(algo);
 670       if (algo->CheckHypothesis((*_father),_subShape, aux_ret))
 671         SetAlgoState(HYP_OK);
 672       else if ( algo->IsStatusFatal( aux_ret )) {
 673         meshDS->RemoveHypothesis(_subShape, anHyp);
 674         ret = aux_ret;
 675       }
 676       else
 677         SetAlgoState(MISSING_HYP);
 678       break;
 679     }
 680     case REMOVE_HYP:
 681     case REMOVE_ALGO:
 682     case ADD_FATHER_HYP:
 683       break;
 684     case ADD_FATHER_ALGO: {    // Algo just added in father
 685       algo = gen->GetAlgo((*_father), _subShape);
 686       ASSERT(algo);
 687       if ( algo == anHyp ) {
 688         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret))
 689           SetAlgoState(HYP_OK);
 690         else
 691           SetAlgoState(MISSING_HYP);
 692       }
 693       break;
 694     }
 695     case REMOVE_FATHER_HYP:
 696       break;
 697     case REMOVE_FATHER_ALGO: {
 698       algo = gen->GetAlgo((*_father), _subShape);
 699       if (algo)
 700       {
 701         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
 702             SetAlgoState(HYP_OK);
 703         else
 704           SetAlgoState(MISSING_HYP);
 705       }
 706       break;
 707     }
 708     case MODIF_HYP: break;
 709     default:
 710       ASSERT(0);
 711       break;
 712     }
 713     break;
 714
 715     // ----------------------------------------------------------------------
 716
 717   case MISSING_HYP:
 718     switch (event)
 719     {
 720     case ADD_HYP: {
 721       algo = gen->GetAlgo((*_father), _subShape);
 722       ASSERT(algo);
 723       if ( algo->CheckHypothesis((*_father),_subShape, ret ))
 724         SetAlgoState(HYP_OK);
 725       if (SMESH_Hypothesis::IsStatusFatal( ret ))
 726         meshDS->RemoveHypothesis(_subShape, anHyp);
 727       else if (!_father->IsUsedHypothesis( anHyp, this ))
 728       {
 729         meshDS->RemoveHypothesis(_subShape, anHyp);
 730         ret = SMESH_Hypothesis::HYP_INCOMPATIBLE;
 731       }
 732       break;
 733     }
 734     case ADD_ALGO: {           //already existing algo : on father ?
 735       algo = gen->GetAlgo((*_father), _subShape);
 736       ASSERT(algo);
 737       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))// ignore hyp status
 738         SetAlgoState(HYP_OK);
 739       else if ( algo->IsStatusFatal( aux_ret )) {
 740         meshDS->RemoveHypothesis(_subShape, anHyp);
 741         ret = aux_ret;
 742       }
 743       else
 744         SetAlgoState(MISSING_HYP);
 745       break;
 746     }
 747     case REMOVE_HYP:
 748       break;
 749     case REMOVE_ALGO: {        // perhaps a father algo applies ?
 750       algo = gen->GetAlgo((*_father), _subShape);
 751       if (algo == NULL)  // no more algo applying on subShape...
 752       {
 753         SetAlgoState(NO_ALGO);
 754       }
 755       else
 756       {
 757         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
 758           SetAlgoState(HYP_OK);
 759         else
 760           SetAlgoState(MISSING_HYP);
 761       }
 762       break;
 763     }
 764     case MODIF_HYP: // assigned hypothesis value may become good
 765     case ADD_FATHER_HYP: {
 766       algo = gen->GetAlgo((*_father), _subShape);
 767       ASSERT(algo);
 768       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
 769         SetAlgoState(HYP_OK);
 770       else
 771         SetAlgoState(MISSING_HYP);
 772       break;
 773     }
 774     case ADD_FATHER_ALGO: { // new father algo
 775       algo = gen->GetAlgo((*_father), _subShape);
 776       ASSERT( algo );
 777       if ( algo == anHyp ) {
 778         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
 779           SetAlgoState(HYP_OK);
 780         else
 781           SetAlgoState(MISSING_HYP);
 782       }
 783       break;
 784     }
 785     case REMOVE_FATHER_HYP:    // nothing to do
 786       break;
 787     case REMOVE_FATHER_ALGO: {
 788       algo = gen->GetAlgo((*_father), _subShape);
 789       if (algo == NULL)  // no more applying algo on father
 790       {
 791         SetAlgoState(NO_ALGO);
 792       }
 793       else
 794       {
 795         if ( algo->CheckHypothesis((*_father),_subShape , aux_ret ))
 796           SetAlgoState(HYP_OK);
 797         else
 798           SetAlgoState(MISSING_HYP);
 799       }
 800       break;
 801     }
 802     default:
 803       ASSERT(0);
 804       break;
 805     }
 806     break;
 807
 808     // ----------------------------------------------------------------------
 809
 810   case HYP_OK:
 811     switch (event)
 812     {
 813     case ADD_HYP: {
 814       algo = gen->GetAlgo((*_father), _subShape);
 815       ASSERT(algo);
 816       if (!algo->CheckHypothesis((*_father),_subShape, ret ))
 817       {
 818         if ( !SMESH_Hypothesis::IsStatusFatal( ret ))
 819           // ret should be fatal: anHyp was not added
 820           ret = SMESH_Hypothesis::HYP_INCOMPATIBLE;
 821       }
 822       else if (!_father->IsUsedHypothesis(  anHyp, this ))
 823         ret = SMESH_Hypothesis::HYP_INCOMPATIBLE;
 824
 825       if (SMESH_Hypothesis::IsStatusFatal( ret ))
 826       {
 827         MESSAGE("do not add extra hypothesis");
 828         meshDS->RemoveHypothesis(_subShape, anHyp);
 829       }
 830       else
 831       {
 832         modifiedHyp = true;
 833       }
 834       break;
 835     }
 836     case ADD_ALGO: {           //already existing algo : on father ?
 837       algo = gen->GetAlgo((*_father), _subShape);
 838       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
 839         // check if algo changes
 840         SMESH_HypoFilter f;
 841         f.Init(   SMESH_HypoFilter::IsAlgo() );
 842         f.And(    SMESH_HypoFilter::IsApplicableTo( _subShape ));
 843         f.AndNot( SMESH_HypoFilter::Is( algo ));
 844         const SMESH_Hypothesis * prevAlgo = _father->GetHypothesis( _subShape, f, true );
 845         if (prevAlgo &&
 846             string(algo->GetName()) != string(prevAlgo->GetName()) )
 847           modifiedHyp = true;
 848       }
 849       else
 850         SetAlgoState(MISSING_HYP);
 851       break;
 852     }
 853     case REMOVE_HYP: {
 854       algo = gen->GetAlgo((*_father), _subShape);
 855       ASSERT(algo);
 856       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
 857         SetAlgoState(HYP_OK);
 858       else
 859         SetAlgoState(MISSING_HYP);
 860       modifiedHyp = true;
 861       break;
 862     }
 863     case REMOVE_ALGO: {         // perhaps a father algo applies ?
 864       algo = gen->GetAlgo((*_father), _subShape);
 865       if (algo == NULL)   // no more algo applying on subShape...
 866       {
 867         SetAlgoState(NO_ALGO);
 868       }
 869       else
 870       {
 871         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
 872           // check if algo remains
 873           if ( anHyp != algo && strcmp( anHyp->GetName(), algo->GetName()) )
 874             modifiedHyp = true;
 875         }
 876         else
 877           SetAlgoState(MISSING_HYP);
 878       }
 879       break;
 880     }
 881     case MODIF_HYP: // hypothesis value may become bad
 882     case ADD_FATHER_HYP: {  // new father hypothesis ?
 883       algo = gen->GetAlgo((*_father), _subShape);
 884       ASSERT(algo);
 885       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
 886       {
 887         if (_father->IsUsedHypothesis( anHyp, this )) // new Hyp
 888           modifiedHyp = true;
 889       }
 890       else
 891         SetAlgoState(MISSING_HYP);
 892       break;
 893     }
 894     case ADD_FATHER_ALGO: {
 895       algo = gen->GetAlgo((*_father), _subShape);
 896       if ( algo == anHyp ) { // a new algo on father
 897         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
 898           // check if algo changes
 899           SMESH_HypoFilter f;
 900           f.Init(   SMESH_HypoFilter::IsAlgo() );
 901           f.And(    SMESH_HypoFilter::IsApplicableTo( _subShape ));
 902           f.AndNot( SMESH_HypoFilter::Is( algo ));
 903           const SMESH_Hypothesis* prevAlgo = _father->GetHypothesis( _subShape, f, true );
 904           if (prevAlgo &&
 905               string(algo->GetName()) != string(prevAlgo->GetName()) )
 906             modifiedHyp = true;
 907         }
 908         else
 909           SetAlgoState(MISSING_HYP);
 910       }
 911       break;
 912     }
 913     case REMOVE_FATHER_HYP: {
 914       algo = gen->GetAlgo((*_father), _subShape);
 915       ASSERT(algo);
 916       if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
 917         // is there the same local hyp or maybe a new father algo applied?
 918         if ( !GetSimilarAttached( _subShape, anHyp ) )
 919           modifiedHyp = true;
 920       }
 921       else
 922         SetAlgoState(MISSING_HYP);
 923       break;
 924     }
 925     case REMOVE_FATHER_ALGO: {
 926       algo = gen->GetAlgo((*_father), _subShape);
 927       if (algo == NULL)  // no more applying algo on father
 928       {
 929         SetAlgoState(NO_ALGO);
 930       }
 931       else
 932       {
 933         if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
 934           // check if algo changes
 935           if ( string(algo->GetName()) != string( anHyp->GetName()) )
 936             modifiedHyp = true;
 937         }
 938         else
 939           SetAlgoState(MISSING_HYP);
 940       }
 941       break;
 942     }
 943     default:
 944       ASSERT(0);
 945       break;
 946     }
 947     break;
 948
 949     // ----------------------------------------------------------------------
 950
 951   default:
 952     ASSERT(0);
 953     break;
 954   }
 955
 956   // detect algorithm hiding
 957   //
 958   if ( ret == SMESH_Hypothesis::HYP_OK &&
 959        ( event == ADD_ALGO || event == ADD_FATHER_ALGO ) &&
 960        algo->GetName() == anHyp->GetName() )
 961   {
 962     // is algo hidden?
 963     SMESH_Gen* gen = _father->GetGen();
 964     TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
 965     for ( ; ( ret == SMESH_Hypothesis::HYP_OK && it.More()); it.Next() ) {
 966       if ( SMESH_Algo* upperAlgo = gen->GetAlgo( *_father, it.Value() ))
 967         if ( !upperAlgo->NeedDescretBoundary() )
 968           ret = SMESH_Hypothesis::HYP_HIDDEN_ALGO;
 969     }
 970     // is algo hiding?
 971     if ( ret == SMESH_Hypothesis::HYP_OK && !algo->NeedDescretBoundary() ) {
 972       map<int, SMESH_subMesh*>::reverse_iterator i_sm = _mapDepend.rbegin();
 973       for ( ; ( ret == SMESH_Hypothesis::HYP_OK && i_sm != _mapDepend.rend()) ; ++i_sm )
 974         if ( gen->GetAlgo( *_father, i_sm->second->_subShape ))
 975           ret = SMESH_Hypothesis::HYP_HIDING_ALGO;
 976     }
 977   }
 978
 979   bool stateChange = ( _algoState != oldAlgoState );
 980
 981   if ( stateChange && _algoState == HYP_OK ) // hyp becomes OK
 982     algo->SetEventListener( this );
 983
 984   NotifyListenersOnEvent( event, ALGO_EVENT, anHyp );
 985
 986   if ( stateChange && oldAlgoState == HYP_OK ) { // hyp becomes KO
 987     DeleteOwnListeners();
 988     if (_subShape.ShapeType() == TopAbs_VERTEX ) {
 989       // restore default states
 990       _algoState = HYP_OK;
 991       _computeState = READY_TO_COMPUTE;
 992     }
 993   }
 994
 995   if (stateChange || modifiedHyp)
 996     ComputeStateEngine(MODIF_ALGO_STATE);
 997
 998   return ret;
 999 }
1000
1001 //=======================================================================
1002 //function : IsConform
1003 //purpose  : check if a conform mesh will be produced by the Algo
1004 //=======================================================================
1005
1006 bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo)
1007 {
1008 //  MESSAGE( "SMESH_subMesh::IsConform" );
1009   if ( !theAlgo ) return false;
1010
1011   // Suppose that theAlgo is applicable to _subShape, do not check it here
1012   //if ( !IsApplicableHypotesis( theAlgo )) return false;
1013
1014   // check only algo that doesn't NeedDescretBoundary(): because mesh made
1015   // on a sub-shape will be ignored by theAlgo
1016   if ( theAlgo->NeedDescretBoundary() ||
1017        !theAlgo->OnlyUnaryInput() ) // all adjacent shapes will be meshed by this algo?
1018     return true;
1019
1020   SMESH_Gen* gen =_father->GetGen();
1021
1022   // only local algo is to be checked
1023   //if ( gen->IsGlobalHypothesis( theAlgo, *_father ))
1024   if ( _subShape.ShapeType() == _father->GetMeshDS()->ShapeToMesh().ShapeType() )
1025     return true;
1026
1027   // check algo attached to adjacent shapes
1028
1029   // loop on one level down sub-meshes
1030   TopoDS_Iterator itsub( _subShape );
1031   for (; itsub.More(); itsub.Next())
1032   {
1033     // loop on adjacent subShapes
1034     TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( itsub.Value() ));
1035     for (; it.More(); it.Next())
1036     {
1037       const TopoDS_Shape& adjacent = it.Value();
1038       if ( _subShape.IsSame( adjacent )) continue;
1039       if ( adjacent.ShapeType() != _subShape.ShapeType())
1040         break;
1041
1042       // check algo attached to smAdjacent
1043       SMESH_Algo * algo = gen->GetAlgo((*_father), adjacent);
1044       if (algo &&
1045           !algo->NeedDescretBoundary() &&
1046           algo->OnlyUnaryInput())
1047         return false; // NOT CONFORM MESH WILL BE PRODUCED
1048     }
1049   }
1050
1051   return true;
1052 }
1053
1054 //=============================================================================
1055 /*!
1056  *
1057  */
1058 //=============================================================================
1059
1060 void SMESH_subMesh::SetAlgoState(int state)
1061 {
1062   _algoState = state;
1063 }
1064
1065 //=============================================================================
1066 /*!
1067  *
1068  */
1069 //=============================================================================
1070 SMESH_Hypothesis::Hypothesis_Status
1071   SMESH_subMesh::SubMeshesAlgoStateEngine(int event,
1072                                           SMESH_Hypothesis * anHyp)
1073 {
1074   SMESH_Hypothesis::Hypothesis_Status ret = SMESH_Hypothesis::HYP_OK;
1075   //EAP: a wire (dim==1) should notify edges (dim==1)
1076   //EAP: int dim = SMESH_Gen::GetShapeDim(_subShape);
1077   //if (_subShape.ShapeType() < TopAbs_EDGE ) // wire,face etc
1078   {
1079     SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
1080     while ( smIt->more() ) {
1081       SMESH_Hypothesis::Hypothesis_Status ret2 =
1082         smIt->next()->AlgoStateEngine(event, anHyp);
1083       if ( ret2 > ret )
1084         ret = ret2;
1085     }
1086   }
1087   return ret;
1088 }
1089
1090 //=============================================================================
1091 /*!
1092  *
1093  */
1094 //=============================================================================
1095
1096 void SMESH_subMesh::CleanDependsOn()
1097 {
1098   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
1099   while ( smIt->more() )
1100     smIt->next()->ComputeStateEngine(CLEAN);
1101 }
1102
1103 //=============================================================================
1104 /*!
1105  *
1106  */
1107 //=============================================================================
1108
1109 void SMESH_subMesh::DumpAlgoState(bool isMain)
1110 {
1111         int dim = SMESH_Gen::GetShapeDim(_subShape);
1112 //   if (dim < 1) return;
1113         if (isMain)
1114         {
1115                 const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
1116
1117                 map < int, SMESH_subMesh * >::const_iterator itsub;
1118                 for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++)
1119                 {
1120                         SMESH_subMesh *sm = (*itsub).second;
1121                         sm->DumpAlgoState(false);
1122                 }
1123         }
1124         int type = _subShape.ShapeType();
1125         MESSAGE("dim = " << dim << " type of shape " << type);
1126         switch (_algoState)
1127         {
1128         case NO_ALGO:
1129                 MESSAGE(" AlgoState = NO_ALGO");
1130                 break;
1131         case MISSING_HYP:
1132                 MESSAGE(" AlgoState = MISSING_HYP");
1133                 break;
1134         case HYP_OK:
1135                 MESSAGE(" AlgoState = HYP_OK");
1136                 break;
1137         }
1138         switch (_computeState)
1139         {
1140         case NOT_READY:
1141                 MESSAGE(" ComputeState = NOT_READY");
1142                 break;
1143         case READY_TO_COMPUTE:
1144                 MESSAGE(" ComputeState = READY_TO_COMPUTE");
1145                 break;
1146         case COMPUTE_OK:
1147                 MESSAGE(" ComputeState = COMPUTE_OK");
1148                 break;
1149         case FAILED_TO_COMPUTE:
1150                 MESSAGE(" ComputeState = FAILED_TO_COMPUTE");
1151                 break;
1152         }
1153 }
1154
1155 //================================================================================
1156 /*!
1157  * \brief Remove nodes and elements bound to submesh
1158   * \param subMesh - submesh containing nodes and elements
1159  */
1160 //================================================================================
1161
1162 static void cleanSubMesh( SMESH_subMesh * subMesh )
1163 {
1164   if (subMesh) {
1165     if (SMESHDS_SubMesh * subMeshDS = subMesh->GetSubMeshDS()) {
1166       SMESHDS_Mesh * meshDS = subMesh->GetFather()->GetMeshDS();
1167       SMDS_ElemIteratorPtr ite = subMeshDS->GetElements();
1168       while (ite->more()) {
1169         const SMDS_MeshElement * elt = ite->next();
1170         //MESSAGE( " RM elt: "<<elt->GetID()<<" ( "<<elt->NbNodes()<<" )" );
1171         //meshDS->RemoveElement(elt);
1172         meshDS->RemoveFreeElement(elt, subMeshDS);
1173       }
1174
1175       SMDS_NodeIteratorPtr itn = subMeshDS->GetNodes();
1176       while (itn->more()) {
1177         const SMDS_MeshNode * node = itn->next();
1178         //MESSAGE( " RM node: "<<node->GetID());
1179         if ( node->NbInverseNodes() == 0 )
1180           meshDS->RemoveFreeNode(node, subMeshDS);
1181         else // for StdMeshers_CompositeSegment_1D: node in one submesh, edge in another
1182           meshDS->RemoveNode(node);
1183       }
1184     }
1185   }
1186 }
1187
1188 //=============================================================================
1189 /*!
1190  *
1191  */
1192 //=============================================================================
1193
1194 bool SMESH_subMesh::ComputeStateEngine(int event)
1195 {
1196   _computeError.reset();
1197
1198   //MESSAGE("SMESH_subMesh::ComputeStateEngine");
1199   //SCRUTE(_computeState);
1200   //SCRUTE(event);
1201
1202   if (_subShape.ShapeType() == TopAbs_VERTEX)
1203   {
1204     _computeState = READY_TO_COMPUTE;
1205     SMESHDS_SubMesh* smDS = GetSubMeshDS();
1206     if ( smDS && smDS->NbNodes() ) {
1207       _computeState = COMPUTE_OK;
1208     }
1209     else if ( event == COMPUTE && !_alwaysComputed ) {
1210       const TopoDS_Vertex & V = TopoDS::Vertex( _subShape );
1211       gp_Pnt P = BRep_Tool::Pnt(V);
1212       if ( SMDS_MeshNode * n = _father->GetMeshDS()->AddNode(P.X(), P.Y(), P.Z()) ) {
1213         _father->GetMeshDS()->SetNodeOnVertex(n,_Id);
1214         _computeState = COMPUTE_OK;
1215       }
1216     }
1217     if ( event == MODIF_ALGO_STATE )
1218       CleanDependants();
1219     return true;
1220   }
1221   SMESH_Gen *gen = _father->GetGen();
1222   SMESH_Algo *algo = 0;
1223   bool ret = true;
1224   SMESH_Hypothesis::Hypothesis_Status hyp_status;
1225   //algo_state oldAlgoState = (algo_state) GetAlgoState();
1226
1227   switch (_computeState)
1228   {
1229
1230     // ----------------------------------------------------------------------
1231
1232   case NOT_READY:
1233     switch (event)
1234     {
1235     case MODIF_ALGO_STATE:
1236       algo = gen->GetAlgo((*_father), _subShape);
1237       if (algo && !algo->NeedDescretBoundary())
1238         CleanDependsOn(); // clean sub-meshes with event CLEAN
1239       if ( _algoState == HYP_OK )
1240         _computeState = READY_TO_COMPUTE;
1241       break;
1242     case COMPUTE:               // nothing to do
1243       break;
1244     case CLEAN:
1245       CleanDependants();
1246       RemoveSubMeshElementsAndNodes();
1247       break;
1248     case SUBMESH_COMPUTED:      // nothing to do
1249       break;
1250     case SUBMESH_RESTORED:
1251       ComputeSubMeshStateEngine( SUBMESH_RESTORED );
1252       break;
1253     case MESH_ENTITY_REMOVED:
1254       break;
1255     case CHECK_COMPUTE_STATE:
1256       if ( IsMeshComputed() )
1257         _computeState = COMPUTE_OK;
1258       break;
1259     default:
1260       ASSERT(0);
1261       break;
1262     }
1263     break;
1264
1265     // ----------------------------------------------------------------------
1266
1267   case READY_TO_COMPUTE:
1268     switch (event)
1269     {
1270     case MODIF_ALGO_STATE:
1271       _computeState = NOT_READY;
1272       algo = gen->GetAlgo((*_father), _subShape);
1273       if (algo)
1274       {
1275         if (!algo->NeedDescretBoundary())
1276           CleanDependsOn(); // clean sub-meshes with event CLEAN
1277         if ( _algoState == HYP_OK )
1278           _computeState = READY_TO_COMPUTE;
1279       }
1280       break;
1281     case COMPUTE:
1282       {
1283         algo = gen->GetAlgo((*_father), _subShape);
1284         ASSERT(algo);
1285         ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
1286         if (!ret)
1287         {
1288           MESSAGE("***** verify compute state *****");
1289           _computeState = NOT_READY;
1290           SetAlgoState(MISSING_HYP);
1291           break;
1292         }
1293         // check submeshes needed
1294         if (_father->HasShapeToMesh() ) {
1295           bool subComputed = SubMeshesComputed();
1296           ret = ( algo->NeedDescretBoundary() ? subComputed :
1297                   ( !subComputed || _father->IsNotConformAllowed() ));
1298           if (!ret) {
1299             _computeState = FAILED_TO_COMPUTE;
1300             if ( !algo->NeedDescretBoundary() )
1301               _computeError =
1302                 SMESH_ComputeError::New(COMPERR_BAD_INPUT_MESH,
1303                                         "Unexpected computed submesh",algo);
1304             break;
1305           }
1306         }
1307         // compute
1308         CleanDependants();
1309         RemoveSubMeshElementsAndNodes();
1310         ret = false;
1311         _computeState = FAILED_TO_COMPUTE;
1312         _computeError = SMESH_ComputeError::New(COMPERR_OK,"",algo);
1313         TopoDS_Shape shape = _subShape;
1314         try {
1315 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
1316           OCC_CATCH_SIGNALS;
1317 #endif
1318           MemoryReserve aMemoryReserve;
1319           algo->InitComputeError();
1320           if ( !_father->HasShapeToMesh() ) // no shape
1321           {
1322             SMESH_MesherHelper helper( *_father );
1323             helper.SetSubShape( shape );
1324             helper.SetElementsOnShape( true );
1325             ret = algo->Compute(*_father, &helper );
1326           }
1327           else
1328           {
1329             if (!algo->OnlyUnaryInput()) {
1330               shape = GetCollection( gen, algo );
1331             }
1332             ret = algo->Compute((*_father), shape);
1333           }
1334           if ( !ret )
1335             _computeError = algo->GetComputeError();
1336         }
1337         catch ( std::bad_alloc& exc ) {
1338           printf("std::bad_alloc thrown inside algo->Compute()\n");
1339           if ( _computeError ) {
1340             _computeError->myName = COMPERR_MEMORY_PB;
1341             //_computeError->myComment = exc.what();
1342           }
1343           cleanSubMesh( this );
1344           throw exc;
1345         }
1346         catch ( Standard_OutOfMemory& exc ) {
1347           printf("Standard_OutOfMemory thrown inside algo->Compute()\n");
1348           if ( _computeError ) {
1349             _computeError->myName = COMPERR_MEMORY_PB;
1350             //_computeError->myComment = exc.what();
1351           }
1352           cleanSubMesh( this );
1353           throw std::bad_alloc();
1354         }
1355         catch (Standard_Failure& ex) {
1356           if ( !_computeError ) _computeError = SMESH_ComputeError::New();
1357           _computeError->myName    = COMPERR_OCC_EXCEPTION;
1358           _computeError->myComment += ex.DynamicType()->Name();
1359           if ( ex.GetMessageString() && strlen( ex.GetMessageString() )) {
1360             _computeError->myComment += ": ";
1361             _computeError->myComment += ex.GetMessageString();
1362           }
1363         }
1364         catch ( SALOME_Exception& S_ex ) {
1365           if ( !_computeError ) _computeError = SMESH_ComputeError::New();
1366           _computeError->myName    = COMPERR_SLM_EXCEPTION;
1367           _computeError->myComment = S_ex.what();
1368         }
1369         catch ( std::exception& exc ) {
1370           if ( !_computeError ) _computeError = SMESH_ComputeError::New();
1371           _computeError->myName    = COMPERR_STD_EXCEPTION;
1372           _computeError->myComment = exc.what();
1373         }
1374         catch ( ... ) {
1375           if ( _computeError )
1376             _computeError->myName = COMPERR_EXCEPTION;
1377           else
1378             ret = false;
1379         }
1380         if (ret && !_alwaysComputed) { // check if anything was built
1381           ret = ( GetSubMeshDS() && ( GetSubMeshDS()->NbElements() || GetSubMeshDS()->NbNodes() ));
1382         }
1383         bool isComputeErrorSet = !CheckComputeError( algo, shape );
1384         if (!ret && !isComputeErrorSet)
1385         {
1386           // Set _computeError
1387           if ( !_computeError )
1388             _computeError = SMESH_ComputeError::New();
1389           if ( _computeError->IsOK() )
1390             _computeError->myName = COMPERR_ALGO_FAILED;
1391           _computeState = FAILED_TO_COMPUTE;
1392         }
1393         if (ret)
1394         {
1395           _computeError.reset();
1396         }
1397         UpdateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED
1398       }
1399       break;
1400     case CLEAN:
1401       CleanDependants();
1402       RemoveSubMeshElementsAndNodes();
1403       _computeState = NOT_READY;
1404       algo = gen->GetAlgo((*_father), _subShape);
1405       if (algo)
1406       {
1407         ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
1408         if (ret)
1409           _computeState = READY_TO_COMPUTE;
1410         else
1411           SetAlgoState(MISSING_HYP);
1412       }
1413       break;
1414     case SUBMESH_COMPUTED:      // nothing to do
1415       break;
1416     case SUBMESH_RESTORED:
1417       // check if a mesh is already computed that may
1418       // happen after retrieval from a file
1419       ComputeStateEngine( CHECK_COMPUTE_STATE );
1420       ComputeSubMeshStateEngine( SUBMESH_RESTORED );
1421       algo = gen->GetAlgo(*_father, _subShape);
1422       if (algo) algo->SubmeshRestored( this );
1423       break;
1424     case MESH_ENTITY_REMOVED:
1425       break;
1426     case CHECK_COMPUTE_STATE:
1427       if ( IsMeshComputed() )
1428         _computeState = COMPUTE_OK;
1429       break;
1430     default:
1431       ASSERT(0);
1432       break;
1433     }
1434     break;
1435
1436     // ----------------------------------------------------------------------
1437
1438   case COMPUTE_OK:
1439     switch (event)
1440     {
1441     case MODIF_ALGO_STATE:
1442       ComputeStateEngine( CLEAN );
1443       algo = gen->GetAlgo((*_father), _subShape);
1444       if (algo && !algo->NeedDescretBoundary())
1445         CleanDependsOn(); // clean sub-meshes with event CLEAN
1446       break;
1447     case COMPUTE:               // nothing to do
1448       break;
1449     case CLEAN:
1450       CleanDependants();  // clean sub-meshes, dependant on this one, with event CLEAN
1451       RemoveSubMeshElementsAndNodes();
1452       _computeState = NOT_READY;
1453       if ( _algoState == HYP_OK )
1454         _computeState = READY_TO_COMPUTE;
1455       break;
1456     case SUBMESH_COMPUTED:      // nothing to do
1457       break;
1458     case SUBMESH_RESTORED:
1459       ComputeStateEngine( CHECK_COMPUTE_STATE );
1460       ComputeSubMeshStateEngine( SUBMESH_RESTORED );
1461       algo = gen->GetAlgo(*_father, _subShape);
1462       if (algo) algo->SubmeshRestored( this );
1463       break;
1464     case MESH_ENTITY_REMOVED:
1465       UpdateDependantsState( CHECK_COMPUTE_STATE );
1466       ComputeStateEngine( CHECK_COMPUTE_STATE );
1467       ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
1468       break;
1469     case CHECK_COMPUTE_STATE:
1470       if ( !IsMeshComputed() )
1471         if (_algoState == HYP_OK)
1472           _computeState = READY_TO_COMPUTE;
1473         else
1474           _computeState = NOT_READY;
1475       break;
1476     default:
1477       ASSERT(0);
1478       break;
1479     }
1480     break;
1481
1482     // ----------------------------------------------------------------------
1483
1484   case FAILED_TO_COMPUTE:
1485     switch (event)
1486     {
1487     case MODIF_ALGO_STATE:
1488       if (_algoState == HYP_OK)
1489         _computeState = READY_TO_COMPUTE;
1490       else
1491         _computeState = NOT_READY;
1492       break;
1493     case COMPUTE:      // nothing to do
1494       break;
1495     case CLEAN:
1496       CleanDependants(); // submeshes dependent on me should be cleaned as well
1497       RemoveSubMeshElementsAndNodes();
1498       break;
1499     case SUBMESH_COMPUTED:      // allow retry compute
1500       if (_algoState == HYP_OK)
1501         _computeState = READY_TO_COMPUTE;
1502       else
1503         _computeState = NOT_READY;
1504       break;
1505     case SUBMESH_RESTORED:
1506       ComputeSubMeshStateEngine( SUBMESH_RESTORED );
1507       break;
1508     case MESH_ENTITY_REMOVED:
1509       break;
1510     case CHECK_COMPUTE_STATE:
1511       if ( IsMeshComputed() )
1512         _computeState = COMPUTE_OK;
1513       else
1514         if (_algoState == HYP_OK)
1515           _computeState = READY_TO_COMPUTE;
1516         else
1517           _computeState = NOT_READY;
1518       break;
1519     default:
1520       ASSERT(0);
1521       break;
1522     }
1523     break;
1524
1525     // ----------------------------------------------------------------------
1526   default:
1527     ASSERT(0);
1528     break;
1529   }
1530
1531   NotifyListenersOnEvent( event, COMPUTE_EVENT );
1532
1533   return ret;
1534 }
1535
1536 //=======================================================================
1537 /*!
1538  * \brief Update compute_state by _computeError and send proper events to
1539  * dependent submeshes
1540   * \retval bool - true if _computeError is NOT set
1541  */
1542 //=======================================================================
1543
1544 bool SMESH_subMesh::CheckComputeError(SMESH_Algo* theAlgo, const TopoDS_Shape& theShape)
1545 {
1546   bool noErrors = true;
1547
1548   if ( !theShape.IsNull() )
1549   {
1550     // Check state of submeshes
1551     if ( !theAlgo->NeedDescretBoundary())
1552     {
1553       SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
1554       while ( smIt->more() )
1555         if ( !smIt->next()->CheckComputeError( theAlgo ))
1556           noErrors = false;
1557     }
1558
1559     // Check state of neighbours
1560     if ( !theAlgo->OnlyUnaryInput() &&
1561          theShape.ShapeType() == TopAbs_COMPOUND &&
1562          !theShape.IsSame( _subShape ))
1563     {
1564       for (TopoDS_Iterator subIt( theShape ); subIt.More(); subIt.Next()) {
1565         SMESH_subMesh* sm = _father->GetSubMesh( subIt.Value() );
1566         if ( sm != this ) {
1567           if ( !sm->CheckComputeError( theAlgo ))
1568             noErrors = false;
1569           UpdateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED
1570         }
1571       }
1572     }
1573   }
1574   {
1575     // Check my state
1576     if ( !_computeError || _computeError->IsOK() )
1577     {
1578       _computeState = COMPUTE_OK;
1579     }
1580     else
1581     {
1582       if ( !_computeError->myAlgo )
1583         _computeError->myAlgo = theAlgo;
1584
1585       // Show error
1586       SMESH_Comment text;
1587       text << theAlgo->GetName() << " failed on subshape #" << _Id << " with error ";
1588       if (_computeError->IsCommon() )
1589         text << _computeError->CommonName();
1590       else
1591         text << _computeError->myName;
1592       if ( _computeError->myComment.size() > 0 )
1593         text << " \"" << _computeError->myComment << "\"";
1594
1595 #ifdef _DEBUG_
1596       cout << text << endl;
1597       // Show vertices location of a failed shape
1598       TopTools_IndexedMapOfShape vMap;
1599       TopExp::MapShapes( _subShape, TopAbs_VERTEX, vMap );
1600       cout << "Subshape vertices " << ( vMap.Extent()>10 ? "(first 10):" : ":") << endl;
1601       for ( int iv = 1; iv <= vMap.Extent() && iv < 11; ++iv ) {
1602         gp_Pnt P( BRep_Tool::Pnt( TopoDS::Vertex( vMap( iv ) )));
1603         cout << "#" << _father->GetMeshDS()->ShapeToIndex( vMap( iv )) << " ";
1604         cout << P.X() << " " << P.Y() << " " << P.Z() << " " << endl;
1605       }
1606 #else
1607       INFOS( text );
1608 #endif
1609       _computeState = FAILED_TO_COMPUTE;
1610       noErrors = false;
1611     }
1612   }
1613   return noErrors;
1614 }
1615
1616 //=======================================================================
1617 //function : ApplyToCollection
1618 //purpose  : Apply theAlgo to all subshapes in theCollection
1619 //=======================================================================
1620
1621 bool SMESH_subMesh::ApplyToCollection (SMESH_Algo*         theAlgo,
1622                                        const TopoDS_Shape& theCollection)
1623 {
1624   MESSAGE("SMESH_subMesh::ApplyToCollection");
1625   ASSERT ( !theAlgo->NeedDescretBoundary() );
1626
1627   if ( _computeError )
1628     _computeError->myName = COMPERR_OK;
1629
1630   bool ok = theAlgo->Compute( *_father, theCollection );
1631
1632   // set _computeState of subshapes
1633   TopExp_Explorer anExplorer( theCollection, _subShape.ShapeType() );
1634   for ( ; anExplorer.More(); anExplorer.Next() )
1635   {
1636     if ( SMESH_subMesh* subMesh = _father->GetSubMeshContaining( anExplorer.Current() ))
1637     {
1638       bool localOK = subMesh->CheckComputeError( theAlgo );
1639       if ( !ok && localOK && !subMesh->IsMeshComputed() )
1640       {
1641         subMesh->_computeError = theAlgo->GetComputeError();
1642         if ( subMesh->_computeError->IsOK() )
1643           _computeError = SMESH_ComputeError::New(COMPERR_ALGO_FAILED);
1644         localOK = CheckComputeError( theAlgo );
1645       }
1646       if ( localOK )
1647         subMesh->UpdateDependantsState( SUBMESH_COMPUTED );
1648       subMesh->UpdateSubMeshState( localOK ? COMPUTE_OK : FAILED_TO_COMPUTE );
1649     }
1650   }
1651
1652   return true;
1653 }
1654
1655
1656 //=======================================================================
1657 //function : UpdateSubMeshState
1658 //purpose  :
1659 //=======================================================================
1660
1661 void SMESH_subMesh::UpdateSubMeshState(const compute_state theState)
1662 {
1663   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
1664   while ( smIt->more() )
1665     smIt->next()->_computeState = theState;
1666 }
1667
1668 //=======================================================================
1669 //function : ComputeSubMeshStateEngine
1670 //purpose  :
1671 //=======================================================================
1672
1673 void SMESH_subMesh::ComputeSubMeshStateEngine(int event)
1674 {
1675   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
1676   while ( smIt->more() )
1677     smIt->next()->ComputeStateEngine(event);
1678 }
1679
1680 //=======================================================================
1681 //function : UpdateDependantsState
1682 //purpose  :
1683 //=======================================================================
1684
1685 void SMESH_subMesh::UpdateDependantsState(const compute_event theEvent)
1686 {
1687   //MESSAGE("SMESH_subMesh::UpdateDependantsState");
1688   TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
1689   for (; it.More(); it.Next())
1690   {
1691     const TopoDS_Shape& ancestor = it.Value();
1692     SMESH_subMesh *aSubMesh =
1693       _father->GetSubMeshContaining(ancestor);
1694     if (aSubMesh)
1695       aSubMesh->ComputeStateEngine( theEvent );
1696   }
1697 }
1698
1699 //=============================================================================
1700 /*!
1701  *
1702  */
1703 //=============================================================================
1704
1705 void SMESH_subMesh::CleanDependants()
1706 {
1707   int dimToClean = SMESH_Gen::GetShapeDim( _subShape ) + 1;
1708
1709   TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
1710   for (; it.More(); it.Next())
1711   {
1712     const TopoDS_Shape& ancestor = it.Value();
1713     if ( SMESH_Gen::GetShapeDim( ancestor ) == dimToClean ) {
1714       // PAL8021. do not go upper than SOLID, else ComputeStateEngine(CLEAN)
1715       // will erase mesh on other shapes in a compound
1716       if ( ancestor.ShapeType() >= TopAbs_SOLID ) {
1717         SMESH_subMesh *aSubMesh = _father->GetSubMeshContaining(ancestor);
1718         if (aSubMesh)
1719           aSubMesh->ComputeStateEngine(CLEAN);
1720       }
1721     }
1722   }
1723 }
1724
1725 //=============================================================================
1726 /*!
1727  *
1728  */
1729 //=============================================================================
1730
1731 void SMESH_subMesh::RemoveSubMeshElementsAndNodes()
1732 {
1733   //SCRUTE(_subShape.ShapeType());
1734
1735   cleanSubMesh( this );
1736
1737   // algo may bind a submesh not to _subShape, eg 3D algo
1738   // sets nodes on SHELL while _subShape may be SOLID
1739
1740   int dim = SMESH_Gen::GetShapeDim( _subShape );
1741   int type = _subShape.ShapeType() + 1;
1742   for ( ; type <= TopAbs_EDGE; type++) {
1743     if ( dim == SMESH_Gen::GetShapeDim( (TopAbs_ShapeEnum) type ))
1744     {
1745       TopExp_Explorer exp( _subShape, (TopAbs_ShapeEnum) type );
1746       for ( ; exp.More(); exp.Next() )
1747         cleanSubMesh( _father->GetSubMeshContaining( exp.Current() ));
1748     }
1749     else
1750       break;
1751   }
1752 }
1753
1754 //=======================================================================
1755 //function : GetCollection
1756 //purpose  : return a shape containing all sub-shapes of the MainShape that can be
1757 //           meshed at once along with _subShape
1758 //=======================================================================
1759
1760 TopoDS_Shape SMESH_subMesh::GetCollection(SMESH_Gen * theGen, SMESH_Algo* theAlgo)
1761 {
1762   MESSAGE("SMESH_subMesh::GetCollection");
1763
1764   TopoDS_Shape mainShape = _father->GetMeshDS()->ShapeToMesh();
1765
1766   if ( mainShape.IsSame( _subShape ))
1767     return _subShape;
1768
1769   const bool ignoreAuxiliaryHyps = false;
1770   list<const SMESHDS_Hypothesis*> aUsedHyp =
1771     theAlgo->GetUsedHypothesis( *_father, _subShape, ignoreAuxiliaryHyps ); // copy
1772
1773   // put in a compound all shapes with the same hypothesis assigned
1774   // and a good ComputState
1775
1776   TopoDS_Compound aCompound;
1777   BRep_Builder aBuilder;
1778   aBuilder.MakeCompound( aCompound );
1779
1780   TopExp_Explorer anExplorer( mainShape, _subShape.ShapeType() );
1781   for ( ; anExplorer.More(); anExplorer.Next() )
1782   {
1783     const TopoDS_Shape& S = anExplorer.Current();
1784     SMESH_subMesh* subMesh = _father->GetSubMesh( S );
1785     if ( subMesh == this )
1786     {
1787       aBuilder.Add( aCompound, S );
1788     }
1789     else if ( subMesh->GetComputeState() == READY_TO_COMPUTE )
1790     {
1791       SMESH_Algo* anAlgo = theGen->GetAlgo( *_father, S );
1792       if (anAlgo == theAlgo &&
1793           anAlgo->GetUsedHypothesis( *_father, S, ignoreAuxiliaryHyps ) == aUsedHyp)
1794         aBuilder.Add( aCompound, S );
1795     }
1796   }
1797
1798   return aCompound;
1799 }
1800
1801 //=======================================================================
1802 //function : GetSimilarAttached
1803 //purpose  : return a hypothesis attached to theShape.
1804 //           If theHyp is provided, similar but not same hypotheses
1805 //           is returned; else only applicable ones having theHypType
1806 //           is returned
1807 //=======================================================================
1808
1809 const SMESH_Hypothesis* SMESH_subMesh::GetSimilarAttached(const TopoDS_Shape&      theShape,
1810                                                           const SMESH_Hypothesis * theHyp,
1811                                                           const int                theHypType)
1812 {
1813   SMESH_HypoFilter hypoKind;
1814   hypoKind.Init( hypoKind.HasType( theHyp ? theHyp->GetType() : theHypType ));
1815   if ( theHyp ) {
1816     hypoKind.And   ( hypoKind.HasDim( theHyp->GetDim() ));
1817     hypoKind.AndNot( hypoKind.Is( theHyp ));
1818     if ( theHyp->IsAuxiliary() )
1819       hypoKind.And( hypoKind.HasName( theHyp->GetName() ));
1820     else
1821       hypoKind.AndNot( hypoKind.IsAuxiliary());
1822   }
1823   else {
1824     hypoKind.And( hypoKind.IsApplicableTo( theShape ));
1825   }
1826
1827   return _father->GetHypothesis( theShape, hypoKind, false );
1828 }
1829
1830 //=======================================================================
1831 //function : CheckConcurentHypothesis
1832 //purpose  : check if there are several applicable hypothesis attached to
1833 //           ancestors
1834 //=======================================================================
1835
1836 SMESH_Hypothesis::Hypothesis_Status
1837   SMESH_subMesh::CheckConcurentHypothesis (const int theHypType)
1838 {
1839   MESSAGE ("SMESH_subMesh::CheckConcurentHypothesis");
1840
1841   // is there local hypothesis on me?
1842   if ( GetSimilarAttached( _subShape, 0, theHypType ) )
1843     return SMESH_Hypothesis::HYP_OK;
1844
1845
1846   TopoDS_Shape aPrevWithHyp;
1847   const SMESH_Hypothesis* aPrevHyp = 0;
1848   TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
1849   for (; it.More(); it.Next())
1850   {
1851     const TopoDS_Shape& ancestor = it.Value();
1852     const SMESH_Hypothesis* hyp = GetSimilarAttached( ancestor, 0, theHypType );
1853     if ( hyp )
1854     {
1855       if ( aPrevWithHyp.IsNull() || aPrevWithHyp.IsSame( ancestor ))
1856       {
1857         aPrevWithHyp = ancestor;
1858         aPrevHyp     = hyp;
1859       }
1860       else if ( aPrevWithHyp.ShapeType() == ancestor.ShapeType() && aPrevHyp != hyp )
1861         return SMESH_Hypothesis::HYP_CONCURENT;
1862       else
1863         return SMESH_Hypothesis::HYP_OK;
1864     }
1865   }
1866   return SMESH_Hypothesis::HYP_OK;
1867 }
1868
1869 //================================================================================
1870 /*!
1871  * \brief Sets an event listener and its data to a submesh
1872  * \param listener - the listener to store
1873  * \param data - the listener data to store
1874  * \param where - the submesh to store the listener and it's data
1875  * \param deleteListener - if true then the listener will be deleted as
1876  *        it is removed from where submesh
1877  *
1878  * It remembers the submesh where it puts the listener in order to delete
1879  * them when HYP_OK algo_state is lost
1880  * After being set, event listener is notified on each event of where submesh.
1881  */
1882 //================================================================================
1883
1884 void SMESH_subMesh::SetEventListener(EventListener*     listener,
1885                                      EventListenerData* data,
1886                                      SMESH_subMesh*     where)
1887 {
1888   if ( listener && where ) {
1889     where->SetEventListener( listener, data );
1890     myOwnListeners.push_back( make_pair( where, listener ));
1891   }
1892 }
1893
1894 //================================================================================
1895 /*!
1896  * \brief Sets an event listener and its data to a submesh
1897  * \param listener - the listener to store
1898  * \param data - the listener data to store
1899  *
1900  * After being set, event listener is notified on each event of a submesh.
1901  */
1902 //================================================================================
1903
1904 void SMESH_subMesh::SetEventListener(EventListener* listener, EventListenerData* data)
1905 {
1906   map< EventListener*, EventListenerData* >::iterator l_d =
1907     myEventListeners.find( listener );
1908   if ( l_d != myEventListeners.end() ) {
1909     if ( l_d->second && l_d->second->IsDeletable() )
1910       delete l_d->second;
1911     l_d->second = data;
1912   }
1913   else
1914     myEventListeners.insert( make_pair( listener, data ));
1915 }
1916
1917 //================================================================================
1918 /*!
1919  * \brief Return an event listener data
1920  * \param listener - the listener whose data is
1921  * \retval EventListenerData* - found data, maybe NULL
1922  */
1923 //================================================================================
1924
1925 EventListenerData* SMESH_subMesh::GetEventListenerData(EventListener* listener) const
1926 {
1927   map< EventListener*, EventListenerData* >::const_iterator l_d =
1928     myEventListeners.find( listener );
1929   if ( l_d != myEventListeners.end() )
1930     return l_d->second;
1931   return 0;
1932 }
1933
1934 //================================================================================
1935 /*!
1936  * \brief Notify stored event listeners on the occured event
1937  * \param event - algo_event or compute_event itself
1938  * \param eventType - algo_event or compute_event
1939  * \param subMesh - the submesh where the event occures
1940  * \param data - listener data stored in the subMesh
1941  * \param hyp - hypothesis, if eventType is algo_event
1942  */
1943 //================================================================================
1944
1945 void SMESH_subMesh::NotifyListenersOnEvent( const int         event,
1946                                             const event_type  eventType,
1947                                             SMESH_Hypothesis* hyp)
1948 {
1949   map< EventListener*, EventListenerData* >::iterator l_d = myEventListeners.begin();
1950   for ( ; l_d != myEventListeners.end(); ++l_d )
1951     l_d->first->ProcessEvent( event, eventType, this, l_d->second, hyp );
1952 }
1953
1954 //================================================================================
1955 /*!
1956  * \brief Unregister the listener and delete listener's data
1957  * \param listener - the event listener
1958  */
1959 //================================================================================
1960
1961 void SMESH_subMesh::DeleteEventListener(EventListener* listener)
1962 {
1963   map< EventListener*, EventListenerData* >::iterator l_d =
1964     myEventListeners.find( listener );
1965   if ( l_d != myEventListeners.end() ) {
1966     if ( l_d->first  && l_d->first->IsDeletable() )  delete l_d->first;
1967     if ( l_d->second && l_d->second->IsDeletable() ) delete l_d->second;
1968     myEventListeners.erase( l_d );
1969   }
1970 }
1971
1972 //================================================================================
1973 /*!
1974  * \brief Delete event listeners depending on algo of this submesh
1975  */
1976 //================================================================================
1977
1978 void SMESH_subMesh::DeleteOwnListeners()
1979 {
1980   list< pair< SMESH_subMesh*, EventListener* > >::iterator sm_l;
1981   for ( sm_l = myOwnListeners.begin(); sm_l != myOwnListeners.end(); ++sm_l)
1982     sm_l->first->DeleteEventListener( sm_l->second );
1983   myOwnListeners.clear();
1984 }
1985
1986 //================================================================================
1987 /*!
1988  * \brief Do something on a certain event
1989  * \param event - algo_event or compute_event itself
1990  * \param eventType - algo_event or compute_event
1991  * \param subMesh - the submesh where the event occures
1992  * \param data - listener data stored in the subMesh
1993  * \param hyp - hypothesis, if eventType is algo_event
1994  *
1995  * The base implementation translates CLEAN event to the subMesh
1996  * stored in listener data. Also it sends SUBMESH_COMPUTED event in case of
1997  * successful COMPUTE event.
1998  */
1999 //================================================================================
2000
2001 void SMESH_subMeshEventListener::ProcessEvent(const int          event,
2002                                               const int          eventType,
2003                                               SMESH_subMesh*     subMesh,
2004                                               EventListenerData* data,
2005                                               const SMESH_Hypothesis*  /*hyp*/)
2006 {
2007   if ( data && !data->mySubMeshes.empty() &&
2008        eventType == SMESH_subMesh::COMPUTE_EVENT)
2009   {
2010     ASSERT( data->mySubMeshes.front() != subMesh );
2011     switch ( event ) {
2012     case SMESH_subMesh::CLEAN:
2013       data->mySubMeshes.front()->ComputeStateEngine( event );
2014       break;
2015     case SMESH_subMesh::COMPUTE:
2016       if ( subMesh->GetComputeState() == SMESH_subMesh::COMPUTE_OK )
2017         data->mySubMeshes.front()->ComputeStateEngine( SMESH_subMesh::SUBMESH_COMPUTED );
2018       break;
2019     default:;
2020     }
2021   }
2022 }
2023
2024 namespace {
2025
2026   //================================================================================
2027   /*!
2028    * \brief Iterator over submeshes and optionally prepended or appended one
2029    */
2030   //================================================================================
2031
2032   struct _Iterator : public SMDS_Iterator<SMESH_subMesh*>
2033   {
2034     _Iterator(SMDS_Iterator<SMESH_subMesh*>* subIt,
2035               SMESH_subMesh*                 prepend,
2036               SMESH_subMesh*                 append): myIt(subIt),myAppend(append)
2037     {
2038       myCur = prepend ? prepend : myIt->more() ? myIt->next() : 0;
2039     }
2040     /// Return true if and only if there are other object in this iterator
2041     virtual bool more()
2042     {
2043       return myCur;
2044     }
2045     /// Return the current object and step to the next one
2046     virtual SMESH_subMesh* next()
2047     {
2048       SMESH_subMesh* res = myCur;
2049       if ( myIt->more() ) { myCur = myIt->next(); }
2050       else                { myCur = myAppend; myAppend = 0; }
2051       return res;
2052     }
2053     /// ~
2054     ~_Iterator()
2055     { delete myIt; }
2056     ///
2057     SMESH_subMesh                 *myAppend, *myCur;
2058     SMDS_Iterator<SMESH_subMesh*> *myIt;
2059   };
2060 }
2061
2062 //================================================================================
2063 /*!
2064  * \brief  Return iterator on the submeshes this one depends on
2065   * \param includeSelf - this submesh to be returned also
2066   * \param reverse - if true, complex shape submeshes go first
2067  */
2068 //================================================================================
2069
2070 SMESH_subMeshIteratorPtr SMESH_subMesh::getDependsOnIterator(const bool includeSelf,
2071                                                              const bool reverse)
2072 {
2073   SMESH_subMesh *prepend=0, *append=0;
2074   if ( includeSelf ) {
2075     if ( reverse ) prepend = this;
2076     else            append = this;
2077   }
2078   typedef map < int, SMESH_subMesh * > TMap;
2079   if ( reverse )
2080   {
2081     return SMESH_subMeshIteratorPtr
2082       ( new _Iterator( new SMDS_mapReverseIterator<TMap>( DependsOn() ), prepend, append ));
2083   }
2084   {
2085     return SMESH_subMeshIteratorPtr
2086       ( new _Iterator( new SMDS_mapIterator<TMap>( DependsOn() ), prepend, append ));
2087   }
2088 }