wavefunctioncrosssection2d.cpp

Go to the documentation of this file.

/**
 * @file wavefunctioncrosssection2d.cpp
 * @brief Implements the wavefunctioncrosssection2d physics/numerical component used by QPE experiments.
 * @ingroup qpe_quantum
 *
 * Source: @c core/quantum/wavefunctioncrosssection2d.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 "wavefunctioncrosssection2d.h"
 
#include "core/math/complexfield2d.h"
 
#include <algorithm>
#include <cmath>
 
namespace qpe {
namespace {
 
std::size_t nearestIndex(double coordinate,
                         std::size_t count,
                         double spacing)
{
    if (count == 0u || !(spacing > 0.0)) {
        return 0u;
    }
 
    const double center = 0.5 * static_cast<double>(count - 1u);
    const double floatingIndex = coordinate / spacing + center;
    const double clamped = std::max(0.0,
        std::min(static_cast<double>(count - 1u), floatingIndex));
    return static_cast<std::size_t>(std::llround(clamped));
}
 
/**
 * @brief Performs physical coordinate.
 * @param index Zero-based index of the selected item.
 * @param count The count value used by the operation.
 * @param spacing The spacing value used by the operation.
 */
double physicalCoordinate(std::size_t index,
                          std::size_t count,
                          double spacing)
{
    return (static_cast<double>(index) -
            0.5 * static_cast<double>(count - 1u)) * spacing;
}
 
/**
 * @brief Performs append sample.
 * @param value Value to assign or evaluate.
 * @param coordinate The coordinate value used by the operation.
 * @param out The out value used by the operation.
 */
void appendSample(const ComplexField2D::Value &value,
                  double coordinate,
                  WaveFunctionCrossSection2DData &out)
{
    const double re = static_cast<double>(value.real());
    const double im = static_cast<double>(value.imag());
    out.coordinate.push_back(coordinate);
    out.realPart.push_back(re);
    out.imaginaryPart.push_back(im);
    out.probability.push_back(re * re + im * im);
    out.phase.push_back(std::atan2(im, re));
}
 
} // namespace
 
WaveFunctionCrossSection2DData WaveFunctionCrossSection2D::sample(
    const ComplexField2D &field,
    CrossSectionAxis axis,
    double position)
{
    WaveFunctionCrossSection2DData out;
    out.axis = axis;
    out.requestedPosition = position;
 
    if (field.empty() || field.width() == 0u || field.height() == 0u) {
        return out;
    }
 
    if (axis == CrossSectionAxis::HorizontalY) {
        const std::size_t y = nearestIndex(position,
                                           field.height(),
                                           static_cast<double>(field.dy()));
        out.actualPosition = physicalCoordinate(y,
                                                field.height(),
                                                static_cast<double>(field.dy()));
        out.coordinate.reserve(field.width());
        out.probability.reserve(field.width());
        out.realPart.reserve(field.width());
        out.imaginaryPart.reserve(field.width());
        out.phase.reserve(field.width());
        for (std::size_t x = 0u; x < field.width(); ++x) {
            appendSample(field(x, y),
                         physicalCoordinate(x,
                                            field.width(),
                                            static_cast<double>(field.dx())),
                         out);
        }
    } else {
        const std::size_t x = nearestIndex(position,
                                           field.width(),
                                           static_cast<double>(field.dx()));
        out.actualPosition = physicalCoordinate(x,
                                                field.width(),
                                                static_cast<double>(field.dx()));
        out.coordinate.reserve(field.height());
        out.probability.reserve(field.height());
        out.realPart.reserve(field.height());
        out.imaginaryPart.reserve(field.height());
        out.phase.reserve(field.height());
        for (std::size_t y = 0u; y < field.height(); ++y) {
            appendSample(field(x, y),
                         physicalCoordinate(y,
                                            field.height(),
                                            static_cast<double>(field.dy())),
                         out);
        }
    }
 
    return out;
}
 
} // namespace qpe