SimpleController.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _SIMPLE_CONTROLLER_H_
#define _SIMPLE_CONTROLLER_H_
 
#include "../Distribution/Remapper.h"
#include "../Scheduler/Scheduler.h"
#include "../graph/Optimiser.h"
#include "Controller.h"
 
namespace Network {

template <typename Time = Types::time_type>
class SimpleController : public IController<Time> {
public:
  std::shared_ptr<Circuits::Circuit<Time>> DistributeCircuit(
      const std::shared_ptr<INetwork<Time>> &network,
      const std::shared_ptr<Circuits::Circuit<Time>> &circuit) override {
    if (!remapper)
      return nullptr; // maybe throw an exception?
 
    // don't destroy the passed one, make a copy
    std::shared_ptr<Circuits::Circuit<Time>> distCirc =
        std::static_pointer_cast<Circuits::Circuit<Time>>(circuit->Clone());
 
    // this is a different optimization than below, that one is for qubits
    // layout in the network this one simpifies the circuit by merging gates
    // could be done after the distribution, perhaps, I'll think about it...
    // might change some things that would break up the netqasm conversion, so
    // for now it's here
 
    // also if it merges three cnots into a swap, for example, it shouldn't be
    // done after 'ConvertForDistribution' because the swap is converted to 3
    // cnots
    if (optimize)
      distCirc->Optimize(optimizeRotationGates);
 
    // this converts the 3 qubit gates and swap to 2-qubit gates (the swap to 3
    // cnots)
    distCirc->ConvertForDistribution();
 
    // virtual, by default does nothing, but in derived classes it can do
    // something for example, for netqasm it arranges the measurements in the
    // proper order for conversion
    distCirc =
        this->DoNetworkSpecificConversionsForDistribution(network, distCirc);
 
    if (optimiser) {
      // optimise the circuit
      optimiser->SetNetworkAndCircuit(network, distCirc);
      optimiser->Optimise();
      const auto &qubitsMap = optimiser->GetQubitsMap();
      distCirc = std::dynamic_pointer_cast<Circuits::Circuit<Time>>(
          distCirc->Remap(qubitsMap, qubitsMap));
    }
 
    // now distribute
 
    // the first thing to do is to adjust the qubits indexes in the circuit
    // according to the network topology walk over the network hosts and add one
    // qubit per host for the entangled one (as it's the case for the 'simple
    // network') and one cbit per host for measuring the entangled qubit for now
    // they will be added at the end of the registers, to be easier to convert
    // the circuit for distribution
 
    return remapper->Remap(network, distCirc);
  }

  std::shared_ptr<Circuits::Circuit<Time>> SplitCompositeOperations(
      const std::shared_ptr<INetwork<Time>> &network,
      const std::shared_ptr<Circuits::Circuit<Time>> &circuit) override {
    if (!remapper)
      return nullptr; // maybe throw an exception?
 
    return remapper->SplitCompositeOperations(network, circuit);
  }

  size_t GetId() const override { return std::numeric_limits<size_t>::max(); }

  size_t GetNumQubits() const override { return 0; }

  size_t GetNumNetworkEntangledQubits() const override { return 0; }

  size_t GetNumClassicalBits() const override { return 0; }

  bool IsQubitOnHost(size_t qubitId) const override { return false; }

  bool IsClassicalBitOnHost(size_t qubitId) const override { return false; }

  bool IsEntangledQubitOnHost(size_t qubitId) const override { return false; }

  bool AreQubitsOnSameHost(size_t qubitId1, size_t qubitId2) const override {
    return false;
  }

  bool AreCbitsOnSameHost(size_t qubitId1, size_t qubitId2) const override {
    return false;
  }

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

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

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

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

  void SetRemapper(
      const std::shared_ptr<Distribution::IRemapper<Time>> &r) override {
    remapper = r;
  }

  std::shared_ptr<Distribution::IRemapper<Time>> GetRemapper() const override {
    return remapper;
  }

  bool SendPacketToHost(size_t hostId,
                        const std::vector<uint8_t> &packet) override {
    return false;
  }

  bool RecvPacketFromHost(size_t hostId,
                          const std::vector<uint8_t> &packet) override {
    return false;
  }

  size_t GetStartQubitId() const override { return 0; }

  size_t GetStartClassicalBitId() const override { return 0; }

  std::shared_ptr<Graphs::IOptimiser<Time>> GetOptimiser() const override {
    return optimiser;
  }

  void CreateOptimiser(Graphs::OptimiserType type) override {
    throw std::runtime_error("SimpleController::CreateOptimiser: not "
                             "implemented for this type of network controller");
  }

  std::shared_ptr<Circuits::Circuit<Time>>
  DoNetworkSpecificConversionsForDistribution(
      const std::shared_ptr<INetwork<Time>> &network,
      const std::shared_ptr<Circuits::Circuit<Time>> &circuit) override {
    return circuit;
  }

  void
  CreateScheduler(const std::shared_ptr<INetwork<Time>> &network,
                  SchedulerType schType =
                      SchedulerType::kNoEntanglementQubitsParallel) override {
    throw std::runtime_error("SimpleController::CreateScheduler: not "
                             "implemented for this type of network controller");
  }

  std::shared_ptr<Schedulers::IScheduler<Time>> GetScheduler() const override {
    return scheduler;
  }
 
  bool GetOptimizeRotationGates() const override {
    return optimizeRotationGates;
  }
 
  void SetOptimizeRotationGates(bool val = true) override {
    optimizeRotationGates = val;
  }

  void SetOptimizeCircuit(bool o = true) override { optimize = o; }

  bool GetOptimizeCircuit() const override { return optimize; }
 
protected:
  std::shared_ptr<Distribution::IRemapper<Time>>
      remapper; 
 
  // the problem with setting a default optimiser here is that everywhere where
  // amplitudes are checked in tests for some network distributions, the tests
  // will fail
  // because the qubits are scrambled by the optimiser, they are rearranged so
  // the number of distributions is reduced so better set it explicitly only
  // when tests for results are checked!
  std::shared_ptr<Graphs::IOptimiser<Time>>
      optimiser; // =
                 // Graphs::Factory<Time>::Create(Graphs::OptimiserType::kMonteCarlo);
                 // /**< The optimiser used to optimise the circuit. */
 
  std::shared_ptr<Schedulers::IScheduler<Time>>
      scheduler; 
 
private:
  bool optimize = true;
  bool optimizeRotationGates =
      true; 
};
} // namespace Network
 
#endif // !_SIMPLE_CONTROLLER_H_