potentialfield2d_tests.cpp

Go to the documentation of this file.

/**
 * @file potentialfield2d_tests.cpp
 * @brief Implements regression and invariant tests for potentialfield2d tests.
 * @ingroup qpe_tests
 *
 * Source: @c tests/potentialfield2d_tests.cpp. This file is part of Quantum Phenomena Explorer (QPE),
 * maintained by Officina Turini. See LICENSE_IT.txt / LICENSE.txt for the
 * QPE freeware source-available terms and THIRD_PARTY_NOTICES.txt for
 * third-party components.
 */
 
#include "potentialfield2d_tests.h"
 
#include "core/math/complexfield2d.h"
#include "core/quantum/potentialfield2d.h"
 
#include <cmath>
#include <stdexcept>
#include <vector>
 
namespace qpe {
namespace tests {
namespace {
 
/**
 * @brief Performs fail.
 * @param errorMessage The error message value used by the operation.
 * @param message The message value used by the operation.
 */
bool fail(std::string &errorMessage, const char *message)
{
    errorMessage = message;
    return false;
}
 
std::size_t nearestIndexX(const PotentialField2D &p, double x)
{
    std::size_t best = 0;
    double bestD = 1.0e30;
    for (std::size_t i = 0; i < p.width(); ++i) {
        const double d = std::abs(p.xCoordinate(i) - x);
        if (d < bestD) {
            bestD = d;
            best = i;
        }
    }
    return best;
}
 
std::size_t nearestIndexY(const PotentialField2D &p, double y)
{
    std::size_t best = 0;
    double bestD = 1.0e30;
    for (std::size_t i = 0; i < p.height(); ++i) {
        const double d = std::abs(p.yCoordinate(i) - y);
        if (d < bestD) {
            bestD = d;
            best = i;
        }
    }
    return best;
}
 
/**
 * @brief Samples is.
 * @param p The p value used by the operation.
 * @param x X coordinate/value.
 * @param y Y coordinate/value.
 * @param expected The expected value used by the operation.
 */
bool sampleIs(const PotentialField2D &p, double x, double y, float expected)
{
    return std::abs(p(nearestIndexX(p, x), nearestIndexY(p, y)) - expected) < 1.0e-6f;
}
 
} // namespace
 
/**
 * @brief Runs potential field2 d tests.
 * @param errorMessage The error message value used by the operation.
 */
bool runPotentialField2DTests(std::string &errorMessage)
{
    errorMessage.clear();
 
    try {
        bool rejected = false;
        try {
            PotentialField2D invalid(8, 8, 0.0f, 1.0f);
        } catch (const std::invalid_argument &) {
            rejected = true;
        }
        if (!rejected) {
            return fail(errorMessage, "invalid spatial step was not rejected");
        }
 
        PotentialField2D potential(8, 4, 0.2f, 0.3f);
        if (potential.width() != 8 || potential.height() != 4 ||
            potential.size() != 32 || potential.empty()) {
            return fail(errorMessage, "potential dimensions are incorrect");
        }
        if (potential.minimum() != 0.0f || potential.maximum() != 0.0f) {
            return fail(errorMessage, "new potential is not zero initialized");
        }
 
        const std::uint64_t revision0 = potential.revision();
        potential.set(2, 1, 4.5f);
        if (std::abs(potential(2, 1) - 4.5f) > 1.0e-6f ||
            potential.revision() == revision0) {
            return fail(errorMessage, "set/revision failed");
        }
        if (potential.maximum() != 4.5f) {
            return fail(errorMessage, "potential maximum is incorrect");
        }
 
        potential.fill(-2.0f);
        if (potential.minimum() != -2.0f || potential.maximum() != -2.0f) {
            return fail(errorMessage, "fill/minimum/maximum failed");
        }
 
        potential.clear();
        if (potential.minimum() != 0.0f || potential.maximum() != 0.0f) {
            return fail(errorMessage, "clear failed");
        }
 
        bool boundsRejected = false;
        try {
            potential.setAt(99, 0, 1.0f);
        } catch (const std::out_of_range &) {
            boundsRejected = true;
        }
        if (!boundsRejected) {
            return fail(errorMessage, "out-of-range access was not rejected");
        }
 
        ComplexField2D matching(8, 4, 0.2f, 0.3f);
        ComplexField2D different(8, 4, 0.25f, 0.3f);
        if (!potential.matchesGrid(matching) || potential.matchesGrid(different)) {
            return fail(errorMessage, "grid compatibility check failed");
        }
 
        // Geometry tests use an odd grid so (0,0) is an exact sample.
        PotentialField2D g(101, 101, 0.1f, 0.1f);
        const std::size_t cx = nearestIndexX(g, 0.0);
        const std::size_t cy = nearestIndexY(g, 0.0);
        if (std::abs(g.xCoordinate(cx)) > 1.0e-9 || std::abs(g.yCoordinate(cy)) > 1.0e-9) {
            return fail(errorMessage, "physical coordinate mapping is incorrect");
        }
 
        std::uint64_t r = g.revision();
        g.addRectangle(0.0f, 0.0f, 2.0f, 1.0f, 3.0f);
        if (g.revision() != r + 1 || !sampleIs(g, 0.0, 0.0, 3.0f) ||
            !sampleIs(g, 0.9, 0.4, 3.0f) || !sampleIs(g, 1.4, 0.0, 0.0f)) {
            return fail(errorMessage, "rectangle primitive failed");
        }
 
        g.clear();
        r = g.revision();
        g.addCircle(0.0f, 0.0f, 1.0f, 4.0f);
        if (g.revision() != r + 1 || !sampleIs(g, 0.0, 0.0, 4.0f) ||
            !sampleIs(g, 0.7, 0.7, 4.0f) || !sampleIs(g, 1.2, 0.0, 0.0f)) {
            return fail(errorMessage, "circle primitive failed");
        }
 
        g.clear();
        g.addBarrier(-2.0f, -2.0f, 2.0f, 2.0f, 0.4f, 5.0f);
        if (!sampleIs(g, 0.0, 0.0, 5.0f) || !sampleIs(g, 0.0, 1.0, 0.0f)) {
            return fail(errorMessage, "barrier primitive failed");
        }
 
        g.clear();
        const std::vector<PotentialPoint2D> triangle = {
            {-1.0f, -1.0f}, {1.0f, -1.0f}, {0.0f, 1.0f}
        };
        g.addPolygon(triangle, 6.0f);
        if (!sampleIs(g, 0.0, 0.0, 6.0f) || !sampleIs(g, 1.5, 0.0, 0.0f)) {
            return fail(errorMessage, "polygon primitive failed");
        }
 
        g.clear();
        g.addSingleSlit(0.0f, 0.4f, 0.0f, 1.0f, 7.0f);
        if (!sampleIs(g, 0.0, 0.0, 0.0f) || !sampleIs(g, 0.0, 1.0, 7.0f) ||
            !sampleIs(g, 1.0, 1.0, 0.0f)) {
            return fail(errorMessage, "single slit primitive failed");
        }
 
        g.clear();
        g.addDoubleSlit(0.0f, 0.4f, 0.0f, 2.0f, 0.6f, 8.0f);
        if (!sampleIs(g, 0.0, -1.0, 0.0f) || !sampleIs(g, 0.0, 1.0, 0.0f) ||
            !sampleIs(g, 0.0, 0.0, 8.0f) || !sampleIs(g, 0.0, 2.0, 8.0f)) {
            return fail(errorMessage, "double slit primitive failed");
        }
 
        g.clear();
        g.addGaussian(0.0f, 0.0f, 1.0f, 2.0f, -4.0f);
        if (!sampleIs(g, 0.0, 0.0, -4.0f) ||
            std::abs(g(nearestIndexX(g, 1.0), nearestIndexY(g, 0.0)) -
                     static_cast<float>(-4.0 * std::exp(-0.5))) > 2.0e-3f) {
            return fail(errorMessage, "Gaussian potential failed");
        }
 
        g.clear();
        g.addHarmonic(0.0f, 0.0f, 1.0f, 2.0f, 4.0f);
        if (!sampleIs(g, 0.0, 0.0, 1.0f) ||
            std::abs(g(nearestIndexX(g, 1.0), nearestIndexY(g, 0.0)) - 2.0f) > 1.0e-5f ||
            std::abs(g(nearestIndexX(g, 0.0), nearestIndexY(g, 1.0)) - 3.0f) > 1.0e-5f) {
            return fail(errorMessage, "harmonic potential failed");
        }
 
        g.clear();
        g.addLinear(0.0f, 0.0f, 0.5f, 2.0f, -1.0f);
        if (!sampleIs(g, 0.0, 0.0, 0.5f) ||
            std::abs(g(nearestIndexX(g, 1.0), nearestIndexY(g, 1.0)) - 1.5f) > 1.0e-5f) {
            return fail(errorMessage, "linear potential failed");
        }
 
        g.clear();
        g.addSoftenedRadial(0.0f, 0.0f, -3.0f, 0.5f);
        if (std::abs(g(nearestIndexX(g, 0.0), nearestIndexY(g, 0.0)) + 6.0f) > 1.0e-5f ||
            !(g(nearestIndexX(g, 2.0), nearestIndexY(g, 0.0)) > -2.0f)) {
            return fail(errorMessage, "softened radial potential failed");
        }
 
        bool smoothRejected = false;
        try {
            g.addGaussian(0.0f, 0.0f, 0.0f, 1.0f, 1.0f);
        } catch (const std::invalid_argument &) {
            smoothRejected = true;
        }
        if (!smoothRejected) {
            return fail(errorMessage, "invalid smooth-potential dimensions were not rejected");
        }
 
        bool geometryRejected = false;
        try {
            g.addCircle(0.0f, 0.0f, -1.0f, 1.0f);
        } catch (const std::invalid_argument &) {
            geometryRejected = true;
        }
        if (!geometryRejected) {
            return fail(errorMessage, "invalid geometry dimensions were not rejected");
        }
    } catch (const std::exception &e) {
        errorMessage = e.what();
        return false;
    }
 
    return true;
}
 
} // namespace tests
} // namespace qpe