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

Cosmetic changes

Browse Source
This commit is contained in:
eap 2020-05-27 20:48:43 +03:00
parent 2fcf0d1b8e
commit 75b15d2531
1 changed files with 80 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

154
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -6425,8 +6425,8 @@ class SMESH_DimHyp
//! fields //! fields
int _dim; //!< a dimension the algo can build (concurrent dimension) int _dim; //!< a dimension the algo can build (concurrent dimension)
int _ownDim; //!< dimension of shape of _subMesh (>=_dim) int _ownDim; //!< dimension of shape of _subMesh (>=_dim)
TopTools_MapOfShape _shapeMap; //!< [sub-]shapes of dimension == _dim TopTools_MapOfShape _shapeMap; //!< [sub-]shapes of dimension == _dim
SMESH_subMesh* _subMesh; const SMESH_subMesh* _subMesh;
list<const SMESHDS_Hypothesis*> _hypotheses; //!< algo is first, then its parameters list<const SMESHDS_Hypothesis*> _hypotheses; //!< algo is first, then its parameters
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -6440,7 +6440,7 @@ class SMESH_DimHyp
const int theDim, const int theDim,
const TopoDS_Shape& theShape) const TopoDS_Shape& theShape)
{ {
_subMesh = (SMESH_subMesh*)theSubMesh; _subMesh = theSubMesh;
SetShape( theDim, theShape ); SetShape( theDim, theShape );
} }
@ -6571,7 +6571,8 @@ void addDimHypInstance(const int theDim,
theAlgo->NeedLowerHyps( theDim )) // IPAL54678 theAlgo->NeedLowerHyps( theDim )) // IPAL54678
return; return;
TDimHypList& listOfdimHyp = theDimHypListArr[theDim]; TDimHypList& listOfdimHyp = theDimHypListArr[theDim];
if ( listOfdimHyp.empty() || listOfdimHyp.back()->_subMesh != theSubMesh ) { if ( listOfdimHyp.empty() || listOfdimHyp.back()->_subMesh != theSubMesh )
{
SMESH_DimHyp* dimHyp = new SMESH_DimHyp( theSubMesh, theDim, theShape ); SMESH_DimHyp* dimHyp = new SMESH_DimHyp( theSubMesh, theDim, theShape );
dimHyp->_hypotheses.push_front(theAlgo); dimHyp->_hypotheses.push_front(theAlgo);
listOfdimHyp.push_back( dimHyp ); listOfdimHyp.push_back( dimHyp );
@ -6627,7 +6628,8 @@ void unionLists(TListOfInt& theListOfId,
const int theIndx ) const int theIndx )
{ {
TListOfListOfInt::iterator it = theListOfListOfId.begin(); TListOfListOfInt::iterator it = theListOfListOfId.begin();
for ( int i = 0; it != theListOfListOfId.end(); it++, i++ ) { for ( int i = 0; it != theListOfListOfId.end(); it++, i++ )
{
if ( i < theIndx ) if ( i < theIndx )
continue; //skip already treated lists continue; //skip already treated lists
// check if other list has any same submesh object // check if other list has any same submesh object
@ -6750,83 +6752,85 @@ TListOfListOfInt SMESH_Mesh_i::findConcurrentSubMeshes()
{ {
TListOfListOfInt anOrder; TListOfListOfInt anOrder;
::SMESH_Mesh& mesh = GetImpl(); ::SMESH_Mesh& mesh = GetImpl();
{
// collect submeshes and detect concurrent algorithms and hypothesises
TDimHypList dimHypListArr[4]; // dimHyp list for each shape dimension
map<int, ::SMESH_subMesh*>::iterator i_sm = _mapSubMesh.begin(); // collect submeshes and detect concurrent algorithms and hypothesises
for ( ; i_sm != _mapSubMesh.end(); i_sm++ ) { TDimHypList dimHypListArr[4]; // dimHyp list for each shape dimension
::SMESH_subMesh* sm = (*i_sm).second;
// shape of submesh
const TopoDS_Shape& aSubMeshShape = sm->GetSubShape();
// list of assigned hypothesises map<int, ::SMESH_subMesh*>::iterator i_sm = _mapSubMesh.begin();
const list <const SMESHDS_Hypothesis*>& hypList = mesh.GetHypothesisList(aSubMeshShape); for ( ; i_sm != _mapSubMesh.end(); i_sm++ ) {
// Find out dimensions where the submesh can be concurrent. ::SMESH_subMesh* sm = (*i_sm).second;
// We define the dimensions by algo of each of hypotheses in hypList // shape of submesh
list <const SMESHDS_Hypothesis*>::const_iterator hypIt = hypList.begin(); const TopoDS_Shape& aSubMeshShape = sm->GetSubShape();
for( ; hypIt != hypList.end(); hypIt++ ) {
SMESH_Algo* anAlgo = 0;
const SMESH_Hypothesis* hyp = dynamic_cast<const SMESH_Hypothesis*>(*hypIt);
if ( hyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO )
// hyp it-self is algo
anAlgo = (SMESH_Algo*)dynamic_cast<const SMESH_Algo*>(hyp);
else {
// try to find algorithm with help of sub-shapes
TopExp_Explorer anExp( aSubMeshShape, shapeTypeByDim(hyp->GetDim()) );
for ( ; !anAlgo && anExp.More(); anExp.Next() )
anAlgo = mesh.GetGen()->GetAlgo( mesh, anExp.Current() );
}
if (!anAlgo)
continue; // no algorithm assigned to a current submesh
int dim = anAlgo->GetDim(); // top concurrent dimension (see comment to SMESH_DimHyp) // list of assigned hypothesises
// the submesh can concurrent at <dim> (or lower dims if !anAlgo->NeedDiscreteBoundary() const list <const SMESHDS_Hypothesis*>& hypList = mesh.GetHypothesisList(aSubMeshShape);
// and !anAlgo->NeedLowerHyps( dim )) // Find out dimensions where the submesh can be concurrent.
// We define the dimensions by algo of each of hypotheses in hypList
// create instance of dimension-hypothesis for found concurrent dimension(s) and algorithm list <const SMESHDS_Hypothesis*>::const_iterator hypIt = hypList.begin();
for ( int j = anAlgo->NeedDiscreteBoundary() ? dim : 1, jn = dim; j <= jn; j++ ) for( ; hypIt != hypList.end(); hypIt++ ) {
addDimHypInstance( j, aSubMeshShape, anAlgo, sm, hypList, dimHypListArr ); SMESH_Algo* anAlgo = 0;
const SMESH_Hypothesis* hyp = dynamic_cast<const SMESH_Hypothesis*>(*hypIt);
if ( hyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO )
// hyp it-self is algo
anAlgo = (SMESH_Algo*)dynamic_cast<const SMESH_Algo*>(hyp);
else {
// try to find algorithm with help of sub-shapes
TopExp_Explorer anExp( aSubMeshShape, shapeTypeByDim(hyp->GetDim()) );
for ( ; !anAlgo && anExp.More(); anExp.Next() )
anAlgo = mesh.GetGen()->GetAlgo( mesh, anExp.Current() );
} }
} // end iterations on submesh if (!anAlgo)
continue; // no algorithm assigned to a current submesh
int dim = anAlgo->GetDim(); // top concurrent dimension (see comment to SMESH_DimHyp)
// the submesh can concurrent at <dim> (or lower dims if !anAlgo->NeedDiscreteBoundary()
// and !anAlgo->NeedLowerHyps( dim ))
// create instance of dimension-hypothesis for found concurrent dimension(s) and algorithm
for ( int j = anAlgo->NeedDiscreteBoundary() ? dim : 1, jn = dim; j <= jn; j++ )
addDimHypInstance( j, aSubMeshShape, anAlgo, sm, hypList, dimHypListArr );
}
} // end iterations on submesh
// iterate on created dimension-hypotheses and check for concurrents // iterate on created dimension-hypotheses and check for concurrents
for ( int i = 0; i < 4; i++ ) { for ( int i = 0; i < 4; i++ )
const TDimHypList& listOfDimHyp = dimHypListArr[i]; {
// check for concurrents in own and other dimensions (step-by-step) const TDimHypList& listOfDimHyp = dimHypListArr[i];
TDimHypList::const_iterator dhIt = listOfDimHyp.begin(); // check for concurrents in own and other dimensions (step-by-step)
for ( ; dhIt != listOfDimHyp.end(); dhIt++ ) { TDimHypList::const_iterator dhIt = listOfDimHyp.begin();
const SMESH_DimHyp* dimHyp = *dhIt; for ( ; dhIt != listOfDimHyp.end(); dhIt++ )
TDimHypList listOfConcurr; {
set<int> setOfConcurrIds; const SMESH_DimHyp* dimHyp = *dhIt;
// looking for concurrents and collect into own list TDimHypList listOfConcurr;
for ( int j = i; j < 4; j++ ) set<int> setOfConcurrIds;
findConcurrents( dimHyp, dimHypListArr[j], listOfConcurr, setOfConcurrIds ); // looking for concurrents and collect into own list
// check if any concurrents found for ( int j = i; j < 4; j++ )
if ( listOfConcurr.size() > 0 ) { findConcurrents( dimHyp, dimHypListArr[j], listOfConcurr, setOfConcurrIds );
// add own submesh to list of concurrent // check if any concurrents found
addInOrderOfPriority( dimHyp, listOfConcurr ); if ( listOfConcurr.size() > 0 )
list<int> listOfConcurrIds; {
TDimHypList::iterator hypIt = listOfConcurr.begin(); // add own submesh to list of concurrent
for ( ; hypIt != listOfConcurr.end(); ++hypIt ) addInOrderOfPriority( dimHyp, listOfConcurr );
listOfConcurrIds.push_back( (*hypIt)->_subMesh->GetId() ); list<int> listOfConcurrIds;
anOrder.push_back( listOfConcurrIds ); TDimHypList::iterator hypIt = listOfConcurr.begin();
} for ( ; hypIt != listOfConcurr.end(); ++hypIt )
listOfConcurrIds.push_back( (*hypIt)->_subMesh->GetId() );
anOrder.push_back( listOfConcurrIds );
} }
} }
removeDimHyps(dimHypListArr);
// now, minimize the number of concurrent groups
// Here we assume that lists of submeshes can have same submesh
// in case of multi-dimension algorithms, as result
// list with common submesh has to be united into one list
int listIndx = 0;
TListOfListOfInt::iterator listIt = anOrder.begin();
for(; listIt != anOrder.end(); listIt++, listIndx++ )
unionLists( *listIt, anOrder, listIndx + 1 );
} }
removeDimHyps(dimHypListArr);
// now, minimize the number of concurrent groups
// Here we assume that lists of submeshes can have same submesh
// in case of multi-dimension algorithms, as result
// list with common submesh has to be united into one list
int listIndx = 0;
TListOfListOfInt::iterator listIt = anOrder.begin();
for(; listIt != anOrder.end(); listIt++, listIndx++ )
unionLists( *listIt, anOrder, listIndx + 1 );
return anOrder; return anOrder;
} }
@ -6913,7 +6917,8 @@ void SMESH_Mesh_i::convertMeshOrder (const TListOfListOfInt& theIdsOrder,
theResOrder.length(nbSet); theResOrder.length(nbSet);
TListOfListOfInt::const_iterator it = theIdsOrder.begin(); TListOfListOfInt::const_iterator it = theIdsOrder.begin();
int listIndx = 0; int listIndx = 0;
for( ; it != theIdsOrder.end(); it++ ) { for( ; it != theIdsOrder.end(); it++ )
{
// translate submesh identificators into submesh objects // translate submesh identificators into submesh objects
// takeing into account real number of concurrent lists // takeing into account real number of concurrent lists
const TListOfInt& aSubOrder = (*it); const TListOfInt& aSubOrder = (*it);
@ -6926,7 +6931,8 @@ void SMESH_Mesh_i::convertMeshOrder (const TListOfListOfInt& theIdsOrder,
aResSubSet->length(aSubOrder.size()); aResSubSet->length(aSubOrder.size());
TListOfInt::const_iterator subIt = aSubOrder.begin(); TListOfInt::const_iterator subIt = aSubOrder.begin();
int j; int j;
for( j = 0; subIt != aSubOrder.end(); subIt++ ) { for( j = 0; subIt != aSubOrder.end(); subIt++ )
{
if ( _mapSubMeshIor.find(*subIt) == _mapSubMeshIor.end() ) if ( _mapSubMeshIor.find(*subIt) == _mapSubMeshIor.end() )
continue; continue;
SMESH::SMESH_subMesh_var subMesh = SMESH::SMESH_subMesh_var subMesh =