test_PolynomialReconstruction.cpp

#include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
#include <catch2/matchers/catch_matchers_all.hpp>

#include <Kokkos_Core.hpp>

#include <utils/PugsAssert.hpp>
#include <utils/Types.hpp>

#include <algebra/SmallMatrix.hpp>
#include <algebra/SmallVector.hpp>
#include <mesh/Mesh.hpp>
#include <mesh/MeshDataManager.hpp>
#include <scheme/DiscreteFunctionP0.hpp>
#include <scheme/DiscreteFunctionVariant.hpp>
#include <scheme/PolynomialReconstruction.hpp>

#include <MeshDataBaseForTests.hpp>

template <typename... DiscreteFunctionT>
std::vector<std::shared_ptr<const DiscreteFunctionVariant>>
build_list(DiscreteFunctionT... input)
{
  std::vector<std::shared_ptr<const DiscreteFunctionVariant>> variant_vector;
  auto convert = [&variant_vector](auto&& df) {
    using DF_T = std::decay_t<decltype(df)>;
    if constexpr (is_discrete_function_v<DF_T> or std::is_same_v<DiscreteFunctionVariant, DF_T>) {
      variant_vector.push_back(std::make_shared<DiscreteFunctionVariant>(df));
    } else if constexpr (is_shared_ptr_v<DF_T>) {
      using DF_Value_T = std::decay_t<typename DF_T::element_type>;
      if constexpr (is_discrete_function_v<DF_Value_T> or std::is_same_v<DiscreteFunctionVariant, DF_Value_T>) {
        variant_vector.push_back(std::make_shared<DiscreteFunctionVariant>(*df));
      } else {
        static_assert(is_false_v<DF_T>, "unexpected type");
      }
    } else {
      static_assert(is_false_v<DF_T>, "unexpected type");
    }
  };

  (convert(input), ...);
  return variant_vector;
}

// clazy:excludeall=non-pod-global-static

TEST_CASE("PolynomialReconstruction", "[scheme]")
{
  SECTION("1D")
  {
    using R1 = TinyVector<1>;

    SECTION("R data")
    {
      for (auto named_mesh : MeshDataBaseForTests::get().all1DMeshes()) {
        SECTION(named_mesh.name())
        {
          auto p_mesh = named_mesh.mesh()->get<Mesh<1>>();
          auto& mesh  = *p_mesh;

          auto affine = [](const R1& x) { return 2.3 + 1.7 * x[0]; };
          auto xj     = MeshDataManager::instance().getMeshData(mesh).xj();

          DiscreteFunctionP0<double> fh{p_mesh};

          parallel_for(
            mesh.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) { fh[cell_id] = affine(xj[cell_id]); });

          DiscreteFunctionVariant fh_v(fh);
          std::shared_ptr<const DiscreteFunctionVariant> p_fh_v = std::make_shared<DiscreteFunctionVariant>(fh);