void LatticeContainer::Get(Lattice &lat){
str_ord = lat.StrOrd();
lat.CopyGaugeField(gauge_p);
}
//-----------------------------------------------------------------------
// Rotate gauge of the lattice (from Min)
//-----------------------------------------------------------------------
void rotate_gauge_explicit(Lattice &lat,int dir)
{
const char *cname="none";
const char *fname="rotate_gauge_explicit";
VRB.Func(cname,fname);
if ((dir<0)||(dir>3)){
VRB.Result(cname,fname,"Error:: direction should be 0,1,2,3\n");
return;
}
int NX(GJP.XnodeSites());
int NY(GJP.YnodeSites());
int NZ(GJP.ZnodeSites());
int NT(GJP.TnodeSites());
//---------------------------------------------------------------
// Set up the gauge fixing and other required conditions
//---------------------------------------------------------------
int num_nodes[4]
= { GJP.Xnodes(), GJP.Ynodes(), GJP.Znodes(), GJP.Tnodes() } ;
int node_sites[4]
= { GJP.XnodeSites(), GJP.YnodeSites(), GJP.ZnodeSites(), GJP.TnodeSites() } ;
int Size[4];
for (int i=0; i<4; i++){
Size[i] = num_nodes[i]*node_sites[i];
}
int *plns;
plns = (int*) smalloc(Size[dir]*sizeof(int));
for (int i=0; i<Size[dir]; i++){
plns[i] = i;
}
int npln = Size[dir];
FixGaugeType normdir;
if (dir==3) normdir = FIX_GAUGE_COULOMB_T;
else if (dir==0) normdir = FIX_GAUGE_COULOMB_X;
else if (dir==1) normdir = FIX_GAUGE_COULOMB_Y;
else normdir = FIX_GAUGE_COULOMB_Z;
//----------------------------------------------------------------------
//initialize the parameters need to gauge fixing ---------------------
//----------------------------------------------------------------------
Matrix *L;
Matrix **Gp;
int ii;
int volume = NX*NY*NZ*NT;
L = (Matrix*) smalloc(4*volume*sizeof(Matrix));
Gp = (Matrix**) smalloc(npln*sizeof(Matrix*));
for(ii=0; ii<npln; ii++)
Gp[ii] = (Matrix*) smalloc(volume/node_sites[dir] * sizeof(Matrix));
//-----------------------------------------------------------------------------
//GAUGE FIXING MATRICES
//-----------------------------------------------------------------------------
for (int slice=0; slice<node_sites[dir]; slice++)
for(int cnt=0; cnt<volume/node_sites[dir]; cnt++)
Gp[slice][cnt]=lat.FixGaugePtr()[slice][cnt];
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
// TRY TO Transform the Lattice to the Coulomb Gauge and store it ---------------
//-------------------------------------------------------------------------------
int tt,xx,yy,zz,temp_ind;
int slice_ind[3];
//slice_ind[3] stores the 3 directions on the 'dir' slice with indices increasing
temp_ind = 0;
for (int i=0; i<4; i++){
if (i!=dir) {
slice_ind[temp_ind] = i;
temp_ind++;
}
}
VRB.Result(cname,fname,"dir == %d \n",dir);
VRB.Result(cname,fname,"slice index == %d %d %d\n",slice_ind[0],slice_ind[1],slice_ind[2]);
// the dummy node_sites for each dummy dirction
int NN[4];
NN[0] = node_sites[slice_ind[0]];
NN[1] = node_sites[slice_ind[1]];
NN[2] = node_sites[slice_ind[2]];
NN[3] = node_sites[dir];
int s[4];
for (int i=0; i<3; i++)
s[i] = slice_ind[i];
s[3] = dir;
//---------------------------------------------------------------------------------
//copy the old lattice config to matrix array L, transform L and then copy back
//---------------------------------------------------------------------------------
lat.CopyGaugeField(L);
int x[4];
// xx yy zz tt are dummy position vector, as tt represents the gfixing direction
for (x[3]=0; x[3]<node_sites[3]; x[3]++)
for (x[2]=0; x[2]<node_sites[2]; x[2]++)
for (x[1]=0; x[1]<node_sites[1]; x[1]++)
for (x[0]=0; x[0]<node_sites[0]; x[0]++)
{
xx = x[slice_ind[0]];
yy = x[slice_ind[1]];
zz = x[slice_ind[2]];
tt = x[dir];
Matrix g = Gp[tt][(zz*NN[1]+yy)*NN[0]+xx];
Matrix D;
Matrix gg ;
Matrix transmit;
//----------------- T Direction ----------------------------
if (tt+1<NN[3]) gg = Gp[tt+1][(zz*NN[1]+yy)*NN[0]+xx];
else {
transmit = Gp[0][(zz*NN[1]+yy)*NN[0]+xx];
getPlusData((IFloat *)&gg, (IFloat *)&transmit,
sizeof(Matrix)/sizeof(IFloat), dir) ;
}
D.Dagger(gg);
L[IND(x[0],x[1],x[2],x[3],dir)] = g*L[IND(x[0],x[1],x[2],x[3],dir)]*D;
//----------------- Z Direction ----------------------------
if (zz+1<NN[2]) gg = Gp[tt][((zz+1)*NN[1]+yy)*NN[0]+xx];
else {
transmit = Gp[tt][((zz+1)%NN[2]*NN[1]+yy)*NN[0]+xx];
getPlusData((IFloat *)&gg, (IFloat *)&transmit,
sizeof(Matrix)/sizeof(IFloat), slice_ind[2]) ;
}
D.Dagger(gg);
L[IND(x[0],x[1],x[2],x[3],slice_ind[2])] = g*L[IND(x[0],x[1],x[2],x[3],slice_ind[2])]*D;
//----------------- Y Direction ----------------------------
if (yy+1<NN[1]) gg = Gp[tt][(zz*NN[1]+(yy+1))*NN[0]+xx];
else {
transmit = Gp[tt][(zz*NN[1]+(yy+1)%NN[1])*NN[0]+xx];
getPlusData((IFloat *)&gg, (IFloat *)&transmit,
sizeof(Matrix)/sizeof(IFloat), slice_ind[1]) ;
}
D.Dagger(gg);
L[IND(x[0],x[1],x[2],x[3],slice_ind[1])] = g*L[IND(x[0],x[1],x[2],x[3],slice_ind[1])]*D;
//----------------- X Direction ----------------------------
if (xx+1<NN[0]) gg = Gp[tt][(zz*NN[1]+yy)*NN[0]+(xx+1)];
else {
transmit = Gp[tt][(zz*NN[1]+yy)*NN[0]+(xx+1)%NN[0]];
getPlusData((IFloat *)&gg, (IFloat *)&transmit,
sizeof(Matrix)/sizeof(IFloat), slice_ind[0]) ;
}
D.Dagger(gg);
L[IND(x[0],x[1],x[2],x[3],slice_ind[0])] = g*L[IND(x[0],x[1],x[2],x[3],slice_ind[0])]*D;
}
lat.GaugeField(L);
//--------------------------------Free L and Gp -------------------------------------
sfree(L);
for (ii=0; ii<npln; ii++)
sfree(Gp[ii]);
sfree(Gp);
sfree(plns);
}