Solvers.hpp

#pragma once
 
#include <memory>
 
#include <dune/common/classname.hh>
#include <dune/common/version.hh>
 
#include <dune/common/ftraits.hh>
#include <dune/common/version.hh>
 
#include <dune/istl/solvers.hh>
 
#if HAVE_SUITESPARSE_UMFPACK
#include <dune/istl/umfpack.hh>
#endif
#if HAVE_SUITESPARSE_LDL
#include <dune/istl/ldl.hh>
#endif
#if HAVE_SUITESPARSE_SPQR
#include <dune/istl/spqr.hh>
#endif
#if HAVE_SUPERLU
#include <dune/istl/superlu.hh>
#endif
 
#include <amdis/CreatorMap.hpp>
#include <amdis/Output.hpp>
 
#include <amdis/linearalgebra/istl/ISTLSolverCreator.hpp>
 
namespace AMDiS
{
 
  template <class Traits>
  class DefaultCreators<tag::solver<Traits>>
  {
    using M = typename Traits::M;
    using X = typename Traits::X;
    using Y = typename Traits::Y;
 
    using FTraits = Dune::FieldTraits<typename M::field_type>;
 
    template <class S>
    using Creator = ISTLSolverCreator<S,Traits>;
 
    using Map = CreatorMap<tag::solver<Traits>>;
 
  public:
    static void init()
    {
      auto cg = new Creator<Dune::CGSolver<X>>;
      Map::addCreator("cg", cg);
 
      // Generalized preconditioned conjugate gradient solver.
      auto pcg = new Creator<Dune::GeneralizedPCGSolver<X>>;
      Map::addCreator("pcg", pcg);
 
      auto fcg = new Creator<Dune::RestartedFCGSolver<X>>;
      Map::addCreator("fcg", fcg);
 
      auto cfcg = new Creator<Dune::CompleteFCGSolver<X>>;
      Map::addCreator("cfcg", cfcg);
 
      auto bicgstab = new Creator<Dune::BiCGSTABSolver<X>>;
      Map::addCreator("bicgstab", bicgstab);
      Map::addCreator("bcgs", bicgstab);
      Map::addCreator("default", bicgstab);
 
      auto minres = new Creator<Dune::MINRESSolver<X>>;
      Map::addCreator("minres", minres);
 
      auto gmres = new Creator<Dune::RestartedGMResSolver<X,Y>>;
      Map::addCreator("gmres", gmres);
 
      auto fgmres = new Creator<Dune::RestartedFlexibleGMResSolver<X,Y>>;
      Map::addCreator("fgmres", fgmres);
 
      init_direct(std::is_same<typename FTraits::real_type, double>{});
    }
 
    static void init_direct(std::false_type)
    {
      warning("Direct solvers not created for the matrix with real_type = {}.",
        Dune::className<typename FTraits::real_type>());
    }
 
    static void init_direct(std::true_type)
    {
#if HAVE_SUITESPARSE_UMFPACK
      auto umfpack = new Creator<Dune::UMFPack<M>>;
      Map::addCreator("umfpack", umfpack);
#endif
 
#if HAVE_SUITESPARSE_LDL
      auto ldl = new Creator<Dune::LDL<M>>;
      Map::addCreator("ldl", ldl);
#endif
 
#if HAVE_SUITESPARSE_SPQR
      auto spqr = new Creator<Dune::SPQR<M>>;
      Map::addCreator("spqr", spqr);
#endif
 
#if HAVE_SUPERLU
      auto superlu = new Creator<Dune::SuperLU<M>>;
      Map::addCreator("superlu", superlu);
#endif
 
      // default direct solvers
#if HAVE_SUITESPARSE_UMFPACK
      Map::addCreator("direct", umfpack);
#elif HAVE_SUPERLU
      Map::addCreator("direct", superlu);
#endif
    }
  };
 
} // end namespace AMDiS