ROL_TypeE_CompositeStepAlgorithm.hpp

Go to the documentation of this file.

// @HEADER
// ************************************************************************
//
//               Rapid Optimization Library (ROL) Package
//                 Copyright (2014) Sandia Corporation
//
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact lead developers:
//              Drew Kouri   (dpkouri@sandia.gov) and
//              Denis Ridzal (dridzal@sandia.gov)
//
// ************************************************************************
// @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