Measurements.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _MEASUREMENTS_H_
#define _MEASUREMENTS_H_
 
#include "Operations.h"
#include <utility>
#include <vector>
 
namespace Circuits
{

struct ReadoutRates
{
    double p_meas1_prep0 = 0.0; 
    double p_meas0_prep1 = 0.0; 
};

template <typename Time = Types::time_type> class MeasurementOperation : public IOperation<Time>
{
  public:
    MeasurementOperation(const std::vector<std::pair<Types::qubit_t, size_t>> &qs = {}, Time delay = 0) : IOperation<Time>(delay)
    {
        SetQubits(qs);
    }

    OperationType GetType() const override
    {
        return OperationType::kMeasurement;
    }

    virtual size_t GetNumQubits() const
    {
        return qubits.size();
    }

    void Clear()
    {
        qubits.clear();
        bits.clear();
    }

    void SetQubits(const std::vector<std::pair<Types::qubit_t, size_t>> &qs)
    {
        qubits.resize(qs.size());
        bits.resize(qs.size());
        for (size_t i = 0; i < qs.size(); ++i)
        {
            qubits[i] = qs[i].first;
            bits[i] = qs[i].second;
        }
    }

    const Types::qubits_vector &GetQubits() const
    {
        return qubits;
    }

    const std::vector<size_t> &GetBitsIndices() const
    {
        return bits;
    }

    void Execute(const std::shared_ptr<Simulators::ISimulator> &sim, OperationState &state) const override
    {
        if (qubits.empty())
            return;
 
        auto res = sim->MeasureMany(qubits);
 
        SetStateFromSample(res, state, sim.get());
    }

    void Sample(const std::shared_ptr<Simulators::ISimulator> &sim, OperationState &state) const
    {
        if (qubits.empty())
            return;
 
        const auto res = sim->SampleCountsMany(qubits, 1).begin()->first;
 
        SetStateFromSample(res, state, sim.get());
    }

    void SetStateFromSample(const std::vector<bool> &measurements, OperationState &state, Simulators::ISimulator *rng = nullptr) const
    {
        if (qubits.empty())
            return;
 
        for (size_t index = 0; index < qubits.size(); ++index)
        {
            bool value = index < measurements.size() && measurements[index];
 
            if (rng && index < readout.size())
            {
                const auto &rates = readout[index];
                if (!value && rates.p_meas1_prep0 > 0.0 && rng->RandomUniform() < rates.p_meas1_prep0)
                    value = true;
                else if (value && rates.p_meas0_prep1 > 0.0 && rng->RandomUniform() < rates.p_meas0_prep1)
                    value = false;
            }
 
            state.SetBit(bits[index], value);
        }
    }

    std::shared_ptr<IOperation<Time>> Clone() const override
    {
        std::vector<std::pair<Types::qubit_t, size_t>> qs(qubits.size());
        for (size_t i = 0; i < qubits.size(); ++i)
            qs[i] = std::make_pair(qubits[i], bits[i]);
 
        auto copy = std::make_shared<MeasurementOperation<Time>>(qs, IOperation<Time>::GetDelay());
        copy->readout = readout;
 
        return copy;
    }

    Types::qubits_vector AffectedQubits() const override
    {
        return qubits;
    }

    std::vector<size_t> AffectedBits() const override
    {
        return GetBitsIndices();
    }

    std::shared_ptr<IOperation<Time>> Remap(const std::unordered_map<Types::qubit_t, Types::qubit_t> &qubitsMap,
                                            const std::unordered_map<Types::qubit_t, Types::qubit_t> &bitsMap = {}) const override
    {
        auto newOp = this->Clone();
 
        for (size_t i = 0; i < qubits.size(); ++i)
        {
            const auto qubitit = qubitsMap.find(qubits[i]);
            if (qubitit != qubitsMap.end())
                std::static_pointer_cast<MeasurementOperation<Time>>(newOp)->SetQubit(i, qubitit->second);
            // else throw std::runtime_error("MeasurementOperation::Remap: qubit not
            // found in map.");
        }
 
        for (size_t i = 0; i < bits.size(); ++i)
        {
            const auto bitit = bitsMap.find(bits[i]);
            if (bitit != bitsMap.end())
                std::static_pointer_cast<MeasurementOperation<Time>>(newOp)->SetBit(i, bitit->second);
            // else throw std::runtime_error("MeasurementOperation::Remap: bit not
            // found in map.");
        }
 
        return newOp;
    }

    bool IsClifford() const override
    {
        return true;
    }

    void SetQubit(size_t index, Types::qubit_t qubit)
    {
        if (index < qubits.size())
            qubits[index] = qubit;
    }

    void SetBit(size_t index, Types::qubit_t bit)
    {
        if (index < bits.size())
            bits[index] = bit;
    }

    void SetReadout(std::vector<ReadoutRates> rates)
    {
        rates.resize(rates.empty() ? 0 : qubits.size());
        readout = std::move(rates);
    }

    void SetReadoutAt(size_t index, const ReadoutRates &rates)
    {
        if (index >= qubits.size())
            return;
        if (readout.size() != qubits.size())
            readout.resize(qubits.size());
        readout[index] = rates;
    }

    const std::vector<ReadoutRates> &GetReadout() const
    {
        return readout;
    }

    bool HasReadout() const
    {
        return !readout.empty();
    }
 
  private:
    Types::qubits_vector qubits;       
    std::vector<size_t> bits;          
    std::vector<ReadoutRates> readout; 
};
 
} // namespace Circuits
 
#endif // !_MEASUREMENTS_H_