TestPDESolver.cpp

#include "montecarlo/PDESolver.hpp"
#include "TestEnvironment.hpp"


constexpr double PDESOLVER_TEST_TOLERANCE = 1e-5;

struct TestParams {
    std::string model;
    std::string problem;
    std::string quantity;
    double Q;
};

class TestPDESolver : public TestWithParam<TestParams> {
protected:
    Meshes *meshes;

    PDESolver *pdeSolver;

    MatrixGraphs *mGraphs;

    SampleID dummyID;

    void SetUp() override {
        dummyID.level = Level(6, 0);
        dummyID.coarse = false;
        dummyID.number = -1;

        if (GetParam().problem.find("1D") != std::string::npos)
            meshes = createTestMeshes("Interval_DirichletBC",
                                      dummyID.level.pLevel,
                                      dummyID.level.fine);

        if (GetParam().problem.find("2D") != std::string::npos)
            meshes = createTestMeshes("Square_DirichletBC",
                                      dummyID.level.pLevel,
                                      dummyID.level.fine);


        pdeSolver = PDESolverCreator(*meshes).
            WithModel(GetParam().model).
            WithProblem(GetParam().problem).Create();
        pdeSolver->SetQuantity(GetParam().quantity);
        mGraphs = pdeSolver->CreateSolutionMatrixGraph(*meshes);
    }

    void TearDown() override {
        delete mGraphs;
        delete pdeSolver;
        delete meshes;
    }
};

class TestLaplace1D : public TestPDESolver {};

INSTANTIATE_TEST_CASE_P(TestPDESolver, TestLaplace1D, Values(
    TestParams{"LagrangeElliptic", "Laplace1D", "L2Error", 0.0},
//    TestParams{"LagrangeElliptic", "Laplace1D", "EnergyError", 0.0},
    TestParams{"LagrangeElliptic", "Laplace1D", "FluxError", 0.0},
    TestParams{"LagrangeElliptic", "Laplace1D", "Inflow", -1.0},
    TestParams{"LagrangeElliptic", "Laplace1D", "Outflow", 1.0},

    TestParams{"MixedElliptic", "Laplace1D", "L2CellAverageError", 0.0},
//    TestParams{"MixedElliptic", "Laplace1D", "EnergyError", 0.0},
    TestParams{"MixedElliptic", "Laplace1D", "FluxError", 0.0},
    TestParams{"MixedElliptic", "Laplace1D", "Inflow", -1.0},
    TestParams{"MixedElliptic", "Laplace1D", "Outflow", 1.0}

//    TestParams{"HybridElliptic", "Laplace1D", "L2CellAverageError", 0.0},
//    TestParams{"HybridElliptic", "Laplace1D", "Inflow", -1.0},
//    TestParams{"HybridElliptic", "Laplace1D", "Outflow", 1.0},
//    TestParams{"HybridElliptic", "Laplace1D", "EnergyError", 0.0},
//    TestParams{"HybridElliptic", "Laplace1D", "FluxError", 0.0},
));

TEST_P(TestLaplace1D, TestRun) {
    SampleSolution solution(*mGraphs, dummyID);
    pdeSolver->Run(solution);
    ASSERT_NEAR(solution.Q, GetParam().Q, PDESOLVER_TEST_TOLERANCE);
}

class TestLaplace2D : public TestPDESolver {};

INSTANTIATE_TEST_CASE_P(TestPDESolver, TestLaplace2D, Values(
    TestParams{"LagrangeElliptic", "Laplace2D", "L2Error", 0.0},
    TestParams{"LagrangeElliptic", "Laplace2D", "EnergyError", 0.0},
    TestParams{"LagrangeElliptic", "Laplace2D", "FluxError", 0.0},
    TestParams{"LagrangeElliptic", "Laplace2D", "Inflow", -1.0},
    TestParams{"LagrangeElliptic", "Laplace2D", "Outflow", 1.0},

    TestParams{"MixedElliptic", "Laplace2D", "L2CellAverageError", 0.0},
    TestParams{"MixedElliptic", "Laplace2D", "EnergyError", 0.0},
    TestParams{"MixedElliptic", "Laplace2D", "FluxError", 0.0},
    TestParams{"MixedElliptic", "Laplace2D", "Inflow", -1.0},
    TestParams{"MixedElliptic", "Laplace2D", "Outflow", 1.0},

//    TestParams{"HybridElliptic", "Laplace2D", "L2CellAverageError", 0.0},
//    TestParams{"HybridElliptic", "Laplace2D", "EnergyError", 0.0},
//    TestParams{"HybridElliptic", "Laplace2D", "FluxError", 0.0},
//    TestParams{"HybridElliptic", "Laplace2D", "Inflow", -1.0},
//    TestParams{"HybridElliptic", "Laplace2D", "Outflow", 1.0},

    TestParams{"DGElliptic", "Laplace2D", "L2Error", 0.0},
    TestParams{"DGElliptic", "Laplace2D", "EnergyError", 0.0},
    TestParams{"DGElliptic", "Laplace2D", "FluxError", 0.0},
    TestParams{"DGElliptic", "Laplace2D", "Inflow", -1.0},
    TestParams{"DGElliptic", "Laplace2D", "Outflow", 1.0}
));

TEST_P(TestLaplace2D, TestRun) {
    SampleSolution solution(*mGraphs, dummyID);
    pdeSolver->Run(solution);
    ASSERT_NEAR(solution.Q, GetParam().Q, PDESOLVER_TEST_TOLERANCE);
}

class TestGaussHat : public TestPDESolver {};

INSTANTIATE_TEST_CASE_P(TestPDESolver, TestGaussHat, Values(
    TestParams{"DGTransport", "GaussHat2D", "Mass", 1.0}
));

TEST_P(TestGaussHat, TestRun) {
    SampleSolution solution(*mGraphs, dummyID);
    pdeSolver->Run(solution);
    ASSERT_NEAR(solution.Q, GetParam().Q, PDESOLVER_TEST_TOLERANCE);
// Todo    ASSERT_NEAR(solution.Cost, GetParam().Cost, PDESOLVER_TEST_TOLERANCE);
}

int main(int argc, char **argv) {
    MppTest mppTest = MppTestBuilder(argc, argv).WithPPM().WithScreenLogging();
    return mppTest.RUN_ALL_MPP_TESTS();
}