quantumberryphaseplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumberryphaseplotwidget.cpp
 * @brief Implements the quantumberryphaseplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumberryphaseplotwidget.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 "quantumberryphaseplotwidget.h"
 
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
 
#include <algorithm>
#include <cmath>
 
namespace {
const double kPi = 3.1415926535897932384626433832795;
 
/**
 * @brief Performs frame.
 * @param p The p value used by the operation.
 * @param r The r value used by the operation.
 */
void frame(QPainter &p, const QRectF &r)
{
    p.setBrush(Qt::NoBrush);
    p.setPen(QPen(QColor(70, 79, 91), 1.0));
    p.drawRect(r);
}
}
 
QuantumBerryPhasePlotWidget::QuantumBerryPhasePlotWidget(QWidget *parent)
    : QWidget(parent)
{
    setMinimumHeight(390);
    setAutoFillBackground(false);
}
 
void QuantumBerryPhasePlotWidget::setData(const qpe::QuantumBerryHistory2D &history)
{
    history_ = &history;
    update();
}
 
void QuantumBerryPhasePlotWidget::clear()
{
    history_ = nullptr;
    update();
}
 
QSize QuantumBerryPhasePlotWidget::minimumSizeHint() const
{
    return QSize(680, 410);
}
 
void QuantumBerryPhasePlotWidget::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    QPainter p(this);
    p.setRenderHint(QPainter::Antialiasing, true);
    p.setRenderHint(QPainter::TextAntialiasing, true);
    p.fillRect(rect(), QColor(14, 17, 22));
 
    const double marginL = 58.0;
    const double marginR = 48.0;
    const double top = 34.0;
    const double gap = 42.0;
    const double bottom = 42.0;
    const double available = std::max(180.0, height() - top - gap - bottom);
    const double upperH = available * 0.48;
    const QRectF loopRect(marginL, top, std::max(100.0, width() - marginL - marginR), upperH);
    const QRectF curveRect(marginL, loopRect.bottom() + gap, loopRect.width(), available - upperH);
    frame(p, loopRect);
    frame(p, curveRect);
 
    p.setPen(QColor(226, 232, 240));
    p.drawText(QRectF(loopRect.left(), 5.0, loopRect.width(), 22.0), Qt::AlignCenter,
               QStringLiteral("Berry loop in parameter space (q1,q2) — degeneracy at the origin"));
    p.drawText(QRectF(curveRect.left(), loopRect.bottom() + 10.0, curveRect.width(), 22.0), Qt::AlignCenter,
               QStringLiteral("Return fidelity and geometric phase extracted from the full wavefunction"));
 
    if (!history_ || !history_->configured() || history_->empty()) {
        p.setPen(QColor(205, 214, 224));
        p.drawText(loopRect, Qt::AlignCenter,
                   QStringLiteral("Load Berry Phase / Geometric Phase and run one cyclic deformation"));
        p.drawText(curveRect, Qt::AlignCenter,
                   QStringLiteral("In the adiabatic limit the endpoint phase tends to ±180°"));
        return;
    }
 
    const std::vector<qpe::QuantumBerrySample2D> &samples = history_->samples();
    const double A = std::max(1.0e-9, history_->config().anisotropy);
    const QPointF center(loopRect.center().x(), loopRect.center().y());
    const double radius = 0.39 * std::min(loopRect.width(), loopRect.height());
    const auto mapQ = [&](double q1, double q2) {
        return QPointF(center.x() + radius * q1 / A,
                       center.y() - radius * q2 / A);
    };
 
    p.setPen(QPen(QColor(66, 73, 82), 1.0));
    p.drawLine(QPointF(loopRect.left() + 12.0, center.y()), QPointF(loopRect.right() - 12.0, center.y()));
    p.drawLine(QPointF(center.x(), loopRect.top() + 12.0), QPointF(center.x(), loopRect.bottom() - 12.0));
    p.setPen(QPen(QColor(115, 126, 140), 1.2, Qt::DashLine));
    p.drawEllipse(center, radius, radius);
 
    QPainterPath path;
    bool first = true;
    for (const qpe::QuantumBerrySample2D &s : samples) {
        const QPointF pt = mapQ(s.q1, s.q2);
        if (first) { path.moveTo(pt); first = false; }
        else path.lineTo(pt);
    }
    p.setPen(QPen(QColor(83, 214, 255), 2.2));
    p.drawPath(path);
 
    p.setPen(Qt::NoPen);
    p.setBrush(QColor(255, 92, 105));
    p.drawEllipse(center, 5.0, 5.0);
    p.setPen(QColor(255, 134, 143));
    p.drawText(QRectF(center.x() + 8.0, center.y() - 19.0, 190.0, 22.0), Qt::AlignLeft,
               QStringLiteral("degeneracy q1=q2=0"));
 
    const qpe::QuantumBerrySample2D &last = samples.back();
    const QPointF current = mapQ(last.q1, last.q2);
    // Make motion obvious even during the first few samples.  The Berry loop
    // is intentionally slow, so a larger live marker and a radial guide give
    // immediate visual feedback that Analysis is receiving samples.
    p.setPen(QPen(QColor(255, 214, 91), 1.3, Qt::DashLine));
    p.drawLine(center, current);
    p.setPen(Qt::NoPen);
    p.setBrush(QColor(255, 214, 91));
    p.drawEllipse(current, 8.0, 8.0);
    p.setPen(QColor(215, 223, 232));
    p.drawText(QRectF(loopRect.left() + 10.0, loopRect.bottom() - 27.0, 310.0, 20.0), Qt::AlignLeft,
               QStringLiteral("physical principal axis rotates by θ/2"));
    p.drawText(QRectF(loopRect.right() - 360.0, loopRect.bottom() - 27.0, 350.0, 20.0), Qt::AlignRight,
               QStringLiteral("samples %1   t=%2   progress %3 %")
                   .arg(static_cast<qulonglong>(samples.size()))
                   .arg(last.time, 0, 'f', 2)
                   .arg(100.0 * last.progress, 0, 'f', 1));
 
    const double t0 = samples.front().time;
    const double t1 = samples.back().time;
    const double span = std::max(1.0e-12, t1 - t0);
    const auto mx = [&](double t) { return curveRect.left() + (t - t0) / span * curveRect.width(); };
    const auto myF = [&](double f) {
        return curveRect.bottom() - std::max(0.0, std::min(1.0, f)) * curveRect.height();
    };
    const auto myP = [&](double phase) {
        const double degrees = phase * 180.0 / kPi;
        return curveRect.center().y() - degrees / 180.0 * 0.5 * curveRect.height();
    };
 
    p.setPen(QPen(QColor(60, 67, 76), 1.0));
    p.drawLine(QPointF(curveRect.left(), curveRect.center().y()), QPointF(curveRect.right(), curveRect.center().y()));
    p.setPen(QPen(QColor(255, 190, 79), 1.0, Qt::DashLine));
    p.drawLine(QPointF(curveRect.left(), curveRect.top()), QPointF(curveRect.right(), curveRect.top()));
    p.drawLine(QPointF(curveRect.left(), curveRect.bottom()), QPointF(curveRect.right(), curveRect.bottom()));
 
    QPainterPath fidelityPath;
    QPainterPath phasePath;
    bool firstF = true;
    bool firstP = true;
    for (const qpe::QuantumBerrySample2D &s : samples) {
        const QPointF pf(mx(s.time), myF(s.returnFidelity));
        if (firstF) { fidelityPath.moveTo(pf); firstF = false; }
        else fidelityPath.lineTo(pf);
        if (s.geometricPhaseValid) {
            const QPointF pp(mx(s.time), myP(s.geometricPhase));
            if (firstP) { phasePath.moveTo(pp); firstP = false; }
            else phasePath.lineTo(pp);
        } else {
            firstP = true;
        }
    }
    p.setPen(QPen(QColor(79, 220, 255), 2.0));
    p.drawPath(fidelityPath);
    if (samples.size() == 1u) {
        p.setBrush(QColor(79, 220, 255));
        p.drawEllipse(QPointF(mx(samples.front().time), myF(samples.front().returnFidelity)), 3.5, 3.5);
        p.setBrush(Qt::NoBrush);
    }
    p.setPen(QPen(QColor(255, 190, 79), 2.0));
    p.drawPath(phasePath);
    if (samples.size() == 1u && samples.front().geometricPhaseValid) {
        p.setBrush(QColor(255, 190, 79));
        p.drawEllipse(QPointF(mx(samples.front().time), myP(samples.front().geometricPhase)), 3.5, 3.5);
        p.setBrush(Qt::NoBrush);
    }
 
    p.setPen(QColor(79, 220, 255));
    p.drawText(QRectF(curveRect.left() + 8.0, curveRect.top() + 5.0, 220.0, 20.0), Qt::AlignLeft,
               QStringLiteral("cyan: return fidelity"));
    p.setPen(QColor(255, 190, 79));
    p.drawText(QRectF(curveRect.left() + 215.0, curveRect.top() + 5.0, 270.0, 20.0), Qt::AlignLeft,
               QStringLiteral("gold: geometric phase (±180° scale)"));
 
    p.setPen(QColor(202, 211, 221));
    p.drawText(QRectF(4.0, curveRect.top() - 8.0, 48.0, 20.0), Qt::AlignRight, QStringLiteral("1"));
    p.drawText(QRectF(4.0, curveRect.bottom() - 10.0, 48.0, 20.0), Qt::AlignRight, QStringLiteral("0"));
    p.drawText(QRectF(curveRect.right() + 5.0, curveRect.top() - 8.0, 42.0, 20.0), Qt::AlignLeft, QStringLiteral("+180°"));
    p.drawText(QRectF(curveRect.right() + 5.0, curveRect.center().y() - 10.0, 42.0, 20.0), Qt::AlignLeft, QStringLiteral("0°"));
    p.drawText(QRectF(curveRect.right() + 5.0, curveRect.bottom() - 10.0, 42.0, 20.0), Qt::AlignLeft, QStringLiteral("-180°"));
    p.drawText(QRectF(curveRect.left(), curveRect.bottom() + 5.0, 85.0, 20.0), Qt::AlignLeft,
               QString::number(t0, 'f', 1));
    p.drawText(QRectF(curveRect.right() - 85.0, curveRect.bottom() + 5.0, 85.0, 20.0), Qt::AlignRight,
               QString::number(t1, 'f', 1));
    p.drawText(QRectF(curveRect.left(), curveRect.bottom() + 4.0, curveRect.width(), 24.0), Qt::AlignCenter,
               QStringLiteral("simulation time"));
}