nlopt_precond.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/base.hpp>
#include <kernel/util/dist.hpp>
 
namespace FEAT
{
  namespace Solver
  {
    template<typename VectorType_, typename FilterType_>
    class NLOptPrecond: public SolverBase<VectorType_>
    {
      public:
        typedef VectorType_ VectorType;
        typedef FilterType_ FilterType;
 
        explicit NLOptPrecond()
        {
        }
 
        virtual ~NLOptPrecond()
        {
        }
 
        virtual void prepare(const VectorType& DOXY(vec_state), FilterType& DOXY(filter))=0;
 
        virtual String name() const override = 0;
 
        virtual Status apply(VectorType& DOXY(vec_cor), const VectorType& DOXY(vec_def)) override = 0;
 
        virtual String info() const
        {
          return this->name();
        }
 
    }; // class NLOptPrecond
 
    template<typename NonlinearOperator_>
    class NonlinearOperatorPrecondWrapper
    : public Solver::NLOptPrecond
    <
      typename NonlinearOperator_::SystemLevelType::GlobalSystemVectorR,
      typename NonlinearOperator_::SystemLevelType::GlobalSystemFilter
    >
    {
      public:
        typedef typename NonlinearOperator_::SystemLevelType::GlobalSystemVectorR VectorType;
        typedef typename NonlinearOperator_::SystemLevelType::GlobalSystemFilter FilterType;
        typedef Solver::NLOptPrecond<VectorType, FilterType> BaseClass;
 
      private:
        NonlinearOperator_ _op;
 
      public:
        template<typename... Args_>
        explicit NonlinearOperatorPrecondWrapper(Args_&&... args):
          _op(std::forward<Args_>(args)...)
          {
          }
 
        virtual ~NonlinearOperatorPrecondWrapper()
        {
        }
 
        virtual String name() const override
        {
          return "NonlinearOperatorPrecondWrapper<"+_op.name()+">";
        }
 
        virtual void prepare(const VectorType& vec_state, FilterType& DOXY(filter)) override
        {
          _op.prepare(vec_state);
        }
 
        virtual void init_numeric() override
        {
          _op.init_numeric();
        }
 
        virtual Solver::Status apply(VectorType& vec_cor, const VectorType& vec_def) override
        {
          Statistics::add_solver_expression(std::make_shared<ExpressionStartSolve>(this->name()));
          Statistics::add_solver_expression(std::make_shared<ExpressionCallPrecond>(this->name(), _op.name()));
 
          Solver::Status st(_op.apply(vec_cor, vec_def));
 
          Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), st, 1));
 
          return st;
        }
 
        virtual String info() const override
        {
          return this->name() + "[" + _op.info() + "]";
        }
 
    }; // class NonlinearOperatorPrecondWrapper
 
    template<typename NonlinearOperator_, typename... Args_>
    inline std::shared_ptr<NonlinearOperatorPrecondWrapper<NonlinearOperator_>>
    new_nonlinear_operator_precond_wrapper(Args_&&... args)
    {
      return std::make_shared<NonlinearOperatorPrecondWrapper<NonlinearOperator_>>(std::forward<Args_>(args)...);
    }
 
  } // namespace Solver
}// namespace FEAT