dg_operator_implicit_explicit.hpp

Go to the documentation of this file.

#pragma once
 
#include <meltpooldg/compressible_flow/convective_kernels.hpp>
#include <meltpooldg/compressible_flow/data_types.hpp>
#include <meltpooldg/compressible_flow/dg_operator_base.hpp>
#include <meltpooldg/compressible_flow/operation_scratch_data.hpp>
#include <meltpooldg/compressible_flow/utils.hpp>
#include <meltpooldg/compressible_flow/viscous_kernels.hpp>
#include <meltpooldg/time_integration/implicit_explicit_integrator.hpp>
 
namespace MeltPoolDG::CompressibleFlow
{
  template <int dim, typename number, bool is_viscous = true>
  class DGOperatorImplicitExplicit final : public DGOperatorBase<dim, number>
  {
  public:
    using VectorType                 = dealii::LinearAlgebra::distributed::Vector<number>;
    using ConservedVariables         = ConservedVariablesType<dim, number>;
    using ConservedVariablesGradient = ConservedVariablesGradientType<dim, number>;
 
    explicit DGOperatorImplicitExplicit(OperationScratchData<dim, number> &flow_scratch_data);
 
    void
    add_external_force(
      std::shared_ptr<ExternalFlowForce<dim, number>>         external_force_residuum,
      std::shared_ptr<ExternalFlowForceJacobian<dim, number>> external_force_jacobian) override;
 
    void
    compute_system_matrix_from_matrixfree(
      dealii::TrilinosWrappers::SparseMatrix &sparse_matrix) const;
 
    void
    compute_inverse_diagonal_from_matrixfree(VectorType &diagonal) const;
 
    void
    reinit() override;
 
    void
    advance_time_step(number time, number time_step) override;
 
    void
    local_cell_jacobian_kernel(FECellIntegrator<dim, dim + 2, number>       &delta_phi,
                               const FECellIntegrator<dim, dim + 2, number> &phi,
                               unsigned int                                  q_index) const;
 
    void
    local_face_jacobian_kernel(FEFaceIntegrator<dim, dim + 2, number>       &delta_phi_m,
                               FEFaceIntegrator<dim, dim + 2, number>       &delta_phi_p,
                               const FEFaceIntegrator<dim, dim + 2, number> &phi_m,
                               const FEFaceIntegrator<dim, dim + 2, number> &phi_p,
                               unsigned                                      q_index) const;
 
    void
    local_boundary_face_jacobian_kernel(FEFaceIntegrator<dim, dim + 2, number>       &delta_phi_m,
                                        const FEFaceIntegrator<dim, dim + 2, number> &phi_m,
                                        unsigned q_index) const;
 
    void
    set_stage_constants(number            current_time,
                        number            time_step,
                        const VectorType &intermediate_explicit_solution_in,
                        number            rhs_scaling_factor = 1.) const;
 
    void
    perform_explicit_stage(number                                         current_time,
                           number                                         time_step,
                           VectorType                                    &dst,
                           const VectorType                              &src,
                           bool                                           zero_dst_vec,
                           const std::function<void(unsigned, unsigned)> &post) const;
 
    void
    apply_jacobian(number time, number time_step, VectorType &dst, const VectorType &src) const;
 
    void
    compute_residual(number            current_time,
                     number            time_step,
                     const VectorType &src,
                     VectorType       &dst,
                     const VectorType &explicit_solution) const;
 
  private:
    mutable const VectorType *intermediate_explicit_solution = nullptr;
 
    mutable VectorType disturbed_residual;
 
    mutable number current_time_increment;
 
    OperationScratchData<dim, number> &flow_scratch_data;
 
    TimeIntegration::ImplicitExplicitIntegrator<dim, number> time_integrator;
 
    ConvectiveKernels<dim, number> convective_terms;
 
    ViscousKernels<dim, number> viscous_terms;
 
    std::vector<std::shared_ptr<ExternalFlowForce<dim, number>>> external_forces_explicit_rhs;
 
    std::vector<std::shared_ptr<ExternalFlowForce<dim, number>>> external_forces_implicit_residual;
 
    std::vector<std::shared_ptr<ExternalFlowForceJacobian<dim, number>>>
      external_forces_implicit_jacobian;
 
    void
    local_cell_explicit_stage(const dealii::MatrixFree<dim, number>                    &matrix_free,
                              dealii::LinearAlgebra::distributed::Vector<number>       &dst,
                              const dealii::LinearAlgebra::distributed::Vector<number> &src,
                              const std::pair<unsigned int, unsigned int> &cell_range) const;
 
    void
    local_face_explicit_stage(const dealii::MatrixFree<dim, number>                    &matrix_free,
                              dealii::LinearAlgebra::distributed::Vector<number>       &dst,
                              const dealii::LinearAlgebra::distributed::Vector<number> &src,
                              const std::pair<unsigned int, unsigned int> &face_range) const;
 
    void
    local_boundary_face_explicit_stage(
      const dealii::MatrixFree<dim, number>                    &matrix_free,
      dealii::LinearAlgebra::distributed::Vector<number>       &dst,
      const dealii::LinearAlgebra::distributed::Vector<number> &src,
      const std::pair<unsigned int, unsigned int>              &face_range) const;
 
    void
    local_cell_residual(const dealii::MatrixFree<dim, number>                    &matrix_free,
                        dealii::LinearAlgebra::distributed::Vector<number>       &dst,
                        const dealii::LinearAlgebra::distributed::Vector<number> &src,
                        const std::pair<unsigned int, unsigned int>              &cell_range) const;
 
    void
    local_face_residual(const dealii::MatrixFree<dim, number>                    &matrix_free,
                        dealii::LinearAlgebra::distributed::Vector<number>       &dst,
                        const dealii::LinearAlgebra::distributed::Vector<number> &src,
                        const std::pair<unsigned int, unsigned int>              &face_range) const;
 
    void
    local_boundary_face_residual(const dealii::MatrixFree<dim, number>              &matrix_free,
                                 dealii::LinearAlgebra::distributed::Vector<number> &dst,
                                 const dealii::LinearAlgebra::distributed::Vector<number> &src,
                                 const std::pair<unsigned int, unsigned int> &face_range) const;
 
    void
    local_cell_jacobian(const dealii::MatrixFree<dim, number>       &matrix_free,
                        VectorType                                  &dst,
                        const VectorType                            &src,
                        const std::pair<unsigned int, unsigned int> &cell_range) const;
 
    void
    local_face_jacobian(const dealii::MatrixFree<dim, number>       &matrix_free,
                        VectorType                                  &dst,
                        const VectorType                            &src,
                        const std::pair<unsigned int, unsigned int> &face_range) const;
 
    void
    local_boundary_face_jacobian(const dealii::MatrixFree<dim, number>              &matrix_free,
                                 dealii::LinearAlgebra::distributed::Vector<number> &dst,
                                 const dealii::LinearAlgebra::distributed::Vector<number> &src,
                                 const std::pair<unsigned int, unsigned int> &face_range) const;
  };
} // namespace MeltPoolDG::CompressibleFlow