quantumquenchplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumquenchplotwidget.cpp
 * @brief Implements the quantumquenchplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumquenchplotwidget.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 "quantumquenchplotwidget.h"
 
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
 
#include <algorithm>
#include <cmath>
#include <limits>
 
QuantumQuenchPlotWidget::QuantumQuenchPlotWidget(QWidget *parent)
    : QWidget(parent)
{
    setMinimumHeight(180);
    setAutoFillBackground(false);
}
 
void QuantumQuenchPlotWidget::setSamples(
    const std::vector<qpe::ObservablesTimeSeries2DSample> &samples)
{
    samples_ = samples;
    update();
}
 
void QuantumQuenchPlotWidget::setQuenchTime(double time)
{
    quenchTime_ = time;
    update();
}
 
void QuantumQuenchPlotWidget::clear()
{
    samples_.clear();
    quenchTime_ = -1.0;
    update();
}
 
QSize QuantumQuenchPlotWidget::minimumSizeHint() const
{
    return QSize(480, 180);
}
 
void QuantumQuenchPlotWidget::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 = quenchTime_ > 0.0 ? quenchTime_ + 4.0 : 1.0;
    double sigmaMin = std::numeric_limits<double>::infinity();
    double sigmaMax = -std::numeric_limits<double>::infinity();
    double energyMin = std::numeric_limits<double>::infinity();
    double energyMax = -std::numeric_limits<double>::infinity();
    for (const qpe::ObservablesTimeSeries2DSample &sample : samples_) {
        tMax = std::max(tMax, sample.time);
        if (std::isfinite(sample.sigmaX)) {
            sigmaMin = std::min(sigmaMin, sample.sigmaX);
            sigmaMax = std::max(sigmaMax, sample.sigmaX);
        }
        if (std::isfinite(sample.totalEnergy)) {
            energyMin = std::min(energyMin, sample.totalEnergy);
            energyMax = std::max(energyMax, sample.totalEnergy);
        }
    }
    if (!(tMax > tMin)) tMax = tMin + 1.0;
    if (!(sigmaMax > sigmaMin)) { sigmaMin = 0.0; sigmaMax = std::max(1.0, sigmaMax); }
    if (!(energyMax > energyMin)) { energyMin -= 0.5; energyMax += 0.5; }
    const double sigmaPad = 0.10 * std::max(1.0e-6, sigmaMax - sigmaMin);
    sigmaMin = std::max(0.0, sigmaMin - sigmaPad);
    sigmaMax += sigmaPad;
    const double energyPad = 0.10 * std::max(1.0e-6, energyMax - energyMin);
    energyMin -= energyPad;
    energyMax += energyPad;
 
    const auto mapX = [plotRect, tMin, tMax](double t) {
        return plotRect.left() + (t - tMin) / (tMax - tMin) * plotRect.width();
    };
    const auto mapSigma = [plotRect, sigmaMin, sigmaMax](double v) {
        return plotRect.bottom() - (v - sigmaMin) / (sigmaMax - sigmaMin) * plotRect.height();
    };
    const auto mapEnergy = [plotRect, energyMin, energyMax](double v) {
        return plotRect.bottom() - (v - energyMin) / (energyMax - energyMin) * plotRect.height();
    };
 
    if (quenchTime_ >= tMin && quenchTime_ <= tMax) {
        painter.setPen(QPen(QColor(255, 220, 100), 1.5, Qt::DashLine));
        painter.drawLine(QPointF(mapX(quenchTime_), plotRect.top()),
                         QPointF(mapX(quenchTime_), plotRect.bottom()));
        painter.drawText(QRectF(mapX(quenchTime_) + 4.0, plotRect.top() + 2.0, 80.0, 18.0),
                         Qt::AlignLeft, QStringLiteral("quench"));
    }
 
    QPainterPath sigmaPath;
    QPainterPath energyPath;
    bool first = true;
    for (const qpe::ObservablesTimeSeries2DSample &sample : samples_) {
        const QPointF ps(mapX(sample.time), mapSigma(sample.sigmaX));
        const QPointF pe(mapX(sample.time), mapEnergy(sample.totalEnergy));
        if (first) {
            sigmaPath.moveTo(ps);
            energyPath.moveTo(pe);
            first = false;
        } else {
            sigmaPath.lineTo(ps);
            energyPath.lineTo(pe);
        }
    }
 
    if (!first) {
        painter.setPen(QPen(QColor(100, 220, 255), 2.2));
        painter.drawPath(sigmaPath);
        painter.setPen(QPen(QColor(255, 170, 105), 1.8));
        painter.drawPath(energyPath);
    } else {
        painter.setPen(QColor(190, 195, 205));
        painter.drawText(plotRect, Qt::AlignCenter,
                         QStringLiteral("Load Quantum Quench and press Play"));
    }
 
    painter.setPen(QColor(210, 215, 222));
    painter.drawText(QRectF(plotRect.left(), 2.0, plotRect.width(), 20.0),
                     Qt::AlignCenter,
                     QStringLiteral("Quantum quench: width and total energy"));
    painter.setPen(QColor(100, 220, 255));
    painter.drawText(QRectF(plotRect.left() + 8.0, plotRect.top() + 5.0, 110.0, 18.0),
                     Qt::AlignLeft, QStringLiteral("sigmaX"));
    painter.setPen(QColor(255, 170, 105));
    painter.drawText(QRectF(plotRect.left() + 80.0, plotRect.top() + 5.0, 110.0, 18.0),
                     Qt::AlignLeft, QStringLiteral("<H>"));
    painter.setPen(QColor(160, 168, 178));
    painter.drawText(QRectF(plotRect.left(), plotRect.bottom() + 5.0,
                            plotRect.width(), 22.0),
                     Qt::AlignCenter, QStringLiteral("simulation time"));
}