void sf_gauge_derivative(const int id, hamiltonian_field_t * const hf) {
int i, mu;
static su3 v, w;
su3 *z;
su3adj *xm;
monomial * mnl = &monomial_list[id];
printf ("hola");
if(mnl->use_rectangles) {
mnl->forcefactor = -mnl->c0 * g_beta/3.0;
}
else {
mnl->forcefactor = -1. * g_beta/3.0;
}
for(i = 0; i < VOLUME; i++) {
for(mu=0;mu<4;mu++) {
z=&hf->gaugefield[i][mu];
xm=&hf->derivative[i][mu];
v=get_staples(i,mu, hf->gaugefield);
_su3_times_su3d(w,*z,v);
_add_trace_lambda((*xm),w);
if(mnl->use_rectangles) {
get_rectangle_staples(&v, i, mu);
_su3_times_su3d(w, *z, v);
_mul_add_trace_lambda((*xm), w, mnl->c1/mnl->c0);
}
}
}
return;
}
void sf_gauge_derivative(const int id, hamiltonian_field_t * const hf) {
int i, mu;
static su3 v, w;
su3 *z;
su3adj *xm;
monomial * mnl = &monomial_list[id];
double factor = -1. * g_beta/3.0;
if(mnl->use_rectangles) {
factor = -mnl->c0 * g_beta/3.0;
}
for(i = 0; i < VOLUME; i++) {
for(mu=0;mu<4;mu++) {
z=&hf->gaugefield[i][mu];
xm=&hf->derivative[i][mu];
get_staples(&v,i,mu, (const su3**) hf->gaugefield);
_su3_times_su3d(w,*z,v);
_trace_lambda_mul_add_assign((*xm), factor, w);
if(mnl->use_rectangles) {
get_rectangle_staples(&v, i, mu);
_su3_times_su3d(w, *z, v);
_trace_lambda_mul_add_assign((*xm), factor*mnl->c1/mnl->c0, w);
}
}
}
return;
}
/* this function calculates the derivative of the momenta: equation 13 of Gottlieb */
void gauge_derivative(const int id, hamiltonian_field_t * const hf) {
monomial * mnl = &monomial_list[id];
double factor = -1. * g_beta/3.0;
if(mnl->use_rectangles) {
mnl->forcefactor = 1.;
factor = -mnl->c0 * g_beta/3.0;
}
double atime, etime;
atime = gettime();
#ifdef OMP
#pragma omp parallel
{
#endif
su3 ALIGN v, w;
int i, mu;
su3 *z;
su3adj *xm;
#ifdef OMP
#pragma omp for
#endif
for(i = 0; i < VOLUME; i++) {
for(mu=0;mu<4;mu++) {
z=&hf->gaugefield[i][mu];
xm=&hf->derivative[i][mu];
get_staples(&v,i,mu, (const su3**) hf->gaugefield);
_su3_times_su3d(w,*z,v);
_trace_lambda_mul_add_assign((*xm), factor, w);
if(mnl->use_rectangles) {
get_rectangle_staples(&v, i, mu);
_su3_times_su3d(w, *z, v);
_trace_lambda_mul_add_assign((*xm), factor*mnl->c1/mnl->c0, w);
}
}
}
#ifdef OMP
} /* OpenMP closing brace */
#endif
etime = gettime();
if(g_debug_level > 1 && g_proc_id == 0) {
printf("# Time for %s monomial derivative: %e s\n", mnl->name, etime-atime);
}
return;
}
void check_su3(su3 *in) {
su3 ans ;
_su3_times_su3d(ans,*in,*in);
printf("[ %f %f , %f %f , %f %f ] \n",
ans.c00.re,ans.c00.im,
ans.c01.re,ans.c01.im,
ans.c02.re,ans.c02.im ) ;
printf("[ %f %f , %f %f , %f %f ] \n",
ans.c10.re,ans.c10.im,
ans.c11.re,ans.c11.im,
ans.c12.re,ans.c12.im ) ;
printf("[ %f %f , %f %f , %f %f ] \n",
ans.c20.re,ans.c20.im,
ans.c21.re,ans.c21.im,
ans.c22.re,ans.c22.im ) ;
}
void apply_gtrafo (su3 ** gfield, su3 * trafofield) {
int it, iz, iy, ix;
int pos;
int mu;
su3 temp1;
if (g_proc_id == 0) {
printf("Applying gauge transformation...");
}
for (it = 0; it < T; it++) {
for (ix = 0; ix < LX; ix++) {
for (iy = 0; iy < LY; iy++) {
for (iz = 0; iz < LZ; iz++) {
#ifdef TM_USE_MPI // this is the MPI implementation of the GLOBAL TEMPORALGAUGE
pos = g_ipt[it][ix][iy][iz];
for (mu = 0; mu < 4; mu++) {
if ((it != T-1) || (mu != 0)) {
/* help = g(x) U_mu(x) */
_su3_times_su3( temp1, trafofield[pos], gfield[pos][mu] ); // temp1 = trafofield[pos] * gfield[pos][mu]
/* U_mu(x) <- U_mu^{'}(x) = help g^{+}(x+mu)*/
_su3_times_su3d( gfield[pos][mu],temp1, trafofield[ g_iup[pos][mu] ]); // gfield[pos][mu] = temp1 * trafofield[ g_iup[pos][mu] ] _ {dagger}
} // = trafofield[pos] * gfield[pos][mu] * trafofield[ g_iup[pos][mu] ]_{dagger}
else {
_su3_times_su3( temp1, trafofield[pos], gfield[pos][mu] );
_su3_times_su3d( gfield[pos][mu],temp1, right[ g_ipt[0][ix][iy][iz] ]); // "rightest" transf. matrices are stored in right[]
}
}
#else // in case of using this version with MPI this is
// a LOCAL version of TEMPORALGAUGE
pos = g_ipt[it][ix][iy][iz];
for (mu = 0; mu < 4; mu++) {
if ((it != T-1) || (mu != 0)) {
/* help = g(x) U_mu(x) */
_su3_times_su3( temp1, trafofield[pos], gfield[pos][mu] );
/* U_mu(x) <- U_mu^{'}(x) = help g^{+}(x+mu)*/
_su3_times_su3d( gfield[pos][mu],temp1, trafofield[ g_iup[pos][mu] ]);
}
else { // (it = T-1) && (mu = 0)
_su3_times_su3( temp1, trafofield[pos], gfield[pos][mu] );
_su3_times_su3d( gfield[pos][mu],temp1, trafofield[ g_ipt[0][ix][iy][iz] ]); // "rightest" transf. matrices are the first (periodic) and are initialized to ID
}
}
#endif
}
}
}
}
if (g_proc_id == 0) {
printf("done\n");
}
/* update gauge copy fields in the next call to HoppingMatrix */
g_update_gauge_copy = 1;
}//apply_gtrafo()
void deriv_Sb_D_psi(spinor * const l, spinor * const k,
hamiltonian_field_t * const hf, const double factor) {
#ifdef BGL
__alignx(16, l);
__alignx(16, k);
#endif
/* for parallelization */
#ifdef MPI
xchange_lexicfield(k);
xchange_lexicfield(l);
#endif
#ifdef OMP
#define static
#pragma omp parallel
{
#endif
int ix,iy;
su3 * restrict up ALIGN;
su3 * restrict um ALIGN;
static su3 v1,v2;
static su3_vector psia,psib,phia,phib;
static spinor rr;
/* spinor * restrict r ALIGN; */
spinor * restrict sp ALIGN;
spinor * restrict sm ALIGN;
#ifdef OMP
#undef static
#endif
#ifdef _KOJAK_INST
#pragma pomp inst begin(derivSb)
#endif
#ifdef XLC
#pragma disjoint(*sp, *sm, *up, *um)
#endif
/************** loop over all lattice sites ****************/
#ifdef OMP
#pragma omp for
#endif
for(ix = 0; ix < (VOLUME); ix++){
rr = (*(l + ix));
/* rr=g_spinor_field[l][icx-ioff]; */
/*multiply the left vector with gamma5*/
_vector_minus_assign(rr.s2, rr.s2);
_vector_minus_assign(rr.s3, rr.s3);
/*********************** direction +0 ********************/
iy=g_iup[ix][0];
sp = k + iy;
up=&hf->gaugefield[ix][0];
_vector_add(psia,(*sp).s0,(*sp).s2);
_vector_add(psib,(*sp).s1,(*sp).s3);
_vector_add(phia,rr.s0,rr.s2);
_vector_add(phib,rr.s1,rr.s3);
_vector_tensor_vector_add(v1, phia, psia, phib, psib);
_su3_times_su3d(v2,*up,v1);
_complex_times_su3(v1,ka0,v2);
_trace_lambda_mul_add_assign_nonlocal(hf->derivative[ix][0], 2.*factor, v1);
/************** direction -0 ****************************/
iy=g_idn[ix][0];
sm = k + iy;
um=&hf->gaugefield[iy][0];
_vector_sub(psia,(*sm).s0,(*sm).s2);
_vector_sub(psib,(*sm).s1,(*sm).s3);
_vector_sub(phia,rr.s0,rr.s2);
_vector_sub(phib,rr.s1,rr.s3);
_vector_tensor_vector_add(v1, psia, phia, psib, phib);
_su3_times_su3d(v2,*um,v1);
_complex_times_su3(v1,ka0,v2);
_trace_lambda_mul_add_assign_nonlocal(hf->derivative[iy][0], 2.*factor, v1);
/*************** direction +1 **************************/
iy=g_iup[ix][1];
sp = k + iy;
up=&hf->gaugefield[ix][1];
_vector_i_add(psia,(*sp).s0,(*sp).s3);
_vector_i_add(psib,(*sp).s1,(*sp).s2);
_vector_i_add(phia,rr.s0,rr.s3);
_vector_i_add(phib,rr.s1,rr.s2);
_vector_tensor_vector_add(v1, phia, psia, phib, psib);
_su3_times_su3d(v2,*up,v1);
_complex_times_su3(v1,ka1,v2);
_trace_lambda_mul_add_assign_nonlocal(hf->derivative[ix][1], 2.*factor, v1);
/**************** direction -1 *************************/
iy=g_idn[ix][1];
sm = k + iy;
um=&hf->gaugefield[iy][1];
_vector_i_sub(psia,(*sm).s0,(*sm).s3);
_vector_i_sub(psib,(*sm).s1,(*sm).s2);
_vector_i_sub(phia,rr.s0,rr.s3);
_vector_i_sub(phib,rr.s1,rr.s2);
_vector_tensor_vector_add(v1, psia, phia, psib, phib);
_su3_times_su3d(v2,*um,v1);
_complex_times_su3(v1,ka1,v2);
_trace_lambda_mul_add_assign_nonlocal(hf->derivative[iy][1], 2.*factor, v1);
/*************** direction +2 **************************/
iy=g_iup[ix][2];
sp = k + iy;
up=&hf->gaugefield[ix][2];
_vector_add(psia,(*sp).s0,(*sp).s3);
_vector_sub(psib,(*sp).s1,(*sp).s2);
_vector_add(phia,rr.s0,rr.s3);
_vector_sub(phib,rr.s1,rr.s2);
_vector_tensor_vector_add(v1, phia, psia, phib, psib);
_su3_times_su3d(v2,*up,v1);
_complex_times_su3(v1,ka2,v2);
_trace_lambda_mul_add_assign_nonlocal(hf->derivative[ix][2], 2.*factor, v1);
/***************** direction -2 ************************/
iy=g_idn[ix][2];
sm = k + iy;
um=&hf->gaugefield[iy][2];
_vector_sub(psia,(*sm).s0,(*sm).s3);
_vector_add(psib,(*sm).s1,(*sm).s2);
_vector_sub(phia,rr.s0,rr.s3);
_vector_add(phib,rr.s1,rr.s2);
_vector_tensor_vector_add(v1, psia, phia, psib, phib);
_su3_times_su3d(v2,*um,v1);
_complex_times_su3(v1,ka2,v2);
_trace_lambda_mul_add_assign_nonlocal(hf->derivative[iy][2], 2.*factor, v1);
/****************** direction +3 ***********************/
iy=g_iup[ix][3];
sp = k + iy;
up=&hf->gaugefield[ix][3];
_vector_i_add(psia,(*sp).s0,(*sp).s2);
_vector_i_sub(psib,(*sp).s1,(*sp).s3);
_vector_i_add(phia,rr.s0,rr.s2);
_vector_i_sub(phib,rr.s1,rr.s3);
_vector_tensor_vector_add(v1, phia, psia, phib, psib);
_su3_times_su3d(v2,*up,v1);
_complex_times_su3(v1,ka3,v2);
_trace_lambda_mul_add_assign_nonlocal(hf->derivative[ix][3], 2.*factor, v1);
/***************** direction -3 ************************/
iy=g_idn[ix][3];
sm = k + iy;
um=&hf->gaugefield[iy][3];
_vector_i_sub(psia,(*sm).s0,(*sm).s2);
_vector_i_add(psib,(*sm).s1,(*sm).s3);
_vector_i_sub(phia,rr.s0,rr.s2);
_vector_i_add(phib,rr.s1,rr.s3);
_vector_tensor_vector_add(v1, psia, phia, psib, phib);
_su3_times_su3d(v2,*um,v1);
_complex_times_su3(v1,ka3,v2);
_trace_lambda_mul_add_assign_nonlocal(hf->derivative[iy][3], 2.*factor, v1);
/****************** end of loop ************************/
}
#ifdef _KOJAK_INST
#pragma pomp inst end(derivSb)
#endif
#ifdef OMP
} /*OpenMP closing brace */
#endif
}
/* Method based on Givens' rotations, as used by Urs Wenger */
void reunitarize(su3 *omega)
{
static su3 w, rot, tmp;
static double trace_old, trace_new;
static _Complex double s0, s1;
static double scale;
_su3_one(w);
trace_old = omega->c00 + omega->c11 + omega->c22;
for (int iter = 0; iter < 200; ++iter)
{
/* Givens' rotation 01 */
s0 = omega->c00 + conj(omega->c11);
s1 = omega->c01 - conj(omega->c10);
scale = 1.0 / sqrt(conj(s0) * s0 + conj(s1) * s1);
s0 *= scale;
s1 *= scale;
/* Projecting */
_su3_one(rot);
rot.c00 = s0;
rot.c11 = conj(s0);
rot.c01 = s1;
rot.c10 = -conj(s1);
_su3_times_su3(tmp, rot, w);
_su3_assign(w, tmp);
_su3_times_su3d(tmp, *omega, rot);
_su3_assign(*omega, tmp);
/* Givens' rotation 12 */
s0 = omega->c11 + conj(omega->c22);
s1 = omega->c12 - conj(omega->c21);
scale = 1.0 / sqrt(conj(s0) * s0 + conj(s1) * s1);
s0 *= scale;
s1 *= scale;
/* Projecting */
_su3_one(rot);
rot.c11 = s0;
rot.c22 = conj(s0);
rot.c12 = s1;
rot.c21 = -conj(s1);
_su3_times_su3(tmp, rot, w);
_su3_assign(w, tmp);
_su3_times_su3d(tmp, *omega, rot);
_su3_assign(*omega, tmp);
/* Givens' rotation 20 */
s0 = omega->c22 + conj(omega->c00);
s1 = omega->c20 - conj(omega->c02);
scale = 1.0 / sqrt(conj(s0) * s0 + conj(s1) * s1);
s0 *= scale;
s1 *= scale;
/* Projecting */
_su3_one(rot);
rot.c22 = s0;
rot.c00 = conj(s0);
rot.c20 = s1;
rot.c02 = -conj(s1);
_su3_times_su3(tmp, rot, w);
_su3_assign(w, tmp);
_su3_times_su3d(tmp, *omega, rot);
_su3_assign(*omega, tmp);
trace_new = omega->c00 + omega->c11 + omega->c22;
if (trace_new - trace_old < 1e-15)
break;
trace_old = trace_new;
}
_su3_assign(*omega, w);
}
void sw_term(su3 ** const gf, const double kappa, const double c_sw) {
int k,l;
int x,xpk,xpl,xmk,xml,xpkml,xplmk,xmkml;
su3 *w1,*w2,*w3,*w4;
double ka_csw_8 = kappa*c_sw/8.;
static su3 v1,v2,plaq;
static su3 fkl[4][4];
static su3 magnetic[4],electric[4];
static su3 aux;
/* compute the clover-leave */
/* l __ __
| | | |
|__| |__|
__ __
| | | |
|__| |__| k */
for(x = 0; x < VOLUME; x++) {
for(k = 0; k < 4; k++) {
for(l = k+1; l < 4; l++) {
xpk=g_iup[x][k];
xpl=g_iup[x][l];
xmk=g_idn[x][k];
xml=g_idn[x][l];
xpkml=g_idn[xpk][l];
xplmk=g_idn[xpl][k];
xmkml=g_idn[xml][k];
w1=&gf[x][k];
w2=&gf[xpk][l];
w3=&gf[xpl][k];
w4=&gf[x][l];
_su3_times_su3(v1,*w1,*w2);
_su3_times_su3(v2,*w4,*w3);
_su3_times_su3d(plaq,v1,v2);
w1=&gf[x][l];
w2=&gf[xplmk][k];
w3=&gf[xmk][l];
w4=&gf[xmk][k];
_su3_times_su3d(v1,*w1,*w2);
_su3d_times_su3(v2,*w3,*w4);
_su3_times_su3_acc(plaq,v1,v2);
w1=&gf[xmk][k];
w2=&gf[xmkml][l];
w3=&gf[xmkml][k];
w4=&gf[xml][l];
_su3_times_su3(v1,*w2,*w1);
_su3_times_su3(v2,*w3,*w4);
_su3d_times_su3_acc(plaq,v1,v2);
w1=&gf[xml][l];
w2=&gf[xml][k];
w3=&gf[xpkml][l];
w4=&gf[x][k];
_su3d_times_su3(v1,*w1,*w2);
_su3_times_su3d(v2,*w3,*w4);
_su3_times_su3_acc(plaq,v1,v2);
_su3_dagger(v2,plaq);
_su3_minus_su3(fkl[k][l],plaq,v2);
}
}
// this is the one in flavour and colour space
// twisted mass term is treated in clover, sw_inv and
// clover_gamma5
_su3_one(sw[x][0][0]);
_su3_one(sw[x][2][0]);
_su3_one(sw[x][0][1]);
_su3_one(sw[x][2][1]);
for(k = 1; k < 4; k++)
{
_su3_assign(electric[k], fkl[0][k]);
}
_su3_assign(magnetic[1], fkl[2][3]);
_su3_minus_assign(magnetic[2], fkl[1][3]);
_su3_assign(magnetic[3], fkl[1][2]);
/* upper left block 6x6 matrix */
_itimes_su3_minus_su3(aux,electric[3],magnetic[3]);
_su3_refac_acc(sw[x][0][0],ka_csw_8,aux);
_itimes_su3_minus_su3(aux,electric[1],magnetic[1]);
_su3_minus_su3(v2,electric[2],magnetic[2]);
_su3_acc(aux,v2);
_real_times_su3(sw[x][1][0],ka_csw_8,aux);
_itimes_su3_minus_su3(aux,magnetic[3],electric[3]);
_su3_refac_acc(sw[x][2][0],ka_csw_8,aux);
/* lower right block 6x6 matrix */
_itimes_su3_plus_su3(aux,electric[3],magnetic[3]);
_su3_refac_acc(sw[x][0][1],(-ka_csw_8),aux);
_itimes_su3_plus_su3(aux,electric[1],magnetic[1]);
_su3_plus_su3(v2,electric[2],magnetic[2]);
_su3_acc(aux,v2);
_real_times_su3(sw[x][1][1],(-ka_csw_8),aux);
_itimes_su3_plus_su3(aux,magnetic[3],electric[3]);
_su3_refac_acc(sw[x][2][1],ka_csw_8,aux);
}
return;
}
void sw_all(hamiltonian_field_t * const hf, const double kappa,
const double c_sw) {
int k,l;
int x,xpk,xpl,xmk,xml,xpkml,xplmk,xmkml;
su3 *w1,*w2,*w3,*w4;
double ka_csw_8 = kappa*c_sw/8.;
static su3 v1,v2,vv1,vv2,plaq;
static su3 vis[4][4];
for(x = 0; x < VOLUME; x++) {
_minus_itimes_su3_plus_su3(vis[0][1],swm[x][1],swm[x][3]);
_su3_minus_su3(vis[0][2],swm[x][1],swm[x][3]);
_itimes_su3_minus_su3(vis[0][3],swm[x][2],swm[x][0]);
_minus_itimes_su3_plus_su3(vis[2][3],swp[x][1],swp[x][3]);
_su3_minus_su3(vis[1][3],swp[x][3],swp[x][1]);
_itimes_su3_minus_su3(vis[1][2],swp[x][2],swp[x][0]);
// project to the traceless anti-hermitian part
_su3_dagger(v1,vis[0][1]);
_su3_minus_su3(vis[0][1],vis[0][1],v1);
_su3_dagger(v1,vis[0][2]);
_su3_minus_su3(vis[0][2],vis[0][2],v1);
_su3_dagger(v1,vis[0][3]);
_su3_minus_su3(vis[0][3],vis[0][3],v1);
_su3_dagger(v1,vis[2][3]);
_su3_minus_su3(vis[2][3],vis[2][3],v1);
_su3_dagger(v1,vis[1][3]);
_su3_minus_su3(vis[1][3],vis[1][3],v1);
_su3_dagger(v1,vis[1][2]);
_su3_minus_su3(vis[1][2],vis[1][2],v1);
for(k = 0; k < 4; k++) {
for(l = k+1; l < 4; l++) {
xpk=g_iup[x][k];
xpl=g_iup[x][l];
xmk=g_idn[x][k];
xml=g_idn[x][l];
xpkml=g_idn[xpk][l];
xplmk=g_idn[xpl][k];
xmkml=g_idn[xml][k];
w1=&hf->gaugefield[x][k];
w2=&hf->gaugefield[xpk][l];
w3=&hf->gaugefield[xpl][k]; /*dag*/
w4=&hf->gaugefield[x][l]; /*dag*/
_su3_times_su3(v1,*w1,*w2);
_su3_times_su3(v2,*w4,*w3);
_su3_times_su3d(plaq,v1,v2);
_su3_times_su3(vv1,plaq,vis[k][l]);
_trace_lambda_mul_add_assign(hf->derivative[x][k], -2.*ka_csw_8, vv1);
_su3d_times_su3(vv2,*w1,vv1);
_su3_times_su3(vv1,vv2,*w1);
_trace_lambda_mul_add_assign(hf->derivative[xpk][l], -2.*ka_csw_8, vv1);
_su3_times_su3(vv2,vis[k][l],plaq);
_su3_dagger(vv1,vv2);
_trace_lambda_mul_add_assign(hf->derivative[x][l], -2.*ka_csw_8, vv1);
_su3d_times_su3(vv2,*w4,vv1);
_su3_times_su3(vv1,vv2,*w4);
_trace_lambda_mul_add_assign(hf->derivative[xpl][k], -2.*ka_csw_8, vv1);
w1=&hf->gaugefield[x][l];
w2=&hf->gaugefield[xplmk][k]; /*dag*/
w3=&hf->gaugefield[xmk][l]; /*dag*/
w4=&hf->gaugefield[xmk][k];
_su3_times_su3d(v1,*w1,*w2);
_su3d_times_su3(v2,*w3,*w4);
_su3_times_su3(plaq,v1,v2);
_su3_times_su3(vv1,plaq,vis[k][l]);
_trace_lambda_mul_add_assign(hf->derivative[x][l], -2.*ka_csw_8, vv1);
_su3_dagger(vv1,v1);
_su3_times_su3d(vv2,vv1,vis[k][l]);
_su3_times_su3d(vv1,vv2,v2);
_trace_lambda_mul_add_assign(hf->derivative[xplmk][k], -2.*ka_csw_8, vv1);
_su3_times_su3(vv2,*w3,vv1);
_su3_times_su3d(vv1,vv2,*w3);
_trace_lambda_mul_add_assign(hf->derivative[xmk][l], -2.*ka_csw_8, vv1);
_su3_dagger(vv2,vv1);
_trace_lambda_mul_add_assign(hf->derivative[xmk][k], -2.*ka_csw_8, vv2);
w1=&hf->gaugefield[xmk][k]; /*dag*/
w2=&hf->gaugefield[xmkml][l]; /*dag*/
w3=&hf->gaugefield[xmkml][k];
w4=&hf->gaugefield[xml][l];
_su3_times_su3(v1,*w2,*w1);
_su3_times_su3(v2,*w3,*w4);
_su3_times_su3d(vv1,*w1,vis[k][l]);
_su3_times_su3d(vv2,vv1,v2);
_su3_times_su3(vv1,vv2,*w2);
_trace_lambda_mul_add_assign(hf->derivative[xmk][k], -2.*ka_csw_8, vv1);
_su3_times_su3(vv2,*w2,vv1);
_su3_times_su3d(vv1,vv2,*w2);
_trace_lambda_mul_add_assign(hf->derivative[xmkml][l], -2.*ka_csw_8, vv1);
_su3_dagger(vv2,vv1);
_trace_lambda_mul_add_assign(hf->derivative[xmkml][k], -2.*ka_csw_8, vv2);
_su3d_times_su3(vv1,*w3,vv2);
_su3_times_su3(vv2,vv1,*w3);
_trace_lambda_mul_add_assign(hf->derivative[xml][l], -2.*ka_csw_8, vv2);
w1=&hf->gaugefield[xml][l]; /*dag*/
w2=&hf->gaugefield[xml][k];
w3=&hf->gaugefield[xpkml][l];
w4=&hf->gaugefield[x][k]; /*dag*/
_su3d_times_su3(v1,*w1,*w2);
_su3_times_su3d(v2,*w3,*w4);
_su3_times_su3d(vv1,*w1,vis[k][l]);
_su3_times_su3d(vv2,vv1,v2);
_su3_times_su3d(vv1,vv2,*w2);
_trace_lambda_mul_add_assign(hf->derivative[xml][l], -2.*ka_csw_8, vv1);
_su3_dagger(vv2,vv1);
_trace_lambda_mul_add_assign(hf->derivative[xml][k], -2.*ka_csw_8, vv2);
_su3d_times_su3(vv1,*w2,vv2);
_su3_times_su3(vv2,vv1,*w2);
_trace_lambda_mul_add_assign(hf->derivative[xpkml][l], -2.*ka_csw_8, vv2);
_su3_dagger(vv2,v2);
_su3_times_su3d(vv1,vv2,v1);
_su3_times_su3d(vv2,vv1,vis[k][l]);
_trace_lambda_mul_add_assign(hf->derivative[x][k], -2.*ka_csw_8, vv2);
}
}
}
return;
}
void deriv_Sb_D_psi(spinor * const l, spinor * const k) {
/* const int l, const int k){ */
int ix,iy;
su3 * restrict up ALIGN;
su3 * restrict um ALIGN;
/* su3adj * restrict ddd; */
/* static su3adj der; */
static su3 v1,v2;
static su3_vector psia,psib,phia,phib;
static spinor rr;
/* spinor * restrict r ALIGN; */
spinor * restrict sp ALIGN;
spinor * restrict sm ALIGN;
#ifdef _KOJAK_INST
#pragma pomp inst begin(derivSb)
#endif
#ifdef XLC
#pragma disjoint(*sp, *sm, *up, *um)
#endif
#ifdef BGL
__alignx(16, l);
__alignx(16, k);
#endif
/* for parallelization */
#ifdef MPI
xchange_lexicfield(k);
xchange_lexicfield(l);
#endif
/************** loop over all lattice sites ****************/
for(ix = 0; ix < (VOLUME); ix++){
rr = (*(l + ix));
/* rr=g_spinor_field[l][icx-ioff]; */
/*multiply the left vector with gamma5*/
_vector_minus_assign(rr.s2, rr.s2);
_vector_minus_assign(rr.s3, rr.s3);
/*********************** direction +0 ********************/
iy=g_iup[ix][0];
sp = k + iy;
/* sp=&g_spinor_field[k][icy]; */
up=&g_gauge_field[ix][0];
_vector_add(psia,(*sp).s0,(*sp).s2);
_vector_add(psib,(*sp).s1,(*sp).s3);
_vector_add(phia,rr.s0,rr.s2);
_vector_add(phib,rr.s1,rr.s3);
_vector_tensor_vector_add(v1, phia, psia, phib, psib);
/* _vector_tensor_vector(v1,phia,psia); */
/* _vector_tensor_vector(v2,phib,psib); */
/* _su3_plus_su3(v1,v1,v2); */
_su3_times_su3d(v2,*up,v1);
_complex_times_su3(v1,ka0,v2);
_trace_lambda_add_assign(df0[ix][0], v1);
/* _trace_lambda(der,v1); */
/* ddd=&df0[ix][0]; */
/* _add_su3adj(*ddd,der); */
/************** direction -0 ****************************/
iy=g_idn[ix][0];
sm = k + iy;
/* sm=&g_spinor_field[k][icy]; */
um=&g_gauge_field[iy][0];
_vector_sub(psia,(*sm).s0,(*sm).s2);
_vector_sub(psib,(*sm).s1,(*sm).s3);
_vector_sub(phia,rr.s0,rr.s2);
_vector_sub(phib,rr.s1,rr.s3);
_vector_tensor_vector_add(v1, psia, phia, psib, phib);
/* _vector_tensor_vector(v1,psia,phia); */
/* _vector_tensor_vector(v2,psib,phib); */
/* _su3_plus_su3(v1,v1,v2); */
_su3_times_su3d(v2,*um,v1);
_complex_times_su3(v1,ka0,v2);
_trace_lambda_add_assign(df0[iy][0], v1);
/* _trace_lambda(der,v1); */
/* ddd=&df0[iy][0]; */
/* _add_su3adj(*ddd,der); */
/*************** direction +1 **************************/
iy=g_iup[ix][1];
sp = k + iy;
/* sp=&g_spinor_field[k][icy]; */
up=&g_gauge_field[ix][1];
_vector_i_add(psia,(*sp).s0,(*sp).s3);
_vector_i_add(psib,(*sp).s1,(*sp).s2);
_vector_i_add(phia,rr.s0,rr.s3);
_vector_i_add(phib,rr.s1,rr.s2);
_vector_tensor_vector_add(v1, phia, psia, phib, psib);
/* _vector_tensor_vector(v1,phia,psia); */
/* _vector_tensor_vector(v2,phib,psib); */
/* _su3_plus_su3(v1,v1,v2); */
_su3_times_su3d(v2,*up,v1);
_complex_times_su3(v1,ka1,v2);
_trace_lambda_add_assign(df0[ix][1], v1);
/* _trace_lambda(der,v1); */
/* ddd=&df0[ix][1]; */
/* _add_su3adj(*ddd,der); */
/**************** direction -1 *************************/
iy=g_idn[ix][1];
sm = k + iy;
/* sm=&g_spinor_field[k][icy]; */
um=&g_gauge_field[iy][1];
_vector_i_sub(psia,(*sm).s0,(*sm).s3);
_vector_i_sub(psib,(*sm).s1,(*sm).s2);
_vector_i_sub(phia,rr.s0,rr.s3);
_vector_i_sub(phib,rr.s1,rr.s2);
_vector_tensor_vector_add(v1, psia, phia, psib, phib);
/* _vector_tensor_vector(v1,psia,phia); */
/* _vector_tensor_vector(v2,psib,phib); */
/* _su3_plus_su3(v1,v1,v2); */
_su3_times_su3d(v2,*um,v1);
_complex_times_su3(v1,ka1,v2);
_trace_lambda_add_assign(df0[iy][1], v1);
/* _trace_lambda(der,v1); */
/* ddd=&df0[iy][1]; */
/* _add_su3adj(*ddd,der); */
/*************** direction +2 **************************/
iy=g_iup[ix][2];
sp = k + iy;
/* sp=&g_spinor_field[k][icy]; */
up=&g_gauge_field[ix][2];
_vector_add(psia,(*sp).s0,(*sp).s3);
_vector_sub(psib,(*sp).s1,(*sp).s2);
_vector_add(phia,rr.s0,rr.s3);
_vector_sub(phib,rr.s1,rr.s2);
_vector_tensor_vector_add(v1, phia, psia, phib, psib);
/* _vector_tensor_vector(v1,phia,psia); */
/* _vector_tensor_vector(v2,phib,psib); */
/* _su3_plus_su3(v1,v1,v2); */
_su3_times_su3d(v2,*up,v1);
_complex_times_su3(v1,ka2,v2);
_trace_lambda_add_assign(df0[ix][2], v1);
/* _trace_lambda(der,v1); */
/* ddd=&df0[ix][2]; */
/* _add_su3adj(*ddd,der); */
/***************** direction -2 ************************/
iy=g_idn[ix][2];
sm = k + iy;
/* sm=&g_spinor_field[k][icy]; */
um=&g_gauge_field[iy][2];
_vector_sub(psia,(*sm).s0,(*sm).s3);
_vector_add(psib,(*sm).s1,(*sm).s2);
_vector_sub(phia,rr.s0,rr.s3);
_vector_add(phib,rr.s1,rr.s2);
_vector_tensor_vector_add(v1, psia, phia, psib, phib);
/* _vector_tensor_vector(v1,psia,phia); */
/* _vector_tensor_vector(v2,psib,phib); */
/* _su3_plus_su3(v1,v1,v2); */
_su3_times_su3d(v2,*um,v1);
_complex_times_su3(v1,ka2,v2);
_trace_lambda_add_assign(df0[iy][2], v1);
/* _trace_lambda(der,v1); */
/* ddd=&df0[iy][2]; */
/* _add_su3adj(*ddd,der); */
/****************** direction +3 ***********************/
iy=g_iup[ix][3];
sp = k + iy;
/* sp=&g_spinor_field[k][icy]; */
up=&g_gauge_field[ix][3];
_vector_i_add(psia,(*sp).s0,(*sp).s2);
_vector_i_sub(psib,(*sp).s1,(*sp).s3);
_vector_i_add(phia,rr.s0,rr.s2);
_vector_i_sub(phib,rr.s1,rr.s3);
_vector_tensor_vector_add(v1, phia, psia, phib, psib);
/* _vector_tensor_vector(v1,phia,psia); */
/* _vector_tensor_vector(v2,phib,psib); */
/* _su3_plus_su3(v1,v1,v2); */
_su3_times_su3d(v2,*up,v1);
_complex_times_su3(v1,ka3,v2);
_trace_lambda_add_assign(df0[ix][3], v1);
/* _trace_lambda(der,v1); */
/* ddd=&df0[ix][3]; */
/* _add_su3adj(*ddd,der); */
/***************** direction -3 ************************/
iy=g_idn[ix][3];
sm = k + iy;
/* sm=&g_spinor_field[k][icy]; */
um=&g_gauge_field[iy][3];
_vector_i_sub(psia,(*sm).s0,(*sm).s2);
_vector_i_add(psib,(*sm).s1,(*sm).s3);
_vector_i_sub(phia,rr.s0,rr.s2);
_vector_i_add(phib,rr.s1,rr.s3);
_vector_tensor_vector_add(v1, psia, phia, psib, phib);
/* _vector_tensor_vector(v1,psia,phia); */
/* _vector_tensor_vector(v2,psib,phib); */
/* _su3_plus_su3(v1,v1,v2); */
_su3_times_su3d(v2,*um,v1);
_complex_times_su3(v1,ka3,v2);
_trace_lambda_add_assign(df0[iy][3], v1);
/* _trace_lambda(der,v1); */
/* ddd=&df0[iy][3]; */
/* _add_su3adj(*ddd,der); */
/****************** end of loop ************************/
}
#ifdef _KOJAK_INST
#pragma pomp inst end(derivSb)
#endif
}
void flip_subgroup(int ix, int mu, su3 vv, int i){
static double vv0,vv1,vv2,vv3,aa0,aa1,aa2,aa3;
static double aux,norm_vv_sq;
static su3 a,w,v;
su3 *z;
_su3_assign(v,vv);
_su3_one(a);
z=&g_gauge_field[ix][mu];
_su3_times_su3d(w,*z,v);
/*
According to Peter's notes ``A Cabibbo-Marinari SU(3)....", eqs. (A.14-A.17)
we have */
if(i==1)
{
vv0 = creal(w.c00) + creal(w.c11);
vv3 = -cimag(w.c00) + cimag(w.c11);
vv1 = -cimag(w.c01) - cimag(w.c10);
vv2 = -creal(w.c01) + creal(w.c10);
}
else if(i==2)
{
vv0 = creal(w.c00) + creal(w.c22);
vv3 = -cimag(w.c00) + cimag(w.c22);
vv1 = -cimag(w.c02) - cimag(w.c20);
vv2 = -creal(w.c02) + creal(w.c20);
}
else
{
vv0 = creal(w.c11) + creal(w.c22);
vv3 = -cimag(w.c11) + cimag(w.c22);
vv1 = -cimag(w.c12) - cimag(w.c21);
vv2 = -creal(w.c12) + creal(w.c21);
}
norm_vv_sq= vv0 * vv0 + vv1 * vv1 + vv2 * vv2 + vv3 * vv3;
aux= 2.0 * vv0 / norm_vv_sq;
aa0 = aux * vv0-1.0;
aa1 = aux * vv1;
aa2 = aux * vv2;
aa3 = aux * vv3;
/* aa is embedded in the SU(3) matrix (a) which can be multiplied on
the link variable using the su3_type operator * . */
if(i==1)
{
a.c00 = aa0 + aa3 * I;
a.c11 = conj(a.c00);
a.c01 = aa2 + aa1 * I;
a.c10 = -conj(a.c01);
}
else if(i==2)
{
a.c00 = aa0 + aa3 * I;
a.c22 = conj(a.c00);
a.c02 = aa2 + aa1 * I;
a.c20 = -conj(a.c02);
}
else
{
a.c11 = aa0 + aa3 * I;
a.c22 = conj(a.c11);
a.c12 = aa2 + aa1 * I;
a.c21 = -conj(a.c12);
}
_su3_times_su3(w,a,*z);
*z=w;
}
int stout_smear_gauge_field(const double rho , const int no_iters) {
const int dim=4 ;
int iter , mu , x;
su3 *gauge_wk[4] ;
su3 wk_staple ;
su3 omega , Exp_p ;
su3adj p;
su3 *gauge_local ;
su3 new_gauge_local ;
/*printf("Entering stout_smear_gauge_field\n");*/
if(g_proc_id == 0 && g_debug_level > 3) {
printf("DUMP OF g_gauge_field in STOUT\n");
print_config_to_screen(g_gauge_field);
printf("STOUT smearing the gauge fields\n") ;
printf("rho = %g number of iterations = %d\n",rho,no_iters) ;
}
/* reserve memory */
for(mu = 0 ; mu < dim ; ++mu) {
gauge_wk[mu] = calloc(VOLUME, sizeof(su3));
if(errno == ENOMEM) {
return(1);
}
}
/* start of the the stout smearing **/
for(iter = 0 ; iter < no_iters ; ++iter) {
for(mu = 0 ; mu < dim ; ++mu) {
for(x= 0 ; x < VOLUME ; x++) {
/*
* we need to save all intermediate gauge configurations
* because they are needed for the force back iteration in
* "stout_smear_force.c"
*/
/*_su3_assign(g_gauge_field_smear_iterations[iter][x][mu], g_gauge_field[x][mu]);*/
/* get staples */
wk_staple = get_staples(x, mu, g_gauge_field) ;
scale_su3(&wk_staple, rho) ;
/* omega = staple * u^dagger */
gauge_local = &g_gauge_field[x][mu];
_su3_times_su3d(omega,wk_staple,*gauge_local);
/* project out anti-hermitian traceless part */
project_anti_herm(&omega) ;
/* exponentiate */
_trace_lambda(p,omega) ;
/* -2.0 to get su3 to su3adjoint consistency ****/
p.d1 /= -2.0 ; p.d2 /= -2.0 ; p.d3 /= -2.0 ; p.d4 /= -2.0 ;
p.d5 /= -2.0 ; p.d6 /= -2.0 ; p.d7 /= -2.0 ; p.d8 /= -2.0 ;
Exp_p = exposu3(p);
/* new_gauge_local = Exp_p * gauge_local */
_su3_times_su3(new_gauge_local,Exp_p,*gauge_local);
gauge_wk[mu][x] = new_gauge_local ;
} /* end the loop over space-time */
}
/** update gauge field on this node **/
for(mu = 0 ; mu < dim ; ++mu) {
for(x= 0 ; x < VOLUME ; ++x) {
g_gauge_field[x][mu] = gauge_wk[mu][x] ;
}
}
if(g_debug_level > 3 && g_proc_id == 0) {
printf("DUMP OF g_gauge_field in STOUT\n");
print_config_to_screen(g_gauge_field);
}
#ifdef MPI
/** update boundaries for parallel stuff **/
xchange_gauge();
#endif
g_update_gauge_copy = 1;
g_update_gauge_energy = 1;
g_update_rectangle_energy = 1;
/*
* here we save the intermediate smeares gauge fields a large array
*/
} /* end loop over stout smearing iterations */
/* free up memory */
for(mu=0 ; mu < dim ; ++mu) {
free(gauge_wk[mu]);
}
if(g_debug_level > 3 && g_proc_id == 0) {
printf("Leaving stout_smear_gauge_field\n");
}
return(0);
}
