SMESH_Algo::SMESH_Algo (int hypId, int studyId, SMESH_Gen * gen)
: SMESH_Hypothesis(hypId, studyId, gen)
{
- gen->_mapAlgo[hypId] = this;
+ //gen->_mapAlgo[hypId] = this;
_onlyUnaryInput = _requireDiscreteBoundary = _requireShape = true;
_quadraticMesh = _supportSubmeshes = false;
{
_shapeType = (1 << TopAbs_VERTEX);
_type = ALGO_0D;
- gen->_map0D_Algo[hypId] = this;
+ //gen->_map0D_Algo[hypId] = this;
}
SMESH_1D_Algo::SMESH_1D_Algo(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_Algo(hypId, studyId, gen)
{
_shapeType = (1 << TopAbs_EDGE);
_type = ALGO_1D;
- gen->_map1D_Algo[hypId] = this;
+ //gen->_map1D_Algo[hypId] = this;
}
SMESH_2D_Algo::SMESH_2D_Algo(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_Algo(hypId, studyId, gen)
{
_shapeType = (1 << TopAbs_FACE);
_type = ALGO_2D;
- gen->_map2D_Algo[hypId] = this;
+ //gen->_map2D_Algo[hypId] = this;
}
SMESH_3D_Algo::SMESH_3D_Algo(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_Algo(hypId, studyId, gen)
{
_shapeType = (1 << TopAbs_SOLID);
_type = ALGO_3D;
- gen->_map3D_Algo[hypId] = this;
+ //gen->_map3D_Algo[hypId] = this;
}
//=============================================================================
const list <const SMESHDS_Hypothesis *> &
SMESH_Algo::GetUsedHypothesis(SMESH_Mesh & aMesh,
const TopoDS_Shape & aShape,
- const bool ignoreAuxiliary)
+ const bool ignoreAuxiliary) const
{
- _usedHypList.clear();
+ SMESH_Algo* me = const_cast< SMESH_Algo* >( this );
+ me->_usedHypList.clear();
SMESH_HypoFilter filter;
if ( InitCompatibleHypoFilter( filter, ignoreAuxiliary ))
{
- aMesh.GetHypotheses( aShape, filter, _usedHypList, true );
+ aMesh.GetHypotheses( aShape, filter, me->_usedHypList, true );
if ( ignoreAuxiliary && _usedHypList.size() > 1 )
- _usedHypList.clear(); //only one compatible hypothesis allowed
+ me->_usedHypList.clear(); //only one compatible hypothesis allowed
}
return _usedHypList;
}
const list<const SMESHDS_Hypothesis *> &
SMESH_Algo::GetAppliedHypothesis(SMESH_Mesh & aMesh,
const TopoDS_Shape & aShape,
- const bool ignoreAuxiliary)
+ const bool ignoreAuxiliary) const
{
- _appliedHypList.clear();
+ SMESH_Algo* me = const_cast< SMESH_Algo* >( this );
+ me->_appliedHypList.clear();
SMESH_HypoFilter filter;
if ( InitCompatibleHypoFilter( filter, ignoreAuxiliary ))
- aMesh.GetHypotheses( aShape, filter, _appliedHypList, false );
+ aMesh.GetHypotheses( aShape, filter, me->_appliedHypList, false );
return _appliedHypList;
}
return length;
}
-//================================================================================
-/*!
- * \brief Calculate normal of a mesh face
- */
-//================================================================================
-
-bool SMESH_Algo::FaceNormal(const SMDS_MeshElement* F, gp_XYZ& normal, bool normalized)
-{
- if ( !F || F->GetType() != SMDSAbs_Face )
- return false;
-
- normal.SetCoord(0,0,0);
- int nbNodes = F->IsQuadratic() ? F->NbNodes()/2 : F->NbNodes();
- for ( int i = 0; i < nbNodes-2; ++i )
- {
- gp_XYZ p[3];
- for ( int n = 0; n < 3; ++n )
- {
- const SMDS_MeshNode* node = F->GetNode( i + n );
- p[n].SetCoord( node->X(), node->Y(), node->Z() );
- }
- normal += ( p[2] - p[1] ) ^ ( p[0] - p[1] );
- }
- double size2 = normal.SquareModulus();
- bool ok = ( size2 > numeric_limits<double>::min() * numeric_limits<double>::min());
- if ( normalized && ok )
- normal /= sqrt( size2 );
-
- return ok;
-}
-
-/*
- * Moved to SMESH_MesherHelper
- */
-// bool SMESH_Algo::IsReversedSubMesh (const TopoDS_Face& theFace,
-// SMESHDS_Mesh* theMeshDS)
-// {
-// }
-
//================================================================================
/*!
* \brief Just return false as the algorithm does not hold parameters values
return 0;
}
-//=======================================================================
-//function : GetCommonNodes
-//purpose : Return nodes common to two elements
-//=======================================================================
-
-vector< const SMDS_MeshNode*> SMESH_Algo::GetCommonNodes(const SMDS_MeshElement* e1,
- const SMDS_MeshElement* e2)
-{
- vector< const SMDS_MeshNode*> common;
- for ( int i = 0 ; i < e1->NbNodes(); ++i )
- if ( e2->GetNodeIndex( e1->GetNode( i )) >= 0 )
- common.push_back( e1->GetNode( i ));
- return common;
-}
-
//=======================================================================
//function : GetMeshError
//purpose : Finds topological errors of a sub-mesh
_error = COMPERR_CANCELED;
}
+//================================================================================
+/*
+ * If possible, returns progress of computation [0.,1.]
+ */
+//================================================================================
+
+double SMESH_Algo::GetProgress() const
+{
+ return _progress;
+}
+
//================================================================================
/*!
* \brief store error and comment and then return ( error == COMPERR_OK )
//================================================================================
/*!
- * \brief initialize compute error
+ * \brief initialize compute error before call of Compute()
*/
//================================================================================
_badInputElements.clear();
_computeCanceled = false;
+ _computeCost = 1;
+ _progressTic = 0;
+ _progress = 0.;
+}
+
+//================================================================================
+/*!
+ * \brief Return compute progress by nb of calls of this method
+ */
+//================================================================================
+
+double SMESH_Algo::GetProgressByTic() const
+{
+ const_cast<SMESH_Algo*>( this )->_progressTic++;
+ double x = 5 * _progressTic;
+ x = ( x < _computeCost ) ? ( x / _computeCost ) : 1.;
+ return 0.9 * sin( x * M_PI / 2 );
}
//================================================================================
