Grace User's Guide (for Grace-5.1.7)

by the Grace Team

1. Introduction

• 1.1 What is Grace?
• 1.2 Copyright statement

2. Installation guide

• 2.1 Installing from sources
• 2.2 Binary installation
• 2.3 Alternative packaging schemes (RPM, ...)

3. Getting started

• 3.1 General concepts
• 3.2 Invocation
• 3.3 Customization

4. Guide to the graphical user interface

• 4.1 GUI controls
• 4.2 The main window
• 4.3 File menu
• 4.4 Edit menu
• 4.5 Data menu
• 4.6 Plot menu
• 4.7 View menu
• 4.8 Window menu
• 4.9 Help menu

5. Command interpreter

• 5.1 General notes
• 5.2 Definitions
• 5.3 Variables
• 5.4 Numerical operators and functions
• 5.5 Procedures
• 5.6 Device parameters
• 5.7 Flow control
• 5.8 Declarations
• 5.9 Graph properties
• 5.10 Set properties

6. Advanced topics

• 6.1 Fonts
• 6.2 Interaction with other applications
• 6.3 FFTW tuning
• 6.4 DL modules

7. References

• 7.1 Typesetting
• 7.2 Device-specific limitations
• 7.3 Device-specific settings
• 7.4 Dates in Grace
• 7.5 Xmgr to Grace migration guide

1. Introduction

1.1 What is Grace?

Grace is a WYSIWYG tool to make two-dimensional plots of numerical data. It runs under various (if not all) flavors of Unix with X11 and M*tif (LessTif or Motif). It also runs under VMS, OS/2, and Windows (95/98/NT/2000). Its capabilities are roughly similar to GUI-based programs like Sigmaplot or Microcal Origin plus script-based tools like Gnuplot or Genplot. Its strength lies in the fact that it combines the convenience of a graphical user interface with the power of a scripting language which enables it to do sophisticated calculations or perform automated tasks.

Grace is derived from Xmgr (a.k.a. ACE/gr), originally written by Paul Turner.

From version number 4.00, the development was taken over by a team of volunteers under the coordination of Evgeny Stambulchik. You can get the newest information about Grace and download the latest version at the Grace home page.

When its copyright was changed to GPL, the name was changed to Grace, which stands for ``GRaphing, Advanced Computation and Exploration of data'' or ``Grace Revamps ACE/gr''. The first version of Grace available is named 5.0.0, while the last public version of Xmgr has the version number 4.1.2.

Paul still maintains and develops a non-public version of Xmgr for internal use.

1.2 Copyright statement

Copyright (©) 1991-1995 Paul J Turner, Portland, OR
Copyright (©) 1996-2002 Grace Development Team

Maintained by Evgeny Stambulchik


                         All Rights Reserved

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

For certain libraries required to build Grace (which are therefore even included in a suitable version) there may be different Copyright/License statements. Though their License may by chance match the one used for Grace, the Grace Copyright holders can not influence or change them.

2. Installation guide

2.1 Installing from sources

1. Configuration
   • Requirements. Grace usually compiles out of the box in a regular Unix-like environment. You need an ANSI C compiler (gcc is just fine), the X11R5 or above libraries and headers, and an implementaion of the M*tif API, version 1.2 or above. If you want to compile your own changes to certain parts of Grace, you will need a parser generator (yacc or, better, bison).
   • Extra libraries. Some features will be available only if additional libraries are installed. Those are:
     • The JPEG backend needs the IJG's ( JPEG library), version 6.x.
     • The PNG backend needs the ( libpng) library (version 0.96 or above).
     • The PDF driver requires the PDFlib library of Thomas Merz to be installed, which is available here, version 3.02 or above.
     • If your computer has the FFTW library installed when Grace is compiled, Grace will link itself to this, and drop all conventional FFT's and DFT's. All transforms will be routed through this package. Note that there is then no difference between pushing the "FFT" button and the "DFT" button, except that FFT will complain if the length isn't a power of 2, and DFT will not. For more information on this package, see the FFTW Home page. In short, this package allows one to do non-power-of-2 length FFT's along with the normal ones. It seems to work very efficiently for any set length which factors into 2^a 3^b 5^c 7^d for integer a, b, c, d. The great feature here is that set lengths which are powers of 10 (e.g. 1000, 10000) and integer multiples of these (500, 2000, 2500, 5000, etc.) can be computed with no significant penalty (maybe 20%) over power-of-2 transforms. Very often, real datasets come in these sizes, and not in powers of 2.
     • In order to read/write sets in the NetCDF data format, you will also need the NetCDF libraries.
   • Decide whether you want to compile in a separate place (thus leaving the source tree pristine). You most probably would want it if compiling Grace for more than one OS and keeping the sources in a central shared (e.g. via NFS) location. If you don't need it, skip the rest of this paragraph and go right to the next step. Otherwise, assuming the sources are in /usr/local/src/grace-x.y.z and the compilation will be performed in /tmp/grace-obj, do the following:

       % mkdir /tmp/grace-obj
       % cd /tmp/grace-obj
       % /usr/local/src/grace-x.y.z/ac-tools/shtool mkshadow \
         /usr/local/src/grace-x.y.z .
                      
     

   • The configure shell script attempts to guess correct values for various system-dependent variables used during compilation. It uses those values to create Make.conf in the top directory of the package. It also create config.h file containing system-dependent definitions. Finally, it creates a shell script config.status that you can run in the future to recreate the current configuration, a file config.cache that saves the results of its tests to speed up reconfiguring, and a file config.log containing compiler output (useful mainly for debugging configure). If at some point config.cache contains results you don't want to keep, you may remove or edit it.
   • Run ./configure --help to get list of additional switches specific to Grace
   • Run ./configure <options>. Just an example:

       % ./configure --enable-grace-home=/opt/grace 
         --with-extra-incpath=/usr/local/include:/opt/include \
         --with-extra-ldpath=/usr/local/lib:/opt/lib --prefix=/usr
                      
     

     would use /usr/local/include and /opt/include in addition to the default include path and /usr/local/lib and /opt/lib in addition to the default ld path. As well, all stuff would be put under the /opt/grace directory and soft links made to /usr/bin, /usr/lib and /usr/include.

     Note: If you change one of the --with-extra-incpath or --with-extra-ldpath options from one run of configure to another, remember to delete the config.cache file!!!

2. Compilation
   • Issue make

     If something goes wrong, try to see if the problem has been described already in the Grace FAQ (in the doc directory).

3. Testing
   • make tests

     This will give you a slide show demonstrating some nice features of Grace.

4. Installation
   • make install
   • make links

     The later (optional) step will make soft links from some files under the Grace home directory to the system-wide default locations (can be changed by the --prefix option during the configuration, see above).

2.2 Binary installation

1. Getting pre-built packages
2. Installation
3. Running tests

2.3 Alternative packaging schemes (RPM, ...)

Not written yet...

3. Getting started

For a jump-in start, you can browse the demos ("Help/Examples" menu tree). These are ordinary Grace projects, so you can play with them and modify them. Also, read the Tutorial.

O.k. Here's a VERY quick introduction:

1. Start the GUI version: xmgrace (return).
2. Select/check the output medium and canvas size in File/Device Setup.
3. If needed, set the graph size ('Viewport' in Plot/Graph Appearance).
4. Load your data with Data/Import/ASCII. 'Load as': 'Single set' for two-column ASCII data, 'Block data' for multi-column ASCII data.
5. Adjust the scales, axis labels and tick marks in Plot/Axis properties. Acknowledge all changes with 'Apply'.
6. Adjust lines, symbols, legends in Plot/Set appearance.
7. Adjust titles, plot frame and legend display in Plot/Graph Appearance.
8. Data can be manipulated in Data/Transformations. To shift a data set by 20 to the left, e.g., in 'Evaluate Expression' select the same set on the left and the right, and say Formula: y=y-20. As you'll probably notice, Grace can do MUCH more than that. Explore at your leisure.
9. When you like your plot, select File/Print. That's it!

3.1 General concepts

Project files

A project file contains all information necessary to restore a plot created by Grace, as well as some of preferences. Each plot is represented on a single page, but may have an unlimited number of graphs.You create a project file of your current graph with File/Save,Save as.

Parameter files

A parameter file contains the detailed settings of your project. It can be used to transfer these settings to a different plot/project. You generate a parameter file with File/Save menu entry selected from the "Plot/Graph appearance popup". You can load the settings contained in a parameter file with File/Open.

Input File formats

Grace understands several input files formats. The most basic one is ASCII text files containing space and comma separated columns of data. The data fields can be either numeric (Fortran 'd' and 'D' exponent markers are supported) or alphanumeric (with or without quotes). Several calendar date formats are recognized automatically and you can specify your own reference for numeric dates formats. Grace also has a command language (see command interpreter), you can include commands in data files using lines having "@" as their first non-blank character. Depending on configuration, Grace can also read NetCDF files (see configuration).

Graphs

A graph consists of (every element is optional): a graph frame, axes, a title and a subtitle, a number of sets and additional annotative objects (time stamp string, text strings, lines, boxes and ellipses).

The graph type can be any of:

• XY Graph
• XY Chart
• Polar Graph
• Fixed Graph
• Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it:

Regions

Regions are sections of the graph defined by the interior or exterior of a polygon, or a half plane defined by a line. Regions are used to restrict data transformations to a geometric area occupied by region.

Real Time Input

Real Time Input refers to the ability Grace has to be fed in real time by an external program. The Grace process spawned by the driver program is a full featured Grace process: the user can interact using the GUI at the same time the program sends data and commands. The process will adapt itself to the incoming data rate.

Hotlinks

Hotlinks are sources containing varying data. Grace can be instructed a file or a pipe is a hotlink in which case it will provide specific commands to refresh the data on a mouse click (a later version will probably allow automatic refresh).

Devices

Grace allows the user to choose between several output devices to produce its graphics. The current list of supported devices is:

• X11
• PostScript (level 1 and level 2)
• EPS (encapsulated PostScript)
• Metafile (which is Grace format, used at the moment mostly for debugging purposes)
• MIF (Maker Interchange Format used by FrameMaker)
• SVG (Scalable Vector Graphics, a language for describing two-dimensional vector and mixed vector/raster graphics in XML)
• PDF (depends on extra libraries, see configuration)
• PNM (portable anymap file format)
• JPEG (depends on extra libraries, see configuration)
• PNG (depends on extra libraries, see configuration)

Note that Grace no longer supports GIF due to the copyright policy of Unisys. Grace can also be instructed to launch conversion programs automatically based on file name. As an example you can produce MIF (FrameMaker Interchange Format) or Java applets using pstoedit, or almost any image format using the netpbm suite (see the FAQ).

Magic path

In many cases, when Grace needs to access a file given with a relative pathname, it searches for the file along the following path: ./pathname:./.grace/pathname:~/.grace/pathname:$GRACE_HOME/pathname

Dynamic modules

Grace can access external functions present in either system or third-party shared libraries or modules specially compiled for use with it. The term dynamic refers to the possibility Grace has to open the library at run time to find the code of the external function, there is no need to recompile Grace itself (the functions already compiled in Grace are "statically linked").

Coordinate frames

There are two types of coordinates in Grace: the world coordinates and the viewport coordinates. Points of data sets are defined in the world coordinates. The viewport coordinates correspond to the image of the plot drawn on the canvas (or printed on, say, PS output page). The transformation converting the world coordinates into the viewport ones is determined by both the graph type and the axis scaling.

Actually, there is yet another level in the hierarchy of coordinates - the device coordinates. However, you (as a user of Grace) should not worry about les ouLI> Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it:

Regions

Regions are sections of the graph defined by the interior or exterior of a polygon, or a half plane defined by a line. Regions are used to restrict data transformations to a geometric area occupied by region.

Real Time Input

Real Time Input refers to the ability Grace has to be fed in real time by an external program. The Grace process spawned by the driver program is a full featured Grace process: the user can interact using the GUI at the same time the program sends data and commands. The process will adapt itself to the incoming data rate.

Hotlinks

Hotlinks are sources containing varying data. Grace can be instructed a file or a pipe is a hotlink in which case it will provide specific commands to refresh the data on a mouse click (a later version will probably allow automatic refresh).

Devices

Grace allows the user to choose between several output devices to produce its graphics. The current list of supported devices is:

• X11
• PostScript (level 1 and level 2)
• EPS (encapsulated PostScript)
• Metafile (which is Grace format, used at the moment mostly for debugging purposes)
• MIF (Maker Interchange Format used by FrameMaker)
• SVG (Scalable Vector Graphics, a language for describing two-dimensional vector and mixed vector/raster graphics in XML)
• PDF (depends on extra libraries, see configuration)
• PNM (portable anymap file format)
• JPEG (depends on extra libraries, see configuration)
• PNG (depends on extra libraries, see configuration)

Note that Grace no longer supports GIF due to the copyright policy of Unisys. Grace can also be instructed to launch conversion programs automatically based on file name. As an example you can produce MIF (FrameMaker Interchange Format) or Java applets using pstoedit, or almost any image format using the netpbm suite (see the FAQ).

Magic path

In many cases, when Grace needs to access a file given with a relative pathname, it searches for the file along the following path: ./pathname:./.grace/pathname:~/.grace/pathname:$GRACE_HOME/pathname

Dynamic modules

Grace can access external functions present in either system or third-party shared libraries or modules specially compiled for use with it. The term dynamic refers to the possibility Grace has to open the library at run time to find the code of the external function, there is no need to recompile Grace itself (the functions already compiled in Grace are "statically linked").

Coordinate frames

There are two types of coordinates in Grace: the world coordinates and the viewport coordinates. Points of data sets are defined in the world coordinates. The viewport coordinates correspond to the image of the plot drawn on the canvas (or printed on, say, PS output page). The transformation converting the world coordinates into the viewport ones is determined by both the graph type and the axis scaling.

Actually, there is yet another level in the hierarchy of coordinates - the device coordinates. However, you (as a user of Grace) should not worry about les ouLI> Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it:

Regions

Regions are sections of the graph defined by the interior or exterior of a polygon, or a half plane defined by a line. Regions are used to restrict data transformations to a geometric area occupied by region.

Real Time Input

Real Time Input refers to the ability Grace has to be fed in real time by an external program. The Grace process spawned by the driver program is a full featured Grace process: the user can interact using the GUI at the same time the program sends data and commands. The process will adapt itself to the incoming data rate.

Hotlinks

Hotlinks are sources containing varying data. Grace can be instructed a file or a pipe is a hotlink in which case it will provide specific commands to refresh the data on a mouse click (a later version will probably allow automatic refresh).

Devices

Grace allows the user to choose between several output devices to produce its graphics. The current list of supported devices is:

• X11
• PostScript (level 1 and level 2)
• EPS (encapsulated PostScript)
• Metafile (which is Grace format, used at the moment mostly for debugging purposes)
• MIF (Maker Interchange Format used by FrameMaker)
• SVG (Scalable Vector Graphics, a language for describing two-dimensional vector and mixed vector/raster graphics in XML)
• PDF (depends on extra libraries, see configuration)
• PNM (portable anymap file format)
• JPEG (depends on extra libraries, see configuration)
• PNG (depends on extra libraries, see configuration)

Note that Grace no longer supports GIF due to the copyright policy of Unisys. Grace can also be instructed to launch conversion programs automatically based on file name. As an example you can produce MIF (FrameMaker Interchange Format) or Java applets using pstoedit, or almost any image format using the netpbm suite (see the FAQ).

Magic path

In many cases, when Grace needs to access a file given with a relative pathname, it searches for the file along the following path: ./pathname:./.grace/pathname:~/.grace/pathname:$GRACE_HOME/pathname

Dynamic modules

Grace can access external functions present in either system or third-party shared libraries or modules specially compiled for use with it. The term dynamic refers to the possibility Grace has to open the library at run time to find the code of the external function, there is no need to recompile Grace itself (the functions already compiled in Grace are "statically linked").

Coordinate frames

There are two types of coordinates in Grace: the world coordinates and the viewport coordinates. Points of data sets are defined in the world coordinates. The viewport coordinates correspond to the image of the plot drawn on the canvas (or printed on, say, PS output page). The transformation converting the world coordinates into the viewport ones is determined by both the graph type and the axis scaling.

Actually, there is yet another level in the hierarchy of coordinates - the device coordinates. However, you (as a user of Grace) should not worry about les ouLI> Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it:

Regions

Regions are sections of the graph defined by the interior or exterior of a polygon, or a half plane defined by a line. Regions are used to restrict data transformations to a geometric area occupied by region.

Real Time Input

Real Time Input refers to the ability Grace has to be fed in real time by an external program. The Grace process spawned by the driver program is a full featured Grace process: the user can interact using the GUI at the same time the program sends data and commands. The process will adapt itself to the incoming data rate.

Hotlinks

Hotlinks are sources containing varying data. Grace can be instructed a file or a pipe is a hotlink in which case it will provide specific commands to refresh the data on a mouse click (a later version will probably allow automatic refresh).

Devices

Grace allows the user to choose between several output devices to produce its graphics. The current list of supported devices is:

• X11
• PostScript (level 1 and level 2)
• EPS (encapsulated PostScript)
• Metafile (which is Grace format, used at the moment mostly for debugging purposes)
• MIF (Maker Interchange Format used by FrameMaker)
• SVG (Scalable Vector Graphics, a language for describing two-dimensional vector and mixed vector/raster graphics in XML)
• PDF (depends on extra libraries, see configuration)
• PNM (portable anymap file format)
• JPEG (depends on extra libraries, see configuration)
• PNG (depends on extra libraries, see configuration)

Note that Grace no longer supports GIF due to the copyright policy of Unisys. Grace can also be instructed to launch conversion programs automatically based on file name. As an example you can produce MIF (FrameMaker Interchange Format) or Java applets using pstoedit, or almost any image format using the netpbm suite (see the FAQ).

Magic path

In many cases, when Grace needs to access a file given with a relative pathname, it searches for the file along the following path: ./pathname:./.grace/pathname:~/.grace/pathname:$GRACE_HOME/pathname

Dynamic modules

Grace can access external functions present in either system or third-party shared libraries or modules specially compiled for use with it. The term dynamic refers to the possibility Grace has to open the library at run time to find the code of the external function, there is no need to recompile Grace itself (the functions already compiled in Grace are "statically linked").

Coordinate frames

There are two types of coordinates in Grace: the world coordinates and the viewport coordinates. Points of data sets are defined in the world coordinates. The viewport coordinates correspond to the image of the plot drawn on the canvas (or printed on, say, PS output page). The transformation converting the world coordinates into the viewport ones is determined by both the graph type and the axis scaling.

Actually, there is yet another level in the hierarchy of coordinates - the device coordinates. However, you (as a user of Grace) should not worry about les ouLI> Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it:

Regions

Regions are sections of the graph defined by the interior or exterior of a polygon, or a half plane defined by a line. Regions are used to restrict data transformations to a geometric area occupied by region.

Real Time Input

Real Time Input refers to the ability Grace has to be fed in real time by an external program. The Grace process spawned by the driver program is a full featured Grace process: the user can interact using the GUI at the same time the program sends data and commands. The process will adapt itself to the incoming data rate.

Hotlinks

Hotlinks are sources containing varying data. Grace can be instructed a file or a pipe is a hotlink in which case it will provide specific commands to refresh the data on a mouse click (a later version will probably allow automatic refresh).

Devices

Grace allows the user to choose between several output devices to produce its graphics. The current list of supported devices is:

• X11
• PostScript (level 1 and level 2)
• EPS (encapsulated PostScript)
• Metafile (which is Grace format, used at the moment mostly for debugging purposes)
• MIF (Maker Interchange Format used by FrameMaker)
• SVG (Scalable Vector Graphics, a language for describing two-dimensional vector and mixed vector/raster graphics in XML)
• PDF (depends on extra libraries, see configuration)
• PNM (portable anymap file format)
• JPEG (depends on extra libraries, see configuration)
• PNG (depends on extra libraries, see configuration)

Note that Grace no longer supports GIF due to the copyright policy of Unisys. Grace can also be instructed to launch conversion programs automatically based on file name. As an example you can produce MIF (FrameMaker Interchange Format) or Java applets using pstoedit, or almost any image format using the netpbm suite (see the FAQ).

Magic path

In many cases, when Grace needs to access a file given with a relative pathname, it searches for the file along the following path: ./pathname:./.grace/pathname:~/.grace/pathname:$GRACE_HOME/pathname

Dynamic modules

Grace can access external functions present in either system or third-party shared libraries or modules specially compiled for use with it. The term dynamic refers to the possibility Grace has to open the library at run time to find the code of the external function, there is no need to recompile Grace itself (the functions already compiled in Grace are "statically linked").

Coordinate frames

There are two types of coordinates in Grace: the world coordinates and the viewport coordinates. Points of data sets are defined in the world coordinates. The viewport coordinates correspond to the image of the plot drawn on the canvas (or printed on, say, PS output page). The transformation converting the world coordinates into the viewport ones is determined by both the graph type and the axis scaling.

Actually, there is yet another level in the hierarchy of coordinates - the device coordinates. However, you (as a user of Grace) should not worry about les ouLI> Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it:

Regions

Regions are sections of the graph defined by the interior or exterior of a polygon, or a half plane defined by a line. Regions are used to restrict data transformations to a geometric area occupied by region.

Real Time Input

Real Time Input refers to the ability Grace has to be fed in real time by an external program. The Grace process spawned by the driver program is a full featured Grace process: the user can interact using the GUI at the same time the program sends data and commands. The process will adapt itself to the incoming data rate.

Hotlinks

Hotlinks are sources containing varying data. Grace can be instructed a file or a pipe is a hotlink in which case it will provide specific commands to refresh the data on a mouse click (a later version will probably allow automatic refresh).

Devices

Grace allows the user to choose between several output devices to produce its graphics. The current list of supported devices is:

• X11
• PostScript (level 1 and level 2)
• EPS (encapsulated PostScript)
• Metafile (which is Grace format, used at the moment mostly for debugging purposes)
• MIF (Maker Interchange Format used by FrameMaker)
• SVG (Scalable Vector Graphics, a language for describing two-dimensional vector and mixed vector/raster graphics in XML)
• PDF (depends on extra libraries, see configuration)
• PNM (portable anymap file format)
• JPEG (depends on extra libraries, see configuration)
• PNG (depends on extra libraries, see configuration)

Note that Grace no longer supports GIF due to the copyright policy of Unisys. Grace can also be instructed to launch conversion programs automatically based on file name. As an example you can produce MIF (FrameMaker Interchange Format) or Java applets using pstoedit, or almost any image format using the netpbm suite (see the FAQ).

Magic path

In many cases, when Grace needs to access a file given with a relative pathname, it searches for the file along the following path: ./pathname:./.grace/pathname:~/.grace/pathname:$GRACE_HOME/pathname

Dynamic modules

Grace can access external functions present in either system or third-party shared libraries or modules specially compiled for use with it. The term dynamic refers to the possibility Grace has to open the library at run time to find the code of the external function, there is no need to recompile Grace itself (the functions already compiled in Grace are "statically linked").

Coordinate frames

There are two types of coordinates in Grace: the world coordinates and the viewport coordinates. Points of data sets are defined in the world coordinates. The viewport coordinates correspond to the image of the plot drawn on the canvas (or printed on, say, PS output page). The transformation converting the world coordinates into the viewport ones is determined by both the graph type and the axis scaling.

Actually, there is yet another level in the hierarchy of coordinates - the device coordinates. However, you (as a user of Grace) should not worry about les ouLI> Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it:

Regions

Regions are sections of the graph defined by the interior or exterior of a polygon, or a half plane defined by a line. Regions are used to restrict data transformations to a geometric area occupied by region.

Real Time Input

Real Time Input refers to the ability Grace has to be fed in real time by an external program. The Grace process spawned by the driver program is a full featured Grace process: the user can interact using the GUI at the same time the program sends data and commands. The process will adapt itself to the incoming data rate.

Hotlinks

Hotlinks are sources containing varying data. Grace can be instructed a file or a pipe is a hotlink in which case it will provide specific commands to refresh the data on a mouse click (a later version will probably allow automatic refresh).

Devices

Grace allows the user to choose between several output devices to produce its graphics. The current list of supported devices is:

• X11
• PostScript (level 1 and level 2)
• EPS (encapsulated PostScript)
• Metafile (which is Grace format, used at the moment mostly for debugging purposes)
• MIF (Maker Interchange Format used by FrameMaker)
• SVG (Scalable Vector Graphics, a language for describing two-dimensional vector and mixed vector/raster graphics in XML)
• PDF (depends on extra libraries, see configuration)
• PNM (portable anymap file format)
• JPEG (depends on extra libraries, see configuration)
• PNG (depends on extra libraries, see configuration)

Note that Grace no longer supports GIF due to the copyright policy of Unisys. Grace can also be instructed to launch conversion programs automatically based on file name. As an example you can produce MIF (FrameMaker Interchange Format) or Java applets using pstoedit, or almost any image format using the netpbm suite (see the FAQ).

Magic path

In many cases, when Grace needs to access a file given with a relative pathname, it searches for the file along the following path: ./pathname:./.grace/pathname:~/.grace/pathname:$GRACE_HOME/pathname

Dynamic modules

Grace can access external functions present in either system or third-party shared libraries or modules specially compiled for use with it. The term dynamic refers to the possibility Grace has to open the library at run time to find the code of the external function, there is no need to recompile Grace itself (the functions already compiled in Grace are "statically linked").

Coordinate frames

There are two types of coordinates in Grace: the world coordinates and the viewport coordinates. Points of data sets are defined in the world coordinates. The viewport coordinates correspond to the image of the plot drawn on the canvas (or printed on, say, PS output page). The transformation converting the world coordinates into the viewport ones is determined by both the graph type and the axis scaling.

Actually, there is yet another level in the hierarchy of coordinates - the device coordinates. However, you (as a user of Grace) should not worry about les ouLI> Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it:

Regions

Regions are sections of the graph defined by the interior or exterior of a polygon, or a half plane defined by a line. Regions are used to restrict data transformations to a geometric area occupied by region.

Real Time Input

Real Time Input refers to the ability Grace has to be fed in real time by an external program. The Grace process spawned by the driver program is a full featured Grace process: the user can interact using the GUI at the same time the program sends data and commands. The process will adapt itself to the incoming data rate.

Hotlinks

Hotlinks are sources containing varying data. Grace can be instructed a file or a pipe is a hotlink in which case it will provide specific commands to refresh the data on a mouse click (a later version will probably allow automatic refresh).

Devices

Grace allows the user to choose between several output devices to produce its graphics. The current list of supported devices is:

• X11
• PostScript (level 1 and level 2)
• EPS (encapsulated PostScript)
• Metafile (which is Grace format, used at the moment mostly for debugging purposes)
• MIF (Maker Interchange Format used by FrameMaker)
• SVG (Scalable Vector Graphics, a language for describing two-dimensional vector and mixed vector/raster graphics in XML)
• PDF (depends on extra libraries, see configuration)
• PNM (portable anymap file format)
• JPEG (depends on extra libraries, see configuration)
• PNG (depends on extra libraries, see configuration)

Note that Grace no longer supports GIF due to the copyright policy of Unisys. Grace can also be instructed to launch conversion programs automatically based on file name. As an example you can produce MIF (FrameMaker Interchange Format) or Java applets using pstoedit, or almost any image format using the netpbm suite (see the FAQ).

Magic path

In many cases, when Grace needs to access a file given with a relative pathname, it searches for the file along the following path: ./pathname:./.grace/pathname:~/.grace/pathname:$GRACE_HOME/pathname

Dynamic modules

Grace can access external functions present in either system or third-party shared libraries or modules specially compiled for use with it. The term dynamic refers to the possibility Grace has to open the library at run time to find the code of the external function, there is no need to recompile Grace itself (the functions already compiled in Grace are "statically linked").

Coordinate frames

There are two types of coordinates in Grace: the world coordinates and the viewport coordinates. Points of data sets are defined in the world coordinates. The viewport coordinates correspond to the image of the plot drawn on the canvas (or printed on, say, PS output page). The transformation converting the world coordinates into the viewport ones is determined by both the graph type and the axis scaling.

Actually, there is yet another level in the hierarchy of coordinates - the device coordinates. However, you (as a user of Grace) should not worry about les ouLI> Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it:

Regions

Regions are sections of the graph defined by the interior or exterior of a polygon, or a half plane defined by a line. Regions are used to restrict data transformations to a geometric area occupied by region.

Real Time Input

Real Time Input refers to the ability Grace has to be fed in real time by an external program. The Grace process spawned by the driver program is a full featured Grace process: the user can interact using the GUI at the same time the program sends data and commands. The process will adapt itself to the incoming data rate.

Hotlinks

Hotlinks are sources containing varying data. Grace can be instructed a file or a pipe is a hotlink in which case it will provide specific commands to refresh the data on a mouse click (a later version will probably allow automatic refresh).

Devices

Grace allows the user to choose between several output devices to produce its graphics. The current list of supported devices is:

• X11
• PostScript (level 1 and level 2)
• EPS (encapsulated PostScript)
• Metafile (which is Grace format, used at the moment mostly for debugging purposes)
• MIF (Maker Interchange Format used by FrameMaker)
• SVG (Scalable Vector Graphics, a language for describing two-dimensional vector and mixed vector/raster graphics in XML)
• PDF (depends on extra libraries, see configuration)
• PNM (portable anymap file format)
• JPEG (depends on extra libraries, see configuration)
• PNG (depends on extra libraries, see configuration)

Note that Grace no longer supports GIF due to the copyright policy of Unisys. Grace can also be instructed to launch conversion programs automatically based on file name. As an example you can produce MIF (FrameMaker Interchange Format) or Java applets using pstoedit, or almost any image format using the netpbm suite (see the FAQ).

Magic path

In many cases, when Grace needs to access a file given with a relative pathname, it searches for the file along the following path: ./pathname:./.grace/pathname:~/.grace/pathname:$GRACE_HOME/pathname

Dynamic modules

Grace can access external functions present in either system or third-party shared libraries or modules specially compiled for use with it. The term dynamic refers to the possibility Grace has to open the library at run time to find the code of the external function, there is no need to recompile Grace itself (the functions already compiled in Grace are "statically linked").

Coordinate frames

There are two types of coordinates in Grace: the world coordinates and the viewport coordinates. Points of data sets are defined in the world coordinates. The viewport coordinates correspond to the image of the plot drawn on the canvas (or printed on, say, PS output page). The transformation converting the world coordinates into the viewport ones is determined by both the graph type and the axis scaling.

Actually, there is yet another level in the hierarchy of coordinates - the device coordinates. However, you (as a user of Grace) should not worry about les ouLI> Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it:

Regions

Regions are sections of the graph defined by the interior or exterior of a polygon, or a half plane defined by a line. Regions are used to restrict data transformations to a geometric area occupied by region.

Real Time Input

Real Time Input refers to the ability Grace has to be fed in real time by an external program. The Grace process spawned by the driver program is a full featured Grace process: the user can interact using the GUI at the same time the program sends data and commands. The process will adapt itself to the incoming data rate.

Hotlinks

Hotlinks are sources containing varying data. Grace can be instructed a file or a pipe is a hotlink in which case it will provide specific commands to refresh the data on a mouse click (a later version will probably allow automatic refresh).

Devices

Grace allows the user to choose between several output devices to produce its graphics. The current list of supported devices is:

• X11
• PostScript (level 1 and level 2)
• EPS (encapsulated PostScript)
• Metafile (which is Grace format, used at the moment mostly for debugging purposes)
• MIF (Maker Interchange Format used by FrameMaker)
• SVG (Scalable Vector Graphics, a language for describing two-dimensional vector and mixed vector/raster graphics in XML)
• PDF (depends on extra libraries, see configuration)
• PNM (portable anymap file format)
• JPEG (depends on extra libraries, see configuration)
• PNG (depends on extra libraries, see configuration)

Note that Grace no longer supports GIF due to the copyright policy of Unisys. Grace can also be instructed to launch conversion programs automatically based on file name. As an example you can produce MIF (FrameMaker Interchange Format) or Java applets using pstoedit, or almost any image format using the netpbm suite (see the FAQ).

Magic path

In many cases, when Grace needs to access a file given with a relative pathname, it searches for the file along the following path: ./pathname:./.grace/pathname:~/.grace/pathname:$GRACE_HOME/pathname

Dynamic modules

Grace can access external functions present in either system or third-party shared libraries or modules specially compiled for use with it. The term dynamic refers to the possibility Grace has to open the library at run time to find the code of the external function, there is no need to recompile Grace itself (the functions already compiled in Grace are "statically linked").

Coordinate frames

There are two types of coordinates in Grace: the world coordinates and the viewport coordinates. Points of data sets are defined in the world coordinates. The viewport coordinates correspond to the image of the plot drawn on the canvas (or printed on, say, PS output page). The transformation converting the world coordinates into the viewport ones is determined by both the graph type and the axis scaling.

Actually, there is yet another level in the hierarchy of coordinates - the device coordinates. However, you (as a user of Grace) should not worry about les ouLI> Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it:

Regions

Regions are sections of the graph defined by the interior or exterior of a polygon, or a half plane defined by a line. Regions are used to restrict data transformations to a geometric area occupied by region.

Real Time Input

Real Time Input refers to the ability Grace has to be fed in real time by an external program. The Grace process spawned by the driver program is a full featured Grace process: the user can interact using the GUI at the same time the program sends data and commands. The process will adapt itself to the incoming data rate.

Hotlinks

Hotlinks are sources containing varying data. Grace can be instructed a file or a pipe is a hotlink in which case it will provide specific commands to refresh the data on a mouse click (a later version will probably allow automatic refresh).

Devices

Grace allows the user to choose between several output devices to produce its graphics. The current list of supported devices is:

• X11
• PostScript (level 1 and level 2)
• EPS (encapsulated PostScript)
• Metafile (which is Grace format, used at the moment mostly for debugging purposes)
• MIF (Maker Interchange Format used by FrameMaker)
• SVG (Scalable Vector Graphics, a language for describing two-dimensional vector and mixed vector/raster graphics in XML)
• PDF (depends on extra libraries, see configuration)
• PNM (portable anymap file format)
• JPEG (depends on extra libraries, see configuration)
• PNG (depends on extra libraries, see configuration)

Note that Grace no longer supports GIF due to the copyright policy of Unisys. Grace can also be instructed to launch conversion programs automatically based on file name. As an example you can produce MIF (FrameMaker Interchange Format) or Java applets using pstoedit, or almost any image format using the netpbm suite (see the FAQ).

Magic path

In many cases, when Grace needs to access a file given with a relative pathname, it searches for the file along the following path: ./pathname:./.grace/pathname:~/.grace/pathname:$GRACE_HOME/pathname

Dynamic modules

Grace can access external functions present in either system or third-party shared libraries or modules specially compiled for use with it. The term dynamic refers to the possibility Grace has to open the library at run time to find the code of the external function, there is no need to recompile Grace itself (the functions already compiled in Grace are "statically linked").

Coordinate frames

There are two types of coordinates in Grace: the world coordinates and the viewport coordinates. Points of data sets are defined in the world coordinates. The viewport coordinates correspond to the image of the plot drawn on the canvas (or printed on, say, PS output page). The transformation converting the world coordinates into the viewport ones is determined by both the graph type and the axis scaling.

Actually, there is yet another level in the hierarchy of coordinates - the device coordinates. However, you (as a user of Grace) should not worry about les ouLI> Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it:

Regions

Regions are sections of the graph defined by the interior or exterior of a polygon, or a half plane defined by a line. Regions are used to restrict data transformations to a geometric area occupied by region.

Real Time Input

Real Time Input refers to the ability Grace has to be fed in real time by an external program. The Grace process spawned by the driver program is a full featured Grace process: the user can interact using the GUI at the same time the program sends data and commands. The process will adapt itself to the incoming data rate.

Hotlinks

Hotlinks are sources containing varying data. Grace can be instructed a file or a pipe is a hotlink in which case it will provide specific commands to refresh the data on a mouse click (a later version will probably allow automatic refresh).

Devices

Grace allows the user to choose between several output devices to produce its graphics. The current list of supported devices is:

• X11
• PostScript (level 1 and level 2)
• EPS (encapsulated PostScript)
• Metafile (which is Grace format, used at the moment mostly for debugging purposes)
• MIF (Maker Interchange Format used by FrameMaker)
• SVG (Scalable Vector Graphics, a language for describing two-dimensional vector and mixed vector/raster graphics in XML)
• PDF (depends on extra libraries, see configuration)
• PNM (portable anymap file format)
• JPEG (depends on extra libraries, see configuration)
• PNG (depends on extra libraries, see configuration)

Note that Grace no longer supports GIF due to the copyright policy of Unisys. Grace can also be instructed to launch conversion programs automatically based on file name. As an example you can produce MIF (FrameMaker Interchange Format) or Java applets using pstoedit, or almost any image format using the netpbm suite (see the FAQ).

Magic path

In many cases, when Grace needs to access a file given with a relative pathname, it searches for the file along the following path: ./pathname:./.grace/pathname:~/.grace/pathname:$GRACE_HOME/pathname

Dynamic modules

Grace can access external functions present in either system or third-party shared libraries or modules specially compiled for use with it. The term dynamic refers to the possibility Grace has to open the library at run time to find the code of the external function, there is no need to recompile Grace itself (the functions already compiled in Grace are "statically linked").

Coordinate frames

There are two types of coordinates in Grace: the world coordinates and the viewport coordinates. Points of data sets are defined in the world coordinates. The viewport coordinates correspond to the image of the plot drawn on the canvas (or printed on, say, PS output page). The transformation converting the world coordinates into the viewport ones is determined by both the graph type and the axis scaling.

Actually, there is yet another level in the hierarchy of coordinates - the device coordinates. However, you (as a user of Grace) should not worry about les ouLI> Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it:

Regions

Regions are sections of the graph defined by the interior or exterior of a polygon, or a half plane defined by a line. Regions are used to restrict data transformations to a geometric area occupied by region.

Real Time Input

Real Time Input refers to the ability Grace has to be fed in real time by an external program. The Grace process spawned by the driver program is a full featured Grace process: the user can interact using the GUI at the same time the program sends data and commands. The process will adapt itself to the incoming data rate.

Hotlinks

Hotlinks are sources containing varying data. Grace can be instructed a file or a pipe is a hotlink in which case it will provide specific commands to refresh the data on a mouse click (a later version will probably allow automatic refresh).

Devices

Grace allows the user to choose between several output devices to produce its graphics. The current list of supported devices is:

• X11
• PostScript (level 1 and level 2)
• EPS (encapsulated PostScript)
• Metafile (which is Grace format, used at the moment mostly for debugging purposes)
• MIF (Maker Interchange Format used by FrameMaker)
• SVG (Scalable Vector Graphics, a language for describing two-dimensional vector and mixed vector/raster graphics in XML)
• PDF (depends on extra libraries, see configuration)
• PNM (portable anymap file format)
• JPEG (depends on extra libraries, see configuration)
• PNG (depends on extra libraries, see configuration)

Note that Grace no longer supports GIF due to the copyright policy of Unisys. Grace can also be instructed to launch conversion programs automatically based on file name. As an example you can produce MIF (FrameMaker Interchange Format) or Java applets using pstoedit, or almost any image format using the netpbm suite (see the FAQ).

Magic path

In many cases, when Grace needs to access a file given with a relative pathname, it searches for the file along the following path: ./pathname:./.grace/pathname:~/.grace/pathname:$GRACE_HOME/pathname

Dynamic modules

Grace can access external functions present in either system or third-party shared libraries or modules specially compiled for use with it. The term dynamic refers to the possibility Grace has to open the library at run time to find the code of the external function, there is no need to recompile Grace itself (the functions already compiled in Grace are "statically linked").

Coordinate frames

There are two types of coordinates in Grace: the world coordinates and the viewport coordinates. Points of data sets are defined in the world coordinates. The viewport coordinates correspond to the image of the plot drawn on the canvas (or printed on, say, PS output page). The transformation converting the world coordinates into the viewport ones is determined by both the graph type and the axis scaling.

Actually, there is yet another level in the hierarchy of coordinates - the device coordinates. However, you (as a user of Grace) should not worry about les ouLI> Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it:

Regions

Regions are sections of the graph defined by the interior or exterior of a polygon, or a half plane defined by a line. Regions are used to restrict data transformations to a geometric area occupied by region.

Real Time Input

Real Time Input refers to the ability Grace has to be fed in real time by an external program. The Grace process spawned by the driver program is a full featured Grace process: the user can interact using the GUI at the same time the program sends data and commands. The process will adapt itself to the incoming data rate.

Hotlinks

Hotlinks are sources containing varying data. Grace can be instructed a file or a pipe is a hotlink in which case it will provide specific commands to refresh the data on a mouse click (a later version will probably allow automatic refresh).

Devices

Grace allows the user to choose between several output devices to produce its graphics. The current list of supported devices is:

• X11
• PostScript (level 1 and level 2)
• EPS (encapsulated PostScript)
• Metafile (which is Grace format, used at the moment mostly for debugging purposes)
• MIF (Maker Interchange Format used by FrameMaker)
• SVG (Scalable Vector Graphics, a language for describing two-dimensional vector and mixed vector/raster graphics in XML)
• PDF (depends on extra libraries, see configuration)
• PNM (portable anymap file format)
• JPEG (depends on extra libraries, see configuration)
• PNG (depends on extra libraries, see configuration)

Note that Grace no longer supports GIF due to the copyright policy of Unisys. Grace can also be instructed to launch conversion programs automatically based on file name. As an example you can produce MIF (FrameMaker Interchange Format) or Java applets using pstoedit, or almost any image format using the netpbm suite (see the FAQ).

Magic path

In many cases, when Grace needs to access a file given with a relative pathname, it searches for the file along the following path: ./pathname:./.grace/pathname:~/.grace/pathname:$GRACE_HOME/pathname

Dynamic modules

Grace can access external functions present in either system or third-party shared libraries or modules specially compiled for use with it. The term dynamic refers to the possibility Grace has to open the library at run time to find the code of the external function, there is no need to recompile Grace itself (the functions already compiled in Grace are "statically linked").

Coordinate frames

There are two types of coordinates in Grace: the world coordinates and the viewport coordinates. Points of data sets are defined in the world coordinates. The viewport coordinates correspond to the image of the plot drawn on the canvas (or printed on, say, PS output page). The transformation converting the world coordinates into the viewport ones is determined by both the graph type and the axis scaling.

Actually, there is yet another level in the hierarchy of coordinates - the device coordinates. However, you (as a user of Grace) should not worry about les ouLI> Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it:

Regions

Regions are sections of the graph defined by the interior or exterior of a polygon, or a half plane defined by a line. Regions are used to restrict data transformations to a geometric area occupied by region.

Real Time Input

Real Time Input refers to the ability Grace has to be fed in real time by an external program. The Grace process spawned by the driver program is a full featured Grace process: the user can interact using the GUI at the same time the program sends data and commands. The process will adapt itself to the incoming data rate.

Hotlinks

Hotlinks are sources containing varying data. Grace can be instructed a file or a pipe is a hotlink in which case it will provide specific commands to refresh the data on a mouse click (a later version will probably allow automatic refresh).

Devices

Grace allows the user to choose between several output devices to produce its graphics. The current list of supported devices is:

• X11
• PostScript (level 1 and level 2)
• EPS (encapsulated PostScript)
• Metafile (which is Grace format, used at the moment mostly for debugging purposes)
• MIF (Maker Interchange Format used by FrameMaker)
• SVG (Scalable Vector Graphics, a language for describing two-dimensional vector and mixed vector/raster graphics in XML)
• PDF (depends on extra libraries, see configuration)
• PNM (portable anymap file format)
• JPEG (depends on extra libraries, see configuration)
• PNG (depends on extra libraries, see configuration)

Note that Grace no longer supports GIF due to the copyright policy of Unisys. Grace can also be instructed to launch conversion programs automatically based on file name. As an example you can produce MIF (FrameMaker Interchange Format) or Java applets using pstoedit, or almost any image format using the netpbm suite (see the FAQ).

Magic path

In many cases, when Grace needs to access a file given with a relative pathname, it searches for the file along the following path: ./pathname:./.grace/pathname:~/.grace/pathname:$GRACE_HOME/pathname

Dynamic modules

Grace can access external functions present in either system or third-party shared libraries or modules specially compiled for use with it. The term dynamic refers to the possibility Grace has to open the library at run time to find the code of the external function, there is no need to recompile Grace itself (the functions already compiled in Grace are "statically linked").

Coordinate frames

There are two types of coordinates in Grace: the world coordinates and the viewport coordinates. Points of data sets are defined in the world coordinates. The viewport coordinates correspond to the image of the plot drawn on the canvas (or printed on, say, PS output page). The transformation converting the world coordinates into the viewport ones is determined by both the graph type and the axis scaling.

Actually, there is yet another level in the hierarchy of coordinates - the device coordinates. However, you (as a user of Grace) should not worry about les ouLI> Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it:

Regions

Regions are sections of the graph defined by the interior or exterior of a polygon, or a half plane defined by a line. Regions are used to restrict data transformations to a geometric area occupied by region.

Real Time Input

Real Time Input refers to the ability Grace has to be fed in real time by an external program. The Grace process spawned by the driver program is a full featured Grace process: the user can interact using the GUI at the same time the program sends data and commands. The process will adapt itself to the incoming data rate.

Hotlinks

Hotlinks are sources containing varying data. Grace can be instructed a file or a pipe is a hotlink in which case it will provide specific commands to refresh the data on a mouse click (a later version will probably allow automatic refresh).

Devices

Grace allows the user to choose between several output devices to produce its graphics. The current list of supported devices is:

• X11
• PostScript (level 1 and level 2)
• EPS (encapsulated PostScript)
• Metafile (which is Grace format, used at the moment mostly for debugging purposes)
• MIF (Maker Interchange Format used by FrameMaker)
• SVG (Scalable Vector Graphics, a language for describing two-dimensional vector and mixed vector/raster graphics in XML)
• PDF (depends on extra libraries, see configuration)
• PNM (portable anymap file format)
• JPEG (depends on extra libraries, see configuration)
• PNG (depends on extra libraries, see configuration)

Note that Grace no longer supports GIF due to the copyright policy of Unisys. Grace can also be instructed to launch conversion programs automatically based on file name. As an example you can produce MIF (FrameMaker Interchange Format) or Java applets using pstoedit, or almost any image format using the netpbm suite (see the FAQ).

Magic path

In many cases, when Grace needs to access a file given with a relative pathname, it searches for the file along the following path: ./pathname:./.grace/pathname:~/.grace/pathname:$GRACE_HOME/pathname

Dynamic modules

Grace can access external functions present in either system or third-party shared libraries or modules specially compiled for use with it. The term dynamic refers to the possibility Grace has to open the library at run time to find the code of the external function, there is no need to recompile Grace itself (the functions already compiled in Grace are "statically linked").

Coordinate frames

There are two types of coordinates in Grace: the world coordinates and the viewport coordinates. Points of data sets are defined in the world coordinates. The viewport coordinates correspond to the image of the plot drawn on the canvas (or printed on, say, PS output page). The transformation converting the world coordinates into the viewport ones is determined by both the graph type and the axis scaling.

Actually, there is yet another level in the hierarchy of coordinates - the device coordinates. However, you (as a user of Grace) should not worry about les ouLI> Pie chart

Datasets

A dataset is a collection of points with x and y coordinates, up to four optional data values (which, depending on the set type, can be displayed as error bars or like) and one optional character string.

Sets

A set is a way of representing datasets. It consists of a pointer to a dataset plus a collection of parameters describing the visual appearance of the data (like color, line dash pattern etc).

The set type can be any of the following:

Not all set types, however, can be plotted on any graph type. The following table summarizes it: