src/SMESH/SMESH_Gen.cxx

   1 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //  SMESH SMESH : implementaion of SMESH idl descriptions
  23 //  File   : SMESH_Gen.cxx
  24 //  Author : Paul RASCLE, EDF
  25 //  Module : SMESH
  26
  27 #include "SMESH_Gen.hxx"
  28 #include "SMESH_subMesh.hxx"
  29 #include "SMESH_HypoFilter.hxx"
  30 #include "SMESHDS_Document.hxx"
  31 #include "SMDS_MeshElement.hxx"
  32 #include "SMDS_MeshNode.hxx"
  33 #include "SMDS_Mesh.hxx"
  34
  35 #include "utilities.h"
  36 #include "OpUtil.hxx"
  37 #include "Utils_ExceptHandlers.hxx"
  38
  39 #include <gp_Pnt.hxx>
  40 #include <BRep_Tool.hxx>
  41 #include <TopTools_ListOfShape.hxx>
  42 #include <TopTools_ListIteratorOfListOfShape.hxx>
  43
  44 #include "memoire.h"
  45
  46 using namespace std;
  47
  48 //=============================================================================
  49 /*!
  50  *  default constructor:
  51  */
  52 //=============================================================================
  53
  54 SMESH_Gen::SMESH_Gen()
  55 {
  56         MESSAGE("SMESH_Gen::SMESH_Gen");
  57         _localId = 0;
  58         _hypId = 0;
  59         _segmentation = 10;
  60         SMDS_Mesh::_meshList.clear();
  61         MESSAGE(SMDS_Mesh::_meshList.size());
  62 }
  63
  64 //=============================================================================
  65 /*!
  66  *
  67  */
  68 //=============================================================================
  69
  70 SMESH_Gen::~SMESH_Gen()
  71 {
  72         MESSAGE("SMESH_Gen::~SMESH_Gen");
  73 }
  74
  75 //=============================================================================
  76 /*!
  77  *
  78  */
  79 //=============================================================================
  80
  81 /*SMESH_Hypothesis *SMESH_Gen::CreateHypothesis(const char *anHyp, int studyId)
  82         throw(SALOME_Exception)
  83 {
  84
  85         MESSAGE("CreateHypothesis("<<anHyp<<","<<studyId<<")");
  86         // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
  87
  88         StudyContextStruct *myStudyContext = GetStudyContext(studyId);
  89
  90         // create a new hypothesis object, store its ref. in studyContext
  91
  92         SMESH_Hypothesis *myHypothesis = _hypothesisFactory.Create(anHyp, studyId);
  93         int hypId = myHypothesis->GetID();
  94         myStudyContext->mapHypothesis[hypId] = myHypothesis;
  95         SCRUTE(studyId);
  96         SCRUTE(hypId);
  97
  98         // store hypothesis in SMESHDS document
  99
 100         myStudyContext->myDocument->AddHypothesis(myHypothesis);
 101         return myHypothesis;
 102 }*/
 103
 104 //=============================================================================
 105 /*!
 106  *
 107  */
 108 //=============================================================================
 109
 110 SMESH_Mesh* SMESH_Gen::CreateMesh(int theStudyId, bool theIsEmbeddedMode)
 111   throw(SALOME_Exception)
 112 {
 113   Unexpect aCatch(SalomeException);
 114   MESSAGE("SMESH_Gen::CreateMesh");
 115
 116   // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
 117   StudyContextStruct *aStudyContext = GetStudyContext(theStudyId);
 118
 119   // create a new SMESH_mesh object
 120   SMESH_Mesh *aMesh = new SMESH_Mesh(_localId++,
 121                                      theStudyId,
 122                                      this,
 123                                      theIsEmbeddedMode,
 124                                      aStudyContext->myDocument);
 125   aStudyContext->mapMesh[_localId] = aMesh;
 126
 127   return aMesh;
 128 }
 129
 130 //=============================================================================
 131 /*!
 132  * Compute a mesh
 133  */
 134 //=============================================================================
 135
 136 bool SMESH_Gen::Compute(SMESH_Mesh &          aMesh,
 137                         const TopoDS_Shape &  aShape,
 138                         const bool            anUpward,
 139                         const ::MeshDimension aDim,
 140                         TSetOfInt*            aShapesId)
 141 {
 142   MESSAGE("SMESH_Gen::Compute");
 143   MEMOSTAT;
 144
 145   bool ret = true;
 146
 147   SMESH_subMesh *sm = aMesh.GetSubMesh(aShape);
 148
 149   const bool includeSelf = true;
 150   const bool complexShapeFirst = true;
 151
 152   SMESH_subMeshIteratorPtr smIt;
 153
 154   if ( anUpward ) // is called from below code here
 155   {
 156     // -----------------------------------------------
 157     // mesh all the subshapes starting from vertices
 158     // -----------------------------------------------
 159     smIt = sm->getDependsOnIterator(includeSelf, !complexShapeFirst);
 160     while ( smIt->more() )
 161     {
 162       SMESH_subMesh* smToCompute = smIt->next();
 163
 164       // do not mesh vertices of a pseudo shape
 165       const TopAbs_ShapeEnum aShType = smToCompute->GetSubShape().ShapeType();
 166       if ( !aMesh.HasShapeToMesh() && aShType == TopAbs_VERTEX )
 167         continue;
 168
 169       // check for preview dimension limitations
 170       if ( aShapesId && GetShapeDim( aShType ) > (int)aDim )
 171       {
 172         // clear compute state to not show previous compute errors
 173         //  if preview invoked less dimension less than previous
 174         smToCompute->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
 175         continue;
 176       }
 177
 178       if (smToCompute->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE)
 179         smToCompute->ComputeStateEngine( SMESH_subMesh::COMPUTE );
 180
 181       // we check all the submeshes here and detect if any of them failed to compute
 182       if (smToCompute->GetComputeState() == SMESH_subMesh::FAILED_TO_COMPUTE)
 183         ret = false;
 184       else if ( aShapesId )
 185         aShapesId->insert( smToCompute->GetId() );
 186     }
 187     return ret;
 188   }
 189   else
 190   {
 191     // -----------------------------------------------------------------
 192     // apply algos that DO NOT require descretized boundaries and DO NOT
 193     // support submeshes, starting from the most complex shapes
 194     // and collect submeshes with algos that DO support submeshes
 195     // -----------------------------------------------------------------
 196     list< SMESH_subMesh* > smWithAlgoSupportingSubmeshes;
 197     smIt = sm->getDependsOnIterator(includeSelf, complexShapeFirst);
 198     while ( smIt->more() )
 199     {
 200       SMESH_subMesh* smToCompute = smIt->next();
 201       if ( smToCompute->GetComputeState() != SMESH_subMesh::READY_TO_COMPUTE )
 202         continue;
 203
 204       const TopoDS_Shape& aSubShape = smToCompute->GetSubShape();
 205       const int aShapeDim = GetShapeDim( aSubShape );
 206       if ( aShapeDim < 1 ) break;
 207
 208       // check for preview dimension limitations
 209       if ( aShapesId && aShapeDim > (int)aDim )
 210         continue;
 211
 212       SMESH_Algo* algo = GetAlgo( aMesh, aSubShape );
 213       if ( algo && !algo->NeedDescretBoundary() )
 214       {
 215         if ( algo->SupportSubmeshes() )
 216           smWithAlgoSupportingSubmeshes.push_back( smToCompute );
 217         else
 218         {
 219           smToCompute->ComputeStateEngine( SMESH_subMesh::COMPUTE );
 220           if ( aShapesId )
 221             aShapesId->insert( smToCompute->GetId() );
 222         }
 223       }
 224     }
 225     // ------------------------------------------------------------
 226     // compute submeshes under shapes with algos that DO NOT require
 227     // descretized boundaries and DO support submeshes
 228     // ------------------------------------------------------------
 229     list< SMESH_subMesh* >::reverse_iterator subIt, subEnd;
 230     subIt  = smWithAlgoSupportingSubmeshes.rbegin();
 231     subEnd = smWithAlgoSupportingSubmeshes.rend();
 232     // start from lower shapes
 233     for ( ; subIt != subEnd; ++subIt )
 234     {
 235       sm = *subIt;
 236
 237       // get a shape the algo is assigned to
 238       TopoDS_Shape algoShape;
 239       if ( !GetAlgo( aMesh, sm->GetSubShape(), & algoShape ))
 240         continue; // strange...
 241
 242       // look for more local algos
 243       smIt = sm->getDependsOnIterator(!includeSelf, !complexShapeFirst);
 244       while ( smIt->more() )
 245       {
 246         SMESH_subMesh* smToCompute = smIt->next();
 247
 248         const TopoDS_Shape& aSubShape = smToCompute->GetSubShape();
 249         const int aShapeDim = GetShapeDim( aSubShape );
 250         //if ( aSubShape.ShapeType() == TopAbs_VERTEX ) continue;
 251         if ( aShapeDim < 1 ) continue;
 252
 253         // check for preview dimension limitations
 254         if ( aShapesId && GetShapeDim( aSubShape.ShapeType() ) > (int)aDim )
 255           continue;
 256
 257         SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() );
 258         filter
 259           .And( SMESH_HypoFilter::IsApplicableTo( aSubShape ))
 260           .And( SMESH_HypoFilter::IsMoreLocalThan( algoShape ));
 261
 262         if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( aSubShape, filter, true )) {
 263           SMESH_Hypothesis::Hypothesis_Status status;
 264           if ( subAlgo->CheckHypothesis( aMesh, aSubShape, status ))
 265             // mesh a lower smToCompute starting from vertices
 266             Compute( aMesh, aSubShape, /*anUpward=*/true, aDim, aShapesId );
 267         }
 268       }
 269     }
 270     // ----------------------------------------------------------
 271     // apply the algos that do not require descretized boundaries
 272     // ----------------------------------------------------------
 273     for ( subIt = smWithAlgoSupportingSubmeshes.rbegin(); subIt != subEnd; ++subIt )
 274     {
 275       sm = *subIt;
 276       if ( sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE)
 277       {
 278         const TopAbs_ShapeEnum aShType = sm->GetSubShape().ShapeType();
 279         // check for preview dimension limitations
 280         if ( aShapesId && GetShapeDim( aShType ) > (int)aDim )
 281           continue;
 282
 283         sm->ComputeStateEngine( SMESH_subMesh::COMPUTE );
 284         if ( aShapesId )
 285           aShapesId->insert( sm->GetId() );
 286       }
 287     }
 288     // -----------------------------------------------
 289     // mesh the rest subshapes starting from vertices
 290     // -----------------------------------------------
 291     ret = Compute( aMesh, aShape, /*anUpward=*/true, aDim, aShapesId );
 292   }
 293
 294   MESSAGE( "VSR - SMESH_Gen::Compute() finished, OK = " << ret);
 295   MEMOSTAT;
 296   return ret;
 297 }
 298
 299
 300 //=============================================================================
 301 /*!
 302  * Evaluate a mesh
 303  */
 304 //=============================================================================
 305
 306 bool SMESH_Gen::Evaluate(SMESH_Mesh &          aMesh,
 307                          const TopoDS_Shape &  aShape,
 308                          MapShapeNbElems&      aResMap,
 309                          const bool            anUpward,
 310                          TSetOfInt*            aShapesId)
 311 {
 312   MESSAGE("SMESH_Gen::Evaluate");
 313
 314   bool ret = true;
 315
 316   SMESH_subMesh *sm = aMesh.GetSubMesh(aShape);
 317
 318   const bool includeSelf = true;
 319   const bool complexShapeFirst = true;
 320   SMESH_subMeshIteratorPtr smIt;
 321
 322   if ( anUpward ) { // is called from below code here
 323     // -----------------------------------------------
 324     // mesh all the subshapes starting from vertices
 325     // -----------------------------------------------
 326     smIt = sm->getDependsOnIterator(includeSelf, !complexShapeFirst);
 327     while ( smIt->more() ) {
 328       SMESH_subMesh* smToCompute = smIt->next();
 329
 330       // do not mesh vertices of a pseudo shape
 331       const TopAbs_ShapeEnum aShType = smToCompute->GetSubShape().ShapeType();
 332       //if ( !aMesh.HasShapeToMesh() && aShType == TopAbs_VERTEX )
 333       //  continue;
 334       if ( !aMesh.HasShapeToMesh() ) {
 335         if( aShType == TopAbs_VERTEX || aShType == TopAbs_WIRE ||
 336             aShType == TopAbs_SHELL )
 337           continue;
 338       }
 339
 340       smToCompute->Evaluate(aResMap);
 341       if( aShapesId )
 342         aShapesId->insert( smToCompute->GetId() );
 343     }
 344     return ret;
 345   }
 346   else {
 347     // -----------------------------------------------------------------
 348     // apply algos that DO NOT require descretized boundaries and DO NOT
 349     // support submeshes, starting from the most complex shapes
 350     // and collect submeshes with algos that DO support submeshes
 351     // -----------------------------------------------------------------
 352     list< SMESH_subMesh* > smWithAlgoSupportingSubmeshes;
 353     smIt = sm->getDependsOnIterator(includeSelf, complexShapeFirst);
 354     while ( smIt->more() ) {
 355       SMESH_subMesh* smToCompute = smIt->next();
 356       const TopoDS_Shape& aSubShape = smToCompute->GetSubShape();
 357       const int aShapeDim = GetShapeDim( aSubShape );
 358       if ( aShapeDim < 1 ) break;
 359
 360       SMESH_Algo* algo = GetAlgo( aMesh, aSubShape );
 361       if ( algo && !algo->NeedDescretBoundary() ) {
 362         if ( algo->SupportSubmeshes() ) {
 363           smWithAlgoSupportingSubmeshes.push_back( smToCompute );
 364         }
 365         else {
 366           smToCompute->Evaluate(aResMap);
 367           if ( aShapesId )
 368             aShapesId->insert( smToCompute->GetId() );
 369         }
 370       }
 371     }
 372     // ------------------------------------------------------------
 373     // compute submeshes under shapes with algos that DO NOT require
 374     // descretized boundaries and DO support submeshes
 375     // ------------------------------------------------------------
 376     list< SMESH_subMesh* >::reverse_iterator subIt, subEnd;
 377     subIt  = smWithAlgoSupportingSubmeshes.rbegin();
 378     subEnd = smWithAlgoSupportingSubmeshes.rend();
 379     // start from lower shapes
 380     for ( ; subIt != subEnd; ++subIt ) {
 381       sm = *subIt;
 382
 383       // get a shape the algo is assigned to
 384       TopoDS_Shape algoShape;
 385       if ( !GetAlgo( aMesh, sm->GetSubShape(), & algoShape ))
 386         continue; // strange...
 387
 388       // look for more local algos
 389       smIt = sm->getDependsOnIterator(!includeSelf, !complexShapeFirst);
 390       while ( smIt->more() ) {
 391         SMESH_subMesh* smToCompute = smIt->next();
 392
 393         const TopoDS_Shape& aSubShape = smToCompute->GetSubShape();
 394         const int aShapeDim = GetShapeDim( aSubShape );
 395         if ( aShapeDim < 1 ) continue;
 396
 397         //const TopAbs_ShapeEnum aShType = smToCompute->GetSubShape().ShapeType();
 398
 399         SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() );
 400         filter
 401           .And( SMESH_HypoFilter::IsApplicableTo( aSubShape ))
 402           .And( SMESH_HypoFilter::IsMoreLocalThan( algoShape ));
 403
 404         if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( aSubShape, filter, true )) {
 405           SMESH_Hypothesis::Hypothesis_Status status;
 406           if ( subAlgo->CheckHypothesis( aMesh, aSubShape, status ))
 407             // mesh a lower smToCompute starting from vertices
 408             Evaluate( aMesh, aSubShape, aResMap, /*anUpward=*/true, aShapesId );
 409         }
 410       }
 411     }
 412     // ----------------------------------------------------------
 413     // apply the algos that do not require descretized boundaries
 414     // ----------------------------------------------------------
 415     for ( subIt = smWithAlgoSupportingSubmeshes.rbegin(); subIt != subEnd; ++subIt )
 416     {
 417       sm = *subIt;
 418       sm->Evaluate(aResMap);
 419       if ( aShapesId )
 420         aShapesId->insert( sm->GetId() );
 421     }
 422
 423     // -----------------------------------------------
 424     // mesh the rest subshapes starting from vertices
 425     // -----------------------------------------------
 426     ret = Evaluate( aMesh, aShape, aResMap, /*anUpward=*/true, aShapesId );
 427   }
 428
 429   MESSAGE( "VSR - SMESH_Gen::Evaluate() finished, OK = " << ret);
 430   return ret;
 431 }
 432
 433
 434 //=======================================================================
 435 //function : checkConformIgnoredAlgos
 436 //purpose  :
 437 //=======================================================================
 438
 439 static bool checkConformIgnoredAlgos(SMESH_Mesh&               aMesh,
 440                                      SMESH_subMesh*            aSubMesh,
 441                                      const SMESH_Algo*         aGlobIgnoAlgo,
 442                                      const SMESH_Algo*         aLocIgnoAlgo,
 443                                      bool &                    checkConform,
 444                                      set<SMESH_subMesh*>&      aCheckedMap,
 445                                      list< SMESH_Gen::TAlgoStateError > & theErrors)
 446 {
 447   ASSERT( aSubMesh );
 448   if ( aSubMesh->GetSubShape().ShapeType() == TopAbs_VERTEX)
 449     return true;
 450
 451
 452   bool ret = true;
 453
 454   const list<const SMESHDS_Hypothesis*>& listHyp =
 455     aMesh.GetMeshDS()->GetHypothesis( aSubMesh->GetSubShape() );
 456   list<const SMESHDS_Hypothesis*>::const_iterator it=listHyp.begin();
 457   for ( ; it != listHyp.end(); it++)
 458   {
 459     const SMESHDS_Hypothesis * aHyp = *it;
 460     if (aHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
 461       continue;
 462
 463     const SMESH_Algo* algo = dynamic_cast<const SMESH_Algo*> (aHyp);
 464     ASSERT ( algo );
 465
 466     if ( aLocIgnoAlgo ) // algo is hidden by a local algo of upper dim
 467     {
 468       INFOS( "Local <" << algo->GetName() << "> is hidden by local <"
 469             << aLocIgnoAlgo->GetName() << ">");
 470     }
 471     else
 472     {
 473       bool isGlobal = (aMesh.IsMainShape( aSubMesh->GetSubShape() ));
 474       int dim = algo->GetDim();
 475       int aMaxGlobIgnoDim = ( aGlobIgnoAlgo ? aGlobIgnoAlgo->GetDim() : -1 );
 476
 477       if ( dim < aMaxGlobIgnoDim )
 478       {
 479         // algo is hidden by a global algo
 480         INFOS( ( isGlobal ? "Global" : "Local" )
 481               << " <" << algo->GetName() << "> is hidden by global <"
 482               << aGlobIgnoAlgo->GetName() << ">");
 483       }
 484       else if ( !algo->NeedDescretBoundary() && !isGlobal)
 485       {
 486         // local algo is not hidden and hides algos on sub-shapes
 487         if (checkConform && !aSubMesh->IsConform( algo ))
 488         {
 489           ret = false;
 490           checkConform = false; // no more check conformity
 491           INFOS( "ERROR: Local <" << algo->GetName() <<
 492                 "> would produce not conform mesh: "
 493                 "<Not Conform Mesh Allowed> hypotesis is missing");
 494           theErrors.push_back( SMESH_Gen::TAlgoStateError() );
 495           theErrors.back().Set( SMESH_Hypothesis::HYP_NOTCONFORM, algo, false );
 496         }
 497
 498         // sub-algos will be hidden by a local <algo>
 499         SMESH_subMeshIteratorPtr revItSub =
 500           aSubMesh->getDependsOnIterator( /*includeSelf=*/false, /*complexShapeFirst=*/true);
 501         bool checkConform2 = false;
 502         while ( revItSub->more() )
 503         {
 504           SMESH_subMesh* sm = revItSub->next();
 505           checkConformIgnoredAlgos (aMesh, sm, aGlobIgnoAlgo,
 506                                     algo, checkConform2, aCheckedMap, theErrors);
 507           aCheckedMap.insert( sm );
 508         }
 509       }
 510     }
 511   }
 512
 513   return ret;
 514 }
 515
 516 //=======================================================================
 517 //function : checkMissing
 518 //purpose  : notify on missing hypothesis
 519 //           Return false if algo or hipothesis is missing
 520 //=======================================================================
 521
 522 static bool checkMissing(SMESH_Gen*                aGen,
 523                          SMESH_Mesh&               aMesh,
 524                          SMESH_subMesh*            aSubMesh,
 525                          const int                 aTopAlgoDim,
 526                          bool*                     globalChecked,
 527                          const bool                checkNoAlgo,
 528                          set<SMESH_subMesh*>&      aCheckedMap,
 529                          list< SMESH_Gen::TAlgoStateError > & theErrors)
 530 {
 531   if ( aSubMesh->GetSubShape().ShapeType() == TopAbs_VERTEX)
 532     return true;
 533
 534   //MESSAGE("=====checkMissing");
 535
 536   int ret = true;
 537   SMESH_Algo* algo = 0;
 538
 539   switch (aSubMesh->GetAlgoState())
 540   {
 541   case SMESH_subMesh::NO_ALGO: {
 542     if (checkNoAlgo)
 543     {
 544       // should there be any algo?
 545       int shapeDim = SMESH_Gen::GetShapeDim( aSubMesh->GetSubShape() );
 546       if (aTopAlgoDim > shapeDim)
 547       {
 548         MESSAGE( "ERROR: " << shapeDim << "D algorithm is missing" );
 549         ret = false;
 550         theErrors.push_back( SMESH_Gen::TAlgoStateError() );
 551         theErrors.back().Set( SMESH_Hypothesis::HYP_MISSING, shapeDim, true );
 552       }
 553     }
 554     return ret;
 555   }
 556   case SMESH_subMesh::MISSING_HYP: {
 557     // notify if an algo missing hyp is attached to aSubMesh
 558     algo = aGen->GetAlgo( aMesh, aSubMesh->GetSubShape() );
 559     ASSERT( algo );
 560     bool IsGlobalHypothesis = aGen->IsGlobalHypothesis( algo, aMesh );
 561     if (!IsGlobalHypothesis || !globalChecked[ algo->GetDim() ])
 562     {
 563       TAlgoStateErrorName errName = SMESH_Hypothesis::HYP_MISSING;
 564       SMESH_Hypothesis::Hypothesis_Status status;
 565       algo->CheckHypothesis( aMesh, aSubMesh->GetSubShape(), status );
 566       if ( status == SMESH_Hypothesis::HYP_BAD_PARAMETER ) {
 567         MESSAGE( "ERROR: hypothesis of " << (IsGlobalHypothesis ? "Global " : "Local ")
 568                  << "<" << algo->GetName() << "> has a bad parameter value");
 569         errName = status;
 570       } else if ( status == SMESH_Hypothesis::HYP_BAD_GEOMETRY ) {
 571         MESSAGE( "ERROR: " << (IsGlobalHypothesis ? "Global " : "Local ")
 572                  << "<" << algo->GetName() << "> assigned to mismatching geometry");
 573         errName = status;
 574       } else {
 575         MESSAGE( "ERROR: " << (IsGlobalHypothesis ? "Global " : "Local ")
 576                  << "<" << algo->GetName() << "> misses some hypothesis");
 577       }
 578       if (IsGlobalHypothesis)
 579         globalChecked[ algo->GetDim() ] = true;
 580       theErrors.push_back( SMESH_Gen::TAlgoStateError() );
 581       theErrors.back().Set( errName, algo, IsGlobalHypothesis );
 582     }
 583     ret = false;
 584     break;
 585   }
 586   case SMESH_subMesh::HYP_OK:
 587     algo = aGen->GetAlgo( aMesh, aSubMesh->GetSubShape() );
 588     ret = true;
 589     break;
 590   default: ASSERT(0);
 591   }
 592
 593   // do not check under algo that hides sub-algos or
 594   // re-start checking NO_ALGO state
 595   ASSERT (algo);
 596   bool isTopLocalAlgo =
 597     ( aTopAlgoDim <= algo->GetDim() && !aGen->IsGlobalHypothesis( algo, aMesh ));
 598   if (!algo->NeedDescretBoundary() || isTopLocalAlgo)
 599   {
 600     bool checkNoAlgo2 = ( algo->NeedDescretBoundary() );
 601     SMESH_subMeshIteratorPtr itsub = aSubMesh->getDependsOnIterator( /*includeSelf=*/false,
 602                                                                      /*complexShapeFirst=*/false);
 603     while ( itsub->more() )
 604     {
 605       // sub-meshes should not be checked further more
 606       SMESH_subMesh* sm = itsub->next();
 607       aCheckedMap.insert( sm );
 608
 609       if (isTopLocalAlgo)
 610       {
 611         //check algo on sub-meshes
 612         int aTopAlgoDim2 = algo->GetDim();
 613         if (!checkMissing (aGen, aMesh, sm, aTopAlgoDim2,
 614                            globalChecked, checkNoAlgo2, aCheckedMap, theErrors))
 615         {
 616           ret = false;
 617           if (sm->GetAlgoState() == SMESH_subMesh::NO_ALGO )
 618             checkNoAlgo2 = false;
 619         }
 620       }
 621     }
 622   }
 623   return ret;
 624 }
 625
 626 //=======================================================================
 627 //function : CheckAlgoState
 628 //purpose  : notify on bad state of attached algos, return false
 629 //           if Compute() would fail because of some algo bad state
 630 //=======================================================================
 631
 632 bool SMESH_Gen::CheckAlgoState(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
 633 {
 634   list< TAlgoStateError > errors;
 635   return GetAlgoState( aMesh, aShape, errors );
 636 }
 637
 638 //=======================================================================
 639 //function : GetAlgoState
 640 //purpose  : notify on bad state of attached algos, return false
 641 //           if Compute() would fail because of some algo bad state
 642 //           theErrors list contains problems description
 643 //=======================================================================
 644
 645 bool SMESH_Gen::GetAlgoState(SMESH_Mesh&               theMesh,
 646                              const TopoDS_Shape&       theShape,
 647                              list< TAlgoStateError > & theErrors)
 648 {
 649   //MESSAGE("SMESH_Gen::CheckAlgoState");
 650
 651   bool ret = true;
 652   bool hasAlgo = false;
 653
 654   SMESH_subMesh* sm = theMesh.GetSubMesh(theShape);
 655   const SMESHDS_Mesh* meshDS = theMesh.GetMeshDS();
 656   TopoDS_Shape mainShape = meshDS->ShapeToMesh();
 657
 658   // -----------------
 659   // get global algos
 660   // -----------------
 661
 662   const SMESH_Algo* aGlobAlgoArr[] = {0,0,0,0};
 663
 664   const list<const SMESHDS_Hypothesis*>& listHyp = meshDS->GetHypothesis( mainShape );
 665   list<const SMESHDS_Hypothesis*>::const_iterator it=listHyp.begin();
 666   for ( ; it != listHyp.end(); it++)
 667   {
 668     const SMESHDS_Hypothesis * aHyp = *it;
 669     if (aHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
 670       continue;
 671
 672     const SMESH_Algo* algo = dynamic_cast<const SMESH_Algo*> (aHyp);
 673     ASSERT ( algo );
 674
 675     int dim = algo->GetDim();
 676     aGlobAlgoArr[ dim ] = algo;
 677
 678     hasAlgo = true;
 679   }
 680
 681   // --------------------------------------------------------
 682   // info on algos that will be ignored because of ones that
 683   // don't NeedDescretBoundary() attached to super-shapes,
 684   // check that a conform mesh will be produced
 685   // --------------------------------------------------------
 686
 687
 688   // find a global algo possibly hiding sub-algos
 689   int dim;
 690   const SMESH_Algo* aGlobIgnoAlgo = 0;
 691   for (dim = 3; dim > 0; dim--)
 692   {
 693     if (aGlobAlgoArr[ dim ] &&
 694         !aGlobAlgoArr[ dim ]->NeedDescretBoundary())
 695     {
 696       aGlobIgnoAlgo = aGlobAlgoArr[ dim ];
 697       break;
 698     }
 699   }
 700
 701   set<SMESH_subMesh*> aCheckedSubs;
 702   bool checkConform = ( !theMesh.IsNotConformAllowed() );
 703
 704   // loop on theShape and its sub-shapes
 705   SMESH_subMeshIteratorPtr revItSub = sm->getDependsOnIterator( /*includeSelf=*/true,
 706                                                                 /*complexShapeFirst=*/true);
 707   while ( revItSub->more() )
 708   {
 709     SMESH_subMesh* smToCheck = revItSub->next();
 710     if ( smToCheck->GetSubShape().ShapeType() == TopAbs_VERTEX)
 711       break;
 712
 713     if ( aCheckedSubs.insert( smToCheck ).second ) // not yet checked
 714       if (!checkConformIgnoredAlgos (theMesh, smToCheck, aGlobIgnoAlgo,
 715                                      0, checkConform, aCheckedSubs, theErrors))
 716         ret = false;
 717
 718     if ( smToCheck->GetAlgoState() != SMESH_subMesh::NO_ALGO )
 719       hasAlgo = true;
 720   }
 721
 722   // ----------------------------------------------------------------
 723   // info on missing hypothesis and find out if all needed algos are
 724   // well defined
 725   // ----------------------------------------------------------------
 726
 727   //MESSAGE( "---info on missing hypothesis and find out if all needed algos are");
 728
 729   // find max dim of global algo
 730   int aTopAlgoDim = 0;
 731   for (dim = 3; dim > 0; dim--)
 732   {
 733     if (aGlobAlgoArr[ dim ])
 734     {
 735       aTopAlgoDim = dim;
 736       break;
 737     }
 738   }
 739   bool checkNoAlgo = theMesh.HasShapeToMesh() ? bool( aTopAlgoDim ) : false;
 740   bool globalChecked[] = { false, false, false, false };
 741
 742   // loop on theShape and its sub-shapes
 743   aCheckedSubs.clear();
 744   revItSub = sm->getDependsOnIterator( /*includeSelf=*/true, /*complexShapeFirst=*/true);
 745   while ( revItSub->more() )
 746   {
 747     SMESH_subMesh* smToCheck = revItSub->next();
 748     if ( smToCheck->GetSubShape().ShapeType() == TopAbs_VERTEX)
 749       break;
 750
 751     if ( aCheckedSubs.insert( smToCheck ).second ) // not yet checked
 752       if (!checkMissing (this, theMesh, smToCheck, aTopAlgoDim,
 753                          globalChecked, checkNoAlgo, aCheckedSubs, theErrors))
 754       {
 755         ret = false;
 756         if (smToCheck->GetAlgoState() == SMESH_subMesh::NO_ALGO )
 757           checkNoAlgo = false;
 758       }
 759   }
 760
 761   if ( !hasAlgo ) {
 762     ret = false;
 763     INFOS( "None algorithm attached" );
 764     theErrors.push_back( TAlgoStateError() );
 765     theErrors.back().Set( SMESH_Hypothesis::HYP_MISSING, 1, true );
 766   }
 767
 768   return ret;
 769 }
 770
 771 //=======================================================================
 772 //function : IsGlobalHypothesis
 773 //purpose  : check if theAlgo is attached to the main shape
 774 //=======================================================================
 775
 776 bool SMESH_Gen::IsGlobalHypothesis(const SMESH_Hypothesis* theHyp, SMESH_Mesh& aMesh)
 777 {
 778   SMESH_HypoFilter filter( SMESH_HypoFilter::Is( theHyp ));
 779   return aMesh.GetHypothesis( aMesh.GetMeshDS()->ShapeToMesh(), filter, false );
 780 }
 781
 782 //=============================================================================
 783 /*!
 784  *
 785  */
 786 //=============================================================================
 787
 788 SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh &         aMesh,
 789                                const TopoDS_Shape & aShape,
 790                                TopoDS_Shape*        assignedTo)
 791 {
 792
 793   SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() );
 794   filter.And( filter.IsApplicableTo( aShape ));
 795
 796   return (SMESH_Algo*) aMesh.GetHypothesis( aShape, filter, true, assignedTo );
 797 }
 798
 799 //=============================================================================
 800 /*!
 801  *
 802  */
 803 //=============================================================================
 804
 805 StudyContextStruct *SMESH_Gen::GetStudyContext(int studyId)
 806 {
 807         // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
 808
 809         if (_mapStudyContext.find(studyId) == _mapStudyContext.end())
 810         {
 811                 _mapStudyContext[studyId] = new StudyContextStruct;
 812                 _mapStudyContext[studyId]->myDocument = new SMESHDS_Document(studyId);
 813         }
 814         StudyContextStruct *myStudyContext = _mapStudyContext[studyId];
 815 //   ASSERT(_mapStudyContext.find(studyId) != _mapStudyContext.end());
 816         return myStudyContext;
 817 }
 818
 819 // //=============================================================================
 820 // /*!
 821 //  *
 822 //  */
 823 // //=============================================================================
 824
 825 // void SMESH_Gen::Save(int studyId, const char *aUrlOfFile)
 826 // {
 827 // }
 828
 829 // //=============================================================================
 830 // /*!
 831 //  *
 832 //  */
 833 // //=============================================================================
 834
 835 // void SMESH_Gen::Load(int studyId, const char *aUrlOfFile)
 836 // {
 837 // }
 838
 839 // //=============================================================================
 840 // /*!
 841 //  *
 842 //  */
 843 // //=============================================================================
 844
 845 // void SMESH_Gen::Close(int studyId)
 846 // {
 847 // }
 848
 849 //=============================================================================
 850 /*!
 851  *
 852  */
 853 //=============================================================================
 854
 855 int SMESH_Gen::GetShapeDim(const TopAbs_ShapeEnum & aShapeType)
 856 {
 857   static vector<int> dim;
 858   if ( dim.empty() )
 859   {
 860     dim.resize( TopAbs_SHAPE, -1 );
 861     dim[ TopAbs_COMPOUND ]  = MeshDim_3D;
 862     dim[ TopAbs_COMPSOLID ] = MeshDim_3D;
 863     dim[ TopAbs_SOLID ]     = MeshDim_3D;
 864     dim[ TopAbs_SHELL ]     = MeshDim_3D;
 865     dim[ TopAbs_FACE  ]     = MeshDim_2D;
 866     dim[ TopAbs_WIRE ]      = MeshDim_1D;
 867     dim[ TopAbs_EDGE ]      = MeshDim_1D;
 868     dim[ TopAbs_VERTEX ]    = MeshDim_0D;
 869   }
 870   return dim[ aShapeType ];
 871 }
 872
 873 //=============================================================================
 874 /*!
 875  *
 876  */
 877 //=============================================================================
 878
 879 int SMESH_Gen::GetANewId()
 880 {
 881         //MESSAGE("SMESH_Gen::GetANewId");
 882         return _hypId++;
 883 }