twolevelmethod.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_TWOLEVELMETHOD_HH
#define DUNE_ISTL_TWOLEVELMETHOD_HH
 
#include<dune/istl/operators.hh>
#include"amg.hh"
#include"galerkin.hh"
#include<dune/istl/solver.hh>
 
#include<dune/common/unused.hh>
 
namespace Dune
{
namespace Amg
{
 
template<class FO, class CO>
class LevelTransferPolicy
{
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 LevelTransferPolicy* clone() const =0;
 
  virtual ~LevelTransferPolicy(){}
 
  protected:
  CoarseRangeType rhs_;
  CoarseDomainType lhs_;
  std::shared_ptr<CoarseOperatorType> operator_;
};
 
template<class O, class C>
class AggregationLevelTransferPolicy
  : public LevelTransferPolicy<O,O>
{
  typedef Dune::Amg::AggregatesMap<typename O::matrix_type::size_type> AggregatesMap;
public:
  typedef LevelTransferPolicy<O,O> FatherType;
  typedef C Criterion;
  typedef SequentialInformation ParallelInformation;
 
  AggregationLevelTransferPolicy(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;
 
     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 = renumberer.coarsen(pinfo, pg, vm,
                                                *aggregatesMap_, pinfo,
                                                noAggregates);
    std::vector<bool>& visited=excluded;
 
    typedef std::vector<bool>::iterator Iterator;
 
    for(Iterator iter= visited.begin(), end=visited.end();
        iter != end; ++iter)
          *iter=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());
  }
 
  AggregationLevelTransferPolicy* clone() const
  {
    return new AggregationLevelTransferPolicy(*this);
  }
 
private:
  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 OneStepAMGCoarseSolverPolicy
{
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;
  OneStepAMGCoarseSolverPolicy(const SmootherArgs& args, const Criterion& c)
    : smootherArgs_(args), criterion_(c)
  {}
  OneStepAMGCoarseSolverPolicy(const OneStepAMGCoarseSolverPolicy& 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, double reduction, InverseOperatorResult& res)
    {
      DUNE_UNUSED_PARAMETER(reduction);
      DUNE_UNUSED_PARAMETER(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);
    }
 
    ~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 TwoLevelMethod :
    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;
  // define the category
  enum {
    category=SolverCategory::sequential
  };
 
  TwoLevelMethod(const FineOperatorType& op,
                 std::shared_ptr<SmootherType> smoother,
                 const LevelTransferPolicy<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_);
  }
 
  TwoLevelMethod(const TwoLevelMethod& other)
  : operator_(other.operator_), coarseSolver_(new CoarseLevelSolver(*other.coarseSolver_)),
    smoother_(other.smoother_), policy_(other.policy_->clone()),
    preSteps_(other.preSteps_), postSteps_(other.postSteps_)
  {}
 
  ~TwoLevelMethod()
  {
    // Each instance has its own policy.
    delete policy_;
    delete coarseSolver_;
  }
 
  void pre(FineDomainType& x, FineRangeType& b)
  {
    smoother_->pre(x,b);
  }
 
  void post(FineDomainType& x)
  {
    DUNE_UNUSED_PARAMETER(x);
  }
 
  void apply(FineDomainType& v, const FineRangeType& d)
  {
    FineDomainType u(v);
    FineRangeType 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_);
 
  }
 
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_;
  LevelTransferPolicy<FO,typename CSP::Operator>* policy_;
  std::size_t preSteps_;
  std::size_t postSteps_;
};
}// end namespace Amg
}// end namespace Dune
 
#endif