Reset.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _RESET_STATE_H_
#define _RESET_STATE_H_
 
#include "QuantumGates.h"
 
namespace Circuits {

template <typename Time = Types::time_type>
class Reset : public IOperation<Time> {
public:
  Reset(const Types::qubits_vector &qubits = {}, Time delay = 0,
        const std::vector<bool> &resetTargets = {})
      : IOperation<Time>(delay), qubits(qubits), resetTargets(resetTargets) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    size_t res = sim->Measure(qubits);
 
    for (size_t qi = 0; res && qi < qubits.size(); ++qi) {
      if ((res & 1) ==
          (resetTargets.size() <= qi ? 1 : (resetTargets[qi] ? 0 : 1))) {
        xgate.SetQubit(qubits[qi]);
        xgate.Execute(sim, state);
      }
 
      res >>= 1;
    }
  }

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

  void SetQubits(const Types::qubits_vector &qs,
                 const std::vector<bool> &resetTgts = {}) {
    qubits = qs;
    resetTargets = resetTgts;
  }

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

  const std::vector<bool> &GetResetTargets() const { return resetTargets; }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<Reset<Time>>(
        GetQubits(), IOperation<Time>::GetDelay(), GetResetTargets());
  }

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

  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<Reset<Time>>(newOp)->SetQubit(i,
                                                               qubitit->second);
    }
 
    return newOp;
  }

  bool IsClifford() const override { return true; }
 
protected:
  void SetQubit(size_t index, Types::qubit_t qubit) {
    if (index < qubits.size())
      qubits[index] = qubit;
  }
 
private:
  Types::qubits_vector qubits;    
  std::vector<bool> resetTargets; 
  mutable XGate<Time> xgate;      
};
 
} // namespace Circuits
 
#endif // !_RESET_STATE_H_