Measurements.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _MEASUREMENTS_H_
#define _MEASUREMENTS_H_
 
#include "Operations.h"
#include <vector>
 
namespace Circuits {
 
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);
  }
 
  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);
  }
 
  void SetStateFromSample(const std::vector<bool> &measurements,
                          OperationState &state) const {
    if (qubits.empty()) return;
 
    for (size_t index = 0; index < qubits.size(); ++index)
      state.SetBit(bits[index],
                   index < measurements.size() && measurements[index]);
  }
 
  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]);
 
    return std::make_shared<MeasurementOperation<Time>>(
        qs, IOperation<Time>::GetDelay());
  }
 
  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;
  }
 
 private:
  Types::qubits_vector qubits; 
  std::vector<size_t>
      bits; 
};
 
}  // namespace Circuits
 
#endif  // !_MEASUREMENTS_H_