/* ---------------------------------------------------------- */
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "TaoCreate_SSFLS"
int TaoCreate_SSFLS(TAO_SOLVER tao)
{
TAO_SSLS *ssls;
int info;
TaoFunctionBegin;
info = TaoNew(TAO_SSLS,&ssls); CHKERRQ(info);
info = PetscLogObjectMemory(tao, sizeof(TAO_SSLS)); CHKERRQ(info);
ssls->delta = 1e-10;
ssls->rho = 2.1;
info=TaoSetTaoSolveRoutine(tao,TaoSolve_SSFLS,(void*)ssls); CHKERRQ(info);
info=TaoSetTaoSetUpDownRoutines(tao,TaoSetUp_SSLS,TaoSetDown_SSLS); CHKERRQ(info);
info=TaoSetTaoOptionsRoutine(tao,TaoSetOptions_SSLS); CHKERRQ(info);
info=TaoSetTaoViewRoutine(tao,TaoView_SSLS); CHKERRQ(info);
info = TaoCreateProjectedArmijoLineSearch(tao); CHKERRQ(info);
info = TaoSetMaximumIterates(tao,2000); CHKERRQ(info);
info = TaoSetMaximumFunctionEvaluations(tao,4000); CHKERRQ(info);
info = TaoSetTolerances(tao,0,0,0,0); CHKERRQ(info);
info = TaoSetGradientTolerances(tao,1.0e-16,0.0,0.0); CHKERRQ(info);
info = TaoSetFunctionLowerBound(tao,1.0e-8); CHKERRQ(info);
TaoFunctionReturn(0);
}
/*
TAOCreate_BCG - Creates the data structure for the nonlinear BCG method
and sets the function pointers for all the routines it needs to call
(TAOSolve_BCG() etc.)
It must be wrapped in EXTERN_C_BEGIN to be dynamically linkable in C++
*/
EXTERN_C_BEGIN
#undef __FUNC__
#define __FUNC__ "TaoCreate_BCG"
int TaoCreate_BCG(TAO_SOLVER tao)
{
TAO_BCG *cg;
int info;
TaoFunctionBegin;
cg = TaoNew(TAO_BCG);CHKPTRQ(cg);
PLogObjectMemory(tao,sizeof(TAO_BCG));
info = TaoSetSolver(tao,TaoSetUp_BCG,TaoSetOptions_BCG,TaoSolve_BCG,
TaoView_BCG,TaoDestroy_BCG,(void*)cg); CHKERRQ(info);
info = TaoSetMaximumIterates(tao,2000); CHKERRQ(info);
info = TaoSetTolerances(tao,1e-4,0,0,0); CHKERRQ(info);
info = TaoSetMaximumFunctionEvaluations(tao,4000); CHKERRQ(info);
info = TaoCreateProjectedLineSearch(tao); CHKERRQ(info);
cg->eta = 100.0;
cg->type = TAO_CG_PRplus;
info = PetscObjectComposeFunctionDynamic((PetscObject)tao,"TaoBCGSetRestartTol_C",
"TaoBCGSetRestartTol_TaoBCG",
(void*)TaoBCGSetRestartTol_TaoBCG);CHKERRQ(info);
TaoFunctionReturn(0);
}
/*------------------------------------------------------------*/
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "TaoCreate_GPCG"
int TaoCreate_GPCG(TAO_SOLVER tao)
{
TAO_GPCG *gpcg;
int info;
TaoFunctionBegin;
info = TaoNew(TAO_GPCG,&gpcg); CHKERRQ(info);
info = PetscLogObjectMemory(tao,sizeof(TAO_GPCG)); CHKERRQ(info);
info=TaoSetTaoSolveRoutine(tao,TaoSolve_GPCG,(void*)gpcg); CHKERRQ(info);
info=TaoSetTaoSetUpDownRoutines(tao,TaoSetUp_GPCG,TaoSetDown_GPCG); CHKERRQ(info);
info=TaoSetTaoOptionsRoutine(tao,TaoSetFromOptions_GPCG); CHKERRQ(info);
info=TaoSetTaoViewRoutine(tao,TaoView_GPCG); CHKERRQ(info);
info=TaoSetTaoDualVariablesRoutine(tao,TaoGetDualVariables_GPCG); CHKERRQ(info);
info = TaoSetMaximumIterates(tao,500); CHKERRQ(info);
info = TaoSetMaximumFunctionEvaluations(tao,100000); CHKERRQ(info);
info = TaoSetTolerances(tao,1e-12,1e-12,0,0); CHKERRQ(info);
/* Initialize pointers and variables */
gpcg->n=0;
gpcg->maxgpits = 8;
gpcg->pg_ftol = 0.1;
gpcg->gp_iterates=0; /* Cumulative number */
gpcg->total_gp_its = 0;
/* Initialize pointers and variables */
gpcg->n_bind=0;
gpcg->n_free = 0;
gpcg->n_upper=0;
gpcg->n_lower=0;
// info = TaoCreateProjectedLineSearch(tao); CHKERRQ(info);
info = TaoGPCGCreateLineSearch(tao); CHKERRQ(info);
TaoFunctionReturn(0);
}
void TaoOptimizationSolver<T>::solve ()
{
LOG_SCOPE("solve()", "TaoOptimizationSolver");
this->init ();
this->system().solution->zero();
PetscMatrix<T> * hessian = cast_ptr<PetscMatrix<T> *>(this->system().matrix);
// PetscVector<T> * gradient = cast_ptr<PetscVector<T> *>(this->system().rhs);
PetscVector<T> * x = cast_ptr<PetscVector<T> *>(this->system().solution.get());
PetscVector<T> * ceq = cast_ptr<PetscVector<T> *>(this->system().C_eq.get());
PetscMatrix<T> * ceq_jac = cast_ptr<PetscMatrix<T> *>(this->system().C_eq_jac.get());
PetscVector<T> * cineq = cast_ptr<PetscVector<T> *>(this->system().C_ineq.get());
PetscMatrix<T> * cineq_jac = cast_ptr<PetscMatrix<T> *>(this->system().C_ineq_jac.get());
PetscVector<T> * lb = cast_ptr<PetscVector<T> *>(&this->system().get_vector("lower_bounds"));
PetscVector<T> * ub = cast_ptr<PetscVector<T> *>(&this->system().get_vector("upper_bounds"));
// Set the starting guess to zero.
x->zero();
PetscErrorCode ierr = 0;
// Workaround for bug where TaoSetFromOptions *reset*
// programmatically set tolerance and max. function evaluation
// values when "-tao_type ipm" was specified on the command line: we
// call TaoSetFromOptions twice (both before and after setting
// custom options programatically)
ierr = TaoSetFromOptions(_tao);
LIBMESH_CHKERR(ierr);
// Set convergence tolerances
// f(X) - f(X*) (estimated) <= fatol
// |f(X) - f(X*)| (estimated) / |f(X)| <= frtol
// ||g(X)|| <= gatol
// ||g(X)|| / |f(X)| <= grtol
// ||g(X)|| / ||g(X0)|| <= gttol
// Command line equivalents: -tao_fatol, -tao_frtol, -tao_gatol, -tao_grtol, -tao_gttol
ierr = TaoSetTolerances(_tao,
#if PETSC_RELEASE_LESS_THAN(3,7,0)
// Releases up to 3.X.Y had fatol and frtol, after that they were removed.
// Hopefully we'll be able to know X and Y soon. Guessing at 3.7.0.
/*fatol=*/PETSC_DEFAULT,
/*frtol=*/PETSC_DEFAULT,
#endif
/*gatol=*/PETSC_DEFAULT,
/*grtol=*/this->objective_function_relative_tolerance,
/*gttol=*/PETSC_DEFAULT);
LIBMESH_CHKERR(ierr);
// Set the max-allowed number of objective function evaluations
// Command line equivalent: -tao_max_funcs
ierr = TaoSetMaximumFunctionEvaluations(_tao, this->max_objective_function_evaluations);
LIBMESH_CHKERR(ierr);
// Set the max-allowed number of optimization iterations.
// Command line equivalent: -tao_max_it
// Not implemented for now as it seems fairly similar to
// ierr = TaoSetMaximumIterations(_tao, 4);
// LIBMESH_CHKERR(ierr);
// Set solution vec and an initial guess
ierr = TaoSetInitialVector(_tao, x->vec());
LIBMESH_CHKERR(ierr);
// We have to have an objective function
libmesh_assert( this->objective_object );
// Set routines for objective, gradient, hessian evaluation
ierr = TaoSetObjectiveRoutine(_tao, __libmesh_tao_objective, this);
LIBMESH_CHKERR(ierr);
if ( this->gradient_object )
{
ierr = TaoSetGradientRoutine(_tao, __libmesh_tao_gradient, this);
LIBMESH_CHKERR(ierr);
}
if ( this->hessian_object )
{
ierr = TaoSetHessianRoutine(_tao, hessian->mat(), hessian->mat(), __libmesh_tao_hessian, this);
LIBMESH_CHKERR(ierr);
}
if ( this->lower_and_upper_bounds_object )
{
// Need to actually compute the bounds vectors first
this->lower_and_upper_bounds_object->lower_and_upper_bounds(this->system());
ierr = TaoSetVariableBounds(_tao,
lb->vec(),
ub->vec());
LIBMESH_CHKERR(ierr);
}
if ( this->equality_constraints_object )
{
ierr = TaoSetEqualityConstraintsRoutine(_tao, ceq->vec(), __libmesh_tao_equality_constraints, this);
LIBMESH_CHKERR(ierr);
}
if ( this->equality_constraints_jacobian_object )
{
ierr = TaoSetJacobianEqualityRoutine(_tao,
ceq_jac->mat(),
ceq_jac->mat(),
__libmesh_tao_equality_constraints_jacobian,
this);
LIBMESH_CHKERR(ierr);
}
// Optionally set inequality constraints
if ( this->inequality_constraints_object )
{
ierr = TaoSetInequalityConstraintsRoutine(_tao, cineq->vec(), __libmesh_tao_inequality_constraints, this);
LIBMESH_CHKERR(ierr);
}
// Optionally set inequality constraints Jacobian
if ( this->inequality_constraints_jacobian_object )
{
ierr = TaoSetJacobianInequalityRoutine(_tao,
cineq_jac->mat(),
cineq_jac->mat(),
__libmesh_tao_inequality_constraints_jacobian,
this);
LIBMESH_CHKERR(ierr);
}
// Check for Tao command line options
ierr = TaoSetFromOptions(_tao);
LIBMESH_CHKERR(ierr);
// Perform the optimization
ierr = TaoSolve(_tao);
LIBMESH_CHKERR(ierr);
// Store the convergence/divergence reason
ierr = TaoGetConvergedReason(_tao, &_reason);
LIBMESH_CHKERR(ierr);
}