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