qubit.h

#ifndef __CCEX_QUBIT_H_
#define __CCEX_QUBIT_H_
 
#include "utilities.h"

typedef struct {
    
    /* Basic spin information (Essential) */

    char name[MAX_CHARARRAY_LENGTH];

    float spin;

    double gyro; 

    double xyz[3];
 
 
    /* Interaction information (Optional) */ 

    double detuning; 

    double overhaus; 
 
    /* Qubit projected state (Optional) */

    MatrixXcd alpha; 

    MatrixXcd beta;
    
} Qubit;

typedef struct {
 
    /* Use only during reading input file -----------------------------------------*/
 
    // QubitArray
    int* _alphaidx;      
    int* _betaidx;       
    /*-----------------------------------------------------------------------------*/
    /* Use during simulation                                                       */
    /*-----------------------------------------------------------------------------*/
    int nqubit; 
    Qubit** qubit; 
    MatrixXcd** intmap; 
    MatrixXcd psia; 
    MatrixXcd psib; 
    MatrixXcd psi0; 
    bool overhaus;  
    /*-----------------------------------------------------------------------------*/
} QubitArray;
 
/* High Level --------------------------------------------------------*/
 
// physical properties
int         QubitArray_dim(QubitArray* qa);
int         QubitArray_dimQubit_i(QubitArray* qa, int i);
double      QubitArray_mindist(double* xyz, QubitArray* qa);
void        QubitArray_setPsiaPsib_fromQubit(QubitArray* qa); // psia = kron(qubit_i_alpha,qubit_j_alpha, ...)
void        QubitArray_setPsiaPsib_fromIdx(QubitArray* qa, float* bfield); // psia, psib : eigenstate of Hq (idx)
void        QubitArray_setPsi0_fromPsiaPsib(QubitArray* qa); // psi0 = Normalize(psia + psib)
 
// Hamiltonian
MatrixXcd   QubitArray_TotalHamil(QubitArray* qa, MatrixXcd** sigmas, float* bfield);
MatrixXcd   QubitArray_SingleHamil(QubitArray* qa, MatrixXcd** sigmas, int iq, float* bfield);
MatrixXcd   QubitArray_ZeemanHamil(QubitArray* qa, MatrixXcd** sigmas, int iq, float* bfield);
MatrixXcd   QubitArray_DetuningHamil(QubitArray* qa, MatrixXcd** sigmas, int iq);
MatrixXcd   QubitArray_OverhausHamil(QubitArray* qa, MatrixXcd** sigmas, int iq);
MatrixXcd   QubitArray_ZFSHamil(QubitArray* qa, MatrixXcd** sigmas, int iq);
MatrixXcd   QubitArray_InteractionHamil(QubitArray* qa, MatrixXcd** sigmas, int iq, int jq);
MatrixXcd** QubitArray_PauliOperators(QubitArray* qa);
MatrixXcd*  QubitArray_PauliOperator_fromPsiaPsib(QubitArray* qa);
 
// density matrix
MatrixXcd   QubitArray_Rho0(QubitArray* qa);
 
// utils
int         QubitArray_getQubitIdx_fromName(QubitArray* qa, const char* name);
 
/* Low Level --------------------------------------------------------*/
 
QubitArray* QubitArray_init(); 
 
// report
void        QubitArray_report(QubitArray* qa);
void        QubitArray_reportQubit_i(QubitArray* qa, int i);
void        QubitArray_reportIntmap(QubitArray* qa);
void        QubitArray_reportPsiaPsib(QubitArray* qa);
void        QubitArray_reportPsi0(QubitArray* qa);
void        QubitArray_reportQubit_overhaus(QubitArray* qa);
 
// alloc
void        QubitArray_allocQubit(QubitArray* qa);      // length = nqubit
void        QubitArray_allocIntmap(QubitArray* qa);     // length = (nqubit,nqubit)
void        QubitArray_alloc_alphaidx_betaidx(QubitArray* qa); // length = 1
 
// set
void        QubitArray_setNqubit(QubitArray* qa, const int nspin);
void        QubitArray_setOverhaus(QubitArray* qa, const bool overhaus);
void        QubitArray_setQubit(QubitArray* qa, Qubit** qubit);
void        QubitArray_set_alphaidx(QubitArray* qa, const int* alphaidx);
void        QubitArray_set_betaidx(QubitArray* qa, const int* betaidx);
void        QubitArray_setIntmap_i_j(QubitArray* qa, const MatrixXcd tensor, int i, int j);
void        QubitArray_setPsia(QubitArray* qa, const MatrixXcd psia);
void        QubitArray_setPsib(QubitArray* qa, const MatrixXcd psib);
void        QubitArray_setPsi0(QubitArray* qa, const MatrixXcd psi0);
void        QubitArray_setQubit_i_name(QubitArray* qa, const char* name, int i);
void        QubitArray_setQubit_i_spin(QubitArray* qa, const float spin, int i);
void        QubitArray_setQubit_i_gyro(QubitArray* qa, const double gyro, int i);
void        QubitArray_setQubit_i_xyz(QubitArray* qa, const double* xyz, int i);
void        QubitArray_setQubit_i_detuning(QubitArray* qa, const double detuning, int i);
void        QubitArray_setQubit_i_overhaus(QubitArray* qa, const double overhaus, int i);
void        QubitArray_setQubit_i_alpha(QubitArray* qa, const MatrixXcd alpha, int i);
void        QubitArray_setQubit_i_beta(QubitArray* qa, const MatrixXcd beta, int i);
void        QubitArray_setQubit_i_alpha_fromMs(QubitArray* qa, const float ms, int i);
void        QubitArray_setQubit_i_beta_fromMs(QubitArray* qa, const float ms, int i);
 
// get (This is not a copy. Watch out when you change the value with this function!)
int         QubitArray_getNqubit(const QubitArray* qa);
bool        QubitArray_getOverhaus(const QubitArray* qa);
int*        QubitArray_get_alphaidx(const QubitArray* qa);
int*        QubitArray_get_betaidx(const QubitArray* qa);
MatrixXcd** QubitArray_getIntmap(const QubitArray* qa);
MatrixXcd   QubitArray_getIntmap_i_j(const QubitArray* qa, int i, int j);
MatrixXcd   QubitArray_getPsia(const QubitArray* qa);
MatrixXcd   QubitArray_getPsib(const QubitArray* qa);
MatrixXcd   QubitArray_getPsi0(const QubitArray* qa);
char*       QubitArray_getQubit_i_name(const QubitArray* qa, int i);
float       QubitArray_getQubit_i_spin(const QubitArray* qa, int i);
double      QubitArray_getQubit_i_gyro(const QubitArray* qa, int i);
double*     QubitArray_getQubit_i_xyz(const QubitArray* qa, int i);
double      QubitArray_getQubit_i_detuning(const QubitArray* qa, int i);
double      QubitArray_getQubit_i_overhaus(const QubitArray* qa, int i);
MatrixXcd   QubitArray_getQubit_i_alpha(const QubitArray* qa, int i);
MatrixXcd   QubitArray_getQubit_i_beta(const QubitArray* qa, int i);
 
// free
void        QubitArray_freeAll(QubitArray* qa);
void        QubitArray_freeQubit(QubitArray* qa);
void        QubitArray_freeIntmap(QubitArray* qa);
void        QubitArray_free_alphaidx_betaidx(QubitArray* qa);
 
#endif // __CCEX_QUBIT_H_