/* From: "COMPUTATIONAL PHYSICS, 2nd Ed" 
   by RH Landau, MJ Paez, and CC Bordeianu 
   Copyright Wiley-VCH, 2007.
   Electronic Materials copyright: R Landau, Oregon State Univ, 2007;
   MJ Paez, Univ Antioquia, 2007; and CC Bordeianu, Univ Bucharest, 2007.
   Support by National Science Foundation                              
*/
// Scatt.java: Soln of Lippmann Schwinger in p space for scattering

import Jama.*;   
import java.io.*; 
import java.util.*; 

public class scatt {   
  
  public static void main(String[] argv) 
                          throws IOException, FileNotFoundException {
														
    PrintWriter q = new PrintWriter
                            (new FileOutputStream("sin2.dat"), true);
    PrintWriter q1 = new PrintWriter
                          (new FileOutputStream("sin2an.dat"), true);
													 
    int n, i, j, Row, Column, M = 300; 
    double pot, lambda, scale, ko, Temp, shift, shiftan, sin2, k2; 
    double pi = 3.1415926535897932384626, b = 1., RN1; 
    double[][] F = new double[M][M]; 
    double[] k = new double[M]; 
		double[] w = new double[M]; 
    double[] D = new double[M]; 
		double[] r = new double[M]; 
    double[] V = new double[M]; 
		double[][] P = new double[M][M]; 
    double[][] L = new double[M][M]; 
		double[][] U = new double[M][M]; 
		
    n = 16;                scale = n/2;         pot = 0. ;
		shiftan = 0.;          lambda = -10.; 
		                                           // Set up Gauss points
    Gauss.gauss(n, 2, 0., 1000., k, w); 
		                                               // Set up D matrix
    for ( ko=0.1; ko <= 2*pi; ko = ko + .01)  {         
      for ( i=0; i<= n-1; i++ )
				                 D[i]=2/pi*w[i]*k[i]*k[i]/(k[i]*k[i]-ko*ko);
      D[n] = 0. ; 
      for (j=0; j <= n-1;j++) D[n]=D[n]+w[j]*ko*ko/(k[j]*k[j]-ko*ko);  
      D[n] = D[n]*(-2./pi); 
			                               // Set up F matrix and V vector
      for ( i=0; i <= n-1; i++ ) {         
        for ( j=0; j <= n-1; j++ )  {
           pot = -b*b * lambda * Math.sin( b*k[i] )
                              * Math.sin( b*k[j] ) / (k[i]*b*k[j]*b);
           F[i][j] = pot*D[j]; 
           if (i==j)  F[i][j] = F[i][j] + 1. ; 
        }
        V[i] = pot;     
      }
			                                // Change arrays into matrices
      Matrix Fmat = new Matrix(F, n, n);    
      Matrix Vvec = new Matrix(n, 1); 
      Matrix Finv = Fmat.inverse(); 
			
      for ( i=0; i <= n-1; i++ )  Vvec.set(i, 0, V[i]); 
			                                               // Invert matrix
      Matrix R = Finv.times(Vvec); 
			
      RN1 = R.get(n-1, 0);                      // Get last vale of R
			                                          // Define phase shift
      shift = Math.atan(-RN1*2*ko);             
      sin2 = Math.sin(shift)*Math.sin(shift); 
      q.println(ko + " " + sin2); 
} }  }