Optimizes the objective function using the Polack-Ribiere scheme. More...

#include <ConjugateGradient.hpp>

Inheritance diagram for ConjugateGradient:

Collaboration diagram for ConjugateGradient:

Public Member Functions
	ConjugateGradient (ObjectiveFunction *objective, MsqError &err)

virtual	~ConjugateGradient ()

virtual void	set_patch_type (PatchData::PatchType type, MsqError &err, int patch_param1=0, int patch_param2=0)
	Set the patch type. More...

void	set_debugging_level (int new_lev)
	Just for debugging purposes or for obtaining more data during the optimization process. More...

	ConjugateGradient (ObjectiveFunction *objective, MsqError &err)

virtual	~ConjugateGradient ()

virtual void	set_patch_type (PatchData::PatchType type, MsqError &err, int patch_param1=0, int patch_param2=0)
	Set the patch type. More...

void	set_debugging_level (int new_lev)
	Just for debugging purposes or for obtaining more data during the optimization process. More...

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 ()

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 ()

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)
	Initialize data for smoothing process. More...

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 ()
	Delete arrays initially created in initialize(). More...

double	get_step (PatchData &pd, double f0, int &j, MsqError &err)
	Returns the step distance to take in the search direction. More...

virtual void	initialize (PatchData &pd, MsqError &err)
	Initialize data for smoothing process. More...

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 ()
	Delete arrays initially created in initialize(). More...

double	get_step (PatchData &pd, double f0, int &j, MsqError &err)
	Returns the step distance to take in the search direction. More...

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
Vector3D *	fGrad
	Culls the vertex list free_vertex_list. More...

Vector3D *	pGrad

PatchDataVerticesMemento *	pMemento

Vector3D *	fNewGrad

int	arraySize

int	conjGradDebug

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

Optimizes the objective function using the Polack-Ribiere scheme.

Definition at line 53 of file includeLinks/ConjugateGradient.hpp.

Constructor & Destructor Documentation

ConjugateGradient	(	ObjectiveFunction *	objective,
		MsqError &	err
	)

Definition at line 46 of file QualityImprover/VertexMover/ConjugateGradient/ConjugateGradient.cpp.

References TerminationCriterion::add_criterion_type_with_int(), PatchData::ELEMENTS_ON_VERTEX_PATCH, QualityImprover::get_inner_termination_criterion(), MsqError::INVALID_STATE, MSQ_ERRRTN, MSQ_SETERR, TerminationCriterion::NUMBER_OF_ITERATES, VertexMover::objFunc, ConjugateGradient::set_debugging_level(), QualityImprover::set_name(), and ConjugateGradient::set_patch_type().

                                                     :
   VertexMover(),
   fGrad(NULL),
   pGrad(NULL),
   pMemento(NULL),
   fNewGrad(NULL)
 {
   this->set_name("ConjugateGradient");
   this->set_patch_type(PatchData::ELEMENTS_ON_VERTEX_PATCH, err, 1); MSQ_ERRRTN(err);
   objFunc=objective;
     //Michael:: default to global?
   set_debugging_level(0);
     //set the default inner termination criterion
   TerminationCriterion* default_crit=get_inner_termination_criterion();
   if(default_crit==NULL){
     MSQ_SETERR(err)("QualityImprover did not create a default inner "
                     "termination criterion.", MsqError::INVALID_STATE);
     return;
   }
   else{
     default_crit->add_criterion_type_with_int(TerminationCriterion::NUMBER_OF_ITERATES,5,err);
     MSQ_ERRRTN(err);
   }
   
 }  

Here is the call graph for this function:

~ConjugateGradient ( )

virtual

Definition at line 74 of file QualityImprover/VertexMover/ConjugateGradient/ConjugateGradient.cpp.

References ConjugateGradient::fGrad, ConjugateGradient::fNewGrad, ConjugateGradient::pGrad, and ConjugateGradient::pMemento.

 {
   // Checks that cleanup() has been called. 
   assert(fGrad==NULL);
   assert(pGrad==NULL);
   assert(pMemento==NULL);
   assert(fNewGrad==NULL);
 }

ConjugateGradient	(	ObjectiveFunction *	objective,
		MsqError &	err
	)

virtual ~ConjugateGradient ( )

virtual

Member Function Documentation

void cleanup ( )

protectedvirtual

Delete arrays initially created in initialize().

Implements VertexMover.

Definition at line 295 of file QualityImprover/VertexMover/ConjugateGradient/ConjugateGradient.cpp.

References ConjugateGradient::fGrad, ConjugateGradient::fNewGrad, ConjugateGradient::pGrad, and ConjugateGradient::pMemento.

 {
     //  cout << "- Executing ConjugateGradient::iteration_end()\n";
   delete []fGrad; fGrad = NULL;
   delete []pGrad; pGrad = NULL;
   delete []fNewGrad; fNewGrad = NULL;
     //pMemento->~PatchDataVerticesMemento();
   delete pMemento;
   pMemento = NULL;
 }

virtual void cleanup ( )

protectedvirtual

Delete arrays initially created in initialize().

Implements VertexMover.

double get_step	(	PatchData &	pd,
		double	f0,
		int &	j,
		MsqError &	err
	)

protected

Returns the step distance to take in the search direction.

Computes a distance to move vertices given an initial position and search direction (stored in data member pGrad).

Returns alp, the double which scales the search direction vector which when added to the old nodal positions yields the new nodal positions.

Todo:: Michael NOTE: ConjugateGradient::get_step's int &j is only to remain consisitent with CUBIT for an initial test. It can be removed.

Returns alp, the double which scales the search direction vector which when added to the old nodal positions yields the new nodal positions.

Todo:: Michael NOTE: ConjugateGradient::get_step's int &j is only to remain consisitent with CUBIT for an initial test. It can be removed.

Definition at line 314 of file QualityImprover/VertexMover/ConjugateGradient/ConjugateGradient.cpp.

References ObjectiveFunction::evaluate(), MsqError::INVALID_MESH, j, MSQ_ERRZERO, Mesquite::MSQ_MIN, MSQ_PRINT, MSQ_SETERR, PatchData::num_vertices(), VertexMover::objFunc, ConjugateGradient::pGrad, ConjugateGradient::pMemento, PatchData::recreate_vertices_memento(), PatchData::set_free_vertices_constrained(), and PatchData::set_to_vertices_memento().

Referenced by ConjugateGradient::optimize_vertex_positions().

 {
   size_t num_vertices=pd.num_vertices();
     //initial guess for alp
   double alp=1.0;
   int jmax=100;
   double rho=0.5;
     //feasible=false implies the mesh is not in the feasible region
   bool feasible=false;
   int found=0;
     //f and fnew hold the objective function value
   double f=0;
   double fnew=0;
     //Counter to avoid infinitly scaling alp
   j=0;
   //save memento
   pd.recreate_vertices_memento(pMemento, err);
     //if we must check feasiblility
     //while step takes mesh into infeasible region and ...
   while (j<jmax && !feasible && alp>MSQ_MIN) {
     ++j;
     pd.set_free_vertices_constrained(pMemento,pGrad,num_vertices,alp,err);
     feasible=objFunc->evaluate(pd,f,err); MSQ_ERRZERO(err);
       //if not feasible, try a smaller alp (take smaller step)
     if(!feasible){
       alp*=rho;
     }
   }//end while ...
   
     //if above while ended due to j>=jmax, no valid step was found.
   if(j>=jmax){
     MSQ_PRINT(2)("\nFeasible Point Not Found");
     return 0.0;
   }
     //Message::print_info("\nOriginal f %f, first new f = %f, alp = %f",f0,f,alp);
     //if new f is larger than original, our step was too large
   if(f>=f0){
     j=0;
     while (j<jmax && found == 0){
       ++j;
       alp *= rho;
       pd.set_free_vertices_constrained(pMemento,pGrad,num_vertices,alp,err);
         //Get new obj value
         //if patch is now invalid, then the feasible region is  convex or
         //we have an error.  For now, we assume an error.
       if(! objFunc->evaluate(pd,f,err) ){
         MSQ_SETERR(err)("Non-convex feasiblility region found.",MsqError::INVALID_MESH);
       }
       pd.set_to_vertices_memento(pMemento,err);MSQ_ERRZERO(err);
         //if our step has now improved the objective function value
       if(f<f0){
         found=1;
       }
     }//   end while j less than jmax
       //Message::print_info("\nj = %d found = %d f = %20.18f f0 = %20.18f\n",j,found,f,f0);
       //if above ended because of j>=jmax, take no step
     if(found==0){
         //Message::print_info("alp = %10.8f, but returning zero\n",alp);
       alp=0.0; 
       return alp;
     }
 
     j=0;
       //while shrinking the step improves the objFunc value further,
       //scale alp down.  Return alp, when scaling once more would
       //no longer improve the objFunc value.  
     while(j<jmax){
       ++j;
       alp*=rho;
       //step alp in search direction from original positions
       pd.set_free_vertices_constrained(pMemento,pGrad,num_vertices,alp,err);MSQ_ERRZERO(err);
 
         //get new objective function value
       if (! objFunc->evaluate(pd,fnew,err))
         MSQ_SETERR(err)("Non-convex feasiblility region found while "
                         "computing new f.",MsqError::INVALID_MESH);
       if(fnew<f){
         f=fnew;
       }
       else{
         //Reset the vertices to original position
         pd.set_to_vertices_memento(pMemento,err);MSQ_ERRZERO(err);
         alp/=rho;
         return alp;
       }
     }
     //Reset the vertices to original position and return alp
     pd.set_to_vertices_memento(pMemento,err);MSQ_ERRZERO(err);
     return alp;
   }
     //else our new f was already smaller than our original
   else{
     j=0;
       //check to see how large of step we can take
     while (j<jmax && found == 0) {
       ++j;
         //scale alp up (rho must be less than 1)
       alp /= rho;
       //step alp in search direction from original positions
       pd.set_free_vertices_constrained(pMemento,pGrad,num_vertices,alp,err);MSQ_ERRZERO(err);
 
       feasible = objFunc->evaluate(pd,fnew, err);MSQ_ERRZERO(err);
       if ( ! feasible ){
          alp *= rho;
          
          //Reset the vertices to original position and return alp
          pd.set_to_vertices_memento(pMemento,err);MSQ_ERRZERO(err);
          return alp;
       }
       if (fnew<f) { 
           f = fnew; 
        }
        else {
          found=1;
          alp *= rho;
        }
     }
 
     //Reset the vertices to original position and return alp
     pd.set_to_vertices_memento(pMemento,err);MSQ_ERRZERO(err);
     return alp;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double get_step	(	PatchData &	pd,
		double	f0,
		int &	j,
		MsqError &	err
	)

protected

Returns the step distance to take in the search direction.

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

protectedvirtual

Initialize data for smoothing process.

Implements VertexMover.

void initialize	(	PatchData &	pd,
		MsqError &	err
	)

protectedvirtual

Initialize data for smoothing process.

Implements VertexMover.

Definition at line 83 of file QualityImprover/VertexMover/ConjugateGradient/ConjugateGradient.cpp.

References ConjugateGradient::arraySize, PatchData::create_vertices_memento(), ConjugateGradient::fGrad, ConjugateGradient::fNewGrad, MSQ_DBGOUT, ConjugateGradient::pGrad, and ConjugateGradient::pMemento.

 {
   MSQ_DBGOUT(2) << "\no   Performing Conjugate Gradient optimization.\n";
   arraySize=5;
   fGrad = new Vector3D[ arraySize ];
   pGrad = new Vector3D[ arraySize ];
   fNewGrad = new Vector3D[ arraySize ];
   //mCoord = new Vector3D[ arraySize ];
   pMemento=pd.create_vertices_memento(err);
 }

Here is the call graph for this function:

void initialize_mesh_iteration	(	PatchData &	pd,
		MsqError &	err
	)

protectedvirtual

Implements VertexMover.

Definition at line 110 of file QualityImprover/VertexMover/ConjugateGradient/ConjugateGradient.cpp.

 {
   
 }

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

Performs Conjugate gradient minimization on the PatchData, pd.

Implements VertexMover.

Definition at line 117 of file QualityImprover/VertexMover/ConjugateGradient/ConjugateGradient.cpp.

References TerminationCriterion::accumulate_inner(), TerminationCriterion::accumulate_patch(), ConjugateGradient::arraySize, ObjectiveFunction::compute_gradient(), ConjugateGradient::conjGradDebug, ConjugateGradient::fGrad, ConjugateGradient::fNewGrad, QualityImprover::get_inner_termination_criterion(), ConjugateGradient::get_step(), PatchData::get_vertex_array(), i, MsqError::INVALID_MESH, j, k, Mesquite::Linf(), MSQ_CHKERR, MSQ_DBGOUT, MSQ_ERRRTN, MSQ_FUNCTION_TIMER, Mesquite::MSQ_MAX_CAP, MSQ_PRINT, MSQ_SETERR, MsqFreeVertexIndexIterator::next(), PatchData::num_free_vertices(), PatchData::num_vertices(), VertexMover::objFunc, ConjugateGradient::pGrad, MsqFreeVertexIndexIterator::reset(), Vector3D::set(), Timer::since_birth(), PatchData::snap_vertex_to_domain(), TerminationCriterion::terminate(), and MsqFreeVertexIndexIterator::value().

                                                               {
   // pd.reorder();
 
   MSQ_FUNCTION_TIMER( "ConjugateGradient::optimize_vertex_positions" );
 
   Timer c_timer;
   int num_vert=pd.num_vertices();
   if(pd.num_free_vertices(err)<1){
      MSQ_DBGOUT(1) << "\nEmpty free vertex list in ConjugateGradient\n";
      return;
   }
   
   if(num_vert>arraySize){
     delete []fGrad;
     delete []pGrad;
     delete []fNewGrad;
       //Increase number to try to avoid reallocating
     arraySize=num_vert + 5;
     fGrad = new Vector3D[ arraySize ];
     pGrad = new Vector3D[ arraySize ];
     fNewGrad = new Vector3D[ arraySize ];
   }
     //zero out arrays
   int zero_loop=0;
   while(zero_loop<arraySize){
     fGrad[zero_loop].set(0,0,0);
     pGrad[zero_loop].set(0,0,0);
     fNewGrad[zero_loop].set(0,0,0);
     ++zero_loop;
   }
   
   // gets the array of vertices for the patch  
   MsqVertex* vertices=pd.get_vertex_array(err);  MSQ_ERRRTN(err);
   int ind;
     //Michael cull list:  possibly set soft_fixed flags here
   
    MsqFreeVertexIndexIterator free_iter(&pd, err);  MSQ_ERRRTN(err);
   
       
    double f=0;
    //Michael, this isn't equivalent to CUBIT because we only want to check
    //the objective function value of the 'bad' elements
    //if invalid initial patch set an error.
    bool temp_bool = objFunc->compute_gradient(pd, fGrad, f, err, num_vert);
    if(MSQ_CHKERR(err))
       return;
   if( ! temp_bool){
     MSQ_SETERR(err)("Conjugate Gradient not able to get valid gradient "
                     "and function values on intial patch.", 
                     MsqError::INVALID_MESH);
     return;
   }
   double grad_norm=MSQ_MAX_CAP;
   
   if(conjGradDebug>0){
     MSQ_PRINT(2)("\nCG's DEGUB LEVEL = %i \n",conjGradDebug);
     grad_norm=Linf(fGrad,num_vert);
     MSQ_PRINT(2)("\nCG's FIRST VALUE = %f,grad_norm = %f",f,grad_norm);
     MSQ_PRINT(2)("\n   TIME %f",c_timer.since_birth());
     grad_norm=MSQ_MAX_CAP;
   }
 
   ind=0;
     //Initializing pGrad (search direction).  
   while(ind<num_vert){    
     pGrad[ind]=(-fGrad[ind]);
     ++ind;
   }
   int j=0; // total nb of step size changes ... not used much
   int i=0; // iteration counter
   int m=0; // 
   double alp=MSQ_MAX_CAP; // alp: scale factor of search direction
     //we know inner_criterion is false because it was checked in
     //loop_over_mesh before being sent here.
   TerminationCriterion* term_crit=get_inner_termination_criterion();
   
     //while ((i<maxIteration && alp>stepBound && grad_norm>normGradientBound)
     //     && !inner_criterion){
   while(!term_crit->terminate()){
     ++i;
       //std::cout<<"\Michael delete i = "<<i;
     int k=0;
     alp=get_step(pd,f,k,err);
     j+=k;
     if(conjGradDebug>2){
       MSQ_PRINT(2)("\n  Alp initial, alp = %20.18f",alp);
     }
 
      // if alp == 0, revert to steepest descent search direction
     if(alp==0){
       free_iter.reset();
       while (free_iter.next()) {
         m=free_iter.value();
         pGrad[m]=(-fGrad[m]);
       }
       alp=get_step(pd,f,k,err);
       j+=k;
       if(conjGradDebug>1){
         MSQ_PRINT(2)("\n CG's search direction reset.");
         if(conjGradDebug>2)
           MSQ_PRINT(2)("\n  Alp was zero, alp = %20.18f",alp);
       }
       
     }
     if(alp!=0){
       free_iter.reset();
       while (free_iter.next()) {
         m=free_iter.value();
         vertices[m] += (alp * pGrad[m]);
           //Added move_to_ownever
         pd.snap_vertex_to_domain(m,err);
       }
       if (! objFunc->compute_gradient(pd, fNewGrad, f, err, num_vert)){
         MSQ_SETERR(err)("Error inside Conjugate Gradient, vertices moved "
                         "making function value invalid.", 
                         MsqError::INVALID_MESH);
         return;
       }
       
       if(conjGradDebug>0){
         grad_norm=Linf(fNewGrad,num_vert);
         MSQ_PRINT(2)("\nCG's VALUE = %f,  iter. = %i,  grad_norm = %f,  alp = %f",f,i,grad_norm,alp);
         MSQ_PRINT(2)("\n   TIME %f",c_timer.since_birth());
       }
       double s11=0;
       double s12=0;
       double s22=0;
       free_iter.reset();
       while (free_iter.next()) {
         m=free_iter.value();
         s11+=fGrad[m]%fGrad[m];
         s12+=fGrad[m]%fNewGrad[m];
         s22+=fNewGrad[m]%fNewGrad[m];
       }
       
         // Steepest Descent (takes 2-3 times as long as P-R)
         //double bet=0;
       
         // Fletcher-Reeves (takes twice as long as P-R)
         //double bet = s22/s11;
 
         // Polack-Ribiere        
       double bet = (s22-s12)/s11;
       free_iter.reset();
       while (free_iter.next()) {
         m=free_iter.value();
         pGrad[m]=(-fNewGrad[m]+(bet*pGrad[m]));
         fGrad[m]=fNewGrad[m];
       }
       if(conjGradDebug>2){
         MSQ_PRINT(2)(" \nSEARCH DIRECTION INFINITY NORM = %e",
                    Linf(fNewGrad,num_vert));
       }
       
     }//end if on alp == 0
       //Removing the following line of code (4/2/03) as it should not
       //be needed with the new version of Termination Criterion.
       //Update mesh before checking criterion
       //pd.update_mesh(err);
     term_crit->accumulate_inner( pd, f, fNewGrad, err );  MSQ_ERRRTN(err);
     term_crit->accumulate_patch( pd, err ); MSQ_ERRRTN(err);
   }//end while
   if(conjGradDebug>0){
     MSQ_PRINT(2)("\nConjugate Gradient complete i=%i ",i);
     MSQ_PRINT(2)("\n-  FINAL value = %f, alp=%4.2e grad_norm=%4.2e",f,alp,grad_norm);
     MSQ_PRINT(2)("\n   FINAL TIME %f",c_timer.since_birth());
   }
 }

Here is the call graph for this function:

void set_debugging_level ( int new_lev )

inline

Just for debugging purposes or for obtaining more data during the optimization process.

Definition at line 65 of file includeLinks/ConjugateGradient.hpp.

References ConjugateGradient::conjGradDebug.

Referenced by ConjugateGradient::ConjugateGradient().

       {
         conjGradDebug=new_lev;
       }

Here is the caller graph for this function:

void set_debugging_level ( int new_lev )

inline

Just for debugging purposes or for obtaining more data during the optimization process.

Definition at line 65 of file src/QualityImprover/VertexMover/ConjugateGradient/ConjugateGradient.hpp.

References ConjugateGradient::conjGradDebug.

       {
         conjGradDebug=new_lev;
       }

virtual void set_patch_type	(	PatchData::PatchType	type,
		MsqError &	err,
		int	patch_param1 = `0`,
		int	patch_param2 = `0`
	)

virtual

Set the patch type.

Reimplemented from PatchDataUser.

void set_patch_type	(	PatchData::PatchType	type,
		MsqError &	err,
		int	patch_param1 = `0`,
		int	patch_param2 = `0`
	)

virtual

Set the patch type.

Reimplemented from PatchDataUser.

Definition at line 99 of file QualityImprover/VertexMover/ConjugateGradient/ConjugateGradient.cpp.

References PatchData::ELEMENTS_ON_VERTEX_PATCH, PatchData::GLOBAL_PATCH, MsqError::INVALID_ARG, MSQ_SETERR, and PatchDataUser::set_patch_type().

Referenced by ConjugateGradient::ConjugateGradient().

 {
   if (type == PatchData::GLOBAL_PATCH || type == PatchData::ELEMENTS_ON_VERTEX_PATCH) {
     PatchDataUser::set_patch_type(type, err, patch_param1, patch_param2);
   } else {
     MSQ_SETERR(err)("Type not supported by ConjugateGradient algorythm.",
                     MsqError::INVALID_ARG);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void terminate_mesh_iteration	(	PatchData &	pd,
		MsqError &	err
	)

protectedvirtual

Implements VertexMover.

Definition at line 288 of file QualityImprover/VertexMover/ConjugateGradient/ConjugateGradient.cpp.

 {
     //  cout << "- Executing ConjugateGradient::iteration_complete()\n";
 }

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

protectedvirtual

Implements VertexMover.

Member Data Documentation

int arraySize

private

Definition at line 96 of file includeLinks/ConjugateGradient.hpp.

Referenced by ConjugateGradient::initialize(), and ConjugateGradient::optimize_vertex_positions().

int conjGradDebug

private

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

Referenced by ConjugateGradient::optimize_vertex_positions(), and ConjugateGradient::set_debugging_level().

Vector3D * fGrad

private

Culls the vertex list free_vertex_list.

Definition at line 92 of file includeLinks/ConjugateGradient.hpp.

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

Vector3D * fNewGrad

private

Definition at line 95 of file includeLinks/ConjugateGradient.hpp.

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

Vector3D * pGrad

private

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

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

PatchDataVerticesMemento * pMemento

private

Definition at line 94 of file includeLinks/ConjugateGradient.hpp.

Referenced by ConjugateGradient::cleanup(), ConjugateGradient::get_step(), ConjugateGradient::initialize(), and ConjugateGradient::~ConjugateGradient().

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