ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-11-15 10:08:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

Replace Descret by Discrete in variable and method names.

Browse Source
This commit is contained in:
gdd 2012-02-17 14:30:02 +00:00
parent 58a5f9cfd1
commit 4ad6a5b19b
9 changed files with 41 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/SMESH/SMESH_Algo.cxx
View File

@ -80,7 +80,7 @@ SMESH_Algo::SMESH_Algo (int hypId, int studyId, SMESH_Gen * gen)
{
gen->_mapAlgo[hypId] = this;
_onlyUnaryInput = _requireDescretBoundary = _requireShape = true;
_onlyUnaryInput = _requireDiscreteBoundary = _requireShape = true;
_quadraticMesh = _supportSubmeshes = false;
_error = COMPERR_OK;
}

10
src/SMESH/SMESH_Algo.hxx
View File

@ -118,7 +118,7 @@ public:
* \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
*/
@ -219,14 +219,14 @@ public:
// 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:
@ -367,9 +367,9 @@ protected:
// 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()

26
src/SMESH/SMESH_Gen.cxx
View File

@ -181,7 +181,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
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
// -----------------------------------------------------------------
@ -210,7 +210,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
continue;
SMESH_Algo* algo = GetAlgo( aMesh, aSubShape, &algoShape );
if ( algo && !algo->NeedDescretBoundary() )
if ( algo && !algo->NeedDiscreteBoundary() )
{
if ( algo->SupportSubmeshes() )
{
@ -272,7 +272,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
// ------------------------------------------------------------
// 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();
@ -315,7 +315,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
}
}
// ----------------------------------------------------------
// 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 )
{
@ -456,7 +456,7 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh,
}
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
// -----------------------------------------------------------------
@ -469,7 +469,7 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh,
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 );
}
@ -488,7 +488,7 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh,
// ------------------------------------------------------------
// 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();
@ -527,7 +527,7 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh,
}
}
// ----------------------------------------------------------
// 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 )
{
@ -598,7 +598,7 @@ static bool checkConformIgnoredAlgos(SMESH_Mesh& aMesh,
<< " <" << 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 ))
@ -712,9 +712,9 @@ static bool checkMissing(SMESH_Gen* aGen,
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() )
@ -797,7 +797,7 @@ bool SMESH_Gen::GetAlgoState(SMESH_Mesh& theMesh,
// --------------------------------------------------------
// 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
// --------------------------------------------------------
@ -808,7 +808,7 @@ bool SMESH_Gen::GetAlgoState(SMESH_Mesh& theMesh,
for (dim = 3; dim > 0; dim--)
{
if (aGlobAlgoArr[ dim ] &&
!aGlobAlgoArr[ dim ]->NeedDescretBoundary())
!aGlobAlgoArr[ dim ]->NeedDiscreteBoundary())
{
aGlobIgnoAlgo = aGlobAlgoArr[ dim ];
break;

32
src/SMESH/SMESH_subMesh.cxx
View File

@ -651,7 +651,7 @@ SMESH_Hypothesis::Hypothesis_Status
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() );
}
}
@ -681,7 +681,7 @@ SMESH_Hypothesis::Hypothesis_Status
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
@ -968,7 +968,7 @@ SMESH_Hypothesis::Hypothesis_Status
// 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();
@ -1012,12 +1012,12 @@ SMESH_Hypothesis::Hypothesis_Status
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 );
@ -1072,9 +1072,9 @@ bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo)
// 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;
@ -1103,7 +1103,7 @@ bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo)
// 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
}
@ -1300,7 +1300,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
{
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;
@ -1342,7 +1342,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
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;
@ -1368,12 +1368,12 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
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);
@ -1535,7 +1535,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
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
@ -1587,7 +1587,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
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;
@ -1675,7 +1675,7 @@ bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap)
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;
@ -1717,7 +1717,7 @@ bool SMESH_subMesh::CheckComputeError(SMESH_Algo* theAlgo, const TopoDS_Shape& t
if ( !theShape.IsNull() )
{
// Check state of submeshes
if ( !theAlgo->NeedDescretBoundary())
if ( !theAlgo->NeedDiscreteBoundary())
{
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
while ( smIt->more() )

4
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -4300,10 +4300,10 @@ SMESH::submesh_array_array* SMESH_Mesh_i::GetMeshOrder()
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

2
src/StdMeshers/StdMeshers_Cartesian_3D.cxx
View File

@ -81,7 +81,7 @@ StdMeshers_Cartesian_3D::StdMeshers_Cartesian_3D(int hypId, int studyId, SMESH_G
_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
}

2
src/StdMeshers/StdMeshers_Import_1D2D.cxx
View File

@ -95,7 +95,7 @@ StdMeshers_Import_1D2D::StdMeshers_Import_1D2D(int hypId, int studyId, SMESH_Gen
_shapeType = (1 << TopAbs_FACE);
_compatibleHypothesis.push_back("ImportSource2D");
_requireDescretBoundary = false;
_requireDiscreteBoundary = false;
}
//=============================================================================

2
src/StdMeshers/StdMeshers_Projection_1D2D.cxx
View File

@ -94,7 +94,7 @@ StdMeshers_Projection_1D2D::StdMeshers_Projection_1D2D(int hypId, int studyId, S
:StdMeshers_Projection_2D(hypId, studyId, gen)
{
_name = "Projection_1D2D";
_requireDescretBoundary = false;
_requireDiscreteBoundary = false;
_supportSubmeshes = true;
}

2
src/StdMeshers/StdMeshers_RadialQuadrangle_1D2D.cxx
View File

@ -78,7 +78,7 @@ StdMeshers_RadialQuadrangle_1D2D::StdMeshers_RadialQuadrangle_1D2D(int hypId,
_compatibleHypothesis.push_back("NumberOfLayers2D");
myNbLayerHypo = 0;
myDistributionHypo = 0;
_requireDescretBoundary = false;
_requireDiscreteBoundary = false;
_supportSubmeshes = true;
}