twolevelmethodcpr.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_ISTL_TWOLEVELMETHODCPR_HH
#define DUNE_ISTL_TWOLEVELMETHODCPR_HH
 
// NOTE: This file is a modified version of dune/istl/paamg/twolevelmethod.hh from
// dune-istl release 2.6.0. Modifications have been kept as minimal as possible.
 
#include <dune/istl/operators.hh>
//#include "amg.hh"
//#include"galerkin.hh"
#include <dune/istl/paamg/amg.hh>
#include <dune/istl/paamg/galerkin.hh>
#include <dune/istl/solver.hh>
 
#include <dune/common/unused.hh>
#include <dune/common/version.hh>
 
#include <algorithm>
#include <cstddef>
#include <iostream>
#include <memory>
#include <tuple>
#include <vector>

namespace Dune
{
namespace Amg
{

template<class FO, class CO>
class LevelTransferPolicyCpr
{
public:
  typedef FO FineOperatorType;
  typedef typename FineOperatorType::range_type FineRangeType;
  typedef typename FineOperatorType::domain_type FineDomainType;
  typedef CO CoarseOperatorType;
  typedef typename CoarseOperatorType::range_type CoarseRangeType;
  typedef typename CoarseOperatorType::domain_type CoarseDomainType;
  std::shared_ptr<CoarseOperatorType>& getCoarseLevelOperator()
  {
    return operator_;
  }

  CoarseRangeType& getCoarseLevelRhs()
  {
    return rhs_;
  }

  CoarseDomainType& getCoarseLevelLhs()
  {
    return lhs_;
  }

  virtual void moveToCoarseLevel(const FineRangeType& fineRhs)=0;
  virtual void moveToFineLevel(FineDomainType& fineLhs)=0;
  virtual void createCoarseLevelSystem(const FineOperatorType& fineOperator)=0;

  virtual void calculateCoarseEntries(const FineOperatorType& fineOperator) = 0;

  virtual LevelTransferPolicyCpr* clone() const =0;

  virtual ~LevelTransferPolicyCpr(){}
 
  protected:
  CoarseRangeType rhs_;
  CoarseDomainType lhs_;
  std::shared_ptr<CoarseOperatorType> operator_;
};

template<class O, class C>
class AggregationLevelTransferPolicyCpr
  : public LevelTransferPolicyCpr<O,O>
{
  typedef Dune::Amg::AggregatesMap<typename O::matrix_type::size_type> AggregatesMap;
public:
  typedef LevelTransferPolicyCpr<O,O> FatherType;
  typedef C Criterion;
  typedef SequentialInformation ParallelInformation;
 
  explicit AggregationLevelTransferPolicyCpr(const Criterion& crit)
  : criterion_(crit)
  {}
 
  void createCoarseLevelSystem(const O& fineOperator)
  {
    prolongDamp_ = criterion_.getProlongationDampingFactor();
    GalerkinProduct<ParallelInformation> productBuilder;
    typedef typename Dune::Amg::MatrixGraph<const typename O::matrix_type> MatrixGraph;
    typedef typename Dune::Amg::PropertiesGraph<MatrixGraph,Dune::Amg::VertexProperties,
      Dune::Amg::EdgeProperties,Dune::IdentityMap,Dune::IdentityMap> PropertiesGraph;
    MatrixGraph mg(fineOperator.getmat());
    PropertiesGraph pg(mg,Dune::IdentityMap(),Dune::IdentityMap());
    typedef NegateSet<typename ParallelInformation::OwnerSet> OverlapFlags;
 
    aggregatesMap_.reset(new AggregatesMap(pg.maxVertex()+1));
 
    int noAggregates, isoAggregates, oneAggregates, skippedAggregates;
 
    std::tie(noAggregates, isoAggregates, oneAggregates, skippedAggregates) =
       aggregatesMap_->buildAggregates(fineOperator.getmat(), pg, criterion_, true);
     std::cout<<"no aggregates="<<noAggregates<<" iso="<<isoAggregates<<" one="<<oneAggregates<<" skipped="<<skippedAggregates<<std::endl;
    // misuse coarsener to renumber aggregates
    Dune::Amg::IndicesCoarsener<Dune::Amg::SequentialInformation,int> renumberer;
    typedef std::vector<bool>::iterator Iterator;
    typedef Dune::IteratorPropertyMap<Iterator, Dune::IdentityMap> VisitedMap;
    std::vector<bool> excluded(fineOperator.getmat().N(), false);
    VisitedMap vm(excluded.begin(), Dune::IdentityMap());
    ParallelInformation pinfo;
 
    std::size_t aggregates = coarsen(renumberer, pinfo, pg, vm,*aggregatesMap_, noAggregates, true);
 
    std::fill(excluded.begin(), excluded.end(), false);
    matrix_.reset(productBuilder.build(mg, vm,
                                       SequentialInformation(),
                                       *aggregatesMap_,
                                       aggregates,
                                       OverlapFlags()));
    productBuilder.calculate(fineOperator.getmat(), *aggregatesMap_, *matrix_, pinfo, OverlapFlags());
    this->lhs_.resize(this->matrix_->M());
    this->rhs_.resize(this->matrix_->N());
    this->operator_.reset(new O(*matrix_));
  }
 
  void moveToCoarseLevel(const typename FatherType::FineRangeType& fineRhs)
  {
    Transfer<std::size_t,typename FatherType::FineRangeType,ParallelInformation>
      ::restrictVector(*aggregatesMap_, this->rhs_, fineRhs, ParallelInformation());
    this->lhs_=0;
  }
 
  void moveToFineLevel(typename FatherType::FineDomainType& fineLhs)
  {
    Transfer<std::size_t,typename FatherType::FineRangeType,ParallelInformation>
      ::prolongateVector(*aggregatesMap_, this->lhs_, fineLhs,
                         prolongDamp_, ParallelInformation());
  }
 
  AggregationLevelTransferPolicyCpr* clone() const
  {
    return new AggregationLevelTransferPolicyCpr(*this);
  }
 
private:
  // trailing return type with decltype used for detecting the signature of coarsen member function by overloading this coarsen function
  template <typename RN, typename PI, typename PG, typename VM, typename AM>
  auto coarsen(RN& renumberer,
               PI& pinfo,
               PG& pg,
               VM& vm,
               AM& aggregatesMap,
               int noAggregates,
               bool useFixedOrder) ->
               decltype(renumberer.coarsen(pinfo, pg, vm, aggregatesMap, pinfo, noAggregates, useFixedOrder))
  {
    return renumberer.coarsen(pinfo, pg, vm, aggregatesMap, pinfo, noAggregates, useFixedOrder);
  }
 
  template <typename RN, typename PI, typename PG, typename VM, typename AM>
  auto coarsen(RN& renumberer,
               PI& pinfo,
               PG& pg,
               VM& vm,
               AM& aggregatesMap,
               int noAggregates, ...)
  {
    return renumberer.coarsen(pinfo, pg, vm, aggregatesMap, pinfo, noAggregates);
  }
 
  typename O::matrix_type::field_type prolongDamp_;
  std::shared_ptr<AggregatesMap> aggregatesMap_;
  Criterion criterion_;
  std::shared_ptr<typename O::matrix_type> matrix_;
};

template<class O, class S, class C>
class OneStepAMGCoarseSolverPolicyCpr
{
public:
  typedef O Operator;
  typedef typename O::range_type X;
  typedef C Criterion;
  typedef S Smoother;
  typedef typename Dune::Amg::SmootherTraits<S>::Arguments SmootherArgs;
  typedef AMG<Operator,X,Smoother> AMGType;
  OneStepAMGCoarseSolverPolicyCpr(const SmootherArgs& args, const Criterion& c)
    : smootherArgs_(args), criterion_(c)
  {}

  OneStepAMGCoarseSolverPolicyCpr(const OneStepAMGCoarseSolverPolicyCpr& other)
  : coarseOperator_(other.coarseOperator_), smootherArgs_(other.smootherArgs_),
    criterion_(other.criterion_)
  {}
private:
  struct AMGInverseOperator : public InverseOperator<X,X>
  {
    AMGInverseOperator(const typename AMGType::Operator& op,
                       const Criterion& crit,
                       const typename AMGType::SmootherArgs& args)
      : amg_(op, crit,args), first_(true)
    {}
 
    void apply(X& x, X& b, [[maybe_unused]] double reduction, [[maybe_unused]] InverseOperatorResult& res)
    {
      if(first_)
      {
        amg_.pre(x,b);
        first_=false;
        x_=x;
      }
      amg_.apply(x,b);
    }
 
    void apply(X& x, X& b, InverseOperatorResult& res)
    {
      return apply(x,b,1e-8,res);
    }
 
    virtual SolverCategory::Category category() const
    {
      return amg_.category();
    }
 
    ~AMGInverseOperator()
    {
      if(!first_)
        amg_.post(x_);
    }
    AMGInverseOperator(const AMGInverseOperator& other)
    : x_(other.x_), amg_(other.amg_), first_(other.first_)
    {
    }
  private:
    X x_;
    AMGType amg_;
    bool first_;
  };
 
public:
  typedef AMGInverseOperator CoarseLevelSolver;

  template<class P>
  CoarseLevelSolver* createCoarseLevelSolver(P& transferPolicy)
  {
    coarseOperator_=transferPolicy.getCoarseLevelOperator();
    AMGInverseOperator* inv = new AMGInverseOperator(*coarseOperator_,
                                                     criterion_,
                                                     smootherArgs_);
 
    return inv; //std::shared_ptr<InverseOperator<X,X> >(inv);
 
  }
 
private:
  std::shared_ptr<Operator> coarseOperator_;
  SmootherArgs smootherArgs_;
  Criterion criterion_;
};

template<class FO, class CSP, class S>
class TwoLevelMethodCpr :
    public Preconditioner<typename FO::domain_type, typename FO::range_type>
{
public:
  typedef CSP CoarseLevelSolverPolicy;
  typedef typename CoarseLevelSolverPolicy::CoarseLevelSolver CoarseLevelSolver;
  typedef FO FineOperatorType;
  typedef typename FineOperatorType::range_type FineRangeType;
  typedef typename FineOperatorType::domain_type FineDomainType;
  typedef typename CSP::Operator CoarseOperatorType;
  typedef typename CoarseOperatorType::range_type CoarseRangeType;
  typedef typename CoarseOperatorType::domain_type CoarseDomainType;
  typedef S SmootherType;

  TwoLevelMethodCpr(const FineOperatorType& op,
                    std::shared_ptr<SmootherType> smoother,
                    const LevelTransferPolicyCpr<FineOperatorType,
                                                 CoarseOperatorType>& policy,
                    CoarseLevelSolverPolicy& coarsePolicy,
                    std::size_t preSteps = 1, std::size_t postSteps = 1)
    : operator_(&op), smoother_(smoother),
      preSteps_(preSteps), postSteps_(postSteps)
  {
    policy_ = policy.clone();
    policy_->createCoarseLevelSystem(*operator_);
    coarseSolver_=coarsePolicy.createCoarseLevelSolver(*policy_);
  }
 
  TwoLevelMethodCpr(const TwoLevelMethodCpr& other)
  : operator_(other.operator_), coarseSolver_(new CoarseLevelSolver(*other.coarseSolver_)),
    smoother_(other.smoother_), policy_(other.policy_->clone()),
    preSteps_(other.preSteps_), postSteps_(other.postSteps_)
  {}
 
  ~TwoLevelMethodCpr()
  {
    // Each instance has its own policy.
    delete policy_;
    delete coarseSolver_;
  }
 
  void updatePreconditioner(FineOperatorType& /* op */,
                            std::shared_ptr<SmootherType> smoother,
                            CoarseLevelSolverPolicy& coarsePolicy)
  {
    updatePreconditioner(smoother, coarsePolicy);
  }
 
  void updatePreconditioner(std::shared_ptr<SmootherType> smoother,
                            CoarseLevelSolverPolicy& coarsePolicy)
  {
    smoother_ = smoother;
    // We assume the matrix has the same sparsity structure and memory locations throughout, only the values are changed.
    smoother_->update();
    if (coarseSolver_) {
      policy_->calculateCoarseEntries(*operator_);
      coarsePolicy.setCoarseOperator(*policy_);
      coarseSolver_->updatePreconditioner();
    } else {
      // we should probably not be heere
      policy_->createCoarseLevelSystem(*operator_);
      coarseSolver_ = coarsePolicy.createCoarseLevelSolver(*policy_);
    }
  }
 
  void pre(FineDomainType& x, FineRangeType& b)
  {
    if (x.dim() != u_.dim()) {
      u_.resize(x.dim());
    }
    if (b.dim() != rhs_.dim()) {
      rhs_.resize(b.dim());
    }
    smoother_->pre(x,b);
  }
 
  void post([[maybe_unused]] FineDomainType& x)
  {
  }
 
  bool hasPerfectUpdate() const
  {
    // The two-level method has perfect update if both the finesmoother and coarse solver do.
    return smoother_->hasPerfectUpdate() && coarseSolver_->hasPerfectUpdate();
  }
 
  void apply(FineDomainType& v, const FineRangeType& d)
  {
    u_ = v;
    rhs_ = d;
    LevelContext context;
    SequentialInformation info;
    context.pinfo=&info;
    context.lhs=&u_;
    context.update=&v;
    context.smoother=smoother_;
    context.rhs=&rhs_;
    context.matrix=operator_;
    // Presmoothing
    presmooth(context, preSteps_);
    //Coarse grid correction
    policy_->moveToCoarseLevel(*context.rhs);
    InverseOperatorResult res;
    coarseSolver_->apply(policy_->getCoarseLevelLhs(), policy_->getCoarseLevelRhs(), res);
    *context.lhs=0;
    policy_->moveToFineLevel(*context.lhs);
    *context.update += *context.lhs;
    // Postsmoothing
    postsmooth(context, postSteps_);
 
  }
//   //! Category of the preconditioner (see SolverCategory::Category)
    virtual SolverCategory::Category category() const
    {
      return SolverCategory::sequential;
    }
 
private:
  struct LevelContext
  {
    typedef S SmootherType;
    std::shared_ptr<SmootherType> smoother;
    FineDomainType* lhs;
    /*
     * @brief The right hand side holding the current residual.
     *
     * This is passed to the smoother as the right hand side.
     */
    FineRangeType* rhs;
    FineDomainType* update;
    SequentialInformation* pinfo;
    const FineOperatorType* matrix;
  };
  const FineOperatorType* operator_;
  CoarseLevelSolver* coarseSolver_;
  std::shared_ptr<S> smoother_;
  LevelTransferPolicyCpr<FO,typename CSP::Operator>* policy_;
  std::size_t preSteps_;
  std::size_t postSteps_;
  mutable FineDomainType u_;
  mutable FineRangeType rhs_;
};
}// end namespace Amg
}// end namespace Dune

#endif