class QPanda::QCloudMachine

Overview

#include <QCloudMachine.h>

class QCloudMachine: public QPanda::QVM
{
public:
    // methods

    void init(std::string token);
    void set_compute_api(std::string url);
    void set_inqure_api(std::string url);

    void set_noise_model(
        NOISE_MODEL model,
        const std::vector<double> single_params,
        const std::vector<double> double_params
        );

    std::map<std::string, double> noise_measure(
        QProg&,
        int shot,
        std::string task_name = "Qurator Experiment"
        );

    std::map<std::string, double> full_amplitude_measure(
        QProg&,
        int shot,
        std::string task_name = "Qurator Experiment"
        );

    std::map<std::string, double> full_amplitude_pmeasure(
        QProg& prog,
        Qnum qubit_vec,
        std::string task_name = "Qurator Experiment"
        );

    std::map<std::string, qcomplex_t> partial_amplitude_pmeasure(
        QProg& prog,
        std::vector<std::string> amplitude_vec,
        std::string task_name = "Qurator Experiment"
        );

    qcomplex_t single_amplitude_pmeasure(QProg& prog, std::string amplitude, std::string task_name = "Qurator Experiment");

    std::map<std::string, double> real_chip_measure(
        QProg&,
        int shot,
        size_t chipid = 0,
        std::string task_name = "Qurator Experiment"
        );

    std::map<std::string, double> real_chip_task(
        QProg&,
        int shot,
        bool mapping_flag,
        bool circuit_optimization,
        bool is_vip,
        size_t chipid = 0
        );

    std::vector<QStat> get_state_tomography_density(QProg&, int shot, size_t chipid = 0);
    std::string get_result_json(std::string taskid, CLOUD_QMACHINE_TYPE type);
};

Inherited Members

public:
    // methods

    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t) = 0;
    virtual void init() = 0;
    virtual QMachineStatus* getStatus() const = 0;
    virtual std::map<std::string, bool> directlyRun(QProg& qProg) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int) = 0;
    virtual std::map<GateType, size_t> getGateTimeMap() const = 0;
    virtual void finalize() = 0;
    virtual QStat getQState() const = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*) = 0;
    virtual void setConfig(const Configuration&) = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual QVec allocateQubits(size_t) = 0;
    virtual ClassicalCondition allocateCBit() = 0;
    virtual ClassicalCondition allocateCBit(size_t) = 0;
    virtual std::vector<ClassicalCondition> allocateCBits(size_t) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void Free_Qubits(QVec&) = 0;
    virtual void Free_CBit(ClassicalCondition&) = 0;
    virtual void Free_CBits(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubit() = 0;
    virtual size_t getAllocateCMem() = 0;
    virtual void setConfigure(const Configuration&) = 0;
    virtual Qubit* qAlloc() = 0;
    virtual QVec qAllocMany(size_t qubit_count) = 0;
    virtual ClassicalCondition cAlloc() = 0;
    virtual ClassicalCondition cAlloc(size_t) = 0;
    virtual std::vector<ClassicalCondition> cAllocMany(size_t) = 0;
    virtual void qFree(Qubit*) = 0;
    virtual void qFreeAll(QVec&) = 0;
    virtual void cFree(ClassicalCondition&) = 0;
    virtual void cFreeAll(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubitNum() = 0;
    virtual size_t getAllocateCMemNum() = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {}) = 0;
    virtual size_t get_allocate_qubits(QVec&) = 0;
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int) = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {});
    virtual Qubit* allocateQubitThroughPhyAddress(size_t);
    virtual Qubit* allocateQubitThroughVirAddress(size_t);
    virtual QMachineStatus* getStatus() const;
    virtual QResult* getResult();
    virtual std::map<std::string, bool> getResultMap();
    virtual void finalize();
    virtual std::map<std::string, bool> directlyRun(QProg& qProg);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<int>&, int);
    virtual std::map<GateType, size_t> getGateTimeMap() const;
    virtual QStat getQState() const;
    virtual size_t getVirtualQubitAddress(Qubit*) const;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*);
    virtual void set_random_engine(RandomEngine* rng);
    virtual void setConfig(const Configuration& config);
    virtual Qubit* allocateQubit();
    virtual QVec allocateQubits(size_t);
    virtual ClassicalCondition allocateCBit();
    virtual std::vector<ClassicalCondition> allocateCBits(size_t);
    virtual ClassicalCondition allocateCBit(size_t);
    virtual size_t getAllocateQubit();
    virtual size_t getAllocateCMem();
    virtual void Free_Qubit(Qubit*);
    virtual void Free_Qubits(QVec&);
    virtual void Free_CBit(ClassicalCondition&);
    virtual void Free_CBits(std::vector<ClassicalCondition>&);
    virtual void setConfigure(const Configuration&);
    virtual Qubit* qAlloc();
    virtual QVec qAllocMany(size_t qubit_count);
    virtual ClassicalCondition cAlloc();
    virtual ClassicalCondition cAlloc(size_t);
    virtual std::vector<ClassicalCondition> cAllocMany(size_t);
    virtual void qFree(Qubit*);
    virtual void qFreeAll(QVec&);
    virtual void cFree(ClassicalCondition&);
    virtual void cFreeAll(std::vector<ClassicalCondition>&);
    virtual size_t getAllocateQubitNum();
    virtual size_t getAllocateCMemNum();
    virtual size_t get_allocate_qubits(QVec&);
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int);

Detailed Documentation

Methods

void init(std::string token)

Init the quantum machine environment.

use this at the begin

Returns:

void

std::map<std::string, double> noise_measure(
    QProg&,
    int shot,
    std::string task_name = "Qurator Experiment"
    )

run a measure quantum program

Parameters:

QProg&	the reference to a quantum program
int&	shot
std::map<std::string
double>

Returns:

measure result

std::map<std::string, double> full_amplitude_measure(
    QProg&,
    int shot,
    std::string task_name = "Qurator Experiment"
    )

run a measure quantum program

Parameters:

QProg&	the reference to a quantum program
int&	shot
std::map<std::string
double>

Returns:

measure result

std::map<std::string, double> full_amplitude_pmeasure(
    QProg& prog,
    Qnum qubit_vec,
    std::string task_name = "Qurator Experiment"
    )

run a pmeasure quantum program

Parameters:

QProg&	the reference to a quantum program
Qnum	& qubit address vector
std::map<std::string
double>

Returns:

pmeasure result

std::map<std::string, qcomplex_t> partial_amplitude_pmeasure(
    QProg& prog,
    std::vector<std::string> amplitude_vec,
    std::string task_name = "Qurator Experiment"
    )

run a pmeasure quantum program with partial amplitude backend

Parameters:

QProg&	the reference to a quantum program
std::vector<std::string>	& amplitude subset
std::map<std::string
qcomplex_t>

Returns:

pmeasure result

qcomplex_t single_amplitude_pmeasure(
    QProg& prog,
    std::string amplitude,
    std::string task_name = "Qurator Experiment"
    )

run a pmeasure quantum program with single amplitude backend

Parameters:

QProg&	the reference to a quantum program
std::string	amplitude
qcomplex_t

Returns:

pmeasure result

std::map<std::string, double> real_chip_measure(
    QProg&,
    int shot,
    size_t chipid = 0,
    std::string task_name = "Qurator Experiment"
    )

run a measure quantum program

Parameters:

QProg&	the reference to a quantum program
int&	shot
std::map<std::string
double>

Returns:

measure result

std::map<std::string, double> real_chip_task(
    QProg&,
    int shot,
    bool mapping_flag,
    bool circuit_optimization,
    bool is_vip,
    size_t chipid = 0
    )

run a measure quantum program

Parameters:

QProg&	the reference to a quantum program
int&	shot
std::map<std::string
double>

Returns:

measure result

std::vector<QStat> get_state_tomography_density(QProg&, int shot, size_t chipid = 0)

get real chip qst matrix

Parameters:

QProg&	the reference to a quantum program
int&	shot
QStat	matrix

Returns:

matrix

std::string get_result_json(std::string taskid, CLOUD_QMACHINE_TYPE type)

get task result

Parameters:

std::string	taskid
CLOUD_QMACHINE_TYPE	type
std::string&	empty taskid

Returns:

string