quantumdoublewellplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumdoublewellplotwidget.cpp
 * @brief Implements the quantumdoublewellplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumdoublewellplotwidget.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 "quantumdoublewellplotwidget.h"
 
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
 
#include <algorithm>
#include <cmath>
 
namespace {
constexpr double kPi = 3.141592653589793238462643383279502884;
}
 
QuantumDoubleWellPlotWidget::QuantumDoubleWellPlotWidget(QWidget *parent)
    : QWidget(parent)
{
    setMinimumHeight(180);
    setAutoFillBackground(false);
}
 
void QuantumDoubleWellPlotWidget::setSamples(
    const std::vector<qpe::ObservablesTimeSeries2DSample> &samples)
{
    samples_ = samples;
    update();
}
 
void QuantumDoubleWellPlotWidget::setTheory(double period)
{
    period_ = period;
    update();
}
 
void QuantumDoubleWellPlotWidget::clear()
{
    samples_.clear();
    period_ = 0.0;
    update();
}
 
QSize QuantumDoubleWellPlotWidget::minimumSizeHint() const
{
    return QSize(480, 180);
}
 
void QuantumDoubleWellPlotWidget::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 plotRect(58.0, 26.0,
                          std::max(10.0, width() - 78.0),
                          std::max(10.0, height() - 64.0));
    painter.setPen(QPen(QColor(78, 86, 96), 1.0));
    for (int i = 0; i <= 4; ++i) {
        const double u = static_cast<double>(i) / 4.0;
        painter.drawLine(QPointF(plotRect.left() + u * plotRect.width(), plotRect.top()),
                         QPointF(plotRect.left() + u * plotRect.width(), plotRect.bottom()));
        painter.drawLine(QPointF(plotRect.left(), plotRect.top() + u * plotRect.height()),
                         QPointF(plotRect.right(), plotRect.top() + u * plotRect.height()));
    }
    painter.setPen(QPen(QColor(170, 180, 190), 1.0));
    painter.drawRect(plotRect);
 
    double tMin = 0.0;
    double tMax = period_ > 0.0 ? period_ : 1.0;
    bool haveSamples = false;
    for (const qpe::ObservablesTimeSeries2DSample &sample : samples_) {
        if (sample.hasDoubleWell) {
            if (!haveSamples) tMin = sample.time;
            tMax = std::max(tMax, sample.time);
            haveSamples = true;
        }
    }
    if (!(tMax > tMin)) tMax = tMin + 1.0;
 
    const auto mapX = [plotRect, tMin, tMax](double t) {
        return plotRect.left() + (t - tMin) / (tMax - tMin) * plotRect.width();
    };
    const auto mapY = [plotRect](double p) {
        const double clamped = std::max(0.0, std::min(1.0, p));
        return plotRect.bottom() - clamped * plotRect.height();
    };
 
    if (period_ > 0.0) {
        QPainterPath idealLeft;
        QPainterPath idealRight;
        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 phase = kPi * t / period_;
            const double left = std::cos(phase) * std::cos(phase);
            const double right = std::sin(phase) * std::sin(phase);
            const QPointF pl(mapX(t), mapY(left));
            const QPointF pr(mapX(t), mapY(right));
            if (i == 0) { idealLeft.moveTo(pl); idealRight.moveTo(pr); }
            else { idealLeft.lineTo(pl); idealRight.lineTo(pr); }
        }
        painter.setPen(QPen(QColor(100, 190, 225, 125), 1.2, Qt::DashLine));
        painter.drawPath(idealLeft);
        painter.setPen(QPen(QColor(255, 180, 105, 125), 1.2, Qt::DashLine));
        painter.drawPath(idealRight);
 
        const double transfer = 0.5 * period_;
        if (transfer >= tMin && transfer <= tMax) {
            painter.setPen(QPen(QColor(170, 175, 185), 1.0, Qt::DashDotLine));
            painter.drawLine(QPointF(mapX(transfer), plotRect.top()),
                             QPointF(mapX(transfer), plotRect.bottom()));
        }
    }
 
    QPainterPath leftPath;
    QPainterPath rightPath;
    bool first = true;
    for (const qpe::ObservablesTimeSeries2DSample &sample : samples_) {
        if (!sample.hasDoubleWell) continue;
        const QPointF pl(mapX(sample.time), mapY(sample.leftWellProbability));
        const QPointF pr(mapX(sample.time), mapY(sample.rightWellProbability));
        if (first) {
            leftPath.moveTo(pl);
            rightPath.moveTo(pr);
            first = false;
        } else {
            leftPath.lineTo(pl);
            rightPath.lineTo(pr);
        }
    }
 
    if (!first) {
        painter.setPen(QPen(QColor(100, 220, 255), 2.2));
        painter.drawPath(leftPath);
        painter.setPen(QPen(QColor(255, 185, 95), 2.2));
        painter.drawPath(rightPath);
    } else {
        painter.setPen(QColor(190, 195, 205));
        painter.drawText(plotRect, Qt::AlignCenter,
                         QStringLiteral("Load the coherent double-well experiment and press Play"));
    }
 
    painter.setPen(QColor(210, 215, 222));
    painter.drawText(QRectF(plotRect.left(), 2.0, plotRect.width(), 20.0),
                     Qt::AlignCenter,
                     QStringLiteral("Coherent tunnelling: left/right well population"));
    painter.setPen(QColor(160, 168, 178));
    painter.drawText(QRectF(2.0, plotRect.top() - 8.0, 52.0, 18.0),
                     Qt::AlignRight | Qt::AlignVCenter, QStringLiteral("1.0"));
    painter.drawText(QRectF(2.0, plotRect.bottom() - 10.0, 52.0, 18.0),
                     Qt::AlignRight | Qt::AlignVCenter, QStringLiteral("0.0"));
    painter.drawText(QRectF(plotRect.left(), plotRect.bottom() + 5.0,
                            plotRect.width(), 22.0),
                     Qt::AlignCenter, QStringLiteral("simulation time"));
 
    painter.setPen(QColor(100, 220, 255));
    painter.drawText(QRectF(plotRect.left() + 8.0, plotRect.top() + 5.0, 150.0, 18.0),
                     Qt::AlignLeft, QStringLiteral("P_left"));
    painter.setPen(QColor(255, 185, 95));
    painter.drawText(QRectF(plotRect.left() + 82.0, plotRect.top() + 5.0, 150.0, 18.0),
                     Qt::AlignLeft, QStringLiteral("P_right"));
}