potentialscene2d.cpp

Go to the documentation of this file.

/**
 * @file potentialscene2d.cpp
 * @brief Implements the potentialscene2d physics/numerical component used by QPE experiments.
 * @ingroup qpe_quantum
 *
 * Source: @c core/quantum/potentialscene2d.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 "potentialscene2d.h"
 
#include "potentialfield2d.h"
 
#include <algorithm>
#include <cmath>
#include <limits>
#include <vector>
 
namespace qpe {
namespace {
 
/**
 * @brief Performs finite.
 * @param v The v value used by the operation.
 */
bool finite(float v) noexcept
{
    return std::isfinite(static_cast<double>(v));
}
 
/**
 * @brief Performs positive.
 * @param v The v value used by the operation.
 */
bool positive(float v) noexcept
{
    return finite(v) && v > 0.0f;
}
 
/**
 * @brief Performs rasterize object.
 * @param object The object value used by the operation.
 * @param field Field data to read or modify.
 */
void rasterizeObject(const PotentialObject2D &object, PotentialField2D &field)
{
    switch (object.type) {
    case PotentialObjectType2D::Rectangle:
        field.addRectangle(object.centerX, object.centerY,
                           object.width, object.height, object.value);
        break;
    case PotentialObjectType2D::Circle:
        field.addCircle(object.centerX, object.centerY,
                        object.radius, object.value);
        break;
    case PotentialObjectType2D::Barrier: {
        const float halfLength = 0.5f * object.length;
        field.addBarrier(object.centerX, object.centerY - halfLength,
                         object.centerX, object.centerY + halfLength,
                         object.thickness, object.value);
        break;
    }
    case PotentialObjectType2D::SingleSlit:
        field.addSingleSlit(object.centerX, object.wallWidth,
                            object.centerY, object.slitHeight, object.value);
        break;
    case PotentialObjectType2D::DoubleSlit:
        field.addDoubleSlit(object.centerX, object.wallWidth,
                            object.centerY, object.slitSeparation,
                            object.slitHeight, object.value);
        break;
    case PotentialObjectType2D::PolygonWedge: {
        const float halfWidth = 0.5f * object.width;
        const float halfHeight = 0.5f * object.height;
        const std::vector<PotentialPoint2D> vertices = {
            {object.centerX - halfWidth, object.centerY},
            {object.centerX + halfWidth, object.centerY - halfHeight},
            {object.centerX + halfWidth, object.centerY + halfHeight}
        };
        field.addPolygon(vertices, object.value);
        break;
    }
    case PotentialObjectType2D::Gaussian:
        field.addGaussian(object.centerX, object.centerY,
                          object.sigmaX, object.sigmaY, object.value);
        break;
    case PotentialObjectType2D::Harmonic:
        field.addHarmonic(object.centerX, object.centerY, object.value,
                          object.curvatureX, object.curvatureY);
        break;
    case PotentialObjectType2D::Linear:
        field.addLinear(object.centerX, object.centerY, object.value,
                        object.slopeX, object.slopeY);
        break;
    case PotentialObjectType2D::SoftenedRadial:
        field.addSoftenedRadial(object.centerX, object.centerY,
                                object.value, object.softening);
        break;
    case PotentialObjectType2D::StadiumExterior:
        field.addStadiumExterior(object.centerX, object.centerY,
                                 object.width, object.radius, object.value);
        break;
    }
}
 
} // namespace
 
bool PotentialObject2D::valid() const noexcept
{
    if (!finite(value) || !finite(centerX) || !finite(centerY)) {
        return false;
    }
 
    switch (type) {
    case PotentialObjectType2D::Rectangle:
    case PotentialObjectType2D::PolygonWedge:
        return positive(width) && positive(height);
    case PotentialObjectType2D::Circle:
        return positive(radius);
    case PotentialObjectType2D::Barrier:
        return positive(length) && positive(thickness);
    case PotentialObjectType2D::SingleSlit:
        return positive(wallWidth) && positive(slitHeight);
    case PotentialObjectType2D::DoubleSlit:
        return positive(wallWidth) && positive(slitHeight) && positive(slitSeparation);
    case PotentialObjectType2D::Gaussian:
        return positive(sigmaX) && positive(sigmaY);
    case PotentialObjectType2D::Harmonic:
        return finite(curvatureX) && finite(curvatureY);
    case PotentialObjectType2D::Linear:
        return finite(slopeX) && finite(slopeY);
    case PotentialObjectType2D::SoftenedRadial:
        return positive(softening);
    case PotentialObjectType2D::StadiumExterior:
        return positive(width) && positive(radius);
    }
    return false;
}
 
std::uint64_t PotentialScene2D::allocateId() noexcept
{
    if (nextId_ == 0) {
        nextId_ = 1;
    }
    const std::uint64_t id = nextId_++;
    if (nextId_ == 0) {
        nextId_ = 1;
    }
    return id;
}
 
std::uint64_t PotentialScene2D::add(PotentialObject2D object)
{
    if (!object.valid()) {
        return 0;
    }
 
    if (object.id == 0 || find(object.id) != nullptr) {
        object.id = allocateId();
    } else if (object.id >= nextId_) {
        nextId_ = object.id + 1;
        if (nextId_ == 0) {
            nextId_ = 1;
        }
    }
 
    objects_.push_back(object);
    return object.id;
}
 
bool PotentialScene2D::update(std::uint64_t id, const PotentialObject2D &object)
{
    PotentialObject2D *existing = find(id);
    if (!existing) {
        return false;
    }
 
    PotentialObject2D replacement = object;
    replacement.id = id;
    if (!replacement.valid()) {
        return false;
    }
 
    *existing = replacement;
    return true;
}
 
bool PotentialScene2D::remove(std::uint64_t id)
{
    const std::vector<PotentialObject2D>::iterator it =
        std::find_if(objects_.begin(), objects_.end(),
                     [id](const PotentialObject2D &object) { return object.id == id; });
    if (it == objects_.end()) {
        return false;
    }
    objects_.erase(it);
    return true;
}
 
void PotentialScene2D::clear() noexcept
{
    objects_.clear();
    nextId_ = 1;
}
 
bool PotentialScene2D::empty() const noexcept
{
    return objects_.empty();
}
 
std::size_t PotentialScene2D::size() const noexcept
{
    return objects_.size();
}
 
const std::vector<PotentialObject2D> &PotentialScene2D::objects() const noexcept
{
    return objects_;
}
 
PotentialObject2D *PotentialScene2D::find(std::uint64_t id) noexcept
{
    for (PotentialObject2D &object : objects_) {
        if (object.id == id) {
            return &object;
        }
    }
    return nullptr;
}
 
const PotentialObject2D *PotentialScene2D::find(std::uint64_t id) const noexcept
{
    for (const PotentialObject2D &object : objects_) {
        if (object.id == id) {
            return &object;
        }
    }
    return nullptr;
}
 
void PotentialScene2D::rasterize(PotentialField2D &target) const
{
    target.clear();
    if (target.empty()) {
        return;
    }
 
    PotentialField2D scratch(target.width(), target.height(), target.dx(), target.dy());
    for (const PotentialObject2D &object : objects_) {
        if (!object.enabled || !object.valid()) {
            continue;
        }
        scratch.clear();
        rasterizeObject(object, scratch);
        target.accumulate(scratch);
    }
}
 
} // namespace qpe