dg_operator_explicit.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/lac/la_parallel_vector.h>
 
#include <deal.II/matrix_free/matrix_free.h>
 
#include <meltpooldg/compressible_flow/convective_kernels.hpp>
#include <meltpooldg/compressible_flow/dg_operator_base.hpp>
#include <meltpooldg/compressible_flow/kernels_n_species.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/explicit_low_storage_runge_kutta_integrator.hpp>
#include <meltpooldg/time_integration/time_integrator_data.hpp>
#include <meltpooldg/utilities/dg_generic_convection_diffusion_worker.hpp>
 
#include <functional>
#include <memory>
#include <utility>
 
namespace MeltPoolDG::CompressibleFlow
{
  template <int dim, typename number, int n_species = 1>
  class DGOperatorExplicit final : public DGOperatorBase<dim, number, n_species>
  {
  public:
    using VectorType = dealii::LinearAlgebra::distributed::Vector<number>;
 
    using ConservedVariables         = ConservedVariablesType<dim, number, n_species>;
    using ConservedVariablesGradient = ConservedVariablesGradientType<dim, number, n_species>;
 
    using FlowFluxType   = FluxType<dim, number, n_species>;
    using FlowSourceType = SourceType<dim, number, n_species>;
 
    using ConvectiveKernel =
      NSpeciesConvectiveFlux<dim, n_species, number, ConservedVariables, FlowFluxType>;
    using DiffusiveKernel = NSpeciesDiffusiveFlux<dim,
                                                  n_species,
                                                  number,
                                                  ConservedVariables,
                                                  ConservedVariablesGradient,
                                                  FlowFluxType>;
 
    using ConvectionDiffusionOperator =
      Utils::DGConvectionDiffusionOperator<dim, number, ConvectiveKernel, DiffusiveKernel>;
 
    using ConvectionOperator = Utils::DGConvectionOperator<dim, number, ConvectiveKernel>;
 
    explicit DGOperatorExplicit(OperationScratchData<dim, number> &flow_scratch_data);
 
    void
    advance_time_step(number time, number time_step) override;
 
    void
    reinit() override;
 
    void
    apply_operator(number                                                 time,
                   number                                                 time_step,
                   VectorType                                            &dst,
                   const VectorType                                      &src,
                   const std::function<void(unsigned int, unsigned int)> &func) const;
 
    void
    add_external_force(std::shared_ptr<ExternalFlowForce<dim, number, n_species>> external_force,
                       std::shared_ptr<ExternalFlowForceJacobian<dim, number, n_species>>) override;
 
  private:
    OperationScratchData<dim, number> &flow_scratch_data;
 
    TimeIntegration::LowStorageExplicitRungeKuttaIntegrator<number> time_integrator;
 
    std::vector<std::shared_ptr<ExternalFlowForce<dim, number, n_species>>> external_forces;
 
    mutable number current_time_step;
 
    bool
    is_viscous() const;
 
    void
    local_apply_cell(const dealii::MatrixFree<dim, number>       &matrix_free,
                     VectorType                                  &dst,
                     const VectorType                            &src,
                     const std::pair<unsigned int, unsigned int> &cell_range) const;
 
    void
    local_apply_face(const dealii::MatrixFree<dim, number>       &matrix_free,
                     VectorType                                  &dst,
                     const VectorType                            &src,
                     const std::pair<unsigned int, unsigned int> &face_range) const;
 
    void
    local_apply_boundary_face(const dealii::MatrixFree<dim, number>       &matrix_free,
                              VectorType                                  &dst,
                              const VectorType                            &src,
                              const std::pair<unsigned int, unsigned int> &face_range) const;
  };
} // namespace MeltPoolDG::CompressibleFlow