quantumloschmidtplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumloschmidtplotwidget.cpp
 * @brief Implements the quantumloschmidtplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumloschmidtplotwidget.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 "quantumloschmidtplotwidget.h"
 
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
 
#include <algorithm>
#include <cmath>
#include <limits>
 
namespace {
 
/**
 * @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);
}
 
/**
 * @brief Performs clamp01.
 * @param v The v value used by the operation.
 */
double clamp01(double v)
{
    return std::max(0.0, std::min(1.0, v));
}
 
} // namespace
 
QuantumLoschmidtPlotWidget::QuantumLoschmidtPlotWidget(QWidget *parent)
    : QWidget(parent)
{
    setMinimumHeight(390);
    setAutoFillBackground(false);
}
 
void QuantumLoschmidtPlotWidget::setData(const qpe::QuantumLoschmidtHistory2D &history)
{
    history_ = &history;
    update();
}
 
void QuantumLoschmidtPlotWidget::clear()
{
    history_ = nullptr;
    update();
}
 
QSize QuantumLoschmidtPlotWidget::minimumSizeHint() const
{
    return QSize(680, 410);
}
 
void QuantumLoschmidtPlotWidget::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 = 42.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 pathRect(marginL, top, std::max(100.0, width() - marginL - marginR), upperH);
    const QRectF echoRect(marginL, pathRect.bottom() + gap, pathRect.width(), available - upperH);
    frame(p, pathRect);
    frame(p, echoRect);
 
    p.setPen(QColor(226, 232, 240));
    p.drawText(QRectF(pathRect.left(), 5.0, pathRect.width(), 22.0), Qt::AlignCenter,
               QStringLiteral("Loschmidt echo — centroid path before and after time reversal"));
    p.drawText(QRectF(echoRect.left(), pathRect.bottom() + 10.0, echoRect.width(), 22.0), Qt::AlignCenter,
               QStringLiteral("Density echo vs coherent time-reversed-state fidelity"));
 
    if (!history_ || !history_->configured() || history_->empty()) {
        p.setPen(QColor(205, 214, 224));
        p.drawText(pathRect, Qt::AlignCenter,
                   QStringLiteral("Load Loschmidt Echo / Quantum Time Reversal and press Play"));
        p.drawText(echoRect, Qt::AlignCenter,
                   QStringLiteral("At t = 2T a perfect reversal should reconstruct the initial density"));
        return;
    }
 
    const std::vector<qpe::QuantumLoschmidtSample2D> &samples = history_->samples();
    const double reversalTime = history_->config().reversalTime;
 
    double minX = std::numeric_limits<double>::infinity();
    double maxX = -std::numeric_limits<double>::infinity();
    double minY = std::numeric_limits<double>::infinity();
    double maxY = -std::numeric_limits<double>::infinity();
    for (const qpe::QuantumLoschmidtSample2D &s : samples) {
        minX = std::min(minX, s.meanX);
        maxX = std::max(maxX, s.meanX);
        minY = std::min(minY, s.meanY);
        maxY = std::max(maxY, s.meanY);
    }
    if (!(maxX > minX)) { minX -= 1.0; maxX += 1.0; }
    if (!(maxY > minY)) { minY -= 1.0; maxY += 1.0; }
    const double padX = 0.12 * std::max(1.0, maxX - minX);
    const double padY = 0.12 * std::max(1.0, maxY - minY);
    minX -= padX; maxX += padX; minY -= padY; maxY += padY;
 
    const auto mxPath = [&](double x) {
        return pathRect.left() + (x - minX) / (maxX - minX) * pathRect.width();
    };
    const auto myPath = [&](double y) {
        return pathRect.bottom() - (y - minY) / (maxY - minY) * pathRect.height();
    };
 
    QPainterPath outbound;
    QPainterPath returning;
    bool outFirst = true;
    bool retFirst = true;
    QPointF reversalPoint;
    bool haveReversalPoint = false;
    for (const qpe::QuantumLoschmidtSample2D &s : samples) {
        const QPointF pt(mxPath(s.meanX), myPath(s.meanY));
        if (s.time <= reversalTime + 1.0e-9 && !s.reversalApplied) {
            if (outFirst) { outbound.moveTo(pt); outFirst = false; }
            else outbound.lineTo(pt);
            reversalPoint = pt;
        } else {
            if (!haveReversalPoint) {
                if (!outFirst) returning.moveTo(reversalPoint);
                else returning.moveTo(pt);
                retFirst = false;
                haveReversalPoint = true;
            }
            if (retFirst) { returning.moveTo(pt); retFirst = false; }
            else returning.lineTo(pt);
        }
    }
 
    p.setPen(QPen(QColor(79, 220, 255), 2.2));
    p.drawPath(outbound);
    p.setPen(QPen(QColor(255, 190, 79), 2.2));
    p.drawPath(returning);
 
    const qpe::QuantumLoschmidtSample2D &first = samples.front();
    const qpe::QuantumLoschmidtSample2D &last = samples.back();
    const QPointF startPt(mxPath(first.meanX), myPath(first.meanY));
    const QPointF currentPt(mxPath(last.meanX), myPath(last.meanY));
    p.setPen(Qt::NoPen);
    p.setBrush(QColor(103, 232, 153));
    p.drawEllipse(startPt, 5.5, 5.5);
    if (haveReversalPoint) {
        p.setBrush(QColor(236, 112, 255));
        p.drawEllipse(reversalPoint, 6.0, 6.0);
    }
    p.setBrush(QColor(244, 247, 251));
    p.drawEllipse(currentPt, 4.5, 4.5);
 
    p.setPen(QColor(79, 220, 255));
    p.drawText(QRectF(pathRect.left() + 8.0, pathRect.top() + 5.0, 180.0, 20.0), Qt::AlignLeft,
               QStringLiteral("cyan: outbound"));
    p.setPen(QColor(255, 190, 79));
    p.drawText(QRectF(pathRect.left() + 142.0, pathRect.top() + 5.0, 180.0, 20.0), Qt::AlignLeft,
               QStringLiteral("gold: return"));
    p.setPen(QColor(202, 211, 221));
    p.drawText(QRectF(pathRect.right() - 320.0, pathRect.top() + 5.0, 310.0, 20.0), Qt::AlignRight,
               QStringLiteral("t=%1   samples=%2")
                   .arg(last.time, 0, 'f', 2)
                   .arg(static_cast<qulonglong>(samples.size())));
 
    const double t0 = 0.0;
    const double tMax = std::max(2.0 * reversalTime, std::max(reversalTime, last.time));
    const auto mx = [&](double t) {
        return echoRect.left() + (t - t0) / std::max(1.0e-12, tMax - t0) * echoRect.width();
    };
    const auto my = [&](double f) {
        return echoRect.bottom() - clamp01(f) * echoRect.height();
    };
 
    p.setPen(QPen(QColor(65, 72, 82), 1.0));
    for (int i = 1; i < 4; ++i) {
        const double yy = echoRect.bottom() - echoRect.height() * static_cast<double>(i) / 4.0;
        p.drawLine(QPointF(echoRect.left(), yy), QPointF(echoRect.right(), yy));
    }
    p.setPen(QPen(QColor(236, 112, 255), 1.2, Qt::DashLine));
    p.drawLine(QPointF(mx(reversalTime), echoRect.top()), QPointF(mx(reversalTime), echoRect.bottom()));
    p.setPen(QPen(QColor(103, 232, 153), 1.2, Qt::DashLine));
    p.drawLine(QPointF(mx(2.0 * reversalTime), echoRect.top()), QPointF(mx(2.0 * reversalTime), echoRect.bottom()));
 
    QPainterPath densityPath;
    QPainterPath statePath;
    bool firstDensity = true;
    bool firstState = true;
    for (const qpe::QuantumLoschmidtSample2D &s : samples) {
        const QPointF pd(mx(s.time), my(s.densityEcho));
        const QPointF ps(mx(s.time), my(s.stateEcho));
        if (firstDensity) { densityPath.moveTo(pd); firstDensity = false; }
        else densityPath.lineTo(pd);
        if (firstState) { statePath.moveTo(ps); firstState = false; }
        else statePath.lineTo(ps);
    }
    p.setPen(QPen(QColor(79, 220, 255), 2.0));
    p.drawPath(densityPath);
    p.setPen(QPen(QColor(255, 190, 79), 2.0));
    p.drawPath(statePath);
 
    p.setPen(QColor(79, 220, 255));
    p.drawText(QRectF(echoRect.left() + 8.0, echoRect.top() + 5.0, 210.0, 20.0), Qt::AlignLeft,
               QStringLiteral("cyan: density echo"));
    p.setPen(QColor(255, 190, 79));
    p.drawText(QRectF(echoRect.left() + 165.0, echoRect.top() + 5.0, 300.0, 20.0), Qt::AlignLeft,
               QStringLiteral("gold: coherent state echo"));
 
    p.setPen(QColor(202, 211, 221));
    p.drawText(QRectF(4.0, echoRect.top() - 8.0, 48.0, 20.0), Qt::AlignRight, QStringLiteral("1"));
    p.drawText(QRectF(4.0, echoRect.bottom() - 10.0, 48.0, 20.0), Qt::AlignRight, QStringLiteral("0"));
    p.drawText(QRectF(echoRect.left(), echoRect.bottom() + 5.0, 70.0, 20.0), Qt::AlignLeft,
               QStringLiteral("0"));
    p.drawText(QRectF(mx(reversalTime) - 70.0, echoRect.bottom() + 5.0, 140.0, 20.0), Qt::AlignCenter,
               QStringLiteral("T = %1").arg(reversalTime, 0, 'f', 2));
    p.drawText(QRectF(mx(2.0 * reversalTime) - 75.0, echoRect.bottom() + 5.0, 150.0, 20.0), Qt::AlignCenter,
               QStringLiteral("2T = %1").arg(2.0 * reversalTime, 0, 'f', 2));
 
    p.setPen(QColor(215, 223, 232));
    p.drawText(QRectF(echoRect.right() - 390.0, echoRect.bottom() - 27.0, 380.0, 20.0), Qt::AlignRight,
               QStringLiteral("current: density=%1   state=%2   norm=%3")
                   .arg(last.densityEcho, 0, 'f', 4)
                   .arg(last.stateEcho, 0, 'f', 4)
                   .arg(last.norm, 0, 'f', 5));
}