operators.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_ISTL_OPERATORS_HH
#define DUNE_ISTL_OPERATORS_HH

#include <dune-istl-config.hh> // DUNE_ISTL_SUPPORT_OLD_CATEGORY_INTERFACE

#include <cmath>
#include <complex>
#include <iostream>
#include <iomanip>
#include <string>

#include <dune/common/exceptions.hh>
#include <dune/common/shared_ptr.hh>

#include "solvercategory.hh"


namespace Dune {

  //=====================================================================
  // Abstract operator interface
  //=====================================================================


  template<class X, class Y>
  class LinearOperator {
  public:
    typedef X domain_type;
    typedef Y range_type;
    typedef typename X::field_type field_type;

    virtual void apply (const X& x, Y& y) const = 0;

    virtual void applyscaleadd (field_type alpha, const X& x, Y& y) const = 0;

    virtual ~LinearOperator () {}

    virtual SolverCategory::Category category() const
#if DUNE_ISTL_SUPPORT_OLD_CATEGORY_INTERFACE
    {
      DUNE_THROW(Dune::Exception,"It is necessary to implement the category method in a derived classes, in the future this method will pure virtual.");
    };
#else
    = 0;
#endif
  };


  template<class M, class X, class Y>
  class AssembledLinearOperator : public LinearOperator<X,Y> {
  public:
    typedef M matrix_type;
    typedef X domain_type;
    typedef Y range_type;
    typedef typename X::field_type field_type;

    virtual const M& getmat () const = 0;
  };



  //=====================================================================
  // Implementation for ISTL-matrix based operator
  //=====================================================================

  template<class M, class X, class Y>
  class MatrixAdapter : public AssembledLinearOperator<M,X,Y>
  {
  public:
    typedef M matrix_type;
    typedef X domain_type;
    typedef Y range_type;
    typedef typename X::field_type field_type;

    explicit MatrixAdapter (const M& A) : _A_(stackobject_to_shared_ptr(A)) {}

    explicit MatrixAdapter (std::shared_ptr<const M> A) : _A_(A) {}

    void apply (const X& x, Y& y) const override
    {
      _A_->mv(x,y);
    }

    void applyscaleadd (field_type alpha, const X& x, Y& y) const override
    {
      _A_->usmv(alpha,x,y);
    }

    const M& getmat () const override
    {
      return *_A_;
    }

    SolverCategory::Category category() const override
    {
      return SolverCategory::sequential;
    }

  private:
    const std::shared_ptr<const M> _A_;
  };

} // end namespace

#endif

// Emacs configuration
// Local Variables:
// tab-width: 4
// indent-tabs-mode: nil
// c-basic-offset: 2
// End: