void TerminationCriterion::accumulate_inner( PatchData& pd,
double of_value,
Vector3D* grad_array,
MsqError& err )
{
//if terminating on the norm of the gradient
//currentGradL2NormSquared = HUGE_VAL;
if (terminationCriterionFlag & (GRADIENT_L2_NORM_ABSOLUTE | GRADIENT_L2_NORM_RELATIVE))
{
currentGradL2NormSquared = length_squared(grad_array, pd.num_free_vertices()); // get the L2 norm
MSQ_DBGOUT_P0_ONLY(debugLevel) << par_string() << " o Info -- gradient L2 norm: " << " "
<< RPM(std::sqrt(currentGradL2NormSquared)) << std::endl;
}
//currentGradInfNorm = 10e6;
if (terminationCriterionFlag & (GRADIENT_INF_NORM_ABSOLUTE | GRADIENT_INF_NORM_RELATIVE))
{
currentGradInfNorm = Linf(grad_array, pd.num_free_vertices()); // get the Linf norm
MSQ_DBGOUT_P0_ONLY(debugLevel) << par_string() << " o Info -- gradient Inf norm: " << " "
<< RPM(currentGradInfNorm) << std::endl;
}
if (terminationCriterionFlag & VERTEX_MOVEMENT_RELATIVE)
{
maxSquaredInitialMovement = pd.get_max_vertex_movement_squared(
initialVerticesMemento, err ); MSQ_ERRRTN(err);
MSQ_DBGOUT_P0_ONLY(debugLevel) << par_string() << " o Info -- max initial vertex movement: " << " "
<< RPM(maxSquaredInitialMovement) << std::endl;
}
previousOFValue = currentOFValue;
currentOFValue = of_value;
if (terminationCriterionFlag & OF_FLAGS) {
MSQ_DBGOUT_P0_ONLY(debugLevel) << par_string() << " o Info -- OF Value: " << " " << RPM(of_value) << " iterationCounter= " << iterationCounter << std::endl;
}
else if (grad_array) {
MSQ_DBGOUT_P0_ONLY(debugLevel) << par_string() << " o OF Value: " << " " << RPM(of_value) << " iterationCounter= " << iterationCounter
//<< " terminationCriterionFlag= " << terminationCriterionFlag << " OF_FLAGS = " << OF_FLAGS
<< std::endl;
}
++iterationCounter;
if (timeStepFileType)
write_timestep( pd, grad_array, err);
if (plotFile.is_open())
plotFile << iterationCounter
<< '\t' << mTimer.since_birth()
<< '\t' << of_value
<< '\t' << std::sqrt( currentGradL2NormSquared )
<< '\t' << currentGradInfNorm
<< '\t' << (maxSquaredMovement > 0.0 ? std::sqrt( maxSquaredMovement ) : 0.0)
<< '\t' << globalInvertedCount
<< std::endl;
}
void TerminationCriterion::accumulate_patch( PatchData& pd, MsqError& err )
{
if (terminationCriterionFlag & MOVEMENT_FLAGS)
{
double patch_max_dist = pd.get_max_vertex_movement_squared( previousVerticesMemento, err );
if (patch_max_dist > maxSquaredMovement)
maxSquaredMovement = patch_max_dist;
pd.recreate_vertices_memento( previousVerticesMemento, err ); MSQ_ERRRTN(err);
}
//if terminating on bounded vertex movement (a bounding box for the mesh)
if(terminationCriterionFlag & BOUNDED_VERTEX_MOVEMENT)
{
const MsqVertex* vert = pd.get_vertex_array(err);
int num_vert = pd.num_free_vertices();
int i=0;
//for each vertex
for(i=0;i<num_vert;++i)
{
//if any of the coordinates are greater than eps
if( (vert[i][0]>boundedVertexMovementEps) ||
(vert[i][1]>boundedVertexMovementEps) ||
(vert[i][2]>boundedVertexMovementEps) )
{
++vertexMovementExceedsBound;
}
}
}
if ((terminationCriterionFlag|cullingMethodFlag) & UNTANGLED_MESH) {
size_t new_count = count_inverted( pd, err );
// be careful here because size_t is unsigned
globalInvertedCount += new_count;
globalInvertedCount -= patchInvertedCount;
patchInvertedCount = new_count;
//if (innerOuterType==TYPE_OUTER)
// MSQ_DBGOUT_P0_ONLY(debugLevel) << par_string() << " o Num Patch Inverted: " << " " << patchInvertedCount << " globalInvertedCount= " << globalInvertedCount << std::endl;
MSQ_ERRRTN(err);
}
}
/*!This function checks the culling method criterion supplied to the object
by the user. If the user does not supply a culling method criterion,
the default criterion is NONE, and in that case, no culling is performed.
If the culling method criterion is satisfied, the interior vertices
of the given patch are flagged as soft_fixed. Otherwise, the soft_fixed
flag is removed from each of the vertices in the patch (interior and
boundary vertices). Also, if the criterion was satisfied, then the
function returns true. Otherwise, the function returns false.
*/
bool TerminationCriterion::cull_vertices(PatchData &pd,
OFEvaluator& of_eval,
MsqError &err)
{
//PRINT_INFO("CULLING_METHOD FLAG = %i",cullingMethodFlag);
//cull_bool will be changed to true if the criterion is satisfied
bool b, cull_bool=false;
double prev_m, init_m;
switch(cullingMethodFlag){
//if no culling is requested, always return false
case NONE:
return cull_bool;
//if culling on quality improvement absolute
case QUALITY_IMPROVEMENT_ABSOLUTE:
//get objective function value
b = of_eval.evaluate(pd, currentOFValue, err);
if (MSQ_CHKERR(err)) return false;
if (!b) {
MSQ_SETERR(err)(MsqError::INVALID_MESH);
return false;
}
//if the improvement was enough, cull
if(currentOFValue <= cullingEps)
{
cull_bool=true;
}
//PRINT_INFO("\ncurrentOFValue = %f, bool = %i\n",currentOFValue,cull_bool);
break;
//if culing on quality improvement relative
case QUALITY_IMPROVEMENT_RELATIVE:
//get objective function value
b = of_eval.evaluate(pd, currentOFValue, err);
if (MSQ_CHKERR(err)) return false;
if(!b){
MSQ_SETERR(err)(MsqError::INVALID_MESH);
return false;
}
//if the improvement was enough, cull
if((currentOFValue-lowerOFBound)<=
(cullingEps*(initialOFValue-lowerOFBound)))
{
cull_bool=true;
}
break;
//if culling on vertex movement absolute
case VERTEX_MOVEMENT_ABSOLUTE:
case VERTEX_MOVEMENT_ABS_EDGE_LENGTH:
//if movement was enough, cull
prev_m = pd.get_max_vertex_movement_squared(previousVerticesMemento,err);
MSQ_ERRZERO(err);
if(prev_m <= cullingEps*cullingEps){
cull_bool=true;
}
break;
//if culling on vertex movement relative
case VERTEX_MOVEMENT_RELATIVE:
//if movement was small enough, cull
prev_m = pd.get_max_vertex_movement_squared(previousVerticesMemento,err);
MSQ_ERRZERO(err);
init_m = pd.get_max_vertex_movement_squared(initialVerticesMemento,err);
MSQ_ERRZERO(err);
if(prev_m <= (cullingEps*cullingEps * init_m)){
cull_bool=true;
}
break;
case UNTANGLED_MESH:
if (!patchInvertedCount)
cull_bool = true;
break;
default:
MSQ_SETERR(err)("Requested culling method not yet implemented.",
MsqError::NOT_IMPLEMENTED);
return false;
};
//Now actually have patch data cull vertices
if(cull_bool)
{
pd.set_free_vertices_soft_fixed(err); MSQ_ERRZERO(err);
}
else
{
pd.set_all_vertices_soft_free(err); MSQ_ERRZERO(err);
}
return cull_bool;
}
