// 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_Mesh* SMESH_Gen::CreateMesh(int studyId)
-throw(SALOME_Exception)
+SMESH_Mesh* SMESH_Gen::CreateMesh(int theStudyId, bool theIsEmbeddedMode)
+ throw(SALOME_Exception)
{
- 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!")));
-// }
+ Unexpect aCatch(SalomeException);
+ MESSAGE("SMESH_Gen::CreateMesh");
- // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
-
- StudyContextStruct *myStudyContext = GetStudyContext(studyId);
-
- // create a new SMESH_mesh object
+ // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
+ StudyContextStruct *aStudyContext = GetStudyContext(theStudyId);
- SMESH_Mesh *mesh = new SMESH_Mesh(_localId++,
- studyId,
- this,
- myStudyContext->myDocument);
- myStudyContext->mapMesh[_localId] = mesh;
+ // create a new SMESH_mesh object
+ SMESH_Mesh *aMesh = new SMESH_Mesh(_localId++,
+ theStudyId,
+ this,
+ theIsEmbeddedMode,
+ aStudyContext->myDocument);
+ aStudyContext->mapMesh[_localId] = aMesh;
- // associate a TopoDS_Shape to the mesh
-
-//mesh->ShapeToMesh(aShape);
- return mesh;
+ return aMesh;
}
//=============================================================================
const SMESH_Algo* aGlobIgnoAlgo,
const SMESH_Algo* aLocIgnoAlgo,
bool & checkConform,
- map<int, SMESH_subMesh*>& aCheckedMap)
+ map<int, 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_Gen::NOT_CONFORM_MESH, 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;
bool checkConform2 = false;
- for ( revItSub = smMap.rbegin(); revItSub != smMap.rend(); revItSub++)
+ for ( revItSub = smMap.rbegin(); revItSub != smMap.rend(); revItSub++)
{
checkConformIgnoredAlgos (aMesh, (*revItSub).second, aGlobIgnoAlgo,
- algo, checkConform2, aCheckedMap);
+ algo, checkConform2, aCheckedMap, theErrors);
int key = (*revItSub).first;
SMESH_subMesh* sm = (*revItSub).second;
if ( aCheckedMap.find( key ) == aCheckedMap.end() )
const int aTopAlgoDim,
bool* globalChecked,
const bool checkNoAlgo,
- map<int, SMESH_subMesh*>& aCheckedMap)
+ map<int, SMESH_subMesh*>& aCheckedMap,
+ list< SMESH_Gen::TAlgoStateError > & theErrors)
{
if ( aSubMesh->GetSubShape().ShapeType() == TopAbs_VERTEX)
return true;
{
INFOS( "ERROR: " << shapeDim << "D algorithm is missing" );
ret = false;
+ theErrors.push_back( SMESH_Gen::TAlgoStateError() );
+ theErrors.back().Set( SMESH_Gen::MISSING_ALGO, shapeDim, true );
}
}
return ret;
<< "<" << 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 );
}
ret = false;
break;
//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();
// -----------------
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() );
+ bool checkConform = ( !theMesh.IsNotConformAllowed() );
int aKey = 1;
SMESH_subMesh* smToCheck = sm;
- // loop on aShape and its sub-shapes
+ // loop on theShape and its sub-shapes
while ( smToCheck )
{
if ( smToCheck->GetSubShape().ShapeType() == TopAbs_VERTEX)
break;
if ( aCheckedMap.find( aKey ) == aCheckedMap.end() )
- if (!checkConformIgnoredAlgos (aMesh, smToCheck, aGlobIgnoAlgo,
- 0, checkConform, aCheckedMap))
+ if (!checkConformIgnoredAlgos (theMesh, smToCheck, aGlobIgnoAlgo,
+ 0, checkConform, aCheckedMap, theErrors))
ret = false;
if ( smToCheck->GetAlgoState() != SMESH_subMesh::NO_ALGO )
bool checkNoAlgo = (bool) aTopAlgoDim;
bool globalChecked[] = { false, false, false, false };
- // loop on aShape and its sub-shapes
+ // loop on theShape and its sub-shapes
while ( smToCheck )
{
if ( smToCheck->GetSubShape().ShapeType() == TopAbs_VERTEX)
break;
if ( aCheckedMap.find( aKey ) == aCheckedMap.end() )
- if (!checkMissing (this, aMesh, smToCheck, aTopAlgoDim,
- globalChecked, checkNoAlgo, aCheckedMap))
+ if (!checkMissing (this, theMesh, smToCheck, aTopAlgoDim,
+ globalChecked, checkNoAlgo, aCheckedMap, theErrors))
{
ret = false;
if (smToCheck->GetAlgoState() == SMESH_subMesh::NO_ALGO )
smToCheck = 0;
}
- if ( !hasAlgo )
+ if ( !hasAlgo ) {
+ ret = false;
INFOS( "None algorithm attached" );
+ theErrors.push_back( TAlgoStateError() );
+ theErrors.back().Set( MISSING_ALGO, 1, true );
+ }
- return ( ret && hasAlgo );
+ return ret;
}
//=======================================================================
if ( algoList.empty() )
return NULL;
- 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;
- }
+ // 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() ));
}
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 ] = 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;
+ }
+ return dim[ aShapeType ];
}
//=============================================================================