timedependentpotential2d.cpp

Go to the documentation of this file.

/**
 * @file timedependentpotential2d.cpp
 * @brief Implements the timedependentpotential2d physics/numerical component used by QPE experiments.
 * @ingroup qpe_quantum
 *
 * Source: @c core/quantum/timedependentpotential2d.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 "timedependentpotential2d.h"
 
#include "core/quantum/potentialfield2d.h"
 
#include <algorithm>
#include <cmath>
 
namespace qpe {
namespace {
 
/**
 * @brief Performs finite.
 * @param value Value to assign or evaluate.
 */
bool finite(double value) noexcept
{
    return std::isfinite(value);
}
 
const double Pi = 3.1415926535897932384626433832795;
 
} // namespace
 
bool TimeDependentPotential2D::validate(const PotentialScene2D &scene,
                                        const QuantumQuench2DConfig &config) noexcept
{
    if (!config.enabled) {
        return true;
    }
    if (config.targetObjectId == 0 || !finite(config.quenchTime) || config.quenchTime < 0.0 ||
        !finite(config.beforeValue) || !finite(config.afterValue)) {
        return false;
    }
    const PotentialObject2D *object = scene.find(config.targetObjectId);
    if (!object) {
        return false;
    }
    double ignored = 0.0;
    return parameterValue(*object, config.parameter, ignored);
}
 
bool TimeDependentPotential2D::validatePeriodic(
    const PotentialScene2D &scene,
    const PeriodicPotentialDrive2DConfig &config) noexcept
{
    if (!config.enabled) {
        return true;
    }
    if (config.targetObjectId == 0 || !finite(config.meanValue) ||
        !finite(config.amplitude) || !finite(config.angularFrequency) ||
        config.angularFrequency < 0.0 || !finite(config.phaseDegrees)) {
        return false;
    }
    const PotentialObject2D *object = scene.find(config.targetObjectId);
    if (!object) {
        return false;
    }
    double ignored = 0.0;
    return parameterValue(*object, config.parameter, ignored);
}
 
bool TimeDependentPotential2D::validateSweep(
    const PotentialScene2D &scene,
    const LinearPotentialSweep2DConfig &config) noexcept
{
    if (!config.enabled) {
        return true;
    }
    if (config.targetObjectId == 0 || !finite(config.startValue) ||
        !finite(config.endValue) || !finite(config.startTime) ||
        !finite(config.duration) || !finite(config.holdDuration) ||
        !finite(config.returnDuration) || config.startTime < 0.0 ||
        !(config.duration > 0.0) || config.holdDuration < 0.0 ||
        (config.returnEnabled && !(config.returnDuration > 0.0))) {
        return false;
    }
    const PotentialObject2D *object = scene.find(config.targetObjectId);
    if (!object) {
        return false;
    }
    double ignored = 0.0;
    return parameterValue(*object, config.parameter, ignored);
}
 
bool TimeDependentPotential2D::validateRamsey(
    const PotentialScene2D &scene,
    const RamseyPulseSequence2DConfig &config) noexcept
{
    if (!config.enabled) {
        return true;
    }
    if (config.targetObjectId == 0 || !finite(config.meanValue) ||
        !finite(config.amplitude) || !finite(config.angularFrequency) ||
        !(config.angularFrequency > 0.0) ||
        !finite(config.firstPulsePhaseDegrees) ||
        !finite(config.secondPulsePhaseDegrees) ||
        !finite(config.startTime) || config.startTime < 0.0 ||
        !finite(config.pulseDuration) || !(config.pulseDuration > 0.0) ||
        !finite(config.freeEvolutionDuration) || config.freeEvolutionDuration < 0.0 ||
        !finite(config.echoPulseDuration) ||
        (config.echoEnabled && !(config.echoPulseDuration > 0.0)) ||
        !finite(config.echoPulsePhaseDegrees)) {
        return false;
    }
    const PotentialObject2D *object = scene.find(config.targetObjectId);
    if (!object) {
        return false;
    }
    double ignored = 0.0;
    return parameterValue(*object, config.parameter, ignored);
}
 
bool TimeDependentPotential2D::applyParameter(PotentialObject2D &object,
                                              TimePotentialParameter2D parameter,
                                              double value) noexcept
{
    if (!finite(value)) {
        return false;
    }
    const float v = static_cast<float>(value);
    switch (parameter) {
    case TimePotentialParameter2D::ObjectValue:
        object.value = v;
        return true;
    case TimePotentialParameter2D::CenterX:
        object.centerX = v;
        return true;
    case TimePotentialParameter2D::CenterY:
        object.centerY = v;
        return true;
    case TimePotentialParameter2D::HarmonicCurvatureX:
        if (object.type != PotentialObjectType2D::Harmonic) return false;
        object.curvatureX = v;
        return true;
    case TimePotentialParameter2D::HarmonicCurvatureY:
        if (object.type != PotentialObjectType2D::Harmonic) return false;
        object.curvatureY = v;
        return true;
    case TimePotentialParameter2D::HarmonicCurvatureXY:
        if (object.type != PotentialObjectType2D::Harmonic) return false;
        object.curvatureX = v;
        object.curvatureY = v;
        return true;
    case TimePotentialParameter2D::LinearSlopeX:
        if (object.type != PotentialObjectType2D::Linear) return false;
        object.slopeX = v;
        return true;
    case TimePotentialParameter2D::LinearSlopeY:
        if (object.type != PotentialObjectType2D::Linear) return false;
        object.slopeY = v;
        return true;
    }
    return false;
}
 
bool TimeDependentPotential2D::parameterValue(const PotentialObject2D &object,
                                              TimePotentialParameter2D parameter,
                                              double &value) noexcept
{
    switch (parameter) {
    case TimePotentialParameter2D::ObjectValue:
        value = object.value;
        return true;
    case TimePotentialParameter2D::CenterX:
        value = object.centerX;
        return true;
    case TimePotentialParameter2D::CenterY:
        value = object.centerY;
        return true;
    case TimePotentialParameter2D::HarmonicCurvatureX:
        if (object.type != PotentialObjectType2D::Harmonic) return false;
        value = object.curvatureX;
        return true;
    case TimePotentialParameter2D::HarmonicCurvatureY:
        if (object.type != PotentialObjectType2D::Harmonic) return false;
        value = object.curvatureY;
        return true;
    case TimePotentialParameter2D::HarmonicCurvatureXY:
        if (object.type != PotentialObjectType2D::Harmonic) return false;
        if (std::abs(static_cast<double>(object.curvatureX) - static_cast<double>(object.curvatureY)) > 1.0e-6) {
            return false;
        }
        value = object.curvatureX;
        return true;
    case TimePotentialParameter2D::LinearSlopeX:
        if (object.type != PotentialObjectType2D::Linear) return false;
        value = object.slopeX;
        return true;
    case TimePotentialParameter2D::LinearSlopeY:
        if (object.type != PotentialObjectType2D::Linear) return false;
        value = object.slopeY;
        return true;
    }
    return false;
}
 
double TimeDependentPotential2D::periodicValue(
    const PeriodicPotentialDrive2DConfig &config,
    double time) noexcept
{
    if (!finite(time)) {
        return config.meanValue;
    }
    const double phase = config.angularFrequency * time + config.phaseDegrees * Pi / 180.0;
    return config.meanValue + config.amplitude * std::sin(phase);
}
 
double TimeDependentPotential2D::sweepValue(
    const LinearPotentialSweep2DConfig &config,
    double time) noexcept
{
    if (!finite(time) || time <= config.startTime) {
        return config.startValue;
    }
 
    const double outwardEnd = config.startTime + config.duration;
    if (time < outwardEnd) {
        const double u = (time - config.startTime) / config.duration;
        return config.startValue + (config.endValue - config.startValue) * u;
    }
 
    if (!config.returnEnabled) {
        return config.endValue;
    }
 
    const double holdEnd = outwardEnd + config.holdDuration;
    if (time < holdEnd) {
        return config.endValue;
    }
 
    const double returnEnd = holdEnd + config.returnDuration;
    if (time >= returnEnd) {
        return config.startValue;
    }
 
    const double u = (time - holdEnd) / config.returnDuration;
    return config.endValue + (config.startValue - config.endValue) * u;
}
 
double TimeDependentPotential2D::sweepTotalDuration(
    const LinearPotentialSweep2DConfig &config) noexcept
{
    if (!config.returnEnabled) {
        return config.duration;
    }
    return config.duration + config.holdDuration + config.returnDuration;
}
 
double TimeDependentPotential2D::ramseyTotalDuration(
    const RamseyPulseSequence2DConfig &config) noexcept
{
    return 2.0 * config.pulseDuration + config.freeEvolutionDuration +
           (config.echoEnabled ? config.echoPulseDuration : 0.0);
}
 
RamseyPulseSegment2D TimeDependentPotential2D::ramseySegment(
    const RamseyPulseSequence2DConfig &config,
    double time,
    double *localPulseTime) noexcept
{
    if (localPulseTime) *localPulseTime = 0.0;
    if (!finite(time) || time < config.startTime) {
        return RamseyPulseSegment2D::Before;
    }
    const double firstEnd = config.startTime + config.pulseDuration;
    if (time < firstEnd) {
        if (localPulseTime) *localPulseTime = time - config.startTime;
        return RamseyPulseSegment2D::FirstPulse;
    }
 
    if (!config.echoEnabled) {
        const double freeEnd = firstEnd + config.freeEvolutionDuration;
        if (time < freeEnd) return RamseyPulseSegment2D::FreeEvolution;
        const double secondEnd = freeEnd + config.pulseDuration;
        if (time < secondEnd) {
            if (localPulseTime) *localPulseTime = time - freeEnd;
            return RamseyPulseSegment2D::SecondPulse;
        }
        return RamseyPulseSegment2D::Finished;
    }
 
    const double halfFree = 0.5 * config.freeEvolutionDuration;
    const double firstFreeEnd = firstEnd + halfFree;
    if (time < firstFreeEnd) return RamseyPulseSegment2D::EchoFreeFirst;
 
    const double echoEnd = firstFreeEnd + config.echoPulseDuration;
    if (time < echoEnd) {
        if (localPulseTime) *localPulseTime = time - firstFreeEnd;
        return RamseyPulseSegment2D::EchoPulse;
    }
 
    const double secondFreeEnd = echoEnd + halfFree;
    if (time < secondFreeEnd) return RamseyPulseSegment2D::EchoFreeSecond;
 
    const double secondEnd = secondFreeEnd + config.pulseDuration;
    if (time < secondEnd) {
        if (localPulseTime) *localPulseTime = time - secondFreeEnd;
        return RamseyPulseSegment2D::SecondPulse;
    }
    return RamseyPulseSegment2D::Finished;
}
 
double TimeDependentPotential2D::ramseyValue(
    const RamseyPulseSequence2DConfig &config,
    double time) noexcept
{
    double localTime = 0.0;
    const RamseyPulseSegment2D segment = ramseySegment(config, time, &localTime);
    if (segment != RamseyPulseSegment2D::FirstPulse &&
        segment != RamseyPulseSegment2D::EchoPulse &&
        segment != RamseyPulseSegment2D::SecondPulse) {
        return config.meanValue;
    }
 
    double phaseDegrees = config.firstPulsePhaseDegrees;
    if (segment == RamseyPulseSegment2D::EchoPulse) {
        phaseDegrees = config.echoPulsePhaseDegrees;
    } else if (segment == RamseyPulseSegment2D::SecondPulse) {
        phaseDegrees = config.secondPulsePhaseDegrees;
    }
    const double phase = config.angularFrequency * localTime + phaseDegrees * Pi / 180.0;
    return config.meanValue + config.amplitude * std::sin(phase);
}
 
QuantumQuench2DState TimeDependentPotential2D::rasterize(
    const PotentialScene2D &baseScene,
    const QuantumQuench2DConfig &config,
    double time,
    PotentialField2D &target)
{
    QuantumQuench2DState state;
    if (!validate(baseScene, config) || !config.enabled) {
        baseScene.rasterize(target);
        state.valid = !config.enabled;
        state.currentValue = 0.0;
        return state;
    }
 
    PotentialScene2D scene = baseScene;
    PotentialObject2D *object = scene.find(config.targetObjectId);
    if (!object) {
        baseScene.rasterize(target);
        return state;
    }
 
    state.fired = time >= config.quenchTime;
    state.currentValue = state.fired ? config.afterValue : config.beforeValue;
    if (!applyParameter(*object, config.parameter, state.currentValue) || !object->valid()) {
        baseScene.rasterize(target);
        return state;
    }
 
    scene.rasterize(target);
    state.valid = true;
    return state;
}
 
PeriodicPotentialDrive2DState TimeDependentPotential2D::rasterizePeriodic(
    const PotentialScene2D &baseScene,
    const PeriodicPotentialDrive2DConfig &config,
    double time,
    PotentialField2D &target)
{
    PeriodicPotentialDrive2DState state;
    if (!validatePeriodic(baseScene, config) || !config.enabled) {
        baseScene.rasterize(target);
        state.valid = !config.enabled;
        state.currentValue = config.meanValue;
        return state;
    }
 
    PotentialScene2D scene = baseScene;
    PotentialObject2D *object = scene.find(config.targetObjectId);
    if (!object) {
        baseScene.rasterize(target);
        return state;
    }
 
    state.phaseRadians = config.angularFrequency * time + config.phaseDegrees * Pi / 180.0;
    state.currentValue = periodicValue(config, time);
    if (!applyParameter(*object, config.parameter, state.currentValue) || !object->valid()) {
        baseScene.rasterize(target);
        return state;
    }
 
    scene.rasterize(target);
    state.valid = true;
    return state;
}
 
LinearPotentialSweep2DState TimeDependentPotential2D::rasterizeSweep(
    const PotentialScene2D &baseScene,
    const LinearPotentialSweep2DConfig &config,
    double time,
    PotentialField2D &target)
{
    LinearPotentialSweep2DState state;
    if (!validateSweep(baseScene, config) || !config.enabled) {
        baseScene.rasterize(target);
        state.valid = !config.enabled;
        state.currentValue = config.startValue;
        return state;
    }
 
    PotentialScene2D scene = baseScene;
    PotentialObject2D *object = scene.find(config.targetObjectId);
    if (!object) {
        baseScene.rasterize(target);
        return state;
    }
 
    state.currentValue = sweepValue(config, time);
    const double outwardEnd = config.startTime + config.duration;
    const double holdEnd = outwardEnd + (config.returnEnabled ? config.holdDuration : 0.0);
    const double endTime = config.startTime + sweepTotalDuration(config);
    state.finished = time >= endTime;
    state.holding = config.returnEnabled && time >= outwardEnd && time < holdEnd;
    state.returning = config.returnEnabled && time >= holdEnd && time < endTime;
    if (time <= config.startTime) {
        state.progress = 0.0;
    } else if (state.finished) {
        state.progress = 1.0;
    } else {
        state.progress = (time - config.startTime) /
                         std::max(1.0e-12, sweepTotalDuration(config));
    }
 
    if (!applyParameter(*object, config.parameter, state.currentValue) || !object->valid()) {
        baseScene.rasterize(target);
        return state;
    }
 
    scene.rasterize(target);
    state.valid = true;
    return state;
}
 
RamseyPulseSequence2DState TimeDependentPotential2D::rasterizeRamsey(
    const PotentialScene2D &baseScene,
    const RamseyPulseSequence2DConfig &config,
    double time,
    PotentialField2D &target)
{
    RamseyPulseSequence2DState state;
    if (!validateRamsey(baseScene, config) || !config.enabled) {
        baseScene.rasterize(target);
        state.valid = !config.enabled;
        state.currentValue = config.meanValue;
        return state;
    }
 
    PotentialScene2D scene = baseScene;
    PotentialObject2D *object = scene.find(config.targetObjectId);
    if (!object) {
        baseScene.rasterize(target);
        return state;
    }
 
    state.segment = ramseySegment(config, time, &state.localPulseTime);
    state.currentValue = ramseyValue(config, time);
    const double total = ramseyTotalDuration(config);
    if (time <= config.startTime) state.progress = 0.0;
    else if (time >= config.startTime + total) state.progress = 1.0;
    else state.progress = (time - config.startTime) / std::max(1.0e-12, total);
 
    if (!applyParameter(*object, config.parameter, state.currentValue) || !object->valid()) {
        baseScene.rasterize(target);
        return state;
    }
 
    scene.rasterize(target);
    state.valid = true;
    return state;
}
 
} // namespace qpe