offline_data.h

Go to the documentation of this file.

//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// Copyright (C) 2020 - 2024 by the ryujin authors
//
 
#pragma once
 
#include <compile_time_options.h>
 
#include "convenience_macros.h"
#include "discretization.h"
#include "mpi_ensemble.h"
#include "observer_pointer.h"
#include "sparse_matrix_simd.h"
#include "state_vector.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 ScalarVector = Vectors::ScalarVector<Number>;
 
    using ScalarVectorFloat = Vectors::ScalarVector<float>;
 
    using BoundaryDescription =
        std::tuple<unsigned int /*i*/,
                   dealii::Tensor<1, dim, Number> /*normal*/,
                   Number /*normal mass*/,
                   Number /*boundary mass*/,
                   dealii::types::boundary_id /*id*/,
                   dealii::Point<dim>> /*position*/;
 
    using CouplingDescription = std::tuple<unsigned int /*i*/, //
                                           unsigned int /*col_idx*/,
                                           unsigned int /*j*/>;
 
    OfflineData(const MPIEnsemble &mpi_ensemble,
                const Discretization<dim> &discretization,
                const std::string &subsection = "/OfflineData");
 
    void prepare(const unsigned int problem_dimension,
                 const unsigned int n_precomputed_values,
                 const unsigned int n_parabolic_state_vectors)
    {
      setup(problem_dimension, n_precomputed_values);
 
      create_matrices();
 
      if (!dof_handler_->has_hp_capabilities())
        create_multigrid_data();
 
      n_parabolic_state_vectors_ = n_parabolic_state_vectors;
    }
 
    ACCESSOR_READ_ONLY(dof_handler)
 
    
    ACCESSOR_READ_ONLY(affine_constraints)
 
    ACCESSOR_READ_ONLY_NO_DEREFERENCE(scalar_partitioner)
 
    ACCESSOR_READ_ONLY_NO_DEREFERENCE(hyperbolic_vector_partitioner)
 
    ACCESSOR_READ_ONLY_NO_DEREFERENCE(precomputed_vector_partitioner)
 
    ACCESSOR_READ_ONLY(n_parabolic_state_vectors);
 
    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(mass_matrix_inverse)
 
    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(incidence_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,
               const unsigned int n_precomputed_values);
 
    void create_matrices();
 
    void create_multigrid_data();
 
 
 
    const MPIEnsemble &mpi_ensemble_;
 
    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>
        hyperbolic_vector_partitioner_;
 
    std::shared_ptr<const dealii::Utilities::MPI::Partitioner>
        precomputed_vector_partitioner_;
 
    unsigned int n_parabolic_state_vectors_;
 
    unsigned int n_export_indices_;
    unsigned int n_locally_internal_;
    unsigned int n_locally_owned_;
    unsigned int n_locally_relevant_;
 
    using BoundaryMap = std::vector<BoundaryDescription>;
    BoundaryMap boundary_map_;
    std::vector<BoundaryMap> level_boundary_map_;
 
    using CouplingBoundaryPairs = std::vector<CouplingDescription>;
    CouplingBoundaryPairs coupling_boundary_pairs_;
 
    dealii::DynamicSparsityPattern sparsity_pattern_;
 
    SparsityPatternSIMD<dealii::VectorizedArray<Number>::size()>
        sparsity_pattern_simd_;
 
    SparseMatrixSIMD<Number> mass_matrix_;
    SparseMatrixSIMD<Number> mass_matrix_inverse_;
 
    ScalarVector lumped_mass_matrix_;
    ScalarVector lumped_mass_matrix_inverse_;
 
    std::vector<ScalarVectorFloat> level_lumped_mass_matrix_;
 
    SparseMatrixSIMD<Number> betaij_matrix_;
    SparseMatrixSIMD<Number, dim> cij_matrix_;
    SparseMatrixSIMD<Number> incidence_matrix_;
 
    Number measure_of_omega_;
 
    dealii::ObserverPointer<const Discretization<dim>> discretization_;
 
    template <typename ITERATOR1, typename ITERATOR2>
    BoundaryMap construct_boundary_map(
        const ITERATOR1 &begin,
        const ITERATOR2 &end,
        const dealii::Utilities::MPI::Partitioner &partitioner) const;
 
    template <typename ITERATOR1, typename ITERATOR2>
    CouplingBoundaryPairs collect_coupling_boundary_pairs(
        const ITERATOR1 &begin,
        const ITERATOR2 &end,
        const dealii::Utilities::MPI::Partitioner &partitioner) const;
 
 
 
    bool treat_fe_nothing_as_boundary_;
    double incidence_relaxation_even_;
    double incidence_relaxation_odd_;
 
  };
 
} /* namespace ryujin */