experimentdocument2d_tests.cpp

Go to the documentation of this file.

/**
 * @file experimentdocument2d_tests.cpp
 * @brief Implements regression and invariant tests for experimentdocument2d tests.
 * @ingroup qpe_tests
 *
 * Source: @c tests/experimentdocument2d_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 "experimentdocument2d_tests.h"
 
#include "core/experiments/experimentdocument2d.h"
 
#include <QJsonArray>
#include <QJsonObject>
#include <QTemporaryDir>
 
#include <cmath>
 
namespace qpe {
namespace tests {
 
/**
 * @brief Runs experiment document2 d tests.
 * @param errorMessage The error message value used by the operation.
 */
bool runExperimentDocument2DTests(std::string &errorMessage)
{
    errorMessage.clear();
 
    ExperimentDocument2D source;
    source.name = QStringLiteral("Round trip test");
    source.sourcePreset = QStringLiteral("Quantum Tunneling (E < V0)");
    source.controls.insert(QStringLiteral("universeWidthSpinBox"), 61.44);
    source.controls.insert(QStringLiteral("geometryComboBox"), 3);
    source.controls.insert(QStringLiteral("currentOverlayCheckBox"), true);
 
    PotentialObject2D barrier;
    barrier.type = PotentialObjectType2D::Barrier;
    barrier.value = 4.5f;
    barrier.centerX = -0.5f;
    barrier.centerY = 0.0f;
    barrier.length = 20.0f;
    barrier.thickness = 0.64f;
    const std::uint64_t barrierId = source.potentialScene.add(barrier);
    source.potentialSceneActive = true;
    source.initialPreparationMode = 2;
    source.boundStateA = 0;
    source.boundStateB = 2;
    source.boundRelativePhaseDegrees = 45.0;
    source.collapseResolution = 0.72;
    source.quench.enabled = true;
    source.quench.targetObjectId = barrierId;
    source.quench.parameter = TimePotentialParameter2D::ObjectValue;
    source.quench.quenchTime = 1.25;
    source.quench.beforeValue = 4.5;
    source.quench.afterValue = 2.25;
 
    PotentialObject2D second = barrier;
    second.centerX = 1.0f;
    const std::uint64_t secondId = source.potentialScene.add(second);
 
    source.periodicDrive.enabled = true;
    source.periodicDrive.targetObjectId = secondId;
    source.periodicDrive.parameter = TimePotentialParameter2D::CenterX;
    source.periodicDrive.meanValue = 1.0;
    source.periodicDrive.amplitude = 0.7;
    source.periodicDrive.angularFrequency = 0.5;
    source.periodicDrive.phaseDegrees = 30.0;
 
    PotentialObject2D gaussian;
    gaussian.type = PotentialObjectType2D::Gaussian;
    gaussian.value = -3.5f;
    gaussian.centerX = 2.0f;
    gaussian.sigmaX = 1.25f;
    gaussian.sigmaY = 2.5f;
    const std::uint64_t gaussianId = source.potentialScene.add(gaussian);
 
    PotentialObject2D linearBias;
    linearBias.type = PotentialObjectType2D::Linear;
    linearBias.slopeX = 0.35f;
    const std::uint64_t biasId = source.potentialScene.add(linearBias);
    source.linearSweep.enabled = true;
    source.linearSweep.targetObjectId = biasId;
    source.linearSweep.parameter = TimePotentialParameter2D::LinearSlopeX;
    source.linearSweep.startValue = 0.35;
    source.linearSweep.endValue = -0.35;
    source.linearSweep.startTime = 0.5;
    source.linearSweep.duration = 4.0;
    source.linearSweep.returnEnabled = true;
    source.linearSweep.holdDuration = 4.0;
    source.linearSweep.returnDuration = 4.0;
 
    source.ramseySequence.enabled = true;
    source.ramseySequence.targetObjectId = biasId;
    source.ramseySequence.parameter = TimePotentialParameter2D::LinearSlopeX;
    source.ramseySequence.meanValue = 0.0;
    source.ramseySequence.amplitude = 0.10;
    source.ramseySequence.angularFrequency = 0.305536;
    source.ramseySequence.firstPulsePhaseDegrees = 0.0;
    source.ramseySequence.secondPulsePhaseDegrees = 0.0;
    source.ramseySequence.startTime = 0.25;
    source.ramseySequence.pulseDuration = 14.35;
    source.ramseySequence.freeEvolutionDuration = 5.5;
    source.ramseySequence.echoEnabled = true;
    source.ramseySequence.echoPulseDuration = 25.75;
    source.ramseySequence.echoPulsePhaseDegrees = 90.0;
    source.ramseyEnsemble.enabled = true;
    source.ramseyEnsemble.detuningStdDev = 0.06;
    source.ramseyEnsemble.memberCount = 41;
    source.talbotInitialState.period = 5.12;
    source.talbotInitialState.toothSigma = 0.45;
    source.talbotInitialState.offsetX = 0.32;
    source.talbotInitialState.centerY = -8.0;
    source.talbotInitialState.sigmaY = 1.5;
    source.talbotInitialState.momentumY = 1.2;
    source.vortexInitialState.envelopeCenterX = 0.0;
    source.vortexInitialState.envelopeCenterY = 0.0;
    source.vortexInitialState.envelopeSigma = 1.0;
    source.vortexInitialState.coreX = 1.0;
    source.vortexInitialState.coreY = 0.0;
    source.vortexInitialState.charge = 1;
    source.andersonInitialState.centerX = 0.0;
    source.andersonInitialState.cleanLaneY = 4.0;
    source.andersonInitialState.disorderLaneY = -4.0;
    source.andersonInitialState.sigma = 0.35;
    source.andersonInitialState.relativePhaseDegrees = 0.0;
    source.kickedRotor.enabled = true;
    source.kickedRotor.firstKickTime = 0.20;
    source.kickedRotor.kickPeriod = 1.0;
    source.kickedRotor.phaseStrength = 6.0;
    source.kickedRotorInitialState.yCenter = 0.0;
    source.kickedRotorInitialState.ySigma = 1.5;
    source.kickedRotorInitialState.initialMomentumMode = 0;
    source.quantumZeno.enabled = true;
    source.quantumZeno.firstMeasurementTime = 0.40;
    source.quantumZeno.measurementPeriod = 0.10;
    source.quantumZeno.laneSplitY = 0.0;
    source.quantumZeno.survivalBoundaryX = 0.40;
    source.quantumZeno.edgeWidth = 0.32;
    source.quantumZenoInitialState.centerX = -5.5;
    source.quantumZenoInitialState.controlLaneY = 4.8;
    source.quantumZenoInitialState.watchedLaneY = -4.8;
    source.quantumZenoInitialState.sigma = 0.80;
    source.quantumZenoInitialState.momentumX = 1.50;
    source.quantumZenoInitialState.relativePhaseDegrees = 0.0;
    source.quantumScar.enabled = true;
    source.quantumScar.orbitBandHalfWidth = 0.80;
    source.quantumScar.referenceEnergy = 9.50;
 
    const QJsonObject json = ExperimentDocument2DJson::toJson(source);
 
    ExperimentDocument2D restored;
    QString qtError;
    if (!ExperimentDocument2DJson::fromJson(json, restored, qtError)) {
        errorMessage = std::string("round trip parse failed: ") + qtError.toStdString();
        return false;
    }
 
    if (restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion ||
        restored.name != source.name ||
        restored.sourcePreset != source.sourcePreset ||
        restored.controls.value(QStringLiteral("geometryComboBox")).toInt() != 3 ||
        !restored.controls.value(QStringLiteral("currentOverlayCheckBox")).toBool() ||
        !restored.potentialSceneActive ||
        restored.potentialScene.size() != 4 ||
        !restored.potentialScene.find(barrierId) ||
        !restored.potentialScene.find(secondId) ||
        !restored.potentialScene.find(gaussianId) ||
        !restored.potentialScene.find(biasId) ||
        std::abs(restored.potentialScene.find(gaussianId)->sigmaY - 2.5f) > 1.0e-6f ||
        restored.initialPreparationMode != 2 || restored.boundStateA != 0 ||
        restored.boundStateB != 2 ||
        std::abs(restored.boundRelativePhaseDegrees - 45.0) > 1.0e-12 ||
        std::abs(restored.collapseResolution - 0.72) > 1.0e-12 ||
        !restored.quench.enabled || restored.quench.targetObjectId != barrierId ||
        restored.quench.parameter != TimePotentialParameter2D::ObjectValue ||
        std::abs(restored.quench.quenchTime - 1.25) > 1.0e-12 ||
        std::abs(restored.quench.afterValue - 2.25) > 1.0e-12 ||
        !restored.periodicDrive.enabled || restored.periodicDrive.targetObjectId != secondId ||
        restored.periodicDrive.parameter != TimePotentialParameter2D::CenterX ||
        std::abs(restored.periodicDrive.amplitude - 0.7) > 1.0e-12 ||
        std::abs(restored.periodicDrive.angularFrequency - 0.5) > 1.0e-12 ||
        std::abs(restored.periodicDrive.phaseDegrees - 30.0) > 1.0e-12 ||
        !restored.linearSweep.enabled || restored.linearSweep.targetObjectId != biasId ||
        restored.linearSweep.parameter != TimePotentialParameter2D::LinearSlopeX ||
        std::abs(restored.linearSweep.startValue - 0.35) > 1.0e-12 ||
        std::abs(restored.linearSweep.endValue + 0.35) > 1.0e-12 ||
        std::abs(restored.linearSweep.startTime - 0.5) > 1.0e-12 ||
        std::abs(restored.linearSweep.duration - 4.0) > 1.0e-12 ||
        !restored.linearSweep.returnEnabled ||
        std::abs(restored.linearSweep.holdDuration - 4.0) > 1.0e-12 ||
        std::abs(restored.linearSweep.returnDuration - 4.0) > 1.0e-12 ||
        !restored.ramseySequence.enabled || restored.ramseySequence.targetObjectId != biasId ||
        restored.ramseySequence.parameter != TimePotentialParameter2D::LinearSlopeX ||
        std::abs(restored.ramseySequence.amplitude - 0.10) > 1.0e-12 ||
        std::abs(restored.ramseySequence.angularFrequency - 0.305536) > 1.0e-12 ||
        std::abs(restored.ramseySequence.startTime - 0.25) > 1.0e-12 ||
        std::abs(restored.ramseySequence.pulseDuration - 14.35) > 1.0e-12 ||
        std::abs(restored.ramseySequence.freeEvolutionDuration - 5.5) > 1.0e-12 ||
        !restored.ramseySequence.echoEnabled ||
        std::abs(restored.ramseySequence.echoPulseDuration - 25.75) > 1.0e-12 ||
        std::abs(restored.ramseySequence.echoPulsePhaseDegrees - 90.0) > 1.0e-12 ||
        !restored.ramseyEnsemble.enabled ||
        std::abs(restored.ramseyEnsemble.detuningStdDev - 0.06) > 1.0e-12 ||
        restored.ramseyEnsemble.memberCount != 41 ||
        std::abs(restored.talbotInitialState.period - 5.12) > 1.0e-12 ||
        std::abs(restored.talbotInitialState.toothSigma - 0.45) > 1.0e-12 ||
        std::abs(restored.talbotInitialState.offsetX - 0.32) > 1.0e-12 ||
        std::abs(restored.talbotInitialState.centerY + 8.0) > 1.0e-12 ||
        std::abs(restored.talbotInitialState.sigmaY - 1.5) > 1.0e-12 ||
        std::abs(restored.talbotInitialState.momentumY - 1.2) > 1.0e-12 ||
        std::abs(restored.vortexInitialState.envelopeSigma - 1.0) > 1.0e-12 ||
        std::abs(restored.vortexInitialState.coreX - 1.0) > 1.0e-12 ||
        std::abs(restored.vortexInitialState.coreY) > 1.0e-12 ||
        restored.vortexInitialState.charge != 1 ||
        !restored.kickedRotor.enabled ||
        std::abs(restored.kickedRotor.firstKickTime - 0.20) > 1.0e-12 ||
        std::abs(restored.kickedRotor.kickPeriod - 1.0) > 1.0e-12 ||
        std::abs(restored.kickedRotor.phaseStrength - 6.0) > 1.0e-12 ||
        std::abs(restored.kickedRotorInitialState.ySigma - 1.5) > 1.0e-12 ||
        restored.kickedRotorInitialState.initialMomentumMode != 0 ||
        !restored.quantumZeno.enabled ||
        std::abs(restored.quantumZeno.firstMeasurementTime - 0.40) > 1.0e-12 ||
        std::abs(restored.quantumZeno.measurementPeriod - 0.10) > 1.0e-12 ||
        std::abs(restored.quantumZeno.survivalBoundaryX - 0.40) > 1.0e-12 ||
        std::abs(restored.quantumZeno.edgeWidth - 0.32) > 1.0e-12 ||
        std::abs(restored.quantumZenoInitialState.controlLaneY - 4.8) > 1.0e-12 ||
        std::abs(restored.quantumZenoInitialState.watchedLaneY + 4.8) > 1.0e-12 ||
        std::abs(restored.quantumZenoInitialState.sigma - 0.80) > 1.0e-12 ||
        std::abs(restored.quantumZenoInitialState.momentumX - 1.50) > 1.0e-12 ||
        !restored.quantumScar.enabled ||
        std::abs(restored.quantumScar.orbitBandHalfWidth - 0.80) > 1.0e-12 ||
        std::abs(restored.quantumScar.referenceEnergy - 9.50) > 1.0e-12) {
        errorMessage = "round trip values differ";
        return false;
    }
 
    QTemporaryDir temporaryDirectory;
    if (!temporaryDirectory.isValid()) {
        errorMessage = "cannot create temporary directory";
        return false;
    }
 
    const QString fileName = temporaryDirectory.filePath(QStringLiteral("experiment.qpe.json"));
    if (!ExperimentDocument2DJson::saveFile(fileName, source, qtError)) {
        errorMessage = std::string("file save failed: ") + qtError.toStdString();
        return false;
    }
 
    ExperimentDocument2D fileRestored;
    if (!ExperimentDocument2DJson::loadFile(fileName, fileRestored, qtError)) {
        errorMessage = std::string("file load failed: ") + qtError.toStdString();
        return false;
    }
    if (fileRestored.controls.value(QStringLiteral("universeWidthSpinBox")).toDouble() != 61.44 ||
        fileRestored.sourcePreset != source.sourcePreset ||
        fileRestored.potentialScene.size() != 4 ||
        fileRestored.initialPreparationMode != 2 ||
        std::abs(fileRestored.collapseResolution - 0.72) > 1.0e-12 ||
        !fileRestored.quench.enabled || fileRestored.quench.targetObjectId != barrierId ||
        !fileRestored.periodicDrive.enabled || fileRestored.periodicDrive.targetObjectId != secondId ||
        !fileRestored.linearSweep.enabled || fileRestored.linearSweep.targetObjectId != biasId ||
        !fileRestored.ramseySequence.enabled || fileRestored.ramseySequence.targetObjectId != biasId ||
        !fileRestored.ramseyEnsemble.enabled || fileRestored.ramseyEnsemble.memberCount != 41 ||
        std::abs(fileRestored.talbotInitialState.period - 5.12) > 1.0e-12 ||
        std::abs(fileRestored.vortexInitialState.coreX - 1.0) > 1.0e-12 ||
        fileRestored.vortexInitialState.charge != 1 ||
        !fileRestored.kickedRotor.enabled ||
        std::abs(fileRestored.kickedRotor.phaseStrength - 6.0) > 1.0e-12 ||
        std::abs(fileRestored.kickedRotorInitialState.ySigma - 1.5) > 1.0e-12 ||
        !fileRestored.quantumZeno.enabled ||
        std::abs(fileRestored.quantumZeno.measurementPeriod - 0.10) > 1.0e-12 ||
        std::abs(fileRestored.quantumZenoInitialState.sigma - 0.80) > 1.0e-12 ||
        !fileRestored.quantumScar.enabled ||
        std::abs(fileRestored.quantumScar.referenceEnergy - 9.50) > 1.0e-12) {
        errorMessage = "file round trip values differ";
        return false;
    }
 
    ExperimentDocument2D talbotSource = source;
    talbotSource.initialPreparationMode = 3;
    talbotSource.name = QStringLiteral("Talbot persistence test");
    const QJsonObject talbotJson = ExperimentDocument2DJson::toJson(talbotSource);
    ExperimentDocument2D talbotRestored;
    if (!ExperimentDocument2DJson::fromJson(talbotJson, talbotRestored, qtError) ||
        talbotRestored.initialPreparationMode != 3 ||
        std::abs(talbotRestored.talbotInitialState.period - 5.12) > 1.0e-12 ||
        std::abs(talbotRestored.talbotInitialState.toothSigma - 0.45) > 1.0e-12 ||
        std::abs(talbotRestored.talbotInitialState.momentumY - 1.2) > 1.0e-12) {
        errorMessage = std::string("schema 13 Talbot preparation round trip failed: ") + qtError.toStdString();
        return false;
    }
 
    ExperimentDocument2D vortexSource = source;
    vortexSource.initialPreparationMode = 4;
    vortexSource.name = QStringLiteral("Vortex persistence test");
    const QJsonObject vortexJson = ExperimentDocument2DJson::toJson(vortexSource);
    ExperimentDocument2D vortexRestored;
    if (!ExperimentDocument2DJson::fromJson(vortexJson, vortexRestored, qtError) ||
        vortexRestored.initialPreparationMode != 4 ||
        std::abs(vortexRestored.vortexInitialState.envelopeSigma - 1.0) > 1.0e-12 ||
        std::abs(vortexRestored.vortexInitialState.coreX - 1.0) > 1.0e-12 ||
        vortexRestored.vortexInitialState.charge != 1) {
        errorMessage = std::string("schema 14 Vortex preparation round trip failed: ") + qtError.toStdString();
        return false;
    }
 
 
    ExperimentDocument2D andersonSource = source;
    andersonSource.initialPreparationMode = 5;
    andersonSource.name = QStringLiteral("Anderson persistence test");
    const QJsonObject andersonJson = ExperimentDocument2DJson::toJson(andersonSource);
    ExperimentDocument2D andersonRestored;
    if (!ExperimentDocument2DJson::fromJson(andersonJson, andersonRestored, qtError) ||
        andersonRestored.initialPreparationMode != 5 ||
        std::abs(andersonRestored.andersonInitialState.cleanLaneY - 4.0) > 1.0e-12 ||
        std::abs(andersonRestored.andersonInitialState.disorderLaneY + 4.0) > 1.0e-12 ||
        std::abs(andersonRestored.andersonInitialState.sigma - 0.35) > 1.0e-12) {
        errorMessage = std::string("schema 15 Anderson preparation round trip failed: ") + qtError.toStdString();
        return false;
    }
 
    ExperimentDocument2D kickedRotorSource = source;
    kickedRotorSource.initialPreparationMode = 6;
    kickedRotorSource.name = QStringLiteral("Kicked Rotor persistence test");
    const QJsonObject kickedRotorJson = ExperimentDocument2DJson::toJson(kickedRotorSource);
    ExperimentDocument2D kickedRotorRestored;
    if (!ExperimentDocument2DJson::fromJson(kickedRotorJson, kickedRotorRestored, qtError) ||
        kickedRotorRestored.initialPreparationMode != 6 ||
        !kickedRotorRestored.kickedRotor.enabled ||
        std::abs(kickedRotorRestored.kickedRotor.firstKickTime - 0.20) > 1.0e-12 ||
        std::abs(kickedRotorRestored.kickedRotor.kickPeriod - 1.0) > 1.0e-12 ||
        std::abs(kickedRotorRestored.kickedRotor.phaseStrength - 6.0) > 1.0e-12 ||
        std::abs(kickedRotorRestored.kickedRotorInitialState.ySigma - 1.5) > 1.0e-12 ||
        kickedRotorRestored.kickedRotorInitialState.initialMomentumMode != 0) {
        errorMessage = std::string("schema 16 Kicked Rotor preparation round trip failed: ") + qtError.toStdString();
        return false;
    }
 
    ExperimentDocument2D zenoSource = source;
    zenoSource.initialPreparationMode = 7;
    zenoSource.name = QStringLiteral("Quantum Zeno persistence test");
    const QJsonObject zenoJson = ExperimentDocument2DJson::toJson(zenoSource);
    ExperimentDocument2D zenoRestored;
    if (!ExperimentDocument2DJson::fromJson(zenoJson, zenoRestored, qtError) ||
        zenoRestored.initialPreparationMode != 7 ||
        !zenoRestored.quantumZeno.enabled ||
        std::abs(zenoRestored.quantumZeno.firstMeasurementTime - 0.40) > 1.0e-12 ||
        std::abs(zenoRestored.quantumZeno.measurementPeriod - 0.10) > 1.0e-12 ||
        std::abs(zenoRestored.quantumZeno.survivalBoundaryX - 0.40) > 1.0e-12 ||
        std::abs(zenoRestored.quantumZeno.edgeWidth - 0.32) > 1.0e-12 ||
        std::abs(zenoRestored.quantumZenoInitialState.controlLaneY - 4.8) > 1.0e-12 ||
        std::abs(zenoRestored.quantumZenoInitialState.watchedLaneY + 4.8) > 1.0e-12 ||
        std::abs(zenoRestored.quantumZenoInitialState.sigma - 0.80) > 1.0e-12 ||
        std::abs(zenoRestored.quantumZenoInitialState.momentumX - 1.50) > 1.0e-12) {
        errorMessage = std::string("schema 17 Quantum Zeno preparation round trip failed: ") + qtError.toStdString();
        return false;
    }
 
    ExperimentDocument2D scarSource = source;
    scarSource.name = QStringLiteral("Quantum Scars persistence test");
    const QJsonObject scarJson = ExperimentDocument2DJson::toJson(scarSource);
    ExperimentDocument2D scarRestored;
    if (!ExperimentDocument2DJson::fromJson(scarJson, scarRestored, qtError) ||
        !scarRestored.quantumScar.enabled ||
        std::abs(scarRestored.quantumScar.orbitBandHalfWidth - 0.80) > 1.0e-12 ||
        std::abs(scarRestored.quantumScar.referenceEnergy - 9.50) > 1.0e-12) {
        errorMessage = std::string("schema 18 Quantum Scars round trip failed: ") + qtError.toStdString();
        return false;
    }
 
    ExperimentDocument2D berrySource;
    berrySource.name = QStringLiteral("Berry Phase persistence test");
    berrySource.sourcePreset = QStringLiteral("Berry Phase / Geometric Phase");
    berrySource.controls.insert(QStringLiteral("universeWidthSpinBox"), 40.96);
    berrySource.initialPreparationMode = 8;
    berrySource.potentialSceneActive = true;
    PotentialObject2D berryTrap;
    berryTrap.type = PotentialObjectType2D::Harmonic;
    berryTrap.curvatureX = 1.0f;
    berryTrap.curvatureY = 1.0f;
    berrySource.potentialScene.add(berryTrap);
    berrySource.quantumBerry.enabled = true;
    berrySource.quantumBerry.anisotropy = 0.35;
    berrySource.quantumBerry.startTime = 0.5;
    berrySource.quantumBerry.duration = 240.0;
    berrySource.quantumBerry.winding = -1;
    const QJsonObject berryJson = ExperimentDocument2DJson::toJson(berrySource);
    ExperimentDocument2D berryRestored;
    if (!ExperimentDocument2DJson::fromJson(berryJson, berryRestored, qtError) ||
        berryRestored.initialPreparationMode != 8 || !berryRestored.quantumBerry.enabled ||
        std::abs(berryRestored.quantumBerry.anisotropy - 0.35) > 1.0e-12 ||
        std::abs(berryRestored.quantumBerry.startTime - 0.5) > 1.0e-12 ||
        std::abs(berryRestored.quantumBerry.duration - 240.0) > 1.0e-12 ||
        berryRestored.quantumBerry.winding != -1) {
        errorMessage = std::string("schema 19 Berry Phase round trip failed: ") + qtError.toStdString();
        return false;
    }
 
    ExperimentDocument2D loschmidtSource;
    loschmidtSource.name = QStringLiteral("Loschmidt Echo persistence test");
    loschmidtSource.sourcePreset = QStringLiteral("Loschmidt Echo / Quantum Time Reversal");
    loschmidtSource.controls.insert(QStringLiteral("universeWidthSpinBox"), 40.96);
    loschmidtSource.quantumLoschmidt.enabled = true;
    loschmidtSource.quantumLoschmidt.reversalTime = 4.25;
    loschmidtSource.quantumLoschmidt.momentumErrorX = 0.12;
    loschmidtSource.quantumLoschmidt.momentumErrorY = -0.07;
    const QJsonObject loschmidtJson = ExperimentDocument2DJson::toJson(loschmidtSource);
    ExperimentDocument2D loschmidtRestored;
    if (!ExperimentDocument2DJson::fromJson(loschmidtJson, loschmidtRestored, qtError) ||
        !loschmidtRestored.quantumLoschmidt.enabled ||
        std::abs(loschmidtRestored.quantumLoschmidt.reversalTime - 4.25) > 1.0e-12 ||
        std::abs(loschmidtRestored.quantumLoschmidt.momentumErrorX - 0.12) > 1.0e-12 ||
        std::abs(loschmidtRestored.quantumLoschmidt.momentumErrorY + 0.07) > 1.0e-12) {
        errorMessage = std::string("schema 20 Loschmidt Echo round trip failed: ") + qtError.toStdString();
        return false;
    }
 
    ExperimentDocument2D moshinskySource;
    moshinskySource.name = QStringLiteral("Moshinsky Shutter persistence test");
    moshinskySource.sourcePreset = QStringLiteral("Moshinsky Shutter / Diffraction in Time");
    moshinskySource.controls.insert(QStringLiteral("universeWidthSpinBox"), 40.96);
    moshinskySource.initialPreparationMode = 9;
    moshinskySource.potentialSceneActive = true;
    PotentialObject2D moshinskyShutter;
    moshinskyShutter.type = PotentialObjectType2D::Barrier;
    moshinskyShutter.value = 120.0f;
    moshinskyShutter.centerX = 0.0f;
    moshinskyShutter.centerY = 0.0f;
    moshinskyShutter.length = 19.0f;
    moshinskyShutter.thickness = 0.32f;
    const std::uint64_t moshinskyShutterId = moshinskySource.potentialScene.add(moshinskyShutter);
    moshinskySource.moshinskyInitialState.enabled = true;
    moshinskySource.moshinskyInitialState.shutterX = 0.0;
    moshinskySource.moshinskyInitialState.envelopeCenterX = -8.0;
    moshinskySource.moshinskyInitialState.envelopeSigmaX = 8.0;
    moshinskySource.moshinskyInitialState.centerY = 0.0;
    moshinskySource.moshinskyInitialState.transverseSigmaY = 3.2;
    moshinskySource.moshinskyInitialState.momentumX = 3.0;
    moshinskySource.moshinskyInitialState.edgeWidth = 0.18;
    moshinskySource.quantumMoshinsky.enabled = true;
    moshinskySource.quantumMoshinsky.shutterObjectId = moshinskyShutterId;
    moshinskySource.quantumMoshinsky.openTime = 0.25;
    moshinskySource.quantumMoshinsky.detectorX = 3.5;
    moshinskySource.quantumMoshinsky.analysisEndTime = 7.0;
    const QJsonObject moshinskyJson = ExperimentDocument2DJson::toJson(moshinskySource);
    ExperimentDocument2D moshinskyRestored;
    if (!ExperimentDocument2DJson::fromJson(moshinskyJson, moshinskyRestored, qtError) ||
        moshinskyRestored.initialPreparationMode != 9 ||
        !moshinskyRestored.moshinskyInitialState.enabled ||
        !moshinskyRestored.quantumMoshinsky.enabled ||
        std::abs(moshinskyRestored.moshinskyInitialState.envelopeCenterX + 8.0) > 1.0e-12 ||
        std::abs(moshinskyRestored.moshinskyInitialState.edgeWidth - 0.18) > 1.0e-12 ||
        std::abs(moshinskyRestored.quantumMoshinsky.openTime - 0.25) > 1.0e-12 ||
        std::abs(moshinskyRestored.quantumMoshinsky.detectorX - 3.5) > 1.0e-12 ||
        std::abs(moshinskyRestored.quantumMoshinsky.analysisEndTime - 7.0) > 1.0e-12 ||
        moshinskyRestored.quantumMoshinsky.shutterObjectId != moshinskyShutterId) {
        errorMessage = std::string("schema 21 Moshinsky Shutter round trip failed: ") + qtError.toStdString();
        return false;
    }
 
    ExperimentDocument2D kapitzaSource;
    kapitzaSource.name = QStringLiteral("Kapitza-Dirac persistence test");
    kapitzaSource.sourcePreset = QStringLiteral("Kapitza-Dirac Diffraction / Optical Standing Wave");
    kapitzaSource.controls.insert(QStringLiteral("universeWidthSpinBox"), 40.96);
    kapitzaSource.initialPreparationMode = 10;
    kapitzaSource.kapitzaDiracInitialState.centerY = -6.25;
    kapitzaSource.kapitzaDiracInitialState.sigmaX = 4.75;
    kapitzaSource.kapitzaDiracInitialState.sigmaY = 1.15;
    kapitzaSource.kapitzaDiracInitialState.momentumY = 1.25;
    kapitzaSource.quantumKapitzaDirac.enabled = true;
    kapitzaSource.quantumKapitzaDirac.latticePeriod = 4.096;
    kapitzaSource.quantumKapitzaDirac.latticeDepth = 15.5;
    kapitzaSource.quantumKapitzaDirac.latticePhaseDegrees = 22.5;
    kapitzaSource.quantumKapitzaDirac.pulseStartTime = 0.1;
    kapitzaSource.quantumKapitzaDirac.pulseDuration = 0.28;
    kapitzaSource.quantumKapitzaDirac.analysisEndTime = 4.5;
    kapitzaSource.quantumKapitzaDirac.maximumOrder = 5;
    const QJsonObject kapitzaJson = ExperimentDocument2DJson::toJson(kapitzaSource);
    ExperimentDocument2D kapitzaRestored;
    if (!ExperimentDocument2DJson::fromJson(kapitzaJson, kapitzaRestored, qtError) ||
        kapitzaRestored.initialPreparationMode != 10 ||
        !kapitzaRestored.quantumKapitzaDirac.enabled ||
        std::abs(kapitzaRestored.kapitzaDiracInitialState.centerY + 6.25) > 1.0e-12 ||
        std::abs(kapitzaRestored.kapitzaDiracInitialState.sigmaX - 4.75) > 1.0e-12 ||
        std::abs(kapitzaRestored.quantumKapitzaDirac.latticeDepth - 15.5) > 1.0e-12 ||
        std::abs(kapitzaRestored.quantumKapitzaDirac.latticePhaseDegrees - 22.5) > 1.0e-12 ||
        std::abs(kapitzaRestored.quantumKapitzaDirac.pulseDuration - 0.28) > 1.0e-12 ||
        kapitzaRestored.quantumKapitzaDirac.maximumOrder != 5) {
        errorMessage = std::string("schema 22 Kapitza-Dirac round trip failed: ") + qtError.toStdString();
        return false;
    }
 
    ExperimentDocument2D aharonovSource;
    aharonovSource.name = QStringLiteral("Aharonov-Bohm persistence test");
    aharonovSource.sourcePreset = QStringLiteral("Aharonov-Bohm Effect / Magnetic Flux");
    aharonovSource.controls.insert(QStringLiteral("universeWidthSpinBox"), 40.96);
    aharonovSource.initialPreparationMode = 11;
    aharonovSource.quantumAharonovBohm.enabled = true;
    aharonovSource.quantumAharonovBohm.solenoidX = 0.3;
    aharonovSource.quantumAharonovBohm.solenoidY = -0.2;
    aharonovSource.quantumAharonovBohm.solenoidRadius = 1.4;
    aharonovSource.quantumAharonovBohm.fluxQuanta = 0.75;
    aharonovSource.quantumAharonovBohm.barrierHeight = 150.0;
    aharonovSource.quantumAharonovBohm.detectorX = 6.5;
    aharonovSource.quantumAharonovBohm.analysisEndTime = 5.5;
    const QJsonObject aharonovJson = ExperimentDocument2DJson::toJson(aharonovSource);
    ExperimentDocument2D aharonovRestored;
    if (!ExperimentDocument2DJson::fromJson(aharonovJson, aharonovRestored, qtError) ||
        aharonovRestored.initialPreparationMode != 11 ||
        !aharonovRestored.quantumAharonovBohm.enabled ||
        std::abs(aharonovRestored.quantumAharonovBohm.solenoidX - 0.3) > 1.0e-12 ||
        std::abs(aharonovRestored.quantumAharonovBohm.solenoidY + 0.2) > 1.0e-12 ||
        std::abs(aharonovRestored.quantumAharonovBohm.solenoidRadius - 1.4) > 1.0e-12 ||
        std::abs(aharonovRestored.quantumAharonovBohm.fluxQuanta - 0.75) > 1.0e-12 ||
        std::abs(aharonovRestored.quantumAharonovBohm.barrierHeight - 150.0) > 1.0e-12 ||
        std::abs(aharonovRestored.quantumAharonovBohm.detectorX - 6.5) > 1.0e-12 ||
        std::abs(aharonovRestored.quantumAharonovBohm.analysisEndTime - 5.5) > 1.0e-12) {
        errorMessage = std::string("schema 23 Aharonov-Bohm round trip failed: ") + qtError.toStdString();
        return false;
    }
 
    ExperimentDocument2D landauSource;
    landauSource.name = QStringLiteral("Landau persistence test");
    landauSource.sourcePreset = QStringLiteral("Landau Levels / Cyclotron Dynamics");
    landauSource.controls.insert(QStringLiteral("landauFieldSpinBox"), 0.72);
    landauSource.initialPreparationMode = 12;
    landauSource.quantumLandau.enabled = true;
    landauSource.quantumLandau.fieldStrength = -0.72;
    landauSource.quantumLandau.preparationMode = 1;
    landauSource.quantumLandau.landauIndex = 3;
    landauSource.quantumLandau.orbitRadius = 6.25;
    landauSource.quantumLandau.analysisEndTime = 18.5;
    const QJsonObject landauJson = ExperimentDocument2DJson::toJson(landauSource);
    ExperimentDocument2D landauRestored;
    if (!ExperimentDocument2DJson::fromJson(landauJson, landauRestored, qtError) ||
        landauRestored.initialPreparationMode != 12 || !landauRestored.quantumLandau.enabled ||
        std::abs(landauRestored.quantumLandau.fieldStrength + 0.72) > 1.0e-12 ||
        landauRestored.quantumLandau.preparationMode != 1 ||
        landauRestored.quantumLandau.landauIndex != 3 ||
        std::abs(landauRestored.quantumLandau.orbitRadius - 6.25) > 1.0e-12 ||
        std::abs(landauRestored.quantumLandau.analysisEndTime - 18.5) > 1.0e-12) {
        errorMessage = std::string("schema 24 Landau round trip failed: ") + qtError.toStdString();
        return false;
    }
 
    ExperimentDocument2D hallSource;
    hallSource.name = QStringLiteral("Quantum Hall edge persistence test");
    hallSource.sourcePreset = QStringLiteral("Quantum Hall Edge State / Chiral Skipping Orbit");
    hallSource.controls.insert(QStringLiteral("hallEdgeFieldSpinBox"), -0.63);
    hallSource.initialPreparationMode = 13;
    hallSource.quantumHallEdge.enabled = true;
    hallSource.quantumHallEdge.fieldStrength = -0.63;
    hallSource.quantumHallEdge.edgeY = -7.5;
    hallSource.quantumHallEdge.wallHeight = 175.0;
    hallSource.quantumHallEdge.launchY = -4.7;
    hallSource.quantumHallEdge.orbitRadius = 5.1;
    hallSource.quantumHallEdge.packetSigma = 0.95;
    hallSource.quantumHallEdge.edgeBand = 4.6;
    hallSource.quantumHallEdge.analysisEndTime = 9.25;
    const QJsonObject hallJson = ExperimentDocument2DJson::toJson(hallSource);
    ExperimentDocument2D hallRestored;
    if (!ExperimentDocument2DJson::fromJson(hallJson, hallRestored, qtError) ||
        hallRestored.initialPreparationMode != 13 || !hallRestored.quantumHallEdge.enabled ||
        std::abs(hallRestored.quantumHallEdge.fieldStrength + 0.63) > 1.0e-12 ||
        std::abs(hallRestored.quantumHallEdge.edgeY + 7.5) > 1.0e-12 ||
        std::abs(hallRestored.quantumHallEdge.wallHeight - 175.0) > 1.0e-12 ||
        std::abs(hallRestored.quantumHallEdge.launchY + 4.7) > 1.0e-12 ||
        std::abs(hallRestored.quantumHallEdge.orbitRadius - 5.1) > 1.0e-12 ||
        std::abs(hallRestored.quantumHallEdge.packetSigma - 0.95) > 1.0e-12 ||
        std::abs(hallRestored.quantumHallEdge.edgeBand - 4.6) > 1.0e-12 ||
        std::abs(hallRestored.quantumHallEdge.analysisEndTime - 9.25) > 1.0e-12) {
        errorMessage = std::string("schema 25 Quantum Hall edge round trip failed: ") + qtError.toStdString();
        return false;
    }
 
    ExperimentDocument2D backflowSource;
    backflowSource.name = QStringLiteral("Quantum backflow persistence test");
    backflowSource.sourcePreset = QStringLiteral("Quantum Backflow / Positive Momentum, Negative Current");
    backflowSource.controls.insert(QStringLiteral("universeWidthSpinBox"), 40.96);
    backflowSource.initialPreparationMode = 14;
    backflowSource.quantumBackflow.enabled = true;
    backflowSource.quantumBackflow.detectorX = 1.25;
    backflowSource.quantumBackflow.slowWaveNumber = 0.42;
    backflowSource.quantumBackflow.fastWaveNumber = 1.55;
    backflowSource.quantumBackflow.momentumSigma = 0.28;
    backflowSource.quantumBackflow.fastAmplitudeRatio = 0.61;
    backflowSource.quantumBackflow.relativePhaseDegrees = 155.0;
    backflowSource.quantumBackflow.initialCenterX = -2.4;
    backflowSource.quantumBackflow.transverseSigma = 3.1;
    backflowSource.quantumBackflow.analysisEndTime = 5.75;
    const QJsonObject backflowJson = ExperimentDocument2DJson::toJson(backflowSource);
    ExperimentDocument2D backflowRestored;
    if (!ExperimentDocument2DJson::fromJson(backflowJson, backflowRestored, qtError) ||
        backflowRestored.initialPreparationMode != 14 || !backflowRestored.quantumBackflow.enabled ||
        std::abs(backflowRestored.quantumBackflow.detectorX - 1.25) > 1.0e-12 ||
        std::abs(backflowRestored.quantumBackflow.slowWaveNumber - 0.42) > 1.0e-12 ||
        std::abs(backflowRestored.quantumBackflow.fastWaveNumber - 1.55) > 1.0e-12 ||
        std::abs(backflowRestored.quantumBackflow.momentumSigma - 0.28) > 1.0e-12 ||
        std::abs(backflowRestored.quantumBackflow.fastAmplitudeRatio - 0.61) > 1.0e-12 ||
        std::abs(backflowRestored.quantumBackflow.relativePhaseDegrees - 155.0) > 1.0e-12 ||
        std::abs(backflowRestored.quantumBackflow.initialCenterX + 2.4) > 1.0e-12 ||
        std::abs(backflowRestored.quantumBackflow.transverseSigma - 3.1) > 1.0e-12 ||
        std::abs(backflowRestored.quantumBackflow.analysisEndTime - 5.75) > 1.0e-12) {
        errorMessage = std::string("schema 26 Quantum backflow round trip failed: ") + qtError.toStdString();
        return false;
    }
 
    ExperimentDocument2D zitterSource;
    zitterSource.name = QStringLiteral("Zitterbewegung persistence test");
    zitterSource.sourcePreset = QStringLiteral("Zitterbewegung / Free Dirac Wave Packet");
    zitterSource.controls.insert(QStringLiteral("universeWidthSpinBox"), 40.96);
    zitterSource.initialPreparationMode = 15;
    zitterSource.quantumZitterbewegung.enabled = true;
    zitterSource.quantumZitterbewegung.lightSpeed = 1.25;
    zitterSource.quantumZitterbewegung.restMass = 0.44;
    zitterSource.quantumZitterbewegung.centerX = -5.25;
    zitterSource.quantumZitterbewegung.centerY = 0.75;
    zitterSource.quantumZitterbewegung.sigma = 3.2;
    zitterSource.quantumZitterbewegung.momentumX = 0.62;
    zitterSource.quantumZitterbewegung.momentumY = -0.14;
    zitterSource.quantumZitterbewegung.preparationMode = 1;
    zitterSource.quantumZitterbewegung.analysisEndTime = 14.5;
    const QJsonObject zitterJson = ExperimentDocument2DJson::toJson(zitterSource);
    ExperimentDocument2D zitterRestored;
    if (!ExperimentDocument2DJson::fromJson(zitterJson, zitterRestored, qtError) ||
        zitterRestored.initialPreparationMode != 15 || !zitterRestored.quantumZitterbewegung.enabled ||
        std::abs(zitterRestored.quantumZitterbewegung.lightSpeed - 1.25) > 1.0e-12 ||
        std::abs(zitterRestored.quantumZitterbewegung.restMass - 0.44) > 1.0e-12 ||
        std::abs(zitterRestored.quantumZitterbewegung.centerX + 5.25) > 1.0e-12 ||
        std::abs(zitterRestored.quantumZitterbewegung.centerY - 0.75) > 1.0e-12 ||
        std::abs(zitterRestored.quantumZitterbewegung.sigma - 3.2) > 1.0e-12 ||
        std::abs(zitterRestored.quantumZitterbewegung.momentumX - 0.62) > 1.0e-12 ||
        std::abs(zitterRestored.quantumZitterbewegung.momentumY + 0.14) > 1.0e-12 ||
        zitterRestored.quantumZitterbewegung.preparationMode != 1 ||
        std::abs(zitterRestored.quantumZitterbewegung.analysisEndTime - 14.5) > 1.0e-12) {
        errorMessage = std::string("schema 27 Zitterbewegung round trip failed: ") + qtError.toStdString();
        return false;
    }
 
    ExperimentDocument2D kleinSource;
    kleinSource.name = QStringLiteral("Klein tunneling persistence test");
    kleinSource.sourcePreset = QStringLiteral("Klein Tunneling / Supercritical Dirac Barrier");
    kleinSource.initialPreparationMode = 16;
    kleinSource.controls.insert(QStringLiteral("boundaryModeComboBox"), 1);
    kleinSource.quantumKleinTunneling.enabled = true;
    kleinSource.quantumKleinTunneling.lightSpeed = 1.15;
    kleinSource.quantumKleinTunneling.restMass = 0.08;
    kleinSource.quantumKleinTunneling.centerX = -9.5;
    kleinSource.quantumKleinTunneling.centerY = 0.6;
    kleinSource.quantumKleinTunneling.sigma = 2.4;
    kleinSource.quantumKleinTunneling.momentumX = 1.6;
    kleinSource.quantumKleinTunneling.momentumY = 0.25;
    kleinSource.quantumKleinTunneling.barrierCenterX = 0.4;
    kleinSource.quantumKleinTunneling.barrierWidth = 2.8;
    kleinSource.quantumKleinTunneling.barrierHeight = 3.5;
    kleinSource.quantumKleinTunneling.detectorX = 6.4;
    kleinSource.quantumKleinTunneling.analysisEndTime = 17.0;
    const QJsonObject kleinJson = ExperimentDocument2DJson::toJson(kleinSource);
    ExperimentDocument2D kleinRestored;
    if (!ExperimentDocument2DJson::fromJson(kleinJson, kleinRestored, qtError) ||
        kleinRestored.initialPreparationMode != 16 ||
        kleinRestored.controls.value(QStringLiteral("boundaryModeComboBox")).toInt() != 1 ||
        !kleinRestored.quantumKleinTunneling.enabled ||
        std::abs(kleinRestored.quantumKleinTunneling.lightSpeed - 1.15) > 1.0e-12 ||
        std::abs(kleinRestored.quantumKleinTunneling.restMass - 0.08) > 1.0e-12 ||
        std::abs(kleinRestored.quantumKleinTunneling.centerX + 9.5) > 1.0e-12 ||
        std::abs(kleinRestored.quantumKleinTunneling.centerY - 0.6) > 1.0e-12 ||
        std::abs(kleinRestored.quantumKleinTunneling.sigma - 2.4) > 1.0e-12 ||
        std::abs(kleinRestored.quantumKleinTunneling.momentumX - 1.6) > 1.0e-12 ||
        std::abs(kleinRestored.quantumKleinTunneling.momentumY - 0.25) > 1.0e-12 ||
        std::abs(kleinRestored.quantumKleinTunneling.barrierCenterX - 0.4) > 1.0e-12 ||
        std::abs(kleinRestored.quantumKleinTunneling.barrierWidth - 2.8) > 1.0e-12 ||
        std::abs(kleinRestored.quantumKleinTunneling.barrierHeight - 3.5) > 1.0e-12 ||
        std::abs(kleinRestored.quantumKleinTunneling.detectorX - 6.4) > 1.0e-12 ||
        std::abs(kleinRestored.quantumKleinTunneling.analysisEndTime - 17.0) > 1.0e-12) {
        errorMessage = std::string("schema 28 Klein tunneling round trip failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 27 had Zitterbewegung but no Klein-tunneling object.
    QJsonObject schema27 = zitterJson;
    schema27.insert(QStringLiteral("schemaVersion"), 27);
    schema27.remove(QStringLiteral("quantumKleinTunneling"));
    ExperimentDocument2D schema27Restored;
    if (!ExperimentDocument2DJson::fromJson(schema27, schema27Restored, qtError) ||
        !schema27Restored.quantumZitterbewegung.enabled ||
        schema27Restored.quantumKleinTunneling.enabled ||
        schema27Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 27 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 26 had quantum backflow but no Dirac spinor object.
    QJsonObject schema26 = backflowJson;
    schema26.insert(QStringLiteral("schemaVersion"), 26);
    schema26.remove(QStringLiteral("quantumZitterbewegung"));
    ExperimentDocument2D schema26Restored;
    if (!ExperimentDocument2DJson::fromJson(schema26, schema26Restored, qtError) ||
        !schema26Restored.quantumBackflow.enabled || schema26Restored.quantumZitterbewegung.enabled ||
        schema26Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 26 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 25 had Hall edge but no quantum-backflow object.
    QJsonObject schema25 = hallJson;
    schema25.insert(QStringLiteral("schemaVersion"), 25);
    schema25.remove(QStringLiteral("quantumBackflow"));
    ExperimentDocument2D schema25Restored;
    if (!ExperimentDocument2DJson::fromJson(schema25, schema25Restored, qtError) ||
        !schema25Restored.quantumHallEdge.enabled || schema25Restored.quantumBackflow.enabled ||
        schema25Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 25 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 24 had uniform-field Landau dynamics but no Hall edge object.
    QJsonObject schema24 = landauJson;
    schema24.insert(QStringLiteral("schemaVersion"), 24);
    schema24.remove(QStringLiteral("quantumHallEdge"));
    ExperimentDocument2D schema24Restored;
    if (!ExperimentDocument2DJson::fromJson(schema24, schema24Restored, qtError) ||
        !schema24Restored.quantumLandau.enabled || schema24Restored.quantumHallEdge.enabled ||
        schema24Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 24 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 23 had Aharonov-Bohm but no uniform-field Landau object.
    QJsonObject schema23 = aharonovJson;
    schema23.insert(QStringLiteral("schemaVersion"), 23);
    schema23.remove(QStringLiteral("quantumLandau"));
    ExperimentDocument2D schema23Restored;
    if (!ExperimentDocument2DJson::fromJson(schema23, schema23Restored, qtError) ||
        !schema23Restored.quantumAharonovBohm.enabled || schema23Restored.quantumLandau.enabled ||
        schema23Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 23 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 22 had Kapitza-Dirac but no Aharonov-Bohm gauge field.
    QJsonObject schema22 = kapitzaJson;
    schema22.insert(QStringLiteral("schemaVersion"), 22);
    schema22.remove(QStringLiteral("quantumAharonovBohm"));
    ExperimentDocument2D schema22Restored;
    if (!ExperimentDocument2DJson::fromJson(schema22, schema22Restored, qtError) ||
        !schema22Restored.quantumKapitzaDirac.enabled ||
        schema22Restored.quantumAharonovBohm.enabled ||
        schema22Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 22 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 21 had Moshinsky Shutter but no Kapitza-Dirac pulse.
    QJsonObject schema21 = moshinskyJson;
    schema21.insert(QStringLiteral("schemaVersion"), 21);
    schema21.remove(QStringLiteral("kapitzaDiracInitialState"));
    schema21.remove(QStringLiteral("quantumKapitzaDirac"));
    ExperimentDocument2D schema21Restored;
    if (!ExperimentDocument2DJson::fromJson(schema21, schema21Restored, qtError) ||
        !schema21Restored.quantumMoshinsky.enabled ||
        schema21Restored.quantumKapitzaDirac.enabled ||
        schema21Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 21 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 20 had Loschmidt Echo but no Moshinsky shutter.
    QJsonObject schema20 = loschmidtJson;
    schema20.insert(QStringLiteral("schemaVersion"), 20);
    schema20.remove(QStringLiteral("moshinskyInitialState"));
    schema20.remove(QStringLiteral("quantumMoshinsky"));
    ExperimentDocument2D schema20Restored;
    if (!ExperimentDocument2DJson::fromJson(schema20, schema20Restored, qtError) ||
        !schema20Restored.quantumLoschmidt.enabled ||
        schema20Restored.quantumMoshinsky.enabled ||
        schema20Restored.moshinskyInitialState.enabled ||
        schema20Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 20 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 19 had Berry Phase but no Loschmidt Echo.
    QJsonObject schema19 = berryJson;
    schema19.insert(QStringLiteral("schemaVersion"), 19);
    schema19.remove(QStringLiteral("quantumLoschmidt"));
    ExperimentDocument2D schema19Restored;
    if (!ExperimentDocument2DJson::fromJson(schema19, schema19Restored, qtError) ||
        !schema19Restored.quantumBerry.enabled ||
        schema19Restored.quantumLoschmidt.enabled ||
        std::abs(schema19Restored.quantumLoschmidt.reversalTime - 4.0) > 1.0e-12 ||
        schema19Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 19 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 18 had Quantum Scars but no Berry loop.
    QJsonObject schema18 = json;
    schema18.insert(QStringLiteral("schemaVersion"), 18);
    schema18.remove(QStringLiteral("quantumBerry"));
    ExperimentDocument2D schema18Restored;
    if (!ExperimentDocument2DJson::fromJson(schema18, schema18Restored, qtError) ||
        schema18Restored.initialPreparationMode != 2 ||
        schema18Restored.quantumBerry.enabled ||
        std::abs(schema18Restored.quantumBerry.anisotropy - 0.35) > 1.0e-12 ||
        std::abs(schema18Restored.quantumBerry.duration - 240.0) > 1.0e-12 ||
        schema18Restored.quantumBerry.winding != 1 ||
        schema18Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 18 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 17 had Quantum Zeno but no Quantum
    // Scars spectral-analysis configuration.
    QJsonObject schema17 = json;
    schema17.insert(QStringLiteral("schemaVersion"), 17);
    schema17.remove(QStringLiteral("quantumScar"));
    ExperimentDocument2D schema17Restored;
    if (!ExperimentDocument2DJson::fromJson(schema17, schema17Restored, qtError) ||
        schema17Restored.initialPreparationMode != 2 ||
        schema17Restored.quantumScar.enabled ||
        std::abs(schema17Restored.quantumScar.orbitBandHalfWidth - 0.75) > 1.0e-12 ||
        std::abs(schema17Restored.quantumScar.referenceEnergy) > 1.0e-12 ||
        schema17Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 17 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 16 had kicked-rotor preparation but no
    // Quantum Zeno configuration or dual-lane initial-state object.
    QJsonObject schema16 = json;
    schema16.insert(QStringLiteral("schemaVersion"), 16);
    schema16.remove(QStringLiteral("quantumZeno"));
    schema16.remove(QStringLiteral("quantumZenoInitialState"));
    ExperimentDocument2D schema16Restored;
    if (!ExperimentDocument2DJson::fromJson(schema16, schema16Restored, qtError) ||
        schema16Restored.initialPreparationMode != 2 ||
        schema16Restored.quantumZeno.enabled ||
        std::abs(schema16Restored.quantumZeno.measurementPeriod - 0.10) > 1.0e-12 ||
        std::abs(schema16Restored.quantumZenoInitialState.sigma - 0.80) > 1.0e-12 ||
        schema16Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 16 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 15 had Anderson preparation but no
    // kicked-rotor configuration or kicked-rotor initial-state object.
    QJsonObject schema15 = json;
    schema15.insert(QStringLiteral("schemaVersion"), 15);
    schema15.remove(QStringLiteral("kickedRotor"));
    schema15.remove(QStringLiteral("kickedRotorInitialState"));
    ExperimentDocument2D schema15Restored;
    if (!ExperimentDocument2DJson::fromJson(schema15, schema15Restored, qtError) ||
        schema15Restored.initialPreparationMode != 2 ||
        schema15Restored.kickedRotor.enabled ||
        std::abs(schema15Restored.kickedRotor.kickPeriod - 1.0) > 1.0e-12 ||
        std::abs(schema15Restored.kickedRotorInitialState.ySigma - 1.5) > 1.0e-12 ||
        schema15Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 15 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 14 had vortex preparation but no Anderson object.
    QJsonObject schema14 = json;
    schema14.insert(QStringLiteral("schemaVersion"), 14);
    schema14.remove(QStringLiteral("andersonInitialState"));
    ExperimentDocument2D schema14Restored;
    if (!ExperimentDocument2DJson::fromJson(schema14, schema14Restored, qtError) ||
        schema14Restored.initialPreparationMode != 2 ||
        std::abs(schema14Restored.andersonInitialState.sigma - 0.35) > 1.0e-12 ||
        schema14Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 14 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 13 had Talbot preparation but no vortex object.
    QJsonObject schema13 = json;
    schema13.insert(QStringLiteral("schemaVersion"), 13);
    schema13.remove(QStringLiteral("vortexInitialState"));
    ExperimentDocument2D schema13Restored;
    if (!ExperimentDocument2DJson::fromJson(schema13, schema13Restored, qtError) ||
        schema13Restored.initialPreparationMode != 2 ||
        std::abs(schema13Restored.vortexInitialState.coreX - 1.0) > 1.0e-12 ||
        schema13Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 13 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 12 had the Ramsey ensemble but no Talbot initial-state object.
    QJsonObject schema12 = json;
    schema12.insert(QStringLiteral("schemaVersion"), 12);
    schema12.remove(QStringLiteral("talbotInitialState"));
    ExperimentDocument2D schema12Restored;
    if (!ExperimentDocument2DJson::fromJson(schema12, schema12Restored, qtError) ||
        schema12Restored.initialPreparationMode != 2 ||
        std::abs(schema12Restored.talbotInitialState.period - 5.12) > 1.0e-12 ||
        schema12Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 12 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 11 had Hahn echo but no static-detuning ensemble.
    QJsonObject schema11 = json;
    schema11.insert(QStringLiteral("schemaVersion"), 11);
    schema11.remove(QStringLiteral("ramseyEnsemble"));
    ExperimentDocument2D schema11Restored;
    if (!ExperimentDocument2DJson::fromJson(schema11, schema11Restored, qtError) ||
        !schema11Restored.ramseySequence.enabled || !schema11Restored.ramseySequence.echoEnabled ||
        schema11Restored.ramseyEnsemble.enabled ||
        schema11Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 11 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 10 had Ramsey but no Hahn-echo fields.
    QJsonObject schema10 = json;
    schema10.insert(QStringLiteral("schemaVersion"), 10);
    QJsonObject ramsey10 = schema10.value(QStringLiteral("ramseySequence")).toObject();
    ramsey10.remove(QStringLiteral("echoEnabled"));
    ramsey10.remove(QStringLiteral("echoPulseDuration"));
    ramsey10.remove(QStringLiteral("echoPulsePhaseDegrees"));
    schema10.insert(QStringLiteral("ramseySequence"), ramsey10);
    ExperimentDocument2D schema10Restored;
    if (!ExperimentDocument2DJson::fromJson(schema10, schema10Restored, qtError) ||
        !schema10Restored.ramseySequence.enabled || schema10Restored.ramseySequence.echoEnabled ||
        schema10Restored.ramseyEnsemble.enabled ||
        schema10Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 10 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 9 had no Ramsey pulse sequence.
    QJsonObject schema9 = json;
    schema9.insert(QStringLiteral("schemaVersion"), 9);
    schema9.remove(QStringLiteral("ramseySequence"));
    ExperimentDocument2D schema9Restored;
    if (!ExperimentDocument2DJson::fromJson(schema9, schema9Restored, qtError) ||
        schema9Restored.ramseySequence.enabled || schema9Restored.ramseyEnsemble.enabled ||
        schema9Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 9 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 8 had the same linearSweep object but
    // no return leg. Missing schema-9 fields must restore one-way semantics.
    QJsonObject schema8 = json;
    schema8.insert(QStringLiteral("schemaVersion"), 8);
    QJsonObject sweep8 = schema8.value(QStringLiteral("linearSweep")).toObject();
    sweep8.remove(QStringLiteral("returnEnabled"));
    sweep8.remove(QStringLiteral("holdDuration"));
    sweep8.remove(QStringLiteral("returnDuration"));
    schema8.insert(QStringLiteral("linearSweep"), sweep8);
    ExperimentDocument2D schema8Restored;
    if (!ExperimentDocument2DJson::fromJson(schema8, schema8Restored, qtError) ||
        !schema8Restored.linearSweep.enabled || schema8Restored.linearSweep.returnEnabled ||
        schema8Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 8 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 2 geometric objects did not contain the
    // smooth-potential numeric fields introduced by schema 3.
    QJsonObject schema2 = json;
    schema2.insert(QStringLiteral("schemaVersion"), 2);
    QJsonObject scene2 = schema2.value(QStringLiteral("potentialScene")).toObject();
    QJsonArray objects2 = scene2.value(QStringLiteral("objects")).toArray();
    while (objects2.size() > 2) objects2.removeLast();
    for (int i = 0; i < objects2.size(); ++i) {
        QJsonObject o = objects2.at(i).toObject();
        o.remove(QStringLiteral("sigmaX"));
        o.remove(QStringLiteral("sigmaY"));
        o.remove(QStringLiteral("curvatureX"));
        o.remove(QStringLiteral("curvatureY"));
        o.remove(QStringLiteral("slopeX"));
        o.remove(QStringLiteral("slopeY"));
        o.remove(QStringLiteral("softening"));
        objects2.replace(i, o);
    }
    scene2.insert(QStringLiteral("objects"), objects2);
    schema2.insert(QStringLiteral("potentialScene"), scene2);
    ExperimentDocument2D schema2Restored;
    if (!ExperimentDocument2DJson::fromJson(schema2, schema2Restored, qtError) ||
        schema2Restored.potentialScene.size() != 2 ||
        schema2Restored.initialPreparationMode != 0 ||
        std::abs(schema2Restored.collapseResolution - 0.65) > 1.0e-12 ||
        schema2Restored.quench.enabled || schema2Restored.periodicDrive.enabled ||
        schema2Restored.linearSweep.enabled || schema2Restored.ramseySequence.enabled ||
        schema2Restored.ramseyEnsemble.enabled || schema2Restored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = std::string("schema 2 compatibility failed: ") + qtError.toStdString();
        return false;
    }
 
    // Backward compatibility: schema 1 had no potentialScene object.  It must
    // still load and be promoted to the current in-memory schema.
    QJsonObject legacy = json;
    legacy.insert(QStringLiteral("schemaVersion"), 1);
    legacy.remove(QStringLiteral("potentialScene"));
    ExperimentDocument2D legacyRestored;
    if (!ExperimentDocument2DJson::fromJson(legacy, legacyRestored, qtError)) {
        errorMessage = std::string("schema 1 compatibility failed: ") + qtError.toStdString();
        return false;
    }
    if (legacyRestored.potentialSceneActive || !legacyRestored.potentialScene.empty() ||
        std::abs(legacyRestored.collapseResolution - 0.65) > 1.0e-12 ||
        legacyRestored.quench.enabled || legacyRestored.periodicDrive.enabled ||
        legacyRestored.linearSweep.enabled || legacyRestored.ramseySequence.enabled ||
        legacyRestored.ramseyEnsemble.enabled || legacyRestored.schemaVersion != ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = "schema 1 compatibility values differ";
        return false;
    }
 
    QJsonObject incompatible = json;
    incompatible.insert(QStringLiteral("schemaVersion"), 999);
    if (ExperimentDocument2DJson::fromJson(incompatible, restored, qtError)) {
        errorMessage = "incompatible schema was accepted";
        return false;
    }
 
    QJsonObject wrongFormat = json;
    wrongFormat.insert(QStringLiteral("format"), QStringLiteral("Other.Application"));
    if (ExperimentDocument2DJson::fromJson(wrongFormat, restored, qtError)) {
        errorMessage = "foreign document format was accepted";
        return false;
    }
 
    return true;
}
 
} // namespace tests
} // namespace qpe