The TerminationCriterion class contains functionality to terminate the VertexMover's optimization. More...

#include <TerminationCriterion.hpp>

Collaboration diagram for TerminationCriterion:

Public Types
enum	TCType { NONE = 0, GRADIENT_L2_NORM_ABSOLUTE = 1, GRADIENT_INF_NORM_ABSOLUTE = 2, GRADIENT_L2_NORM_RELATIVE = 4, GRADIENT_INF_NORM_RELATIVE = 8, KKT = 16, QUALITY_IMPROVEMENT_ABSOLUTE = 32, QUALITY_IMPROVEMENT_RELATIVE = 64, NUMBER_OF_ITERATES = 128, CPU_TIME = 256, VERTEX_MOVEMENT_ABSOLUTE = 512, VERTEX_MOVEMENT_RELATIVE = 1024, SUCCESSIVE_IMPROVEMENTS_ABSOLUTE = 2048, SUCCESSIVE_IMPROVEMENTS_RELATIVE = 4096, BOUNDED_VERTEX_MOVEMENT = 8192, NONE = 0, GRADIENT_L2_NORM_ABSOLUTE = 1, GRADIENT_INF_NORM_ABSOLUTE = 2, GRADIENT_L2_NORM_RELATIVE = 4, GRADIENT_INF_NORM_RELATIVE = 8, KKT = 16, QUALITY_IMPROVEMENT_ABSOLUTE = 32, QUALITY_IMPROVEMENT_RELATIVE = 64, NUMBER_OF_ITERATES = 128, CPU_TIME = 256, VERTEX_MOVEMENT_ABSOLUTE = 512, VERTEX_MOVEMENT_RELATIVE = 1024, SUCCESSIVE_IMPROVEMENTS_ABSOLUTE = 2048, SUCCESSIVE_IMPROVEMENTS_RELATIVE = 4096, BOUNDED_VERTEX_MOVEMENT = 8192 }

enum	TCType { NONE = 0, GRADIENT_L2_NORM_ABSOLUTE = 1, GRADIENT_INF_NORM_ABSOLUTE = 2, GRADIENT_L2_NORM_RELATIVE = 4, GRADIENT_INF_NORM_RELATIVE = 8, KKT = 16, QUALITY_IMPROVEMENT_ABSOLUTE = 32, QUALITY_IMPROVEMENT_RELATIVE = 64, NUMBER_OF_ITERATES = 128, CPU_TIME = 256, VERTEX_MOVEMENT_ABSOLUTE = 512, VERTEX_MOVEMENT_RELATIVE = 1024, SUCCESSIVE_IMPROVEMENTS_ABSOLUTE = 2048, SUCCESSIVE_IMPROVEMENTS_RELATIVE = 4096, BOUNDED_VERTEX_MOVEMENT = 8192, NONE = 0, GRADIENT_L2_NORM_ABSOLUTE = 1, GRADIENT_INF_NORM_ABSOLUTE = 2, GRADIENT_L2_NORM_RELATIVE = 4, GRADIENT_INF_NORM_RELATIVE = 8, KKT = 16, QUALITY_IMPROVEMENT_ABSOLUTE = 32, QUALITY_IMPROVEMENT_RELATIVE = 64, NUMBER_OF_ITERATES = 128, CPU_TIME = 256, VERTEX_MOVEMENT_ABSOLUTE = 512, VERTEX_MOVEMENT_RELATIVE = 1024, SUCCESSIVE_IMPROVEMENTS_ABSOLUTE = 2048, SUCCESSIVE_IMPROVEMENTS_RELATIVE = 4096, BOUNDED_VERTEX_MOVEMENT = 8192 }

Public Member Functions
	TerminationCriterion ()
	Constructor which does not take any arguements. More...

	~TerminationCriterion ()
	Destructor. More...

void	add_criterion_type_with_double (TCType tc_type, double eps, MsqError &err)
	Sets the criterion by specifing the TCType and the eps value. More...

void	add_criterion_type_with_int (TCType tc_type, int bound, MsqError &err)
	Sets the criterion by specifing the TCType and the integer value. More...

void	remove_criterion_type (TCType tc_type, MsqError &err)
	Removes the criterion by specifing just the TCType. More...

void	set_culling_type (TCType tc_type, double eps, MsqError &err)
	Sets the type of criterion that the user would like to use for culling purposes (along with the associated tolerance. More...

void	remove_culling (MsqError &err)
	Removes any previously set culling types (sets the culling type to be NONE). More...

void	reset_outer (MeshSet &ms, ObjectiveFunction *of, MsqError &err)
	Clear any data accumulated during an outer iteration. More...

void	reset_inner (PatchData &pd, ObjectiveFunction *of, MsqError &err)
	Clear any data accumulated during an inner iteration. More...

void	reset_patch (PatchData &pd, MsqError &err)
	Shared inner and outer initialization during inner loop. More...

void	accumulate_inner (PatchData &pd, MsqError &err)
	Accumulate data during inner iteration. More...

void	accumulate_inner (PatchData &pd, double of_value, Vector3D *of_grads, MsqError &err)
	Accumulate data during inner iteration. More...

void	accumulate_patch (PatchData &pd, MsqError &err)
	Common code for both inner and outer termination criteria during inner iteration. More...

void	accumulate_outer (MeshSet &ms, MsqError &err)

bool	terminate ()
	Check if termination criterion has been met. More...

bool	cull_vertices (PatchData &pd, ObjectiveFunction *obj_ptr, MsqError &err)
	Function which determines whether this patch should be 'culled'. More...

void	cleanup (MeshSet &ms, MsqError &err)
	Cleans up after the TerminationCriterion is finished. More...

double	get_current_function_value ()
	This function returns the current function value. More...

void	set_debug_output_level (int i)

	TerminationCriterion ()
	Constructor which does not take any arguements. More...

	~TerminationCriterion ()
	Destructor. More...

void	add_criterion_type_with_double (TCType tc_type, double eps, MsqError &err)
	Sets the criterion by specifing the TCType and the eps value. More...

void	add_criterion_type_with_int (TCType tc_type, int bound, MsqError &err)
	Sets the criterion by specifing the TCType and the integer value. More...

void	remove_criterion_type (TCType tc_type, MsqError &err)
	Removes the criterion by specifing just the TCType. More...

void	set_culling_type (TCType tc_type, double eps, MsqError &err)
	Sets the type of criterion that the user would like to use for culling purposes (along with the associated tolerance. More...

void	remove_culling (MsqError &err)
	Removes any previously set culling types (sets the culling type to be NONE). More...

void	reset_outer (MeshSet &ms, ObjectiveFunction *of, MsqError &err)
	Clear any data accumulated during an outer iteration. More...

void	reset_inner (PatchData &pd, ObjectiveFunction *of, MsqError &err)
	Clear any data accumulated during an inner iteration. More...

void	reset_patch (PatchData &pd, MsqError &err)
	Shared inner and outer initialization during inner loop. More...

void	accumulate_inner (PatchData &pd, MsqError &err)
	Accumulate data during inner iteration. More...

void	accumulate_inner (PatchData &pd, double of_value, Vector3D *of_grads, MsqError &err)
	Accumulate data during inner iteration. More...

void	accumulate_patch (PatchData &pd, MsqError &err)
	Common code for both inner and outer termination criteria during inner iteration. More...

void	accumulate_outer (MeshSet &ms, MsqError &err)

bool	terminate ()
	Check if termination criterion has been met. More...

bool	cull_vertices (PatchData &pd, ObjectiveFunction *obj_ptr, MsqError &err)
	Function which determines whether this patch should be 'culled'. More...

void	cleanup (MeshSet &ms, MsqError &err)
	Cleans up after the TerminationCriterion is finished. More...

double	get_current_function_value ()
	This function returns the current function value. More...

void	set_debug_output_level (int i)

Private Attributes
long unsigned int	terminationCriterionFlag
	Bit flag of termination crit. More...

long unsigned int	cullingMethodFlag

double	cullingEps

ObjectiveFunction *	OFPtr

double	initialOFValue

double	previousOFValue

double	currentOFValue

double	lowerOFBound

msq_std::vector< Vector3D >	mGrad

double	initialGradL2Norm

double	currentGradL2Norm

double	gradL2NormAbsoluteEps

double	gradL2NormRelativeEps

double	initialGradInfNorm

double	currentGradInfNorm

double	gradInfNormAbsoluteEps

double	gradInfNormRelativeEps

double	qualityImprovementAbsoluteEps

double	qualityImprovementRelativeEps

int	iterationBound

int	iterationCounter

Timer	mTimer

double	timeBound

PatchDataVerticesMemento *	initialVerticesMemento

PatchDataVerticesMemento *	previousVerticesMemento

double	vertexMovementAbsoluteEps

double	vertexMovementRelativeEps

double	maxSquaredInitialMovement

double	maxSquaredMovement

double	successiveImprovementsAbsoluteEps

double	successiveImprovementsRelativeEps

double	boundedVertexMovementEps

int	vertexMovementExceedsBound

int	debugLevel

Detailed Description

The TerminationCriterion class contains functionality to terminate the VertexMover's optimization.

The TerminationCriterion class has three roles. It is used to terminate the optimization on a single patch; it is used to terminate the iterations over all patches in the mesh; and it is used to cull vertices frm the optimization processes. Thus, for each optimzation, two TerminationCriterion objects are used. The class contains five important member functions used in the VertexMover: initialize(), reset(), terminate(), cull_vertices(), and cleanup(). These functions are each explained in detail below. In general, the only one of these functions called directly from a concrete VertexMover is terminate() which allows the concrete VertexMover to determine when to stop producing new iterates on a given patch. All other functionality is handled from the base VertexMover base class.

There are several different types of termination criteria available. These types are listed in teh enumberation TCType. Multiple criteria types can be set on a given TermiantionCriterion object, and when this occurs, the optimization process will terminate whenever any of the criteria have been satisfied.

The following is a brief description of how TerminationCriterion is used within Mesquite. Functions called during QualityImprovement can be devided into three groups: reset_* - Initialize data for an iteration accumulate_* - Update TC for changed data during iteration terminate - Check if the termination criterion has been met. There are three different forms of the reset_* and accumulate_* functions which are called on the inner, outer, or both TerminationCriterion classes: _outer - Called on outer termination criterion. _inner - Called on inner termination criterion. _patch - Called on outer termination criterion for each patch and on inner termination criterion for each inner iteration.

If implementing a new TerminationCriterion, the following rules should be followed. If the value must be calculated on a global patch for the outer TC, then: o The functionality should be added to *_inner (yes, INNER) o The *_outer methods should be updated to call the *_inner with a global patch when your TC is requested. o The internal data for any such TC should be initialized in the reset_inner method. If the value for the outer criterion can be calculated from each local patch when iterating over the mesh with local patches, then: o The functionality should be added to *_patch o Any state values pertaining to the entire iteration must be initialized in reset_inner(..) and cleared in terminate() o Any patch-specific data should be initialized in reset_patch o Care should be taken that terminate() does not check uninitialized data if called before the first call to accumulate_patch()

Definition at line 119 of file includeLinks/TerminationCriterion.hpp.

Member Enumeration Documentation

enum TCType

defines the termination criterion

Enumerator
NONE
GRADIENT_L2_NORM_ABSOLUTE	checks the gradient $\nabla f$ of objective function $f : I\!\!R^{3N} \rightarrow I\!\!R$ against a double and stops when $\sqrt{\sum_{i=1}^{3N}\nabla f_i^2}<d$
GRADIENT_INF_NORM_ABSOLUTE	checks the gradient $\nabla f$ of objective function $f : I\!\!R^{3N} \rightarrow I\!\!R$ against a double and stops when $\max_{i=1}^{3N} \nabla f_i < d$
GRADIENT_L2_NORM_RELATIVE	terminates on the j_th iteration when $\sqrt{\sum_{i=1}^{3N}\nabla f_{i,j}^2}<d\sqrt{\sum_{i=1}^{3N}\nabla f_{i,0}^2}$ That is, terminates when the norm of the gradient is small than some scaling factor times the norm of the original gradient.
GRADIENT_INF_NORM_RELATIVE	terminates on the j_th iteration when $\max_{i=1 \cdots 3N}\nabla f_{i,j}<d \max_{i=1 \cdots 3N}\nabla f_{i,0}$ That is, terminates when the norm of the gradient is small than some scaling factor times the norm of the original gradient. (Using the infinity norm.)
KKT	Not yet implemented.
QUALITY_IMPROVEMENT_ABSOLUTE	Terminates when the objective function value is smaller than the given scalar value.
QUALITY_IMPROVEMENT_RELATIVE	Terminates when the objective function value is smaller than the given scalar value times the original objective function value.
NUMBER_OF_ITERATES	Terminates when the number of iterations exceeds a given integer.
CPU_TIME	Terminates when the algorithm exceeds an allotted time limit (given in seconds).
VERTEX_MOVEMENT_ABSOLUTE	Terminates when a the maximum distance moved by any vertex during the previous iteration is below the given value.
VERTEX_MOVEMENT_RELATIVE	Terminates when a the maximum distance moved by any vertex during the previous iteration is below the given value times the maximum distance moved by any vertex over the entire course of the optimization.
SUCCESSIVE_IMPROVEMENTS_ABSOLUTE	Terminates when the decrease in the objective function value since the previous iteration is below the given value.
SUCCESSIVE_IMPROVEMENTS_RELATIVE	Terminates when the decrease in the objective function value since the previous iteration is below the given value times the decrease in the objective function value since the beginning of this optimization process.
BOUNDED_VERTEX_MOVEMENT	Terminates when any vertex leaves the bounding box, defined by the given value, d. That is, when the absolute value of a single coordinate of vertex's position exceeds d.
NONE
GRADIENT_L2_NORM_ABSOLUTE	checks the gradient $\nabla f$ of objective function $f : I\!\!R^{3N} \rightarrow I\!\!R$ against a double and stops when $\sqrt{\sum_{i=1}^{3N}\nabla f_i^2}<d$
GRADIENT_INF_NORM_ABSOLUTE	checks the gradient $\nabla f$ of objective function $f : I\!\!R^{3N} \rightarrow I\!\!R$ against a double and stops when $\max_{i=1}^{3N} \nabla f_i < d$
GRADIENT_L2_NORM_RELATIVE	terminates on the j_th iteration when $\sqrt{\sum_{i=1}^{3N}\nabla f_{i,j}^2}<d\sqrt{\sum_{i=1}^{3N}\nabla f_{i,0}^2}$ That is, terminates when the norm of the gradient is small than some scaling factor times the norm of the original gradient.
GRADIENT_INF_NORM_RELATIVE	terminates on the j_th iteration when $\max_{i=1 \cdots 3N}\nabla f_{i,j}<d \max_{i=1 \cdots 3N}\nabla f_{i,0}$ That is, terminates when the norm of the gradient is small than some scaling factor times the norm of the original gradient. (Using the infinity norm.)
KKT	Not yet implemented.
QUALITY_IMPROVEMENT_ABSOLUTE	Terminates when the objective function value is smaller than the given scalar value.
QUALITY_IMPROVEMENT_RELATIVE	Terminates when the objective function value is smaller than the given scalar value times the original objective function value.
NUMBER_OF_ITERATES	Terminates when the number of iterations exceeds a given integer.
CPU_TIME	Terminates when the algorithm exceeds an allotted time limit (given in seconds).
VERTEX_MOVEMENT_ABSOLUTE	Terminates when a the maximum distance moved by any vertex during the previous iteration is below the given value.
VERTEX_MOVEMENT_RELATIVE	Terminates when a the maximum distance moved by any vertex during the previous iteration is below the given value times the maximum distance moved by any vertex over the entire course of the optimization.
SUCCESSIVE_IMPROVEMENTS_ABSOLUTE	Terminates when the decrease in the objective function value since the previous iteration is below the given value.
SUCCESSIVE_IMPROVEMENTS_RELATIVE	Terminates when the decrease in the objective function value since the previous iteration is below the given value times the decrease in the objective function value since the beginning of this optimization process.
BOUNDED_VERTEX_MOVEMENT	Terminates when any vertex leaves the bounding box, defined by the given value, d. That is, when the absolute value of a single coordinate of vertex's position exceeds d.

Definition at line 124 of file includeLinks/TerminationCriterion.hpp.

                 {
        NONE    = 0,
        GRADIENT_L2_NORM_ABSOLUTE = 1,  
        GRADIENT_INF_NORM_ABSOLUTE = 2,
        GRADIENT_L2_NORM_RELATIVE = 4,
        GRADIENT_INF_NORM_RELATIVE = 8,
        KKT  = 16,
        QUALITY_IMPROVEMENT_ABSOLUTE = 32,
        QUALITY_IMPROVEMENT_RELATIVE = 64,
        NUMBER_OF_ITERATES = 128,
        CPU_TIME  = 256,
        VERTEX_MOVEMENT_ABSOLUTE  = 512,
        VERTEX_MOVEMENT_RELATIVE  = 1024,
        SUCCESSIVE_IMPROVEMENTS_ABSOLUTE = 2048,
        SUCCESSIVE_IMPROVEMENTS_RELATIVE = 4096,
        BOUNDED_VERTEX_MOVEMENT = 8192
     };

enum TCType

Enumerator
NONE
GRADIENT_L2_NORM_ABSOLUTE	checks the gradient $\nabla f$ of objective function $f : I\!\!R^{3N} \rightarrow I\!\!R$ against a double and stops when $\sqrt{\sum_{i=1}^{3N}\nabla f_i^2}<d$
GRADIENT_INF_NORM_ABSOLUTE	checks the gradient $\nabla f$ of objective function $f : I\!\!R^{3N} \rightarrow I\!\!R$ against a double and stops when $\max_{i=1}^{3N} \nabla f_i < d$
GRADIENT_L2_NORM_RELATIVE	terminates on the j_th iteration when $\sqrt{\sum_{i=1}^{3N}\nabla f_{i,j}^2}<d\sqrt{\sum_{i=1}^{3N}\nabla f_{i,0}^2}$ That is, terminates when the norm of the gradient is small than some scaling factor times the norm of the original gradient.
GRADIENT_INF_NORM_RELATIVE	terminates on the j_th iteration when $\max_{i=1 \cdots 3N}\nabla f_{i,j}<d \max_{i=1 \cdots 3N}\nabla f_{i,0}$ That is, terminates when the norm of the gradient is small than some scaling factor times the norm of the original gradient. (Using the infinity norm.)
KKT	Not yet implemented.
QUALITY_IMPROVEMENT_ABSOLUTE	Terminates when the objective function value is smaller than the given scalar value.
QUALITY_IMPROVEMENT_RELATIVE	Terminates when the objective function value is smaller than the given scalar value times the original objective function value.
NUMBER_OF_ITERATES	Terminates when the number of iterations exceeds a given integer.
CPU_TIME	Terminates when the algorithm exceeds an allotted time limit (given in seconds).
VERTEX_MOVEMENT_ABSOLUTE	Terminates when a the maximum distance moved by any vertex during the previous iteration is below the given value.
VERTEX_MOVEMENT_RELATIVE	Terminates when a the maximum distance moved by any vertex during the previous iteration is below the given value times the maximum distance moved by any vertex over the entire course of the optimization.
SUCCESSIVE_IMPROVEMENTS_ABSOLUTE	Terminates when the decrease in the objective function value since the previous iteration is below the given value.
SUCCESSIVE_IMPROVEMENTS_RELATIVE	Terminates when the decrease in the objective function value since the previous iteration is below the given value times the decrease in the objective function value since the beginning of this optimization process.
BOUNDED_VERTEX_MOVEMENT	Terminates when any vertex leaves the bounding box, defined by the given value, d. That is, when the absolute value of a single coordinate of vertex's position exceeds d.
NONE
GRADIENT_L2_NORM_ABSOLUTE	checks the gradient $\nabla f$ of objective function $f : I\!\!R^{3N} \rightarrow I\!\!R$ against a double and stops when $\sqrt{\sum_{i=1}^{3N}\nabla f_i^2}<d$
GRADIENT_INF_NORM_ABSOLUTE	checks the gradient $\nabla f$ of objective function $f : I\!\!R^{3N} \rightarrow I\!\!R$ against a double and stops when $\max_{i=1}^{3N} \nabla f_i < d$
GRADIENT_L2_NORM_RELATIVE	terminates on the j_th iteration when $\sqrt{\sum_{i=1}^{3N}\nabla f_{i,j}^2}<d\sqrt{\sum_{i=1}^{3N}\nabla f_{i,0}^2}$ That is, terminates when the norm of the gradient is small than some scaling factor times the norm of the original gradient.
GRADIENT_INF_NORM_RELATIVE	terminates on the j_th iteration when $\max_{i=1 \cdots 3N}\nabla f_{i,j}<d \max_{i=1 \cdots 3N}\nabla f_{i,0}$ That is, terminates when the norm of the gradient is small than some scaling factor times the norm of the original gradient. (Using the infinity norm.)
KKT	Not yet implemented.
QUALITY_IMPROVEMENT_ABSOLUTE	Terminates when the objective function value is smaller than the given scalar value.
QUALITY_IMPROVEMENT_RELATIVE	Terminates when the objective function value is smaller than the given scalar value times the original objective function value.
NUMBER_OF_ITERATES	Terminates when the number of iterations exceeds a given integer.
CPU_TIME	Terminates when the algorithm exceeds an allotted time limit (given in seconds).
VERTEX_MOVEMENT_ABSOLUTE	Terminates when a the maximum distance moved by any vertex during the previous iteration is below the given value.
VERTEX_MOVEMENT_RELATIVE	Terminates when a the maximum distance moved by any vertex during the previous iteration is below the given value times the maximum distance moved by any vertex over the entire course of the optimization.
SUCCESSIVE_IMPROVEMENTS_ABSOLUTE	Terminates when the decrease in the objective function value since the previous iteration is below the given value.
SUCCESSIVE_IMPROVEMENTS_RELATIVE	Terminates when the decrease in the objective function value since the previous iteration is below the given value times the decrease in the objective function value since the beginning of this optimization process.
BOUNDED_VERTEX_MOVEMENT	Terminates when any vertex leaves the bounding box, defined by the given value, d. That is, when the absolute value of a single coordinate of vertex's position exceeds d.

Definition at line 124 of file src/Control/TerminationCriterion.hpp.

                 {
        NONE    = 0,
        GRADIENT_L2_NORM_ABSOLUTE = 1,  
        GRADIENT_INF_NORM_ABSOLUTE = 2,
        GRADIENT_L2_NORM_RELATIVE = 4,
        GRADIENT_INF_NORM_RELATIVE = 8,
        KKT  = 16,
        QUALITY_IMPROVEMENT_ABSOLUTE = 32,
        QUALITY_IMPROVEMENT_RELATIVE = 64,
        NUMBER_OF_ITERATES = 128,
        CPU_TIME  = 256,
        VERTEX_MOVEMENT_ABSOLUTE  = 512,
        VERTEX_MOVEMENT_RELATIVE  = 1024,
        SUCCESSIVE_IMPROVEMENTS_ABSOLUTE = 2048,
        SUCCESSIVE_IMPROVEMENTS_RELATIVE = 4096,
        BOUNDED_VERTEX_MOVEMENT = 8192
     };

Constructor & Destructor Documentation

TerminationCriterion ( )

Constructor which does not take any arguements.

Constructor initializes all of the data members which are not necessarily automatically initialized in their constructors.

Definition at line 62 of file Control/TerminationCriterion.cpp.

   : mGrad(8),
     initialVerticesMemento(0),
     previousVerticesMemento(0),
     debugLevel(2)
 {
   terminationCriterionFlag=NONE;
   cullingMethodFlag=NONE;
   cullingEps=0.0;
   initialOFValue=0.0;
   previousOFValue=0.0;
   currentOFValue = 0.0;
   lowerOFBound=0.0;
   initialGradL2Norm=0.0;
   initialGradInfNorm=0.0;
     //initial size of the gradient array
   gradL2NormAbsoluteEps=0.0;
   gradL2NormRelativeEps=0.0;
   gradInfNormAbsoluteEps=0.0;
   gradInfNormRelativeEps=0.0;
   qualityImprovementAbsoluteEps=0.0;
   qualityImprovementRelativeEps=0.0;
   iterationBound=0;
   iterationCounter=0;
   timeBound=0.0;
   vertexMovementAbsoluteEps=0.0;
   vertexMovementRelativeEps=0.0;
   successiveImprovementsAbsoluteEps=0.0;
   successiveImprovementsRelativeEps=0.0;
   boundedVertexMovementEps=0.0;
   
 }

~TerminationCriterion ( )

inline

Destructor.

Definition at line 185 of file includeLinks/TerminationCriterion.hpp.

185 {};

TerminationCriterion ( )

Constructor which does not take any arguements.

~TerminationCriterion ( )

inline

Destructor.

Definition at line 185 of file src/Control/TerminationCriterion.hpp.

185 {};

Member Function Documentation

void accumulate_inner	(	PatchData &	pd,
		MsqError &	err
	)

Accumulate data during inner iteration.

Definition at line 375 of file Control/TerminationCriterion.cpp.

References ObjectiveFunction::compute_gradient(), ObjectiveFunction::evaluate(), Mesquite::GRAD_FLAGS, MsqError::INVALID_MESH, TerminationCriterion::mGrad, MSQ_CHKERR, MSQ_ERRRTN, MSQ_SETERR, PatchData::num_vertices(), Mesquite::OF_FLAGS, TerminationCriterion::OFPtr, and TerminationCriterion::terminationCriterionFlag.

Referenced by TerminationCriterion::accumulate_outer(), ConjugateGradient::optimize_vertex_positions(), SteepestDescent::optimize_vertex_positions(), and FeasibleNewton::optimize_vertex_positions().

 {
   double of_value = 0;
   
   if (terminationCriterionFlag & GRAD_FLAGS)
   {
     mGrad.resize( pd.num_vertices() );
     bool b = OFPtr->compute_gradient(pd, &mGrad[0], of_value, err, pd.num_vertices());
     MSQ_ERRRTN(err);
     if (!b) {
       MSQ_SETERR(err)("Initial patch is invalid for gradient compuation.",
                       MsqError::INVALID_MESH);
       return;
     }
   }
   else if (terminationCriterionFlag & OF_FLAGS)
   {
     bool b = OFPtr->evaluate(pd, of_value, err); MSQ_ERRRTN(err);
     if (!b) {
       MSQ_SETERR(err)("Invalid patch passed to TerminationCriterion.",
                       MsqError::INVALID_MESH);
       return;
     }
   }
 
   accumulate_inner( pd, of_value, &mGrad[0], err );  MSQ_CHKERR(err);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void accumulate_inner	(	PatchData &	pd,
		MsqError &	err
	)

Accumulate data during inner iteration.

void accumulate_inner	(	PatchData &	pd,
		double	of_value,
		Vector3D *	of_grads,
		MsqError &	err
	)

Accumulate data during inner iteration.

Definition at line 404 of file Control/TerminationCriterion.cpp.

 {
   //if terminating on the norm of the gradient
   currentGradL2Norm = 10e6;
   if (terminationCriterionFlag & (GRADIENT_L2_NORM_ABSOLUTE | GRADIENT_L2_NORM_RELATIVE)) 
   {
     currentGradL2Norm = length(grad_array, pd.num_vertices()); // get the L2 norm
     MSQ_DBGOUT(debugLevel) << "  o TermCrit -- gradient L2 norm: " 
       << currentGradL2Norm << msq_stdio::endl;
   }
   currentGradInfNorm = 10e6;
   if (terminationCriterionFlag & (GRADIENT_INF_NORM_ABSOLUTE | GRADIENT_INF_NORM_RELATIVE)) 
   {
     currentGradInfNorm = length(grad_array, pd.num_vertices()); // get the Linf norm
     MSQ_DBGOUT(debugLevel) << "  o TermCrit -- gradient Inf norm: " 
       << currentGradInfNorm << msq_stdio::endl;
   } 
   
   if (terminationCriterionFlag & VERTEX_MOVEMENT_RELATIVE)
   {
     maxSquaredInitialMovement = pd.get_max_vertex_movement_squared(
                                initialVerticesMemento, err );  MSQ_ERRRTN(err);
   }
   
   previousOFValue = currentOFValue;
   currentOFValue = of_value;
   if (terminationCriterionFlag & OF_FLAGS)
     MSQ_DBGOUT(debugLevel) << "  o TermCrit -- OF Value: " << of_value << msq_stdio::endl;
   else if (grad_array)
     MSQ_DBGOUT(debugLevel) << "  o OF Value: " << of_value << msq_stdio::endl;
 
   ++iterationCounter;
 }

Here is the call graph for this function:

void accumulate_inner	(	PatchData &	pd,
		double	of_value,
		Vector3D *	of_grads,
		MsqError &	err
	)

Accumulate data during inner iteration.

void accumulate_outer	(	MeshSet &	ms,
		MsqError &	err
	)

Definition at line 442 of file Control/TerminationCriterion.cpp.

References TerminationCriterion::accumulate_inner(), MeshSet::get_next_patch(), PatchData::GLOBAL_PATCH, Mesquite::GRAD_FLAGS, MSQ_ERRRTN, Mesquite::OF_FLAGS, PatchDataParameters::set_patch_type(), TerminationCriterion::terminationCriterionFlag, and TerminationCriterion::VERTEX_MOVEMENT_RELATIVE.

Referenced by VertexMover::loop_over_mesh().

 {
   PatchData global_patch;
   
     //if we need to fill out the global patch data object.
   if (terminationCriterionFlag & (GRAD_FLAGS|OF_FLAGS|VERTEX_MOVEMENT_RELATIVE))
   {
     PatchDataParameters global_params;
     global_params.set_patch_type( PatchData::GLOBAL_PATCH, err, 0, 0 );MSQ_ERRRTN(err);
     ms.get_next_patch( global_patch, global_params, err );             MSQ_ERRRTN(err);
   }
   
   accumulate_inner( global_patch, err );                             MSQ_ERRRTN(err);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void accumulate_outer	(	MeshSet &	ms,
		MsqError &	err
	)

void accumulate_patch	(	PatchData &	pd,
		MsqError &	err
	)

Common code for both inner and outer termination criteria during inner iteration.

Definition at line 458 of file Control/TerminationCriterion.cpp.

Referenced by VertexMover::loop_over_mesh(), ConjugateGradient::optimize_vertex_positions(), and FeasibleNewton::optimize_vertex_positions().

 {
   if (terminationCriterionFlag & (VERTEX_MOVEMENT_ABSOLUTE|VERTEX_MOVEMENT_RELATIVE))
   {
     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)
   {
     MsqVertex* vert = pd.get_vertex_array(err);
     int num_vert = pd.num_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;
       }
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void accumulate_patch	(	PatchData &	pd,
		MsqError &	err
	)

Common code for both inner and outer termination criteria during inner iteration.

void add_criterion_type_with_double	(	TCType	tc_type,
		double	eps,
		MsqError &	err
	)

Sets the criterion by specifing the TCType and the eps value.

void add_criterion_type_with_double	(	TCType	tc_type,
		double	eps,
		MsqError &	err
	)

Sets the criterion by specifing the TCType and the eps value.

Function to add a type of termination criterion to this object. It is only valid if the specified criterion type requires a single double value.

Definition at line 100 of file Control/TerminationCriterion.cpp.

Referenced by FeasibleNewton::FeasibleNewton().

 {
   switch(tc_type){
     case GRADIENT_L2_NORM_ABSOLUTE:
        terminationCriterionFlag|=GRADIENT_L2_NORM_ABSOLUTE;
        gradL2NormAbsoluteEps=eps;
        break; 
     case GRADIENT_INF_NORM_ABSOLUTE:
        terminationCriterionFlag|=GRADIENT_INF_NORM_ABSOLUTE;
        gradInfNormAbsoluteEps=eps;
        break;
     case GRADIENT_L2_NORM_RELATIVE:
        terminationCriterionFlag|=GRADIENT_L2_NORM_RELATIVE;
        gradL2NormRelativeEps=eps;
        break;  
     case GRADIENT_INF_NORM_RELATIVE:
        terminationCriterionFlag|=GRADIENT_INF_NORM_RELATIVE;
        gradInfNormRelativeEps=eps;
        break;  
     case QUALITY_IMPROVEMENT_ABSOLUTE:
        terminationCriterionFlag|=QUALITY_IMPROVEMENT_ABSOLUTE;
        qualityImprovementAbsoluteEps=eps;
        break;
     case QUALITY_IMPROVEMENT_RELATIVE:
        terminationCriterionFlag|=QUALITY_IMPROVEMENT_RELATIVE;
        qualityImprovementRelativeEps=eps;
        break;
     case CPU_TIME:
        terminationCriterionFlag|=CPU_TIME;
        timeBound=eps;
        break;
     case VERTEX_MOVEMENT_ABSOLUTE:
        terminationCriterionFlag|=VERTEX_MOVEMENT_ABSOLUTE;
          //we actually compare squared movement to squared epsilon
        vertexMovementAbsoluteEps=(eps*eps);
        break;
     case VERTEX_MOVEMENT_RELATIVE:
        terminationCriterionFlag|=VERTEX_MOVEMENT_RELATIVE;
          //we actually compare squared movement to squared epsilon
        vertexMovementRelativeEps=(eps*eps);
        break;
     case SUCCESSIVE_IMPROVEMENTS_ABSOLUTE:
        terminationCriterionFlag|=SUCCESSIVE_IMPROVEMENTS_ABSOLUTE;
        successiveImprovementsAbsoluteEps=eps;
        break;
     case SUCCESSIVE_IMPROVEMENTS_RELATIVE:
        terminationCriterionFlag|=SUCCESSIVE_IMPROVEMENTS_RELATIVE;
        successiveImprovementsRelativeEps=eps;
        break;
     case BOUNDED_VERTEX_MOVEMENT:
        terminationCriterionFlag|=BOUNDED_VERTEX_MOVEMENT;
        boundedVertexMovementEps=eps;
        break;
     default:
        MSQ_SETERR(err)("TCType not valid for this function.",MsqError::INVALID_ARG);
   };
 }

Here is the caller graph for this function:

void add_criterion_type_with_int	(	TCType	tc_type,
		int	bound,
		MsqError &	err
	)

Sets the criterion by specifing the TCType and the integer value.

Function to add a type of termination criterion to this object. It is only valid if the specified criterion type requires a single integer value.

Definition at line 163 of file Control/TerminationCriterion.cpp.

References MsqError::INVALID_ARG, TerminationCriterion::iterationBound, MSQ_SETERR, TerminationCriterion::NUMBER_OF_ITERATES, and TerminationCriterion::terminationCriterionFlag.

Referenced by ConjugateGradient::ConjugateGradient(), LaplacianIQ::LaplacianIQ(), QualityImprover::QualityImprover(), and ShapeImprovementWrapper::ShapeImprovementWrapper().

 {
   switch(tc_type){
     case NUMBER_OF_ITERATES:
        terminationCriterionFlag|=NUMBER_OF_ITERATES;
        iterationBound=bound;
        break;
     default:
        MSQ_SETERR(err)("TCType not valid for this function.",MsqError::INVALID_ARG);
   };
 }

Here is the caller graph for this function:

void add_criterion_type_with_int	(	TCType	tc_type,
		int	bound,
		MsqError &	err
	)

Sets the criterion by specifing the TCType and the integer value.

void cleanup	(	MeshSet &	ms,
		MsqError &	err
	)

Cleans up after the TerminationCriterion is finished.

void cleanup	(	MeshSet &	ms,
		MsqError &	err
	)

Cleans up after the TerminationCriterion is finished.

Currently this only deletes the memento of the vertex positions and the mGrad vector if neccessary. When culling, we remove the soft fixed flags from all of the vertices.

Definition at line 707 of file Control/TerminationCriterion.cpp.

References MeshSet::clear_all_soft_fixed_flags(), TerminationCriterion::cullingMethodFlag, TerminationCriterion::initialVerticesMemento, MSQ_ERRRTN, and TerminationCriterion::previousVerticesMemento.

Referenced by VertexMover::loop_over_mesh().

 {
   delete previousVerticesMemento;
   delete initialVerticesMemento;
   previousVerticesMemento = 0;
   initialVerticesMemento = 0;
 
   if(cullingMethodFlag){
     ms.clear_all_soft_fixed_flags(err); MSQ_ERRRTN(err);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool cull_vertices	(	PatchData &	pd,
		ObjectiveFunction *	obj_ptr,
		MsqError &	err
	)

Function which determines whether this patch should be 'culled'.

bool cull_vertices	(	PatchData &	pd,
		ObjectiveFunction *	obj_ptr,
		MsqError &	err
	)

Function which determines whether this patch should be 'culled'.

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.

Definition at line 618 of file Control/TerminationCriterion.cpp.

Referenced by VertexMover::loop_over_mesh().

 {
     //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 = obj_ptr->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 = obj_ptr->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:
          //if movement was enough, cull
        prev_m = pd.get_max_vertex_movement_squared(previousVerticesMemento,err);
        MSQ_ERRZERO(err);
        if(prev_m <= 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 * init_m)){
          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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double get_current_function_value ( )

inline

This function returns the current function value.

Todo:: Michael: this function is not reliable. It needs to be more robust. How do we know whether currentOFValue got updated or not? We may want to make sure that all the criteria get checked.

Definition at line 240 of file includeLinks/TerminationCriterion.hpp.

References TerminationCriterion::currentOFValue.

241 {return currentOFValue;}

Mesquite::TerminationCriterion::currentOFValue

double currentOFValue

Definition: includeLinks/TerminationCriterion.hpp:261

double get_current_function_value ( )

inline

This function returns the current function value.

Todo:: Michael: this function is not reliable. It needs to be more robust. How do we know whether currentOFValue got updated or not? We may want to make sure that all the criteria get checked.

Definition at line 240 of file src/Control/TerminationCriterion.hpp.

References TerminationCriterion::currentOFValue.

241 {return currentOFValue;}

Mesquite::TerminationCriterion::currentOFValue

double currentOFValue

Definition: includeLinks/TerminationCriterion.hpp:261

void remove_criterion_type	(	TCType	tc_type,
		MsqError &	err
	)

Removes the criterion by specifing just the TCType.

void remove_criterion_type	(	TCType	tc_type,
		MsqError &	err
	)

Removes the criterion by specifing just the TCType.

Function to remove a previously set criterion type.

Definition at line 177 of file Control/TerminationCriterion.cpp.

References TerminationCriterion::terminationCriterionFlag.

 {
   terminationCriterionFlag&=(~tc_type);
 }

void remove_culling ( MsqError & err )

Removes any previously set culling types (sets the culling type to be NONE).

void remove_culling ( MsqError & err )

Removes any previously set culling types (sets the culling type to be NONE).

Sets the culling type to be NONE.

Definition at line 217 of file Control/TerminationCriterion.cpp.

References TerminationCriterion::cullingMethodFlag, and TerminationCriterion::NONE.

 {
   cullingMethodFlag=NONE;
 }

void reset_inner	(	PatchData &	pd,
		ObjectiveFunction *	of,
		MsqError &	err
	)

Clear any data accumulated during an inner iteration.

void reset_inner	(	PatchData &	pd,
		ObjectiveFunction *	obj_ptr,
		MsqError &	err
	)

Clear any data accumulated during an inner iteration.

Reset function using using a PatchData object. This function is called for the inner-stopping criterion directly from the loop over mesh function in VertexMover. For outer criterion, it is called from the reset function which takes a MeshSet object. This function prepares the object to be used by setting the initial values of some of the data members. As examples, if needed, it resets the cpu timer to zero, the iteration counter to zero, and the initial and previous objective function values to the current objective function value for this patch. The return value for this function is similar to that of terminate(). The function returns false if the checked criteria have not been satisfied, and true if they have been. reset() only checks the GRADIENT_INF_NORM_ABSOLUTE, GRADIENT_L2_NORM_ABSOLUTE, and the QUALITY_IMPROVEMENT_ABSOLUTE criteria. Checking these criteria allows the QualityImprover to skip the entire optimization if the initial mesh satisfies the appropriate conditions.

Definition at line 265 of file Control/TerminationCriterion.cpp.

Referenced by VertexMover::loop_over_mesh(), and TerminationCriterion::reset_outer().

 {
   const unsigned long totalFlag = terminationCriterionFlag | cullingMethodFlag;
   OFPtr = obj_ptr;
   
     // clear flag for BOUNDED_VERTEX_MOVEMENT
   vertexMovementExceedsBound = 0;
   
     // Use -1 to denote that this isn't initialized yet.
     // As all valid values must be >= 0.0, a negative
     // value indicates that it is uninitialized and is
     // always less than any valid value.
   maxSquaredMovement = -1;
   
     // Clear the iteration count.
   iterationCounter = 0;
   
     //reset the inner timer if needed
   if(totalFlag & CPU_TIME){
     mTimer.reset();
   }
    
     //GRADIENT
   if(totalFlag & GRAD_FLAGS)
   {
     int num_vertices=pd.num_vertices();
     mGrad.resize( num_vertices );
 
       //get gradient and make sure it is valid
     bool b = obj_ptr->compute_gradient(pd, &mGrad[0] , currentOFValue, 
                                        err, num_vertices); MSQ_ERRRTN(err);
     if (!b) {
       MSQ_SETERR(err)("Initial patch is invalid for gradient computation.", 
                       MsqError::INVALID_STATE);
       return;
     } 
 
       //get the gradient norms
     if (totalFlag & (GRADIENT_INF_NORM_ABSOLUTE|GRADIENT_INF_NORM_RELATIVE))
     {
       currentGradInfNorm = initialGradInfNorm = Linf(&mGrad[0], num_vertices);
       MSQ_DBGOUT(debugLevel) << "  o Initial gradient Inf norm: " 
         << initialGradInfNorm << msq_stdio::endl;
     }  
     if (totalFlag & (GRADIENT_L2_NORM_ABSOLUTE|GRADIENT_L2_NORM_RELATIVE))
     {
       currentGradL2Norm = initialGradL2Norm = length(&mGrad[0], num_vertices);
       MSQ_DBGOUT(debugLevel) << "  o Initial gradient L2 norm: " 
         << initialGradL2Norm << msq_stdio::endl;
     }  
       //the OFvalue comes for free, so save it
     previousOFValue=currentOFValue;
     initialOFValue=currentOFValue;
   }
   //find the initial objective function value if needed and not already
   //computed.  If we needed the gradient, we have the OF value for free.
   else if (totalFlag & OF_FLAGS)
   {
       //ensure the obj_ptr is not null
     if(obj_ptr==NULL){
       MSQ_SETERR(err)("Error termination criteria set which uses objective "
                       "functions, but no objective function is available.",
                       MsqError::INVALID_STATE);
       return;
     }
     
     bool b = obj_ptr->evaluate(pd, currentOFValue, err); MSQ_ERRRTN(err);
     if (!b){
       MSQ_SETERR(err)("Initial patch is invalid for evaluation.",MsqError::INVALID_STATE);
       return;
     }
       //std::cout<<"\nReseting initial of value = "<<initialOFValue;
     previousOFValue=currentOFValue;
     initialOFValue=currentOFValue;
   }
   
   if (totalFlag & (GRAD_FLAGS|OF_FLAGS))
     MSQ_DBGOUT(debugLevel) << "  o Initial OF value: " << initialOFValue << msq_stdio::endl;
   
     // Store current vertex locations now, because we'll
     // need them later to compare the current movement with.
   if (totalFlag & VERTEX_MOVEMENT_RELATIVE)
   {
     if (initialVerticesMemento)
     {
       pd.recreate_vertices_memento( initialVerticesMemento, err );
     }
     else
     {
       initialVerticesMemento = pd.create_vertices_memento( err );
     }
     MSQ_ERRRTN(err);
     maxSquaredInitialMovement = DBL_MAX;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void reset_outer	(	MeshSet &	ms,
		ObjectiveFunction *	of,
		MsqError &	err
	)

Clear any data accumulated during an outer iteration.

void reset_outer	(	MeshSet &	ms,
		ObjectiveFunction *	obj_ptr,
		MsqError &	err
	)

Clear any data accumulated during an outer iteration.

This version of reset is called using a MeshSet, which implies it is only called when this criterion is used as the 'outer' termination criterion.

Definition at line 228 of file Control/TerminationCriterion.cpp.

References TerminationCriterion::cullingMethodFlag, MeshSet::get_next_patch(), PatchData::GLOBAL_PATCH, Mesquite::GRAD_FLAGS, MSQ_ERRRTN, Mesquite::OF_FLAGS, TerminationCriterion::reset_inner(), PatchDataParameters::set_patch_type(), TerminationCriterion::terminationCriterionFlag, and TerminationCriterion::VERTEX_MOVEMENT_RELATIVE.

Referenced by VertexMover::loop_over_mesh().

 {
   const unsigned long totalFlag = terminationCriterionFlag | cullingMethodFlag;
   PatchData global_patch;
   
     //if we need to fill out the global patch data object.
   if (totalFlag & (GRAD_FLAGS | OF_FLAGS | VERTEX_MOVEMENT_RELATIVE))
   {
     PatchDataParameters global_patch_params;
     global_patch_params.set_patch_type( PatchData::GLOBAL_PATCH, err, 0, 0 );
        MSQ_ERRRTN(err);
     ms.get_next_patch( global_patch, global_patch_params, err ); 
        MSQ_ERRRTN(err);
   }
 
     //now call the other reset
   reset_inner( global_patch, obj_ptr, err ); MSQ_ERRRTN(err);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void reset_patch	(	PatchData &	pd,
		MsqError &	err
	)

Shared inner and outer initialization during inner loop.

Definition at line 362 of file Control/TerminationCriterion.cpp.

References PatchData::create_vertices_memento(), TerminationCriterion::cullingMethodFlag, MSQ_ERRRTN, TerminationCriterion::previousVerticesMemento, PatchData::recreate_vertices_memento(), TerminationCriterion::terminationCriterionFlag, TerminationCriterion::VERTEX_MOVEMENT_ABSOLUTE, and TerminationCriterion::VERTEX_MOVEMENT_RELATIVE.

Referenced by VertexMover::loop_over_mesh().

 {
   const unsigned long totalFlag = terminationCriterionFlag | cullingMethodFlag;
   if (totalFlag & (VERTEX_MOVEMENT_ABSOLUTE | VERTEX_MOVEMENT_RELATIVE))
   {
     if (previousVerticesMemento)
       pd.recreate_vertices_memento(previousVerticesMemento,err); 
     else
       previousVerticesMemento = pd.create_vertices_memento(err);
     MSQ_ERRRTN(err);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void reset_patch	(	PatchData &	pd,
		MsqError &	err
	)

Shared inner and outer initialization during inner loop.

void set_culling_type	(	TCType	tc_type,
		double	eps,
		MsqError &	err
	)

Sets the type of criterion that the user would like to use for culling purposes (along with the associated tolerance.

Function to add a type of termination criterion to this object which will be used for culling purposes only. As part of the global termination criterion, the outer criterion will also check to make sure that there are still free vertices in the mesh.

Definition at line 188 of file Control/TerminationCriterion.cpp.

References TerminationCriterion::cullingEps, TerminationCriterion::cullingMethodFlag, MsqError::INVALID_ARG, MSQ_SETERR, TerminationCriterion::QUALITY_IMPROVEMENT_ABSOLUTE, TerminationCriterion::QUALITY_IMPROVEMENT_RELATIVE, TerminationCriterion::SUCCESSIVE_IMPROVEMENTS_ABSOLUTE, TerminationCriterion::SUCCESSIVE_IMPROVEMENTS_RELATIVE, TerminationCriterion::VERTEX_MOVEMENT_ABSOLUTE, and TerminationCriterion::VERTEX_MOVEMENT_RELATIVE.

 {
   switch(tc_type){
     case QUALITY_IMPROVEMENT_ABSOLUTE:
        cullingMethodFlag=QUALITY_IMPROVEMENT_ABSOLUTE;
        break;
     case QUALITY_IMPROVEMENT_RELATIVE:
        cullingMethodFlag=QUALITY_IMPROVEMENT_RELATIVE;
        break;
     case VERTEX_MOVEMENT_ABSOLUTE:
        cullingMethodFlag=VERTEX_MOVEMENT_ABSOLUTE;
        break;
     case VERTEX_MOVEMENT_RELATIVE:
        cullingMethodFlag=VERTEX_MOVEMENT_RELATIVE;
        break;   
     case SUCCESSIVE_IMPROVEMENTS_ABSOLUTE:
        cullingMethodFlag=SUCCESSIVE_IMPROVEMENTS_ABSOLUTE;
        break;
      case SUCCESSIVE_IMPROVEMENTS_RELATIVE:
        cullingMethodFlag=SUCCESSIVE_IMPROVEMENTS_RELATIVE;
        break;  
     default:
        MSQ_SETERR(err)("TCType not valid for this function.",MsqError::INVALID_ARG);
   };
   cullingEps=eps;
 }

void set_culling_type	(	TCType	tc_type,
		double	eps,
		MsqError &	err
	)

Sets the type of criterion that the user would like to use for culling purposes (along with the associated tolerance.

void set_debug_output_level ( int i )

inline

Definition at line 243 of file includeLinks/TerminationCriterion.hpp.

References TerminationCriterion::debugLevel, and i.

Referenced by VertexMover::loop_over_mesh().

244 { debugLevel = i; }

i

blockLoc i

Definition: read.cpp:79

Mesquite::TerminationCriterion::debugLevel

int debugLevel

Definition: includeLinks/TerminationCriterion.hpp:300

Here is the caller graph for this function:

void set_debug_output_level ( int i )

inline

Definition at line 243 of file src/Control/TerminationCriterion.hpp.

References TerminationCriterion::debugLevel, and i.

244 { debugLevel = i; }

i

blockLoc i

Definition: read.cpp:79

Mesquite::TerminationCriterion::debugLevel

int debugLevel

Definition: includeLinks/TerminationCriterion.hpp:300

bool terminate ( )

Check if termination criterion has been met.

bool terminate ( )

Check if termination criterion has been met.

This function evaluates the needed information and then evaluates the termination criteria. If any of the selected criteria are satisfied, the function returns true. Otherwise, the function returns false.

Definition at line 493 of file Control/TerminationCriterion.cpp.

Referenced by VertexMover::loop_over_mesh(), ConjugateGradient::optimize_vertex_positions(), SteepestDescent::optimize_vertex_positions(), and FeasibleNewton::optimize_vertex_positions().

 {
   bool return_flag = false;
   //  cout<<"\nInside terminate(pd,of,err):  flag = "<<terminationCriterionFlag << endl;
 
     //First check for an interrupt signal
   if (MsqInterrupt::interrupt())
   {
      MSQ_DBGOUT(debugLevel) << "  o TermCrit -- INTERRUPTED" << msq_stdio::endl;
     return true;
   }
   
     //if terminating on numbering of inner iterations
   if (NUMBER_OF_ITERATES & terminationCriterionFlag
     && iterationCounter >= iterationBound)
   {
     return_flag = true;
     MSQ_DBGOUT(debugLevel) << "  o TermCrit -- Reached " << iterationBound << " iterations." << msq_stdio::endl;
   }
   
   if (CPU_TIME & terminationCriterionFlag && mTimer.since_birth()>=timeBound)
   {
     return_flag=true;
     MSQ_DBGOUT(debugLevel) << "  o TermCrit -- Exceeded CPU time." << msq_stdio::endl;
   }
   
   
   if ((VERTEX_MOVEMENT_ABSOLUTE|VERTEX_MOVEMENT_RELATIVE) & terminationCriterionFlag
       && maxSquaredMovement >= 0.0)
   {
     MSQ_DBGOUT(debugLevel) << "  o TermCrit -- Maximuim vertex movement: "
     << sqrt(maxSquaredMovement) << msq_stdio::endl;
 
     if (VERTEX_MOVEMENT_ABSOLUTE & terminationCriterionFlag 
         && maxSquaredMovement <= vertexMovementAbsoluteEps)
     {
       return_flag = true;
     }
   
     if (VERTEX_MOVEMENT_RELATIVE & terminationCriterionFlag
         && maxSquaredMovement <= vertexMovementRelativeEps*maxSquaredInitialMovement)
     {
       return_flag = true;
     }
     
       // Clear this value at the end of each iteration.
     maxSquaredMovement = -1.0;
   }
 
   if (GRADIENT_L2_NORM_ABSOLUTE & terminationCriterionFlag &&
       currentGradL2Norm <= gradL2NormAbsoluteEps)
   {
     return_flag = true;
   }
   
   if (GRADIENT_INF_NORM_ABSOLUTE & terminationCriterionFlag &&
       currentGradInfNorm <= gradInfNormAbsoluteEps)
   {
     return_flag = true;
   }
   
   if (GRADIENT_L2_NORM_RELATIVE & terminationCriterionFlag &&
       currentGradL2Norm <= (gradL2NormRelativeEps * initialGradL2Norm))
   {
     return_flag = true;
   }
   
   if (GRADIENT_INF_NORM_RELATIVE & terminationCriterionFlag &&
       currentGradInfNorm <= (gradInfNormRelativeEps * initialGradInfNorm))
   {
     return_flag = true;
   }
   
   if (QUALITY_IMPROVEMENT_ABSOLUTE & terminationCriterionFlag &&
       currentOFValue <= qualityImprovementAbsoluteEps)
   {
     return_flag = true;
   }
   
   if (QUALITY_IMPROVEMENT_RELATIVE & terminationCriterionFlag &&
       (currentOFValue - lowerOFBound) <= 
         qualityImprovementRelativeEps * (initialOFValue - lowerOFBound))
   {
     return_flag = true;
   }
   
   if (SUCCESSIVE_IMPROVEMENTS_ABSOLUTE & terminationCriterionFlag &&
      (previousOFValue - currentOFValue) <= successiveImprovementsRelativeEps)
   {
     return_flag = true;
   }
   
   if (SUCCESSIVE_IMPROVEMENTS_RELATIVE & terminationCriterionFlag &&
       (previousOFValue - currentOFValue) <= 
         successiveImprovementsRelativeEps * (initialOFValue - currentOFValue))
   {
     return_flag = true;
   }
   
   if (BOUNDED_VERTEX_MOVEMENT & terminationCriterionFlag && vertexMovementExceedsBound)
   {
     return_flag = true;
     MSQ_DBGOUT(debugLevel) << "  o TermCrit -- " << vertexMovementExceedsBound
                            << " vertices out of bounds." << msq_stdio::endl;
   }
   
     // clear this value at the end of each iteration
   vertexMovementExceedsBound = 0;
 
     //if none of the criteria were satisfied
   return return_flag;
 }