offline_data.h

Go to the documentation of this file.

//
// SPDX-License-Identifier: MIT
// Copyright (C) 2020 - 2023 by the ryujin authors
//
 
#pragma once
 
#include <compile_time_options.h>
 
#include "convenience_macros.h"
#include "discretization.h"
#include "multicomponent_vector.h"
#include "sparse_matrix_simd.h"
 
#include <deal.II/base/parameter_acceptor.h>
#include <deal.II/base/partitioner.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/lac/affine_constraints.h>
#include <deal.II/lac/la_parallel_vector.h>
#include <deal.II/lac/sparse_matrix.h>
 
#include <deal.II/numerics/data_out.h>
 
namespace ryujin
{
  template <int dim, typename Number = double>
  class OfflineData : public dealii::ParameterAcceptor
  {
  public:
    using scalar_type = dealii::LinearAlgebra::distributed::Vector<Number>;
 
    using boundary_description =
        std::tuple<dealii::Tensor<1, dim, Number> /*normal*/,
                   Number /*normal mass*/,
                   Number /*boundary mass*/,
                   dealii::types::boundary_id /*id*/,
                   dealii::Point<dim>> /*position*/;
 
    OfflineData(const MPI_Comm &mpi_communicator,
                const Discretization<dim> &discretization,
                const std::string &subsection = "/OfflineData");
 
    void prepare(const unsigned int problem_dimension)
    {
      setup(problem_dimension);
      assemble();
      create_multigrid_data();
    }
 
    ACCESSOR_READ_ONLY(dof_handler)
 
    
    ACCESSOR_READ_ONLY(affine_constraints)
 
    ACCESSOR_READ_ONLY_NO_DEREFERENCE(scalar_partitioner)
 
    ACCESSOR_READ_ONLY_NO_DEREFERENCE(vector_partitioner)
 
    ACCESSOR_READ_ONLY(n_export_indices)
 
    ACCESSOR_READ_ONLY(n_locally_internal)
 
    ACCESSOR_READ_ONLY(n_locally_owned)
 
    ACCESSOR_READ_ONLY(n_locally_relevant)
 
    ACCESSOR_READ_ONLY(boundary_map)
 
    ACCESSOR_READ_ONLY(coupling_boundary_pairs)
 
    ACCESSOR_READ_ONLY(level_boundary_map)
 
    ACCESSOR_READ_ONLY(sparsity_pattern)
 
    ACCESSOR_READ_ONLY(sparsity_pattern_simd)
 
    ACCESSOR_READ_ONLY(mass_matrix)
 
    ACCESSOR_READ_ONLY(lumped_mass_matrix)
 
    ACCESSOR_READ_ONLY(lumped_mass_matrix_inverse)
 
    ACCESSOR_READ_ONLY(level_lumped_mass_matrix)
 
    ACCESSOR_READ_ONLY(betaij_matrix)
 
    ACCESSOR_READ_ONLY(cij_matrix)
 
    ACCESSOR_READ_ONLY(measure_of_omega)
 
    ACCESSOR_READ_ONLY(discretization)
 
  private:
    void create_constraints_and_sparsity_pattern();
 
    void setup(const unsigned int problem_dimension);
 
    void assemble();
 
    void create_multigrid_data();
 
    std::unique_ptr<dealii::DoFHandler<dim>> dof_handler_;
 
    dealii::AffineConstraints<Number> affine_constraints_;
 
    std::shared_ptr<const dealii::Utilities::MPI::Partitioner>
        scalar_partitioner_;
 
    std::shared_ptr<const dealii::Utilities::MPI::Partitioner>
        vector_partitioner_;
 
    unsigned int n_export_indices_;
    unsigned int n_locally_internal_;
    unsigned int n_locally_owned_;
    unsigned int n_locally_relevant_;
 
    using boundary_map_type =
        std::multimap<dealii::types::global_dof_index, boundary_description>;
    using coupling_boundary_pairs_type =
        std::vector<std::tuple<dealii::types::global_dof_index,
                               unsigned int,
                               dealii::types::global_dof_index>>;
    boundary_map_type boundary_map_;
    coupling_boundary_pairs_type coupling_boundary_pairs_;
 
    std::vector<boundary_map_type> level_boundary_map_;
 
    dealii::DynamicSparsityPattern sparsity_pattern_;
 
    SparsityPatternSIMD<dealii::VectorizedArray<Number>::size()>
        sparsity_pattern_simd_;
 
    SparseMatrixSIMD<Number> mass_matrix_;
 
    dealii::LinearAlgebra::distributed::Vector<Number> lumped_mass_matrix_;
    dealii::LinearAlgebra::distributed::Vector<Number>
        lumped_mass_matrix_inverse_;
 
    std::vector<dealii::LinearAlgebra::distributed::Vector<float>>
        level_lumped_mass_matrix_;
 
    SparseMatrixSIMD<Number> betaij_matrix_;
    SparseMatrixSIMD<Number, dim> cij_matrix_;
 
    Number measure_of_omega_;
 
    dealii::SmartPointer<const Discretization<dim>> discretization_;
 
    const MPI_Comm &mpi_communicator_;
 
    template <typename ITERATOR1, typename ITERATOR2>
    boundary_map_type construct_boundary_map(
        const ITERATOR1 &begin,
        const ITERATOR2 &end,
        const dealii::Utilities::MPI::Partitioner &partitioner) const;
  };
 
} /* namespace ryujin */