Controller.h

Go to the documentation of this file.

/*******************************************************
 
Copyright (C) 2023 2639731 ONTARIO INC. <joe.diadamo.dryrock@gmail.com>
 
The files in this repository make up the Codebase.
 
All files in this Codebase are owned by 2639731 ONTARIO INC..
 
Any files within this Codebase can not be copied and/or distributed without the
express permission of 2639731 ONTARIO INC.
 
*******************************************************/
 
#pragma once
 
#ifndef _CONTROLLER_INTERFACE_H_
#define _CONTROLLER_INTERFACE_H_
 
#include "../Circuit/Circuit.h"
#include "../Simulators/Simulator.h"
#include "Host.h"
 
namespace Distribution {
template <typename Time>
class IRemapper;
}
 
namespace Graphs {
template <typename Time>
class IOptimiser;
 
enum class OptimiserType;
}  // namespace Graphs
 
namespace Schedulers {
template <typename Time>
class IScheduler;
 
template <typename Time = Types::time_type>
struct ExecuteCircuit {
  ExecuteCircuit() = default;
 
  ExecuteCircuit(const std::shared_ptr<Circuits::Circuit<Time>> &circuit,
                 size_t shots)
      : circuit(circuit), shots(shots) {}
 
  virtual ~ExecuteCircuit() = default;
 
  bool operator==(const ExecuteCircuit<Time> &other) const {
    return circuit == other.circuit && shots == other.shots;
  }
 
  std::shared_ptr<Circuits::Circuit<Time>> circuit;
  size_t shots = 1000;
};
}  // namespace Schedulers
 
namespace Network {
 
enum class SchedulerType : int {
  kNoEntanglementQubits = 0,
  kNoEntanglementQubitsParallel
};
 
template <typename Time>
class INetwork;
 
template <typename Time = Types::time_type>
class IController : public IHost<Time> {
 public:
  virtual std::shared_ptr<Circuits::Circuit<Time>> DistributeCircuit(
      const std::shared_ptr<INetwork<Time>> &network,
      const std::shared_ptr<Circuits::Circuit<Time>> &circuit) = 0;
 
  virtual std::shared_ptr<Circuits::Circuit<Time>> SplitCompositeOperations(
      const std::shared_ptr<INetwork<Time>> &network,
      const std::shared_ptr<Circuits::Circuit<Time>> &circuit) = 0;
 
  virtual void SetRemapper(
      const std::shared_ptr<Distribution::IRemapper<Time>> &remapper) = 0;
 
  virtual std::shared_ptr<Distribution::IRemapper<Time>> GetRemapper()
      const = 0;
 
  virtual std::shared_ptr<Circuits::Circuit<Time>>
  DoNetworkSpecificConversionsForDistribution(
      const std::shared_ptr<INetwork<Time>> &network,
      const std::shared_ptr<Circuits::Circuit<Time>> &circuit) = 0;
 
  virtual std::shared_ptr<Graphs::IOptimiser<Time>> GetOptimiser() const = 0;
 
  virtual void CreateOptimiser(Graphs::OptimiserType type) = 0;
 
  virtual void CreateScheduler(
      const std::shared_ptr<INetwork<Time>> &network,
      SchedulerType schType = SchedulerType::kNoEntanglementQubitsParallel) = 0;
 
  virtual std::shared_ptr<Schedulers::IScheduler<Time>> GetScheduler()
      const = 0;
 
  virtual void SetOptimizeCircuit(bool optimize = true) = 0;
 
  virtual bool GetOptimizeCircuit() const = 0;
 
  virtual bool GetOptimizeRotationGates() const = 0;
 
  virtual void SetOptimizeRotationGates(bool val = true) = 0;
};
 
}  // namespace Network
 
#endif  // !_CONTROLLER_INTERFACE_H_