quantumkleinheightscan2d_tests.cpp

Go to the documentation of this file.

/**
 * @file quantumkleinheightscan2d_tests.cpp
 * @brief Implements regression and invariant tests for quantumkleinheightscan2d tests.
 * @ingroup qpe_tests
 *
 * Source: @c tests/quantumkleinheightscan2d_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 "tests/quantumkleinheightscan2d_tests.h"
#include "core/quantum/quantumkleinheightscan2d.h"
 
#include <cmath>
 
namespace qpe { namespace tests {
 
/**
 * @brief Runs quantum klein height scan2 d tests.
 * @param errorMessage The error message value used by the operation.
 */
bool runQuantumKleinHeightScan2DTests(std::string &errorMessage)
{
    QuantumKleinTunneling2DConfig c;
    c.enabled = true;
    c.lightSpeed = 1.0;
    c.restMass = 0.05;
    c.centerX = -10.0;
    c.centerY = 0.0;
    c.sigma = 2.2;
    c.momentumX = 1.5;
    c.momentumY = 0.0;
    c.barrierCenterX = 0.0;
    c.barrierWidth = 3.0;
    c.barrierHeight = 3.2;
    c.detectorX = 6.0;
    c.analysisEndTime = 18.0;
 
    const QuantumKleinHeightPoint2D zero = QuantumKleinHeightScan2D::evaluate(c, 0.0, 1.0);
    if (!zero.valid || std::fabs(zero.transmission - 1.0) > 1.0e-12 ||
        std::fabs(zero.reflection) > 1.0e-12 ||
        zero.regime != QuantumKleinBarrierRegime2D::PositiveBranchPropagation) {
        errorMessage = "Klein height scan zero-barrier reference failed";
        return false;
    }
 
    const double lower = QuantumKleinTunneling2D::normalIncidenceLowerThreshold(c);
    const double upper = QuantumKleinTunneling2D::normalIncidenceUpperThreshold(c);
    const QuantumKleinHeightPoint2D subcritical = QuantumKleinHeightScan2D::evaluate(c, lower - 0.15, 1.0);
    const QuantumKleinHeightPoint2D evanescent = QuantumKleinHeightScan2D::evaluate(c, 0.5 * (lower + upper), 1.0);
    const QuantumKleinHeightPoint2D supercritical = QuantumKleinHeightScan2D::evaluate(c, 3.2, 1.0);
    if (!subcritical.valid || !evanescent.valid || !supercritical.valid ||
        subcritical.regime != QuantumKleinBarrierRegime2D::PositiveBranchPropagation ||
        evanescent.regime != QuantumKleinBarrierRegime2D::EvanescentGap ||
        supercritical.regime != QuantumKleinBarrierRegime2D::SupercriticalKlein) {
        errorMessage = "Klein height scan regime classification failed";
        return false;
    }
 
    const QuantumKleinHeightScan2DResult scan = QuantumKleinHeightScan2D::scan(c, 0.0, 4.0, 241, 1.0);
    if (!scan.valid || scan.points.size() != 241u ||
        std::fabs(scan.incidentEnergy - QuantumKleinTunneling2D::incidentEnergy(c)) > 1.0e-12 ||
        std::fabs(scan.lowerThreshold - lower) > 1.0e-12 ||
        std::fabs(scan.upperThreshold - upper) > 1.0e-12) {
        errorMessage = "Klein height scan result metadata failed";
        return false;
    }
 
    int conservationCount = 0;
    for (const QuantumKleinHeightPoint2D &point : scan.points) {
        if (!point.valid) continue;
        if (point.transmission < -1.0e-12 || point.transmission > 1.0 + 1.0e-12 ||
            point.reflection < -1.0e-12 || point.reflection > 1.0 + 1.0e-12 ||
            std::fabs(point.transmission + point.reflection - 1.0) > 2.0e-8) {
            errorMessage = "Klein height scan probability conservation failed";
            return false;
        }
        ++conservationCount;
    }
    if (conservationCount < 239) {
        errorMessage = "Klein height scan has too many invalid points";
        return false;
    }
 
    errorMessage.clear();
    return true;
}
 
} } // namespace qpe::tests