quantumkleintunneling2d_tests.cpp

Go to the documentation of this file.

/**
 * @file quantumkleintunneling2d_tests.cpp
 * @brief Implements regression and invariant tests for quantumkleintunneling2d tests.
 * @ingroup qpe_tests
 *
 * Source: @c tests/quantumkleintunneling2d_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 "core/quantum/quantumkleintunneling2d.h"
#include "core/quantum/diracsplitstepsolver2d.h"
#include "core/quantum/potentialfield2d.h"
 
#include <cmath>
#include <iostream>
#include <string>
 
namespace qpe { namespace tests {
 
/**
 * @brief Runs quantum klein tunneling2 d tests.
 * @param errorMessage The error message value used by the operation.
 */
bool runQuantumKleinTunneling2DTests(std::string &errorMessage)
{
    QuantumKleinTunneling2DConfig c;
    c.enabled = true;
    DiracSpinor2D s(128, 128, 0.16f, 0.16f);
    std::string why;
    if (!QuantumKleinTunneling2D::prepareIncidentState(s, c, 1.0, &why)) {
        errorMessage = why; return false;
    }
    if (std::abs(s.norm2()-1.0) > 2.0e-5) {
        errorMessage = "Klein incident state is not normalized"; return false;
    }
    QuantumKleinTunneling2DConfig masslessConfig = c;
    masslessConfig.restMass = 0.0;
    DiracSpinor2D masslessState(128, 128, 0.16f, 0.16f);
    if (!QuantumKleinTunneling2D::prepareIncidentState(masslessState, masslessConfig, 1.0, &why) ||
        !std::isfinite(masslessState.norm2()) || std::abs(masslessState.norm2()-1.0) > 2.0e-5) {
        errorMessage = "exact massless Klein incident state is invalid"; return false;
    }
    PotentialField2D p(128,128,0.16f,0.16f);
    if (!QuantumKleinTunneling2D::rasterizeBarrier(p,c,&why) || p.maximum() < 3.19f) {
        errorMessage = "Klein barrier rasterization failed"; return false;
    }
    if (!QuantumKleinTunneling2D::inKleinZone(c)) {
        errorMessage = "default Klein preset is not in the Klein zone"; return false;
    }
    if (std::abs(QuantumKleinTunneling2D::incidentMomentumMagnitude(c) - 1.5) > 1.0e-12 ||
        QuantumKleinTunneling2D::classifyBarrierRegime(c) != QuantumKleinBarrierRegime2D::SupercriticalKlein) {
        errorMessage = "Klein momentum/regime helper regression"; return false;
    }
    QuantumKleinTunneling2DConfig gap = c;
    gap.barrierHeight = QuantumKleinTunneling2D::incidentEnergy(gap);
    if (QuantumKleinTunneling2D::classifyBarrierRegime(gap) != QuantumKleinBarrierRegime2D::EvanescentGap) {
        errorMessage = "Klein evanescent-regime classifier regression"; return false;
    }
    QuantumKleinTunneling2DConfig low = c;
    low.barrierHeight = 0.5;
    if (QuantumKleinTunneling2D::classifyBarrierRegime(low) != QuantumKleinBarrierRegime2D::PositiveBranchPropagation) {
        errorMessage = "Klein positive-branch classifier regression"; return false;
    }
    const QuantumKleinTunnelingSample2D a = QuantumKleinTunneling2D::measure(s,c,0.0);
    if (!(a.leftProbability > 0.95) || std::abs(a.norm-1.0) > 2.0e-5) {
        errorMessage = "Klein initial partition is invalid"; return false;
    }
    DiracSplitStep2DParams dp; dp.hbar=1.0f; dp.dt=0.02f; dp.lightSpeed=1.0f; dp.restMass=0.05f;
    DiracSplitStepSolver2D solver(dp);
    for (int i=0;i<20;++i) solver.step(s,p);
    if (std::abs(s.norm2()-1.0) > 2.0e-4) {
        errorMessage = "Dirac scalar-barrier step lost norm"; return false;
    }
    DiracSplitStep2DParams dp0=dp; dp0.restMass=0.0f;
    DiracSplitStepSolver2D masslessSolver(dp0);
    for (int i=0;i<20;++i) masslessSolver.step(masslessState,p);
    if (!std::isfinite(masslessState.norm2()) || std::abs(masslessState.norm2()-1.0) > 2.0e-4) {
        errorMessage = "massless Dirac scalar-barrier step lost norm"; return false;
    }
    std::cout << "QuantumKleinTunneling2D tests OK\n";
    return true;
}
 
} } // namespace qpe::tests