quantumzenoplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumzenoplotwidget.cpp
 * @brief Implements the quantumzenoplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumzenoplotwidget.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/quantumzenoplotwidget.h"
 
#include "core/quantum/quantumzeno2d.h"
 
#include <QPainter>
#include <QPainterPath>
#include <QPaintEvent>
#include <QPen>
#include <QString>
 
#include <algorithm>
#include <cmath>
 
QuantumZenoPlotWidget::QuantumZenoPlotWidget(QWidget *parent)
    : QWidget(parent)
{
    setAutoFillBackground(false);
}
 
void QuantumZenoPlotWidget::setData(const qpe::QuantumZenoHistory2D &history,
                                    const qpe::QuantumZenoProfile2D &profile)
{
    history_ = &history;
    profile_ = profile;
    update();
}
 
void QuantumZenoPlotWidget::clear()
{
    history_ = nullptr;
    profile_ = qpe::QuantumZenoProfile2D();
    update();
}
 
QSize QuantumZenoPlotWidget::minimumSizeHint() const
{
    return QSize(620, 410);
}
 
void QuantumZenoPlotWidget::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    QPainter p(this);
    p.setRenderHint(QPainter::Antialiasing, true);
    p.setRenderHint(QPainter::TextAntialiasing, true);
    p.fillRect(rect(), QColor(13, 17, 23));
 
    const QColor text(210, 220, 230);
    const QColor frame(70, 82, 94);
    const QColor watched(80, 220, 235);
    const QColor control(245, 170, 70);
    const QColor boundary(235, 90, 105);
 
    p.setPen(text);
    p.drawText(QRect(8, 2, width() - 16, 20), Qt::AlignCenter,
               QStringLiteral("Quantum Zeno effect: unmeasured escape vs repeatedly watched survival"));
 
    const int marginL = 58;
    const int marginR = 20;
    const int top = 28;
    const int gap = 38;
    const int bottom = 30;
    const int panelH = std::max(95, (height() - top - bottom - gap) / 2);
    const QRect survivalRect(marginL, top,
                             std::max(20, width() - marginL - marginR), panelH);
    const QRect profileRect(marginL, top + panelH + gap,
                            std::max(20, width() - marginL - marginR), panelH);
 
    auto drawFrame = [&](const QRect &r, const QString &title) {
        p.setPen(frame);
        p.drawRect(r);
        p.setPen(text);
        p.drawText(QRect(r.left(), r.top() - 20, r.width(), 18), Qt::AlignLeft, title);
    };
    drawFrame(survivalRect, QStringLiteral("Survival probability"));
    drawFrame(profileRect, QStringLiteral("Current X profile (each lane normalized for shape)"));
 
    if (!history_ || !history_->configured() || history_->empty()) {
        p.setPen(text);
        p.drawText(rect(), Qt::AlignCenter,
                   QStringLiteral("Run the Quantum Zeno / Watched Escape preset"));
        return;
    }
 
    const std::vector<qpe::QuantumZenoSample2D> &samples = history_->samples();
    const qpe::QuantumZenoSample2D &latest = samples.back();
    const qpe::QuantumZeno2DConfig &config = history_->config();
    const double tMax = std::max(1.0e-9, samples.back().time);
 
    auto mapT = [&](double t) {
        return survivalRect.left() + t / tMax * survivalRect.width();
    };
    auto mapSurvival = [&](double v) {
        const double clamped = std::max(0.0, std::min(1.0, v));
        return survivalRect.bottom() - clamped * survivalRect.height();
    };
 
    p.setPen(QPen(frame, 1, Qt::DotLine));
    for (int i = 1; i < 4; ++i) {
        const double level = 0.25 * static_cast<double>(i);
        const int yy = static_cast<int>(std::lround(mapSurvival(level)));
        p.drawLine(survivalRect.left(), yy, survivalRect.right(), yy);
    }
 
    auto drawSurvival = [&](bool watchedSeries, const QColor &color) {
        QPainterPath path;
        bool started = false;
        for (const qpe::QuantumZenoSample2D &sample : samples) {
            const double value = watchedSeries
                ? sample.watchedCumulativeSurvival
                : sample.controlSurvival;
            const QPointF q(mapT(sample.time), mapSurvival(value));
            if (!started) { path.moveTo(q); started = true; }
            else path.lineTo(q);
        }
        p.setPen(QPen(color, 2.2));
        p.drawPath(path);
    };
    drawSurvival(false, control);
    drawSurvival(true, watched);
 
    p.setPen(control);
    p.drawText(survivalRect.adjusted(8, 6, -8, -6),
               Qt::AlignTop | Qt::AlignLeft,
               QStringLiteral("upper control: no measurements"));
    p.setPen(watched);
    p.drawText(survivalRect.adjusted(8, 6, -8, -6),
               Qt::AlignTop | Qt::AlignRight,
               QStringLiteral("lower watched: repeated YES projections"));
    p.setPen(text);
    p.drawText(QRect(4, survivalRect.top(), 48, 18), Qt::AlignRight,
               QStringLiteral("1.0"));
    p.drawText(QRect(4, survivalRect.bottom() - 16, 48, 18), Qt::AlignRight,
               QStringLiteral("0.0"));
    p.drawText(QRect(survivalRect.left(), survivalRect.bottom() + 4,
                     survivalRect.width(), 20),
               Qt::AlignRight,
               QStringLiteral("t=%1   measurements=%2")
                   .arg(tMax, 0, 'f', 1)
                   .arg(static_cast<qulonglong>(latest.measurementCount)));
 
    if (!profile_.control.empty() &&
        profile_.control.size() == profile_.watched.size() && profile_.dx > 0.0) {
        const double xMin = profile_.xMin;
        const double xMax = xMin + profile_.dx *
                            static_cast<double>(profile_.control.size() - 1u);
        double maxP = 0.0;
        for (float v : profile_.control) maxP = std::max(maxP, static_cast<double>(v));
        for (float v : profile_.watched) maxP = std::max(maxP, static_cast<double>(v));
        maxP = std::max(maxP, 1.0e-12);
 
        auto mapX = [&](double x) {
            return profileRect.left() + (x - xMin) / (xMax - xMin) * profileRect.width();
        };
        auto mapP = [&](double value) {
            return profileRect.bottom() - value / maxP * profileRect.height();
        };
 
        const int bx = static_cast<int>(std::lround(mapX(config.survivalBoundaryX)));
        if (bx >= profileRect.left() && bx <= profileRect.right()) {
            p.setPen(QPen(boundary, 1.5, Qt::DashLine));
            p.drawLine(bx, profileRect.top(), bx, profileRect.bottom());
            p.drawText(QRect(bx + 4, profileRect.top() + 4, 120, 18),
                       Qt::AlignLeft, QStringLiteral("measurement edge"));
        }
 
        auto drawProfile = [&](const std::vector<float> &values, const QColor &color) {
            QPainterPath path;
            bool started = false;
            for (std::size_t i = 0u; i < values.size(); ++i) {
                const double x = xMin + static_cast<double>(i) * profile_.dx;
                const QPointF q(mapX(x), mapP(values[i]));
                if (!started) { path.moveTo(q); started = true; }
                else path.lineTo(q);
            }
            p.setPen(QPen(color, 2.0));
            p.drawPath(path);
        };
        drawProfile(profile_.control, control);
        drawProfile(profile_.watched, watched);
 
        p.setPen(text);
        p.drawText(profileRect.adjusted(8, 6, -8, -6),
                   Qt::AlignBottom | Qt::AlignLeft,
                   QStringLiteral("orange control   cyan watched"));
        p.drawText(QRect(profileRect.left(), profileRect.bottom() + 4,
                         profileRect.width(), 20),
                   Qt::AlignLeft,
                   QStringLiteral("x=%1").arg(xMin, 0, 'f', 1));
        p.drawText(QRect(profileRect.left(), profileRect.bottom() + 4,
                         profileRect.width(), 20),
                   Qt::AlignRight,
                   QStringLiteral("x=%1").arg(xMax, 0, 'f', 1));
    }
}