{
gen->_mapAlgo[hypId] = this;
- _onlyUnaryInput = _requireDescretBoundary = _requireShape = true;
+ _onlyUnaryInput = _requireDiscreteBoundary = _requireShape = true;
_quadraticMesh = _supportSubmeshes = false;
_error = COMPERR_OK;
}
* \param aShape - the shape
* \retval bool - is a success
*
- * Algorithms that !NeedDescretBoundary() || !OnlyUnaryInput() are
+ * Algorithms that !NeedDiscreteBoundary() || !OnlyUnaryInput() are
* to set SMESH_ComputeError returned by SMESH_submesh::GetComputeError()
* to report problematic sub-shapes
*/
// an input temporary shape that is neither MainShape nor
// its child.
- bool NeedDescretBoundary() const { return _requireDescretBoundary; }
+ bool NeedDiscreteBoundary() const { return _requireDiscreteBoundary; }
// 3 - is a Dim-1 mesh prerequisite
bool NeedShape() const { return _requireShape; }
// 4 - is shape existance required
bool SupportSubmeshes() const { return _supportSubmeshes; }
- // 5 - whether supports submeshes if !NeedDescretBoundary()
+ // 5 - whether supports submeshes if !NeedDiscreteBoundary()
public:
// in what turn and with what input shape.
// These fields must be redefined if necessary by each descendant at constructor.
bool _onlyUnaryInput; // mesh one shape of GetDim() at once. Default TRUE
- bool _requireDescretBoundary; // GetDim()-1 mesh must be present. Default TRUE
+ bool _requireDiscreteBoundary; // GetDim()-1 mesh must be present. Default TRUE
bool _requireShape; // work with GetDim()-1 mesh bound to geom only. Default TRUE
- bool _supportSubmeshes; // if !_requireDescretBoundary. Default FALSE
+ bool _supportSubmeshes; // if !_requireDiscreteBoundary. Default FALSE
// quadratic mesh creation required,
// is usually set trough SMESH_MesherHelper::IsQuadraticSubMesh()
else
{
// -----------------------------------------------------------------
- // apply algos that DO NOT require descretized boundaries and DO NOT
+ // apply algos that DO NOT require Discreteized boundaries and DO NOT
// support submeshes, starting from the most complex shapes
// and collect submeshes with algos that DO support submeshes
// -----------------------------------------------------------------
continue;
SMESH_Algo* algo = GetAlgo( aMesh, aSubShape, &algoShape );
- if ( algo && !algo->NeedDescretBoundary() )
+ if ( algo && !algo->NeedDiscreteBoundary() )
{
if ( algo->SupportSubmeshes() )
{
// ------------------------------------------------------------
// compute submeshes under shapes with algos that DO NOT require
- // descretized boundaries and DO support submeshes
+ // Discreteized boundaries and DO support submeshes
// ------------------------------------------------------------
list< SMESH_subMesh* >::iterator subIt, subEnd;
subIt = smWithAlgoSupportingSubmeshes.begin();
}
}
// ----------------------------------------------------------
- // apply the algos that do not require descretized boundaries
+ // apply the algos that do not require Discreteized boundaries
// ----------------------------------------------------------
for ( subIt = smWithAlgoSupportingSubmeshes.begin(); subIt != subEnd; ++subIt )
{
}
else {
// -----------------------------------------------------------------
- // apply algos that DO NOT require descretized boundaries and DO NOT
+ // apply algos that DO NOT require Discreteized boundaries and DO NOT
// support submeshes, starting from the most complex shapes
// and collect submeshes with algos that DO support submeshes
// -----------------------------------------------------------------
if ( aShapeDim < 1 ) break;
SMESH_Algo* algo = GetAlgo( aMesh, aSubShape );
- if ( algo && !algo->NeedDescretBoundary() ) {
+ if ( algo && !algo->NeedDiscreteBoundary() ) {
if ( algo->SupportSubmeshes() ) {
smWithAlgoSupportingSubmeshes.push_front( smToCompute );
}
// ------------------------------------------------------------
// compute submeshes under shapes with algos that DO NOT require
- // descretized boundaries and DO support submeshes
+ // Discreteized boundaries and DO support submeshes
// ------------------------------------------------------------
list< SMESH_subMesh* >::iterator subIt, subEnd;
subIt = smWithAlgoSupportingSubmeshes.begin();
}
}
// ----------------------------------------------------------
- // apply the algos that do not require descretized boundaries
+ // apply the algos that do not require Discreteized boundaries
// ----------------------------------------------------------
for ( subIt = smWithAlgoSupportingSubmeshes.begin(); subIt != subEnd; ++subIt )
{
<< " <" << algo->GetName() << "> is hidden by global <"
<< aGlobIgnoAlgo->GetName() << ">");
}
- else if ( !algo->NeedDescretBoundary() && !isGlobal)
+ else if ( !algo->NeedDiscreteBoundary() && !isGlobal)
{
// local algo is not hidden and hides algos on sub-shapes
if (checkConform && !aSubMesh->IsConform( algo ))
ASSERT (algo);
bool isTopLocalAlgo =
( aTopAlgoDim <= algo->GetDim() && !aGen->IsGlobalHypothesis( algo, aMesh ));
- if (!algo->NeedDescretBoundary() || isTopLocalAlgo)
+ if (!algo->NeedDiscreteBoundary() || isTopLocalAlgo)
{
- bool checkNoAlgo2 = ( algo->NeedDescretBoundary() );
+ bool checkNoAlgo2 = ( algo->NeedDiscreteBoundary() );
SMESH_subMeshIteratorPtr itsub = aSubMesh->getDependsOnIterator( /*includeSelf=*/false,
/*complexShapeFirst=*/false);
while ( itsub->more() )
// --------------------------------------------------------
// info on algos that will be ignored because of ones that
- // don't NeedDescretBoundary() attached to super-shapes,
+ // don't NeedDiscreteBoundary() attached to super-shapes,
// check that a conform mesh will be produced
// --------------------------------------------------------
for (dim = 3; dim > 0; dim--)
{
if (aGlobAlgoArr[ dim ] &&
- !aGlobAlgoArr[ dim ]->NeedDescretBoundary())
+ !aGlobAlgoArr[ dim ]->NeedDiscreteBoundary())
{
aGlobIgnoAlgo = aGlobAlgoArr[ dim ];
break;
filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+1 ));
filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+2 ));
if ( SMESH_Algo * curAlgo = (SMESH_Algo*) _father->GetHypothesis( _subShape, filter, true ))
- needFullClean = ( !curAlgo->NeedDescretBoundary() );
+ needFullClean = ( !curAlgo->NeedDiscreteBoundary() );
}
}
if (event == REMOVE_ALGO)
{
algo = dynamic_cast<SMESH_Algo*> (anHyp);
- if (!algo->NeedDescretBoundary())
+ if (!algo->NeedDiscreteBoundary())
{
// clean all mesh in the tree of the current submesh;
// we must perform it now because later
// IPAL21346. Edges not removed when Netgen 1d-2d is removed from a SOLID.
// CLEAN was not called at event REMOVE_ALGO because the algo is not applicable to SOLID.
algo = dynamic_cast<SMESH_Algo*> (anHyp);
- if (!algo->NeedDescretBoundary())
+ if (!algo->NeedDiscreteBoundary())
needFullClean = true;
algo = GetAlgo();
TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
for ( ; ( ret == SMESH_Hypothesis::HYP_OK && it.More()); it.Next() ) {
if ( SMESH_Algo* upperAlgo = gen->GetAlgo( *_father, it.Value() ))
- if ( !upperAlgo->NeedDescretBoundary() && !upperAlgo->SupportSubmeshes())
+ if ( !upperAlgo->NeedDiscreteBoundary() && !upperAlgo->SupportSubmeshes())
ret = SMESH_Hypothesis::HYP_HIDDEN_ALGO;
}
// is algo hiding?
if ( ret == SMESH_Hypothesis::HYP_OK &&
- !algo->NeedDescretBoundary() &&
+ !algo->NeedDiscreteBoundary() &&
!algo->SupportSubmeshes()) {
TopoDS_Shape algoAssignedTo, otherAssignedTo;
gen->GetAlgo( *_father, _subShape, &algoAssignedTo );
// Suppose that theAlgo is applicable to _subShape, do not check it here
//if ( !IsApplicableHypotesis( theAlgo )) return false;
- // check only algo that doesn't NeedDescretBoundary(): because mesh made
+ // check only algo that doesn't NeedDiscreteBoundary(): because mesh made
// on a sub-shape will be ignored by theAlgo
- if ( theAlgo->NeedDescretBoundary() ||
+ if ( theAlgo->NeedDiscreteBoundary() ||
!theAlgo->OnlyUnaryInput() ) // all adjacent shapes will be meshed by this algo?
return true;
// check algo attached to smAdjacent
SMESH_Algo * algo = gen->GetAlgo((*_father), adjacent);
if (algo &&
- !algo->NeedDescretBoundary() &&
+ !algo->NeedDiscreteBoundary() &&
algo->OnlyUnaryInput())
return false; // NOT CONFORM MESH WILL BE PRODUCED
}
{
case MODIF_ALGO_STATE:
algo = GetAlgo();
- if (algo && !algo->NeedDescretBoundary())
+ if (algo && !algo->NeedDiscreteBoundary())
CleanDependsOn(); // clean sub-meshes with event CLEAN
if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE;
algo = GetAlgo();
if (algo)
{
- if (!algo->NeedDescretBoundary())
+ if (!algo->NeedDiscreteBoundary())
CleanDependsOn(); // clean sub-meshes with event CLEAN
if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE;
shape = GetCollection( gen, algo, subComputed );
else
subComputed = SubMeshesComputed();
- ret = ( algo->NeedDescretBoundary() ? subComputed :
+ ret = ( algo->NeedDiscreteBoundary() ? subComputed :
algo->SupportSubmeshes() ? true :
( !subComputed || _father->IsNotConformAllowed() ));
if (!ret) {
_computeState = FAILED_TO_COMPUTE;
- if ( !algo->NeedDescretBoundary() )
+ if ( !algo->NeedDiscreteBoundary() )
_computeError =
SMESH_ComputeError::New(COMPERR_BAD_INPUT_MESH,
"Unexpected computed submesh",algo);
case MODIF_ALGO_STATE:
ComputeStateEngine( CLEAN );
algo = GetAlgo();
- if (algo && !algo->NeedDescretBoundary())
+ if (algo && !algo->NeedDiscreteBoundary())
CleanDependsOn(); // clean sub-meshes with event CLEAN
break;
case COMPUTE: // nothing to do
if ( !IsEmpty() )
ComputeStateEngine( CLEAN );
algo = GetAlgo();
- if (algo && !algo->NeedDescretBoundary())
+ if (algo && !algo->NeedDiscreteBoundary())
CleanDependsOn(); // clean sub-meshes with event CLEAN
if (_algoState == HYP_OK)
_computeState = READY_TO_COMPUTE;
ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
if (!ret) return false;
- if (_father->HasShapeToMesh() && algo->NeedDescretBoundary())
+ if (_father->HasShapeToMesh() && algo->NeedDiscreteBoundary())
{
// check submeshes needed
bool subMeshEvaluated = true;
if ( !theShape.IsNull() )
{
// Check state of submeshes
- if ( !theAlgo->NeedDescretBoundary())
+ if ( !theAlgo->NeedDiscreteBoundary())
{
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
while ( smIt->more() )
continue; // no assigned algorithm to current submesh
int dim = anAlgo->GetDim(); // top concurrent dimension (see comment to SMESH_DimHyp)
- // the submesh can concurrent at <dim> (or lower dims if !anAlgo->NeedDescretBoundary())
+ // the submesh can concurrent at <dim> (or lower dims if !anAlgo->NeedDiscreteBoundary())
// create instance of dimension-hypothesis for found concurrent dimension(s) and algorithm
- for ( int j = anAlgo->NeedDescretBoundary() ? dim : 1, jn = dim; j <= jn; j++ )
+ for ( int j = anAlgo->NeedDiscreteBoundary() ? dim : 1, jn = dim; j <= jn; j++ )
addDimHypInstance( j, aSubMeshShape, anAlgo, sm, hypList, dimHypListArr );
}
} // end iterations on submesh
_compatibleHypothesis.push_back("CartesianParameters3D");
_onlyUnaryInput = false; // to mesh all SOLIDs at once
- _requireDescretBoundary = false; // 2D mesh not needed
+ _requireDiscreteBoundary = false; // 2D mesh not needed
_supportSubmeshes = false; // do not use any existing mesh
}
_shapeType = (1 << TopAbs_FACE);
_compatibleHypothesis.push_back("ImportSource2D");
- _requireDescretBoundary = false;
+ _requireDiscreteBoundary = false;
}
//=============================================================================
:StdMeshers_Projection_2D(hypId, studyId, gen)
{
_name = "Projection_1D2D";
- _requireDescretBoundary = false;
+ _requireDiscreteBoundary = false;
_supportSubmeshes = true;
}
_compatibleHypothesis.push_back("NumberOfLayers2D");
myNbLayerHypo = 0;
myDistributionHypo = 0;
- _requireDescretBoundary = false;
+ _requireDiscreteBoundary = false;
_supportSubmeshes = true;
}
