ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-24 03:20:33 +05:00
Code Issues Packages Projects Releases Wiki Activity

#20282 EDF 22320 - general compute fails

Browse Source 
don't apply 1D-2D algorithms before 1D-2D-3D ones if sub-mesh order says opposite
This commit is contained in:
eap 2020-12-14 16:41:04 +03:00
parent fba6d9eef3
commit 223210ad12
5 changed files with 49 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
src/SMESH/SMESH_Gen.cxx
View File

@ -338,12 +338,13 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
std::vector< SMESH_subMesh* > smVec;
for ( aShapeDim = 0; aShapeDim < 4; ++aShapeDim )
smVec.insert( smVec.end(),
smWithAlgoSupportingSubmeshes[aShapeDim].begin(),
smWithAlgoSupportingSubmeshes[aShapeDim].end() );
{
// ------------------------------------------------
// sort list of sub-meshes according to mesh order
// ------------------------------------------------
smVec.assign( smWithAlgoSupportingSubmeshes[ aShapeDim ].begin(),
smWithAlgoSupportingSubmeshes[ aShapeDim ].end() );
aMesh.SortByMeshOrder( smVec );
// ------------------------------------------------------------
@ -354,20 +355,29 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
for ( size_t i = 0; i < smVec.size(); ++i )
{
sm = smVec[i];
if ( sm->GetComputeState() != SMESH_subMesh::READY_TO_COMPUTE)
continue;
const TopAbs_ShapeEnum shapeType = sm->GetSubShape().ShapeType();
// get a shape the algo is assigned to
if ( !GetAlgo( sm, & algoShape ))
continue; // strange...
// look for more local algos
smIt = sm->getDependsOnIterator(!includeSelf, !complexShapeFirst);
if ( SMESH_subMesh* algoSM = aMesh.GetSubMesh( algoShape ))
smIt = algoSM->getDependsOnIterator(!includeSelf, !complexShapeFirst);
else
smIt = sm->getDependsOnIterator(!includeSelf, !complexShapeFirst);
while ( smIt->more() )
{
SMESH_subMesh* smToCompute = smIt->next();
const TopoDS_Shape& aSubShape = smToCompute->GetSubShape();
const int aShapeDim = GetShapeDim( aSubShape );
if ( aShapeDim < 1 ) continue;
if ( aShapeDim < 1 || aSubShape.ShapeType() == shapeType )
continue;
// check for preview dimension limitations
if ( aShapesId && GetShapeDim( aSubShape.ShapeType() ) > (int)aDim )
@ -391,22 +401,15 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
Compute( aMesh, aSubShape, aFlags | SHAPE_ONLY_UPWARD, aDim, aShapesId, localAllowed );
}
}
}
// --------------------------------
// apply the all-dimensional algos
// --------------------------------
for ( size_t i = 0; i < smVec.size(); ++i )
{
sm = smVec[i];
if ( sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE)
// --------------------------------
// apply the all-dimensional algo
// --------------------------------
{
const TopAbs_ShapeEnum shapeType = sm->GetSubShape().ShapeType();
if (_compute_canceled)
return false;
// check for preview dimension limitations
if ( aShapesId && GetShapeDim( shapeType ) > (int)aDim )
continue;
if (_compute_canceled)
return false;
sm->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes ));
setCurrentSubMesh( sm );
sm->ComputeStateEngine( computeEvent );
@ -416,7 +419,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
aShapesId->insert( sm->GetId() );
}
}
} // loop on shape dimensions
}
// -----------------------------------------------
// mesh the rest sub-shapes starting from vertices
@ -1074,15 +1077,18 @@ std::vector< std::string > SMESH_Gen::GetPluginXMLPaths()
xmlPath += sep + plugin + ".xml";
bool fileOK;
#ifdef WIN32
#ifdef UNICODE
#ifdef UNICODE
const wchar_t* path = Kernel_Utils::decode_s(xmlPath);
#else
#else
const char* path = xmlPath.c_str();
#endif
#endif
fileOK = (GetFileAttributes(path) != INVALID_FILE_ATTRIBUTES);
#ifdef UNICODE
#ifdef UNICODE
delete path;
#endif
#endif
#else
fileOK = (access(xmlPath.c_str(), F_OK) == 0);
#endif

1
src/SMESH/SMESH_Mesh.cxx
View File

@ -2432,6 +2432,7 @@ bool SMESH_Mesh::SortByMeshOrder(std::vector<SMESH_subMesh*>& theListToSort) con
smVec.push_back( sm );
if ( sm->GetSubMeshDS() && sm->GetSubMeshDS()->IsComplexSubmesh() )
{
smVec.reserve( smVec.size() + sm->GetSubMeshDS()->NbSubMeshes() );
SMESHDS_SubMeshIteratorPtr smdsIt = sm->GetSubMeshDS()->GetSubMeshIterator();
while ( smdsIt->more() )
{

2
src/SMESHGUI/SMESHGUI.cxx
View File

@ -4686,7 +4686,7 @@ void SMESHGUI::initialize( CAM_Application* app )
popupMgr()->insert( separator(), -1, 0 );
createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && " + isNotEmpty );
createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
createPopupItem( SMESHOp::OpShowErrors, OB, mesh, "&& selcount=1 && hasErrors" );
createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );

22
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -6584,10 +6584,13 @@ void findConcurrents(const SMESH_DimHyp* theDimHyp,
}
//-----------------------------------------------------------------------------
void unionLists(TListOfInt& theListOfId,
bool unionLists(TListOfInt& theListOfId,
TListOfListOfInt& theListOfListOfId,
const int theIndx )
{
bool changed = false;
if ( theListOfId.empty() )
return changed;
TListOfListOfInt::iterator it = theListOfListOfId.begin();
for ( int i = 0; it != theListOfListOfId.end(); it++, i++ )
{
@ -6603,11 +6606,15 @@ void unionLists(TListOfInt& theListOfId,
TListOfInt::iterator it2 = otherListOfId.begin();
for ( ; it2 != otherListOfId.end(); it2++ ) {
if ( find( theListOfId.begin(), theListOfId.end(), (*it2) ) == theListOfId.end() )
{
theListOfId.push_back(*it2);
changed = true;
}
}
// clear source list
otherListOfId.clear();
}
return changed;
}
//-----------------------------------------------------------------------------
@ -6691,10 +6698,15 @@ SMESH::submesh_array_array* SMESH_Mesh_i::GetMeshOrder()
TListOfListOfInt allConurrent = findConcurrentSubMeshes();
anOrder.splice( anOrder.end(), allConurrent );
int listIndx = 0;
TListOfListOfInt::iterator listIt = anOrder.begin();
for(; listIt != anOrder.end(); listIt++, listIndx++ )
unionLists( *listIt, anOrder, listIndx + 1 );
bool changed;
do {
changed = false;
TListOfListOfInt::iterator listIt = anOrder.begin();
for ( int listIndx = 1; listIt != anOrder.end(); listIt++, listIndx++ )
if ( unionLists( *listIt, anOrder, listIndx ))
changed = true;
}
while ( changed );
// convert submesh ids into interface instances
// and dump command into python

2
src/StdMeshers/StdMeshers_Prism_3D.cxx
View File

@ -1841,6 +1841,8 @@ bool StdMeshers_Prism_3D::computeWalls(const Prism_3D::TPrismTopo& thePrism)
mesh->GetSubMesh( v )->ComputeStateEngine( SMESH_subMesh::COMPUTE );
const SMDS_MeshNode* n = SMESH_Algo::VertexNode( v, meshDS );
newNodes[ is2ndV ? newNodes.size()-1 : 0 ] = (SMDS_MeshNode*) n;
if ( !n )
return toSM( error( TCom("No node on vertex #") << meshDS->ShapeToIndex( v )));
}
// compute nodes on target EDGEs