FORALLSITES(i,s){
mult_su3_na( (su3_matrix *)(gen_pt[0][i]), &LINK(dir0), &tmat1 );
su3_adjoint( &tmat1, &tmat2 );
add_su3_matrix( &FIELD_STRENGTH(component), &tmat1,
&FIELD_STRENGTH(component) );
sub_su3_matrix( &FIELD_STRENGTH(component), &tmat2,
&FIELD_STRENGTH(component) );
}
FORALLSITES(i,s){
mult_su3_na( (su3_matrix *)(gen_pt[0][i]),
(su3_matrix *)(gen_pt[1][i]), ((su3_matrix *)F_PT(s,f_mn)) );
mult_su3_nn( &(s->tempmat1), ((su3_matrix *)F_PT(s,f_mn)),
&(s->tempmat2) );
mult_su3_nn( ((su3_matrix *)F_PT(s,f_mn)), &(s->tempmat1),
&(s->staple) );
}
int main(int argc, char **argv)
{
su3_matrix a, b, c, d;
int i,j,iter=1;
struct sched_param param={sched_priority:20};
volatile unsigned long long timeA, timeMILC, timeSSE;
unsigned int seed=1;
int randomfd;
if ((randomfd=open("/dev/urandom", O_RDONLY)) < 0)
perror("Attempt to open /dev/urandom");
if (read(randomfd, &seed, sizeof(seed)) < sizeof(seed))
perror("Attempt to read /dev/urandom");
close(randomfd);
srand(seed);
if (sched_setscheduler(0, SCHED_FIFO, ¶m) < 0)
perror("Attempt to put in real time queue");
if (argc > 1) sscanf(argv[1],"%d",&iter);
for (i=0; i<3; i++) {
for (j=0; j<3; j++) {
a.e[i][j].real = (Real)(rand() - RAND_MAX/2)/(Real)(RAND_MAX/2)*2.0;
a.e[i][j].imag = (Real)(rand() - RAND_MAX/2)/(Real)(RAND_MAX/2)*2.0;
b.e[i][j].real = (Real)(rand() - RAND_MAX/2)/(Real)(RAND_MAX/2)*2.0;
b.e[i][j].imag = (Real)(rand() - RAND_MAX/2)/(Real)(RAND_MAX/2)*2.0;
}
}
rdtscll(timeA);
for (i=0; i<iter; i++) {
mult_su3_na(&a, &b, &c);
}
rdtscll(timeMILC);
timeMILC -= timeA;
rdtscll(timeA);
for (i=0; i<iter; i++) {
_inline_sse_mult_su3_na(&a, &b, &d);
}
rdtscll(timeSSE);
timeSSE -= timeA;
for (i=0; i<3; i++) {
printf("%4.1f%+4.1fi %4.1f%+4.1fi %4.1f%+4.1fi | %4.1f%+4.1fi %4.1f%+4.1fi %4.1f%+4.1fi | %4.1f%+4.1fi %4.1f%+4.1fi %4.1f%+4.1fi | %4.1f%+4.1fi %4.1f%+4.1fi %4.1f%+4.1fi\n",
a.e[i][0].real, a.e[i][0].imag, a.e[i][1].real, a.e[i][1].imag, a.e[i][2].real, a.e[i][2].imag,
b.e[i][0].real, b.e[i][0].imag, b.e[i][1].real, b.e[i][1].imag, b.e[i][2].real, b.e[i][2].imag,
c.e[i][0].real, c.e[i][0].imag, c.e[i][1].real, c.e[i][1].imag, c.e[i][2].real, c.e[i][2].imag,
d.e[i][0].real, d.e[i][0].imag, d.e[i][1].real, d.e[i][1].imag, d.e[i][2].real, d.e[i][2].imag);
}
printf("Time per iteration:\n MILC: %Lu\n SSE: %Lu\n", timeMILC/(unsigned long long)iter,
timeSSE/(unsigned long long)iter);
exit(0);
}
void relax(int NumStp)
{
/* Do overrelaxation by SU(2) subgroups */
int NumTrj, Nhit, index1, ina, inb, ii;
int subl;
Real a0, a1, a2, a3, asq, r;
register int dir, i;
register site *st;
su3_matrix action;
su2_matrix u;
Nhit = 3;
for( NumTrj = 0 ; NumTrj < NumStp; NumTrj++)
for( subl = 0; subl < N_SUBL32; subl++) {
FORALLUPDIR(dir) {
/* updating links in direction dir */
/* compute the staple */
dsdu_qhb_subl(dir, subl);
for(index1=0;index1< Nhit;index1++) {
/* pick out an SU(2) subgroup */
ina=(index1+1) % Nc;
inb=(index1+2) % Nc;
if(ina > inb){ ii=ina; ina=inb; inb=ii;}
FORSOMESUBLATTICE(i,st,subl) {
mult_su3_na(&(st->link[dir]), &(st->staple), &action);
/*decompose the action into SU(2) subgroups using Pauli matrix expansion */
/* The SU(2) hit matrix is represented as a0 + i * Sum j (sigma j * aj)*/
a0 = action.e[ina][ina].real + action.e[inb][inb].real;
a3 = action.e[ina][ina].imag - action.e[inb][inb].imag;
a1 = action.e[ina][inb].imag + action.e[inb][ina].imag;
a2 = action.e[ina][inb].real - action.e[inb][ina].real;
/* Normalize and complex conjugate u */
asq = a0*a0 + a1*a1 + a2*a2 + a3*a3;
r = sqrt((double)asq );
a0 = a0/r; a1 = -a1/r; a2 = -a2/r; a3 = -a3/r;
/* Elements of SU(2) matrix */
u.e[0][0] = cmplx( a0, a3);
u.e[0][1] = cmplx( a2, a1);
u.e[1][0] = cmplx(-a2, a1);
u.e[1][1] = cmplx( a0,-a3);
/* Do SU(2) hit on all links twice (to overrelax) */
left_su2_hit_n(&u,ina,inb,&(st->link[dir]));
left_su2_hit_n(&u,ina,inb,&(st->link[dir]));
} /* st */
} /* hits */
} /* direction */
} /* subl, NumTrj */
/* update the momenta with the gauge force */
void gauge_force(Real eps) {
register int i,dir1,dir2;
register site *st;
msg_tag *tag0,*tag1,*tag2;
int start;
su3_matrix tmat1,tmat2;
register Real eb3;
/**double dtime,dclock();
dtime = -dclock();**/
eb3 = eps*beta/3.0;
/* Loop over directions, update mom[dir1] */
for(dir1=XUP; dir1<=TUP; dir1++){
/* Loop over other directions, computing force from plaquettes in
the dir1,dir2 plane */
start=1; /* indicates staple sum not initialized */
for(dir2=XUP;dir2<=TUP;dir2++)if(dir2 != dir1){
/* get link[dir2] from direction dir1 */
tag0 = start_gather_site( F_OFFSET(link[dir2]), sizeof(su3_matrix),
dir1, EVENANDODD, gen_pt[0] );
/* Start gather for the "upper staple" */
tag2 = start_gather_site( F_OFFSET(link[dir1]), sizeof(su3_matrix),
dir2, EVENANDODD, gen_pt[2] );
/* begin the computation "at the dir2DOWN point", we will
later gather the intermediate result "to the home point" */
wait_gather(tag0);
FORALLSITES(i,st){
mult_su3_an( &(st->link[dir2]), &(st->link[dir1]), &tmat1 );
mult_su3_nn( &tmat1, (su3_matrix *)gen_pt[0][i],
&(st->tempmat1) );
}
/* Gather this partial result "up to home site" */
tag1 = start_gather_site( F_OFFSET(tempmat1), sizeof(su3_matrix),
OPP_DIR(dir2), EVENANDODD, gen_pt[1] );
/* begin the computation of the "upper" staple. Note that
one of the links has already been gathered, since it
was used in computing the "lower" staple of the site
above us (in dir2) */
wait_gather(tag2);
if(start){ /* this is the first contribution to staple */
FORALLSITES(i,st){
mult_su3_nn( &(st->link[dir2]), (su3_matrix *)gen_pt[2][i],
&tmat1);
mult_su3_na( &tmat1, (su3_matrix *)gen_pt[0][i],
&(st->staple) );
}
start=0;
}
static void
get_Q_from_VUadj(su3_matrix *Q, su3_matrix *V, su3_matrix *U){
complex minusI;
complex tr;
su3_matrix Omega;
minusI = cmplx(0, -1); /* -i */
/* Omega = V U^adj */
mult_su3_na( V, U, &Omega );
/* Q = traceless hermitian part of [-i Omega] */
c_scalar_mult_su3mat( &Omega, &minusI, &Omega );
traceless_hermitian_su3( Q, &Omega );
}
static void
get_Q_from_VUadj(su3_matrix *Q, su3_matrix *V, su3_matrix *U){
complex x;
complex tr;
su3_matrix Om;
x = cmplx(0, 0.5); /* i/2 */
/* Om = V U^adj */
mult_su3_na( V, U, &Om );
/* Q = i/2(Om^adj - Om) */
su3_adjoint( &Om, Q );
sub_su3_matrix( Q, &Om, &Om );
c_scalar_mult_su3mat( &Om, &x, Q );
/* Q = Q - Tr Q/3 */
tr = trace_su3( Q );
CDIVREAL(tr, 3., tr);
CSUB(Q->e[0][0],tr,Q->e[0][0]);
CSUB(Q->e[1][1],tr,Q->e[1][1]);
CSUB(Q->e[2][2],tr,Q->e[2][2]);
}
void monte_block_ape_b(int NumStp1)
{
int NumTrj,Nhit, index1, ina, inb,ii,cb;
int parity;
Real b3;
register int dir,i;
register site *st;
void dsdu_ape(register int dir1, int parity);
su3_matrix tmat1;
Real a0,a1,a2,a3,asq;
int index,ind1,ind2,step;
su2_matrix h;
Real alpha;
int NumStp;
NumStp=3 ;
Nhit=5;
alpha=0.3;
b3=alpha/(1.0-alpha)/6.0;
b3=1.0/b3;
if(this_node==0)printf("pure APE blocking with alpha %e N %d\n",alpha,NumStp);
/* set bb_link=link */
FORALLSITES(i,st)for(dir=XUP;dir<=TUP;dir++){
st->blocked_link[8+dir]= st->link[dir];
}
/* ape blocking steps_rg levels*/
for(step=1;step<=NumStp;step++){
for(parity=ODD;parity<=EVEN;parity++)
for(dir=XUP;dir<=TUP;dir++){
/* compute the gauge force */
dsdu_ape(dir,parity);
FORSOMEPARITY(i,st,parity){
{
/* set blocked_link=bb_link temporarily*/
st->blocked_link[4+dir]= st->blocked_link[8+dir];
/* add the staple to the blocked link. ``staple'' will become the new
blocked_link after normalization */
scalar_mult_add_su3_matrix(&(st->tempmat2),
&(st->blocked_link[8+dir]),b3,&(st->tempmat2));
/* if(i==0&&step==1){
printf("\n\n step=%d i=%d dir=%d\n",step,i,dir);
dumpmat(&(st->blocked_link[8+dir]));
dumpmat(&(st->tempmat2));
}*/
/* Now do hits in the SU(2) subgroup to "normalize" staple */
for(index=0;index<3*Nhit;index++){
/* pick out an SU(2) subgroup */
ind1=(index) % 3;
ind2=(index+1) % 3;
if(ind1 > ind2){ ii=ind1; ind1=ind2; ind2=ii;}
mult_su3_na( &(st->blocked_link[4+dir]), &(st->tempmat2), &tmat1 );
/* Extract SU(2) subgroup in Pauli matrix representation,
a0 + i * sum_j a_j sigma_j, from the SU(3) matrix tmat1 */
a0 = tmat1.e[ind1][ind1].real + tmat1.e[ind2][ind2].real;
a1 = tmat1.e[ind1][ind2].imag + tmat1.e[ind2][ind1].imag;
a2 = tmat1.e[ind1][ind2].real - tmat1.e[ind2][ind1].real;
a3 = tmat1.e[ind1][ind1].imag - tmat1.e[ind2][ind2].imag;
/* Normalize and put complex conjugate into u */
asq = a0*a0 + a1*a1 + a2*a2 + a3*a3;
asq = sqrt((double)asq);
a0 = a0/asq; a1 = a1/asq; a2 = a2/asq; a3 = a3/asq;
h.e[0][0] = cmplx( a0,-a3);
h.e[0][1] = cmplx(-a2,-a1);
h.e[1][0] = cmplx( a2,-a1);
h.e[1][1] = cmplx( a0, a3);
/* Do the SU(2) hit */
left_su2_hit_n( &h, ind1, ind2, &(st->blocked_link[4+dir]));
} /* indices */
} /* end loop over sites */
}} /* direction and parity */
// Calculate upper staple, add it
FORALLSITES(i, s) {
mult_su3_nn((su3_matrix*)F_PT(s,lnk2), (su3_matrix *)gen_pt[1][i], &tmat1);
mult_su3_na(&tmat1, (su3_matrix *)gen_pt[0][i], &tmat2);
add_su3_matrix(stp + i, &tmat2, stp + i);
}
static complex
KS_2pt_trace(su3_matrix * antiquark, wilson_propagator * quark,
int * g_snk, int n_snk, int *g_src, int n_src, int *p, site *s)
{
int t;
int my_x;
int my_y;
int my_z;
complex trace;
int s0;
int c0,c1,i;
wilson_propagator temp,temp1;
su3_matrix mat, mat1;
t = s->t;
my_x = s->x;
my_y = s->y;
my_z = s->z;
temp = *quark;
//multiply by gamma_snk
for(i=0;i<n_snk;i++)
for(c0=0;c0<3;c0++){
mult_swv_by_gamma_l( &(temp.c[c0]), &(temp1.c[c0]), g_snk[i]);
temp.c[c0] = temp1.c[c0];
}
//multiply by Omega field
if((t % 2) == 1)
for(c0=0;c0<3;c0++){
mult_swv_by_gamma_l( &(temp.c[c0]), &(temp1.c[c0]), TUP);
temp.c[c0] = temp1.c[c0];
}
if((my_x % 2) == 1)
for(c0=0;c0<3;c0++){
mult_swv_by_gamma_l( &(temp.c[c0]), &(temp1.c[c0]), XUP);
temp.c[c0] = temp1.c[c0];
}
if((my_y % 2) == 1)
for(c0=0;c0<3;c0++){
mult_swv_by_gamma_l( &(temp.c[c0]), &(temp1.c[c0]), YUP);
temp.c[c0] = temp1.c[c0];
}
if((my_z % 2) == 1)
for(c0=0;c0<3;c0++){
mult_swv_by_gamma_l( &(temp.c[c0]), &(temp1.c[c0]), ZUP);
temp.c[c0] = temp1.c[c0];
}
//mulptiply by gamma_src
for(c0=0;c0<3;c0++)
for(i=0;i<n_src;i++)
{
mult_swv_by_gamma_l( &(temp.c[c0]), &(temp1.c[c0]), g_src[i]);
temp.c[c0] = temp1.c[c0];
}
for(c0=0;c0<3;c0++)
for(c1=0;c1<3;c1++){
trace.real = 0.0;
trace.imag = 0.0;
for(s0=0;s0<4;s0++){
trace.real += temp.c[c0].d[s0].d[s0].c[c1].real;
trace.imag += temp.c[c0].d[s0].d[s0].c[c1].imag;
}
mat.e[c0][c1].real = trace.real;
mat.e[c0][c1].imag = trace.imag;
}
mult_su3_na(&mat, antiquark, &mat1); //antiquark is just the staggered prop su3 matrix
trace = trace_su3(&mat1);
return(trace);
}
/* Now make +mu +nu plaquette and put in f_mn */
FORALLSITES(i,s){
mult_su3_nn( &(s->link[mu]), ((su3_matrix *)F_PT(s,f_mn)), &tmat4 );
mult_su3_na( &tmat4, &(s->link[nu]), ((su3_matrix *)F_PT(s,f_mn)) );
}
/* compute wiggly links in direction dir1 decorated in direction dir2 */
void hyp_block_stage1(register int dir1, register int dir2, int parity,
su3_matrix *U_link, su3_matrix *Wiggly_link, int dir_exclude,
hyp_coeffs_t *hc ) {
register int i;
register site *st;
msg_tag *tag0,*tag1,*tag2,*tag3,*tag4;
int start;
register int count,nWiggly;
su3_matrix tmat1,tmat2,fatq;
su3_matrix *tempmat1;
int disp[4]; /* displacement vector for general gather */
/* create temporary storage, one matrix per site */
tempmat1 = create_mn_special(1);
start=1; /* indicates staple sum not initialized */
// array size is fixed for 4D, in 3D not all entries are filled
nWiggly = 12;
count=3*dir1+dir2;
if(dir2>dir1)count=count-1;
/* displacement vector for link 2 sites away */
for(i=XUP;i<=TUP;i++)disp[i]=0;
disp[dir1] = 1;
disp[dir2] = -1;
/* get U_link[dir2] from direction dir1 */
tag0 = declare_strided_gather( U_link + dir2, 4*sizeof(su3_matrix),
sizeof(su3_matrix), dir1, parity, gen_pt[0] );
do_gather( tag0 );
/* get U_link[dir1] from direction dir2 */
tag1 = declare_strided_gather( U_link + dir1, 4*sizeof(su3_matrix),
sizeof(su3_matrix), dir2, parity, gen_pt[1] );
do_gather( tag1 );
/* get U_link[dir2] from direction -dir2 */
tag2 = declare_strided_gather( U_link + dir2, 4*sizeof(su3_matrix),
sizeof(su3_matrix), OPP_DIR(dir2), parity, gen_pt[2] );
do_gather( tag2 );
/* get U_link[dir1] from direction -dir2 */
tag3 = declare_strided_gather( U_link + dir1, 4*sizeof(su3_matrix),
sizeof(su3_matrix), OPP_DIR(dir2), parity, gen_pt[3] );
do_gather( tag3 );
/* get U_link[dir2] from displacement +dir1-dir2 */
tag4 = start_general_strided_gather( (char *)(U_link + dir2), 4*sizeof(su3_matrix),
sizeof(su3_matrix), disp, parity, gen_pt[4] );
/* Upper staple */
wait_gather(tag0);
wait_gather(tag1);
if(start){ /* this is the first contribution to staple */
FORSOMEPARITY(i,st,parity){
mult_su3_nn( &(U_link[4*i+dir2]), (su3_matrix *)gen_pt[1][i], &tmat1 );
mult_su3_na( &tmat1, (su3_matrix *)gen_pt[0][i], &(tempmat1[i]) );
}
start=0;
}
/* update the momenta with the gauge force */
void QOP_symanzik_1loop_gauge_force(QOP_info_t *info, QOP_GaugeField *gauge,
QOP_Force *force, QOP_gauge_coeffs_t *coeffs, Real eps)
{
register int i,dir;
register site *st;
su3_matrix tmat1;
register Real eb3; /* Note: eps now includes eps*beta */
register su3_matrix* momentum;
su3_matrix *staple, *tempmat1;
/* lengths of various kinds of loops */
int *loop_length = get_loop_length();
/* number of rotations/reflections for each kind */
int *loop_num = get_loop_num();
/* table of directions, 1 for each kind of loop */
int ***loop_table = get_loop_table();
/* table of coefficients in action, for various "representations"
(actually, powers of the trace) */
Real **loop_coeff = get_loop_coeff(); /* We make our own */
int max_length = get_max_length(); /* For Symanzik 1 loop! */
int nloop = get_nloop();
int nreps = get_nreps();
su3_matrix *forwardlink[4];
su3_matrix *tmpmom[4];
int nflop = 153004; /* For Symanzik1 action */
Real final_flop;
double dtime;
int j,k;
int *dirs,length;
int *path_dir,path_length;
int ln,iloop;
Real action,act2,new_term;
int ncount;
char myname[] = "imp_gauge_force";
dtime=-dclock();
info->status = QOP_FAIL;
/* Parity requirements */
if(gauge->evenodd != QOP_EVENODD ||
force->evenodd != QOP_EVENODD
)
{
printf("QOP_asqtad_force: Bad parity gauge %d force %d\n",
gauge->evenodd, force->evenodd);
return;
}
/* Map field pointers to local static pointers */
FORALLUPDIR(dir){
forwardlink[dir] = gauge->g + dir*sites_on_node;
tmpmom[dir] = force->f + dir*sites_on_node;
}
/* Check loop coefficients */
if(coeffs->plaquette != loop_coeff[0][0] ||
coeffs->rectangle != loop_coeff[1][0] ||
coeffs->parallelogram != loop_coeff[2][0])
{
printf("%s(%d): Path coeffs don't match\n",myname,this_node);
return;
}
/* Allocate arrays according to action */
dirs = (int *)malloc(max_length*sizeof(int));
if(dirs == NULL){
printf("%s(%d): Can't malloc dirs\n",myname,this_node);
return;
}
path_dir = (int *)malloc(max_length*sizeof(int));
if(path_dir == NULL){
printf("%s(%d): Can't malloc path_dir\n",myname,this_node);
return;
}
staple = (su3_matrix *)special_alloc(sites_on_node*sizeof(su3_matrix));
if(staple == NULL){
printf("%s(%d): Can't malloc temporary\n",myname,this_node);
return;
}
tempmat1 = (su3_matrix *)special_alloc(sites_on_node*sizeof(su3_matrix));
if(tempmat1 == NULL){
printf("%s(%d): Can't malloc temporary\n",myname,this_node);
return;
}
eb3 = eps/3.0;
/* Loop over directions, update mom[dir] */
for(dir=XUP; dir<=TUP; dir++){
FORALLSITES(i,st)for(j=0;j<3;j++)for(k=0;k<3;k++){
staple[i].e[j][k]=cmplx(0.0,0.0);
} END_LOOP
ncount=0;
for(iloop=0;iloop<nloop;iloop++){
length=loop_length[iloop];
for(ln=0;ln<loop_num[iloop];ln++){
/**printf("UPD: "); printpath( loop_table[iloop][ln], length );**/
/* set up dirs. we are looking at loop starting in "XUP"
direction, rotate so it starts in "dir" direction. */
for(k=0;k<length;k++){
if( GOES_FORWARDS(loop_table[iloop][ln][k]) ){
dirs[k]=(dir+loop_table[iloop][ln][k] )% 4;
}
else {
dirs[k]=OPP_DIR(
(dir+OPP_DIR(loop_table[iloop][ln][k]))%4 );
}
}
path_length= length-1; /* generalized "staple" */
/* check for links in direction of momentum to be
updated, each such link gives a contribution. Note
the direction of the path - opposite the link. */
for(k=0;k<length;k++)if( dirs[k]==dir||dirs[k]==OPP_DIR(dir)) {
if( GOES_FORWARDS(dirs[k]) ) for(j=0;j<path_length;j++) {
path_dir[j] = dirs[(k+j+1)%length];
}
if( GOES_BACKWARDS(dirs[k]) ) for(j=0;j<path_length;j++) {
path_dir[path_length-1-j] =
OPP_DIR(dirs[(k+j+1)%length]);
}
/**if(dir==XUP)printf("X_UPDATE PATH: "); printpath( path_dir, path_length );**/
path_product(path_dir,path_length, tempmat1);
/* We took the path in the other direction from our
old convention in order to get it to end up
"at our site", so now take adjoint */
/* then compute "single_action" contribution to
staple */
FORALLSITES(i,st){
su3_adjoint( &(tempmat1[i]), &tmat1 );
/* first we compute the fundamental term */
new_term = loop_coeff[iloop][0];
/* now we add in the higher representations */
if(nreps > 1){
node0_printf("WARNING: THIS CODE IS NOT TESTED\n"); exit(0);
act2=1.0;
action = 3.0 - realtrace_su3(forwardlink[dir]+i,
&tmat1 );
for(j=1;j<nreps;j++){
act2 *= action;
new_term +=
loop_coeff[iloop][j]*act2*(Real)(j+1);
}
} /* end if nreps > 1 */
scalar_mult_add_su3_matrix( &(staple[i]), &tmat1,
new_term, &(staple[i]) );
} END_LOOP
ncount++;
} /* k (location in path) */
} /* ln */
} /* iloop */
/* Now multiply the staple sum by the link, then update momentum */
FORALLSITES(i,st){
mult_su3_na( forwardlink[dir]+i, &(staple[i]), &tmat1 );
momentum = tmpmom[dir] + i;
scalar_mult_sub_su3_matrix( momentum, &tmat1,
eb3, momentum );
} END_LOOP
/* update the momenta with the gauge force */
void imp_gauge_force_cpu( Real eps, field_offset mom_off ){
register int i,dir;
register site *st;
su3_matrix tmat1,tmat2;
register Real eb3;
register anti_hermitmat* momentum;
su3_matrix *staple, *tempmat1;
/* lengths of various kinds of loops */
int *loop_length = get_loop_length();
/* number of rotations/reflections for each kind */
int *loop_num = get_loop_num();
/* table of directions, 1 for each kind of loop */
int ***loop_table = get_loop_table();
/* table of coefficients in action, for various "representations"
(actually, powers of the trace) */
Real **loop_coeff = get_loop_coeff();
int max_length = get_max_length();
int nloop = get_nloop();
int nreps = get_nreps();
#ifdef GFTIME
int nflop = 153004; /* For Symanzik1 action */
double dtime;
#endif
int j,k;
int *dirs,length;
int *path_dir,path_length;
int ln,iloop;
Real action,act2,new_term;
int ncount;
char myname[] = "imp_gauge_force";
#ifdef GFTIME
dtime=-dclock();
#endif
dirs = (int *)malloc(max_length*sizeof(int));
if(dirs == NULL){
printf("%s(%d): Can't malloc dirs\n",myname,this_node);
terminate(1);
}
path_dir = (int *)malloc(max_length*sizeof(int));
if(path_dir == NULL){
printf("%s(%d): Can't malloc path_dir\n",myname,this_node);
terminate(1);
}
staple = (su3_matrix *)special_alloc(sites_on_node*sizeof(su3_matrix));
if(staple == NULL){
printf("%s(%d): Can't malloc temporary\n",myname,this_node);
terminate(1);
}
tempmat1 = (su3_matrix *)special_alloc(sites_on_node*sizeof(su3_matrix));
if(tempmat1 == NULL){
printf("%s(%d): Can't malloc temporary\n",myname,this_node);
terminate(1);
}
eb3 = eps*beta/3.0;
/* Loop over directions, update mom[dir] */
for(dir=XUP; dir<=TUP; dir++){
FORALLSITES(i,st)for(j=0;j<3;j++)for(k=0;k<3;k++){
staple[i].e[j][k]=cmplx(0.0,0.0);
} END_LOOP
ncount=0;
for(iloop=0;iloop<nloop;iloop++){
length=loop_length[iloop];
for(ln=0;ln<loop_num[iloop];ln++){
/**printf("UPD: "); printpath( loop_table[iloop][ln], length );**/
/* set up dirs. we are looking at loop starting in "XUP"
direction, rotate so it starts in "dir" direction. */
for(k=0;k<length;k++){
if( GOES_FORWARDS(loop_table[iloop][ln][k]) ){
dirs[k]=(dir+loop_table[iloop][ln][k] )% 4;
}
else {
dirs[k]=OPP_DIR(
(dir+OPP_DIR(loop_table[iloop][ln][k]))%4 );
}
}
path_length= length-1; /* generalized "staple" */
/* check for links in direction of momentum to be
updated, each such link gives a contribution. Note
the direction of the path - opposite the link. */
for(k=0;k<length;k++)if( dirs[k]==dir||dirs[k]==OPP_DIR(dir)) {
if( GOES_FORWARDS(dirs[k]) ) for(j=0;j<path_length;j++) {
path_dir[j] = dirs[(k+j+1)%length];
}
if( GOES_BACKWARDS(dirs[k]) ) for(j=0;j<path_length;j++) {
path_dir[path_length-1-j] =
OPP_DIR(dirs[(k+j+1)%length]);
}
/**if(dir==XUP)printf("X_UPDATE PATH: "); printpath( path_dir, path_length );**/
path_product(path_dir,path_length, tempmat1);
/* We took the path in the other direction from our
old convention in order to get it to end up
"at our site", so now take adjoint */
/* then compute "single_action" contribution to
staple */
FORALLSITES(i,st){
su3_adjoint( &(tempmat1[i]), &tmat1 );
/* first we compute the fundamental term */
new_term = loop_coeff[iloop][0];
/* now we add in the higher representations */
if(nreps > 1){
node0_printf("WARNING: THIS CODE IS NOT TESTED\n"); exit(0);
act2=1.0;
action = 3.0 - realtrace_su3(&(st->link[dir]),
&tmat1 );
for(j=1;j<nreps;j++){
act2 *= action;
new_term +=
loop_coeff[iloop][j]*act2*(Real)(j+1);
}
} /* end if nreps > 1 */
scalar_mult_add_su3_matrix( &(staple[i]), &tmat1,
new_term, &(staple[i]) );
} END_LOOP
ncount++;
} /* k (location in path) */
} /* ln */
} /* iloop */
/* Now multiply the staple sum by the link, then update momentum */
FORALLSITES(i,st){
mult_su3_na( &(st->link[dir]), &(staple[i]), &tmat1 );
momentum = (anti_hermitmat *)F_PT(st,mom_off);
uncompress_anti_hermitian( &momentum[dir], &tmat2 );
scalar_mult_sub_su3_matrix( &tmat2, &tmat1,
eb3, &(staple[i]) );
make_anti_hermitian( &(staple[i]), &momentum[dir] );
} END_LOOP
void make_field_strength(
field_offset link_src, /* field offset for su3_matrix[4] type
for the source link matrices */
field_offset field_dest /* field offset for su3_matrix[6] type
for the resulting field strength */
)
{
register int i,component,dir0=-99,dir1=-99;
register site *s;
int j;
su3_matrix tmat1,tmat2;
su3_matrix *temp1,*temp2;
complex cc;
msg_tag *mtag0,*mtag1;
/* Allocate temporary space for two su3_matrix fields */
temp1 = (su3_matrix *)malloc(sites_on_node*sizeof(su3_matrix));
if(temp1 == NULL){
printf("field_strength: No room for temp1\n");
terminate(1);
}
temp2 = (su3_matrix *)malloc(sites_on_node*sizeof(su3_matrix));
if(temp2 == NULL){
printf("field_strength: No room for temp2\n");
terminate(1);
}
for(component=FS_XY;component<=FS_ZT;component++){
switch(component){
case FS_XY: dir0=XUP; dir1=YUP; break;
case FS_XZ: dir0=XUP; dir1=ZUP; break;
case FS_YZ: dir0=YUP; dir1=ZUP; break;
case FS_XT: dir0=XUP; dir1=TUP; break;
case FS_YT: dir0=YUP; dir1=TUP; break;
case FS_ZT: dir0=ZUP; dir1=TUP; break;
}
/* Plaquette in +dir0 +dir1 direction */
mtag0 = start_gather_site( LINK_OFFSET(dir0), sizeof(su3_matrix),
dir1, EVENANDODD, gen_pt[0] );
mtag1 = start_gather_site( LINK_OFFSET(dir1), sizeof(su3_matrix),
dir0, EVENANDODD, gen_pt[1] );
wait_gather(mtag0);
wait_gather(mtag1);
FORALLSITES(i,s){
mult_su3_nn( &LINK(dir0),
(su3_matrix *)(gen_pt[1][i]), &tmat1 );
mult_su3_na( &tmat1, (su3_matrix *)(gen_pt[0][i]), &tmat2 );
mult_su3_na( &tmat2, &LINK(dir1), &tmat1 );
su3_adjoint( &tmat1, &tmat2 );
sub_su3_matrix( &tmat1, &tmat2, &FIELD_STRENGTH(component) );
}
/**cleanup_gather(mtag0); Use same gather in next plaquette**/
cleanup_gather(mtag1);
/* Plaquette in -dir0 +dir1 direction */
/**mtag0 = start_gather_site( LINK_OFFSET(dir0),
sizeof(su3_matrix), dir1, EVENANDODD, gen_pt[0] );
wait_gather(mtag0); Already gathered above**/
FORALLSITES(i,s){
mult_su3_an( &LINK(dir1),
&LINK(dir0), &tmat1 );
mult_su3_an( (su3_matrix *)(gen_pt[0][i]), &tmat1, &temp1[i] );
}