scale_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/solver/base.hpp>
 
namespace FEAT
{
  namespace Solver
  {
    template<typename Vector_, typename Filter_>
    class ScalePrecond :
      public SolverBase<Vector_>
    {
    protected:
      typedef typename Vector_::DataType DataType;
      const Filter_& _filter;
      DataType _omega;
      typedef SolverBase<Vector_> BaseClass;
 
    public:
      explicit ScalePrecond(const Filter_& filter, DataType omega) :
        _filter(filter),
        _omega(omega)
      {
      }
 
      explicit ScalePrecond(const String& section_name, const PropertyMap* section,
        const Filter_& filter) :
        BaseClass(section_name, section),
        _filter(filter),
        _omega(0)
      {
        // Check if we have set _krylov_vim
        auto omega_p = section->query("omega");
        if(omega_p.second && !omega_p.first.parse(this->_omega))
          throw ParseError(section_name + ".omega", omega_p.first, "a positive float");
      }
 
      virtual ~ScalePrecond()
      {
      }
 
      virtual String name() const override
      {
        return "Scale";
      }
 
      void set_omega(DataType omega)
      {
        XASSERT(omega > DataType(0));
        _omega = omega;
      }
 
      virtual Status apply(Vector_& vec_cor, const Vector_& vec_def) override
      {
        vec_cor.scale(vec_def, this->_omega);
        _filter.filter_cor(vec_cor);
        return Status::success;
      }
    }; // class ScalePrecond<...>
 
 
    template<typename Filter_, typename DataType_>
    inline std::shared_ptr<ScalePrecond<typename Filter_::VectorType, Filter_>> new_scale_precond(
      const Filter_& filter, DataType_ omega)
    {
      return std::make_shared<ScalePrecond<typename Filter_::VectorType, Filter_>>(filter, omega);
    }
 
    template<typename Filter_>
    inline std::shared_ptr<ScalePrecond<typename Filter_::VectorType, Filter_>> new_scale_precond(
      const String& section_name, const PropertyMap* section,
      const Filter_& filter)
    {
      return std::make_shared<ScalePrecond<typename Filter_::VectorType, Filter_>>(
        section_name, section, filter);
    }
  } // namespace Solver
} // namespace FEAT