Replace Descret by Discrete in variable and method names.

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

View File

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

View File

@ -118,7 +118,7 @@ public:
* \param aShape - the shape * \param aShape - the shape
* \retval bool - is a success * \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 set SMESH_ComputeError returned by SMESH_submesh::GetComputeError()
* to report problematic sub-shapes * to report problematic sub-shapes
*/ */
@ -219,14 +219,14 @@ public:
// an input temporary shape that is neither MainShape nor // an input temporary shape that is neither MainShape nor
// its child. // its child.
bool NeedDescretBoundary() const { return _requireDescretBoundary; } bool NeedDiscreteBoundary() const { return _requireDiscreteBoundary; }
// 3 - is a Dim-1 mesh prerequisite // 3 - is a Dim-1 mesh prerequisite
bool NeedShape() const { return _requireShape; } bool NeedShape() const { return _requireShape; }
// 4 - is shape existance required // 4 - is shape existance required
bool SupportSubmeshes() const { return _supportSubmeshes; } bool SupportSubmeshes() const { return _supportSubmeshes; }
// 5 - whether supports submeshes if !NeedDescretBoundary() // 5 - whether supports submeshes if !NeedDiscreteBoundary()
public: public:
@ -367,9 +367,9 @@ protected:
// in what turn and with what input shape. // in what turn and with what input shape.
// These fields must be redefined if necessary by each descendant at constructor. // These fields must be redefined if necessary by each descendant at constructor.
bool _onlyUnaryInput; // mesh one shape of GetDim() at once. Default TRUE 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 _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, // quadratic mesh creation required,
// is usually set trough SMESH_MesherHelper::IsQuadraticSubMesh() // is usually set trough SMESH_MesherHelper::IsQuadraticSubMesh()

View File

@ -181,7 +181,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
else 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 // support submeshes, starting from the most complex shapes
// and collect submeshes with algos that DO support submeshes // and collect submeshes with algos that DO support submeshes
// ----------------------------------------------------------------- // -----------------------------------------------------------------
@ -210,7 +210,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
continue; continue;
SMESH_Algo* algo = GetAlgo( aMesh, aSubShape, &algoShape ); SMESH_Algo* algo = GetAlgo( aMesh, aSubShape, &algoShape );
if ( algo && !algo->NeedDescretBoundary() ) if ( algo && !algo->NeedDiscreteBoundary() )
{ {
if ( algo->SupportSubmeshes() ) if ( algo->SupportSubmeshes() )
{ {
@ -272,7 +272,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
// ------------------------------------------------------------ // ------------------------------------------------------------
// compute submeshes under shapes with algos that DO NOT require // 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; list< SMESH_subMesh* >::iterator subIt, subEnd;
subIt = smWithAlgoSupportingSubmeshes.begin(); 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 ) for ( subIt = smWithAlgoSupportingSubmeshes.begin(); subIt != subEnd; ++subIt )
{ {
@ -456,7 +456,7 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh,
} }
else { 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 // support submeshes, starting from the most complex shapes
// and collect submeshes with algos that DO support submeshes // and collect submeshes with algos that DO support submeshes
// ----------------------------------------------------------------- // -----------------------------------------------------------------
@ -469,7 +469,7 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh,
if ( aShapeDim < 1 ) break; if ( aShapeDim < 1 ) break;
SMESH_Algo* algo = GetAlgo( aMesh, aSubShape ); SMESH_Algo* algo = GetAlgo( aMesh, aSubShape );
if ( algo && !algo->NeedDescretBoundary() ) { if ( algo && !algo->NeedDiscreteBoundary() ) {
if ( algo->SupportSubmeshes() ) { if ( algo->SupportSubmeshes() ) {
smWithAlgoSupportingSubmeshes.push_front( smToCompute ); 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 // 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; list< SMESH_subMesh* >::iterator subIt, subEnd;
subIt = smWithAlgoSupportingSubmeshes.begin(); 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 ) for ( subIt = smWithAlgoSupportingSubmeshes.begin(); subIt != subEnd; ++subIt )
{ {
@ -598,7 +598,7 @@ static bool checkConformIgnoredAlgos(SMESH_Mesh& aMesh,
<< " <" << algo->GetName() << "> is hidden by global <" << " <" << algo->GetName() << "> is hidden by global <"
<< aGlobIgnoAlgo->GetName() << ">"); << aGlobIgnoAlgo->GetName() << ">");
} }
else if ( !algo->NeedDescretBoundary() && !isGlobal) else if ( !algo->NeedDiscreteBoundary() && !isGlobal)
{ {
// local algo is not hidden and hides algos on sub-shapes // local algo is not hidden and hides algos on sub-shapes
if (checkConform && !aSubMesh->IsConform( algo )) if (checkConform && !aSubMesh->IsConform( algo ))
@ -712,9 +712,9 @@ static bool checkMissing(SMESH_Gen* aGen,
ASSERT (algo); ASSERT (algo);
bool isTopLocalAlgo = bool isTopLocalAlgo =
( aTopAlgoDim <= algo->GetDim() && !aGen->IsGlobalHypothesis( algo, aMesh )); ( 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, SMESH_subMeshIteratorPtr itsub = aSubMesh->getDependsOnIterator( /*includeSelf=*/false,
/*complexShapeFirst=*/false); /*complexShapeFirst=*/false);
while ( itsub->more() ) 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 // 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 // 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--) for (dim = 3; dim > 0; dim--)
{ {
if (aGlobAlgoArr[ dim ] && if (aGlobAlgoArr[ dim ] &&
!aGlobAlgoArr[ dim ]->NeedDescretBoundary()) !aGlobAlgoArr[ dim ]->NeedDiscreteBoundary())
{ {
aGlobIgnoAlgo = aGlobAlgoArr[ dim ]; aGlobIgnoAlgo = aGlobAlgoArr[ dim ];
break; break;

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()+1 ));
filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+2 )); filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+2 ));
if ( SMESH_Algo * curAlgo = (SMESH_Algo*) _father->GetHypothesis( _subShape, filter, true )) 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) if (event == REMOVE_ALGO)
{ {
algo = dynamic_cast<SMESH_Algo*> (anHyp); algo = dynamic_cast<SMESH_Algo*> (anHyp);
if (!algo->NeedDescretBoundary()) if (!algo->NeedDiscreteBoundary())
{ {
// clean all mesh in the tree of the current submesh; // clean all mesh in the tree of the current submesh;
// we must perform it now because later // 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. // 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. // CLEAN was not called at event REMOVE_ALGO because the algo is not applicable to SOLID.
algo = dynamic_cast<SMESH_Algo*> (anHyp); algo = dynamic_cast<SMESH_Algo*> (anHyp);
if (!algo->NeedDescretBoundary()) if (!algo->NeedDiscreteBoundary())
needFullClean = true; needFullClean = true;
algo = GetAlgo(); algo = GetAlgo();
@ -1012,12 +1012,12 @@ SMESH_Hypothesis::Hypothesis_Status
TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape )); TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
for ( ; ( ret == SMESH_Hypothesis::HYP_OK && it.More()); it.Next() ) { for ( ; ( ret == SMESH_Hypothesis::HYP_OK && it.More()); it.Next() ) {
if ( SMESH_Algo* upperAlgo = gen->GetAlgo( *_father, it.Value() )) 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; ret = SMESH_Hypothesis::HYP_HIDDEN_ALGO;
} }
// is algo hiding? // is algo hiding?
if ( ret == SMESH_Hypothesis::HYP_OK && if ( ret == SMESH_Hypothesis::HYP_OK &&
!algo->NeedDescretBoundary() && !algo->NeedDiscreteBoundary() &&
!algo->SupportSubmeshes()) { !algo->SupportSubmeshes()) {
TopoDS_Shape algoAssignedTo, otherAssignedTo; TopoDS_Shape algoAssignedTo, otherAssignedTo;
gen->GetAlgo( *_father, _subShape, &algoAssignedTo ); 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 // Suppose that theAlgo is applicable to _subShape, do not check it here
//if ( !IsApplicableHypotesis( theAlgo )) return false; //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 // 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? !theAlgo->OnlyUnaryInput() ) // all adjacent shapes will be meshed by this algo?
return true; return true;
@ -1103,7 +1103,7 @@ bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo)
// check algo attached to smAdjacent // check algo attached to smAdjacent
SMESH_Algo * algo = gen->GetAlgo((*_father), adjacent); SMESH_Algo * algo = gen->GetAlgo((*_father), adjacent);
if (algo && if (algo &&
!algo->NeedDescretBoundary() && !algo->NeedDiscreteBoundary() &&
algo->OnlyUnaryInput()) algo->OnlyUnaryInput())
return false; // NOT CONFORM MESH WILL BE PRODUCED return false; // NOT CONFORM MESH WILL BE PRODUCED
} }
@ -1300,7 +1300,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
{ {
case MODIF_ALGO_STATE: case MODIF_ALGO_STATE:
algo = GetAlgo(); algo = GetAlgo();
if (algo && !algo->NeedDescretBoundary()) if (algo && !algo->NeedDiscreteBoundary())
CleanDependsOn(); // clean sub-meshes with event CLEAN CleanDependsOn(); // clean sub-meshes with event CLEAN
if ( _algoState == HYP_OK ) if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE; _computeState = READY_TO_COMPUTE;
@ -1342,7 +1342,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
algo = GetAlgo(); algo = GetAlgo();
if (algo) if (algo)
{ {
if (!algo->NeedDescretBoundary()) if (!algo->NeedDiscreteBoundary())
CleanDependsOn(); // clean sub-meshes with event CLEAN CleanDependsOn(); // clean sub-meshes with event CLEAN
if ( _algoState == HYP_OK ) if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE; _computeState = READY_TO_COMPUTE;
@ -1368,12 +1368,12 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
shape = GetCollection( gen, algo, subComputed ); shape = GetCollection( gen, algo, subComputed );
else else
subComputed = SubMeshesComputed(); subComputed = SubMeshesComputed();
ret = ( algo->NeedDescretBoundary() ? subComputed : ret = ( algo->NeedDiscreteBoundary() ? subComputed :
algo->SupportSubmeshes() ? true : algo->SupportSubmeshes() ? true :
( !subComputed || _father->IsNotConformAllowed() )); ( !subComputed || _father->IsNotConformAllowed() ));
if (!ret) { if (!ret) {
_computeState = FAILED_TO_COMPUTE; _computeState = FAILED_TO_COMPUTE;
if ( !algo->NeedDescretBoundary() ) if ( !algo->NeedDiscreteBoundary() )
_computeError = _computeError =
SMESH_ComputeError::New(COMPERR_BAD_INPUT_MESH, SMESH_ComputeError::New(COMPERR_BAD_INPUT_MESH,
"Unexpected computed submesh",algo); "Unexpected computed submesh",algo);
@ -1535,7 +1535,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
case MODIF_ALGO_STATE: case MODIF_ALGO_STATE:
ComputeStateEngine( CLEAN ); ComputeStateEngine( CLEAN );
algo = GetAlgo(); algo = GetAlgo();
if (algo && !algo->NeedDescretBoundary()) if (algo && !algo->NeedDiscreteBoundary())
CleanDependsOn(); // clean sub-meshes with event CLEAN CleanDependsOn(); // clean sub-meshes with event CLEAN
break; break;
case COMPUTE: // nothing to do case COMPUTE: // nothing to do
@ -1587,7 +1587,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
if ( !IsEmpty() ) if ( !IsEmpty() )
ComputeStateEngine( CLEAN ); ComputeStateEngine( CLEAN );
algo = GetAlgo(); algo = GetAlgo();
if (algo && !algo->NeedDescretBoundary()) if (algo && !algo->NeedDiscreteBoundary())
CleanDependsOn(); // clean sub-meshes with event CLEAN CleanDependsOn(); // clean sub-meshes with event CLEAN
if (_algoState == HYP_OK) if (_algoState == HYP_OK)
_computeState = READY_TO_COMPUTE; _computeState = READY_TO_COMPUTE;
@ -1675,7 +1675,7 @@ bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap)
ret = algo->CheckHypothesis((*_father), _subShape, hyp_status); ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
if (!ret) return false; if (!ret) return false;
if (_father->HasShapeToMesh() && algo->NeedDescretBoundary()) if (_father->HasShapeToMesh() && algo->NeedDiscreteBoundary())
{ {
// check submeshes needed // check submeshes needed
bool subMeshEvaluated = true; bool subMeshEvaluated = true;
@ -1717,7 +1717,7 @@ bool SMESH_subMesh::CheckComputeError(SMESH_Algo* theAlgo, const TopoDS_Shape& t
if ( !theShape.IsNull() ) if ( !theShape.IsNull() )
{ {
// Check state of submeshes // Check state of submeshes
if ( !theAlgo->NeedDescretBoundary()) if ( !theAlgo->NeedDiscreteBoundary())
{ {
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false); SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
while ( smIt->more() ) while ( smIt->more() )

View File

@ -4300,10 +4300,10 @@ SMESH::submesh_array_array* SMESH_Mesh_i::GetMeshOrder()
continue; // no assigned algorithm to current submesh continue; // no assigned algorithm to current submesh
int dim = anAlgo->GetDim(); // top concurrent dimension (see comment to SMESH_DimHyp) 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 // 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 ); addDimHypInstance( j, aSubMeshShape, anAlgo, sm, hypList, dimHypListArr );
} }
} // end iterations on submesh } // end iterations on submesh

View File

@ -81,7 +81,7 @@ StdMeshers_Cartesian_3D::StdMeshers_Cartesian_3D(int hypId, int studyId, SMESH_G
_compatibleHypothesis.push_back("CartesianParameters3D"); _compatibleHypothesis.push_back("CartesianParameters3D");
_onlyUnaryInput = false; // to mesh all SOLIDs at once _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 _supportSubmeshes = false; // do not use any existing mesh
} }

View File

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

View File

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

View File

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