directPreconditioner.hh

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/*  This file is part of the library KASKADE 7                               */
/*  https://www.zib.de/research/projects/kaskade7-finite-element-toolbox     */
/*                                                                           */
/*  Copyright (C) 2002-2016 Zuse Institute Berlin                            */
/*                                                                           */
/*  KASKADE 7 is distributed under the terms of the ZIB Academic License.    */
/*    see $KASKADE/academic.txt                                              */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#ifndef DIRECT_PRECONDITIONER_HH
#define DIRECT_PRECONDITIONER_HH
 
#include <memory>
 
#include <dune/istl/preconditioners.hh>
#include <dune/istl/solvercategory.hh>
 
#include "linalg/crsutil.hh"
#include "linalg/matrixTraits.hh"
#include "linalg/symmetricOperators.hh"
#include "utilities/duneInterface.hh"
 
namespace Kaskade
{
  // forward declarations
  template <class,class> class Factorization;
  template <class,class> class NumaBCRSMatrix;
 
  template <class Op>
  class DirectPreconditioner: public Dune::Preconditioner<typename Op::Domain, typename Op::Range>
  {
    typedef typename Op::Domain Domain;
    typedef typename Op::Domain Range;
    typedef typename GetScalar<Domain>::type Scalar;
 
  public:
    static int const category = Dune::SolverCategory::sequential;
 
    DirectPreconditioner(Op const& op, DirectType directType=DirectType::UMFPACK, MatrixProperties property=MatrixProperties::SYMMETRIC)
      : factorization(getFactorization(directType,op.template get<MatrixAsTriplet<Scalar> >(),typename Factorization<Scalar>::Options(property)))
    {}
 
    void pre(Domain&, Range&) {}
    void post (Domain&) {}
 
    void apply (Domain& x, Range const& y)
    {
      std::vector<Scalar> b(y.dim());
      vectorToSequence(y,begin(b));
      factorization->solve(b);
      vectorFromSequence(x,begin(b));
    }
 
  private:
    std::unique_ptr<Factorization<Scalar>> factorization;
  };
  
 
 
} // namespace Kaskade
#endif