abstract_assembler.hh

Go to the documentation of this file.

#pragma once
 
// DiFfRG
#include <DiFfRG/common/linear_algebra.hh>
#include <DiFfRG/common/mpi.hh>
#include <DiFfRG/discretization/common/solution_view.hh>
#include <DiFfRG/discretization/data/output_session.hh>
 
namespace DiFfRG
{
  using namespace dealii;
 
  template <unsigned int dim, typename VectorType> class DataOutput;
 
  namespace internal
  {
    template <typename... Args> constexpr void validate_readout_helper_arity()
    {
      static_assert(sizeof...(Args) == 3,
                    "The readout helper now requires a stable readout ID: helper(id, EoM, outputter)");
    }
 
  } // namespace internal
 
  template <typename VectorType, typename SparseMatrixType, uint dim> class AbstractAssembler
  {
  public:
    using NumberType = typename get_type::NumberType<VectorType>;
 
    virtual SummaryEvent summary() const { return {}; }
 
    virtual void attach_data_output(OutputFrame<dim, VectorType> &data_out, const VectorType &solution,
                                    const VectorType &variables = VectorType(),
                                    const VectorType &dt_solution = VectorType(),
                                    const VectorType &residual = VectorType()) = 0;
 
    [[deprecated("Override attach_data_output(OutputFrame<dim, VectorType>&, ...) instead")]] virtual void
    attach_data_output(DataOutput<dim, VectorType> &, const VectorType &, const VectorType & = VectorType(),
                       const VectorType & = VectorType(), const VectorType & = VectorType()) = delete;
 
    virtual void reinit() = 0;
 
    virtual void set_time(double t) = 0;
 
    virtual const get_type::SparsityPattern<SparseMatrixType> &get_sparsity_pattern_jacobian() const = 0;
 
    virtual IndexSet get_differential_indices() const = 0;
 
    virtual void reinit_vector(VectorType &vector) const = 0;
 
    virtual void reinit_matrix(SparseMatrixType &matrix) const = 0;
 
    virtual MPI_Comm get_communicator() const = 0;
 
    virtual void reinit_solution_view(SolutionView<VectorType> &view) const = 0;
 
    virtual const SparseMatrixType &get_mass_matrix() const = 0;
 
 
    virtual void residual_variables([[maybe_unused]] VectorType &residual, [[maybe_unused]] const VectorType &variables,
                                    [[maybe_unused]] const VectorType &spatial_solution)
    {
      throw std::runtime_error("residual_variables() is not implemented by this assembler");
    };
 
    virtual void jacobian_variables([[maybe_unused]] FullMatrix<NumberType> &jacobian,
                                    [[maybe_unused]] const VectorType &variables,
                                    [[maybe_unused]] const VectorType &spatial_solution)
    {
      throw std::runtime_error("jacobian_variables() is not implemented by this assembler");
    };
 
    void mass(VectorType &mass, const VectorType &solution_global, NumberType weight)
    {
      this->mass(mass, solution_global, solution_global, weight);
    }
 
    virtual void mass(VectorType &mass, const VectorType &solution_global, const VectorType &solution_global_dot,
                      NumberType weight) = 0;
 
    void residual(VectorType &residual, const VectorType &solution_global, NumberType weight, NumberType weight_mass,
                  const VectorType &variables = VectorType())
    {
      this->residual(residual, solution_global, weight, solution_global, weight_mass, variables);
    }
 
    virtual void residual(VectorType &residual, const VectorType &solution_global, NumberType weight,
                          const VectorType &solution_global_dot, NumberType weight_mass,
                          const VectorType &variables = VectorType()) = 0;
 
    void jacobian_mass(SparseMatrixType &jacobian, const VectorType &solution_global, NumberType mass_weight = 1.)
    {
      this->jacobian_mass(jacobian, solution_global, solution_global, mass_weight, 0.);
    }
 
    virtual void jacobian_mass(SparseMatrixType &jacobian, const VectorType &solution_global,
                               const VectorType &solution_global_dot, NumberType alpha = 1., NumberType beta = 1.) = 0;
 
    void jacobian(SparseMatrixType &jacobian, const VectorType &solution_global, NumberType weight,
                  NumberType mass_weight, const VectorType &variables = VectorType())
    {
      this->jacobian(jacobian, solution_global, weight, solution_global, mass_weight, mass_weight, variables);
    }
 
    virtual void jacobian(SparseMatrixType &jacobian, const VectorType &solution_global, NumberType weight,
                          const VectorType &solution_global_dot, NumberType alpha, NumberType beta,
                          const VectorType &variables = VectorType()) = 0;
  };
} // namespace DiFfRG