fixed_step_linesearch.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
#include <kernel/base_header.hpp>
#include <kernel/solver/linesearch.hpp>
 
namespace FEAT
{
  namespace Solver
  {
 
    template<typename Functional_, typename Filter_>
    class FixedStepLinesearch : public Linesearch<Functional_, Filter_>
    {
      public:
        typedef Filter_ FilterType;
        typedef typename Functional_::VectorTypeR VectorType;
        typedef typename Functional_::DataType DataType;
        typedef Linesearch<Functional_, Filter_> BaseClass;
 
      private:
        DataType _step_length;
 
      public:
        explicit FixedStepLinesearch(Functional_& functional, Filter_& filter, const DataType step_length,
        bool keep_iterates = false) :
          BaseClass("FS-LS", functional, filter, keep_iterates),
          _step_length(step_length)
          {
            this->_alpha_min = _step_length;
          }
 
        explicit FixedStepLinesearch(const String& section_name, const PropertyMap* section,
        Functional_& functional, Filter_& filter) :
          BaseClass("FS-LS", section_name, section, functional, filter),
          _step_length(-1)
          {
            this->set_max_iter(0);
            this->_alpha_min = _step_length;
 
            // Check if we need to set the step length
            auto step_length_p = section->query("step_length");
            if(step_length_p.second)
            {
              set_step_length(std::stod(step_length_p.first));
            }
            else
            {
              XABORTM(name()+" config section is missing the mandatory step_length key!");
            }
 
          }
 
        virtual ~FixedStepLinesearch()
        {
        }
 
        virtual String name() const override
        {
          return "Fixed-Step-Linesearch";
        }
 
        virtual DataType get_rel_update() const override
        {
          return _step_length*this->_norm_dir;
        }
 
        virtual void set_step_length(DataType step_length)
        {
          XASSERT(step_length > DataType(0));
 
          _step_length = step_length;
        }
 
        virtual Status apply(VectorType& vec_cor, const VectorType& vec_dir) override
        {
          this->_norm_dir = vec_dir.norm2();
          // clear solution vector
          vec_cor.format();
          vec_cor.axpy(vec_dir, _step_length);
 
          this->_functional.prepare(vec_cor, this->_filter);
 
          return Status::success;
        }
 
        virtual Status correct(VectorType& vec_sol, const VectorType& vec_dir) override
        {
          this->_norm_dir = vec_dir.norm2();
          vec_sol.axpy(vec_dir, _step_length);
 
          this->_functional.prepare(vec_sol, this->_filter);
          this->_functional.eval_fval_grad(this->_fval_min, this->_vec_grad);
          this->_filter.filter_def(this->_vec_grad);
 
          return Status::success;
        }
    }; // class FixedStepLinesearch
 
    template<typename Functional_, typename Filter_>
    inline std::shared_ptr<FixedStepLinesearch<Functional_, Filter_>> new_fixed_step_linesearch(
      Functional_& functional, Filter_& filter, typename Functional_::DataType step_length, bool keep_iterates = false)
      {
        return
          std::make_shared<FixedStepLinesearch<Functional_, Filter_>>(functional, filter, step_length, keep_iterates);
      }
 
    template<typename Functional_, typename Filter_>
    inline std::shared_ptr<FixedStepLinesearch<Functional_, Filter_>> new_fixed_step_linesearch(
      const String& section_name, const PropertyMap* section, Functional_& functional, Filter_& filter)
      {
        return
          std::make_shared<FixedStepLinesearch<Functional_, Filter_>>(section_name, section, functional, filter);
      }
  } // namespace Solver
} // namespace FEAT