time_integrator_util.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "meltpooldg/core/scratch_data.hpp"
#include <meltpooldg/linear_algebra/linear_solver_data.hpp>
#include <meltpooldg/linear_algebra/preconditioner.hpp>
#include <meltpooldg/linear_algebra/preconditioner_factory.hpp>
#include <meltpooldg/time_integration/bdf_time_integration.hpp>
#include <meltpooldg/time_integration/explicit_low_storage_runge_kutta_integrator.hpp>
#include <meltpooldg/time_integration/explicit_runge_kutta_chebyshev_integrator.hpp>
#include <meltpooldg/time_integration/one_step_theta.hpp>
#include <meltpooldg/time_integration/time_integrator_base.hpp>
#include <meltpooldg/time_integration/time_integrator_data.hpp>
 
#include <meltpooldg/utilities/cpp23_functions.h>
 
#include <functional>
 
namespace MeltPoolDG::TimeIntegration
{
  inline bool
  time_integrator_scheme_is_explicit(const TimeIntegratorSchemes scheme)
  {
    if (Utils::contains(explicit_lsrk_supported_schemes, scheme))
      return true;
    else if (Utils::contains(explicit_rkc_supported_schemes, scheme))
      return true;
    return false;
  }
 
  inline bool
  time_integrator_scheme_is_implicit(const TimeIntegratorSchemes scheme)
  {
    if (Utils::contains(bdf_supported_schemes, scheme))
      return true;
    return false;
  }
 
  template <typename number, typename PDEOperator>
  TimeIntegratorBase<number> *
  explicit_time_integrator_factory(const PDEOperator                &pde_operator,
                                   const TimeIntegratorData<number> &params)
  {
    if (Utils::contains(explicit_lsrk_supported_schemes, params.integrator_type))
      {
        auto integrator = new LowStorageExplicitRungeKuttaIntegrator<number>(
          params, std::bind_front(&PDEOperator::apply_operator, &pde_operator));
        return integrator;
      }
    else if (Utils::contains(explicit_rkc_supported_schemes, params.integrator_type))
      {
        auto integrator = new ExplicitRungeKuttaChebyshevIntegrator<number>(
          params, std::bind_front(&PDEOperator::apply_operator, &pde_operator));
        return integrator;
      }
    return nullptr;
  }
 
  template <int dim, typename number, typename PDEOperator>
  TimeIntegratorBase<number> *
  implicit_time_integrator_factory(const PDEOperator                   &pde_operator,
                                   const ScratchData<dim, dim, number> &scratch_data,
                                   const unsigned int                   dof_idx,
                                   const TimeIntegratorData<number>    &params)
  {
    using VectorType = typename BDFIntegrator<dim, number>::VectorType;
 
    if (Utils::contains(bdf_supported_schemes, params.integrator_type))
      {
        auto preconditioner = make_preconditioner<dim, number, PDEOperator, VectorType>(
          params.linear_solver_data.preconditioner_type,
          &pde_operator,
          scratch_data,
          dof_idx,
          true);
 
        const typename TimeIntegration::BDFIntegrator<dim, number>::SolverFunctions
          bdf_solver_functions{.compute_jacobian =
                                 std::bind_front(&PDEOperator::apply_jacobian, &pde_operator),
                               .compute_residual =
                                 std::bind_front(&PDEOperator::compute_residual, &pde_operator),
                               .distribute_constraints = std::function<void(VectorType &)>()};
 
        auto integrator =
          new BDFIntegrator<dim, number>(params, bdf_solver_functions, std::move(preconditioner));
        return integrator;
      }
    return nullptr;
  }
 
 
  template <typename number,
            typename PDEOperator,
            typename VectorType = dealii::LinearAlgebra::distributed::Vector<number>>
  TimeIntegratorBase<number> *
  time_integrator_factory(const PDEOperator                &pde_operator,
                          const TimeIntegratorData<number> &params,
                          const LinearSolverData<number>   &linear_solver_data,
                          dealii::TimerOutput &)
  {
    if (Utils::contains(explicit_lsrk_supported_schemes, params.integrator_type))
      {
        auto integrator = new LowStorageExplicitRungeKuttaIntegrator<number>(
          params,
          [&pde_operator](number time,
                          number,
                          dealii::LinearAlgebra::distributed::Vector<number>       &dst,
                          const dealii::LinearAlgebra::distributed::Vector<number> &src,
                          std::function<void(unsigned, unsigned)>                   post) {
            pde_operator.apply_operator(time, dst, src, post);
          });
        return integrator;
      }
    else if (Utils::contains(explicit_rkc_supported_schemes, params.integrator_type))
      {
        auto integrator = new ExplicitRungeKuttaChebyshevIntegrator<number>(
          params,
          [&pde_operator](number time,
                          number,
                          dealii::LinearAlgebra::distributed::Vector<number>       &dst,
                          const dealii::LinearAlgebra::distributed::Vector<number> &src,
                          std::function<void(unsigned, unsigned)>                   post) {
            pde_operator.apply_operator(time, dst, src, post);
          });
        return integrator;
      }
    if (Utils::contains(one_step_theta_supported_schemes, params.integrator_type))
      return new OneStepTheta<number, PDEOperator>(pde_operator, params, linear_solver_data);
    DEAL_II_NOT_IMPLEMENTED();
  }
} // namespace MeltPoolDG::TimeIntegration