quantumkleinheightscanplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumkleinheightscanplotwidget.cpp
 * @brief Implements the quantumkleinheightscanplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumkleinheightscanplotwidget.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 "quantumkleinheightscanplotwidget.h"
 
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
 
#include <algorithm>
#include <cmath>
 
QuantumKleinHeightScanPlotWidget::QuantumKleinHeightScanPlotWidget(QWidget *parent)
    : QWidget(parent)
{
}
 
void QuantumKleinHeightScanPlotWidget::setData(const qpe::QuantumKleinHeightScan2DResult &scan,
                                                double currentBarrierHeight,
                                                double packetTransmission)
{
    scan_ = scan;
    currentBarrierHeight_ = currentBarrierHeight;
    packetTransmission_ = packetTransmission;
    update();
}
 
void QuantumKleinHeightScanPlotWidget::clear()
{
    scan_ = qpe::QuantumKleinHeightScan2DResult();
    packetTransmission_ = -1.0;
    update();
}
 
QSize QuantumKleinHeightScanPlotWidget::minimumSizeHint() const
{
    return QSize(690, 450);
}
 
void QuantumKleinHeightScanPlotWidget::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    QPainter p(this);
    p.setRenderHint(QPainter::Antialiasing, true);
    p.fillRect(rect(), QColor(9, 13, 19));
 
    QFont titleFont = font();
    titleFont.setBold(true);
    p.setFont(titleFont);
    p.setPen(QColor(230, 238, 246));
    p.drawText(QRect(12, 6, width() - 24, 25), Qt::AlignLeft | Qt::AlignVCenter,
               QStringLiteral("Klein barrier-height reference — stationary plane-wave T(V0)"));
 
    if (!scan_.valid || scan_.points.empty()) {
        p.setFont(font());
        p.setPen(QColor(145, 162, 178));
        p.drawText(QRect(20, 45, width() - 40, height() - 65),
                   Qt::AlignCenter | Qt::TextWordWrap,
                   QStringLiteral("Load the Klein Transmission vs Barrier Height preset."));
        return;
    }
 
    const int left = 64, right = 24, top = 48, bottom = 58;
    QRect plot(left, top, std::max(120, width() - left - right),
               std::max(120, height() - top - bottom));
    p.setBrush(QColor(5, 9, 15));
    p.setPen(QColor(54, 72, 88));
    p.drawRect(plot);
 
    const double vmin = scan_.minimumBarrierHeight;
    const double vmax = scan_.maximumBarrierHeight;
    const auto xOf = [&](double v) {
        return plot.left() + (v - vmin) / std::max(1.0e-12, vmax - vmin) * plot.width();
    };
    const auto yOf = [&](double transmission) {
        return plot.bottom() - std::max(0.0, std::min(1.0, transmission)) * plot.height();
    };
 
    // Regime bands. These are explanatory overlays only; the curve itself is
    // calculated from spinor matching and does not depend on the renderer.
    const double low = std::max(vmin, std::min(vmax, scan_.lowerThreshold));
    const double high = std::max(vmin, std::min(vmax, scan_.upperThreshold));
    if (low > vmin)
        p.fillRect(QRectF(xOf(vmin), plot.top(), xOf(low) - xOf(vmin), plot.height()), QColor(40, 85, 60, 45));
    if (high > low)
        p.fillRect(QRectF(xOf(low), plot.top(), xOf(high) - xOf(low), plot.height()), QColor(120, 85, 35, 55));
    if (vmax > high)
        p.fillRect(QRectF(xOf(high), plot.top(), xOf(vmax) - xOf(high), plot.height()), QColor(45, 70, 120, 45));
 
    p.setFont(font());
    p.setPen(QColor(77, 94, 109));
    for (int i = 0; i <= 5; ++i) {
        const double t = static_cast<double>(i) / 5.0;
        const int y = static_cast<int>(std::lround(yOf(t)));
        p.drawLine(plot.left(), y, plot.right(), y);
        p.setPen(QColor(170, 184, 197));
        p.drawText(QRect(7, y - 9, 50, 18), Qt::AlignRight | Qt::AlignVCenter,
                   QString::number(t, 'f', 1));
        p.setPen(QColor(77, 94, 109));
    }
 
    for (int i = 0; i <= 8; ++i) {
        const double v = vmin + (vmax - vmin) * static_cast<double>(i) / 8.0;
        const int x = static_cast<int>(std::lround(xOf(v)));
        p.drawLine(x, plot.top(), x, plot.bottom());
        p.setPen(QColor(170, 184, 197));
        p.drawText(QRect(x - 24, plot.bottom() + 5, 48, 20), Qt::AlignHCenter | Qt::AlignTop,
                   QString::number(v, 'f', 1));
        p.setPen(QColor(77, 94, 109));
    }
 
    if (scan_.lowerThreshold >= vmin && scan_.lowerThreshold <= vmax) {
        const int x = static_cast<int>(std::lround(xOf(scan_.lowerThreshold)));
        p.setPen(QPen(QColor(255, 205, 95), 1.4, Qt::DashLine));
        p.drawLine(x, plot.top(), x, plot.bottom());
    }
    if (scan_.upperThreshold >= vmin && scan_.upperThreshold <= vmax) {
        const int x = static_cast<int>(std::lround(xOf(scan_.upperThreshold)));
        p.setPen(QPen(QColor(255, 205, 95), 1.4, Qt::DashLine));
        p.drawLine(x, plot.top(), x, plot.bottom());
    }
 
    QPainterPath path;
    bool first = true;
    for (const qpe::QuantumKleinHeightPoint2D &point : scan_.points) {
        if (!point.valid) { first = true; continue; }
        const QPointF q(xOf(point.barrierHeight), yOf(point.transmission));
        if (first) { path.moveTo(q); first = false; }
        else path.lineTo(q);
    }
    p.setPen(QPen(QColor(100, 220, 255), 2.4));
    p.setBrush(Qt::NoBrush);
    p.drawPath(path);
 
    if (currentBarrierHeight_ >= vmin && currentBarrierHeight_ <= vmax) {
        double referenceT = scan_.points.front().transmission;
        for (std::size_t i = 1; i < scan_.points.size(); ++i) {
            const auto &a0 = scan_.points[i - 1u];
            const auto &a1 = scan_.points[i];
            if (!a0.valid || !a1.valid) continue;
            if (currentBarrierHeight_ <= a1.barrierHeight) {
                const double f = (currentBarrierHeight_ - a0.barrierHeight) /
                    std::max(1.0e-12, a1.barrierHeight - a0.barrierHeight);
                referenceT = a0.transmission + f * (a1.transmission - a0.transmission);
                break;
            }
        }
        const int x = static_cast<int>(std::lround(xOf(currentBarrierHeight_)));
        p.setPen(QPen(QColor(255, 205, 95), 1.5, Qt::DashLine));
        p.drawLine(x, plot.top(), x, plot.bottom());
        p.setBrush(QColor(255, 205, 95));
        p.setPen(Qt::NoPen);
        p.drawEllipse(QPointF(xOf(currentBarrierHeight_), yOf(referenceT)), 5.0, 5.0);
 
        if (packetTransmission_ >= 0.0 && packetTransmission_ <= 1.05) {
            p.setBrush(QColor(255, 126, 126));
            p.drawEllipse(QPointF(xOf(currentBarrierHeight_), yOf(packetTransmission_)), 5.0, 5.0);
        }
    }
 
    p.setPen(QColor(188, 202, 214));
    p.setFont(font());
    p.drawText(QRect(plot.left(), plot.bottom() + 29, plot.width(), 22), Qt::AlignCenter,
               QStringLiteral("barrier height V0   |   cyan: plane-wave T(V0)   yellow: current reference   red: time-domain packet max P_right"));
 
    p.setPen(QColor(235, 240, 245));
    p.drawText(QRect(plot.left() + 8, plot.top() + 6, plot.width() - 16, 44),
               Qt::AlignLeft | Qt::AlignTop,
               QStringLiteral("E=%1   |p|=%2   angle=%3 deg   width=%4   thresholds: %5 / %6")
                   .arg(scan_.incidentEnergy, 0, 'f', 4)
                   .arg(scan_.momentumMagnitude, 0, 'f', 4)
                   .arg(scan_.incidenceAngleDegrees, 0, 'f', 2)
                   .arg(scan_.barrierWidth, 0, 'f', 3)
                   .arg(scan_.lowerThreshold, 0, 'f', 4)
                   .arg(scan_.upperThreshold, 0, 'f', 4));
 
    p.setPen(QColor(170, 184, 197));
    const int labelY = plot.top() + 28;
    p.drawText(QRect(static_cast<int>(xOf(vmin)) + 6, labelY, std::max(0, static_cast<int>(xOf(low) - xOf(vmin)) - 12), 20),
               Qt::AlignCenter, QStringLiteral("positive branch"));
    p.drawText(QRect(static_cast<int>(xOf(low)), labelY, std::max(0, static_cast<int>(xOf(high) - xOf(low))), 20),
               Qt::AlignCenter, QStringLiteral("evanescent"));
    p.drawText(QRect(static_cast<int>(xOf(high)), labelY, std::max(0, static_cast<int>(xOf(vmax) - xOf(high))), 20),
               Qt::AlignCenter, QStringLiteral("supercritical Klein"));
}