src/SMESH/SMESH_subMesh.cxx

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