-// SMESH SMESH : implementaion of SMESH idl descriptions
+// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
//
-// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
-// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
-//
-//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+
+// SMESH SMESH : implementaion of SMESH idl descriptions
// File : SMESH_Gen.cxx
// Author : Paul RASCLE, EDF
// Module : SMESH
-// $Header$
-
+//
+#define CHRONODEF
#include "SMESH_Gen.hxx"
#include "SMESH_subMesh.hxx"
+#include "SMESH_HypoFilter.hxx"
+#include "SMESHDS_Document.hxx"
#include "SMDS_MeshElement.hxx"
#include "SMDS_MeshNode.hxx"
+#include "SMDS_Mesh.hxx"
#include "utilities.h"
#include "OpUtil.hxx"
#include "Utils_ExceptHandlers.hxx"
-#include <gp_Pnt.hxx>
-#include <BRep_Tool.hxx>
-#include <TopTools_ListOfShape.hxx>
-#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <TopoDS_Iterator.hxx>
+
+#include "memoire.h"
using namespace std;
//=============================================================================
/*!
- * default constructor:
+ * Constructor
*/
//=============================================================================
SMESH_Gen::SMESH_Gen()
{
- MESSAGE("SMESH_Gen::SMESH_Gen");
- _localId = 0;
- _hypId = 0;
+ MESSAGE("SMESH_Gen::SMESH_Gen");
+ _localId = 0;
+ _hypId = 0;
+ _segmentation = _nbSegments = 10;
+ SMDS_Mesh::_meshList.clear();
+ MESSAGE(SMDS_Mesh::_meshList.size());
+ _counters = new counters(100);
+#ifdef WITH_SMESH_CANCEL_COMPUTE
+ _compute_canceled = false;
+ _sm_current = NULL;
+#endif
}
//=============================================================================
/*!
- *
+ * Destructor
*/
//=============================================================================
SMESH_Gen::~SMESH_Gen()
{
- MESSAGE("SMESH_Gen::~SMESH_Gen");
+ MESSAGE("SMESH_Gen::~SMESH_Gen");
}
//=============================================================================
/*!
- *
+ * Creates a mesh in a study.
+ * if (theIsEmbeddedMode) { mesh modification commands are not logged }
*/
//=============================================================================
-/*SMESH_Hypothesis *SMESH_Gen::CreateHypothesis(const char *anHyp, int studyId)
- throw(SALOME_Exception)
+SMESH_Mesh* SMESH_Gen::CreateMesh(int theStudyId, bool theIsEmbeddedMode)
+ throw(SALOME_Exception)
{
+ Unexpect aCatch(SalomeException);
+ MESSAGE("SMESH_Gen::CreateMesh");
- MESSAGE("CreateHypothesis("<<anHyp<<","<<studyId<<")");
- // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
-
- StudyContextStruct *myStudyContext = GetStudyContext(studyId);
+ // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
+ StudyContextStruct *aStudyContext = GetStudyContext(theStudyId);
- // create a new hypothesis object, store its ref. in studyContext
+ // create a new SMESH_mesh object
+ SMESH_Mesh *aMesh = new SMESH_Mesh(_localId++,
+ theStudyId,
+ this,
+ theIsEmbeddedMode,
+ aStudyContext->myDocument);
+ aStudyContext->mapMesh[_localId] = aMesh;
- SMESH_Hypothesis *myHypothesis = _hypothesisFactory.Create(anHyp, studyId);
- int hypId = myHypothesis->GetID();
- myStudyContext->mapHypothesis[hypId] = myHypothesis;
- SCRUTE(studyId);
- SCRUTE(hypId);
-
- // store hypothesis in SMESHDS document
-
- myStudyContext->myDocument->AddHypothesis(myHypothesis);
- return myHypothesis;
-}*/
+ return aMesh;
+}
//=============================================================================
/*!
- *
+ * Compute a mesh
*/
//=============================================================================
-SMESH_Mesh* SMESH_Gen::CreateMesh(int studyId)
-throw(SALOME_Exception)
+bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape,
+ const bool anUpward,
+ const ::MeshDimension aDim,
+ TSetOfInt* aShapesId)
{
- Unexpect aCatch(SalomeException);
- MESSAGE("SMESH_Gen::CreateMesh");
-// if (aShape.ShapeType() == TopAbs_COMPOUND)
-// {
-// INFOS("Mesh Compound not yet implemented!");
-// throw(SALOME_Exception(LOCALIZED("Mesh Compound not yet implemented!")));
-// }
+ MESSAGE("SMESH_Gen::Compute");
+ MEMOSTAT;
+
+ bool ret = true;
+
+ SMESH_subMesh *sm = aMesh.GetSubMesh(aShape);
+
+ const bool includeSelf = true;
+ const bool complexShapeFirst = true;
- // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
+ SMESH_subMeshIteratorPtr smIt;
- StudyContextStruct *myStudyContext = GetStudyContext(studyId);
+ if ( anUpward ) // is called from below code here
+ {
+ // -----------------------------------------------
+ // mesh all the subshapes starting from vertices
+ // -----------------------------------------------
+ smIt = sm->getDependsOnIterator(includeSelf, !complexShapeFirst);
+ while ( smIt->more() )
+ {
+ SMESH_subMesh* smToCompute = smIt->next();
+
+ // do not mesh vertices of a pseudo shape
+ const TopAbs_ShapeEnum aShType = smToCompute->GetSubShape().ShapeType();
+ if ( !aMesh.HasShapeToMesh() && aShType == TopAbs_VERTEX )
+ continue;
+
+ // check for preview dimension limitations
+ if ( aShapesId && GetShapeDim( aShType ) > (int)aDim )
+ {
+ // clear compute state to not show previous compute errors
+ // if preview invoked less dimension less than previous
+ smToCompute->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
+ continue;
+ }
- // create a new SMESH_mesh object
+ if (smToCompute->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE)
+ {
+#ifdef WITH_SMESH_CANCEL_COMPUTE
+ if (_compute_canceled)
+ return false;
+ _sm_current = smToCompute;
+#endif
+ smToCompute->ComputeStateEngine( SMESH_subMesh::COMPUTE );
+#ifdef WITH_SMESH_CANCEL_COMPUTE
+ _sm_current = NULL;
+#endif
+ }
- SMESH_Mesh *mesh = new SMESH_Mesh(_localId++,
- studyId,
- this,
- myStudyContext->myDocument);
- myStudyContext->mapMesh[_localId] = mesh;
+ // we check all the submeshes here and detect if any of them failed to compute
+ if (smToCompute->GetComputeState() == SMESH_subMesh::FAILED_TO_COMPUTE)
+ ret = false;
+ else if ( aShapesId )
+ aShapesId->insert( smToCompute->GetId() );
+ }
+ //aMesh.GetMeshDS()->Modified();
+ return ret;
+ }
+ else
+ {
+ // -----------------------------------------------------------------
+ // apply algos that DO NOT require descretized boundaries and DO NOT
+ // support submeshes, starting from the most complex shapes
+ // and collect submeshes with algos that DO support submeshes
+ // -----------------------------------------------------------------
+ list< SMESH_subMesh* > smWithAlgoSupportingSubmeshes;
+
+ // map to sort sm with same dim algos according to dim of
+ // the shape the algo assigned to (issue 0021217)
+ multimap< int, SMESH_subMesh* > shDim2sm;
+ multimap< int, SMESH_subMesh* >::reverse_iterator shDim2smIt;
+ TopoDS_Shape algoShape;
+ int prevShapeDim = -1;
+
+ smIt = sm->getDependsOnIterator(includeSelf, complexShapeFirst);
+ while ( smIt->more() )
+ {
+ SMESH_subMesh* smToCompute = smIt->next();
+ if ( smToCompute->GetComputeState() != SMESH_subMesh::READY_TO_COMPUTE )
+ continue;
+
+ const TopoDS_Shape& aSubShape = smToCompute->GetSubShape();
+ int aShapeDim = GetShapeDim( aSubShape );
+ if ( aShapeDim < 1 ) break;
+
+ // check for preview dimension limitations
+ if ( aShapesId && aShapeDim > (int)aDim )
+ continue;
+
+ SMESH_Algo* algo = GetAlgo( aMesh, aSubShape, &algoShape );
+ if ( algo && !algo->NeedDescretBoundary() )
+ {
+ if ( algo->SupportSubmeshes() )
+ {
+ // reload sub-meshes from shDim2sm into smWithAlgoSupportingSubmeshes
+ if ( prevShapeDim != aShapeDim )
+ {
+ prevShapeDim = aShapeDim;
+ for ( shDim2smIt = shDim2sm.rbegin(); shDim2smIt != shDim2sm.rend(); ++shDim2smIt )
+ smWithAlgoSupportingSubmeshes.push_front( shDim2smIt->second );
+ shDim2sm.clear();
+ }
+ // add smToCompute to shDim2sm map
+ aShapeDim = GetShapeDim( algoShape );
+ if ( algoShape.ShapeType() == TopAbs_COMPOUND )
+ {
+ TopoDS_Iterator it( algoShape );
+ aShapeDim += GetShapeDim( it.Value() );
+ }
+ shDim2sm.insert( make_pair( aShapeDim, smToCompute ));
+ }
+ else
+ {
+#ifdef WITH_SMESH_CANCEL_COMPUTE
+ if (_compute_canceled)
+ return false;
+ _sm_current = smToCompute;
+#endif
+ smToCompute->ComputeStateEngine( SMESH_subMesh::COMPUTE );
+#ifdef WITH_SMESH_CANCEL_COMPUTE
+ _sm_current = NULL;
+#endif
+ if ( aShapesId )
+ aShapesId->insert( smToCompute->GetId() );
+ }
+ }
+ }
+ // reload sub-meshes from shDim2sm into smWithAlgoSupportingSubmeshes
+ for ( shDim2smIt = shDim2sm.rbegin(); shDim2smIt != shDim2sm.rend(); ++shDim2smIt )
+ smWithAlgoSupportingSubmeshes.push_front( shDim2smIt->second );
+
+ // ------------------------------------------------------------
+ // sort list of submeshes according to mesh order
+ // ------------------------------------------------------------
+ aMesh.SortByMeshOrder( smWithAlgoSupportingSubmeshes );
+
+ // ------------------------------------------------------------
+ // compute submeshes under shapes with algos that DO NOT require
+ // descretized boundaries and DO support submeshes
+ // ------------------------------------------------------------
+ list< SMESH_subMesh* >::iterator subIt, subEnd;
+ subIt = smWithAlgoSupportingSubmeshes.begin();
+ subEnd = smWithAlgoSupportingSubmeshes.end();
+ // start from lower shapes
+ for ( ; subIt != subEnd; ++subIt )
+ {
+ sm = *subIt;
- // associate a TopoDS_Shape to the mesh
+ // get a shape the algo is assigned to
+ if ( !GetAlgo( aMesh, sm->GetSubShape(), & algoShape ))
+ continue; // strange...
-//mesh->ShapeToMesh(aShape);
- return mesh;
+ // look for more local algos
+ 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 ( aSubShape.ShapeType() == TopAbs_VERTEX ) continue;
+ if ( aShapeDim < 1 ) continue;
+
+ // check for preview dimension limitations
+ if ( aShapesId && GetShapeDim( aSubShape.ShapeType() ) > (int)aDim )
+ continue;
+
+ SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() );
+ filter
+ .And( SMESH_HypoFilter::IsApplicableTo( aSubShape ))
+ .And( SMESH_HypoFilter::IsMoreLocalThan( algoShape ));
+
+ if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( aSubShape, filter, true )) {
+ SMESH_Hypothesis::Hypothesis_Status status;
+ if ( subAlgo->CheckHypothesis( aMesh, aSubShape, status ))
+ // mesh a lower smToCompute starting from vertices
+ Compute( aMesh, aSubShape, /*anUpward=*/true, aDim, aShapesId );
+ }
+ }
+ }
+ // ----------------------------------------------------------
+ // apply the algos that do not require descretized boundaries
+ // ----------------------------------------------------------
+ for ( subIt = smWithAlgoSupportingSubmeshes.begin(); subIt != subEnd; ++subIt )
+ {
+ sm = *subIt;
+ if ( sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE)
+ {
+ const TopAbs_ShapeEnum aShType = sm->GetSubShape().ShapeType();
+ // check for preview dimension limitations
+ if ( aShapesId && GetShapeDim( aShType ) > (int)aDim )
+ continue;
+
+#ifdef WITH_SMESH_CANCEL_COMPUTE
+ if (_compute_canceled)
+ return false;
+ _sm_current = sm;
+#endif
+ sm->ComputeStateEngine( SMESH_subMesh::COMPUTE );
+#ifdef WITH_SMESH_CANCEL_COMPUTE
+ _sm_current = NULL;
+#endif
+ if ( aShapesId )
+ aShapesId->insert( sm->GetId() );
+ }
+ }
+ // -----------------------------------------------
+ // mesh the rest subshapes starting from vertices
+ // -----------------------------------------------
+ ret = Compute( aMesh, aShape, /*anUpward=*/true, aDim, aShapesId );
+ }
+
+ MESSAGE( "VSR - SMESH_Gen::Compute() finished, OK = " << ret);
+ MEMOSTAT;
+
+ SMESHDS_Mesh *myMesh = aMesh.GetMeshDS();
+ myMesh->adjustStructure();
+ MESSAGE("*** compactMesh after compute");
+ myMesh->compactMesh();
+ //myMesh->adjustStructure();
+ list<int> listind = myMesh->SubMeshIndices();
+ list<int>::iterator it = listind.begin();
+ int total = 0;
+ for(; it != listind.end(); ++it)
+ {
+ ::SMESHDS_SubMesh *subMesh = myMesh->MeshElements(*it);
+ total += subMesh->getSize();
+ }
+ MESSAGE("total elements and nodes in submesh sets:" << total);
+ MESSAGE("Number of node objects " << SMDS_MeshNode::nbNodes);
+ MESSAGE("Number of cell objects " << SMDS_MeshCell::nbCells);
+ //myMesh->dumpGrid();
+ //aMesh.GetMeshDS()->Modified();
+ return ret;
}
+
+#ifdef WITH_SMESH_CANCEL_COMPUTE
//=============================================================================
/*!
- *
+ * Prepare Compute a mesh
*/
//=============================================================================
+void SMESH_Gen::PrepareCompute(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape)
+{
+ _compute_canceled = false;
+ _sm_current = NULL;
+}
+//=============================================================================
+/*!
+ * Cancel Compute a mesh
+ */
+//=============================================================================
+void SMESH_Gen::CancelCompute(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape)
+{
+ _compute_canceled = true;
+ if(_sm_current)
+ {
+ _sm_current->ComputeStateEngine( SMESH_subMesh::COMPUTE_CANCELED );
+ }
+}
+#endif
-bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape)
+//=============================================================================
+/*!
+ * Evaluate a mesh
+ */
+//=============================================================================
+
+bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape,
+ MapShapeNbElems& aResMap,
+ const bool anUpward,
+ TSetOfInt* aShapesId)
{
- MESSAGE("SMESH_Gen::Compute");
- // bool isDone = false;
- /*
- Algo : s'appuie ou non sur une geometrie
- Si geometrie:
- Vertex : rien à faire (range le point)
- Edge, Wire, collection d'edge et wire : 1D
- Face, Shell, collection de Face et Shells : 2D
- Solid, Collection de Solid : 3D
- */
- // *** corriger commentaires
- // check hypothesis associated to the mesh :
- // - only one algo : type compatible with the type of the shape
- // - hypothesis = compatible with algo
- // - check if hypothesis are applicable to this algo
- // - check contradictions within hypothesis
- // (test if enough hypothesis is done further)
+ MESSAGE("SMESH_Gen::Evaluate");
bool ret = true;
-// if ( !CheckAlgoState( aMesh, aShape ))
-// {
-// INFOS( "ABORT MESHING: some algos or hypothesis are missing");
-// return false;
-// }
-
SMESH_subMesh *sm = aMesh.GetSubMesh(aShape);
- if ( sm->GetComputeState() == SMESH_subMesh::COMPUTE_OK )
- return true; // already computed
-
- // -----------------------------------------------------------------
- // apply algos that do not require descretized boundaries, starting
- // from the most complex shapes
- // -----------------------------------------------------------------
-
- // map containing all subshapes in the order: vertices, edges, faces...
- const map<int, SMESH_subMesh*>& smMap = sm->DependsOn();
- map<int, SMESH_subMesh*>::const_reverse_iterator revItSub = smMap.rbegin();
-
- SMESH_subMesh* smToCompute = sm;
- while ( smToCompute )
- {
- const TopoDS_Shape& aSubShape = smToCompute->GetSubShape();
- if ( GetShapeDim( aSubShape ) < 1 ) break;
-
- SMESH_Algo* algo = GetAlgo( aMesh, aSubShape );
- if (algo && !algo->NeedDescretBoundary()) {
- if (smToCompute->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE) {
- ret = smToCompute->ComputeStateEngine( SMESH_subMesh::COMPUTE );
- } else if (smToCompute->GetComputeState() == SMESH_subMesh::FAILED_TO_COMPUTE) {
- // JFA for PAL6524
- ret = false;
- } else {
+ const bool includeSelf = true;
+ const bool complexShapeFirst = true;
+ SMESH_subMeshIteratorPtr smIt;
+
+ if ( anUpward ) { // is called from below code here
+ // -----------------------------------------------
+ // mesh all the subshapes starting from vertices
+ // -----------------------------------------------
+ smIt = sm->getDependsOnIterator(includeSelf, !complexShapeFirst);
+ while ( smIt->more() ) {
+ SMESH_subMesh* smToCompute = smIt->next();
+
+ // do not mesh vertices of a pseudo shape
+ const TopAbs_ShapeEnum aShType = smToCompute->GetSubShape().ShapeType();
+ //if ( !aMesh.HasShapeToMesh() && aShType == TopAbs_VERTEX )
+ // continue;
+ if ( !aMesh.HasShapeToMesh() ) {
+ if( aShType == TopAbs_VERTEX || aShType == TopAbs_WIRE ||
+ aShType == TopAbs_SHELL )
+ continue;
}
- }
- if (!ret)
- return false;
- // next subMesh
- if (revItSub != smMap.rend())
- {
- smToCompute = (*revItSub).second;
- revItSub++;
+ smToCompute->Evaluate(aResMap);
+ if( aShapesId )
+ aShapesId->insert( smToCompute->GetId() );
}
- else
- smToCompute = 0;
+ return ret;
}
-
- // -----------------------------------------------
- // mesh the rest subshapes starting from vertices
- // -----------------------------------------------
-
- int i, nbSub = smMap.size();
- map<int, SMESH_subMesh*>::const_iterator itSub = smMap.begin();
- for ( i = 0; i <= nbSub; ++i ) // loop on the whole map plus <sm>
- {
- if ( itSub == smMap.end() )
- smToCompute = sm;
- else
- smToCompute = (itSub++)->second;
- if (smToCompute->GetComputeState() != SMESH_subMesh::READY_TO_COMPUTE) {
- if (smToCompute->GetComputeState() == SMESH_subMesh::FAILED_TO_COMPUTE)
- ret = false;
- continue;
+ else {
+ // -----------------------------------------------------------------
+ // apply algos that DO NOT require descretized boundaries and DO NOT
+ // support submeshes, starting from the most complex shapes
+ // and collect submeshes with algos that DO support submeshes
+ // -----------------------------------------------------------------
+ list< SMESH_subMesh* > smWithAlgoSupportingSubmeshes;
+ 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 ) break;
+
+ SMESH_Algo* algo = GetAlgo( aMesh, aSubShape );
+ if ( algo && !algo->NeedDescretBoundary() ) {
+ if ( algo->SupportSubmeshes() ) {
+ smWithAlgoSupportingSubmeshes.push_front( smToCompute );
+ }
+ else {
+ smToCompute->Evaluate(aResMap);
+ if ( aShapesId )
+ aShapesId->insert( smToCompute->GetId() );
+ }
+ }
}
- TopoDS_Shape subShape = smToCompute->GetSubShape();
- if ( subShape.ShapeType() != TopAbs_VERTEX )
- {
- if ( !smToCompute->ComputeStateEngine(SMESH_subMesh::COMPUTE) )
- ret = false;
+
+ // ------------------------------------------------------------
+ // sort list of meshes according to mesh order
+ // ------------------------------------------------------------
+ aMesh.SortByMeshOrder( smWithAlgoSupportingSubmeshes );
+
+ // ------------------------------------------------------------
+ // compute submeshes under shapes with algos that DO NOT require
+ // descretized boundaries and DO support submeshes
+ // ------------------------------------------------------------
+ list< SMESH_subMesh* >::iterator subIt, subEnd;
+ subIt = smWithAlgoSupportingSubmeshes.begin();
+ subEnd = smWithAlgoSupportingSubmeshes.end();
+ // start from lower shapes
+ for ( ; subIt != subEnd; ++subIt ) {
+ sm = *subIt;
+
+ // get a shape the algo is assigned to
+ TopoDS_Shape algoShape;
+ if ( !GetAlgo( aMesh, sm->GetSubShape(), & algoShape ))
+ continue; // strange...
+
+ // look for more local algos
+ 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;
+
+ //const TopAbs_ShapeEnum aShType = smToCompute->GetSubShape().ShapeType();
+
+ SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() );
+ filter
+ .And( SMESH_HypoFilter::IsApplicableTo( aSubShape ))
+ .And( SMESH_HypoFilter::IsMoreLocalThan( algoShape ));
+
+ if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( aSubShape, filter, true )) {
+ SMESH_Hypothesis::Hypothesis_Status status;
+ if ( subAlgo->CheckHypothesis( aMesh, aSubShape, status ))
+ // mesh a lower smToCompute starting from vertices
+ Evaluate( aMesh, aSubShape, aResMap, /*anUpward=*/true, aShapesId );
+ }
+ }
}
- else
+ // ----------------------------------------------------------
+ // apply the algos that do not require descretized boundaries
+ // ----------------------------------------------------------
+ for ( subIt = smWithAlgoSupportingSubmeshes.begin(); subIt != subEnd; ++subIt )
{
- TopoDS_Vertex V1 = TopoDS::Vertex(subShape);
- gp_Pnt P1 = BRep_Tool::Pnt(V1);
- SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
- SMDS_MeshNode * node = meshDS->AddNode(P1.X(), P1.Y(), P1.Z());
- if ( node ) { // san - increase robustness
- meshDS->SetNodeOnVertex(node, V1);
- smToCompute->ComputeStateEngine(SMESH_subMesh::COMPUTE);
- }
+ sm = *subIt;
+ sm->Evaluate(aResMap);
+ if ( aShapesId )
+ aShapesId->insert( sm->GetId() );
}
+
+ // -----------------------------------------------
+ // mesh the rest subshapes starting from vertices
+ // -----------------------------------------------
+ ret = Evaluate( aMesh, aShape, aResMap, /*anUpward=*/true, aShapesId );
}
- MESSAGE( "VSR - SMESH_Gen::Compute() finished, OK = " << ret);
+ MESSAGE( "VSR - SMESH_Gen::Evaluate() finished, OK = " << ret);
return ret;
}
const SMESH_Algo* aGlobIgnoAlgo,
const SMESH_Algo* aLocIgnoAlgo,
bool & checkConform,
- map<int, SMESH_subMesh*>& aCheckedMap)
+ set<SMESH_subMesh*>& aCheckedMap,
+ list< SMESH_Gen::TAlgoStateError > & theErrors)
{
ASSERT( aSubMesh );
if ( aSubMesh->GetSubShape().ShapeType() == TopAbs_VERTEX)
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_Hypothesis::HYP_NOTCONFORM, 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;
+ SMESH_subMeshIteratorPtr revItSub =
+ aSubMesh->getDependsOnIterator( /*includeSelf=*/false, /*complexShapeFirst=*/true);
bool checkConform2 = false;
- for ( revItSub = smMap.rbegin(); revItSub != smMap.rend(); revItSub++)
+ while ( revItSub->more() )
{
- checkConformIgnoredAlgos (aMesh, (*revItSub).second, aGlobIgnoAlgo,
- algo, checkConform2, aCheckedMap);
- int key = (*revItSub).first;
- SMESH_subMesh* sm = (*revItSub).second;
- if ( aCheckedMap.find( key ) == aCheckedMap.end() )
- {
- aCheckedMap[ key ] = sm;
- }
+ SMESH_subMesh* sm = revItSub->next();
+ checkConformIgnoredAlgos (aMesh, sm, aGlobIgnoAlgo,
+ algo, checkConform2, aCheckedMap, theErrors);
+ aCheckedMap.insert( sm );
}
}
}
const int aTopAlgoDim,
bool* globalChecked,
const bool checkNoAlgo,
- map<int, SMESH_subMesh*>& aCheckedMap)
+ set<SMESH_subMesh*>& aCheckedMap,
+ list< SMESH_Gen::TAlgoStateError > & theErrors)
{
if ( aSubMesh->GetSubShape().ShapeType() == TopAbs_VERTEX)
return true;
int shapeDim = SMESH_Gen::GetShapeDim( aSubMesh->GetSubShape() );
if (aTopAlgoDim > shapeDim)
{
- INFOS( "ERROR: " << shapeDim << "D algorithm is missing" );
+ MESSAGE( "ERROR: " << shapeDim << "D algorithm is missing" );
ret = false;
+ theErrors.push_back( SMESH_Gen::TAlgoStateError() );
+ theErrors.back().Set( SMESH_Hypothesis::HYP_MISSING, shapeDim, true );
}
}
return ret;
// notify if an algo missing hyp is attached to aSubMesh
algo = aGen->GetAlgo( aMesh, aSubMesh->GetSubShape() );
ASSERT( algo );
- bool isGlobalAlgo = aGen->IsGlobalAlgo( algo, aMesh );
- if (!isGlobalAlgo || !globalChecked[ algo->GetDim() ])
+ bool IsGlobalHypothesis = aGen->IsGlobalHypothesis( algo, aMesh );
+ if (!IsGlobalHypothesis || !globalChecked[ algo->GetDim() ])
{
- INFOS( "ERROR: " << (isGlobalAlgo ? "Global " : "Local ")
- << "<" << algo->GetName() << "> misses some hypothesis");
- if (isGlobalAlgo)
+ TAlgoStateErrorName errName = SMESH_Hypothesis::HYP_MISSING;
+ SMESH_Hypothesis::Hypothesis_Status status;
+ algo->CheckHypothesis( aMesh, aSubMesh->GetSubShape(), status );
+ if ( status == SMESH_Hypothesis::HYP_BAD_PARAMETER ) {
+ MESSAGE( "ERROR: hypothesis of " << (IsGlobalHypothesis ? "Global " : "Local ")
+ << "<" << algo->GetName() << "> has a bad parameter value");
+ errName = status;
+ } else if ( status == SMESH_Hypothesis::HYP_BAD_GEOMETRY ) {
+ MESSAGE( "ERROR: " << (IsGlobalHypothesis ? "Global " : "Local ")
+ << "<" << algo->GetName() << "> assigned to mismatching geometry");
+ errName = status;
+ } else {
+ MESSAGE( "ERROR: " << (IsGlobalHypothesis ? "Global " : "Local ")
+ << "<" << algo->GetName() << "> misses some hypothesis");
+ }
+ if (IsGlobalHypothesis)
globalChecked[ algo->GetDim() ] = true;
+ theErrors.push_back( SMESH_Gen::TAlgoStateError() );
+ theErrors.back().Set( errName, algo, IsGlobalHypothesis );
}
ret = false;
break;
// re-start checking NO_ALGO state
ASSERT (algo);
bool isTopLocalAlgo =
- ( aTopAlgoDim <= algo->GetDim() && !aGen->IsGlobalAlgo( algo, aMesh ));
+ ( 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++)
+ SMESH_subMeshIteratorPtr itsub = aSubMesh->getDependsOnIterator( /*includeSelf=*/false,
+ /*complexShapeFirst=*/false);
+ while ( itsub->more() )
{
// 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;
+ SMESH_subMesh* sm = itsub->next();
+ aCheckedMap.insert( sm );
if (isTopLocalAlgo)
{
//check algo on sub-meshes
int aTopAlgoDim2 = algo->GetDim();
if (!checkMissing (aGen, aMesh, sm, aTopAlgoDim2,
- globalChecked, checkNoAlgo2, aCheckedMap))
+ globalChecked, checkNoAlgo2, aCheckedMap, theErrors))
{
ret = false;
if (sm->GetAlgoState() == SMESH_subMesh::NO_ALGO )
//=======================================================================
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 = aMesh.GetSubMesh(aShape);
- const SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
+ SMESH_subMesh* sm = theMesh.GetSubMesh(theShape);
+ const SMESHDS_Mesh* meshDS = theMesh.GetMeshDS();
TopoDS_Shape mainShape = meshDS->ShapeToMesh();
// -----------------
// --------------------------------------------------------
- // find a global algo possibly hidding sub-algos
+ // find a global algo possibly hiding sub-algos
int dim;
const SMESH_Algo* aGlobIgnoAlgo = 0;
for (dim = 3; dim > 0; dim--)
}
}
- 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 = ( !aMesh.IsNotConformAllowed() );
- int aKey = 1;
- SMESH_subMesh* smToCheck = sm;
+ set<SMESH_subMesh*> aCheckedSubs;
+ bool checkConform = ( !theMesh.IsNotConformAllowed() );
- // loop on aShape and its sub-shapes
- while ( smToCheck )
+ // loop on theShape and its sub-shapes
+ SMESH_subMeshIteratorPtr revItSub = sm->getDependsOnIterator( /*includeSelf=*/true,
+ /*complexShapeFirst=*/true);
+ while ( revItSub->more() )
{
+ SMESH_subMesh* smToCheck = revItSub->next();
if ( smToCheck->GetSubShape().ShapeType() == TopAbs_VERTEX)
break;
- if ( aCheckedMap.find( aKey ) == aCheckedMap.end() )
- if (!checkConformIgnoredAlgos (aMesh, smToCheck, aGlobIgnoAlgo,
- 0, checkConform, aCheckedMap))
+ if ( aCheckedSubs.insert( smToCheck ).second ) // not yet checked
+ if (!checkConformIgnoredAlgos (theMesh, smToCheck, aGlobIgnoAlgo,
+ 0, checkConform, aCheckedSubs, 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;
- }
-
}
// ----------------------------------------------------------------
break;
}
}
- aCheckedMap.clear();
- smToCheck = sm;
- revItSub = smMap.rbegin();
- bool checkNoAlgo = (bool) aTopAlgoDim;
+ bool checkNoAlgo = theMesh.HasShapeToMesh() ? bool( aTopAlgoDim ) : false;
bool globalChecked[] = { false, false, false, false };
- // loop on aShape and its sub-shapes
- while ( smToCheck )
+ // loop on theShape and its sub-shapes
+ aCheckedSubs.clear();
+ revItSub = sm->getDependsOnIterator( /*includeSelf=*/true, /*complexShapeFirst=*/true);
+ while ( revItSub->more() )
{
+ SMESH_subMesh* smToCheck = revItSub->next();
if ( smToCheck->GetSubShape().ShapeType() == TopAbs_VERTEX)
break;
- if ( aCheckedMap.find( aKey ) == aCheckedMap.end() )
- if (!checkMissing (this, aMesh, smToCheck, aTopAlgoDim,
- globalChecked, checkNoAlgo, aCheckedMap))
+ if ( aCheckedSubs.insert( smToCheck ).second ) // not yet checked
+ if (!checkMissing (this, theMesh, smToCheck, aTopAlgoDim,
+ globalChecked, checkNoAlgo, aCheckedSubs, 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 )
+ if ( !hasAlgo ) {
+ ret = false;
INFOS( "None algorithm attached" );
+ theErrors.push_back( TAlgoStateError() );
+ theErrors.back().Set( SMESH_Hypothesis::HYP_MISSING, 1, true );
+ }
- return ( ret && hasAlgo );
+ return ret;
}
//=======================================================================
-//function : IsGlobalAlgo
+//function : IsGlobalHypothesis
//purpose : check if theAlgo is attached to the main shape
//=======================================================================
-bool SMESH_Gen::IsGlobalAlgo(const SMESH_Algo* theAlgo, SMESH_Mesh& aMesh)
-{
- const SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
- TopoDS_Shape mainShape = meshDS->ShapeToMesh();
- const list<const SMESHDS_Hypothesis*>& listHyp = meshDS->GetHypothesis( mainShape );
- list<const SMESHDS_Hypothesis*>::const_iterator it=listHyp.begin();
- for ( ; it != listHyp.end(); it++)
- if ( *it == theAlgo )
- return true;
-
- return false;
-}
-
-
-//=======================================================================
-//function : getAlgoId
-//purpose : return algo ID or -1 if not found
-//=======================================================================
-
-static int getAlgo(const list<const SMESHDS_Hypothesis*>& theHypList,
- const int theAlgoDim,
- const int theAlgoShapeType)
+bool SMESH_Gen::IsGlobalHypothesis(const SMESH_Hypothesis* theHyp, SMESH_Mesh& aMesh)
{
- list<const SMESHDS_Hypothesis*>::const_iterator it = theHypList.begin();
-
- int nb_algo = 0;
- int algo_id = -1;
-
- while (it!=theHypList.end())
- {
- const SMESH_Hypothesis *anHyp = static_cast< const SMESH_Hypothesis *>( *it );
- if (anHyp->GetType() > SMESHDS_Hypothesis::PARAM_ALGO &&
- anHyp->GetDim() == theAlgoDim &&
- ((anHyp->GetShapeType()) & (1 << theAlgoShapeType)))
- {
- nb_algo++;
- algo_id = anHyp->GetID();
- break;
- }
-
- //if (nb_algo > 1) return -1; // more than one algo
- it++;
- }
-
- return algo_id;
+ SMESH_HypoFilter filter( SMESH_HypoFilter::Is( theHyp ));
+ return aMesh.GetHypothesis( aMesh.GetMeshDS()->ShapeToMesh(), filter, false );
}
//=============================================================================
/*!
- *
+ * Finds algo to mesh a shape. Optionally returns a shape the found algo is bound to
*/
//=============================================================================
-SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape)
+SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape,
+ TopoDS_Shape* assignedTo)
{
-// MESSAGE("SMESH_Gen::GetAlgo");
-
- const SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
- int dim = GetShapeDim( aShape );
- int shape_type = aShape.ShapeType();
- int algo_id = -1;
+ SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() );
+ filter.And( filter.IsApplicableTo( aShape ));
- algo_id = getAlgo( meshDS->GetHypothesis( aShape ), dim, shape_type );
-
- if (algo_id < 0)
- {
- // try ansestors
- TopTools_ListIteratorOfListOfShape ancIt( aMesh.GetAncestors( aShape ));
- for (; ancIt.More(); ancIt.Next())
- {
- const TopoDS_Shape& ancestor = ancIt.Value();
- algo_id = getAlgo( meshDS->GetHypothesis( ancestor ), dim, shape_type );
- if ( algo_id >= 0 )
- break;
- }
- if (algo_id < 0) return NULL;
- }
-
- ASSERT(_mapAlgo.find(algo_id) != _mapAlgo.end());
-
- return _mapAlgo[algo_id];
-
-// const SMESHDS_Hypothesis *theHyp = NULL;
-// SMESH_Algo *algo = NULL;
-// const SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
-// int hypType;
-// int hypId;
-// int algoDim;
-
-// // try shape first, then main shape
-
-// TopoDS_Shape mainShape = meshDS->ShapeToMesh();
-// const TopoDS_Shape *shapeToTry[2] = { &aShape, &mainShape };
-
-// for (int iShape = 0; iShape < 2; iShape++)
-// {
-// TopoDS_Shape tryShape = (*shapeToTry[iShape]);
-
-// const list<const SMESHDS_Hypothesis*>& listHyp =
-// meshDS->GetHypothesis(tryShape);
-// list<const SMESHDS_Hypothesis*>::const_iterator it=listHyp.begin();
-
-// int nb_algo = 0;
-// int shapeDim = GetShapeDim(aShape);
-// int typeOfShape = aShape.ShapeType();
-
-// while (it!=listHyp.end())
-// {
-// const SMESHDS_Hypothesis *anHyp = *it;
-// hypType = anHyp->GetType();
-// //SCRUTE(hypType);
-// if (hypType > SMESHDS_Hypothesis::PARAM_ALGO)
-// {
-// switch (hypType)
-// {
-// case SMESHDS_Hypothesis::ALGO_1D:
-// algoDim = 1;
-// break;
-// case SMESHDS_Hypothesis::ALGO_2D:
-// algoDim = 2;
-// break;
-// case SMESHDS_Hypothesis::ALGO_3D:
-// algoDim = 3;
-// break;
-// default:
-// algoDim = 0;
-// break;
-// }
-// //SCRUTE(algoDim);
-// //SCRUTE(shapeDim);
-// //SCRUTE(typeOfShape);
-// if (shapeDim == algoDim) // count only algos of shape dim.
-// { // discard algos for subshapes
-// hypId = anHyp->GetID(); // (of lower dim.)
-// ASSERT(_mapAlgo.find(hypId) != _mapAlgo.end());
-// SMESH_Algo *anAlgo = _mapAlgo[hypId];
-// //SCRUTE(anAlgo->GetShapeType());
-// //if (anAlgo->GetShapeType() == typeOfShape)
-// if ((anAlgo->GetShapeType()) & (1 << typeOfShape))
-// { // only specific TopoDS_Shape
-// nb_algo++;
-// theHyp = anHyp;
-// }
-// }
-// }
-// if (nb_algo > 1) return NULL; // more than one algo
-// it++;
-// }
-// if (nb_algo == 1) // one algo found : OK
-// break; // do not try a parent shape
-// }
-
-// if (!theHyp)
-// return NULL; // no algo found
-
-// hypType = theHyp->GetType();
-// hypId = theHyp->GetID();
-
-// ASSERT(_mapAlgo.find(hypId) != _mapAlgo.end());
-// algo = _mapAlgo[hypId];
-// //MESSAGE("Algo found " << algo->GetName() << " Id " << hypId);
-// return algo;
+ return (SMESH_Algo*) aMesh.GetHypothesis( aShape, filter, true, assignedTo );
}
//=============================================================================
/*!
- *
+ * Returns StudyContextStruct for a study
*/
//=============================================================================
StudyContextStruct *SMESH_Gen::GetStudyContext(int studyId)
{
- // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
-
- if (_mapStudyContext.find(studyId) == _mapStudyContext.end())
- {
- _mapStudyContext[studyId] = new StudyContextStruct;
- _mapStudyContext[studyId]->myDocument = new SMESHDS_Document(studyId);
- }
- StudyContextStruct *myStudyContext = _mapStudyContext[studyId];
-// ASSERT(_mapStudyContext.find(studyId) != _mapStudyContext.end());
- return myStudyContext;
-}
-
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
+ // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
-void SMESH_Gen::Save(int studyId, const char *aUrlOfFile)
-{
-}
-
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-
-void SMESH_Gen::Load(int studyId, const char *aUrlOfFile)
-{
-}
-
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-
-void SMESH_Gen::Close(int studyId)
-{
+ if (_mapStudyContext.find(studyId) == _mapStudyContext.end())
+ {
+ _mapStudyContext[studyId] = new StudyContextStruct;
+ _mapStudyContext[studyId]->myDocument = new SMESHDS_Document(studyId);
+ }
+ StudyContextStruct *myStudyContext = _mapStudyContext[studyId];
+ return myStudyContext;
}
-//=============================================================================
+//================================================================================
/*!
- *
+ * \brief Return shape dimension by TopAbs_ShapeEnum
*/
-//=============================================================================
+//================================================================================
int SMESH_Gen::GetShapeDim(const TopAbs_ShapeEnum & aShapeType)
{
- int shapeDim = -1; // Shape dimension: 0D, 1D, 2D, 3D
- int type = aShapeType;//.ShapeType();
- switch (type)
- {
- case TopAbs_COMPOUND:
- case TopAbs_COMPSOLID:
- case TopAbs_SOLID:
- case TopAbs_SHELL:
- {
- shapeDim = 3;
- break;
- }
- // case TopAbs_SHELL:
- case TopAbs_FACE:
- {
- shapeDim = 2;
- break;
- }
- case TopAbs_WIRE:
- case TopAbs_EDGE:
- {
- shapeDim = 1;
- break;
- }
- case TopAbs_VERTEX:
- {
- shapeDim = 0;
- break;
- }
- }
- return shapeDim;
+ static vector<int> dim;
+ if ( dim.empty() )
+ {
+ dim.resize( TopAbs_SHAPE, -1 );
+ dim[ TopAbs_COMPOUND ] = MeshDim_3D;
+ dim[ TopAbs_COMPSOLID ] = MeshDim_3D;
+ dim[ TopAbs_SOLID ] = MeshDim_3D;
+ dim[ TopAbs_SHELL ] = MeshDim_3D;
+ dim[ TopAbs_FACE ] = MeshDim_2D;
+ dim[ TopAbs_WIRE ] = MeshDim_1D;
+ dim[ TopAbs_EDGE ] = MeshDim_1D;
+ dim[ TopAbs_VERTEX ] = MeshDim_0D;
+ }
+ return dim[ aShapeType ];
}
//=============================================================================
/*!
- *
+ * Genarate a new id unique withing this Gen
*/
//=============================================================================
int SMESH_Gen::GetANewId()
{
- //MESSAGE("SMESH_Gen::GetANewId");
- return _hypId++;
+ return _hypId++;
}