quantumkickedrotorplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumkickedrotorplotwidget.cpp
 * @brief Implements the quantumkickedrotorplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumkickedrotorplotwidget.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/quantumkickedrotorplotwidget.h"
 
#include "core/quantum/quantumkickedrotor2d.h"
 
#include <QPainter>
#include <QPainterPath>
#include <QPaintEvent>
#include <QPen>
#include <QString>
 
#include <algorithm>
#include <cmath>
 
namespace {
 
/**
 * @brief Performs heat color.
 * @param value Value to assign or evaluate.
 */
QColor heatColor(double value)
{
    value = std::max(0.0, std::min(1.0, value));
    if (value < 0.25) {
        const double u = value / 0.25;
        return QColor(8, static_cast<int>(25 + 80 * u), static_cast<int>(45 + 150 * u));
    }
    if (value < 0.55) {
        const double u = (value - 0.25) / 0.30;
        return QColor(static_cast<int>(15 + 30 * u), static_cast<int>(105 + 120 * u), 210);
    }
    if (value < 0.80) {
        const double u = (value - 0.55) / 0.25;
        return QColor(static_cast<int>(45 + 205 * u), static_cast<int>(225 - 40 * u), static_cast<int>(210 - 150 * u));
    }
    const double u = (value - 0.80) / 0.20;
    return QColor(250, static_cast<int>(185 + 70 * u), static_cast<int>(60 + 195 * u));
}
 
} // namespace
 
QuantumKickedRotorPlotWidget::QuantumKickedRotorPlotWidget(QWidget *parent)
    : QWidget(parent)
{
    setAutoFillBackground(false);
}
 
void QuantumKickedRotorPlotWidget::setData(const qpe::QuantumKickedRotorHistory2D &history)
{
    history_ = &history;
    update();
}
 
void QuantumKickedRotorPlotWidget::clear()
{
    history_ = nullptr;
    update();
}
 
QSize QuantumKickedRotorPlotWidget::minimumSizeHint() const
{
    return QSize(620, 410);
}
 
void QuantumKickedRotorPlotWidget::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));
    p.setPen(QColor(210, 220, 230));
 
    const int marginL = 58;
    const int marginR = 18;
    const int top = 28;
    const int gap = 40;
    const int bottom = 30;
    const int carpetH = std::max(120, (height() - top - bottom - gap) * 3 / 5);
    const int spreadH = std::max(90, height() - top - bottom - gap - carpetH);
    const QRect carpetRect(marginL, top, std::max(40, width() - marginL - marginR), carpetH);
    const QRect spreadRect(marginL, top + carpetH + gap,
                           std::max(40, width() - marginL - marginR), spreadH);
 
    p.drawText(QRect(8, 3, width() - 16, 20), Qt::AlignCenter,
               QStringLiteral("Quantum kicked rotor: diffusion in momentum, then dynamical localization"));
 
    if (!history_ || !history_->configured() || history_->empty()) {
        p.drawText(rect(), Qt::AlignCenter,
                   QStringLiteral("Run the Quantum Kicked Rotor preset"));
        return;
    }
 
    const std::vector<qpe::QuantumKickedRotorSample2D> &samples = history_->samples();
    p.setPen(QColor(72, 84, 96));
    p.drawRect(carpetRect);
    p.drawRect(spreadRect);
    p.setPen(QColor(210, 220, 230));
    p.drawText(QRect(carpetRect.left(), carpetRect.top() - 20, carpetRect.width(), 18),
               Qt::AlignLeft,
               QStringLiteral("Stroboscopic momentum carpet  P(n) after each kick"));
    p.drawText(QRect(spreadRect.left(), spreadRect.top() - 20, spreadRect.width(), 18),
               Qt::AlignLeft,
               QStringLiteral("Momentum diffusion: <n^2> quantum vs classical standard map"));
 
    std::size_t modeCount = 0u;
    double maxProbability = 0.0;
    for (const qpe::QuantumKickedRotorSample2D &s : samples) {
        modeCount = std::max(modeCount, s.modeProbability.size());
        for (float v : s.modeProbability) maxProbability = std::max(maxProbability, static_cast<double>(v));
    }
    maxProbability = std::max(maxProbability, 1.0e-12);
 
    if (modeCount > 0u) {
        const double rowH = static_cast<double>(carpetRect.height()) / static_cast<double>(samples.size());
        const double cellW = static_cast<double>(carpetRect.width()) / static_cast<double>(modeCount);
        for (std::size_t row = 0u; row < samples.size(); ++row) {
            const qpe::QuantumKickedRotorSample2D &s = samples[row];
            for (std::size_t col = 0u; col < s.modeProbability.size(); ++col) {
                const double normalized = std::sqrt(static_cast<double>(s.modeProbability[col]) / maxProbability);
                const QRectF cell(carpetRect.left() + static_cast<double>(col) * cellW,
                                  carpetRect.top() + static_cast<double>(row) * rowH,
                                  std::max(1.0, cellW + 0.5),
                                  std::max(1.0, rowH + 0.5));
                p.fillRect(cell, heatColor(normalized));
            }
        }
 
        const qpe::QuantumKickedRotorSample2D &latest = samples.back();
        const double nMin = latest.modeMin;
        const double nMax = latest.modeMin + latest.modeStep * static_cast<double>(modeCount - 1u);
        p.setPen(QColor(210, 220, 230));
        p.drawText(QRect(carpetRect.left(), carpetRect.bottom() + 3, carpetRect.width(), 20),
                   Qt::AlignLeft,
                   QStringLiteral("n=%1").arg(nMin, 0, 'f', 0));
        p.drawText(QRect(carpetRect.left(), carpetRect.bottom() + 3, carpetRect.width(), 20),
                   Qt::AlignCenter, QStringLiteral("momentum mode n"));
        p.drawText(QRect(carpetRect.left(), carpetRect.bottom() + 3, carpetRect.width(), 20),
                   Qt::AlignRight,
                   QStringLiteral("n=%1").arg(nMax, 0, 'f', 0));
        p.drawText(QRect(4, carpetRect.top(), 50, carpetRect.height()),
                   Qt::AlignRight | Qt::AlignTop,
                   QStringLiteral("kick 0"));
        p.drawText(QRect(4, carpetRect.top(), 50, carpetRect.height()),
                   Qt::AlignRight | Qt::AlignBottom,
                   QStringLiteral("kick %1").arg(static_cast<qulonglong>(latest.kickCount)));
    }
 
    const std::size_t maxKick = std::max<std::size_t>(1u, samples.back().kickCount);
    double yMax = 1.0;
    for (const qpe::QuantumKickedRotorSample2D &s : samples) {
        yMax = std::max(yMax, std::max(s.meanModeSquared, s.classicalMeanModeSquared));
    }
    auto mapKick = [&](std::size_t kick) {
        return spreadRect.left() + static_cast<double>(kick) /
            static_cast<double>(maxKick) * spreadRect.width();
    };
    auto mapY = [&](double value) {
        return spreadRect.bottom() - value / yMax * spreadRect.height();
    };
 
    auto drawSeries = [&](bool classical) {
        QPainterPath path;
        bool started = false;
        for (const qpe::QuantumKickedRotorSample2D &s : samples) {
            const double value = classical ? s.classicalMeanModeSquared : s.meanModeSquared;
            const QPointF point(mapKick(s.kickCount), mapY(value));
            if (!started) { path.moveTo(point); started = true; }
            else path.lineTo(point);
        }
        p.setPen(QPen(classical ? QColor(245, 166, 70) : QColor(80, 220, 235),
                      classical ? 1.6 : 2.2,
                      classical ? Qt::DashLine : Qt::SolidLine));
        p.drawPath(path);
    };
    drawSeries(false);
    drawSeries(true);
 
    p.setPen(QColor(80, 220, 235));
    p.drawText(spreadRect.adjusted(8, 6, -8, -6), Qt::AlignTop | Qt::AlignLeft,
               QStringLiteral("quantum <n^2>"));
    p.setPen(QColor(245, 166, 70));
    p.drawText(spreadRect.adjusted(8, 6, -8, -6), Qt::AlignTop | Qt::AlignRight,
               QStringLiteral("classical diffusion"));
    p.setPen(QColor(210, 220, 230));
    p.drawText(QRect(4, spreadRect.top(), 50, spreadRect.height()),
               Qt::AlignRight | Qt::AlignTop,
               QString::number(yMax, 'f', 0));
    p.drawText(QRect(spreadRect.left(), spreadRect.bottom() + 4, spreadRect.width(), 20),
               Qt::AlignCenter,
               QStringLiteral("number of kicks"));
}