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.Perform();
 952 }
 953
 954 void SMESH_Mesh::ExportSTL(const char *file, const bool isascii) throw(SALOME_Exception)
 955 {
 956   Unexpect aCatch(SalomeException);
 957   DriverSTL_W_SMDS_Mesh myWriter;
 958   myWriter.SetFile(string(file));
 959   myWriter.SetIsAscii( isascii );
 960   myWriter.SetMesh(_myMeshDS);
 961   myWriter.SetMeshId(_idDoc);
 962   myWriter.Perform();
 963 }
 964
 965 //=============================================================================
 966 /*!
 967  *
 968  */
 969 //=============================================================================
 970 int SMESH_Mesh::NbNodes() throw(SALOME_Exception)
 971 {
 972   Unexpect aCatch(SalomeException);
 973   return _myMeshDS->NbNodes();
 974 }
 975
 976 //=============================================================================
 977 /*!
 978  *
 979  */
 980 //=============================================================================
 981 int SMESH_Mesh::NbEdges() throw(SALOME_Exception)
 982 {
 983   Unexpect aCatch(SalomeException);
 984   return _myMeshDS->NbEdges();
 985 }
 986
 987 //=============================================================================
 988 /*!
 989  *
 990  */
 991 //=============================================================================
 992 int SMESH_Mesh::NbFaces() throw(SALOME_Exception)
 993 {
 994   Unexpect aCatch(SalomeException);
 995   return _myMeshDS->NbFaces();
 996 }
 997
 998 ///////////////////////////////////////////////////////////////////////////////
 999 /// Return the number of 3 nodes faces in the mesh. This method run in O(n)
1000 ///////////////////////////////////////////////////////////////////////////////
1001 int SMESH_Mesh::NbTriangles() throw(SALOME_Exception)
1002 {
1003   Unexpect aCatch(SalomeException);
1004   int Nb = 0;
1005
1006   SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
1007   //while(itFaces->more()) if(itFaces->next()->NbNodes()==3) Nb++;
1008   const SMDS_MeshFace * curFace;
1009   while (itFaces->more()) {
1010     curFace = itFaces->next();
1011     if ( !curFace->IsPoly() &&
1012          ( curFace->NbNodes()==3 || curFace->NbNodes()==6 ) ) Nb++;
1013   }
1014   return Nb;
1015 }
1016
1017 ///////////////////////////////////////////////////////////////////////////////
1018 /// Return the number of 4 nodes faces in the mesh. This method run in O(n)
1019 ///////////////////////////////////////////////////////////////////////////////
1020 int SMESH_Mesh::NbQuadrangles() throw(SALOME_Exception)
1021 {
1022   Unexpect aCatch(SalomeException);
1023   int Nb = 0;
1024
1025   SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
1026   //while(itFaces->more()) if(itFaces->next()->NbNodes()==4) Nb++;
1027   const SMDS_MeshFace * curFace;
1028   while (itFaces->more()) {
1029     curFace = itFaces->next();
1030     if ( !curFace->IsPoly() &&
1031          ( curFace->NbNodes() == 4 || curFace->NbNodes()==8 ) ) Nb++;
1032   }
1033   return Nb;
1034 }
1035
1036 ///////////////////////////////////////////////////////////////////////////////
1037 /// Return the number of polygonal faces in the mesh. This method run in O(n)
1038 ///////////////////////////////////////////////////////////////////////////////
1039 int SMESH_Mesh::NbPolygons() throw(SALOME_Exception)
1040 {
1041   Unexpect aCatch(SalomeException);
1042   int Nb = 0;
1043   SMDS_FaceIteratorPtr itFaces = _myMeshDS->facesIterator();
1044   while (itFaces->more())
1045     if (itFaces->next()->IsPoly()) Nb++;
1046   return Nb;
1047 }
1048
1049 //=============================================================================
1050 /*!
1051  *
1052  */
1053 //=============================================================================
1054 int SMESH_Mesh::NbVolumes() throw(SALOME_Exception)
1055 {
1056   Unexpect aCatch(SalomeException);
1057   return _myMeshDS->NbVolumes();
1058 }
1059
1060 int SMESH_Mesh::NbTetras() throw(SALOME_Exception)
1061 {
1062   Unexpect aCatch(SalomeException);
1063   int Nb = 0;
1064   SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
1065   //while(itVolumes->more()) if(itVolumes->next()->NbNodes()==4) Nb++;
1066   const SMDS_MeshVolume * curVolume;
1067   while (itVolumes->more()) {
1068     curVolume = itVolumes->next();
1069     if ( !curVolume->IsPoly() &&
1070          ( curVolume->NbNodes() == 4 || curVolume->NbNodes()==10 ) ) Nb++;
1071   }
1072   return Nb;
1073 }
1074
1075 int SMESH_Mesh::NbHexas() throw(SALOME_Exception)
1076 {
1077   Unexpect aCatch(SalomeException);
1078   int Nb = 0;
1079   SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
1080   //while(itVolumes->more()) if(itVolumes->next()->NbNodes()==8) Nb++;
1081   const SMDS_MeshVolume * curVolume;
1082   while (itVolumes->more()) {
1083     curVolume = itVolumes->next();
1084     if ( !curVolume->IsPoly() &&
1085          ( curVolume->NbNodes() == 8 || curVolume->NbNodes()==20 ) ) Nb++;
1086   }
1087   return Nb;
1088 }
1089
1090 int SMESH_Mesh::NbPyramids() throw(SALOME_Exception)
1091 {
1092   Unexpect aCatch(SalomeException);
1093   int Nb = 0;
1094   SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
1095   //while(itVolumes->more()) if(itVolumes->next()->NbNodes()==5) Nb++;
1096   const SMDS_MeshVolume * curVolume;
1097   while (itVolumes->more()) {
1098     curVolume = itVolumes->next();
1099     if ( !curVolume->IsPoly() &&
1100          ( curVolume->NbNodes() == 5 || curVolume->NbNodes()==13 ) ) Nb++;
1101   }
1102   return Nb;
1103 }
1104
1105 int SMESH_Mesh::NbPrisms() throw(SALOME_Exception)
1106 {
1107   Unexpect aCatch(SalomeException);
1108   int Nb = 0;
1109   SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
1110   //while(itVolumes->more()) if(itVolumes->next()->NbNodes()==6) Nb++;
1111   const SMDS_MeshVolume * curVolume;
1112   while (itVolumes->more()) {
1113     curVolume = itVolumes->next();
1114     if ( !curVolume->IsPoly() &&
1115          ( curVolume->NbNodes() == 6 || curVolume->NbNodes()==15 ) ) Nb++;
1116   }
1117   return Nb;
1118 }
1119
1120 int SMESH_Mesh::NbPolyhedrons() throw(SALOME_Exception)
1121 {
1122   Unexpect aCatch(SalomeException);
1123   int Nb = 0;
1124   SMDS_VolumeIteratorPtr itVolumes = _myMeshDS->volumesIterator();
1125   while (itVolumes->more())
1126     if (itVolumes->next()->IsPoly()) Nb++;
1127   return Nb;
1128 }
1129
1130 //=============================================================================
1131 /*!
1132  *
1133  */
1134 //=============================================================================
1135 int SMESH_Mesh::NbSubMesh() throw(SALOME_Exception)
1136 {
1137   Unexpect aCatch(SalomeException);
1138   return _myMeshDS->NbSubMesh();
1139 }
1140
1141 //=======================================================================
1142 //function : IsNotConformAllowed
1143 //purpose  : check if a hypothesis alowing notconform mesh is present
1144 //=======================================================================
1145
1146 bool SMESH_Mesh::IsNotConformAllowed() const
1147 {
1148   if(MYDEBUG) MESSAGE("SMESH_Mesh::IsNotConformAllowed");
1149
1150   SMESH_HypoFilter filter( SMESH_HypoFilter::HasName( "NotConformAllowed" ));
1151   return GetHypothesis( _myMeshDS->ShapeToMesh(), filter, false );
1152 }
1153
1154 //=======================================================================
1155 //function : IsMainShape
1156 //purpose  :
1157 //=======================================================================
1158
1159 bool SMESH_Mesh::IsMainShape(const TopoDS_Shape& theShape) const
1160 {
1161   return theShape.IsSame(_myMeshDS->ShapeToMesh() );
1162 }
1163
1164 //=============================================================================
1165 /*!
1166  *
1167  */
1168 //=============================================================================
1169
1170 SMESH_Group* SMESH_Mesh::AddGroup (const SMDSAbs_ElementType theType,
1171                                    const char*               theName,
1172                                    int&                      theId,
1173                                    const TopoDS_Shape&       theShape)
1174 {
1175   if (_mapGroup.find(_groupId) != _mapGroup.end())
1176     return NULL;
1177   theId = _groupId;
1178   SMESH_Group* aGroup = new SMESH_Group (theId, this, theType, theName, theShape);
1179   GetMeshDS()->AddGroup( aGroup->GetGroupDS() );
1180   _mapGroup[_groupId++] = aGroup;
1181   return aGroup;
1182 }
1183
1184 //=============================================================================
1185 /*!
1186  *
1187  */
1188 //=============================================================================
1189
1190 SMESH_Group* SMESH_Mesh::GetGroup (const int theGroupID)
1191 {
1192   if (_mapGroup.find(theGroupID) == _mapGroup.end())
1193     return NULL;
1194   return _mapGroup[theGroupID];
1195 }
1196
1197
1198 //=============================================================================
1199 /*!
1200  *
1201  */
1202 //=============================================================================
1203
1204 list<int> SMESH_Mesh::GetGroupIds()
1205 {
1206   list<int> anIds;
1207   for ( map<int, SMESH_Group*>::const_iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ )
1208     anIds.push_back( it->first );
1209
1210   return anIds;
1211 }
1212
1213
1214 //=============================================================================
1215 /*!
1216  *
1217  */
1218 //=============================================================================
1219
1220 void SMESH_Mesh::RemoveGroup (const int theGroupID)
1221 {
1222   if (_mapGroup.find(theGroupID) == _mapGroup.end())
1223     return;
1224   GetMeshDS()->RemoveGroup( _mapGroup[theGroupID]->GetGroupDS() );
1225   delete _mapGroup[theGroupID];
1226   _mapGroup.erase (theGroupID);
1227 }
1228
1229 //=============================================================================
1230 /*!
1231  *  IsLocal1DHypothesis
1232  *  Returns a local 1D hypothesis used for theEdge
1233  */
1234 //=============================================================================
1235 const SMESH_Hypothesis* SMESH_Mesh::IsLocal1DHypothesis (const TopoDS_Shape& theEdge)
1236 {
1237   SMESH_HypoFilter hypo ( SMESH_HypoFilter::HasDim( 1 ));
1238   hypo.AndNot( hypo.IsAlgo() ).AndNot( hypo.IsAssignedTo( GetMeshDS()->ShapeToMesh() ));
1239
1240   return GetHypothesis( theEdge, hypo, true );
1241 }
1242
1243 //=============================================================================
1244 /*!
1245  *  IsPropagationHypothesis
1246  */
1247 //=============================================================================
1248 bool SMESH_Mesh::IsPropagationHypothesis (const TopoDS_Shape& theEdge)
1249 {
1250   return _mapPropagationChains.Contains(theEdge);
1251 }
1252
1253 //=============================================================================
1254 /*!
1255  *  IsPropagatedHypothesis
1256  */
1257 //=============================================================================
1258 bool SMESH_Mesh::IsPropagatedHypothesis (const TopoDS_Shape& theEdge,
1259                                          TopoDS_Shape&       theMainEdge)
1260 {
1261   int nbChains = _mapPropagationChains.Extent();
1262   for (int i = 1; i <= nbChains; i++) {
1263     //const TopTools_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromIndex(i);
1264     const SMESH_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromIndex(i);
1265     if (aChain.Contains(theEdge)) {
1266       theMainEdge = _mapPropagationChains.FindKey(i);
1267       return true;
1268     }
1269   }
1270
1271   return false;
1272 }
1273 //=============================================================================
1274 /*!
1275  *  IsReversedInChain
1276  */
1277 //=============================================================================
1278
1279 bool SMESH_Mesh::IsReversedInChain (const TopoDS_Shape& theEdge,
1280                                     const TopoDS_Shape& theMainEdge)
1281 {
1282   if ( !theMainEdge.IsNull() && !theEdge.IsNull() &&
1283       _mapPropagationChains.Contains( theMainEdge ))
1284   {
1285     const SMESH_IndexedMapOfShape& aChain =
1286       _mapPropagationChains.FindFromKey( theMainEdge );
1287     int index = aChain.FindIndex( theEdge );
1288     if ( index )
1289       return aChain(index).Orientation() == TopAbs_REVERSED;
1290   }
1291   return false;
1292 }
1293
1294 //=============================================================================
1295 /*!
1296  *  CleanMeshOnPropagationChain
1297  */
1298 //=============================================================================
1299 void SMESH_Mesh::CleanMeshOnPropagationChain (const TopoDS_Shape& theMainEdge)
1300 {
1301   const SMESH_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromKey(theMainEdge);
1302   int i, nbEdges = aChain.Extent();
1303   for (i = 1; i <= nbEdges; i++) {
1304     TopoDS_Shape anEdge = aChain.FindKey(i);
1305     SMESH_subMesh *subMesh = GetSubMesh(anEdge);
1306     SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS();
1307     if (subMeshDS && subMeshDS->NbElements() > 0) {
1308       subMesh->ComputeStateEngine(SMESH_subMesh::CLEAN);
1309     }
1310   }
1311 }
1312
1313 //=============================================================================
1314 /*!
1315  *  RebuildPropagationChains
1316  *  Rebuild all existing propagation chains.
1317  *  Have to be used, if 1D hypothesis have been assigned/removed to/from any edge
1318  */
1319 //=============================================================================
1320 bool SMESH_Mesh::RebuildPropagationChains()
1321 {
1322   bool ret = true;
1323
1324   // Clean all chains, because they can be not up-to-date
1325   int i, nbChains = _mapPropagationChains.Extent();
1326   for (i = 1; i <= nbChains; i++) {
1327     TopoDS_Shape aMainEdge = _mapPropagationChains.FindKey(i);
1328     CleanMeshOnPropagationChain(aMainEdge);
1329     _mapPropagationChains.ChangeFromIndex(i).Clear();
1330   }
1331
1332   // Build all chains
1333   for (i = 1; i <= nbChains; i++) {
1334     TopoDS_Shape aMainEdge = _mapPropagationChains.FindKey(i);
1335     if (!BuildPropagationChain(aMainEdge))
1336       ret = false;
1337     CleanMeshOnPropagationChain(aMainEdge);
1338   }
1339
1340   return ret;
1341 }
1342
1343 //=============================================================================
1344 /*!
1345  *  RemovePropagationChain
1346  *  Have to be used, if Propagation hypothesis is removed from <theMainEdge>
1347  */
1348 //=============================================================================
1349 bool SMESH_Mesh::RemovePropagationChain (const TopoDS_Shape& theMainEdge)
1350 {
1351   if (!_mapPropagationChains.Contains(theMainEdge))
1352     return false;
1353
1354   // Clean mesh elements and nodes, built on the chain
1355   CleanMeshOnPropagationChain(theMainEdge);
1356
1357   // Clean the chain
1358   _mapPropagationChains.ChangeFromKey(theMainEdge).Clear();
1359
1360   // Remove the chain from the map
1361   int i = _mapPropagationChains.FindIndex(theMainEdge);
1362   if ( i == _mapPropagationChains.Extent() )
1363     _mapPropagationChains.RemoveLast();
1364   else {
1365     TopoDS_Vertex anEmptyShape;
1366     BRep_Builder BB;
1367     BB.MakeVertex(anEmptyShape, gp_Pnt(0,0,0), 0.1);
1368     SMESH_IndexedMapOfShape anEmptyMap;
1369     _mapPropagationChains.Substitute(i, anEmptyShape, anEmptyMap);
1370   }
1371
1372   return true;
1373 }
1374
1375 //=============================================================================
1376 /*!
1377  *  BuildPropagationChain
1378  */
1379 //=============================================================================
1380 bool SMESH_Mesh::BuildPropagationChain (const TopoDS_Shape& theMainEdge)
1381 {
1382   if (theMainEdge.ShapeType() != TopAbs_EDGE) return true;
1383
1384   // Add new chain, if there is no
1385   if (!_mapPropagationChains.Contains(theMainEdge)) {
1386     SMESH_IndexedMapOfShape aNewChain;
1387     _mapPropagationChains.Add(theMainEdge, aNewChain);
1388   }
1389
1390   // Check presence of 1D hypothesis to be propagated
1391   const SMESH_Hypothesis* aMainHyp = IsLocal1DHypothesis(theMainEdge);
1392   if (!aMainHyp) {
1393     MESSAGE("Warning: There is no 1D hypothesis to propagate. Please, assign.");
1394     return true;
1395   }
1396
1397   // Edges, on which the 1D hypothesis will be propagated from <theMainEdge>
1398   SMESH_IndexedMapOfShape& aChain = _mapPropagationChains.ChangeFromKey(theMainEdge);
1399   if (aChain.Extent() > 0) {
1400     CleanMeshOnPropagationChain(theMainEdge);
1401     aChain.Clear();
1402   }
1403
1404   // At first put <theMainEdge> in the chain
1405   aChain.Add(theMainEdge);
1406
1407   // List of edges, added to chain on the previous cycle pass
1408   TopTools_ListOfShape listPrevEdges;
1409   listPrevEdges.Append(theMainEdge.Oriented( TopAbs_FORWARD ));
1410
1411 //   5____4____3____4____5____6
1412 //   |    |    |    |    |    |
1413 //   |    |    |    |    |    |
1414 //   4____3____2____3____4____5
1415 //   |    |    |    |    |    |      Number in the each knot of
1416 //   |    |    |    |    |    |      grid indicates cycle pass,
1417 //   3____2____1____2____3____4      on which corresponding edge
1418 //   |    |    |    |    |    |      (perpendicular to the plane
1419 //   |    |    |    |    |    |      of view) will be found.
1420 //   2____1____0____1____2____3
1421 //   |    |    |    |    |    |
1422 //   |    |    |    |    |    |
1423 //   3____2____1____2____3____4
1424
1425   // Collect all edges pass by pass
1426   while (listPrevEdges.Extent() > 0) {
1427     // List of edges, added to chain on this cycle pass
1428     TopTools_ListOfShape listCurEdges;
1429
1430     // Find the next portion of edges
1431     TopTools_ListIteratorOfListOfShape itE (listPrevEdges);
1432     for (; itE.More(); itE.Next()) {
1433       TopoDS_Shape anE = itE.Value();
1434
1435       // Iterate on faces, having edge <anE>
1436       TopTools_ListIteratorOfListOfShape itA (GetAncestors(anE));
1437       for (; itA.More(); itA.Next()) {
1438         TopoDS_Shape aW = itA.Value();
1439
1440         // There are objects of different type among the ancestors of edge
1441         if (aW.ShapeType() == TopAbs_WIRE) {
1442           TopoDS_Shape anOppE;
1443
1444           BRepTools_WireExplorer aWE (TopoDS::Wire(aW));
1445           Standard_Integer nb = 1, found = 0;
1446           TopTools_Array1OfShape anEdges (1,4);
1447           for (; aWE.More(); aWE.Next(), nb++) {
1448             if (nb > 4) {
1449               found = 0;
1450               break;
1451             }
1452             anEdges(nb) = aWE.Current();
1453             if (!_mapAncestors.Contains(anEdges(nb))) {
1454               MESSAGE("WIRE EXPLORER HAVE GIVEN AN INVALID EDGE !!!");
1455               break;
1456             }
1457             if (anEdges(nb).IsSame(anE)) found = nb;
1458           }
1459
1460           if (nb == 5 && found > 0) {
1461             // Quadrangle face found, get an opposite edge
1462             Standard_Integer opp = found + 2;
1463             if (opp > 4) opp -= 4;
1464             anOppE = anEdges(opp);
1465
1466             // add anOppE to aChain if ...
1467             if (!aChain.Contains(anOppE)) { // ... anOppE is not in aChain
1468               if (!IsLocal1DHypothesis(anOppE)) { // ... no other 1d hyp on anOppE
1469                 TopoDS_Shape aMainEdgeForOppEdge; // ... no other hyp is propagated to anOppE
1470                 if (!IsPropagatedHypothesis(anOppE, aMainEdgeForOppEdge))
1471                 {
1472                   // Add found edge to the chain oriented so that to
1473                   // have it co-directed with a forward MainEdge
1474                   TopAbs_Orientation ori = anE.Orientation();
1475                   if ( anEdges(opp).Orientation() == anEdges(found).Orientation() )
1476                     ori = TopAbs::Reverse( ori );
1477                   anOppE.Orientation( ori );
1478                   aChain.Add(anOppE);
1479                   listCurEdges.Append(anOppE);
1480                 }
1481                 else {
1482                   // Collision!
1483                   MESSAGE("Error: Collision between propagated hypotheses");
1484                   CleanMeshOnPropagationChain(theMainEdge);
1485                   aChain.Clear();
1486                   return ( aMainHyp == IsLocal1DHypothesis(aMainEdgeForOppEdge) );
1487                 }
1488               }
1489             }
1490           } // if (nb == 5 && found > 0)
1491         } // if (aF.ShapeType() == TopAbs_WIRE)
1492       } // for (; itF.More(); itF.Next())
1493     } // for (; itE.More(); itE.Next())
1494
1495     listPrevEdges = listCurEdges;
1496   } // while (listPrevEdges.Extent() > 0)
1497
1498   CleanMeshOnPropagationChain(theMainEdge);
1499   return true;
1500 }
1501
1502 //=======================================================================
1503 //function : GetAncestors
1504 //purpose  : return list of ancestors of theSubShape in the order
1505 //           that lower dimention shapes come first.
1506 //=======================================================================
1507
1508 const TopTools_ListOfShape& SMESH_Mesh::GetAncestors(const TopoDS_Shape& theS) const
1509 {
1510   if ( _mapAncestors.Contains( theS ) )
1511     return _mapAncestors.FindFromKey( theS );
1512
1513   static TopTools_ListOfShape emptyList;
1514   return emptyList;
1515 }
1516
1517 //=======================================================================
1518 //function : Dump
1519 //purpose  : dumps contents of mesh to stream [ debug purposes ]
1520 //=======================================================================
1521 ostream& SMESH_Mesh::Dump(ostream& save)
1522 {
1523   save << "========================== Dump contents of mesh ==========================" << endl;
1524   save << "1) Total number of nodes:     " << NbNodes() << endl;
1525   save << "2) Total number of edges:     " << NbEdges() << endl;
1526   save << "3) Total number of faces:     " << NbFaces() << endl;
1527   if ( NbFaces() > 0 ) {
1528     int nb3 = NbTriangles();
1529     int nb4 = NbQuadrangles();
1530     save << "3.1.) Number of triangles:    " << nb3 << endl;
1531     save << "3.2.) Number of quadrangles:  " << nb4 << endl;
1532     if ( nb3 + nb4 !=  NbFaces() ) {
1533       map<int,int> myFaceMap;
1534       SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
1535       while( itFaces->more( ) ) {
1536         int nbNodes = itFaces->next()->NbNodes();
1537         if ( myFaceMap.find( nbNodes ) == myFaceMap.end() )
1538           myFaceMap[ nbNodes ] = 0;
1539         myFaceMap[ nbNodes ] = myFaceMap[ nbNodes ] + 1;
1540       }
1541       save << "3.3.) Faces in detail: " << endl;
1542       map <int,int>::iterator itF;
1543       for (itF = myFaceMap.begin(); itF != myFaceMap.end(); itF++)
1544         save << "--> nb nodes: " << itF->first << " - nb elemens: " << itF->second << endl;
1545     }
1546   }
1547   save << "4) Total number of volumes:   " << NbVolumes() << endl;
1548   if ( NbVolumes() > 0 ) {
1549     int nb8 = NbHexas();
1550     int nb4 = NbTetras();
1551     int nb5 = NbPyramids();
1552     int nb6 = NbPrisms();
1553     save << "4.1.) Number of hexahedrons:  " << nb8 << endl;
1554     save << "4.2.) Number of tetrahedrons: " << nb4 << endl;
1555     save << "4.3.) Number of prisms:       " << nb6 << endl;
1556     save << "4.4.) Number of pyramides:    " << nb5 << endl;
1557     if ( nb8 + nb4 + nb5 + nb6 != NbVolumes() ) {
1558       map<int,int> myVolumesMap;
1559       SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
1560       while( itVolumes->more( ) ) {
1561         int nbNodes = itVolumes->next()->NbNodes();
1562         if ( myVolumesMap.find( nbNodes ) == myVolumesMap.end() )
1563           myVolumesMap[ nbNodes ] = 0;
1564         myVolumesMap[ nbNodes ] = myVolumesMap[ nbNodes ] + 1;
1565       }
1566       save << "4.5.) Volumes in detail: " << endl;
1567       map <int,int>::iterator itV;
1568       for (itV = myVolumesMap.begin(); itV != myVolumesMap.end(); itV++)
1569         save << "--> nb nodes: " << itV->first << " - nb elemens: " << itV->second << endl;
1570     }
1571   }
1572   save << "===========================================================================" << endl;
1573   return save;
1574 }
1575
1576 //=======================================================================
1577 //function : GetElementType
1578 //purpose  : Returns type of mesh element with certain id
1579 //=======================================================================
1580 SMDSAbs_ElementType SMESH_Mesh::GetElementType( const int id, const bool iselem )
1581 {
1582   return _myMeshDS->GetElementType( id, iselem );
1583 }