quantumdiracmasslesscomparisonplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumdiracmasslesscomparisonplotwidget.cpp
 * @brief Implements the quantumdiracmasslesscomparisonplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumdiracmasslesscomparisonplotwidget.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 "quantumdiracmasslesscomparisonplotwidget.h"
 
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
 
#include <algorithm>
#include <cmath>
 
QuantumDiracMasslessComparisonPlotWidget::QuantumDiracMasslessComparisonPlotWidget(QWidget *parent)
    : QWidget(parent)
{
}
 
void QuantumDiracMasslessComparisonPlotWidget::setData(
    const qpe::QuantumDiracMasslessComparison2DResult &scan,
    double currentAngleDegrees,
    double packetTransmission)
{
    scan_ = scan;
    currentAngleDegrees_ = currentAngleDegrees;
    packetTransmission_ = packetTransmission;
    update();
}
 
void QuantumDiracMasslessComparisonPlotWidget::clear()
{
    scan_ = qpe::QuantumDiracMasslessComparison2DResult();
    packetTransmission_ = -1.0;
    update();
}
 
QSize QuantumDiracMasslessComparisonPlotWidget::minimumSizeHint() const
{
    return QSize(700, 460);
}
 
void QuantumDiracMasslessComparisonPlotWidget::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("Massless Dirac / graphene-like analogue — same E, same barrier"));
 
    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 Massless Dirac / Graphene-like Klein Analogue preset."));
        return;
    }
 
    const int left = 64, right = 24, top = 50, bottom = 62;
    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 amin = scan_.minimumAngleDegrees;
    const double amax = scan_.maximumAngleDegrees;
    const auto xOf = [&](double angle) {
        return plot.left() + (angle - amin) / std::max(1.0e-12, amax - amin) * plot.width();
    };
    const auto yOf = [&](double transmission) {
        return plot.bottom() - std::max(0.0, std::min(1.0, transmission)) * plot.height();
    };
 
    // Emphasize the near-normal sector where chirality-protected transmission
    // is easiest to read before finite-width resonances dominate the curve.
    const double nearNormalEnd = std::min(12.0, amax);
    if (nearNormalEnd > amin) {
        p.fillRect(QRectF(xOf(amin), plot.top(), xOf(nearNormalEnd) - xOf(amin), plot.height()),
                   QColor(45, 80, 110, 42));
    }
 
    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 <= 7; ++i) {
        const double angle = amin + (amax - amin) * static_cast<double>(i) / 7.0;
        const int x = static_cast<int>(std::lround(xOf(angle)));
        p.drawLine(x, plot.top(), x, plot.bottom());
        p.setPen(QColor(170, 184, 197));
        p.drawText(QRect(x - 28, plot.bottom() + 5, 56, 20), Qt::AlignHCenter | Qt::AlignTop,
                   QString::number(angle, 'f', 0));
        p.setPen(QColor(77, 94, 109));
    }
 
    auto drawCurve = [&](bool massless, const QColor &color, double width) {
        QPainterPath path;
        bool first = true;
        for (const qpe::QuantumDiracMasslessComparisonPoint2D &point : scan_.points) {
            if (!point.valid) { first = true; continue; }
            const double t = massless ? point.masslessTransmission : point.massiveTransmission;
            const QPointF q(xOf(point.angleDegrees), yOf(t));
            if (first) { path.moveTo(q); first = false; }
            else path.lineTo(q);
        }
        p.setBrush(Qt::NoBrush);
        p.setPen(QPen(color, width));
        p.drawPath(path);
    };
 
    drawCurve(false, QColor(220, 130, 255), 2.0);
    drawCurve(true, QColor(100, 220, 255), 2.6);
 
    if (currentAngleDegrees_ >= amin && currentAngleDegrees_ <= amax) {
        double referenceT = scan_.points.front().masslessTransmission;
        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 (currentAngleDegrees_ <= a1.angleDegrees) {
                const double f = (currentAngleDegrees_ - a0.angleDegrees) /
                    std::max(1.0e-12, a1.angleDegrees - a0.angleDegrees);
                referenceT = a0.masslessTransmission + f *
                    (a1.masslessTransmission - a0.masslessTransmission);
                break;
            }
        }
        const int x = static_cast<int>(std::lround(xOf(currentAngleDegrees_)));
        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(currentAngleDegrees_), yOf(referenceT)), 5.0, 5.0);
        if (packetTransmission_ >= 0.0 && packetTransmission_ <= 1.05) {
            p.setBrush(QColor(255, 126, 126));
            p.drawEllipse(QPointF(xOf(currentAngleDegrees_), yOf(packetTransmission_)), 5.0, 5.0);
        }
    }
 
    p.setPen(QColor(188, 202, 214));
    p.setFont(font());
    p.drawText(QRect(plot.left(), plot.bottom() + 30, plot.width(), 24), Qt::AlignCenter,
               QStringLiteral("incidence angle (deg)   cyan: m=0   violet: massive fixed-E control   yellow: current m=0 reference   red: packet max P_right"));
 
    const qpe::QuantumDiracMasslessComparisonPoint2D normal = scan_.points.front();
    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   V0=%2   width=%3   p(m=0)=%4   p(m=%5)=%6   T0: %7 vs %8")
                   .arg(scan_.fixedIncidentEnergy, 0, 'f', 4)
                   .arg(scan_.barrierHeight, 0, 'f', 3)
                   .arg(scan_.barrierWidth, 0, 'f', 3)
                   .arg(scan_.masslessMomentumMagnitude, 0, 'f', 4)
                   .arg(scan_.massiveRestMass, 0, 'f', 2)
                   .arg(scan_.massiveMomentumMagnitude, 0, 'f', 4)
                   .arg(normal.valid ? normal.masslessTransmission : 0.0, 0, 'f', 4)
                   .arg(normal.valid ? normal.massiveTransmission : 0.0, 0, 'f', 4));
 
    p.setPen(QColor(170, 184, 197));
    p.drawText(QRect(static_cast<int>(xOf(amin)) + 4, plot.top() + 30,
                     std::max(0, static_cast<int>(xOf(nearNormalEnd) - xOf(amin)) - 8), 20),
               Qt::AlignCenter, QStringLiteral("near-normal chirality window"));
}