static void
make_herm(NCPROT QLA_ColorMatrix(*m), int idx, void *args)
{
QLA_Complex tr;
QLA_c_eq_r(tr, 0);
for(int i=0; i<QLA_Nc; i++) {
for(int j=i; j<QLA_Nc; j++) {
QLA_Complex t1, t2;
QLA_c_eq_c(t1, QLA_elem_M(*m,i,j));
QLA_c_eq_c(t2, QLA_elem_M(*m,j,i));
QLA_c_peq_ca(t1, t2);
QLA_c_eq_r_times_c(t1, 0.5, t1);
QLA_c_eq_c(QLA_elem_M(*m,i,j), t1);
QLA_c_eq_ca(QLA_elem_M(*m,j,i), t1);
}
QLA_c_peq_c(tr, QLA_elem_M(*m,i,i));
}
QLA_c_eq_r_times_c(tr, 1./QLA_Nc, tr);
for(int i=0; i<QLA_Nc; i++) {
QLA_c_meq_c(QLA_elem_M(*m,i,i), tr);
}
}
static double
q_CL_u_reader(int d, const int p[], int a, int b, int re_im, void *env)
{
QLA_D_Complex z;
QCArgs *args = env;
int i = QDP_index_L(args->lat, p);
if (p[d] == (args->lattice[d] - 1)) {
QLA_c_eq_c_times_c(z, args->bf[d], QLA_elem_M(args->uf[d][i], a, b));
} else {
QLA_c_eq_c(z, QLA_elem_M(args->uf[d][i], a, b));
}
if (re_im == 0)
return QLA_real(z);
else
return QLA_imag(z);
}
/*
* qcd.Clover(U, -- 1, {U0,U1,U2,U3}, a table of color matrices
* kappa, -- 2, double, the hopping parameter
* c_sw, -- 3, double, the clover term
* boundary) -- 4, {r/c, ...}, a table of boundary phases
*/
static int
q_clover(lua_State *L)
{
int i;
luaL_checktype(L, 1, LUA_TTABLE);
lua_pushnumber(L, 1);
lua_gettable(L, 1);
qlua_checkLatColMat3(L, -1, NULL, 3);
mLattice *S = qlua_ObjLattice(L, -1);
int Sidx = lua_gettop(L);
mClover *c = qlua_newClover(L, Sidx);
if (S->rank != QOP_CLOVER_DIM)
return luaL_error(L, "clover is not implemented for #L=%d", S->rank);
if (QDP_Ns != QOP_CLOVER_FERMION_DIM)
return luaL_error(L, "clover does not support Ns=%d", QDP_Ns);
QCArgs args;
luaL_checktype(L, 4, LUA_TTABLE);
for (i = 0; i < QOP_CLOVER_DIM; i++) {
lua_pushnumber(L, i + 1);
lua_gettable(L, 4);
switch (qlua_qtype(L, -1)) {
case qReal:
QLA_c_eq_r_plus_ir(args.bf[i], lua_tonumber(L, -1), 0);
break;
case qComplex:
QLA_c_eq_c(args.bf[i], *qlua_checkComplex(L, -1));
break;
default:
luaL_error(L, "bad clover boundary condition type");
}
lua_pop(L, 1);
}
double kappa = luaL_checknumber(L, 2);
double c_sw = luaL_checknumber(L, 3);
c->kappa = kappa;
c->c_sw = c_sw;
QDP_D3_ColorMatrix *UF[Nz];
luaL_checktype(L, 1, LUA_TTABLE);
CALL_QDP(L);
/* create a temporary F, and temp M */
for (i = QOP_CLOVER_DIM; i < Nz; i++)
UF[i] = QDP_D3_create_M_L(S->lat);
/* extract U from the arguments */
for (i = 0; i < QOP_CLOVER_DIM; i++) {
lua_pushnumber(L, i + 1); /* [sic] lua indexing */
lua_gettable(L, 1);
UF[i] = qlua_checkLatColMat3(L, -1, S, 3)->ptr;
lua_pop(L, 1);
}
int mu, nu;
QDP_Shift *neighbor = QDP_neighbor_L(S->lat);
CALL_QDP(L); /* just in case, because we touched LUA state above */
/* compute 8i*F[mu,nu] in UF[Nf...] */
for (i = 0, mu = 0; mu < QOP_CLOVER_DIM; mu++) {
for (nu = mu + 1; nu < QOP_CLOVER_DIM; nu++, i++) {
/* clover in [mu, nu] --> UF[Nu + i] */
QDP_D3_M_eq_sM(UF[Nt], UF[nu], neighbor[mu], QDP_forward,
S->all);
QDP_D3_M_eq_Ma_times_M(UF[Nt+1], UF[nu], UF[mu], S->all);
QDP_D3_M_eq_M_times_M(UF[Nt+2], UF[Nt+1], UF[Nt], S->all);
QDP_D3_M_eq_sM(UF[Nt+3], UF[Nt+2], neighbor[nu], QDP_backward,
S->all);
QDP_D3_M_eq_M_times_Ma(UF[Nt+4], UF[Nt+3], UF[mu], S->all);
QDP_D3_M_eq_sM(UF[Nt+1], UF[mu], neighbor[nu], QDP_forward,
S->all);
QDP_D3_M_eq_Ma_times_M(UF[Nt+5], UF[mu], UF[Nt+3], S->all);
QDP_D3_M_eq_M_times_Ma(UF[Nt+2], UF[Nt], UF[Nt+1], S->all);
QDP_D3_M_eq_M_times_Ma(UF[Nt+3], UF[Nt+2], UF[nu], S->all);
QDP_D3_M_peq_M_times_M(UF[Nt+4], UF[mu], UF[Nt+3], S->all);
QDP_D3_M_peq_M_times_M(UF[Nt+5], UF[Nt+3], UF[mu], S->all);
QDP_D3_M_eq_sM(UF[Nt+2], UF[Nt+5], neighbor[mu], QDP_backward,
S->all);
QDP_D3_M_peq_M(UF[Nt+4], UF[Nt+2], S->all);
QDP_D3_M_eq_M(UF[Nu+i], UF[Nt+4], S->all);
QDP_D3_M_meq_Ma(UF[Nu+i], UF[Nt+4], S->all);
}
}
args.lat = S->lat;
/* create the clover state */
QDP_latsize_L(S->lat, args.lattice);
struct QOP_CLOVER_Config cc;
cc.self = S->node;
cc.master_p = QMP_is_primary_node();
cc.rank = S->rank;
cc.lat = S->dim;
cc.net = S->net;
cc.neighbor_up = S->neighbor_up;
cc.neighbor_down = S->neighbor_down;
cc.sublattice = qlua_sublattice;
cc.env = S;
if (QOP_CLOVER_init(&c->state, &cc))
return luaL_error(L, "CLOVER_init() failed");
/* import the gauge field */
for (i = 0; i < Nt; i++) {
args.uf[i] = QDP_D3_expose_M(UF[i]);
}
if (QOP_CLOVER_import_gauge(&c->gauge, c->state, kappa, c_sw,
q_CL_u_reader, q_CL_f_reader, &args)) {
return luaL_error(L, "CLOVER_import_gauge() failed");
}
for (i = 0; i < Nt; i++)
QDP_D3_reset_M(UF[i]);
/* clean up temporaries */
for (i = QOP_CLOVER_DIM; i < Nz; i++)
QDP_D3_destroy_M(UF[i]);
return 1;
}
static void
hb_func(NCPROT1 QLA_ColorMatrix(*m), int site)
{
QLA_RandomState *srs = rs + site;
if(QLA_Nc==1) { // exp(-fac*Re[u*z]) = exp(-fac*|z|*cos(t))
// call Wensley heatbath
QLA_Complex cc;
QLA_Real r, phi, g, theta;
// *m contains r*exp(i*phi), extract r and phi
// extract QLA matrix element as complex number
QLA_c_eq_c(cc, QLA_elem_M(*m,0,0));
// get norm and arg
QLA_R_eq_norm_C( &r, &cc );
QLA_R_eq_arg_C( &phi, &cc );
g = fac*r;
// generate theta with probability P(theta)=exp( g*cos(theta) )
get_hb1( &theta, g, srs );
// convert to real and imag
//QLA_Real vr = cos( theta - phi );
//QLA_Real vi = sin( theta - phi );
// assemble QLA complex number and set QLA U(1) matrix to this
//QLA_c_eq_r_plus_i_r( QLA_elem_M(*m,0,0), vr, vi );
QLA_elem_M(*m,0,0) = QLAP(cexpi)(theta - phi);
} else {
QLA_ColorMatrix(s);
QLA_ColorMatrix(t);
QLA_ColorMatrix(tt);
QLA_Complex one;
QLA_c_eq_r(one, 1);
QLA_M_eq_c(&s, &one);
/* Loop over SU(2) subgroup index */
for(int i=0; i<QLA_Nc; i++) {
for(int j=i+1; j<QLA_Nc; j++) {
QLA_Real a[4], b[4], r[4], rn, rl;
su2_extract(NCARG r, m, i, j);
rn = sqrt( r[0]*r[0] + r[1]*r[1] + r[2]*r[2] + r[3]*r[3] );
rl = fac*rn;
if(rn<1e-10) {
a[0] = 1; a[1] = a[2] = a[3] = 0;
} else {
rn = 1/rn;
a[0] = rn*r[0];
a[1] = -rn*r[1];
a[2] = -rn*r[2];
a[3] = -rn*r[3];
}
get_hb2(b, rl, srs);
//b[0] = 1; b[1] = b[2] = b[3] = 0;
r[0] = b[0]*a[0] - b[1]*a[1] - b[2]*a[2] - b[3]*a[3];
r[1] = b[0]*a[1] + b[1]*a[0] - b[2]*a[3] + b[3]*a[2];
r[2] = b[0]*a[2] + b[2]*a[0] - b[3]*a[1] + b[1]*a[3];
r[3] = b[0]*a[3] + b[3]*a[0] - b[1]*a[2] + b[2]*a[1];
su2_fill(NCARG &t, r, i, j);
QLA_M_eq_M_times_M(&tt, &t, &s);
QLA_M_eq_M(&s, &tt);
QLA_M_eq_M_times_M(&tt, &t, m);
QLA_M_eq_M(m, &tt);
}
}
QLA_M_eq_M(m, &s);
}
}
