#include "DriverSTL_R_SMDS_Mesh.h"
#include <BRepTools_WireExplorer.hxx>
+#include <BRepPrimAPI_MakeBox.hxx>
#include <BRep_Builder.hxx>
#include <gp_Pnt.hxx>
static int MYDEBUG = 0;
#endif
+#define cSMESH_Hyp(h) static_cast<const SMESH_Hypothesis*>(h)
+
+typedef SMESH_HypoFilter THypType;
//=============================================================================
/*!
*/
//=============================================================================
-SMESH_Mesh::SMESH_Mesh(int theLocalId,
- int theStudyId,
- SMESH_Gen* theGen,
- bool theIsEmbeddedMode,
+SMESH_Mesh::SMESH_Mesh(int theLocalId,
+ int theStudyId,
+ SMESH_Gen* theGen,
+ bool theIsEmbeddedMode,
SMESHDS_Document* theDocument):
_groupId( 0 )
{
- INFOS("SMESH_Mesh::SMESH_Mesh(int localId)");
- _id = theLocalId;
- _studyId = theStudyId;
- _gen = theGen;
- _myDocument = theDocument;
- _idDoc = theDocument->NewMesh(theIsEmbeddedMode);
- _myMeshDS = theDocument->GetMesh(_idDoc);
+ MESSAGE("SMESH_Mesh::SMESH_Mesh(int localId)");
+ _id = theLocalId;
+ _studyId = theStudyId;
+ _gen = theGen;
+ _myDocument = theDocument;
+ _idDoc = theDocument->NewMesh(theIsEmbeddedMode);
+ _myMeshDS = theDocument->GetMesh(_idDoc);
_isShapeToMesh = false;
+ _isAutoColor = false;
+ _myMeshDS->ShapeToMesh( PseudoShape() );
}
//=============================================================================
//=============================================================================
/*!
- *
+ * \brief Set geometry to be meshed
*/
//=============================================================================
{
if(MYDEBUG) MESSAGE("SMESH_Mesh::ShapeToMesh");
- if ( !_myMeshDS->ShapeToMesh().IsNull() && aShape.IsNull() )
+ if ( !aShape.IsNull() && _isShapeToMesh )
+ throw SALOME_Exception(LOCALIZED ("a shape to mesh has already been defined"));
+
+ // clear current data
+ if ( !_myMeshDS->ShapeToMesh().IsNull() )
{
// removal of a shape to mesh, delete objects referring to sub-shapes:
// - sub-meshes
else
i_gr++;
}
- _mapPropagationChains.Clear();
+ _mapAncestors.Clear();
+
+ // clear SMESHDS
+ TopoDS_Shape aNullShape;
+ _myMeshDS->ShapeToMesh( aNullShape );
}
- else
+
+ // set a new geometry
+ if ( !aShape.IsNull() )
{
- if (_isShapeToMesh)
- throw SALOME_Exception(LOCALIZED ("a shape to mesh has already been defined"));
+ _myMeshDS->ShapeToMesh(aShape);
+ _isShapeToMesh = true;
+
+ // fill _mapAncestors
+ int desType, ancType;
+ for ( desType = TopAbs_VERTEX; desType > TopAbs_COMPOUND; desType-- )
+ for ( ancType = desType - 1; ancType >= TopAbs_COMPOUND; ancType-- )
+ TopExp::MapShapesAndAncestors ( aShape,
+ (TopAbs_ShapeEnum) desType,
+ (TopAbs_ShapeEnum) ancType,
+ _mapAncestors );
}
- _isShapeToMesh = true;
- _myMeshDS->ShapeToMesh(aShape);
-
- // fill _mapAncestors
- _mapAncestors.Clear();
- int desType, ancType;
- for ( desType = TopAbs_VERTEX; desType > TopAbs_COMPOUND; desType-- )
- for ( ancType = desType - 1; ancType >= TopAbs_COMPOUND; ancType-- )
- TopExp::MapShapesAndAncestors ( aShape,
- (TopAbs_ShapeEnum) desType,
- (TopAbs_ShapeEnum) ancType,
- _mapAncestors );
-
- // NRI : 24/02/03
- //EAP: 1/9/04 TopExp::MapShapes(aShape, _subShapes); USE the same map of _myMeshDS
+}
+
+//=======================================================================
+/*!
+ * \brief Return geometry to be meshed. (It may be a PseudoShape()!)
+ */
+//=======================================================================
+
+TopoDS_Shape SMESH_Mesh::GetShapeToMesh() const
+{
+ return _myMeshDS->ShapeToMesh();
+}
+
+//=======================================================================
+/*!
+ * \brief Return a solid which is returned by GetShapeToMesh() if
+ * a real geometry to be meshed was not set
+ */
+//=======================================================================
+
+const TopoDS_Solid& SMESH_Mesh::PseudoShape()
+{
+ static TopoDS_Solid aSolid;
+ if ( aSolid.IsNull() )
+ {
+ aSolid = BRepPrimAPI_MakeBox(1,1,1);
+ }
+ return aSolid;
}
//=======================================================================
if(MYDEBUG) MESSAGE("UNVToMesh - theFileName = "<<theFileName);
if(_isShapeToMesh)
throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
- _isShapeToMesh = true;
+ _isShapeToMesh = false;
DriverUNV_R_SMDS_Mesh myReader;
myReader.SetMesh(_myMeshDS);
myReader.SetFile(theFileName);
if(MYDEBUG) MESSAGE("MEDToMesh - theFileName = "<<theFileName<<", mesh name = "<<theMeshName);
if(_isShapeToMesh)
throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
- _isShapeToMesh = true;
+ _isShapeToMesh = false;
DriverMED_R_SMESHDS_Mesh myReader;
myReader.SetMesh(_myMeshDS);
myReader.SetMeshId(-1);
if(MYDEBUG) MESSAGE("STLToMesh - theFileName = "<<theFileName);
if(_isShapeToMesh)
throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
- _isShapeToMesh = true;
+ _isShapeToMesh = false;
DriverSTL_R_SMDS_Mesh myReader;
myReader.SetMesh(_myMeshDS);
myReader.SetFile(theFileName);
if ( ret < aBestRet )
aBestRet = ret;
}
+ // bind hypotheses to a group just to know
+ SMESH_Hypothesis *anHyp = _gen->GetStudyContext(_studyId)->mapHypothesis[anHypId];
+ GetMeshDS()->AddHypothesis( aSubShape, anHyp );
+
if ( SMESH_Hypothesis::IsStatusFatal( aBestRet ))
return aBestRet;
return aWorstNotFatal;
// shape
- int event;
- if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
- event = SMESH_subMesh::ADD_HYP;
- else
- event = SMESH_subMesh::ADD_ALGO;
+ bool isAlgo = ( !anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO );
+ int event = isAlgo ? SMESH_subMesh::ADD_ALGO : SMESH_subMesh::ADD_HYP;
+
SMESH_Hypothesis::Hypothesis_Status ret = subMesh->AlgoStateEngine(event, anHyp);
// subShapes
if (!SMESH_Hypothesis::IsStatusFatal(ret) &&
- !subMesh->IsApplicableHypotesis( anHyp )) // is added on father
+ anHyp->GetDim() <= SMESH_Gen::GetShapeDim(aSubShape)) // is added on father
{
- if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
- event = SMESH_subMesh::ADD_FATHER_HYP;
- else
- event = SMESH_subMesh::ADD_FATHER_ALGO;
+ event = isAlgo ? SMESH_subMesh::ADD_FATHER_ALGO : SMESH_subMesh::ADD_FATHER_HYP;
+
SMESH_Hypothesis::Hypothesis_Status ret2 =
subMesh->SubMeshesAlgoStateEngine(event, anHyp);
if (ret2 > ret)
// check concurent hypotheses on ansestors
if (ret < SMESH_Hypothesis::HYP_CONCURENT && !isGlobalHyp )
{
- const map < int, SMESH_subMesh * >& smMap = subMesh->DependsOn();
- map < int, SMESH_subMesh * >::const_iterator smIt = smMap.begin();
- for ( ; smIt != smMap.end(); smIt++ ) {
- if ( smIt->second->IsApplicableHypotesis( anHyp )) {
- ret2 = smIt->second->CheckConcurentHypothesis( anHyp->GetType() );
+ SMESH_subMeshIteratorPtr smIt = subMesh->getDependsOnIterator(false,false);
+ while ( smIt->more() ) {
+ SMESH_subMesh* sm = smIt->next();
+ if ( sm->IsApplicableHypotesis( anHyp )) {
+ ret2 = sm->CheckConcurentHypothesis( anHyp->GetType() );
if (ret2 > ret) {
ret = ret2;
break;
if ( ret < aBestRet )
aBestRet = ret;
}
+ SMESH_Hypothesis *anHyp = _gen->GetStudyContext(_studyId)->mapHypothesis[anHypId];
+ GetMeshDS()->RemoveHypothesis( aSubShape, anHyp );
+
if ( SMESH_Hypothesis::IsStatusFatal( aBestRet ))
return aBestRet;
return aWorstNotFatal;
SMESH_Hypothesis *anHyp = sc->mapHypothesis[anHypId];
int hypType = anHyp->GetType();
if(MYDEBUG) SCRUTE(hypType);
- int event;
// shape
- if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
- event = SMESH_subMesh::REMOVE_HYP;
- else
- event = SMESH_subMesh::REMOVE_ALGO;
+ bool isAlgo = ( !anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO );
+ int event = isAlgo ? SMESH_subMesh::REMOVE_ALGO : SMESH_subMesh::REMOVE_HYP;
+
SMESH_Hypothesis::Hypothesis_Status ret = subMesh->AlgoStateEngine(event, anHyp);
// there may appear concurrent hyps that were covered by the removed hyp
// subShapes
if (!SMESH_Hypothesis::IsStatusFatal(ret) &&
- !subMesh->IsApplicableHypotesis( anHyp )) // is removed from father
+ anHyp->GetDim() <= SMESH_Gen::GetShapeDim(aSubShape)) // is removed from father
{
- if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
- event = SMESH_subMesh::REMOVE_FATHER_HYP;
- else
- event = SMESH_subMesh::REMOVE_FATHER_ALGO;
+ event = isAlgo ? SMESH_subMesh::REMOVE_FATHER_ALGO : SMESH_subMesh::REMOVE_FATHER_HYP;
+
SMESH_Hypothesis::Hypothesis_Status ret2 =
subMesh->SubMeshesAlgoStateEngine(event, anHyp);
if (ret2 > ret) // more severe
// check concurent hypotheses on ansestors
if (ret < SMESH_Hypothesis::HYP_CONCURENT && !IsMainShape( aSubShape ) )
{
- const map < int, SMESH_subMesh * >& smMap = subMesh->DependsOn();
- map < int, SMESH_subMesh * >::const_iterator smIt = smMap.begin();
- for ( ; smIt != smMap.end(); smIt++ ) {
- if ( smIt->second->IsApplicableHypotesis( anHyp )) {
- ret2 = smIt->second->CheckConcurentHypothesis( anHyp->GetType() );
+ SMESH_subMeshIteratorPtr smIt = subMesh->getDependsOnIterator(false,false);
+ while ( smIt->more() ) {
+ SMESH_subMesh* sm = smIt->next();
+ if ( sm->IsApplicableHypotesis( anHyp )) {
+ ret2 = sm->CheckConcurentHypothesis( anHyp->GetType() );
if (ret2 > ret) {
ret = ret2;
break;
*/
//=============================================================================
-SMESHDS_Mesh * SMESH_Mesh::GetMeshDS()
-{
- return _myMeshDS;
-}
-
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-
const list<const SMESHDS_Hypothesis*>&
SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const
throw(SALOME_Exception)
}
//=======================================================================
-//function : GetHypothesis
-//purpose :
+/*!
+ * \brief Return the hypothesis assigned to the shape
+ * \param aSubShape - the shape to check
+ * \param aFilter - the hypothesis filter
+ * \param andAncestors - flag to check hypos assigned to ancestors of the shape
+ * \retval SMESH_Hypothesis* - the first hypo passed through aFilter
+ */
//=======================================================================
const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const TopoDS_Shape & aSubShape,
const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
for ( ; hyp != hypList.end(); hyp++ ) {
- const SMESH_Hypothesis * h = static_cast<const SMESH_Hypothesis*>( *hyp );
+ const SMESH_Hypothesis * h = cSMESH_Hyp( *hyp );
if ( aFilter.IsOk( h, aSubShape))
return h;
}
const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(it.Value());
list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
for ( ; hyp != hypList.end(); hyp++ ) {
- const SMESH_Hypothesis * h = static_cast<const SMESH_Hypothesis*>( *hyp );
+ const SMESH_Hypothesis * h = cSMESH_Hyp( *hyp );
if (aFilter.IsOk( h, it.Value() ))
return h;
}
return 0;
}
-//=======================================================================
-//function : GetHypotheses
-//purpose :
-//=======================================================================
-
//================================================================================
/*!
* \brief Return hypothesis assigned to the shape
set<string> hypTypes; // to exclude same type hypos from the result list
int nbHyps = 0;
+ // only one main hypothesis is allowed
+ bool mainHypFound = false;
+
// fill in hypTypes
list<const SMESHDS_Hypothesis*>::const_iterator hyp;
- for ( hyp = aHypList.begin(); hyp != aHypList.end(); hyp++ )
+ for ( hyp = aHypList.begin(); hyp != aHypList.end(); hyp++ ) {
if ( hypTypes.insert( (*hyp)->GetName() ).second )
nbHyps++;
+ if ( !cSMESH_Hyp(*hyp)->IsAuxiliary() )
+ mainHypFound = true;
+ }
// get hypos from aSubShape
{
const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ )
- if ( aFilter.IsOk (static_cast<const SMESH_Hypothesis*>( *hyp ), aSubShape) &&
+ if ( aFilter.IsOk (cSMESH_Hyp( *hyp ), aSubShape) &&
+ ( cSMESH_Hyp(*hyp)->IsAuxiliary() || !mainHypFound ) &&
hypTypes.insert( (*hyp)->GetName() ).second )
{
aHypList.push_back( *hyp );
nbHyps++;
+ if ( !cSMESH_Hyp(*hyp)->IsAuxiliary() )
+ mainHypFound = true;
}
}
continue;
const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(it.Value());
for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ )
- if (aFilter.IsOk( static_cast<const SMESH_Hypothesis*>( *hyp ), it.Value() ) &&
- hypTypes.insert( (*hyp)->GetName() ).second ) {
+ if (aFilter.IsOk( cSMESH_Hyp( *hyp ), it.Value() ) &&
+ ( cSMESH_Hyp(*hyp)->IsAuxiliary() || !mainHypFound ) &&
+ hypTypes.insert( (*hyp)->GetName() ).second )
+ {
aHypList.push_back( *hyp );
nbHyps++;
+ if ( !cSMESH_Hyp(*hyp)->IsAuxiliary() )
+ mainHypFound = true;
}
}
}
_myMeshDS->GetScript()->Clear();
}
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-
-int SMESH_Mesh::GetId()
-{
- if(MYDEBUG) MESSAGE("SMESH_Mesh::GetId");
- return _id;
-}
-
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-
-SMESH_Gen *SMESH_Mesh::GetGen()
-{
- return _gen;
-}
-
//=============================================================================
/*!
* Get or Create the SMESH_subMesh object implementation
//purpose : Say all submeshes using theChangedHyp that it has been modified
//=======================================================================
-void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* theChangedHyp)
+void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* hyp)
{
Unexpect aCatch(SalomeException);
- const SMESH_Hypothesis* hyp = static_cast<const SMESH_Hypothesis*>(theChangedHyp);
-
const SMESH_Algo *foundAlgo = 0;
- SMESH_HypoFilter algoKind( SMESH_HypoFilter::IsAlgo() );
- SMESH_HypoFilter compatibleHypoKind;
+ SMESH_HypoFilter algoKind, compatibleHypoKind;
list <const SMESHDS_Hypothesis * > usedHyps;
const TopoDS_Shape & aSubShape = aSubMesh->GetSubShape();
if ( !foundAlgo ) // init filter for algo search
- algoKind.And( algoKind.IsApplicableTo( aSubShape ));
+ algoKind.Init( THypType::IsAlgo() ).And( THypType::IsApplicableTo( aSubShape ));
const SMESH_Algo *algo = static_cast<const SMESH_Algo*>
( GetHypothesis( aSubShape, algoKind, true ));
if ( GetHypotheses( aSubShape, compatibleHypoKind, usedHyps, true ) &&
find( usedHyps.begin(), usedHyps.end(), hyp ) != usedHyps.end() )
{
- aSubMesh->ComputeStateEngine(SMESH_subMesh::MODIF_HYP);
-
- if ( algo->GetDim() == 1 && IsPropagationHypothesis( aSubShape ))
- CleanMeshOnPropagationChain( aSubShape );
+ aSubMesh->AlgoStateEngine(SMESH_subMesh::MODIF_HYP,
+ const_cast< SMESH_Hypothesis*>( hyp ));
}
}
}
}
}
+//=============================================================================
+/*!
+ * Auto color functionality
+ */
+//=============================================================================
+void SMESH_Mesh::SetAutoColor(bool theAutoColor) throw(SALOME_Exception)
+{
+ Unexpect aCatch(SalomeException);
+ _isAutoColor = theAutoColor;
+}
+
+bool SMESH_Mesh::GetAutoColor() throw(SALOME_Exception)
+{
+ Unexpect aCatch(SalomeException);
+ return _isAutoColor;
+}
+
//=============================================================================
/*! Export* methods.
* To store mesh contents on disk in different formats.
myWriter.Perform();
}
-//=============================================================================
+//================================================================================
/*!
- *
+ * \brief Return number of nodes in the mesh
*/
-//=============================================================================
+//================================================================================
+
int SMESH_Mesh::NbNodes() throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
return _myMeshDS->NbNodes();
}
-//=============================================================================
+//================================================================================
/*!
- *
+ * \brief Return number of edges of given order in the mesh
*/
-//=============================================================================
-int SMESH_Mesh::NbEdges(ElementOrder order) throw(SALOME_Exception)
+//================================================================================
+
+int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
- if (order == ORDER_ANY)
- return _myMeshDS->NbEdges();
-
- int Nb = 0;
- SMDS_EdgeIteratorPtr it = _myMeshDS->edgesIterator();
- while (it->more()) {
- const SMDS_MeshEdge* cur = it->next();
- if ( order == ORDER_LINEAR && !cur->IsQuadratic() ||
- order == ORDER_QUADRATIC && cur->IsQuadratic() )
- Nb++;
- }
- return Nb;
+ return _myMeshDS->GetMeshInfo().NbEdges(order);
}
-//=============================================================================
+//================================================================================
/*!
- *
+ * \brief Return number of faces of given order in the mesh
*/
-//=============================================================================
-int SMESH_Mesh::NbFaces(ElementOrder order) throw(SALOME_Exception)
+//================================================================================
+
+int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
- if (order == ORDER_ANY)
- return _myMeshDS->NbFaces();
-
- int Nb = 0;
- SMDS_FaceIteratorPtr it = _myMeshDS->facesIterator();
- while (it->more()) {
- const SMDS_MeshFace* cur = it->next();
- if ( order == ORDER_LINEAR && !cur->IsQuadratic() ||
- order == ORDER_QUADRATIC && cur->IsQuadratic() )
- Nb++;
- }
- return Nb;
+ return _myMeshDS->GetMeshInfo().NbFaces(order);
}
-///////////////////////////////////////////////////////////////////////////////
-/// Return the number of 3 nodes faces in the mesh. This method run in O(n)
-///////////////////////////////////////////////////////////////////////////////
-int SMESH_Mesh::NbTriangles(ElementOrder order) throw(SALOME_Exception)
+//================================================================================
+/*!
+ * \brief Return the number of faces in the mesh
+ */
+//================================================================================
+
+int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
- int Nb = 0;
-
- SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
- while (itFaces->more()) {
- const SMDS_MeshFace* curFace = itFaces->next();
- int nbnod = curFace->NbNodes();
- if ( !curFace->IsPoly() &&
- ( order == ORDER_ANY && (nbnod==3 || nbnod==6) ||
- order == ORDER_LINEAR && nbnod==3 ||
- order == ORDER_QUADRATIC && nbnod==6 ) )
- Nb++;
- }
- return Nb;
+ return _myMeshDS->GetMeshInfo().NbTriangles(order);
}
-///////////////////////////////////////////////////////////////////////////////
-/// Return the number of 4 nodes faces in the mesh. This method run in O(n)
-///////////////////////////////////////////////////////////////////////////////
-int SMESH_Mesh::NbQuadrangles(ElementOrder order) throw(SALOME_Exception)
+//================================================================================
+/*!
+ * \brief Return the number nodes faces in the mesh
+ */
+//================================================================================
+
+int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
- int Nb = 0;
-
- SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
- while (itFaces->more()) {
- const SMDS_MeshFace* curFace = itFaces->next();
- int nbnod = curFace->NbNodes();
- if ( !curFace->IsPoly() &&
- ( order == ORDER_ANY && (nbnod==4 || nbnod==8) ||
- order == ORDER_LINEAR && nbnod==4 ||
- order == ORDER_QUADRATIC && nbnod==8 ) )
- Nb++;
- }
- return Nb;
+ return _myMeshDS->GetMeshInfo().NbQuadrangles(order);
}
-///////////////////////////////////////////////////////////////////////////////
-/// Return the number of polygonal faces in the mesh. This method run in O(n)
-///////////////////////////////////////////////////////////////////////////////
+//================================================================================
+/*!
+ * \brief Return the number of polygonal faces in the mesh
+ */
+//================================================================================
+
int SMESH_Mesh::NbPolygons() throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
- int Nb = 0;
- SMDS_FaceIteratorPtr itFaces = _myMeshDS->facesIterator();
- while (itFaces->more())
- if (itFaces->next()->IsPoly()) Nb++;
- return Nb;
+ return _myMeshDS->GetMeshInfo().NbPolygons();
}
-//=============================================================================
+//================================================================================
/*!
- *
+ * \brief Return number of volumes of given order in the mesh
*/
-//=============================================================================
-int SMESH_Mesh::NbVolumes(ElementOrder order) throw(SALOME_Exception)
+//================================================================================
+
+int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
- if (order == ORDER_ANY)
- return _myMeshDS->NbVolumes();
-
- int Nb = 0;
- SMDS_VolumeIteratorPtr it = _myMeshDS->volumesIterator();
- while (it->more()) {
- const SMDS_MeshVolume* cur = it->next();
- if ( order == ORDER_LINEAR && !cur->IsQuadratic() ||
- order == ORDER_QUADRATIC && cur->IsQuadratic() )
- Nb++;
- }
- return Nb;
+ return _myMeshDS->GetMeshInfo().NbVolumes(order);
}
-int SMESH_Mesh::NbTetras(ElementOrder order) throw(SALOME_Exception)
+//================================================================================
+/*!
+ * \brief Return number of tetrahedrons of given order in the mesh
+ */
+//================================================================================
+
+int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
- int Nb = 0;
- SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
- while (itVolumes->more()) {
- const SMDS_MeshVolume* curVolume = itVolumes->next();
- int nbnod = curVolume->NbNodes();
- if ( !curVolume->IsPoly() &&
- ( order == ORDER_ANY && (nbnod==4 || nbnod==10) ||
- order == ORDER_LINEAR && nbnod==4 ||
- order == ORDER_QUADRATIC && nbnod==10 ) )
- Nb++;
- }
- return Nb;
+ return _myMeshDS->GetMeshInfo().NbTetras(order);
}
-int SMESH_Mesh::NbHexas(ElementOrder order) throw(SALOME_Exception)
+//================================================================================
+/*!
+ * \brief Return number of hexahedrons of given order in the mesh
+ */
+//================================================================================
+
+int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
- int Nb = 0;
- SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
- while (itVolumes->more()) {
- const SMDS_MeshVolume* curVolume = itVolumes->next();
- int nbnod = curVolume->NbNodes();
- if ( !curVolume->IsPoly() &&
- ( order == ORDER_ANY && (nbnod==8 || nbnod==20) ||
- order == ORDER_LINEAR && nbnod==8 ||
- order == ORDER_QUADRATIC && nbnod==20 ) )
- Nb++;
- }
- return Nb;
+ return _myMeshDS->GetMeshInfo().NbHexas(order);
}
-int SMESH_Mesh::NbPyramids(ElementOrder order) throw(SALOME_Exception)
+//================================================================================
+/*!
+ * \brief Return number of pyramids of given order in the mesh
+ */
+//================================================================================
+
+int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
- int Nb = 0;
- SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
- while (itVolumes->more()) {
- const SMDS_MeshVolume* curVolume = itVolumes->next();
- int nbnod = curVolume->NbNodes();
- if ( !curVolume->IsPoly() &&
- ( order == ORDER_ANY && (nbnod==5 || nbnod==13) ||
- order == ORDER_LINEAR && nbnod==5 ||
- order == ORDER_QUADRATIC && nbnod==13 ) )
- Nb++;
- }
- return Nb;
+ return _myMeshDS->GetMeshInfo().NbPyramids(order);
}
-int SMESH_Mesh::NbPrisms(ElementOrder order) throw(SALOME_Exception)
+//================================================================================
+/*!
+ * \brief Return number of prisms (penthahedrons) of given order in the mesh
+ */
+//================================================================================
+
+int SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
- int Nb = 0;
- SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
- while (itVolumes->more()) {
- const SMDS_MeshVolume* curVolume = itVolumes->next();
- int nbnod = curVolume->NbNodes();
- if ( !curVolume->IsPoly() &&
- ( order == ORDER_ANY && (nbnod==6 || nbnod==15) ||
- order == ORDER_LINEAR && nbnod==6 ||
- order == ORDER_QUADRATIC && nbnod==15 ) )
- Nb++;
- }
- return Nb;
+ return _myMeshDS->GetMeshInfo().NbPrisms(order);
}
+//================================================================================
+/*!
+ * \brief Return number of polyhedrons in the mesh
+ */
+//================================================================================
+
int SMESH_Mesh::NbPolyhedrons() throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
- int Nb = 0;
- SMDS_VolumeIteratorPtr itVolumes = _myMeshDS->volumesIterator();
- while (itVolumes->more())
- if (itVolumes->next()->IsPoly()) Nb++;
- return Nb;
+ return _myMeshDS->GetMeshInfo().NbPolyhedrons();
}
-//=============================================================================
+//================================================================================
/*!
- *
+ * \brief Return number of submeshes in the mesh
*/
-//=============================================================================
+//================================================================================
+
int SMESH_Mesh::NbSubMesh() throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
{
if(MYDEBUG) MESSAGE("SMESH_Mesh::IsNotConformAllowed");
- SMESH_HypoFilter filter( SMESH_HypoFilter::HasName( "NotConformAllowed" ));
+ static SMESH_HypoFilter filter( SMESH_HypoFilter::HasName( "NotConformAllowed" ));
return GetHypothesis( _myMeshDS->ShapeToMesh(), filter, false );
}
_mapGroup.erase (theGroupID);
}
-//=============================================================================
-/*!
- * IsLocal1DHypothesis
- * Returns a local 1D hypothesis used for theEdge
- */
-//=============================================================================
-const SMESH_Hypothesis* SMESH_Mesh::IsLocal1DHypothesis (const TopoDS_Shape& theEdge)
-{
- SMESH_HypoFilter hypo ( SMESH_HypoFilter::HasDim( 1 ));
- hypo.AndNot( hypo.IsAlgo() ).AndNot( hypo.IsAssignedTo( GetMeshDS()->ShapeToMesh() ));
-
- return GetHypothesis( theEdge, hypo, true );
-}
-
-//=============================================================================
-/*!
- * IsPropagationHypothesis
- */
-//=============================================================================
-bool SMESH_Mesh::IsPropagationHypothesis (const TopoDS_Shape& theEdge)
-{
- return _mapPropagationChains.Contains(theEdge);
-}
-
-//=============================================================================
-/*!
- * IsPropagatedHypothesis
- */
-//=============================================================================
-bool SMESH_Mesh::IsPropagatedHypothesis (const TopoDS_Shape& theEdge,
- TopoDS_Shape& theMainEdge)
-{
- int nbChains = _mapPropagationChains.Extent();
- for (int i = 1; i <= nbChains; i++) {
- //const TopTools_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromIndex(i);
- const SMESH_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromIndex(i);
- if (aChain.Contains(theEdge)) {
- theMainEdge = _mapPropagationChains.FindKey(i);
- return true;
- }
- }
-
- return false;
-}
-//=============================================================================
-/*!
- * IsReversedInChain
- */
-//=============================================================================
-
-bool SMESH_Mesh::IsReversedInChain (const TopoDS_Shape& theEdge,
- const TopoDS_Shape& theMainEdge)
-{
- if ( !theMainEdge.IsNull() && !theEdge.IsNull() &&
- _mapPropagationChains.Contains( theMainEdge ))
- {
- const SMESH_IndexedMapOfShape& aChain =
- _mapPropagationChains.FindFromKey( theMainEdge );
- int index = aChain.FindIndex( theEdge );
- if ( index )
- return aChain(index).Orientation() == TopAbs_REVERSED;
- }
- return false;
-}
-
-//=============================================================================
-/*!
- * CleanMeshOnPropagationChain
- */
-//=============================================================================
-void SMESH_Mesh::CleanMeshOnPropagationChain (const TopoDS_Shape& theMainEdge)
-{
- const SMESH_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromKey(theMainEdge);
- int i, nbEdges = aChain.Extent();
- for (i = 1; i <= nbEdges; i++) {
- TopoDS_Shape anEdge = aChain.FindKey(i);
- SMESH_subMesh *subMesh = GetSubMesh(anEdge);
- SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS();
- if (subMeshDS && subMeshDS->NbElements() > 0) {
- subMesh->ComputeStateEngine(SMESH_subMesh::CLEAN);
- }
- }
-}
-
-//=============================================================================
-/*!
- * RebuildPropagationChains
- * Rebuild all existing propagation chains.
- * Have to be used, if 1D hypothesis have been assigned/removed to/from any edge
- */
-//=============================================================================
-bool SMESH_Mesh::RebuildPropagationChains()
-{
- bool ret = true;
-
- // Clean all chains, because they can be not up-to-date
- int i, nbChains = _mapPropagationChains.Extent();
- for (i = 1; i <= nbChains; i++) {
- TopoDS_Shape aMainEdge = _mapPropagationChains.FindKey(i);
- CleanMeshOnPropagationChain(aMainEdge);
- _mapPropagationChains.ChangeFromIndex(i).Clear();
- }
-
- // Build all chains
- for (i = 1; i <= nbChains; i++) {
- TopoDS_Shape aMainEdge = _mapPropagationChains.FindKey(i);
- if (!BuildPropagationChain(aMainEdge))
- ret = false;
- CleanMeshOnPropagationChain(aMainEdge);
- }
-
- return ret;
-}
-
-//=============================================================================
-/*!
- * RemovePropagationChain
- * Have to be used, if Propagation hypothesis is removed from <theMainEdge>
- */
-//=============================================================================
-bool SMESH_Mesh::RemovePropagationChain (const TopoDS_Shape& theMainEdge)
-{
- if (!_mapPropagationChains.Contains(theMainEdge))
- return false;
-
- // Clean mesh elements and nodes, built on the chain
- CleanMeshOnPropagationChain(theMainEdge);
-
- // Clean the chain
- _mapPropagationChains.ChangeFromKey(theMainEdge).Clear();
-
- // Remove the chain from the map
- int i = _mapPropagationChains.FindIndex(theMainEdge);
- if ( i == _mapPropagationChains.Extent() )
- _mapPropagationChains.RemoveLast();
- else {
- TopoDS_Vertex anEmptyShape;
- BRep_Builder BB;
- BB.MakeVertex(anEmptyShape, gp_Pnt(0,0,0), 0.1);
- SMESH_IndexedMapOfShape anEmptyMap;
- _mapPropagationChains.Substitute(i, anEmptyShape, anEmptyMap);
- }
-
- return true;
-}
-
-//=============================================================================
-/*!
- * BuildPropagationChain
- */
-//=============================================================================
-bool SMESH_Mesh::BuildPropagationChain (const TopoDS_Shape& theMainEdge)
-{
- if (theMainEdge.ShapeType() != TopAbs_EDGE) return true;
-
- // Add new chain, if there is no
- if (!_mapPropagationChains.Contains(theMainEdge)) {
- SMESH_IndexedMapOfShape aNewChain;
- _mapPropagationChains.Add(theMainEdge, aNewChain);
- }
-
- // Check presence of 1D hypothesis to be propagated
- const SMESH_Hypothesis* aMainHyp = IsLocal1DHypothesis(theMainEdge);
- if (!aMainHyp) {
- MESSAGE("Warning: There is no 1D hypothesis to propagate. Please, assign.");
- return true;
- }
-
- // Edges, on which the 1D hypothesis will be propagated from <theMainEdge>
- SMESH_IndexedMapOfShape& aChain = _mapPropagationChains.ChangeFromKey(theMainEdge);
- if (aChain.Extent() > 0) {
- CleanMeshOnPropagationChain(theMainEdge);
- aChain.Clear();
- }
-
- // At first put <theMainEdge> in the chain
- aChain.Add(theMainEdge);
-
- // List of edges, added to chain on the previous cycle pass
- TopTools_ListOfShape listPrevEdges;
- listPrevEdges.Append(theMainEdge.Oriented( TopAbs_FORWARD ));
-
-// 5____4____3____4____5____6
-// | | | | | |
-// | | | | | |
-// 4____3____2____3____4____5
-// | | | | | | Number in the each knot of
-// | | | | | | grid indicates cycle pass,
-// 3____2____1____2____3____4 on which corresponding edge
-// | | | | | | (perpendicular to the plane
-// | | | | | | of view) will be found.
-// 2____1____0____1____2____3
-// | | | | | |
-// | | | | | |
-// 3____2____1____2____3____4
-
- // Collect all edges pass by pass
- while (listPrevEdges.Extent() > 0) {
- // List of edges, added to chain on this cycle pass
- TopTools_ListOfShape listCurEdges;
-
- // Find the next portion of edges
- TopTools_ListIteratorOfListOfShape itE (listPrevEdges);
- for (; itE.More(); itE.Next()) {
- TopoDS_Shape anE = itE.Value();
-
- // Iterate on faces, having edge <anE>
- TopTools_ListIteratorOfListOfShape itA (GetAncestors(anE));
- for (; itA.More(); itA.Next()) {
- TopoDS_Shape aW = itA.Value();
-
- // There are objects of different type among the ancestors of edge
- if (aW.ShapeType() == TopAbs_WIRE) {
- TopoDS_Shape anOppE;
-
- BRepTools_WireExplorer aWE (TopoDS::Wire(aW));
- Standard_Integer nb = 1, found = 0;
- TopTools_Array1OfShape anEdges (1,4);
- for (; aWE.More(); aWE.Next(), nb++) {
- if (nb > 4) {
- found = 0;
- break;
- }
- anEdges(nb) = aWE.Current();
- if (!_mapAncestors.Contains(anEdges(nb))) {
- MESSAGE("WIRE EXPLORER HAVE GIVEN AN INVALID EDGE !!!");
- break;
- }
- if (anEdges(nb).IsSame(anE)) found = nb;
- }
-
- if (nb == 5 && found > 0) {
- // Quadrangle face found, get an opposite edge
- Standard_Integer opp = found + 2;
- if (opp > 4) opp -= 4;
- anOppE = anEdges(opp);
-
- // add anOppE to aChain if ...
- if (!aChain.Contains(anOppE)) { // ... anOppE is not in aChain
- if (!IsLocal1DHypothesis(anOppE)) { // ... no other 1d hyp on anOppE
- TopoDS_Shape aMainEdgeForOppEdge; // ... no other hyp is propagated to anOppE
- if (!IsPropagatedHypothesis(anOppE, aMainEdgeForOppEdge))
- {
- // Add found edge to the chain oriented so that to
- // have it co-directed with a forward MainEdge
- TopAbs_Orientation ori = anE.Orientation();
- if ( anEdges(opp).Orientation() == anEdges(found).Orientation() )
- ori = TopAbs::Reverse( ori );
- anOppE.Orientation( ori );
- aChain.Add(anOppE);
- listCurEdges.Append(anOppE);
- }
- else {
- // Collision!
- MESSAGE("Error: Collision between propagated hypotheses");
- CleanMeshOnPropagationChain(theMainEdge);
- aChain.Clear();
- return ( aMainHyp == IsLocal1DHypothesis(aMainEdgeForOppEdge) );
- }
- }
- }
- } // if (nb == 5 && found > 0)
- } // if (aF.ShapeType() == TopAbs_WIRE)
- } // for (; itF.More(); itF.Next())
- } // for (; itE.More(); itE.Next())
-
- listPrevEdges = listCurEdges;
- } // while (listPrevEdges.Extent() > 0)
-
- CleanMeshOnPropagationChain(theMainEdge);
- return true;
-}
-
//=======================================================================
//function : GetAncestors
//purpose : return list of ancestors of theSubShape in the order
//function : Dump
//purpose : dumps contents of mesh to stream [ debug purposes ]
//=======================================================================
+
ostream& SMESH_Mesh::Dump(ostream& save)
{
- save << "========================== Dump contents of mesh ==========================" << endl;
- save << "1) Total number of nodes: " << NbNodes() << endl;
- save << "2) Total number of edges: " << NbEdges() << endl;
- save << "3) Total number of faces: " << NbFaces() << endl;
- if ( NbFaces() > 0 ) {
- int nb3 = NbTriangles();
- int nb4 = NbQuadrangles();
- save << "3.1.) Number of triangles: " << nb3 << endl;
- save << "3.2.) Number of quadrangles: " << nb4 << endl;
- if ( nb3 + nb4 != NbFaces() ) {
- map<int,int> myFaceMap;
- SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
- while( itFaces->more( ) ) {
- int nbNodes = itFaces->next()->NbNodes();
- if ( myFaceMap.find( nbNodes ) == myFaceMap.end() )
- myFaceMap[ nbNodes ] = 0;
- myFaceMap[ nbNodes ] = myFaceMap[ nbNodes ] + 1;
+ int clause = 0;
+ save << "========================== Dump contents of mesh ==========================" << endl << endl;
+ save << ++clause << ") Total number of nodes: \t" << NbNodes() << endl;
+ save << ++clause << ") Total number of edges: \t" << NbEdges() << endl;
+ save << ++clause << ") Total number of faces: \t" << NbFaces() << endl;
+ save << ++clause << ") Total number of polygons:\t" << NbPolygons() << endl;
+ save << ++clause << ") Total number of volumes:\t" << NbVolumes() << endl;
+ save << ++clause << ") Total number of polyhedrons:\t" << NbPolyhedrons() << endl << endl;
+ for ( int isQuadratic = 0; isQuadratic < 2; ++isQuadratic )
+ {
+ string orderStr = isQuadratic ? "quadratic" : "linear";
+ SMDSAbs_ElementOrder order = isQuadratic ? ORDER_QUADRATIC : ORDER_LINEAR;
+
+ save << ++clause << ") Total number of " << orderStr << " edges:\t" << NbEdges(order) << endl;
+ save << ++clause << ") Total number of " << orderStr << " faces:\t" << NbFaces(order) << endl;
+ if ( NbFaces(order) > 0 ) {
+ int nb3 = NbTriangles(order);
+ int nb4 = NbQuadrangles(order);
+ save << clause << ".1) Number of " << orderStr << " triangles: \t" << nb3 << endl;
+ save << clause << ".2) Number of " << orderStr << " quadrangles:\t" << nb4 << endl;
+ if ( nb3 + nb4 != NbFaces(order) ) {
+ map<int,int> myFaceMap;
+ SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
+ while( itFaces->more( ) ) {
+ int nbNodes = itFaces->next()->NbNodes();
+ if ( myFaceMap.find( nbNodes ) == myFaceMap.end() )
+ myFaceMap[ nbNodes ] = 0;
+ myFaceMap[ nbNodes ] = myFaceMap[ nbNodes ] + 1;
+ }
+ save << clause << ".3) Faces in detail: " << endl;
+ map <int,int>::iterator itF;
+ for (itF = myFaceMap.begin(); itF != myFaceMap.end(); itF++)
+ save << "--> nb nodes: " << itF->first << " - nb elemens:\t" << itF->second << endl;
}
- save << "3.3.) Faces in detail: " << endl;
- map <int,int>::iterator itF;
- for (itF = myFaceMap.begin(); itF != myFaceMap.end(); itF++)
- save << "--> nb nodes: " << itF->first << " - nb elemens: " << itF->second << endl;
}
- }
- save << "4) Total number of volumes: " << NbVolumes() << endl;
- if ( NbVolumes() > 0 ) {
- int nb8 = NbHexas();
- int nb4 = NbTetras();
- int nb5 = NbPyramids();
- int nb6 = NbPrisms();
- save << "4.1.) Number of hexahedrons: " << nb8 << endl;
- save << "4.2.) Number of tetrahedrons: " << nb4 << endl;
- save << "4.3.) Number of prisms: " << nb6 << endl;
- save << "4.4.) Number of pyramides: " << nb5 << endl;
- if ( nb8 + nb4 + nb5 + nb6 != NbVolumes() ) {
- map<int,int> myVolumesMap;
- SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
- while( itVolumes->more( ) ) {
- int nbNodes = itVolumes->next()->NbNodes();
- if ( myVolumesMap.find( nbNodes ) == myVolumesMap.end() )
- myVolumesMap[ nbNodes ] = 0;
- myVolumesMap[ nbNodes ] = myVolumesMap[ nbNodes ] + 1;
+ save << ++clause << ") Total number of " << orderStr << " volumes:\t" << NbVolumes(order) << endl;
+ if ( NbVolumes(order) > 0 ) {
+ int nb8 = NbHexas(order);
+ int nb4 = NbTetras(order);
+ int nb5 = NbPyramids(order);
+ int nb6 = NbPrisms(order);
+ save << clause << ".1) Number of " << orderStr << " hexahedrons:\t" << nb8 << endl;
+ save << clause << ".2) Number of " << orderStr << " tetrahedrons:\t" << nb4 << endl;
+ save << clause << ".3) Number of " << orderStr << " prisms: \t" << nb6 << endl;
+ save << clause << ".4) Number of " << orderStr << " pyramids:\t" << nb5 << endl;
+ if ( nb8 + nb4 + nb5 + nb6 != NbVolumes(order) ) {
+ map<int,int> myVolumesMap;
+ SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
+ while( itVolumes->more( ) ) {
+ int nbNodes = itVolumes->next()->NbNodes();
+ if ( myVolumesMap.find( nbNodes ) == myVolumesMap.end() )
+ myVolumesMap[ nbNodes ] = 0;
+ myVolumesMap[ nbNodes ] = myVolumesMap[ nbNodes ] + 1;
+ }
+ save << clause << ".5) Volumes in detail: " << endl;
+ map <int,int>::iterator itV;
+ for (itV = myVolumesMap.begin(); itV != myVolumesMap.end(); itV++)
+ save << "--> nb nodes: " << itV->first << " - nb elemens:\t" << itV->second << endl;
}
- save << "4.5.) Volumes in detail: " << endl;
- map <int,int>::iterator itV;
- for (itV = myVolumesMap.begin(); itV != myVolumesMap.end(); itV++)
- save << "--> nb nodes: " << itV->first << " - nb elemens: " << itV->second << endl;
}
+ save << endl;
}
save << "===========================================================================" << endl;
return save;
//function : GetElementType
//purpose : Returns type of mesh element with certain id
//=======================================================================
+
SMDSAbs_ElementType SMESH_Mesh::GetElementType( const int id, const bool iselem )
{
return _myMeshDS->GetElementType( id, iselem );