gate.hpp

Go to the documentation of this file.

#include <stdio.h>
#include <iostream> 
#include <math.h>
#include <assert.h>
#include <petscmat.h>
#include <vector>
#include "defs.hpp"
#include "util.hpp"
#pragma once
 
class Gate {
  protected:
    Mat V_re, V_im; 
 
    std::vector<size_t> nessential; 
    std::vector<size_t> nlevels; 
    int mpirank_petsc; 
    int mpisize_petsc; 
    int mpirank_world; 
 
    bool quietmode; 
 
    PetscInt dim_ess; 
    PetscInt dim_rho; 
 
    double final_time; 
    std::vector<double> gate_rot_freq; 
 
    DecoherenceType decoherence_type; 
 
 
  private:
    Mat VxV_re, VxV_im;     
    Vec x;                  
    IS isu, isv;            
 
  public:
    Gate();
 
    Gate(const std::vector<size_t>& nlevels_, const std::vector<size_t>& nessential_, double time_, const std::vector<double>& gate_rot_freq, DecoherenceType decoherence_type_, bool quietmode=false);
 
    virtual ~Gate();
 
    PetscInt getDimRho() { return dim_rho; };
 
    void assembleGate();
 
    void applyGate(const Vec state, Vec VrhoV);
};
 
class XGate : public Gate {
  public:
    XGate(const std::vector<size_t>& nlevels_, const std::vector<size_t>& nessential_, double time, const std::vector<double>& rotation_frequencies_, DecoherenceType decoherence_type_, bool quietmode=false);
    ~XGate();
};
 
class YGate : public Gate {
  public:
    YGate(const std::vector<size_t>& nlevels_, const std::vector<size_t>& nessential_, double time, const std::vector<double>& rotation_frequencies_, DecoherenceType decoherence_type_, bool quietmode=false);
    ~YGate();
};
 
class ZGate : public Gate {
  public:
    ZGate(const std::vector<size_t>& nlevels_, const std::vector<size_t>& nessential_, double time, const std::vector<double>& rotation_frequencies_, DecoherenceType decoherence_type_, bool quietmode=false);
    ~ZGate();
};
 
class HadamardGate : public Gate {
  public:
    HadamardGate(const std::vector<size_t>& nlevels_, const std::vector<size_t>& nessential_, double time, const std::vector<double>& rotation_frequencies_, DecoherenceType decoherence_type_, bool quietmode=false);
    ~HadamardGate();
};
 
class CNOT : public Gate {
    public:
    CNOT(const std::vector<size_t>& nlevels_, const std::vector<size_t>& nessential_, double time, const std::vector<double>& rotation_frequencies_, DecoherenceType decoherence_type_, bool quietmode=false);
    ~CNOT();
};
 
class SWAP: public Gate {
    public:
    SWAP(const std::vector<size_t>& nlevels_, const std::vector<size_t>& nessential_, double time, const std::vector<double>& rotation_frequencies_, DecoherenceType decoherence_type_, bool quietmode=false);
    ~SWAP();
};
 
 
class SWAP_0Q: public Gate {
    public:
    SWAP_0Q(const std::vector<size_t>& nlevels_, const std::vector<size_t>& nessential_, double time, const std::vector<double>& rotation_frequencies_, DecoherenceType decoherence_type_, bool quietmode=false);
    ~SWAP_0Q();
};
 
class CQNOT: public Gate {
    public:
    CQNOT(const std::vector<size_t>& nlevels_, const std::vector<size_t>& nessential_, double time, const std::vector<double>& rotation_frequencies_, DecoherenceType decoherence_type_, bool quietmode=false);
    ~CQNOT();
};
 
class QFT: public Gate {
  public:
    QFT(const std::vector<size_t>& nlevels_, const std::vector<size_t>& nessential_, double time, const std::vector<double>& rotation_frequencies_, DecoherenceType decoherence_type_, bool quietmode=false);
    ~QFT();
};
 
class FromFile: public Gate {
  public:
    FromFile(const std::vector<size_t>& nlevels_, const std::vector<size_t>& nessential_, double time, const std::vector<double>& rotation_frequencies_, DecoherenceType decoherence_type_, const std::string& filename, bool quietmode=false);
    ~FromFile();
};
 
 
Gate* initTargetGate(GateType target_gate, const std::string& file, const std::vector<size_t>& nlevels, const std::vector<size_t>& nessential, double total_time, DecoherenceType decoherence_type, const std::vector<double>& gate_rot_freq, bool quietmode);