/*    Java applet reflPW.java calculates the plane-wave optical
       reflectance of a multi-layer stack.  
      Modified 01/03/2001 to properly handle thread stop signalling 
                            by M. I. Gallant  Copyright  01/03/2001 
 */

import java.awt.*;

public class reflPW extends java.applet.Applet implements Runnable {

 private volatile Thread runner;   //to allow efficient interruption
 Image offIm;
 Graphics offGr;
 boolean initFinished = false;
 String modeType = "TE" ;
 int wApp, hApp, hPlot, dataHeight, pixGap;
 int nReg, nVary, pts;
 double lam, k0, deg, theta, tmin, tmax, tt, xOld, xPlot, yOld, yPlot, deltaThick;
 double plotYmin, plotYmax;  // plot range.
 double[] thick; 
 double scaleX, scaleY, reflectance;  // scale factors for plotting.
 double[] RR;          // reflectance array.
 Color appBgnd;
 cNum refl, r12, r23;
 cNum[] index, kx;
 Label[]  lThick;
  TextField[]  tIndexR, tIndexI, tThick;
  TextField tLam, tDeg, tReflect, tNvary;
  TextField tTmin, tTmax;
  TextField tYmin, tYmax;

public void init() {

/* set initial default parameters */ 
    nReg = 5;
    pts = 201;          // # of data points to compute/plot.
    RR = new double[pts] ;
    kx = new cNum[nReg]  ;
    lam = 1.30 ;
    k0 = 2.0*Math.PI/lam ;
    deg = 5.0;
    nVary = 1;
    tmin = 0.0;        // plot range in um.
    tmax = 0.25; 
    plotYmin = 0.0;    // reflectance plot range.
    plotYmax = 1.0; 
    reflectance = 0.55;
  deltaThick = (tmax-tmin)/(pts-1) ;
  theta = (Math.PI)/180*deg;     // angle in radians.
  dataHeight = 300; 
  pixGap = 5;                 //pixel gap for grid plot.
  appBgnd = getBackground();
  wApp = this.size().width;
  hApp  = this.size().height;
  hPlot =  hApp - dataHeight;

    offIm = createImage(wApp, hPlot);  // create buffer for backgnd image.
    offGr = offIm.getGraphics();

  setLayout(new GridLayout(nReg+4, 4, 2,2) );
  guiSetup();  
  createGrid() ;
 validate();
}

public Insets insets() {
 return new Insets(hPlot+2,2,2,10);
  }

 public void start()  {
     if (runner == null)  {
     runner = new Thread(this);
     runner.start();
    }
 }

public void stop() {
  runner = null ;
 }

 
 public void pause(int time) {
            try { Thread.sleep(time);}  // wait for time milliseconds.
            catch (InterruptedException e) { }
       }
/* -------------  Main Calculation Loop  Thread------------------------ */
 public void run() {
   //displayData();
 Thread thisthread = Thread.currentThread() ;
 double ksint = k0*Math.sin(theta);  
 cNum ni0 = new cNum(ksint*ksint*(index[0].re)*(index[0].re) , 0) ;  
 cNum[]  kxRat = new cNum[nReg-1] ; 

  for (int i=0; i < nReg; i++) {
    cNum nik0;
     nik0  = cMath.rcMul(k0, index[i]);
     kx[i] = cMath.cSqrt(cMath.cSub(cMath.cMul(nik0,nik0) , ni0)) ;
   }   
  for (int i=0; i <nReg-1 ; i++) 
     kxRat[i] = cMath.cMul(kx[i+1], cMath.cDiv(index[i], index[i+1]).squared() ) ;   //ratio of index*kx squared.
   

for (int j=0; j < pts  ; j++) {
    thick[nVary] = tmin + j*deltaThick ;  // vary thickness of selected layer.

  int lay0=nReg-2 ;
 if (modeType.equals("TE"))  
  r23 = cMath.cDiv(cMath.cSub(kx[lay0], kx[lay0+1]), cMath.cAdd(kx[lay0], kx[lay0+1]));    //s-pol
 else
  r23 = cMath.cDiv(cMath.cSub(kx[lay0], kxRat[lay0]), cMath.cAdd(kx[lay0], kxRat[lay0]));  //p-pol


 for (int lay =lay0; lay>0; lay--) {       //Rouard's method iteration.
  cNum cpart, denom, num, phase; 
  cNum cUnit = new cNum(1.0, 0) ;
  
 if (modeType.equals("TE"))
  r12 = cMath.cDiv(cMath.cSub(kx[lay-1], kx[lay]), cMath.cAdd(kx[lay-1], kx[lay]));    //s-pol
  else
  r12 = cMath.cDiv(cMath.cSub(kx[lay-1], kxRat[lay-1]), cMath.cAdd(kx[lay-1], kxRat[lay-1]));  //p-pol

  phase =  (cMath.cMul(cMath.rcMul(2*thick[lay],cMath.ima), kx[lay])).neg() ;
  cpart =  cMath.cMul(r23, cMath.cExp(phase)) ;
  num   =  cMath.cAdd(r12, cpart) ;
  denom =  cMath.cAdd(cUnit, cMath.cMul(r12, cpart)) ;
  refl  =  cMath.cDiv(num, denom); 
  r23 = refl ;                     //iterate.
  }
  RR[j] = refl.magsq();
   if (runner != thisthread)   // check for signal to stop this thread.
	return ;
 }

    initFinished = true;   
   repaint(); 
}

/*--------------------------------------------------------------- */



 public void update(Graphics g) {
   if (!initFinished) return ;        
    g.clipRect(0,0,wApp, hPlot) ;
   scaleX = wApp/(tmax-tmin);
   scaleY = hPlot/(plotYmax-plotYmin);
  g.drawImage(offIm,0,0,this) ;   // draw the grid.
  g.setColor(Color.black);
   for (int i=0; i <  pts ;  i++ ) { 
      tt = tmin + i*deltaThick ;
      xPlot =scaleX*(tt-tmin);
          reflectance = RR[i];
          yPlot =hPlot - scaleY*(reflectance-plotYmin) ; 
           if(i==0) {
              xOld=xPlot;    yOld=yPlot;
            }
      if(yPlot>0 && yPlot<hPlot)  //only plot if in bounds.
      g.drawLine((int)xOld, (int)yOld, (int)xPlot, (int)yPlot);
      xOld = xPlot;   yOld = yPlot;
    // tReflect.setText(String.valueOf(reflectance));   
   }
 } 


 public void paint(Graphics g) {
  update(g) ;
 }


 void createGrid() {
   offGr.setColor(appBgnd);
   offGr.fillRect(0,0,wApp, hPlot); 
   offGr.setColor(Color.red) ;
   offGr.drawRect(0,0,wApp,hPlot);
   offGr.drawRect(1,1,wApp-2,hPlot-2);

   for (int x=0; x<=wApp; x+=wApp/10 ) {  
        offGr.drawLine(x, hPlot, x, hPlot-7);    
     for (int j=hPlot-8; j>0; j-=pixGap)
        offGr.drawLine(x,j,x,j);        // dot grid.
      }

   for (int y=0; y<=hPlot; y+=hPlot/10 ) {  
        offGr.drawLine(0, y, 7, y);    
     for (int j=8; j<wApp; j+=pixGap)
       offGr.drawLine(j, y, j, y);
     }

 }


    void displayData() {
       System.out.println("Wavelength " + lam);
       System.out.println("Angle " + deg);
       System.out.println("tmin  " +tmin);
       System.out.println("tmax  " +tmax);
       System.out.println("plotYmin  "+plotYmin);
       System.out.println("plotYmax  "+plotYmax);
       System.out.println("nVary  "+nVary);
         for(int i=1; i<nReg-1; i++) 
         System.out.println("thick "+i+" "+thick[i] +"  um");
       for(int i=0; i < nReg ; i++)  { 
       System.out.println("index "+i+"real  "+index[i].re);
       System.out.println("index "+i+"imag  "+index[i].im);   
        }    
    }



void guiSetup() {

add(new Label("Lamda (um)   ", Label.RIGHT) );
tLam = new TextField(String.valueOf(lam), 7);
add(tLam);
add(new Label("Angle (deg)   ", Label.RIGHT) );
tDeg = new TextField(String.valueOf(deg), 7);
add(tDeg);
  
 add(new Label("tmin (um)   ", Label.RIGHT) );      // horizontal plot range.
  tTmin = new TextField(String.valueOf(tmin), 7);
   add(tTmin);
       add(new Label("tmax (um)   ", Label.RIGHT) );
       tTmax = new TextField(String.valueOf(tmax), 7);
       add(tTmax);

  add(new Label("ymin    ", Label.RIGHT) );           //vertical plot range.
  tYmin = new TextField(String.valueOf(plotYmin), 7);
   add(tYmin);
       add(new Label("ymax    ", Label.RIGHT) );
       tYmax = new TextField(String.valueOf(plotYmax), 7);
       add(tYmax);

 


thick = new double[nReg] ;
index = new cNum[nReg] ;   
 
  for (int i=0; i<= nReg-1; i++)  {   ;   //default values (no reflection; 1 nm layers).
         thick[i] = 1.0;
         index[i] = new cNum (1.0,0.00); 
      }

/*  Override above to reasonable initial values */
          index[0] = new cNum(1.0, 0.0);
          index[1] = new cNum(1.8, 0.0); 
          index[2] = new cNum(3.2 ,0.0); 
/*  -------------------------------------- */

tNvary  =  new TextField(String.valueOf(nVary));
tIndexR  = new TextField[nReg];     // Text fields.
tIndexI  = new TextField[nReg];
lThick   = new Label[nReg];
tThick   = new TextField[nReg];
tReflect = new TextField(String.valueOf(reflectance)); // will update dynamically.
   add(new Label("Layer Var  ", Label.RIGHT ));
   add(tNvary);


add(new Label("--- n-real ---    ", Label.RIGHT));
add(new Label("--- n-imag ---   ", Label.RIGHT));

 for (int i=0; i<=nReg-1; i++) {
   tIndexR[i]  = new TextField(String.valueOf(index[i].re), 7);
   tIndexI[i]  = new TextField(String.valueOf(index[i].im), 7);
   
   lThick[i]  = new Label("thick "+i+"  (um)  ",  Label.RIGHT);
   tThick[i]  = new TextField(String.valueOf(thick[i]), 7);
   
          if (i>0 && i<nReg-1) {
              add(lThick[i]) ;
              add(tThick[i]);    
             }
          else  if (i==0)     {
            add(tReflect);
            add(new Label("<---- X/Y  Coord. "));
         }    
         else  if (i==nReg-1)  {
             add(new Button(modeType));
             add(new Button("CALCULATE"));
            } 
       
     add(tIndexR[i]);   add(tIndexI[i]);

   }
validate();

  }  //end of guiSetup method. 

  
       public boolean mouseDown(Event evt, int x, int y) {  
       tReflect.setText(String.valueOf(x/scaleX + tmin)); 
      return true;
     }
    public boolean mouseUp(Event evt, int x, int y) {        
       tReflect.setText(String.valueOf(plotYmin + (hPlot-y)/scaleY)); 
       return true;
     }    


 public boolean action(Event evt, Object arg) {     //intercept AWT action.
      if (evt.target instanceof Button) 
             if( ((String)arg).equals("TE") )  {    //Check first to see if TYPE button.
                  ((Button) evt.target).setLabel("TM") ;         //change the label on button, and ...
                   modeType = "TM" ;            // change the modeType variable.
               }
             else   
            if( ((String)arg).equals("TM") )  {
                ((Button) evt.target).setLabel("TE") ;
                   modeType = "TE" ;
             }
       adjustData((String)arg);            //  reset to new data and compute + replot.
       return true;
   }


// ------------ Handler for Button Press ----------------

   void adjustData( String buttonName) {
       runner=null;    //signal to stop the thread.
         
         tmin = Double.valueOf(tTmin.getText()).doubleValue() ;         
         tmax = Double.valueOf(tTmax.getText()).doubleValue() ;
         plotYmin = Double.valueOf(tYmin.getText()).doubleValue() ; 
         plotYmax = Double.valueOf(tYmax.getText()).doubleValue() ; 
         lam = Double.valueOf(tLam.getText()).doubleValue() ;         
         deg = Double.valueOf(tDeg.getText()).doubleValue() ;         
         nVary =  Integer.parseInt(tNvary.getText()) ; 
    for (int i=1; i < nReg-1; i++)
      thick[i] = Double.valueOf(tThick[i].getText()).doubleValue() ;          
    for (int i=0; i <= nReg-1; i++) {
     index[i].re = Double.valueOf(tIndexR[i].getText()).doubleValue() ; 
     index[i].im = Double.valueOf(tIndexI[i].getText()).doubleValue() ; 
    }
 deltaThick = (tmax-tmin)/(pts-1) ;
 theta = (Math.PI)/180*deg;      
 k0 = 2.0*Math.PI/lam ;

  start();
 }

   public String getAppletInfo() {
   return "Copyright 1996, 2001 Michel Gallant";
  } 

}