void
qpb_sun_project(qpb_link *u, int n)
{
gsl_eigen_hermv_workspace *gsl_work = gsl_eigen_hermv_alloc(NC);
gsl_matrix_complex *B = gsl_matrix_complex_alloc(NC, NC);
gsl_matrix_complex *A = gsl_matrix_complex_alloc(NC, NC);
gsl_matrix_complex *V = gsl_matrix_complex_alloc(NC, NC);
gsl_matrix_complex *U = gsl_matrix_complex_alloc(NC, NC);
gsl_matrix_complex *D = gsl_matrix_complex_alloc(NC, NC);
gsl_vector *S = gsl_vector_alloc(NC);
gsl_permutation *perm = gsl_permutation_alloc(NC);
for(int k=0; k<n; k++){
qpb_complex *a = (qpb_complex *)(u + k);
for(int i=0; i<NC; i++)
for(int j=0; j<NC; j++)
gsl_matrix_complex_set(A, i, j, gsl_complex_rect(a[j + i*NC].re, a[j + i*NC].im));
gsl_matrix_complex_memcpy(U, A);
int sgn;
gsl_linalg_complex_LU_decomp(U, perm, &sgn);
gsl_complex det_A = gsl_linalg_complex_LU_det(U, sgn);
qpb_double phi = gsl_complex_arg(det_A);
gsl_complex one = gsl_complex_rect(1., 0.);
gsl_complex zero = gsl_complex_rect(0., 0.);
gsl_matrix_complex_memcpy(U, A);
svd(U, V, S);
get_theta_matrix(D, S, phi);
gsl_blas_zgemm(CblasNoTrans, CblasNoTrans, one, U, D, zero, B);
gsl_blas_zgemm(CblasNoTrans, CblasConjTrans, one, B, V, zero, A);
for(int i=0; i<NC; i++)
for(int j=0; j<NC; j++){
a[j + i*NC].re = GSL_REAL(gsl_matrix_complex_get(A, i, j));
a[j + i*NC].im = GSL_IMAG(gsl_matrix_complex_get(A, i, j));
}
}
gsl_matrix_complex_free(A);
gsl_matrix_complex_free(B);
gsl_matrix_complex_free(V);
gsl_matrix_complex_free(U);
gsl_matrix_complex_free(D);
gsl_permutation_free(perm);
gsl_vector_free(S);
gsl_eigen_hermv_free(gsl_work);
return;
}
/*
* Calculate the matrix exponent of A and store in eA.
* Algorithm: Truncated Talyor series.
*
* WARNING: Large errors possible and it's slow.
*/
int
gsl_ext_expm_complex(gsl_matrix_complex *A, gsl_matrix_complex *eA)
{
int i;
gsl_complex alpha, beta, z;
gsl_matrix_complex *I, *T;
I = gsl_matrix_complex_alloc(A->size1, A->size2);
T = gsl_matrix_complex_alloc(A->size1, A->size2);
GSL_SET_COMPLEX(&alpha, 1.0, 0.0);
GSL_SET_COMPLEX(&beta, 0.0, 0.0);
gsl_matrix_complex_set_identity(I);
gsl_matrix_complex_set_identity(eA);
for (i = 50; i > 0; i--)
{
GSL_SET_COMPLEX(&z, 1.0 / i, 0.0);
gsl_matrix_complex_scale(eA, z);
gsl_blas_zgemm(CblasNoTrans, CblasNoTrans, alpha, eA, A, beta, T);
gsl_matrix_complex_add(T, I);
gsl_matrix_complex_memcpy(eA, T);
}
return 0;
}
void expm(gsl_matrix_complex * L, gsl_complex t, gsl_matrix * m)
{
int i,j,s;
gsl_vector_complex *eval = gsl_vector_complex_alloc(4);
gsl_matrix_complex *evec = gsl_matrix_complex_alloc(4, 4);
gsl_eigen_nonsymmv_workspace * w = gsl_eigen_nonsymmv_alloc(4);
gsl_matrix_complex *evalmat = gsl_matrix_complex_alloc(4, 4);
gsl_matrix_complex *vd = gsl_matrix_complex_alloc(4, 4);
gsl_complex one = gsl_complex_rect(1, 0);
gsl_complex zero = gsl_complex_rect(0, 0);
gsl_matrix_complex *K = gsl_matrix_complex_alloc(4, 4);
gsl_permutation *p = gsl_permutation_alloc(4);
gsl_vector_complex *x = gsl_vector_complex_alloc(4);
gsl_vector_complex_view bp;
gsl_complex z;
gsl_eigen_nonsymmv(m, eval, evec, w);
gsl_eigen_nonsymmv_sort(eval, evec, GSL_EIGEN_SORT_ABS_DESC);
gsl_eigen_nonsymmv_free(w); // clear workspace
for (i = 0; i < 4; i++)
{
gsl_complex eval_i = gsl_vector_complex_get(eval, i);
gsl_complex expeval = gsl_complex_mul(eval_i,t);
expeval = gsl_complex_exp(expeval);
gsl_matrix_complex_set(evalmat, i, i, expeval);
}
gsl_vector_complex_free(eval); // clear vector for eigenvalues
// v'L'=De'v'
gsl_blas_zgemm(CblasTrans, CblasTrans, one, evalmat, evec, zero, vd);
gsl_matrix_complex_transpose(evec);//transpose v
gsl_matrix_complex_memcpy(K,evec);
for (i = 0; i < 4; i++)
{
bp = gsl_matrix_complex_column(vd, i);
gsl_linalg_complex_LU_decomp(evec, p, &s);
gsl_linalg_complex_LU_solve(evec, p, &bp.vector, x);
for (j = 0; j < 4; j++)
{
z = gsl_vector_complex_get(x, j);
gsl_matrix_complex_set(L,i,j,z); //'through the looking glass' transpose
}
gsl_matrix_complex_memcpy(evec,K);
}
gsl_permutation_free(p);
gsl_vector_complex_free(x);
gsl_matrix_complex_free(vd);
gsl_matrix_complex_free(evec);
gsl_matrix_complex_free(evalmat);
gsl_matrix_complex_free(K);
}
int gsl_matrix_complex_multiply(gsl_matrix_complex* A, gsl_matrix_complex* B,
gsl_matrix_complex* C)
{
gsl_complex a = {1.0, 0.0}, b = {0.0, 0.0};
return gsl_blas_zgemm(CblasNoTrans, CblasNoTrans,
a, A, B, b, C);
}
//
// XXX: implement with GSL matrices instead of QDPACK matrices
//
qdpack_complex
qdpack_matrix_multiply_vmv(qdpack_matrix_t *mat, qdpack_matrix_t *v)
{
qdpack_matrix_t *prod, *expt;
gsl_complex res;
prod = qdpack_matrix_alloc(mat->m, 1);
expt = qdpack_matrix_alloc(1, 1);
gsl_blas_zgemm(CblasNoTrans, CblasNoTrans, GSL_COMPLEX_ONE, mat->data, v->data, QDPACK_COMPLEX_ZERO, prod->data);
gsl_blas_zgemm(CblasTrans, CblasNoTrans, GSL_COMPLEX_ONE, v->data, prod->data, QDPACK_COMPLEX_ZERO, expt->data); // ConjTrans ??
res = qdpack_matrix_get(expt, 0, 0);
qdpack_matrix_free(expt);
qdpack_matrix_free(prod);
return res;
}
/* ---
* Process the density matrix for time t (calc. expectations values,
* store to file, etc.)
*/
int
rho_store_cb(qdpack_operator_t *rho_t, double t, qdpack_hilbert_space_t *qs, qdpack_simulation_t *sp)
{
int i, j, ri;
qdpack_complex N_expt, op1_expt, op2_expt;
char filename[1024], row[16384];
qdpack_operator_t *dm_part;
if (USE_EIGENBASIS == 1)
{
gsl_eigen_hermv(sp->H_t, sp->eval, sp->evec, sp->w);
gsl_eigen_hermv_sort(sp->eval, sp->evec, GSL_EIGEN_SORT_VAL_ASC);
gsl_blas_zgemm(CblasConjTrans, CblasNoTrans, QDPACK_COMPLEX_ONE, sp->evec, rho_t, QDPACK_COMPLEX_ZERO, rho_tmp_t);
gsl_blas_zgemm(CblasNoTrans, CblasNoTrans, QDPACK_COMPLEX_ONE, rho_tmp_t, sp->evec, QDPACK_COMPLEX_ZERO, rho_eb_t);
}
else
{
qdpack_operator_memcpy(rho_eb_t, rho_t);
}
/* -- store expectation value of sigma z -- * /
N_expt = qdpack_operator_expectation_value(rho_t, sp->N_op[i]);
snprintf(filename, sizeof(filename), "%s/sigma_z_expt_%d%s_x_%.2f_y_%.2f.dat", DATADIR, i, sp->simsig, sp->x, sp->y);
snprintf(row, sizeof(row), "%f\t%f\t%f", t, QDPACK_REAL(N_expt), QDPACK_IMAG(N_expt));
qdpack_file_row_add(filename, row);
*/
//if (1) // if ( abs(sin(p->h_td_w * t)) < 0.1 ) // close to bias point
if (t > sp->Tf/2.0)
{
pe_expt_sum += QDPACK_REAL(qdpack_operator_get(rho_eb_t, 1, 1));
pe_expt_no++;
}
return 0;
}
void gsl_matrix_complex_change_basis_UCMU(gsl_matrix_complex* U, gsl_matrix_complex* M){
unsigned int numneu = U->size1;
gsl_matrix_complex *U1 = gsl_matrix_complex_alloc(numneu,numneu);
gsl_matrix_complex *U2 = gsl_matrix_complex_alloc(numneu,numneu);
gsl_matrix_complex_memcpy(U1,U);
gsl_matrix_complex_memcpy(U2,U);
gsl_matrix_complex *T1 = gsl_matrix_complex_alloc(numneu,numneu);
// doing : U M U^dagger
gsl_blas_zgemm(CblasNoTrans,CblasNoTrans,
gsl_complex_rect(1.0,0.0),M,
U1,gsl_complex_rect(0.0,0.0),T1);
gsl_blas_zgemm(CblasConjTrans,CblasNoTrans,
gsl_complex_rect(1.0,0.0),U2,
T1,gsl_complex_rect(0.0,0.0),M);
// now H_current is in the interaction basis of the mass basis
gsl_matrix_complex_free(U1);
gsl_matrix_complex_free(U2);
gsl_matrix_complex_free(T1);
}
std::unique_ptr<gsl_matrix_complex,void (*)(gsl_matrix_complex*)> Const::GetTransformationMatrix(size_t dim) const{
if(dim>SQUIDS_MAX_HILBERT_DIM)
throw std::runtime_error("Const::GetTransformationMatrix: dimension must be less than " SQUIDS_MAX_HILBERT_DIM_STR);
gsl_matrix_complex* U = gsl_matrix_complex_alloc(dim,dim);
gsl_matrix_complex* R = gsl_matrix_complex_alloc(dim,dim);
gsl_matrix_complex* dummy = gsl_matrix_complex_alloc(dim,dim);
gsl_matrix_complex_set_identity(U);
gsl_matrix_complex_set_identity(R);
gsl_matrix_complex_set_zero(dummy);
const auto unit=gsl_complex_rect(1,0);
const auto zero=gsl_complex_rect(0,0);
auto to_gsl=[](const std::complex<double>& c)->gsl_complex{
return(gsl_complex_rect(c.real(),c.imag()));
};
//construct each subspace rotation and accumulate the product
for(size_t j=1; j<dim; j++){
for(size_t i=0; i<j; i++){
//set up the subspace rotation
double theta=GetMixingAngle(i,j);
double delta=GetPhase(i,j);
double c=cos(theta);
auto cp=sin(theta)*std::exp(std::complex<double>(0,-delta));
auto cpc=-std::conj(cp);
gsl_matrix_complex_set(R,i,i,to_gsl(c));
gsl_matrix_complex_set(R,i,j,to_gsl(cp));
gsl_matrix_complex_set(R,j,i,to_gsl(cpc));
gsl_matrix_complex_set(R,j,j,to_gsl(c));
//multiply this rotation onto the product from the left
gsl_blas_zgemm(CblasNoTrans,CblasNoTrans,unit,R,U,zero,dummy);
std::swap(U,dummy);
//clean up the rotation matrix for next iteration
gsl_matrix_complex_set(R,i,i,unit);
gsl_matrix_complex_set(R,i,j,zero);
gsl_matrix_complex_set(R,j,i,zero);
gsl_matrix_complex_set(R,j,j,unit);
}
}
//clean up temporary matrices
gsl_matrix_complex_free(R);
gsl_matrix_complex_free(dummy);
return std::unique_ptr<gsl_matrix_complex,void (*)(gsl_matrix_complex*)>(U,gsl_matrix_complex_free);
}
/*
computes the svd of a complex matrix. Missing in gsl.
*/
int
svd(gsl_matrix_complex *A, gsl_matrix_complex *V, gsl_vector *S)
{
int n = A->size1;
gsl_eigen_hermv_workspace *gsl_work = gsl_eigen_hermv_alloc(n);
gsl_matrix_complex *Asq = gsl_matrix_complex_alloc(n, n);
gsl_complex zero = gsl_complex_rect(0., 0.);
gsl_complex one = gsl_complex_rect(1., 0.);
gsl_vector *e = gsl_vector_alloc(n);
gsl_matrix_complex *U = gsl_matrix_complex_alloc(n, n);
gsl_blas_zgemm(CblasNoTrans, CblasConjTrans, one, A, A, zero, Asq);
gsl_eigen_hermv(Asq, e, U, gsl_work);
gsl_eigen_hermv_sort(e, U, GSL_EIGEN_SORT_VAL_DESC);
gsl_blas_zgemm(CblasConjTrans, CblasNoTrans, one, A, A, zero, Asq);
gsl_eigen_hermv(Asq, e, V, gsl_work);
gsl_eigen_hermv_sort(e, V, GSL_EIGEN_SORT_VAL_DESC);
gsl_blas_zgemm(CblasNoTrans, CblasNoTrans, one, A, V, zero, Asq);
gsl_blas_zgemm(CblasConjTrans, CblasNoTrans, one, U, Asq, zero, A);
for(int i=0; i<n; i++){
gsl_complex x = gsl_matrix_complex_get(A, i, i);
double phase = gsl_complex_arg(gsl_complex_mul_real(x, 1./sqrt(e->data[i])));
gsl_vector_complex_view U_col = gsl_matrix_complex_column(U, i);
gsl_vector_complex_scale(&U_col.vector, gsl_complex_polar(1., phase));
gsl_vector_set(S, i, sqrt(gsl_vector_get(e, i)));
}
gsl_matrix_complex_memcpy(A, U);
gsl_vector_free(e);
gsl_matrix_complex_free(U);
gsl_matrix_complex_free(Asq);
gsl_eigen_hermv_free(gsl_work);
return 0;
}
//
// dot product for vector-like matrices (should check that dimensions of both
// are [m x 1])
//
qdpack_complex
qdpack_matrix_dot(qdpack_matrix_t *a, qdpack_matrix_t *b)
{
// use gsl_blas_zdotc(a->data, b->data, &z); ?
qdpack_matrix_t *prod;
gsl_complex z;
prod = qdpack_matrix_alloc(1, 1);
gsl_blas_zgemm(CblasTrans, CblasNoTrans, GSL_COMPLEX_ONE, a->data, b->data, QDPACK_COMPLEX_ZERO, prod->data); // ConjTrans ??
z = qdpack_matrix_get(prod, 0, 0);
qdpack_matrix_free(prod);
return z;
}
//
// BLAS style operator/matrix multiplication: C = alpha op(A) * op(B) + beta C
//
void
qdpack_matrix_blas_zgemm(QDPACK_TRANSPOSE_t transA,
QDPACK_TRANSPOSE_t transB,
qdpack_complex alpha,
qdpack_matrix_t *A,
qdpack_matrix_t *B,
qdpack_complex beta,
qdpack_matrix_t *C)
{
if (A && A->data && B && B->data && C && C->data)
{
gsl_blas_zgemm(transA, transB, alpha, A->data, B->data, beta, C->data);
}
else
{
fprintf(stderr, "%s: ERROR: NULL valued operator\n", __PRETTY_FUNCTION__);
}
}
static int
cm_mul_cm(lua_State *L)
{
mMatComplex *a = qlua_checkMatComplex(L, 1);
mMatComplex *b = qlua_checkMatComplex(L, 2);
int al = a->l_size;
int ar = a->r_size;
int bl = b->l_size;
int br = b->r_size;
mMatComplex *r = qlua_newMatComplex(L, al, br);
gsl_complex z1, z0;
if (ar != bl)
return luaL_error(L, "matrix sizes mismatch in m * m");
GSL_SET_COMPLEX(&z1, 1.0, 0.0);
GSL_SET_COMPLEX(&z0, 0.0, 0.0);
gsl_blas_zgemm(CblasNoTrans, CblasNoTrans, z1, a->m, b->m, z0, r->m);
return 1;
}
double Calculator::getIntensity(double Q)
{
std::complex<double> cppf1, cppf2;
gsl_complex alpha, beta;
gsl_complex gslf1, gslf2;
int s;
double avFactor;
cppf1 = m_sf1->F(0.0, 0.0, Q, m_energy);
cppf2 = m_sf2->F(0.0, 0.0, Q, m_energy);
gslf1 = gsl_complex_rect(cppf1.real(), cppf1.imag());
gslf2 = gsl_complex_rect(cppf2.real(), cppf2.imag());
avFactor = exp(-2.0 / m_N);
alpha = gsl_complex_rect (1.0, 0.0);
beta = gsl_complex_rect (0.0, 0.0);
/*set vector F (scattering factors)*/
gsl_vector_complex_set(F, 0, gslf1);
gsl_vector_complex_set(F, 1, gslf2);
/*set vector conj(F) (scattering factors)*/
gsl_vector_complex_set(Fconj, 0, gsl_complex_conjugate(gslf1));
gsl_vector_complex_set(Fconj, 1, gsl_complex_conjugate(gslf2));
/*set exp matrix*/
setMatrixExp(m_Exp, Q);
/*find W = P * Exp * Ps * conj(F) vector:*/
/* (1) W = alpha * Ps * conj(F) + beta * W */
gsl_blas_zgemv (CblasNoTrans, alpha, m_Ps, Fconj, beta, W);
/*printf("W(1):\n");
gsl_vector_complex_fprintf (stdout, W, "%g");*/
/* (2) W = alpha * Exp * tmp_vec + beta * W */
gsl_blas_zgemv (CblasNoTrans, alpha, m_Exp, W, beta, tmp_vec);
/*printf("W(2):\n");
gsl_vector_complex_fprintf (stdout, tmp_vec, "%g");*/
/* (3) W = alpha * P * tmp_vec + beta * W */
gsl_blas_zgemv (CblasNoTrans, alpha, m_P, tmp_vec, beta, W);
/*Find J0 = F.(Ps * conj(F)) */
gsl_blas_zgemv (CblasNoTrans, alpha, m_Ps, Fconj, beta, tmp_vec);
gsl_blas_zdotu (F, tmp_vec, &J0);
/*alpha = exp(-2 / N)*/
alpha = gsl_complex_rect (avFactor, 0.0);
beta = gsl_complex_rect (0.0, 0.0);
/*find T matrix: T = alpha * P * exp + beta * T*/
gsl_blas_zgemm (CblasNoTrans, CblasNoTrans, alpha, m_P, m_Exp, beta, T);
/*printf("T:\n");
gsl_matrix_complex_fprintf (stdout, T, "%g");*/
/*Find Jns = F. (G * W) */
/*tmp_mat = I */
gsl_matrix_complex_set_identity (tmp_mat);
/*tmp_mat = I - T */
gsl_matrix_complex_sub (tmp_mat, T);
/*LU decomposition*/
gsl_linalg_complex_LU_decomp(tmp_mat, perm, &s);
/*calculate product G * W = (I - T)^(-1) W directly using LU decomposition*/
gsl_linalg_complex_LU_solve (tmp_mat, perm, W, tmp_vec);
/*calculate F.(G * W)*/
gsl_blas_zdotu (F, tmp_vec, &Jns);
/*Find Js = F.(G^2 * (I - T^N) * W) however, this term should be negligible*/
/*result = N *(2 * Jns + J0) - Js */
alpha = gsl_complex_mul_real (Jns, 2.0 * avFactor);
alpha = gsl_complex_add (alpha, J0);
return m_N * m_I0 * GSL_REAL(alpha) * getPLGfactor(getTheta(Q)) + m_Ibg;
}
/* ---
* Program starts here.
*
*/
int
main(int argc, char **argv)
{
qdpack_hilbert_space_t *qs;
qdpack_operator_t *rho_q, *rho_c;
qdpack_operator_t *rho0, *rho_t;
qdpack_operator_list_t dm_list;
int qsn, i, noff, nsize, npeak;
double Navg, fw, fA, phi, Gc, Gq, gqc, x, y, pDelta, G1, G2, T1, T2;
double yi, yf, yd;
qdpack_simulation_t param;
qdpack_simulation_init(¶m);
if (argc != 5)
{
printf("usage: %s x y-init y-delta y-final\n", argv[0]);
exit(0);
}
snprintf(DATADIR, sizeof(DATADIR), DATADIR_TEMPLATE, argv[0]);
// ---- PARAMETERS START
//
// frequency in units of GHz and time in units of ns
//
//
// x = coefficient of sigma_z in qubit hamiltonian, in units of driving frequency
// x = epsilon / (fw * 2 * M_PI)
//
// y = the driving amplitude in units of driving frequency
// y = h_td_A / (fw * 2 * M_PI)
//
// get values from command line parameters
x = strtod(argv[1], NULL);
yi = strtod(argv[2], NULL);
yd = strtod(argv[3], NULL);
yf = strtod(argv[4], NULL);
fw = 1.0; // driving frequency
pDelta = fw/300.0; // coefficient of sigma_x in qubit hamiltonain
T1 = 1000.0 / fw; // relaxation time
T2 = 5.0 / fw; // dephasing time
param.Ti = 0.0;
param.Tf = T1 * 5.0; // must be large enough to reach the steady state
param.dT = (param.Tf-param.Ti) / 1000.0;
// ---- PARAMETERS END
//
// setup parameter vectors
//
param.epsilon = epsilon;
param.delta = delta;
simulation.ho_w = ho_w;
param.x = x;
for (i = 0; i < 10; i++)
{
param.epsilon[i] *= 2*M_PI;
param.delta[i] *= 2*M_PI;
simulation.ho_w[i] *= 2*M_PI;
lambda[i] = (double *)calloc(10, sizeof(double));
}
param.lambda = lambda;
param.cont_basis_transform = 0;
param.h_td_w = fw * 2 * M_PI;
G1 = 1.0/T1;
G2 = 1.0/T2;
/*
* create a new quantum system object
*/
qs = qdpack_hilbert_space_new();
qdpack_hilbert_space_add(qs, 2);
qsn = qdpack_hilbert_space_nstates(qs);
qdpack_hilbert_space_print(qs);
param.qs = qs;
// setup hamiltonian functions
param.H0_func = (hamiltonian_func_t)hamiltonian_qubits;
param.H1_func = (hamiltonian_func_t)hamiltonian_z_drive;
param.Ht_func = (hamiltonian_td_func_t)hamiltonian_sd_t;
// preallocate matrices
param.H_t = qdpack_operator_alloc(qsn, qsn);
param.H0 = qdpack_operator_alloc(qsn, qsn);
param.H1 = qdpack_operator_alloc(qsn, qsn);
param.N_op[0] = qdpack_operator_alloc(qsn, qsn);
operator_ho_N(param.N_op[0], qs, 0, 0);
/*
* Set up dissipation
*
*/
param.wT = 0.0 * 2 * M_PI;
param.do_n = 0;
Navg = 0; // zero temperature
// relaxation
param.do_a[param.do_n] = qdpack_operator_alloc(qsn, qsn);
operator_ho_lowering(param.do_a[param.do_n], qs, 0, 0);
param.do_ad[param.do_n] = qdpack_operator_alloc(qsn, qsn);
operator_ho_raising(param.do_ad[param.do_n], qs, 0, 0);
param.do_g1[param.do_n] = G1 * (1 + Navg); // relaxation rate
param.do_g2[param.do_n] = G1 * Navg; // excitation rate
param.do_n++;
// dephasing
param.do_a[param.do_n] = qdpack_operator_alloc(qsn, qsn);
operator_sigma_z(param.do_a[param.do_n], qs, 0);
param.do_ad[param.do_n] = qdpack_operator_alloc(qsn, qsn);
operator_sigma_z(param.do_ad[param.do_n], qs, 0);
param.do_g1[param.do_n] = G2 / 2;
param.do_g2[param.do_n] = G2 / 2;
param.do_n++;
param.eval = gsl_vector_alloc(2);
param.evec = qdpack_operator_alloc(2, 2);
param.w = gsl_eigen_hermv_alloc(2);
snprintf(param.simsig, sizeof(param.simsig), "_dDelta_%.3f_G1_%.3f_G2_%.4f_fw_%.3f", pDelta, G1, G2, fw);
/* storage space for final rho */
param.rho_f = qdpack_operator_alloc(qsn, qsn);
rho_eb_t = qdpack_operator_alloc(qsn, qsn);
rho_tmp_t = qdpack_operator_alloc(qsn, qsn);
/*
* Setup initial state
*/
rho_q = qdpack_dm_pure_TLS(0.0);
qdpack_operator_list_init(&dm_list);
qdpack_operator_list_append(&dm_list, rho_q);
rho0 = qdpack_operator_alloc(qsn, qsn);
qdpack_operator_tensor(rho0, qs, &dm_list);
delta[0] = pDelta * (2*M_PI);
epsilon[0] = x * fw * (2*M_PI);
for (y = yi; y <= yf; y += yd)
{
pe_expt_sum = 0.0;
pe_expt_no = 0;
param.y = y;
param.h_td_A = y * fw * 2 * M_PI;
printf("ITERATION: %s: x = %f, y = %f\n", param.simsig, param.x, param.y);
if (USE_EIGENBASIS == 1)
{
param.H0_func(param.H0, qs, ¶m);
gsl_eigen_hermv(param.H0, param.eval, param.evec, param.w);
gsl_eigen_hermv_sort(param.eval, param.evec, GSL_EIGEN_SORT_VAL_ASC);
// rho_0 = S rho_eb_0 S^{-1}
gsl_blas_zgemm(CblasNoTrans, CblasNoTrans, QDPACK_COMPLEX_ONE, param.evec, rho_q, QDPACK_COMPLEX_ZERO, rho_tmp_t);
gsl_blas_zgemm(CblasNoTrans, CblasConjTrans, QDPACK_COMPLEX_ONE, rho_tmp_t, param.evec, QDPACK_COMPLEX_ZERO, rho0);
qdpack_operator_free(param.H0);
}
/*
* Evolve the quantum system until time t = T, where the steady state
* is assumed to be reached.
*
*/
//if (qdpack_evolve_dm_lme_ib_t(qs, rho0, ¶m, rho_store_cb) != 0)
if (qdpack_evolve_dm_lme_t(qs, rho0, ¶m, rho_store_cb) != 0)
{
fprintf(stderr, "Evolution of the quantum system failed.\n");
return -1;
}
rho_store_final_cb(param.rho_f, param.Tf, qs, ¶m);
}
return 0;
}
void MAIAllocator::Run() {
// fetch channel matrix
gsl_matrix_complex hmm = min1.GetDataObj();
// hmm : channel coeffs matrix h(n) (M**2xN)
// ij
// ch matrix structure
//
// +- -+
// | h(0) . . . . h(n) | |
// | 11 11 | |
// | | | Rx1
// | h(0) . . . . h(n) | |
// | 12 12 | |
// | |
// | h(0) . . . . h(n) | |
// | 21 21 | |
// | | | Rx2
// | h(0) . . . . h(n) | |
// | 22 22 | |
// +- -+
//
// where h(n) represents the channel impulse response
// ij
//
// at time n, from tx_i to rx_j
// the matrix has MxM rows and N comumns.
// The (i,j) channel is locater at row i*M+j
// with i,j in the range [0,M-1] and rows counting from 0
//
//
// fetch error report
// e(u) = errors for user u in the last ERROR_REPORT_INTERVAL (ERI) frames
gsl_vector_uint temperr = vin2.GetDataObj();
// update error reports at receiver rx_m every ERI
if (ericount % ERROR_REPORT_INTERVAL == 0) { // once every ERU
if (temperr.size == M()) {
gsl_vector_uint_memcpy(errs,&temperr);
}
ericount = 0;
}
//
// every DECISION_INTERVAL frames we updates the CSI knowledge
//
if (framecount % DECISION_INTERVAL == 0) {
for (int u=0;u<M();u++) { // user loop
// extract time domain response from hmm corresponding to txn-->rxn channel
gsl_vector_complex_const_view hii = gsl_matrix_complex_const_row(&hmm,u*M()+u);
// copy the N-sized vector hii into u-th column of huu
gsl_matrix_complex_set_col(huu,u,&hii.vector);
} // user loop
//cout << "maiallocator:453 - CSI update received" << endl;
// huu matrix structure
//
// +- -+
// | h(0) . . . . h(n) |
// | 11 uu |
// | |
// | h(n) . . . . h(n) |
// | 11 uu |
// +- -+
//
// where h(n) represents the channel impulse response
// ii
//
// at time n, from tx_u to rx_u
// the matrix has N rows and M columns.
//
// ATTENTION! user_0 channel response is the first column
//
// Hmat(NxM) = Fourier( huu(NxM) )
//
gsl_blas_zgemm(CblasNoTrans,
CblasNoTrans,
gsl_complex_rect(1,0),
transform_mat,
huu,
gsl_complex_rect(0,0),
Hmat);
#ifdef SHOW_MATRIX
cout << "Hmat(freq,user) (frame:" << framecount << ") = " << endl;
gsl_matrix_complex_show(Hmat);
#endif
//
// ***********************************************************
// CARRIER ALLOCATION STRATEGIES
// ***********************************************************
//
switch (Mode()) {
case 0: // FIXED_ALLOCATION
break;
case 1: // GIVE_BEST_CARR
//
// SORT CARRIERS OF EACH USERS
//
// uses Hmat: the frequency responses of channel tx_n --> rx_n
//
// starting from user u ...
// find the best (in u ranking) unused carrier and assign it to u
// next user until no more available carriers
for(int u=0; u<M(); u++) { // cycle through users
gsl_vector_complex_const_view huser
= gsl_matrix_complex_const_column(Hmat,u);
gsl_vector_uint_view sortindu = gsl_matrix_uint_column(Hperm,u);
for (int j=0; j<N(); j++) {
double currpower
= gsl_complex_abs2(gsl_vector_complex_get(&huser.vector,j));
gsl_vector_set(huserabs,j,currpower);
}
// sort over c using abs(h(u,c))
gsl_sort_vector_index(p,huserabs);
for (int j=0; j<N(); j++) {
uint currindex = p->data[j];
gsl_vector_uint_set(&sortindu.vector,j,currindex);
}
}
//
// FIND INITIAL USER RANDOMLY
//
curruser = gsl_rng_uniform_int(ran,M());
//
// ASSIGN FREQUENCIES
//
gsl_vector_uint_set_all(nextcarr,0);
gsl_vector_uint_set_all(usedcarr,0);
for (int j=0; j<J(); j++) {
for (int uu=0; uu<M(); uu++) {
int u = (uu+curruser) % M();
int isassigned = 0;
while (! isassigned) {
int tag = gsl_vector_uint_get(nextcarr,u);
gsl_vector_uint_set(nextcarr,u,++tag);
int carrier = gsl_matrix_uint_get(Hperm,N()-tag,u);
if (! gsl_vector_uint_get(usedcarr,carrier)) {
isassigned = 1;
gsl_vector_uint_set(usedcarr,carrier,isassigned);
gsl_matrix_uint_set(signature_frequencies,u,j,carrier);
} else if (tag==N()) {
cerr << "Block: " << BlockName << " allocation problem." << endl;
exit(1);
}
}
}
}
//
// show channels and permutations
//
// gsl_matrix_complex_show(Hmat);
//gsl_matrix_uint_show(Hperm);
//gsl_matrix_uint_show(signature_frequencies);
break;
case 2: // SWAP_BAD_GOOD
//
// SWAP_BAD_GOOD
//
// sort carriers for each user
// choose randomly a starting user u
// for each user starting with u
// swap worst carrier used by u with best carrier if used by others
// sort carriers
for(int u=0; u<M(); u++) {
gsl_vector_complex_const_view huser
= gsl_matrix_complex_const_column(Hmat,u);
gsl_vector_uint_view sortindu = gsl_matrix_uint_column(Hperm,u);
gsl_vector_view huserabs = gsl_matrix_column(habs,u);
for (int j=0; j<N(); j++) {
double currpower
= gsl_complex_abs2(gsl_vector_complex_get(&huser.vector,j));
gsl_vector_set(&huserabs.vector,j,currpower);
}
//
// sort channels for user <u>
//
gsl_sort_vector_index(p,&huserabs.vector);
for (int j=0; j<N(); j++) {
uint currindex = p->data[j];
gsl_vector_uint_set(&sortindu.vector,j,currindex);
}
}
//
// Hperm(N,USERS) contains sorted channels index for each users
// habs(N,USERS) contains channel energy per each user
//
//
// FIND INITIAL USER RANDOMLY for fairness
//
curruser = gsl_rng_uniform_int(ran,M());
//
// ASSIGN FREQUENCIES
//
//
// for each user ...
//
for (int uu=0; uu<M(); uu++) {
int u = (uu+curruser) % M();
//
// worst allocated channel for user u
//
double worstvalue=GSL_POSINF;
unsigned int worstjindex;
for (int j=0; j<J(); j++) {
unsigned int chind = gsl_matrix_uint_get(signature_frequencies,u,j);
double currh = gsl_matrix_get(habs,chind,u);
if (currh < worstvalue) {
worstvalue = currh;
worstjindex = j;
}
}
//
// find best channel allocated by other users
//
//
double bestvalue=0;
unsigned int bestuser, bestjindex;
for (int uuu=0; uuu<M()-1; uuu++) {
unsigned int otheru = (uuu+u) % M();
for (int j=0; j<J(); j++) {
unsigned int chind
= gsl_matrix_uint_get(signature_frequencies,otheru,j);
double currh = gsl_matrix_get(habs,chind,otheru);
if (currh > bestvalue) {
bestvalue = currh;
bestjindex = j;
bestuser = otheru;
}
}
}
//
// finally the swap !
//
unsigned int chind
= gsl_matrix_uint_get(signature_frequencies,u,worstjindex);
gsl_matrix_uint_set(signature_frequencies,u,worstjindex,
gsl_matrix_uint_get(signature_frequencies,
bestuser,bestjindex));
gsl_matrix_uint_set(signature_frequencies,bestuser,bestjindex,chind);
// cout << "\n\nProcessing user " << u << endl
// << "\tSwapped " << u << "." << worstjindex
// << " <-> " << bestuser << "." << bestjindex << endl;
}
break;
case 3: // BEST_OVERLAP
//
// SORT CARRIERS OF EACH USERS
//
gsl_matrix_uint_memcpy(signature_frequencies,
signature_frequencies_init);
for(int u=0; u<M(); u++) {
gsl_vector_complex_const_view huser
= gsl_matrix_complex_const_column(Hmat,u);
gsl_vector_uint_view sortindu = gsl_matrix_uint_column(Hperm,u);
for (int j=0; j<N(); j++) {
double currpower = gsl_complex_abs2(gsl_vector_complex_get(&huser.vector,
j));
gsl_vector_set(huserabs,j,currpower);
}
gsl_sort_vector_index(p,huserabs);
for (int j=0; j<N(); j++) {
uint currindex = p->data[j];
gsl_vector_uint_set(&sortindu.vector,j,currindex);
}
}
//
// each user take his best carriers allowing carrier overlap
//
for (int u=0; u<M(); u++) {
for (int j=0; j<J(); j++) {
int carrier = gsl_matrix_uint_get(Hperm,N()-j-1,u);
gsl_matrix_uint_set(signature_frequencies,u,j,carrier);
}
}
//
// show channels and permutations
//
//gsl_matrix_complex_show(Hmat);
//gsl_matrix_uint_show(Hperm);
//gsl_matrix_uint_show(signature_frequencies);
break;
case 4: // SOAR_AI
//
// SOAR
//
// agent crai5
// bases the decisions on the frequency response tx_m --> rx_m in Hmat(N,M)
// for each user it proposes a swap between carriers if the instantaneous impulse channel response
// is better
//
// agent crai6
// for each user it proposes a swap of allocated carriers with one other users
// error report is the metric for correct decisions (RL)
#ifdef PAUSED
// keypress
cout << "pause maillocator: before decision loop ... (press ENTER key)" << endl;
cin.ignore();
#endif
// Every DECISION_INTERVAL we increase the input-time and allow decisions
if (framecount % DECISION_INTERVAL == 0) {
pAgent->Update(inputTime,++input_time);
pAgent->Commit();
}
// run agent till output
noDecisions = 0;
numberCommands=0;
while (! (noDecisions) ) { // main decisional loop
//
// INPUT LINK Update
//
UpdateInputLink();
//pAgent->RunSelf(1);
pAgent->RunSelfTilOutput();
numberCommands = pAgent->GetNumberCommands() ;
#ifdef PAUSED
// keypress
cout << "pause maillocator: after RunSelfTilOutput() ... (press ENTER key)" << endl;
cin.ignore();
#endif
// loop through received commands
for (int cmd = 0 ; cmd < numberCommands ; cmd++) {
Identifier* pCommand = pAgent->GetCommand(cmd) ;
string name = pCommand->GetCommandName() ;
if (name == "assign-free") {
std::string sUid = pCommand->GetParameterValue("uid");
std::string sDeassign = pCommand->GetParameterValue("deassign");
std::string sAssign = pCommand->GetParameterValue("assign");
#ifdef SHOW_SOAR
cout << "assign-free command received [ u:"
<< sUid << " , -"
<< sDeassign << " , +"
<< sAssign << " ]"
<< endl;
#endif
AssignFree(sUid,sDeassign,sAssign);
pCommand->AddStatusComplete();
} else if (name == "swap-carriers") {
std::string sU1 = pCommand->GetParameterValue("u1");
std::string sC1 = pCommand->GetParameterValue("c1");
std::string sU2 = pCommand->GetParameterValue("u2");
std::string sC2 = pCommand->GetParameterValue("c2");
#ifdef SHOW_SOAR
cout << "swap-carriers command received [ u1:"
<< sU1 << " , c1:"
<< sC1 << " , u2:"
<< sU2 << " , c2:"
<< sC2 << " ]" << endl;
#endif
SwapCarriers(sU1,sC1,sU2,sC2);
pCommand->AddStatusComplete();
} else if (name == "increase-power") {
std::string sUid = pCommand->GetParameterValue("uid");
std::string sCid = pCommand->GetParameterValue("cid");
#ifdef SHOW_SOAR
cout << "increase-power command received [ u:"
<< sUid << " , c:"
<< sCid << " ]" << endl;
#endif
IncreasePower(sUid,sCid);
pCommand->AddStatusComplete();
break;
} else if (name == "no-choices") {
#ifdef SHOW_SOAR
cout << "no-choices command received" << endl;
#endif
noDecisions = 1;
pCommand->AddStatusComplete();
break;
} else {
#ifdef SHOW_SOAR
cout << "ignoring unknown output command from SOAR" << endl;
#endif
break;
}
// cout << "framecount = " << framecount << endl;
} // end command loop
} // while (! (noDecisions) )
break;
} // switch (Mode())
} // if DECISION_INTERVAL % 0
//
// every 10s dump frame count
//
time(&nowtime);
if (difftime(nowtime,reporttime) > TIMEDELTA) {
reporttime = nowtime;
cout << "frame:" << framecount << "\r";
cout.flush();
}
//////// production of data
framecount++;
ericount++;
mout1.DeliverDataObj( *signature_frequencies );
mout2.DeliverDataObj( *signature_powers );
#ifdef SHOW_MATRIX
cout << "signature frequencies (frame:" << framecount-1 << ") = " << endl;
gsl_matrix_uint_show(signature_frequencies);
#endif
}
static VALUE rb_gsl_blas_zgemm(int argc, VALUE *argv, VALUE obj)
{
gsl_matrix_complex *A = NULL, *B = NULL, *C = NULL;
gsl_complex *pa = NULL, *pb = NULL;
CBLAS_TRANSPOSE_t TransA, TransB;
int flag = 0;
(*pa).dat[0] = 1.0; (*pa).dat[1] = 0.0;
(*pb).dat[0] = 0.0; (*pb).dat[1] = 0.0;
switch (argc) {
case 2:
CHECK_MATRIX_COMPLEX(argv[0]);
CHECK_MATRIX_COMPLEX(argv[1]);
Data_Get_Struct(argv[0], gsl_matrix_complex, A);
Data_Get_Struct(argv[1], gsl_matrix_complex, B);
C = gsl_matrix_complex_calloc(A->size1, B->size2);
TransA = CblasNoTrans; TransB = CblasNoTrans;
flag = 1;
break;
case 5:
CHECK_FIXNUM(argv[0]);
CHECK_FIXNUM(argv[1]);
CHECK_COMPLEX(argv[2]);
CHECK_MATRIX_COMPLEX(argv[3]);
CHECK_MATRIX_COMPLEX(argv[4]);
TransA = FIX2INT(argv[0]);
TransB = FIX2INT(argv[1]);
Data_Get_Struct(argv[2], gsl_complex, pa);
Data_Get_Struct(argv[3], gsl_matrix_complex, A);
Data_Get_Struct(argv[4], gsl_matrix_complex, B);
C = gsl_matrix_complex_calloc(A->size1, B->size2);
flag = 1;
break;
case 6:
CHECK_FIXNUM(argv[0]);
CHECK_FIXNUM(argv[1]);
CHECK_COMPLEX(argv[2]);
CHECK_MATRIX_COMPLEX(argv[3]);
CHECK_MATRIX_COMPLEX(argv[4]);
CHECK_COMPLEX(argv[5]);
TransA = FIX2INT(argv[0]);
TransB = FIX2INT(argv[1]);
Data_Get_Struct(argv[2], gsl_complex, pa);
Data_Get_Struct(argv[3], gsl_matrix_complex, A);
Data_Get_Struct(argv[4], gsl_matrix_complex, B);
Data_Get_Struct(argv[5], gsl_complex, pb);
C = gsl_matrix_complex_calloc(A->size1, B->size2);
flag = 1;
break;
case 7:
CHECK_FIXNUM(argv[0]);
CHECK_FIXNUM(argv[1]);
CHECK_COMPLEX(argv[2]);
CHECK_MATRIX_COMPLEX(argv[3]);
CHECK_MATRIX_COMPLEX(argv[4]);
CHECK_COMPLEX(argv[5]);
CHECK_MATRIX_COMPLEX(argv[6]);
TransA = FIX2INT(argv[0]);
TransB = FIX2INT(argv[1]);
Data_Get_Struct(argv[2], gsl_complex, pa);
Data_Get_Struct(argv[3], gsl_matrix_complex, A);
Data_Get_Struct(argv[4], gsl_matrix_complex, B);
Data_Get_Struct(argv[5], gsl_complex, pb);
Data_Get_Struct(argv[6], gsl_matrix_complex, C);
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 7)", argc);
break;
}
gsl_blas_zgemm(TransA, TransB, *pa, A, B, *pb, C);
if (flag == 1) return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, C);
else return argv[6];
}
bool Matrix_Product(gsl_complex alpha, CBLAS_TRANSPOSE_t tA, gsl_matrix_complex *A, CBLAS_TRANSPOSE_t tB, gsl_matrix_complex *B, gsl_complex beta ,gsl_matrix_complex *C ){
gsl_blas_zgemm(tA, tB,alpha,A,B,beta,C);
return true;
}
/**
* C++ version of gsl_blas_zgemm().
* @param TransA Transpose type
* @param TransB Transpose type for B
* @param alpha A constant
* @param A A matrix
* @param B Another matrix
* @param beta Another constant
* @param C Another matrix
* @return Error code on failure
*/
int zgemm( CBLAS_TRANSPOSE_t TransA, CBLAS_TRANSPOSE_t TransB, complex const& alpha,
matrix_complex const& A, matrix_complex const& B, complex const& beta,
matrix_complex& C ){
return gsl_blas_zgemm( TransA, TransB, alpha.get(), A.get(), B.get(), beta.get(), C.get() ); }
void MBlockUser::Run() {
//
// Allocation Matrices
//
gsl_matrix_uint signature_frequencies=min2.GetDataObj();
gsl_matrix signature_powers=min3.GetDataObj();
//
// input bits
//
gsl_matrix_uint inputbits = min1.GetDataObj();
//
// outer loop: the users
//
for (int u=0;u<M();u++) {
gsl_vector_complex_view tmpout = gsl_matrix_complex_column(outmat,u);
//
//
// FETCH K INPUT SYMBOLS
//
//
for (int j=0;j<K();j++) {
symbol_id=0;
//////// I take Nb bits from input and map it in new_symbol
for (int i=0;i<Nb();i++) {
symbol_id = (symbol_id << 1);
// symbol_id += in1.GetDataObj();
symbol_id += gsl_matrix_uint_get(&inputbits,u,j*Nb()+i);
}
new_symbol = gsl_complex_polar(1.0,
symbol_arg *
double(gsl_vector_uint_get(gray_encoding,
symbol_id)));
gsl_vector_complex_set(tmp,j,new_symbol);
}
//
//
// SELECTION MATRIX UPDATE and POWER
//
//
// gsl_matrix_complex_set_identity(selection_mat);
gsl_matrix_complex_set_zero(selection_mat);
for (int i=0;i<J(); i++) {
unsigned int carrier=gsl_matrix_uint_get(&signature_frequencies,u,i);
double power=gsl_matrix_get(&signature_powers,u,i);
gsl_complex one=gsl_complex_polar(power,0.0);
gsl_matrix_complex_set(selection_mat,carrier,i,one);
}
//
//
// PRECODING MATRIX UPDATE
//
//
#ifdef GIANNAKIS_PRECODING
double roarg=2.0*double(M_PI/N());
for (int i=0;i<J(); i++) {
unsigned int carrier=gsl_matrix_uint_get(&signature_frequencies,u,i);
for (int j=0; j<K(); j++) {
gsl_complex ro=gsl_complex_polar(sqrt(1.0/double(J())),-j*carrier*roarg);
gsl_matrix_complex_set(coding_mat,i,j,ro);
}
}
#else
double roarg=2.0*double(M_PI/J());
for (int i=0;i<J(); i++) {
for (int j=0; j<K(); j++) {
gsl_complex ro=gsl_complex_polar(sqrt(1.0/double(J())),-j*i*roarg);
gsl_matrix_complex_set(coding_mat,i,j,ro);
}
}
#endif
#ifdef SHOW_MATRIX
cout << endl << BlockName << " user: "******"coding matrix (theta) = " << endl;
gsl_matrix_complex_show(coding_mat);
cout << "T^h*T matrix = " << endl;
gsl_matrix_complex_show(THT);
cout << "T^h*T trace = "
<< GSL_REAL(trace)
<< ", "
<< GSL_IMAG(trace)
<< endl;
gsl_matrix_complex_free(THT);
#endif
//
//
// PRECODING
//
//
gsl_blas_zgemv(CblasNoTrans,
gsl_complex_rect(1.0,0),
coding_mat,
tmp,
gsl_complex_rect(0,0),
tmp1);
//
//
// CARRIER SELECTION
//
//
gsl_blas_zgemv(CblasNoTrans,
gsl_complex_rect(1.0,0),
selection_mat,
tmp1,
gsl_complex_rect(0,0),
tmp2);
//
//
// IFFT TRANSFORM
//
//
gsl_blas_zgemv(CblasNoTrans,
gsl_complex_rect(1.0,0),
transform_mat,
tmp2,
gsl_complex_rect(0,0),
&tmpout.vector);
// cout << "\n\n symbols (user " << u << ") = " << endl;
// gsl_vector_complex_fprintf(stdout,tmp,"%f");
#ifdef SHOW_MATRIX
cout << "\n\n symbols (user " << u << ") = " << endl;
gsl_vector_complex_fprintf(stdout,tmp,"%f");
cout << "\n\n precoded = " << endl;
gsl_vector_complex_fprintf(stdout,tmp1,"%f");
cout << "\n\n precoded selected = " << endl;
gsl_vector_complex_fprintf(stdout,tmp2,"%f");
cout << "\n\n precoded selected transformed = " << endl;
gsl_vector_complex_fprintf(stdout,&tmpout.vector,"%f");
#endif
} // close user loop
mout1.DeliverDataObj(*outmat);
}
