observablestimeseries2d.h

Go to the documentation of this file.

/**
 * @file observablestimeseries2d.h
 * @brief Declares the observablestimeseries2d physics/numerical component used by QPE experiments.
 * @ingroup qpe_quantum
 *
 * Source: @c core/quantum/observablestimeseries2d.h. 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.
 */
 
#pragma once
 
#include <cstddef>
#include <vector>
 
namespace qpe {
 
/**
 * @brief Data record containing Observables Time Series2D Sample.
 *
 * The structure carries computed data without coupling the numerical component to the GUI or renderer.
 */
struct ObservablesTimeSeries2DSample
{
    double time = 0.0;
    double meanX = 0.0;
    double meanY = 0.0;
    double sigmaX = 0.0;
    double sigmaY = 0.0;
    double norm = 0.0;
    double absorbedProbability = 0.0;
    double reflectionProbability = 0.0;
    double transmissionProbability = 0.0;
    double kineticEnergy = 0.0;
    double potentialEnergy = 0.0;
    double totalEnergy = 0.0;
    double energyDriftPercent = 0.0;
    bool hasScattering = false;
 
    // Step 20: coherent tunnelling in a symmetric double well.
    double leftWellProbability = 0.0;
    double rightWellProbability = 0.0;
    double centralBarrierProbability = 0.0;
    bool hasDoubleWell = false;
 
    // Step 23: projection of the live 2D wavefunction onto the two lowest
    // stationary states of the undriven double well.
    double twoLevelPopulationA = 0.0;
    double twoLevelPopulationB = 0.0;
    double twoLevelCapturedPopulation = 0.0;
    bool hasDrivenTwoLevel = false;
 
    // Step 24: Landau-Zener projections in the zero-bias two-state basis and
    // its instantaneous adiabatic rotation.
    double landauZenerLeftPopulation = 0.0;
    double landauZenerRightPopulation = 0.0;
    double landauZenerLowerPopulation = 0.0;
    double landauZenerUpperPopulation = 0.0;
    double landauZenerCapturedPopulation = 0.0;
    bool hasLandauZener = false;
 
    // Step 25: double-passage Landau-Zener-Stueckelberg interferometry.
    double stueckelbergLeftPopulation = 0.0;
    double stueckelbergRightPopulation = 0.0;
    double stueckelbergLowerPopulation = 0.0;
    double stueckelbergUpperPopulation = 0.0;
    double stueckelbergCapturedPopulation = 0.0;
    bool hasStueckelberg = false;
 
    // Step 26: Ramsey pulse-sequence populations in the stationary two-level
    // basis. These are projections of the live 2D field, not a separate state.
    double ramseyPopulationA = 0.0;
    double ramseyPopulationB = 0.0;
    double ramseyCapturedPopulation = 0.0;
    bool hasRamsey = false;
};
 
// Small bounded history used by the Analysis dock. It deliberately stores
// already-computed observables rather than wavefunction snapshots, so memory
// use stays tiny even for long runs and large 2D grids.
/**
 * @brief Implements the Observables Time Series2D component.
 *
 * The class provides one focused service within the QPE architecture and is documented here independently of the experiment-level Help.
 */
class ObservablesTimeSeries2D
{
public:
    /**
     * @brief Constructs a Observables Time Series 2D instance.
     * @param maximumSamples The maximum samples value used by the operation.
     */
    explicit ObservablesTimeSeries2D(std::size_t maximumSamples = 4096u);
 
    /**
     * @brief Clears stored state and returns the component to its empty/default state.
     */
    void clear() noexcept;
    /**
     * @brief Sets maximum samples.
     * @param maximumSamples The maximum samples value used by the operation.
     */
    void setMaximumSamples(std::size_t maximumSamples);
    /**
     * @brief Carries out maximum samples.
     */
    std::size_t maximumSamples() const noexcept { return maximumSamples_; }
 
    /**
     * @brief Carries out append.
     * @param sample The sample value used by the operation.
     */
    void append(const ObservablesTimeSeries2DSample &sample);
 
    /**
     * @brief Samples s.
     */
    const std::vector<ObservablesTimeSeries2DSample> &samples() const noexcept
    {
        return samples_;
    }
 
    /**
     * @brief Returns whether the object contains no data.
     * @param empty The empty value used by the operation.
     */
    bool empty() const noexcept { return samples_.empty(); }
    /**
     * @brief Returns size.
     * @param size The size value used by the operation.
     */
    std::size_t size() const noexcept { return samples_.size(); }
 
private:
    /**
     * @brief Carries out trim to limit.
     */
    void trimToLimit();
 
    std::size_t maximumSamples_ = 4096u;
    std::vector<ObservablesTimeSeries2DSample> samples_;
};
 
} // namespace qpe