wavepacketobservables2d_tests.cpp

Go to the documentation of this file.

/**
 * @file wavepacketobservables2d_tests.cpp
 * @brief Implements regression and invariant tests for wavepacketobservables2d tests.
 * @ingroup qpe_tests
 *
 * Source: @c tests/wavepacketobservables2d_tests.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 "wavepacketobservables2d_tests.h"
 
#include "core/math/complexfield2d.h"
#include "core/quantum/gaussianpacket2d.h"
#include "core/quantum/splitstepfouriersolver2d.h"
#include "core/quantum/wavepacketobservables2d.h"
 
#include <cmath>
#include <sstream>
 
namespace qpe { namespace tests {
namespace {
 
/**
 * @brief Performs near.
 * @param a The a value used by the operation.
 * @param b The b value used by the operation.
 * @param tolerance The tolerance value used by the operation.
 */
bool near(double a, double b, double tolerance)
{
    return std::abs(a - b) <= tolerance;
}
 
} // namespace
 
/**
 * @brief Runs wave packet observables2 d tests.
 * @param error Output diagnostic text on failure.
 */
bool runWavePacketObservables2DTests(std::string &error)
{
    error.clear();
 
    ComplexField2D field(256, 256, 0.08f, 0.08f);
 
    GaussianPacket2DParams packet;
    packet.centerX = -4.0f;
    packet.centerY = 0.75f;
    packet.sigma = 0.9f;
    packet.momentumX = 2.5f;
    packet.momentumY = 0.0f;
    packet.hbar = 1.0f;
    GaussianPacket2D::initialize(field, packet);
 
    const SpatialObservables2D initial = WavePacketObservables2D::spatial(field);
    if (!near(initial.norm2, 1.0, 2.0e-5) ||
        !near(initial.meanX, packet.centerX, 2.0e-3) ||
        !near(initial.meanY, packet.centerY, 2.0e-3) ||
        !near(initial.sigmaX, packet.sigma, 2.0e-3) ||
        !near(initial.sigmaY, packet.sigma, 2.0e-3)) {
        std::ostringstream ss;
        ss << "initial spatial observables mismatch: norm=" << initial.norm2
           << " meanX=" << initial.meanX << " meanY=" << initial.meanY
           << " sigmaX=" << initial.sigmaX << " sigmaY=" << initial.sigmaY;
        error = ss.str();
        return false;
    }
 
    SplitStepFourier2DParams solverParams;
    solverParams.mass = 1.0f;
    solverParams.hbar = 1.0f;
    solverParams.dt = 0.02f;
    SplitStepFourierSolver2D solver(solverParams);
 
    const int steps = 25; // t = 0.5
    for (int i = 0; i < steps; ++i) {
        solver.stepFree(field);
    }
 
    const SpatialObservables2D evolved = WavePacketObservables2D::spatial(field);
    const double t = solver.time();
    const double expectedMeanX = static_cast<double>(packet.centerX) +
        static_cast<double>(packet.momentumX) / solverParams.mass * t;
    const double sigma0 = packet.sigma;
    const double spreadingTerm = solverParams.hbar * t /
        (2.0 * solverParams.mass * sigma0 * sigma0);
    const double expectedSigma = sigma0 * std::sqrt(1.0 + spreadingTerm * spreadingTerm);
 
    if (!near(evolved.norm2, 1.0, 1.0e-4) ||
        !near(evolved.meanX, expectedMeanX, 1.5e-2) ||
        !near(evolved.meanY, packet.centerY, 5.0e-3) ||
        !near(evolved.sigmaX, expectedSigma, 1.5e-2) ||
        !near(evolved.sigmaY, expectedSigma, 1.5e-2)) {
        std::ostringstream ss;
        ss << "free propagation mismatch: norm=" << evolved.norm2
           << " meanX=" << evolved.meanX << " expectedX=" << expectedMeanX
           << " sigmaX=" << evolved.sigmaX << " expectedSigma=" << expectedSigma;
        error = ss.str();
        return false;
    }
 
    return true;
}
 
} } // namespace qpe::tests