ramseyinterferometry2d_tests.cpp

Go to the documentation of this file.

/**
 * @file ramseyinterferometry2d_tests.cpp
 * @brief Implements regression and invariant tests for ramseyinterferometry2d tests.
 * @ingroup qpe_tests
 *
 * Source: @c tests/ramseyinterferometry2d_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 "ramseyinterferometry2d_tests.h"
 
#include "core/quantum/boundstates1d.h"
#include "core/quantum/ramseyinterferometry2d.h"
#include "core/quantum/timedependentpotential2d.h"
 
#include <algorithm>
#include <cmath>
 
namespace qpe {
namespace tests {
 
/**
 * @brief Runs ramsey interferometry2 d tests.
 * @param errorMessage The error message value used by the operation.
 */
bool runRamseyInterferometry2DTests(std::string &errorMessage)
{
    errorMessage.clear();
 
    // A compact synthetic two-state spectrum is enough to test the Ramsey
    // reference model.  The full 2D split-step validation is kept separate.
    BoundStateSpectrum1D spectrum;
    spectrum.valid = true;
    spectrum.dx = 0.1;
    spectrum.x.resize(81u);
    for (std::size_t i = 0; i < spectrum.x.size(); ++i) {
        spectrum.x[i] = (static_cast<double>(i) - 40.0) * spectrum.dx;
    }
 
    BoundState1D ground;
    BoundState1D excited;
    ground.energy = 0.2;
    excited.energy = 0.5;
    ground.amplitude.resize(spectrum.x.size(), 0.0);
    excited.amplitude.resize(spectrum.x.size(), 0.0);
    for (std::size_t i = 0; i < spectrum.x.size(); ++i) {
        const double x = spectrum.x[i];
        ground.amplitude[i] = std::exp(-0.5 * x * x);
        excited.amplitude[i] = x * std::exp(-0.5 * x * x);
    }
    auto normalize = [&spectrum](std::vector<float> &v) {
        double n = 0.0;
        for (float q : v) n += q * q * spectrum.dx;
        n = std::sqrt(n);
        for (float &q : v) q = static_cast<float>(static_cast<double>(q) / n);
    };
    normalize(ground.amplitude);
    normalize(excited.amplitude);
    spectrum.states.push_back(ground);
    spectrum.states.push_back(excited);
 
    RamseyPulseSequence2DConfig sequence;
    sequence.enabled = true;
    sequence.targetObjectId = 1;
    sequence.parameter = TimePotentialParameter2D::LinearSlopeX;
    sequence.meanValue = 0.0;
    sequence.amplitude = 0.10;
    sequence.angularFrequency = 0.30;
    sequence.startTime = 0.0;
    sequence.pulseDuration = 12.0;
    sequence.freeEvolutionDuration = 5.0;
    sequence.firstPulsePhaseDegrees = 0.0;
    sequence.secondPulsePhaseDegrees = 0.0;
 
    const RamseyTheory2D theory = RamseyInterferometry2D::analyze(spectrum, sequence, 0, 1, 1.0);
    if (!theory.valid || std::abs(theory.transitionAngularFrequency - 0.30) > 1.0e-12 ||
        !(std::abs(theory.couplingMatrixElementX) > 0.1) ||
        !(theory.idealPiOver2Duration > 0.0) ||
        std::abs((theory.predictedFinalPopulationA + theory.predictedFinalPopulationB) - 1.0) > 2.0e-4) {
        errorMessage = "Ramsey theory analysis is inconsistent";
        return false;
    }
 
    const std::vector<RamseyFringeSample2D> fringe =
        RamseyInterferometry2D::scanFreeEvolution(spectrum, sequence, 0.0, 30.0, 61, 0, 1, 1.0);
    if (fringe.size() != 61u) {
        errorMessage = "Ramsey fringe scan has wrong sample count";
        return false;
    }
    double minP2 = 1.0;
    double maxP2 = 0.0;
    for (const RamseyFringeSample2D &sample : fringe) {
        minP2 = std::min(minP2, sample.populationB);
        maxP2 = std::max(maxP2, sample.populationB);
        if (sample.populationA < -1.0e-8 || sample.populationB < -1.0e-8 ||
            sample.populationA > 1.0001 || sample.populationB > 1.0001) {
            errorMessage = "Ramsey fringe population is out of range";
            return false;
        }
    }
    if (!(maxP2 - minP2 > 0.20)) {
        errorMessage = "Ramsey fringe contrast is unexpectedly small";
        return false;
    }
 
    // Step 27: a calibrated central pi pulse should strongly reduce the
    // sensitivity to free-evolution time in the same two-level reference.
    RamseyPulseSequence2DConfig echo = sequence;
    echo.echoEnabled = true;
    echo.echoPulseDuration = 2.0 * sequence.pulseDuration;
    echo.echoPulsePhaseDegrees = 90.0;
    const RamseyTheory2D echoTheory = RamseyInterferometry2D::analyze(spectrum, echo, 0, 1, 1.0);
    if (!echoTheory.valid || !echoTheory.echoEnabled ||
        !(echoTheory.echoPulseEnd > echoTheory.echoPulseStart)) {
        errorMessage = "Hahn-echo theory timing is invalid";
        return false;
    }
    const std::vector<RamseyFringeSample2D> echoFringe =
        RamseyInterferometry2D::scanFreeEvolution(spectrum, echo, 0.0, 30.0, 61, 0, 1, 1.0);
    if (echoFringe.size() != 61u) {
        errorMessage = "Hahn-echo fringe scan has wrong sample count";
        return false;
    }
 
    // Step 28: the static-detuning ensemble is diagnostic only.  Its mean
    // probabilities must remain normalized, and sigma=0 must collapse to the
    // nominal two-level prediction within the ensemble integration tolerance.
    RamseyEnsemble2DConfig ensemble;
    ensemble.enabled = true;
    ensemble.detuningStdDev = 0.06;
    ensemble.memberCount = 41;
    if (!RamseyInterferometry2D::validateEnsembleConfig(ensemble)) {
        errorMessage = "valid Ramsey ensemble config was rejected";
        return false;
    }
    const RamseyEnsembleResult2D ensembleResult =
        RamseyInterferometry2D::analyzeStaticDetuningEnsemble(
            spectrum, sequence, ensemble, 0, 1, 1.0);
    if (!ensembleResult.valid || ensembleResult.memberCount != 41 ||
        std::abs((ensembleResult.meanPopulationA + ensembleResult.meanPopulationB) - 1.0) > 3.0e-4 ||
        ensembleResult.meanPopulationA < -1.0e-8 || ensembleResult.meanPopulationB < -1.0e-8 ||
        ensembleResult.meanPopulationA > 1.0001 || ensembleResult.meanPopulationB > 1.0001) {
        errorMessage = "Ramsey static-detuning ensemble result is inconsistent";
        return false;
    }
    const std::vector<RamseyEnsembleFringeSample2D> ensembleFringe =
        RamseyInterferometry2D::scanFreeEvolutionEnsemble(
            spectrum, sequence, ensemble, 0.0, 30.0, 61, 0, 1, 1.0);
    if (ensembleFringe.size() != 61u) {
        errorMessage = "Ramsey ensemble fringe scan has wrong sample count";
        return false;
    }
    for (const RamseyEnsembleFringeSample2D &sample : ensembleFringe) {
        if (sample.meanPopulationA < -1.0e-8 || sample.meanPopulationB < -1.0e-8 ||
            sample.meanPopulationA > 1.0001 || sample.meanPopulationB > 1.0001 ||
            std::abs((sample.meanPopulationA + sample.meanPopulationB) - 1.0) > 3.0e-4) {
            errorMessage = "Ramsey ensemble fringe population is inconsistent";
            return false;
        }
    }
 
    RamseyEnsemble2DConfig zeroWidth = ensemble;
    zeroWidth.detuningStdDev = 0.0;
    const RamseyEnsembleResult2D zeroWidthResult =
        RamseyInterferometry2D::analyzeStaticDetuningEnsemble(
            spectrum, sequence, zeroWidth, 0, 1, 1.0);
    if (!zeroWidthResult.valid || zeroWidthResult.memberCount != 1 ||
        std::abs(zeroWidthResult.meanPopulationA - theory.predictedFinalPopulationA) > 2.0e-3 ||
        std::abs(zeroWidthResult.meanPopulationB - theory.predictedFinalPopulationB) > 2.0e-3) {
        errorMessage = "zero-width Ramsey ensemble does not reduce to the nominal system";
        return false;
    }
 
    RamseyEnsemble2DConfig invalidEnsemble = ensemble;
    invalidEnsemble.memberCount = 2;
    if (RamseyInterferometry2D::validateEnsembleConfig(invalidEnsemble)) {
        errorMessage = "invalid Ramsey ensemble config was accepted";
        return false;
    }
 
    return true;
}
 
} // namespace tests
} // namespace qpe