SimpleHost.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _SIMPLE_HOST_H_
#define _SIMPLE_HOST_H_
 
#include <numeric>
 
#include "Host.h"
#include "Network.h"
 
namespace Network
{

template <typename Time = Types::time_type> class SimpleHost : public IHost<Time>
{
  public:
    SimpleHost(size_t hostId, size_t startQubitId, size_t numQubits, size_t startClassicalBitId, size_t numClassicalBits)
        : id(hostId), startQubitId(startQubitId), numQubits(numQubits), startClassicalBitId(startClassicalBitId), numClassicalBits(numClassicalBits)
    {
    }

    size_t GetId() const override
    {
        return id;
    }

    size_t GetNumQubits() const override
    {
        return numQubits;
    }

    size_t GetNumNetworkEntangledQubits() const override
    {
        if (std::numeric_limits<size_t>::max() == entangledQubitId)
            return 0;
 
        return 1;
    }

    size_t GetNumClassicalBits() const override
    {
        return numClassicalBits;
    }

    bool IsQubitOnHost(size_t qubitId) const override
    {
        return qubitId >= startQubitId && qubitId < startQubitId + numQubits;
    }

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

    bool IsClassicalBitOnHost(size_t cbitId) const override
    {
        return (cbitId >= startClassicalBitId && cbitId < startClassicalBitId + numClassicalBits) || cbitId == entangledQubitMeasurementBit;
    }

    bool IsEntangledQubitOnHost(size_t qubitId) const override
    {
        if (GetNumNetworkEntangledQubits() == 0)
            return false;
 
        return qubitId == entangledQubitId;
    }

    bool AreCbitsOnSameHost(size_t cbitId1, size_t cbitId2) const override
    {
        return IsClassicalBitOnHost(cbitId1) && IsClassicalBitOnHost(cbitId2);
    }

    std::vector<size_t> GetQubitsIds() const override
    {
        std::vector<size_t> res(numQubits);
 
        std::iota(res.begin(), res.end(), startQubitId);
 
        return res;
    }

    std::vector<size_t> GetNetworkEntangledQubitsIds() const override
    {
        if (GetNumNetworkEntangledQubits() == 0)
            return {};
 
        return {entangledQubitId};
    }

    std::vector<size_t> GetClassicalBitsIds() const override
    {
        std::vector<size_t> res(numClassicalBits);
 
        std::iota(res.begin(), res.end(), startClassicalBitId);
 
        return res;
    }

    std::vector<size_t> GetEntangledQubitMeasurementBitIds() const override
    {
        if (std::numeric_limits<size_t>::max() == entangledQubitMeasurementBit)
            return {};
 
        return {entangledQubitMeasurementBit};
    }

    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 startQubitId;
    }

    size_t GetStartClassicalBitId() const override
    {
        return startClassicalBitId;
    }

    void SetEntangledQubitId(size_t id)
    {
        entangledQubitId = id;
    }

    void SetEntangledQubitMeasurementBit(size_t id)
    {
        entangledQubitMeasurementBit = id;
    }
 
  private:
    size_t id; 
 
    size_t startQubitId = 0; 
    size_t numQubits = 0;    
 
    size_t startClassicalBitId = 0; 
    size_t numClassicalBits = 0;    
 
    size_t entangledQubitId = std::numeric_limits<size_t>::max();             
    size_t entangledQubitMeasurementBit = std::numeric_limits<size_t>::max(); 
};
 
} // namespace Network
 
#endif // ! _SIMPLE_HOST_H_