dg_operator_implicit.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/lac/la_parallel_vector.h>
 
#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/viscous_kernels.hpp>
#include <meltpooldg/time_integration/bdf_time_integration.hpp>
#include <meltpooldg/time_integration/time_integrator_data.hpp>
 
 
namespace MeltPoolDG::CompressibleFlow
{
  template <int dim, typename number, bool is_viscous = true>
  class DGOperatorImplicit final : public DGOperatorBase<dim, number>
  {
  public:
    using VectorType                 = dealii::LinearAlgebra::distributed::Vector<number>;
    using ConservedVariables         = ConservedVariablesType<dim, number>;
    using ConservedVariablesGradient = ConservedVariablesGradientType<dim, number>;
 
    explicit DGOperatorImplicit(OperationScratchData<dim, number> &flow_scratch_data);
 
    void
    reinit() override;
 
    void
    advance_time_step(number time, number time_step) override;
 
    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
    apply_jacobian(number            time_step,
                   VectorType       &dst,
                   const VectorType &src) const; // TODO
 
    void
    compute_residual(number            current_time,
                     number            time_step,
                     const VectorType &src,
                     VectorType       &dst,
                     const VectorType &old_solution) const; // TODO
 
 
    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 int                                  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 int q_index) const;
 
  private:
    mutable const VectorType *time_integrator_old_solution = nullptr;
 
    mutable VectorType disturbed_residual;
 
    mutable number current_time_step;
 
    OperationScratchData<dim, number> &flow_scratch_data;
 
    TimeIntegration::BDFIntegrator<dim, number> time_integrator;
 
    ConvectiveKernels<dim, number> convective_terms;
 
    ViscousKernels<dim, number> viscous_terms;
 
    std::vector<std::shared_ptr<ExternalFlowForce<dim, number>>> external_forces_residual;
 
    std::vector<std::shared_ptr<ExternalFlowForceJacobian<dim, number>>> external_forces_jacobian;
 
    void
    apply_jacobian_analytic(const VectorType &src, VectorType &dst) const;
 
    void
    apply_jacobian_finite_differences(const VectorType &src, VectorType &dst) 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