X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH%2FSMESH_subMesh.cxx;h=0b697d7a0b9eeaafb6d6a37a3cd2aa5898edfb5d;hb=HEAD;hp=38a44570802e1d6ee81e7a912518f4ff68123752;hpb=f050ab35304c662a16612e31b646529ed1be13a2;p=modules%2Fsmesh.git diff --git a/src/SMESH/SMESH_subMesh.cxx b/src/SMESH/SMESH_subMesh.cxx index 38a445708..18b6c3cdf 100644 --- a/src/SMESH/SMESH_subMesh.cxx +++ b/src/SMESH/SMESH_subMesh.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2024 CEA, EDF, OPEN CASCADE // // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS @@ -20,28 +20,26 @@ // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // -// SMESH SMESH : implementaion of SMESH idl descriptions +// SMESH SMESH : implementation of SMESH idl descriptions // File : SMESH_subMesh.cxx // Author : Paul RASCLE, EDF // Module : SMESH #include "SMESH_subMesh.hxx" +#include "SMDS_SetIterator.hxx" +#include "SMESHDS_Mesh.hxx" #include "SMESH_Algo.hxx" +#include "SMESH_Comment.hxx" #include "SMESH_Gen.hxx" #include "SMESH_HypoFilter.hxx" #include "SMESH_Hypothesis.hxx" #include "SMESH_Mesh.hxx" #include "SMESH_MesherHelper.hxx" #include "SMESH_subMeshEventListener.hxx" -#include "SMESH_Comment.hxx" -#include "SMDS_SetIterator.hxx" -#include "SMDSAbs_ElementType.hxx" - -#include +#include "SMESH_MeshLocker.hxx" #include "utilities.h" -#include "OpUtil.hxx" #include "Basics_Utils.hxx" #include @@ -63,6 +61,11 @@ using namespace std; +#ifdef _DEBUG_ +// enable printing algo + shape id + hypo used while meshing +#define PRINT_WHO_COMPUTE_WHAT +#endif + //============================================================================= /*! * \brief Allocate some memory at construction and release it at destruction. @@ -107,6 +110,7 @@ SMESH_subMesh::SMESH_subMesh(int Id, } _computeCost = 0; // how costly is to compute this sub-mesh _realComputeCost = 0; + _allowedSubShapes = nullptr; } //============================================================================= @@ -198,7 +202,7 @@ SMESH_Algo* SMESH_subMesh::GetAlgo() const if ( !_algo ) { SMESH_subMesh* me = const_cast< SMESH_subMesh* >( this ); - me->_algo = _father->GetGen()->GetAlgo( me ); + me->_algo = _father->GetGen()->GetAlgo( me, & me->_algoShape ); } return _algo; } @@ -241,7 +245,7 @@ bool SMESH_subMesh::IsMeshComputed() const { if ( _alwaysComputed ) return true; - // algo may bind a submesh not to _subShape, eg 3D algo + // algo may bind a sub-mesh not to _subShape, eg 3D algo // sets nodes on SHELL while _subShape may be SOLID SMESHDS_Mesh* meshDS = _father->GetMeshDS(); @@ -253,7 +257,7 @@ bool SMESH_subMesh::IsMeshComputed() const TopExp_Explorer exp( _subShape, (TopAbs_ShapeEnum) type ); for ( ; exp.More(); exp.Next() ) { - if ( SMESHDS_SubMesh * smDS = meshDS->MeshElements( exp.Current() )) + if ( SMESHDS_SubMesh * smDS = meshDS->MeshElements( exp.Current() ) ) { bool computed = (dim > 0) ? smDS->NbElements() : smDS->NbNodes(); if ( computed ) @@ -268,6 +272,42 @@ bool SMESH_subMesh::IsMeshComputed() const return false; } +//================================================================================ +/*! + * \brief Check if any upper level sub-shape is not computed. + * Used to update a sub-mesh icon + */ +//================================================================================ + +bool SMESH_subMesh::IsComputedPartially() const +{ + SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(/*includeSelf=*/true, + /*SolidFirst=*/true); + bool allComputed = true; + TopAbs_ShapeEnum readyType = TopAbs_VERTEX; // max value + while ( smIt->more() && allComputed ) + { + SMESH_subMesh* sm = smIt->next(); + + if ( sm->GetSubShape().ShapeType() > readyType ) + break; // lower dimension -> stop + if ( sm->GetComputeState() != SMESH_subMesh::NOT_READY ) + readyType = sm->GetSubShape().ShapeType(); + + switch ( sm->GetComputeState() ) + { + case SMESH_subMesh::READY_TO_COMPUTE: + case SMESH_subMesh::FAILED_TO_COMPUTE: + allComputed = false;// sm->IsMeshComputed(); + break; + case SMESH_subMesh::NOT_READY: + case SMESH_subMesh::COMPUTE_OK: + continue; + } + } + return !allComputed; +} + //============================================================================= /*! * Return true if all sub-meshes have been meshed @@ -280,7 +320,7 @@ bool SMESH_subMesh::SubMeshesComputed(bool * isFailedToCompute/*=0*/) const int dimToCheck = myDim - 1; bool subMeshesComputed = true; if ( isFailedToCompute ) *isFailedToCompute = false; - // check subMeshes with upper dimension => reverse iteration + // check sub-meshes with upper dimension => reverse iteration SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true); while ( smIt->more() ) { @@ -291,67 +331,22 @@ bool SMESH_subMesh::SubMeshesComputed(bool * isFailedToCompute/*=0*/) const // MSV 07.04.2006: restrict checking to myDim-1 only. Ex., there is no sense // in checking of existence of edges if the algo needs only faces. Moreover, - // degenerated edges may have no submesh, as after computing NETGEN_2D. + // degenerated edges may have no sub-mesh, as after computing NETGEN_2D. if ( !_algo || _algo->NeedDiscreteBoundary() ) { int dim = SMESH_Gen::GetShapeDim( ss ); if (dim < dimToCheck) - break; // the rest subMeshes are all of less dimension + break; // the rest sub-meshes are all of less dimension } SMESHDS_SubMesh * ds = sm->GetSubMeshDS(); - bool computeOk = (sm->GetComputeState() == COMPUTE_OK || - (ds && ( dimToCheck ? ds->NbElements() : ds->NbNodes() ))); + bool computeOk = ((sm->GetComputeState() == COMPUTE_OK ) || + (ds && ( dimToCheck ? ds->NbElements() : ds->NbNodes() ))); if (!computeOk) { subMeshesComputed = false; + if ( isFailedToCompute && !(*isFailedToCompute) ) *isFailedToCompute = ( sm->GetComputeState() == FAILED_TO_COMPUTE ); - // int type = ss.ShapeType(); - - // switch (type) - // { - // case TopAbs_COMPOUND: - // { - // MESSAGE("The not computed sub mesh is a COMPOUND"); - // break; - // } - // case TopAbs_COMPSOLID: - // { - // MESSAGE("The not computed sub mesh is a COMPSOLID"); - // break; - // } - // case TopAbs_SHELL: - // { - // MESSAGE("The not computed sub mesh is a SHEL"); - // break; - // } - // case TopAbs_WIRE: - // { - // MESSAGE("The not computed sub mesh is a WIRE"); - // break; - // } - // case TopAbs_SOLID: - // { - // MESSAGE("The not computed sub mesh is a SOLID"); - // break; - // } - // case TopAbs_FACE: - // { - // MESSAGE("The not computed sub mesh is a FACE"); - // break; - // } - // case TopAbs_EDGE: - // { - // MESSAGE("The not computed sub mesh is a EDGE"); - // break; - // } - // default: - // { - // MESSAGE("The not computed sub mesh is of unknown type"); - // break; - // } - // } - if ( !isFailedToCompute ) break; } @@ -407,7 +402,7 @@ int SMESH_subMesh::computeCost() const */ //============================================================================= -const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn() +const std::map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn() { if ( _dependenceAnalysed || !_father->HasShapeToMesh() ) return _mapDepend; @@ -533,7 +528,7 @@ const TopoDS_Shape & SMESH_subMesh::GetSubShape() const //======================================================================= //function : CanAddHypothesis //purpose : return true if theHypothesis can be attached to me: -// its dimention is checked +// its dimension is checked //======================================================================= bool SMESH_subMesh::CanAddHypothesis(const SMESH_Hypothesis* theHypothesis) const @@ -554,12 +549,25 @@ bool SMESH_subMesh::CanAddHypothesis(const SMESH_Hypothesis* theHypothesis) cons } //======================================================================= -//function : IsApplicableHypotesis -//purpose : +//function : IsApplicableHypothesis +//purpose : check if this sub-mesh can be computed using a hypothesis +//======================================================================= + +bool SMESH_subMesh::IsApplicableHypothesis(const SMESH_Hypothesis* theHypothesis) const +{ + if ( !_father->HasShapeToMesh() && _subShape.ShapeType() == TopAbs_SOLID ) + return true; // true for the PseudoShape + + return IsApplicableHypothesis( theHypothesis, _subShape.ShapeType() ); +} + +//======================================================================= +//function : IsApplicableHypothesis +//purpose : compare shape type and hypothesis type //======================================================================= -bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis, - const TopAbs_ShapeEnum theShapeType) +bool SMESH_subMesh::IsApplicableHypothesis(const SMESH_Hypothesis* theHypothesis, + const TopAbs_ShapeEnum theShapeType) { if ( theHypothesis->GetType() > SMESHDS_Hypothesis::PARAM_ALGO) { @@ -602,14 +610,14 @@ bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis, * \param [in] event - what happens * \param [in] anHyp - a hypothesis * \return SMESH_Hypothesis::Hypothesis_Status - a treatment result. - * + * * Optional description of a problematic situation (if any) can be retrieved * via GetComputeError(). */ //================================================================================ SMESH_Hypothesis::Hypothesis_Status - SMESH_subMesh::AlgoStateEngine(int event, SMESH_Hypothesis * anHyp) + SMESH_subMesh::AlgoStateEngine(algo_event event, SMESH_Hypothesis * anHyp) { // **** les retour des evenement shape sont significatifs // (add ou remove fait ou non) @@ -651,7 +659,7 @@ SMESH_Hypothesis::Hypothesis_Status bool modifiedHyp = (event == MODIF_HYP); // if set to true, force event MODIF_ALGO_STATE SMESH_Algo* algoRequiringCleaning = 0; - bool isApplicableHyp = IsApplicableHypotesis( anHyp ); + bool isApplicableHyp = IsApplicableHypothesis( anHyp ); if (event == ADD_ALGO || event == ADD_FATHER_ALGO) { @@ -673,7 +681,7 @@ SMESH_Hypothesis::Hypothesis_Status filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+1 )); filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+2 )); if ( SMESH_Algo * curAlgo = (SMESH_Algo*)_father->GetHypothesis( this, filter, true )) - if ( !curAlgo->NeedDiscreteBoundary() ) + if ( !curAlgo->NeedDiscreteBoundary() && curAlgo != anHyp ) algoRequiringCleaning = curAlgo; } } @@ -883,7 +891,10 @@ SMESH_Hypothesis::Hypothesis_Status ret = SMESH_Hypothesis::HYP_INCOMPATIBLE; } else if (!_father->IsUsedHypothesis( anHyp, this )) - ret = SMESH_Hypothesis::HYP_INCOMPATIBLE; + { + if ( anHyp->GetDim() == this->GetAlgo()->GetDim() ) + ret = SMESH_Hypothesis::HYP_INCOMPATIBLE; + } if (SMESH_Hypothesis::IsStatusFatal( ret )) { @@ -907,7 +918,10 @@ SMESH_Hypothesis::Hypothesis_Status const SMESH_Hypothesis * prevAlgo = _father->GetHypothesis( this, f, true ); if (prevAlgo && string( algo->GetName()) != prevAlgo->GetName()) - modifiedHyp = true; + { + oldAlgoState = NO_ALGO; // force setting event listener (#16648) + modifiedHyp = true; + } } else setAlgoState(MISSING_HYP); @@ -1023,8 +1037,8 @@ SMESH_Hypothesis::Hypothesis_Status // detect algorithm hiding // - if ( ret == SMESH_Hypothesis::HYP_OK && - ( event == ADD_ALGO || event == ADD_FATHER_ALGO ) && algo && + if ( ret == SMESH_Hypothesis::HYP_OK && + ( event == ADD_ALGO || event == ADD_FATHER_ALGO ) && algo && algo->GetName() == anHyp->GetName() ) { // is algo hidden? @@ -1101,7 +1115,7 @@ bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo) if ( !theAlgo ) return false; // Suppose that theAlgo is applicable to _subShape, do not check it here - //if ( !IsApplicableHypotesis( theAlgo )) return false; + //if ( !IsApplicableHypothesis( theAlgo )) return false; // check only algo that doesn't NeedDiscreteBoundary(): because mesh made // on a sub-shape will be ignored by theAlgo @@ -1167,7 +1181,7 @@ void SMESH_subMesh::setAlgoState(algo_state state) //================================================================================ SMESH_Hypothesis::Hypothesis_Status - SMESH_subMesh::SubMeshesAlgoStateEngine(int event, + SMESH_subMesh::SubMeshesAlgoStateEngine(algo_event event, SMESH_Hypothesis * anHyp, bool exitOnFatal) { @@ -1217,8 +1231,6 @@ void SMESH_subMesh::cleanDependsOn( SMESH_Algo* algoRequiringCleaning/*=0*/ ) } else if ( algoRequiringCleaning && algoRequiringCleaning->SupportSubmeshes() ) { - SMESHDS_Mesh* meshDS = _father->GetMeshDS(); - // find sub-meshes to keep elements on set< SMESH_subMesh* > smToKeep; TopAbs_ShapeEnum prevShapeType = TopAbs_SHAPE; @@ -1234,26 +1246,29 @@ void SMESH_subMesh::cleanDependsOn( SMESH_Algo* algoRequiringCleaning/*=0*/ ) if ( !sameShapeType ) { // check if the algo allows presence of global algos of dimension the algo - // can generate it-self + // can generate it-self; + // always keep a node on VERTEX, as this node can be shared by segments + // lying on EDGEs not shared by the VERTEX of sm, due to MergeNodes (PAL23068) int shapeDim = SMESH_Gen::GetShapeDim( sm->GetSubShape() ); - keepSubMeshes = algoRequiringCleaning->NeedLowerHyps( shapeDim ); + keepSubMeshes = ( algoRequiringCleaning->NeedLowerHyps( shapeDim ) || shapeDim == 0 ); prevShapeType = sm->GetSubShape().ShapeType(); toKeepPrevShapeType = keepSubMeshes; } if ( !keepSubMeshes ) { - // look for an algo assigned to sm - bool algoFound = false; - const list& hyps = meshDS->GetHypothesis( sm->_subShape ); - list::const_iterator h = hyps.begin(); - for ( ; ( !algoFound && h != hyps.end() ); ++h ) - algoFound = ((*h)->GetType() != SMESHDS_Hypothesis::PARAM_ALGO ); - keepSubMeshes = algoFound; + // look for a local algo used to mesh sm + TopoDS_Shape algoShape = SMESH_MesherHelper::GetShapeOfHypothesis + ( algoRequiringCleaning, _subShape, _father ); + SMESH_HypoFilter moreLocalAlgo; + moreLocalAlgo.Init( SMESH_HypoFilter::IsMoreLocalThan( algoShape, *_father )); + moreLocalAlgo.And ( SMESH_HypoFilter::IsAlgo() ); + bool localAlgoFound = _father->GetHypothesis( sm->_subShape, moreLocalAlgo, true ); + keepSubMeshes = localAlgoFound; } // remember all sub-meshes of sm if ( keepSubMeshes ) { - SMESH_subMeshIteratorPtr smIt2 = getDependsOnIterator(false); + SMESH_subMeshIteratorPtr smIt2 = sm->getDependsOnIterator(true); while ( smIt2->more() ) smToKeep.insert( smIt2->next() ); } @@ -1316,25 +1331,24 @@ void SMESH_subMesh::DumpAlgoState(bool isMain) static void cleanSubMesh( SMESH_subMesh * subMesh ) { if (subMesh) { - if (SMESHDS_SubMesh * subMeshDS = subMesh->GetSubMeshDS()) { + if (SMESHDS_SubMesh * subMeshDS = subMesh->GetSubMeshDS()) + { SMESHDS_Mesh * meshDS = subMesh->GetFather()->GetMeshDS(); - SMDS_ElemIteratorPtr ite = subMeshDS->GetElements(); - while (ite->more()) { - const SMDS_MeshElement * elt = ite->next(); - //MESSAGE( " RM elt: "<GetID()<<" ( "<NbNodes()<<" )" ); - //meshDS->RemoveElement(elt); - meshDS->RemoveFreeElement(elt, 0); - } - - SMDS_NodeIteratorPtr itn = subMeshDS->GetNodes(); - while (itn->more()) { - const SMDS_MeshNode * node = itn->next(); - //MESSAGE( " RM node: "<GetID()); - if ( node->NbInverseElements() == 0 ) - meshDS->RemoveFreeNode(node, 0); - else // for StdMeshers_CompositeSegment_1D: node in one submesh, edge in another - meshDS->RemoveNode(node); - } + smIdType nbElems = subMeshDS->NbElements(); + if ( nbElems > 0 ) + for ( SMDS_ElemIteratorPtr ite = subMeshDS->GetElements(); ite->more(); ) + meshDS->RemoveFreeElement( ite->next(), subMeshDS ); + + smIdType nbNodes = subMeshDS->NbNodes(); + if ( nbNodes > 0 ) + for ( SMDS_NodeIteratorPtr itn = subMeshDS->GetNodes(); itn->more() ; ) + { + const SMDS_MeshNode * node = itn->next(); + if ( node->NbInverseElements() == 0 ) + meshDS->RemoveFreeNode( node, subMeshDS ); + else // for StdMeshers_CompositeSegment_1D: node in one submesh, edge in another + meshDS->RemoveNode( node ); + } subMeshDS->Clear(); } } @@ -1346,7 +1360,7 @@ static void cleanSubMesh( SMESH_subMesh * subMesh ) */ //============================================================================= -bool SMESH_subMesh::ComputeStateEngine(int event) +bool SMESH_subMesh::ComputeStateEngine(compute_event event) { switch ( event ) { case MODIF_ALGO_STATE: @@ -1382,6 +1396,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event) else if (( event == COMPUTE || event == COMPUTE_SUBMESH ) && !_alwaysComputed ) { + SMESH_MeshLocker myLocker(_father); const TopoDS_Vertex & V = TopoDS::Vertex( _subShape ); gp_Pnt P = BRep_Tool::Pnt(V); if ( SMDS_MeshNode * n = _father->GetMeshDS()->AddNode(P.X(), P.Y(), P.Z()) ) { @@ -1434,6 +1449,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event) loadDependentMeshes(); ComputeSubMeshStateEngine( SUBMESH_LOADED ); //break; + // fall through case CHECK_COMPUTE_STATE: if ( IsMeshComputed() ) _computeState = COMPUTE_OK; @@ -1460,6 +1476,32 @@ bool SMESH_subMesh::ComputeStateEngine(int event) _computeState = READY_TO_COMPUTE; } break; + + case COMPUTE_NOGEOM: // no geometry; can be several algos + if ( !_father->HasShapeToMesh() ) + { + algo = GetAlgo(); // current algo + if ( algo ) + { + // apply algos in the order of increasing dimension + std::list< const SMESHDS_Hypothesis * > algos = _father->GetHypothesisList( _subShape ); + for ( int t = SMESHDS_Hypothesis::ALGO_1D; t <= SMESHDS_Hypothesis::ALGO_3D; ++t ) + { + std::list::iterator al = algos.begin(); + for ( ; al != algos.end(); ++al ) + if ( (*al)->GetType() == t ) + { + _algo = (SMESH_Algo*) *al; + _computeState = READY_TO_COMPUTE; + if ( !ComputeStateEngine( COMPUTE )) + break; + } + } + _algo = algo; // restore + } + break; + } + // fall through case COMPUTE: case COMPUTE_SUBMESH: { @@ -1474,16 +1516,21 @@ bool SMESH_subMesh::ComputeStateEngine(int event) break; } TopoDS_Shape shape = _subShape; - algo->SubMeshesToCompute().assign( 1, this ); + algo->setSubMeshesToCompute(this); // check submeshes needed - if (_father->HasShapeToMesh() ) { + // When computing in parallel mode we do not have a additional layer of submesh + // The check should not be done in parallel as that check is not thread-safe + if (_father->HasShapeToMesh() && (!_father->IsParallel() || shape.ShapeType() != _father->GetParallelElement() )) { bool subComputed = false, subFailed = false; if (!algo->OnlyUnaryInput()) { - if ( event == COMPUTE /*&& - ( algo->NeedDiscreteBoundary() || algo->SupportSubmeshes() )*/) - shape = getCollection( gen, algo, subComputed, subFailed, algo->SubMeshesToCompute()); - else - subComputed = SubMeshesComputed( & subFailed ); + // --- commented for bos#22320 to compute all sub-shapes at once if possible; + // --- in case COMPUTE_SUBMESH, set of sub-shapes is limited + // --- by calling SetAllowedSubShapes() + // if ( event == COMPUTE ) + // shape = getCollection( gen, algo, subComputed, subFailed, algo->SubMeshesToComput; + // else + // subComputed = SubMeshesComputed( & subFailed ); + shape = getCollection( gen, algo, subComputed, subFailed, algo->SubMeshesToCompute()); } else { subComputed = SubMeshesComputed(); @@ -1535,7 +1582,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event) _computeError = SMESH_ComputeError::Worst( _computeError, algo->GetComputeError() ); } catch ( ::SMESH_ComputeError& comperr ) { - cout << " SMESH_ComputeError caught" << endl; + MESSAGE(" SMESH_ComputeError caught"); if ( !_computeError ) _computeError = SMESH_ComputeError::New(); *_computeError = comperr; } @@ -1543,7 +1590,6 @@ bool SMESH_subMesh::ComputeStateEngine(int event) MESSAGE("std::bad_alloc thrown inside algo->Compute()"); if ( _computeError ) { _computeError->myName = COMPERR_MEMORY_PB; - //_computeError->myComment = exc.what(); } cleanSubMesh( this ); throw exc; @@ -1552,7 +1598,6 @@ bool SMESH_subMesh::ComputeStateEngine(int event) MESSAGE("Standard_OutOfMemory thrown inside algo->Compute()"); if ( _computeError ) { _computeError->myName = COMPERR_MEMORY_PB; - //_computeError->myComment = exc.what(); } cleanSubMesh( this ); throw std::bad_alloc(); @@ -1593,7 +1638,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event) ret = false; // check if anything was built TopExp_Explorer subS(shape, _subShape.ShapeType()); - if (ret) + if ( ret ) { for (; ret && subS.More(); subS.Next()) if ( !_father->GetSubMesh( subS.Current() )->IsMeshComputed() && @@ -1601,10 +1646,29 @@ bool SMESH_subMesh::ComputeStateEngine(int event) !algo->isDegenerated( TopoDS::Edge( subS.Current() )))) ret = false; } +#ifdef PRINT_WHO_COMPUTE_WHAT + for (subS.ReInit(); subS.More(); subS.Next()) + { + SMESH_MeshLocker myLocker(_father); + const std::list & hyps = + _algo->GetUsedHypothesis( *_father, _subShape ); + SMESH_Comment hypStr; + if ( !hyps.empty() ) + { + hypStr << hyps.front()->GetName() << " "; + ((SMESHDS_Hypothesis*)hyps.front())->SaveTo( hypStr.Stream() ); + hypStr << " "; + } + cout << _father->GetSubMesh( subS.Current() )->GetId() + << " " << ( ret ? "OK" : "FAIL" ) + << " " << _algo->GetName() + << " " << hypStr << endl; + } +#endif // Set _computeError - if (!ret && !isComputeErrorSet) + if ( !ret && !isComputeErrorSet ) { - for (subS.ReInit(); subS.More(); subS.Next()) + for ( subS.ReInit(); subS.More(); subS.Next() ) { SMESH_subMesh* sm = _father->GetSubMesh( subS.Current() ); if ( !sm->IsMeshComputed() ) @@ -1618,11 +1682,41 @@ bool SMESH_subMesh::ComputeStateEngine(int event) } } } - if (ret && _computeError && _computeError->myName != COMPERR_WARNING ) + if ( ret && _computeError && _computeError->myName != COMPERR_WARNING ) { _computeError.reset(); } + // transform errors into warnings if it is caused by mesh edition (imp 0023068) + if (!ret && _father->GetIsModified() ) + { + for (subS.ReInit(); subS.More(); subS.Next()) + { + SMESH_subMesh* sm = _father->GetSubMesh( subS.Current() ); + if ( !sm->IsMeshComputed() && sm->_computeError ) + { + // check if there is a VERTEX w/o nodes + // with READY_TO_COMPUTE state (after MergeNodes()) + SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(false,false); + while ( smIt->more() ) + { + SMESH_subMesh * vertSM = smIt->next(); + if ( vertSM->_subShape.ShapeType() != TopAbs_VERTEX ) break; + if ( vertSM->GetComputeState() == READY_TO_COMPUTE ) + { + SMESHDS_SubMesh * ds = vertSM->GetSubMeshDS(); + if ( !ds || ds->NbNodes() == 0 ) + { + sm->_computeState = READY_TO_COMPUTE; + sm->_computeError->myName = COMPERR_WARNING; + break; + } + } + } + } + } + } + // send event SUBMESH_COMPUTED if ( ret ) { if ( !algo->NeedDiscreteBoundary() ) @@ -1642,6 +1736,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event) else updateDependantsState( SUBMESH_COMPUTED ); } + // let algo clear its data gathered while algo->Compute() + algo->CheckHypothesis((*_father), _subShape, hyp_status); } break; case COMPUTE_CANCELED: // nothing to do @@ -1676,6 +1772,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event) loadDependentMeshes(); ComputeSubMeshStateEngine( SUBMESH_LOADED ); //break; + // fall through case CHECK_COMPUTE_STATE: if ( IsMeshComputed() ) _computeState = COMPUTE_OK; @@ -1701,10 +1798,12 @@ bool SMESH_subMesh::ComputeStateEngine(int event) break; case COMPUTE: // nothing to do break; + case COMPUTE_SUBMESH: // nothing to do + break; case COMPUTE_CANCELED: // nothing to do break; case CLEAN: - cleanDependants(); // clean sub-meshes, dependant on this one, with event CLEAN + cleanDependants(); // clean sub-meshes, dependent on this one, with event CLEAN removeSubMeshElementsAndNodes(); _computeState = NOT_READY; if ( _algoState == HYP_OK ) @@ -1825,7 +1924,7 @@ bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap) bool ret = true; if (_subShape.ShapeType() == TopAbs_VERTEX) { - vector aVec(SMDSEntity_Last,0); + vector aVec(SMDSEntity_Last,0); aVec[SMDSEntity_Node] = 1; aResMap.insert(make_pair(this,aVec)); return ret; @@ -1852,7 +1951,7 @@ bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap) SMESH_subMesh* sm = smIt->next(); int dim = SMESH_Gen::GetShapeDim( sm->GetSubShape() ); if (dim < dimToCheck) break; // the rest subMeshes are all of less dimension - const vector & nbs = aResMap[ sm ]; + const vector & nbs = aResMap[ sm ]; subMeshEvaluated = (std::accumulate( nbs.begin(), nbs.end(), 0 ) > 0 ); } if ( !subMeshEvaluated ) @@ -1862,7 +1961,7 @@ bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap) if ( IsMeshComputed() ) { - vector & nbEntities = aResMap[ this ]; + vector & nbEntities = aResMap[ this ]; nbEntities.resize( SMDSEntity_Last, 0 ); if ( SMESHDS_SubMesh* sm = GetSubMeshDS() ) { @@ -1876,7 +1975,7 @@ bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap) { ret = algo->Evaluate((*_father), _subShape, aResMap); } - aResMap.insert( make_pair( this,vector(0))); + aResMap.insert( make_pair( this,vector(0))); } return ret; @@ -1983,7 +2082,7 @@ void SMESH_subMesh::updateSubMeshState(const compute_state theState) //purpose : //======================================================================= -void SMESH_subMesh::ComputeSubMeshStateEngine(int event, const bool includeSelf) +void SMESH_subMesh::ComputeSubMeshStateEngine(compute_event event, const bool includeSelf) { SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(includeSelf,false); while ( smIt->more() ) @@ -2006,7 +2105,7 @@ void SMESH_subMesh::updateDependantsState(const compute_event theEvent) //======================================================================= //function : cleanDependants -//purpose : +//purpose : //======================================================================= void SMESH_subMesh::cleanDependants() @@ -2030,7 +2129,7 @@ void SMESH_subMesh::cleanDependants() //======================================================================= //function : removeSubMeshElementsAndNodes -//purpose : +//purpose : //======================================================================= void SMESH_subMesh::removeSubMeshElementsAndNodes() @@ -2060,7 +2159,7 @@ void SMESH_subMesh::removeSubMeshElementsAndNodes() // meshed at once along with _subShape //======================================================================= -TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen, +TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * /*theGen*/, SMESH_Algo* theAlgo, bool & theSubComputed, bool & theSubFailed, @@ -2074,8 +2173,9 @@ TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen, return _subShape; const bool skipAuxHyps = false; - list aUsedHyp = + list usedHyps = theAlgo->GetUsedHypothesis( *_father, _subShape, skipAuxHyps ); // copy + std::list < TopoDS_Shape > assiShapes = theAlgo->GetAssignedShapes(); // put in a compound all shapes with the same hypothesis assigned // and a good ComputeState @@ -2091,27 +2191,36 @@ TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen, { SMESH_subMesh* subMesh = smIt->next(); const TopoDS_Shape& S = subMesh->_subShape; - if ( S.ShapeType() != this->_subShape.ShapeType() ) + + if ( S.ShapeType() != this->_subShape.ShapeType() ){ continue; - theSubs.push_back( subMesh ); + } + if ( _allowedSubShapes && !_allowedSubShapes->IsEmpty() && !_allowedSubShapes->Contains( S )){ + continue; + } if ( subMesh == this ) { aBuilder.Add( aCompound, S ); + theSubs.push_back( subMesh ); } else if ( subMesh->GetComputeState() == READY_TO_COMPUTE ) { SMESH_Algo* anAlgo = subMesh->GetAlgo(); + if (( anAlgo->IsSameName( *theAlgo )) && // same algo - ( anAlgo->GetUsedHypothesis( *_father, S, skipAuxHyps ) == aUsedHyp )) // same hyps + ( anAlgo->GetUsedHypothesis( *_father, S, skipAuxHyps ) == usedHyps ) && // same hyps + ( anAlgo->GetAssignedShapes() == assiShapes ) && // on same sub-shapes + ( _algoShape == subMesh->_algoShape )) { aBuilder.Add( aCompound, S ); if ( !subMesh->SubMeshesComputed() ) theSubComputed = false; + theSubs.push_back( subMesh ); } } } - return aCompound; + return theSubs.size() == 1 ? theSubs[0]->GetSubShape() : aCompound; } //======================================================================= @@ -2144,18 +2253,16 @@ const SMESH_Hypothesis* SMESH_subMesh::getSimilarAttached(const TopoDS_Shape& } //======================================================================= -//function : CheckConcurentHypothesis +//function : CheckConcurrentHypothesis //purpose : check if there are several applicable hypothesis attached to // ancestors //======================================================================= SMESH_Hypothesis::Hypothesis_Status - SMESH_subMesh::CheckConcurentHypothesis (const int theHypType) + SMESH_subMesh::CheckConcurrentHypothesis( SMESH_Hypothesis* theHypothesis) { - MESSAGE ("SMESH_subMesh::CheckConcurentHypothesis"); - // is there local hypothesis on me? - if ( getSimilarAttached( _subShape, 0, theHypType ) ) + if ( getSimilarAttached( _subShape, theHypothesis ) ) return SMESH_Hypothesis::HYP_OK; @@ -2165,7 +2272,7 @@ SMESH_Hypothesis::Hypothesis_Status for (; it.More(); it.Next()) { const TopoDS_Shape& ancestor = it.Value(); - const SMESH_Hypothesis* hyp = getSimilarAttached( ancestor, 0, theHypType ); + const SMESH_Hypothesis* hyp = getSimilarAttached( ancestor, theHypothesis ); if ( hyp ) { if ( aPrevWithHyp.IsNull() || aPrevWithHyp.IsSame( ancestor )) @@ -2174,7 +2281,7 @@ SMESH_Hypothesis::Hypothesis_Status aPrevHyp = hyp; } else if ( aPrevWithHyp.ShapeType() == ancestor.ShapeType() && aPrevHyp != hyp ) - return SMESH_Hypothesis::HYP_CONCURENT; + return SMESH_Hypothesis::HYP_CONCURRENT; else return SMESH_Hypothesis::HYP_OK; } @@ -2202,7 +2309,7 @@ SMESH_subMesh::OwnListenerData::OwnListenerData( SMESH_subMesh* sm, EventListene * \param listener - the listener to store * \param data - the listener data to store * \param where - the submesh to store the listener and it's data - * + * * It remembers the submesh where it puts the listener in order to delete * them when HYP_OK algo_state is lost * After being set, event listener is notified on each event of where submesh. @@ -2224,7 +2331,7 @@ void SMESH_subMesh::SetEventListener(EventListener* listener, * \brief Sets an event listener and its data to a submesh * \param listener - the listener to store * \param data - the listener data to store - * + * * After being set, event listener is notified on each event of a submesh. */ //================================================================================ @@ -2236,9 +2343,9 @@ void SMESH_subMesh::setEventListener(EventListener* listener, _eventListeners.find( listener ); if ( l_d != _eventListeners.end() ) { EventListenerData* curData = l_d->second; + l_d->second = data; if ( curData && curData != data && curData->IsDeletable() ) delete curData; - l_d->second = data; } else { @@ -2246,6 +2353,7 @@ void SMESH_subMesh::setEventListener(EventListener* listener, if ( listener->GetName() == l_d->first->GetName() ) { EventListenerData* curData = l_d->second; + l_d->second = 0; if ( curData && curData != data && curData->IsDeletable() ) delete curData; if ( l_d->first != listener && l_d->first->IsDeletable() ) @@ -2323,7 +2431,7 @@ EventListenerData* SMESH_subMesh::GetEventListenerData(const string& listenerNam //================================================================================ /*! - * \brief Notify stored event listeners on the occured event + * \brief Notify stored event listeners on the occurred event * \param event - algo_event or compute_event itself * \param eventType - algo_event or compute_event * \param hyp - hypothesis, if eventType is algo_event @@ -2409,7 +2517,8 @@ void SMESH_subMesh::loadDependentMeshes() { list< OwnListenerData >::iterator d; for ( d = _ownListeners.begin(); d != _ownListeners.end(); ++d ) - if ( _father != d->mySubMesh->_father ) + if ( _father != d->mySubMesh->_father && + _father->FindMesh( d->myMeshID )) d->mySubMesh->_father->Load(); // map< EventListener*, EventListenerData* >::iterator l_d = _eventListeners.begin(); @@ -2429,10 +2538,10 @@ void SMESH_subMesh::loadDependentMeshes() * \brief Do something on a certain event * \param event - algo_event or compute_event itself * \param eventType - algo_event or compute_event - * \param subMesh - the submesh where the event occures + * \param subMesh - the submesh where the event occurs * \param data - listener data stored in the subMesh * \param hyp - hypothesis, if eventType is algo_event - * + * * The base implementation translates CLEAN event to the subMesh * stored in listener data. Also it sends SUBMESH_COMPUTED event in case of * successful COMPUTE event. @@ -2454,7 +2563,7 @@ void SMESH_subMeshEventListener::ProcessEvent(const int event, switch ( event ) { case SMESH_subMesh::CLEAN: for ( ; smIt != smEnd; ++ smIt) - (*smIt)->ComputeStateEngine( event ); + (*smIt)->ComputeStateEngine( SMESH_subMesh::compute_event( event )); break; case SMESH_subMesh::COMPUTE: case SMESH_subMesh::COMPUTE_SUBMESH: @@ -2508,9 +2617,9 @@ namespace { //================================================================================ /*! - * \brief Return iterator on the submeshes this one depends on - * \param includeSelf - this submesh to be returned also - * \param reverse - if true, complex shape submeshes go first + * \brief Return iterator on the submeshes this one depends on + * \param includeSelf - this submesh to be returned also + * \param reverse - if true, complex shape submeshes go first */ //================================================================================ @@ -2551,8 +2660,13 @@ const std::vector< SMESH_subMesh * > & SMESH_subMesh::GetAncestors() const SMESH_subMesh* me = const_cast< SMESH_subMesh* >( this ); me->_ancestors.reserve( ancShapes.Extent() ); + // assure that all sub-meshes exist + TopoDS_Shape mainShape = _father->GetShapeToMesh(); + if ( !mainShape.IsNull() ) + _father->GetSubMesh( mainShape )->DependsOn(); + TopTools_MapOfShape map; - + for ( TopTools_ListIteratorOfListOfShape it( ancShapes ); it.More(); it.Next() ) if ( SMESH_subMesh* sm = _father->GetSubMeshContaining( it.Value() )) if ( map.Add( it.Value() ))