quantumdriveplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumdriveplotwidget.cpp
 * @brief Implements the quantumdriveplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumdriveplotwidget.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 "quantumdriveplotwidget.h"
 
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
 
#include <algorithm>
#include <cmath>
#include <limits>
 
namespace {
const double Pi = 3.1415926535897932384626433832795;
}
 
QuantumDrivePlotWidget::QuantumDrivePlotWidget(QWidget *parent)
    : QWidget(parent)
{
    setMinimumHeight(190);
    setAutoFillBackground(false);
}
 
void QuantumDrivePlotWidget::setSamples(
    const std::vector<qpe::ObservablesTimeSeries2DSample> &samples)
{
    samples_ = samples;
    update();
}
 
void QuantumDrivePlotWidget::setDrive(double meanValue,
                                      double amplitude,
                                      double angularFrequency,
                                      double phaseDegrees)
{
    meanValue_ = meanValue;
    amplitude_ = amplitude;
    angularFrequency_ = angularFrequency;
    phaseRadians_ = phaseDegrees * Pi / 180.0;
    update();
}
 
void QuantumDrivePlotWidget::clear()
{
    samples_.clear();
    update();
}
 
QSize QuantumDrivePlotWidget::minimumSizeHint() const
{
    return QSize(480, 190);
}
 
void QuantumDrivePlotWidget::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, 28.0,
                          std::max(10.0, width() - 78.0),
                          std::max(10.0, height() - 66.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 tMax = 8.0;
    double xMaxAbs = std::max(1.0, std::abs(meanValue_) + std::abs(amplitude_));
    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.meanX)) xMaxAbs = std::max(xMaxAbs, std::abs(sample.meanX));
        if (std::isfinite(sample.totalEnergy)) {
            energyMin = std::min(energyMin, sample.totalEnergy);
            energyMax = std::max(energyMax, sample.totalEnergy);
        }
    }
    xMaxAbs *= 1.12;
    if (!(energyMax > energyMin)) {
        if (!std::isfinite(energyMin)) { energyMin = 0.0; energyMax = 1.0; }
        else { energyMin -= 0.5; energyMax += 0.5; }
    }
    const double ePad = 0.10 * std::max(1.0e-6, energyMax - energyMin);
    energyMin -= ePad;
    energyMax += ePad;
 
    const auto mapX = [plotRect, tMax](double t) {
        return plotRect.left() + t / tMax * plotRect.width();
    };
    const auto mapPosition = [plotRect, xMaxAbs](double v) {
        return plotRect.center().y() - v / xMaxAbs * 0.5 * plotRect.height();
    };
    const auto mapEnergy = [plotRect, energyMin, energyMax](double v) {
        return plotRect.bottom() - (v - energyMin) / (energyMax - energyMin) * plotRect.height();
    };
 
    painter.setPen(QPen(QColor(125, 132, 142), 1.0, Qt::DashLine));
    painter.drawLine(QPointF(plotRect.left(), mapPosition(0.0)),
                     QPointF(plotRect.right(), mapPosition(0.0)));
 
    QPainterPath drivePath;
    const int samples = 300;
    for (int i = 0; i <= samples; ++i) {
        const double t = tMax * static_cast<double>(i) / samples;
        const double center = meanValue_ + amplitude_ * std::sin(angularFrequency_ * t + phaseRadians_);
        const QPointF p(mapX(t), mapPosition(center));
        if (i == 0) drivePath.moveTo(p); else drivePath.lineTo(p);
    }
    painter.setPen(QPen(QColor(175, 125, 255), 1.4, Qt::DashLine));
    painter.drawPath(drivePath);
 
    QPainterPath meanPath;
    QPainterPath energyPath;
    bool first = true;
    for (const qpe::ObservablesTimeSeries2DSample &sample : samples_) {
        const QPointF pm(mapX(sample.time), mapPosition(sample.meanX));
        const QPointF pe(mapX(sample.time), mapEnergy(sample.totalEnergy));
        if (first) {
            meanPath.moveTo(pm);
            energyPath.moveTo(pe);
            first = false;
        } else {
            meanPath.lineTo(pm);
            energyPath.lineTo(pe);
        }
    }
    if (!first) {
        painter.setPen(QPen(QColor(100, 220, 255), 2.2));
        painter.drawPath(meanPath);
        painter.setPen(QPen(QColor(255, 170, 105), 1.7));
        painter.drawPath(energyPath);
    } else {
        painter.setPen(QColor(190, 195, 205));
        painter.drawText(plotRect, Qt::AlignCenter,
                         QStringLiteral("Load a Driven Harmonic Trap and press Play"));
    }
 
    painter.setPen(QColor(210, 215, 222));
    painter.drawText(QRectF(plotRect.left(), 2.0, plotRect.width(), 22.0),
                     Qt::AlignCenter,
                     QStringLiteral("Periodic drive: packet centre, trap centre and total energy"));
    painter.setPen(QColor(100, 220, 255));
    painter.drawText(QRectF(plotRect.left() + 8.0, plotRect.top() + 5.0, 90.0, 18.0),
                     Qt::AlignLeft, QStringLiteral("<x>"));
    painter.setPen(QColor(175, 125, 255));
    painter.drawText(QRectF(plotRect.left() + 52.0, plotRect.top() + 5.0, 120.0, 18.0),
                     Qt::AlignLeft, QStringLiteral("trap centre"));
    painter.setPen(QColor(255, 170, 105));
    painter.drawText(QRectF(plotRect.left() + 145.0, plotRect.top() + 5.0, 90.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"));
}