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\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\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           //UpdateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED
1397         }
1398         UpdateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED
1399       }
1400       break;
1401     case CLEAN:
1402       CleanDependants();
1403       RemoveSubMeshElementsAndNodes();
1404       _computeState = NOT_READY;
1405       algo = gen->GetAlgo((*_father), _subShape);
1406       if (algo)
1407       {
1408         ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
1409         if (ret)
1410           _computeState = READY_TO_COMPUTE;
1411         else
1412           SetAlgoState(MISSING_HYP);
1413       }
1414       break;
1415     case SUBMESH_COMPUTED:      // nothing to do
1416       break;
1417     case SUBMESH_RESTORED:
1418       // check if a mesh is already computed that may
1419       // happen after retrieval from a file
1420       ComputeStateEngine( CHECK_COMPUTE_STATE );
1421       ComputeSubMeshStateEngine( SUBMESH_RESTORED );
1422       algo = gen->GetAlgo(*_father, _subShape);
1423       if (algo) algo->SubmeshRestored( this );
1424       break;
1425     case MESH_ENTITY_REMOVED:
1426       break;
1427     case CHECK_COMPUTE_STATE:
1428       if ( IsMeshComputed() )
1429         _computeState = COMPUTE_OK;
1430       break;
1431     default:
1432       ASSERT(0);
1433       break;
1434     }
1435     break;
1436
1437     // ----------------------------------------------------------------------
1438
1439   case COMPUTE_OK:
1440     switch (event)
1441     {
1442     case MODIF_ALGO_STATE:
1443       ComputeStateEngine( CLEAN );
1444       algo = gen->GetAlgo((*_father), _subShape);
1445       if (algo && !algo->NeedDescretBoundary())
1446         CleanDependsOn(); // clean sub-meshes with event CLEAN
1447       break;
1448     case COMPUTE:               // nothing to do
1449       break;
1450     case CLEAN:
1451       CleanDependants();  // clean sub-meshes, dependant on this one, with event CLEAN
1452       RemoveSubMeshElementsAndNodes();
1453       _computeState = NOT_READY;
1454       if ( _algoState == HYP_OK )
1455         _computeState = READY_TO_COMPUTE;
1456       break;
1457     case SUBMESH_COMPUTED:      // nothing to do
1458       break;
1459     case SUBMESH_RESTORED:
1460       ComputeStateEngine( CHECK_COMPUTE_STATE );
1461       ComputeSubMeshStateEngine( SUBMESH_RESTORED );
1462       algo = gen->GetAlgo(*_father, _subShape);
1463       if (algo) algo->SubmeshRestored( this );
1464       break;
1465     case MESH_ENTITY_REMOVED:
1466       UpdateDependantsState( CHECK_COMPUTE_STATE );
1467       ComputeStateEngine( CHECK_COMPUTE_STATE );
1468       ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
1469       break;
1470     case CHECK_COMPUTE_STATE:
1471       if ( !IsMeshComputed() )
1472         if (_algoState == HYP_OK)
1473           _computeState = READY_TO_COMPUTE;
1474         else
1475           _computeState = NOT_READY;
1476       break;
1477     default:
1478       ASSERT(0);
1479       break;
1480     }
1481     break;
1482
1483     // ----------------------------------------------------------------------
1484
1485   case FAILED_TO_COMPUTE:
1486     switch (event)
1487     {
1488     case MODIF_ALGO_STATE:
1489       if (_algoState == HYP_OK)
1490         _computeState = READY_TO_COMPUTE;
1491       else
1492         _computeState = NOT_READY;
1493       break;
1494     case COMPUTE:      // nothing to do
1495       break;
1496     case CLEAN:
1497       CleanDependants(); // submeshes dependent on me should be cleaned as well
1498       RemoveSubMeshElementsAndNodes();
1499       break;
1500     case SUBMESH_COMPUTED:      // allow retry compute
1501       if (_algoState == HYP_OK)
1502         _computeState = READY_TO_COMPUTE;
1503       else
1504         _computeState = NOT_READY;
1505       break;
1506     case SUBMESH_RESTORED:
1507       ComputeSubMeshStateEngine( SUBMESH_RESTORED );
1508       break;
1509     case MESH_ENTITY_REMOVED:
1510       break;
1511     case CHECK_COMPUTE_STATE:
1512       if ( IsMeshComputed() )
1513         _computeState = COMPUTE_OK;
1514       else
1515         if (_algoState == HYP_OK)
1516           _computeState = READY_TO_COMPUTE;
1517         else
1518           _computeState = NOT_READY;
1519       break;
1520     default:
1521       ASSERT(0);
1522       break;
1523     }
1524     break;
1525
1526     // ----------------------------------------------------------------------
1527   default:
1528     ASSERT(0);
1529     break;
1530   }
1531
1532   NotifyListenersOnEvent( event, COMPUTE_EVENT );
1533
1534   return ret;
1535 }
1536
1537 //=======================================================================
1538 /*!
1539  * \brief Update compute_state by _computeError and send proper events to
1540  * dependent submeshes
1541   * \retval bool - true if _computeError is NOT set
1542  */
1543 //=======================================================================
1544
1545 bool SMESH_subMesh::CheckComputeError(SMESH_Algo* theAlgo, const TopoDS_Shape& theShape)
1546 {
1547   bool noErrors = true;
1548
1549   if ( !theShape.IsNull() )
1550   {
1551     // Check state of submeshes
1552     if ( !theAlgo->NeedDescretBoundary())
1553     {
1554       SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
1555       while ( smIt->more() )
1556         if ( !smIt->next()->CheckComputeError( theAlgo ))
1557           noErrors = false;
1558     }
1559
1560     // Check state of neighbours
1561     if ( !theAlgo->OnlyUnaryInput() &&
1562          theShape.ShapeType() == TopAbs_COMPOUND &&
1563          !theShape.IsSame( _subShape ))
1564     {
1565       for (TopoDS_Iterator subIt( theShape ); subIt.More(); subIt.Next()) {
1566         SMESH_subMesh* sm = _father->GetSubMesh( subIt.Value() );
1567         if ( sm != this ) {
1568           if ( !sm->CheckComputeError( theAlgo ))
1569             noErrors = false;
1570           UpdateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED
1571         }
1572       }
1573     }
1574   }
1575   {
1576     // Check my state
1577     if ( !_computeError || _computeError->IsOK() )
1578     {
1579       _computeState = COMPUTE_OK;
1580     }
1581     else
1582     {
1583       if ( !_computeError->myAlgo )
1584         _computeError->myAlgo = theAlgo;
1585
1586       // Show error
1587       SMESH_Comment text;
1588       text << theAlgo->GetName() << " failed on subshape #" << _Id << " with error ";
1589       if (_computeError->IsCommon() )
1590         text << _computeError->CommonName();
1591       else
1592         text << _computeError->myName;
1593       if ( _computeError->myComment.size() > 0 )
1594         text << " \"" << _computeError->myComment << "\"";
1595
1596 #ifdef _DEBUG_
1597       cout << text << endl;
1598       // Show vertices location of a failed shape
1599       TopTools_IndexedMapOfShape vMap;
1600       TopExp::MapShapes( _subShape, TopAbs_VERTEX, vMap );
1601       cout << "Subshape vertices " << ( vMap.Extent()>10 ? "(first 10):" : ":") << endl;
1602       for ( int iv = 1; iv <= vMap.Extent() && iv < 11; ++iv ) {
1603         gp_Pnt P( BRep_Tool::Pnt( TopoDS::Vertex( vMap( iv ) )));
1604         cout << "#" << _father->GetMeshDS()->ShapeToIndex( vMap( iv )) << " ";
1605         cout << P.X() << " " << P.Y() << " " << P.Z() << " " << endl;
1606       }
1607 #else
1608       INFOS( text );
1609 #endif
1610       _computeState = FAILED_TO_COMPUTE;
1611       noErrors = false;
1612     }
1613   }
1614   if ( !theAlgo->OnlyUnaryInput() && !theShape.IsNull() &&
1615        theShape.ShapeType() == TopAbs_COMPOUND )
1616   {
1617     for (TopoDS_Iterator subIt( theShape ); subIt.More(); subIt.Next()) {
1618       SMESH_subMesh* sm = _father->GetSubMesh( subIt.Value() );
1619       if ( sm != this && !sm->CheckComputeError( theAlgo ))
1620         noErrors = false;
1621     }
1622   }
1623   return noErrors;
1624 }
1625
1626 //=======================================================================
1627 //function : ApplyToCollection
1628 //purpose  : Apply theAlgo to all subshapes in theCollection
1629 //=======================================================================
1630
1631 bool SMESH_subMesh::ApplyToCollection (SMESH_Algo*         theAlgo,
1632                                        const TopoDS_Shape& theCollection)
1633 {
1634   MESSAGE("SMESH_subMesh::ApplyToCollection");
1635   ASSERT ( !theAlgo->NeedDescretBoundary() );
1636
1637   if ( _computeError )
1638     _computeError->myName = COMPERR_OK;
1639
1640   bool ok = theAlgo->Compute( *_father, theCollection );
1641
1642   // set _computeState of subshapes
1643   TopExp_Explorer anExplorer( theCollection, _subShape.ShapeType() );
1644   for ( ; anExplorer.More(); anExplorer.Next() )
1645   {
1646     if ( SMESH_subMesh* subMesh = _father->GetSubMeshContaining( anExplorer.Current() ))
1647     {
1648       bool localOK = subMesh->CheckComputeError( theAlgo );
1649       if ( !ok && localOK && !subMesh->IsMeshComputed() )
1650       {
1651         subMesh->_computeError = theAlgo->GetComputeError();
1652         if ( subMesh->_computeError->IsOK() )
1653           _computeError = SMESH_ComputeError::New(COMPERR_ALGO_FAILED);
1654         localOK = CheckComputeError( theAlgo );
1655       }
1656       if ( localOK )
1657         subMesh->UpdateDependantsState( SUBMESH_COMPUTED );
1658       subMesh->UpdateSubMeshState( localOK ? COMPUTE_OK : FAILED_TO_COMPUTE );
1659     }
1660   }
1661
1662   return true;
1663 }
1664
1665
1666 //=======================================================================
1667 //function : UpdateSubMeshState
1668 //purpose  :
1669 //=======================================================================
1670
1671 void SMESH_subMesh::UpdateSubMeshState(const compute_state theState)
1672 {
1673   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
1674   while ( smIt->more() )
1675     smIt->next()->_computeState = theState;
1676 }
1677
1678 //=======================================================================
1679 //function : ComputeSubMeshStateEngine
1680 //purpose  :
1681 //=======================================================================
1682
1683 void SMESH_subMesh::ComputeSubMeshStateEngine(int event)
1684 {
1685   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
1686   while ( smIt->more() )
1687     smIt->next()->ComputeStateEngine(event);
1688 }
1689
1690 //=======================================================================
1691 //function : UpdateDependantsState
1692 //purpose  :
1693 //=======================================================================
1694
1695 void SMESH_subMesh::UpdateDependantsState(const compute_event theEvent)
1696 {
1697   //MESSAGE("SMESH_subMesh::UpdateDependantsState");
1698   TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
1699   for (; it.More(); it.Next())
1700   {
1701     const TopoDS_Shape& ancestor = it.Value();
1702     SMESH_subMesh *aSubMesh =
1703       _father->GetSubMeshContaining(ancestor);
1704     if (aSubMesh)
1705       aSubMesh->ComputeStateEngine( theEvent );
1706   }
1707 }
1708
1709 //=============================================================================
1710 /*!
1711  *
1712  */
1713 //=============================================================================
1714
1715 void SMESH_subMesh::CleanDependants()
1716 {
1717   int dimToClean = SMESH_Gen::GetShapeDim( _subShape ) + 1;
1718
1719   TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
1720   for (; it.More(); it.Next())
1721   {
1722     const TopoDS_Shape& ancestor = it.Value();
1723     if ( SMESH_Gen::GetShapeDim( ancestor ) == dimToClean ) {
1724       // PAL8021. do not go upper than SOLID, else ComputeStateEngine(CLEAN)
1725       // will erase mesh on other shapes in a compound
1726       if ( ancestor.ShapeType() >= TopAbs_SOLID ) {
1727         SMESH_subMesh *aSubMesh = _father->GetSubMeshContaining(ancestor);
1728         if (aSubMesh)
1729           aSubMesh->ComputeStateEngine(CLEAN);
1730       }
1731     }
1732   }
1733 }
1734
1735 //=============================================================================
1736 /*!
1737  *
1738  */
1739 //=============================================================================
1740
1741 void SMESH_subMesh::RemoveSubMeshElementsAndNodes()
1742 {
1743   //SCRUTE(_subShape.ShapeType());
1744
1745   cleanSubMesh( this );
1746
1747   // algo may bind a submesh not to _subShape, eg 3D algo
1748   // sets nodes on SHELL while _subShape may be SOLID
1749
1750   int dim = SMESH_Gen::GetShapeDim( _subShape );
1751   int type = _subShape.ShapeType() + 1;
1752   for ( ; type <= TopAbs_EDGE; type++) {
1753     if ( dim == SMESH_Gen::GetShapeDim( (TopAbs_ShapeEnum) type ))
1754     {
1755       TopExp_Explorer exp( _subShape, (TopAbs_ShapeEnum) type );
1756       for ( ; exp.More(); exp.Next() )
1757         cleanSubMesh( _father->GetSubMeshContaining( exp.Current() ));
1758     }
1759     else
1760       break;
1761   }
1762 }
1763
1764 //=======================================================================
1765 //function : GetCollection
1766 //purpose  : return a shape containing all sub-shapes of the MainShape that can be
1767 //           meshed at once along with _subShape
1768 //=======================================================================
1769
1770 TopoDS_Shape SMESH_subMesh::GetCollection(SMESH_Gen * theGen, SMESH_Algo* theAlgo)
1771 {
1772   MESSAGE("SMESH_subMesh::GetCollection");
1773
1774   TopoDS_Shape mainShape = _father->GetMeshDS()->ShapeToMesh();
1775
1776   if ( mainShape.IsSame( _subShape ))
1777     return _subShape;
1778
1779   const bool ignoreAuxiliaryHyps = false;
1780   list<const SMESHDS_Hypothesis*> aUsedHyp =
1781     theAlgo->GetUsedHypothesis( *_father, _subShape, ignoreAuxiliaryHyps ); // copy
1782
1783   // put in a compound all shapes with the same hypothesis assigned
1784   // and a good ComputState
1785
1786   TopoDS_Compound aCompound;
1787   BRep_Builder aBuilder;
1788   aBuilder.MakeCompound( aCompound );
1789
1790   TopExp_Explorer anExplorer( mainShape, _subShape.ShapeType() );
1791   for ( ; anExplorer.More(); anExplorer.Next() )
1792   {
1793     const TopoDS_Shape& S = anExplorer.Current();
1794     SMESH_subMesh* subMesh = _father->GetSubMesh( S );
1795     if ( subMesh == this )
1796     {
1797       aBuilder.Add( aCompound, S );
1798     }
1799     else if ( subMesh->GetComputeState() == READY_TO_COMPUTE )
1800     {
1801       SMESH_Algo* anAlgo = theGen->GetAlgo( *_father, S );
1802       if (anAlgo == theAlgo &&
1803           anAlgo->GetUsedHypothesis( *_father, S, ignoreAuxiliaryHyps ) == aUsedHyp)
1804         aBuilder.Add( aCompound, S );
1805     }
1806   }
1807
1808   return aCompound;
1809 }
1810
1811 //=======================================================================
1812 //function : GetSimilarAttached
1813 //purpose  : return a hypothesis attached to theShape.
1814 //           If theHyp is provided, similar but not same hypotheses
1815 //           is returned; else only applicable ones having theHypType
1816 //           is returned
1817 //=======================================================================
1818
1819 const SMESH_Hypothesis* SMESH_subMesh::GetSimilarAttached(const TopoDS_Shape&      theShape,
1820                                                           const SMESH_Hypothesis * theHyp,
1821                                                           const int                theHypType)
1822 {
1823   SMESH_HypoFilter hypoKind;
1824   hypoKind.Init( hypoKind.HasType( theHyp ? theHyp->GetType() : theHypType ));
1825   if ( theHyp ) {
1826     hypoKind.And   ( hypoKind.HasDim( theHyp->GetDim() ));
1827     hypoKind.AndNot( hypoKind.Is( theHyp ));
1828     if ( theHyp->IsAuxiliary() )
1829       hypoKind.And( hypoKind.HasName( theHyp->GetName() ));
1830     else
1831       hypoKind.AndNot( hypoKind.IsAuxiliary());
1832   }
1833   else {
1834     hypoKind.And( hypoKind.IsApplicableTo( theShape ));
1835   }
1836
1837   return _father->GetHypothesis( theShape, hypoKind, false );
1838 }
1839
1840 //=======================================================================
1841 //function : CheckConcurentHypothesis
1842 //purpose  : check if there are several applicable hypothesis attached to
1843 //           ancestors
1844 //=======================================================================
1845
1846 SMESH_Hypothesis::Hypothesis_Status
1847   SMESH_subMesh::CheckConcurentHypothesis (const int theHypType)
1848 {
1849   MESSAGE ("SMESH_subMesh::CheckConcurentHypothesis");
1850
1851   // is there local hypothesis on me?
1852   if ( GetSimilarAttached( _subShape, 0, theHypType ) )
1853     return SMESH_Hypothesis::HYP_OK;
1854
1855
1856   TopoDS_Shape aPrevWithHyp;
1857   const SMESH_Hypothesis* aPrevHyp = 0;
1858   TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
1859   for (; it.More(); it.Next())
1860   {
1861     const TopoDS_Shape& ancestor = it.Value();
1862     const SMESH_Hypothesis* hyp = GetSimilarAttached( ancestor, 0, theHypType );
1863     if ( hyp )
1864     {
1865       if ( aPrevWithHyp.IsNull() || aPrevWithHyp.IsSame( ancestor ))
1866       {
1867         aPrevWithHyp = ancestor;
1868         aPrevHyp     = hyp;
1869       }
1870       else if ( aPrevWithHyp.ShapeType() == ancestor.ShapeType() && aPrevHyp != hyp )
1871         return SMESH_Hypothesis::HYP_CONCURENT;
1872       else
1873         return SMESH_Hypothesis::HYP_OK;
1874     }
1875   }
1876   return SMESH_Hypothesis::HYP_OK;
1877 }
1878
1879 //================================================================================
1880 /*!
1881  * \brief Sets an event listener and its data to a submesh
1882  * \param listener - the listener to store
1883  * \param data - the listener data to store
1884  * \param where - the submesh to store the listener and it's data
1885  * \param deleteListener - if true then the listener will be deleted as
1886  *        it is removed from where submesh
1887  *
1888  * It remembers the submesh where it puts the listener in order to delete
1889  * them when HYP_OK algo_state is lost
1890  * After being set, event listener is notified on each event of where submesh.
1891  */
1892 //================================================================================
1893
1894 void SMESH_subMesh::SetEventListener(EventListener*     listener,
1895                                      EventListenerData* data,
1896                                      SMESH_subMesh*     where)
1897 {
1898   if ( listener && where ) {
1899     where->SetEventListener( listener, data );
1900     myOwnListeners.push_back( make_pair( where, listener ));
1901   }
1902 }
1903
1904 //================================================================================
1905 /*!
1906  * \brief Sets an event listener and its data to a submesh
1907  * \param listener - the listener to store
1908  * \param data - the listener data to store
1909  *
1910  * After being set, event listener is notified on each event of a submesh.
1911  */
1912 //================================================================================
1913
1914 void SMESH_subMesh::SetEventListener(EventListener* listener, EventListenerData* data)
1915 {
1916   map< EventListener*, EventListenerData* >::iterator l_d =
1917     myEventListeners.find( listener );
1918   if ( l_d != myEventListeners.end() ) {
1919     if ( l_d->second && l_d->second->IsDeletable() )
1920       delete l_d->second;
1921     l_d->second = data;
1922   }
1923   else
1924     myEventListeners.insert( make_pair( listener, data ));
1925 }
1926
1927 //================================================================================
1928 /*!
1929  * \brief Return an event listener data
1930  * \param listener - the listener whose data is
1931  * \retval EventListenerData* - found data, maybe NULL
1932  */
1933 //================================================================================
1934
1935 EventListenerData* SMESH_subMesh::GetEventListenerData(EventListener* listener) const
1936 {
1937   map< EventListener*, EventListenerData* >::const_iterator l_d =
1938     myEventListeners.find( listener );
1939   if ( l_d != myEventListeners.end() )
1940     return l_d->second;
1941   return 0;
1942 }
1943
1944 //================================================================================
1945 /*!
1946  * \brief Notify stored event listeners on the occured event
1947  * \param event - algo_event or compute_event itself
1948  * \param eventType - algo_event or compute_event
1949  * \param subMesh - the submesh where the event occures
1950  * \param data - listener data stored in the subMesh
1951  * \param hyp - hypothesis, if eventType is algo_event
1952  */
1953 //================================================================================
1954
1955 void SMESH_subMesh::NotifyListenersOnEvent( const int         event,
1956                                             const event_type  eventType,
1957                                             SMESH_Hypothesis* hyp)
1958 {
1959   map< EventListener*, EventListenerData* >::iterator l_d = myEventListeners.begin();
1960   for ( ; l_d != myEventListeners.end(); ++l_d )
1961     l_d->first->ProcessEvent( event, eventType, this, l_d->second, hyp );
1962 }
1963
1964 //================================================================================
1965 /*!
1966  * \brief Unregister the listener and delete listener's data
1967  * \param listener - the event listener
1968  */
1969 //================================================================================
1970
1971 void SMESH_subMesh::DeleteEventListener(EventListener* listener)
1972 {
1973   map< EventListener*, EventListenerData* >::iterator l_d =
1974     myEventListeners.find( listener );
1975   if ( l_d != myEventListeners.end() ) {
1976     if ( l_d->first  && l_d->first->IsDeletable() )  delete l_d->first;
1977     if ( l_d->second && l_d->second->IsDeletable() ) delete l_d->second;
1978     myEventListeners.erase( l_d );
1979   }
1980 }
1981
1982 //================================================================================
1983 /*!
1984  * \brief Delete event listeners depending on algo of this submesh
1985  */
1986 //================================================================================
1987
1988 void SMESH_subMesh::DeleteOwnListeners()
1989 {
1990   list< pair< SMESH_subMesh*, EventListener* > >::iterator sm_l;
1991   for ( sm_l = myOwnListeners.begin(); sm_l != myOwnListeners.end(); ++sm_l)
1992     sm_l->first->DeleteEventListener( sm_l->second );
1993   myOwnListeners.clear();
1994 }
1995
1996 //================================================================================
1997 /*!
1998  * \brief Do something on a certain event
1999  * \param event - algo_event or compute_event itself
2000  * \param eventType - algo_event or compute_event
2001  * \param subMesh - the submesh where the event occures
2002  * \param data - listener data stored in the subMesh
2003  * \param hyp - hypothesis, if eventType is algo_event
2004  *
2005  * The base implementation translates CLEAN event to the subMesh
2006  * stored in listener data. Also it sends SUBMESH_COMPUTED event in case of
2007  * successful COMPUTE event.
2008  */
2009 //================================================================================
2010
2011 void SMESH_subMeshEventListener::ProcessEvent(const int          event,
2012                                               const int          eventType,
2013                                               SMESH_subMesh*     subMesh,
2014                                               EventListenerData* data,
2015                                               const SMESH_Hypothesis*  /*hyp*/)
2016 {
2017   if ( data && !data->mySubMeshes.empty() &&
2018        eventType == SMESH_subMesh::COMPUTE_EVENT)
2019   {
2020     ASSERT( data->mySubMeshes.front() != subMesh );
2021     switch ( event ) {
2022     case SMESH_subMesh::CLEAN:
2023       data->mySubMeshes.front()->ComputeStateEngine( event );
2024       break;
2025     case SMESH_subMesh::COMPUTE:
2026       if ( subMesh->GetComputeState() == SMESH_subMesh::COMPUTE_OK )
2027         data->mySubMeshes.front()->ComputeStateEngine( SMESH_subMesh::SUBMESH_COMPUTED );
2028       break;
2029     default:;
2030     }
2031   }
2032 }
2033
2034 namespace {
2035
2036   //================================================================================
2037   /*!
2038    * \brief Iterator over submeshes and optionally prepended or appended one
2039    */
2040   //================================================================================
2041
2042   struct _Iterator : public SMDS_Iterator<SMESH_subMesh*>
2043   {
2044     _Iterator(SMDS_Iterator<SMESH_subMesh*>* subIt,
2045               SMESH_subMesh*                 prepend,
2046               SMESH_subMesh*                 append): myIt(subIt),myAppend(append)
2047     {
2048       myCur = prepend ? prepend : myIt->more() ? myIt->next() : 0;
2049     }
2050     /// Return true if and only if there are other object in this iterator
2051     virtual bool more()
2052     {
2053       return myCur;
2054     }
2055     /// Return the current object and step to the next one
2056     virtual SMESH_subMesh* next()
2057     {
2058       SMESH_subMesh* res = myCur;
2059       if ( myIt->more() ) { myCur = myIt->next(); }
2060       else                { myCur = myAppend; myAppend = 0; }
2061       return res;
2062     }
2063     /// ~
2064     ~_Iterator()
2065     { delete myIt; }
2066     ///
2067     SMESH_subMesh                 *myAppend, *myCur;
2068     SMDS_Iterator<SMESH_subMesh*> *myIt;
2069   };
2070 }
2071
2072 //================================================================================
2073 /*!
2074  * \brief  Return iterator on the submeshes this one depends on
2075   * \param includeSelf - this submesh to be returned also
2076   * \param reverse - if true, complex shape submeshes go first
2077  */
2078 //================================================================================
2079
2080 SMESH_subMeshIteratorPtr SMESH_subMesh::getDependsOnIterator(const bool includeSelf,
2081                                                              const bool reverse)
2082 {
2083   SMESH_subMesh *prepend=0, *append=0;
2084   if ( includeSelf ) {
2085     if ( reverse ) prepend = this;
2086     else            append = this;
2087   }
2088   typedef map < int, SMESH_subMesh * > TMap;
2089   if ( reverse )
2090   {
2091     return SMESH_subMeshIteratorPtr
2092       ( new _Iterator( new SMDS_mapReverseIterator<TMap>( DependsOn() ), prepend, append ));
2093   }
2094   {
2095     return SMESH_subMeshIteratorPtr
2096       ( new _Iterator( new SMDS_mapIterator<TMap>( DependsOn() ), prepend, append ));
2097   }
2098 }