-// SMESH SMESH : implementaion of SMESH idl descriptions
+// Copyright (C) 2007-2008 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$
#include "SMESH_Gen.hxx"
#include "SMESH_subMesh.hxx"
#include "SMESH_HypoFilter.hxx"
+#include "SMESHDS_Document.hxx"
#include "SMDS_MeshElement.hxx"
#include "SMDS_MeshNode.hxx"
MESSAGE("SMESH_Gen::SMESH_Gen");
_localId = 0;
_hypId = 0;
+ _segmentation = 10;
}
//=============================================================================
//=============================================================================
/*!
- *
+ * Compute a mesh
*/
//=============================================================================
-bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape)
+bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape,
+ const bool anUpward,
+ const ::MeshDimension aDim,
+ 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)
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
- // -----------------------------------------------------------------
+ const bool includeSelf = true;
+ const bool complexShapeFirst = true;
- // 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_subMeshIteratorPtr smIt;
- SMESH_subMesh* smToCompute = sm;
- while ( smToCompute )
+ if ( anUpward ) // is called from below code here
{
- 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 {
- }
- }
- if (!ret)
- return false;
-
- // next subMesh
- if (revItSub != smMap.rend())
+ // -----------------------------------------------
+ // mesh all the subshapes starting from vertices
+ // -----------------------------------------------
+ smIt = sm->getDependsOnIterator(includeSelf, !complexShapeFirst);
+ while ( smIt->more() )
{
- smToCompute = (*revItSub).second;
- revItSub++;
- }
- else
- smToCompute = 0;
- }
+ SMESH_subMesh* smToCompute = smIt->next();
- // -----------------------------------------------
- // mesh the rest subshapes starting from vertices
- // -----------------------------------------------
+ // do not mesh vertices of a pseudo shape
+ const TopAbs_ShapeEnum aShType = smToCompute->GetSubShape().ShapeType();
+ if ( !aMesh.HasShapeToMesh() && aShType == TopAbs_VERTEX )
+ continue;
- 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) {
+ // 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;
+ }
+
+ if (smToCompute->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE)
+ smToCompute->ComputeStateEngine( SMESH_subMesh::COMPUTE );
+
+ // 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;
- continue;
+ else if ( aShapesId )
+ aShapesId->insert( smToCompute->GetId() );
}
- TopoDS_Shape subShape = smToCompute->GetSubShape();
- if ( subShape.ShapeType() != TopAbs_VERTEX )
+ 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;
+ smIt = sm->getDependsOnIterator(includeSelf, complexShapeFirst);
+ while ( smIt->more() )
{
- if ( !smToCompute->ComputeStateEngine(SMESH_subMesh::COMPUTE) )
- ret = false;
+ SMESH_subMesh* smToCompute = smIt->next();
+ if ( smToCompute->GetComputeState() != SMESH_subMesh::READY_TO_COMPUTE )
+ continue;
+
+ const TopoDS_Shape& aSubShape = smToCompute->GetSubShape();
+ const 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 );
+ if ( algo && !algo->NeedDescretBoundary() )
+ {
+ if ( algo->SupportSubmeshes() )
+ smWithAlgoSupportingSubmeshes.push_back( smToCompute );
+ else
+ {
+ smToCompute->ComputeStateEngine( SMESH_subMesh::COMPUTE );
+ if ( aShapesId )
+ aShapesId->insert( smToCompute->GetId() );
+ }
+ }
}
- else
+ // ------------------------------------------------------------
+ // compute submeshes under shapes with algos that DO NOT require
+ // descretized boundaries and DO support submeshes
+ // ------------------------------------------------------------
+ list< SMESH_subMesh* >::reverse_iterator subIt, subEnd;
+ subIt = smWithAlgoSupportingSubmeshes.rbegin();
+ subEnd = smWithAlgoSupportingSubmeshes.rend();
+ // start from lower shapes
+ for ( ; 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;
+
+ // 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 ( 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.rbegin(); subIt != subEnd; ++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;
+
+ sm->ComputeStateEngine( SMESH_subMesh::COMPUTE );
+ 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);
return ret;
}
-
//=======================================================================
//function : checkConformIgnoredAlgos
//purpose :
"> 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 );
+ theErrors.back().Set( SMESH_Hypothesis::HYP_NOTCONFORM, algo, false );
}
// sub-algos will be hidden by a local <algo>
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_Gen::MISSING_ALGO, shapeDim, true );
+ theErrors.back().Set( SMESH_Hypothesis::HYP_MISSING, shapeDim, true );
}
}
return ret;
bool IsGlobalHypothesis = aGen->IsGlobalHypothesis( algo, aMesh );
if (!IsGlobalHypothesis || !globalChecked[ algo->GetDim() ])
{
- INFOS( "ERROR: " << (IsGlobalHypothesis ? "Global " : "Local ")
- << "<" << algo->GetName() << "> misses some hypothesis");
+ 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( SMESH_Gen::MISSING_HYPO, algo, IsGlobalHypothesis );
+ theErrors.back().Set( errName, algo, IsGlobalHypothesis );
}
ret = false;
break;
// --------------------------------------------------------
- // 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--)
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 theShape and its sub-shapes
ret = false;
INFOS( "None algorithm attached" );
theErrors.push_back( TAlgoStateError() );
- theErrors.back().Set( MISSING_ALGO, 1, true );
+ theErrors.back().Set( SMESH_Hypothesis::HYP_MISSING, 1, true );
}
return ret;
*/
//=============================================================================
-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");
SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() );
filter.And( filter.IsApplicableTo( aShape ));
- list <const SMESHDS_Hypothesis * > algoList;
- aMesh.GetHypotheses( aShape, filter, algoList, true );
-
- if ( algoList.empty() )
- return NULL;
-
- // Now it is checked in SMESH_Mesh::GetHypotheses()
-// if (algoList.size() > 1 ) { // check if there is one algo several times
-// list <const SMESHDS_Hypothesis * >::iterator algo = algoList.begin();
-// for ( ; algo != algoList.end(); ++algo )
-// if ( (*algo) != algoList.front() &&
-// (*algo)->GetName() != algoList.front()->GetName() )
-// return NULL;
-// }
-
- return const_cast<SMESH_Algo*> ( static_cast<const SMESH_Algo* >( algoList.front() ));
+ return (SMESH_Algo*) aMesh.GetHypothesis( aShape, filter, true, assignedTo );
}
//=============================================================================
return myStudyContext;
}
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
+// //=============================================================================
+// /*!
+// *
+// */
+// //=============================================================================
-void SMESH_Gen::Save(int studyId, const char *aUrlOfFile)
-{
-}
+// void SMESH_Gen::Save(int studyId, const char *aUrlOfFile)
+// {
+// }
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
+// //=============================================================================
+// /*!
+// *
+// */
+// //=============================================================================
-void SMESH_Gen::Load(int studyId, const char *aUrlOfFile)
-{
-}
+// void SMESH_Gen::Load(int studyId, const char *aUrlOfFile)
+// {
+// }
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
+// //=============================================================================
+// /*!
+// *
+// */
+// //=============================================================================
-void SMESH_Gen::Close(int studyId)
-{
-}
+// void SMESH_Gen::Close(int studyId)
+// {
+// }
//=============================================================================
/*!
if ( dim.empty() )
{
dim.resize( TopAbs_SHAPE, -1 );
- dim[ TopAbs_COMPOUND ] = 3;
- dim[ TopAbs_COMPSOLID ] = 3;
- dim[ TopAbs_SOLID ] = 3;
- dim[ TopAbs_SHELL ] = 3;
- dim[ TopAbs_FACE ] = 2;
- dim[ TopAbs_WIRE ] = 1;
- dim[ TopAbs_EDGE ] = 1;
- dim[ TopAbs_VERTEX ] = 0;
+ 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 ];
}
