//
// Created by jholder on 24.10.21.
//
#include <catch2/catch.hpp>
#include <Integratoren2d_forceless.h>
#include <Calculation.h>
#include <Compute.h>
#include <Integratoren2d_force.h>

TEST_CASE("Integratoren") {
    auto zero_Force = [](const Eigen::Vector2d &  /*pos*/,
                         const Eigen::Vector2d &  /*torque*/) -> Eigen::Vector2d { return {0.0, 0.0}; };
    auto zero_Torque = [](const Eigen::Vector2d &  /*pos*/,
                          const Eigen::Vector2d &  /*torque*/) -> double { return 0.0; };
    auto euler_Zero = [&](Rod2d &rod, Simulation &sim) {
        return Integratoren2d_force::Set1_Euler(rod, sim, zero_Force, zero_Torque);
    };
    auto heun_Zero = [&](Rod2d &rod, Simulation &sim) {
        return Integratoren2d_force::Set2_Heun(rod, sim, zero_Force, zero_Torque);
    };
    auto exact_Zero = [&](Rod2d &rod, Simulation &sim) {
        return Integratoren2d_force::Set3_Exact(rod, sim, zero_Force, zero_Torque);
    };
    auto bdas_Zero = [&](Rod2d &rod, Simulation &sim) {
        return Integratoren2d_force::Set4_BDAS(rod, sim, zero_Force, zero_Torque);
    };
    SECTION("Euler") {
        Calculation euler(Integratoren2d_forceless::Set1_Euler, {{Compute::Type::msd, 1},
                                                                 {Compute::Type::oaf, 1}}, 0.01, 12345);
        euler.run(10000);
        for (auto &c: euler.getComputes()) { CHECK(c.getDifference() <= 0.005); }
        Calculation euler_force(euler_Zero, {{Compute::Type::msd, 1},
                                             {Compute::Type::oaf, 1}}, 0.01, 12345);
        euler_force.run(10000);
        for (auto &c: euler_force.getComputes()) { CHECK(c.getDifference() <= 0.005); }
    }SECTION("Heun") {
        {
            Calculation heun(Integratoren2d_forceless::Set2_Heun, {{Compute::Type::msd, 1},
                                                                   {Compute::Type::oaf, 1}}, 0.01, 12345);
            heun.run(10000);
            for (auto &c: heun.getComputes()) { CHECK(c.getDifference() <= 0.005); }
        }
        {
            Calculation heun_force(heun_Zero, {{Compute::Type::msd, 1},
                                               {Compute::Type::oaf, 1}}, 0.01, 12345);
            heun_force.run(10000);
            for (auto &c: heun_force.getComputes()) { CHECK(c.getDifference() <= 0.005); }
        }
    }SECTION("Exact") {
        {
            Calculation exact(Integratoren2d_forceless::Set3_Exact, {{Compute::Type::msd, 1},
                                                                     {Compute::Type::oaf, 1}}, 0.01, 12345);
            exact.run(10000);
            for (auto &c: exact.getComputes()) { CHECK(c.getDifference() <= 0.005); }
        }
        {
            Calculation exact_force(exact_Zero, {{Compute::Type::msd, 1},
                                                 {Compute::Type::oaf, 1}}, 0.01, 12345);
            exact_force.run(10000);
            for (auto &c: exact_force.getComputes()) { CHECK(c.getDifference() <= 0.005); }
        }
    }SECTION("BDAS") {
        {
            Calculation bdas(Integratoren2d_forceless::Set4_BDAS, {{Compute::Type::msd, 1},
                                                                   {Compute::Type::oaf, 1}}, 0.01, 12345);
            bdas.run(10000);
            for (auto &c: bdas.getComputes()) { CHECK(c.getDifference() <= 0.005); }
        }
        {
            Calculation bdas_zero(bdas_Zero, {{Compute::Type::msd, 1},
                                              {Compute::Type::oaf, 1}}, 0.01, 12345);
            bdas_zero.run(10000);
            for (auto &c: bdas_zero.getComputes()) { CHECK(c.getDifference() <= 0.005); }
        }
    }
}