DirectRunner.hpp

#pragma once

#include <algorithm>
#include <string>

#include <dune/common/ftraits.hh>

#include <amdis/Output.hpp>
#include <amdis/linearalgebra/RunnerInterface.hpp>
#include <amdis/linearalgebra/SolverInfo.hpp>

namespace AMDiS
{
  /**
  * \ingroup Solver
  * \class AMDiS::DirectRunner
  * \brief \implements RunnerInterface for the (external) direct solvers
  */
  template <template <class> class Solver, class Mat, class Sol, class Rhs>
  class DirectRunner
      : public RunnerInterface<Mat, Sol, Rhs>
  {
  protected:
    using Super = RunnerInterface<Mat, Sol, Rhs>;
    using BaseSolver  = Dune::InverseOperator<Sol, Rhs>;
    using ISTLSolver = Solver<Mat>;

  public:
    /// Constructor.
    DirectRunner(std::string const& prefix)
      : solverCreator_(prefix)
    {}

    /// Implementes \ref RunnerInterface::init()
    void init(Mat const& A) override
    {
      solver_ = solverCreator_.create(A);
    }

    /// Implementes \ref RunnerInterface::exit()
    void exit() override
    {
      solver_.reset();
    }

    /// Implementes \ref RunnerInterface::solve()
    int solve(Mat const& A, Sol& x, Rhs const& b,
              SolverInfo& solverInfo) override
    {
      // storing some statistics
      Dune::InverseOperatorResult statistics;

      // solve the linear system
      Rhs _b = b;
      solver_->apply(x, _b, statistics);

      solverInfo.setRelResidual(statistics.reduction);

      return 0;
    }

  private:
    ISTLSolverCreator<Solver<Mat>> solverCreator_;
    std::shared_ptr<BaseSolver> solver_;
  };
}