quantumkleinmassscan2d.cpp

Go to the documentation of this file.

/**
 * @file quantumkleinmassscan2d.cpp
 * @brief Implements the quantumkleinmassscan2d physics/numerical component used by QPE experiments.
 * @ingroup qpe_quantum
 *
 * Source: @c core/quantum/quantumkleinmassscan2d.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 "quantumkleinmassscan2d.h"
 
#include "core/quantum/quantumkleinanglescan2d.h"
 
#include <algorithm>
#include <cmath>
 
namespace qpe {
namespace {
 
constexpr double kPi = 3.141592653589793238462643383279502884;
/**
 * @brief Performs finite.
 * @param x X coordinate/value.
 */
bool finite(double x) noexcept { return std::isfinite(x); }
 
} // namespace
 
QuantumKleinMassPoint2D QuantumKleinMassScan2D::evaluate(
    const QuantumKleinTunneling2DConfig &baseConfig, double restMass, double hbar) noexcept
{
    QuantumKleinMassPoint2D out;
    out.restMass = restMass;
 
    if (!QuantumKleinTunneling2D::validateConfig(baseConfig, nullptr) ||
        !finite(restMass) || restMass <= 0.0 ||
        !finite(hbar) || hbar <= 0.0) {
        return out;
    }
 
    const double c = baseConfig.lightSpeed;
    const double cc = c * c;
    const double e = QuantumKleinTunneling2D::incidentEnergy(baseConfig);
    const double rest = restMass * cc;
    if (!(rest < e)) return out;
 
    const double momentumSquared = (e * e - rest * rest) / cc;
    if (!(momentumSquared > 0.0) || !finite(momentumSquared)) return out;
 
    const double p = std::sqrt(momentumSquared);
    const double angleDegrees = QuantumKleinTunneling2D::incidenceAngleDegrees(baseConfig);
    const double theta = angleDegrees * kPi / 180.0;
 
    QuantumKleinTunneling2DConfig cMass = baseConfig;
    cMass.restMass = restMass;
    cMass.momentumX = p * std::cos(theta);
    cMass.momentumY = p * std::sin(theta);
    if (!QuantumKleinTunneling2D::validateConfig(cMass, nullptr)) return out;
 
    const QuantumKleinAnglePoint2D reference =
        QuantumKleinAngleScan2D::evaluate(cMass, std::abs(angleDegrees), hbar);
    if (!reference.valid) return out;
 
    out.restEnergy = rest;
    out.gapEnergy = 2.0 * rest;
    out.momentumMagnitude = p;
    out.transmission = reference.transmission;
    out.reflection = reference.reflection;
    out.interiorLongitudinalMomentumSquared = reference.interiorLongitudinalMomentumSquared;
    out.regime = reference.regime;
    out.valid = true;
    return out;
}
 
QuantumKleinMassScan2DResult QuantumKleinMassScan2D::scan(
    const QuantumKleinTunneling2DConfig &baseConfig,
    double minimumRestMass, double maximumRestMass,
    int samples, double hbar) noexcept
{
    QuantumKleinMassScan2DResult out;
    if (!QuantumKleinTunneling2D::validateConfig(baseConfig, nullptr) ||
        !finite(minimumRestMass) || !finite(maximumRestMass) ||
        minimumRestMass <= 0.0 || maximumRestMass <= minimumRestMass ||
        samples < 2 || samples > 2001 || !finite(hbar) || hbar <= 0.0) {
        return out;
    }
 
    const double c = baseConfig.lightSpeed;
    const double cc = c * c;
    const double e = QuantumKleinTunneling2D::incidentEnergy(baseConfig);
    const double kinematicLimit = e / cc;
    if (!(maximumRestMass < kinematicLimit)) return out;
 
    out.hbar = hbar;
    out.fixedIncidentEnergy = e;
    out.incidenceAngleDegrees = QuantumKleinTunneling2D::incidenceAngleDegrees(baseConfig);
    out.barrierHeight = baseConfig.barrierHeight;
    out.barrierWidth = baseConfig.barrierWidth;
    out.minimumRestMass = minimumRestMass;
    out.maximumRestMass = maximumRestMass;
    out.kinematicMassLimit = kinematicLimit;
    out.normalIncidenceRegimeThresholdMass = std::abs(baseConfig.barrierHeight - e) / cc;
    out.points.reserve(static_cast<std::size_t>(samples));
 
    int validCount = 0;
    for (int i = 0; i < samples; ++i) {
        const double f = static_cast<double>(i) / static_cast<double>(samples - 1);
        const double mass = minimumRestMass + f * (maximumRestMass - minimumRestMass);
        const QuantumKleinMassPoint2D point = evaluate(baseConfig, mass, hbar);
        if (point.valid) ++validCount;
        out.points.push_back(point);
    }
 
    // A singular matching point can occur exactly at the propagation/evanescent
    // boundary. One or two isolated misses must not invalidate the whole scan.
    out.valid = validCount >= samples - 2 &&
        out.points.size() == static_cast<std::size_t>(samples);
    return out;
}
 
} // namespace qpe