quantumlandauzenerplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumlandauzenerplotwidget.cpp
 * @brief Implements the quantumlandauzenerplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumlandauzenerplotwidget.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 "quantumlandauzenerplotwidget.h"
 
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
 
#include <algorithm>
#include <cmath>
 
QuantumLandauZenerPlotWidget::QuantumLandauZenerPlotWidget(QWidget *parent)
    : QWidget(parent)
{
    setMinimumHeight(220);
    setAutoFillBackground(false);
}
 
void QuantumLandauZenerPlotWidget::setSamples(
    const std::vector<qpe::ObservablesTimeSeries2DSample> &samples)
{
    samples_ = samples;
    update();
}
 
void QuantumLandauZenerPlotWidget::setTheory(const qpe::LandauZenerTheory2D &theory)
{
    theory_ = theory;
    update();
}
 
void QuantumLandauZenerPlotWidget::setSweep(const qpe::LinearPotentialSweep2DConfig &sweep)
{
    sweep_ = sweep;
    update();
}
 
void QuantumLandauZenerPlotWidget::clear()
{
    samples_.clear();
    theory_ = qpe::LandauZenerTheory2D();
    sweep_ = qpe::LinearPotentialSweep2DConfig();
    update();
}
 
QSize QuantumLandauZenerPlotWidget::minimumSizeHint() const
{
    return QSize(520, 220);
}
 
void QuantumLandauZenerPlotWidget::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    QPainter painter(this);
    painter.setRenderHint(QPainter::Antialiasing, true);
    painter.setRenderHint(QPainter::TextAntialiasing, true);
    painter.fillRect(rect(), QColor(15, 18, 23));
 
    const QRectF probRect(58.0, 28.0,
                          std::max(10.0, width() - 80.0),
                          std::max(80.0, height() - 108.0));
    const QRectF biasRect(probRect.left(), probRect.bottom() + 18.0,
                          probRect.width(), 34.0);
 
    double tMin = 0.0;
    double tMax = sweep_.enabled ? sweep_.startTime + sweep_.duration : 1.0;
    bool haveSamples = false;
    for (const qpe::ObservablesTimeSeries2DSample &sample : samples_) {
        if (!sample.hasLandauZener) continue;
        if (!haveSamples) tMin = std::min(0.0, sample.time);
        tMax = std::max(tMax, sample.time);
        haveSamples = true;
    }
    if (!(tMax > tMin)) tMax = tMin + 1.0;
 
    const auto mapX = [probRect, tMin, tMax](double t) {
        return probRect.left() + (t - tMin) / (tMax - tMin) * probRect.width();
    };
    const auto mapP = [probRect](double p) {
        const double q = std::max(0.0, std::min(1.0, p));
        return probRect.bottom() - q * probRect.height();
    };
 
    painter.setPen(QPen(QColor(75, 84, 94), 1.0));
    for (int i = 0; i <= 4; ++i) {
        const double u = static_cast<double>(i) / 4.0;
        painter.drawLine(QPointF(probRect.left() + u * probRect.width(), probRect.top()),
                         QPointF(probRect.left() + u * probRect.width(), probRect.bottom()));
        painter.drawLine(QPointF(probRect.left(), probRect.top() + u * probRect.height()),
                         QPointF(probRect.right(), probRect.top() + u * probRect.height()));
    }
    painter.setPen(QPen(QColor(170, 180, 190), 1.0));
    painter.drawRect(probRect);
 
    if (theory_.valid && theory_.crossingTime >= tMin && theory_.crossingTime <= tMax) {
        painter.setPen(QPen(QColor(210, 210, 220, 120), 1.0, Qt::DashDotLine));
        painter.drawLine(QPointF(mapX(theory_.crossingTime), probRect.top()),
                         QPointF(mapX(theory_.crossingTime), biasRect.bottom()));
    }
 
    QPainterPath lowerPath;
    QPainterPath upperPath;
    QPainterPath leftPath;
    QPainterPath rightPath;
    QPainterPath capturedPath;
    bool first = true;
    for (const qpe::ObservablesTimeSeries2DSample &sample : samples_) {
        if (!sample.hasLandauZener) continue;
        const QPointF lower(mapX(sample.time), mapP(sample.landauZenerLowerPopulation));
        const QPointF upper(mapX(sample.time), mapP(sample.landauZenerUpperPopulation));
        const QPointF left(mapX(sample.time), mapP(sample.landauZenerLeftPopulation));
        const QPointF right(mapX(sample.time), mapP(sample.landauZenerRightPopulation));
        const QPointF captured(mapX(sample.time), mapP(sample.landauZenerCapturedPopulation));
        if (first) {
            lowerPath.moveTo(lower);
            upperPath.moveTo(upper);
            leftPath.moveTo(left);
            rightPath.moveTo(right);
            capturedPath.moveTo(captured);
            first = false;
        } else {
            lowerPath.lineTo(lower);
            upperPath.lineTo(upper);
            leftPath.lineTo(left);
            rightPath.lineTo(right);
            capturedPath.lineTo(captured);
        }
    }
 
    if (!first) {
        painter.setPen(QPen(QColor(105, 220, 255), 2.3));
        painter.drawPath(lowerPath);
        painter.setPen(QPen(QColor(255, 165, 100), 2.1));
        painter.drawPath(upperPath);
        painter.setPen(QPen(QColor(120, 235, 150, 180), 1.5, Qt::DashLine));
        painter.drawPath(leftPath);
        painter.setPen(QPen(QColor(225, 135, 245, 180), 1.5, Qt::DashLine));
        painter.drawPath(rightPath);
        painter.setPen(QPen(QColor(185, 190, 200), 1.0, Qt::DotLine));
        painter.drawPath(capturedPath);
    } else {
        painter.setPen(QColor(190, 195, 205));
        painter.drawText(probRect, Qt::AlignCenter,
                         QStringLiteral("Load a Landau-Zener sweep preset and press Play"));
    }
 
    painter.setPen(QPen(QColor(80, 88, 98), 1.0));
    painter.drawRect(biasRect);
    const double maxBias = std::max(1.0e-12,
        std::max(std::abs(sweep_.startValue), std::abs(sweep_.endValue)));
    const auto mapBiasY = [biasRect, maxBias](double value) {
        const double q = std::max(-1.0, std::min(1.0, value / maxBias));
        return biasRect.center().y() - 0.45 * q * biasRect.height();
    };
    painter.setPen(QPen(QColor(105, 115, 125), 1.0, Qt::DashLine));
    painter.drawLine(QPointF(biasRect.left(), biasRect.center().y()),
                     QPointF(biasRect.right(), biasRect.center().y()));
    if (sweep_.enabled) {
        QPainterPath biasPath;
        const int segments = 240;
        for (int i = 0; i <= segments; ++i) {
            const double t = tMin + (tMax - tMin) * static_cast<double>(i) /
                                        static_cast<double>(segments);
            const double value = qpe::TimeDependentPotential2D::sweepValue(sweep_, t);
            const QPointF point(mapX(t), mapBiasY(value));
            if (i == 0) biasPath.moveTo(point); else biasPath.lineTo(point);
        }
        painter.setPen(QPen(QColor(240, 215, 105), 1.8));
        painter.drawPath(biasPath);
    }
 
    painter.setPen(QColor(210, 215, 222));
    painter.drawText(QRectF(probRect.left(), 2.0, probRect.width(), 22.0),
                     Qt::AlignCenter,
                     QStringLiteral("Landau-Zener sweep: adiabatic and localized populations"));
    painter.setPen(QColor(160, 168, 178));
    painter.drawText(QRectF(2.0, probRect.top() - 8.0, 52.0, 18.0),
                     Qt::AlignRight | Qt::AlignVCenter, QStringLiteral("1.0"));
    painter.drawText(QRectF(2.0, probRect.bottom() - 10.0, 52.0, 18.0),
                     Qt::AlignRight | Qt::AlignVCenter, QStringLiteral("0.0"));
    painter.drawText(QRectF(2.0, biasRect.top() + 6.0, 52.0, 18.0),
                     Qt::AlignRight | Qt::AlignVCenter, QStringLiteral("bias"));
    painter.drawText(QRectF(probRect.left(), biasRect.bottom() + 3.0,
                            probRect.width(), 18.0),
                     Qt::AlignCenter, QStringLiteral("simulation time"));
 
    painter.setPen(QColor(105, 220, 255));
    painter.drawText(QRectF(probRect.left() + 8.0, probRect.top() + 4.0, 105.0, 18.0),
                     Qt::AlignLeft, QStringLiteral("P(lower)"));
    painter.setPen(QColor(255, 165, 100));
    painter.drawText(QRectF(probRect.left() + 92.0, probRect.top() + 4.0, 105.0, 18.0),
                     Qt::AlignLeft, QStringLiteral("P(upper)"));
    painter.setPen(QColor(120, 235, 150));
    painter.drawText(QRectF(probRect.left() + 176.0, probRect.top() + 4.0, 90.0, 18.0),
                     Qt::AlignLeft, QStringLiteral("P(left)"));
    painter.setPen(QColor(225, 135, 245));
    painter.drawText(QRectF(probRect.left() + 246.0, probRect.top() + 4.0, 95.0, 18.0),
                     Qt::AlignLeft, QStringLiteral("P(right)"));
}