quantumtextureframe2d.cpp

Go to the documentation of this file.

/**
 * @file quantumtextureframe2d.cpp
 * @brief Implements the quantumtextureframe2d visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumtextureframe2d.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 "quantumtextureframe2d.h"
 
#include "core/math/complexfield2d.h"
#include "core/quantum/potentialfield2d.h"
 
#include <algorithm>
#include <cmath>
#include <stdexcept>
 
namespace qpe {
 
bool QuantumTextureFrame2D::empty() const noexcept
{
    const std::size_t sampleCount = width * height;
    return width == 0 || height == 0 ||
           probability.size() != sampleCount ||
           phase.size() != sampleCount ||
           potential.size() != sampleCount;
}
 
QuantumTextureFrame2D QuantumTextureFrame2D::build(const ComplexField2D &field,
                                                   const PotentialField2D &potentialField)
{
    if (field.empty()) {
        return QuantumTextureFrame2D();
    }
 
    if (!potentialField.empty() && !potentialField.matchesGrid(field)) {
        throw std::invalid_argument("QuantumTextureFrame2D: potential grid does not match wavefunction grid");
    }
 
    QuantumTextureFrame2D frame;
    frame.width = field.width();
    frame.height = field.height();
 
    const std::size_t sampleCount = field.size();
    frame.probability.resize(sampleCount);
    frame.phase.resize(sampleCount);
    frame.potential.resize(sampleCount, 0.0f);
 
    const ComplexField2D::Value *psi = field.data();
    const PotentialField2D::Value *potential = potentialField.empty()
                                                   ? nullptr
                                                   : potentialField.data();
 
    for (std::size_t i = 0; i < sampleCount; ++i) {
        const float real = psi[i].real();
        const float imag = psi[i].imag();
        const float p = real * real + imag * imag;
        const float ph = std::atan2(imag, real);
        const float v = potential ? potential[i] : 0.0f;
 
        frame.probability[i] = p;
        frame.phase[i] = ph;
        frame.potential[i] = v;
 
        frame.maxProbability = std::max(frame.maxProbability, p);
        frame.maxAbsPotential = std::max(frame.maxAbsPotential, std::abs(v));
    }
 
    return frame;
}
 
} // namespace qpe