\documentstyle{article}
 \textwidth6.5in
\textheight8.5in
\evensidemargin0in
\oddsidemargin0in
\topmargin-.5in
\parindent0em
\parskip=12pt
\begin{document}


\begin{center}
  \bf {My long-term career goals} \\
\end {center}

My long-term career goal has always been to \emph{design software/infrastructure} 
to support research in physics.
I have been especially interested in\emph{ visualization of physics} from high 
performance computing codes.  One interest that I have always had, has been in designing 
``useful'' systems, which other physicists, both experimental and computational,  could take advantage of.  
I have learned that building a code to model complex physical 
phenomena is like building an experimental laboratory. Care must be taken when designing such 
a system, and one must build tools to aid their research. In experimental physics, sometimes 
having better diagnostic tools can unearth new-physics, which researchers weren't even aware 
of. In computational physics, better tools typically meant better algorithms, better computers, and 
better visualization systems.  I have been working in developing tools which others can take advantage of, including:
designing a code which computes the initial conditions of 2 black holes, designing portions of ``The binary black hole
grand challenge project'', developing a visualization system for the spectroscopy group at PPPL, 
developing a collaborative visualization system which is being used at other institutions, and designing high performance 
interpolation routines. 
Thus, I feel that my research goals are goals which will allow me to \emph{help other scientists gain insight into their research}.
Specifically, my long-term goals are:
1. To help researchers visualize their data as I learn about their code/physics.
2. To develop infrastructure which will allow them to better understand some of the 
  phenomena in their code.
3. Allow researchers to collaborate more effectively.
4. Allow researchers easier ways to catalog and retrieve their data.
5. Help educate students more effectively. 
6. To understand the evolution of scientific visualization software and hardware, to help 
  understand future trends.
I feel that the CPPG visualization position fits perfectly within my plans, because it will allow me to conduct my 
research/work that will greatly impact others. 

For the CPPG visualization job, I realize that my first duties would be to visualize their data. 
One of my first goals will be to make the visualization for the researchers, so that they can use it 
independently.  This will involve a series of workshops/tutorial sessions, which will allow the 
researchers to feel comfortable using the visualization tools. Since the initial software that should 
be used is AVS, because it is one of the best overall visualization systems, I would like to design 
a series of maps which researchers could use to visualize their data. Eventually, I would like to 
get student support to help create a series of maps, which are useful for the researchers in this 
community. Since AVS allows users to create their own modules, I would like to create whatever 
modules are needed by the community, and then train students to work with me developing new 
modules. Since learning to write code for this system is easy, I feel that this could be an excellent 
way for students to learn about the theoretical fusion research being done at PPPL. Students 
would not only work with me in creating these modules, but they will would also visualize the 
data and try to understand the physics. I feel that this can be an excellent way for students to gain 
exposure to this field, and to basic computational science. 

My next task would be to integrate a series of visualization API's to the researchers code. 
This will then allow researchers to interactively visualize their calculations. By using codes like 
Scivis, my personal visualization system, researchers will be able to perform complex analysis of 
their data, and collaboratively share this information with other researchers. Although various 
researchers are using this system, I feel that there is much improvement needed for this system. I 
would like to write proposals to help fund a visualization system for plasma physics research. I 
envision a system that will aid computationalist and experimentalists. To be more specific, I feel 
that with such a system, data from experimental apparatus could come directly into this 
visualization system. To the system, this data will be no different than data derived from codes 
from high performance calculations.  This would then allow experimentalist to collaboratively 
share their data with researchers at other institutions. Such a system could run not only on the 
researchers machines at work, but also at home. This will allow researchers the freedom to 
monitor their codes/equipment from their comfort of their own homes at night, or during the 
weekend. One of my motivations in creating Scivis was to allow me to watch my calculations 
from at home and at work. Since high performance calculations take many hours of computer 
time, interactively watching a calculation could allow researchers to prematurely end 
calculations, which have run astray. Interactive visualization can also helps researchers 
understand more of their calculation than with visualization from files. While watching a 
calculation, users could have the ability to visualize grid functions, which they didn't want to 
visualize at first.

Since collaboration in science  is essential in today's world, working with researchers at the 
computer science department at Princeton will greatly aid the visualization 
research that will be done at PPPL. After talking to the researchers there, I felt that one 
tremendous tool that PPPL could use would be their wall. By building a wall at PPPL, it will 
allow researchers at PPPL to work closer with researchers at other locations where they have a 
similar wall. Collaborative software is now just beginning to penetrate into the national labs. By 
building a ``more-collaborative'' environment inside PPPL, researchers would be able to not only 
talk to one-another with such a system, but also, by placing cameras next to experimental 
apparatus, and linking this video system on the web (in a secure fashion), researchers could 
monitor their machines even during travel periods. Such a system is being built at PNNL for their experimentalists..
I envision writing proposals to develop a similar  system at PPPL.  

By creating a system that will not only aid computationalists, but also experimentalists, I feel 
that data warehouse techniques, and data mining techniques will become important. This will 
allow researchers to easily look through the vast amount of data coming from the experimental 
machines, and compare this to data coming from codes or from data from other researchers 
experimental machines. By keeping an archive on-line, researchers will be able to work together 
to analyze data much easier.  Eventually, I would expect experimental researchers to compare 
their data with data from their codes. This comparison could be accomplished easily with 
effective data mining software. This is a very new area, which could aid researchers in the PPPL 
community. 

One system, which we could work on, would be education at a distance.  By building 
collaborative infrastructure for computationalists and experimentalists, students could learn 
about fusion research in a easy environment. Physics students at Princeton University could 
watch on a ``wall visualization system'' a teacher at PPPL trying to teach them about fusion 
research. The Researcher at PPPL could show camera views of the diagnostic equipment, along 
with plots of the data from these machines.  With such a large screen, students at PPPL could 
also take advantage of seeing machines, experimental data, and computational data all at the 
same time. 

One of the major attractions about this visualization position at PPPL is that I would be able to 
follow the trends in high-performance computing and scientific visualization. By watching the 
trends, I will enjoy making managerial positions on the movement of computation/visualization 
at PPPL. Since the computational group at PPPL is small, I feel that there is great amount of 
work/research to be done in order to make the visualization group at PPPL into a world-class 
organization.

Thus, I feel that the visualization position at PPPL can provide myself with an environment which helps me work
on my career goals, as I can help researchers in the PPPL community. 
I have a long history of designing software,  which have aided other researchers, and I would like to continue
my research at PPPL.  I  immensely  enjoyed working at PPPL previously, and would like to be at PPPL again.

Thank You,

\textsf{Scott Klasky}

\clearpage
I have enclosed one of the routines inside my new visualization package SV2.  Information about this visualization 
system can be obtained from http://www.npac.syr.edu/users/scott/papers/sv2.ps. If needed, I can tar up the entire
SV2 package, but this package is over 24000 lines of code. I thought that this one routine illustrates my coding 
style.  If you want to see a 3d multigrid java code, which illustrates how Java could look similar to F77, I can email
this routine too (426 lines). 

\begin{verbatim}
// S. Klasky Oct. 1998
// Copyright Syracuse University, NPAC
// This is the main engine of SV2
package sv.engine;

import java.io.*;
import sv.data.*;
import sv.gui.*;
import sv.viewer.*;

/**
 * the SV2 builtin engine. 
 */

public class SV2Engine {
  // We can use (eventually) 4 different viewers inside of SV2
  public static final int VIEWER_BUILTIN = 0;
  public static final int VIEWER_BRUTE   = 1;
  public static final int VIEWER_VRML    = 2;
  public static final int VIEWER_AVS     = 3;
  // We have the capability of using 2 different collaboration models
  public static final int COLLAB_BUILTIN = 0;
  public static final int COLLAB_TANGO   = 1;

  static SV2GUI gui;
  static SV2Engine engine;

  // THIS CLIENT'S IDENTIFICATION
  static long identification = -1;

  // cache directory
  static File cache_dir = null;

  /**
   * visualization frame manager
   */
    public static ViewManager vmanager;

    /**
     * collaboration handler
     */
    public static cSendChannel sender;
    
    /**
     * SV2 engine
     * @param h server host name
     * @param sp server port number
   * @param cp client port number
   * @param s configuration directory
   * @param cache cache directory
   * @param c collaboration option
   * @param v viewer option
   */
    public SV2Engine(String h, int sp, int cp, String s, String cache, int c, int v) {
   engine = this;
   String cache_dir_name = "";

   if (cache == null) {
       String tmp = System.getProperty("os.name");
       if (tmp.indexOf("indow") > 0) 
      cache_dir_name = "C:\\temp\\sv2C\\";
       else
      cache_dir_name = "/tmp/sv2/sv2C/";
   } else
       cache_dir_name = cache;

   initChacheDir(cache_dir_name);

   // first setup the gui
   gui = new SV2GUI(this);
   gui.setLocation(100, 100);
   gui.setSize(640, 480);
   gui.setVisible(true);

   // set up various work module and start those
   vmanager = new ViewManager(engine, v, s);
   cRecvChannel receiver = new cRecvChannel(engine, cp);
   sender = new cSendChannel(engine, h, sp, cp, c);

   receiver.start();
    }

    /**
   * received brief information of the data set from the server
   * @param brief received brief information 
   * This occurs when data is piped into SV2. Initially only the header information is sent
  *  but then we can have the rest of the data sent, upon the user's request.
   */
    public void receivedBriefInfo(DataSetBrief brief) {
   gui.addBriefInfo(brief);    
    }

    /**
   * read data from a file
   */
    public static void readFile(String filename) {

   gui.progress(0);

   try {
       DataInputStream in = new DataInputStream(
                       new BufferedInputStream(new FileInputStream(filename)));
       DataReader.readDataFile(engine, in);
       in.close();

   } catch (Exception e) {
       e.printStackTrace();
       gui.message("Reading file failed: " + filename + " ...", true);
       gui.progress(0);  
       return;
   }
    
   gui.message("Reading: done.", false);
   gui.progress(0);  
    }

    /**
   * return GUI component
   */
    public SV2GUI getGUI() {
   return gui;
    }

    /**
   * return identification
   */
    public long getID() {
   return identification;
    }

    /**
   * set identification
   */
    public void setID(long id) {
   identification = id;
    }

    /**
   * exit from SV2 session
   */
    public static void exitSession() {
   if (cache_dir != null && cache_dir.exists()) {
       String[] files = cache_dir.list();
       for (int i=0; i<files.length; i++) {
      File elem = new File(cache_dir, files[i]);
      elem.delete();
       }
       //cache_dir.delete();
   }

   try {
       sender.notifyExit(identification);
   } catch (Exception e) { }

   System.out.println("\n SV2 exits.");
   System.exit(0);
    }

    /**
   * return cooked cache dierctory
   */
    public File getCacheDir() {
   return cache_dir;
    }

    // initialize the cache directory
    private void initChacheDir(String dir) {
   cache_dir = new File(dir);

   if (!cache_dir.exists()) {
       if (!cache_dir.mkdir()) {
      System.out.println("Cache directory creation failed.");
      System.exit(1);
       }
   }

   if (!cache_dir.canRead() || !cache_dir.canWrite()) {
       System.out.println("Can't read or write the cache directory.");
       System.exit(1);
   }
    }


} // end of class
\end{verbatim}


\end{document} 
