My long-term career goals

My long-term career goal has always been to design software/infrastructure to support research in physics. I have been especially interested in 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 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,

Scott Klasky 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).

// 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