OptimizeSolve.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "SolveObject.h"
 
#include "SolverParams.h"
#include "PetscSupport.h"
 
#include "ExecFlagEnum.h"
#include <petsctao.h>
 
#include "libmesh/petsc_vector.h"
#include "libmesh/petsc_matrix.h"
 
class OptimizationReporterBase;
 
class OptimizeSolve : public SolveObject
{
public:
  static InputParameters validParams();
  OptimizeSolve(Executioner & ex);
 
  virtual bool solve() override;
 
  const OptimizationReporterBase & getOptimizationReporter() const { return *_obj_function; }
 
  void getTaoSolutionStatus(std::vector<int> & tot_iters,
                            std::vector<double> & gnorm,
                            std::vector<int> & obj_iters,
                            std::vector<double> & cnorm,
                            std::vector<int> & grad_iters,
                            std::vector<double> & xdiff,
                            std::vector<int> & hess_iters,
                            std::vector<double> & f,
                            std::vector<int> & tot_solves) const;
 
protected:
  virtual PetscErrorCode variableBounds(Tao tao);
 
  virtual Real objectiveFunction();
 
  virtual void gradientFunction(libMesh::PetscVector<Number> & gradient);
 
  virtual PetscErrorCode applyHessian(libMesh::PetscVector<Number> & s,
                                      libMesh::PetscVector<Number> & Hs);
 
  const libMesh::Parallel::Communicator _my_comm;
 
  const ExecFlagEnum & _solve_on;
 
  OptimizationReporterBase * _obj_function = nullptr;
 
  OptimizationReporterBase * getObjFunction() { return _obj_function; }
 
  Tao _tao;
 
private:
  bool _verbose;
 
  bool _output_opt_iters;
 
  int _obj_iterate = 0;
  int _grad_iterate = 0;
  int _hess_iterate = 0;
  std::vector<int> _total_iterate_vec;
  std::vector<int> _obj_iterate_vec;
  std::vector<int> _grad_iterate_vec;
  std::vector<int> _hess_iterate_vec;
  std::vector<int> _function_solve_vec;
  std::vector<double> _f_vec;
  std::vector<double> _gnorm_vec;
  std::vector<double> _cnorm_vec;
  std::vector<double> _xdiff_vec;
 
  Moose::PetscSupport::PetscOptions _petsc_options;
  SolverParams _solver_params;
 
  PetscErrorCode taoSolve();
 
  void setTaoSolutionStatus(double f, int its, double gnorm, double cnorm, double xdiff);
 
  static PetscErrorCode objectiveFunctionWrapper(Tao tao, Vec x, Real * objective, void * ctx);
  static PetscErrorCode hessianFunctionWrapper(Tao tao, Vec x, Mat hessian, Mat pc, void * ctx);
  static PetscErrorCode applyHessianWrapper(Mat H, Vec s, Vec Hs);
  static PetscErrorCode
  objectiveAndGradientFunctionWrapper(Tao tao, Vec x, Real * objective, Vec gradient, void * ctx);
  static PetscErrorCode variableBoundsWrapper(Tao /*tao*/, Vec xl, Vec xu, void * ctx);
  static PetscErrorCode monitor(Tao tao, void * ctx);
  static PetscErrorCode equalityFunctionWrapper(Tao tao, Vec x, Vec ce, void * ctx);
  static PetscErrorCode
  equalityGradientFunctionWrapper(Tao tao, Vec x, Mat gradient_e, Mat gradient_epre, void * ctx);
  static PetscErrorCode inequalityFunctionWrapper(Tao tao, Vec x, Vec ci, void * ctx);
  static PetscErrorCode
  inequalityGradientFunctionWrapper(Tao tao, Vec x, Mat gradient_i, Mat gradient_ipre, void * ctx);
 
  const enum class TaoSolverEnum {
    NEWTON_TRUST_REGION,
    BOUNDED_NEWTON_TRUST_REGION,
    BOUNDED_CONJUGATE_GRADIENT,
    NEWTON_LINE_SEARCH,
    BOUNDED_NEWTON_LINE_SEARCH,
    BOUNDED_QUASI_NEWTON_TRUST_REGION,
    NEWTON_TRUST_LINE,
    BOUNDED_NEWTON_TRUST_LINE,
    QUASI_NEWTON,
    BOUNDED_QUASI_NEWTON,
    NELDER_MEAD,
    BOUNDED_QUASI_NEWTON_LINE_SEARCH,
    ORTHANT_QUASI_NEWTON,
    GRADIENT_PROJECTION_CONJUGATE_GRADIENT,
    BUNDLE_RISK_MIN,
    AUGMENTED_LAGRANGIAN_MULTIPLIER_METHOD
  } _tao_solver_enum;
 
  dof_id_type _ndof;
 
  std::unique_ptr<libMesh::PetscVector<Number>> _parameters;
 
  Mat _hessian;
 
  Vec _ce;
 
  Vec _ci;
 
  Mat _gradient_e;
 
  Mat _gradient_i;
 
  PetscErrorCode taoALCreate();
  PetscErrorCode taoALDestroy();
};