// w0015grid.java  wing in wind tunnel, plot, get left and right grid
//             wing defined by y=f(x), sequence of points around boundary
//             can rotate x,y about center at maximum chord to ax1,ay1
//             write output file  w0015a**.dat  ** is angle of attack


import java.awt.*;
import java.awt.event.*;
import java.io.*;

public class w0015grid extends Frame
{
  double xmin = 0.0;
  double xmax = 1.0;
  double xoff = 50.0;
  double yoff = 400.0;
  double scale = 500.0; // for plotting
  double ymin; // computed, depends on angle of attack 
  double ymax;
  double xmins;
  double xmaxs;
  double xtop, ytop, xbot, ybot, xfront, yfront; // special points 
  double xadj = -0.5; // approx center for output 
  double grid = 0.01; // grid spacing, may be computed 
  int written = 0;
  int maxwrite = 3;
  int width = 600;
  int height = 600; // upper part for title 
  double Pi = 3.14159265358979323846;
  int npts = 200;
  double xp[] = new double[npts];
  double yp[] = new double[npts];
  int outpts = 100;
  int ixbound[] = new int[outpts]; // output boundary
  int jybound[] = new int[outpts];
  double xgrid[] = new double[outpts]; // output grid
  double ygrid[] = new double[outpts];
  int npts_grid;
  int nxg;
  double angle_deg = 22.0; // may be read in 
  String angle_ch = "22";
  String fname = "w0015a22.grid";
  String ltr = "a";
  double ndiv=11.0;  // number of xg divisions
  int n = 0;
  boolean connect = false;
  // FILE* fout;

  w0015grid(String gname, String ang, String altr)
  {
    System.out.println("w0015grid.java running");
    angle_ch = ang;
    angle_deg = (double)Integer.parseInt(angle_ch);
    fname = gname.substring(0,5)+altr+angle_ch+gname.substring(8,13);
    if(altr.equals("b")) ndiv = 5.0;
    if(altr.equals("c")) ndiv = 17.0;
    System.out.println("writing "+fname+" angle_deg="+angle_deg+" ndiv="+ndiv);
    build_bound(angle_deg);
    yminmax();
    compute_grid();
    write_grid(); // writes grid and boundary indices

    setTitle("fname");
    setSize(width,height);
    setBackground(Color.white);
    setForeground(Color.black);
    addWindowListener(new WindowAdapter()
    {
      public void windowClosing(WindowEvent e)
      {
        System.exit(0);
      }
    });
    setVisible(true);
    this.addMouseListener (new mousePressHandler());

  } // end constructor w0015grid

  class mousePressHandler extends MouseAdapter
  {
    public void mousePressed (MouseEvent e)
    {
      int x, y, b;
      x = e.getX();
      y = e.getY();
      b = e.getButton();
      if(b==3 && n>0)
      {
        connect=true;
      }
      requestFocus();
      System.out.println("at x="+x+"   y="+y+"   b="+b); // debug print
      repaint();
    } // end mousePressed
  } // end class mousePressedHandler

  public void paint(Graphics g)
  {
    g.setColor(Color.black);
    g.drawString(fname, 20, 50);
    g.setColor(Color.red);
    for(int i=0; i<npts; i++)
    {
      if(i==0 || i==npts-1)
          System.out.println("in paint, x="+((int)(scale*xp[i]+xoff))+
                             ", y="+(height-(int)(scale*yp[i]+yoff)));
      g.drawOval((int)(scale*xp[i]+xoff), height-(int)(scale*yp[i]+yoff),
                 2, 2);
    }
    g.drawOval((int)(scale*0.3+xoff), height-(int)(scale*0.0+yoff), 2, 2);
                                                   // center at maximum chord 

    g.setColor(Color.blue);
    for(int i=0; i<npts-1; i++)
    {
      g.drawLine((int)(scale*xp[i]+xoff)+1,
                 height-(int)(scale*yp[i]+yoff)+1,
                 (int)(scale*xp[i+1]+xoff)+1,
                 height-(int)(scale*yp[i+1]+yoff)+1);
    }
    // draw selected grid points
    g.setColor(Color.black);
    for(int i=0; i<npts_grid; i++)
    {
      g.drawOval((int)(scale*xgrid[ixbound[i]]+xoff),
                 height-(int)(scale*ygrid[jybound[i]]+yoff),
                 3, 3);
    }
  } // end paint


  double f(double x) // basic symmetrical wing, x=0.0,1.0, need top/bot 
  {
    return (15./20.)*(0.29690*Math.sqrt(x)-0.12600*x-0.35160*x*x+
	  	      0.28430*x*x*x-0.10150*x*x*x*x);
  } // end f 

  // rotate wing coordinates based on angle of attack 
  void pitch(double angle, double x, double y, double ax[], double ay[])
  {
    double xc;
    xc = x-0.3; // rotate about maximum chord 
    ax[0] = 0.3+xc*Math.cos(angle)+y*Math.sin(angle);
    ay[0] = -xc*Math.sin(angle)+y*Math.cos(angle);
  } // end pitch 

  void yminmax() // uses and sets globals for min/max 
  {
    ymax = yp[0];
    ymin = yp[0];
    xmaxs = xp[0];
    xmins = xp[0];
    ytop = yp[0]; // for top and bottom grid point 
    xtop = xp[0];
    for(int j=1; j<npts; j++)
    {
      ymax = Math.max(ymax,yp[j]);
      ymin = Math.min(ymin,yp[j]);
      xmaxs = Math.max(xmaxs,xp[j]);
      xmins = Math.min(xmins,xp[j]);
      if(yp[j]>ytop) { ytop=yp[j]; xtop = xp[j];}
    }
    System.out.println("ymin="+ymin+",  ymax="+ymax);
    System.out.println("xmins="+xmins+", xmaxs="+xmaxs);
    System.out.println("xtop="+xtop+", ytop="+ytop);
    System.out.println("grid step="+grid);
  } // end yminmax 

  void build_bound(double angle_deg) // build wing boundary 
  {
    double x1, y1;
    double ax1[] = new double[1];     // top, positive surface 
    double ay1[] = new double[1];
    double nax1[] = new double[1]; // negative surface 
    double nay1[] = new double[1];
    double dx;
    double angle;

    angle = Pi*angle_deg/180.0;
    n = npts/2;
    dx = (xmax-xmin)/(double)(n-1);
    for(int j=0; j<n; j++)
    {
      x1=xmin+j*dx;
      y1=f(x1);
      pitch(angle, x1, y1, ax1, ay1);
      pitch(angle, x1, -y1, nax1, nay1);
      xp[j] = nax1[0];
      yp[j] = nay1[0];
      xp[npts-1-j] = ax1[0]; // run bottom backwards 
      yp[npts-1-j] = ay1[0]; 
    }
    pitch(angle, 1.0, 0.0, ax1, ay1);
    xbot = ax1[0];
    ybot = ay1[0];
    System.out.println("build bound xbot="+xbot+", ybot="+ybot);
    pitch(angle, 0.0, 0.0, ax1, ay1);
    xfront = ax1[0];
    yfront = ay1[0];
    System.out.println("build bound xfront="+xfront+", yfront="+yfront);
  } // end build_bound 

  int inside(double x1, double y1)
                     // an even number of crossings means outside 
  {
    int j;
    int c=0; // out, setting this one, plots points outside 
    double xinter;
    double x=x1-xoff;
    double y=y1-yoff;

    if(x<xmins) return 0; // obvious outside 
    if(x>xmaxs) return 0;
    if(y<ymin)  return 0;
    if(y>ymax)  return 0;
    for(j=0; j<npts-1; j++) // scan for x crossings 
    {
      if(y>Math.max(yp[j],yp[j+1])) continue;  // y high   
      if(y<Math.min(yp[j],yp[j+1])) continue;  // y low    
      if(x>Math.max(xp[j],xp[j+1])) continue;  // x beyond 
      xinter = xp[j]+(y-yp[j])*(xp[j+1]-xp[j])/(yp[j+1]-yp[j]);
      if(x>xinter) continue;              // x beyond 
      c = 1-c; // crossing 
    }
    return c;
  } // end inside 

  void compute_grid()
  {
    double x, lgrid;
    int i=0; // will be global npts_grid == ygrid size

    nxg = 0;
    lgrid = (xfront+xbot)/ndiv;
    System.out.println("xfront="+xfront+", xbot="+xbot+", lgrid="+lgrid);

    System.out.println("nxg   xgrid   i   ygrid ");
    xgrid[nxg] = xfront; // lead point 
    ygrid[i] = yfront; 
    System.out.println(nxg+"  "+xgrid[i]+"  "+i+"  "+ygrid[i]);
    ixbound[i] = nxg;
    nxg++;
    jybound[i] = i;
    i++;
    for(x=xfront+lgrid/2.0; x<xbot-lgrid/3.0; x=x+lgrid)
    {
      xgrid[nxg] = x;
      System.out.println("grid at x="+x);
      for(int j=0; j<npts-1; j++)
      {
        if(x>Math.max(xp[j],xp[j+1])) continue;  // x high   
        if(x<Math.min(xp[j],xp[j+1])) continue;  // x low    
        ygrid[i] = yp[j]+(x-xp[j])*(yp[j+1]-yp[j])/(xp[j+1]-xp[j]);
        ixbound[i] = nxg;
        jybound[i] = i;
        System.out.println(i+"  "+xgrid[nxg]+"  "+ygrid[i]+" "+ixbound[i]+
                           "  "+jybound[i]);
        i++;
      }
      nxg++;
    }
    xgrid[nxg] = xbot; // trail point 
    ygrid[i] = ybot; 
    ixbound[i] = nxg;
    jybound[i] = i;
    System.out.println(i+"  "+xgrid[nxg]+"  "+ygrid[i]+" "+ixbound[i]+
                       "  "+jybound[i]);
    i++;
    npts_grid = i;
    nxg++;

    // debug
    // System.out.println("raw points i, x, y ");
    // for(i=0; i<npts; i++) System.out.println(i+"  "+xp[i]+"  "+yp[i]);
  } // end compute_grid 

  void write_grid()
  {
    BufferedWriter out; // for write
    PrintWriter file_out; // for write
    double t;
    int ki, kj;

    try
    {
      out = new BufferedWriter(new FileWriter(fname));
      file_out = new PrintWriter(out);
    }
    catch(Exception e)
    {
      System.out.println("unable to open file "+fname);
      return;
    }
    System.out.println("nxg="+nxg+",  nyg=npts_grid="+npts_grid);
    // write size
    file_out.println(nxg);
    // now write xgrid
    for(int i=0; i<nxg; i++)
    {
      file_out.println(xgrid[i]);
    }
    // sort ygrid  small to large
    for(int i=0; i<npts_grid-1; i++)
      for(int j=i+1; j<npts_grid; j++)
	if(ygrid[i]>ygrid[j])
	{
	  t = ygrid[i];
	  ygrid[i] = ygrid[j];
	  ygrid[j] = t;
          for(int k=0; k<npts_grid; k++)
	  {
	    if(jybound[k]==i) jybound[k] = j;
            else if(jybound[k]==j) jybound[k] = i;
	  }
	}

    // write size
    file_out.println(npts_grid);
    // now write ygrid
    for(int i=0; i<npts_grid; i++)
      file_out.println(ygrid[i]);

    // write size
    file_out.println(npts_grid);
    // now write boundary indices
    for(int i=0; i<npts_grid; i++)
      file_out.println(ixbound[i]+"  "+jybound[i]+"  "+
                       xgrid[ixbound[i]]+"  "+ygrid[jybound[i]]);
    file_out.println();
    file_out.close();
    System.out.println(fname+" closed");
  } // end write_grid 

  public static void main(String args[])
  {
    // read in name of .grid file                                            
    String gname = "w0015a22.grid";
    if(args.length>0)
        gname = args[0];
    String ang="22";
    if(args.length>1)
        ang = args[1];
    String altr = "a";
    if(args.length>2)
        altr = args[2];
    new w0015grid(gname, ang, altr);
    System.out.println("w0015grid.java ends "+altr+ang);
  }
} // end class w0015grid