/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
| YLL 4/11/2004
| Now: WolffXY
| 
| Basic framework for wolffxyulation.
| Class inheritance hierarchy:
|     wolffxy extends Applet
|     wolffxyCanvas extends Canvas
|     wolffxyFrame extends Frame
| Member hierarchy:
|     wolffxyFrame sf
|     |--- Applet applet
|          |--- wolffxyFrame sf (circular reference)
|     |--- GridBagConstraints gbc (data structure)
|     |--- wolffxyCanvas cv (placed LHS)
|     |--- Panel panelControl (placed RHS)
|          |--- ...
| Coordinate systems:
|     xmax=xbor+xdisp+xbor  (wolffxyulate xmax*ymax cells, display xdisp*ydisp)
|     
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*
<applet code=wolffxy.class width=10 height=10>
Sorry, you need a Java-enabled browser to see the wolffxyulation.
<param name=RES value=128>
</applet>
*/

import java.awt.*;
import java.applet.Applet;
import java.awt.event.*;
import java.util.Random;

public class wolffxy extends Applet {
  //----- Override Applet methods -----
  wolffxyFrame sf;
  public void init() {sf = new wolffxyFrame(this);	sf.init(); }
  public void destroy() {if (sf != null) sf.dispose(); sf = null;   }
};

class wolffxyCanvas extends Canvas {
  wolffxyFrame sf;
  wolffxyCanvas(wolffxyFrame sf0) {sf = sf0;}
  public Dimension getPreferredSize() {return new Dimension(300,400);}
  public void update(Graphics g) {sf.updatewolffxy(g);}
  public void paint(Graphics g) {sf.updatewolffxy(g);}
};

class wolffxyFrame extends Frame
  implements ComponentListener, ActionListener,
	     ItemListener, WindowListener {

  //----- Objects -----
  static long timeNow,timeLast,timeElapsed;
  static int framesElapsed=0;
  double fps;
  boolean boolDetails=true;
  Random random;
  Dimension dimWin;
  int wxmax,wymax;
  Image imOffscreen;
  Panel panelControl;
  Checkbox cbStep;
  Checkbox cbRunning;
  Checkbox cbDetails;
  Label labelFPS;
  wolffxyCanvas cv;
  wolffxy applet;
  TextField tfSizeX;
  TextField tfSizeY;
  TextField tfSpeed;
  TextField tfCoupling;

  static final Color col0 = new Color (0xFFFFFF);
  static final Color col1 = new Color (0x0000FF);
  static final Color col10 = new Color (0xFFCCCC);
  static final Color col01 = new Color (0x66DDFF);
  final int delay1 = 1;
  final int delay2 = 1000;

  static final double pi = (double)Math.PI;
  static final double twopi = (double)(2*Math.PI);
  static final double ootwopi = (double)(1/(2*Math.PI));
  int xmax;
  int ymax;
  int xdisp;
  int ydisp;
  int iSpeed;
  double fCoupling;
  int pause;
  byte cc[][]; //cluster flag
  int xqueue[];
  int yqueue[];
  double ff[][]; // phi
  double ux[][]; // cos phi
  double uy[][]; // sin phi

  List listPreset;

  //----- Constructor -----
  wolffxyFrame(wolffxy applet0) {super("wolffxy"); applet = applet0; }

  //----- init(), reinit() are actually user-defined ----
  public void init() {
    //----- GUI-----
    this.addWindowListener(this);

    cv = new wolffxyCanvas(this);
    cv.addComponentListener(this);

    panelControl = new Panel();
    panelControl.setLayout(new GridBagLayout());
    GridBagConstraints gbc = new GridBagConstraints();
    gbc.fill = GridBagConstraints.HORIZONTAL;
    gbc.insets = new Insets (0, 8, 0, 8);  // S,W,N,E

    this.add(cv, BorderLayout.CENTER);
    this.add(panelControl, BorderLayout.LINE_END);

    gbc.gridwidth = GridBagConstraints.RELATIVE;
    panelControl.add(new Label("System size LX"), gbc);
    gbc.gridwidth = GridBagConstraints.REMAINDER;
    panelControl.add(tfSizeX = new TextField("16"), gbc);
    tfSizeX.addActionListener(this);

    gbc.gridwidth = GridBagConstraints.RELATIVE;
    panelControl.add(new Label("System size LY"), gbc);
    gbc.gridwidth = GridBagConstraints.REMAINDER;
    panelControl.add(tfSizeY = new TextField("16"), gbc);
    tfSizeY.addActionListener(this);

    gbc.gridwidth = GridBagConstraints.RELATIVE;
    panelControl.add(new Label("Coupling J"), gbc);
    gbc.gridwidth = GridBagConstraints.REMAINDER;
    panelControl.add(tfCoupling = new TextField("1.0"), gbc);
    tfCoupling.addActionListener(this);

    gbc.gridwidth = GridBagConstraints.RELATIVE;
    panelControl.add(new Label("Speed"), gbc);
    gbc.gridwidth = GridBagConstraints.REMAINDER;
    panelControl.add(tfSpeed = new TextField("1"), gbc);
    tfSpeed.addActionListener(this);

    gbc.fill = GridBagConstraints.NONE;
    gbc.anchor = GridBagConstraints.WEST;
    panelControl.add(cbStep = new Checkbox("Step", true), gbc);
    cbStep.addItemListener(this);
    panelControl.add(cbRunning = new Checkbox("Running", true), gbc);
    cbRunning.addItemListener(this);
    panelControl.add(cbDetails = new Checkbox("Details", false), gbc);
    cbDetails.addItemListener(this);

    labelFPS = new Label("FPS                  ");
    panelControl.add(labelFPS, gbc);



    listPreset = new List(4, false);
    listPreset.add("Phase (colour)");
    listPreset.add("Energy density");
    listPreset.add("Vorticity");
    listPreset.add("Phase (graph)");
    listPreset.select(0);
    panelControl.add(listPreset, gbc);


    //----- Params -----
    int blah=123;
    try {blah = Integer.parseInt(applet.getParameter("RES"));} catch (Exception e) {}
    tfSizeX.setText(Integer.toString(blah));
    tfSizeY.setText(Integer.toString(blah));
    setParams();
    pause = 10;

    //----- Various -----
    random = new Random();
    timeNow = System.currentTimeMillis();
    timeLast = System.currentTimeMillis();

    reinit();
    cv.setBackground(Color.black);    //
    setSize(600, 500);
    handleResize();
    show();
  }

  void reinit() {
    xdisp = xmax = Integer.parseInt(tfSizeX.getText());
    ydisp = ymax = Integer.parseInt(tfSizeY.getText());
    System.out.println("reinit " + xmax + " " + ymax + "\n");
    ff = new double[xmax][ymax];
    ux = new double[xmax][ymax];
    uy = new double[xmax][ymax];
    cc = new byte[xmax][ymax];
    xqueue = new int[xmax*ymax+10]; //wouldn't need such a large array
    yqueue = new int[xmax*ymax+10]; // if we used circular queue. never mind
    int x,y;
    for (x=0; x<xmax; x++) {
      for (y=0; y<ymax; y++) {
	ux[x][y] = 1d;
	uy[x][y] = 0d;
      }
    }
  }

  //----- Override paint -----
  public void paint(Graphics g) {cv.repaint();}
  //----- Implement WindowListener -----
  public void windowClosing(WindowEvent e) {dispose();}
  public void windowOpened(WindowEvent e) {}
  public void windowIconified(WindowEvent e) {}
  public void windowDeiconified(WindowEvent e) {}
  public void windowClosed(WindowEvent e) {}
  public void windowActivated(WindowEvent e) {}
  public void windowDeactivated(WindowEvent e) {}
  //----- Implement ComponentListener -----
  public void componentHidden(ComponentEvent e){}
  public void componentMoved(ComponentEvent e){}
  public void componentShown(ComponentEvent e) {cv.repaint();  }
  public void componentResized(ComponentEvent e) {handleResize(); cv.repaint(100);}
  //----- Implement ItemListener -----
  public void itemStateChanged(ItemEvent e) {
    if (e.getItemSelectable() == cbRunning ||
	e.getItemSelectable() == cbStep	)
      cv.repaint();
  }
  //----- Implement ActionListener -----
  public void actionPerformed(ActionEvent e) {
    if (e.getSource()==tfSizeX || e.getSource()==tfSizeY) {
      reinit(); cv.repaint();
    }
    else if (true) { // if (e.getSource()==tfCoupling || ...)
      setParams();
    }
  }

  //----- User-defined methods -----
  // setParams() gets value from text fields (and sliders)? and puts to vars
  void setParams() {
    iSpeed = Integer.parseInt (tfSpeed.getText());
    fCoupling = Double.parseDouble (tfCoupling.getText());
  }

  void handleResize() {
    // It's a pity we couldn't use setMinimumSize(new Dimension(0,0)) on "cv",
    // because Canvas is not a subclass of Component.
    dimWin = cv.getSize(); wxmax = dimWin.width; wymax = dimWin.height;
    if (wxmax<=0 || wymax<=0) return;
    imOffscreen = createImage(wxmax, wymax);
  }

  //----- This version takes 0<h<6, 0<s<1, 0<v<255 -----
  final int hsv2rgb(double h, double s, double v) { 
    int ir,ig,ib;
    int iq;
    double fr,fg,fb,p,q,x1,x2,x3;
    q = iq = (int)Math.floor(h);
    p = h - q;  // p is the fractional part of h
    x1 = v * (1 - s);
    x2 = v * (1 - s*p); //--- only one of x2 and x3 need be computed
    x3 = v * (1 - s*(1-p));
    iq = (iq+600)%6; // iq is the integer part of h, modulo 6
    switch(iq) {
    case 0:  fr=v ; fg=x3; fb=x1; break;
    case 1:  fr=x2; fg=v ; fb=x1; break;
    case 2:  fr=x1; fg=v ; fb=x3; break;
    case 3:  fr=x1; fg=x2; fb=v ; break;
    case 4:  fr=x3; fg=x1; fb=v ; break;
    default: fr=v ; fg=x1; fb=x2;
    }
    //    System.out.println (h + " " + q + " " + iq + " " + p + " " + fr + " " + fg + " " + fb);
    ir = (int)fr;
    ig = (int)fg;
    ib = (int)fb;
    return ((ir<<8)+ig<<8)+ib;
  }


  public void updatewolffxy(Graphics realg) {
    if (dimWin == null || wxmax == 0) {handleResize(); return;} // IE workaround

    Graphics g = imOffscreen.getGraphics();
    boolean boolRunning = cbRunning.getState();
    boolean boolDetails = cbDetails.getState();
    boolean boolStep = cbStep.getState();
    int iIterations;
    int xscal = wxmax/xdisp;
    int yscal = wymax/ydisp;
    int x,y,col,X,Y,X1,Y1,X2,Y2;
    int xp,yp,xm,ym,nbonds;
    double p,blahJ,ax,ay,asq,au,au_asq,coeff,au2,auau2_asq;
    int x2,y2;
    int ihead,itail;
    byte s = 0;

    if (boolRunning||boolStep) {

      timeNow = System.currentTimeMillis();
      timeElapsed = timeNow - timeLast;
      framesElapsed++;
      if (timeElapsed >= 1000) {
	fps = framesElapsed*1000.0f/timeElapsed;
	//labelFPS.setText (timeElapsed+"ms"); 
	labelFPS.setText ("FPS: "+(int)fps + "; IPS: " +(int)(fps*iSpeed));
	timeLast = timeNow;
	framesElapsed = 0;
      }
  


      //=============== PERFORM ONE STEP OF WOLFF ALGORITHM ============
      // Floodfill algorithm for cluster detection (e.g., in site percolation):
      // Method 1: Depth-first fill (uses stack).
      // Method 2: Breadth-first fill (uses queue).
      //
      // Wolff algorithm: wolffxyilar to floodfill,
      // but with a probability p<1 of making each bond.
      //
      // Select x,y at random.  Activate bond with prob p=1-e^(-2J)
      iIterations = boolDetails ? 1 : iSpeed;
      for (int iter=0; iter<iIterations; iter++) { // may be perform multiple steps

	//----- CHOOSE A RANDOM DIRECTION: VECTOR (ax,ay) AND asq -----
	do {
	  ax = random.nextDouble()*2-1; // I forgot this before!
	  ay = random.nextDouble()*2-1;
	  asq = ax*ax + ay*ay;
	} while (asq > 1 || asq < 0.0001);  // Second test is hardly necessary.
	

	//------ INIT CLUSTER-LABEL ARRAY -----
	for (x=0; x<xmax; x++) {
	  for (y=0; y<ymax; y++) {
	    cc[x][y] = 0;
	  }
	}

	//------ PUSH FIRST SPIN ONTO QUEUE -----
	ihead = 0;
	itail = 0;
	xqueue[itail] = x = random.nextInt(xmax);
	yqueue[itail] = y = random.nextInt(ymax);
	cc[x][y] = 1;

	for (; ihead<=itail; ihead++) {
	  //----- PROCESS SPIN AT HEAD OF QUEUE -----
	  // REVERSE PROJECTION OF U ALONG A
	  // (ux,uy) -= (2 * (ux,uy).(ax,ay)) * (ax,ay)
	  x = xqueue[ihead];
	  y = yqueue[ihead];
	  au = ax*ux[x][y] + ay*uy[x][y];
	  au_asq = au/asq;
	  coeff = 2*au_asq;
	  ux[x][y] -= coeff*ax;
	  uy[x][y] -= coeff*ay;

	  // DRAW ARROWS ETC.
	  //System.out.println (ihead + "   ("+x+","+y+")   " + "   " + itail);
	  if (boolDetails) {
	    X = x*xscal;
	    Y = y*yscal;
	    X1 = X + xscal/2;
	    Y1 = Y + yscal/2;
	    X2 = X1 + (int)(ux[x][y]*xscal/2);
	    Y2 = Y1 + (int)(uy[x][y]*xscal/2);     // NOTE!!!!!! USE xscal NOT yscal HERE
	    realg.setColor (Color.gray);
	    realg.fillRect(X, Y, xscal, yscal);
	    realg.setColor (Color.white);
	    realg.drawLine (X1, Y1, X2, Y2); 

	    for (int idelay=0; idelay<delay1*25000; idelay++);
	    //try {Thread.sleep(0, delay1);} catch(Exception e) {}
	  }

	  //----- ADD NEIGHBOURS -----
	  // FOR each neighbour x',y':
	  //   IF x',y' is not already in cluster
	  //   AND  ran() < 1 - min(1, exp( - J(A.U)(A.U')   ))    [3 conds total]
	  //   THEN add (x',y') to queue.
	  //   AND mark that it is now in cluster
	  xp=x+1; if(xp==xmax) xp=0;
	  yp=y+1; if(yp==ymax) yp=0;
	  xm=x-1; if(xm<0) xm=xmax-1;
	  ym=y-1; if(ym<0) ym=ymax-1;
	  // actually auau2_asq  could be stored to mavoid recomputing
	  // in array ---- call it auqueue

	  x2=xp; y2=y;
	  if (cc[x2][y2]==0) { // Cond 1
	    au2 = ax*ux[x2][y2] + ay*uy[x2][y2];
	    auau2_asq = au_asq*au2;
	    if (auau2_asq > 0) { // Cond 2
	      if (random.nextDouble() >= Math.exp(-fCoupling*auau2_asq)) { // Cond 3
		itail++;
		xqueue[itail] = x2;
		yqueue[itail] = y2;
		cc[x2][y2] = 1;
	      }
	    }
	  }
	  x2=xm;
	  if (cc[x2][y2]==0) { // Cond 1
	    au2 = ax*ux[x2][y2] + ay*uy[x2][y2];
	    auau2_asq = au_asq*au2;
	    if (auau2_asq > 0) { // Cond 2
	      if (random.nextDouble() >= Math.exp(-fCoupling*auau2_asq)) { // Cond 3
		itail++;
		xqueue[itail] = x2;
		yqueue[itail] = y2;
		cc[x2][y2] = 1;
	      }
	    }
	  }

	  x2=x; y2=yp;
	  if (cc[x2][y2]==0) { // Cond 1
	    au2 = ax*ux[x2][y2] + ay*uy[x2][y2];
	    auau2_asq = au_asq*au2;
	    if (auau2_asq > 0) { // Cond 2
	      if (random.nextDouble() >= Math.exp(-fCoupling*auau2_asq)) { // Cond 3
		itail++;
		xqueue[itail] = x2;
		yqueue[itail] = y2;
		cc[x2][y2] = 1;
	      }
	    }
	  }

	  y2=ym;
	  if (cc[x2][y2]==0) { // Cond 1
	    au2 = ax*ux[x2][y2] + ay*uy[x2][y2];
	    auau2_asq = au_asq*au2;
	    if (auau2_asq > 0) { // Cond 2
	      if (random.nextDouble() >= Math.exp(-fCoupling*auau2_asq)) { // Cond 3
		itail++;
		xqueue[itail] = x2;
		yqueue[itail] = y2;
		cc[x2][y2] = 1;
	      }
	    }
	  }

	}
      
      }

      //System.out.println ("=========");   
      if (boolDetails) {
	try {Thread.sleep(delay2);} catch(Exception e) {}
      }
    }//end if boolrunning


 
    //----- Update the offscreen image -----

    if (boolRunning||boolStep) {
      g.setColor(cv.getBackground());
      g.fillRect(0, 0, wxmax, wymax);  // takes a long time

      switch (listPreset.getSelectedIndex()) {
      case 0:
	for (x=0; x<xmax; x++) {
	  for (y=0; y<ymax; y++) {
	    X = x*xscal;
	    Y = y*yscal;
	    X1 = X + xscal/2;
	    Y1 = Y + yscal/2;
	    X2 = X1 + (int)(ux[x][y]*xscal/2);
	    Y2 = Y1 + (int)(uy[x][y]*xscal/2);     // NOTE!!!!!! USE xscal NOT yscal HERE
	    g.setColor(new Color(hsv2rgb (3+Math.atan2(ux[x][y], uy[x][y])*(6*ootwopi), 
					  1d,
					  255d)));
	    //Math.min(255d, blahJ*30d)  )));
	    g.drawLine (X1, Y1, X2, Y2); 
	  }
	}
	break;
      case 1:
	// PLOT ENERGY DENSITY
	for (x=0; x<xmax; x++) {
	  for (y=0; y<ymax; y++) {
	    X = x*xscal;
	    Y = y*yscal;

	    //---BLAH.  blah J i s= dummmy var
	    xp=x+1; if(xp==xmax) xp=0;
	    yp=y+1; if(yp==ymax) yp=0;
	    xm=x-1; if(xm<0) xm=xmax-1;
	    ym=y-1; if(ym<0) ym=ymax-1;
	    blahJ = 
	      ( 4d
		- (ux[xp][y] + ux[xm][y] + ux[x][yp] + ux[x][ym]) * ux[x][y]
		- (uy[xp][y] + uy[xm][y] + uy[x][yp] + uy[x][ym]) * uy[x][y]
		);

	    /// erm plot vorticity ...?
	    g.setColor(new Color( 0x010101 * Math.min(255, (int)(blahJ*30d))  ));
	    g.fillRect (X, Y, xscal, yscal);
	  }
	}
	break;
      case 2:
	// PLOT VORTICITY    
	for (x=0; x<xmax; x++) {
	  for (y=0; y<ymax; y++) {
	    ff[x][y] = Math.atan2( uy[x][y], ux[x][y] );
	  }
	}
	for (x=0; x<xmax; x++) {
	  for (y=0; y<ymax; y++) {
	    X = x*xscal;
	    Y = y*yscal;
	    xp=x+1; if(xp==xmax) xp=0;
	    yp=y+1; if(yp==ymax) yp=0;
	    double dum1,dum2;
	    dum2 = 0d;
	    dum1 = ff[x][y] - ff[xp][y]; if (dum1<-pi) dum1+=twopi; else if (dum1>pi) dum1-=twopi; dum2+=dum1;
	    dum1 = ff[xp][y] - ff[xp][yp]; if (dum1<-pi) dum1+=twopi; else if (dum1>pi) dum1-=twopi; dum2+=dum1;
	    dum1 = ff[xp][yp] - ff[x][yp]; if (dum1<-pi) dum1+=twopi; else if (dum1>pi) dum1-=twopi; dum2+=dum1;
	    dum1 = ff[x][yp] - ff[x][y]; if (dum1<-pi) dum1+=twopi; else if (dum1>pi) dum1-=twopi; dum2+=dum1;
	    //System.out.println(dum2+" ");
	    if (dum2 >= 1d) g.setColor(Color.red);
	    else if (dum2<=- 1d) g.setColor(Color.blue);
	    else g.setColor(Color.black);
	    g.fillRect (X, Y, xscal, yscal);
	  }
	}
	break;
    case 3:
      double dum1,dum2;
      // PLOT PHASE VS X VALUE    
      for (x=0; x<xmax; x++) {
	for (y=0; y<ymax; y++) {
	  ff[x][y] = Math.atan2( uy[x][y], ux[x][y] );
	}
      }
      for (y=0; y<ymax; y++) {
	X = 0; Y = 0;
	dum2 = 0;
	for (x=0; x<xmax; x++) {
	  xp = (x+1)%xmax;
	  dum1 = ff[x][y] - ff[xp][y]; if (dum1<-pi) dum1+=twopi; else if (dum1>pi) dum1-=twopi; dum2+=dum1;
	  X2 = x*xscal;
	  Y2 = (int) ( (y + 0.5 + dum2*0.01)*yscal);
	  if (x>0) {
	    g.setColor(Color.white);
	    g.drawLine (X, Y, X2, Y2);
	  }
	  X = X2; Y = Y2;
	}
      }
      break;
    
      // PLOT VORTICITY 2 .. oops this wversion is bad
      /*
	if (boolRunning||boolStep) {
	for (x=0; x<xmax; x++) {
	for (y=0; y<ymax; y++) {
	ff[x][y] = Math.atan2( uy[x][y], ux[x][y] );
	}
	}
	for (x=0; x<xmax; x++) {
	for (y=0; y<ymax; y++) {
	X = x*xscal;
	Y = y*yscal;
	xp=(x+1)%xmax; yp=(y+1)%ymax;
	xm=(x+xmax-1)%xmax; ym=(y+ymax-1)%ymax;
	double dum1,dum2;
	dum2 = 0d;
	dum1 = ff[xp][yp] - ff[xp][y]; if (dum1<-pi) dum1+=twopi; else if (dum1>pi) dum1-=twopi; dum2+=dum1;
	dum1 = ff[xp][y] - ff[xp][ym]; if (dum1<-pi) dum1+=twopi; else if (dum1>pi) dum1-=twopi; dum2+=dum1;
	dum1 = ff[xp][ym] - ff[x][ym]; if (dum1<-pi) dum1+=twopi; else if (dum1>pi) dum1-=twopi; dum2+=dum1;
	dum1 = ff[x][ym] - ff[xm][ym]; if (dum1<-pi) dum1+=twopi; else if (dum1>pi) dum1-=twopi; dum2+=dum1;
	dum1 = ff[xm][ym] - ff[xm][y]; if (dum1<-pi) dum1+=twopi; else if (dum1>pi) dum1-=twopi; dum2+=dum1;
	dum1 = ff[xm][y] - ff[xm][yp]; if (dum1<-pi) dum1+=twopi; else if (dum1>pi) dum1-=twopi; dum2+=dum1;
	dum1 = ff[xm][yp] - ff[x][yp]; if (dum1<-pi) dum1+=twopi; else if (dum1>pi) dum1-=twopi; dum2+=dum1;
	dum1 = ff[x][yp] - ff[xp][yp]; if (dum1<-pi) dum1+=twopi; else if (dum1>pi) dum1-=twopi; dum2+=dum1;
	//System.out.println(dum2+" ");
	if (dum2 >= 1d) g.setColor(Color.red);
	else if (dum2<=- 1d) g.setColor(Color.blue);
	else g.setColor(Color.black);
	g.fillRect (X, Y, xscal, yscal);
	}
	}
	}
      */
      } // end switch
    } //end if 
    //----- Put offscreen image to screen even if sim is paused -----
    realg.drawImage(imOffscreen, 0, 0, this);
    //----- Trigger the next update with <pause> millisec delay  -----
    if (boolRunning) {
      // Don't trigger! ======= HACK ======
      cv.repaint(pause); //??
    }

    if (!boolRunning) cbStep.setState(false);
  }

}