quantumcrosssectionplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumcrosssectionplotwidget.cpp
 * @brief Implements the quantumcrosssectionplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumcrosssectionplotwidget.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 "quantumcrosssectionplotwidget.h"
 
#include <QPainter>
#include <QPainterPath>
#include <QPaintEvent>
 
#include <algorithm>
#include <cmath>
 
namespace {
const double kPi = 3.14159265358979323846;
}
 
QuantumCrossSectionPlotWidget::QuantumCrossSectionPlotWidget(QWidget *parent)
    : QWidget(parent)
{
    setMinimumHeight(180);
    setAutoFillBackground(false);
}
 
void QuantumCrossSectionPlotWidget::setCrossSection(
    const qpe::WaveFunctionCrossSection2DData &data)
{
    data_ = data;
    update();
}
 
void QuantumCrossSectionPlotWidget::clearCrossSection()
{
    data_ = qpe::WaveFunctionCrossSection2DData();
    update();
}
 
void QuantumCrossSectionPlotWidget::setCurve(Curve curve)
{
    curve_ = curve;
    update();
}
 
void QuantumCrossSectionPlotWidget::setMomentumSpace(bool momentumSpace)
{
    if (momentumSpace_ != momentumSpace) {
        momentumSpace_ = momentumSpace;
        update();
    }
}
 
QSize QuantumCrossSectionPlotWidget::minimumSizeHint() const
{
    return QSize(420, 180);
}
 
const std::vector<double> &QuantumCrossSectionPlotWidget::selectedValues() const
{
    switch (curve_) {
    case Curve::Real:
        return data_.realPart;
    case Curve::Imaginary:
        return data_.imaginaryPart;
    case Curve::Phase:
        return data_.phase;
    case Curve::Probability:
    default:
        return data_.probability;
    }
}
 
QString QuantumCrossSectionPlotWidget::curveTitle() const
{
    switch (curve_) {
    case Curve::Real: return QStringLiteral("Re(psi)");
    case Curve::Imaginary: return QStringLiteral("Im(psi)");
    case Curve::Phase: return QStringLiteral("phase / rad");
    case Curve::Probability:
    default:
        return momentumSpace_
            ? QStringLiteral("|psi_tilde|^2")
            : QStringLiteral("|psi|^2");
    }
}
 
void QuantumCrossSectionPlotWidget::valueRange(double &minimum, double &maximum) const
{
    const std::vector<double> &values = selectedValues();
    if (values.empty()) {
        minimum = 0.0;
        maximum = 1.0;
        return;
    }
 
    if (curve_ == Curve::Phase) {
        minimum = -kPi;
        maximum = kPi;
        return;
    }
 
    const std::pair<std::vector<double>::const_iterator,
                    std::vector<double>::const_iterator> mm =
        std::minmax_element(values.begin(), values.end());
    minimum = *mm.first;
    maximum = *mm.second;
 
    if (curve_ == Curve::Probability) {
        minimum = 0.0;
    } else {
        minimum = std::min(minimum, 0.0);
        maximum = std::max(maximum, 0.0);
    }
 
    if (!(maximum > minimum)) {
        const double pad = std::max(1.0, std::fabs(maximum)) * 0.5;
        minimum -= pad;
        maximum += pad;
    }
}
 
void QuantumCrossSectionPlotWidget::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, 24.0,
                          std::max(10.0, width() - 78.0),
                          std::max(10.0, height() - 62.0));
 
    painter.setPen(QPen(QColor(78, 86, 96), 1.0));
    for (int i = 0; i <= 4; ++i) {
        const double tx = static_cast<double>(i) / 4.0;
        const double x = plotRect.left() + tx * plotRect.width();
        painter.drawLine(QPointF(x, plotRect.top()), QPointF(x, plotRect.bottom()));
        const double y = plotRect.top() + tx * plotRect.height();
        painter.drawLine(QPointF(plotRect.left(), y), QPointF(plotRect.right(), y));
    }
 
    painter.setPen(QPen(QColor(170, 180, 190), 1.0));
    painter.drawRect(plotRect);
 
    if (data_.empty()) {
        painter.setPen(QColor(190, 195, 205));
        painter.drawText(plotRect, Qt::AlignCenter, QStringLiteral("No cross-section data"));
        return;
    }
 
    const std::vector<double> &values = selectedValues();
    if (values.size() != data_.coordinate.size() || values.size() < 2u) {
        return;
    }
 
    const double xMin = data_.coordinate.front();
    const double xMax = data_.coordinate.back();
    double yMin = 0.0;
    double yMax = 1.0;
    valueRange(yMin, yMax);
 
    const auto mapX = [plotRect, xMin, xMax](double x) {
        const double t = (x - xMin) / std::max(1.0e-30, xMax - xMin);
        return plotRect.left() + t * plotRect.width();
    };
    const auto mapY = [plotRect, yMin, yMax](double y) {
        const double t = (y - yMin) / std::max(1.0e-30, yMax - yMin);
        return plotRect.bottom() - t * plotRect.height();
    };
 
    if (yMin < 0.0 && yMax > 0.0) {
        painter.setPen(QPen(QColor(125, 130, 138), 1.0, Qt::DashLine));
        const double y0 = mapY(0.0);
        painter.drawLine(QPointF(plotRect.left(), y0), QPointF(plotRect.right(), y0));
    }
 
    QPainterPath path;
    path.moveTo(mapX(data_.coordinate[0]), mapY(values[0]));
    for (std::size_t i = 1u; i < values.size(); ++i) {
        path.lineTo(mapX(data_.coordinate[i]), mapY(values[i]));
    }
    painter.setPen(QPen(QColor(255, 200, 70), 2.0));
    painter.drawPath(path);
 
    painter.setPen(QColor(210, 215, 222));
    painter.drawText(QRectF(plotRect.left(), 2.0, plotRect.width(), 20.0),
                     Qt::AlignCenter,
                     QStringLiteral("%1   section=%2")
                         .arg(curveTitle())
                         .arg(data_.actualPosition, 0, 'f', 3));
 
    painter.setPen(QColor(160, 168, 178));
    painter.drawText(QRectF(2.0, plotRect.top() - 8.0, 52.0, 18.0),
                     Qt::AlignRight | Qt::AlignVCenter,
                     QString::number(yMax, 'g', 4));
    painter.drawText(QRectF(2.0, plotRect.bottom() - 10.0, 52.0, 18.0),
                     Qt::AlignRight | Qt::AlignVCenter,
                     QString::number(yMin, 'g', 4));
    painter.drawText(QRectF(plotRect.left(), plotRect.bottom() + 6.0, 80.0, 20.0),
                     Qt::AlignLeft,
                     QString::number(xMin, 'f', 2));
    painter.drawText(QRectF(plotRect.right() - 80.0, plotRect.bottom() + 6.0, 80.0, 20.0),
                     Qt::AlignRight,
                     QString::number(xMax, 'f', 2));
 
    QString axisName;
    if (momentumSpace_) {
        axisName = data_.axis == qpe::CrossSectionAxis::HorizontalY
            ? QStringLiteral("p_x") : QStringLiteral("p_y");
    } else {
        axisName = data_.axis == qpe::CrossSectionAxis::HorizontalY
            ? QStringLiteral("x") : QStringLiteral("y");
    }
    painter.drawText(QRectF(plotRect.left(), plotRect.bottom() + 4.0,
                            plotRect.width(), 24.0),
                     Qt::AlignCenter,
                     axisName);
}