quantumkapitzadiracplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumkapitzadiracplotwidget.cpp
 * @brief Implements the quantumkapitzadiracplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumkapitzadiracplotwidget.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 "graphics/renderer/quantumkapitzadiracplotwidget.h"
 
#include <QPainter>
#include <QPaintEvent>
#include <QPainterPath>
#include <QPen>
 
#include <algorithm>
#include <cmath>
 
namespace {
 
/**
 * @brief Performs heat color.
 * @param value Value to assign or evaluate.
 */
QColor heatColor(double value)
{
    const double v = std::max(0.0, std::min(1.0, value));
    if (v < 0.35) {
        const double u = v / 0.35;
        return QColor(static_cast<int>(7 + 16 * u),
                      static_cast<int>(12 + 75 * u),
                      static_cast<int>(28 + 150 * u));
    }
    if (v < 0.72) {
        const double u = (v - 0.35) / 0.37;
        return QColor(static_cast<int>(23 + 28 * u),
                      static_cast<int>(87 + 145 * u),
                      static_cast<int>(178 + 58 * u));
    }
    const double u = (v - 0.72) / 0.28;
    return QColor(static_cast<int>(51 + 204 * u),
                  static_cast<int>(232 + 23 * u),
                  static_cast<int>(236 - 92 * u));
}
 
} // namespace
 
QuantumKapitzaDiracPlotWidget::QuantumKapitzaDiracPlotWidget(QWidget *parent)
    : QWidget(parent)
{
    setAutoFillBackground(false);
}
 
void QuantumKapitzaDiracPlotWidget::setData(const qpe::QuantumKapitzaDiracHistory2D &history)
{
    history_ = &history;
    update();
}
 
void QuantumKapitzaDiracPlotWidget::clear()
{
    history_ = nullptr;
    update();
}
 
QSize QuantumKapitzaDiracPlotWidget::minimumSizeHint() const
{
    return QSize(650, 430);
}
 
void QuantumKapitzaDiracPlotWidget::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    QPainter p(this);
    p.setRenderHint(QPainter::Antialiasing, true);
    p.fillRect(rect(), QColor(11, 16, 22));
 
    QFont title = font();
    title.setBold(true);
    p.setFont(title);
    p.setPen(QColor(224, 234, 242));
    p.drawText(QRect(12, 7, width() - 24, 24), Qt::AlignLeft | Qt::AlignVCenter,
               QStringLiteral("Kapitza-Dirac diffraction — momentum orders from a light grating"));
 
    if (!history_ || !history_->configured() || history_->empty()) {
        p.setFont(font());
        p.setPen(QColor(150, 166, 180));
        p.drawText(QRect(20, 50, width() - 40, height() - 70),
                   Qt::AlignCenter | Qt::TextWordWrap,
                   QStringLiteral("Load Kapitza-Dirac Diffraction and press Play"));
        return;
    }
 
    const std::vector<qpe::QuantumKapitzaDiracSample2D> &samples = history_->samples();
    const qpe::QuantumKapitzaDirac2DConfig &config = history_->config();
    const qpe::QuantumKapitzaDiracSample2D &last = samples.back();
 
    const int left = 62;
    const int right = 18;
    const int top = 40;
    const int gap = 38;
    const int barsH = std::max(120, height() / 3);
    const int carpetBottom = height() - barsH - gap;
    QRect carpet(left, top, std::max(20, width() - left - right),
                 std::max(90, carpetBottom - top));
    QRect bars(left, carpet.bottom() + gap, carpet.width(),
               std::max(80, height() - (carpet.bottom() + gap) - 28));
 
    p.setPen(QColor(62, 77, 90));
    p.setBrush(QColor(6, 11, 16));
    p.drawRect(carpet);
    p.drawRect(bars);
 
    double maxP = 1.0e-12;
    for (const qpe::QuantumKapitzaDiracSample2D &s : samples) {
        for (float v : s.momentumProbability) maxP = std::max(maxP, static_cast<double>(v));
    }
    const std::size_t bins = last.momentumProbability.size();
    if (bins > 0u) {
        for (std::size_t row = 0u; row < samples.size(); ++row) {
            const qpe::QuantumKapitzaDiracSample2D &s = samples[row];
            const int y0 = carpet.top() + static_cast<int>(
                static_cast<double>(row) / samples.size() * carpet.height());
            const int y1 = carpet.top() + static_cast<int>(
                static_cast<double>(row + 1u) / samples.size() * carpet.height());
            for (std::size_t col = 0u; col < s.momentumProbability.size(); ++col) {
                const int x0 = carpet.left() + static_cast<int>(
                    static_cast<double>(col) / bins * carpet.width());
                const int x1 = carpet.left() + static_cast<int>(
                    static_cast<double>(col + 1u) / bins * carpet.width());
                const double q = std::sqrt(std::max(0.0,
                    static_cast<double>(s.momentumProbability[col])) / maxP);
                p.fillRect(QRect(x0, y0, std::max(1, x1 - x0 + 1),
                                 std::max(1, y1 - y0 + 1)), heatColor(q));
            }
        }
 
        const double pMin = last.momentumMin;
        const double pMax = last.momentumMin +
            last.momentumStep * static_cast<double>(bins > 0u ? bins - 1u : 0u);
        const auto mapP = [&](double momentum) {
            const double u = (momentum - pMin) / std::max(1.0e-12, pMax - pMin);
            return carpet.left() + u * carpet.width();
        };
        p.setPen(QPen(QColor(255, 205, 78, 180), 1.0, Qt::DashLine));
        for (int n = -config.maximumOrder; n <= config.maximumOrder; ++n) {
            const double px = static_cast<double>(n) * last.reciprocalMomentum;
            if (px < pMin || px > pMax) continue;
            p.drawLine(QPointF(mapP(px), carpet.top()), QPointF(mapP(px), carpet.bottom()));
        }
        p.setPen(QColor(180, 197, 210));
        p.drawText(QRect(carpet.left(), carpet.bottom() + 4, carpet.width(), 20),
                   Qt::AlignCenter,
                   QStringLiteral("p_x   —   gold guides: n G,   G=2 pi hbar / a"));
        p.drawText(QRect(4, carpet.top(), left - 10, 20),
                   Qt::AlignRight | Qt::AlignVCenter, QStringLiteral("t=0"));
        p.drawText(QRect(4, carpet.bottom() - 20, left - 10, 20),
                   Qt::AlignRight | Qt::AlignVCenter,
                   QStringLiteral("%1").arg(last.time, 0, 'f', 2));
    }
 
    const int orderCount = static_cast<int>(last.orderProbability.size());
    if (orderCount > 0) {
        double maxOrderP = 1.0e-12;
        for (float v : last.orderProbability) maxOrderP = std::max(maxOrderP, static_cast<double>(v));
        const double cellW = static_cast<double>(bars.width()) / orderCount;
        for (int i = 0; i < orderCount; ++i) {
            const double v = static_cast<double>(last.orderProbability[static_cast<std::size_t>(i)]);
            const double h = v / maxOrderP * (bars.height() - 30);
            const QRectF r(bars.left() + i * cellW + 0.12 * cellW,
                           bars.bottom() - h,
                           0.76 * cellW,
                           h);
            p.fillRect(r, QColor(83, 211, 238));
            p.setPen(QColor(205, 220, 231));
            const int n = i - config.maximumOrder;
            p.drawText(QRectF(bars.left() + i * cellW, bars.bottom() + 3,
                              cellW, 20), Qt::AlignCenter,
                       QString::number(n));
        }
        p.setPen(QColor(180, 197, 210));
        p.drawText(QRect(4, bars.top(), left - 10, 20),
                   Qt::AlignRight | Qt::AlignVCenter,
                   QStringLiteral("Pmax"));
        p.drawText(QRect(bars.left(), bars.bottom() + 22, bars.width(), 20),
                   Qt::AlignCenter,
                   QStringLiteral("diffraction order n"));
    }
 
    p.setPen(QColor(225, 235, 242));
    const QString stage = last.pulseActive ? QStringLiteral("LIGHT PULSE ON") :
        (last.time >= config.pulseStartTime + config.pulseDuration
             ? QStringLiteral("free expansion") : QStringLiteral("before pulse"));
    p.drawText(QRect(bars.left() + 8, bars.top() + 5, bars.width() - 16, 20),
               Qt::AlignLeft | Qt::AlignVCenter,
               QStringLiteral("%1   samples=%2   t=%3   G=%4   pulse area beta=%5")
                   .arg(stage)
                   .arg(static_cast<qulonglong>(samples.size()))
                   .arg(last.time, 0, 'f', 3)
                   .arg(last.reciprocalMomentum, 0, 'f', 4)
                   .arg(qpe::QuantumKapitzaDirac2D::pulseArea(config, history_->hbar()), 0, 'f', 3));
}