preconditioner.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <meltpooldg/core/scratch_data.hpp>
 
#include <any>
#include <memory>
#include <utility>
 
namespace MeltPoolDG
{
  template <typename PreconditionerType, unsigned int dim, typename VectorType, typename number>
  concept PreconditionerTypeConcept =
    requires(PreconditionerType preconditioner, VectorType &vec, const VectorType &const_vec) {
      preconditioner.update(std::declval<std::any>());
 
      preconditioner.vmult(vec, const_vec);
 
      preconditioner.reinit();
    };
 
 
  template <unsigned int dim, typename VectorType, typename number>
  class Preconditioner
  {
  public:
    Preconditioner() = default;
 
    template <typename PreconditionerType>
    explicit Preconditioner(PreconditionerType &&preconditioner)
      : preconditioner_pimpl(new PreconditionerModel<PreconditionerType>(std::move(preconditioner)))
    {}
 
    void
    vmult(VectorType &dst, const VectorType &src) const
    {
      preconditioner_pimpl->vmult(dst, src);
    }
 
    void
    update(const std::any &external_setup = std::any())
    {
      if (flag_update_preconditioner == always_update or flag_update_preconditioner == update_once)
        preconditioner_pimpl->update(external_setup);
      if (flag_update_preconditioner == update_once)
        flag_update_preconditioner = do_not_update;
    }
 
    void
    reinit()
    {
      preconditioner_pimpl->reinit();
    }
 
    bool
    is_initialized() const
    {
      return (preconditioner_pimpl != nullptr);
    }
 
    void
    clear()
    {
      preconditioner_pimpl->reset(nullptr);
    }
 
    void
    set_do_update_preconditioner(const bool do_update, const bool do_overwrite = false)
    {
      if ((do_update || flag_update_preconditioner == update_once) && not do_overwrite)
        flag_update_preconditioner = update_once;
      else
        flag_update_preconditioner = do_not_update;
    }
 
  private:
    struct PreconditionerConcept
    {
      virtual ~PreconditionerConcept() = default;
 
      virtual void
      vmult(VectorType &dst, const VectorType &src) const = 0;
 
      virtual void
      update(const std::any &external_setup) = 0;
 
      virtual void
      reinit() = 0;
    };
 
    template <PreconditionerTypeConcept<dim, VectorType, number> PreconditionerType>
    struct PreconditionerModel final : public PreconditionerConcept
    {
    public:
      explicit PreconditionerModel(PreconditionerType &&preconditioner_in)
        : preconditioner(std::forward<PreconditionerType>(preconditioner_in))
      {}
 
      void
      vmult(VectorType &dst, const VectorType &src) const override
      {
        preconditioner.vmult(dst, src);
      }
 
      void
      update(const std::any &external_setup) override
      {
        preconditioner.update(external_setup);
      }
 
      void
      reinit() override
      {
        preconditioner.reinit();
      }
 
    private:
      PreconditionerType preconditioner;
    };
 
    std::unique_ptr<PreconditionerConcept> preconditioner_pimpl;
 
    enum
    {
      always_update,
      update_once,
      do_not_update
    } flag_update_preconditioner{always_update};
  };
} // namespace MeltPoolDG