State.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _SIMULATOR_STATE_H_
#define _SIMULATOR_STATE_H_
 
#include <Eigen/Eigen>
#include <complex>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#ifndef NO_QISKIT_AER
#include "framework/linalg/vector.hpp"
#endif
 
#include "SimulatorObserver.h"
 
namespace Simulators {
 
/*
template<class T> class avoid_init_allocator : public std::allocator<T>
{
public:
        using std::allocator<T>::allocator;
 
        template <class U, class... Args> void construct(U*, Args&&...) {}
};
*/
 
enum class SimulatorType : int {
#ifndef NO_QISKIT_AER
  kQiskitAer, 
#endif
  kQCSim, 
#ifndef NO_QISKIT_AER
  kCompositeQiskitAer, 
#endif
  kCompositeQCSim, 
  kGpuSim 
};
 
enum class SimulationType : int {
  kStatevector,        
  kMatrixProductState, 
  kStabilizer,         
  kTensorNetwork,      
  kPauliPropagator,    
  kExtendedStabilizer, 
  kOther 
};
 
class IState {
 public:
  virtual ~IState() = default;
 
  virtual void Initialize() = 0;
 
  virtual void InitializeState(
      size_t num_qubits, std::vector<std::complex<double>> &amplitudes) = 0;
 
#ifndef NO_QISKIT_AER
  virtual void InitializeState(
      size_t num_qubits, AER::Vector<std::complex<double>> &amplitudes) = 0;
#endif
 
  virtual void InitializeState(size_t num_qubits,
                               Eigen::VectorXcd &amplitudes) = 0;
 
  virtual void Reset() = 0;
 
  virtual void Configure(const char *key, const char *value) = 0;
 
  virtual std::string GetConfiguration(const char *key) const = 0;
 
  virtual size_t AllocateQubits(size_t num_qubits) = 0;
 
  virtual size_t GetNumberOfQubits() const = 0;
 
  virtual void Clear() = 0;
 
  virtual size_t Measure(const Types::qubits_vector &qubits) = 0;
 
  virtual void ApplyReset(const Types::qubits_vector &qubits) = 0;
 
  virtual double Probability(Types::qubit_t outcome) = 0;
 
  virtual std::complex<double> Amplitude(Types::qubit_t outcome) = 0;
 
  virtual std::vector<double> AllProbabilities() = 0;
 
  virtual std::vector<double> Probabilities(
      const Types::qubits_vector &qubits) = 0;
 
  virtual std::unordered_map<Types::qubit_t, Types::qubit_t> SampleCounts(
      const Types::qubits_vector &qubits, size_t shots = 1000) = 0;
 
  virtual double ExpectationValue(const std::string &pauliString) = 0;
 
  void RegisterObserver(const std::shared_ptr<ISimulatorObserver> &observer) {
    observers.insert(observer);
  }
 
  void UnregisterObserver(const std::shared_ptr<ISimulatorObserver> &observer) {
    observers.erase(observer);
  }
 
  void ClearObservers() { observers.clear(); }
 
  virtual SimulatorType GetType() const = 0;
 
  virtual SimulationType GetSimulationType() const = 0;
 
  virtual void Flush() = 0;
 
  virtual void SaveStateToInternalDestructive() = 0;
 
  virtual void RestoreInternalDestructiveSavedState() = 0;
 
  virtual void SaveState() = 0;
 
  virtual void RestoreState() = 0;
 
  virtual std::complex<double> AmplitudeRaw(Types::qubit_t outcome) = 0;
 
  virtual void SetMultithreading(bool multithreading = true) = 0;
 
  virtual bool GetMultithreading() const = 0;
 
  virtual bool IsQcsim() const = 0;
 
  virtual Types::qubit_t MeasureNoCollapse() = 0;
 
 protected:
  void DontNotify() { notifyObservers = false; }
 
  void Notify() { notifyObservers = true; }
 
  void NotifyObservers(const Types::qubits_vector &affectedQubits) {
    if (!notifyObservers) return;
 
    for (auto &observer : observers) {
      observer->Update(affectedQubits);
    }
  }
 
 private:
  std::unordered_set<std::shared_ptr<ISimulatorObserver>>
      observers; 
  bool notifyObservers =
      true; 
};
 
}  // namespace Simulators
 
#endif  // !_SIMULATOR_STATE_H_