ROL_TypeE_CompositeStepAlgorithm.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//               Rapid Optimization Library (ROL) Package
//
// Copyright 2014 NTESS and the ROL contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
#ifndef ROL_TYPEE_COMPOSITESTEPALGORITHM_H
#define ROL_TYPEE_COMPOSITESTEPALGORITHM_H
 
#include "ROL_TypeE_Algorithm.hpp"
 
namespace ROL {
namespace TypeE {
 
template<typename Real>
class CompositeStepAlgorithm : public TypeE::Algorithm<Real> {
private:
  // Parameter list.
  ParameterList list_;
 
  // Vectors used for cloning.
  ROL::Ptr<Vector<Real> > xvec_;
  ROL::Ptr<Vector<Real> > gvec_;
  ROL::Ptr<Vector<Real> > cvec_;
  ROL::Ptr<Vector<Real> > lvec_;
 
  // Diagnostic return flags for subalgorithms.
  int flagCG_;
  int flagAC_;
  int iterCG_;
 
  // Stopping conditions.
  int maxiterCG_;
  int maxiterOSS_;
  Real tolCG_;
  Real tolOSS_;
  bool tolOSSfixed_;
 
  // Tolerances and stopping conditions for subalgorithms.
  Real lmhtol_;
  Real qntol_;
  Real pgtol_;
  Real projtol_;
  Real tangtol_;
  Real tntmax_;
 
  // Trust-region parameters.
  Real zeta_;
  Real Delta_;
  Real penalty_;
  Real eta_;
  bool useConHess_;
 
  Real ared_;
  Real pred_;
  Real snorm_;
  Real nnorm_;
  Real tnorm_;
 
  // Output flags.
  bool infoQN_;
  bool infoLM_;
  bool infoTS_;
  bool infoAC_;
  bool infoLS_;
  bool infoALL_;
 
  // Performance summary.
  int totalIterCG_;
  int totalProj_;
  int totalNegCurv_;
  int totalRef_;
  int totalCallLS_;
  int totalIterLS_;
 
  // Verbosity flags.
  int verbosity_;
  bool printHeader_;
 
  using TypeE::Algorithm<Real>::state_;
  using TypeE::Algorithm<Real>::status_;
 
  void initialize(Vector<Real>        &x,
                  const Vector<Real>  &g,
                  Vector<Real>        &l,
                  const Vector<Real>  &c,
                  Objective<Real>     &obj,
                  Constraint<Real>    &con,
                  std::ostream        &outStream = std::cout);
 
  void computeTrial(Vector<Real> &s,
                    const Vector<Real> &x,
                    const Vector<Real> &l,
                    Objective<Real>    &obj,
                    Constraint<Real>   &con,
                    std::ostream       &os);
 
  void updateRadius(Vector<Real>       &x,
                    Vector<Real>       &l,
                    const Vector<Real> &s,
                    Objective<Real>    &obj,
                    Constraint<Real>   &con,
                    std::ostream       &os);
 
  void computeLagrangeMultiplier(Vector<Real>       &l,
                                 const Vector<Real> &x,
                                 const Vector<Real> &gf,
                                 Constraint<Real>   &con,
                                 std::ostream       &os);
 
  void computeQuasinormalStep(Vector<Real>       &n,
                              const Vector<Real> &c,
                              const Vector<Real> &x,
                              Real               delta,
                              Constraint<Real>   &con,
                              std::ostream       &os);
 
  void solveTangentialSubproblem(Vector<Real>       &t,
                                 Vector<Real>       &tCP,
                                 Vector<Real>       &Wg,
                                 const Vector<Real> &x,
                                 const Vector<Real> &g,
                                 const Vector<Real> &n,
                                 const Vector<Real> &l,
                                 Real               delta,
                                 Objective<Real>    &obj,
                                 Constraint<Real>   &con,
                                 std::ostream       &os);
 
  void accept(Vector<Real> &s, Vector<Real> &n, Vector<Real> &t, Real f_new, Vector<Real> &c_new,
              Vector<Real> &gf_new, Vector<Real> &l_new, Vector<Real> &g_new,
              const Vector<Real> &x, const Vector<Real> &l, Real f, const Vector<Real> &gf, const Vector<Real> &c,
              const Vector<Real> &g, Vector<Real> &tCP, Vector<Real> &Wg,
              Objective<Real> &obj, Constraint<Real> &con, std::ostream &os);
 
  template<typename T> int sgn(T val) const;
 
  void printInfoLS(const std::vector<Real> &res, std::ostream& os) const;
 
  Real setTolOSS(const Real intol) const;
 
 
public:
 
  CompositeStepAlgorithm(ParameterList &list);
 
  using TypeE::Algorithm<Real>::run;
  virtual void run(Vector<Real>       &x,
                   const Vector<Real> &g,
                   Objective<Real>    &obj,
                   Constraint<Real>   &econ,
                   Vector<Real>       &emul,
                   const Vector<Real> &eres,
                   std::ostream       &outStream = std::cout) override;
 
  virtual void writeHeader(std::ostream& os) const override;
 
  virtual void writeName(std::ostream& os) const override;
 
  virtual void writeOutput(std::ostream& os, const bool print_header = false) const override;
 
}; // class ROL::TypeE::CompositeStepAlgorithm
 
} // namespace TypeE
} // namespace ROL
 
#include "ROL_TypeE_CompositeStepAlgorithm_Def.hpp"
 
#endif