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/Interfaces/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_