-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
// Module : SMESH
//
#include "StdMeshers_Regular_1D.hxx"
-#include "StdMeshers_Distribution.hxx"
+#include "SMDS_MeshElement.hxx"
+#include "SMDS_MeshNode.hxx"
+#include "SMESH_Comment.hxx"
+#include "SMESH_Gen.hxx"
+#include "SMESH_HypoFilter.hxx"
+#include "SMESH_Mesh.hxx"
+#include "SMESH_subMesh.hxx"
+#include "SMESH_subMeshEventListener.hxx"
+#include "StdMeshers_Adaptive1D.hxx"
#include "StdMeshers_Arithmetic1D.hxx"
#include "StdMeshers_AutomaticLength.hxx"
#include "StdMeshers_Deflection1D.hxx"
+#include "StdMeshers_Distribution.hxx"
+#include "StdMeshers_FixedPoints1D.hxx"
#include "StdMeshers_LocalLength.hxx"
#include "StdMeshers_MaxLength.hxx"
#include "StdMeshers_NumberOfSegments.hxx"
#include "StdMeshers_SegmentLengthAroundVertex.hxx"
#include "StdMeshers_StartEndLength.hxx"
-#include "SMESH_Gen.hxx"
-#include "SMESH_Mesh.hxx"
-#include "SMESH_HypoFilter.hxx"
-#include "SMESH_subMesh.hxx"
-#include "SMESH_subMeshEventListener.hxx"
-#include "SMESH_Comment.hxx"
-
-#include "SMDS_MeshElement.hxx"
-#include "SMDS_MeshNode.hxx"
-
#include "Utils_SALOME_Exception.hxx"
#include "utilities.h"
//=============================================================================
StdMeshers_Regular_1D::StdMeshers_Regular_1D(int hypId, int studyId,
- SMESH_Gen * gen):SMESH_1D_Algo(hypId, studyId, gen)
+ SMESH_Gen * gen)
+ :SMESH_1D_Algo(hypId, studyId, gen)
{
- MESSAGE("StdMeshers_Regular_1D::StdMeshers_Regular_1D");
- _name = "Regular_1D";
- _shapeType = (1 << TopAbs_EDGE);
- _fpHyp = 0;
-
- _compatibleHypothesis.push_back("LocalLength");
- _compatibleHypothesis.push_back("MaxLength");
- _compatibleHypothesis.push_back("NumberOfSegments");
- _compatibleHypothesis.push_back("StartEndLength");
- _compatibleHypothesis.push_back("Deflection1D");
- _compatibleHypothesis.push_back("Arithmetic1D");
- _compatibleHypothesis.push_back("FixedPoints1D");
- _compatibleHypothesis.push_back("AutomaticLength");
-
- _compatibleHypothesis.push_back("QuadraticMesh"); // auxiliary !!!
- _compatibleHypothesis.push_back("Propagation"); // auxiliary !!!
+ MESSAGE("StdMeshers_Regular_1D::StdMeshers_Regular_1D");
+ _name = "Regular_1D";
+ _shapeType = (1 << TopAbs_EDGE);
+ _fpHyp = 0;
+
+ _compatibleHypothesis.push_back("LocalLength");
+ _compatibleHypothesis.push_back("MaxLength");
+ _compatibleHypothesis.push_back("NumberOfSegments");
+ _compatibleHypothesis.push_back("StartEndLength");
+ _compatibleHypothesis.push_back("Deflection1D");
+ _compatibleHypothesis.push_back("Arithmetic1D");
+ _compatibleHypothesis.push_back("FixedPoints1D");
+ _compatibleHypothesis.push_back("AutomaticLength");
+ _compatibleHypothesis.push_back("Adaptive1D");
+
+ _compatibleHypothesis.push_back("QuadraticMesh"); // auxiliary !!!
+ _compatibleHypothesis.push_back("Propagation"); // auxiliary !!!
}
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
*/
//=============================================================================
-bool StdMeshers_Regular_1D::CheckHypothesis
- (SMESH_Mesh& aMesh,
- const TopoDS_Shape& aShape,
- SMESH_Hypothesis::Hypothesis_Status& aStatus)
+bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ Hypothesis_Status& aStatus )
{
_hypType = NONE;
_quadraticMesh = false;
+ _onlyUnaryInput = true;
const list <const SMESHDS_Hypothesis * > & hyps =
GetUsedHypothesis(aMesh, aShape, /*ignoreAuxiliaryHyps=*/false);
(dynamic_cast <const StdMeshers_AutomaticLength * >(theHyp));
ASSERT(hyp);
_value[ BEG_LENGTH_IND ] = _value[ END_LENGTH_IND ] = hyp->GetLength( &aMesh, aShape );
-// _value[ BEG_LENGTH_IND ] = hyp->GetLength( &aMesh, aShape );
-// _value[ END_LENGTH_IND ] = Precision::Confusion(); // ?? or set to zero?
ASSERT( _value[ BEG_LENGTH_IND ] > 0 );
_hypType = MAX_LENGTH;
aStatus = SMESH_Hypothesis::HYP_OK;
}
+ else if (hypName == "Adaptive1D")
+ {
+ _adaptiveHyp = dynamic_cast < const StdMeshers_Adaptive1D* >(theHyp);
+ ASSERT(_adaptiveHyp);
+ _hypType = ADAPTIVE;
+ _onlyUnaryInput = false;
+ }
else
aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
bool adjustNeighbors2an = false)
{
int i, nPar = theParams.size();
- if ( a1 + an < length && nPar > 1 )
+ if ( a1 + an <= length && nPar > 1 )
{
bool reverse = ( U1 > Un );
GCPnts_AbscissaPoint Discret(C3d, reverse ? an : -an, Un);
dUn = Utgt - theParams.back();
}
- double q = dUn / ( nPar - 1 );
if ( !adjustNeighbors2an )
{
- q = dUn / ( Utgt - Un ); // (signed) factor of segment length change
+ double q = dUn / ( Utgt - Un ); // (signed) factor of segment length change
for ( itU = theParams.rbegin(), i = 1; i < nPar; i++ ) {
double prevU = *itU;
(*itU) += dUn;
dUn = q * (*itU - prevU) * (prevU-U1)/(Un-U1);
}
}
- else {
+ else if ( nPar == 1 )
+ {
+ theParams.back() += dUn;
+ }
+ else
+ {
+ double q = dUn / ( nPar - 1 );
theParams.back() += dUn;
double sign = reverse ? -1 : 1;
double prevU = theParams.back();
double Um = *itU++;
double Lm = GCPnts_AbscissaPoint::Length( theC3d, Um, *itU);
double L = GCPnts_AbscissaPoint::Length( theC3d, *itU, l);
- StdMeshers_Regular_1D algo( *this );
- algo._hypType = BEG_END_LENGTH;
- algo._value[ BEG_LENGTH_IND ] = Lm;
- algo._value[ END_LENGTH_IND ] = vertexLength;
+ static StdMeshers_Regular_1D* auxAlgo = 0;
+ if ( !auxAlgo ) {
+ auxAlgo = new StdMeshers_Regular_1D( _gen->GetANewId(), _studyId, _gen );
+ auxAlgo->_hypType = BEG_END_LENGTH;
+ }
+ auxAlgo->_value[ BEG_LENGTH_IND ] = Lm;
+ auxAlgo->_value[ END_LENGTH_IND ] = vertexLength;
double from = *itU, to = l;
if ( isEnd1 ) {
std::swap( from, to );
- std::swap( algo._value[ BEG_LENGTH_IND ], algo._value[ END_LENGTH_IND ]);
+ std::swap( auxAlgo->_value[ BEG_LENGTH_IND ], auxAlgo->_value[ END_LENGTH_IND ]);
}
list<double> params;
- if ( algo.computeInternalParameters( theMesh, theC3d, L, from, to, params, false ))
+ if ( auxAlgo->computeInternalParameters( theMesh, theC3d, L, from, to, params, false ))
{
if ( isEnd1 ) params.reverse();
while ( 1 + nHalf-- )
case NB_SEGMENTS: {
double eltSize = 1;
+ int nbSegments;
if ( _hypType == MAX_LENGTH )
{
double nbseg = ceil(theLength / _value[ BEG_LENGTH_IND ]); // integer sup
if (nbseg <= 0)
nbseg = 1; // degenerated edge
eltSize = theLength / nbseg;
+ nbSegments = (int) nbseg;
}
else if ( _hypType == LOCAL_LENGTH )
{
if (nbseg <= 0)
nbseg = 1; // degenerated edge
eltSize = theLength / nbseg;
+ nbSegments = (int) nbseg;
}
else
{
// Number Of Segments hypothesis
- int NbSegm = _ivalue[ NB_SEGMENTS_IND ];
- if ( NbSegm < 1 ) return false;
- if ( NbSegm == 1 ) return true;
+ nbSegments = _ivalue[ NB_SEGMENTS_IND ];
+ if ( nbSegments < 1 ) return false;
+ if ( nbSegments == 1 ) return true;
switch (_ivalue[ DISTR_TYPE_IND ])
{
if (fabs(scale - 1.0) < Precision::Confusion()) {
// special case to avoid division by zero
- for (int i = 1; i < NbSegm; i++) {
- double param = f + (l - f) * i / NbSegm;
+ for (int i = 1; i < nbSegments; i++) {
+ double param = f + (l - f) * i / nbSegments;
theParams.push_back( param );
}
} else {
if ( theReverse )
scale = 1.0 / scale;
- double alpha = pow(scale, 1.0 / (NbSegm - 1));
- double factor = (l - f) / (1.0 - pow(alpha, NbSegm));
+ double alpha = pow(scale, 1.0 / (nbSegments - 1));
+ double factor = (l - f) / (1.0 - pow(alpha, nbSegments));
- for (int i = 1; i < NbSegm; i++) {
+ for (int i = 1; i < nbSegments; i++) {
double param = f + factor * (1.0 - pow(alpha, i));
theParams.push_back( param );
}
}
break;
case StdMeshers_NumberOfSegments::DT_Regular:
- eltSize = theLength / _ivalue[ NB_SEGMENTS_IND ];
+ eltSize = theLength / nbSegments;
break;
default:
return false;
if ( !Discret.IsDone() )
return error( "GCPnts_UniformAbscissa failed");
- int NbPoints = Discret.NbPoints();
- for ( int i = 2; i < NbPoints; i++ )
+ int NbPoints = Min( Discret.NbPoints(), nbSegments + 1 );
+ for ( int i = 2; i < NbPoints; i++ ) // skip 1st and last points
{
double param = Discret.Parameter(i);
theParams.push_back( param );
}
- compensateError( eltSize, eltSize, f, l, theLength, theC3d, theParams ); // for PAL9899
+ compensateError( eltSize, eltSize, f, l, theLength, theC3d, theParams, true ); // for PAL9899
return true;
}
if ( _hypType == NONE )
return false;
+ if ( _hypType == ADAPTIVE )
+ {
+ _adaptiveHyp->GetAlgo()->InitComputeError();
+ _adaptiveHyp->GetAlgo()->Compute( theMesh, theShape );
+ return error( _adaptiveHyp->GetAlgo()->GetComputeError() );
+ }
+
SMESHDS_Mesh * meshDS = theMesh.GetMeshDS();
const TopoDS_Edge & EE = TopoDS::Edge(theShape);
if ( _hypType == NONE )
return false;
- //SMESHDS_Mesh * meshDS = theMesh.GetMeshDS();
+ if ( _hypType == ADAPTIVE )
+ {
+ _adaptiveHyp->GetAlgo()->InitComputeError();
+ _adaptiveHyp->GetAlgo()->Evaluate( theMesh, theShape, aResMap );
+ return error( _adaptiveHyp->GetAlgo()->GetComputeError() );
+ }
const TopoDS_Edge & EE = TopoDS::Edge(theShape);
TopoDS_Edge E = TopoDS::Edge(EE.Oriented(TopAbs_FORWARD));
- // int shapeID = meshDS->ShapeToIndex( E );
double f, l;
Handle(Geom_Curve) Curve = BRep_Tool::Curve(E, f, l);
return _usedHypList;
}
+
+//================================================================================
+/*!
+ * \brief Pass CancelCompute() to a child algorithm
+ */
+//================================================================================
+
+void StdMeshers_Regular_1D::CancelCompute()
+{
+ SMESH_Algo::CancelCompute();
+ if ( _hypType == ADAPTIVE )
+ _adaptiveHyp->GetAlgo()->CancelCompute();
+}