Session 2 - Data input


Binary data input

NCL can only read binary files that contain a single record with the following exception: if the multiple record file was written with a Fortran write on a similar computer, it can be read using the following approach:

binary_input.ncl contains a script for reading a binary file written with the following Fortran write:

    write(1) ujan(64,129)
    write(1) vjan(64,129)
    write(1) ujul(64,129)
    write(1) vjul(64,129)
where all variables are declared real.

In this script, we read one large array with function cbinread. We then access the four variables shown above by manipulating array indices, and print selected subsections. To run this script, click on the linked name above to bring the example script into your browser window. Copy it into your working directory by using the save as option under the file menu on your browser. If you use the name binary_input.ncl when you copy the file into your working directory, then in your command window type the command:

ncl < binary_input.ncl

This script should produce the following printout:

Variable: file1 (subsection)
Type: float
Total Size: 36 bytes
	    9 values
Number of Dimensions: 1
Dimensions and sizes:   [9]
Coordinates:
Number Of Attributes: 1
_FillValue
(0)     -0.324061
(1)     -0.405162
(2)     -0.488875
(3)     -0.575251
(4)     -0.664285
(5)     4.62765e-41
(6)     4.62765e-41
(7)     -4.421
(8)     -4.33548


Variable: ujan (subsection)
Type: float
Total Size: 20 bytes
	    5 values
Number of Dimensions: 1
Dimensions and sizes:   [5]
Coordinates:
Number Of Attributes: 1
_FillValue
(0)     2.09424
(1)     2.34562
(2)     2.59404
(3)     2.83838
(4)     3.07748


Variable: vjan (subsection)
Type: float
Total Size: 20 bytes
	    5 values
Number of Dimensions: 1
Dimensions and sizes:   [5]
Coordinates:
Number Of Attributes: 1
_FillValue
(0)     -4.421
(1)     -4.33548
(2)     -4.23407
(3)     -4.11683
(4)     -3.9839


Variable: ujul (subsection)
Type: float
Total Size: 20 bytes
	    5 values
Number of Dimensions: 1
Dimensions and sizes:   [5]
Coordinates:
Number Of Attributes: 1
_FillValue
(0)     -1.81509
(1)     -1.62264
(2)     -1.4211
(3)     -1.21071
(4)     -0.991782


Variable: vjul (subsection)
Type: float
Total Size: 20 bytes
	    5 values
Number of Dimensions: 1
Dimensions and sizes:   [5]
Coordinates:
Number Of Attributes: 1
_FillValue
(0)     -4.1472
(1)     -4.25654
(2)     -4.35799
(3)     -4.45075
(4)     -4.534

Note: cbinread can read multiple-record Fortran files as a single read ONLY on the same type of system that wrote them.

ASCII data input

ascii_input.ncl contains a script for reading an ascii file written with the following Fortran write:

    WRITE(1,1)LAT(64),LON(129),LEV(1),U(64,129),V(64,129),AVOR(64,129)
where all variables are declared real.

In this script, we read one large array with function asciiread. We then extract the variables by manipulating array indices, and print selected subsections. To run this script, click on the linked name above to bring the example script into your browser window. Copy it into your working directory by using the save as option under the file menu on your browser. If you use the name ascii_input.ncl when you copy the file into your working directory, then in your command window type the command:

ncl < ascii_input.ncl > out_ascii

In this command, we direct the output of NCL into the file out_ascii because we have chosen to print some fairly large array segments. You can see the actual stored latitudes, longitudes, pressure level, and subsections of u, v, and the vorticity. Note in this case that the vorticity field is empty.

netCDF data input

netCDF_input.ncl contains a script that reads January sea surface temperature data and does a default contour plot into an X11 window.

The metadata content of the file is printed, and an X11 graphic is generated that should look like:

HDF data input

To be included.

GRIB data input

grib1.ncl contains a script that reads surface pressure data on a Lambert Conformal projection and plots it with an overlaid map.

The metadata content of the file is printed and an X11 graphic is generated that should look like:


Creating data objects

CoordArrays data - A single XyPlot curve

Assume we have read a netCDF file "a" that contains the variables: T(frtime, level, lat, lon) and level. Dimensions are: T(7,10,33,36) and level(10). We will plot T at one frtime, one latitude, and one longitude, versus the pressure level.

To create a data object "field1", we assign variable "T" from file "a" to the X axis and variable "level" to the Y axis. We then create an XyPlot object and connect this data object to it as in:

;
; Create a CoordArrays data object with pressure level as the Y axis
; and temperature as the X axis.
;
field1 = create "field1" coordArraysClass defaultapp

     "caYArray": (a->level(:))

; From the T array, use frtime index 0, all levels, lat index 16, lon index 0.
; Convert from Degrees K to Degrees F

     "caXArray": (a->T(0,:,16,0) - 273.15) * 9 / 5 + 32.0
end create

;
; Create an XyPlot object "xy_plot"and connect the data object "field1".
;
xy_plot = create "xy_plot" xyPlotClass wks
    "xyCoordData": field1
end create
xy_t_vs_pn.ncl is a full NCL example that incorporates a single-curve data object. To run this script, click on the linked name above to bring the example script into your browser window. Copy it into your working directory by using the save as option under the file menu on your browser. If you use the name xy_t_vs_pn.ncl when you copy the file into your working directory, then in your command window type the command:

ncl < xy_t_vs_pn.ncl

An NCGM file named xy_t_vs_pn.ncgm is created. It can be plotted with the NCAR NCGM interpreter ctrans via the command:

ctrans -d X11 xy_t_vs_pn.ncgm

The graphic should look like:


CoordArrays data - Multiple curves for XyPlot

In the previous example, we showed how to plot a single curve. In this example, we will bring in multiple curves.
;
; Create variables to contain data. ydra is dimensioned ncurve by npts.
;
npts = 500
ncurve = 4
ydra = new((/ncurve,npts/), float)
;
; This code segment leaves out the step of loading values into ydra.
; See the complete example mentioned below.
;
; If only one axis is defined in a CoordArrays data object, then the
; other axis automatically defaults to (1,2,...,N), where N is the
; number of points in the defined axis.
;
dataid = create "xyData" coordArraysClass defaultapp
    "caYArray": ydra
end create

;
; Create a XyPlot object "plotid".  Connect the data object "dataid".
;
plotid = create "xyPlot" xyPlotClass xworkid
    "xyCoordData": dataid
end create
;
xy_x1_y1n.ncl is an example of a complete visualization script that plots three curves.

Important Note: Here is a somewhat tricky part of the HLU object-oriented interface. When you set the attributes of the curves such as their dash pattern, color, line thickness, etc., it must be done through a special object called the DataSpec object. It cannot be done directly through XyPlot resources. We will see how to do this later in this session.

ScalarField data - 2D arrays for ContourPlot

; create a scalarField data object, where b is a 2-D array of temperature
; as a function of latitude and longitude.
;
sstjan = create "sf" scalarFieldClass noparent
"sfDataArray" : b
"sfXCStartV" :  30.
"sfXCEndV" :   390.
"sfYCStartV" : file1->lat(0)
"sfYCEndV" : file1->lat(dimsizes(file1->lat)-1)
end create
;
; Assign the ScalarField data object "sstjan" to ContourPlot object "cn".
;
cn = create "cn" contourPlotClass x
"cnScalarFieldData" : sstjan
end create

cn_defaultn.ncl is a full NCL script that incorporates the use of a ScalarField data object.

VectorField data - 2D arrays for VectorPlot

vf =  addfile (datafile,"r")    ; Load netCDF file "vf"

; create a VectorField data object, U and V are 4-D arrays which are a
; function of time, level, latitude and longitude.  Use the 1st time & level.
;
vfield = create "VectorField" vectorFieldClass appid
    "vfUDataArray" : vf->U(0,0,:,:)
    "vfVDataArray" : vf->V(0,0,:,:)

;                               Specify X from the ist longitude to the last
    "vfXCStartV" : vf->lon(0)
    "vfXCEndV" : vf->lon(dimsizes(vf->lon) - 1)

;                               Specify Y from the ist latitude to the last
    "vfYCStartV" : vf->lat(0)
    "vfYCEndV" : vf->lat(dimsizes(vf->lat) - 1)

;                               Specify a stride of 3 in both dimensions
    "vfXCStride" : 3          ; i.e., plot a vector at every 4th point.
    "vfYCStride" : 3
  end create
;
; Create a VectorPlot object "vcid" and connect the data object "vfield".
;
vcid = create "vectorplot" vectorPlotClass wid
    "vcVectorFieldData":      vfield
end create

vc_speedn.ncl is a full NCL script that incorporates the use of a VectorField data object.


Visualizing User Data

Visualizing 1-D arrays - X vs Y plots

Data input

In this XyPlot example, we will read data from a netCDF file that is included with Version 4.0 of NCAR Graphics. The NCL code to do this is:
;
; Open NCAR Graphics NetCDF file containing temperature forecast information.
;
filedir = ncargpath("data")
filename = filedir + "/cdf/contour.cdf"
a = addfile(filename,"r")
print (a)
The ncargpath function locates the NCAR Graphics "data" directory on our system. This UNIX path is then appended to "/cdf/contour.cdf" so that we can read the file contour.cdf using the addfile function. To see the contents of this file, we will use the NCL print function. A partial list of the contents of file a is:
filename:       contour
path:   /cyclone/ncargd/dev/sun4_SunOS_4_1_3_U1/lib/ncarg/data/cdf/contour.cdf
[The above path is specific to your current NCAR Graphics host]
	file global attributes:
		history
		title
	dimensions:
		frtime = 7
		level = 10
		lat = 33
		lon = 36
	variables:
		float T ( frtime, level, lat, lon )
			long_name
			units
			valid_range
			_FillValue
		long frtime ( frtime )
			long_name
			units
		float level ( level )
			long_name
			units
		float lat ( lat )
			long_name
			units
		float lon ( lon )
			long_name
			units
The temperature variable (T) is a function of four variables: time, pressure level, latitude, and longitude. There are ten pressure levels. To discover what they are, we can execute NCL interactively with the string of commands:
ncl
filedir = ncargpath("data")
filename = filedir + "/cdf/contour.cdf"
a = addfile(filename,"r")
print (a->level)
quit
The NCL syntax a->level says extract the variable "level" from the file "a". The result of the print statement will be:
Variable: level (file variable)
Type: float
Total Size: 40 bytes
	    10 values
Number of Dimensions: 1
Dimensions and sizes:   [level | 10]
Coordinates:
	    level: [xx..xx]
Number Of Attributes: 2
units
long_name
(0)     1000
(1)     850
(2)     700
(3)     500
(4)     400
(5)     300
(6)     250
(7)     200
(8)     150
(9)     100
Thus, we see that the ten pressure levels at which temperature is sampled vary from 1000mb to 100mb.

Select PostScript output

In this case, we will arbitrarily choose to output PostScript by setting our if-then switches to:
; Select a PostScript file as the form of output
;
NCGM=0
X11=0
PS=1

Create a data object

;
; Create a CoordArrays data object with pressure levels loaded into
; caYArray and convert from Degrees K to Degrees F for caXArray.
;
field1 = create "field1" coordArraysClass defaultapp

     "caYArray": (a->level(:))
     "caXArray": (a->T(0,:,16,0) - 273.15) * 9 / 5 + 32.0
end create
The variable "level" is 1-dimensional. The colon subscripting of level(:) says use all available values in this dimension. T is a 4-dimensional variable of form T(time,level,latitude,longitude). In our indexing of T, we are requesting the first time step, all levels, the 17th latitude, and the first longitude. To see what the time, latitude, and longitude are, we can execute NCL interactively as follows:
ncl
filedir = ncargpath("data")
filename = filedir + "/cdf/contour.cdf"
a = addfile(filename,"r")
print (a->frtime(0))
print (a->lat(16))
print (a->lon(0))
quit
The output will show that the time is 0 hours, the latitude is 40 degrees north and the longitude is 140 degrees east. Note that we could print all the values of a variable using either no index or a colon. We can also print a range of indices using (index1:index2).

Create an XyPlot object

Finally, we create an XyPlot object and send it to our workstation (a PostScript file).
;
; Create XyPlot object and assign data to it
;
xy_plot = create "xy_plot" xyPlotClass wks
    "xyCoordData": field1
end create
draw(xy_plot)
frame(wks)
We have already placed all of these segments of NCL script into a template called xy_template1.ncl. It can be copied into your directory via the file/save as menus of your browser and executed with the command:

ncl < xy_template1.ncl

A PostScript file named xy_template1.ps is created. It can be plotted with the ghostscript interpreter gs via the command:

gs xy_template1.ps

The graphic should look like:

Using multiple XyPlot resources to configure our plot

So far we have used a fairly modest number of resources in changing the appearance of a graphical object. This time let's make some major changes to our pressure/temperature plot. For one thing, we would like to see the pressure scale correspond to the way pressure appears in the atmosphere (decreasing with altitude). We will also choose an irregular scale in the pressure dimension. We will add a set of titles and choose a higher quality filled font from our array of available text fonts. We will also color the data curve green based on index 3 of the "default" color table and increase its width (line thickness in X11 resource terminology).

The new set of resources for the xy_plot object will include:

    "vpXF": .15                 ; set the viewport where the plot will go
    "vpYF": .85
    "vpWidthF" :  .7
    "vpHeightF" : .7
    "trYReverse" : "True"       ; reverse the pressure axis
    "xyYStyle"   : "irregular"  ; make the pressure scale irregular
    "xyYIrregularPoints"   : (/1000.,850.,700.,500.,400.,300.,250.,200.,150.,100./)
;
    "trYMaxF" : 1000.           ; set the scale ranges
    "trYMinF" : 100.
    "trXMaxF" :  40.
    "trXMinF" : -80.
    "tiMainString" : "Upper Air Forecasts"      ; define the titles
    "tiMainFontHeightF" : 0.035                 ; their sizes
    "tiXAxisString" : "Temperature (Deg F)"
    "tiYAxisString" : "Pressure (mb)"
    "tiXAxisFontHeightF" : 0.02
    "tiYAxisFontHeightF" : 0.02
    "tiMainFont" : "helvetica-bold"             ; and the font type
    "tiXAxisFont" : "helvetica-bold"
    "tiYAxisFont" : "helvetica-bold"

The DataSpec object controls the data resources

There is one more change we need to do. The curve data is not controlled by the XyPlot object; it is controlled by the DataSpec (data specification) object. Thus we need to add the following NCL code to change the curve color and thickness:
; Retrieve the name of the xyCoordDataSpec object created for the
; xy_plot object using the getvalues function.
;
getvalues xy_plot
    "xyCoordDataSpec" : xydataspec
end getvalues
;
; Set curve related resources of the xydataspec object.
;
setvalues xydataspec
	"xyLineColor"                   : 3     ; index 3 of the "default"
;                                                 color table is green
	"xyLineThicknessF"              : 3.0   ; triple the line thickness
end setvalues
We will call this new example xy_template2.ncl. It can be copied into your directory via the file/save as menus of your browser and executed with the command:

ncl < xy_template2.ncl

A PostScript file named xy_template2.ps is created. It can be plotted with the ghostscript interpreter gs via the command:

gs xy_template2.ps

The graphic should look like:


Visualizing 2-D arrays - Contour plots

In the XyPlot tutorials, we created a data object and connected it to the XyPlot object. The XyPlot object requires user data in the form of one or more 1-dimensional arrays. The ContourPlot object also needs user data, but of a different type. It needs a 2-dimensional array. This requires a ScalarField data object.

As in the case of the XyPlot templates, we will need to read data, create a data (ScalarField) object, and create a graphical object. In this case, it is a ContourPlot object instead of an XyPlot object. The steps are:

Data input

In this ContourPlot example, we will read data from a netCDF file that is available from the Unidata program of UCAR. We will read u and v components of the wind at a 925mb level and use NCL to compute the wind speed.
;
; Read Unidata NetCDF files containing U and V wind components.
;
path = "./"
file1 = addfile(path+"94111000_aU.cdf","r")     ; read U
file2 = addfile(path+"94111000_aV.cdf","r")     ; read V
;print (file1)                                  ; look at the file contents
;print (file2)                                  ; if you so desire
u = new((/73,73/),float)        ; define a new array u(73,73)
v = new((/73,73/),float)        ; define v(73,73)
u = file1->u(0,0,:,:)           ; u and v are 4 dimensional in file1
;                                 u(time,level,lat,lon)
v =  file2->v(0,0,:,:)          ; use the 1st time and level, all lats & lons
;
spd = sqrt(u*u+v*v)             ; compute the wind speed

Select NCGM output

This time we will arbitrarily choose to output an NCGM by setting our if-then switches to:
; Select an ncgm file as the form of output
;
NCGM=1
X11=0
PS=0

Create a Data object

;
; Create a ScalarField data object with the computed wind speed.
;
cndata = create "cndata" scalarFieldClass defaultapp
"sfDataArray" : spd                             ; the data to plot is spd
"sfXCStartV" :  file1->lon(0)                   ; longitude range of file1
"sfXCEndV"   :  file1->lon(dimsizes(file1->lon)-1)
"sfYCStartV" :  file1->lat(0)                   ; latitude range of file1
"sfYCEndV"   :  file1->lat(dimsizes(file1->lat)-1)
end create
The wind speed is a function of latitude and longitude. We will simply assign max and min values based on the first and last values in the lat and lon arrays.

Create a ContourPlot object with default resources

Finally, we create a ContourPlot object and send it to our workstation (an NCGM file). We allow all resources to default except of course connecting the ScalarField data object "cndata".
;
; Create the ContourPlot object and assign data to it
;
cn_plot = create "cn_plot" contourPlotClass wks
;
 "cnScalarFieldData" : cndata              ; assign the data object
end create
;
draw(cn_plot)                                   ; draw the contour plot
frame(wks)                                      ; advance the frame
We have already placed all of these segments of NCL script into a template called cn_template0.ncl. It can be copied into your directory via the file/save as menus of your browser and executed with the command:

ncl < cn_template0.ncl

An NCGM file named cn_template0.ncgm is created. It can be plotted with the NCAR NCGM interpreter ctrans via the command:

ctrans -d X11 cn_template0.ncgm

The graphic should look like:

Well there are a lot of problems with this wind speed contour plot. We can't tell highs from lows, it has too many contour lines, the X scales don't go to the edges, X covers 360 degrees and Y only 180 but there is a square viewport, there are no titles.... Let's reconfigure the plot by changing some resources.

Change ContourPlot resources

This time we will set a bunch of resources to accomplish filled-color contours with a defining color label bar.
;
; Create the ContourPlot object and assign data to it
;
cn_plot = create "cn_plot" contourPlotClass wks
;
"vpXF" : .10                               ; set the viewport
"vpYF" : .80
"vpWidthF" : .80
"vpHeightF" : .40
 "cnScalarFieldData" : cndata              ; assign the data object
 "cnFillOn" : "True"                       ; turn on contour fills
 "cnFillColors": (/3,4,5,6,7,8,9,10,11,12,13,14,15/)  ; contour fill colors
;
; Set the range and spacing of the contour levels.
;
 "cnLevelSelectionMode" : "ManualLevels"
 "cnMinLevelValF" : 2.0
 "cnMaxLevelValF" : 28.0
 "cnLevelSpacingF" : 3.0
;
; Turn off the contour lines and labels except the information label
;
 "cnLinesOn" : "False"
 "cnLineLabelsOn" : "False"
 "cnHighLabelsOn" : "False"
 "cnLowLabelsOn" : "False"
 "cnInfoLabelOn" : "True"
;
 "tmXBLabelFontHeightF" :  .015         ; set x axis scale size
 "tmYLLabelFontHeightF" :  .015         ; set y axis scale size
;
 "pmLabelBarDisplayMode" : "ALWAYS"     ; turn on the overlay labelbar
 "pmLabelBarHeightF" : .15              ; set the labelbar height
 "pmLabelBarWidthF" : .8                ;                  width
 "pmLabelBarSide" : "bottom"            ; location and orientation
;
 "lbOrientation" : "horizontal"
 "lbBoxLinesOn" : 0                     ; no lines between labelbar colors
 "lbLabelsOn" : "True"                  ; turn on the labels
 "lbPerimOn" : "False"                  ; turn off the box around the labelbar
 "lbAutoManage"       : "False"         ; allows us to control label sizes
 "lbLabelFontHeightF" : 0.015           ; set the label size
 "lbLabelFont"        : "times-roman"   ;               font
end create
;
draw(cn_plot)                                   ; draw the contour plot
frame(wks)                                      ; advance the frame
We placed this updated script into the previous example to create a new template called cn_template1.ncl. It can be copied into your directory via the file/save as menus of your browser and executed with the command:

ncl < cn_template1.ncl

An NCGM named cn_template1.ncgm is created. It can be plotted with the NCAR NCGM interpreter ctrans via the command:

ctrans -d X11 cn_template1.ncgm

The graphic should look like:

Well there are a few things we still don't like about this wind speed contour plot. First, the color bar has too many blues and yellows that are too similar. It is hard to interpret the highs and lows in the plot. Let's implement a new color map.

Define a custom color map

Here is the NCL code to define a new color map named cmap and assign it to our output workstation:
;
; Generate a new color map. Color indices '0' and '1' are the background
; and foreground colors respectively.
;
ncolors = 16
cmap = new( (/ncolors,3/), float)
;
cmap(0,:) = (/1.00,1.00,1.00/)  ; white
cmap(1,:) = (/0.00,0.00,0.00/)  ; black
cmap(2,:) = (/0.00,0.00,1.00/)  ; blue
cmap(3,:) = (/0.20,0.56,0.80/)  ; sky blue
cmap(4,:) = (/0.00,1.00,1.00/)  ; cyan
cmap(5,:) = (/0.50,0.00,1.00/)  ; blue magenta
cmap(6,:) = (/0.00,1.00,0.00/)  ; green
cmap(7,:) = (/0.14,0.56,0.14/)  ; forest green
cmap(8,:) = (/1.00,1.00,0.00/)  ; yellow
cmap(9,:) = (/1.00,0.50,0.00/)  ; orange
cmap(10,:) = (/1.00,0.00,1.00/) ; magenta
cmap(11,:) = (/1.00,0.00,0.00/) ; red
cmap(12,:) = (/0.65,0.16,0.16/) ; brown
cmap(13,:) = (/0.86,0.58,0.44/) ; tan
cmap(14,:) = (/0.66,0.66,0.66/) ; light gray
cmap(15,:) = (/0.40,0.40,0.40/) ; dark gray
;
; Now assign this color map to the selected workstation.
; using resource wkColorMap as in:
;
;wks = create "wks" ncgmWorkstationClass defaultapp
;      "wkColorMap" : cmap
;end create
;
; NOTE:  This resource applies to all workstation types.
;
Finally, we need to define the contour colors using the ContourPlot resource cnFillColors.

This new code was put into cn_template2.ncl. It can be copied into your directory via the file/save as menus of your browser and executed with the command:

ncl < cn_template2.ncl

An NCGM named cn_template2.ncgm is created. It can be plotted with the NCAR NCGM interpreter ctrans via the command:

ctrans -d X11 cn_template2.ncgm

The graphic should look like:

Okay, now we can at least tell where the highs and lows are. The low areas are shaded in grays, the high areas are in yellow to red. However, this still isn't a very appealing map. Let's change it to have color-filled land, a better set of longitude scales, suppress the information label, and add some Main, X, and Y titles.

Add a MapPlot object

We can import the map example from mp_template1.ncl. It had a cylindrical equidistant projection that we want. We saw in mp_template2.ncl that we could turn on the map fill with the resource mpFillOn set to True. We will also select the same viewport we are using for the ContourPlot object. The NCL script is:
map = create "map" mapPlotClass wks
   "vpXF" : .10                         ; define the viewport location
   "vpYF" : .80
   "vpWidthF" : .80                     ; and size
   "vpHeightF" : .40
;  "mpFillOn"  :  "True"                ; fill the map
;  "mpFillColor"  : 1                   ; with the color black
;  "mpOceanFillColor" : "Transparent"
end create

draw(map)
Starting from cn_template2.ncl, changing some ContourPlot resources, and adding this MapPlot object produces a new example we will call cn_template3.ncl. It can be copied into your directory via the file/save as menus of your browser and executed with the command:

ncl < cn_template3.ncl

An NCGM named cn_template3.ncgm is created. It can be plotted with the NCAR NCGM interpreter ctrans via the command:

ctrans -d X11 cn_template3.ncgm

The graphic should look like:

Well our plot is starting to look a little better. Want to play with a few more resources? You may want to change your workstation to be an X11 window. This way you can change a resource or resources and immediately see the result when you execute your NCL script. To help you navigate your way through the many resources of ContourPlot, it may be helpful to know some of the components of a ContourPlot graphic that have multiple resources. They include:

HLU ContourPlot resources are part of the online NCAR Graphics documentation set. Note that the resources are documented in the HLU Reference Guide, not the NCL Reference Guide.


Return to NCL Scientific Tutorial.

User Guide Control Panel

NG4 Home, Index, Examples, Glossary, Feedback, UG Contents, UG WhereAmI?


$Revision: 1.8 $ $Date: 1996/05/30 13:48:18 $