using namespace std;
//================================================================================
-namespace VISCOUS
+namespace VISCOUS_3D
{
typedef int TGeomID;
* \brief Listener of events of 3D sub-meshes computed with viscous layers.
* It is used to clear an inferior dim sub-meshes modified by viscous layers
*/
- class _SrinkShapeListener : SMESH_subMeshEventListener
+ class _ShrinkShapeListener : SMESH_subMeshEventListener
{
- _SrinkShapeListener()
+ _ShrinkShapeListener()
: SMESH_subMeshEventListener(/*isDeletable=*/false,
- "StdMeshers_ViscousLayers::_SrinkShapeListener") {}
- static SMESH_subMeshEventListener* Get() { static _SrinkShapeListener l; return &l; }
+ "StdMeshers_ViscousLayers::_ShrinkShapeListener") {}
public:
+ static SMESH_subMeshEventListener* Get() { static _ShrinkShapeListener l; return &l; }
virtual void ProcessEvent(const int event,
const int eventType,
SMESH_subMesh* solidSM,
SMESH_subMeshEventListener::ProcessEvent(event,eventType,solidSM,data,hyp);
}
}
- static void ToClearSubMeshWithSolid( SMESH_subMesh* sm,
- const TopoDS_Shape& solid)
- {
- SMESH_subMesh* solidSM = sm->GetFather()->GetSubMesh( solid );
- SMESH_subMeshEventListenerData* data = solidSM->GetEventListenerData( Get());
- if ( data )
- {
- if ( find( data->mySubMeshes.begin(), data->mySubMeshes.end(), sm ) ==
- data->mySubMeshes.end())
- data->mySubMeshes.push_back( sm );
- }
- else
- {
- data = SMESH_subMeshEventListenerData::MakeData( /*dependent=*/sm );
- sm->SetEventListener( Get(), data, /*whereToListenTo=*/solidSM );
- }
- }
};
//--------------------------------------------------------------------------------
/*!
}
};
+ //================================================================================
+ /*!
+ * \brief sets a sub-mesh event listener to clear sub-meshes of sub-shapes of
+ * the main shape when sub-mesh of the main shape is cleared,
+ * for example to clear sub-meshes of FACEs when sub-mesh of a SOLID
+ * is cleared
+ */
+ //================================================================================
+
+ void ToClearSubWithMain( SMESH_subMesh* sub, const TopoDS_Shape& main)
+ {
+ SMESH_subMesh* mainSM = sub->GetFather()->GetSubMesh( main );
+ SMESH_subMeshEventListenerData* data =
+ mainSM->GetEventListenerData( _ShrinkShapeListener::Get());
+ if ( data )
+ {
+ if ( find( data->mySubMeshes.begin(), data->mySubMeshes.end(), sub ) ==
+ data->mySubMeshes.end())
+ data->mySubMeshes.push_back( sub );
+ }
+ else
+ {
+ data = SMESH_subMeshEventListenerData::MakeData( /*dependent=*/sub );
+ sub->SetEventListener( _ShrinkShapeListener::Get(), data, /*whereToListenTo=*/mainSM );
+ }
+ }
//--------------------------------------------------------------------------------
/*!
* \brief Simplex (triangle or tetrahedron) based on 1 (tria) or 2 (tet) nodes of
{
double _r; // radius
double _k; // factor to correct node smoothed position
+ double _h2lenRatio; // avgNormProj / (2*avgDist)
public:
static _Curvature* New( double avgNormProj, double avgDist )
{
c->_r = avgDist * avgDist / avgNormProj;
c->_k = avgDist * avgDist / c->_r / c->_r;
c->_k *= ( c->_r < 0 ? 1/1.1 : 1.1 ); // not to be too restrictive
+ c->_h2lenRatio = avgNormProj / ( avgDist + avgDist );
}
return c;
}
double lenDelta(double len) const { return _k * ( _r + len ); }
+ double lenDeltaByDist(double dist) const { return dist * _h2lenRatio; }
};
struct _LayerEdge;
//--------------------------------------------------------------------------------
_nn[3]=_le2->_nodes[0];
}
};
-} // namespace VISCOUS
+} // namespace VISCOUS_3D
//================================================================================
// StdMeshers_ViscousLayers hypothesis
_name = StdMeshers_ViscousLayers::GetHypType();
_param_algo_dim = -3; // auxiliary hyp used by 3D algos
} // --------------------------------------------------------------------------------
-void StdMeshers_ViscousLayers::SetIgnoreFaces(const std::vector<int>& faceIds)
+void StdMeshers_ViscousLayers::SetBndShapesToIgnore(const std::vector<int>& faceIds)
{
- if ( faceIds != _ignoreFaceIds )
- _ignoreFaceIds = faceIds, NotifySubMeshesHypothesisModification();
+ if ( faceIds != _ignoreBndShapeIds )
+ _ignoreBndShapeIds = faceIds, NotifySubMeshesHypothesisModification();
+} // --------------------------------------------------------------------------------
+bool StdMeshers_ViscousLayers::IsIgnoredShape(const int shapeID) const
+{
+ return ( find( _ignoreBndShapeIds.begin(), _ignoreBndShapeIds.end(), shapeID )
+ != _ignoreBndShapeIds.end() );
} // --------------------------------------------------------------------------------
void StdMeshers_ViscousLayers::SetTotalThickness(double thickness)
{
const TopoDS_Shape& theShape,
const bool toMakeN2NMap) const
{
- using namespace VISCOUS;
+ using namespace VISCOUS_3D;
_ViscousBuilder bulder;
SMESH_ComputeErrorPtr err = bulder.Compute( theMesh, theShape );
if ( err && !err->IsOK() )
save << " " << _nbLayers
<< " " << _thickness
<< " " << _stretchFactor
- << " " << _ignoreFaceIds.size();
- for ( unsigned i = 0; i < _ignoreFaceIds.size(); ++i )
- save << " " << _ignoreFaceIds[i];
+ << " " << _ignoreBndShapeIds.size();
+ for ( unsigned i = 0; i < _ignoreBndShapeIds.size(); ++i )
+ save << " " << _ignoreBndShapeIds[i];
return save;
} // --------------------------------------------------------------------------------
std::istream & StdMeshers_ViscousLayers::LoadFrom(std::istream & load)
{
int nbFaces, faceID;
load >> _nbLayers >> _thickness >> _stretchFactor >> nbFaces;
- while ( _ignoreFaceIds.size() < nbFaces && load >> faceID )
- _ignoreFaceIds.push_back( faceID );
+ while ( _ignoreBndShapeIds.size() < nbFaces && load >> faceID )
+ _ignoreBndShapeIds.push_back( faceID );
return load;
} // --------------------------------------------------------------------------------
bool StdMeshers_ViscousLayers::SetParametersByMesh(const SMESH_Mesh* theMesh,
gp_XYZ dir(0,0,0);
if ( !( ok = ( edges.size() > 0 ))) return dir;
// get average dir of edges going fromV
- gp_Vec edgeDir;
- for ( unsigned i = 0; i < edges.size(); ++i )
- {
- edgeDir = getEdgeDir( edges[i], fromV );
- double size2 = edgeDir.SquareMagnitude();
- if ( size2 > numeric_limits<double>::min() )
- edgeDir /= sqrt( size2 );
- else
- ok = false;
- dir += edgeDir.XYZ();
- }
+ gp_XYZ edgeDir;
+ //if ( edges.size() > 1 )
+ for ( unsigned i = 0; i < edges.size(); ++i )
+ {
+ edgeDir = getEdgeDir( edges[i], fromV );
+ double size2 = edgeDir.SquareModulus();
+ if ( size2 > numeric_limits<double>::min() )
+ edgeDir /= sqrt( size2 );
+ else
+ ok = false;
+ dir += edgeDir;
+ }
gp_XYZ fromEdgeDir = getFaceDir( F, edges[0], node, helper, ok );
- if ( edges.size() == 1 || dir.SquareModulus() < 1e-10)
+ if ( edges.size() == 1 )
dir = fromEdgeDir;
+ else if ( dir.SquareModulus() < 0.1 ) // ~< 20 degrees
+ dir = fromEdgeDir + getFaceDir( F, edges[1], node, helper, ok );
else if ( dir * fromEdgeDir < 0 )
dir *= -1;
if ( ok )
{
//dir /= edges.size();
if ( cosin ) {
- double angle = edgeDir.Angle( dir );
+ double angle = gp_Vec( edgeDir ).Angle( dir );
*cosin = cos( angle );
}
}
#endif
}
-using namespace VISCOUS;
+using namespace VISCOUS_3D;
//================================================================================
/*!
{
if ( ! makeLayer(_sdVec[i]) )
return _error;
+
+ if ( _sdVec[i]._edges.size() == 0 )
+ continue;
if ( ! inflate(_sdVec[i]) )
return _error;
vector<TopoDS_Shape> ignoreFaces;
for ( unsigned i = 0; i < _sdVec.size(); ++i )
{
- vector<TGeomID> ids = _sdVec[i]._hyp->GetIgnoreFaces();
+ vector<TGeomID> ids = _sdVec[i]._hyp->GetBndShapesToIgnore();
for ( unsigned i = 0; i < ids.size(); ++i )
{
const TopoDS_Shape& s = getMeshDS()->IndexToShape( ids[i] );
{
_ignoreShapeIds.insert( faceInd );
ignoreFaces.push_back( exp.Current() );
- if ( SMESH_Algo::IsReversedSubMesh( TopoDS::Face( exp.Current() ), getMeshDS()))
+ if ( helper.IsReversedSubMesh( TopoDS::Face( exp.Current() )))
_sdVec[i]._reversedFaceIds.insert( faceInd );
}
}
if ( data._stepSize < 1. )
data._epsilon *= data._stepSize;
- // Put _LayerEdge's into a vector
+ // Put _LayerEdge's into the vector data._edges
if ( !sortEdges( data, edgesByGeom ))
return false;
}
case SMDS_TOP_VERTEX: {
TopoDS_Vertex V = TopoDS::Vertex( helper.GetSubShapeByNode( node, getMeshDS()));
- gp_Vec inFaceDir = getFaceDir( F, V, node, helper, normOK);
- double angle = inFaceDir.Angle( edge._normal ); // [0,PI]
+ gp_XYZ inFaceDir = getFaceDir( F, V, node, helper, normOK);
+ double angle = gp_Vec( inFaceDir).Angle( edge._normal ); // [0,PI]
edge._cosin = cos( angle );
//cout << "Cosin on VERTEX " << edge._cosin << " node " << node->GetID() << endl;
break;
{
if ( data._edges[i]->IsOnEdge() ) continue;
data._edges[i]->FindIntersection( *searcher, intersecDist, data._epsilon );
- if ( geomSize > intersecDist )
+ if ( geomSize > intersecDist && intersecDist > 0 )
geomSize = intersecDist;
}
if ( data._stepSize > 0.3 * geomSize )
else // 2D
{
const gp_XY center( center3D.X(), center3D.Y() );
-
+
gp_XY uv0 = helper.GetNodeUV( F, data._edges[iFrom]->_2neibors->_nodes[0]);
gp_XY uvM = helper.GetNodeUV( F, data._edges[iFrom]->_nodes.back());
gp_XY uv1 = helper.GetNodeUV( F, data._edges[iTo-1]->_2neibors->_nodes[1]);
gp_Vec2d vec0( center, uv0 );
- gp_Vec2d vecM( center, uvM);
+ gp_Vec2d vecM( center, uvM );
gp_Vec2d vec1( center, uv1 );
double uLast = vec0.Angle( vec1 ); // -PI - +PI
double uMidl = vec0.Angle( vecM );
- if ( uLast < 0 ) uLast += 2.*M_PI; // 0.0 - 2*PI
- if ( uMidl < 0 ) uMidl += 2.*M_PI;
- const bool sense = ( uMidl < uLast );
+ if ( uLast * uMidl < 0. )
+ uLast += ( uMidl > 0 ? +2. : -2. ) * M_PI;
const double radius = 0.5 * ( vec0.Magnitude() + vec1.Magnitude() );
- gp_Ax2d axis( center, vec0 );
- gp_Circ2d circ ( axis, radius, sense );
+ gp_Ax2d axis( center, vec0 );
+ gp_Circ2d circ( axis, radius );
for ( int i = iFrom; i < iTo; ++i )
{
double newU = uLast * len[i-iFrom] / len.back();
}
if ( intFound )
{
- if ( dist < segLen*(1.01))
+ if ( dist < segLen*(1.01) && dist > -(_len-segLen) )
segmentIntersected = true;
if ( distance > dist )
distance = dist, iFace = j;
double lenDelta = 0;
if ( _curvature )
{
- lenDelta = _curvature->lenDelta( _len );
+ //lenDelta = _curvature->lenDelta( _len );
+ lenDelta = _curvature->lenDeltaByDist( dist01 );
newPos.ChangeCoord() += _normal * lenDelta;
}
}
}
+ if ( !getMeshDS()->IsEmbeddedMode() )
+ // Log node movement
+ for ( unsigned i = 0; i < data._edges.size(); ++i )
+ {
+ _LayerEdge& edge = *data._edges[i];
+ SMESH_TNodeXYZ p ( edge._nodes.back() );
+ getMeshDS()->MoveNode( p._node, p.X(), p.Y(), p.Z() );
+ }
+
// TODO: make quadratic prisms and polyhedrons(?)
helper.SetElementsOnShape(true);
helper.ToFixNodeParameters( true );
// EDGE's to shrink
- map< int, _Shrinker1D > e2shrMap;
+ map< TGeomID, _Shrinker1D > e2shrMap;
// loop on FACES to srink mesh on
map< TGeomID, _SolidData* >::iterator f2sd = f2sdMap.begin();
_Shrinker1D& srinker = e2shrMap[ edgeIndex ];
eShri1D.insert( & srinker );
srinker.AddEdge( edge, helper );
+ VISCOUS_3D::ToClearSubWithMain( _mesh->GetSubMesh( edge->_sWOL ), data._solid );
// restore params of nodes on EGDE if the EDGE has been already
// srinked while srinking another FACE
srinker.RestoreParams();
for ( unsigned i = 0; i < nodesToSmooth.size(); ++i )
{
moved |= nodesToSmooth[i].Smooth( badNb,surface,helper,refSign,
- /*isCentroidal=*/isConcaveFace,/*set3D=*/false );
+ /*isCentroidal=*/isConcaveFace,
+ /*set3D=*/isConcaveFace);
}
if ( badNb < oldBadNb )
nbNoImpSteps = 0;
bool highQuality;
{
const bool hasTria = _mesh->NbTriangles(), hasQuad = _mesh->NbQuadrangles();
- if ( hasTria != hasQuad )
- {
+ if ( hasTria != hasQuad ) {
highQuality = hasQuad;
}
- else
- {
+ else {
set<int> nbNodesSet;
SMDS_ElemIteratorPtr fIt = smDS->GetElements();
while ( fIt->more() && nbNodesSet.size() < 2 )
dumpFunctionEnd();
}
// Set an event listener to clear FACE sub-mesh together with SOLID sub-mesh
- _SrinkShapeListener::ToClearSubMeshWithSolid( sm, data._solid );
+ VISCOUS_3D::ToClearSubWithMain( sm, data._solid );
+
+ if ( !getMeshDS()->IsEmbeddedMode() )
+ // Log node movement
+ for ( unsigned i = 0; i < nodesToSmooth.size(); ++i )
+ {
+ SMESH_TNodeXYZ p ( nodesToSmooth[i]._node );
+ getMeshDS()->MoveNode( nodesToSmooth[i]._node, p.X(), p.Y(), p.Z() );
+ }
} // loop on FACES to srink mesh on
GeomAdaptor_Curve aCurve(C, f,l);
const double totLen = GCPnts_AbscissaPoint::Length(aCurve, f, l);
- int nbExpectNodes = eSubMesh->NbNodes() - e->_nodes.size();
+ int nbExpectNodes = eSubMesh->NbNodes();
_initU .reserve( nbExpectNodes );
_normPar.reserve( nbExpectNodes );
_nodes .reserve( nbExpectNodes );
reverse = ( helper.GetSubShapeOri( F, E ) == TopAbs_REVERSED );
if ( helper.GetSubShapeOri( data._solid, F ) == TopAbs_REVERSED )
reverse = !reverse, F.Reverse();
- if ( SMESH_Algo::IsReversedSubMesh( TopoDS::Face(F), getMeshDS() ))
+ if ( helper.IsReversedSubMesh( TopoDS::Face(F) ))
reverse = !reverse;
}
else