diracspinor2d.cpp

Go to the documentation of this file.

/**
 * @file diracspinor2d.cpp
 * @brief Implements storage, normalization, observables, and utilities for two-component Dirac spinor fields.
 * @ingroup qpe_quantum
 *
 * Source: @c core/quantum/diracspinor2d.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 "diracspinor2d.h"
 
#include <algorithm>
#include <cmath>
 
namespace qpe {
 
DiracSpinor2D::DiracSpinor2D(std::size_t width, std::size_t height, float dx, float dy)
{
    resize(width, height, dx, dy);
}
 
void DiracSpinor2D::resize(std::size_t width, std::size_t height, float dx, float dy)
{
    upper_.resize(width, height, dx, dy);
    lower_.resize(width, height, dx, dy);
}
 
void DiracSpinor2D::clear() noexcept
{
    upper_.clear();
    lower_.clear();
}
 
void DiracSpinor2D::fill(const ComplexField2D::Value &upperValue,
                         const ComplexField2D::Value &lowerValue)
{
    upper_.fill(upperValue);
    lower_.fill(lowerValue);
}
 
bool DiracSpinor2D::empty() const noexcept
{
    return upper_.empty() || lower_.empty();
}
 
bool DiracSpinor2D::matchesGrid(const ComplexField2D &field) const noexcept
{
    return !empty() && !field.empty() &&
           width() == field.width() && height() == field.height() &&
           dx() == field.dx() && dy() == field.dy();
}
 
double DiracSpinor2D::norm2() const noexcept
{
    return empty() ? 0.0 : upper_.norm2() + lower_.norm2();
}
 
double DiracSpinor2D::norm() const noexcept
{
    return std::sqrt(norm2());
}
 
bool DiracSpinor2D::normalize() noexcept
{
    const double n = norm();
    if (!(n > 0.0) || !std::isfinite(n)) return false;
    const float s = static_cast<float>(1.0 / n);
    for (std::size_t i = 0; i < upper_.size(); ++i) {
        upper_.data()[i] *= s;
        lower_.data()[i] *= s;
    }
    return true;
}
 
double DiracSpinor2D::upperPopulation() const noexcept
{
    const double n = norm2();
    return n > 0.0 ? upper_.norm2() / n : 0.0;
}
 
double DiracSpinor2D::lowerPopulation() const noexcept
{
    const double n = norm2();
    return n > 0.0 ? lower_.norm2() / n : 0.0;
}
 
void DiracSpinor2D::writeDensityProxy(ComplexField2D &out) const
{
    if (empty()) {
        out.clear();
        return;
    }
    if (!matchesGrid(out)) out.resize(width(), height(), dx(), dy());
    for (std::size_t i = 0; i < upper_.size(); ++i) {
        const double rho = std::norm(upper_.data()[i]) + std::norm(lower_.data()[i]);
        out.data()[i] = ComplexField2D::Value(static_cast<float>(std::sqrt(std::max(0.0, rho))), 0.0f);
    }
}
 
} // namespace qpe