scratch_data.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/base/index_set.h>
#include <deal.II/base/mpi.h>
#include <deal.II/base/mpi_remote_point_evaluation.h>
#include <deal.II/base/partitioner.h>
#include <deal.II/base/quadrature.h>
#include <deal.II/base/timer.h>
#include <deal.II/base/vectorization.h>
 
#include <deal.II/dofs/dof_handler.h>
 
#include <deal.II/fe/fe.h>
#include <deal.II/fe/mapping.h>
 
#include <deal.II/grid/tria.h>
 
#include <deal.II/lac/affine_constraints.h>
#include <deal.II/lac/la_parallel_block_vector.h>
#include <deal.II/lac/la_parallel_vector.h>
 
#include <deal.II/matrix_free/matrix_free.h>
 
#include <meltpooldg/cut/util.hpp>
#include <meltpooldg/utilities/conditional_ostream.hpp>
 
#include <functional>
#include <map>
#include <memory>
#include <vector>
 
namespace MeltPoolDG
{
  template <int dim, int spacedim, typename number>
  class ScratchData
  {
  private:
    using VectorizedArrayType = dealii::VectorizedArray<number>;
    using VectorType          = dealii::LinearAlgebra::distributed::Vector<number>;
    using BlockVectorType     = dealii::LinearAlgebra::distributed::BlockVector<number>;
 
  public:
    ScratchData(const MPI_Comm     mpi_communicator,
                const unsigned int verbosity_level_in,
                const bool         do_matrix_free);
 
    void
    reinit(const dealii::Mapping<dim, spacedim>                         &mapping,
           const std::vector<const dealii::DoFHandler<dim, spacedim> *> &dof_handler,
           const std::vector<const dealii::AffineConstraints<number> *> &constraint,
           const std::vector<dealii::Quadrature<dim>>                   &quad,
           const bool                                                    enable_boundary_face_loops,
           const bool                                                    enable_inner_face_loops,
           const bool enable_normal_vector_update = false);
    void
    set_mapping(const dealii::Mapping<dim, spacedim> &mapping);
 
    void
    set_mapping(const std::shared_ptr<dealii::Mapping<dim, spacedim>> mapping);
 
    unsigned int
    attach_dof_handler(const dealii::DoFHandler<dim, spacedim> &dof_handler);
 
    unsigned int
    attach_constraint_matrix(const dealii::AffineConstraints<number> &constraint);
 
    unsigned int
    attach_dof_handler_and_constraint(const dealii::DoFHandler<dim, spacedim> &dof_handler,
                                      const dealii::AffineConstraints<number> &constraint);
 
    unsigned int
    attach_quadrature(const dealii::Quadrature<dim> &quadrature);
 
    void
    create_partitioning();
 
    void
    build(const bool enable_boundary_face_loops,
          const bool enable_inner_face_loops,
          const bool enable_normal_vector_update       = false,
          const bool enable_inner_face_hessians_update = false);
 
    void
    initialize_dof_vector(VectorType &vec, const unsigned int dof_idx) const;
 
    void
    initialize_dof_vector(BlockVectorType &vec, const unsigned int dof_idx) const;
 
    void
    initialize_dof_vector(BlockVectorType                     &vec,
                          const std::array<unsigned int, dim> &dof_indices_per_block) const;
 
    void
    initialize_bc_vector(VectorType &vec, const unsigned int dof_idx) const;
 
    void
    initialize_bc_vector(BlockVectorType &vec, const unsigned int dof_idx) const;
 
    void
    clear();
 
    void
    create_remote_point_evaluation(const unsigned int                        dof_idx,
                                   const std::function<std::vector<bool>()> &marked_vertices = {});
 
    const dealii::Mapping<dim, spacedim> &
    get_mapping() const;
    const dealii::FiniteElement<dim, spacedim> &
    get_fe(const unsigned int fe_index) const;
    const dealii::AffineConstraints<number> &
    get_constraint(const unsigned int constraint_index) const;
    dealii::AffineConstraints<number> &
    get_constraint(const unsigned int constraint_index);
    const std::vector<const dealii::AffineConstraints<number> *> &
    get_constraints() const;
    const dealii::Quadrature<dim> &
    get_quadrature(const unsigned int quad_index) const;
 
    const std::vector<dealii::Quadrature<dim>> &
    get_quadratures() const;
    const dealii::Quadrature<dim - 1> &
    get_face_quadrature(const unsigned int quad_index) const;
    const std::vector<dealii::Quadrature<dim - 1>> &
    get_face_quadratures() const;
    dealii::MatrixFree<dim, number, VectorizedArrayType> &
    get_matrix_free();
    const dealii::MatrixFree<dim, number, VectorizedArrayType> &
    get_matrix_free() const;
    const dealii::DoFHandler<dim, spacedim> &
    get_dof_handler(const unsigned int dof_idx) const;
    dealii::DoFHandler<dim, spacedim> &
    get_dof_handler(const unsigned int dof_idx);
    const std::vector<const dealii::DoFHandler<dim, spacedim> *> &
    get_dof_handlers() const;
    const dealii::Triangulation<dim> &
    get_triangulation(const unsigned int dof_idx = 0) const;
    unsigned int
    get_n_dofs_per_cell(const unsigned int dof_idx) const;
 
    unsigned int
    get_degree(const unsigned int dof_idx) const;
    unsigned int
    get_n_q_points(const unsigned int dof_idx) const;
    const number &
    get_min_cell_size() const;
    number
    get_min_cell_size(const unsigned int dof_idx) const;
 
    const number &
    get_max_cell_size() const;
 
    const number &
    get_min_diameter() const;
 
    const dealii::AlignedVector<dealii::VectorizedArray<number>> &
    get_cell_sizes() const;
 
    MPI_Comm
    get_mpi_comm(const unsigned int dof_idx = 0) const;
    const dealii::IndexSet &
    get_locally_owned_dofs(const unsigned int dof_idx) const;
 
    const dealii::IndexSet &
    get_locally_relevant_dofs(const unsigned int dof_idx) const;
 
    const std::shared_ptr<dealii::Utilities::MPI::Partitioner> &
    get_partitioner(const unsigned int dof_idx) const;
    const ConditionalOStream
    get_pcout(const unsigned int level = 1) const;
 
    unsigned int
    get_cell_range_category(const std::pair<unsigned, unsigned> &cell_range) const;
 
    std::pair<unsigned int, unsigned int>
    get_face_range_category(const std::pair<unsigned, unsigned> &face_range) const;
 
    bool
    is_hex_mesh(const unsigned int dof_idx = 0) const;
 
    bool
    is_FE_Q_iso_Q_1(const unsigned int dof_idx, const unsigned int component = 0) const;
 
    bool
    is_FE_DGQ(const unsigned int dof_idx, const unsigned int component = 0) const;
 
    CutUtil::CutPhaseType
    get_cut_type(const unsigned int dof_idx) const;
 
    dealii::TimerOutput &
    get_timer() const;
 
    dealii::Utilities::MPI::RemotePointEvaluation<dim, dim> &
    get_remote_point_evaluation(const unsigned int dof_idx) const;
 
    bool enable_boundary_faces;
 
    bool enable_inner_faces;
 
  private:
    bool                                                   do_matrix_free;
    std::vector<dealii::ConditionalOStream>                pcout;
    std::shared_ptr<dealii::Mapping<dim, spacedim>>        mapping;
    std::vector<const dealii::DoFHandler<dim, spacedim> *> dof_handler;
    std::vector<const dealii::AffineConstraints<number> *> constraint;
    std::vector<dealii::Quadrature<dim>>                   quad;
    std::vector<dealii::Quadrature<dim - 1>>               face_quad;
    number                                                 min_cell_size;
    number max_cell_size; // only computed in case of matrixfree
    number min_diameter;
    dealii::AlignedVector<dealii::VectorizedArray<number>>            cell_sizes;
    std::vector<dealii::IndexSet>                                     locally_owned_dofs;
    std::vector<dealii::IndexSet>                                     locally_relevant_dofs;
    std::vector<std::shared_ptr<dealii::Utilities::MPI::Partitioner>> partitioner;
    std::map<unsigned int, std::shared_ptr<dealii::Utilities::MPI::RemotePointEvaluation<dim, dim>>>
                       rpe;
    const unsigned int verbosity_level;
 
    mutable std::shared_ptr<dealii::TimerOutput> timer;
 
    dealii::MatrixFree<dim, number, VectorizedArrayType> matrix_free;
 
    void
    create_pcout(MPI_Comm mpi_communicator);
  };
} // namespace MeltPoolDG