High Performance implementation of the Feasible Newton algorythm. More...

#include <FeasibleNewton.hpp>

Inheritance diagram for FeasibleNewton:

Collaboration diagram for FeasibleNewton:

Public Member Functions
	FeasibleNewton (ObjectiveFunction *of)

virtual	~FeasibleNewton ()

void	set_lower_gradient_bound (double gradc)

	FeasibleNewton (ObjectiveFunction *of)

virtual	~FeasibleNewton ()

void	set_lower_gradient_bound (double gradc)

Public Member Functions inherited from VertexMover
virtual	~VertexMover ()

virtual double	loop_over_mesh (MeshSet &ms, MsqError &err)
	Improves the quality of the MeshSet, calling some methods specified in a class derived from VertexMover. More...

virtual	~VertexMover ()

virtual double	loop_over_mesh (MeshSet &ms, MsqError &err)
	This is the "run" function of PatchDataUser. It can do anything really. More...

Public Member Functions inherited from QualityImprover
virtual	~QualityImprover ()

void	set_name (msq_std::string name)
	provides a name to the QualityImprover (use it in constructor). More...

virtual msq_std::string	get_name ()
	retrieves the QualityImprover name. A default name should be set in the constructor. More...

virtual AlgorithmType	get_algorithm_type ()
	Return the algorithm type (to avoid RTTI use). More...

void	set_inner_termination_criterion (TerminationCriterion *crit)
	Sets in the termination criterion for the concrete solver's optimization. More...

void	set_outer_termination_criterion (TerminationCriterion *crit)
	Sets in the termination criterion for the outer loop over patches. More...

virtual	~QualityImprover ()

void	set_name (msq_std::string name)
	provides a name to the QualityImprover (use it in constructor). More...

virtual msq_std::string	get_name ()
	retrieves the QualityImprover name. A default name should be set in the constructor. More...

virtual AlgorithmType	get_algorithm_type ()
	Return the algorithm type (to avoid RTTI use). More...

void	set_inner_termination_criterion (TerminationCriterion *crit)
	Sets in the termination criterion for the concrete solver's optimization. More...

void	set_outer_termination_criterion (TerminationCriterion *crit)
	Sets in the termination criterion for the outer loop over patches. More...

Public Member Functions inherited from PatchDataUser
virtual	~PatchDataUser ()

virtual void	set_patch_type (PatchData::PatchType patch_type, MsqError &err, int param1=0, int param2=0)
	Sets the Patch Type. More...

PatchData::PatchType	get_patch_type ()
	Returns the Patch Type. More...

int	get_nb_layers (MsqError &err)
	Returns number of layers (if relevant for partition algorythm). More...

void	add_culling_method (enum PatchData::culling_method cm)
	Sets on the culling method passed as argument. More...

void	no_culling_method ()
	Sets off all culling methods. More...

void	remove_culling_method (enum PatchData::culling_method cm)
	Sets off the culling method passed as argument. More...

long unsigned int	get_culling_method_bits ()
	Returns the bitset containing culling methods flags. More...

void	set_all_parameters (PatchDataParameters &params)

PatchDataParameters &	get_all_parameters ()
	Returns the PatchDataParameters object. More...

void	set_global_patch (PatchData *pd, MsqError &err)
	Sets the Global Patch, so that it can be use by contiguoug PatchDataUser. More...

PatchData *	get_global_patch ()
	Returns the Global Patch. More...

void	no_global_patch ()
	Sets the Global Patch pointer to NULL. More...

virtual	~PatchDataUser ()

virtual void	set_patch_type (PatchData::PatchType patch_type, MsqError &err, int param1=0, int param2=0)
	Sets the Patch Type. More...

PatchData::PatchType	get_patch_type ()
	Returns the Patch Type. More...

int	get_nb_layers (MsqError &err)
	Returns number of layers (if relevant for partition algorythm). More...

void	add_culling_method (enum PatchData::culling_method cm)
	Sets on the culling method passed as argument. More...

void	no_culling_method ()
	Sets off all culling methods. More...

void	remove_culling_method (enum PatchData::culling_method cm)
	Sets off the culling method passed as argument. More...

long unsigned int	get_culling_method_bits ()
	Returns the bitset containing culling methods flags. More...

void	set_all_parameters (PatchDataParameters &params)

PatchDataParameters &	get_all_parameters ()
	Returns the PatchDataParameters object. More...

void	set_global_patch (PatchData *pd, MsqError &err)
	Sets the Global Patch, so that it can be use by contiguoug PatchDataUser. More...

PatchData *	get_global_patch ()
	Returns the Global Patch. More...

void	no_global_patch ()
	Sets the Global Patch pointer to NULL. More...

Protected Member Functions
virtual void	initialize (PatchData &pd, MsqError &err)

virtual void	optimize_vertex_positions (PatchData &pd, MsqError &err)

virtual void	initialize_mesh_iteration (PatchData &pd, MsqError &err)

virtual void	terminate_mesh_iteration (PatchData &pd, MsqError &err)

virtual void	cleanup ()

virtual void	initialize (PatchData &pd, MsqError &err)

virtual void	optimize_vertex_positions (PatchData &pd, MsqError &err)

virtual void	initialize_mesh_iteration (PatchData &pd, MsqError &err)

virtual void	terminate_mesh_iteration (PatchData &pd, MsqError &err)

virtual void	cleanup ()

Protected Member Functions inherited from VertexMover
	VertexMover ()

size_t	check_feasible (PatchData &pd, MsqError &err)
	CHECK FEASIBLE IS NOT YET IMPLEMENTED. More...

	VertexMover ()

size_t	check_feasible (PatchData &pd, MsqError &err)
	CHECK FEASIBLE IS NOT YET IMPLEMENTED. More...

Protected Member Functions inherited from QualityImprover
	QualityImprover ()

const MeshSet *	get_mesh_set () const

MeshSet *	get_mesh_set ()

void	set_mesh_set (MeshSet *ms)

TerminationCriterion *	get_outer_termination_criterion ()
	return the outer termination criterion pointer More...

TerminationCriterion *	get_inner_termination_criterion ()
	return the inner termination criterion pointer More...

	QualityImprover ()

const MeshSet *	get_mesh_set () const

MeshSet *	get_mesh_set ()

void	set_mesh_set (MeshSet *ms)

TerminationCriterion *	get_outer_termination_criterion ()
	return the outer termination criterion pointer More...

TerminationCriterion *	get_inner_termination_criterion ()
	return the inner termination criterion pointer More...

Protected Member Functions inherited from PatchDataUser
	PatchDataUser ()

	PatchDataUser ()

Private Attributes
double	convTol

MsqHessian	mHessian

PatchDataVerticesMemento *	coordsMem

Additional Inherited Members
Public Types inherited from PatchDataUser
enum	AlgorithmType { QUALITY_IMPROVER, QUALITY_ASSESSOR, MESH_TRANSFORM, TARGET_CALCULATOR, QUALITY_IMPROVER, QUALITY_ASSESSOR, MESH_TRANSFORM, TARGET_CALCULATOR }

enum	AlgorithmType { QUALITY_IMPROVER, QUALITY_ASSESSOR, MESH_TRANSFORM, TARGET_CALCULATOR, QUALITY_IMPROVER, QUALITY_ASSESSOR, MESH_TRANSFORM, TARGET_CALCULATOR }

Protected Attributes inherited from VertexMover
ObjectiveFunction *	objFunc

Detailed Description

High Performance implementation of the Feasible Newton algorythm.

Consider our non-linear objective function $f: I\!\!R^{3N} \rightarrow I\!\!R$ where $ N $ is the number of vertices of the mesh, and $ 3N $ is therefore the number of degrees of freedom of the mesh. The Taylor expansion of $ f $ around the point $ x_0 $ is

$f(x_0+d) = f(x_0) + \nabla f(x_0)d + \frac{1}{2} d^T\nabla^2 f(x_0)d + ... \;\;\; .$

Each iteration of the Newton algorithm tries to find a descent vector that minimizes the above quadratic approximation, i.e. it looks for

$\min_{d} q(d;x_0) = f(x_0) + \nabla f(x_0)d + \frac{1}{2} d^T\nabla^2 f(x_0)d \;\; .$

We know that if a quadratic function has a finite minimum, it is reached at the point where the function gradient is null and that the function Hessian is then positive definite. Therefore we are looking for $ d $ such that $\nabla q(d;x_0) =0$ . We have

$\nabla q(d;x_0) = \nabla f(x_0) + \nabla^2 f(x_0)d \;\;,$

therefore we must solve for $ d $ the system

$\nabla^2 f(x_0)d = -\nabla f(x_0) \;\; .$

We assume that the Hessian is positive definite and we use the conjugate gradient algebraic solver to solve the above system. If the conjugate gradient solver finds a direction of negative curvature, the Hessian was not positive definite and we take a step in that direction of negative curvature, which is a descent direction.

Definition at line 93 of file includeLinks/FeasibleNewton.hpp.

Constructor & Destructor Documentation

FeasibleNewton ( ObjectiveFunction * of )

Definition at line 57 of file QualityImprover/VertexMover/FeasibleNewton/FeasibleNewton.cpp.

References TerminationCriterion::add_criterion_type_with_double(), FeasibleNewton::convTol, FeasibleNewton::coordsMem, QualityImprover::get_inner_termination_criterion(), PatchData::GLOBAL_PATCH, TerminationCriterion::GRADIENT_L2_NORM_ABSOLUTE, MSQ_CHKERR, VertexMover::objFunc, QualityImprover::set_name(), and PatchDataUser::set_patch_type().

                                                     :
   VertexMover()
 {
   coordsMem=NULL;
   objFunc=of;
   MsqError err;
   convTol=1e-6;
   this->set_name("FeasibleNewton");
   set_patch_type(PatchData::GLOBAL_PATCH, err);
   TerminationCriterion* default_crit=get_inner_termination_criterion();
   default_crit->add_criterion_type_with_double(
                     TerminationCriterion::GRADIENT_L2_NORM_ABSOLUTE, 5e-5, err);
   MSQ_CHKERR(err);
 }  

Here is the call graph for this function:

virtual ~FeasibleNewton ( )

inlinevirtual

Definition at line 98 of file includeLinks/FeasibleNewton.hpp.

References FeasibleNewton::coordsMem.

99 { delete coordsMem; }

Mesquite::FeasibleNewton::coordsMem

PatchDataVerticesMemento * coordsMem

Definition: includeLinks/FeasibleNewton.hpp:118

FeasibleNewton ( ObjectiveFunction * of )

virtual ~FeasibleNewton ( )

inlinevirtual

Definition at line 98 of file src/QualityImprover/VertexMover/FeasibleNewton/FeasibleNewton.hpp.

References FeasibleNewton::coordsMem.

99 { delete coordsMem; }

Mesquite::FeasibleNewton::coordsMem

PatchDataVerticesMemento * coordsMem

Definition: includeLinks/FeasibleNewton.hpp:118

Member Function Documentation

void cleanup ( )

protectedvirtual

Implements VertexMover.

Definition at line 351 of file QualityImprover/VertexMover/FeasibleNewton/FeasibleNewton.cpp.

References FeasibleNewton::coordsMem.

 {
   delete coordsMem; coordsMem = NULL;
 }

virtual void cleanup ( )

protectedvirtual

Implements VertexMover.

virtual void initialize	(	PatchData &	pd,
		MsqError &	err
	)

protectedvirtual

Implements VertexMover.

void initialize	(	PatchData &	pd,
		MsqError &	err
	)

protectedvirtual

Implements VertexMover.

Definition at line 73 of file QualityImprover/VertexMover/FeasibleNewton/FeasibleNewton.cpp.

References FeasibleNewton::coordsMem, PatchData::create_vertices_memento(), and MSQ_CHKERR.

 {
   // Cannot do anything.  Variable sizes with maximum size dependent
   // upon the entire MeshSet.
   coordsMem = pd.create_vertices_memento(err); MSQ_CHKERR(err);
 }

Here is the call graph for this function:

void initialize_mesh_iteration	(	PatchData &	pd,
		MsqError &	err
	)

protectedvirtual

Implements VertexMover.

Definition at line 80 of file QualityImprover/VertexMover/FeasibleNewton/FeasibleNewton.cpp.

References PatchData::reorder().

 {
   pd.reorder();
 }

Here is the call graph for this function:

virtual void initialize_mesh_iteration	(	PatchData &	pd,
		MsqError &	err
	)

protectedvirtual

Implements VertexMover.

virtual void optimize_vertex_positions	(	PatchData &	pd,
		MsqError &	err
	)

protectedvirtual

Implements VertexMover.

void optimize_vertex_positions	(	PatchData &	pd,
		MsqError &	err
	)

protectedvirtual

Implements VertexMover.

Definition at line 85 of file QualityImprover/VertexMover/FeasibleNewton/FeasibleNewton.cpp.

References TerminationCriterion::accumulate_inner(), TerminationCriterion::accumulate_patch(), MsqHessian::cg_solver(), ObjectiveFunction::compute_gradient(), ObjectiveFunction::compute_hessian(), FeasibleNewton::convTol, FeasibleNewton::coordsMem, d, ObjectiveFunction::evaluate(), QualityImprover::get_inner_termination_criterion(), PatchData::get_vertex_array(), i, MsqHessian::initialize(), Mesquite::inner(), MsqError::INTERNAL_ERROR, Mesquite::length(), FeasibleNewton::mHessian, PatchData::move_free_vertices_constrained(), MSQ_DBG, MSQ_DBGOUT, MSQ_ERRRTN, MSQ_FUNCTION_TIMER, MSQ_PRINT, MSQ_SETERR, MsqFreeVertexIndexIterator::next(), PatchData::num_free_vertices(), PatchData::num_vertices(), VertexMover::objFunc, PatchData::recreate_vertices_memento(), MsqFreeVertexIndexIterator::reset(), PatchData::set_to_vertices_memento(), TerminationCriterion::terminate(), and MsqFreeVertexIndexIterator::value().

 {
   MSQ_FUNCTION_TIMER( "FeasibleNewton::optimize_vertex_positions" );
   MSQ_DBGOUT(2) << "\no  Performing Feasible Newton optimization.\n";
 
   const double sigma   = 1e-4;
   const double beta0   = 0.25;
   const double beta1   = 0.80;
   const double tol1    = 1e-8;
   const double tol2    = 1e-12;
   const double epsilon = 1e-10;
   double original_value, new_value;
   double beta;
   
   int nv = pd.num_vertices();
   msq_std::vector<Vector3D> grad_vect(nv), d_vect(nv);
   Vector3D* grad = &grad_vect[0];
   Vector3D* d = &d_vect[0];
   bool fn_bool=true;// bool used for determining validity of patch
 
   int i;
 
   // TODD -- Don't blame the code for bad things happening when using a
   //         bad termination test or requesting more accuracy than is
   //         possible.
   //
   //         Also, 
 
   // 1.  Allocate a hessian and calculate the sparsity pattern.
   mHessian.initialize(pd, err); MSQ_ERRRTN(err);
 
   // 3.  Calculate the norm of the gradient for the patch
   MSQ_DBGOUT(3) << "  o  gradient norm: " << length(grad, nv) << msq_stdio::endl;
   
   // does the Feasible Newton iteration until stopping is required.
   // Terminate when inner termination criterion signals.
 
   /* Computes the value of the stopping criterion*/
   TerminationCriterion* term_crit=get_inner_termination_criterion();
   while ( !term_crit->terminate() ) {
     fn_bool = objFunc->compute_hessian( pd, mHessian, grad, original_value, err );
     MSQ_ERRRTN(err);
     if (!fn_bool) {
       MSQ_SETERR(err)("invalid patch for hessian calculation", MsqError::INTERNAL_ERROR);
       return; 
     }
   
     // Prints out free vertices coordinates. 
     if (MSQ_DBG(3)) {
       MSQ_DBGOUT(3) << "\n  o Free vertices ("<< pd.num_free_vertices(err)
                 <<")original coordinates:\n ";
       MSQ_ERRRTN(err);
       MsqVertex* toto1 = pd.get_vertex_array(err); MSQ_ERRRTN(err);
       MsqFreeVertexIndexIterator ind1(&pd, err); MSQ_ERRRTN(err);
       ind1.reset();
       while (ind1.next()) {
         MSQ_DBGOUT(3) << "\t\t\t" << toto1[ind1.value()];
       }
     }
       
     // 4. Calculate a direction using preconditionned conjugate gradients
     //    to find a zero of the Newton system of equations (H*d = -g)
     //    (a) stop if conjugate iteration limit reached
     //    (b) stop if relative residual is small
     //    (c) stop if direction of negative curvature is obtained
 
     mHessian.cg_solver(d, grad, err); MSQ_ERRRTN(err);
 
     // 5. Check for descent direction (inner produce of gradient and
     //    direction is negative.
     double alpha = inner(grad, d, nv);
     // TODD -- Add back in if you encounter problems -- do a gradient
     //         step if the direction from the conjugate gradient solver
     //         is not a descent direction for the objective function.  We
     //         SHOULD always get a descent direction from the conjugate
     //         method though, unless the preconditioner is not positive
     //         definite.
     // If direction is positive, does a gradient (steepest descent) step.
 
     if (alpha > -epsilon) {
       MSQ_PRINT(1)("Newton direction not guaranteed descent.  Ensure preconditioner is positive definite.\n");
 
       // TODD: removed performing gradient step here since we will use
       // gradient if step does not produce descent.  Instead we set
       // alpha to a small negative value.
 
       alpha = -epsilon;
 
       // alpha = inner(grad, grad, nv); // compute norm squared of gradient
       // if (alpha < 1) alpha = 1;      // take max with constant
       // for (i = 0; i < nv; ++i) {
       //   d[i] = -grad[i] / alpha;     // compute scaled gradient
       // }
       // alpha = inner(grad, d, nv);    // recompute alpha
       //                                // equal to one for large gradient
     }
     
     alpha *= sigma;
     beta = 1.0;
     pd.recreate_vertices_memento(coordsMem, err); MSQ_ERRRTN(err);
     
     // TODD: Unrolling the linesearch loop.  We do a function and
     // gradient evaluation when beta = 1.  Otherwise, we end up
     // in the linesearch regime.  We expect that several
     // evaluations will be made, so we only do a function evaluation
     // and finish with a gradient evaluation.  When beta = 1, we also
     // check the gradient for stability.
 
     // TODD -- the Armijo linesearch is based on the objective function,
     //         so theoretically we only need to evaluate the objective
     //         function.  However, near a very accurate solution, say with
     //         the two norm of the gradient of the objective function less
     //         than 1e-5, the numerical error in the objective function
     //         calculation is enough that the Armijo linesearch will
     //         fail.  To correct this situation, the iterate is accepted
     //         when the norm of the gradient is also small.  If you need
     //         high accuracy and have a large mesh, talk with Todd about
     //         the numerical issues so that we can fix it.
 
     // TODD -- the Armijo linesearch here is only good for differentiable
     //         functions.  When projections are involved, you should change
     //         to a form of the linesearch meant for nondifferentiable
     //         functions.
 
     pd.move_free_vertices_constrained(d, nv, beta, err); MSQ_ERRRTN(err);
     fn_bool = objFunc->compute_gradient(pd, grad, new_value, err); MSQ_ERRRTN(err);
     if ((fn_bool && (original_value - new_value >= -alpha*beta - epsilon)) ||
         (fn_bool && (length(grad, nv) < 100*convTol))) {
       // Armijo linesearch rules passed.
     }
     else {
       if (!fn_bool) {
         // Function undefined.  Use the higher decrease rate.
         beta *= beta0;
       }
       else {
         // Function defined, but not sufficient decrease
         // Use the lower decrease rate.
         beta *= beta1;
       }
       pd.set_to_vertices_memento(coordsMem, err); MSQ_ERRRTN(err);
       
       // Standard Armijo linesearch rules
  
       while (beta >= tol1) {
         // 6. Search along the direction
         //    (a) trial = x + beta*d
         pd.move_free_vertices_constrained(d, nv, beta, err); MSQ_ERRRTN(err);
         //    (b) function evaluation
         fn_bool = objFunc->evaluate(pd, new_value, err);  MSQ_ERRRTN(err);
         //    (c) check for sufficient decrease and stop
         if (!fn_bool) { 
           // function not defined at trial point
           beta *= beta0;
         }
         else if (original_value - new_value >= -alpha*beta - epsilon ) {
           // iterate is acceptable.
           break; 
         }
         else {
           // iterate is not acceptable -- shrink beta
           beta *= beta1;
         }
         pd.set_to_vertices_memento(coordsMem, err); MSQ_ERRRTN(err);
       } 
 
       if (beta < tol1) {
         // assert(pd.set_to_vertices_memento called last)
 
         // TODD -- Lower limit on steplength reached.  Direction does not 
         //         appear to make sufficient progress decreasing the 
         //         objective function.  This can happen when you are 
         //         very near a solution due to numerical errors in 
         //         computing the objective function.  It can also happen 
         //         when the direction is not a descent direction and when
         //         you are projecting the iterates onto a surface.
         //
         //         The latter cases require the use of a linesearch on
         //         a gradient step.  If this linesearch terminate with
         //         insufficient decrease, then you are at a critical 
         //         point and should stop!
         //
         //         The numerical errors with the objective function cannot
         //         be overcome.  Eventually, the gradient step will
         //         fail to compute a new direction and you will stop.
 
         MSQ_PRINT(1)("Sufficient decrease not obtained in linesearch; switching to gradient.\n");
 
         alpha = inner(grad, grad, nv);  // compute norm squared of gradient
         if (alpha < 1) alpha = 1;       // take max with constant
         for (i = 0; i < nv; ++i) {
           d[i] = -grad[i] / alpha;      // compute scaled gradient
         }
         alpha = inner(grad, d, nv);     // recompute alpha
         alpha *= sigma;                 // equal to one for large gradient
         beta = 1.0;
 
         // Standard Armijo linesearch rules
         while (beta >= tol2) {
           // 6. Search along the direction
           //    (a) trial = x + beta*d
           pd.move_free_vertices_constrained(d, nv, beta, err); MSQ_ERRRTN(err);
           //    (b) function evaluation
           fn_bool = objFunc->evaluate(pd, new_value, err);  MSQ_ERRRTN(err);
           //    (c) check for sufficient decrease and stop
           if (!fn_bool) { 
             // function not defined at trial point
             beta *= beta0;
           }
           else if (original_value - new_value >= -alpha*beta - epsilon ) {
             // iterate is acceptable.
             break; 
           }
           else {
             // iterate is not acceptable -- shrink beta
             beta *= beta1;
           }
           pd.set_to_vertices_memento(coordsMem, err); MSQ_ERRRTN(err);
         } 
 
         if (beta < tol2) {
           // assert(pd.set_to_vertices_memento called last)
           
           // TODD -- Lower limit on steplength reached.  Gradient does not 
           //         appear to make sufficient progress decreasing the 
           //         objective function.  This can happen when you are 
           //         very near a solution due to numerical errors in 
           //         computing the objective function.  Most likely you
           //         are at a critical point for the problem.
 
           MSQ_PRINT(1)("Sufficient decrease not obtained with gradient; critical point likely found.\n");
           break;
         }
       }
 
       // Compute the gradient at the new point -- needed by termination check
       fn_bool = objFunc->compute_gradient(pd, grad, new_value, err); MSQ_ERRRTN(err);
     }
 
     // Prints out free vertices coordinates. 
     if (MSQ_DBG(3)) {
       MSQ_DBGOUT(3) << "  o Free vertices new coordinates: \n";
       MsqVertex* toto1 = pd.get_vertex_array(err); MSQ_ERRRTN(err);
       MsqFreeVertexIndexIterator ind(&pd, err); MSQ_ERRRTN(err);
       ind.reset();
       while (ind.next()) {
         MSQ_DBGOUT(3) << "\t\t\t" << toto1[ind.value()];
       }
     }
 
     // checks stopping criterion 
     term_crit->accumulate_inner( pd, new_value, grad, err ); MSQ_ERRRTN(err);
     term_crit->accumulate_patch( pd, err ); MSQ_ERRRTN(err);
   }
   MSQ_PRINT(2)("FINISHED\n");
 }

Here is the call graph for this function:

void set_lower_gradient_bound ( double gradc )

inline

Sets a minimum value for the gradient. If the gradient is below that value, we stop iterating.

Definition at line 103 of file src/QualityImprover/VertexMover/FeasibleNewton/FeasibleNewton.hpp.

References FeasibleNewton::convTol.

103 {

104 convTol=gradc;}

Mesquite::FeasibleNewton::convTol

double convTol

Definition: includeLinks/FeasibleNewton.hpp:116

void set_lower_gradient_bound ( double gradc )

inline

Sets a minimum value for the gradient. If the gradient is below that value, we stop iterating.

Definition at line 103 of file includeLinks/FeasibleNewton.hpp.

References FeasibleNewton::convTol.

103 {

104 convTol=gradc;}

Mesquite::FeasibleNewton::convTol

double convTol

Definition: includeLinks/FeasibleNewton.hpp:116

void terminate_mesh_iteration	(	PatchData &	pd,
		MsqError &	err
	)

protectedvirtual

Implements VertexMover.

Definition at line 344 of file QualityImprover/VertexMover/FeasibleNewton/FeasibleNewton.cpp.

 {
 
     //Michael::  Should the vertices memento be delete here???
   //  cout << "- Executing FeasibleNewton::iteration_complete()\n";
 }

virtual void terminate_mesh_iteration	(	PatchData &	pd,
		MsqError &	err
	)

protectedvirtual

Implements VertexMover.

Member Data Documentation

double convTol

private

Definition at line 116 of file includeLinks/FeasibleNewton.hpp.

Referenced by FeasibleNewton::FeasibleNewton(), FeasibleNewton::optimize_vertex_positions(), and FeasibleNewton::set_lower_gradient_bound().

PatchDataVerticesMemento * coordsMem

private

Definition at line 118 of file includeLinks/FeasibleNewton.hpp.

Referenced by FeasibleNewton::cleanup(), FeasibleNewton::FeasibleNewton(), FeasibleNewton::initialize(), FeasibleNewton::optimize_vertex_positions(), and FeasibleNewton::~FeasibleNewton().

MsqHessian mHessian

private

Definition at line 117 of file includeLinks/FeasibleNewton.hpp.

Referenced by FeasibleNewton::optimize_vertex_positions().

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation