experimentdocument2d.cpp

Go to the documentation of this file.

/**
 * @file experimentdocument2d.cpp
 * @brief Implements schema-28 experiment JSON serialization, parsing, validation, and compatibility handling.
 * @ingroup qpe_experiments
 *
 * Source: @c core/experiments/experimentdocument2d.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.h"
 
#include <QFile>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonParseError>
#include <QSaveFile>
 
#include <cmath>
 
namespace qpe {
namespace {
 
/**
 * @brief Performs potential type name.
 * @param type The type value used by the operation.
 */
QString potentialTypeName(PotentialObjectType2D type)
{
    switch (type) {
    case PotentialObjectType2D::Rectangle: return QStringLiteral("rectangle");
    case PotentialObjectType2D::Circle: return QStringLiteral("circle");
    case PotentialObjectType2D::Barrier: return QStringLiteral("barrier");
    case PotentialObjectType2D::SingleSlit: return QStringLiteral("singleSlit");
    case PotentialObjectType2D::DoubleSlit: return QStringLiteral("doubleSlit");
    case PotentialObjectType2D::PolygonWedge: return QStringLiteral("polygonWedge");
    case PotentialObjectType2D::Gaussian: return QStringLiteral("gaussian");
    case PotentialObjectType2D::Harmonic: return QStringLiteral("harmonic");
    case PotentialObjectType2D::Linear: return QStringLiteral("linear");
    case PotentialObjectType2D::SoftenedRadial: return QStringLiteral("softenedRadial");
    case PotentialObjectType2D::StadiumExterior: return QStringLiteral("stadiumExterior");
    }
    return QString();
}
 
/**
 * @brief Performs potential type from name.
 * @param name The name value used by the operation.
 * @param type The type value used by the operation.
 */
bool potentialTypeFromName(const QString &name, PotentialObjectType2D &type)
{
    if (name == QStringLiteral("rectangle")) type = PotentialObjectType2D::Rectangle;
    else if (name == QStringLiteral("circle")) type = PotentialObjectType2D::Circle;
    else if (name == QStringLiteral("barrier")) type = PotentialObjectType2D::Barrier;
    else if (name == QStringLiteral("singleSlit")) type = PotentialObjectType2D::SingleSlit;
    else if (name == QStringLiteral("doubleSlit")) type = PotentialObjectType2D::DoubleSlit;
    else if (name == QStringLiteral("polygonWedge")) type = PotentialObjectType2D::PolygonWedge;
    else if (name == QStringLiteral("gaussian")) type = PotentialObjectType2D::Gaussian;
    else if (name == QStringLiteral("harmonic")) type = PotentialObjectType2D::Harmonic;
    else if (name == QStringLiteral("linear")) type = PotentialObjectType2D::Linear;
    else if (name == QStringLiteral("softenedRadial")) type = PotentialObjectType2D::SoftenedRadial;
    else if (name == QStringLiteral("stadiumExterior")) type = PotentialObjectType2D::StadiumExterior;
    else return false;
    return true;
}
 
/**
 * @brief Performs potential object to json.
 * @param object The object value used by the operation.
 */
QJsonObject potentialObjectToJson(const PotentialObject2D &object)
{
    QJsonObject json;
    json.insert(QStringLiteral("id"), QString::number(static_cast<qulonglong>(object.id)));
    json.insert(QStringLiteral("type"), potentialTypeName(object.type));
    json.insert(QStringLiteral("enabled"), object.enabled);
    json.insert(QStringLiteral("value"), object.value);
    json.insert(QStringLiteral("centerX"), object.centerX);
    json.insert(QStringLiteral("centerY"), object.centerY);
    json.insert(QStringLiteral("width"), object.width);
    json.insert(QStringLiteral("height"), object.height);
    json.insert(QStringLiteral("radius"), object.radius);
    json.insert(QStringLiteral("length"), object.length);
    json.insert(QStringLiteral("thickness"), object.thickness);
    json.insert(QStringLiteral("wallWidth"), object.wallWidth);
    json.insert(QStringLiteral("slitHeight"), object.slitHeight);
    json.insert(QStringLiteral("slitSeparation"), object.slitSeparation);
    json.insert(QStringLiteral("sigmaX"), object.sigmaX);
    json.insert(QStringLiteral("sigmaY"), object.sigmaY);
    json.insert(QStringLiteral("curvatureX"), object.curvatureX);
    json.insert(QStringLiteral("curvatureY"), object.curvatureY);
    json.insert(QStringLiteral("slopeX"), object.slopeX);
    json.insert(QStringLiteral("slopeY"), object.slopeY);
    json.insert(QStringLiteral("softening"), object.softening);
    return json;
}
 
/**
 * @brief Performs finite json number.
 * @param json The json value used by the operation.
 * @param name The name value used by the operation.
 * @param value Value to assign or evaluate.
 */
bool finiteJsonNumber(const QJsonObject &json, const char *name, float &value)
{
    const QJsonValue item = json.value(QString::fromLatin1(name));
    if (!item.isDouble()) {
        return false;
    }
    const double number = item.toDouble();
    if (!std::isfinite(number)) {
        return false;
    }
    value = static_cast<float>(number);
    return std::isfinite(static_cast<double>(value));
}
 
/**
 * @brief Performs potential object from json.
 * @param json The json value used by the operation.
 * @param object The object value used by the operation.
 * @param errorMessage The error message value used by the operation.
 * @param index Zero-based index of the selected item.
 */
bool potentialObjectFromJson(const QJsonObject &json,
                             PotentialObject2D &object,
                             QString &errorMessage,
                             int index)
{
    PotentialObject2D parsed;
 
    const QString idText = json.value(QStringLiteral("id")).toString();
    bool idOk = false;
    const qulonglong id = idText.toULongLong(&idOk);
    if (!idOk || id == 0) {
        errorMessage = QStringLiteral("Potential scene object %1 has an invalid id.").arg(index);
        return false;
    }
    parsed.id = static_cast<std::uint64_t>(id);
 
    if (!potentialTypeFromName(json.value(QStringLiteral("type")).toString(), parsed.type)) {
        errorMessage = QStringLiteral("Potential scene object %1 has an unknown type.").arg(index);
        return false;
    }
 
    const QJsonValue enabledValue = json.value(QStringLiteral("enabled"));
    if (!enabledValue.isBool()) {
        errorMessage = QStringLiteral("Potential scene object %1 has an invalid enabled flag.").arg(index);
        return false;
    }
    parsed.enabled = enabledValue.toBool();
 
    const char *fields[] = {
        "value", "centerX", "centerY", "width", "height", "radius",
        "length", "thickness", "wallWidth", "slitHeight", "slitSeparation"
    };
    float *values[] = {
        &parsed.value, &parsed.centerX, &parsed.centerY, &parsed.width,
        &parsed.height, &parsed.radius, &parsed.length, &parsed.thickness,
        &parsed.wallWidth, &parsed.slitHeight, &parsed.slitSeparation
    };
    const int fieldCount = static_cast<int>(sizeof(fields) / sizeof(fields[0]));
    for (int i = 0; i < fieldCount; ++i) {
        if (!finiteJsonNumber(json, fields[i], *values[i])) {
            errorMessage = QStringLiteral("Potential scene object %1 has invalid numeric field '%2'.")
                               .arg(index)
                               .arg(QString::fromLatin1(fields[i]));
            return false;
        }
    }
 
    const char *smoothFields[] = {
        "sigmaX", "sigmaY", "curvatureX", "curvatureY",
        "slopeX", "slopeY", "softening"
    };
    float *smoothValues[] = {
        &parsed.sigmaX, &parsed.sigmaY, &parsed.curvatureX, &parsed.curvatureY,
        &parsed.slopeX, &parsed.slopeY, &parsed.softening
    };
    const int smoothCount = static_cast<int>(sizeof(smoothFields) / sizeof(smoothFields[0]));
    for (int i = 0; i < smoothCount; ++i) {
        const QJsonValue item = json.value(QString::fromLatin1(smoothFields[i]));
        if (item.isUndefined()) {
            continue; // schema-2 geometric scene
        }
        if (!finiteJsonNumber(json, smoothFields[i], *smoothValues[i])) {
            errorMessage = QStringLiteral("Potential scene object %1 has invalid numeric field '%2'.")
                               .arg(index)
                               .arg(QString::fromLatin1(smoothFields[i]));
            return false;
        }
    }
 
    if (!parsed.valid()) {
        errorMessage = QStringLiteral("Potential scene object %1 contains invalid geometry dimensions.").arg(index);
        return false;
    }
 
    object = parsed;
    return true;
}
 
/**
 * @brief Performs potential scene to json.
 * @param document The document value used by the operation.
 */
QJsonObject potentialSceneToJson(const ExperimentDocument2D &document)
{
    QJsonArray objects;
    const std::vector<PotentialObject2D> &sceneObjects = document.potentialScene.objects();
    for (const PotentialObject2D &object : sceneObjects) {
        objects.append(potentialObjectToJson(object));
    }
 
    QJsonObject scene;
    scene.insert(QStringLiteral("active"), document.potentialSceneActive);
    scene.insert(QStringLiteral("composition"), QStringLiteral("additive"));
    scene.insert(QStringLiteral("objects"), objects);
    return scene;
}
 
/**
 * @brief Performs potential scene from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool potentialSceneFromJson(const QJsonObject &json,
                            ExperimentDocument2D &document,
                            QString &errorMessage)
{
    const QJsonValue sceneValue = json.value(QStringLiteral("potentialScene"));
    if (!sceneValue.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23 is missing a valid potentialScene object.");
        return false;
    }
 
    const QJsonObject sceneJson = sceneValue.toObject();
    const QJsonValue activeValue = sceneJson.value(QStringLiteral("active"));
    const QJsonValue objectsValue = sceneJson.value(QStringLiteral("objects"));
    if (!activeValue.isBool() || !objectsValue.isArray()) {
        errorMessage = QStringLiteral("Experiment potentialScene must contain active and objects fields.");
        return false;
    }
 
    const QString composition = sceneJson.value(QStringLiteral("composition")).toString();
    if (!composition.isEmpty() && composition != QStringLiteral("additive")) {
        errorMessage = QStringLiteral("Unsupported potential scene composition '%1'.").arg(composition);
        return false;
    }
 
    PotentialScene2D scene;
    const QJsonArray objects = objectsValue.toArray();
    if (objects.size() > 512) {
        errorMessage = QStringLiteral("Potential scene contains too many objects (%1).").arg(objects.size());
        return false;
    }
 
    for (int i = 0; i < objects.size(); ++i) {
        if (!objects.at(i).isObject()) {
            errorMessage = QStringLiteral("Potential scene object %1 is not a JSON object.").arg(i);
            return false;
        }
        PotentialObject2D object;
        if (!potentialObjectFromJson(objects.at(i).toObject(), object, errorMessage, i)) {
            return false;
        }
        const std::uint64_t requestedId = object.id;
        const std::uint64_t insertedId = scene.add(object);
        if (insertedId != requestedId) {
            errorMessage = QStringLiteral("Potential scene contains duplicate object id %1.")
                               .arg(QString::number(static_cast<qulonglong>(requestedId)));
            return false;
        }
    }
 
    document.potentialSceneActive = activeValue.toBool();
    document.potentialScene = scene;
    if (document.potentialSceneActive && document.potentialScene.empty()) {
        document.potentialSceneActive = false;
    }
    return true;
}
 
/**
 * @brief Initializes ial preparation to json.
 * @param document The document value used by the operation.
 */
QJsonObject initialPreparationToJson(const ExperimentDocument2D &document)
{
    QJsonObject prep;
    QString type = QStringLiteral("gaussian");
    if (document.initialPreparationMode == 1) type = QStringLiteral("boundEigenstate");
    else if (document.initialPreparationMode == 2) type = QStringLiteral("boundSuperposition");
    else if (document.initialPreparationMode == 3) type = QStringLiteral("talbotComb");
    else if (document.initialPreparationMode == 4) type = QStringLiteral("vortex");
    else if (document.initialPreparationMode == 5) type = QStringLiteral("andersonDualLane");
    else if (document.initialPreparationMode == 6) type = QStringLiteral("kickedRotor");
    else if (document.initialPreparationMode == 7) type = QStringLiteral("quantumZeno");
    else if (document.initialPreparationMode == 8) type = QStringLiteral("berryFirstExcited");
    else if (document.initialPreparationMode == 9) type = QStringLiteral("moshinskyShutter");
    else if (document.initialPreparationMode == 10) type = QStringLiteral("kapitzaDiracBeam");
    else if (document.initialPreparationMode == 11) type = QStringLiteral("aharonovBohmBeam");
    else if (document.initialPreparationMode == 12) type = QStringLiteral("landauMagneticState");
    else if (document.initialPreparationMode == 13) type = QStringLiteral("quantumHallEdgeState");
    else if (document.initialPreparationMode == 14) type = QStringLiteral("quantumBackflowState");
    else if (document.initialPreparationMode == 15) type = QStringLiteral("diracZitterbewegungState");
    else if (document.initialPreparationMode == 16) type = QStringLiteral("diracKleinTunnelingState");
    prep.insert(QStringLiteral("type"), type);
    prep.insert(QStringLiteral("stateA"), document.boundStateA);
    prep.insert(QStringLiteral("stateB"), document.boundStateB);
    prep.insert(QStringLiteral("relativePhaseDegrees"), document.boundRelativePhaseDegrees);
    return prep;
}
 
 
/**
 * @brief Measures ment collapse to json.
 * @param document The document value used by the operation.
 */
QJsonObject measurementCollapseToJson(const ExperimentDocument2D &document)
{
    QJsonObject measurement;
    measurement.insert(QStringLiteral("resolution"), document.collapseResolution);
    return measurement;
}
 
/**
 * @brief Measures ment collapse from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool measurementCollapseFromJson(const QJsonObject &json,
                                 ExperimentDocument2D &document,
                                 QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("measurementCollapse"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23/24 is missing a valid measurementCollapse object.");
        return false;
    }
    const QJsonValue resolution = value.toObject().value(QStringLiteral("resolution"));
    if (!resolution.isDouble()) {
        errorMessage = QStringLiteral("Experiment measurementCollapse contains an invalid resolution.");
        return false;
    }
    document.collapseResolution = resolution.toDouble();
    if (!(document.collapseResolution > 0.0) ||
        !std::isfinite(document.collapseResolution) ||
        document.collapseResolution > 20.0) {
        errorMessage = QStringLiteral("Experiment measurement-collapse resolution is out of range.");
        return false;
    }
    return true;
}
 
 
/**
 * @brief Performs quantum quench to json.
 * @param document The document value used by the operation.
 */
QJsonObject quantumQuenchToJson(const ExperimentDocument2D &document)
{
    QJsonObject q;
    q.insert(QStringLiteral("enabled"), document.quench.enabled);
    q.insert(QStringLiteral("targetObjectId"), QString::number(static_cast<qulonglong>(document.quench.targetObjectId)));
    q.insert(QStringLiteral("parameter"), static_cast<int>(document.quench.parameter));
    q.insert(QStringLiteral("time"), document.quench.quenchTime);
    q.insert(QStringLiteral("before"), document.quench.beforeValue);
    q.insert(QStringLiteral("after"), document.quench.afterValue);
    return q;
}
 
/**
 * @brief Performs quantum quench from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool quantumQuenchFromJson(const QJsonObject &json,
                           ExperimentDocument2D &document,
                           QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("quantumQuench"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23 is missing a valid quantumQuench object.");
        return false;
    }
    const QJsonObject q = value.toObject();
    if (!q.value(QStringLiteral("enabled")).isBool() ||
        !q.value(QStringLiteral("parameter")).isDouble() ||
        !q.value(QStringLiteral("time")).isDouble() ||
        !q.value(QStringLiteral("before")).isDouble() ||
        !q.value(QStringLiteral("after")).isDouble()) {
        errorMessage = QStringLiteral("Experiment quantumQuench contains invalid fields.");
        return false;
    }
    document.quench.enabled = q.value(QStringLiteral("enabled")).toBool();
    bool idOk = false;
    const qulonglong id = q.value(QStringLiteral("targetObjectId")).toString().toULongLong(&idOk);
    document.quench.targetObjectId = idOk ? static_cast<std::uint64_t>(id) : 0;
    const int param = q.value(QStringLiteral("parameter")).toInt(-1);
    if (param < 0 || param > 7) {
        errorMessage = QStringLiteral("Experiment quantumQuench has an unsupported parameter.");
        return false;
    }
    document.quench.parameter = static_cast<TimePotentialParameter2D>(param);
    document.quench.quenchTime = q.value(QStringLiteral("time")).toDouble();
    document.quench.beforeValue = q.value(QStringLiteral("before")).toDouble();
    document.quench.afterValue = q.value(QStringLiteral("after")).toDouble();
    if (document.quench.enabled && !TimeDependentPotential2D::validate(document.potentialScene, document.quench)) {
        errorMessage = QStringLiteral("Experiment quantumQuench does not match its potential scene.");
        return false;
    }
    return true;
}
 
 
/**
 * @brief Performs periodic drive to json.
 * @param document The document value used by the operation.
 */
QJsonObject periodicDriveToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.periodicDrive.enabled);
    d.insert(QStringLiteral("targetObjectId"), QString::number(static_cast<qulonglong>(document.periodicDrive.targetObjectId)));
    d.insert(QStringLiteral("parameter"), static_cast<int>(document.periodicDrive.parameter));
    d.insert(QStringLiteral("mean"), document.periodicDrive.meanValue);
    d.insert(QStringLiteral("amplitude"), document.periodicDrive.amplitude);
    d.insert(QStringLiteral("angularFrequency"), document.periodicDrive.angularFrequency);
    d.insert(QStringLiteral("phaseDegrees"), document.periodicDrive.phaseDegrees);
    return d;
}
 
/**
 * @brief Performs periodic drive from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool periodicDriveFromJson(const QJsonObject &json,
                           ExperimentDocument2D &document,
                           QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("periodicDrive"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23 is missing a valid periodicDrive object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    if (!d.value(QStringLiteral("enabled")).isBool() ||
        !d.value(QStringLiteral("parameter")).isDouble() ||
        !d.value(QStringLiteral("mean")).isDouble() ||
        !d.value(QStringLiteral("amplitude")).isDouble() ||
        !d.value(QStringLiteral("angularFrequency")).isDouble() ||
        !d.value(QStringLiteral("phaseDegrees")).isDouble()) {
        errorMessage = QStringLiteral("Experiment periodicDrive contains invalid fields.");
        return false;
    }
    document.periodicDrive.enabled = d.value(QStringLiteral("enabled")).toBool();
    bool idOk = false;
    const qulonglong id = d.value(QStringLiteral("targetObjectId")).toString().toULongLong(&idOk);
    document.periodicDrive.targetObjectId = idOk ? static_cast<std::uint64_t>(id) : 0;
    const int param = d.value(QStringLiteral("parameter")).toInt(-1);
    if (param < 0 || param > 7) {
        errorMessage = QStringLiteral("Experiment periodicDrive has an unsupported parameter.");
        return false;
    }
    document.periodicDrive.parameter = static_cast<TimePotentialParameter2D>(param);
    document.periodicDrive.meanValue = d.value(QStringLiteral("mean")).toDouble();
    document.periodicDrive.amplitude = d.value(QStringLiteral("amplitude")).toDouble();
    document.periodicDrive.angularFrequency = d.value(QStringLiteral("angularFrequency")).toDouble();
    document.periodicDrive.phaseDegrees = d.value(QStringLiteral("phaseDegrees")).toDouble();
    if (document.periodicDrive.enabled &&
        !TimeDependentPotential2D::validatePeriodic(document.potentialScene, document.periodicDrive)) {
        errorMessage = QStringLiteral("Experiment periodicDrive does not match its potential scene.");
        return false;
    }
    return true;
}
 
/**
 * @brief Performs linear sweep to json.
 * @param document The document value used by the operation.
 */
QJsonObject linearSweepToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.linearSweep.enabled);
    d.insert(QStringLiteral("targetObjectId"), QString::number(static_cast<qulonglong>(document.linearSweep.targetObjectId)));
    d.insert(QStringLiteral("parameter"), static_cast<int>(document.linearSweep.parameter));
    d.insert(QStringLiteral("startValue"), document.linearSweep.startValue);
    d.insert(QStringLiteral("endValue"), document.linearSweep.endValue);
    d.insert(QStringLiteral("startTime"), document.linearSweep.startTime);
    d.insert(QStringLiteral("duration"), document.linearSweep.duration);
    d.insert(QStringLiteral("returnEnabled"), document.linearSweep.returnEnabled);
    d.insert(QStringLiteral("holdDuration"), document.linearSweep.holdDuration);
    d.insert(QStringLiteral("returnDuration"), document.linearSweep.returnDuration);
    return d;
}
 
/**
 * @brief Performs linear sweep from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool linearSweepFromJson(const QJsonObject &json,
                         ExperimentDocument2D &document,
                         QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("linearSweep"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23 is missing a valid linearSweep object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    if (!d.value(QStringLiteral("enabled")).isBool() ||
        !d.value(QStringLiteral("parameter")).isDouble() ||
        !d.value(QStringLiteral("startValue")).isDouble() ||
        !d.value(QStringLiteral("endValue")).isDouble() ||
        !d.value(QStringLiteral("startTime")).isDouble() ||
        !d.value(QStringLiteral("duration")).isDouble()) {
        errorMessage = QStringLiteral("Experiment linearSweep contains invalid fields.");
        return false;
    }
    document.linearSweep.enabled = d.value(QStringLiteral("enabled")).toBool();
    bool idOk = false;
    const qulonglong id = d.value(QStringLiteral("targetObjectId")).toString().toULongLong(&idOk);
    document.linearSweep.targetObjectId = idOk ? static_cast<std::uint64_t>(id) : 0;
    const int param = d.value(QStringLiteral("parameter")).toInt(-1);
    if (param < 0 || param > 7) {
        errorMessage = QStringLiteral("Experiment linearSweep has an unsupported parameter.");
        return false;
    }
    document.linearSweep.parameter = static_cast<TimePotentialParameter2D>(param);
    document.linearSweep.startValue = d.value(QStringLiteral("startValue")).toDouble();
    document.linearSweep.endValue = d.value(QStringLiteral("endValue")).toDouble();
    document.linearSweep.startTime = d.value(QStringLiteral("startTime")).toDouble();
    document.linearSweep.duration = d.value(QStringLiteral("duration")).toDouble();
    // Schema 8 had only a one-way sweep. Schema 9 adds optional return-leg
    // fields; when they are absent we preserve the old one-way semantics.
    const QJsonValue returnEnabledValue = d.value(QStringLiteral("returnEnabled"));
    const QJsonValue holdDurationValue = d.value(QStringLiteral("holdDuration"));
    const QJsonValue returnDurationValue = d.value(QStringLiteral("returnDuration"));
    if (!returnEnabledValue.isUndefined()) {
        if (!returnEnabledValue.isBool()) {
            errorMessage = QStringLiteral("Experiment linearSweep returnEnabled is invalid.");
            return false;
        }
        document.linearSweep.returnEnabled = returnEnabledValue.toBool();
    }
    if (!holdDurationValue.isUndefined()) {
        if (!holdDurationValue.isDouble()) {
            errorMessage = QStringLiteral("Experiment linearSweep holdDuration is invalid.");
            return false;
        }
        document.linearSweep.holdDuration = holdDurationValue.toDouble();
    }
    if (!returnDurationValue.isUndefined()) {
        if (!returnDurationValue.isDouble()) {
            errorMessage = QStringLiteral("Experiment linearSweep returnDuration is invalid.");
            return false;
        }
        document.linearSweep.returnDuration = returnDurationValue.toDouble();
    }
    if (document.linearSweep.enabled &&
        !TimeDependentPotential2D::validateSweep(document.potentialScene, document.linearSweep)) {
        errorMessage = QStringLiteral("Experiment linearSweep does not match its potential scene.");
        return false;
    }
    return true;
}
 
/**
 * @brief Performs ramsey sequence to json.
 * @param document The document value used by the operation.
 */
QJsonObject ramseySequenceToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.ramseySequence.enabled);
    d.insert(QStringLiteral("targetObjectId"), QString::number(static_cast<qulonglong>(document.ramseySequence.targetObjectId)));
    d.insert(QStringLiteral("parameter"), static_cast<int>(document.ramseySequence.parameter));
    d.insert(QStringLiteral("mean"), document.ramseySequence.meanValue);
    d.insert(QStringLiteral("amplitude"), document.ramseySequence.amplitude);
    d.insert(QStringLiteral("angularFrequency"), document.ramseySequence.angularFrequency);
    d.insert(QStringLiteral("firstPhaseDegrees"), document.ramseySequence.firstPulsePhaseDegrees);
    d.insert(QStringLiteral("secondPhaseDegrees"), document.ramseySequence.secondPulsePhaseDegrees);
    d.insert(QStringLiteral("startTime"), document.ramseySequence.startTime);
    d.insert(QStringLiteral("pulseDuration"), document.ramseySequence.pulseDuration);
    d.insert(QStringLiteral("freeEvolutionDuration"), document.ramseySequence.freeEvolutionDuration);
    d.insert(QStringLiteral("echoEnabled"), document.ramseySequence.echoEnabled);
    d.insert(QStringLiteral("echoPulseDuration"), document.ramseySequence.echoPulseDuration);
    d.insert(QStringLiteral("echoPulsePhaseDegrees"), document.ramseySequence.echoPulsePhaseDegrees);
    return d;
}
 
/**
 * @brief Performs ramsey sequence from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool ramseySequenceFromJson(const QJsonObject &json,
                            ExperimentDocument2D &document,
                            QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("ramseySequence"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 10/11/12/13/14/15/16/17/18/19/20/21/22/23 is missing a valid ramseySequence object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    const char *numericFields[] = {
        "parameter", "mean", "amplitude", "angularFrequency",
        "firstPhaseDegrees", "secondPhaseDegrees", "startTime",
        "pulseDuration", "freeEvolutionDuration"
    };
    if (!d.value(QStringLiteral("enabled")).isBool()) {
        errorMessage = QStringLiteral("Experiment ramseySequence contains an invalid enabled field.");
        return false;
    }
    for (const char *field : numericFields) {
        if (!d.value(QString::fromLatin1(field)).isDouble()) {
            errorMessage = QStringLiteral("Experiment ramseySequence contains invalid numeric fields.");
            return false;
        }
    }
    document.ramseySequence.enabled = d.value(QStringLiteral("enabled")).toBool();
    bool idOk = false;
    const qulonglong id = d.value(QStringLiteral("targetObjectId")).toString().toULongLong(&idOk);
    document.ramseySequence.targetObjectId = idOk ? static_cast<std::uint64_t>(id) : 0;
    const int param = d.value(QStringLiteral("parameter")).toInt(-1);
    if (param < 0 || param > 7) {
        errorMessage = QStringLiteral("Experiment ramseySequence has an unsupported parameter.");
        return false;
    }
    document.ramseySequence.parameter = static_cast<TimePotentialParameter2D>(param);
    document.ramseySequence.meanValue = d.value(QStringLiteral("mean")).toDouble();
    document.ramseySequence.amplitude = d.value(QStringLiteral("amplitude")).toDouble();
    document.ramseySequence.angularFrequency = d.value(QStringLiteral("angularFrequency")).toDouble();
    document.ramseySequence.firstPulsePhaseDegrees = d.value(QStringLiteral("firstPhaseDegrees")).toDouble();
    document.ramseySequence.secondPulsePhaseDegrees = d.value(QStringLiteral("secondPhaseDegrees")).toDouble();
    document.ramseySequence.startTime = d.value(QStringLiteral("startTime")).toDouble();
    document.ramseySequence.pulseDuration = d.value(QStringLiteral("pulseDuration")).toDouble();
    document.ramseySequence.freeEvolutionDuration = d.value(QStringLiteral("freeEvolutionDuration")).toDouble();
    // Schema 10 had no echo fields. Missing values therefore mean ordinary Ramsey.
    document.ramseySequence.echoEnabled = d.value(QStringLiteral("echoEnabled")).toBool(false);
    if (d.value(QStringLiteral("echoPulseDuration")).isDouble())
        document.ramseySequence.echoPulseDuration = d.value(QStringLiteral("echoPulseDuration")).toDouble();
    if (d.value(QStringLiteral("echoPulsePhaseDegrees")).isDouble())
        document.ramseySequence.echoPulsePhaseDegrees = d.value(QStringLiteral("echoPulsePhaseDegrees")).toDouble();
    if (document.ramseySequence.enabled &&
        !TimeDependentPotential2D::validateRamsey(document.potentialScene, document.ramseySequence)) {
        errorMessage = QStringLiteral("Experiment ramseySequence does not match its potential scene.");
        return false;
    }
    return true;
}
 
/**
 * @brief Performs ramsey ensemble to json.
 * @param document The document value used by the operation.
 */
QJsonObject ramseyEnsembleToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.ramseyEnsemble.enabled);
    d.insert(QStringLiteral("detuningStdDev"), document.ramseyEnsemble.detuningStdDev);
    d.insert(QStringLiteral("memberCount"), document.ramseyEnsemble.memberCount);
    return d;
}
 
/**
 * @brief Performs ramsey ensemble from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool ramseyEnsembleFromJson(const QJsonObject &json,
                            ExperimentDocument2D &document,
                            QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("ramseyEnsemble"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 12/13/14/15/16/17/18/19/20/21/22/23 is missing a valid ramseyEnsemble object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    if (!d.value(QStringLiteral("enabled")).isBool() ||
        !d.value(QStringLiteral("detuningStdDev")).isDouble() ||
        !d.value(QStringLiteral("memberCount")).isDouble()) {
        errorMessage = QStringLiteral("Experiment ramseyEnsemble contains invalid fields.");
        return false;
    }
    document.ramseyEnsemble.enabled = d.value(QStringLiteral("enabled")).toBool();
    document.ramseyEnsemble.detuningStdDev = d.value(QStringLiteral("detuningStdDev")).toDouble();
    document.ramseyEnsemble.memberCount = d.value(QStringLiteral("memberCount")).toInt(-1);
    if (!RamseyInterferometry2D::validateEnsembleConfig(document.ramseyEnsemble)) {
        errorMessage = QStringLiteral("Experiment ramseyEnsemble values are out of range.");
        return false;
    }
    return true;
}
 
/**
 * @brief Performs talbot initial state to json.
 * @param document The document value used by the operation.
 */
QJsonObject talbotInitialStateToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("period"), document.talbotInitialState.period);
    d.insert(QStringLiteral("toothSigma"), document.talbotInitialState.toothSigma);
    d.insert(QStringLiteral("offsetX"), document.talbotInitialState.offsetX);
    d.insert(QStringLiteral("centerY"), document.talbotInitialState.centerY);
    d.insert(QStringLiteral("sigmaY"), document.talbotInitialState.sigmaY);
    d.insert(QStringLiteral("momentumY"), document.talbotInitialState.momentumY);
    return d;
}
 
/**
 * @brief Performs talbot initial state from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool talbotInitialStateFromJson(const QJsonObject &json,
                                ExperimentDocument2D &document,
                                QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("talbotInitialState"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 13/14 is missing a valid talbotInitialState object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    const char *const names[] = {"period", "toothSigma", "offsetX", "centerY", "sigmaY", "momentumY"};
    for (const char *name : names) {
        if (!d.value(QString::fromLatin1(name)).isDouble()) {
            errorMessage = QStringLiteral("Experiment talbotInitialState contains invalid fields.");
            return false;
        }
    }
    document.talbotInitialState.period = d.value(QStringLiteral("period")).toDouble();
    document.talbotInitialState.toothSigma = d.value(QStringLiteral("toothSigma")).toDouble();
    document.talbotInitialState.offsetX = d.value(QStringLiteral("offsetX")).toDouble();
    document.talbotInitialState.centerY = d.value(QStringLiteral("centerY")).toDouble();
    document.talbotInitialState.sigmaY = d.value(QStringLiteral("sigmaY")).toDouble();
    document.talbotInitialState.momentumY = d.value(QStringLiteral("momentumY")).toDouble();
    if (!QuantumTalbot2D::validateConfig(document.talbotInitialState, nullptr)) {
        errorMessage = QStringLiteral("Experiment talbotInitialState values are out of range.");
        return false;
    }
    return true;
}
 
/**
 * @brief Performs vortex initial state to json.
 * @param document The document value used by the operation.
 */
QJsonObject vortexInitialStateToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("envelopeCenterX"), document.vortexInitialState.envelopeCenterX);
    d.insert(QStringLiteral("envelopeCenterY"), document.vortexInitialState.envelopeCenterY);
    d.insert(QStringLiteral("envelopeSigma"), document.vortexInitialState.envelopeSigma);
    d.insert(QStringLiteral("coreX"), document.vortexInitialState.coreX);
    d.insert(QStringLiteral("coreY"), document.vortexInitialState.coreY);
    d.insert(QStringLiteral("charge"), document.vortexInitialState.charge);
    return d;
}
 
/**
 * @brief Performs vortex initial state from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool vortexInitialStateFromJson(const QJsonObject &json,
                                ExperimentDocument2D &document,
                                QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("vortexInitialState"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 14/15/16/17/18/19/20/21/22/23 is missing a valid vortexInitialState object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    const char *const names[] = {"envelopeCenterX", "envelopeCenterY", "envelopeSigma", "coreX", "coreY", "charge"};
    for (const char *name : names) {
        if (!d.value(QString::fromLatin1(name)).isDouble()) {
            errorMessage = QStringLiteral("Experiment vortexInitialState contains invalid fields.");
            return false;
        }
    }
    document.vortexInitialState.envelopeCenterX = d.value(QStringLiteral("envelopeCenterX")).toDouble();
    document.vortexInitialState.envelopeCenterY = d.value(QStringLiteral("envelopeCenterY")).toDouble();
    document.vortexInitialState.envelopeSigma = d.value(QStringLiteral("envelopeSigma")).toDouble();
    document.vortexInitialState.coreX = d.value(QStringLiteral("coreX")).toDouble();
    document.vortexInitialState.coreY = d.value(QStringLiteral("coreY")).toDouble();
    document.vortexInitialState.charge = d.value(QStringLiteral("charge")).toInt(0);
    if (!QuantumVortex2D::validateConfig(document.vortexInitialState, nullptr)) {
        errorMessage = QStringLiteral("Experiment vortexInitialState values are out of range.");
        return false;
    }
    return true;
}
 
 
/**
 * @brief Performs anderson initial state to json.
 * @param document The document value used by the operation.
 */
QJsonObject andersonInitialStateToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("centerX"), document.andersonInitialState.centerX);
    d.insert(QStringLiteral("cleanLaneY"), document.andersonInitialState.cleanLaneY);
    d.insert(QStringLiteral("disorderLaneY"), document.andersonInitialState.disorderLaneY);
    d.insert(QStringLiteral("sigma"), document.andersonInitialState.sigma);
    d.insert(QStringLiteral("relativePhaseDegrees"), document.andersonInitialState.relativePhaseDegrees);
    return d;
}
 
/**
 * @brief Performs anderson initial state from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool andersonInitialStateFromJson(const QJsonObject &json,
                                  ExperimentDocument2D &document,
                                  QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("andersonInitialState"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 15 is missing a valid andersonInitialState object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    const char *const names[] = {"centerX", "cleanLaneY", "disorderLaneY", "sigma", "relativePhaseDegrees"};
    for (const char *name : names) {
        if (!d.value(QString::fromLatin1(name)).isDouble()) {
            errorMessage = QStringLiteral("Experiment andersonInitialState contains invalid fields.");
            return false;
        }
    }
    document.andersonInitialState.centerX = d.value(QStringLiteral("centerX")).toDouble();
    document.andersonInitialState.cleanLaneY = d.value(QStringLiteral("cleanLaneY")).toDouble();
    document.andersonInitialState.disorderLaneY = d.value(QStringLiteral("disorderLaneY")).toDouble();
    document.andersonInitialState.sigma = d.value(QStringLiteral("sigma")).toDouble();
    document.andersonInitialState.relativePhaseDegrees = d.value(QStringLiteral("relativePhaseDegrees")).toDouble();
    if (!QuantumAnderson2D::validateConfig(document.andersonInitialState, nullptr)) {
        errorMessage = QStringLiteral("Experiment andersonInitialState values are out of range.");
        return false;
    }
    return true;
}
 
 
/**
 * @brief Performs kicked rotor to json.
 * @param document The document value used by the operation.
 */
QJsonObject kickedRotorToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.kickedRotor.enabled);
    d.insert(QStringLiteral("firstKickTime"), document.kickedRotor.firstKickTime);
    d.insert(QStringLiteral("kickPeriod"), document.kickedRotor.kickPeriod);
    d.insert(QStringLiteral("phaseStrength"), document.kickedRotor.phaseStrength);
    return d;
}
 
/**
 * @brief Performs kicked rotor from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool kickedRotorFromJson(const QJsonObject &json,
                         ExperimentDocument2D &document,
                         QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("kickedRotor"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 16/17/18/19/20/21/22/23 is missing a valid kickedRotor object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    if (!d.value(QStringLiteral("enabled")).isBool() ||
        !d.value(QStringLiteral("firstKickTime")).isDouble() ||
        !d.value(QStringLiteral("kickPeriod")).isDouble() ||
        !d.value(QStringLiteral("phaseStrength")).isDouble()) {
        errorMessage = QStringLiteral("Experiment kickedRotor contains invalid fields.");
        return false;
    }
    document.kickedRotor.enabled = d.value(QStringLiteral("enabled")).toBool();
    document.kickedRotor.firstKickTime = d.value(QStringLiteral("firstKickTime")).toDouble();
    document.kickedRotor.kickPeriod = d.value(QStringLiteral("kickPeriod")).toDouble();
    document.kickedRotor.phaseStrength = d.value(QStringLiteral("phaseStrength")).toDouble();
    if (!QuantumKickedRotor2D::validateConfig(document.kickedRotor, nullptr)) {
        errorMessage = QStringLiteral("Experiment kickedRotor values are out of range.");
        return false;
    }
    return true;
}
 
/**
 * @brief Performs kicked rotor initial state to json.
 * @param document The document value used by the operation.
 */
QJsonObject kickedRotorInitialStateToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("yCenter"), document.kickedRotorInitialState.yCenter);
    d.insert(QStringLiteral("ySigma"), document.kickedRotorInitialState.ySigma);
    d.insert(QStringLiteral("initialMomentumMode"), document.kickedRotorInitialState.initialMomentumMode);
    return d;
}
 
/**
 * @brief Performs kicked rotor initial state from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool kickedRotorInitialStateFromJson(const QJsonObject &json,
                                     ExperimentDocument2D &document,
                                     QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("kickedRotorInitialState"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 16/17/18/19/20/21/22/23 is missing a valid kickedRotorInitialState object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    if (!d.value(QStringLiteral("yCenter")).isDouble() ||
        !d.value(QStringLiteral("ySigma")).isDouble() ||
        !d.value(QStringLiteral("initialMomentumMode")).isDouble()) {
        errorMessage = QStringLiteral("Experiment kickedRotorInitialState contains invalid fields.");
        return false;
    }
    document.kickedRotorInitialState.yCenter = d.value(QStringLiteral("yCenter")).toDouble();
    document.kickedRotorInitialState.ySigma = d.value(QStringLiteral("ySigma")).toDouble();
    document.kickedRotorInitialState.initialMomentumMode =
        d.value(QStringLiteral("initialMomentumMode")).toInt(0);
    if (!QuantumKickedRotor2D::validateInitialState(document.kickedRotorInitialState, nullptr)) {
        errorMessage = QStringLiteral("Experiment kickedRotorInitialState values are out of range.");
        return false;
    }
    return true;
}
 
 
/**
 * @brief Performs quantum zeno to json.
 * @param document The document value used by the operation.
 */
QJsonObject quantumZenoToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.quantumZeno.enabled);
    d.insert(QStringLiteral("firstMeasurementTime"), document.quantumZeno.firstMeasurementTime);
    d.insert(QStringLiteral("measurementPeriod"), document.quantumZeno.measurementPeriod);
    d.insert(QStringLiteral("laneSplitY"), document.quantumZeno.laneSplitY);
    d.insert(QStringLiteral("survivalBoundaryX"), document.quantumZeno.survivalBoundaryX);
    d.insert(QStringLiteral("edgeWidth"), document.quantumZeno.edgeWidth);
    return d;
}
 
/**
 * @brief Performs quantum zeno from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool quantumZenoFromJson(const QJsonObject &json,
                         ExperimentDocument2D &document,
                         QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("quantumZeno"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 17/18 is missing a valid quantumZeno object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    if (!d.value(QStringLiteral("enabled")).isBool() ||
        !d.value(QStringLiteral("firstMeasurementTime")).isDouble() ||
        !d.value(QStringLiteral("measurementPeriod")).isDouble() ||
        !d.value(QStringLiteral("laneSplitY")).isDouble() ||
        !d.value(QStringLiteral("survivalBoundaryX")).isDouble() ||
        !d.value(QStringLiteral("edgeWidth")).isDouble()) {
        errorMessage = QStringLiteral("Experiment quantumZeno contains invalid fields.");
        return false;
    }
    document.quantumZeno.enabled = d.value(QStringLiteral("enabled")).toBool();
    document.quantumZeno.firstMeasurementTime = d.value(QStringLiteral("firstMeasurementTime")).toDouble();
    document.quantumZeno.measurementPeriod = d.value(QStringLiteral("measurementPeriod")).toDouble();
    document.quantumZeno.laneSplitY = d.value(QStringLiteral("laneSplitY")).toDouble();
    document.quantumZeno.survivalBoundaryX = d.value(QStringLiteral("survivalBoundaryX")).toDouble();
    document.quantumZeno.edgeWidth = d.value(QStringLiteral("edgeWidth")).toDouble();
    if (!QuantumZeno2D::validateConfig(document.quantumZeno, nullptr)) {
        errorMessage = QStringLiteral("Experiment quantumZeno values are out of range.");
        return false;
    }
    return true;
}
 
/**
 * @brief Performs quantum zeno initial state to json.
 * @param document The document value used by the operation.
 */
QJsonObject quantumZenoInitialStateToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("centerX"), document.quantumZenoInitialState.centerX);
    d.insert(QStringLiteral("controlLaneY"), document.quantumZenoInitialState.controlLaneY);
    d.insert(QStringLiteral("watchedLaneY"), document.quantumZenoInitialState.watchedLaneY);
    d.insert(QStringLiteral("sigma"), document.quantumZenoInitialState.sigma);
    d.insert(QStringLiteral("momentumX"), document.quantumZenoInitialState.momentumX);
    d.insert(QStringLiteral("relativePhaseDegrees"), document.quantumZenoInitialState.relativePhaseDegrees);
    return d;
}
 
/**
 * @brief Performs quantum zeno initial state from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool quantumZenoInitialStateFromJson(const QJsonObject &json,
                                     ExperimentDocument2D &document,
                                     QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("quantumZenoInitialState"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 17/18 is missing a valid quantumZenoInitialState object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    if (!d.value(QStringLiteral("centerX")).isDouble() ||
        !d.value(QStringLiteral("controlLaneY")).isDouble() ||
        !d.value(QStringLiteral("watchedLaneY")).isDouble() ||
        !d.value(QStringLiteral("sigma")).isDouble() ||
        !d.value(QStringLiteral("momentumX")).isDouble() ||
        !d.value(QStringLiteral("relativePhaseDegrees")).isDouble()) {
        errorMessage = QStringLiteral("Experiment quantumZenoInitialState contains invalid fields.");
        return false;
    }
    document.quantumZenoInitialState.centerX = d.value(QStringLiteral("centerX")).toDouble();
    document.quantumZenoInitialState.controlLaneY = d.value(QStringLiteral("controlLaneY")).toDouble();
    document.quantumZenoInitialState.watchedLaneY = d.value(QStringLiteral("watchedLaneY")).toDouble();
    document.quantumZenoInitialState.sigma = d.value(QStringLiteral("sigma")).toDouble();
    document.quantumZenoInitialState.momentumX = d.value(QStringLiteral("momentumX")).toDouble();
    document.quantumZenoInitialState.relativePhaseDegrees = d.value(QStringLiteral("relativePhaseDegrees")).toDouble();
    if (!QuantumZeno2D::validateInitialState(document.quantumZenoInitialState, nullptr)) {
        errorMessage = QStringLiteral("Experiment quantumZenoInitialState values are out of range.");
        return false;
    }
    return true;
}
 
/**
 * @brief Performs quantum scar to json.
 * @param document The document value used by the operation.
 */
QJsonObject quantumScarToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.quantumScar.enabled);
    d.insert(QStringLiteral("orbitBandHalfWidth"), document.quantumScar.orbitBandHalfWidth);
    d.insert(QStringLiteral("referenceEnergy"), document.quantumScar.referenceEnergy);
    return d;
}
 
/**
 * @brief Performs quantum scar from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool quantumScarFromJson(const QJsonObject &json,
                         ExperimentDocument2D &document,
                         QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("quantumScar"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 18 is missing a valid quantumScar object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    if (!d.value(QStringLiteral("enabled")).isBool() ||
        !d.value(QStringLiteral("orbitBandHalfWidth")).isDouble() ||
        !d.value(QStringLiteral("referenceEnergy")).isDouble()) {
        errorMessage = QStringLiteral("Experiment quantumScar contains invalid fields.");
        return false;
    }
    document.quantumScar.enabled = d.value(QStringLiteral("enabled")).toBool();
    document.quantumScar.orbitBandHalfWidth = d.value(QStringLiteral("orbitBandHalfWidth")).toDouble();
    document.quantumScar.referenceEnergy = d.value(QStringLiteral("referenceEnergy")).toDouble();
    if (!QuantumScars2D::validateConfig(document.quantumScar, nullptr)) {
        errorMessage = QStringLiteral("Experiment quantumScar values are out of range.");
        return false;
    }
    return true;
}
 
/**
 * @brief Performs quantum berry to json.
 * @param document The document value used by the operation.
 */
QJsonObject quantumBerryToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.quantumBerry.enabled);
    d.insert(QStringLiteral("anisotropy"), document.quantumBerry.anisotropy);
    d.insert(QStringLiteral("startTime"), document.quantumBerry.startTime);
    d.insert(QStringLiteral("duration"), document.quantumBerry.duration);
    d.insert(QStringLiteral("winding"), document.quantumBerry.winding);
    return d;
}
 
/**
 * @brief Performs quantum berry from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool quantumBerryFromJson(const QJsonObject &json,
                          ExperimentDocument2D &document,
                          QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("quantumBerry"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 19 is missing a valid quantumBerry object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    if (!d.value(QStringLiteral("enabled")).isBool() ||
        !d.value(QStringLiteral("anisotropy")).isDouble() ||
        !d.value(QStringLiteral("startTime")).isDouble() ||
        !d.value(QStringLiteral("duration")).isDouble() ||
        !d.value(QStringLiteral("winding")).isDouble()) {
        errorMessage = QStringLiteral("Experiment quantumBerry contains invalid fields.");
        return false;
    }
    document.quantumBerry.enabled = d.value(QStringLiteral("enabled")).toBool();
    document.quantumBerry.anisotropy = d.value(QStringLiteral("anisotropy")).toDouble();
    document.quantumBerry.startTime = d.value(QStringLiteral("startTime")).toDouble();
    document.quantumBerry.duration = d.value(QStringLiteral("duration")).toDouble();
    document.quantumBerry.winding = d.value(QStringLiteral("winding")).toInt(0);
 
    if (document.quantumBerry.enabled) {
        QuantumBerryTrap2D trap;
        if (!QuantumBerryPhase2D::identifyTrap(document.potentialScene, trap, nullptr) ||
            !QuantumBerryPhase2D::validateConfig(document.quantumBerry, trap, nullptr)) {
            errorMessage = QStringLiteral("Experiment quantumBerry values or base harmonic trap are invalid.");
            return false;
        }
    }
    return true;
}
 
 
/**
 * @brief Performs quantum loschmidt to json.
 * @param document The document value used by the operation.
 */
QJsonObject quantumLoschmidtToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.quantumLoschmidt.enabled);
    d.insert(QStringLiteral("reversalTime"), document.quantumLoschmidt.reversalTime);
    d.insert(QStringLiteral("momentumErrorX"), document.quantumLoschmidt.momentumErrorX);
    d.insert(QStringLiteral("momentumErrorY"), document.quantumLoschmidt.momentumErrorY);
    return d;
}
 
/**
 * @brief Performs quantum loschmidt from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool quantumLoschmidtFromJson(const QJsonObject &json,
                              ExperimentDocument2D &document,
                              QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("quantumLoschmidt"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 20 is missing a valid quantumLoschmidt object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    if (!d.value(QStringLiteral("enabled")).isBool() ||
        !d.value(QStringLiteral("reversalTime")).isDouble() ||
        !d.value(QStringLiteral("momentumErrorX")).isDouble() ||
        !d.value(QStringLiteral("momentumErrorY")).isDouble()) {
        errorMessage = QStringLiteral("Experiment quantumLoschmidt contains invalid fields.");
        return false;
    }
    document.quantumLoschmidt.enabled = d.value(QStringLiteral("enabled")).toBool();
    document.quantumLoschmidt.reversalTime = d.value(QStringLiteral("reversalTime")).toDouble();
    document.quantumLoschmidt.momentumErrorX = d.value(QStringLiteral("momentumErrorX")).toDouble();
    document.quantumLoschmidt.momentumErrorY = d.value(QStringLiteral("momentumErrorY")).toDouble();
    if (!QuantumLoschmidtEcho2D::validateConfig(document.quantumLoschmidt, nullptr)) {
        errorMessage = QStringLiteral("Experiment quantumLoschmidt values are out of range.");
        return false;
    }
    return true;
}
 
 
/**
 * @brief Performs moshinsky initial state to json.
 * @param document The document value used by the operation.
 */
QJsonObject moshinskyInitialStateToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.moshinskyInitialState.enabled);
    d.insert(QStringLiteral("shutterX"), document.moshinskyInitialState.shutterX);
    d.insert(QStringLiteral("envelopeCenterX"), document.moshinskyInitialState.envelopeCenterX);
    d.insert(QStringLiteral("envelopeSigmaX"), document.moshinskyInitialState.envelopeSigmaX);
    d.insert(QStringLiteral("centerY"), document.moshinskyInitialState.centerY);
    d.insert(QStringLiteral("transverseSigmaY"), document.moshinskyInitialState.transverseSigmaY);
    d.insert(QStringLiteral("momentumX"), document.moshinskyInitialState.momentumX);
    d.insert(QStringLiteral("edgeWidth"), document.moshinskyInitialState.edgeWidth);
    return d;
}
 
/**
 * @brief Performs moshinsky initial state from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool moshinskyInitialStateFromJson(const QJsonObject &json,
                                    ExperimentDocument2D &document,
                                    QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("moshinskyInitialState"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 21 is missing a valid moshinskyInitialState object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    const char *names[] = {
        "shutterX", "envelopeCenterX", "envelopeSigmaX", "centerY",
        "transverseSigmaY", "momentumX", "edgeWidth"
    };
    if (!d.value(QStringLiteral("enabled")).isBool()) {
        errorMessage = QStringLiteral("Experiment moshinskyInitialState has invalid enabled field.");
        return false;
    }
    for (const char *name : names) {
        if (!d.value(QString::fromLatin1(name)).isDouble()) {
            errorMessage = QStringLiteral("Experiment moshinskyInitialState contains invalid numeric fields.");
            return false;
        }
    }
    document.moshinskyInitialState.enabled = d.value(QStringLiteral("enabled")).toBool();
    document.moshinskyInitialState.shutterX = d.value(QStringLiteral("shutterX")).toDouble();
    document.moshinskyInitialState.envelopeCenterX = d.value(QStringLiteral("envelopeCenterX")).toDouble();
    document.moshinskyInitialState.envelopeSigmaX = d.value(QStringLiteral("envelopeSigmaX")).toDouble();
    document.moshinskyInitialState.centerY = d.value(QStringLiteral("centerY")).toDouble();
    document.moshinskyInitialState.transverseSigmaY = d.value(QStringLiteral("transverseSigmaY")).toDouble();
    document.moshinskyInitialState.momentumX = d.value(QStringLiteral("momentumX")).toDouble();
    document.moshinskyInitialState.edgeWidth = d.value(QStringLiteral("edgeWidth")).toDouble();
    if (!QuantumMoshinsky2D::validateInitialState(document.moshinskyInitialState, nullptr)) {
        errorMessage = QStringLiteral("Experiment moshinskyInitialState values are out of range.");
        return false;
    }
    return true;
}
 
/**
 * @brief Performs quantum moshinsky to json.
 * @param document The document value used by the operation.
 */
QJsonObject quantumMoshinskyToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.quantumMoshinsky.enabled);
    d.insert(QStringLiteral("shutterObjectId"),
             QString::number(static_cast<qulonglong>(document.quantumMoshinsky.shutterObjectId)));
    d.insert(QStringLiteral("openTime"), document.quantumMoshinsky.openTime);
    d.insert(QStringLiteral("detectorX"), document.quantumMoshinsky.detectorX);
    d.insert(QStringLiteral("analysisEndTime"), document.quantumMoshinsky.analysisEndTime);
    return d;
}
 
/**
 * @brief Performs quantum moshinsky from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool quantumMoshinskyFromJson(const QJsonObject &json,
                               ExperimentDocument2D &document,
                               QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("quantumMoshinsky"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 21 is missing a valid quantumMoshinsky object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    if (!d.value(QStringLiteral("enabled")).isBool() ||
        !d.value(QStringLiteral("openTime")).isDouble() ||
        !d.value(QStringLiteral("detectorX")).isDouble() ||
        !d.value(QStringLiteral("analysisEndTime")).isDouble()) {
        errorMessage = QStringLiteral("Experiment quantumMoshinsky contains invalid fields.");
        return false;
    }
    document.quantumMoshinsky.enabled = d.value(QStringLiteral("enabled")).toBool();
    bool idOk = false;
    const qulonglong id = d.value(QStringLiteral("shutterObjectId")).toString().toULongLong(&idOk);
    document.quantumMoshinsky.shutterObjectId = idOk ? static_cast<std::uint64_t>(id) : 0u;
    document.quantumMoshinsky.openTime = d.value(QStringLiteral("openTime")).toDouble();
    document.quantumMoshinsky.detectorX = d.value(QStringLiteral("detectorX")).toDouble();
    document.quantumMoshinsky.analysisEndTime = d.value(QStringLiteral("analysisEndTime")).toDouble();
    if (document.quantumMoshinsky.enabled &&
        !QuantumMoshinsky2D::validateConfig(document.potentialScene, document.quantumMoshinsky, nullptr, nullptr)) {
        errorMessage = QStringLiteral("Experiment quantumMoshinsky does not match its potential scene.");
        return false;
    }
    return true;
}
 
 
/**
 * @brief Performs kapitza dirac initial state to json.
 * @param document The document value used by the operation.
 */
QJsonObject kapitzaDiracInitialStateToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("centerX"), document.kapitzaDiracInitialState.centerX);
    d.insert(QStringLiteral("centerY"), document.kapitzaDiracInitialState.centerY);
    d.insert(QStringLiteral("sigmaX"), document.kapitzaDiracInitialState.sigmaX);
    d.insert(QStringLiteral("sigmaY"), document.kapitzaDiracInitialState.sigmaY);
    d.insert(QStringLiteral("momentumX"), document.kapitzaDiracInitialState.momentumX);
    d.insert(QStringLiteral("momentumY"), document.kapitzaDiracInitialState.momentumY);
    return d;
}
 
/**
 * @brief Performs kapitza dirac initial state from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool kapitzaDiracInitialStateFromJson(const QJsonObject &json,
                                      ExperimentDocument2D &document,
                                      QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("kapitzaDiracInitialState"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 22 is missing a valid kapitzaDiracInitialState object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    const char *names[] = {"centerX", "centerY", "sigmaX", "sigmaY", "momentumX", "momentumY"};
    for (const char *name : names) {
        if (!d.value(QString::fromLatin1(name)).isDouble()) {
            errorMessage = QStringLiteral("Experiment kapitzaDiracInitialState contains invalid numeric fields.");
            return false;
        }
    }
    document.kapitzaDiracInitialState.centerX = d.value(QStringLiteral("centerX")).toDouble();
    document.kapitzaDiracInitialState.centerY = d.value(QStringLiteral("centerY")).toDouble();
    document.kapitzaDiracInitialState.sigmaX = d.value(QStringLiteral("sigmaX")).toDouble();
    document.kapitzaDiracInitialState.sigmaY = d.value(QStringLiteral("sigmaY")).toDouble();
    document.kapitzaDiracInitialState.momentumX = d.value(QStringLiteral("momentumX")).toDouble();
    document.kapitzaDiracInitialState.momentumY = d.value(QStringLiteral("momentumY")).toDouble();
    if (!QuantumKapitzaDirac2D::validateInitialState(document.kapitzaDiracInitialState, nullptr)) {
        errorMessage = QStringLiteral("Experiment kapitzaDiracInitialState values are out of range.");
        return false;
    }
    return true;
}
 
/**
 * @brief Performs quantum kapitza dirac to json.
 * @param document The document value used by the operation.
 */
QJsonObject quantumKapitzaDiracToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.quantumKapitzaDirac.enabled);
    d.insert(QStringLiteral("latticePeriod"), document.quantumKapitzaDirac.latticePeriod);
    d.insert(QStringLiteral("latticeDepth"), document.quantumKapitzaDirac.latticeDepth);
    d.insert(QStringLiteral("latticePhaseDegrees"), document.quantumKapitzaDirac.latticePhaseDegrees);
    d.insert(QStringLiteral("pulseStartTime"), document.quantumKapitzaDirac.pulseStartTime);
    d.insert(QStringLiteral("pulseDuration"), document.quantumKapitzaDirac.pulseDuration);
    d.insert(QStringLiteral("analysisEndTime"), document.quantumKapitzaDirac.analysisEndTime);
    d.insert(QStringLiteral("maximumOrder"), document.quantumKapitzaDirac.maximumOrder);
    return d;
}
 
/**
 * @brief Performs quantum kapitza dirac from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool quantumKapitzaDiracFromJson(const QJsonObject &json,
                                  ExperimentDocument2D &document,
                                  QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("quantumKapitzaDirac"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 22 is missing a valid quantumKapitzaDirac object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    if (!d.value(QStringLiteral("enabled")).isBool() ||
        !d.value(QStringLiteral("latticePeriod")).isDouble() ||
        !d.value(QStringLiteral("latticeDepth")).isDouble() ||
        !d.value(QStringLiteral("latticePhaseDegrees")).isDouble() ||
        !d.value(QStringLiteral("pulseStartTime")).isDouble() ||
        !d.value(QStringLiteral("pulseDuration")).isDouble() ||
        !d.value(QStringLiteral("analysisEndTime")).isDouble() ||
        !d.value(QStringLiteral("maximumOrder")).isDouble()) {
        errorMessage = QStringLiteral("Experiment quantumKapitzaDirac contains invalid fields.");
        return false;
    }
    document.quantumKapitzaDirac.enabled = d.value(QStringLiteral("enabled")).toBool();
    document.quantumKapitzaDirac.latticePeriod = d.value(QStringLiteral("latticePeriod")).toDouble();
    document.quantumKapitzaDirac.latticeDepth = d.value(QStringLiteral("latticeDepth")).toDouble();
    document.quantumKapitzaDirac.latticePhaseDegrees = d.value(QStringLiteral("latticePhaseDegrees")).toDouble();
    document.quantumKapitzaDirac.pulseStartTime = d.value(QStringLiteral("pulseStartTime")).toDouble();
    document.quantumKapitzaDirac.pulseDuration = d.value(QStringLiteral("pulseDuration")).toDouble();
    document.quantumKapitzaDirac.analysisEndTime = d.value(QStringLiteral("analysisEndTime")).toDouble();
    document.quantumKapitzaDirac.maximumOrder = d.value(QStringLiteral("maximumOrder")).toInt();
    if (!QuantumKapitzaDirac2D::validateConfig(document.quantumKapitzaDirac, 1.0, nullptr)) {
        errorMessage = QStringLiteral("Experiment quantumKapitzaDirac values are out of range.");
        return false;
    }
    return true;
}
 
 
/**
 * @brief Performs quantum aharonov bohm to json.
 * @param document The document value used by the operation.
 */
QJsonObject quantumAharonovBohmToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.quantumAharonovBohm.enabled);
    d.insert(QStringLiteral("solenoidX"), document.quantumAharonovBohm.solenoidX);
    d.insert(QStringLiteral("solenoidY"), document.quantumAharonovBohm.solenoidY);
    d.insert(QStringLiteral("solenoidRadius"), document.quantumAharonovBohm.solenoidRadius);
    d.insert(QStringLiteral("fluxQuanta"), document.quantumAharonovBohm.fluxQuanta);
    d.insert(QStringLiteral("barrierHeight"), document.quantumAharonovBohm.barrierHeight);
    d.insert(QStringLiteral("detectorX"), document.quantumAharonovBohm.detectorX);
    d.insert(QStringLiteral("analysisEndTime"), document.quantumAharonovBohm.analysisEndTime);
    return d;
}
 
/**
 * @brief Performs quantum aharonov bohm from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool quantumAharonovBohmFromJson(const QJsonObject &json,
                                  ExperimentDocument2D &document,
                                  QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("quantumAharonovBohm"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 23 is missing a valid quantumAharonovBohm object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    const char *numeric[] = {"solenoidX","solenoidY","solenoidRadius","fluxQuanta","barrierHeight","detectorX","analysisEndTime"};
    if (!d.value(QStringLiteral("enabled")).isBool()) {
        errorMessage = QStringLiteral("Experiment quantumAharonovBohm contains an invalid enabled field.");
        return false;
    }
    for (const char *name : numeric) {
        if (!d.value(QString::fromLatin1(name)).isDouble()) {
            errorMessage = QStringLiteral("Experiment quantumAharonovBohm contains invalid numeric fields.");
            return false;
        }
    }
    document.quantumAharonovBohm.enabled = d.value(QStringLiteral("enabled")).toBool();
    document.quantumAharonovBohm.solenoidX = d.value(QStringLiteral("solenoidX")).toDouble();
    document.quantumAharonovBohm.solenoidY = d.value(QStringLiteral("solenoidY")).toDouble();
    document.quantumAharonovBohm.solenoidRadius = d.value(QStringLiteral("solenoidRadius")).toDouble();
    document.quantumAharonovBohm.fluxQuanta = d.value(QStringLiteral("fluxQuanta")).toDouble();
    document.quantumAharonovBohm.barrierHeight = d.value(QStringLiteral("barrierHeight")).toDouble();
    document.quantumAharonovBohm.detectorX = d.value(QStringLiteral("detectorX")).toDouble();
    document.quantumAharonovBohm.analysisEndTime = d.value(QStringLiteral("analysisEndTime")).toDouble();
    if (!QuantumAharonovBohm2D::validateConfig(document.quantumAharonovBohm, nullptr)) {
        errorMessage = QStringLiteral("Experiment quantumAharonovBohm values are out of range.");
        return false;
    }
    return true;
}
 
/**
 * @brief Performs quantum landau to json.
 * @param document The document value used by the operation.
 */
QJsonObject quantumLandauToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.quantumLandau.enabled);
    d.insert(QStringLiteral("fieldStrength"), document.quantumLandau.fieldStrength);
    d.insert(QStringLiteral("preparationMode"), document.quantumLandau.preparationMode);
    d.insert(QStringLiteral("landauIndex"), document.quantumLandau.landauIndex);
    d.insert(QStringLiteral("orbitRadius"), document.quantumLandau.orbitRadius);
    d.insert(QStringLiteral("analysisEndTime"), document.quantumLandau.analysisEndTime);
    return d;
}
 
/**
 * @brief Performs quantum landau from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool quantumLandauFromJson(const QJsonObject &json, ExperimentDocument2D &document, QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("quantumLandau"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 24 is missing a valid quantumLandau object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    if (!d.value(QStringLiteral("enabled")).isBool() ||
        !d.value(QStringLiteral("fieldStrength")).isDouble() ||
        !d.value(QStringLiteral("preparationMode")).isDouble() ||
        !d.value(QStringLiteral("landauIndex")).isDouble() ||
        !d.value(QStringLiteral("orbitRadius")).isDouble() ||
        !d.value(QStringLiteral("analysisEndTime")).isDouble()) {
        errorMessage = QStringLiteral("Experiment quantumLandau contains invalid fields.");
        return false;
    }
    document.quantumLandau.enabled = d.value(QStringLiteral("enabled")).toBool();
    document.quantumLandau.fieldStrength = d.value(QStringLiteral("fieldStrength")).toDouble();
    document.quantumLandau.preparationMode = d.value(QStringLiteral("preparationMode")).toInt();
    document.quantumLandau.landauIndex = d.value(QStringLiteral("landauIndex")).toInt();
    document.quantumLandau.orbitRadius = d.value(QStringLiteral("orbitRadius")).toDouble();
    document.quantumLandau.analysisEndTime = d.value(QStringLiteral("analysisEndTime")).toDouble();
    if (!QuantumLandau2D::validateConfig(document.quantumLandau, nullptr)) {
        errorMessage = QStringLiteral("Experiment quantumLandau values are out of range.");
        return false;
    }
    return true;
}
 
/**
 * @brief Performs quantum hall edge to json.
 * @param document The document value used by the operation.
 */
QJsonObject quantumHallEdgeToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.quantumHallEdge.enabled);
    d.insert(QStringLiteral("fieldStrength"), document.quantumHallEdge.fieldStrength);
    d.insert(QStringLiteral("edgeY"), document.quantumHallEdge.edgeY);
    d.insert(QStringLiteral("wallHeight"), document.quantumHallEdge.wallHeight);
    d.insert(QStringLiteral("launchY"), document.quantumHallEdge.launchY);
    d.insert(QStringLiteral("orbitRadius"), document.quantumHallEdge.orbitRadius);
    d.insert(QStringLiteral("packetSigma"), document.quantumHallEdge.packetSigma);
    d.insert(QStringLiteral("edgeBand"), document.quantumHallEdge.edgeBand);
    d.insert(QStringLiteral("analysisEndTime"), document.quantumHallEdge.analysisEndTime);
    return d;
}
 
/**
 * @brief Performs quantum hall edge from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool quantumHallEdgeFromJson(const QJsonObject &json, ExperimentDocument2D &document, QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("quantumHallEdge"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 25 is missing a valid quantumHallEdge object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    const char *fields[] = {"fieldStrength","edgeY","wallHeight","launchY","orbitRadius","packetSigma","edgeBand","analysisEndTime"};
    if (!d.value(QStringLiteral("enabled")).isBool()) {
        errorMessage = QStringLiteral("Experiment quantumHallEdge contains invalid fields."); return false;
    }
    for (const char *f : fields) {
        if (!d.value(QString::fromLatin1(f)).isDouble()) {
            errorMessage = QStringLiteral("Experiment quantumHallEdge contains invalid fields."); return false;
        }
    }
    document.quantumHallEdge.enabled = d.value(QStringLiteral("enabled")).toBool();
    document.quantumHallEdge.fieldStrength = d.value(QStringLiteral("fieldStrength")).toDouble();
    document.quantumHallEdge.edgeY = d.value(QStringLiteral("edgeY")).toDouble();
    document.quantumHallEdge.wallHeight = d.value(QStringLiteral("wallHeight")).toDouble();
    document.quantumHallEdge.launchY = d.value(QStringLiteral("launchY")).toDouble();
    document.quantumHallEdge.orbitRadius = d.value(QStringLiteral("orbitRadius")).toDouble();
    document.quantumHallEdge.packetSigma = d.value(QStringLiteral("packetSigma")).toDouble();
    document.quantumHallEdge.edgeBand = d.value(QStringLiteral("edgeBand")).toDouble();
    document.quantumHallEdge.analysisEndTime = d.value(QStringLiteral("analysisEndTime")).toDouble();
    if (!QuantumHallEdge2D::validateConfig(document.quantumHallEdge, nullptr)) {
        errorMessage = QStringLiteral("Experiment quantumHallEdge values are out of range."); return false;
    }
    return true;
}
 
 
/**
 * @brief Performs quantum backflow to json.
 * @param document The document value used by the operation.
 */
QJsonObject quantumBackflowToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.quantumBackflow.enabled);
    d.insert(QStringLiteral("detectorX"), document.quantumBackflow.detectorX);
    d.insert(QStringLiteral("slowWaveNumber"), document.quantumBackflow.slowWaveNumber);
    d.insert(QStringLiteral("fastWaveNumber"), document.quantumBackflow.fastWaveNumber);
    d.insert(QStringLiteral("momentumSigma"), document.quantumBackflow.momentumSigma);
    d.insert(QStringLiteral("fastAmplitudeRatio"), document.quantumBackflow.fastAmplitudeRatio);
    d.insert(QStringLiteral("relativePhaseDegrees"), document.quantumBackflow.relativePhaseDegrees);
    d.insert(QStringLiteral("initialCenterX"), document.quantumBackflow.initialCenterX);
    d.insert(QStringLiteral("transverseSigma"), document.quantumBackflow.transverseSigma);
    d.insert(QStringLiteral("analysisEndTime"), document.quantumBackflow.analysisEndTime);
    return d;
}
 
/**
 * @brief Performs quantum backflow from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool quantumBackflowFromJson(const QJsonObject &json, ExperimentDocument2D &document, QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("quantumBackflow"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 26 is missing a valid quantumBackflow object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    const char *fields[] = {"detectorX","slowWaveNumber","fastWaveNumber","momentumSigma",
                            "fastAmplitudeRatio","relativePhaseDegrees","initialCenterX",
                            "transverseSigma","analysisEndTime"};
    if (!d.value(QStringLiteral("enabled")).isBool()) {
        errorMessage = QStringLiteral("Experiment quantumBackflow contains invalid fields.");
        return false;
    }
    for (const char *f : fields) {
        if (!d.value(QString::fromLatin1(f)).isDouble()) {
            errorMessage = QStringLiteral("Experiment quantumBackflow contains invalid fields.");
            return false;
        }
    }
    document.quantumBackflow.enabled = d.value(QStringLiteral("enabled")).toBool();
    document.quantumBackflow.detectorX = d.value(QStringLiteral("detectorX")).toDouble();
    document.quantumBackflow.slowWaveNumber = d.value(QStringLiteral("slowWaveNumber")).toDouble();
    document.quantumBackflow.fastWaveNumber = d.value(QStringLiteral("fastWaveNumber")).toDouble();
    document.quantumBackflow.momentumSigma = d.value(QStringLiteral("momentumSigma")).toDouble();
    document.quantumBackflow.fastAmplitudeRatio = d.value(QStringLiteral("fastAmplitudeRatio")).toDouble();
    document.quantumBackflow.relativePhaseDegrees = d.value(QStringLiteral("relativePhaseDegrees")).toDouble();
    document.quantumBackflow.initialCenterX = d.value(QStringLiteral("initialCenterX")).toDouble();
    document.quantumBackflow.transverseSigma = d.value(QStringLiteral("transverseSigma")).toDouble();
    document.quantumBackflow.analysisEndTime = d.value(QStringLiteral("analysisEndTime")).toDouble();
    if (!QuantumBackflow2D::validateConfig(document.quantumBackflow, nullptr)) {
        errorMessage = QStringLiteral("Experiment quantumBackflow values are out of range.");
        return false;
    }
    return true;
}
 
 
/**
 * @brief Performs quantum zitterbewegung to json.
 * @param document The document value used by the operation.
 */
QJsonObject quantumZitterbewegungToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    d.insert(QStringLiteral("enabled"), document.quantumZitterbewegung.enabled);
    d.insert(QStringLiteral("lightSpeed"), document.quantumZitterbewegung.lightSpeed);
    d.insert(QStringLiteral("restMass"), document.quantumZitterbewegung.restMass);
    d.insert(QStringLiteral("centerX"), document.quantumZitterbewegung.centerX);
    d.insert(QStringLiteral("centerY"), document.quantumZitterbewegung.centerY);
    d.insert(QStringLiteral("sigma"), document.quantumZitterbewegung.sigma);
    d.insert(QStringLiteral("momentumX"), document.quantumZitterbewegung.momentumX);
    d.insert(QStringLiteral("momentumY"), document.quantumZitterbewegung.momentumY);
    d.insert(QStringLiteral("preparationMode"), document.quantumZitterbewegung.preparationMode);
    d.insert(QStringLiteral("analysisEndTime"), document.quantumZitterbewegung.analysisEndTime);
    return d;
}
 
/**
 * @brief Performs quantum zitterbewegung from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool quantumZitterbewegungFromJson(const QJsonObject &json,
                                   ExperimentDocument2D &document,
                                   QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("quantumZitterbewegung"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 27 is missing a valid quantumZitterbewegung object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    if (!d.value(QStringLiteral("enabled")).isBool() ||
        !d.value(QStringLiteral("preparationMode")).isDouble()) {
        errorMessage = QStringLiteral("Experiment quantumZitterbewegung contains invalid fields.");
        return false;
    }
    const char *fields[] = {"lightSpeed","restMass","centerX","centerY","sigma",
                            "momentumX","momentumY","analysisEndTime"};
    for (const char *f : fields) {
        if (!d.value(QString::fromLatin1(f)).isDouble()) {
            errorMessage = QStringLiteral("Experiment quantumZitterbewegung contains invalid fields.");
            return false;
        }
    }
    document.quantumZitterbewegung.enabled = d.value(QStringLiteral("enabled")).toBool();
    document.quantumZitterbewegung.lightSpeed = d.value(QStringLiteral("lightSpeed")).toDouble();
    document.quantumZitterbewegung.restMass = d.value(QStringLiteral("restMass")).toDouble();
    document.quantumZitterbewegung.centerX = d.value(QStringLiteral("centerX")).toDouble();
    document.quantumZitterbewegung.centerY = d.value(QStringLiteral("centerY")).toDouble();
    document.quantumZitterbewegung.sigma = d.value(QStringLiteral("sigma")).toDouble();
    document.quantumZitterbewegung.momentumX = d.value(QStringLiteral("momentumX")).toDouble();
    document.quantumZitterbewegung.momentumY = d.value(QStringLiteral("momentumY")).toDouble();
    document.quantumZitterbewegung.preparationMode = d.value(QStringLiteral("preparationMode")).toInt(-1);
    document.quantumZitterbewegung.analysisEndTime = d.value(QStringLiteral("analysisEndTime")).toDouble();
    if (!QuantumZitterbewegung2D::validateConfig(document.quantumZitterbewegung, nullptr)) {
        errorMessage = QStringLiteral("Experiment quantumZitterbewegung values are out of range.");
        return false;
    }
    return true;
}
 
 
/**
 * @brief Performs quantum klein tunneling to json.
 * @param document The document value used by the operation.
 */
QJsonObject quantumKleinTunnelingToJson(const ExperimentDocument2D &document)
{
    QJsonObject d;
    const auto &c = document.quantumKleinTunneling;
    d.insert(QStringLiteral("enabled"), c.enabled);
    d.insert(QStringLiteral("lightSpeed"), c.lightSpeed);
    d.insert(QStringLiteral("restMass"), c.restMass);
    d.insert(QStringLiteral("centerX"), c.centerX);
    d.insert(QStringLiteral("centerY"), c.centerY);
    d.insert(QStringLiteral("sigma"), c.sigma);
    d.insert(QStringLiteral("momentumX"), c.momentumX);
    d.insert(QStringLiteral("momentumY"), c.momentumY);
    d.insert(QStringLiteral("barrierCenterX"), c.barrierCenterX);
    d.insert(QStringLiteral("barrierWidth"), c.barrierWidth);
    d.insert(QStringLiteral("barrierHeight"), c.barrierHeight);
    d.insert(QStringLiteral("detectorX"), c.detectorX);
    d.insert(QStringLiteral("analysisEndTime"), c.analysisEndTime);
    return d;
}
 
/**
 * @brief Performs quantum klein tunneling from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool quantumKleinTunnelingFromJson(const QJsonObject &json,
                                   ExperimentDocument2D &document,
                                   QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("quantumKleinTunneling"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 28 is missing a valid quantumKleinTunneling object.");
        return false;
    }
    const QJsonObject d = value.toObject();
    if (!d.value(QStringLiteral("enabled")).isBool()) {
        errorMessage = QStringLiteral("Experiment quantumKleinTunneling contains invalid fields.");
        return false;
    }
    const char *fields[] = {"lightSpeed","restMass","centerX","centerY","sigma","momentumX","momentumY",
                            "barrierCenterX","barrierWidth","barrierHeight","detectorX","analysisEndTime"};
    for (const char *f : fields) {
        if (!d.value(QString::fromLatin1(f)).isDouble()) {
            errorMessage = QStringLiteral("Experiment quantumKleinTunneling contains invalid fields.");
            return false;
        }
    }
    auto &c = document.quantumKleinTunneling;
    c.enabled = d.value(QStringLiteral("enabled")).toBool();
    c.lightSpeed = d.value(QStringLiteral("lightSpeed")).toDouble();
    c.restMass = d.value(QStringLiteral("restMass")).toDouble();
    c.centerX = d.value(QStringLiteral("centerX")).toDouble();
    c.centerY = d.value(QStringLiteral("centerY")).toDouble();
    c.sigma = d.value(QStringLiteral("sigma")).toDouble();
    c.momentumX = d.value(QStringLiteral("momentumX")).toDouble();
    c.momentumY = d.value(QStringLiteral("momentumY")).toDouble();
    c.barrierCenterX = d.value(QStringLiteral("barrierCenterX")).toDouble();
    c.barrierWidth = d.value(QStringLiteral("barrierWidth")).toDouble();
    c.barrierHeight = d.value(QStringLiteral("barrierHeight")).toDouble();
    c.detectorX = d.value(QStringLiteral("detectorX")).toDouble();
    c.analysisEndTime = d.value(QStringLiteral("analysisEndTime")).toDouble();
    if (!QuantumKleinTunneling2D::validateConfig(c, nullptr)) {
        errorMessage = QStringLiteral("Experiment quantumKleinTunneling values are out of range.");
        return false;
    }
    return true;
}
 
/**
 * @brief Initializes ial preparation from json.
 * @param json The json value used by the operation.
 * @param document The document value used by the operation.
 * @param errorMessage The error message value used by the operation.
 */
bool initialPreparationFromJson(const QJsonObject &json,
                                ExperimentDocument2D &document,
                                QString &errorMessage)
{
    const QJsonValue value = json.value(QStringLiteral("initialPreparation"));
    if (!value.isObject()) {
        errorMessage = QStringLiteral("Experiment schema 4+ is missing a valid initialPreparation object.");
        return false;
    }
    const QJsonObject prep = value.toObject();
    const QString type = prep.value(QStringLiteral("type")).toString();
    if (type == QStringLiteral("gaussian")) document.initialPreparationMode = 0;
    else if (type == QStringLiteral("boundEigenstate")) document.initialPreparationMode = 1;
    else if (type == QStringLiteral("boundSuperposition")) document.initialPreparationMode = 2;
    else if (type == QStringLiteral("talbotComb")) document.initialPreparationMode = 3;
    else if (type == QStringLiteral("vortex")) document.initialPreparationMode = 4;
    else if (type == QStringLiteral("andersonDualLane")) document.initialPreparationMode = 5;
    else if (type == QStringLiteral("kickedRotor")) document.initialPreparationMode = 6;
    else if (type == QStringLiteral("quantumZeno")) document.initialPreparationMode = 7;
    else if (type == QStringLiteral("berryFirstExcited")) document.initialPreparationMode = 8;
    else if (type == QStringLiteral("moshinskyShutter")) document.initialPreparationMode = 9;
    else if (type == QStringLiteral("kapitzaDiracBeam")) document.initialPreparationMode = 10;
    else if (type == QStringLiteral("aharonovBohmBeam")) document.initialPreparationMode = 11;
    else if (type == QStringLiteral("landauMagneticState")) document.initialPreparationMode = 12;
    else if (type == QStringLiteral("quantumHallEdgeState")) document.initialPreparationMode = 13;
    else if (type == QStringLiteral("quantumBackflowState")) document.initialPreparationMode = 14;
    else if (type == QStringLiteral("diracZitterbewegungState")) document.initialPreparationMode = 15;
    else if (type == QStringLiteral("diracKleinTunnelingState")) document.initialPreparationMode = 16;
    else {
        errorMessage = QStringLiteral("Experiment initialPreparation has unknown type '%1'.").arg(type);
        return false;
    }
 
    const QJsonValue a = prep.value(QStringLiteral("stateA"));
    const QJsonValue b = prep.value(QStringLiteral("stateB"));
    const QJsonValue phase = prep.value(QStringLiteral("relativePhaseDegrees"));
    if (!a.isDouble() || !b.isDouble() || !phase.isDouble()) {
        errorMessage = QStringLiteral("Experiment initialPreparation contains invalid state/phase fields.");
        return false;
    }
    document.boundStateA = a.toInt(-1);
    document.boundStateB = b.toInt(-1);
    document.boundRelativePhaseDegrees = phase.toDouble();
    if (document.boundStateA < 0 || document.boundStateA > 31 ||
        document.boundStateB < 0 || document.boundStateB > 31 ||
        !std::isfinite(document.boundRelativePhaseDegrees)) {
        errorMessage = QStringLiteral("Experiment initialPreparation values are out of range.");
        return false;
    }
    if (document.initialPreparationMode == 2 && document.boundStateA == document.boundStateB) {
        errorMessage = QStringLiteral("Bound-state superposition requires two different states.");
        return false;
    }
    return true;
}
 
} // namespace
 
QString ExperimentDocument2DJson::formatId()
{
    return QStringLiteral("QuantumPhenomenaExplorer.Experiment2D");
}
 
QJsonObject ExperimentDocument2DJson::toJson(const ExperimentDocument2D &document)
{
    QJsonObject controlsObject;
    QMap<QString, QVariant>::const_iterator it = document.controls.constBegin();
    for (; it != document.controls.constEnd(); ++it) {
        controlsObject.insert(it.key(), QJsonValue::fromVariant(it.value()));
    }
 
    QJsonObject root;
    root.insert(QStringLiteral("format"), formatId());
    root.insert(QStringLiteral("schemaVersion"), document.schemaVersion);
    root.insert(QStringLiteral("name"), document.name);
    root.insert(QStringLiteral("sourcePreset"), document.sourcePreset);
    root.insert(QStringLiteral("controls"), controlsObject);
    if (document.schemaVersion >= 2) {
        root.insert(QStringLiteral("potentialScene"), potentialSceneToJson(document));
    }
    if (document.schemaVersion >= 4) {
        root.insert(QStringLiteral("initialPreparation"), initialPreparationToJson(document));
    }
    if (document.schemaVersion >= 5) {
        root.insert(QStringLiteral("measurementCollapse"), measurementCollapseToJson(document));
    }
    if (document.schemaVersion >= 6) {
        root.insert(QStringLiteral("quantumQuench"), quantumQuenchToJson(document));
    }
    if (document.schemaVersion >= 7) {
        root.insert(QStringLiteral("periodicDrive"), periodicDriveToJson(document));
    }
    if (document.schemaVersion >= 8) {
        root.insert(QStringLiteral("linearSweep"), linearSweepToJson(document));
    }
    if (document.schemaVersion >= 10) {
        root.insert(QStringLiteral("ramseySequence"), ramseySequenceToJson(document));
    }
    if (document.schemaVersion >= 12) {
        root.insert(QStringLiteral("ramseyEnsemble"), ramseyEnsembleToJson(document));
    }
    if (document.schemaVersion >= 13) {
        root.insert(QStringLiteral("talbotInitialState"), talbotInitialStateToJson(document));
    }
    if (document.schemaVersion >= 14) {
        root.insert(QStringLiteral("vortexInitialState"), vortexInitialStateToJson(document));
    }
    if (document.schemaVersion >= 15) {
        root.insert(QStringLiteral("andersonInitialState"), andersonInitialStateToJson(document));
    }
    if (document.schemaVersion >= 16) {
        root.insert(QStringLiteral("kickedRotor"), kickedRotorToJson(document));
        root.insert(QStringLiteral("kickedRotorInitialState"), kickedRotorInitialStateToJson(document));
    }
    if (document.schemaVersion >= 17) {
        root.insert(QStringLiteral("quantumZeno"), quantumZenoToJson(document));
        root.insert(QStringLiteral("quantumZenoInitialState"), quantumZenoInitialStateToJson(document));
    }
    if (document.schemaVersion >= 18) {
        root.insert(QStringLiteral("quantumScar"), quantumScarToJson(document));
    }
    if (document.schemaVersion >= 19) {
        root.insert(QStringLiteral("quantumBerry"), quantumBerryToJson(document));
    }
    if (document.schemaVersion >= 20) {
        root.insert(QStringLiteral("quantumLoschmidt"), quantumLoschmidtToJson(document));
    }
    if (document.schemaVersion >= 21) {
        root.insert(QStringLiteral("moshinskyInitialState"), moshinskyInitialStateToJson(document));
        root.insert(QStringLiteral("quantumMoshinsky"), quantumMoshinskyToJson(document));
    }
    if (document.schemaVersion >= 22) {
        root.insert(QStringLiteral("kapitzaDiracInitialState"), kapitzaDiracInitialStateToJson(document));
        root.insert(QStringLiteral("quantumKapitzaDirac"), quantumKapitzaDiracToJson(document));
    }
    if (document.schemaVersion >= 23) {
        root.insert(QStringLiteral("quantumAharonovBohm"), quantumAharonovBohmToJson(document));
    }
    if (document.schemaVersion >= 24) {
        root.insert(QStringLiteral("quantumLandau"), quantumLandauToJson(document));
    }
    if (document.schemaVersion >= 25) {
        root.insert(QStringLiteral("quantumHallEdge"), quantumHallEdgeToJson(document));
    }
    if (document.schemaVersion >= 26) {
        root.insert(QStringLiteral("quantumBackflow"), quantumBackflowToJson(document));
    }
    if (document.schemaVersion >= 27) {
        root.insert(QStringLiteral("quantumZitterbewegung"), quantumZitterbewegungToJson(document));
    }
    if (document.schemaVersion >= 28) {
        root.insert(QStringLiteral("quantumKleinTunneling"), quantumKleinTunnelingToJson(document));
    }
    return root;
}
 
bool ExperimentDocument2DJson::fromJson(const QJsonObject &json,
                                         ExperimentDocument2D &document,
                                         QString &errorMessage)
{
    errorMessage.clear();
 
    const QString format = json.value(QStringLiteral("format")).toString();
    if (format != formatId()) {
        errorMessage = QStringLiteral("This JSON file is not a Quantum Phenomena Explorer experiment document.");
        return false;
    }
 
    const QJsonValue versionValue = json.value(QStringLiteral("schemaVersion"));
    if (!versionValue.isDouble()) {
        errorMessage = QStringLiteral("Experiment document is missing a valid schemaVersion.");
        return false;
    }
 
    const int version = versionValue.toInt(-1);
    if (version < 1 || version > ExperimentDocument2D::CurrentSchemaVersion) {
        errorMessage = QStringLiteral("Unsupported experiment schema version %1 (this build supports versions 1 through %2).")
                           .arg(version)
                           .arg(ExperimentDocument2D::CurrentSchemaVersion);
        return false;
    }
 
    const QJsonValue controlsValue = json.value(QStringLiteral("controls"));
    if (!controlsValue.isObject()) {
        errorMessage = QStringLiteral("Experiment document does not contain a valid controls object.");
        return false;
    }
 
    ExperimentDocument2D parsed;
    // In-memory documents are always promoted to the current schema after a
    // successful load.  Re-saving an older document therefore writes the current schema.
    parsed.schemaVersion = ExperimentDocument2D::CurrentSchemaVersion;
    parsed.name = json.value(QStringLiteral("name")).toString();
    parsed.sourcePreset = json.value(QStringLiteral("sourcePreset")).toString();
 
    const QJsonObject controlsObject = controlsValue.toObject();
    QJsonObject::const_iterator it = controlsObject.constBegin();
    for (; it != controlsObject.constEnd(); ++it) {
        if (it.value().isUndefined() || it.value().isNull() ||
            it.value().isArray() || it.value().isObject()) {
            continue;
        }
        parsed.controls.insert(it.key(), it.value().toVariant());
    }
 
    if (parsed.controls.isEmpty()) {
        errorMessage = QStringLiteral("Experiment document contains no usable control values.");
        return false;
    }
 
    if (version >= 2 && !potentialSceneFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 4 && !initialPreparationFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 5 && !measurementCollapseFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 6 && !quantumQuenchFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 7 && !periodicDriveFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 8 && !linearSweepFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 10 && !ramseySequenceFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 12 && !ramseyEnsembleFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 13 && !talbotInitialStateFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 14 && !vortexInitialStateFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 15 && !andersonInitialStateFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 16 && !kickedRotorFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 16 && !kickedRotorInitialStateFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 17 && !quantumZenoFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 17 && !quantumZenoInitialStateFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 18 && !quantumScarFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 19 && !quantumBerryFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 20 && !quantumLoschmidtFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 21 && !moshinskyInitialStateFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 21 && !quantumMoshinskyFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 22 && !kapitzaDiracInitialStateFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 22 && !quantumKapitzaDiracFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 23 && !quantumAharonovBohmFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 24 && !quantumLandauFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 25 && !quantumHallEdgeFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 26 && !quantumBackflowFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 27 && !quantumZitterbewegungFromJson(json, parsed, errorMessage)) {
        return false;
    }
    if (version >= 28 && !quantumKleinTunnelingFromJson(json, parsed, errorMessage)) {
        return false;
    }
 
    document = parsed;
    return true;
}
 
bool ExperimentDocument2DJson::saveFile(const QString &fileName,
                                         const ExperimentDocument2D &document,
                                         QString &errorMessage)
{
    errorMessage.clear();
 
    QSaveFile file(fileName);
    if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
        errorMessage = QStringLiteral("Cannot open '%1' for writing: %2")
                           .arg(fileName, file.errorString());
        return false;
    }
 
    const QJsonDocument jsonDocument(toJson(document));
    const QByteArray bytes = jsonDocument.toJson(QJsonDocument::Indented);
    if (file.write(bytes) != bytes.size()) {
        errorMessage = QStringLiteral("Cannot write '%1': %2")
                           .arg(fileName, file.errorString());
        file.cancelWriting();
        return false;
    }
 
    if (!file.commit()) {
        errorMessage = QStringLiteral("Cannot commit '%1': %2")
                           .arg(fileName, file.errorString());
        return false;
    }
 
    return true;
}
 
bool ExperimentDocument2DJson::loadFile(const QString &fileName,
                                         ExperimentDocument2D &document,
                                         QString &errorMessage)
{
    errorMessage.clear();
 
    QFile file(fileName);
    if (!file.open(QIODevice::ReadOnly)) {
        errorMessage = QStringLiteral("Cannot open '%1': %2")
                           .arg(fileName, file.errorString());
        return false;
    }
 
    QJsonParseError parseError;
    const QJsonDocument jsonDocument = QJsonDocument::fromJson(file.readAll(), &parseError);
    if (parseError.error != QJsonParseError::NoError) {
        errorMessage = QStringLiteral("JSON parse error at offset %1: %2")
                           .arg(parseError.offset)
                           .arg(parseError.errorString());
        return false;
    }
 
    if (!jsonDocument.isObject()) {
        errorMessage = QStringLiteral("Experiment JSON root must be an object.");
        return false;
    }
 
    return fromJson(jsonDocument.object(), document, errorMessage);
}
 
} // namespace qpe