parameters.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_AMG_PARAMETERS_HH
#define DUNE_AMG_PARAMETERS_HH
 
#include <cstddef>
 
namespace Dune
{
  namespace Amg
  {
    class DependencyParameters
    {
    public:
      DependencyParameters()
        : alpha_(1.0/3.0), beta_(1.0E-5)
      {}
 
      void setBeta(double b)
      {
        beta_ = b;
      }
 
      double beta() const
      {
        return beta_;
      }
 
      void setAlpha(double a)
      {
        alpha_ = a;
      }
 
      double alpha() const
      {
        return alpha_;
      }
 
    private:
      double alpha_, beta_;
    };
 
    class AggregationParameters :
      public DependencyParameters
    {
    public:
      AggregationParameters()
        : maxDistance_(2), minAggregateSize_(4), maxAggregateSize_(6),
          connectivity_(15), skipiso_(false)
      {}
 
      void setDefaultValuesIsotropic(std::size_t dim, std::size_t diameter=2)
      {
        maxDistance_=diameter-1;
        std::size_t csize=1;
 
        for(; dim>0; dim--) {
          csize*=diameter;
          maxDistance_+=diameter-1;
        }
        minAggregateSize_=csize;
        maxAggregateSize_=static_cast<std::size_t>(csize*1.5);
      }
 
      void setDefaultValuesAnisotropic(std::size_t dim,std::size_t diameter=2)
      {
        setDefaultValuesIsotropic(dim, diameter);
        maxDistance_+=dim-1;
      }
      std::size_t maxDistance() const { return maxDistance_;}
 
      void setMaxDistance(std::size_t distance) { maxDistance_ = distance;}
 
      bool skipIsolated() const
      {
        return skipiso_;
      }
 
      void setSkipIsolated(bool skip)
      {
        skipiso_=skip;
      }
 
      std::size_t minAggregateSize() const { return minAggregateSize_;}
 
      void setMinAggregateSize(std::size_t size){ minAggregateSize_=size;}
 
      std::size_t maxAggregateSize() const { return maxAggregateSize_;}
 
      void setMaxAggregateSize(std::size_t size){ maxAggregateSize_ = size;}
 
      std::size_t maxConnectivity() const { return connectivity_;}
 
      void setMaxConnectivity(std::size_t connectivity){ connectivity_ = connectivity;}
 
    private:
      std::size_t maxDistance_, minAggregateSize_, maxAggregateSize_, connectivity_;
      bool skipiso_;
 
    };
 
 
    enum AccumulationMode {
      noAccu = 0,
      atOnceAccu=1,
      successiveAccu=2
    };
 
 
 
 
    class CoarseningParameters : public AggregationParameters
    {
    public:
      void setMaxLevel(int l)
      {
        maxLevel_ = l;
      }
      int maxLevel() const
      {
        return maxLevel_;
      }
 
      void setCoarsenTarget(int nodes)
      {
        coarsenTarget_ = nodes;
      }
 
      int coarsenTarget() const
      {
        return coarsenTarget_;
      }
 
      void setMinCoarsenRate(double rate)
      {
        minCoarsenRate_ = rate;
      }
 
      double minCoarsenRate() const
      {
        return minCoarsenRate_;
      }
 
      AccumulationMode accumulate() const
      {
        return accumulate_;
      }
      void setAccumulate(AccumulationMode accu)
      {
        accumulate_=accu;
      }
 
      void setAccumulate(bool accu){
        accumulate_=accu ? successiveAccu : noAccu;
      }
 
      bool useFixedOrder() const
      {
        return useFixedOrder_;
      }
 
      void setUseFixedOrder(bool useFixedOrder)
      {
        useFixedOrder_ = useFixedOrder;
      }
 
      void setProlongationDampingFactor(double d)
      {
        dampingFactor_ = d;
      }
 
      double getProlongationDampingFactor() const
      {
        return dampingFactor_;
      }
      CoarseningParameters(int maxLevel=100, int coarsenTarget=1000, double minCoarsenRate=1.2,
                           double prolongDamp=1.6, AccumulationMode accumulate=successiveAccu,
                           bool useFixedOrder = false)
        : maxLevel_(maxLevel), coarsenTarget_(coarsenTarget), minCoarsenRate_(minCoarsenRate),
          dampingFactor_(prolongDamp), accumulate_( accumulate), useFixedOrder_(useFixedOrder)
      {}
 
    private:
      int maxLevel_;
      int coarsenTarget_;
      double minCoarsenRate_;
      double dampingFactor_;
      AccumulationMode accumulate_;
      bool useFixedOrder_;
    };
 
    class Parameters : public CoarseningParameters
    {
    public:
      void setDebugLevel(int level)
      {
        debugLevel_ = level;
      }
 
      int debugLevel() const
      {
        return debugLevel_;
      }
 
      void setNoPreSmoothSteps(std::size_t steps)
      {
        preSmoothSteps_=steps;
      }
      std::size_t getNoPreSmoothSteps() const
      {
        return preSmoothSteps_;
      }
 
      void setNoPostSmoothSteps(std::size_t steps)
      {
        postSmoothSteps_=steps;
      }
      std::size_t getNoPostSmoothSteps() const
      {
        return postSmoothSteps_;
      }
 
      void setGamma(std::size_t gamma)
      {
        gamma_=gamma;
      }
      std::size_t getGamma() const
      {
        return gamma_;
      }
 
      void setAdditive(bool additive)
      {
        additive_=additive;
      }
 
      bool getAdditive() const
      {
        return additive_;
      }
 
      Parameters(int maxLevel=100, int coarsenTarget=1000, double minCoarsenRate=1.2,
                 double prolongDamp=1.6, AccumulationMode accumulate=successiveAccu, bool useFixedOrder = false)
        : CoarseningParameters(maxLevel, coarsenTarget, minCoarsenRate, prolongDamp, accumulate, useFixedOrder)
          , debugLevel_(2), preSmoothSteps_(2), postSmoothSteps_(2), gamma_(1),
          additive_(false)
      {}
    private:
      int debugLevel_;
      std::size_t preSmoothSteps_;
      std::size_t postSmoothSteps_;
      std::size_t gamma_;
      bool additive_;
    };
 
  } //namespace AMG
 
} //namespace Dune
#endif