+static bool checkConformIgnoredAlgos(SMESH_Mesh& aMesh,
+ SMESH_subMesh* aSubMesh,
+ const SMESH_Algo* aGlobIgnoAlgo,
+ const SMESH_Algo* aLocIgnoAlgo,
+ bool & checkConform,
+ map<int, SMESH_subMesh*>& aCheckedMap,
+ list< SMESH_Gen::TAlgoStateError > & theErrors)
+{
+ ASSERT( aSubMesh );
+ if ( aSubMesh->GetSubShape().ShapeType() == TopAbs_VERTEX)
+ return true;
+
+
+ bool ret = true;
+
+ const list<const SMESHDS_Hypothesis*>& listHyp =
+ aMesh.GetMeshDS()->GetHypothesis( aSubMesh->GetSubShape() );
+ list<const SMESHDS_Hypothesis*>::const_iterator it=listHyp.begin();
+ for ( ; it != listHyp.end(); it++)
+ {
+ const SMESHDS_Hypothesis * aHyp = *it;
+ if (aHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
+ continue;
+
+ const SMESH_Algo* algo = dynamic_cast<const SMESH_Algo*> (aHyp);
+ ASSERT ( algo );
+
+ if ( aLocIgnoAlgo ) // algo is hidden by a local algo of upper dim
+ {
+ INFOS( "Local <" << algo->GetName() << "> is hidden by local <"
+ << aLocIgnoAlgo->GetName() << ">");
+ }
+ else
+ {
+ bool isGlobal = (aMesh.IsMainShape( aSubMesh->GetSubShape() ));
+ int dim = algo->GetDim();
+ int aMaxGlobIgnoDim = ( aGlobIgnoAlgo ? aGlobIgnoAlgo->GetDim() : -1 );
+
+ if ( dim < aMaxGlobIgnoDim )
+ {
+ // algo is hidden by a global algo
+ INFOS( ( isGlobal ? "Global" : "Local" )
+ << " <" << algo->GetName() << "> is hidden by global <"
+ << aGlobIgnoAlgo->GetName() << ">");
+ }
+ else if ( !algo->NeedDescretBoundary() && !isGlobal)
+ {
+ // local algo is not hidden and hides algos on sub-shapes
+ if (checkConform && !aSubMesh->IsConform( algo ))
+ {
+ ret = false;
+ checkConform = false; // no more check conformity
+ INFOS( "ERROR: Local <" << algo->GetName() <<
+ "> would produce not conform mesh: "
+ "<Not Conform Mesh Allowed> hypotesis is missing");
+ theErrors.push_back( SMESH_Gen::TAlgoStateError() );
+ theErrors.back().Set( SMESH_Gen::NOT_CONFORM_MESH, algo, false );
+ }
+
+ // sub-algos will be hidden by a local <algo>
+ const map<int, SMESH_subMesh*>& smMap = aSubMesh->DependsOn();
+ map<int, SMESH_subMesh*>::const_reverse_iterator revItSub;
+ bool checkConform2 = false;
+ for ( revItSub = smMap.rbegin(); revItSub != smMap.rend(); revItSub++)
+ {
+ checkConformIgnoredAlgos (aMesh, (*revItSub).second, aGlobIgnoAlgo,
+ algo, checkConform2, aCheckedMap, theErrors);
+ int key = (*revItSub).first;
+ SMESH_subMesh* sm = (*revItSub).second;
+ if ( aCheckedMap.find( key ) == aCheckedMap.end() )
+ {
+ aCheckedMap[ key ] = sm;
+ }
+ }
+ }
+ }
+ }
+
+ return ret;
+}
+
+//=======================================================================
+//function : checkMissing
+//purpose : notify on missing hypothesis
+// Return false if algo or hipothesis is missing
+//=======================================================================
+
+static bool checkMissing(SMESH_Gen* aGen,
+ SMESH_Mesh& aMesh,
+ SMESH_subMesh* aSubMesh,
+ const int aTopAlgoDim,
+ bool* globalChecked,
+ const bool checkNoAlgo,
+ map<int, SMESH_subMesh*>& aCheckedMap,
+ list< SMESH_Gen::TAlgoStateError > & theErrors)
+{
+ if ( aSubMesh->GetSubShape().ShapeType() == TopAbs_VERTEX)
+ return true;
+
+ //MESSAGE("=====checkMissing");
+
+ int ret = true;
+ SMESH_Algo* algo = 0;
+
+ switch (aSubMesh->GetAlgoState())
+ {
+ case SMESH_subMesh::NO_ALGO: {
+ if (checkNoAlgo)
+ {
+ // should there be any algo?
+ int shapeDim = SMESH_Gen::GetShapeDim( aSubMesh->GetSubShape() );
+ if (aTopAlgoDim > shapeDim)
+ {
+ INFOS( "ERROR: " << shapeDim << "D algorithm is missing" );
+ ret = false;
+ theErrors.push_back( SMESH_Gen::TAlgoStateError() );
+ theErrors.back().Set( SMESH_Gen::MISSING_ALGO, shapeDim, true );
+ }
+ }
+ return ret;
+ }
+ case SMESH_subMesh::MISSING_HYP: {
+ // notify if an algo missing hyp is attached to aSubMesh
+ algo = aGen->GetAlgo( aMesh, aSubMesh->GetSubShape() );
+ ASSERT( algo );
+ bool IsGlobalHypothesis = aGen->IsGlobalHypothesis( algo, aMesh );
+ if (!IsGlobalHypothesis || !globalChecked[ algo->GetDim() ])
+ {
+ INFOS( "ERROR: " << (IsGlobalHypothesis ? "Global " : "Local ")
+ << "<" << algo->GetName() << "> misses some hypothesis");
+ if (IsGlobalHypothesis)
+ globalChecked[ algo->GetDim() ] = true;
+ theErrors.push_back( SMESH_Gen::TAlgoStateError() );
+ theErrors.back().Set( SMESH_Gen::MISSING_HYPO, algo, IsGlobalHypothesis );
+ }
+ ret = false;
+ break;
+ }
+ case SMESH_subMesh::HYP_OK:
+ algo = aGen->GetAlgo( aMesh, aSubMesh->GetSubShape() );
+ ret = true;
+ break;
+ default: ASSERT(0);
+ }
+
+ // do not check under algo that hides sub-algos or
+ // re-start checking NO_ALGO state
+ ASSERT (algo);
+ bool isTopLocalAlgo =
+ ( aTopAlgoDim <= algo->GetDim() && !aGen->IsGlobalHypothesis( algo, aMesh ));
+ if (!algo->NeedDescretBoundary() || isTopLocalAlgo)
+ {
+ bool checkNoAlgo2 = ( algo->NeedDescretBoundary() );
+ const map<int, SMESH_subMesh*>& subMeshes = aSubMesh->DependsOn();
+ map<int, SMESH_subMesh*>::const_iterator itsub;
+ for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++)
+ {
+ // sub-meshes should not be checked further more
+ int key = (*itsub).first;
+ SMESH_subMesh* sm = (*itsub).second;
+ if ( aCheckedMap.find( key ) == aCheckedMap.end() )
+ aCheckedMap[ key ] = sm;
+
+ if (isTopLocalAlgo)
+ {
+ //check algo on sub-meshes
+ int aTopAlgoDim2 = algo->GetDim();
+ if (!checkMissing (aGen, aMesh, sm, aTopAlgoDim2,
+ globalChecked, checkNoAlgo2, aCheckedMap, theErrors))
+ {
+ ret = false;
+ if (sm->GetAlgoState() == SMESH_subMesh::NO_ALGO )
+ checkNoAlgo2 = false;
+ }
+ }
+ }
+ }
+ return ret;
+}
+
+//=======================================================================
+//function : CheckAlgoState
+//purpose : notify on bad state of attached algos, return false
+// if Compute() would fail because of some algo bad state
+//=======================================================================
+
+bool SMESH_Gen::CheckAlgoState(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
+{
+ list< TAlgoStateError > errors;
+ return GetAlgoState( aMesh, aShape, errors );
+}
+
+//=======================================================================
+//function : GetAlgoState
+//purpose : notify on bad state of attached algos, return false
+// if Compute() would fail because of some algo bad state
+// theErrors list contains problems description
+//=======================================================================
+
+bool SMESH_Gen::GetAlgoState(SMESH_Mesh& theMesh,
+ const TopoDS_Shape& theShape,
+ list< TAlgoStateError > & theErrors)
+{
+ //MESSAGE("SMESH_Gen::CheckAlgoState");
+
+ bool ret = true;
+ bool hasAlgo = false;
+
+ SMESH_subMesh* sm = theMesh.GetSubMesh(theShape);
+ const SMESHDS_Mesh* meshDS = theMesh.GetMeshDS();
+ TopoDS_Shape mainShape = meshDS->ShapeToMesh();
+
+ // -----------------
+ // get global algos
+ // -----------------
+
+ const SMESH_Algo* aGlobAlgoArr[] = {0,0,0,0};
+
+ const list<const SMESHDS_Hypothesis*>& listHyp = meshDS->GetHypothesis( mainShape );
+ list<const SMESHDS_Hypothesis*>::const_iterator it=listHyp.begin();
+ for ( ; it != listHyp.end(); it++)
+ {
+ const SMESHDS_Hypothesis * aHyp = *it;
+ if (aHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
+ continue;
+
+ const SMESH_Algo* algo = dynamic_cast<const SMESH_Algo*> (aHyp);
+ ASSERT ( algo );
+
+ int dim = algo->GetDim();
+ aGlobAlgoArr[ dim ] = algo;
+
+ hasAlgo = true;
+ }
+
+ // --------------------------------------------------------
+ // info on algos that will be ignored because of ones that
+ // don't NeedDescretBoundary() attached to super-shapes,
+ // check that a conform mesh will be produced
+ // --------------------------------------------------------
+
+
+ // find a global algo possibly hidding sub-algos
+ int dim;
+ const SMESH_Algo* aGlobIgnoAlgo = 0;
+ for (dim = 3; dim > 0; dim--)
+ {
+ if (aGlobAlgoArr[ dim ] &&
+ !aGlobAlgoArr[ dim ]->NeedDescretBoundary())
+ {
+ aGlobIgnoAlgo = aGlobAlgoArr[ dim ];
+ break;
+ }
+ }
+
+ const map<int, SMESH_subMesh*>& smMap = sm->DependsOn();
+ map<int, SMESH_subMesh*>::const_reverse_iterator revItSub = smMap.rbegin();
+ map<int, SMESH_subMesh*> aCheckedMap;
+ bool checkConform = ( !theMesh.IsNotConformAllowed() );
+ int aKey = 1;
+ SMESH_subMesh* smToCheck = sm;
+
+ // loop on theShape and its sub-shapes
+ while ( smToCheck )
+ {
+ if ( smToCheck->GetSubShape().ShapeType() == TopAbs_VERTEX)
+ break;
+
+ if ( aCheckedMap.find( aKey ) == aCheckedMap.end() )
+ if (!checkConformIgnoredAlgos (theMesh, smToCheck, aGlobIgnoAlgo,
+ 0, checkConform, aCheckedMap, theErrors))
+ ret = false;
+
+ if ( smToCheck->GetAlgoState() != SMESH_subMesh::NO_ALGO )
+ hasAlgo = true;
+
+ // next subMesh
+ if (revItSub != smMap.rend())
+ {
+ aKey = (*revItSub).first;
+ smToCheck = (*revItSub).second;
+ revItSub++;
+ }
+ else
+ {
+ smToCheck = 0;
+ }
+
+ }
+
+ // ----------------------------------------------------------------
+ // info on missing hypothesis and find out if all needed algos are
+ // well defined
+ // ----------------------------------------------------------------
+
+ //MESSAGE( "---info on missing hypothesis and find out if all needed algos are");
+
+ // find max dim of global algo
+ int aTopAlgoDim = 0;
+ for (dim = 3; dim > 0; dim--)
+ {
+ if (aGlobAlgoArr[ dim ])
+ {
+ aTopAlgoDim = dim;
+ break;
+ }
+ }
+ aCheckedMap.clear();
+ smToCheck = sm;
+ revItSub = smMap.rbegin();
+ bool checkNoAlgo = (bool) aTopAlgoDim;
+ bool globalChecked[] = { false, false, false, false };
+
+ // loop on theShape and its sub-shapes
+ while ( smToCheck )
+ {
+ if ( smToCheck->GetSubShape().ShapeType() == TopAbs_VERTEX)
+ break;
+
+ if ( aCheckedMap.find( aKey ) == aCheckedMap.end() )
+ if (!checkMissing (this, theMesh, smToCheck, aTopAlgoDim,
+ globalChecked, checkNoAlgo, aCheckedMap, theErrors))
+ {
+ ret = false;
+ if (smToCheck->GetAlgoState() == SMESH_subMesh::NO_ALGO )
+ checkNoAlgo = false;
+ }
+
+ // next subMesh
+ if (revItSub != smMap.rend())
+ {
+ aKey = (*revItSub).first;
+ smToCheck = (*revItSub).second;
+ revItSub++;
+ }
+ else
+ smToCheck = 0;
+ }
+
+ if ( !hasAlgo ) {
+ ret = false;
+ INFOS( "None algorithm attached" );
+ theErrors.push_back( TAlgoStateError() );
+ theErrors.back().Set( MISSING_ALGO, 1, true );
+ }
+
+ return ret;
+}
+
+//=======================================================================
+//function : IsGlobalHypothesis
+//purpose : check if theAlgo is attached to the main shape
+//=======================================================================
+
+bool SMESH_Gen::IsGlobalHypothesis(const SMESH_Hypothesis* theHyp, SMESH_Mesh& aMesh)
+{
+ SMESH_HypoFilter filter( SMESH_HypoFilter::Is( theHyp ));
+ return aMesh.GetHypothesis( aMesh.GetMeshDS()->ShapeToMesh(), filter, false );