src/SMESH/SMESH_subMesh.cxx

   1 // Copyright (C) 2007-2013  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 ( event == CLEAN )
1352     _alwaysComputed = false; // Unset 'true' set by MergeNodes() (issue 0022182)
1353
1354   if (_subShape.ShapeType() == TopAbs_VERTEX)
1355   {
1356     _computeState = READY_TO_COMPUTE;
1357     SMESHDS_SubMesh* smDS = GetSubMeshDS();
1358     if ( smDS && smDS->NbNodes() )
1359     {
1360       if ( event == CLEAN ) {
1361         cleanDependants();
1362         cleanSubMesh( this );
1363       }
1364       else
1365         _computeState = COMPUTE_OK;
1366     }
1367     else if (( event == COMPUTE || event == COMPUTE_SUBMESH )
1368              && !_alwaysComputed )
1369     {
1370       const TopoDS_Vertex & V = TopoDS::Vertex( _subShape );
1371       gp_Pnt P = BRep_Tool::Pnt(V);
1372       if ( SMDS_MeshNode * n = _father->GetMeshDS()->AddNode(P.X(), P.Y(), P.Z()) ) {
1373         _father->GetMeshDS()->SetNodeOnVertex(n,_Id);
1374         _computeState = COMPUTE_OK;
1375       }
1376     }
1377     if ( event == MODIF_ALGO_STATE )
1378       cleanDependants();
1379     return true;
1380   }
1381   SMESH_Gen *gen = _father->GetGen();
1382   SMESH_Algo *algo = 0;
1383   bool ret = true;
1384   SMESH_Hypothesis::Hypothesis_Status hyp_status;
1385   //algo_state oldAlgoState = (algo_state) GetAlgoState();
1386
1387   switch (_computeState)
1388   {
1389
1390     // ----------------------------------------------------------------------
1391
1392   case NOT_READY:
1393     switch (event)
1394     {
1395     case MODIF_ALGO_STATE:
1396       algo = GetAlgo();
1397       if (algo && !algo->NeedDiscreteBoundary())
1398         cleanDependsOn( algo ); // clean sub-meshes with event CLEAN
1399       if ( _algoState == HYP_OK )
1400         _computeState = READY_TO_COMPUTE;
1401       break;
1402     case COMPUTE:               // nothing to do
1403     case COMPUTE_SUBMESH:
1404       break;
1405     case COMPUTE_CANCELED:      // nothing to do
1406       break;
1407     case CLEAN:
1408       cleanDependants();
1409       removeSubMeshElementsAndNodes();
1410       break;
1411     case SUBMESH_COMPUTED:      // nothing to do
1412       break;
1413     case SUBMESH_RESTORED:
1414       ComputeSubMeshStateEngine( SUBMESH_RESTORED );
1415       break;
1416     case MESH_ENTITY_REMOVED:
1417       break;
1418     case SUBMESH_LOADED:
1419       loadDependentMeshes();
1420       ComputeSubMeshStateEngine( SUBMESH_LOADED );
1421       //break;
1422     case CHECK_COMPUTE_STATE:
1423       if ( IsMeshComputed() )
1424         _computeState = COMPUTE_OK;
1425       break;
1426     default:
1427       ASSERT(0);
1428       break;
1429     }
1430     break;
1431
1432     // ----------------------------------------------------------------------
1433
1434   case READY_TO_COMPUTE:
1435     switch (event)
1436     {
1437     case MODIF_ALGO_STATE:
1438       _computeState = NOT_READY;
1439       algo = GetAlgo();
1440       if (algo)
1441       {
1442         if (!algo->NeedDiscreteBoundary())
1443           cleanDependsOn( algo ); // clean sub-meshes with event CLEAN
1444         if ( _algoState == HYP_OK )
1445           _computeState = READY_TO_COMPUTE;
1446       }
1447       break;
1448     case COMPUTE:
1449     case COMPUTE_SUBMESH:
1450       {
1451         algo = GetAlgo();
1452         ASSERT(algo);
1453         ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
1454         if (!ret)
1455         {
1456           MESSAGE("***** verify compute state *****");
1457           _computeState = NOT_READY;
1458           setAlgoState(MISSING_HYP);
1459           break;
1460         }
1461         TopoDS_Shape shape = _subShape;
1462         // check submeshes needed
1463         if (_father->HasShapeToMesh() ) {
1464           bool subComputed = false, subFailed = false;
1465           if (!algo->OnlyUnaryInput()) {
1466             if ( event == COMPUTE &&
1467                  ( algo->NeedDiscreteBoundary() || algo->SupportSubmeshes() ))
1468               shape = getCollection( gen, algo, subComputed, subFailed );
1469             else
1470               subComputed = SubMeshesComputed( & subFailed );
1471           }
1472           else {
1473             subComputed = SubMeshesComputed();
1474           }
1475           ret = ( algo->NeedDiscreteBoundary() ? subComputed :
1476                   algo->SupportSubmeshes() ? !subFailed :
1477                   ( !subComputed || _father->IsNotConformAllowed() ));
1478           if (!ret)
1479           {
1480             _computeState = FAILED_TO_COMPUTE;
1481             if ( !algo->NeedDiscreteBoundary() && !subFailed )
1482               _computeError =
1483                 SMESH_ComputeError::New(COMPERR_BAD_INPUT_MESH,
1484                                         "Unexpected computed submesh",algo);
1485             break; // goto exit
1486           }
1487         }
1488         // Compute
1489
1490         //cleanDependants(); for "UseExisting_*D" algos
1491         //removeSubMeshElementsAndNodes();
1492         loadDependentMeshes();
1493         ret = false;
1494         _computeState = FAILED_TO_COMPUTE;
1495         _computeError = SMESH_ComputeError::New(COMPERR_OK,"",algo);
1496         try {
1497 #if OCC_VERSION_LARGE > 0x06010000
1498           OCC_CATCH_SIGNALS;
1499 #endif
1500           algo->InitComputeError();
1501           MemoryReserve aMemoryReserve;
1502           SMDS_Mesh::CheckMemory();
1503           Kernel_Utils::Localizer loc;
1504           if ( !_father->HasShapeToMesh() ) // no shape
1505           {
1506             SMESH_MesherHelper helper( *_father );
1507             helper.SetSubShape( shape );
1508             helper.SetElementsOnShape( true );
1509             ret = algo->Compute(*_father, &helper );
1510           }
1511           else
1512           {
1513             ret = algo->Compute((*_father), shape);
1514           }
1515           if ( !_computeError || ( !ret && _computeError->IsOK() ) ) // algo can set _computeError of submesh
1516             _computeError = algo->GetComputeError();
1517         }
1518         catch ( ::SMESH_ComputeError& comperr ) {
1519           cout << " SMESH_ComputeError caught" << endl;
1520           if ( !_computeError ) _computeError = SMESH_ComputeError::New();
1521           *_computeError = comperr;
1522         }
1523         catch ( std::bad_alloc& exc ) {
1524           MESSAGE("std::bad_alloc thrown inside algo->Compute()");
1525           if ( _computeError ) {
1526             _computeError->myName = COMPERR_MEMORY_PB;
1527             //_computeError->myComment = exc.what();
1528           }
1529           cleanSubMesh( this );
1530           throw exc;
1531         }
1532         catch ( Standard_OutOfMemory& exc ) {
1533           MESSAGE("Standard_OutOfMemory thrown inside algo->Compute()");
1534           if ( _computeError ) {
1535             _computeError->myName = COMPERR_MEMORY_PB;
1536             //_computeError->myComment = exc.what();
1537           }
1538           cleanSubMesh( this );
1539           throw std::bad_alloc();
1540         }
1541         catch (Standard_Failure& ex) {
1542           if ( !_computeError ) _computeError = SMESH_ComputeError::New();
1543           _computeError->myName    = COMPERR_OCC_EXCEPTION;
1544           _computeError->myComment += ex.DynamicType()->Name();
1545           if ( ex.GetMessageString() && strlen( ex.GetMessageString() )) {
1546             _computeError->myComment += ": ";
1547             _computeError->myComment += ex.GetMessageString();
1548           }
1549         }
1550         catch ( SALOME_Exception& S_ex ) {
1551           const int skipSalomeShift = 7; /* to skip "Salome " of
1552                                             "Salome Exception" prefix returned
1553                                             by SALOME_Exception::what() */
1554           if ( !_computeError ) _computeError = SMESH_ComputeError::New();
1555           _computeError->myName    = COMPERR_SLM_EXCEPTION;
1556           _computeError->myComment = S_ex.what() + skipSalomeShift;
1557         }
1558         catch ( std::exception& exc ) {
1559           if ( !_computeError ) _computeError = SMESH_ComputeError::New();
1560           _computeError->myName    = COMPERR_STD_EXCEPTION;
1561           _computeError->myComment = exc.what();
1562         }
1563         catch ( ... ) {
1564           if ( _computeError )
1565             _computeError->myName = COMPERR_EXCEPTION;
1566           else
1567             ret = false;
1568         }
1569         // check if an error reported on any sub-shape
1570         bool isComputeErrorSet = !checkComputeError( algo, ret, shape );
1571         if ( isComputeErrorSet )
1572           ret = false;
1573         // check if anything was built
1574         TopExp_Explorer subS(shape, _subShape.ShapeType());
1575         if (ret)
1576         {
1577           for (; ret && subS.More(); subS.Next())
1578             ret = _father->GetSubMesh( subS.Current() )->IsMeshComputed();
1579         }
1580         // Set _computeError
1581         if (!ret && !isComputeErrorSet)
1582         {
1583           for (subS.ReInit(); subS.More(); subS.Next())
1584           {
1585             SMESH_subMesh* sm = _father->GetSubMesh( subS.Current() );
1586             if ( !sm->IsMeshComputed() )
1587             {
1588               if ( !sm->_computeError )
1589                 sm->_computeError = SMESH_ComputeError::New();
1590               if ( sm->_computeError->IsOK() )
1591                 sm->_computeError->myName = COMPERR_ALGO_FAILED;
1592               sm->_computeState = FAILED_TO_COMPUTE;
1593               sm->_computeError->myAlgo = algo;
1594             }
1595           }
1596         }
1597         if (ret && _computeError && _computeError->myName != COMPERR_WARNING )
1598         {
1599           _computeError.reset();
1600         }
1601
1602         // send event SUBMESH_COMPUTED
1603         if ( ret ) {
1604           if ( !algo->NeedDiscreteBoundary() )
1605             // send SUBMESH_COMPUTED to dependants of all sub-meshes of shape
1606             for (subS.ReInit(); subS.More(); subS.Next())
1607             {
1608               SMESH_subMesh* sm = _father->GetSubMesh( subS.Current() );
1609               SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(false,false);
1610               while ( smIt->more() ) {
1611                 sm = smIt->next();
1612                 if ( sm->GetSubShape().ShapeType() == TopAbs_VERTEX )
1613                   sm->updateDependantsState( SUBMESH_COMPUTED );
1614                 else
1615                   break;
1616               }
1617             }
1618           else
1619             updateDependantsState( SUBMESH_COMPUTED );
1620         }
1621       }
1622       break;
1623     case COMPUTE_CANCELED:               // nothing to do
1624       break;
1625     case CLEAN:
1626       cleanDependants();
1627       removeSubMeshElementsAndNodes();
1628       _computeState = NOT_READY;
1629       algo = GetAlgo();
1630       if (algo)
1631       {
1632         ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
1633         if (ret)
1634           _computeState = READY_TO_COMPUTE;
1635         else
1636           setAlgoState(MISSING_HYP);
1637       }
1638       break;
1639     case SUBMESH_COMPUTED:      // nothing to do
1640       break;
1641     case SUBMESH_RESTORED:
1642       // check if a mesh is already computed that may
1643       // happen after retrieval from a file
1644       ComputeStateEngine( CHECK_COMPUTE_STATE );
1645       ComputeSubMeshStateEngine( SUBMESH_RESTORED );
1646       algo = GetAlgo();
1647       if (algo) algo->SubmeshRestored( this );
1648       break;
1649     case MESH_ENTITY_REMOVED:
1650       break;
1651     case SUBMESH_LOADED:
1652       loadDependentMeshes();
1653       ComputeSubMeshStateEngine( SUBMESH_LOADED );
1654       //break;
1655     case CHECK_COMPUTE_STATE:
1656       if ( IsMeshComputed() )
1657         _computeState = COMPUTE_OK;
1658       break;
1659     default:
1660       ASSERT(0);
1661       break;
1662     }
1663     break;
1664
1665     // ----------------------------------------------------------------------
1666
1667   case COMPUTE_OK:
1668     switch (event)
1669     {
1670     case MODIF_ALGO_STATE:
1671       ComputeStateEngine( CLEAN );
1672       algo = GetAlgo();
1673       if (algo && !algo->NeedDiscreteBoundary())
1674         cleanDependsOn( algo ); // clean sub-meshes with event CLEAN
1675       break;
1676     case COMPUTE:               // nothing to do
1677       break;
1678     case COMPUTE_CANCELED:      // nothing to do
1679       break;
1680     case CLEAN:
1681       cleanDependants();  // clean sub-meshes, dependant on this one, with event CLEAN
1682       removeSubMeshElementsAndNodes();
1683       _computeState = NOT_READY;
1684       if ( _algoState == HYP_OK )
1685         _computeState = READY_TO_COMPUTE;
1686       break;
1687     case SUBMESH_COMPUTED:      // nothing to do
1688       break;
1689     case SUBMESH_RESTORED:
1690       ComputeStateEngine( CHECK_COMPUTE_STATE );
1691       ComputeSubMeshStateEngine( SUBMESH_RESTORED );
1692       algo = GetAlgo();
1693       if (algo) algo->SubmeshRestored( this );
1694       break;
1695     case MESH_ENTITY_REMOVED:
1696       updateDependantsState    ( CHECK_COMPUTE_STATE );
1697       ComputeStateEngine       ( CHECK_COMPUTE_STATE );
1698       ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
1699       break;
1700     case CHECK_COMPUTE_STATE:
1701       if ( !IsMeshComputed() ) {
1702         if (_algoState == HYP_OK)
1703           _computeState = READY_TO_COMPUTE;
1704         else
1705           _computeState = NOT_READY;
1706       }
1707       break;
1708     case SUBMESH_LOADED:
1709       // already treated event, thanks to which _computeState == COMPUTE_OK
1710       break;
1711     default:
1712       ASSERT(0);
1713       break;
1714     }
1715     break;
1716
1717     // ----------------------------------------------------------------------
1718
1719   case FAILED_TO_COMPUTE:
1720     switch (event)
1721     {
1722     case MODIF_ALGO_STATE:
1723       if ( !IsEmpty() )
1724         ComputeStateEngine( CLEAN );
1725       algo = GetAlgo();
1726       if (algo && !algo->NeedDiscreteBoundary())
1727         cleanDependsOn( algo ); // clean sub-meshes with event CLEAN
1728       if (_algoState == HYP_OK)
1729         _computeState = READY_TO_COMPUTE;
1730       else
1731         _computeState = NOT_READY;
1732       break;
1733     case COMPUTE:        // nothing to do
1734     case COMPUTE_SUBMESH:
1735       break;
1736     case COMPUTE_CANCELED:
1737       {
1738         algo = GetAlgo();
1739         algo->CancelCompute();
1740       }
1741       break;
1742     case CLEAN:
1743       cleanDependants(); // submeshes dependent on me should be cleaned as well
1744       removeSubMeshElementsAndNodes();
1745       break;
1746     case SUBMESH_COMPUTED:      // allow retry compute
1747       if (_algoState == HYP_OK)
1748         _computeState = READY_TO_COMPUTE;
1749       else
1750         _computeState = NOT_READY;
1751       break;
1752     case SUBMESH_RESTORED:
1753       ComputeSubMeshStateEngine( SUBMESH_RESTORED );
1754       break;
1755     case MESH_ENTITY_REMOVED:
1756       break;
1757     case CHECK_COMPUTE_STATE:
1758       if ( IsMeshComputed() )
1759         _computeState = COMPUTE_OK;
1760       else
1761         if (_algoState == HYP_OK)
1762           _computeState = READY_TO_COMPUTE;
1763         else
1764           _computeState = NOT_READY;
1765       break;
1766     // case SUBMESH_LOADED:
1767     //   break;
1768     default:
1769       ASSERT(0);
1770       break;
1771     }
1772     break;
1773
1774     // ----------------------------------------------------------------------
1775   default:
1776     ASSERT(0);
1777     break;
1778   }
1779
1780   notifyListenersOnEvent( event, COMPUTE_EVENT );
1781
1782   return ret;
1783 }
1784
1785
1786 //=============================================================================
1787 /*!
1788  *
1789  */
1790 //=============================================================================
1791
1792 bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap)
1793 {
1794   _computeError.reset();
1795
1796   bool ret = true;
1797
1798   if (_subShape.ShapeType() == TopAbs_VERTEX) {
1799     vector<int> aVec(SMDSEntity_Last,0);
1800     aVec[SMDSEntity_Node] = 1;
1801     aResMap.insert(make_pair(this,aVec));
1802     return ret;
1803   }
1804
1805   //SMESH_Gen *gen = _father->GetGen();
1806   SMESH_Algo *algo = 0;
1807   SMESH_Hypothesis::Hypothesis_Status hyp_status;
1808
1809   algo = GetAlgo();
1810   if(algo && !aResMap.count(this) )
1811   {
1812     ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
1813     if (!ret) return false;
1814
1815     if (_father->HasShapeToMesh() && algo->NeedDiscreteBoundary())
1816     {
1817       // check submeshes needed
1818       bool subMeshEvaluated = true;
1819       int dimToCheck = SMESH_Gen::GetShapeDim( _subShape ) - 1;
1820       SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,/*complexShapeFirst=*/true);
1821       while ( smIt->more() && subMeshEvaluated )
1822       {
1823         SMESH_subMesh* sm = smIt->next();
1824         int dim = SMESH_Gen::GetShapeDim( sm->GetSubShape() );
1825         if (dim < dimToCheck) break; // the rest subMeshes are all of less dimension
1826         const vector<int> & nbs = aResMap[ sm ];
1827         subMeshEvaluated = (std::accumulate( nbs.begin(), nbs.end(), 0 ) > 0 );
1828       }
1829       if ( !subMeshEvaluated )
1830         return false;
1831     }
1832     _computeError = SMESH_ComputeError::New(COMPERR_OK,"",algo);
1833     ret = algo->Evaluate((*_father), _subShape, aResMap);
1834
1835     aResMap.insert( make_pair( this,vector<int>(0)));
1836   }
1837
1838   return ret;
1839 }
1840
1841
1842 //=======================================================================
1843 /*!
1844  * \brief Update compute_state by _computeError and send proper events to
1845  * dependent submeshes
1846   * \retval bool - true if _computeError is NOT set
1847  */
1848 //=======================================================================
1849
1850 bool SMESH_subMesh::checkComputeError(SMESH_Algo*         theAlgo,
1851                                       const bool          theComputeOK,
1852                                       const TopoDS_Shape& theShape)
1853 {
1854   bool noErrors = true;
1855
1856   if ( !theShape.IsNull() )
1857   {
1858     // Check state of submeshes
1859     if ( !theAlgo->NeedDiscreteBoundary())
1860     {
1861       SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
1862       while ( smIt->more() )
1863         if ( !smIt->next()->checkComputeError( theAlgo, theComputeOK ))
1864           noErrors = false;
1865     }
1866
1867     // Check state of neighbours
1868     if ( !theAlgo->OnlyUnaryInput() &&
1869          theShape.ShapeType() == TopAbs_COMPOUND &&
1870          !theShape.IsSame( _subShape ))
1871     {
1872       for (TopoDS_Iterator subIt( theShape ); subIt.More(); subIt.Next()) {
1873         SMESH_subMesh* sm = _father->GetSubMesh( subIt.Value() );
1874         if ( sm != this ) {
1875           if ( !sm->checkComputeError( theAlgo, theComputeOK, sm->GetSubShape() ))
1876             noErrors = false;
1877           updateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED
1878         }
1879       }
1880     }
1881   }
1882   {
1883
1884     // Set my _computeState
1885
1886     if ( !_computeError || _computeError->IsOK() )
1887     {
1888       // no error description is set to this sub-mesh, check if any mesh is computed
1889       _computeState = IsMeshComputed() ? COMPUTE_OK : FAILED_TO_COMPUTE;
1890       if ( _computeState != COMPUTE_OK )
1891       {
1892         if ( _subShape.ShapeType() == TopAbs_EDGE &&
1893              BRep_Tool::Degenerated( TopoDS::Edge( _subShape )) )
1894           _computeState = COMPUTE_OK;
1895         else if ( theComputeOK )
1896           _computeError = SMESH_ComputeError::New(COMPERR_NO_MESH_ON_SHAPE,"",theAlgo);
1897       }
1898     }
1899
1900     if ( _computeError && !_computeError->IsOK() )
1901     {
1902       if ( !_computeError->myAlgo )
1903         _computeError->myAlgo = theAlgo;
1904
1905       // Show error
1906       SMESH_Comment text;
1907       text << theAlgo->GetName() << " failed on sub-shape #" << _Id << " with error ";
1908       if (_computeError->IsCommon() )
1909         text << _computeError->CommonName();
1910       else
1911         text << _computeError->myName;
1912       if ( _computeError->myComment.size() > 0 )
1913         text << " \"" << _computeError->myComment << "\"";
1914
1915       INFOS( text );
1916
1917       _computeState = _computeError->IsKO() ? FAILED_TO_COMPUTE : COMPUTE_OK;
1918
1919       noErrors = false;
1920     }
1921   }
1922   return noErrors;
1923 }
1924
1925 //=======================================================================
1926 //function : updateSubMeshState
1927 //purpose  :
1928 //=======================================================================
1929
1930 void SMESH_subMesh::updateSubMeshState(const compute_state theState)
1931 {
1932   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
1933   while ( smIt->more() )
1934     smIt->next()->_computeState = theState;
1935 }
1936
1937 //=======================================================================
1938 //function : ComputeSubMeshStateEngine
1939 //purpose  :
1940 //=======================================================================
1941
1942 void SMESH_subMesh::ComputeSubMeshStateEngine(int event, const bool includeSelf)
1943 {
1944   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(includeSelf,false);
1945   while ( smIt->more() )
1946     smIt->next()->ComputeStateEngine(event);
1947 }
1948
1949 //=======================================================================
1950 //function : updateDependantsState
1951 //purpose  :
1952 //=======================================================================
1953
1954 void SMESH_subMesh::updateDependantsState(const compute_event theEvent)
1955 {
1956   TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
1957   for (; it.More(); it.Next())
1958   {
1959     const TopoDS_Shape& ancestor = it.Value();
1960     if ( SMESH_subMesh *aSubMesh = _father->GetSubMeshContaining(ancestor))
1961       aSubMesh->ComputeStateEngine( theEvent );
1962   }
1963 }
1964
1965 //=============================================================================
1966 /*!
1967  *
1968  */
1969 //=============================================================================
1970
1971 void SMESH_subMesh::cleanDependants()
1972 {
1973   int dimToClean = SMESH_Gen::GetShapeDim( _subShape ) + 1;
1974
1975   TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
1976   for (; it.More(); it.Next())
1977   {
1978     const TopoDS_Shape& ancestor = it.Value();
1979     if ( SMESH_Gen::GetShapeDim( ancestor ) == dimToClean ) {
1980       // PAL8021. do not go upper than SOLID, else ComputeStateEngine(CLEAN)
1981       // will erase mesh on other shapes in a compound
1982       if ( ancestor.ShapeType() >= TopAbs_SOLID ) {
1983         SMESH_subMesh *aSubMesh = _father->GetSubMeshContaining(ancestor);
1984         if (aSubMesh &&
1985             !aSubMesh->IsEmpty() ) // prevent infinite CLEAN via event lesteners
1986           aSubMesh->ComputeStateEngine(CLEAN);
1987       }
1988     }
1989   }
1990 }
1991
1992 //=============================================================================
1993 /*!
1994  *
1995  */
1996 //=============================================================================
1997
1998 void SMESH_subMesh::removeSubMeshElementsAndNodes()
1999 {
2000   cleanSubMesh( this );
2001
2002   // algo may bind a submesh not to _subShape, eg 3D algo
2003   // sets nodes on SHELL while _subShape may be SOLID
2004
2005   int dim = SMESH_Gen::GetShapeDim( _subShape );
2006   int type = _subShape.ShapeType() + 1;
2007   for ( ; type <= TopAbs_EDGE; type++) {
2008     if ( dim == SMESH_Gen::GetShapeDim( (TopAbs_ShapeEnum) type ))
2009     {
2010       TopExp_Explorer exp( _subShape, (TopAbs_ShapeEnum) type );
2011       for ( ; exp.More(); exp.Next() )
2012         cleanSubMesh( _father->GetSubMeshContaining( exp.Current() ));
2013     }
2014     else
2015       break;
2016   }
2017 }
2018
2019 //=======================================================================
2020 //function : getCollection
2021 //purpose  : return a shape containing all sub-shapes of the MainShape that can be
2022 //           meshed at once along with _subShape
2023 //=======================================================================
2024
2025 TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen,
2026                                           SMESH_Algo* theAlgo,
2027                                           bool &      theSubComputed,
2028                                           bool &      theSubFailed)
2029 {
2030   theSubComputed = SubMeshesComputed( & theSubFailed );
2031
2032   TopoDS_Shape mainShape = _father->GetMeshDS()->ShapeToMesh();
2033
2034   if ( mainShape.IsSame( _subShape ))
2035     return _subShape;
2036
2037   const bool ignoreAuxiliaryHyps = false;
2038   list<const SMESHDS_Hypothesis*> aUsedHyp =
2039     theAlgo->GetUsedHypothesis( *_father, _subShape, ignoreAuxiliaryHyps ); // copy
2040
2041   // put in a compound all shapes with the same hypothesis assigned
2042   // and a good ComputState
2043
2044   TopoDS_Compound aCompound;
2045   BRep_Builder aBuilder;
2046   aBuilder.MakeCompound( aCompound );
2047
2048   TopExp_Explorer anExplorer( mainShape, _subShape.ShapeType() );
2049   for ( ; anExplorer.More(); anExplorer.Next() )
2050   {
2051     const TopoDS_Shape& S = anExplorer.Current();
2052     SMESH_subMesh* subMesh = _father->GetSubMesh( S );
2053     if ( subMesh == this )
2054     {
2055       aBuilder.Add( aCompound, S );
2056     }
2057     else if ( subMesh->GetComputeState() == READY_TO_COMPUTE )
2058     {
2059       SMESH_Algo* anAlgo = theGen->GetAlgo( *_father, S );
2060       if (strcmp( anAlgo->GetName(), theAlgo->GetName()) == 0 && // same algo
2061           anAlgo->GetUsedHypothesis( *_father, S, ignoreAuxiliaryHyps ) == aUsedHyp) // same hyps
2062         aBuilder.Add( aCompound, S );
2063       if ( !subMesh->SubMeshesComputed() )
2064         theSubComputed = false;
2065     }
2066   }
2067
2068   return aCompound;
2069 }
2070
2071 //=======================================================================
2072 //function : getSimilarAttached
2073 //purpose  : return a hypothesis attached to theShape.
2074 //           If theHyp is provided, similar but not same hypotheses
2075 //           is returned; else only applicable ones having theHypType
2076 //           is returned
2077 //=======================================================================
2078
2079 const SMESH_Hypothesis* SMESH_subMesh::getSimilarAttached(const TopoDS_Shape&      theShape,
2080                                                           const SMESH_Hypothesis * theHyp,
2081                                                           const int                theHypType)
2082 {
2083   SMESH_HypoFilter hypoKind;
2084   hypoKind.Init( hypoKind.HasType( theHyp ? theHyp->GetType() : theHypType ));
2085   if ( theHyp ) {
2086     hypoKind.And   ( hypoKind.HasDim( theHyp->GetDim() ));
2087     hypoKind.AndNot( hypoKind.Is( theHyp ));
2088     if ( theHyp->IsAuxiliary() )
2089       hypoKind.And( hypoKind.HasName( theHyp->GetName() ));
2090     else
2091       hypoKind.AndNot( hypoKind.IsAuxiliary());
2092   }
2093   else {
2094     hypoKind.And( hypoKind.IsApplicableTo( theShape ));
2095   }
2096
2097   return _father->GetHypothesis( theShape, hypoKind, false );
2098 }
2099
2100 //=======================================================================
2101 //function : CheckConcurentHypothesis
2102 //purpose  : check if there are several applicable hypothesis attached to
2103 //           ancestors
2104 //=======================================================================
2105
2106 SMESH_Hypothesis::Hypothesis_Status
2107   SMESH_subMesh::CheckConcurentHypothesis (const int theHypType)
2108 {
2109   MESSAGE ("SMESH_subMesh::CheckConcurentHypothesis");
2110
2111   // is there local hypothesis on me?
2112   if ( getSimilarAttached( _subShape, 0, theHypType ) )
2113     return SMESH_Hypothesis::HYP_OK;
2114
2115
2116   TopoDS_Shape aPrevWithHyp;
2117   const SMESH_Hypothesis* aPrevHyp = 0;
2118   TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
2119   for (; it.More(); it.Next())
2120   {
2121     const TopoDS_Shape& ancestor = it.Value();
2122     const SMESH_Hypothesis* hyp = getSimilarAttached( ancestor, 0, theHypType );
2123     if ( hyp )
2124     {
2125       if ( aPrevWithHyp.IsNull() || aPrevWithHyp.IsSame( ancestor ))
2126       {
2127         aPrevWithHyp = ancestor;
2128         aPrevHyp     = hyp;
2129       }
2130       else if ( aPrevWithHyp.ShapeType() == ancestor.ShapeType() && aPrevHyp != hyp )
2131         return SMESH_Hypothesis::HYP_CONCURENT;
2132       else
2133         return SMESH_Hypothesis::HYP_OK;
2134     }
2135   }
2136   return SMESH_Hypothesis::HYP_OK;
2137 }
2138
2139 //================================================================================
2140 /*!
2141  * \brief Constructor of OwnListenerData
2142  */
2143 //================================================================================
2144
2145 SMESH_subMesh::OwnListenerData::OwnListenerData( SMESH_subMesh* sm, EventListener* el):
2146   mySubMesh( sm ),
2147   myMeshID( sm ? sm->GetFather()->GetId() : -1 ),
2148   mySubMeshID( sm ? sm->GetId() : -1 ),
2149   myListener( el )
2150 {
2151 }
2152
2153 //================================================================================
2154 /*!
2155  * \brief Sets an event listener and its data to a submesh
2156  * \param listener - the listener to store
2157  * \param data - the listener data to store
2158  * \param where - the submesh to store the listener and it's data
2159  *
2160  * It remembers the submesh where it puts the listener in order to delete
2161  * them when HYP_OK algo_state is lost
2162  * After being set, event listener is notified on each event of where submesh.
2163  */
2164 //================================================================================
2165
2166 void SMESH_subMesh::SetEventListener(EventListener*     listener,
2167                                      EventListenerData* data,
2168                                      SMESH_subMesh*     where)
2169 {
2170   if ( listener && where ) {
2171     where->setEventListener( listener, data );
2172     _ownListeners.push_back( OwnListenerData( where, listener ));
2173   }
2174 }
2175
2176 //================================================================================
2177 /*!
2178  * \brief Sets an event listener and its data to a submesh
2179  * \param listener - the listener to store
2180  * \param data - the listener data to store
2181  *
2182  * After being set, event listener is notified on each event of a submesh.
2183  */
2184 //================================================================================
2185
2186 void SMESH_subMesh::setEventListener(EventListener*     listener,
2187                                      EventListenerData* data)
2188 {
2189   map< EventListener*, EventListenerData* >::iterator l_d =
2190     _eventListeners.find( listener );
2191   if ( l_d != _eventListeners.end() ) {
2192     EventListenerData* curData = l_d->second;
2193     if ( curData && curData != data && curData->IsDeletable() )
2194       delete curData;
2195     l_d->second = data;
2196   }
2197   else
2198   {
2199     for ( l_d = _eventListeners.begin(); l_d != _eventListeners.end(); ++l_d )
2200       if ( listener->GetName() == l_d->first->GetName() )
2201       {
2202         EventListenerData* curData = l_d->second;
2203         if ( curData && curData != data && curData->IsDeletable() )
2204           delete curData;
2205         if ( l_d->first->IsDeletable() )
2206           delete l_d->first;
2207         _eventListeners.erase( l_d );
2208         break;
2209       }
2210     _eventListeners.insert( make_pair( listener, data ));
2211   }
2212 }
2213
2214 //================================================================================
2215 /*!
2216  * \brief Return an event listener data
2217  * \param listener - the listener whose data is
2218  * \retval EventListenerData* - found data, maybe NULL
2219  */
2220 //================================================================================
2221
2222 EventListenerData* SMESH_subMesh::GetEventListenerData(EventListener* listener) const
2223 {
2224   map< EventListener*, EventListenerData* >::const_iterator l_d =
2225     _eventListeners.find( listener );
2226   if ( l_d != _eventListeners.end() )
2227     return l_d->second;
2228   return 0;
2229 }
2230
2231 //================================================================================
2232 /*!
2233  * \brief Return an event listener data
2234  * \param listenerName - the listener name
2235  * \retval EventListenerData* - found data, maybe NULL
2236  */
2237 //================================================================================
2238
2239 EventListenerData* SMESH_subMesh::GetEventListenerData(const string& listenerName) const
2240 {
2241   map< EventListener*, EventListenerData* >::const_iterator l_d = _eventListeners.begin();
2242   for ( ; l_d != _eventListeners.end(); ++l_d )
2243     if ( listenerName == l_d->first->GetName() )
2244       return l_d->second;
2245   return 0;
2246 }
2247
2248 //================================================================================
2249 /*!
2250  * \brief Notify stored event listeners on the occured event
2251  * \param event - algo_event or compute_event itself
2252  * \param eventType - algo_event or compute_event
2253  * \param hyp - hypothesis, if eventType is algo_event
2254  */
2255 //================================================================================
2256
2257 void SMESH_subMesh::notifyListenersOnEvent( const int         event,
2258                                             const event_type  eventType,
2259                                             SMESH_Hypothesis* hyp)
2260 {
2261   map< EventListener*, EventListenerData* >::iterator l_d = _eventListeners.begin();
2262   for ( ; l_d != _eventListeners.end();  )
2263   {
2264     std::pair< EventListener*, EventListenerData* > li_da = *l_d++; /* copy to enable removal
2265                                                                        of a listener from
2266                                                                        _eventListeners by
2267                                                                        its ProcessEvent() */
2268     if ( li_da.first->myBusySM.insert( this ).second )
2269     {
2270       const size_t nbListenersBefore = _eventListeners.size();
2271       li_da.first->ProcessEvent( event, eventType, this, li_da.second, hyp );
2272       if ( nbListenersBefore == _eventListeners.size() )
2273         li_da.first->myBusySM.erase( this ); // a listener hopefully not removed
2274     }
2275   }
2276 }
2277
2278 //================================================================================
2279 /*!
2280  * \brief Unregister the listener and delete listener's data
2281  * \param listener - the event listener
2282  */
2283 //================================================================================
2284
2285 void SMESH_subMesh::DeleteEventListener(EventListener* listener)
2286 {
2287   map< EventListener*, EventListenerData* >::iterator l_d =
2288     _eventListeners.find( listener );
2289   if ( l_d != _eventListeners.end() && l_d->first )
2290   {
2291     if ( l_d->second && l_d->second->IsDeletable() )
2292     {
2293       delete l_d->second;
2294     }
2295     l_d->first->myBusySM.erase( this );
2296     if ( l_d->first->IsDeletable() )
2297     {
2298       l_d->first->BeforeDelete( this, l_d->second );
2299       delete l_d->first;
2300     }
2301     _eventListeners.erase( l_d );
2302   }
2303 }
2304
2305 //================================================================================
2306 /*!
2307  * \brief Delete event listeners depending on algo of this submesh
2308  */
2309 //================================================================================
2310
2311 void SMESH_subMesh::deleteOwnListeners()
2312 {
2313   list< OwnListenerData >::iterator d;
2314   for ( d = _ownListeners.begin(); d != _ownListeners.end(); ++d )
2315   {
2316     if ( !_father->MeshExists( d->myMeshID ))
2317       continue;
2318     if ( _father->GetId() == d->myMeshID && !_father->GetSubMeshContaining( d->mySubMeshID ))
2319       continue;
2320     d->mySubMesh->DeleteEventListener( d->myListener );
2321   }
2322   _ownListeners.clear();
2323 }
2324
2325 //=======================================================================
2326 //function : loadDependentMeshes
2327 //purpose  : loads dependent meshes on SUBMESH_LOADED event
2328 //=======================================================================
2329
2330 void SMESH_subMesh::loadDependentMeshes()
2331 {
2332   list< OwnListenerData >::iterator d;
2333   for ( d = _ownListeners.begin(); d != _ownListeners.end(); ++d )
2334     if ( _father != d->mySubMesh->_father )
2335       d->mySubMesh->_father->Load();
2336
2337   // map< EventListener*, EventListenerData* >::iterator l_d = _eventListeners.begin();
2338   // for ( ; l_d != _eventListeners.end(); ++l_d )
2339   //   if ( l_d->second )
2340   //   {
2341   //     const list<SMESH_subMesh*>& smList = l_d->second->mySubMeshes;
2342   //     list<SMESH_subMesh*>::const_iterator sm = smList.begin();
2343   //     for ( ; sm != smList.end(); ++sm )
2344   //       if ( _father != (*sm)->_father )
2345   //         (*sm)->_father->Load();
2346   //   }
2347 }
2348
2349 //================================================================================
2350 /*!
2351  * \brief Do something on a certain event
2352  * \param event - algo_event or compute_event itself
2353  * \param eventType - algo_event or compute_event
2354  * \param subMesh - the submesh where the event occures
2355  * \param data - listener data stored in the subMesh
2356  * \param hyp - hypothesis, if eventType is algo_event
2357  *
2358  * The base implementation translates CLEAN event to the subMesh
2359  * stored in listener data. Also it sends SUBMESH_COMPUTED event in case of
2360  * successful COMPUTE event.
2361  */
2362 //================================================================================
2363
2364 void SMESH_subMeshEventListener::ProcessEvent(const int          event,
2365                                               const int          eventType,
2366                                               SMESH_subMesh*     subMesh,
2367                                               EventListenerData* data,
2368                                               const SMESH_Hypothesis*  /*hyp*/)
2369 {
2370   if ( data && !data->mySubMeshes.empty() &&
2371        eventType == SMESH_subMesh::COMPUTE_EVENT)
2372   {
2373     ASSERT( data->mySubMeshes.front() != subMesh );
2374     list<SMESH_subMesh*>::iterator smIt = data->mySubMeshes.begin();
2375     list<SMESH_subMesh*>::iterator smEnd = data->mySubMeshes.end();
2376     switch ( event ) {
2377     case SMESH_subMesh::CLEAN:
2378       for ( ; smIt != smEnd; ++ smIt)
2379         (*smIt)->ComputeStateEngine( event );
2380       break;
2381     case SMESH_subMesh::COMPUTE:
2382     case SMESH_subMesh::COMPUTE_SUBMESH:
2383       if ( subMesh->GetComputeState() == SMESH_subMesh::COMPUTE_OK )
2384         for ( ; smIt != smEnd; ++ smIt)
2385           (*smIt)->ComputeStateEngine( SMESH_subMesh::SUBMESH_COMPUTED );
2386       break;
2387     default:;
2388     }
2389   }
2390 }
2391
2392 namespace {
2393
2394   //================================================================================
2395   /*!
2396    * \brief Iterator over submeshes and optionally prepended or appended one
2397    */
2398   //================================================================================
2399
2400   struct _Iterator : public SMDS_Iterator<SMESH_subMesh*>
2401   {
2402     _Iterator(SMDS_Iterator<SMESH_subMesh*>* subIt,
2403               SMESH_subMesh*                 prepend,
2404               SMESH_subMesh*                 append): myIt(subIt),myAppend(append)
2405     {
2406       myCur = prepend ? prepend : myIt->more() ? myIt->next() : append;
2407       if ( myCur == append ) append = 0;
2408     }
2409     /// Return true if and only if there are other object in this iterator
2410     virtual bool more()
2411     {
2412       return myCur;
2413     }
2414     /// Return the current object and step to the next one
2415     virtual SMESH_subMesh* next()
2416     {
2417       SMESH_subMesh* res = myCur;
2418       if ( myIt->more() ) { myCur = myIt->next(); }
2419       else                { myCur = myAppend; myAppend = 0; }
2420       return res;
2421     }
2422     /// ~
2423     ~_Iterator()
2424     { delete myIt; }
2425     ///
2426     SMESH_subMesh                 *myAppend, *myCur;
2427     SMDS_Iterator<SMESH_subMesh*> *myIt;
2428   };
2429 }
2430
2431 //================================================================================
2432 /*!
2433  * \brief  Return iterator on the submeshes this one depends on
2434   * \param includeSelf - this submesh to be returned also
2435   * \param reverse - if true, complex shape submeshes go first
2436  */
2437 //================================================================================
2438
2439 SMESH_subMeshIteratorPtr SMESH_subMesh::getDependsOnIterator(const bool includeSelf,
2440                                                              const bool reverse) const
2441 {
2442   SMESH_subMesh *me = (SMESH_subMesh*) this;
2443   SMESH_subMesh *prepend=0, *append=0;
2444   if ( includeSelf ) {
2445     if ( reverse ) prepend = me;
2446     else            append = me;
2447   }
2448   typedef map < int, SMESH_subMesh * > TMap;
2449   if ( reverse )
2450   {
2451     return SMESH_subMeshIteratorPtr
2452       ( new _Iterator( new SMDS_mapReverseIterator<TMap>( me->DependsOn() ), prepend, append ));
2453   }
2454   {
2455     return SMESH_subMeshIteratorPtr
2456       ( new _Iterator( new SMDS_mapIterator<TMap>( me->DependsOn() ), prepend, append ));
2457   }
2458 }
2459
2460 //================================================================================
2461 /*!
2462  * \brief  Find common submeshes (based on shared sub-shapes with other
2463   * \param theOther submesh to check
2464   * \param theSetOfCommon set of common submesh
2465  */
2466 //================================================================================
2467
2468 bool SMESH_subMesh::FindIntersection(const SMESH_subMesh* theOther,
2469                                      std::set<const SMESH_subMesh*>& theSetOfCommon ) const
2470 {
2471   int oldNb = theSetOfCommon.size();
2472   // check main submeshes
2473   const map <int, SMESH_subMesh*>::const_iterator otherEnd = theOther->_mapDepend.end();
2474   if ( theOther->_mapDepend.find(this->GetId()) != otherEnd )
2475     theSetOfCommon.insert( this );
2476   if ( _mapDepend.find(theOther->GetId()) != _mapDepend.end() )
2477     theSetOfCommon.insert( theOther );
2478   // check common submeshes
2479   map <int, SMESH_subMesh*>::const_iterator mapIt = _mapDepend.begin();
2480   for( ; mapIt != _mapDepend.end(); mapIt++ )
2481     if ( theOther->_mapDepend.find((*mapIt).first) != otherEnd )
2482       theSetOfCommon.insert( (*mapIt).second );
2483   return oldNb < theSetOfCommon.size();
2484 }