From 4ad6a5b19bae49eae5c02662e70c1229262cace5 Mon Sep 17 00:00:00 2001 From: gdd Date: Fri, 17 Feb 2012 14:30:02 +0000 Subject: [PATCH] Replace Descret by Discrete in variable and method names. --- src/SMESH/SMESH_Algo.cxx | 2 +- src/SMESH/SMESH_Algo.hxx | 10 +++--- src/SMESH/SMESH_Gen.cxx | 26 +++++++-------- src/SMESH/SMESH_subMesh.cxx | 32 +++++++++---------- src/SMESH_I/SMESH_Mesh_i.cxx | 4 +-- src/StdMeshers/StdMeshers_Cartesian_3D.cxx | 2 +- src/StdMeshers/StdMeshers_Import_1D2D.cxx | 2 +- src/StdMeshers/StdMeshers_Projection_1D2D.cxx | 2 +- .../StdMeshers_RadialQuadrangle_1D2D.cxx | 2 +- 9 files changed, 41 insertions(+), 41 deletions(-) diff --git a/src/SMESH/SMESH_Algo.cxx b/src/SMESH/SMESH_Algo.cxx index f1d3fad65..867194fc3 100644 --- a/src/SMESH/SMESH_Algo.cxx +++ b/src/SMESH/SMESH_Algo.cxx @@ -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; } diff --git a/src/SMESH/SMESH_Algo.hxx b/src/SMESH/SMESH_Algo.hxx index 7dc98110b..380254d53 100644 --- a/src/SMESH/SMESH_Algo.hxx +++ b/src/SMESH/SMESH_Algo.hxx @@ -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() diff --git a/src/SMESH/SMESH_Gen.cxx b/src/SMESH/SMESH_Gen.cxx index ac79496d2..6908f41fd 100644 --- a/src/SMESH/SMESH_Gen.cxx +++ b/src/SMESH/SMESH_Gen.cxx @@ -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; diff --git a/src/SMESH/SMESH_subMesh.cxx b/src/SMESH/SMESH_subMesh.cxx index 68b1eeef2..cfa74ea4b 100644 --- a/src/SMESH/SMESH_subMesh.cxx +++ b/src/SMESH/SMESH_subMesh.cxx @@ -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 (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 (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() ) diff --git a/src/SMESH_I/SMESH_Mesh_i.cxx b/src/SMESH_I/SMESH_Mesh_i.cxx index b41fe79e3..77edc2ffa 100644 --- a/src/SMESH_I/SMESH_Mesh_i.cxx +++ b/src/SMESH_I/SMESH_Mesh_i.cxx @@ -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 (or lower dims if !anAlgo->NeedDescretBoundary()) + // the submesh can concurrent at (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 diff --git a/src/StdMeshers/StdMeshers_Cartesian_3D.cxx b/src/StdMeshers/StdMeshers_Cartesian_3D.cxx index 9ec55d129..16bc0d223 100644 --- a/src/StdMeshers/StdMeshers_Cartesian_3D.cxx +++ b/src/StdMeshers/StdMeshers_Cartesian_3D.cxx @@ -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 } diff --git a/src/StdMeshers/StdMeshers_Import_1D2D.cxx b/src/StdMeshers/StdMeshers_Import_1D2D.cxx index 2ecf6c1d7..326aeaa11 100644 --- a/src/StdMeshers/StdMeshers_Import_1D2D.cxx +++ b/src/StdMeshers/StdMeshers_Import_1D2D.cxx @@ -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; } //============================================================================= diff --git a/src/StdMeshers/StdMeshers_Projection_1D2D.cxx b/src/StdMeshers/StdMeshers_Projection_1D2D.cxx index ac46c0380..15c15dfa7 100644 --- a/src/StdMeshers/StdMeshers_Projection_1D2D.cxx +++ b/src/StdMeshers/StdMeshers_Projection_1D2D.cxx @@ -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; } diff --git a/src/StdMeshers/StdMeshers_RadialQuadrangle_1D2D.cxx b/src/StdMeshers/StdMeshers_RadialQuadrangle_1D2D.cxx index c1c846646..96e84ce2e 100644 --- a/src/StdMeshers/StdMeshers_RadialQuadrangle_1D2D.cxx +++ b/src/StdMeshers/StdMeshers_RadialQuadrangle_1D2D.cxx @@ -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; } -- 2.39.2