ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-29 19:00:35 +05:00
Code Issues Packages Projects Releases Wiki Activity

0022124: [CEA 763] Projection 1D does not work with Netgen 1D2D

Browse Source 
Do not call algo->Compute() if !algo->NeedDiscreteBoundary() and
  computing a sub-mesh of the current sub-mesh already failed.
This commit is contained in:
eap 2013-02-19 12:04:39 +00:00
parent 3060a379b0
commit 9c8fdf5101
1 changed files with 89 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

168
src/SMESH/SMESH_subMesh.cxx
View File

@ -88,22 +88,22 @@ SMESH_subMesh::SMESH_subMesh(int Id,
SMESHDS_Mesh * meshDS, SMESHDS_Mesh * meshDS,
const TopoDS_Shape & aSubShape) const TopoDS_Shape & aSubShape)
{ {
_subShape = aSubShape; _subShape = aSubShape;
_subMeshDS = meshDS->MeshElements(_subShape); // may be null ... _subMeshDS = meshDS->MeshElements(_subShape); // may be null ...
_father = father; _father = father;
_Id = Id; _Id = Id;
_dependenceAnalysed = _alwaysComputed = false; _dependenceAnalysed = _alwaysComputed = false;
_algo = 0;
if (_subShape.ShapeType() == TopAbs_VERTEX) if (_subShape.ShapeType() == TopAbs_VERTEX)
{ {
_algoState = HYP_OK; _algoState = HYP_OK;
_computeState = READY_TO_COMPUTE; _computeState = READY_TO_COMPUTE;
} }
else else
{ {
_algoState = NO_ALGO; _algoState = NO_ALGO;
_computeState = NOT_READY; _computeState = NOT_READY;
} }
} }
//============================================================================= //=============================================================================
@ -194,7 +194,9 @@ SMESH_subMesh *SMESH_subMesh::GetFirstToCompute()
SMESH_Algo* SMESH_subMesh::GetAlgo() const SMESH_Algo* SMESH_subMesh::GetAlgo() const
{ {
return _father->GetGen()->GetAlgo(*_father, _subShape); if ( !_algo )
((SMESH_subMesh*)this)->_algo = _father->GetGen()->GetAlgo(*_father, _subShape);
return _algo;
} }
//================================================================================ //================================================================================
@ -268,11 +270,12 @@ bool SMESH_subMesh::IsMeshComputed() const
*/ */
//============================================================================= //=============================================================================
bool SMESH_subMesh::SubMeshesComputed() const bool SMESH_subMesh::SubMeshesComputed(bool * isFailedToCompute/*=0*/) const
{ {
int myDim = SMESH_Gen::GetShapeDim( _subShape ); int myDim = SMESH_Gen::GetShapeDim( _subShape );
int dimToCheck = myDim - 1; int dimToCheck = myDim - 1;
bool subMeshesComputed = true; bool subMeshesComputed = true;
if ( isFailedToCompute ) *isFailedToCompute = false;
// check subMeshes with upper dimension => reverse iteration // check subMeshes with upper dimension => reverse iteration
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true); SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true);
while ( smIt->more() ) while ( smIt->more() )
@ -281,66 +284,72 @@ bool SMESH_subMesh::SubMeshesComputed() const
if ( sm->_alwaysComputed ) if ( sm->_alwaysComputed )
continue; continue;
const TopoDS_Shape & ss = sm->GetSubShape(); const TopoDS_Shape & ss = sm->GetSubShape();
// MSV 07.04.2006: restrict checking to myDim-1 only. Ex., there is no sense // 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, // 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 submesh, as after computing NETGEN_2D.
int dim = SMESH_Gen::GetShapeDim( ss ); if ( !_algo || _algo->NeedDiscreteBoundary() ) {
if (dim < dimToCheck) int dim = SMESH_Gen::GetShapeDim( ss );
break; // the rest subMeshes are all of less dimension if (dim < dimToCheck)
break; // the rest subMeshes are all of less dimension
}
SMESHDS_SubMesh * ds = sm->GetSubMeshDS(); SMESHDS_SubMesh * ds = sm->GetSubMeshDS();
bool computeOk = (sm->GetComputeState() == COMPUTE_OK || bool computeOk = (sm->GetComputeState() == COMPUTE_OK ||
(ds && ( dimToCheck ? ds->NbElements() : ds->NbNodes() ))); (ds && ( dimToCheck ? ds->NbElements() : ds->NbNodes() )));
if (!computeOk) if (!computeOk)
{ {
int type = ss.ShapeType();
subMeshesComputed = false; subMeshesComputed = false;
if ( isFailedToCompute && !(*isFailedToCompute) )
*isFailedToCompute = ( sm->GetComputeState() == FAILED_TO_COMPUTE );
switch (type) // int type = ss.ShapeType();
{
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;
}
}
break; // 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;
} }
} }
return subMeshesComputed; return subMeshesComputed;
@ -609,6 +618,7 @@ SMESH_Hypothesis::Hypothesis_Status
SMESHDS_Mesh* meshDS =_father->GetMeshDS(); SMESHDS_Mesh* meshDS =_father->GetMeshDS();
SMESH_Algo* algo = 0; SMESH_Algo* algo = 0;
_algo = 0;
if (_subShape.ShapeType() == TopAbs_VERTEX ) if (_subShape.ShapeType() == TopAbs_VERTEX )
{ {
@ -1323,10 +1333,6 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
default:; default:;
} }
//MESSAGE("SMESH_subMesh::ComputeStateEngine");
//SCRUTE(_computeState);
//SCRUTE(event);
if (_subShape.ShapeType() == TopAbs_VERTEX) if (_subShape.ShapeType() == TopAbs_VERTEX)
{ {
_computeState = READY_TO_COMPUTE; _computeState = READY_TO_COMPUTE;
@ -1434,21 +1440,22 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
TopoDS_Shape shape = _subShape; TopoDS_Shape shape = _subShape;
// check submeshes needed // check submeshes needed
if (_father->HasShapeToMesh() ) { if (_father->HasShapeToMesh() ) {
bool subComputed = false; bool subComputed = false, subFailed = false;
if (!algo->OnlyUnaryInput()) if (!algo->OnlyUnaryInput())
shape = getCollection( gen, algo, subComputed ); shape = getCollection( gen, algo, subComputed, subFailed );
else else
subComputed = SubMeshesComputed(); subComputed = SubMeshesComputed();
ret = ( algo->NeedDiscreteBoundary() ? subComputed : ret = ( algo->NeedDiscreteBoundary() ? subComputed :
algo->SupportSubmeshes() ? true : algo->SupportSubmeshes() ? !subFailed :
( !subComputed || _father->IsNotConformAllowed() )); ( !subComputed || _father->IsNotConformAllowed() ));
if (!ret) { if (!ret)
{
_computeState = FAILED_TO_COMPUTE; _computeState = FAILED_TO_COMPUTE;
if ( !algo->NeedDiscreteBoundary() ) if ( !algo->NeedDiscreteBoundary() && !subFailed )
_computeError = _computeError =
SMESH_ComputeError::New(COMPERR_BAD_INPUT_MESH, SMESH_ComputeError::New(COMPERR_BAD_INPUT_MESH,
"Unexpected computed submesh",algo); "Unexpected computed submesh",algo);
break; break; // goto exit
} }
} }
// Compute // Compute
@ -1534,6 +1541,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
} }
// check if an error reported on any sub-shape // check if an error reported on any sub-shape
bool isComputeErrorSet = !checkComputeError( algo, ret, shape ); bool isComputeErrorSet = !checkComputeError( algo, ret, shape );
if ( isComputeErrorSet )
ret = false;
// check if anything was built // check if anything was built
TopExp_Explorer subS(shape, _subShape.ShapeType()); TopExp_Explorer subS(shape, _subShape.ShapeType());
if (ret) if (ret)
@ -1991,9 +2000,10 @@ void SMESH_subMesh::removeSubMeshElementsAndNodes()
TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen, TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen,
SMESH_Algo* theAlgo, SMESH_Algo* theAlgo,
bool & theSubComputed) bool & theSubComputed,
bool & theSubFailed)
{ {
theSubComputed = SubMeshesComputed(); theSubComputed = SubMeshesComputed( & theSubFailed );
TopoDS_Shape mainShape = _father->GetMeshDS()->ShapeToMesh(); TopoDS_Shape mainShape = _father->GetMeshDS()->ShapeToMesh();