fe_subcell_face_evaluation.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/base/vectorization.h>
 
#include <deal.II/matrix_free/fe_evaluation.h>
 
#include <bitset>
#include <ranges>
#include <vector>
 
namespace MeltPoolDG
{
  template <int dim, int n_components, typename number>
  class FESubcellFaceEvaluation
  {
    using VectorizedArrayType = dealii::VectorizedArray<number>;
 
    static constexpr unsigned int n_lanes = VectorizedArrayType::size();
 
  public:
    using value_type =
      dealii::FEFaceEvaluation<dim, -1, 0, n_components, number, VectorizedArrayType>::value_type;
 
    using gradient_type = dealii::
      FEFaceEvaluation<dim, -1, 0, n_components, number, VectorizedArrayType>::gradient_type;
 
    FESubcellFaceEvaluation(const dealii::MatrixFree<dim, number> &matrix_free,
                            const bool                             is_interior_face,
                            const unsigned int                     dof_no,
                            const unsigned int                     quad_no);
 
    void
    reinit(const unsigned int face_batch_index);
 
    void
    read_dof_values(const dealii::LinearAlgebra::distributed::Vector<number> &src_vector,
                    const std::bitset<n_lanes> &mask = std::bitset<n_lanes>().flip());
 
    void
    evaluate(const dealii::EvaluationFlags::EvaluationFlags evaluation_flags);
 
    void
    gather_evaluate(const dealii::LinearAlgebra::distributed::Vector<number> &input_vector,
                    const dealii::EvaluationFlags::EvaluationFlags            evaluation_flags,
                    const std::bitset<n_lanes> &mask = std::bitset<n_lanes>().flip());
 
    value_type
    get_value(const unsigned int subcell_index) const;
 
    void
    submit_flux(const unsigned int subcell_index, const value_type &normal_flux);
 
    void
    integrate();
 
    void
    distribute_local_to_global(dealii::LinearAlgebra::distributed::Vector<number> &dst_vector,
                               const std::bitset<n_lanes> &mask = std::bitset<n_lanes>().flip());
 
    void
    integrate_scatter(dealii::LinearAlgebra::distributed::Vector<number> &dst_vector,
                      const std::bitset<n_lanes> &mask = std::bitset<n_lanes>().flip());
 
    std::ranges::iota_view<unsigned int, unsigned int>
    subcell_face_indices() const;
 
    VectorizedArrayType
    subcell_face_size(const unsigned int subcell_index) const;
 
    dealii::Point<dim, VectorizedArrayType>
    subcell_location(const unsigned int subcell_index) const;
 
    unsigned int
    n_subcell_faces() const;
 
    dealii::Tensor<1, dim, VectorizedArrayType>
    normal_vector(const unsigned int subcell_index) const;
 
    bool
    at_boundary() const;
 
    dealii::types::boundary_id
    boundary_id() const;
 
    VectorizedArrayType
    subcell_size(const unsigned int subcell_index) const;
 
  private:
    unsigned int n_subcells_1d = dealii::numbers::invalid_unsigned_int;
 
    unsigned int n_subcells_face = dealii::numbers::invalid_unsigned_int;
 
    unsigned int face_batch_index = dealii::numbers::invalid_unsigned_int;
 
    const dealii::MatrixFree<dim, number> &matrix_free;
 
    const bool is_interior_face;
 
    unsigned int face_no = dealii::numbers::invalid_unsigned_int;
 
    std::vector<value_type> layer_values;
 
    std::vector<value_type> submitted_fluxes;
 
    std::vector<VectorizedArrayType> subcell_face_sizes;
 
    std::vector<VectorizedArrayType> subcell_sizes;
 
    std::vector<dealii::Tensor<1, dim, VectorizedArrayType>> subcell_face_normals;
 
    std::vector<dealii::Point<dim, VectorizedArrayType>> subcell_locations;
 
    std::vector<VectorizedArrayType> integrated_subcell_values_buffer;
 
    bool is_reinitialized = false;
 
    bool dof_values_initialized = false;
 
    bool subcell_values_initialized = false;
 
    bool subcell_fluxes_submitted = false;
 
    bool is_boundary_face = false;
 
    dealii::FEEvaluation<dim, -1, 0, n_components, number, VectorizedArrayType> fe_cell_evaluator;
 
    dealii::FEFaceEvaluation<dim, -1, 0, n_components, number, VectorizedArrayType>
      fe_face_evaluator;
 
    unsigned int
    layer_index(const unsigned int subcell_index) const;
 
    unsigned int
    face_to_cell_quadrature_index(
      const unsigned int                                              face_no,
      const unsigned int                                              q_face,
      const dealii::internal::MatrixFreeFunctions::ShapeInfo<number> &shape_info) const;
 
    void
    determine_subcell_face_sizes();
 
    void
    determine_subcell_face_normals();
 
    void
    determine_subcell_sizes();
 
    void
    determine_subcell_locations();
 
    void
    setup_internal_data_structures();
 
    void
    project_dof_values_to_subcell_values(
      const dealii::EvaluationFlags::EvaluationFlags evaluation_flags);
  };
} // namespace MeltPoolDG