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