dirac_convergence_test.h

#ifndef HLDO_SPHERE_DEBUG_DIRAC_CONVERGENCE_H
#define HLDO_SPHERE_DEBUG_DIRAC_CONVERGENCE_H
 
#include <dirac_operator_source_problem.h>
#include <lf/io/vtk_writer.h>
#include <lf/mesh/hybrid2d/mesh_factory.h>
#include <lf/mesh/utils/tp_triag_mesh_builder.h>
#include <lf/mesh/utils/utils.h>
#include <lf/quad/quad.h>
#include <lf/refinement/refinement.h>
#include <lf/uscalfe/uscalfe.h>
#include <mesh_function_whitney_one.h>
#include <mesh_function_whitney_two.h>
#include <mesh_function_whitney_zero.h>
#include <norms.h>
#include <results_processing.h>
#include <sphere_triag_mesh_builder.h>
 
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
 
namespace projects::hldo_sphere {
namespace debugging {
 
using complex = std::complex<double>;
 
struct SolutionList {
  std::vector<Eigen::Matrix<complex, Eigen::Dynamic, 1>> mu_zero;
  std::vector<Eigen::Matrix<complex, Eigen::Dynamic, 1>> mu_one;
  std::vector<Eigen::Matrix<complex, Eigen::Dynamic, 1>> mu_two;
};
 
class DiracConvergenceTest {
 public:
  DiracConvergenceTest(
      std::function<complex(const Eigen::Matrix<double, 3, 1> &)> f_zero,
      std::function<
          Eigen::Matrix<complex, 3, 1>(const Eigen::Matrix<double, 3, 1> &)>
          f_one,
      std::function<complex(const Eigen::Matrix<double, 3, 1> &)> f_two,
      double &k)
      : f_zero_(f_zero), f_one_(f_one), f_two_(f_two), k_(k) {}
 
  void Compute(unsigned refinement_levels);
 
 private:
  std::function<complex(const Eigen::Matrix<double, 3, 1> &)> f_zero_;
  std::function<Eigen::Matrix<complex, 3, 1>(
      const Eigen::Matrix<double, 3, 1> &)>
      f_one_;
  std::function<complex(const Eigen::Matrix<double, 3, 1> &)> f_two_;
  double &k_;
};
}  // namespace debugging
}  // namespace projects::hldo_sphere
 
#endif  // HLDO_SPHERE_DEBUG_DIRAC_CONVERGENCE_H