test_reconstruction.cpp

#include <scheme/test_reconstruction.hpp>

#include <scheme/PolynomialReconstruction.hpp>
#include <utils/Timer.hpp>

void
test_reconstruction(const std::shared_ptr<const MeshVariant>& mesh_v,
                    const std::shared_ptr<const DiscreteFunctionVariant>& discrete_function_v)
{
  std::cout << "** one variable at a time (30 times)\n";
  PolynomialReconstructionDescriptor descriptor{1};

  std::visit(
    [&](auto&& p_mesh) {
      std::visit(
        [&](auto&& discrete_function) {
          using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
          PolynomialReconstruction reconstruction{descriptor};
          if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
            Timer t;
            for (size_t i = 0; i < 30; ++i) {
              auto res = reconstruction.build(*p_mesh, discrete_function);
            }
            t.pause();
            std::cout << "t = " << t << '\n';
          }
        },
        discrete_function_v->discreteFunction());
    },
    mesh_v->variant());

  std::cout << "finished!\n";
}

void
test_reconstruction_one(const std::shared_ptr<const MeshVariant>& mesh_v,
                        const std::shared_ptr<const DiscreteFunctionVariant>& discrete_function_v)
{
  PolynomialReconstructionDescriptor descriptor{1};
  std::visit(
    [&](auto&& p_mesh) {
      std::visit(
        [&](auto&& discrete_function) {
          using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
          PolynomialReconstruction reconstruction{descriptor};
          if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
            for (size_t i = 0; i < 30; ++i) {
              auto res = reconstruction.build(*p_mesh, discrete_function);
            }
          }
        },
        discrete_function_v->discreteFunction());
    },
    mesh_v->variant());
}

void
test_reconstruction(const std::vector<std::shared_ptr<const DiscreteFunctionVariant>>& discrete_function_variant_list)
{
  PolynomialReconstructionDescriptor descriptor{1};
  {
    std::cout << "** variable list one by one (50 times)\n";
    Timer t;
    for (auto discrete_function_v : discrete_function_variant_list) {
      std::visit(
        [&](auto&& discrete_function) {
          auto mesh_v = discrete_function.meshVariant();
          std::visit(
            [&](auto&& p_mesh) {
              using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
              PolynomialReconstruction reconstruction{descriptor};
              if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
                for (size_t i = 0; i < 50; ++i) {
                  auto res = reconstruction.build(*p_mesh, discrete_function);
                }
              } else if constexpr (is_discrete_function_P0_vector_v<DiscreteFunctionT>) {
                std::cout << "Omitting discrete function p0 vector!\n";
              }
            },
            mesh_v->variant());
        },
        discrete_function_v->discreteFunction());
    }
    t.pause();
    std::cout << "t = " << t << '\n';
  }

  {
    std::cout << "** variable list at once (50 times)\n";

    PolynomialReconstruction reconstruction{descriptor};
    Timer t;
    for (size_t i = 0; i < 50; ++i) {
      auto res = reconstruction.build(discrete_function_variant_list);
    }
    t.pause();
    std::cout << "t = " << t << '\n';
  }

  std::cout << "finished!\n";
}