quantumkleinanglescanplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumkleinanglescanplotwidget.cpp
 * @brief Implements the quantumkleinanglescanplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumkleinanglescanplotwidget.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 "quantumkleinanglescanplotwidget.h"
 
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
 
#include <algorithm>
#include <cmath>
 
QuantumKleinAngleScanPlotWidget::QuantumKleinAngleScanPlotWidget(QWidget *parent)
    : QWidget(parent)
{
}
 
void QuantumKleinAngleScanPlotWidget::setData(const qpe::QuantumKleinAngleScan2DResult &scan,
                                               double currentAngleDegrees,
                                               double packetTransmission)
{
    scan_ = scan;
    currentAngleDegrees_ = currentAngleDegrees;
    packetTransmission_ = packetTransmission;
    update();
}
 
void QuantumKleinAngleScanPlotWidget::clear()
{
    scan_ = qpe::QuantumKleinAngleScan2DResult();
    packetTransmission_ = -1.0;
    update();
}
 
QSize QuantumKleinAngleScanPlotWidget::minimumSizeHint() const
{
    return QSize(670, 440);
}
 
void QuantumKleinAngleScanPlotWidget::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 angular reference — stationary plane-wave T(theta) at fixed |p|"));
 
    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 Incidence Angle preset."));
        return;
    }
 
    const int left = 62, right = 22, top = 46, bottom = 54;
    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();
    };
 
    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(6, y - 9, 50, 18), Qt::AlignRight | Qt::AlignVCenter,
                   QString::number(t, 'f', 1));
        p.setPen(QColor(77, 94, 109));
    }
 
    for (int a = 0; a <= 70; a += 10) {
        if (a < amin || a > amax) continue;
        const int x = static_cast<int>(std::lround(xOf(static_cast<double>(a))));
        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,
                   QStringLiteral("%1 deg").arg(a));
        p.setPen(QColor(77, 94, 109));
    }
 
    QPainterPath path;
    bool first = true;
    for (const qpe::QuantumKleinAnglePoint2D &point : scan_.points) {
        if (!point.valid) { first = true; continue; }
        const QPointF q(xOf(point.angleDegrees), 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 (currentAngleDegrees_ >= amin && currentAngleDegrees_ <= amax) {
        // Interpolate the displayed reference curve at the current angle.
        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 (currentAngleDegrees_ <= a1.angleDegrees) {
                const double f = (currentAngleDegrees_ - a0.angleDegrees) /
                    std::max(1.0e-12, a1.angleDegrees - a0.angleDegrees);
                referenceT = a0.transmission + f * (a1.transmission - a0.transmission);
                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() + 27, plot.width(), 22), Qt::AlignCenter,
               QStringLiteral("incidence angle theta   |   cyan: plane-wave reference   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, 42),
               Qt::AlignLeft | Qt::AlignTop,
               QStringLiteral("|p|=%1   E=%2   V0=%3   width=%4   scan=%5..%6 deg")
                   .arg(scan_.momentumMagnitude, 0, 'f', 4)
                   .arg(scan_.incidentEnergy, 0, 'f', 4)
                   .arg(scan_.barrierHeight, 0, 'f', 3)
                   .arg(scan_.barrierWidth, 0, 'f', 3)
                   .arg(scan_.minimumAngleDegrees, 0, 'f', 0)
                   .arg(scan_.maximumAngleDegrees, 0, 'f', 0));
}