As with most packages in Emacs, there are a number of different ways of accessing all of the functions in @fuse{}. The most primitive manner of accessing functions is to type M-x followed by the name of the function. Additionally, most user functions are bound to key sequences. Most of these involve typing C-c followed by another control character and then followed by a single character. These are lengthy key sequences. Major modes typically use C-c sequences. To have enough options available, I felt it necessary to have all of the @fuse{} functions use a second control prefix.
C- means to strike the control key while striking the following character. M- means to strike the esc key before striking the following key. Alternatively, you can hold down the alt or meta key while striking the following key.
The list of key sequences is rather lengthy and has been excluded from this document. The tutorial, see section `Introduction' in The Fuse Tutorial, demonstrates the use of many functions. All of the key sequences recognized by @fuse{} are listed in the quick reference card.
Virtually all of the functions in @fuse{} are bound to either the
Input
menu or to one of the program menus. Whenever you edit and
input file with @fuse{} there will be a pull down menu labels
Input
and one labelled with the name of the program corresponding
to that input file.
@fuse{} makes use of the ability of XEmacs to display a toolbar. By default, a toolbar appears at the left side of the screen when a buffer in input-mode is displayed. The toolbar has a several of the most commonly used functions bound to it, including functions for making templates, running programs, plotting output, and examining log files.
As discussed in the introduction, one of the fundamental purposed of a user interface to a set of programs is providing an environment in which to run the programs. @fuse{} allows you to run any of the programs with a key or mouse sequence. When a program is run, a second window is opened to display all of the run-time messages written to standard output and standard error by the program. This allows you to follow the progress of the program and to see when the program has finished.
The programs are always invoked using the shell's `time' command. Upon completion of the program, this causes a summary of the time consumed by the program to be written to the run-time display window. Generally this summary is rather cryptic but usually includes the real time elapsed and the amount of CPU time used. It would be nice to parse this string into a more readable form, but unfortunately its format is different under different shells and operating systems. Even so, it is sufficiently useful to know this information that I offer the unparsed string despite its crypticness.
The advantages of having the run-time messages written to a buffer in the manner described above is that it records a running log of work done during the @fuse{} session. This log can be saved to a file using `input-save-run-log' (normally bound to C-c C-b l and found in the `Input:miscellaneous' menu). This runtime log is also written whenever Emacs is exited so that your last session can be reviewed.
If you are working in a windowing environment, the run-time messages buffer will be displayed in a separate frame from the frame containing the input files. This frame is only about 20 lines tall and lacks much of the normal decoration of an emacs frame. The idea is that it is a display-only frame which takes up only a small amount of screen real estate. This frame may be shared with the gnuplot script buffer, but typically is not. This is controlled with the variable `input-use-frames-flag'.
Several functions and features are used by @fuse{} to control program execution.
@fuse{} is able to batch process input files by sequentially running the appropriate program on any number of input files. This is accomplished using a dired buffer. See the Emacs documentation for details about dired.
To enable @fuse{}'s batch processing capabilities, you must have this lines somewhere in your `.emacs' file
(add-hook 'dired-load-hook '(lambda () (load "fuse-dired")))
Once that is done, any time you are in a dired buffer you will be able to run any of the programs covered by @fuse{}. First mark some number of input files using the `m' command (or any other marking command) in dired. Then invoke `fuse-dired-run-marked' by typing C-c r. @fuse{} will then load each marked file and run the program appropriate to that file. Just sit back and watch.
Note that the batch run may require some interactive response in certain situations. For example, if @fuse{} cannot figure out the program associated with the input file (see section Automatic configuration), @fuse{} will query you for it.
@fuse{} plots the output of FEFF and the UWXAFS programs by parsing for the input file for information about the data that needs to be plotted and constructing a GNUPLOT script based on what it finds. It then pipes the contents of this script to GNUPLOT. The scripts can be saved by moving the cursor to the script buffer and typing C-x C-s.
When one of the plotting options is chosen, a second window or a separate frame opens up showing the contents of the GNUPLOT script. Assuming there are no problems, the plot will be displayed and control of the cursor will return to the window containing the input file.
If you are working in a windowing environment, the run-time messages buffer will be displayed in a separate frame from the frame containing the input files. This frame is only about 20 lines tall and lacks much of the normal decoration of an emacs frame. I assume that you only rarely will edit the gnuplot script, so displaying it in a separate and rather small frame seems preferable. This frame may shared with the run-time messages buffer, but typically is not. This behavior is controlled by the variable `input-use-frames-flag'.
fuse-gnuplot-history
.
Hitting C-c C-f k will terminate the GNUPLOT process and
close the frame containing the gnuplot script.
For more details about using gnuplot-mode, see the reference card
`gpelcard.ps' which comes with @fuse{}.
pl '<eshift esh=5 data.xmu'Note that any of these scripts can be used at the command line by redirecting their output to a file. For example:
# kw w=5 data.chi > data.chi.weighted # gnufix esh=5 xmu.dat > xmu.data.fixed # eshift esh=5 data.xmu > data.xmu.shifted # mr data.xmu, 1 > data.xmu.asciiThese scripts are all in the `scripts' directory in the distribution. The directory containing these scripts is the value of
fuse-bin-location
. This directory is added to the
exec-path
when @fuse{} is started.
@fuse{} is supposed to have a mechanism for detecting problems with the commands sent to GNUPLOT. In truth, I never got this to work properly and found that it was not entirely necessary. If something goes wrong with the plot, look at the `gnuplot-program' buffer by simply switching to that buffer or by using the `gnuplot-jump-to-gnuplot-buffer' function, normally bound to C-c C-e and in the `Gnuplot' menu in the gnuplot-buffer.
@fuse{}'s plotting functions are able to interact with either ASCII data or data in the UWXAFS binary format. Because of certain features of the UWXAFS binary format, the GNUPLOT scripts generated by @fuse{} may not be what you want. For example, a script for a FEFFIT fit is written assuming that the output data was written to a new file rather than appended to a pre-existing file. Thus the fit script uses numeric keys (`nkeys') beginning with 1.
Interaction with the UWXAFS binary files is one of the weaker areas in @fuse{}. In truth, I rarely use the binary files and my memory of how the programs read and write them is a bit fuzzy. In particular, I don't recall how AUTOBK writes its many possible output files when binary output is used. I have a few ideas about how to improve plotting from the binary files. It could be possible to set an nkey offset variable to handle pre-existing files. Another possibility would be something like Dired mode in Emacs, where the contents of the binary file are displayed to a buffer and records could be marked and subsequently plotted.
Go to the first, previous, next, last section, table of contents.