src/SMESH/SMESH_Mesh.cxx

   1 //  SMESH SMESH : implementaion of SMESH idl descriptions
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  21 //
  22 //
  23 //
  24 //  File   : SMESH_Mesh.cxx
  25 //  Author : Paul RASCLE, EDF
  26 //  Module : SMESH
  27 //  $Header$
  28
  29 #include "SMESH_Mesh.hxx"
  30 #include "SMESH_subMesh.hxx"
  31 #include "SMESH_Gen.hxx"
  32 #include "SMESH_Hypothesis.hxx"
  33 #include "SMESH_Group.hxx"
  34 #include "SMESH_HypoFilter.hxx"
  35 #include "SMESHDS_Group.hxx"
  36 #include "SMESHDS_Script.hxx"
  37 #include "SMESHDS_GroupOnGeom.hxx"
  38 #include "SMDS_MeshVolume.hxx"
  39
  40 #include "utilities.h"
  41
  42 #include "DriverMED_W_SMESHDS_Mesh.h"
  43 #include "DriverDAT_W_SMDS_Mesh.h"
  44 #include "DriverUNV_W_SMDS_Mesh.h"
  45 #include "DriverSTL_W_SMDS_Mesh.h"
  46
  47 #include "DriverMED_R_SMESHDS_Mesh.h"
  48 #include "DriverUNV_R_SMDS_Mesh.h"
  49 #include "DriverSTL_R_SMDS_Mesh.h"
  50
  51 #include <BRepTools_WireExplorer.hxx>
  52 #include <BRep_Builder.hxx>
  53 #include <gp_Pnt.hxx>
  54
  55 #include <TCollection_AsciiString.hxx>
  56 #include <TopExp.hxx>
  57 #include <TopTools_ListOfShape.hxx>
  58 #include <TopTools_Array1OfShape.hxx>
  59 #include <TopTools_ListIteratorOfListOfShape.hxx>
  60 #include <TopTools_MapOfShape.hxx>
  61
  62 #include <memory>
  63
  64 #include "Utils_ExceptHandlers.hxx"
  65
  66 #ifdef _DEBUG_
  67 static int MYDEBUG = 0;
  68 #else
  69 static int MYDEBUG = 0;
  70 #endif
  71
  72
  73 //=============================================================================
  74 /*!
  75  *
  76  */
  77 //=============================================================================
  78
  79 SMESH_Mesh::SMESH_Mesh(int localId, int studyId, SMESH_Gen * gen, SMESHDS_Document * myDocument)
  80 : _groupId( 0 )
  81 {
  82   INFOS("SMESH_Mesh::SMESH_Mesh(int localId)");
  83         _id = localId;
  84         _studyId = studyId;
  85         _gen = gen;
  86         _myDocument = myDocument;
  87         _idDoc = _myDocument->NewMesh();
  88         _myMeshDS = _myDocument->GetMesh(_idDoc);
  89         _isShapeToMesh = false;
  90 }
  91
  92 //=============================================================================
  93 /*!
  94  *
  95  */
  96 //=============================================================================
  97
  98 SMESH_Mesh::~SMESH_Mesh()
  99 {
 100   INFOS("SMESH_Mesh::~SMESH_Mesh");
 101
 102   // delete groups
 103   map < int, SMESH_Group * >::iterator itg;
 104   for (itg = _mapGroup.begin(); itg != _mapGroup.end(); itg++) {
 105     SMESH_Group *aGroup = (*itg).second;
 106     delete aGroup;
 107   }
 108 }
 109
 110 //=============================================================================
 111 /*!
 112  *
 113  */
 114 //=============================================================================
 115
 116 void SMESH_Mesh::ShapeToMesh(const TopoDS_Shape & aShape)
 117 {
 118   if(MYDEBUG) MESSAGE("SMESH_Mesh::ShapeToMesh");
 119
 120   if ( !_myMeshDS->ShapeToMesh().IsNull() && aShape.IsNull() )
 121   {
 122     // removal of a shape to mesh, delete objects referring to sub-shapes:
 123     // - sub-meshes
 124     map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.begin();
 125     for ( ; i_sm != _mapSubMesh.end(); ++i_sm )
 126       delete i_sm->second;
 127     _mapSubMesh.clear();
 128     //  - groups on geometry
 129     map <int, SMESH_Group *>::iterator i_gr = _mapGroup.begin();
 130     while ( i_gr != _mapGroup.end() ) {
 131       if ( dynamic_cast<SMESHDS_GroupOnGeom*>( i_gr->second->GetGroupDS() )) {
 132         _myMeshDS->RemoveGroup( i_gr->second->GetGroupDS() );
 133         delete i_gr->second;
 134         _mapGroup.erase( i_gr++ );
 135       }
 136       else
 137         i_gr++;
 138     }
 139     _mapPropagationChains.Clear();
 140   }
 141   else
 142   {
 143     if (_isShapeToMesh)
 144       throw SALOME_Exception(LOCALIZED ("a shape to mesh has already been defined"));
 145   }
 146   _isShapeToMesh = true;
 147   _myMeshDS->ShapeToMesh(aShape);
 148
 149   // fill _mapAncestors
 150   _mapAncestors.Clear();
 151   int desType, ancType;
 152   for ( desType = TopAbs_EDGE; desType > TopAbs_COMPOUND; desType-- )
 153     for ( ancType = desType - 1; ancType >= TopAbs_COMPOUND; ancType-- )
 154       TopExp::MapShapesAndAncestors ( aShape,
 155                                      (TopAbs_ShapeEnum) desType,
 156                                      (TopAbs_ShapeEnum) ancType,
 157                                      _mapAncestors );
 158
 159   // NRI : 24/02/03
 160   //EAP: 1/9/04 TopExp::MapShapes(aShape, _subShapes); USE the same map of _myMeshDS
 161 }
 162
 163 //=======================================================================
 164 //function : UNVToMesh
 165 //purpose  :
 166 //=======================================================================
 167
 168 int SMESH_Mesh::UNVToMesh(const char* theFileName)
 169 {
 170   if(MYDEBUG) MESSAGE("UNVToMesh - theFileName = "<<theFileName);
 171   if(_isShapeToMesh)
 172     throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
 173   _isShapeToMesh = true;
 174   DriverUNV_R_SMDS_Mesh myReader;
 175   myReader.SetMesh(_myMeshDS);
 176   myReader.SetFile(theFileName);
 177   myReader.SetMeshId(-1);
 178   myReader.Perform();
 179   if(MYDEBUG){
 180     MESSAGE("MEDToMesh - _myMeshDS->NbNodes() = "<<_myMeshDS->NbNodes());
 181     MESSAGE("MEDToMesh - _myMeshDS->NbEdges() = "<<_myMeshDS->NbEdges());
 182     MESSAGE("MEDToMesh - _myMeshDS->NbFaces() = "<<_myMeshDS->NbFaces());
 183     MESSAGE("MEDToMesh - _myMeshDS->NbVolumes() = "<<_myMeshDS->NbVolumes());
 184   }
 185   return 1;
 186 }
 187
 188 //=======================================================================
 189 //function : MEDToMesh
 190 //purpose  :
 191 //=======================================================================
 192
 193 int SMESH_Mesh::MEDToMesh(const char* theFileName, const char* theMeshName)
 194 {
 195   if(MYDEBUG) MESSAGE("MEDToMesh - theFileName = "<<theFileName<<", mesh name = "<<theMeshName);
 196   if(_isShapeToMesh)
 197     throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
 198   _isShapeToMesh = true;
 199   DriverMED_R_SMESHDS_Mesh myReader;
 200   myReader.SetMesh(_myMeshDS);
 201   myReader.SetMeshId(-1);
 202   myReader.SetFile(theFileName);
 203   myReader.SetMeshName(theMeshName);
 204   Driver_Mesh::Status status = myReader.Perform();
 205   if(MYDEBUG){
 206     MESSAGE("MEDToMesh - _myMeshDS->NbNodes() = "<<_myMeshDS->NbNodes());
 207     MESSAGE("MEDToMesh - _myMeshDS->NbEdges() = "<<_myMeshDS->NbEdges());
 208     MESSAGE("MEDToMesh - _myMeshDS->NbFaces() = "<<_myMeshDS->NbFaces());
 209     MESSAGE("MEDToMesh - _myMeshDS->NbVolumes() = "<<_myMeshDS->NbVolumes());
 210   }
 211
 212   // Reading groups (sub-meshes are out of scope of MED import functionality)
 213   list<string> aGroupNames = myReader.GetGroupNames();
 214   if(MYDEBUG) MESSAGE("MEDToMesh - Nb groups = "<<aGroupNames.size());
 215   int anId;
 216   for ( list<string>::iterator it = aGroupNames.begin(); it != aGroupNames.end(); it++ ) {
 217     SMESH_Group* aGroup = AddGroup( SMDSAbs_All, it->c_str(), anId );
 218     if ( aGroup ) {
 219       if(MYDEBUG) MESSAGE("MEDToMesh - group added: "<<it->c_str());
 220       SMESHDS_Group* aGroupDS = dynamic_cast<SMESHDS_Group*>( aGroup->GetGroupDS() );
 221       if ( aGroupDS ) {
 222         aGroupDS->SetStoreName( it->c_str() );
 223         myReader.GetGroup( aGroupDS );
 224       }
 225     }
 226   }
 227   return (int) status;
 228 }
 229
 230 //=======================================================================
 231 //function : STLToMesh
 232 //purpose  :
 233 //=======================================================================
 234
 235 int SMESH_Mesh::STLToMesh(const char* theFileName)
 236 {
 237   if(MYDEBUG) MESSAGE("UNVToMesh - theFileName = "<<theFileName);
 238   if(_isShapeToMesh)
 239     throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
 240   _isShapeToMesh = true;
 241   DriverSTL_R_SMDS_Mesh myReader;
 242   myReader.SetMesh(_myMeshDS);
 243   myReader.SetFile(theFileName);
 244   myReader.SetMeshId(-1);
 245   myReader.Perform();
 246   if(MYDEBUG){
 247     MESSAGE("MEDToMesh - _myMeshDS->NbNodes() = "<<_myMeshDS->NbNodes());
 248     MESSAGE("MEDToMesh - _myMeshDS->NbEdges() = "<<_myMeshDS->NbEdges());
 249     MESSAGE("MEDToMesh - _myMeshDS->NbFaces() = "<<_myMeshDS->NbFaces());
 250     MESSAGE("MEDToMesh - _myMeshDS->NbVolumes() = "<<_myMeshDS->NbVolumes());
 251   }
 252   return 1;
 253 }
 254
 255 //=============================================================================
 256 /*!
 257  *
 258  */
 259 //=============================================================================
 260
 261 SMESH_Hypothesis::Hypothesis_Status
 262   SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
 263                             int                  anHypId  ) throw(SALOME_Exception)
 264 {
 265   Unexpect aCatch(SalomeException);
 266   if(MYDEBUG) MESSAGE("SMESH_Mesh::AddHypothesis");
 267
 268   SMESH_subMesh *subMesh = GetSubMesh(aSubShape);
 269   SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS();
 270   if ( subMeshDS && subMeshDS->IsComplexSubmesh() )
 271   {
 272     // return the worst but not fatal state of all group memebers
 273     SMESH_Hypothesis::Hypothesis_Status aBestRet, aWorstNotFatal, ret;
 274     aBestRet = SMESH_Hypothesis::HYP_BAD_DIM;
 275     aWorstNotFatal = SMESH_Hypothesis::HYP_OK;
 276     for ( TopoDS_Iterator itS ( aSubShape ); itS.More(); itS.Next())
 277     {
 278       ret = AddHypothesis( itS.Value(), anHypId );
 279       if ( !SMESH_Hypothesis::IsStatusFatal( ret ) && ret > aWorstNotFatal )
 280         aWorstNotFatal = ret;
 281       if ( ret < aBestRet )
 282         aBestRet = ret;
 283     }
 284     if ( SMESH_Hypothesis::IsStatusFatal( aBestRet ))
 285       return aBestRet;
 286     return aWorstNotFatal;
 287   }
 288
 289   StudyContextStruct *sc = _gen->GetStudyContext(_studyId);
 290   if (sc->mapHypothesis.find(anHypId) == sc->mapHypothesis.end())
 291   {
 292     if(MYDEBUG) MESSAGE("Hypothesis ID does not give an hypothesis");
 293     if(MYDEBUG) {
 294       SCRUTE(_studyId);
 295       SCRUTE(anHypId);
 296     }
 297     throw SALOME_Exception(LOCALIZED("hypothesis does not exist"));
 298   }
 299
 300   SMESH_Hypothesis *anHyp = sc->mapHypothesis[anHypId];
 301   MESSAGE( "SMESH_Mesh::AddHypothesis " << anHyp->GetName() );
 302
 303   bool isGlobalHyp = IsMainShape( aSubShape );
 304
 305   // NotConformAllowed can be only global
 306   if ( !isGlobalHyp )
 307   {
 308     string hypName = anHyp->GetName();
 309     if ( hypName == "NotConformAllowed" )
 310     {
 311       if(MYDEBUG) MESSAGE( "Hypotesis <NotConformAllowed> can be only global" );
 312       return SMESH_Hypothesis::HYP_INCOMPATIBLE;
 313     }
 314   }
 315
 316   // shape
 317
 318   int event;
 319   if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
 320     event = SMESH_subMesh::ADD_HYP;
 321   else
 322     event = SMESH_subMesh::ADD_ALGO;
 323   SMESH_Hypothesis::Hypothesis_Status ret = subMesh->AlgoStateEngine(event, anHyp);
 324
 325   // subShapes
 326   if (!SMESH_Hypothesis::IsStatusFatal(ret) &&
 327       !subMesh->IsApplicableHypotesis( anHyp )) // is added on father
 328   {
 329     if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
 330       event = SMESH_subMesh::ADD_FATHER_HYP;
 331     else
 332       event = SMESH_subMesh::ADD_FATHER_ALGO;
 333     SMESH_Hypothesis::Hypothesis_Status ret2 =
 334       subMesh->SubMeshesAlgoStateEngine(event, anHyp);
 335     if (ret2 > ret)
 336       ret = ret2;
 337
 338     // check concurent hypotheses on ansestors
 339     if (ret < SMESH_Hypothesis::HYP_CONCURENT && !isGlobalHyp )
 340     {
 341       const map < int, SMESH_subMesh * >& smMap = subMesh->DependsOn();
 342       map < int, SMESH_subMesh * >::const_iterator smIt = smMap.begin();
 343       for ( ; smIt != smMap.end(); smIt++ ) {
 344         if ( smIt->second->IsApplicableHypotesis( anHyp )) {
 345           ret2 = smIt->second->CheckConcurentHypothesis( anHyp->GetType() );
 346           if (ret2 > ret) {
 347             ret = ret2;
 348             break;
 349           }
 350         }
 351       }
 352     }
 353   }
 354
 355   if(MYDEBUG) subMesh->DumpAlgoState(true);
 356   SCRUTE(ret);
 357   return ret;
 358 }
 359
 360 //=============================================================================
 361 /*!
 362  *
 363  */
 364 //=============================================================================
 365
 366 SMESH_Hypothesis::Hypothesis_Status
 367   SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
 368                                int anHypId)throw(SALOME_Exception)
 369 {
 370   Unexpect aCatch(SalomeException);
 371   if(MYDEBUG) MESSAGE("SMESH_Mesh::RemoveHypothesis");
 372
 373   SMESH_subMesh *subMesh = GetSubMesh(aSubShape);
 374   SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS();
 375   if ( subMeshDS && subMeshDS->IsComplexSubmesh() )
 376   {
 377     // return the worst but not fatal state of all group memebers
 378     SMESH_Hypothesis::Hypothesis_Status aBestRet, aWorstNotFatal, ret;
 379     aBestRet = SMESH_Hypothesis::HYP_BAD_DIM;
 380     aWorstNotFatal = SMESH_Hypothesis::HYP_OK;
 381     for ( TopoDS_Iterator itS ( aSubShape ); itS.More(); itS.Next())
 382     {
 383       ret = RemoveHypothesis( itS.Value(), anHypId );
 384       if ( !SMESH_Hypothesis::IsStatusFatal( ret ) && ret > aWorstNotFatal )
 385         aWorstNotFatal = ret;
 386       if ( ret < aBestRet )
 387         aBestRet = ret;
 388     }
 389     if ( SMESH_Hypothesis::IsStatusFatal( aBestRet ))
 390       return aBestRet;
 391     return aWorstNotFatal;
 392   }
 393
 394   StudyContextStruct *sc = _gen->GetStudyContext(_studyId);
 395   if (sc->mapHypothesis.find(anHypId) == sc->mapHypothesis.end())
 396     throw SALOME_Exception(LOCALIZED("hypothesis does not exist"));
 397
 398   SMESH_Hypothesis *anHyp = sc->mapHypothesis[anHypId];
 399   int hypType = anHyp->GetType();
 400   if(MYDEBUG) SCRUTE(hypType);
 401   int event;
 402
 403   // shape
 404
 405   if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
 406     event = SMESH_subMesh::REMOVE_HYP;
 407   else
 408     event = SMESH_subMesh::REMOVE_ALGO;
 409   SMESH_Hypothesis::Hypothesis_Status ret = subMesh->AlgoStateEngine(event, anHyp);
 410
 411   // there may appear concurrent hyps that were covered by the removed hyp
 412   if (ret < SMESH_Hypothesis::HYP_CONCURENT &&
 413       subMesh->IsApplicableHypotesis( anHyp ) &&
 414       subMesh->CheckConcurentHypothesis( anHyp->GetType() ) != SMESH_Hypothesis::HYP_OK)
 415     ret = SMESH_Hypothesis::HYP_CONCURENT;
 416
 417   // subShapes
 418   if (!SMESH_Hypothesis::IsStatusFatal(ret) &&
 419       !subMesh->IsApplicableHypotesis( anHyp )) // is removed from father
 420   {
 421     if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
 422       event = SMESH_subMesh::REMOVE_FATHER_HYP;
 423     else
 424       event = SMESH_subMesh::REMOVE_FATHER_ALGO;
 425     SMESH_Hypothesis::Hypothesis_Status ret2 =
 426       subMesh->SubMeshesAlgoStateEngine(event, anHyp);
 427     if (ret2 > ret) // more severe
 428       ret = ret2;
 429
 430     // check concurent hypotheses on ansestors
 431     if (ret < SMESH_Hypothesis::HYP_CONCURENT && !IsMainShape( aSubShape ) )
 432     {
 433       const map < int, SMESH_subMesh * >& smMap = subMesh->DependsOn();
 434       map < int, SMESH_subMesh * >::const_iterator smIt = smMap.begin();
 435       for ( ; smIt != smMap.end(); smIt++ ) {
 436         if ( smIt->second->IsApplicableHypotesis( anHyp )) {
 437           ret2 = smIt->second->CheckConcurentHypothesis( anHyp->GetType() );
 438           if (ret2 > ret) {
 439             ret = ret2;
 440             break;
 441           }
 442         }
 443       }
 444     }
 445   }
 446
 447   if(MYDEBUG) subMesh->DumpAlgoState(true);
 448   if(MYDEBUG) SCRUTE(ret);
 449   return ret;
 450 }
 451
 452 //=============================================================================
 453 /*!
 454  *
 455  */
 456 //=============================================================================
 457
 458 SMESHDS_Mesh * SMESH_Mesh::GetMeshDS()
 459 {
 460   return _myMeshDS;
 461 }
 462
 463 //=============================================================================
 464 /*!
 465  *
 466  */
 467 //=============================================================================
 468
 469 const list<const SMESHDS_Hypothesis*>&
 470 SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const
 471   throw(SALOME_Exception)
 472 {
 473   Unexpect aCatch(SalomeException);
 474   return _myMeshDS->GetHypothesis(aSubShape);
 475 }
 476
 477 //=======================================================================
 478 //function : GetHypothesis
 479 //purpose  :
 480 //=======================================================================
 481
 482 const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const TopoDS_Shape &    aSubShape,
 483                                                    const SMESH_HypoFilter& aFilter,
 484                                                    const bool              andAncestors) const
 485 {
 486   {
 487     const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
 488     list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
 489     for ( ; hyp != hypList.end(); hyp++ ) {
 490       const SMESH_Hypothesis * h = static_cast<const SMESH_Hypothesis*>( *hyp );
 491       if ( aFilter.IsOk( h, aSubShape))
 492         return h;
 493     }
 494   }
 495   if ( andAncestors )
 496   {
 497     TopTools_ListIteratorOfListOfShape it( GetAncestors( aSubShape ));
 498     for (; it.More(); it.Next() )
 499     {
 500       const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(it.Value());
 501       list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
 502       for ( ; hyp != hypList.end(); hyp++ ) {
 503         const SMESH_Hypothesis * h = static_cast<const SMESH_Hypothesis*>( *hyp );
 504         if (aFilter.IsOk( h, it.Value() ))
 505           return h;
 506       }
 507     }
 508   }
 509   return 0;
 510 }
 511
 512 //=======================================================================
 513 //function : GetHypotheses
 514 //purpose  :
 515 //=======================================================================
 516
 517 bool SMESH_Mesh::GetHypotheses(const TopoDS_Shape &                aSubShape,
 518                                const SMESH_HypoFilter&             aFilter,
 519                                list <const SMESHDS_Hypothesis * >& aHypList,
 520                                const bool                          andAncestors) const
 521 {
 522   int nbHyp = 0;
 523   {
 524     const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
 525     list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
 526     for ( ; hyp != hypList.end(); hyp++ )
 527       if ( aFilter.IsOk (static_cast<const SMESH_Hypothesis*>( *hyp ), aSubShape)) {
 528         aHypList.push_back( *hyp );
 529         nbHyp++;
 530       }
 531   }
 532   // get hypos from shape of one type only: if any hypo is found on edge, do
 533   // not look up on faces
 534   if ( !nbHyp && andAncestors )
 535   {
 536     TopTools_MapOfShape map;
 537     TopTools_ListIteratorOfListOfShape it( GetAncestors( aSubShape ));
 538     int shapeType = it.More() ? it.Value().ShapeType() : TopAbs_SHAPE;
 539     for (; it.More(); it.Next() )
 540     {
 541       if ( nbHyp && shapeType != it.Value().ShapeType() )
 542         break;
 543       shapeType = it.Value().ShapeType();
 544       if ( !map.Add( it.Value() ))
 545         continue;
 546       const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(it.Value());
 547       list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
 548       for ( ; hyp != hypList.end(); hyp++ )
 549         if (aFilter.IsOk( static_cast<const SMESH_Hypothesis*>( *hyp ), it.Value() )) {
 550         aHypList.push_back( *hyp );
 551         nbHyp++;
 552       }
 553     }
 554   }
 555   return nbHyp;
 556 }
 557
 558 //=============================================================================
 559 /*!
 560  *
 561  */
 562 //=============================================================================
 563
 564 const list<SMESHDS_Command*> & SMESH_Mesh::GetLog() throw(SALOME_Exception)
 565 {
 566   Unexpect aCatch(SalomeException);
 567   if(MYDEBUG) MESSAGE("SMESH_Mesh::GetLog");
 568   return _myMeshDS->GetScript()->GetCommands();
 569 }
 570
 571 //=============================================================================
 572 /*!
 573  *
 574  */
 575 //=============================================================================
 576 void SMESH_Mesh::ClearLog() throw(SALOME_Exception)
 577 {
 578   Unexpect aCatch(SalomeException);
 579   if(MYDEBUG) MESSAGE("SMESH_Mesh::ClearLog");
 580   _myMeshDS->GetScript()->Clear();
 581 }
 582
 583 //=============================================================================
 584 /*!
 585  *
 586  */
 587 //=============================================================================
 588
 589 int SMESH_Mesh::GetId()
 590 {
 591   if(MYDEBUG) MESSAGE("SMESH_Mesh::GetId");
 592   return _id;
 593 }
 594
 595 //=============================================================================
 596 /*!
 597  *
 598  */
 599 //=============================================================================
 600
 601 SMESH_Gen *SMESH_Mesh::GetGen()
 602 {
 603   return _gen;
 604 }
 605
 606 //=============================================================================
 607 /*!
 608  * Get or Create the SMESH_subMesh object implementation
 609  */
 610 //=============================================================================
 611
 612 SMESH_subMesh *SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
 613 throw(SALOME_Exception)
 614 {
 615   Unexpect aCatch(SalomeException);
 616   SMESH_subMesh *aSubMesh;
 617   int index = _myMeshDS->ShapeToIndex(aSubShape);
 618
 619   // for submeshes on GEOM Group
 620   if ( !index && aSubShape.ShapeType() == TopAbs_COMPOUND ) {
 621     TopoDS_Iterator it( aSubShape );
 622     if ( it.More() )
 623       index = _myMeshDS->AddCompoundSubmesh( aSubShape, it.Value().ShapeType() );
 624   }
 625
 626   if (_mapSubMesh.find(index) != _mapSubMesh.end())
 627     {
 628       aSubMesh = _mapSubMesh[index];
 629     }
 630   else
 631     {
 632       aSubMesh = new SMESH_subMesh(index, this, _myMeshDS, aSubShape);
 633       _mapSubMesh[index] = aSubMesh;
 634     }
 635   return aSubMesh;
 636 }
 637
 638 //=============================================================================
 639 /*!
 640  * Get the SMESH_subMesh object implementation. Dont create it, return null
 641  * if it does not exist.
 642  */
 643 //=============================================================================
 644
 645 SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape)
 646 throw(SALOME_Exception)
 647 {
 648   Unexpect aCatch(SalomeException);
 649   bool isFound = false;
 650   SMESH_subMesh *aSubMesh = NULL;
 651
 652   int index = _myMeshDS->ShapeToIndex(aSubShape);
 653   if (_mapSubMesh.find(index) != _mapSubMesh.end())
 654     {
 655       aSubMesh = _mapSubMesh[index];
 656       isFound = true;
 657     }
 658   if (!isFound)
 659     aSubMesh = NULL;
 660   return aSubMesh;
 661 }
 662
 663 //=======================================================================
 664 //function : IsUsedHypothesis
 665 //purpose  : Return True if anHyp is used to mesh aSubShape
 666 //=======================================================================
 667
 668 bool SMESH_Mesh::IsUsedHypothesis(SMESHDS_Hypothesis * anHyp,
 669                                   const TopoDS_Shape & aSubShape)
 670 {
 671   SMESH_Hypothesis* hyp = static_cast<SMESH_Hypothesis*>(anHyp);
 672   // check if anHyp is applicable to aSubShape
 673   SMESH_subMesh * subMesh = GetSubMeshContaining( aSubShape );
 674   if ( !subMesh || !subMesh->IsApplicableHypotesis( hyp ))
 675     return false;
 676
 677   SMESH_Algo *algo = _gen->GetAlgo(*this, aSubShape);
 678
 679   // algorithm
 680   if (anHyp->GetType() > SMESHDS_Hypothesis::PARAM_ALGO)
 681     return ( anHyp == algo );
 682
 683   // algorithm parameter
 684   if (algo)
 685   {
 686     // look trough hypotheses used by algo
 687     const list <const SMESHDS_Hypothesis * >&usedHyps =
 688       algo->GetUsedHypothesis(*this, aSubShape);
 689     return ( find( usedHyps.begin(), usedHyps.end(), anHyp ) != usedHyps.end() );
 690   }
 691
 692   // look through all assigned hypotheses
 693   SMESH_HypoFilter filter( SMESH_HypoFilter::Is( hyp ));
 694   return GetHypothesis( aSubShape, filter, true );
 695 }
 696
 697
 698 //=============================================================================
 699 /*!
 700  *
 701  */
 702 //=============================================================================
 703
 704 const list < SMESH_subMesh * >&
 705         SMESH_Mesh::GetSubMeshUsingHypothesis(SMESHDS_Hypothesis * anHyp)
 706 throw(SALOME_Exception)
 707 {
 708   Unexpect aCatch(SalomeException);
 709         if(MYDEBUG) MESSAGE("SMESH_Mesh::GetSubMeshUsingHypothesis");
 710         map < int, SMESH_subMesh * >::iterator itsm;
 711         _subMeshesUsingHypothesisList.clear();
 712         for (itsm = _mapSubMesh.begin(); itsm != _mapSubMesh.end(); itsm++)
 713         {
 714                 SMESH_subMesh *aSubMesh = (*itsm).second;
 715                 if ( IsUsedHypothesis ( anHyp, aSubMesh->GetSubShape() ))
 716                         _subMeshesUsingHypothesisList.push_back(aSubMesh);
 717         }
 718         return _subMeshesUsingHypothesisList;
 719 }
 720
 721 //=============================================================================
 722 /*!
 723  *
 724  */
 725 //=============================================================================
 726
 727 void SMESH_Mesh::ExportMED(const char *file,
 728                            const char* theMeshName,
 729                            bool theAutoGroups,
 730                            int theVersion)
 731   throw(SALOME_Exception)
 732 {
 733   Unexpect aCatch(SalomeException);
 734   DriverMED_W_SMESHDS_Mesh myWriter;
 735   myWriter.SetFile    ( file, MED::EVersion(theVersion) );
 736   myWriter.SetMesh    ( _myMeshDS   );
 737   if ( !theMeshName )
 738     myWriter.SetMeshId  ( _idDoc      );
 739   else {
 740     myWriter.SetMeshId  ( -1          );
 741     myWriter.SetMeshName( theMeshName );
 742   }
 743
 744   if ( theAutoGroups ) {
 745     myWriter.AddGroupOfNodes();
 746     myWriter.AddGroupOfEdges();
 747     myWriter.AddGroupOfFaces();
 748     myWriter.AddGroupOfVolumes();
 749   }
 750
 751   for ( map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
 752     SMESH_Group*       aGroup   = it->second;
 753     SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS();
 754     if ( aGroupDS ) {
 755       aGroupDS->SetStoreName( aGroup->GetName() );
 756       myWriter.AddGroup( aGroupDS );
 757     }
 758   }
 759
 760   myWriter.Perform();
 761 }
 762
 763 void SMESH_Mesh::ExportDAT(const char *file) throw(SALOME_Exception)
 764 {
 765   Unexpect aCatch(SalomeException);
 766   DriverDAT_W_SMDS_Mesh myWriter;
 767   myWriter.SetFile(string(file));
 768   myWriter.SetMesh(_myMeshDS);
 769   myWriter.SetMeshId(_idDoc);
 770   myWriter.Perform();
 771 }
 772
 773 void SMESH_Mesh::ExportUNV(const char *file) throw(SALOME_Exception)
 774 {
 775   Unexpect aCatch(SalomeException);
 776   DriverUNV_W_SMDS_Mesh myWriter;
 777   myWriter.SetFile(string(file));
 778   myWriter.SetMesh(_myMeshDS);
 779   myWriter.SetMeshId(_idDoc);
 780   myWriter.Perform();
 781 }
 782
 783 void SMESH_Mesh::ExportSTL(const char *file, const bool isascii) throw(SALOME_Exception)
 784 {
 785   Unexpect aCatch(SalomeException);
 786   DriverSTL_W_SMDS_Mesh myWriter;
 787   myWriter.SetFile(string(file));
 788   myWriter.SetIsAscii( isascii );
 789   myWriter.SetMesh(_myMeshDS);
 790   myWriter.SetMeshId(_idDoc);
 791   myWriter.Perform();
 792 }
 793
 794 //=============================================================================
 795 /*!
 796  *
 797  */
 798 //=============================================================================
 799 int SMESH_Mesh::NbNodes() throw(SALOME_Exception)
 800 {
 801   Unexpect aCatch(SalomeException);
 802   return _myMeshDS->NbNodes();
 803 }
 804
 805 //=============================================================================
 806 /*!
 807  *
 808  */
 809 //=============================================================================
 810 int SMESH_Mesh::NbEdges() throw(SALOME_Exception)
 811 {
 812   Unexpect aCatch(SalomeException);
 813   return _myMeshDS->NbEdges();
 814 }
 815
 816 //=============================================================================
 817 /*!
 818  *
 819  */
 820 //=============================================================================
 821 int SMESH_Mesh::NbFaces() throw(SALOME_Exception)
 822 {
 823   Unexpect aCatch(SalomeException);
 824   return _myMeshDS->NbFaces();
 825 }
 826
 827 ///////////////////////////////////////////////////////////////////////////////
 828 /// Return the number of 3 nodes faces in the mesh. This method run in O(n)
 829 ///////////////////////////////////////////////////////////////////////////////
 830 int SMESH_Mesh::NbTriangles() throw(SALOME_Exception)
 831 {
 832   Unexpect aCatch(SalomeException);
 833   int Nb = 0;
 834
 835   SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
 836   //while(itFaces->more()) if(itFaces->next()->NbNodes()==3) Nb++;
 837   const SMDS_MeshFace * curFace;
 838   while (itFaces->more()) {
 839     curFace = itFaces->next();
 840     if (!curFace->IsPoly() && curFace->NbNodes() == 3) Nb++;
 841   }
 842   return Nb;
 843 }
 844
 845 ///////////////////////////////////////////////////////////////////////////////
 846 /// Return the number of 4 nodes faces in the mesh. This method run in O(n)
 847 ///////////////////////////////////////////////////////////////////////////////
 848 int SMESH_Mesh::NbQuadrangles() throw(SALOME_Exception)
 849 {
 850   Unexpect aCatch(SalomeException);
 851   int Nb = 0;
 852
 853   SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
 854   //while(itFaces->more()) if(itFaces->next()->NbNodes()==4) Nb++;
 855   const SMDS_MeshFace * curFace;
 856   while (itFaces->more()) {
 857     curFace = itFaces->next();
 858     if (!curFace->IsPoly() && curFace->NbNodes() == 4) Nb++;
 859   }
 860   return Nb;
 861 }
 862
 863 ///////////////////////////////////////////////////////////////////////////////
 864 /// Return the number of polygonal faces in the mesh. This method run in O(n)
 865 ///////////////////////////////////////////////////////////////////////////////
 866 int SMESH_Mesh::NbPolygons() throw(SALOME_Exception)
 867 {
 868   Unexpect aCatch(SalomeException);
 869   int Nb = 0;
 870   SMDS_FaceIteratorPtr itFaces = _myMeshDS->facesIterator();
 871   while (itFaces->more())
 872     if (itFaces->next()->IsPoly()) Nb++;
 873   return Nb;
 874 }
 875
 876 //=============================================================================
 877 /*!
 878  *
 879  */
 880 //=============================================================================
 881 int SMESH_Mesh::NbVolumes() throw(SALOME_Exception)
 882 {
 883   Unexpect aCatch(SalomeException);
 884   return _myMeshDS->NbVolumes();
 885 }
 886
 887 int SMESH_Mesh::NbTetras() throw(SALOME_Exception)
 888 {
 889   Unexpect aCatch(SalomeException);
 890   int Nb = 0;
 891   SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
 892   //while(itVolumes->more()) if(itVolumes->next()->NbNodes()==4) Nb++;
 893   const SMDS_MeshVolume * curVolume;
 894   while (itVolumes->more()) {
 895     curVolume = itVolumes->next();
 896     if (!curVolume->IsPoly() && curVolume->NbNodes() == 4) Nb++;
 897   }
 898   return Nb;
 899 }
 900
 901 int SMESH_Mesh::NbHexas() throw(SALOME_Exception)
 902 {
 903   Unexpect aCatch(SalomeException);
 904   int Nb = 0;
 905   SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
 906   //while(itVolumes->more()) if(itVolumes->next()->NbNodes()==8) Nb++;
 907   const SMDS_MeshVolume * curVolume;
 908   while (itVolumes->more()) {
 909     curVolume = itVolumes->next();
 910     if (!curVolume->IsPoly() && curVolume->NbNodes() == 8) Nb++;
 911   }
 912   return Nb;
 913 }
 914
 915 int SMESH_Mesh::NbPyramids() throw(SALOME_Exception)
 916 {
 917   Unexpect aCatch(SalomeException);
 918   int Nb = 0;
 919   SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
 920   //while(itVolumes->more()) if(itVolumes->next()->NbNodes()==5) Nb++;
 921   const SMDS_MeshVolume * curVolume;
 922   while (itVolumes->more()) {
 923     curVolume = itVolumes->next();
 924     if (!curVolume->IsPoly() && curVolume->NbNodes() == 5) Nb++;
 925   }
 926   return Nb;
 927 }
 928
 929 int SMESH_Mesh::NbPrisms() throw(SALOME_Exception)
 930 {
 931   Unexpect aCatch(SalomeException);
 932   int Nb = 0;
 933   SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
 934   //while(itVolumes->more()) if(itVolumes->next()->NbNodes()==6) Nb++;
 935   const SMDS_MeshVolume * curVolume;
 936   while (itVolumes->more()) {
 937     curVolume = itVolumes->next();
 938     if (!curVolume->IsPoly() && curVolume->NbNodes() == 6) Nb++;
 939   }
 940   return Nb;
 941 }
 942
 943 int SMESH_Mesh::NbPolyhedrons() throw(SALOME_Exception)
 944 {
 945   Unexpect aCatch(SalomeException);
 946   int Nb = 0;
 947   SMDS_VolumeIteratorPtr itVolumes = _myMeshDS->volumesIterator();
 948   while (itVolumes->more())
 949     if (itVolumes->next()->IsPoly()) Nb++;
 950   return Nb;
 951 }
 952
 953 //=============================================================================
 954 /*!
 955  *
 956  */
 957 //=============================================================================
 958 int SMESH_Mesh::NbSubMesh() throw(SALOME_Exception)
 959 {
 960   Unexpect aCatch(SalomeException);
 961   return _myMeshDS->NbSubMesh();
 962 }
 963
 964 //=======================================================================
 965 //function : IsNotConformAllowed
 966 //purpose  : check if a hypothesis alowing notconform mesh is present
 967 //=======================================================================
 968
 969 bool SMESH_Mesh::IsNotConformAllowed() const
 970 {
 971   if(MYDEBUG) MESSAGE("SMESH_Mesh::IsNotConformAllowed");
 972
 973   SMESH_HypoFilter filter( SMESH_HypoFilter::HasName( "NotConformAllowed" ));
 974   return GetHypothesis( _myMeshDS->ShapeToMesh(), filter, false );
 975 }
 976
 977 //=======================================================================
 978 //function : IsMainShape
 979 //purpose  :
 980 //=======================================================================
 981
 982 bool SMESH_Mesh::IsMainShape(const TopoDS_Shape& theShape) const
 983 {
 984   return theShape.IsSame(_myMeshDS->ShapeToMesh() );
 985 }
 986
 987 //=============================================================================
 988 /*!
 989  *
 990  */
 991 //=============================================================================
 992
 993 SMESH_Group* SMESH_Mesh::AddGroup (const SMDSAbs_ElementType theType,
 994                                    const char*               theName,
 995                                    int&                      theId,
 996                                    const TopoDS_Shape&       theShape)
 997 {
 998   if (_mapGroup.find(_groupId) != _mapGroup.end())
 999     return NULL;
1000   theId = _groupId;
1001   SMESH_Group* aGroup = new SMESH_Group (theId, this, theType, theName, theShape);
1002   GetMeshDS()->AddGroup( aGroup->GetGroupDS() );
1003   _mapGroup[_groupId++] = aGroup;
1004   return aGroup;
1005 }
1006
1007 //=============================================================================
1008 /*!
1009  *
1010  */
1011 //=============================================================================
1012
1013 SMESH_Group* SMESH_Mesh::GetGroup (const int theGroupID)
1014 {
1015   if (_mapGroup.find(theGroupID) == _mapGroup.end())
1016     return NULL;
1017   return _mapGroup[theGroupID];
1018 }
1019
1020
1021 //=============================================================================
1022 /*!
1023  *
1024  */
1025 //=============================================================================
1026
1027 list<int> SMESH_Mesh::GetGroupIds()
1028 {
1029   list<int> anIds;
1030   for ( map<int, SMESH_Group*>::const_iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ )
1031     anIds.push_back( it->first );
1032
1033   return anIds;
1034 }
1035
1036
1037 //=============================================================================
1038 /*!
1039  *
1040  */
1041 //=============================================================================
1042
1043 void SMESH_Mesh::RemoveGroup (const int theGroupID)
1044 {
1045   if (_mapGroup.find(theGroupID) == _mapGroup.end())
1046     return;
1047   GetMeshDS()->RemoveGroup( _mapGroup[theGroupID]->GetGroupDS() );
1048   _mapGroup.erase (theGroupID);
1049   delete _mapGroup[theGroupID];
1050 }
1051
1052 //=============================================================================
1053 /*!
1054  *  IsLocal1DHypothesis
1055  *  Returns a local 1D hypothesis used for theEdge
1056  */
1057 //=============================================================================
1058 const SMESH_Hypothesis* SMESH_Mesh::IsLocal1DHypothesis (const TopoDS_Shape& theEdge)
1059 {
1060   SMESH_HypoFilter filter( SMESH_HypoFilter::HasDim( 1 ));
1061   filter.AndNot( SMESH_HypoFilter::IsAlgo() );
1062   filter.AndNot( SMESH_HypoFilter::IsGlobal( GetMeshDS()->ShapeToMesh() ));
1063
1064   return GetHypothesis( theEdge, filter, true );
1065 }
1066
1067 //=============================================================================
1068 /*!
1069  *  IsPropagationHypothesis
1070  */
1071 //=============================================================================
1072 bool SMESH_Mesh::IsPropagationHypothesis (const TopoDS_Shape& theEdge)
1073 {
1074   return _mapPropagationChains.Contains(theEdge);
1075 }
1076
1077 //=============================================================================
1078 /*!
1079  *  IsPropagatedHypothesis
1080  */
1081 //=============================================================================
1082 bool SMESH_Mesh::IsPropagatedHypothesis (const TopoDS_Shape& theEdge,
1083                                          TopoDS_Shape&       theMainEdge)
1084 {
1085   int nbChains = _mapPropagationChains.Extent();
1086   for (int i = 1; i <= nbChains; i++) {
1087     const TopTools_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromIndex(i);
1088     if (aChain.Contains(theEdge)) {
1089       theMainEdge = _mapPropagationChains.FindKey(i);
1090       return true;
1091     }
1092   }
1093
1094   return false;
1095 }
1096 //=============================================================================
1097 /*!
1098  *  IsReversedInChain
1099  */
1100 //=============================================================================
1101
1102 bool SMESH_Mesh::IsReversedInChain (const TopoDS_Shape& theEdge,
1103                                     const TopoDS_Shape& theMainEdge)
1104 {
1105   if ( !theMainEdge.IsNull() && !theEdge.IsNull() &&
1106       _mapPropagationChains.Contains( theMainEdge ))
1107   {
1108     const TopTools_IndexedMapOfShape& aChain =
1109       _mapPropagationChains.FindFromKey( theMainEdge );
1110     int index = aChain.FindIndex( theEdge );
1111     if ( index )
1112       return aChain(index).Orientation() == TopAbs_REVERSED;
1113   }
1114   return false;
1115 }
1116
1117 //=============================================================================
1118 /*!
1119  *  CleanMeshOnPropagationChain
1120  */
1121 //=============================================================================
1122 void SMESH_Mesh::CleanMeshOnPropagationChain (const TopoDS_Shape& theMainEdge)
1123 {
1124   const TopTools_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromKey(theMainEdge);
1125   int i, nbEdges = aChain.Extent();
1126   for (i = 1; i <= nbEdges; i++) {
1127     TopoDS_Shape anEdge = aChain.FindKey(i);
1128     SMESH_subMesh *subMesh = GetSubMesh(anEdge);
1129     SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS();
1130     if (subMeshDS && subMeshDS->NbElements() > 0) {
1131       subMesh->ComputeStateEngine(SMESH_subMesh::CLEANDEP);
1132     }
1133   }
1134 }
1135
1136 //=============================================================================
1137 /*!
1138  *  RebuildPropagationChains
1139  *  Rebuild all existing propagation chains.
1140  *  Have to be used, if 1D hypothesis have been assigned/removed to/from any edge
1141  */
1142 //=============================================================================
1143 bool SMESH_Mesh::RebuildPropagationChains()
1144 {
1145   bool ret = true;
1146
1147   // Clean all chains, because they can be not up-to-date
1148   int i, nbChains = _mapPropagationChains.Extent();
1149   for (i = 1; i <= nbChains; i++) {
1150     TopoDS_Shape aMainEdge = _mapPropagationChains.FindKey(i);
1151     CleanMeshOnPropagationChain(aMainEdge);
1152     _mapPropagationChains.ChangeFromIndex(i).Clear();
1153   }
1154
1155   // Build all chains
1156   for (i = 1; i <= nbChains; i++) {
1157     TopoDS_Shape aMainEdge = _mapPropagationChains.FindKey(i);
1158     if (!BuildPropagationChain(aMainEdge))
1159       ret = false;
1160     CleanMeshOnPropagationChain(aMainEdge);
1161   }
1162
1163   return ret;
1164 }
1165
1166 //=============================================================================
1167 /*!
1168  *  RemovePropagationChain
1169  *  Have to be used, if Propagation hypothesis is removed from <theMainEdge>
1170  */
1171 //=============================================================================
1172 bool SMESH_Mesh::RemovePropagationChain (const TopoDS_Shape& theMainEdge)
1173 {
1174   if (!_mapPropagationChains.Contains(theMainEdge))
1175     return false;
1176
1177   // Clean mesh elements and nodes, built on the chain
1178   CleanMeshOnPropagationChain(theMainEdge);
1179
1180   // Clean the chain
1181   _mapPropagationChains.ChangeFromKey(theMainEdge).Clear();
1182
1183   // Remove the chain from the map
1184   int i = _mapPropagationChains.FindIndex(theMainEdge);
1185   if ( i == _mapPropagationChains.Extent() )
1186     _mapPropagationChains.RemoveLast();
1187   else {
1188     TopoDS_Vertex anEmptyShape;
1189     BRep_Builder BB;
1190     BB.MakeVertex(anEmptyShape, gp_Pnt(0,0,0), 0.1);
1191     TopTools_IndexedMapOfShape anEmptyMap;
1192     _mapPropagationChains.Substitute(i, anEmptyShape, anEmptyMap);
1193   }
1194
1195   return true;
1196 }
1197
1198 //=============================================================================
1199 /*!
1200  *  BuildPropagationChain
1201  */
1202 //=============================================================================
1203 bool SMESH_Mesh::BuildPropagationChain (const TopoDS_Shape& theMainEdge)
1204 {
1205   if (theMainEdge.ShapeType() != TopAbs_EDGE) return true;
1206
1207   // Add new chain, if there is no
1208   if (!_mapPropagationChains.Contains(theMainEdge)) {
1209     TopTools_IndexedMapOfShape aNewChain;
1210     _mapPropagationChains.Add(theMainEdge, aNewChain);
1211   }
1212
1213   // Check presence of 1D hypothesis to be propagated
1214   const SMESH_Hypothesis* aMainHyp = IsLocal1DHypothesis(theMainEdge);
1215   if (!aMainHyp) {
1216     MESSAGE("Warning: There is no 1D hypothesis to propagate. Please, assign.");
1217     return true;
1218   }
1219
1220   // Edges, on which the 1D hypothesis will be propagated from <theMainEdge>
1221   TopTools_IndexedMapOfShape& aChain = _mapPropagationChains.ChangeFromKey(theMainEdge);
1222   if (aChain.Extent() > 0) {
1223     CleanMeshOnPropagationChain(theMainEdge);
1224     aChain.Clear();
1225   }
1226
1227   // At first put <theMainEdge> in the chain
1228   aChain.Add(theMainEdge);
1229
1230   // List of edges, added to chain on the previous cycle pass
1231   TopTools_ListOfShape listPrevEdges;
1232   listPrevEdges.Append(theMainEdge.Oriented( TopAbs_FORWARD ));
1233
1234 //   5____4____3____4____5____6
1235 //   |    |    |    |    |    |
1236 //   |    |    |    |    |    |
1237 //   4____3____2____3____4____5
1238 //   |    |    |    |    |    |      Number in the each knot of
1239 //   |    |    |    |    |    |      grid indicates cycle pass,
1240 //   3____2____1____2____3____4      on which corresponding edge
1241 //   |    |    |    |    |    |      (perpendicular to the plane
1242 //   |    |    |    |    |    |      of view) will be found.
1243 //   2____1____0____1____2____3
1244 //   |    |    |    |    |    |
1245 //   |    |    |    |    |    |
1246 //   3____2____1____2____3____4
1247
1248   // Collect all edges pass by pass
1249   while (listPrevEdges.Extent() > 0) {
1250     // List of edges, added to chain on this cycle pass
1251     TopTools_ListOfShape listCurEdges;
1252
1253     // Find the next portion of edges
1254     TopTools_ListIteratorOfListOfShape itE (listPrevEdges);
1255     for (; itE.More(); itE.Next()) {
1256       TopoDS_Shape anE = itE.Value();
1257
1258       // Iterate on faces, having edge <anE>
1259       TopTools_ListIteratorOfListOfShape itA (GetAncestors(anE));
1260       for (; itA.More(); itA.Next()) {
1261         TopoDS_Shape aW = itA.Value();
1262
1263         // There are objects of different type among the ancestors of edge
1264         if (aW.ShapeType() == TopAbs_WIRE) {
1265           TopoDS_Shape anOppE;
1266
1267           BRepTools_WireExplorer aWE (TopoDS::Wire(aW));
1268           Standard_Integer nb = 1, found = 0;
1269           TopTools_Array1OfShape anEdges (1,4);
1270           for (; aWE.More(); aWE.Next(), nb++) {
1271             if (nb > 4) {
1272               found = 0;
1273               break;
1274             }
1275             anEdges(nb) = aWE.Current();
1276             if (!_mapAncestors.Contains(anEdges(nb))) {
1277               MESSAGE("WIRE EXPLORER HAVE GIVEN AN INVALID EDGE !!!");
1278               break;
1279             }
1280             if (anEdges(nb).IsSame(anE)) found = nb;
1281           }
1282
1283           if (nb == 5 && found > 0) {
1284             // Quadrangle face found, get an opposite edge
1285             Standard_Integer opp = found + 2;
1286             if (opp > 4) opp -= 4;
1287             anOppE = anEdges(opp);
1288
1289             // add anOppE to aChain if ...
1290             if (!aChain.Contains(anOppE)) { // ... anOppE is not in aChain
1291               if (!IsLocal1DHypothesis(anOppE)) { // ... no other 1d hyp on anOppE
1292                 TopoDS_Shape aMainEdgeForOppEdge; // ... no other hyp is propagated to anOppE
1293                 if (!IsPropagatedHypothesis(anOppE, aMainEdgeForOppEdge))
1294                 {
1295                   // Add found edge to the chain oriented so that to
1296                   // have it co-directed with a forward MainEdge
1297                   TopAbs_Orientation ori = anE.Orientation();
1298                   if ( anEdges(opp).Orientation() == anEdges(found).Orientation() )
1299                     ori = TopAbs::Reverse( ori );
1300                   anOppE.Orientation( ori );
1301                   aChain.Add(anOppE);
1302                   listCurEdges.Append(anOppE);
1303                 }
1304                 else {
1305                   // Collision!
1306                   MESSAGE("Error: Collision between propagated hypotheses");
1307                   CleanMeshOnPropagationChain(theMainEdge);
1308                   aChain.Clear();
1309                   return ( aMainHyp == IsLocal1DHypothesis(aMainEdgeForOppEdge) );
1310                 }
1311               }
1312             }
1313           } // if (nb == 5 && found > 0)
1314         } // if (aF.ShapeType() == TopAbs_WIRE)
1315       } // for (; itF.More(); itF.Next())
1316     } // for (; itE.More(); itE.Next())
1317
1318     listPrevEdges = listCurEdges;
1319   } // while (listPrevEdges.Extent() > 0)
1320
1321   CleanMeshOnPropagationChain(theMainEdge);
1322   return true;
1323 }
1324
1325 //=======================================================================
1326 //function : GetAncestors
1327 //purpose  : return list of ancestors of theSubShape in the order
1328 //           that lower dimention shapes come first.
1329 //=======================================================================
1330
1331 const TopTools_ListOfShape& SMESH_Mesh::GetAncestors(const TopoDS_Shape& theS) const
1332 {
1333   if ( _mapAncestors.Contains( theS ) )
1334     return _mapAncestors.FindFromKey( theS );
1335
1336   static TopTools_ListOfShape emptyList;
1337   return emptyList;
1338 }
1339
1340 //=======================================================================
1341 //function : Dump
1342 //purpose  : dumps contents of mesh to stream [ debug purposes ]
1343 //=======================================================================
1344 ostream& SMESH_Mesh::Dump(ostream& save)
1345 {
1346   save << "========================== Dump contents of mesh ==========================" << endl;
1347   save << "1) Total number of nodes:     " << NbNodes() << endl;
1348   save << "2) Total number of edges:     " << NbEdges() << endl;
1349   save << "3) Total number of faces:     " << NbFaces() << endl;
1350   if ( NbFaces() > 0 ) {
1351     int nb3 = NbTriangles();
1352     int nb4 = NbQuadrangles();
1353     save << "3.1.) Number of triangles:    " << nb3 << endl;
1354     save << "3.2.) Number of quadrangles:  " << nb4 << endl;
1355     if ( nb3 + nb4 !=  NbFaces() ) {
1356       map<int,int> myFaceMap;
1357       SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
1358       while( itFaces->more( ) ) {
1359         int nbNodes = itFaces->next()->NbNodes();
1360         if ( myFaceMap.find( nbNodes ) == myFaceMap.end() )
1361           myFaceMap[ nbNodes ] = 0;
1362         myFaceMap[ nbNodes ] = myFaceMap[ nbNodes ] + 1;
1363       }
1364       save << "3.3.) Faces in detail: " << endl;
1365       map <int,int>::iterator itF;
1366       for (itF = myFaceMap.begin(); itF != myFaceMap.end(); itF++)
1367         save << "--> nb nodes: " << itF->first << " - nb elemens: " << itF->second << endl;
1368     }
1369   }
1370   save << "4) Total number of volumes:   " << NbVolumes() << endl;
1371   if ( NbVolumes() > 0 ) {
1372     int nb8 = NbHexas();
1373     int nb4 = NbTetras();
1374     int nb5 = NbPyramids();
1375     int nb6 = NbPrisms();
1376     save << "4.1.) Number of hexahedrons:  " << nb8 << endl;
1377     save << "4.2.) Number of tetrahedrons: " << nb4 << endl;
1378     save << "4.3.) Number of prisms:       " << nb6 << endl;
1379     save << "4.4.) Number of pyramides:    " << nb5 << endl;
1380     if ( nb8 + nb4 + nb5 + nb6 != NbVolumes() ) {
1381       map<int,int> myVolumesMap;
1382       SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
1383       while( itVolumes->more( ) ) {
1384         int nbNodes = itVolumes->next()->NbNodes();
1385         if ( myVolumesMap.find( nbNodes ) == myVolumesMap.end() )
1386           myVolumesMap[ nbNodes ] = 0;
1387         myVolumesMap[ nbNodes ] = myVolumesMap[ nbNodes ] + 1;
1388       }
1389       save << "4.5.) Volumes in detail: " << endl;
1390       map <int,int>::iterator itV;
1391       for (itV = myVolumesMap.begin(); itV != myVolumesMap.end(); itV++)
1392         save << "--> nb nodes: " << itV->first << " - nb elemens: " << itV->second << endl;
1393     }
1394   }
1395   save << "===========================================================================" << endl;
1396   return save;
1397 }