quantumzeno2d_tests.cpp

Go to the documentation of this file.

/**
 * @file quantumzeno2d_tests.cpp
 * @brief Implements regression and invariant tests for quantumzeno2d tests.
 * @ingroup qpe_tests
 *
 * Source: @c tests/quantumzeno2d_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 "tests/quantumzeno2d_tests.h"
 
#include "core/quantum/absorbingboundary2d.h"
#include "core/quantum/potentialfield2d.h"
#include "core/quantum/quantumzeno2d.h"
#include "core/quantum/splitstepfouriersolver2d.h"
 
#include <cmath>
 
namespace qpe {
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::fabs(a - b) <= tolerance;
}
 
/**
 * @brief Performs guided config.
 */
QuantumZeno2DConfig guidedConfig()
{
    QuantumZeno2DConfig config;
    config.enabled = true;
    config.firstMeasurementTime = 0.40;
    config.measurementPeriod = 0.10;
    config.laneSplitY = 0.0;
    config.survivalBoundaryX = 0.40;
    config.edgeWidth = 0.32;
    return config;
}
 
/**
 * @brief Performs guided initial.
 */
QuantumZenoInitialState2DConfig guidedInitial()
{
    QuantumZenoInitialState2DConfig initial;
    initial.centerX = -5.5;
    initial.controlLaneY = 4.8;
    initial.watchedLaneY = -4.8;
    initial.sigma = 0.80;
    initial.momentumX = 1.50;
    return initial;
}
 
/**
 * @brief Builds guided potential.
 * @param potential Potential field used by the operation.
 */
void buildGuidedPotential(PotentialField2D &potential)
{
    const float fullWidth = 40.96f;
    potential.addRectangle(0.0f, 0.0f, fullWidth, 0.64f, 120.0f);
    potential.addRectangle(0.0f, 9.76f, fullWidth, 0.48f, 120.0f);
    potential.addRectangle(0.0f, -9.76f, fullWidth, 0.48f, 120.0f);
    potential.addRectangle(-9.0f, 4.8f, 0.64f, 8.60f, 120.0f);
    potential.addRectangle(-9.0f, -4.8f, 0.64f, 8.60f, 120.0f);
    potential.addRectangle(0.0f, 4.8f, 0.80f, 8.60f, 4.0f);
    potential.addRectangle(0.0f, -4.8f, 0.80f, 8.60f, 4.0f);
}
 
/**
 * @brief Performs test dual lane initialization.
 */
bool testDualLaneInitialization()
{
    ComplexField2D field(128u, 128u, 0.32f, 0.16f);
    const QuantumZenoInitialState2DConfig initial = guidedInitial();
    const QuantumZeno2DConfig config = guidedConfig();
    if (!QuantumZeno2D::initializeDualLane(field, initial, nullptr)) return false;
    const double control = QuantumZeno2D::laneNorm(field, config, false);
    const double watched = QuantumZeno2D::laneNorm(field, config, true);
    return near(field.norm2(), 1.0, 3.0e-5) &&
           near(control, 0.5, 2.0e-3) && near(watched, 0.5, 2.0e-3);
}
 
/**
 * @brief Performs test measurement preserves control and renormalizes watched.
 */
bool testMeasurementPreservesControlAndRenormalizesWatched()
{
    ComplexField2D field(128u, 128u, 0.32f, 0.16f);
    const QuantumZenoInitialState2DConfig initial = guidedInitial();
    const QuantumZeno2DConfig config = guidedConfig();
    if (!QuantumZeno2D::initializeDualLane(field, initial, nullptr)) return false;
 
    const double controlBefore = QuantumZeno2D::laneNorm(field, config, false);
    const double watchedTarget = QuantumZeno2D::laneNorm(field, config, true);
    QuantumZenoMeasurementResult2D result;
    if (!QuantumZeno2D::applySurvivalMeasurement(
            field, config, watchedTarget, result, nullptr)) return false;
 
    const double controlAfter = QuantumZeno2D::laneNorm(field, config, false);
    return result.valid && result.acceptanceProbability > 0.99 &&
           near(controlBefore, controlAfter, 5.0e-6) &&
           near(result.watchedNormAfterRenormalization, watchedTarget, 5.0e-5);
}
 
/**
 * @brief Performs test watched escape suppression.
 */
bool testWatchedEscapeSuppression()
{
    ComplexField2D field(128u, 128u, 0.32f, 0.16f);
    const QuantumZenoInitialState2DConfig initial = guidedInitial();
    const QuantumZeno2DConfig config = guidedConfig();
    if (!QuantumZeno2D::initializeDualLane(field, initial, nullptr)) return false;
 
    PotentialField2D potential(128u, 128u, 0.32f, 0.16f);
    buildGuidedPotential(potential);
 
    SplitStepFourier2DParams params;
    params.mass = 1.0f;
    params.hbar = 1.0f;
    params.dt = 0.02f;
    SplitStepFourierSolver2D solver(params);
    solver.prepare(field);
    solver.preparePotential(potential);
 
    AbsorbingBoundary2D absorber;
    AbsorbingBoundary2DParams boundary;
    boundary.enabled = true;
    boundary.widthFraction = 0.12f;
    boundary.strength = 5.0f;
    boundary.exponent = 3.0f;
    absorber.configure(field, params.dt, boundary);
 
    const double targetWatched = QuantumZeno2D::laneNorm(field, config, true);
    const double initialControl = QuantumZeno2D::laneNorm(field, config, false);
    double cumulative = 1.0;
    std::size_t measurementCount = 0u;
 
    while (solver.time() < 15.0 - 1.0e-9) {
        const double epsilon = 0.5 * static_cast<double>(params.dt) + 1.0e-9;
        while (solver.time() + epsilon >=
               QuantumZeno2D::scheduledMeasurementTime(config, measurementCount)) {
            QuantumZenoMeasurementResult2D result;
            if (!QuantumZeno2D::applySurvivalMeasurement(
                    field, config, targetWatched, result, nullptr)) return false;
            cumulative *= result.acceptanceProbability;
            ++measurementCount;
        }
        solver.step(field, potential);
        absorber.apply(field);
    }
 
    const QuantumZenoSample2D sample = QuantumZeno2D::measure(
        field, config, solver.time(), measurementCount, cumulative, initialControl);
 
    // The watched ensemble should retain much more survival probability than
    // the unmeasured control after the same tunnelling/escape time.
    return measurementCount > 100u &&
           sample.controlSurvival < 0.75 &&
           sample.watchedCumulativeSurvival > 0.80 &&
           sample.watchedCumulativeSurvival > sample.controlSurvival + 0.18 &&
           sample.watchedConditionalAcceptance > 0.97 &&
           sample.totalNorm > 0.70 && sample.totalNorm < 1.10;
}
 
} // namespace
 
bool QuantumZeno2DTests::runAll()
{
    return testDualLaneInitialization() &&
           testMeasurementPreservesControlAndRenormalizesWatched() &&
           testWatchedEscapeSuppression();
}
 
} // namespace qpe