quantumbackflowplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumbackflowplotwidget.cpp
 * @brief Implements the quantumbackflowplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumbackflowplotwidget.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 "quantumbackflowplotwidget.h"
 
#include <QPainter>
#include <QPainterPath>
#include <QPaintEvent>
#include <algorithm>
#include <cmath>
 
QuantumBackflowPlotWidget::QuantumBackflowPlotWidget(QWidget *parent)
    : QWidget(parent) {}
 
void QuantumBackflowPlotWidget::setData(const qpe::QuantumBackflowHistory2D &history)
{
    history_ = &history;
    update();
}
 
void QuantumBackflowPlotWidget::clear()
{
    history_ = nullptr;
    update();
}
 
QSize QuantumBackflowPlotWidget::minimumSizeHint() const
{
    return QSize(650, 430);
}
 
void QuantumBackflowPlotWidget::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    QPainter p(this);
    p.setRenderHint(QPainter::Antialiasing, true);
    p.fillRect(rect(), QColor(10, 14, 20));
 
    QFont bold = font();
    bold.setBold(true);
    p.setFont(bold);
    p.setPen(QColor(225, 235, 244));
    p.drawText(QRect(12, 7, width() - 24, 24), Qt::AlignLeft | Qt::AlignVCenter,
               QStringLiteral("Quantum backflow — positive momentum, negative probability current"));
 
    if (!history_ || !history_->configured() || history_->samples().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 Quantum Backflow and press Play"));
        return;
    }
 
    const auto &s = history_->samples();
    const auto &cfg = history_->config();
    const auto &last = s.back();
 
    const int left = 62;
    const int right = 18;
    const int top = 42;
    const int gap = 28;
    const int bottomH = 155;
    QRect currentR(left, top, std::max(140, width() - left - right),
                   std::max(145, height() - top - gap - bottomH - 30));
    QRect probR(left, currentR.bottom() + gap, currentR.width(),
                std::max(110, height() - (currentR.bottom() + gap) - 28));
 
    p.setPen(QColor(55, 72, 88));
    p.setBrush(QColor(5, 9, 15));
    p.drawRect(currentR);
    p.drawRect(probR);
 
    const double tmax = std::max(cfg.analysisEndTime, last.time);
    auto tx = [&](double t) {
        return currentR.left() + t / std::max(1.0e-12, tmax) * currentR.width();
    };
 
    double maxAbsJ = 1.0e-6;
    for (const auto &a : s) maxAbsJ = std::max(maxAbsJ, std::abs(a.detectorCurrent));
    maxAbsJ *= 1.12;
    auto jy = [&](double j) {
        return currentR.center().y() - j / maxAbsJ * (0.46 * currentR.height());
    };
 
    const double zeroY = jy(0.0);
    p.setPen(QPen(QColor(90, 105, 120), 1.0, Qt::DashLine));
    p.drawLine(QPointF(currentR.left(), zeroY), QPointF(currentR.right(), zeroY));
 
    // Shade samples that are genuinely flowing backwards.
    p.setPen(Qt::NoPen);
    p.setBrush(QColor(220, 70, 95, 40));
    for (std::size_t i = 1; i < s.size(); ++i) {
        if (s[i - 1].detectorCurrent < 0.0 || s[i].detectorCurrent < 0.0) {
            const double xa = tx(s[i - 1].time);
            const double xb = tx(s[i].time);
            p.drawRect(QRectF(std::min(xa, xb), currentR.top(), std::abs(xb - xa) + 1.0, currentR.height()));
        }
    }
 
    QPainterPath currentPath;
    for (std::size_t i = 0; i < s.size(); ++i) {
        QPointF q(tx(s[i].time), jy(s[i].detectorCurrent));
        if (i == 0) currentPath.moveTo(q); else currentPath.lineTo(q);
    }
    p.setPen(QPen(QColor(105, 220, 255), 2.1));
    p.drawPath(currentPath);
 
    auto py = [&](double v) {
        return probR.bottom() - std::max(0.0, std::min(1.0, v)) * probR.height();
    };
    double maxFlux = std::max(0.01, history_->maximumBackwardFlux());
    auto fy = [&](double v) {
        return probR.bottom() - std::max(0.0, v) / maxFlux * (0.45 * probR.height());
    };
 
    QPainterPath leftPath, fluxPath;
    for (std::size_t i = 0; i < s.size(); ++i) {
        QPointF a(tx(s[i].time), py(s[i].probabilityLeft));
        QPointF b(tx(s[i].time), fy(s[i].cumulativeBackwardFlux));
        if (i == 0) { leftPath.moveTo(a); fluxPath.moveTo(b); }
        else { leftPath.lineTo(a); fluxPath.lineTo(b); }
    }
    p.setPen(QPen(QColor(120, 235, 160), 2.0));
    p.drawPath(leftPath);
    p.setPen(QPen(QColor(255, 209, 102), 1.8));
    p.drawPath(fluxPath);
 
    p.setFont(font());
    p.setPen(QColor(180, 198, 212));
    p.drawText(QRect(currentR.left(), currentR.bottom() + 3, currentR.width(), 20), Qt::AlignCenter,
               QStringLiteral("time   cyan: integrated Jx at detector   red shade: Jx < 0"));
    p.drawText(QRect(probR.left(), probR.bottom() + 4, probR.width(), 20), Qt::AlignCenter,
               QStringLiteral("green: P(x < detector)   yellow: accumulated backward flux"));
 
    p.setPen(QColor(232, 238, 244));
    const QString state = last.detectorCurrent < 0.0 ? QStringLiteral("BACKFLOW") : QStringLiteral("forward flow");
    p.drawText(QRect(currentR.left() + 8, currentR.top() + 5, currentR.width() - 16, 22),
               Qt::AlignLeft | Qt::AlignVCenter,
               QStringLiteral("p_x>0 fraction=%1   Jmin=%2   backflow=%3   now: %4")
                   .arg(history_->positiveMomentumFraction(), 0, 'f', 9)
                   .arg(history_->minimumCurrent(), 0, 'g', 5)
                   .arg(history_->maximumBackwardFlux(), 0, 'g', 5)
                   .arg(state));
}