import java.awt.*;
import java.util.*;

public class XY {

   private final int J = 1;
   private double spinAngle[][];
   private int L;
   private double T, H, dtheta;		// implicitly assuming the field is in the y direction
   public int time_counter;
   public double E, Mx, My, ave_Mx, ave_My, ave_E;
   
   public XY()  { }
   public XY(int L, double T, double H, double dtheta) {  reinitialize(L, T, H, dtheta);  }
 
   public boolean reinitialize(int L, double T, double H, double dtheta) {
       this.L = L;
       if(T<0) { 
           System.out.println("\nTemperature is negative, automatically negated!");
           T *= -1;
       }
       this.T = T;
       this.H = H;
       this.dtheta = dtheta;
       time_counter = 1;
       ave_Mx = ave_My = ave_E = 0;
       spinAngle = new double[L][L];

       for(int i=0; i<L; i++)
          for(int j=0; j<L; j++) 
              spinAngle[i][j] = Math.random()*2*Math.PI;
          
       getME();
       return true;
    }
 
   public void resetT(double T) {
       if(T<0) {
           System.out.println("\nTemperature is negative, automatically negated!");
           T *= -1;
       }
       this.T = T;
   }
   
   public void resetH(double H) {
       this.H = H;
   }
   
   public void resetDtheta(double dtheta) {
       if(dtheta <0) dtheta *= -1;
       if(dtheta < Math.PI) 
           this.dtheta = dtheta;
       else
           this.dtheta = dtheta - (int)(dtheta/Math.PI)*Math.PI;
   }
              
   private int pbc(int x) {
       if(x >= L) 
           return (x-L);
       else if(x<0) 
           return (x+L);
       else
           return x;
   }

   private void getME() {
       E = Mx = My= 0;

       for(int i=0; i<L; i++)
          for(int j=0; j<L; j++)
             {  
                 Mx += Math.cos(spinAngle[i][j]);
                 My += Math.sin(spinAngle[i][j]);
                 E += Math.cos(spinAngle[i][j] - spinAngle[i][pbc(j+1)]);
                 E += Math.cos(spinAngle[i][j] - spinAngle[pbc(i+1)][j]);
             }
       E = -J*E - H*My;                
   }                              

   private boolean rotate() {
       int x = (int) (Math.random()*L);
       int y = (int) (Math.random()*L);
       double angulo = spinAngle[x][y];
       double deltaMx = - Math.cos(angulo);
       double deltaMy = - Math.sin(angulo);
       double deltaE = - Math.cos(spinAngle[pbc(x-1)][y] - angulo) 
        		       - Math.cos(spinAngle[pbc(x+1)][y] - angulo)
        			   - Math.cos(spinAngle[x][pbc(y-1)] - angulo)
        			   - Math.cos(spinAngle[x][pbc(y+1)] - angulo);

       double tempDtheta = (2*Math.random() - 1)*dtheta;
       
       deltaMx += Math.cos(angulo + tempDtheta);
       deltaMy += Math.sin(angulo + tempDtheta);       
       deltaE  +=  Math.cos(spinAngle[pbc(x-1)][y] - angulo - tempDtheta) 
        		 + Math.cos(spinAngle[pbc(x+1)][y] - angulo - tempDtheta)
        		 + Math.cos(spinAngle[x][pbc(y-1)] - angulo - tempDtheta)
        		 + Math.cos(spinAngle[x][pbc(y+1)] - angulo - tempDtheta);

       deltaE = -J*deltaE - H*deltaMy;
       if(deltaE <=0 || Math.random()<Math.exp(-deltaE/T))
         {
             spinAngle[x][y] += tempDtheta;
             if(spinAngle[x][y] > 2*Math.PI)        // limit the angle to between 0 and 2*Pi
                 spinAngle[x][y] -= 2*Math.PI;
             else if(spinAngle[x][y] < -2*Math.PI)
                 spinAngle[x][y] += 2*Math.PI;
                 
             Mx += deltaMx;
             My += deltaMy;
             E += deltaE;
             return true;
         }
       else
             return false;
    }

   public void rotateSpinBloc(int xStart, int yStart, int xEnd, int yEnd, double alpha) {
       for(int i=xStart; i<=xEnd; i++)
           for(int j=yStart; j<=yEnd; j++) {
               spinAngle[i][j] += alpha;
               if(spinAngle[i][j] > 2*Math.PI) 
                   spinAngle[i][j] -= 2*Math.PI;
               else if(spinAngle[i][j] < 0)
                   spinAngle[i][j] += 2*Math.PI;
           }
       getME();
   }
           
   public void onestep() {
       int N = L*L; 
       for(int i=0; i<N; i++)
          rotate();
       ave_Mx += Mx;
       ave_My += My;
       ave_E += E;
       time_counter ++;
   }

   private int identifyVortex(int x, int y) {  // this part requires all angles between 0 and 2*Pi
       double delta = 0;
       double angles[] = new double[] { spinAngle[x][y], spinAngle[x][pbc(y+1)], spinAngle[pbc(x+1)][pbc(y+1)], spinAngle[pbc(x+1)][y] };

       for(int i=0; i<3; i++) {
           double temp = angles[i+1] - angles[i];
           if(temp <= Math.PI && temp > -Math.PI)
               delta += temp;
           else if(temp > Math.PI)
               delta += (temp - 2*Math.PI);
           else
               delta += (temp + 2*Math.PI);
       }
       if(delta > Math.PI) 
           return 1;
       else if(delta < -Math.PI)
           return -1;
       else 
           return 0;
   }
              
   private void drawOneSpin(Graphics g, int x0, int y0, double length, double theta) {
   	   int dx = (int)(length/2*Math.cos(theta));
   	   int dy = (int)(length/2*Math.sin(theta));
   	   g.drawLine(x0-dx, y0+dy, x0+dx, y0-dy);      // in display, y axis points downward
   	   
   	   int dx2 = (int)(length/4*Math.cos(theta + Math.PI/6));
   	   int dy2 = (int)(length/4*Math.sin(theta + Math.PI/6));
   	   g.drawLine(x0+dx, y0-dy, x0+dx-dx2, y0-dy+dy2);
   	   
   	   dx2 = (int)(length/4*Math.cos(theta - Math.PI/6));
   	   dy2 = (int)(length/4*Math.sin(theta - Math.PI/6));
   	   g.drawLine(x0+dx, y0-dy, x0+dx-dx2, y0-dy+dy2);
   }
      
   private void drawPlus(Graphics g, int x0, int y0, double length) {
       int ds = (int)(length/2);
       g.drawLine(x0-ds, y0, x0+ds, y0);
       g.drawLine(x0, y0-ds, x0, y0+ds);
   }
    
   private void drawMinus(Graphics g, int x0, int y0, double length) {
       int ds = (int)(length/2);
       g.drawLine(x0-ds, y0, x0+ds, y0);
   }
   
   public void drawSpins(Graphics g, int x0, int y0, int width, int height) {
       double dx = ((double) width) / L;
       double dy = ((double) height) / L;

       double spinLength = dx;
       if(dy < dx)
           spinLength = dy;
            
       g.setColor(Color.blue);
       for(int i=0; i<L; i++)
           for(int j=0; j<L; j++) {
               int xPos = x0 + (int)(i*dx + dx/2); 
               int yPos = y0 + (int)(j*dy + dy/2);
               drawOneSpin(g, xPos, yPos, spinLength, spinAngle[i][j]);
 
               int vorticity = identifyVortex(i, j);
               if(vorticity == 1) {
                   g.setColor(Color.red);
                   drawPlus(g, x0+(int)((i+1)*dx), y0+(int)((j+1)*dy), spinLength/3);
                   g.setColor(Color.blue);
               }
               else if(vorticity == -1) {
                   g.setColor(new Color(0, 180, 20));
                   drawMinus(g, x0+(int)((i+1)*dx), y0+(int)((j+1)*dy), spinLength/3);
                   g.setColor(Color.blue);
               }                   
           }  
    }
}