abstract_assembler.hh

Go to the documentation of this file.

#pragma once
 
// DiFfRG
#include <DiFfRG/common/types.hh>
#include <DiFfRG/discretization/data/data_output.hh>
 
namespace DiFfRG
{
  using namespace dealii;
 
  template <typename VectorType, typename SparseMatrixType, uint dim> class AbstractAssembler
  {
  public:
    using NumberType = typename get_type::NumberType<VectorType>;
 
    virtual void attach_data_output(DataOutput<dim, VectorType> &data_out, const VectorType &solution,
                                    const VectorType &variables = VectorType(),
                                    const VectorType &dt_solution = VectorType(),
                                    const VectorType &residual = VectorType()) = 0;
 
    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 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("Not implemented!");
    };
 
    virtual void jacobian_variables([[maybe_unused]] FullMatrix<NumberType> &jacobian,
                                    [[maybe_unused]] const VectorType &variables,
                                    [[maybe_unused]] const VectorType &spatial_solution)
    {
      throw std::runtime_error("Not implemented!");
    };
 
    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