class QPanda::NoiseSimulator

#include <NoiseSimulator.h>

class NoiseSimulator: public QPanda::TraversalInterface
{
public:
    // methods

    bool has_quantum_error();
    void set_rotation_error(double);

    void set_measure_error(
        NOISE_MODEL model,
        double param
        );

    void set_measure_error(
        NOISE_MODEL model,
        double param,
        const Qnum& qubits_vec
        );

    void set_measure_error(
        NOISE_MODEL model,
        double T1,
        double T2,
        double time_param
        );

    void set_measure_error(
        NOISE_MODEL model,
        double T1,
        double T2,
        double time_param,
        const Qnum& qubits_vec
        );

    void set_reset_error(
        double,
        double
        );

    void set_readout_error(
        const std::vector<std::vector<double>>& readout_params,
        const Qnum& qubits
        );

    void set_combining_error(
        GateType gate_type,
        const KarusError& karus_error,
        const std::vector<Qnum>& qubits_vecs
        );

    void set_mixed_unitary_error(
        GateType gate_type,
        const std::vector<QStat>& karus_matrices
        );

    void set_mixed_unitary_error(
        GateType gate_type,
        const std::vector<QStat>& unitary_matrices,
        const std::vector<double>& probs_vec
        );

    void set_mixed_unitary_error(
        GateType gate_type,
        const std::vector<QStat>& karus_matrices,
        const std::vector<Qnum>& qubits_vecs
        );

    void set_mixed_unitary_error(
        GateType gate_type,
        const std::vector<QStat>& unitary_matrices,
        const std::vector<double>& probs_vec,
        const std::vector<Qnum>& qubits_vecs
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double param
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double param,
        const Qnum& qubits_vec
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double param,
        const std::vector<Qnum>& qubits_vecs
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double T1,
        double T2,
        double time_param
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double T1,
        double T2,
        double time_param,
        const Qnum& qubits_vecs
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double T1,
        double T2,
        double time_param,
        const std::vector<Qnum>& qubits_vecs
        );

    void set_mps_qpu_and_result(
        std::shared_ptr<MPSImplQPU> mps_qpu,
        QResult* result
        );

    void execute(
        std::shared_ptr<AbstractQGateNode>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractClassicalProg>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractQuantumMeasure>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractQuantumReset>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractQuantumCircuit>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractQuantumProgram>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractControlFlowNode>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );