quantumboundstateplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumboundstateplotwidget.cpp
 * @brief Implements the quantumboundstateplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumboundstateplotwidget.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 "quantumboundstateplotwidget.h"
 
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
 
#include <algorithm>
#include <cmath>
 
QuantumBoundStatePlotWidget::QuantumBoundStatePlotWidget(QWidget *parent)
    : QWidget(parent)
{
    setMinimumHeight(170);
    setAutoFillBackground(false);
}
 
void QuantumBoundStatePlotWidget::setSpectrum(const qpe::BoundStateSpectrum1D &spectrum,
                                              int selectedStateIndex)
{
    spectrum_ = spectrum;
    selectedStateIndex_ = selectedStateIndex;
    update();
}
 
void QuantumBoundStatePlotWidget::clearSpectrum()
{
    spectrum_ = qpe::BoundStateSpectrum1D();
    selectedStateIndex_ = -1;
    update();
}
 
QSize QuantumBoundStatePlotWidget::minimumSizeHint() const
{
    return QSize(480, 170);
}
 
void QuantumBoundStatePlotWidget::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(62.0, 26.0,
                          std::max(10.0, width() - 84.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);
 
    if (!spectrum_.valid || spectrum_.x.size() < 2u || spectrum_.states.empty()) {
        painter.setPen(QColor(190, 195, 205));
        painter.drawText(plotRect, Qt::AlignCenter,
                         QStringLiteral("Compute bound states for a Y-invariant confining potential"));
        return;
    }
 
    const double xMin = spectrum_.x.front();
    const double xMax = spectrum_.x.back();
    double yMin = *std::min_element(spectrum_.potential.begin(), spectrum_.potential.end());
    double yMax = *std::max_element(spectrum_.potential.begin(), spectrum_.potential.end());
    for (const qpe::BoundState1D &state : spectrum_.states) {
        yMin = std::min(yMin, state.energy);
        yMax = std::max(yMax, state.energy);
    }
    yMax = std::max(yMax, spectrum_.continuumThreshold);
    const double yPad = 0.08 * std::max(1.0e-9, yMax - yMin);
    yMin -= yPad;
    yMax += yPad;
 
    const auto mapX = [plotRect, xMin, xMax](double value) {
        const double u = (value - xMin) / std::max(1.0e-30, xMax - xMin);
        return plotRect.left() + u * plotRect.width();
    };
    const auto mapY = [plotRect, yMin, yMax](double value) {
        const double u = (value - yMin) / std::max(1.0e-30, yMax - yMin);
        return plotRect.bottom() - u * plotRect.height();
    };
 
    // Potential profile.
    QPainterPath potentialPath;
    for (std::size_t i = 0u; i < spectrum_.x.size(); ++i) {
        const QPointF p(mapX(spectrum_.x[i]), mapY(spectrum_.potential[i]));
        if (i == 0u) potentialPath.moveTo(p); else potentialPath.lineTo(p);
    }
    painter.setPen(QPen(QColor(185, 190, 198), 2.0));
    painter.drawPath(potentialPath);
 
    // Continuum/escape threshold.
    const double thresholdY = mapY(spectrum_.continuumThreshold);
    painter.setPen(QPen(QColor(130, 140, 150), 1.0, Qt::DashLine));
    painter.drawLine(QPointF(plotRect.left(), thresholdY), QPointF(plotRect.right(), thresholdY));
    painter.setPen(QColor(145, 152, 162));
    painter.drawText(QRectF(plotRect.right() - 150.0, thresholdY - 18.0, 146.0, 18.0),
                     Qt::AlignRight | Qt::AlignVCenter,
                     QStringLiteral("continuum %1").arg(spectrum_.continuumThreshold, 0, 'g', 5));
 
    // Energy ladder. Selected state is highlighted.
    for (std::size_t i = 0u; i < spectrum_.states.size(); ++i) {
        const qpe::BoundState1D &state = spectrum_.states[i];
        const bool selected = static_cast<int>(i) == selectedStateIndex_;
        painter.setPen(QPen(selected ? QColor(255, 184, 70) : QColor(82, 190, 235),
                            selected ? 2.0 : 1.2,
                            selected ? Qt::SolidLine : Qt::DashLine));
        const double y = mapY(state.energy);
        painter.drawLine(QPointF(plotRect.left(), y), QPointF(plotRect.right(), y));
        painter.setPen(selected ? QColor(255, 205, 115) : QColor(130, 205, 235));
        painter.drawText(QRectF(plotRect.left() + 5.0, y - 18.0, 130.0, 18.0),
                         Qt::AlignLeft | Qt::AlignVCenter,
                         QStringLiteral("n=%1  E=%2")
                             .arg(state.quantumNumber)
                             .arg(state.energy, 0, 'g', 5));
    }
 
    if (selectedStateIndex_ >= 0 &&
        selectedStateIndex_ < static_cast<int>(spectrum_.states.size())) {
        const qpe::BoundState1D &state = spectrum_.states[static_cast<std::size_t>(selectedStateIndex_)];
        float maxAbs = 0.0f;
        for (float value : state.amplitude) {
            maxAbs = std::max(maxAbs, std::abs(value));
        }
        if (maxAbs > 0.0f) {
            // Classic textbook view: draw phi_n vertically around its energy line.
            const double energySpan = std::max(1.0e-9, yMax - yMin);
            const double amplitudeEnergyScale = 0.075 * energySpan / static_cast<double>(maxAbs);
            QPainterPath statePath;
            for (std::size_t i = 0u; i < spectrum_.x.size(); ++i) {
                const double displayEnergy = state.energy +
                    amplitudeEnergyScale * static_cast<double>(state.amplitude[i]);
                const QPointF p(mapX(spectrum_.x[i]), mapY(displayEnergy));
                if (i == 0u) statePath.moveTo(p); else statePath.lineTo(p);
            }
            painter.setPen(QPen(QColor(255, 220, 120), 2.2));
            painter.drawPath(statePath);
 
            // Mark zero crossings of the selected real eigenfunction.
            painter.setBrush(QColor(255, 115, 125));
            painter.setPen(Qt::NoPen);
            const float nodeThreshold = 0.015f * maxAbs;
            for (std::size_t i = 1u; i < state.amplitude.size(); ++i) {
                const float a = state.amplitude[i - 1u];
                const float b = state.amplitude[i];
                if (std::max(std::abs(a), std::abs(b)) >= nodeThreshold &&
                    ((a < 0.0f && b > 0.0f) || (a > 0.0f && b < 0.0f))) {
                    const double t = std::abs(static_cast<double>(a)) /
                                     std::max(1.0e-30, std::abs(static_cast<double>(a)) +
                                                         std::abs(static_cast<double>(b)));
                    const double x = spectrum_.x[i - 1u] +
                                     t * (spectrum_.x[i] - spectrum_.x[i - 1u]);
                    painter.drawEllipse(QPointF(mapX(x), mapY(state.energy)), 3.2, 3.2);
                }
            }
        }
    }
 
    painter.setPen(QColor(210, 215, 222));
    painter.drawText(QRectF(plotRect.left(), 2.0, plotRect.width(), 20.0),
                     Qt::AlignCenter,
                     QStringLiteral("Bound-state ladder: V(x), E_n and selected eigenfunction"));
    painter.setPen(QColor(160, 168, 178));
    painter.drawText(QRectF(plotRect.left(), plotRect.bottom() + 5.0, plotRect.width(), 22.0),
                     Qt::AlignCenter, QStringLiteral("x"));
    painter.drawText(QRectF(2.0, plotRect.top() - 6.0, 55.0, 18.0),
                     Qt::AlignRight | Qt::AlignVCenter,
                     QString::number(yMax, 'g', 4));
    painter.drawText(QRectF(2.0, plotRect.bottom() - 10.0, 55.0, 18.0),
                     Qt::AlignRight | Qt::AlignVCenter,
                     QString::number(yMin, 'g', 4));
}